githits 0.1.5 → 0.1.8

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   version
-} from "./shared/chunk-0fnprry7.js";
+} from "./shared/chunk-6w8an8m7.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -547,11 +547,40 @@ function getApiUrl() {
 function getEnvApiToken() {
   return process.env.GITHITS_API_TOKEN;
 }
+// src/services/exec-service.ts
+import { spawn } from "node:child_process";
+
+class ExecServiceImpl {
+  async exec(command, args) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(command, args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env },
+        ...process.platform === "win32" && { shell: true }
+      });
+      const stdoutChunks = [];
+      const stderrChunks = [];
+      child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+      child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+      child.on("error", (error) => {
+        reject(error);
+      });
+      child.on("close", (code) => {
+        resolve({
+          exitCode: code ?? 1,
+          stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+          stderr: Buffer.concat(stderrChunks).toString("utf-8")
+        });
+      });
+    });
+  }
+}
 // src/services/filesystem-service.ts
 import {
   mkdir,
   readdir,
   readFile,
+  rename,
   stat,
   unlink,
   writeFile
@@ -609,6 +638,23 @@ class FileSystemServiceImpl {
       return false;
     }
   }
+  async atomicWriteFile(path, contents) {
+    const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    let mode = 384;
+    try {
+      const existing = await stat(path);
+      mode = existing.mode & 511;
+    } catch {}
+    try {
+      await writeFile(tmpPath, contents, { mode });
+      await rename(tmpPath, path);
+    } catch (error) {
+      try {
+        await unlink(tmpPath);
+      } catch {}
+      throw error;
+    }
+  }
 }
 // src/services/githits-service.ts
 class AuthenticationError extends Error {
@@ -891,6 +937,28 @@ class MigratingAuthStorage {
     return this.primary.getStorageLocation();
   }
 }
+// src/services/prompt-service.ts
+import { checkbox, select } from "@inquirer/prompts";
+
+class PromptServiceImpl {
+  async checkbox(message, choices) {
+    return checkbox({ message, choices });
+  }
+  async confirm3(message) {
+    return select({
+      message,
+      choices: [
+        { value: "yes", name: "Yes" },
+        { value: "no", name: "No" },
+        {
+          value: "always",
+          name: "Yes to all",
+          description: "Skip confirmation for remaining agents"
+        }
+      ]
+    });
+  }
+}
 // src/services/refreshing-githits-service.ts
 class RefreshingGitHitsService {
   apiUrl;
@@ -1239,6 +1307,495 @@ function registerFeedbackCommand(program) {
     }
   });
 }
+// src/commands/init/setup-handlers.ts
+function mergeServerConfig(existingContent, serversKey, serverName, serverConfig) {
+  let content = existingContent;
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  const trimmed = content.trim();
+  if (trimmed === "") {
+    content = "{}";
+  }
+  let config;
+  try {
+    config = JSON.parse(content);
+  } catch (err) {
+    return {
+      status: "parse_error",
+      error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    return {
+      status: "parse_error",
+      error: "Config file root is not a JSON object"
+    };
+  }
+  if (!(serversKey in config)) {
+    config[serversKey] = {};
+  }
+  const servers = config[serversKey];
+  if (typeof servers !== "object" || servers === null || Array.isArray(servers)) {
+    return {
+      status: "parse_error",
+      error: `"${serversKey}" is not a JSON object`
+    };
+  }
+  const serversObj = servers;
+  if (serverName in serversObj) {
+    return { status: "already_configured" };
+  }
+  serversObj[serverName] = serverConfig;
+  return {
+    status: "added",
+    content: `${JSON.stringify(config, null, 2)}
+`
+  };
+}
+function formatSetupPreview(config) {
+  if (config.method === "cli") {
+    return config.commands.map((cmd) => `Will run: ${cmd.command} ${cmd.args.join(" ")}`).join(`
+`);
+  }
+  const snippet = JSON.stringify({ [config.serverName]: config.serverConfig }, null, 2);
+  return `Will add to ${config.configPath}:
+
+${snippet}`;
+}
+async function isAlreadyConfigured(config, fs) {
+  try {
+    let content;
+    try {
+      content = await fs.readFile(config.configPath);
+    } catch {
+      return false;
+    }
+    if (content.charCodeAt(0) === 65279) {
+      content = content.slice(1);
+    }
+    const trimmed = content.trim();
+    if (trimmed === "") {
+      return false;
+    }
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return false;
+    }
+    const servers = parsed[config.serversKey];
+    if (typeof servers !== "object" || servers === null || Array.isArray(servers)) {
+      return false;
+    }
+    return config.serverName in servers;
+  } catch {
+    return false;
+  }
+}
+async function isCliAlreadyConfigured(check, execService) {
+  try {
+    const result = await execService.exec(check.command, check.args);
+    const combined = `${result.stdout} ${result.stderr}`;
+    return check.configuredPattern.test(combined);
+  } catch {
+    return false;
+  }
+}
+var ALREADY_EXISTS_PATTERNS = [
+  /already exists/i,
+  /already configured/i,
+  /already added/i
+];
+function isAlreadyConfiguredOutput(output) {
+  return ALREADY_EXISTS_PATTERNS.some((pattern) => pattern.test(output));
+}
+async function executeCliCommand(cmd, execService) {
+  try {
+    const result = await execService.exec(cmd.command, cmd.args);
+    const combined = `${result.stdout} ${result.stderr}`;
+    if (isAlreadyConfiguredOutput(combined)) {
+      return {
+        status: "already_configured",
+        message: `GitHits already configured via ${cmd.command}`
+      };
+    }
+    if (result.exitCode === 0) {
+      return { status: "success", message: "Configured successfully" };
+    }
+    const detail = result.stderr.trim() || result.stdout.trim();
+    return {
+      status: "failed",
+      message: `Command exited with code ${result.exitCode}${detail ? `: ${detail}` : ""}`
+    };
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return {
+        status: "failed",
+        message: `"${cmd.command}" not found on PATH. Install it or configure manually.`
+      };
+    }
+    return {
+      status: "failed",
+      message: `Failed to run command: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+async function executeCliSetup(setup, execService) {
+  let anyAlreadyConfigured = false;
+  for (const cmd of setup.commands) {
+    const result = await executeCliCommand(cmd, execService);
+    if (result.status === "failed") {
+      return result;
+    }
+    if (result.status === "already_configured") {
+      anyAlreadyConfigured = true;
+    }
+  }
+  if (anyAlreadyConfigured) {
+    return {
+      status: "already_configured",
+      message: `GitHits already configured via ${setup.commands[0]?.command}`
+    };
+  }
+  return { status: "success", message: "Configured successfully" };
+}
+async function executeConfigFileSetup(setup, fs) {
+  try {
+    const parentDir = fs.getDirname(setup.configPath);
+    await fs.ensureDir(parentDir);
+    let existingContent = "";
+    try {
+      existingContent = await fs.readFile(setup.configPath);
+    } catch (err) {
+      if (!(err instanceof Error) || !("code" in err) || err.code !== "ENOENT") {
+        return {
+          status: "failed",
+          message: `Cannot read ${setup.configPath}: ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+    }
+    const result = mergeServerConfig(existingContent, setup.serversKey, setup.serverName, setup.serverConfig);
+    if (result.status === "already_configured") {
+      return {
+        status: "already_configured",
+        message: `GitHits already configured in ${setup.configPath}`
+      };
+    }
+    if (result.status === "parse_error") {
+      return {
+        status: "failed",
+        message: `Cannot parse ${setup.configPath}: ${result.error}. File left unchanged.`
+      };
+    }
+    await fs.atomicWriteFile(setup.configPath, result.content);
+    return { status: "success", message: "Configured successfully" };
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "EACCES") {
+      return {
+        status: "failed",
+        message: `Permission denied writing to ${setup.configPath}. Check file permissions.`
+      };
+    }
+    return {
+      status: "failed",
+      message: `Failed to configure: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+
+// src/commands/init/agent-definitions.ts
+function getAppDataPath(fs, appName) {
+  const home = fs.getHomeDir();
+  switch (process.platform) {
+    case "win32":
+      return fs.joinPath(process.env.APPDATA ?? fs.joinPath(home, "AppData", "Roaming"), appName);
+    case "darwin":
+      return fs.joinPath(home, "Library", "Application Support", appName);
+    default:
+      return fs.joinPath(home, ".config", appName);
+  }
+}
+async function isExecutableAvailable(exec, executable) {
+  try {
+    const lookupCommand = process.platform === "win32" ? "where" : "which";
+    const result = await exec.exec(lookupCommand, [executable]);
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+var claudeCode = {
+  name: "Claude Code",
+  id: "claude-code",
+  detectionMethod: "binary",
+  setupMethod: "cli",
+  detectBinary: async (exec) => isExecutableAvailable(exec, "claude"),
+  getSetupConfig: () => ({
+    method: "cli",
+    commands: [
+      {
+        command: "claude",
+        args: ["plugin", "marketplace", "add", "githits-com/githits-cli"]
+      },
+      {
+        command: "claude",
+        args: ["plugin", "install", "githits@githits-plugins"]
+      }
+    ],
+    checkCommand: {
+      command: "claude",
+      args: ["plugin", "list"],
+      configuredPattern: /githits/i
+    }
+  })
+};
+var cursor = {
+  name: "Cursor",
+  id: "cursor",
+  detectionMethod: "path",
+  setupMethod: "config-file",
+  detectPaths: (fs) => [fs.joinPath(fs.getHomeDir(), ".cursor")],
+  getSetupConfig: (fs) => ({
+    method: "config-file",
+    configPath: fs.joinPath(fs.getHomeDir(), ".cursor", "mcp.json"),
+    serversKey: "mcpServers",
+    serverName: "GitHits",
+    serverConfig: { url: getMcpUrl() }
+  })
+};
+var windsurf = {
+  name: "Windsurf",
+  id: "windsurf",
+  detectionMethod: "path",
+  setupMethod: "config-file",
+  detectPaths: (fs) => [fs.joinPath(fs.getHomeDir(), ".codeium", "windsurf")],
+  getSetupConfig: (fs) => ({
+    method: "config-file",
+    configPath: fs.joinPath(fs.getHomeDir(), ".codeium", "windsurf", "mcp_config.json"),
+    serversKey: "mcpServers",
+    serverName: "GitHits",
+    serverConfig: { serverUrl: getMcpUrl() }
+  })
+};
+var claudeDesktop = {
+  name: "Claude Desktop",
+  id: "claude-desktop",
+  detectionMethod: "path",
+  setupMethod: "config-file",
+  detectPaths: (fs) => {
+    const appData = getAppDataPath(fs, "Claude");
+    if (process.platform === "win32") {
+      const home = fs.getHomeDir();
+      const localAppData = process.env.LOCALAPPDATA ?? fs.joinPath(home, "AppData", "Local");
+      return [
+        appData,
+        fs.joinPath(localAppData, "Claude"),
+        fs.joinPath(localAppData, "Programs", "Claude")
+      ];
+    }
+    return [appData];
+  },
+  getSetupConfig: (fs) => {
+    const appData = getAppDataPath(fs, "Claude");
+    return {
+      method: "config-file",
+      configPath: fs.joinPath(appData, "claude_desktop_config.json"),
+      serversKey: "mcpServers",
+      serverName: "GitHits",
+      serverConfig: {
+        command: "npx",
+        args: ["-y", "mcp-remote", getMcpUrl()]
+      }
+    };
+  }
+};
+var codexCli = {
+  name: "Codex CLI",
+  id: "codex-cli",
+  detectionMethod: "binary",
+  setupMethod: "cli",
+  detectBinary: async (exec) => isExecutableAvailable(exec, "codex"),
+  getSetupConfig: () => ({
+    method: "cli",
+    commands: [
+      {
+        command: "codex",
+        args: [
+          "mcp",
+          "add",
+          "githits",
+          "--",
+          "npx",
+          "-y",
+          "githits@latest",
+          "mcp",
+          "start"
+        ]
+      }
+    ],
+    checkCommand: {
+      command: "codex",
+      args: ["mcp", "list"],
+      configuredPattern: /githits/i
+    }
+  })
+};
+var vscode = {
+  name: "VS Code / Copilot",
+  id: "vscode",
+  detectionMethod: "path",
+  setupMethod: "config-file",
+  detectPaths: (fs) => {
+    const appData = getAppDataPath(fs, "Code");
+    return [appData];
+  },
+  getSetupConfig: (fs) => {
+    const appData = getAppDataPath(fs, "Code");
+    return {
+      method: "config-file",
+      configPath: fs.joinPath(appData, "User", "mcp.json"),
+      serversKey: "servers",
+      serverName: "GitHits",
+      serverConfig: { url: getMcpUrl(), type: "http" }
+    };
+  }
+};
+var cline = {
+  name: "Cline",
+  id: "cline",
+  detectionMethod: "path",
+  setupMethod: "config-file",
+  detectPaths: (fs) => [fs.joinPath(fs.getHomeDir(), ".cline")],
+  getSetupConfig: (fs) => ({
+    method: "config-file",
+    configPath: fs.joinPath(fs.getHomeDir(), ".cline", "data", "settings", "cline_mcp_settings.json"),
+    serversKey: "mcpServers",
+    serverName: "GitHits",
+    serverConfig: { url: getMcpUrl(), type: "streamableHttp" }
+  })
+};
+var geminiCli = {
+  name: "Gemini CLI",
+  id: "gemini-cli",
+  detectionMethod: "binary",
+  setupMethod: "cli",
+  detectBinary: async (exec) => isExecutableAvailable(exec, "gemini"),
+  getSetupConfig: () => ({
+    method: "cli",
+    commands: [
+      {
+        command: "gemini",
+        args: [
+          "extensions",
+          "install",
+          "https://github.com/githits-com/githits-cli"
+        ]
+      }
+    ],
+    checkCommand: {
+      command: "gemini",
+      args: ["extensions", "list"],
+      configuredPattern: /githits/i
+    }
+  })
+};
+var googleAntigravity = {
+  name: "Google Antigravity",
+  id: "google-antigravity",
+  detectionMethod: "path",
+  setupMethod: "config-file",
+  detectPaths: (fs) => [fs.joinPath(fs.getHomeDir(), ".gemini", "antigravity")],
+  getSetupConfig: (fs) => ({
+    method: "config-file",
+    configPath: fs.joinPath(fs.getHomeDir(), ".gemini", "antigravity", "mcp_config.json"),
+    serversKey: "mcpServers",
+    serverName: "GitHits",
+    serverConfig: { serverUrl: getMcpUrl() }
+  })
+};
+var openCode = {
+  name: "OpenCode",
+  id: "opencode",
+  detectionMethod: "binary",
+  setupMethod: "config-file",
+  detectBinary: async (exec) => isExecutableAvailable(exec, "opencode"),
+  getSetupConfig: (fs) => ({
+    method: "config-file",
+    configPath: process.platform === "win32" ? fs.joinPath(process.env.APPDATA ?? fs.joinPath(fs.getHomeDir(), "AppData", "Roaming"), "opencode", "opencode.json") : fs.joinPath(fs.getHomeDir(), ".config", "opencode", "opencode.json"),
+    serversKey: "mcp",
+    serverName: "GitHits",
+    serverConfig: {
+      type: "local",
+      command: ["npx", "-y", "githits@latest", "mcp", "start"],
+      enabled: true
+    }
+  })
+};
+var agentDefinitions = [
+  claudeCode,
+  cursor,
+  windsurf,
+  vscode,
+  cline,
+  claudeDesktop,
+  codexCli,
+  geminiCli,
+  googleAntigravity,
+  openCode
+];
+async function scanAgents(definitions, fs, execService) {
+  const result = {
+    needsSetup: [],
+    alreadyConfigured: [],
+    notDetected: []
+  };
+  for (const agent of definitions) {
+    let detected = false;
+    if (agent.detectionMethod === "binary" && agent.detectBinary) {
+      try {
+        detected = await agent.detectBinary(execService);
+      } catch {
+        detected = false;
+      }
+    } else if (agent.detectionMethod === "path" && agent.detectPaths) {
+      const paths = agent.detectPaths(fs);
+      for (const path of paths) {
+        if (await fs.isDirectory(path)) {
+          detected = true;
+          break;
+        }
+      }
+    }
+    if (!detected) {
+      result.notDetected.push(agent);
+      continue;
+    }
+    if (agent.setupMethod === "config-file") {
+      const config = agent.getSetupConfig(fs);
+      if (config.method === "config-file" && await isAlreadyConfigured(config, fs)) {
+        result.alreadyConfigured.push(agent);
+      } else {
+        result.needsSetup.push(agent);
+      }
+    } else {
+      const config = agent.getSetupConfig(fs);
+      if (config.method === "cli" && config.checkCommand) {
+        const configured = await isCliAlreadyConfigured(config.checkCommand, execService);
+        if (configured) {
+          result.alreadyConfigured.push(agent);
+        } else {
+          result.needsSetup.push(agent);
+        }
+      } else {
+        result.needsSetup.push(agent);
+      }
+    }
+  }
+  return result;
+}
+// node_modules/@inquirer/core/dist/lib/errors.js
+class ExitPromptError extends Error {
+  name = "ExitPromptError";
+}
 // src/shared/colors.ts
 var colors = {
   reset: "\x1B[0m",
@@ -1263,6 +1820,18 @@ function colorize(text, color, useColors) {
     return text;
   return `${colors[color]}${text}${colors.reset}`;
 }
+function success(text, useColors) {
+  const checkmark = useColors ? `${colors.green}✓${colors.reset}` : "✓";
+  return `${checkmark} ${text}`;
+}
+function error(text, useColors) {
+  const cross = useColors ? `${colors.red}✗${colors.reset}` : "✗";
+  return `${cross} ${text}`;
+}
+function warning(text, useColors) {
+  const warn = useColors ? `${colors.yellow}⚠${colors.reset}` : "⚠";
+  return `${warn} ${text}`;
+}
 function highlight(text, useColors) {
   if (!useColors)
     return text;
@@ -1274,76 +1843,24 @@ function dim(text, useColors) {
   return `${colors.dim}${text}${colors.reset}`;
 }
 
-// src/shared/language-filter.ts
-var DEFAULT_LIMIT = 5;
-function filterLanguages(languages, query, limit = DEFAULT_LIMIT) {
-  const lowerQuery = query.toLowerCase();
-  return languages.filter((lang) => lang.name.toLowerCase().includes(lowerQuery) || lang.display_name.toLowerCase().includes(lowerQuery) || lang.aliases.some((a) => a.toLowerCase().includes(lowerQuery))).slice(0, limit).map(({ name, display_name }) => ({ name, display_name }));
-}
-
-// src/commands/languages.ts
-async function languagesAction(query, options, deps) {
-  requireAuth(deps);
-  try {
-    const allLanguages = await deps.githitsService.getLanguages();
-    const displayList = query ? filterLanguages(allLanguages, query) : allLanguages.map(({ name, display_name }) => ({ name, display_name }));
-    if (options.json) {
-      console.log(JSON.stringify(displayList));
-    } else if (query && displayList.length === 0) {
-      console.log(`No languages matching "${query}".`);
-    } else {
-      const useColors = shouldUseColors();
-      for (const lang of displayList) {
-        console.log(`  ${colorize(lang.name, "cyan", useColors)}  ${dim(lang.display_name, useColors)}`);
-      }
-    }
-  } catch (error) {
-    console.error(`Failed to list languages: ${error instanceof Error ? error.message : error}`);
-    process.exit(1);
-  }
-}
-var LANGUAGES_DESCRIPTION = `List supported programming languages.
-
-Without a query, lists all supported languages.
-With a query, filters to the top 5 matches by name, display name, or alias.
-
-Examples:
-  githits languages              List all languages
-  githits languages python       Filter by name
-  githits languages type --json  JSON output for piping`;
-function registerLanguagesCommand(program) {
-  program.command("languages").summary("List supported programming languages").description(LANGUAGES_DESCRIPTION).argument("[query]", "Filter by name, display name, or alias").option("--json", "Output as JSON for piping").action(async (query, options) => {
-    try {
-      const deps = await createContainer();
-      await languagesAction(query, options, deps);
-    } catch (error) {
-      if (error instanceof AuthRequiredError)
-        process.exit(1);
-      throw error;
-    }
-  });
-}
 // src/commands/login.ts
 var TIMEOUT_MS = 5 * 60 * 1000;
 function randomPort() {
   return Math.floor(Math.random() * 2000) + 8000;
 }
-async function loginAction(options, deps) {
+async function loginFlow(options, deps) {
   const { authService, authStorage, browserService, mcpUrl } = deps;
   if (options.port !== undefined && (Number.isNaN(options.port) || options.port < 1 || options.port > 65535)) {
-    console.error("Invalid port number. Must be between 1 and 65535.");
-    process.exit(1);
+    return {
+      status: "failed",
+      message: "Invalid port number. Must be between 1 and 65535."
+    };
   }
   const existing = await authStorage.loadTokens(mcpUrl);
   if (existing && !options.force) {
     const isExpired = existing.expiresAt && new Date(existing.expiresAt) < new Date;
     if (!isExpired) {
-      console.log(`Already logged in.
-`);
-      console.log(`  Environment: ${mcpUrl}
-`);
-      console.log("To re-authenticate, use `githits login --force`.");
-      return;
+      return { status: "already_authenticated", message: "Already logged in." };
     }
     console.log(`Token expired. Starting new login...
 `);
@@ -1427,22 +1944,18 @@ async function loginAction(options, deps) {
     callback = await Promise.race([serverPromise, timeoutPromise]);
     if (timeoutId)
       clearTimeout(timeoutId);
-  } catch (error) {
+  } catch (error2) {
     if (timeoutId)
       clearTimeout(timeoutId);
-    if (error instanceof Error) {
-      console.log(`${error.message}.
-`);
-      console.log("Run `githits login` to try again.");
-    }
-    process.exit(1);
+    const msg = error2 instanceof Error ? error2.message : "Authentication failed";
+    return { status: "failed", message: `${msg}.` };
   }
   if (callback.type !== "success") {
-    console.log(`${callback.message}
-`);
-    console.log("Run `githits login` to try again.");
     await new Promise((r) => setTimeout(r, 2000));
-    process.exit(1);
+    return {
+      status: "failed",
+      message: callback.message ?? "Authentication callback failed."
+    };
   }
   let tokenResponse;
   try {
@@ -1454,14 +1967,15 @@ async function loginAction(options, deps) {
       codeVerifier: verifier,
       redirectUri
     });
-  } catch (error) {
+  } catch (error2) {
     try {
       await authStorage.clearClient(mcpUrl);
     } catch {}
-    console.error(`Failed to complete authentication: ${error instanceof Error ? error.message : error}
-`);
-    console.log("Run `githits login` to try again.");
-    process.exit(1);
+    const msg = error2 instanceof Error ? error2.message : String(error2);
+    return {
+      status: "failed",
+      message: `Failed to complete authentication: ${msg}`
+    };
   }
   const expiresAt = new Date(Date.now() + tokenResponse.expiresIn * 1000).toISOString();
   await authStorage.saveTokens(mcpUrl, {
@@ -1471,10 +1985,31 @@ async function loginAction(options, deps) {
     createdAt: new Date().toISOString()
   });
   const hours = Math.round(tokenResponse.expiresIn / 3600);
+  return {
+    status: "success",
+    message: `Logged in successfully. Token expires in ${hours} hour${hours !== 1 ? "s" : ""}.`
+  };
+}
+async function loginAction(options, deps) {
+  const result = await loginFlow(options, deps);
+  if (result.status === "already_authenticated") {
+    console.log(`Already logged in.
+`);
+    console.log(`  Environment: ${deps.mcpUrl}
+`);
+    console.log("To re-authenticate, use `githits login --force`.");
+    return;
+  }
+  if (result.status === "failed") {
+    console.error(`${result.message}
+`);
+    console.log("Run `githits login` to try again.");
+    process.exit(1);
+  }
   console.log(`Logged in successfully.
 `);
-  console.log(`  Environment: ${mcpUrl}`);
-  console.log(`  Token expires in: ${hours} hour${hours !== 1 ? "s" : ""}`);
+  console.log(`  Environment: ${deps.mcpUrl}`);
+  console.log(result.message.replace("Logged in successfully. ", "  "));
   console.log(`
 You're ready to use githits with your AI assistant.`);
 }
@@ -1491,6 +2026,217 @@ function registerLoginCommand(program) {
     await loginAction(options, deps);
   });
 }
+
+// src/commands/init/init.ts
+async function initAction(options, deps) {
+  const useColors = shouldUseColors();
+  const { fileSystemService, promptService, execService, createLoginDeps } = deps;
+  console.log(`
+  ${colorize("GitHits", "bold", useColors)} — Set up MCP server for your coding agents
+`);
+  if (!options.skipLogin && createLoginDeps) {
+    console.log(`  Checking authentication...
+`);
+    let loginResult;
+    try {
+      const loginDeps = await createLoginDeps();
+      loginResult = await loginFlow({}, loginDeps);
+    } catch (error2) {
+      const msg = error2 instanceof Error ? error2.message : String(error2);
+      loginResult = { status: "failed", message: msg };
+    }
+    if (loginResult.status === "already_authenticated") {
+      console.log(`    ${success("Already authenticated", useColors)}
+`);
+    } else if (loginResult.status === "success") {
+      console.log(`    ${success("Logged in successfully", useColors)}
+`);
+    } else {
+      console.log(`    ${warning(`Login failed: ${loginResult.message}`, useColors)}
+`);
+      if (!options.yes) {
+        try {
+          const choice = await promptService.confirm3("Continue without authentication?");
+          if (choice === "no") {
+            console.log("\n  Setup cancelled. Run `githits login` to authenticate.\n");
+            return;
+          }
+        } catch (err) {
+          if (err instanceof ExitPromptError) {
+            console.log(`
+  Setup cancelled.
+`);
+            return;
+          }
+          throw err;
+        }
+      }
+      console.log(`    Continuing without authentication...
+`);
+    }
+  }
+  console.log(`  Scanning for available agents...
+`);
+  const scan = await scanAgents(agentDefinitions, fileSystemService, execService);
+  for (const agent of scan.alreadyConfigured) {
+    console.log(`    ${success(`${agent.name} — already configured`, useColors)}`);
+  }
+  for (const agent of scan.needsSetup) {
+    console.log(`    ${colorize(`● ${agent.name} — needs setup`, "cyan", useColors)}`);
+  }
+  for (const agent of scan.notDetected) {
+    console.log(`    ${colorize(`${agent.name} — not detected`, "dim", useColors)}`);
+  }
+  console.log();
+  if (scan.needsSetup.length === 0 && scan.alreadyConfigured.length === 0) {
+    console.log(`  No coding agents detected. Install an agent and try again.
+`);
+    return;
+  }
+  if (scan.needsSetup.length === 0) {
+    console.log(`  All detected agents are already configured. Nothing to do.
+`);
+    return;
+  }
+  const toSetup = scan.needsSetup;
+  const outcomes = [];
+  let alwaysMode = options.yes ?? false;
+  for (const agent of toSetup) {
+    console.log(`  Setting up ${colorize(agent.name, "bold", useColors)}...
+`);
+    const config = agent.getSetupConfig(fileSystemService);
+    const preview = formatSetupPreview(config);
+    for (const line of preview.split(`
+`)) {
+      console.log(`    ${line}`);
+    }
+    console.log();
+    if (!alwaysMode) {
+      let choice;
+      try {
+        choice = await promptService.confirm3("Proceed?");
+      } catch (err) {
+        if (err instanceof ExitPromptError) {
+          console.log(`
+  Setup cancelled.
+`);
+          return;
+        }
+        throw err;
+      }
+      if (choice === "no") {
+        outcomes.push({ name: agent.name, status: "skipped" });
+        console.log();
+        continue;
+      }
+      if (choice === "always") {
+        alwaysMode = true;
+      }
+    }
+    const result = config.method === "cli" ? await executeCliSetup(config, execService) : await executeConfigFileSetup(config, fileSystemService);
+    outcomes.push({ name: agent.name, status: result.status });
+    if (result.status === "success") {
+      console.log(`    ${success(`${agent.name} configured`, useColors)}
+`);
+    } else if (result.status === "already_configured") {
+      console.log(`    ${warning(`${agent.name} already configured`, useColors)}
+`);
+    } else {
+      console.log(`    ${error(result.message, useColors)}
+`);
+    }
+  }
+  const configured = outcomes.filter((o) => o.status === "success").length;
+  const alreadyDone = outcomes.filter((o) => o.status === "already_configured").length + scan.alreadyConfigured.length;
+  const failed = outcomes.filter((o) => o.status === "failed").length;
+  const skipped = outcomes.filter((o) => o.status === "skipped").length;
+  if (configured > 0 || alreadyDone > 0) {
+    console.log("  Done! GitHits is ready.");
+  } else if (failed > 0) {
+    console.log("  Setup completed with errors.");
+  } else if (skipped > 0) {
+    console.log("  Setup skipped.");
+  }
+  if (failed > 0) {
+    console.log(`  ${failed} agent${failed !== 1 ? "s" : ""} failed to configure.`);
+  }
+  if (skipped > 0) {
+    console.log(`  ${skipped} agent${skipped !== 1 ? "s" : ""} skipped.`);
+  }
+  console.log();
+}
+var INIT_DESCRIPTION = `Set up GitHits MCP server for your coding agents.
+
+Authenticates with your GitHits account, then scans for available agents
+(Claude Code, Cursor, Windsurf, VS Code, Cline, Claude Desktop, Codex CLI,
+Gemini CLI, Google Antigravity), checks which are already configured,
+and sets up unconfigured ones with your confirmation.
+
+Supports CLI-based setup (Claude Code, Codex, Gemini CLI) and config
+file editing (Cursor, Windsurf, VS Code, Cline, Claude Desktop,
+Google Antigravity) with atomic writes.`;
+function registerInitCommand(program) {
+  program.command("init").summary("Set up MCP server for your coding agents").description(INIT_DESCRIPTION).option("-y, --yes", "Skip prompts, configure all detected agents").option("--skip-login", "Skip authentication step").action(async (options) => {
+    const fileSystemService = new FileSystemServiceImpl;
+    const promptService = new PromptServiceImpl;
+    const execService = new ExecServiceImpl;
+    await initAction(options, {
+      fileSystemService,
+      promptService,
+      execService,
+      createLoginDeps: () => createContainer()
+    });
+  });
+}
+// src/shared/language-filter.ts
+var DEFAULT_LIMIT = 5;
+function filterLanguages(languages, query, limit = DEFAULT_LIMIT) {
+  const lowerQuery = query.toLowerCase();
+  return languages.filter((lang) => lang.name.toLowerCase().includes(lowerQuery) || lang.display_name.toLowerCase().includes(lowerQuery) || lang.aliases.some((a) => a.toLowerCase().includes(lowerQuery))).slice(0, limit).map(({ name, display_name }) => ({ name, display_name }));
+}
+
+// src/commands/languages.ts
+async function languagesAction(query, options, deps) {
+  requireAuth(deps);
+  try {
+    const allLanguages = await deps.githitsService.getLanguages();
+    const displayList = query ? filterLanguages(allLanguages, query) : allLanguages.map(({ name, display_name }) => ({ name, display_name }));
+    if (options.json) {
+      console.log(JSON.stringify(displayList));
+    } else if (query && displayList.length === 0) {
+      console.log(`No languages matching "${query}".`);
+    } else {
+      const useColors = shouldUseColors();
+      for (const lang of displayList) {
+        console.log(`  ${colorize(lang.name, "cyan", useColors)}  ${dim(lang.display_name, useColors)}`);
+      }
+    }
+  } catch (error2) {
+    console.error(`Failed to list languages: ${error2 instanceof Error ? error2.message : error2}`);
+    process.exit(1);
+  }
+}
+var LANGUAGES_DESCRIPTION = `List supported programming languages.
+
+Without a query, lists all supported languages.
+With a query, filters to the top 5 matches by name, display name, or alias.
+
+Examples:
+  githits languages              List all languages
+  githits languages python       Filter by name
+  githits languages type --json  JSON output for piping`;
+function registerLanguagesCommand(program) {
+  program.command("languages").summary("List supported programming languages").description(LANGUAGES_DESCRIPTION).argument("[query]", "Filter by name, display name, or alias").option("--json", "Output as JSON for piping").action(async (query, options) => {
+    try {
+      const deps = await createContainer();
+      await languagesAction(query, options, deps);
+    } catch (error2) {
+      if (error2 instanceof AuthRequiredError)
+        process.exit(1);
+      throw error2;
+    }
+  });
+}
 // src/commands/logout.ts
 async function logoutAction(deps) {
   const { authStorage, mcpUrl } = deps;
@@ -1498,13 +2244,13 @@ async function logoutAction(deps) {
   let firstError;
   try {
     await authStorage.clearTokens(mcpUrl);
-  } catch (error) {
-    firstError = error;
+  } catch (error2) {
+    firstError = error2;
   }
   try {
     await authStorage.clearClient(mcpUrl);
-  } catch (error) {
-    firstError ??= error;
+  } catch (error2) {
+    firstError ??= error2;
   }
   if (!auth) {
     console.log(`Not currently logged in.
@@ -1553,8 +2299,8 @@ function errorResult(message) {
 async function withErrorHandling(operation, fn) {
   try {
     return await fn();
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : "Unknown error";
     return errorResult(`Failed to ${operation}: ${message}`);
   }
 }
@@ -1775,8 +2521,8 @@ async function searchAction(query, options, deps) {
     } else {
       console.log(result);
     }
-  } catch (error) {
-    console.error(`Failed to search: ${error instanceof Error ? error.message : error}`);
+  } catch (error2) {
+    console.error(`Failed to search: ${error2 instanceof Error ? error2.message : error2}`);
     process.exit(1);
   }
 }
@@ -1796,10 +2542,10 @@ function registerSearchCommand(program) {
     try {
       const deps = await createContainer();
       await searchAction(query, options, deps);
-    } catch (error) {
-      if (error instanceof AuthRequiredError)
+    } catch (error2) {
+      if (error2 instanceof AuthRequiredError)
         process.exit(1);
-      throw error;
+      throw error2;
     }
   });
 }
@@ -1811,6 +2557,7 @@ program.name("githits").description("Code examples from global open source for y
   }
 }).addHelpText("after", `
 Getting started:
+  githits init                           Set up MCP for your coding agents
   githits login                          Authenticate with your GitHits account
   githits mcp                            Start MCP server for your AI assistant
   githits search "query" --lang python   Search for code examples
@@ -1818,6 +2565,7 @@ Getting started:
 Learn more at https://githits.com
 Docs: https://app.githits.com/docs/
 Support: support@githits.com`);
+registerInitCommand(program);
 registerLoginCommand(program);
 registerLogoutCommand(program);
 registerMcpCommand(program);