sdlc-subagents 0.1.0

package/README.md

@@ -0,0 +1,124 @@
+# sdlc-subagents
+
+Configure [OpenCode](https://opencode.ai) as an orchestrator of multiple coding agent CLIs.
+
+Run one command and your OpenCode agent learns how to delegate tasks to the right sub-agent CLI based on the task type.
+
+## Supported Sub-Agents
+
+| Agent | Command | Best For |
+|-------|---------|----------|
+| [Gemini CLI](https://github.com/google-gemini/gemini-cli) | `gemini` | Context engineering, large codebase analysis, research |
+| [GitHub Copilot CLI](https://githubnext.com/projects/copilot-cli) | `copilot` | PR creation, issue management, GitHub workflows |
+| [Claude Code](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/overview) | `claude` | Complex refactoring, architecture changes, debugging |
+| [Aider](https://aider.chat) | `aider` | Pair programming, auto-commits, any LLM provider |
+| [Kimi CLI](https://github.com/MoonshotAI/kimi-cli) | `kimi` | Front-end development, UI components, long-context |
+| [Cursor CLI](https://cursor.sh) | `agent` | IDE-grade coding, cloud handoff, rapid prototyping |
+
+## Quick Start
+
+```bash
+npx sdlc-subagents
+```
+
+That's it. The tool will:
+
+1. **Detect** which coding agent CLIs are installed on your system
+2. **Generate** OpenCode skill files (`.agents/skills/*/SKILL.md`) for each agent
+3. **Configure** `opencode.json` with permissions and `/delegate` commands
+
+## What Gets Created
+
+```
+your-project/
+  .agents/
+    skills/
+      sdlc-orchestrator/SKILL.md    # Master routing skill
+      gemini-cli/SKILL.md           # Gemini CLI delegation
+      copilot-cli/SKILL.md          # GitHub Copilot delegation
+      claude-code/SKILL.md          # Claude Code delegation
+      aider/SKILL.md                # Aider delegation
+      kimi-cli/SKILL.md             # Kimi CLI delegation
+      cursor-cli/SKILL.md           # Cursor CLI delegation
+  opencode.json                     # Permissions + custom commands
+```
+
+## Usage in OpenCode
+
+After running `npx sdlc-subagents`, open your project with OpenCode. The agent will automatically discover the skills.
+
+### Auto-routing
+
+Ask OpenCode to delegate and it will pick the best agent:
+
+```
+/delegate Analyze the entire codebase and generate API documentation
+```
+
+OpenCode routes this to Gemini CLI (large context + research).
+
+### Force a specific agent
+
+```
+/delegate-claude-code Refactor the auth module to use strategy pattern
+/delegate-copilot-cli Create a PR for the current branch changes
+/delegate-aider Add input validation to all API endpoints
+/delegate-kimi-cli Build a responsive dashboard with Tailwind
+```
+
+### Natural language
+
+You don't even need the commands. Just describe your task and OpenCode will load the orchestrator skill and route to the right agent:
+
+```
+> Use Gemini to research how the payment system works across all microservices
+> Have Claude refactor the database layer to use Prisma
+> Ask Aider to add tests for the auth module, commit each test separately
+```
+
+## How It Works
+
+The tool generates [OpenCode Agent Skills](https://opencode.ai/docs/skills/) - markdown files that teach OpenCode when and how to delegate to each sub-agent CLI.
+
+Each skill contains:
+- **When to delegate**: Task types the agent excels at
+- **How to invoke**: Exact CLI commands for non-interactive use
+- **Delegation patterns**: Copy-paste bash patterns for capturing output
+- **Important notes**: Auth requirements, flags, gotchas
+
+The master `sdlc-orchestrator` skill provides a routing table that maps task types to the recommended agent.
+
+## Re-running
+
+Running `npx sdlc-subagents` again is safe. It will:
+- Update skill files with latest templates
+- Merge new config into existing `opencode.json` (preserves your customizations)
+- Re-detect installed CLIs
+
+## Installing the Sub-Agent CLIs
+
+The tool works even if not all CLIs are installed - it scaffolds skills for all agents so you can install them later. Install commands:
+
+```bash
+# Gemini CLI
+npm install -g @google/gemini-cli
+
+# GitHub Copilot CLI
+npm install -g @github/copilot
+
+# Claude Code
+npm install -g @anthropic-ai/claude-code
+
+# Aider
+pipx install aider-chat
+
+# Kimi CLI
+uv tool install --python 3.13 kimi-cli
+
+# Cursor CLI
+curl https://cursor.sh/cli -fsS | bash
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+
+// src/agents.ts
+var AGENTS = [
+  {
+    id: "gemini-cli",
+    name: "Gemini CLI",
+    command: "gemini",
+    installCommand: "npm install -g @google/gemini-cli",
+    description: "Google's Gemini coding agent with 1M token context window, built-in Google Search grounding, and generous free tier",
+    bestFor: "Context engineering, large codebase analysis, research-heavy tasks, documentation generation",
+    nonInteractiveFlag: '-p "PROMPT"',
+    detectCommand: "gemini",
+    env: ["GOOGLE_API_KEY"]
+  },
+  {
+    id: "copilot-cli",
+    name: "GitHub Copilot CLI",
+    command: "copilot",
+    installCommand: "npm install -g @github/copilot",
+    description: "GitHub's agentic coding CLI deeply integrated with GitHub workflows - PRs, issues, code review",
+    bestFor: "GitHub workflow automation, PR creation and review, issue management, repository operations",
+    nonInteractiveFlag: '--prompt "PROMPT"',
+    detectCommand: "copilot"
+  },
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    command: "claude",
+    installCommand: "npm install -g @anthropic-ai/claude-code",
+    description: "Anthropic's terminal coding agent with deep agentic capabilities, multi-file editing, and sub-agent support",
+    bestFor: "Complex refactoring, architecture-level changes, multi-file edits, code review, debugging",
+    nonInteractiveFlag: '-p "PROMPT"',
+    detectCommand: "claude",
+    env: ["ANTHROPIC_API_KEY"]
+  },
+  {
+    id: "aider",
+    name: "Aider",
+    command: "aider",
+    installCommand: "pipx install aider-chat",
+    description: "Model-agnostic AI pair programming tool that works with any LLM and auto-commits changes to git",
+    bestFor: "Pair programming, incremental changes with auto-commits, working with any LLM provider, architect mode for complex changes",
+    nonInteractiveFlag: '--message "PROMPT" --yes',
+    detectCommand: "aider",
+    env: ["OPENAI_API_KEY", "ANTHROPIC_API_KEY"]
+  },
+  {
+    id: "kimi-cli",
+    name: "Kimi CLI",
+    command: "kimi",
+    installCommand: "uv tool install --python 3.13 kimi-cli",
+    description: "Moonshot AI's terminal coding agent with long-context support via Kimi K2 model and MCP integration",
+    bestFor: "Front-end development, full-stack tasks, long-context code understanding",
+    nonInteractiveFlag: "stdin pipe",
+    detectCommand: "kimi",
+    env: ["KIMI_API_KEY"]
+  },
+  {
+    id: "cursor-cli",
+    name: "Cursor CLI",
+    command: "agent",
+    installCommand: "curl https://cursor.sh/cli -fsS | bash",
+    description: "Cursor's terminal agent with full IDE-grade capabilities, cloud handoff, and multi-model support",
+    bestFor: "IDE-grade coding in terminal, cloud agent delegation, rapid prototyping",
+    nonInteractiveFlag: '-p "PROMPT"',
+    detectCommand: "agent"
+  }
+];
+
+// src/index.ts
+var bold = (s) => `\x1B[1m${s}\x1B[0m`;
+var green = (s) => `\x1B[32m${s}\x1B[0m`;
+var yellow = (s) => `\x1B[33m${s}\x1B[0m`;
+var red = (s) => `\x1B[31m${s}\x1B[0m`;
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var cyan = (s) => `\x1B[36m${s}\x1B[0m`;
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var TEMPLATES_DIR = resolve(__dirname, "..", "templates");
+function isCommandAvailable(command) {
+  try {
+    const cmd = process.platform === "win32" ? `where ${command}` : `which ${command}`;
+    execSync(cmd, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectInstalledAgents() {
+  const results = /* @__PURE__ */ new Map();
+  for (const agent of AGENTS) {
+    results.set(agent.id, isCommandAvailable(agent.detectCommand));
+  }
+  return results;
+}
+function readTemplate(relativePath) {
+  const fullPath = join(TEMPLATES_DIR, relativePath);
+  return readFileSync(fullPath, "utf-8");
+}
+function writeFile(targetDir, relativePath, content) {
+  const fullPath = join(targetDir, relativePath);
+  const dir = dirname(fullPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const existed = existsSync(fullPath);
+  writeFileSync(fullPath, content, "utf-8");
+  return existed ? "updated" : "created";
+}
+function generateOpencodeJson(targetDir, installedMap) {
+  const existingPath = join(targetDir, "opencode.json");
+  let existing = {};
+  if (existsSync(existingPath)) {
+    try {
+      existing = JSON.parse(readFileSync(existingPath, "utf-8"));
+    } catch {
+    }
+  }
+  const skillPerms = {
+    "sdlc-orchestrator": "allow"
+  };
+  for (const agent of AGENTS) {
+    skillPerms[agent.id] = "allow";
+  }
+  const commands = {};
+  for (const agent of AGENTS) {
+    const installed = installedMap.get(agent.id);
+    commands[`delegate-${agent.id}`] = {
+      template: `Load the "${agent.id}" skill and delegate the following task to ${agent.name}: $ARGUMENTS`,
+      description: `Delegate a task to ${agent.name}${installed ? "" : " (not installed)"}`
+    };
+  }
+  const config = {
+    $schema: "https://opencode.ai/config.json",
+    ...existing,
+    permission: {
+      ...existing.permission,
+      skill: {
+        ...existing.permission?.skill ?? {},
+        ...skillPerms
+      }
+    },
+    command: {
+      ...existing.command,
+      ...commands,
+      "delegate": {
+        template: 'Load the "sdlc-orchestrator" skill. Based on the task type, choose the best sub-agent CLI and delegate: $ARGUMENTS',
+        description: "Auto-route a task to the best available sub-agent CLI"
+      }
+    },
+    instructions: mergeInstructions(
+      existing.instructions ?? [],
+      []
+    )
+  };
+  return JSON.stringify(config, null, 2);
+}
+function mergeInstructions(existing, additions) {
+  const set = /* @__PURE__ */ new Set([...existing, ...additions]);
+  return [...set];
+}
+async function main() {
+  const targetDir = process.cwd();
+  console.log();
+  console.log(
+    bold("  SDLC Sub-Agents") + dim(" \u2014 Configure OpenCode as an orchestrator of coding agent CLIs")
+  );
+  console.log();
+  console.log(dim("  Detecting installed coding agent CLIs..."));
+  console.log();
+  const installed = detectInstalledAgents();
+  const found = [];
+  const missing = [];
+  for (const agent of AGENTS) {
+    if (installed.get(agent.id)) {
+      found.push(agent);
+      console.log(
+        `  ${green("+")} ${bold(agent.name)} ${dim(`(${agent.command})`)}`
+      );
+    } else {
+      missing.push(agent);
+      console.log(
+        `  ${red("-")} ${bold(agent.name)} ${dim("not found")} ${dim(`\u2014 install: ${agent.installCommand}`)}`
+      );
+    }
+  }
+  console.log();
+  console.log(
+    `  ${green(String(found.length))} detected, ${yellow(String(missing.length))} not found`
+  );
+  console.log();
+  console.log(dim("  Writing skill files..."));
+  const skillsDir = ".agents/skills";
+  const orchestratorContent = readTemplate(
+    "skills/sdlc-orchestrator/SKILL.md"
+  );
+  const orchResult = writeFile(
+    targetDir,
+    `${skillsDir}/sdlc-orchestrator/SKILL.md`,
+    orchestratorContent
+  );
+  console.log(
+    `  ${green("+")} ${orchResult} ${cyan(`${skillsDir}/sdlc-orchestrator/SKILL.md`)}`
+  );
+  for (const agent of AGENTS) {
+    const content = readTemplate(`skills/${agent.id}/SKILL.md`);
+    const result = writeFile(
+      targetDir,
+      `${skillsDir}/${agent.id}/SKILL.md`,
+      content
+    );
+    const status = installed.get(agent.id) ? green("+") : yellow("~");
+    console.log(
+      `  ${status} ${result} ${cyan(`${skillsDir}/${agent.id}/SKILL.md`)}`
+    );
+  }
+  console.log();
+  console.log(dim("  Configuring opencode.json..."));
+  const opencodeJson = generateOpencodeJson(targetDir, installed);
+  const jsonResult = writeFile(targetDir, "opencode.json", opencodeJson);
+  console.log(`  ${green("+")} ${jsonResult} ${cyan("opencode.json")}`);
+  console.log();
+  console.log(bold("  Done!") + " Your project is now configured.");
+  console.log();
+  console.log(dim("  What was created:"));
+  console.log(
+    `  ${dim("1.")} ${cyan(`${skillsDir}/sdlc-orchestrator/SKILL.md`)} ${dim("\u2014 master routing skill")}`
+  );
+  for (const agent of AGENTS) {
+    console.log(
+      `  ${dim("  ")} ${cyan(`${skillsDir}/${agent.id}/SKILL.md`)} ${dim(`\u2014 ${agent.bestFor.split(",")[0]}`)}`
+    );
+  }
+  console.log(
+    `  ${dim("2.")} ${cyan("opencode.json")} ${dim("\u2014 permissions + /delegate commands")}`
+  );
+  console.log();
+  console.log(bold("  Usage in OpenCode:"));
+  console.log(
+    `  ${dim(">")} OpenCode will automatically discover the skills and`
+  );
+  console.log(
+    `    know how to delegate to each sub-agent based on task type.`
+  );
+  console.log();
+  console.log(`  ${dim(">")} You can also use custom commands:`);
+  console.log(
+    `    ${cyan("/delegate")} ${dim("auto-route to best agent")}`
+  );
+  for (const agent of AGENTS) {
+    console.log(
+      `    ${cyan(`/delegate-${agent.id}`)} ${dim(`force ${agent.name}`)}`
+    );
+  }
+  if (missing.length > 0) {
+    console.log();
+    console.log(yellow("  Missing CLIs (install when ready):"));
+    for (const agent of missing) {
+      console.log(`    ${dim("$")} ${agent.installCommand}`);
+    }
+  }
+  console.log();
+}
+main().catch((err) => {
+  console.error(red(`Error: ${err instanceof Error ? err.message : err}`));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "sdlc-subagents",
+  "version": "0.1.0",
+  "description": "Scaffold OpenCode as an orchestrator of multiple coding agent CLIs (Gemini, Copilot, Claude, Aider, Kimi, Cursor)",
+  "bin": {
+    "sdlc-subagents": "dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "opencode",
+    "sdlc",
+    "ai-agents",
+    "coding-agents",
+    "gemini-cli",
+    "claude-code",
+    "aider",
+    "copilot",
+    "kimi",
+    "cursor",
+    "orchestrator"
+  ],
+  "author": "Roy Zalta",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^25.4.0",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  }
+}

package/templates/skills/aider/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: aider
+description: Delegate tasks to Aider for AI pair programming with auto-git-commits, model-agnostic LLM support, and architect mode for complex changes. Works with any LLM provider.
+---
+
+## What is Aider
+
+Aider is a model-agnostic AI pair programming tool for the terminal. It works with any LLM (OpenAI, Anthropic, DeepSeek, local models via Ollama), automatically commits every change to git with descriptive messages, and supports an architect mode where one model plans and another edits.
+
+## When to delegate to Aider
+
+Use Aider when you need to:
+- Make incremental code changes with automatic git commits for each step
+- Work with a specific LLM that other tools don't support (e.g., DeepSeek, local Ollama models)
+- Use architect mode to have one model plan changes and another implement them
+- Pair program on a specific set of files
+- Make changes that should be individually tracked in git history
+- Work with repositories where you want fine-grained commit history of AI changes
+
+## How to invoke Aider
+
+### Non-interactive (recommended for delegation)
+
+Use `--message` with `--yes` for fully non-interactive execution:
+
+```bash
+aider --message "YOUR PROMPT HERE" --yes
+```
+
+### With specific model
+
+```bash
+aider --message "YOUR PROMPT" --yes --model sonnet
+```
+
+### With architect mode (plan + implement split)
+
+```bash
+aider --message "YOUR PROMPT" --yes --architect --model o3-mini --editor-model sonnet
+```
+
+### With specific files in context
+
+```bash
+aider --message "YOUR PROMPT" --yes --file src/auth.ts --file src/types.ts
+```
+
+### With read-only context files
+
+```bash
+aider --message "YOUR PROMPT" --yes --file src/auth.ts --read docs/api-spec.md
+```
+
+### Dry run (preview changes without applying)
+
+```bash
+aider --message "YOUR PROMPT" --yes --dry-run
+```
+
+### Disable auto-git-commit
+
+```bash
+aider --message "YOUR PROMPT" --yes --no-git
+```
+
+## Important notes
+
+- Requires API keys via environment variables (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, etc.) or `--api-key` flag
+- By default, Aider auto-commits every change to git with a descriptive message
+- The `--yes` flag is essential for non-interactive use (auto-confirms all prompts)
+- Aider exits after completing the `--message` task
+- Architect mode (`--architect`) is powerful for complex changes: one model reasons about the approach, another implements
+- Use `--file` to explicitly add files to context (otherwise Aider uses its own heuristics)
+- Use `--no-stream` if you want to capture complete output
+
+## Delegation pattern
+
+For targeted file changes:
+
+```bash
+aider --message "Add input validation to the createUser function in src/users.ts. Validate email format and password strength. Add corresponding tests." --yes --file src/users.ts --file tests/users.test.ts
+```
+
+For architect-mode complex changes:
+
+```bash
+aider --message "Migrate the database layer from raw SQL to Prisma ORM. Update all repository files accordingly." --yes --architect --model o3-mini --editor-model sonnet
+```
+
+For changes with specific LLM:
+
+```bash
+aider --message "Optimize the rendering performance of the dashboard component" --yes --model deepseek --file src/components/Dashboard.tsx
+```

package/templates/skills/claude-code/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: claude-code
+description: Delegate tasks to Claude Code for complex refactoring, architecture-level changes, multi-file edits, in-depth code review, and debugging. Excels at deep reasoning about code structure.
+---
+
+## What is Claude Code
+
+Claude Code is Anthropic's terminal-based coding agent. It reads entire codebases, performs multi-file edits, runs commands, manages git, and supports multi-agent workflows with sub-agent delegation.
+
+## When to delegate to Claude Code
+
+Use Claude Code when you need to:
+- Perform complex multi-file refactoring
+- Make architecture-level changes across a codebase
+- Debug complex issues that require deep code understanding
+- Conduct thorough code reviews with actionable feedback
+- Implement features that span multiple files and modules
+- Work on tasks that benefit from Claude's strong reasoning capabilities
+- Review git diffs and provide structured feedback
+
+## How to invoke Claude Code
+
+### Non-interactive (recommended for delegation)
+
+Use the `-p` flag for non-interactive print mode:
+
+```bash
+claude -p "YOUR PROMPT HERE"
+```
+
+### With structured output
+
+```bash
+claude -p "YOUR PROMPT" --output-format json
+```
+
+### Pipe input for review
+
+```bash
+git diff | claude -p "Review these changes for bugs and security issues"
+```
+
+### Resume last conversation
+
+```bash
+claude -c
+```
+
+### With specific model
+
+```bash
+claude -p "YOUR PROMPT" --model claude-sonnet-4-5
+```
+
+### Restrict available tools
+
+```bash
+claude -p "YOUR PROMPT" --allowedTools "read,grep,glob"
+```
+
+## Important notes
+
+- Requires Claude Pro/Max subscription or `ANTHROPIC_API_KEY`
+- The `-p` flag is essential for non-interactive use
+- Supports `--output-format json` for machine-readable structured output
+- Supports `--input-format stream-json` for pipeline integration
+- Creates `CLAUDE.md` project config file (similar to AGENTS.md)
+- Claude Code has its own sub-agent support - useful for breaking down complex tasks
+
+## Delegation pattern
+
+For code changes:
+
+```bash
+RESULT=$(claude -p "Refactor the authentication module in src/auth/ to use the strategy pattern. Maintain backward compatibility with existing tests. Return a summary of changes made.")
+```
+
+For code review:
+
+```bash
+RESULT=$(git diff main..HEAD | claude -p "Review these changes. Focus on: 1) Security vulnerabilities 2) Performance regressions 3) API contract changes. Output as structured markdown." --output-format text)
+```
+
+For debugging:
+
+```bash
+RESULT=$(claude -p "The test in tests/auth.test.ts is failing with error: [ERROR]. Investigate the root cause and fix it. Return the fix as a diff.")
+```

package/templates/skills/copilot-cli/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: copilot-cli
+description: Delegate tasks to GitHub Copilot CLI for GitHub workflow automation, PR creation and review, issue management, and repository operations. Deeply integrated with GitHub's ecosystem.
+---
+
+## What is GitHub Copilot CLI
+
+GitHub Copilot CLI is GitHub's agentic coding tool for the terminal. It provides deep integration with GitHub workflows including pull requests, issues, code review, and repository management alongside standard coding capabilities.
+
+## When to delegate to Copilot CLI
+
+Use GitHub Copilot CLI when you need to:
+- Create, review, or manage pull requests
+- Manage GitHub issues (create, update, close, label)
+- Perform code review with GitHub-native feedback
+- Automate GitHub repository operations (branch management, releases)
+- Generate PR descriptions from code changes
+- Push changes and create PRs in a single flow using `/delegate`
+- Work with GitHub Actions workflows
+
+## How to invoke Copilot CLI
+
+### Non-interactive (recommended for delegation)
+
+```bash
+copilot --prompt "YOUR PROMPT HERE"
+```
+
+### Auto-approve all operations
+
+```bash
+copilot --prompt "YOUR PROMPT" --allow-all
+```
+
+### Delegate changes as a PR
+
+Inside Copilot CLI, the `/delegate` command pushes changes as a PR to a remote repo. For non-interactive use:
+
+```bash
+copilot --prompt "Make the following changes and create a PR: [DESCRIPTION]" --allow-all
+```
+
+## Important notes
+
+- Requires a GitHub Copilot subscription (Pro, Pro+, Business, or Enterprise)
+- Authentication is via GitHub account (`/login` on first run)
+- The older `gh copilot` extension was deprecated in Oct 2025 - use the standalone `copilot` command
+- Requires Node.js v22+
+- Copilot CLI has native access to GitHub API - no need for `gh` CLI separately
+
+## Delegation pattern
+
+When delegating GitHub-related tasks to Copilot CLI:
+
+```bash
+RESULT=$(copilot --prompt "Review the current branch changes and create a PR with title '[TITLE]' and description covering: [ASPECTS TO COVER]" --allow-all)
+```
+
+For read-only operations (e.g., listing issues):
+
+```bash
+RESULT=$(copilot --prompt "List all open issues labeled 'bug' in this repository. Return them as a markdown table with columns: number, title, assignee, created date.")
+```

package/templates/skills/cursor-cli/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: cursor-cli
+description: Delegate tasks to Cursor CLI (agent command) for IDE-grade coding in the terminal, cloud agent handoff for long-running tasks, and rapid prototyping with multi-model support.
+---
+
+## What is Cursor CLI
+
+Cursor CLI brings the full Cursor IDE agent experience to the terminal. It supports cloud agent handoff (start locally, continue remotely), works with any model in your Cursor subscription, and provides the same powerful coding capabilities as the Cursor editor.
+
+## When to delegate to Cursor CLI
+
+Use Cursor CLI when you need to:
+- Perform IDE-grade code generation and editing from the terminal
+- Hand off long-running tasks to cloud agents
+- Rapidly prototype features with multi-model support
+- Work on tasks that benefit from Cursor's proprietary model routing
+- Use plan mode to get implementation strategies before coding
+- Run background coding tasks while you work on other things
+
+## How to invoke Cursor CLI
+
+### Non-interactive (recommended for delegation)
+
+Use the `-p` flag for non-interactive print mode:
+
+```bash
+agent -p "YOUR PROMPT HERE"
+```
+
+### With cloud handoff (long-running tasks)
+
+```bash
+agent -p "YOUR PROMPT" -c --cloud
+```
+
+### With specific model
+
+```bash
+agent -p "YOUR PROMPT" --model gpt-5.2
+```
+
+### Plan mode (get strategy without making changes)
+
+```bash
+agent -p "YOUR PROMPT" --mode=plan
+```
+
+### Ask mode (answer questions without changes)
+
+```bash
+agent -p "YOUR PROMPT" --mode=ask
+```
+
+### Full agent mode (default - makes changes)
+
+```bash
+agent -p "YOUR PROMPT" --mode=agent
+```
+
+### List active/previous sessions
+
+```bash
+agent ls
+```
+
+### Resume a previous session
+
+```bash
+agent resume
+```
+
+## Important notes
+
+- Install via `curl https://cursor.sh/cli -fsS | bash`
+- Requires a Cursor subscription for authentication
+- The CLI command is `agent` (NOT `cursor`)
+- Still in beta - some features may change
+- The `-p` flag is essential for non-interactive use
+- Cloud mode (`-c` or `--cloud`) hands off to remote agents - useful for long tasks
+- Supports `--output-format text` for clean output capture
+
+## Delegation pattern
+
+For rapid prototyping:
+
+```bash
+RESULT=$(agent -p "Create a complete CRUD API for a blog post system using Express.js and TypeScript. Include routes, controllers, types, and basic validation. Structure files under src/api/posts/")
+```
+
+For planning before implementation:
+
+```bash
+PLAN=$(agent -p "How should I implement real-time notifications in this Next.js app? Consider WebSocket vs SSE, database design, and component architecture." --mode=plan)
+```
+
+For cloud-delegated long tasks:
+
+```bash
+agent -p "Migrate the entire test suite from Jest to Vitest. Update all config files, test utilities, and mocks. Ensure all tests pass." -c --cloud
+```

package/templates/skills/gemini-cli/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: gemini-cli
+description: Delegate tasks to Gemini CLI for context engineering, large codebase analysis, research-heavy coding tasks, and documentation generation. Gemini has a 1M token context window and built-in Google Search grounding.
+---
+
+## What is Gemini CLI
+
+Gemini CLI is Google's agentic coding tool for the terminal. It leverages Gemini models with up to 1M tokens of context, built-in Google Search grounding, and can read/edit files, run shell commands, and fetch web content.
+
+## When to delegate to Gemini CLI
+
+Use Gemini CLI when you need to:
+- Analyze very large codebases or files that exceed your context window
+- Research external APIs, libraries, or frameworks using Google Search grounding
+- Generate documentation from large amounts of source code
+- Perform context engineering tasks that benefit from massive context windows
+- Cross-reference multiple large files simultaneously
+- Understand complex dependency trees across an entire monorepo
+
+## How to invoke Gemini CLI
+
+### Non-interactive (recommended for delegation)
+
+Use the `-p` flag for non-interactive execution. The agent will run the prompt, produce output, and exit:
+
+```bash
+gemini -p "YOUR PROMPT HERE"
+```
+
+### With specific model
+
+```bash
+gemini -p "YOUR PROMPT" -m gemini-2.5-pro
+```
+
+### With all project files in context
+
+```bash
+gemini -p "YOUR PROMPT" -a
+```
+
+### Auto-approve all tool calls (use with caution)
+
+```bash
+gemini -p "YOUR PROMPT" --yolo
+```
+
+## Important notes
+
+- Gemini CLI requires authentication via Google account (free tier: 60 req/min, 1000/day) or `GOOGLE_API_KEY` env var
+- The `-p` flag is essential for non-interactive use - without it, Gemini enters interactive mode
+- Output from `-p` mode goes to stdout and can be captured
+- Gemini CLI creates a `GEMINI.md` project config file (similar to AGENTS.md)
+- For sandboxed execution, use `-s` flag (requires Docker)
+
+## Delegation pattern
+
+When delegating to Gemini CLI, structure your bash command like this:
+
+```bash
+RESULT=$(gemini -p "Analyze the following codebase concern: [SPECIFIC TASK]. Focus on [SPECIFIC ASPECTS]. Return your analysis as structured markdown.")
+```
+
+Then use the captured output to continue your work.

package/templates/skills/kimi-cli/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: kimi-cli
+description: Delegate tasks to Kimi CLI for front-end development, full-stack coding, and long-context code understanding. Powered by Moonshot AI's Kimi K2 model with extended context support.
+---
+
+## What is Kimi CLI
+
+Kimi CLI is Moonshot AI's terminal-based autonomous coding agent. It leverages the Kimi K2 model with long-context support, reads and edits code, executes shell commands, and supports MCP tools integration.
+
+## When to delegate to Kimi CLI
+
+Use Kimi CLI when you need to:
+- Build or modify front-end components (React, Vue, Svelte, etc.)
+- Implement full-stack features end-to-end
+- Work on tasks that benefit from long-context understanding
+- Generate UI code from descriptions or mockups
+- Perform front-end-specific tasks (styling, responsive design, accessibility)
+- Work with MCP-connected tools and resources
+
+## How to invoke Kimi CLI
+
+### Non-interactive (recommended for delegation)
+
+Kimi CLI accepts prompts via stdin pipe:
+
+```bash
+echo "YOUR PROMPT HERE" | kimi
+```
+
+### With specific model
+
+```bash
+echo "YOUR PROMPT" | kimi --model kimi-k2
+```
+
+### With MCP configuration
+
+```bash
+echo "YOUR PROMPT" | kimi --mcp-config-file ~/.config/kimi/mcp.json
+```
+
+## Important notes
+
+- Install via `uv tool install --python 3.13 kimi-cli` (requires `uv` package manager)
+- Authentication via `/login` command on first run (OAuth) or `KIMI_API_KEY` env var
+- Non-interactive mode uses stdin pipe (not a `-p` flag like other tools)
+- Kimi CLI creates an `AGENTS.md` project config (via `/init` command)
+- Supports OpenAI-compatible API format
+- Excels at front-end and UI-related coding tasks
+
+## Delegation pattern
+
+For front-end component creation:
+
+```bash
+RESULT=$(echo "Create a responsive navigation bar component using React and Tailwind CSS. It should have a logo, links (Home, About, Contact), a mobile hamburger menu, and dark mode toggle. Export as NavBar from src/components/NavBar.tsx" | kimi)
+```
+
+For full-stack features:
+
+```bash
+RESULT=$(echo "Implement a user profile page with the following: 1) React component at src/pages/Profile.tsx 2) API endpoint at src/api/profile.ts 3) Form for editing name, email, avatar. Use existing auth context from src/contexts/auth.tsx" | kimi)
+```
+
+For styling and accessibility:
+
+```bash
+RESULT=$(echo "Audit the components in src/components/ for accessibility issues. Fix any WCAG 2.1 AA violations. Add proper ARIA labels, keyboard navigation, and focus management." | kimi)
+```

package/templates/skills/sdlc-orchestrator/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: sdlc-orchestrator
+description: Orchestrate multiple coding agent CLIs as sub-agents. Load this skill to understand which coding agent CLI to delegate tasks to based on task type (front-end, context engineering, GitHub workflows, refactoring, pair programming, rapid prototyping).
+---
+
+## SDLC Sub-Agent Orchestration
+
+You have access to multiple coding agent CLIs that you can delegate tasks to via the Bash tool. Each agent has different strengths. Use the `skill` tool to load the specific agent's skill for detailed invocation instructions.
+
+## Agent Routing Table
+
+| Task Type | Recommended Agent | Skill to Load |
+|-----------|-------------------|---------------|
+| Large codebase analysis, research, documentation | Gemini CLI | `gemini-cli` |
+| GitHub PRs, issues, code review, repo management | Copilot CLI | `copilot-cli` |
+| Complex refactoring, architecture changes, debugging | Claude Code | `claude-code` |
+| Incremental changes with git commits, multi-model | Aider | `aider` |
+| Front-end development, UI components, styling | Kimi CLI | `kimi-cli` |
+| IDE-grade coding, cloud handoff, rapid prototyping | Cursor CLI | `cursor-cli` |
+
+## How to delegate
+
+1. **Identify the task type** from the user's request
+2. **Load the specific agent skill** using the `skill` tool (e.g., `skill({ name: "gemini-cli" })`)
+3. **Follow the delegation pattern** described in that skill
+4. **Execute via Bash** using the agent's non-interactive mode
+5. **Process the output** and continue your work
+
+## Quick reference for non-interactive invocation
+
+```
+gemini -p "PROMPT"                    # Gemini CLI
+copilot --prompt "PROMPT"             # GitHub Copilot CLI
+claude -p "PROMPT"                    # Claude Code
+aider --message "PROMPT" --yes        # Aider
+echo "PROMPT" | kimi                  # Kimi CLI
+agent -p "PROMPT"                     # Cursor CLI
+```
+
+## Multi-agent workflows
+
+You can chain multiple agents for complex SDLC workflows:
+
+1. **Research phase**: Use Gemini CLI to analyze requirements and existing code
+2. **Implementation phase**: Use Claude Code or Aider for the actual coding
+3. **Front-end phase**: Use Kimi CLI for UI components
+4. **Review phase**: Use Copilot CLI to create PRs with review
+5. **Iteration phase**: Use Aider for incremental fixes based on review feedback
+
+## Important rules
+
+- Always check if the target CLI is available before delegating (use `which <command>`)
+- Use non-interactive mode to capture output - never launch interactive sessions
+- If a CLI is not installed, inform the user and provide the install command
+- Prefer delegating to the agent best suited for the task type
+- Capture output using command substitution: `RESULT=$(command)`
+- If a task is simple enough for you to handle directly, don't delegate - only delegate complex or specialized tasks