@braingrid/cli 0.2.3 → 0.2.4

package/dist/cli.js

@@ -343,7 +343,7 @@ var DEFAULT_OPTIONS = {
   // No-op by default
 };
 async function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function calculateDelay(attempt, initialDelay, maxDelay, backoffMultiplier) {
   const exponentialDelay = initialDelay * Math.pow(backoffMultiplier, attempt - 1);
@@ -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.4" : "0.0.0-test";
 var PRODUCTION_CONFIG = {
   apiUrl: "https://app.braingrid.ai",
   workosAuthUrl: "https://sensitive-harvest-60.authkit.app",
@@ -531,7 +531,7 @@ var OAuth2Handler = class {
    * Start local HTTP server to handle OAuth callback
    */
   async startCallbackServer(port) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       this.server = createServer((req, res) => {
         const url = new URL(req.url || "", `http://127.0.0.1:${port}`);
         if (url.pathname === "/callback") {
@@ -634,7 +634,7 @@ var OAuth2Handler = class {
       });
       this.server.listen(port, "127.0.0.1", () => {
         logger2.debug(`Callback server listening on http://127.0.0.1:${port}`);
-        resolve();
+        resolve2();
       });
     });
   }
@@ -699,7 +699,7 @@ var OAuth2Handler = class {
    * Wait for the authorization code from the callback
    */
   async waitForAuthorizationCode(timeoutMs = 3e5) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const startTime = Date.now();
       const checkInterval = setInterval(() => {
         if (this.abortController?.signal.aborted) {
@@ -714,7 +714,7 @@ var OAuth2Handler = class {
         }
         if (this.authorizationCode) {
           clearInterval(checkInterval);
-          resolve(this.authorizationCode);
+          resolve2(this.authorizationCode);
           return;
         }
         if (Date.now() - startTime > timeoutMs) {
@@ -2091,7 +2091,7 @@ async function waitWithSpinner(message, checkFn, intervalMs = 3e3, maxAttempts =
         return true;
       }
       if (attempt < maxAttempts - 1) {
-        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
       }
     }
     if (spinnerInterval) clearInterval(spinnerInterval);
@@ -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";
+import { fileURLToPath } from "url";
+
+// 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((resolve2) => setTimeout(resolve2, 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 = scriptPath;
+    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 __filename = fileURLToPath(import.meta.url);
+        const __dirname = path5.dirname(__filename);
+        const scriptPath = path5.resolve(__dirname, "../../.claude/statusline.sh");
+        const scriptContent = await fs4.readFile(scriptPath, "utf8");
+        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/README.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);