@braingrid/cli 0.2.3 → 0.2.5

package/CHANGELOG.md

@@ -5,6 +5,77 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.5] - 2025-11-11
+
+### Fixed
+
+- **Status line installation in setup command** (#38)
+  - Fixed critical bug where `braingrid setup claude-code` failed to install status line
+  - Changed to fetch `statusline.sh` from GitHub repository instead of local package
+  - Fixed configuration format to use object with `type`, `command`, and `padding` fields
+  - Removed unused `fileURLToPath` import from setup handlers
+  - Status line now correctly installs and displays BrainGrid context in Claude Code
+
+### Changed
+
+- **CLAUDE.md injection source** (#38)
+  - Setup command now fetches `claude-code/CLAUDE.md` instead of `claude-code/README.md`
+  - Provides cleaner, more focused BrainGrid workflow instructions for injection
+  - Injected content matches the curated `.claude/CLAUDE.md` format
+
+- **AGENTS.md injection consistency** (#38)
+  - Created `.cursor/AGENTS.md` with same BrainGrid workflow content as `.claude/CLAUDE.md`
+  - Updated `cursor/AGENTS.md` in braingrid repo to match injection pattern (44 lines)
+  - Both Claude Code and Cursor now follow consistent injection pattern
+  - Provides unified BrainGrid workflow experience across both IDEs
+
+## [0.2.4] - 2025-11-10
+
+### Added
+
+- **BrainGrid context in Claude Code status line** (#36)
+  - Two-line status display showing project/requirement/task progress
+  - Auto-detects from `.braingrid/project.json` and git branch names
+  - Color-coded output: cyan for project, green for requirement, yellow for tasks
+  - Displays current task completion (e.g., `PROJ-130 > REQ-128 [2/5]`)
+  - Always shows workspace path, model name, and token usage
+  - Installed automatically with `braingrid setup claude-code`
+
+- **Setup commands for Claude Code and Cursor integrations** (#35)
+  - New `braingrid setup claude-code` command installs slash commands and skills
+  - New `braingrid setup cursor` command installs Cursor rules and commands
+  - Fetches integration files from BrainGridAI/braingrid repository
+  - Injects content into CLAUDE.md or AGENTS.md with markers
+  - Interactive prompts for file conflicts with overwrite/skip/all/quit options
+  - Dry-run mode with `--dry-run` flag
+  - Force mode with `--force` flag to skip all prompts
+
+- **Cursor IDE integration** (#34)
+  - Added AGENTS.md standard for Cursor AI agent configuration
+  - Supports auto-detection of project and requirement context
+  - Works with agent mode for autonomous task execution
+
+- **Claude Code sync automation** (#33)
+  - New `pnpm docs:sync-claude` command syncs skills and slash commands
+  - Automatically updates BrainGridAI/braingrid repository
+  - Keeps Claude Code integration files in sync across repos
+
+### Fixed
+
+- **Status line script path resolution** (code review fixes)
+  - Fixed critical bug using `import.meta.url` instead of `process.cwd()`
+  - Script now loads from package location, not user's directory
+  - Prevents "file not found" errors during setup
+
+- **Shell script error handling**
+  - Added `set -o pipefail` to status line script
+  - Properly detects braingrid command failures in pipelines
+  - More robust JSON parsing with better error detection
+
+- **Token display formatting**
+  - Fixed bug showing incorrect token counts (e.g., "24000k/200000k")
+  - Now correctly displays as "24k/200k tokens"
+
 ## [0.2.3] - 2025-01-10
 
 ### Added

package/README.md

@@ -37,6 +37,80 @@ npm install -g @braingrid/cli
 
 ---
 
+## AI Coding Tool Integration
+
+BrainGrid integrates natively with AI coding tools like **Cursor IDE** and **Claude Code** through the [AGENTS.md standard](https://agents.md/), providing seamless access to spec-driven development workflows directly in your editor.
+
+### What is AGENTS.md?
+
+[AGENTS.md](https://agents.md/) is an open standard that allows AI coding assistants to automatically load project-specific guidance and commands. BrainGrid uses this standard to provide consistent CLI guidance across multiple tools:
+
+- ✅ **Cursor IDE** - Automatic loading via AGENTS.md + slash commands
+- ✅ **Claude Code** - Automatic loading via AGENTS.md or .claude/CLAUDE.md
+- ✅ **GitHub Copilot** - Context from AGENTS.md
+- ✅ **Growing ecosystem** of AGENTS.md-compatible tools
+
+### Setup for Cursor IDE
+
+**Prerequisites:**
+
+- Cursor IDE installed ([download here](https://cursor.sh/))
+- BrainGrid CLI installed and authenticated
+
+**How it works:**
+
+1. **AGENTS.md** at your repository root is automatically loaded by Cursor
+2. **.cursor/rules/braingrid.mdc** provides Cursor-specific enhancements (always-on rules)
+3. **Slash commands** available via `/` in Cursor's Agent input
+
+**Available Commands:**
+
+Type `/` in Cursor's Agent input to access:
+
+- `/specify` - Create AI-refined requirements from natural language
+- `/breakdown` - Break requirements into implementation tasks
+- `/save-requirement` - Save requirement content to BrainGrid
+- `/build` - Generate complete implementation plan
+
+**Quick Start Example:**
+
+```bash
+# In Cursor IDE Agent input
+/specify "Add user authentication with OAuth2"
+# → Creates REQ-123
+
+/breakdown REQ-123
+# → Generates 5-10 implementation tasks
+
+/build REQ-123
+# → Shows complete requirement with all task prompts
+```
+
+### Setup for Claude Code
+
+BrainGrid's AGENTS.md file also works with Claude Code. You can either:
+
+1. **Use AGENTS.md directly** (Claude Code automatically reads it)
+2. **Symlink for compatibility**: `ln -s AGENTS.md .claude/CLAUDE.md`
+
+Claude Code also provides its own slash commands in `.claude/commands/`.
+
+### Cross-IDE Compatibility
+
+The AGENTS.md standard ensures your BrainGrid setup works across tools:
+
+- **AGENTS.md** provides CLI guidance for all compatible tools
+- **Tool-specific directories** (.cursor/, .claude/) add enhanced features
+- **Single source of truth** for BrainGrid workflows
+
+**Learn more:**
+
+- [AGENTS.md standard](https://agents.md/)
+- [BrainGrid documentation](https://www.braingrid.ai)
+- Full CLI command reference in [AGENTS.md](./AGENTS.md)
+
+---
+
 ## QuickStart: One-Minute Flow
 
 ```bash
@@ -87,6 +161,69 @@ The `init` command creates a `.braingrid/project.json` file in the `.braingrid/`
 
 > **Note:** The init command always asks for confirmation before initializing unless you use the `--force` flag.
 
+### Setup Commands
+
+Install BrainGrid integration files for AI coding tools. These commands fetch integration files from the [BrainGrid repository](https://github.com/BrainGridAI/braingrid) and install them in your project.
+
+**Prerequisites:**
+
+- **GitHub CLI** must be installed and authenticated
+  - macOS: `brew install gh`
+  - Windows: `winget install GitHub.CLI`
+  - Linux: See [GitHub CLI installation](https://cli.github.com/manual/installation)
+  - After installing: `gh auth login`
+
+**Commands:**
+
+```bash
+# Install Claude Code integration
+braingrid setup claude-code
+
+# Install Cursor integration
+braingrid setup cursor
+
+# Skip prompts and overwrite all existing files
+braingrid setup claude-code --force
+
+# Preview changes without making modifications
+braingrid setup cursor --dry-run
+```
+
+**What gets installed:**
+
+- **Claude Code integration:**
+  - Commands in `.claude/commands/` (specify, breakdown, build, save-requirement)
+  - Skills in `.claude/skills/braingrid-cli/`
+  - Content injected into `CLAUDE.md` (or creates it if it doesn't exist)
+
+- **Cursor integration:**
+  - Commands in `.cursor/commands/` (specify, breakdown, build, save-requirement)
+  - Rules in `.cursor/rules/`
+  - Content injected into `AGENTS.md` (or creates it if it doesn't exist)
+
+**Options:**
+
+- `--force` - Skip prompts and overwrite all existing files without asking
+- `--dry-run` - Show what would be done without making any changes
+
+**File Conflicts:**
+
+When files already exist, you'll be prompted to choose:
+
+- `[O]verwrite` - Replace this file
+- `[S]kip` - Keep existing file
+- `[A]ll` - Overwrite all remaining files
+- `[Q]uit` - Cancel installation
+
+**Marker-based Updates:**
+
+Running setup again will update the BrainGrid sections in `CLAUDE.md` or `AGENTS.md` without duplicating content. The CLI uses HTML comment markers to identify and replace existing BrainGrid content.
+
+**Learn more:**
+
+- [Claude Code integration guide](https://braingrid.ai/docs/integrations/claude-code)
+- [Cursor integration guide](https://braingrid.ai/docs/integrations/cursor)
+
 ### Project Commands
 
 ```bash

package/dist/cli.js

@@ -422,7 +422,7 @@ import axios3, { AxiosError as AxiosError2 } from "axios";
 
 // src/build-config.ts
 var BUILD_ENV = true ? "production" : process.env.NODE_ENV === "test" ? "development" : "production";
-var CLI_VERSION = true ? "0.2.3" : "0.0.0-test";
+var CLI_VERSION = true ? "0.2.5" : "0.0.0-test";
 var PRODUCTION_CONFIG = {
   apiUrl: "https://app.braingrid.ai",
   workosAuthUrl: "https://sensitive-harvest-60.authkit.app",
@@ -6113,6 +6113,431 @@ async function handleUpdate(opts) {
   }
 }
 
+// src/handlers/setup.handlers.ts
+import chalk14 from "chalk";
+import { select as select3 } from "@inquirer/prompts";
+import * as path5 from "path";
+import * as fs4 from "fs/promises";
+
+// src/utils/command-execution.ts
+import { exec as exec4, spawn } from "child_process";
+import { promisify as promisify4 } from "util";
+var execAsyncReal = promisify4(exec4);
+async function execAsync4(command, options, isTestMode = false, mockExecHandler) {
+  if (isTestMode && mockExecHandler) {
+    return mockExecHandler(command);
+  }
+  const defaultOptions = {
+    maxBuffer: 1024 * 1024 * 10,
+    // 10MB default
+    timeout: 3e5,
+    // 5 minutes
+    ...options
+  };
+  if (command.includes("claude")) {
+    defaultOptions.maxBuffer = 1024 * 1024 * 50;
+    defaultOptions.timeout = 6e5;
+  }
+  return execAsyncReal(command, defaultOptions);
+}
+
+// src/services/setup-service.ts
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+var GITHUB_OWNER = "BrainGridAI";
+var GITHUB_REPO = "braingrid";
+var MAX_RETRIES = 3;
+var INITIAL_RETRY_DELAY = 100;
+var BEGIN_MARKER = "<!-- BEGIN BRAINGRID INTEGRATION -->";
+var END_MARKER = "<!-- END BRAINGRID INTEGRATION -->";
+async function withRetry(fn, retries = MAX_RETRIES, delay = INITIAL_RETRY_DELAY) {
+  try {
+    return await fn();
+  } catch (error) {
+    if (retries === 0) {
+      throw error;
+    }
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const isNetworkError = errorMessage.includes("ECONNRESET") || errorMessage.includes("ETIMEDOUT") || errorMessage.includes("ENOTFOUND") || errorMessage.includes("network");
+    if (!isNetworkError) {
+      throw error;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return withRetry(fn, retries - 1, delay * 2);
+  }
+}
+function parseGitHubError(error) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  if (errorMessage.includes("404") || errorMessage.includes("Not Found")) {
+    return "File or directory not found in BrainGrid repository";
+  }
+  if (errorMessage.includes("403") || errorMessage.includes("rate limit")) {
+    return "GitHub API rate limit exceeded. Please wait a few minutes and try again.\nCheck rate limit status: gh api rate_limit";
+  }
+  if (errorMessage.includes("401") || errorMessage.includes("Unauthorized")) {
+    return "GitHub CLI is not authenticated. Run: gh auth login";
+  }
+  try {
+    const match = errorMessage.match(/\{.*\}/s);
+    if (match) {
+      const errorData = JSON.parse(match[0]);
+      return errorData.message || errorMessage;
+    }
+  } catch {
+  }
+  return errorMessage;
+}
+async function fetchFileFromGitHub(path6) {
+  return withRetry(async () => {
+    try {
+      const command = `gh api repos/${GITHUB_OWNER}/${GITHUB_REPO}/contents/${path6}`;
+      const { stdout } = await execAsync4(command);
+      const response = JSON.parse(stdout);
+      if (response.type !== "file") {
+        throw new Error(`Path ${path6} is not a file`);
+      }
+      if (!response.content || !response.encoding) {
+        throw new Error(`No content found for file ${path6}`);
+      }
+      if (response.encoding !== "base64") {
+        throw new Error(`Unexpected encoding: ${response.encoding}`);
+      }
+      const content = Buffer.from(response.content, "base64").toString("utf8");
+      return content;
+    } catch (error) {
+      const parsedError = parseGitHubError(error);
+      throw new Error(`Failed to fetch file ${path6}: ${parsedError}`);
+    }
+  });
+}
+async function listGitHubDirectory(path6) {
+  return withRetry(async () => {
+    try {
+      const command = `gh api repos/${GITHUB_OWNER}/${GITHUB_REPO}/contents/${path6}`;
+      const { stdout } = await execAsync4(command);
+      const response = JSON.parse(stdout);
+      if (!Array.isArray(response)) {
+        throw new Error(`Path ${path6} is not a directory`);
+      }
+      return response.map((item) => ({
+        name: item.name,
+        type: item.type,
+        path: item.path
+      }));
+    } catch (error) {
+      const parsedError = parseGitHubError(error);
+      throw new Error(`Failed to list directory ${path6}: ${parsedError}`);
+    }
+  });
+}
+async function copyFileFromGitHub(sourcePath, targetPath) {
+  try {
+    const content = await fetchFileFromGitHub(sourcePath);
+    const parentDir = path4.dirname(targetPath);
+    await fs3.mkdir(parentDir, { recursive: true });
+    await fs3.writeFile(targetPath, content, { encoding: "utf8", mode: 420 });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to copy file ${sourcePath} to ${targetPath}: ${errorMessage}`);
+  }
+}
+async function injectContentIntoFile(targetPath, content) {
+  try {
+    let fileContent;
+    let fileExists2 = false;
+    try {
+      fileContent = await fs3.readFile(targetPath, "utf8");
+      fileExists2 = true;
+    } catch {
+      fileContent = "";
+    }
+    if (fileExists2) {
+      const beginIndex = fileContent.indexOf(BEGIN_MARKER);
+      const endIndex = fileContent.indexOf(END_MARKER);
+      if (beginIndex !== -1 && endIndex !== -1 && endIndex > beginIndex) {
+        const before = fileContent.substring(0, beginIndex);
+        const after = fileContent.substring(endIndex + END_MARKER.length);
+        const newContent = `${before}${BEGIN_MARKER}
+${content}
+${END_MARKER}${after}`;
+        await fs3.writeFile(targetPath, newContent, { encoding: "utf8" });
+      } else {
+        const newContent = `${fileContent}
+
+${BEGIN_MARKER}
+${content}
+${END_MARKER}
+`;
+        await fs3.writeFile(targetPath, newContent, { encoding: "utf8" });
+      }
+    } else {
+      const parentDir = path4.dirname(targetPath);
+      await fs3.mkdir(parentDir, { recursive: true });
+      const newContent = `${BEGIN_MARKER}
+${content}
+${END_MARKER}
+`;
+      await fs3.writeFile(targetPath, newContent, { encoding: "utf8", mode: 420 });
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to inject content into ${targetPath}: ${errorMessage}`);
+  }
+}
+async function installStatusLineScript(scriptContent, targetPath = ".claude/statusline.sh") {
+  try {
+    const parentDir = path4.dirname(targetPath);
+    await fs3.mkdir(parentDir, { recursive: true });
+    await fs3.writeFile(targetPath, scriptContent, { encoding: "utf8", mode: 493 });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to install status line script to ${targetPath}: ${errorMessage}`);
+  }
+}
+async function updateClaudeSettings(settingsPath = ".claude/settings.json", scriptPath = ".claude/statusline.sh") {
+  try {
+    let settings = {};
+    try {
+      const content2 = await fs3.readFile(settingsPath, "utf8");
+      settings = JSON.parse(content2);
+    } catch {
+    }
+    settings.statusLine = {
+      type: "command",
+      command: scriptPath,
+      padding: 0
+    };
+    const parentDir = path4.dirname(settingsPath);
+    await fs3.mkdir(parentDir, { recursive: true });
+    const content = JSON.stringify(settings, null, 2);
+    await fs3.writeFile(settingsPath, content, { encoding: "utf8" });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to update Claude settings at ${settingsPath}: ${errorMessage}`);
+  }
+}
+
+// src/handlers/setup.handlers.ts
+async function fileExists(filePath) {
+  try {
+    await fs4.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkPrerequisites() {
+  try {
+    await execAsync4("gh --version");
+  } catch {
+    return {
+      success: false,
+      message: chalk14.red("\u274C GitHub CLI is not installed.\n\n") + chalk14.dim("Install instructions:\n") + chalk14.dim("  macOS: ") + chalk14.cyan("brew install gh") + chalk14.dim("\n") + chalk14.dim("  Windows: ") + chalk14.cyan("winget install GitHub.CLI") + chalk14.dim("\n") + chalk14.dim("  Linux: See ") + chalk14.cyan("https://cli.github.com/manual/installation") + chalk14.dim("\n\n") + chalk14.dim("After installing, run: ") + chalk14.cyan("gh auth login")
+    };
+  }
+  try {
+    await execAsync4("gh auth status");
+  } catch {
+    return {
+      success: false,
+      message: chalk14.red("\u274C Not authenticated with GitHub CLI.\n\n") + chalk14.dim("Please run: ") + chalk14.cyan("gh auth login")
+    };
+  }
+  return null;
+}
+async function getFileList(sourcePaths, targetPaths) {
+  const operations = [];
+  for (let i = 0; i < sourcePaths.length; i++) {
+    const sourcePath = sourcePaths[i];
+    const targetPath = targetPaths[i];
+    try {
+      const items = await listGitHubDirectory(sourcePath);
+      for (const item of items) {
+        if (item.type === "file") {
+          const itemTargetPath = path5.join(targetPath, item.name);
+          const exists = await fileExists(itemTargetPath);
+          operations.push({
+            type: "copy",
+            sourcePath: item.path,
+            targetPath: itemTargetPath,
+            exists
+          });
+        }
+      }
+    } catch (error) {
+      console.warn(
+        chalk14.yellow(`\u26A0\uFE0F  Could not list directory: ${sourcePath}`),
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  return operations;
+}
+function displayInstallationPlan(operations, injectionFile) {
+  console.log(chalk14.bold("\n\u{1F4CB} Installation Plan:\n"));
+  console.log(chalk14.cyan("  Content Injection:"));
+  console.log(chalk14.dim(`    ${injectionFile}`));
+  const newFiles = operations.filter((op) => !op.exists);
+  const existingFiles = operations.filter((op) => op.exists);
+  if (newFiles.length > 0) {
+    console.log(chalk14.cyan("\n  New Files:"));
+    for (const op of newFiles) {
+      console.log(chalk14.dim(`    ${op.targetPath}`));
+    }
+  }
+  if (existingFiles.length > 0) {
+    console.log(chalk14.yellow("\n  Existing Files (will prompt):"));
+    for (const op of existingFiles) {
+      console.log(chalk14.dim(`    ${op.targetPath}`));
+    }
+  }
+  console.log("");
+}
+async function promptForConflict(filePath) {
+  const answer = await select3({
+    message: chalk14.yellow(`File exists: ${filePath}`),
+    choices: [
+      { name: "[O]verwrite - Replace this file", value: "overwrite" },
+      { name: "[S]kip - Keep existing file", value: "skip" },
+      { name: "[A]ll - Overwrite all remaining", value: "all" },
+      { name: "[Q]uit - Cancel installation", value: "quit" }
+    ]
+  });
+  return answer;
+}
+async function installFiles(operations, force) {
+  let installed = 0;
+  let skipped = 0;
+  let overwriteAll = force;
+  for (const operation of operations) {
+    if (operation.exists && !overwriteAll) {
+      const response = await promptForConflict(operation.targetPath);
+      if (response === "quit") {
+        return { installed, skipped, cancelled: true };
+      } else if (response === "skip") {
+        skipped++;
+        continue;
+      } else if (response === "all") {
+        overwriteAll = true;
+      }
+    }
+    try {
+      await copyFileFromGitHub(operation.sourcePath, operation.targetPath);
+      installed++;
+    } catch (error) {
+      console.error(
+        chalk14.red(`Failed to copy ${operation.targetPath}:`),
+        error instanceof Error ? error.message : String(error)
+      );
+      skipped++;
+    }
+  }
+  return { installed, skipped, cancelled: false };
+}
+async function _handleSetup(config, opts) {
+  try {
+    const prerequisiteError = await checkPrerequisites();
+    if (prerequisiteError) {
+      return prerequisiteError;
+    }
+    console.log(chalk14.bold(`\u{1F680} Setting up ${config.name} integration...
+`));
+    const operations = await getFileList(config.sourceDirs, config.targetDirs);
+    const injectionFileExists = await fileExists(config.injection.targetFile);
+    operations.push({
+      type: "inject",
+      sourcePath: config.injection.sourceFile,
+      targetPath: config.injection.targetFile,
+      exists: injectionFileExists
+    });
+    displayInstallationPlan(
+      operations.filter((op) => op.type === "copy"),
+      config.injection.targetFile
+    );
+    if (opts.dryRun) {
+      return {
+        success: true,
+        message: chalk14.green("\u2705 Dry-run complete. No files were modified.\n\n") + chalk14.dim(`Would install ${operations.length} files.`)
+      };
+    }
+    const copyOps = operations.filter((op) => op.type === "copy");
+    const result = await installFiles(copyOps, opts.force || false);
+    if (result.cancelled) {
+      return {
+        success: false,
+        message: chalk14.yellow("\u26A0\uFE0F  Installation cancelled.\n\n") + chalk14.dim(`Installed: ${result.installed}, Skipped: ${result.skipped}`),
+        code: "CANCELLED"
+      };
+    }
+    try {
+      const content = await fetchFileFromGitHub(config.injection.sourceFile);
+      await injectContentIntoFile(config.injection.targetFile, content);
+    } catch (error) {
+      console.error(
+        chalk14.red(`Failed to inject content into ${config.injection.targetFile}:`),
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    let statusLineInstalled = false;
+    if (config.name === "Claude Code") {
+      try {
+        const scriptContent = await fetchFileFromGitHub("claude-code/statusline.sh");
+        await installStatusLineScript(scriptContent);
+        await updateClaudeSettings();
+        statusLineInstalled = true;
+      } catch (error) {
+        console.error(
+          chalk14.yellow("\u26A0\uFE0F  Failed to install status line script:"),
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    }
+    const statusLineMessage = statusLineInstalled ? chalk14.dim("  Status line: .claude/statusline.sh\n") : "";
+    return {
+      success: true,
+      message: chalk14.green(`\u2705 ${config.name} integration installed successfully!
+
+`) + chalk14.dim("Files installed:\n") + chalk14.dim(`  Commands: ${result.installed} files
+`) + statusLineMessage + chalk14.dim(`  Content injected into: ${config.injection.targetFile}
+
+`) + chalk14.dim("Next steps:\n") + chalk14.dim("  1. Review the integration files\n") + chalk14.dim(`  2. Open ${config.name}
+`) + chalk14.dim("  3. Try the /specify or /breakdown commands\n") + chalk14.dim("  4. Learn more: ") + chalk14.cyan(config.docsUrl)
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: chalk14.red(`\u274C Setup failed: ${errorMessage}`)
+    };
+  }
+}
+async function handleSetupClaudeCode(opts) {
+  const config = {
+    name: "Claude Code",
+    sourceDirs: ["claude-code/commands", "claude-code/skills"],
+    targetDirs: [".claude/commands", ".claude/skills/braingrid-cli"],
+    injection: {
+      sourceFile: "claude-code/CLAUDE.md",
+      targetFile: "CLAUDE.md"
+    },
+    docsUrl: "https://braingrid.ai/docs/claude-code"
+  };
+  return _handleSetup(config, opts);
+}
+async function handleSetupCursor(opts) {
+  const config = {
+    name: "Cursor",
+    sourceDirs: ["cursor/commands", "cursor/rules"],
+    targetDirs: [".cursor/commands", ".cursor/rules"],
+    injection: {
+      sourceFile: "cursor/AGENTS.md",
+      targetFile: "AGENTS.md"
+    },
+    docsUrl: "https://braingrid.ai/docs/cursor"
+  };
+  return _handleSetup(config, opts);
+}
+
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
 var packageJson = require2("../package.json");
@@ -6170,6 +6595,18 @@ program.command("specify").description("Create AI-refined requirement from promp
     process.exit(1);
   }
 });
+var createSetupAction = (handler) => {
+  return async (opts) => {
+    const result = await handler(opts);
+    console.log(result.message);
+    if (!result.success) {
+      process.exit(1);
+    }
+  };
+};
+var setup = program.command("setup").description("Setup BrainGrid integrations for AI coding tools");
+setup.command("claude-code").description("Install Claude Code integration").option("--force", "overwrite existing files without prompting").option("--dry-run", "show what would be done without making changes").action(createSetupAction(handleSetupClaudeCode));
+setup.command("cursor").description("Install Cursor integration").option("--force", "overwrite existing files without prompting").option("--dry-run", "show what would be done without making changes").action(createSetupAction(handleSetupCursor));
 var project = program.command("project").description("Manage projects");
 project.command("list").description("List all projects").option("--format <format>", "output format (table, json, xml, markdown)", "table").option("--page <page>", "page number for pagination", "1").option("--limit <limit>", "number of projects per page", "20").action(async (opts) => {
   const result = await handleProjectList(opts);