feat: add Cursor CLI and Kilocode CLI support with auto-launch

- Add Cursor CLI and Kilocode CLI as coding assistant options
- Implement auto-detection of installed coding assistants using which command
- Auto-launch selected coding assistant with initial prompt after project setup
- Show installed assistants first in white, not installed in gray with (not installed)
- Replace manual instruction display with automatic process spawning
- Update README with new assistants and auto-launch feature

Author: rogeriochaves

README.md

@@ -9,7 +9,7 @@ Superagents helps you kickstart agent projects with the right structure, tooling
 - **Agent Testing Pyramid** methodology
 - **LangWatch** integration for prompt management, testing, and evaluation
 - **Framework-specific** configurations (Agno, Mastra)
-- **Coding assistant** setup (Claude Code) pre-configured to be an expert in your chosen framework
+- **Auto-launched coding assistant** (Claude Code, Cursor CLI, or Kilocode CLI) pre-configured as an expert in your chosen framework
 - **Production-ready** project structure
 
 ## Installation
@@ -47,7 +47,7 @@ The CLI will guide you through:
 
 1. **Programming Language**: Python or TypeScript
 2. **Agent Framework**: Agno (Python) or Mastra (TypeScript)
-3. **Coding Assistant**: Claude Code
+3. **Coding Assistant**: Claude Code, Cursor CLI, or Kilocode CLI
 4. **LLM Provider**: OpenAI
 5. **API Keys**: OpenAI and LangWatch
 6. **Project Goal**: What you want to build
@@ -97,17 +97,22 @@ Learn more: https://scenario.langwatch.ai/best-practices/the-agent-testing-pyram
 
 ### 🤖 Coding Assistant Setup
 
-Your coding assistant (e.g., Claude Code) is pre-configured with:
-- Framework-specific knowledge (via MCP or docs)
-- LangWatch best practices
-- Prompt management expertise
-- Testing methodologies
+Your coding assistant (e.g., Claude Code, Cursor CLI, Kilocode CLI) is:
+- **Automatically launched** after project setup with initial prompt
+- Pre-configured with framework-specific knowledge (via MCP or docs)
+- Loaded with LangWatch best practices
+- Equipped with prompt management expertise
+- Set up with testing methodologies
+- Auto-detected - the CLI shows which assistants are installed on your system
 
 ## Requirements
 
 - Node.js 18+
 - npm or pnpm
-- Claude Code (for coding assistant)
+- A coding assistant CLI (one of the following):
+  - [Claude Code](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code-agent) (`claude`)
+  - [Cursor CLI](https://www.cursor.com/) (`cursor-agent`)
+  - [Kilocode CLI](https://www.kilocode.ai/) (`kilocode`)
 - API Keys:
   - OpenAI API key
   - LangWatch API key (get one at https://app.langwatch.ai/authorize)
@@ -135,18 +140,28 @@ pnpm build
 
 ```bash
 superagents init trading-agent
-# Select: Python, Agno, Claude Code, OpenAI
+# Select: Python, Agno, your preferred coding assistant, OpenAI
 # Goal: "Build an agent that can analyze stock prices and provide trading recommendations"
 ```
 
 ### TypeScript + Mastra
 
 ```bash
 superagents init customer-support
-# Select: TypeScript, Mastra, Claude Code, OpenAI
+# Select: TypeScript, Mastra, your preferred coding assistant, OpenAI
 # Goal: "Build a customer support agent that can handle common queries and escalate complex issues"
 ```
 
+### Coding Assistant Auto-Launch
+
+After project setup completes, Superagents **automatically launches** your chosen coding assistant with a customized initial prompt that includes:
+- Your project goal
+- Framework-specific context
+- Best practices guidance
+- Next steps to get started
+
+The CLI detects which coding assistants are installed on your system and shows installed options first in the selection menu. Not installed assistants appear in gray with "(not installed)" but can still be selected.
+
 ## Resources
 
 - [LangWatch](https://langwatch.ai)

src/assistant-kickoff/display-instructions.ts

@@ -1,28 +1,46 @@
+import chalk from 'chalk';
 import type { ProjectConfig } from '../types.js';
 import { buildInitialPrompt } from './build-initial-prompt.js';
-import { displayInstructions } from './display-instructions.js';
+import { getCodingAssistantProvider } from '../providers/coding-assistants/index.js';
 
 /**
  * Kicks off the coding assistant with initial instructions.
- * 
+ *
  * @param params - Parameters object
  * @param params.projectPath - Absolute path to project root
  * @param params.config - Project configuration
- * @returns Promise that resolves when instructions are displayed
- * 
+ * @returns Promise that resolves when assistant is launched
+ *
  * @example
  * ```ts
  * await kickoffAssistant({ projectPath: '/path/to/project', config });
  * ```
  */
-export const kickoffAssistant = async ({ 
-  projectPath, 
-  config 
-}: { 
-  projectPath: string; 
-  config: ProjectConfig; 
+export const kickoffAssistant = async ({
+  projectPath,
+  config
+}: {
+  projectPath: string;
+  config: ProjectConfig;
 }): Promise<void> => {
   const prompt = buildInitialPrompt({ config });
-  displayInstructions({ projectPath, config, prompt });
+  const provider = getCodingAssistantProvider({ assistant: config.codingAssistant });
+
+  console.log(chalk.bold.cyan('\n🤖 Launching your coding assistant...\n'));
+  console.log(chalk.gray('Initial prompt:'));
+  console.log(chalk.white(`"${prompt}"\n`));
+  console.log(chalk.yellow(`Starting ${provider.displayName}...\n`));
+
+  try {
+    await provider.launch({ projectPath, prompt });
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk.red(`\n❌ Failed to launch ${provider.displayName}: ${error.message}`));
+      console.log(chalk.yellow('\nYou can manually start the assistant by running:'));
+      console.log(chalk.cyan(`  cd ${projectPath}`));
+      console.log(chalk.cyan(`  ${provider.command} "${prompt}"`));
+    }
+    throw error;
+  }
 };
 

src/assistant-kickoff/kickoff-assistant.ts

@@ -0,0 +1,51 @@
+import chalk from "chalk";
+import { getAllCodingAssistants } from "../../providers/coding-assistants/index.js";
+import type { CodingAssistant } from "../../types.js";
+import { detectInstalledAgents } from "../detect-installed-agents.js";
+
+type Choice = {
+  name: string;
+  value: CodingAssistant;
+};
+
+/**
+ * Builds coding assistant choices with installed agents shown first in white,
+ * and not installed agents shown later in gray with "(not installed)" suffix.
+ *
+ * @returns Promise resolving to array of choice objects for inquirer
+ *
+ * @example
+ * ```ts
+ * const choices = await buildCodingAssistantChoices();
+ * // Returns: [
+ * //   { name: "Claude Code", value: "claude-code" },
+ * //   { name: chalk.gray("Cursor CLI (not installed)"), value: "cursor-cli" }
+ * // ]
+ * ```
+ */
+export const buildCodingAssistantChoices = async (): Promise<Choice[]> => {
+  const assistants = getAllCodingAssistants();
+  const installedMap = await detectInstalledAgents();
+
+  const installed: Choice[] = [];
+  const notInstalled: Choice[] = [];
+
+  for (const assistant of assistants) {
+    const isInstalled = installedMap[assistant.id];
+    const choice: Choice = {
+      name: isInstalled
+        ? assistant.displayName
+        : chalk.gray(`${assistant.displayName} (not installed)`),
+      value: assistant.id as CodingAssistant,
+    };
+
+    if (isInstalled) {
+      installed.push(choice);
+    } else {
+      notInstalled.push(choice);
+    }
+  }
+
+  return [...installed, ...notInstalled];
+};
+

src/config-collection/choice-builders/coding-assistant-choices.ts

@@ -8,6 +8,7 @@ import type {
 } from "../types.js";
 import { buildLanguageChoices } from "./choice-builders/language-choices.js";
 import { buildFrameworkChoices } from "./choice-builders/framework-choices.js";
+import { buildCodingAssistantChoices } from "./choice-builders/coding-assistant-choices.js";
 import { validateOpenAIKey } from "./validators/openai-key.js";
 import { validateLangWatchKey } from "./validators/langwatch-key.js";
 import { validateProjectGoal } from "./validators/project-goal.js";
@@ -41,8 +42,8 @@ export const collectConfig = async (): Promise<ProjectConfig> => {
     });
 
     const codingAssistant = await select<CodingAssistant>({
-      message: "What coding assistant do you want to use?",
-      choices: [{ name: "Claude Code", value: "claude-code" }],
+      message: "What is your preferred coding assistant?",
+      choices: await buildCodingAssistantChoices(),
     });
 
     const llmProvider = await select<LLMProvider>({
@@ -66,7 +67,7 @@ export const collectConfig = async (): Promise<ProjectConfig> => {
     });
 
     const projectGoal = await input({
-      message: "What do you want to build?",
+      message: "What is your agent going to do?",
       validate: validateProjectGoal,
     });
 

src/config-collection/collect-config.ts

@@ -0,0 +1,53 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+/**
+ * Checks if a command is available in the system PATH.
+ *
+ * @param command - The command to check (e.g., 'claude', 'cursor-agent')
+ * @returns Promise resolving to true if command exists, false otherwise
+ *
+ * @example
+ * ```ts
+ * const hasCommand = await isCommandAvailable('claude');
+ * // Returns: true if claude is installed
+ * ```
+ */
+export const isCommandAvailable = async (command: string): Promise<boolean> => {
+  try {
+    await execAsync(`which ${command}`);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Detects which coding assistants are installed on the system.
+ *
+ * @returns Promise resolving to a map of assistant IDs to installation status
+ *
+ * @example
+ * ```ts
+ * const installed = await detectInstalledAgents();
+ * // Returns: { 'claude-code': true, 'cursor': false, 'kilocode': true }
+ * ```
+ */
+export const detectInstalledAgents = async (): Promise<
+  Record<string, boolean>
+> => {
+  const [hasClaude, hasCursor, hasKilocode] = await Promise.all([
+    isCommandAvailable("claude"),
+    isCommandAvailable("cursor-agent"),
+    isCommandAvailable("kilocode"),
+  ]);
+
+  return {
+    "claude-code": hasClaude,
+    "cursor-cli": hasCursor,
+    kilocode: hasKilocode,
+  };
+};
+

src/config-collection/detect-installed-agents.ts

@@ -1,5 +1,6 @@
 import * as fs from "fs/promises";
 import * as path from "path";
+import { spawn } from "child_process";
 import type { CodingAssistantProvider, MCPConfigFile } from "../index.js";
 
 /**
@@ -9,13 +10,33 @@ import type { CodingAssistantProvider, MCPConfigFile } from "../index.js";
 export const ClaudeCodingAssistantProvider: CodingAssistantProvider = {
   id: "claude-code",
   displayName: "Claude Code",
+  command: "claude",
 
   async writeMCPConfig({ projectPath, config }) {
     const mcpConfigPath = path.join(projectPath, ".mcp.json");
     await fs.writeFile(mcpConfigPath, JSON.stringify(config, null, 2));
   },
 
-  getKickoffInstructions: () =>
-    "Open this project in Claude Code and start the conversation.",
+  async launch({ projectPath, prompt }) {
+    return new Promise((resolve, reject) => {
+      const child = spawn("claude", [prompt], {
+        cwd: projectPath,
+        stdio: "inherit",
+        shell: true,
+      });
+
+      child.on("error", (error) => {
+        reject(new Error(`Failed to launch Claude Code: ${error.message}`));
+      });
+
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Claude Code exited with code ${code}`));
+        }
+      });
+    });
+  },
 };
 

src/providers/coding-assistants/claude/index.ts

@@ -0,0 +1,42 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { spawn } from "child_process";
+import type { CodingAssistantProvider, MCPConfigFile } from "../index.js";
+
+/**
+ * Cursor CLI assistant provider implementation.
+ * Writes MCP configuration as .mcp.json in project root.
+ */
+export const CursorCodingAssistantProvider: CodingAssistantProvider = {
+  id: "cursor-cli",
+  displayName: "Cursor CLI",
+  command: "cursor-agent",
+
+  async writeMCPConfig({ projectPath, config }) {
+    const mcpConfigPath = path.join(projectPath, ".mcp.json");
+    await fs.writeFile(mcpConfigPath, JSON.stringify(config, null, 2));
+  },
+
+  async launch({ projectPath, prompt }) {
+    return new Promise((resolve, reject) => {
+      const child = spawn("cursor-agent", [prompt], {
+        cwd: projectPath,
+        stdio: "inherit",
+        shell: true,
+      });
+
+      child.on("error", (error) => {
+        reject(new Error(`Failed to launch Cursor CLI: ${error.message}`));
+      });
+
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Cursor CLI exited with code ${code}`));
+        }
+      });
+    });
+  },
+};
+