PM Agent Extension — AI-powered Product Management for OSS projects

[ASekiguchi]

What would you like to be added?

A Gemini CLI Extension that provides AI-powered Product Management capabilities as a reusable, bottom-up framework for OSS projects. This extension would analyze existing project artifacts (Issues, PRs, commits, docs, roadmap) and generate structured PM outputs — without requiring a human Product Manager.

Why is this needed?

The structural gap in OSS product management

Most OSS projects, including Gemini CLI, are engineering-led — which is a strength for code quality but creates a structural gap in product management:

Function	Current state in typical OSS	Impact
Requirements gathering	Ad-hoc via Issues and discussions	Fragmented, no single source of truth
Prioritization	Maintainer intuition + community pressure	Inconsistent, not data-driven
Roadmap management	Static markdown file (ROADMAP.md)	Disconnects from actual development activity
User feedback synthesis	Manual reading of Issues	Time-consuming, insights get lost
Release planning	Engineering-driven milestone tracking	Lacks user-impact perspective
Competitive analysis	Not systematically tracked	Reactive instead of proactive

Why a bottom-up AI approach is better than hiring a PM

Traditional PM involvement in OSS has friction:

• Cultural mismatch: PMs use different tools (Jira, Notion, Confluence) than developers (GitHub, terminal)
• Context switching cost: Developers must context-switch to PM workflows
• Scalability: Human PMs can't be embedded in every OSS project

A bottom-up AI PM Agent solves this by:

1. Working where developers already work — inside the CLI and GitHub
2. Deriving insights from existing artifacts — no new data entry required
3. Producing developer-friendly outputs — markdown, not slide decks
4. Scaling across projects — one extension, any OSS project

Enterprise adoption accelerator

This directly addresses a key adoption barrier: enterprises evaluating Gemini CLI need structured product artifacts (PRDs, roadmaps, risk assessments) that OSS projects typically don't maintain. An AI PM Agent can generate these on-demand, bridging the gap between OSS development culture and enterprise procurement requirements.

Proposed design

Architecture: Gemini CLI Extension

Using Gemini CLI's existing extension framework (no core fork required):

pm-agent/
├── gemini-extension.json        # Extension manifest
├── GEMINI.md                    # PM context & principles
│
├── mcp-server/
│   ├── server.js                # MCP server with PM tools
│   └── package.json
│
├── skills/
│   ├── requirements-analyzer/
│   │   └── SKILL.md             # Extract requirements from Issues/PRs
│   ├── roadmap-generator/
│   │   └── SKILL.md             # Generate/update roadmap from activity
│   ├── backlog-prioritizer/
│   │   └── SKILL.md             # Prioritize backlog using frameworks
│   ├── release-planner/
│   │   └── SKILL.md             # Plan releases with user impact analysis
│   └── competitive-analyzer/
│       └── SKILL.md             # Track competitive landscape
│
├── commands/
│   ├── pm/
│   │   ├── analyze.toml         # /pm:analyze - Full project analysis
│   │   ├── roadmap.toml         # /pm:roadmap - Generate roadmap
│   │   ├── prioritize.toml      # /pm:prioritize - Prioritize backlog
│   │   ├── prd.toml             # /pm:prd - Generate PRD
│   │   └── health.toml          # /pm:health - Project health check
│
├── hooks/
│   └── hooks.json               # Lifecycle hooks for context injection
│
└── references/
    ├── frameworks/
    │   ├── swot.md
    │   ├── kano-model.md
    │   ├── moscow.md
    │   ├── rice-scoring.md
    │   └── aarrr-funnel.md
    └── templates/
        ├── prd-template.md
        ├── user-story-template.md
        └── release-notes-template.md

Component details

1. MCP Server — PM Tools

Tools exposed to the LLM for data gathering and analysis:

// Tool: analyze_project_issues
// Fetches and categorizes GitHub Issues into PM-relevant groupings
server.registerTool('analyze_project_issues', {
  description: 'Analyze GitHub issues to extract requirements, feature requests, bugs, and UX feedback',
  inputSchema: z.object({
    owner: z.string(),
    repo: z.string(),
    since: z.string().optional(),  // ISO date
    labels: z.array(z.string()).optional(),
  }).shape,
}, async ({ owner, repo, since, labels }) => {
  // Fetch issues via GitHub API
  // Categorize: feature request, bug, UX feedback, tech debt
  // Extract implicit requirements
  // Return structured analysis
});

// Tool: generate_roadmap
// Synthesizes a roadmap from issues, PRs, and commit activity
server.registerTool('generate_roadmap', { ... });

// Tool: calculate_priority_score
// Applies RICE/MoSCoW scoring to backlog items
server.registerTool('calculate_priority_score', { ... });

// Tool: analyze_commit_velocity
// Tracks development velocity and identifies trends
server.registerTool('analyze_commit_velocity', { ... });

// Tool: extract_user_feedback
// Parses issue comments for user sentiment and pain points
server.registerTool('extract_user_feedback', { ... });

2. Skills — Specialized PM Workflows

requirements-analyzer — Extracts structured requirements from raw project data:

---
name: requirements-analyzer
description: |
  Analyzes GitHub Issues, PRs, discussions, and docs to extract
  structured product requirements. Produces user stories, acceptance
  criteria, and dependency maps. Activate when asked to "analyze
  requirements", "what do users want", or "extract user stories".
---

roadmap-generator — Creates data-driven roadmaps:

---
name: roadmap-generator
description: |
  Generates or updates product roadmaps based on current Issues,
  PR activity, commit velocity, and stated priorities. Outputs
  timeline views, dependency graphs, and milestone definitions.
  Activate when asked to "create roadmap", "update roadmap", or
  "what should we build next".
---

backlog-prioritizer — Applies PM frameworks to prioritization:

---
name: backlog-prioritizer
description: |
  Prioritizes product backlog using data-driven frameworks (RICE,
  MoSCoW, Kano Model). Considers user impact, development effort,
  strategic alignment, and competitive positioning. Activate when
  asked to "prioritize", "what's most important", or "rank features".
---

3. Custom Commands — Developer-Friendly Entry Points

# commands/pm/analyze.toml
description = "Run a full PM analysis of this project"
prompt = """
Analyze this project from a Product Management perspective.

Use the following data sources:
1. Recent Issues: !{gh issue list --limit 50 --json title,labels,createdAt,comments}
2. Recent PRs: !{gh pr list --limit 30 --state merged --json title,labels,mergedAt}
3. Commit velocity: !{git log --oneline --since="3 months ago" | wc -l} commits in 3 months
4. Current roadmap: @{ROADMAP.md}
5. Project context: @{GEMINI.md}

Produce:
- Executive summary (3-5 bullets)
- SWOT analysis
- Top 5 user pain points (from Issues)
- Recommended priorities (RICE scored)
- Roadmap alignment check
"""

# commands/pm/health.toml
description = "Quick project health check"
prompt = """
Run a project health check:

Issue stats:
- Open issues: !{gh issue list --state open --json id | jq length}
- Closed this month: !{gh issue list --state closed --json closedAt | jq '[.[] | select(.closedAt > "{{date -30d}}")]' | jq length}
- Avg response time: analyze from !{gh issue list --limit 20 --json createdAt,comments}

PR stats:
- Open PRs: !{gh pr list --state open --json id | jq length}
- Merged this month: !{gh pr list --state merged --json mergedAt | jq '[.[] | select(.mergedAt > "{{date -30d}}")]' | jq length}

Commit activity:
- This month: !{git log --oneline --since="1 month ago" | wc -l}
- Last month: !{git log --oneline --since="2 months ago" --until="1 month ago" | wc -l}

Produce a health scorecard with: velocity trend, community engagement, issue resolution rate, and risk flags.
"""

4. Hooks — Automatic PM Context

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "name": "inject-pm-context",
            "type": "command",
            "command": "node ${extensionPath}/hooks/inject-project-summary.js",
            "timeout": 10000
          }
        ]
      }
    ]
  }
}

The inject-project-summary.js hook could cache and inject a brief project status summary (open issues count, recent activity, current milestone) at session start — giving the PM Agent always-fresh context.

Example user interactions

# Full project analysis
> /pm:analyze
→ Generates SWOT, prioritized backlog, roadmap alignment report

# Quick health check
> /pm:health
→ Shows velocity trends, issue resolution rates, risk flags

# Generate a PRD from Issues
> /pm:prd "authentication improvements"
→ Scans auth-related Issues, synthesizes a PRD with user stories

# Prioritize the backlog
> /pm:prioritize
→ Applies RICE scoring to open Issues, suggests sprint planning

# Update the roadmap
> /pm:roadmap
→ Compares ROADMAP.md against actual development activity, suggests updates

# Natural language works too
> "What are the top user pain points right now?"
→ The requirements-analyzer skill activates automatically

Why this should be an OSS extension (not internal tool)

1. Every OSS project needs PM — This extension is project-agnostic. Any repo with Issues and a README can benefit.
2. Dog-fooding Gemini CLI's extension system — Demonstrates the power of the extension architecture to the community.
3. Attracts non-engineer contributors — Connects to the non-engineer contribution proposal (Enable non-engineer contributions (PM, UX Designer) to the OSS project #20495). PM Agent outputs create entry points for non-engineers to engage.
4. Enterprise value — Companies evaluating OSS tools can run /pm:analyze to get instant product intelligence.

Implementation phases

Phase 1: Core Analysis (MVP)

• MCP server with analyze_project_issues and analyze_commit_velocity tools
• requirements-analyzer skill
• /pm:analyze and /pm:health commands
• Works with any GitHub repository

Phase 2: Planning Tools

• roadmap-generator and backlog-prioritizer skills
• /pm:roadmap and /pm:prioritize commands
• RICE/MoSCoW scoring integration
• Competitive analysis skill

Phase 3: Automation & Integration

• Hooks for automatic context injection
• /pm:prd generation
• Release planning integration
• Scheduled health reports (via CI/cron)

Expected impact

• For maintainers: Data-driven prioritization without PM overhead
• For contributors: Clear understanding of what matters most
• For enterprises: Structured product artifacts for evaluation and procurement
• For the Gemini CLI ecosystem: A showcase extension that demonstrates the platform's extensibility

Technical feasibility

This proposal uses only existing Gemini CLI extension capabilities:

• MCP servers for tools (GA)
• Skills for specialized workflows (GA)
• Custom commands for user entry points (GA)
• Hooks for context injection (GA)
• No core modifications required
• No fork needed

Additional context

This proposal builds on Issue #20495 (Enable non-engineer contributions) and addresses the broader challenge of making OSS projects more product-aware. The AI PM Agent is a concrete mechanism to bridge the gap between engineering-led development and product-informed decision making.

The approach is bottom-up by design: instead of imposing PM processes on developers, it derives PM insights from artifacts developers already create (Issues, PRs, commits, docs). This makes it developer-friendly and zero-friction to adopt.