@vohongtho.infotech/code-intel 1.0.1 → 1.0.2

package/dist/cli/main.js

@@ -9,7 +9,7 @@ import winston from 'winston';
 import DailyRotateFile from 'winston-daily-rotate-file';
 import fs39, { readFileSync, existsSync } from 'fs';
 import path39, { dirname, join } from 'path';
-import os13 from 'os';
+import os18 from 'os';
 import { Registry, collectDefaultMetrics, Counter, Histogram, Gauge } from 'prom-client';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
@@ -38,6 +38,7 @@ import https from 'https';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import process2 from 'process';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -327,13 +328,13 @@ var init_logger = __esm({
         };
       }
       /** Global log directory: ~/.code-intel/logs */
-      static LOG_DIR = path39.join(os13.homedir(), ".code-intel", "logs");
+      static LOG_DIR = path39.join(os18.homedir(), ".code-intel", "logs");
       static getLogger() {
         if (!_Logger.instance) {
           const isProduction = process.env.NODE_ENV === "production";
           const logLevel = process.env.LOG_LEVEL ?? "info";
           const transports = [];
-          transports.push(new winston.transports.Console());
+          transports.push(new winston.transports.Console({ stderrLevels: ["error", "warn", "info", "http", "verbose", "debug", "silly"] }));
           if (!isProduction) {
             try {
               if (!fs39.existsSync(_Logger.LOG_DIR)) {
@@ -3115,7 +3116,7 @@ var init_llm_governance = __esm({
       }
       /** Path to the JSONL log file. */
       getLogPath() {
-        return process.env["CODE_INTEL_GOVERNANCE_LOG_PATH"] ?? path39.join(os13.homedir(), ".code-intel", "llm-governance.jsonl");
+        return process.env["CODE_INTEL_GOVERNANCE_LOG_PATH"] ?? path39.join(os18.homedir(), ".code-intel", "llm-governance.jsonl");
       }
       /**
        * Append an entry to the governance log.
@@ -3276,6 +3277,49 @@ var init_anthropic = __esm({
   }
 });
 
+// src/llm/providers/custom.ts
+var custom_exports = {};
+__export(custom_exports, {
+  CustomProvider: () => CustomProvider
+});
+var CustomProvider;
+var init_custom = __esm({
+  "src/llm/providers/custom.ts"() {
+    CustomProvider = class {
+      modelName;
+      baseUrl;
+      apiKey;
+      constructor(baseUrl, model, apiKey = "") {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.modelName = model;
+        this.apiKey = apiKey;
+      }
+      async summarize(prompt2) {
+        const url = `${this.baseUrl}/chat/completions`;
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (this.apiKey) {
+          headers["Authorization"] = `Bearer ${this.apiKey}`;
+        }
+        const body = JSON.stringify({
+          model: this.modelName,
+          messages: [{ role: "user", content: prompt2 }],
+          max_tokens: 200,
+          temperature: 0.3
+        });
+        const res = await fetch(url, { method: "POST", headers, body });
+        if (!res.ok) {
+          const text = await res.text().catch(() => res.statusText);
+          throw new Error(`Custom LLM API error ${res.status}: ${text}`);
+        }
+        const data = await res.json();
+        return data.choices?.[0]?.message?.content?.trim() ?? "";
+      }
+    };
+  }
+});
+
 // src/llm/providers/ollama.ts
 var ollama_exports = {};
 __export(ollama_exports, {
@@ -3319,7 +3363,7 @@ __export(factory_exports, {
   createLLMProvider: () => createLLMProvider
 });
 async function createLLMProvider(config = {}) {
-  const { provider = "ollama", model } = config;
+  const { provider = "ollama", model, baseUrl, apiKey } = config;
   switch (provider) {
     case "openai": {
       const { OpenAIProvider: OpenAIProvider2 } = await Promise.resolve().then(() => (init_openai(), openai_exports));
@@ -3329,6 +3373,13 @@ async function createLLMProvider(config = {}) {
       const { AnthropicProvider: AnthropicProvider2 } = await Promise.resolve().then(() => (init_anthropic(), anthropic_exports));
       return new AnthropicProvider2(model);
     }
+    case "custom": {
+      const { CustomProvider: CustomProvider2 } = await Promise.resolve().then(() => (init_custom(), custom_exports));
+      const url = baseUrl ?? "http://localhost:1234/v1";
+      const mdl = model ?? "default";
+      const key = apiKey ?? "";
+      return new CustomProvider2(url, mdl, key);
+    }
     case "ollama":
     default: {
       const { OllamaProvider: OllamaProvider2 } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
@@ -3482,7 +3533,7 @@ var init_worker_pool = __esm({
       constructor(opts) {
         super();
         this.workerScript = opts.workerScript;
-        this.workerCount = opts.workerCount ?? Math.max(1, os13.cpus().length - 1);
+        this.workerCount = opts.workerCount ?? Math.max(1, os18.cpus().length - 1);
         this.maxQueueSize = opts.maxQueueSize ?? 200;
         this.maxTaskRetries = opts.maxTaskRetries ?? 2;
       }
@@ -3610,7 +3661,7 @@ var init_parse_phase_parallel = __esm({
         if (!context2.fileCache) context2.fileCache = /* @__PURE__ */ new Map();
         if (!context2.fileFunctionIndex) context2.fileFunctionIndex = /* @__PURE__ */ new Map();
         const filePaths = context2.filePaths;
-        const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os13.cpus().length - 1);
+        const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os18.cpus().length - 1);
         const CONCURRENCY = 64;
         for (let i = 0; i < filePaths.length; i += CONCURRENCY) {
           const batch = filePaths.slice(i, i + CONCURRENCY);
@@ -3739,7 +3790,7 @@ var init_resolve_phase_parallel = __esm({
         const snapshot = { symbolIndex, fileSymbolIndex, fileIndex, workspaceRoot };
         const workerScript = workerScriptPath2();
         const workerScriptExists = fs39.existsSync(workerScript);
-        const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os13.cpus().length - 1);
+        const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os18.cpus().length - 1);
         if (!workerScriptExists || workerCount === 1) {
           logger_default.info(`[resolve-parallel] falling back to sequential`);
           const { resolvePhase: resolvePhase2 } = await Promise.resolve().then(() => (init_resolve_phase(), resolve_phase_exports));
@@ -4531,7 +4582,7 @@ async function loadGraphToDB(graph, dbManager) {
     } catch {
     }
   }
-  const tmpDir = fs39.mkdtempSync(path39.join(os13.tmpdir(), "code-intel-csv-"));
+  const tmpDir = fs39.mkdtempSync(path39.join(os18.tmpdir(), "code-intel-csv-"));
   try {
     const nodeTableFiles = writeNodeCSVs(graph, tmpDir);
     const edgeGroups = writeEdgeCSV(graph, tmpDir);
@@ -4717,7 +4768,7 @@ function removeRepo(repoPath) {
 var GLOBAL_DIR, REPOS_FILE;
 var init_repo_registry = __esm({
   "src/storage/repo-registry.ts"() {
-    GLOBAL_DIR = path39.join(os13.homedir(), ".code-intel");
+    GLOBAL_DIR = path39.join(os18.homedir(), ".code-intel");
     REPOS_FILE = path39.join(GLOBAL_DIR, "repos.json");
   }
 });
@@ -4888,7 +4939,7 @@ function loadSyncResult(groupName) {
 var GROUPS_DIR;
 var init_group_registry = __esm({
   "src/multi-repo/group-registry.ts"() {
-    GROUPS_DIR = path39.join(os13.homedir(), ".code-intel", "groups");
+    GROUPS_DIR = path39.join(os18.homedir(), ".code-intel", "groups");
   }
 });
 
@@ -5447,14 +5498,14 @@ function runPrerequisiteChecks() {
     });
   }
   try {
-    const out = execSync(`df -BM "${os13.homedir()}" 2>/dev/null | tail -1 | awk '{print $4}'`, { encoding: "utf8" });
+    const out = execSync(`df -BM "${os18.homedir()}" 2>/dev/null | tail -1 | awk '{print $4}'`, { encoding: "utf8" });
     const availMB = parseInt(out.trim().replace("M", ""), 10);
     if (Number.isFinite(availMB) && availMB < 500) {
       results.push({
         name: "Disk space",
         ok: false,
         level: "warn",
-        message: `Low disk space: ${availMB} MB available in ${os13.homedir()} (500 MB recommended)`
+        message: `Low disk space: ${availMB} MB available in ${os18.homedir()} (500 MB recommended)`
       });
     }
   } catch {
@@ -5475,6 +5526,7 @@ var init_codes = __esm({
       RATE_LIMIT_EXCEEDED: "CI-1100",
       PAYLOAD_TOO_LARGE: "CI-1101",
       INVALID_REQUEST: "CI-1200",
+      CONFLICT: "CI-1409",
       // Config (CI-2xxx)
       CONFIG_INVALID: "CI-2000",
       CONFIG_NOT_FOUND: "CI-2001",
@@ -5544,7 +5596,7 @@ var init_fs_secure = __esm({
   }
 });
 function getUsersDBPath() {
-  return process.env["CODE_INTEL_USERS_DB_PATH"] ?? path39.join(os13.homedir(), ".code-intel", "users.db");
+  return process.env["CODE_INTEL_USERS_DB_PATH"] ?? path39.join(os18.homedir(), ".code-intel", "users.db");
 }
 function getOrCreateUsersDB() {
   if (!_usersDB) {
@@ -5837,17 +5889,17 @@ function getScryptN() {
   return Number.isInteger(v) && v >= 1024 ? v : 1 << 14;
 }
 function getSecretsPath() {
-  return process.env["CODE_INTEL_SECRETS_PATH"] ?? path39.join(os13.homedir(), ".code-intel", ".secrets");
+  return process.env["CODE_INTEL_SECRETS_PATH"] ?? path39.join(os18.homedir(), ".code-intel", ".secrets");
 }
 function getMasterPassword() {
   const fromEnv = process.env["CODE_INTEL_SECRET_KEY"];
   if (fromEnv && fromEnv.length >= 16) return fromEnv;
   let username = "unknown";
   try {
-    username = os13.userInfo().username;
+    username = os18.userInfo().username;
   } catch {
   }
-  return `code-intel-machine:${os13.hostname()}:${username}:${os13.platform()}`;
+  return `code-intel-machine:${os18.hostname()}:${username}:${os18.platform()}`;
 }
 function deriveKey(password, salt) {
   return crypto5.scryptSync(password, salt, KEY_LEN, { N: getScryptN(), r: 8, p: 1 });
@@ -8313,6 +8365,7 @@ async function runInitWizard(opts = {}) {
       { label: "Ollama (local, free, requires Ollama running)", value: "ollama" },
       { label: "OpenAI (requires OPENAI_API_KEY env var)", value: "openai" },
       { label: "Anthropic (requires ANTHROPIC_API_KEY env var)", value: "anthropic" },
+      { label: "Custom (OpenAI-compatible API \u2014 enter URL, token & model)", value: "custom" },
       { label: "Skip (configure later)", value: "none" }
     ], 0);
     cfg.llm.provider = llmProvider;
@@ -8328,6 +8381,19 @@ async function runInitWizard(opts = {}) {
       cfg.llm.model = "llama3";
       cfg.llm.apiKey = "";
       console.log("  Make sure Ollama is running: https://ollama.com");
+    } else if (llmProvider === "custom") {
+      console.log("  Configure your OpenAI-compatible provider (e.g. LM Studio, vLLM, Together, Groq, Azure).\n");
+      const baseUrl = (await prompt(rl, "  API Base URL (e.g. http://localhost:1234/v1): ")).trim();
+      cfg.llm.baseUrl = baseUrl || "http://localhost:1234/v1";
+      const apiKey = (await prompt(rl, "  API Token/Key (leave blank if not required): ")).trim();
+      cfg.llm.apiKey = apiKey || "";
+      const model = (await prompt(rl, "  Model name (e.g. mistral-7b-instruct): ")).trim();
+      cfg.llm.model = model || "default";
+      console.log(`
+  \u2705  Custom provider configured:`);
+      console.log(`     URL:   ${cfg.llm.baseUrl}`);
+      console.log(`     Model: ${cfg.llm.model}`);
+      console.log(`     Token: ${cfg.llm.apiKey ? "(set)" : "(none)"}`);
     } else {
       cfg.llm.apiKey = "";
       console.log("  Skipped. Run `code-intel config set llm.provider openai` later.");
@@ -8392,7 +8458,7 @@ function printNextSteps() {
 var GLOBAL_DIR2, CONFIG_PATH, DEFAULT_CONFIG, EDITORS;
 var init_init_wizard = __esm({
   "src/cli/init-wizard.ts"() {
-    GLOBAL_DIR2 = path39.join(os13.homedir(), ".code-intel");
+    GLOBAL_DIR2 = path39.join(os18.homedir(), ".code-intel");
     CONFIG_PATH = path39.join(GLOBAL_DIR2, "config.json");
     DEFAULT_CONFIG = {
       $schema: "https://code-intel.dev/config-schema.json",
@@ -8705,9 +8771,10 @@ var init_config_manager = __esm({
       /access[_-]?token/i
     ];
     CONFIG_SCHEMA = {
-      "llm.provider": { type: "string", enum: ["openai", "anthropic", "ollama", "none"], default: "ollama", description: "LLM provider for AI summaries" },
+      "llm.provider": { type: "string", enum: ["openai", "anthropic", "ollama", "custom", "none"], default: "ollama", description: "LLM provider for AI summaries" },
       "llm.model": { type: "string", default: "llama3", description: "LLM model name" },
       "llm.apiKey": { type: "string", default: "", description: "API key \u2014 use $ENV_VAR syntax, e.g. $OPENAI_API_KEY" },
+      "llm.baseUrl": { type: "string", default: "", description: "Base URL for custom OpenAI-compatible API (e.g. http://localhost:1234/v1)" },
       "llm.batchSize": { type: "number", minimum: 1, maximum: 100, default: 20, description: "Concurrent LLM calls per batch" },
       "llm.maxTokensPerSummary": { type: "number", minimum: 10, maximum: 2e3, default: 100, description: "Max tokens per AI summary" },
       "embeddings.model": { type: "string", default: "all-MiniLM-L6-v2", description: "Embedding model name" },
@@ -10394,7 +10461,7 @@ var JobsDB = class {
   }
 };
 function getJobsDBPath() {
-  return path39.join(os13.homedir(), ".code-intel", "jobs.db");
+  return path39.join(os18.homedir(), ".code-intel", "jobs.db");
 }
 var _jobsDB = null;
 function getOrCreateJobsDB() {
@@ -10489,14 +10556,14 @@ var BACKUP_VERSION = "1.0";
 var ALGORITHM = "aes-256-gcm";
 var IV_LENGTH = 16;
 function getBackupDir() {
-  return path39.join(os13.homedir(), ".code-intel", "backups");
+  return path39.join(os18.homedir(), ".code-intel", "backups");
 }
 function getBackupKey() {
   const keyHex = process.env["CODE_INTEL_BACKUP_KEY"];
   if (keyHex && keyHex.length >= 64) {
     return Buffer.from(keyHex.slice(0, 64), "hex");
   }
-  const seed = `code-intel-backup-${os13.hostname()}-${os13.homedir()}`;
+  const seed = `code-intel-backup-${os18.hostname()}-${os18.homedir()}`;
   return crypto5.createHash("sha256").update(seed).digest();
 }
 function encryptBuffer(data, key) {
@@ -10538,11 +10605,11 @@ var BackupService = class {
         filesToBackup.push({ name: f, localPath: fp });
       }
     }
-    const registryPath = path39.join(os13.homedir(), ".code-intel", "registry.json");
+    const registryPath = path39.join(os18.homedir(), ".code-intel", "registry.json");
     if (fs39.existsSync(registryPath)) {
       filesToBackup.push({ name: "registry.json", localPath: registryPath });
     }
-    const usersDbPath = path39.join(os13.homedir(), ".code-intel", "users.db");
+    const usersDbPath = path39.join(os18.homedir(), ".code-intel", "users.db");
     if (fs39.existsSync(usersDbPath)) {
       filesToBackup.push({ name: "users.db", localPath: usersDbPath });
     }
@@ -10708,7 +10775,7 @@ var BackupService = class {
       }
       let destPath;
       if (name === "registry.json" || name === "users.db") {
-        destPath = path39.join(os13.homedir(), ".code-intel", name);
+        destPath = path39.join(os18.homedir(), ".code-intel", name);
       } else {
         destPath = path39.join(codeIntelDir, name);
       }
@@ -12387,6 +12454,97 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     }
     res.json(result);
   });
+  app.post("/api/v1/groups", requireAuth, requireRole("analyst"), (req, res) => {
+    const { name } = req.body;
+    if (!name || !name.trim()) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: "Group name is required" } });
+      return;
+    }
+    const trimmed = name.trim();
+    if (groupExists(trimmed)) {
+      res.status(409).json({ error: { code: ErrorCodes.CONFLICT, message: `Group "${trimmed}" already exists` } });
+      return;
+    }
+    const group = { name: trimmed, createdAt: (/* @__PURE__ */ new Date()).toISOString(), members: [] };
+    saveGroup(group);
+    res.status(201).json(group);
+  });
+  app.delete("/api/v1/groups/:name", requireAuth, requireRole("analyst"), (req, res) => {
+    const groupName = req.params["name"];
+    if (!groupExists(groupName)) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    deleteGroup(groupName);
+    res.status(204).end();
+  });
+  app.patch("/api/v1/groups/:name", requireAuth, requireRole("analyst"), (req, res) => {
+    const groupName = req.params["name"];
+    const group = loadGroup(groupName);
+    if (!group) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    const { name } = req.body;
+    if (!name || !name.trim()) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: "New name is required" } });
+      return;
+    }
+    const newName = name.trim();
+    if (newName !== group.name && groupExists(newName)) {
+      res.status(409).json({ error: { code: ErrorCodes.CONFLICT, message: `Group "${newName}" already exists` } });
+      return;
+    }
+    if (newName !== group.name) {
+      deleteGroup(group.name);
+      group.name = newName;
+    }
+    saveGroup(group);
+    res.json(group);
+  });
+  app.post("/api/v1/groups/:name/members", requireAuth, requireRole("analyst"), (req, res) => {
+    const groupName = req.params["name"];
+    const group = loadGroup(groupName);
+    if (!group) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    const { groupPath, registryName } = req.body;
+    if (!groupPath || !registryName) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: "groupPath and registryName are required" } });
+      return;
+    }
+    const registry = loadRegistry();
+    if (!registry.find((r) => r.name === registryName)) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: `Repo "${registryName}" not found in registry. Run code-intel analyze first.` } });
+      return;
+    }
+    try {
+      const updated = addMember(groupName, { groupPath, registryName });
+      res.json(updated);
+    } catch (err) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: err instanceof Error ? err.message : String(err) } });
+    }
+  });
+  app.delete("/api/v1/groups/:name/members", requireAuth, requireRole("analyst"), (req, res) => {
+    const groupName = req.params["name"];
+    const group = loadGroup(groupName);
+    if (!group) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    const { groupPath } = req.body;
+    if (!groupPath) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: "groupPath is required" } });
+      return;
+    }
+    try {
+      const updated = removeMember(groupName, groupPath);
+      res.json(updated);
+    } catch (err) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: err instanceof Error ? err.message : String(err) } });
+    }
+  });
   app.post("/api/v1/groups/:name/sync", async (req, res) => {
     const group = loadGroup(req.params.name);
     if (!group) {
@@ -12397,8 +12555,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       const result = await syncGroup(group);
       saveSyncResult(result);
       group.lastSync = result.syncedAt;
-      const { saveGroup: saveGroup2 } = await Promise.resolve().then(() => (init_group_registry(), group_registry_exports));
-      saveGroup2(group);
+      saveGroup(group);
       res.json(result);
     } catch (err) {
       res.status(500).json({ error: { code: ErrorCodes.INTERNAL_ERROR, message: err instanceof Error ? err.message : String(err) } });
@@ -14954,6 +15111,14 @@ function writeContextFiles(workspaceRoot, projectName, stats, skills) {
   const kiroDir = path39.join(workspaceRoot, ".kiro", "steering");
   if (!fs39.existsSync(kiroDir)) fs39.mkdirSync(kiroDir, { recursive: true });
   upsertFile(path39.join(kiroDir, "code-intel.md"), block, "code-intel.md");
+  upsertFile(path39.join(workspaceRoot, ".clinerules"), block, ".clinerules");
+  upsertFile(path39.join(workspaceRoot, ".windsurfrules"), block, ".windsurfrules");
+  const kilocodeDir = path39.join(workspaceRoot, ".kilocode", "rules");
+  if (!fs39.existsSync(kilocodeDir)) fs39.mkdirSync(kilocodeDir, { recursive: true });
+  upsertFile(path39.join(kilocodeDir, "code-intel-rules.md"), block, "code-intel-rules.md");
+  const agentsDir = path39.join(workspaceRoot, ".agents", "rules");
+  if (!fs39.existsSync(agentsDir)) fs39.mkdirSync(agentsDir, { recursive: true });
+  upsertFile(path39.join(agentsDir, "code-intel-rules.md"), block, "code-intel-rules.md");
 }
 function buildBlock(projectName, stats, skills) {
   const skillTableRows = skills.map(
@@ -15451,7 +15616,7 @@ var MigrationRunner = class {
     try {
       const dbFile = this.db.name;
       if (!dbFile || !fs39.existsSync(dbFile)) return;
-      const backupDir = path39.join(os13.homedir(), ".code-intel", "backups", "pre-migration");
+      const backupDir = path39.join(os18.homedir(), ".code-intel", "backups", "pre-migration");
       fs39.mkdirSync(backupDir, { recursive: true });
       const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
       const baseName = path39.basename(dbFile, ".db");
@@ -15607,7 +15772,7 @@ init_tracing();
 init_init_wizard();
 init_config_manager();
 init_codes();
-var GLOBAL_DIR3 = path39.join(os13.homedir(), ".code-intel");
+var GLOBAL_DIR3 = path39.join(os18.homedir(), ".code-intel");
 function loadRepoPaths() {
   try {
     const data = fs39.readFileSync(path39.join(GLOBAL_DIR3, "repos.json"), "utf-8");
@@ -15881,7 +16046,7 @@ function autoInstallCompletion() {
   }
   console.log(`  Detected shell: ${shell}`);
   if (shell === "fish") {
-    const dir = path39.join(os13.homedir(), ".config", "fish", "completions");
+    const dir = path39.join(os18.homedir(), ".config", "fish", "completions");
     const dest = path39.join(dir, "code-intel.fish");
     fs39.mkdirSync(dir, { recursive: true });
     fs39.writeFileSync(dest, fishCompletion(), "utf-8");
@@ -15894,7 +16059,7 @@ source <(code-intel completion zsh)
 ` : `
 source <(code-intel completion bash)
 `;
-  const rcFile = shell === "zsh" ? path39.join(os13.homedir(), ".zshrc") : path39.join(os13.homedir(), ".bashrc");
+  const rcFile = shell === "zsh" ? path39.join(os18.homedir(), ".zshrc") : path39.join(os18.homedir(), ".bashrc");
   try {
     const existing = fs39.existsSync(rcFile) ? fs39.readFileSync(rcFile, "utf-8") : "";
     if (existing.includes("code-intel completion")) {
@@ -15921,7 +16086,7 @@ function generateCompletion(shell) {
       return fishCompletion();
   }
 }
-var GLOBAL_DIR4 = path39.join(os13.homedir(), ".code-intel");
+var GLOBAL_DIR4 = path39.join(os18.homedir(), ".code-intel");
 var META_PATH = path39.join(GLOBAL_DIR4, "update-meta.json");
 var PACKAGE_NAME = "code-intel";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
@@ -16047,14 +16212,170 @@ async function runUpdate(opts = {}) {
     process.exit(1);
   }
 }
+var SOURCE_EXT = /* @__PURE__ */ new Set([
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "py",
+  "pyi",
+  "rs",
+  "go",
+  "java",
+  "kt",
+  "kts",
+  "rb",
+  "cs",
+  "cpp",
+  "cc",
+  "cxx",
+  "c",
+  "h",
+  "hpp",
+  "swift",
+  "scala",
+  "php"
+]);
+var REGEX_META_RE = /[.*+?^${}()|[\]\\]/;
+var SYMBOL_ID_RE = /^[A-Za-z_$][A-Za-z0-9_$.-]*$/;
+function isSymbolLike(term) {
+  return SYMBOL_ID_RE.test(term) && !REGEX_META_RE.test(term);
+}
+function isSourceFile(filePath) {
+  const dot = filePath.lastIndexOf(".");
+  if (dot === -1) return false;
+  return SOURCE_EXT.has(filePath.slice(dot + 1).toLowerCase());
+}
+function fileStem(filePath) {
+  const base = filePath.includes("/") ? filePath.slice(filePath.lastIndexOf("/") + 1) : filePath;
+  const dot = base.lastIndexOf(".");
+  return dot === -1 ? base : base.slice(0, dot);
+}
+function extractGrepSymbol(cmd) {
+  if (/(?:^|\s)-[a-zA-Z]*[cvlLoZ]/.test(cmd)) return null;
+  const quoted = cmd.match(/(?:^|\s)["']([^"']+)["'](?:\s|$)/);
+  if (quoted) {
+    const term = quoted[1];
+    return isSymbolLike(term) ? term : null;
+  }
+  const tokens = cmd.split(/\s+/).slice(1);
+  for (const tok of tokens) {
+    if (tok.startsWith("-")) continue;
+    if (tok.startsWith("/")) continue;
+    if (tok.startsWith("./") || tok.startsWith("../")) continue;
+    if (tok.includes("/")) continue;
+    if (tok === "." || tok === "..") continue;
+    return isSymbolLike(tok) ? tok : null;
+  }
+  return null;
+}
+function rewriteCommand(cmd) {
+  try {
+    const trimmed = cmd.trim();
+    if (!trimmed) return null;
+    if (trimmed.startsWith("code-intel ") || trimmed === "code-intel") return null;
+    if (/(?:&&|\|\||;|\|)/.test(trimmed)) return null;
+    if (/^grep\s/.test(trimmed)) {
+      const sym = extractGrepSymbol(trimmed);
+      if (sym) return `code-intel search "${sym}"`;
+      return null;
+    }
+    if (/^rg\s/.test(trimmed)) {
+      if (/\s--files(?:\s|$)/.test(trimmed)) return null;
+      if (/\s--files-with-matches(?:\s|$)/.test(trimmed)) return null;
+      if (/\s--type-not\b/.test(trimmed)) return null;
+      const sym = extractGrepSymbol(trimmed);
+      if (sym) return `code-intel search "${sym}"`;
+      return null;
+    }
+    if (/^cat\s/.test(trimmed)) {
+      const m = trimmed.match(/^cat\s+(\S+)$/);
+      if (!m) return null;
+      const filePath = m[1];
+      if (filePath === "-") return null;
+      if (filePath.startsWith(">")) return null;
+      if (!isSourceFile(filePath)) return null;
+      return `code-intel inspect ${fileStem(filePath)}`;
+    }
+    if (/^(?:head|tail)\s/.test(trimmed)) {
+      if (/\s-f\b/.test(trimmed)) return null;
+      const m = trimmed.match(
+        /^(?:head|tail)\s+(?:-\d+\s+|-n\s+\d+\s+|--lines=\d+\s+)?(\S+)$/
+      );
+      if (!m) return null;
+      const filePath = m[1];
+      if (!isSourceFile(filePath)) return null;
+      return `code-intel inspect ${fileStem(filePath)}`;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function runRewrite(cmd) {
+  const rewritten = rewriteCommand(cmd.trim());
+  if (rewritten === null) {
+    process2.exit(1);
+  }
+  process2.stdout.write(rewritten);
+  process2.exit(0);
+}
+function runClaudeHook() {
+  process2.on("uncaughtException", () => process2.exit(0));
+  process2.on("unhandledRejection", () => process2.exit(0));
+  let input = "";
+  process2.stdin.setEncoding("utf-8");
+  process2.stdin.on("data", (chunk) => {
+    input += chunk;
+  });
+  process2.stdin.on("end", () => {
+    try {
+      if (!input.trim()) {
+        process2.exit(0);
+      }
+      const parsed = JSON.parse(input);
+      const cmd = parsed?.tool_input?.command;
+      if (typeof cmd !== "string" || !cmd.trim()) {
+        process2.exit(0);
+      }
+      const rewritten = rewriteCommand(cmd);
+      if (rewritten === null || rewritten === cmd) {
+        process2.exit(0);
+      }
+      const response = {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "allow",
+          permissionDecisionReason: "code-intel: semantic search replaces grep/cat",
+          updatedInput: {
+            ...parsed.tool_input,
+            command: rewritten
+          }
+        }
+      };
+      process2.stdout.write(JSON.stringify(response));
+      process2.exit(0);
+    } catch {
+      process2.exit(0);
+    }
+  });
+  process2.stdin.on("error", () => {
+    process2.exit(0);
+  });
+}
 
 // src/cli/main.ts
 var __filename$1 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname(__filename$1);
 var _pkg = JSON.parse(readFileSync(join(__dirname2, "../../package.json"), "utf-8"));
-initTracing();
+var IS_HOOK_MODE = process.argv[2] === "hook";
+if (!IS_HOOK_MODE) {
+  initTracing();
+}
 var debugMode = process.argv.includes("--debug");
-{
+if (!IS_HOOK_MODE) {
   const checks = runPrerequisiteChecks();
   for (const c of checks) {
     const icon = c.level === "error" ? "\u2717" : "\u26A0";
@@ -16062,20 +16383,28 @@ var debugMode = process.argv.includes("--debug");
 `);
   }
 }
-if (!configExists()) {
+if (!IS_HOOK_MODE && !configExists()) {
   process.stderr.write(
     "  \u2139  No config found. Run `code-intel init` to set up your environment.\n"
   );
 }
 process.on("uncaughtException", (err) => {
+  if (IS_HOOK_MODE) {
+    process.exit(0);
+  }
   process.stderr.write(formatCliError(err, debugMode));
   process.exit(1);
 });
 process.on("unhandledRejection", (err) => {
+  if (IS_HOOK_MODE) {
+    process.exit(0);
+  }
   process.stderr.write(formatCliError(err, debugMode));
   process.exit(1);
 });
-backgroundVersionCheck(_pkg.version);
+if (!IS_HOOK_MODE) {
+  backgroundVersionCheck(_pkg.version);
+}
 var program = new Command();
 var BANNER = `
   \u25C8  Code Intelligence Platform  v${_pkg.version}
@@ -16125,6 +16454,8 @@ program.name("code-intel").description("Code Intelligence Platform \u2014 Static
   \u2502  server                                                                                                            \u2502
   \u2502    code-intel mcp [path]                    Launch the MCP stdio server consumed by AI-enabled editors            \u2502
   \u2502    code-intel serve [path] --port <n>       Start the HTTP API and serve the interactive web UI (default :4747)   \u2502
+  \u2502    code-intel serve --detach                Start the server in the background (frees the terminal)               \u2502
+  \u2502    code-intel stop [path]                   Stop a background server started with --detach                        \u2502
   \u2502                                                                                                                    \u2502
   \u2502  registry                                                                                                          \u2502
   \u2502    code-intel list                          Display all repositories that have been indexed                       \u2502
@@ -16272,7 +16603,9 @@ async function analyzeWorkspace(targetPath, options) {
       provider: options.llmProvider ?? "ollama",
       model: options.llmModel,
       batchSize: options.llmBatchSize,
-      maxNodesPerRun: options.llmMaxNodes
+      maxNodesPerRun: options.llmMaxNodes,
+      baseUrl: options.llmBaseUrl,
+      apiKey: options.llmApiKey
     } : void 0,
     onProgress: options?.silent ? void 0 : (phase, msg) => {
       if (!options?.silent) {
@@ -16706,6 +17039,396 @@ program.command("completion").description("Generate shell completion scripts (ba
   }
   process.stdout.write(generateCompletion(shell));
 });
+var CODE_INTEL_HOOK_CMD = "code-intel-hook claude";
+var CODE_INTEL_CURSOR_HOOK_CMD = "code-intel-hook cursor";
+var CODE_INTEL_GEMINI_HOOK_CMD = "code-intel-hook gemini";
+function hookAlreadyPresent(root) {
+  const entries = root?.hooks?.PreToolUse;
+  if (!Array.isArray(entries)) return false;
+  return entries.some(
+    (entry) => Array.isArray(entry?.hooks) && entry.hooks.some(
+      (h) => typeof h?.command === "string" && (h.command.includes("code-intel-hook") || h.command.includes("code-intel hook"))
+    )
+  );
+}
+function insertHookEntry(root) {
+  const existingHooks = root.hooks ?? {};
+  const existingPreToolUse = Array.isArray(
+    existingHooks.PreToolUse
+  ) ? existingHooks.PreToolUse : [];
+  const newEntry = {
+    matcher: "Bash",
+    hooks: [{ type: "command", command: CODE_INTEL_HOOK_CMD }]
+  };
+  return {
+    ...root,
+    hooks: {
+      ...existingHooks,
+      PreToolUse: [newEntry, ...existingPreToolUse]
+    }
+  };
+}
+function installClaudeHook() {
+  const settingsPath = path39.join(os18.homedir(), ".claude", "settings.json");
+  let root = {};
+  if (fs39.existsSync(settingsPath)) {
+    try {
+      const raw = fs39.readFileSync(settingsPath, "utf-8");
+      root = JSON.parse(raw);
+    } catch (err) {
+      return {
+        result: "skipped",
+        reason: `Could not parse ~/.claude/settings.json: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  if (hookAlreadyPresent(root)) {
+    return { result: "already-present" };
+  }
+  const updated = insertHookEntry(root);
+  if (fs39.existsSync(settingsPath)) {
+    try {
+      fs39.copyFileSync(settingsPath, `${settingsPath}.bak`);
+    } catch {
+      logger_default.warn("  \u26A0   Could not create settings.json backup \u2014 proceeding anyway");
+    }
+  }
+  try {
+    fs39.mkdirSync(path39.dirname(settingsPath), { recursive: true });
+    const tmp = `${settingsPath}.tmp.${Date.now()}`;
+    fs39.writeFileSync(tmp, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+    fs39.renameSync(tmp, settingsPath);
+  } catch (err) {
+    return {
+      result: "skipped",
+      reason: `Could not write ~/.claude/settings.json: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  return { result: "installed" };
+}
+var COPILOT_HOOK_JSON_CONTENT = JSON.stringify({
+  hooks: {
+    PreToolUse: [
+      { type: "command", command: CODE_INTEL_HOOK_CMD.replace("claude", "copilot"), cwd: ".", timeout: 5 }
+    ]
+  }
+}, null, 2) + "\n";
+function installCopilotHook(workspaceRoot = ".") {
+  const githubDir = path39.join(workspaceRoot, ".github");
+  const hooksDir = path39.join(githubDir, "hooks");
+  const hookFile = path39.join(hooksDir, "code-intel-rewrite.json");
+  try {
+    fs39.mkdirSync(hooksDir, { recursive: true });
+    if (fs39.existsSync(hookFile)) {
+      try {
+        const existing = JSON.parse(fs39.readFileSync(hookFile, "utf-8"));
+        const hooks = existing?.hooks?.PreToolUse;
+        if (Array.isArray(hooks) && hooks.some(
+          (h) => typeof h?.command === "string" && h.command.includes("code-intel")
+        )) {
+          return { result: "already-present" };
+        }
+      } catch {
+      }
+    }
+    const tmp = `${hookFile}.tmp.${Date.now()}`;
+    fs39.writeFileSync(tmp, COPILOT_HOOK_JSON_CONTENT, "utf-8");
+    fs39.renameSync(tmp, hookFile);
+    return { result: "installed" };
+  } catch (err) {
+    return { result: "skipped", reason: `Could not write .github/hooks/code-intel-rewrite.json: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+var OPENCODE_PLUGIN_CONTENT = `import type { Plugin } from "@opencode-ai/plugin"
+import { execSync } from "node:child_process"
+
+// code-intel OpenCode plugin \u2014 rewrites symbol-discovery commands to semantic equivalents.
+// Requires: code-intel installed and in PATH.
+// To change rewrite rules, edit hook-rewriter.ts in the code-intel source.
+
+let codeIntelAvailable: boolean | null = null
+
+function checkCodeIntel(): boolean {
+  if (codeIntelAvailable !== null) return codeIntelAvailable
+  try {
+    execSync("which code-intel", { stdio: "ignore" })
+    codeIntelAvailable = true
+  } catch {
+    codeIntelAvailable = false
+  }
+  return codeIntelAvailable
+}
+
+function tryRewrite(command: string): string | null {
+  try {
+    const result = execSync(\`code-intel rewrite \${JSON.stringify(command)}\`, {
+      encoding: "utf-8",
+      timeout: 2000,
+    }).trim()
+    return result && result !== command ? result : null
+  } catch {
+    return null
+  }
+}
+
+export const CodeIntelOpenCodePlugin: Plugin = async ({ $ }) => {
+  if (!checkCodeIntel()) {
+    console.warn("[code-intel] code-intel binary not found in PATH \u2014 plugin disabled")
+    return {}
+  }
+  return {
+    "tool.execute.before": async (input, output) => {
+      const tool = String(input?.tool ?? "").toLowerCase()
+      if (tool !== "bash" && tool !== "shell") return
+      const args = output?.args
+      if (!args || typeof args !== "object") return
+      const command = (args as Record<string, unknown>).command
+      if (typeof command !== "string" || !command) return
+      try {
+        const rewritten = tryRewrite(command)
+        if (rewritten) {
+          ;(args as Record<string, unknown>).command = rewritten
+        }
+      } catch {
+        // non-blocking
+      }
+    },
+  }
+}
+`;
+function installOpenCodePlugin() {
+  const pluginDir = path39.join(os18.homedir(), ".config", "opencode", "plugins");
+  const pluginFile = path39.join(pluginDir, "code-intel.ts");
+  const opencodeCfg = path39.join(os18.homedir(), ".config", "opencode");
+  if (!fs39.existsSync(opencodeCfg)) {
+    return { result: "skipped", reason: "OpenCode not installed (~/.config/opencode not found)" };
+  }
+  if (fs39.existsSync(pluginFile)) {
+    return { result: "already-present" };
+  }
+  try {
+    fs39.mkdirSync(pluginDir, { recursive: true });
+    const tmp = `${pluginFile}.tmp.${Date.now()}`;
+    fs39.writeFileSync(tmp, OPENCODE_PLUGIN_CONTENT, "utf-8");
+    fs39.renameSync(tmp, pluginFile);
+    return { result: "installed" };
+  } catch (err) {
+    return { result: "skipped", reason: `Could not write plugin: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+var OPENCLAW_PLUGIN_CONTENT = `import { execSync } from "node:child_process";
+
+// code-intel OpenClaw plugin \u2014 rewrites symbol-discovery commands to semantic equivalents.
+// Requires: code-intel installed and in PATH.
+// To change rewrite rules, edit hook-rewriter.ts in the code-intel source.
+
+let codeIntelAvailable: boolean | null = null;
+
+function checkCodeIntel(): boolean {
+  if (codeIntelAvailable !== null) return codeIntelAvailable;
+  try {
+    execSync("which code-intel", { stdio: "ignore" });
+    codeIntelAvailable = true;
+  } catch {
+    codeIntelAvailable = false;
+  }
+  return codeIntelAvailable;
+}
+
+function tryRewrite(command: string): string | null {
+  try {
+    const result = execSync(\`code-intel rewrite \${JSON.stringify(command)}\`, {
+      encoding: "utf-8",
+      timeout: 2000,
+    }).trim();
+    return result && result !== command ? result : null;
+  } catch {
+    return null;
+  }
+}
+
+export default function register(api: any) {
+  const pluginConfig = api.config ?? {};
+  const enabled = pluginConfig.enabled !== false;
+  const verbose = pluginConfig.verbose === true;
+
+  if (!enabled) return;
+
+  if (!checkCodeIntel()) {
+    console.warn("[code-intel] code-intel binary not found in PATH \u2014 plugin disabled");
+    return;
+  }
+
+  api.on(
+    "before_tool_call",
+    (event: { toolName: string; params: Record<string, unknown> }) => {
+      if (event.toolName !== "exec") return;
+      const command = event.params?.command;
+      if (typeof command !== "string") return;
+      const rewritten = tryRewrite(command);
+      if (!rewritten) return;
+      if (verbose) console.log(\`[code-intel] \${command} -> \${rewritten}\`);
+      return { params: { ...event.params, command: rewritten } };
+    },
+    { priority: 10 }
+  );
+
+  if (verbose) console.log("[code-intel] OpenClaw plugin registered");
+}
+`;
+function installOpenClawPlugin() {
+  const openclawDir = path39.join(os18.homedir(), ".openclaw");
+  if (!fs39.existsSync(openclawDir)) {
+    return { result: "skipped", reason: "OpenClaw not installed (~/.openclaw directory not found)" };
+  }
+  const pluginDir = path39.join(openclawDir, "extensions", "code-intel");
+  const pluginFile = path39.join(pluginDir, "index.ts");
+  if (fs39.existsSync(pluginFile)) {
+    return { result: "already-present" };
+  }
+  try {
+    fs39.mkdirSync(pluginDir, { recursive: true });
+    const tmp = `${pluginFile}.tmp.${Date.now()}`;
+    fs39.writeFileSync(tmp, OPENCLAW_PLUGIN_CONTENT, "utf-8");
+    fs39.renameSync(tmp, pluginFile);
+    return { result: "installed" };
+  } catch (err) {
+    return { result: "skipped", reason: `Could not write plugin: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+var CODE_INTEL_RULES_CONTENT = `# Code Intelligence \u2014 Tool Policy
+
+## MANDATORY: Use code-intel before any code action
+
+**FORBIDDEN** (never use for symbol/code discovery): \`grep\`, \`rg\`, \`find\`, \`cat\`, \`sed\`, \`ls\`
+
+**REQUIRED workflow**:
+\`\`\`bash
+code-intel search "<concept>"    # replaces grep/rg/find
+code-intel inspect <symbol>      # replaces cat + manual reading
+code-intel impact <symbol>       # replaces manual caller tracing
+\`\`\`
+
+Rules:
+- NEVER open a file cold \u2014 always \`code-intel search\` first
+- NEVER use grep for symbols \u2014 use \`code-intel search\` instead
+- If impact shows \u2265 5 callers \u2192 warn user: HIGH blast radius
+`;
+function installRulesFile(filePath, agentName) {
+  try {
+    const dir = path39.dirname(filePath);
+    if (!fs39.existsSync(dir)) {
+      fs39.mkdirSync(dir, { recursive: true });
+    }
+    if (fs39.existsSync(filePath)) {
+      const existing = fs39.readFileSync(filePath, "utf-8");
+      if (existing.includes("code-intel search") || existing.includes("code-intel inspect")) {
+        return { result: "already-present" };
+      }
+      fs39.appendFileSync(filePath, "\n---\n\n" + CODE_INTEL_RULES_CONTENT);
+      return { result: "installed" };
+    }
+    fs39.writeFileSync(filePath, CODE_INTEL_RULES_CONTENT, "utf-8");
+    return { result: "installed" };
+  } catch (err) {
+    return { result: "skipped", reason: `Could not write ${agentName} rules: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+function cursorHookAlreadyPresent(root) {
+  const hooks = root?.hooks;
+  const preToolUse = hooks?.preToolUse;
+  if (!Array.isArray(preToolUse)) return false;
+  return preToolUse.some((entry) => {
+    const cmd = entry?.command;
+    return typeof cmd === "string" && (cmd.includes("code-intel-hook") || cmd.includes("code-intel hook"));
+  });
+}
+function installCursorHook() {
+  const cursorDir = path39.join(os18.homedir(), ".cursor");
+  const hooksPath = path39.join(cursorDir, "hooks.json");
+  let root = { version: 1 };
+  if (fs39.existsSync(hooksPath)) {
+    try {
+      const raw = fs39.readFileSync(hooksPath, "utf-8");
+      if (raw.trim()) root = JSON.parse(raw);
+    } catch (err) {
+      return { result: "skipped", reason: `Could not parse ~/.cursor/hooks.json: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  } else if (!fs39.existsSync(cursorDir)) {
+    return { result: "skipped", reason: "Cursor not installed (~/.cursor directory not found)" };
+  }
+  if (cursorHookAlreadyPresent(root)) return { result: "already-present" };
+  if (fs39.existsSync(hooksPath)) {
+    try {
+      fs39.copyFileSync(hooksPath, `${hooksPath}.bak`);
+    } catch {
+    }
+  }
+  const existingHooks = root.hooks ?? {};
+  const existingPreToolUse = Array.isArray(existingHooks.preToolUse) ? existingHooks.preToolUse : [];
+  const newEntry = { command: CODE_INTEL_CURSOR_HOOK_CMD, matcher: "Shell" };
+  const updated = { ...root, hooks: { ...existingHooks, preToolUse: [newEntry, ...existingPreToolUse] } };
+  try {
+    fs39.mkdirSync(cursorDir, { recursive: true });
+    const tmp = `${hooksPath}.tmp.${Date.now()}`;
+    fs39.writeFileSync(tmp, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+    fs39.renameSync(tmp, hooksPath);
+  } catch (err) {
+    return { result: "skipped", reason: `Could not write ~/.cursor/hooks.json: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  return { result: "installed" };
+}
+function geminiHookAlreadyPresent(root) {
+  const hooks = root?.hooks;
+  const beforeTool = hooks?.BeforeTool;
+  if (!Array.isArray(beforeTool)) return false;
+  return beforeTool.some((entry) => {
+    const entryHooks = entry?.hooks;
+    if (!Array.isArray(entryHooks)) return false;
+    return entryHooks.some((h) => {
+      const cmd = h?.command;
+      return typeof cmd === "string" && (cmd.includes("code-intel-hook") || cmd.includes("code-intel hook"));
+    });
+  });
+}
+function installGeminiHook() {
+  const geminiDir = path39.join(os18.homedir(), ".gemini");
+  const settingsPath = path39.join(geminiDir, "settings.json");
+  if (!fs39.existsSync(geminiDir)) {
+    return { result: "skipped", reason: "Gemini CLI not installed (~/.gemini directory not found)" };
+  }
+  let root = {};
+  if (fs39.existsSync(settingsPath)) {
+    try {
+      const raw = fs39.readFileSync(settingsPath, "utf-8");
+      if (raw.trim()) root = JSON.parse(raw);
+    } catch (err) {
+      return { result: "skipped", reason: `Could not parse ~/.gemini/settings.json: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+  if (geminiHookAlreadyPresent(root)) return { result: "already-present" };
+  if (fs39.existsSync(settingsPath)) {
+    try {
+      fs39.copyFileSync(settingsPath, `${settingsPath}.bak`);
+    } catch {
+    }
+  }
+  const existingHooks = root.hooks ?? {};
+  const existingBeforeTool = Array.isArray(existingHooks.BeforeTool) ? existingHooks.BeforeTool : [];
+  const newEntry = {
+    matcher: "run_shell_command",
+    hooks: [{ type: "command", command: CODE_INTEL_GEMINI_HOOK_CMD }]
+  };
+  const updated = { ...root, hooks: { ...existingHooks, BeforeTool: [newEntry, ...existingBeforeTool] } };
+  try {
+    const tmp = `${settingsPath}.tmp.${Date.now()}`;
+    fs39.writeFileSync(tmp, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+    fs39.renameSync(tmp, settingsPath);
+  } catch (err) {
+    return { result: "skipped", reason: `Could not write ~/.gemini/settings.json: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  return { result: "installed" };
+}
 program.command("setup").description("Configure MCP server for your editors (one-time setup)").option("--completion", "Auto-install shell completion for the detected shell").addHelpText("after", `
   Configure the code-intel MCP server for Claude Desktop, VS Code, or any
   editor that supports the Model Context Protocol.
@@ -16761,8 +17484,129 @@ program.command("setup").description("Configure MCP server for your editors (one
   console.log("  " + JSON.stringify({ servers: { "code-intel": { type: "stdio", command: "npx", args: ["code-intel", "mcp", "."] } } }, null, 2).split("\n").join("\n  "));
   console.log('\n  To verify in VS Code: open Command Palette \u2192 "MCP: List Servers" and confirm code-intel is Running.');
   console.log("\n  Next: run `code-intel analyze` inside your project to build the knowledge graph.\n");
+  const hookResult = installClaudeHook();
+  if (hookResult.result === "installed") {
+    const backupPath = path39.join(os18.homedir(), ".claude", "settings.json.bak");
+    console.log("\n  \u2705  Claude Code hook installed");
+    console.log("     grep/rg/cat on source files \u2192 code-intel search/inspect");
+    if (fs39.existsSync(backupPath)) {
+      console.log(`     Backup: ${backupPath}`);
+    }
+    console.log("\n  \u21BA  Restart Claude Code for the hook to take effect.");
+  } else if (hookResult.result === "already-present") {
+    console.log("\n  \u2705  Claude Code hook already installed");
+  } else {
+    logger_default.warn(`
+  \u26A0   Claude Code hook skipped: ${hookResult.reason}`);
+    console.log("\n  Add manually to ~/.claude/settings.json under hooks.PreToolUse[]:");
+    console.log("  (insert as the FIRST entry so it runs before any existing hooks)\n");
+    console.log("  " + JSON.stringify({
+      matcher: "Bash",
+      hooks: [{ type: "command", command: CODE_INTEL_HOOK_CMD }]
+    }, null, 2).split("\n").join("\n  "));
+  }
+  const cursorResult = installCursorHook();
+  if (cursorResult.result === "installed") {
+    console.log("\n  \u2705  Cursor hook installed");
+    console.log("     grep/rg/cat on source files \u2192 code-intel search/inspect");
+  } else if (cursorResult.result === "already-present") {
+    console.log("\n  \u2705  Cursor hook already installed");
+  } else {
+    console.log(`
+  \u2139   Cursor hook skipped: ${cursorResult.reason}`);
+  }
+  const geminiResult = installGeminiHook();
+  if (geminiResult.result === "installed") {
+    console.log("\n  \u2705  Gemini CLI hook installed");
+    console.log("     grep/rg/cat on source files \u2192 code-intel search/inspect");
+  } else if (geminiResult.result === "already-present") {
+    console.log("\n  \u2705  Gemini CLI hook already installed");
+  } else {
+    console.log(`
+  \u2139   Gemini CLI hook skipped: ${geminiResult.reason}`);
+  }
+  const copilotResult = installCopilotHook(process.cwd());
+  if (copilotResult.result === "installed") {
+    console.log("\n  \u2705  GitHub Copilot hook installed (.github/hooks/code-intel-rewrite.json)");
+    console.log("     grep/rg/cat on source files \u2192 code-intel search/inspect");
+  } else if (copilotResult.result === "already-present") {
+    console.log("\n  \u2705  GitHub Copilot hook already installed");
+  } else {
+    console.log(`
+  \u2139   GitHub Copilot hook skipped: ${copilotResult.reason}`);
+  }
+  const openCodeResult = installOpenCodePlugin();
+  if (openCodeResult.result === "installed") {
+    console.log("\n  \u2705  OpenCode plugin installed (~/.config/opencode/plugins/code-intel.ts)");
+    console.log("     grep/rg/cat on source files \u2192 code-intel search/inspect");
+  } else if (openCodeResult.result === "already-present") {
+    console.log("\n  \u2705  OpenCode plugin already installed");
+  } else {
+    console.log(`
+  \u2139   OpenCode plugin skipped: ${openCodeResult.reason}`);
+  }
+  const openClawResult = installOpenClawPlugin();
+  if (openClawResult.result === "installed") {
+    console.log("\n  \u2705  OpenClaw plugin installed (~/.openclaw/extensions/code-intel/)");
+    console.log("     grep/rg/cat on source files \u2192 code-intel search/inspect");
+  } else if (openClawResult.result === "already-present") {
+    console.log("\n  \u2705  OpenClaw plugin already installed");
+  } else {
+    console.log(`
+  \u2139   OpenClaw plugin skipped: ${openClawResult.reason}`);
+  }
+  console.log("\n  \u2500\u2500\u2500 Prompt-level agents (rules files) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  const cwd = process.cwd();
+  const clineResult = installRulesFile(path39.join(cwd, ".clinerules"), "Cline");
+  if (clineResult.result === "installed") {
+    console.log("  \u2705  Cline/Roo Code rules installed (.clinerules)");
+  } else if (clineResult.result === "already-present") {
+    console.log("  \u2705  Cline/Roo Code rules already present (.clinerules)");
+  } else {
+    console.log(`  \u2139   Cline/Roo Code rules skipped: ${clineResult.reason}`);
+  }
+  const windsurfResult = installRulesFile(path39.join(cwd, ".windsurfrules"), "Windsurf");
+  if (windsurfResult.result === "installed") {
+    console.log("  \u2705  Windsurf rules installed (.windsurfrules)");
+  } else if (windsurfResult.result === "already-present") {
+    console.log("  \u2705  Windsurf rules already present (.windsurfrules)");
+  } else {
+    console.log(`  \u2139   Windsurf rules skipped: ${windsurfResult.reason}`);
+  }
+  const kiloResult = installRulesFile(
+    path39.join(cwd, ".kilocode", "rules", "code-intel-rules.md"),
+    "Kilo Code"
+  );
+  if (kiloResult.result === "installed") {
+    console.log("  \u2705  Kilo Code rules installed (.kilocode/rules/code-intel-rules.md)");
+  } else if (kiloResult.result === "already-present") {
+    console.log("  \u2705  Kilo Code rules already present");
+  } else {
+    console.log(`  \u2139   Kilo Code rules skipped: ${kiloResult.reason}`);
+  }
+  const antigravityResult = installRulesFile(
+    path39.join(cwd, ".agents", "rules", "code-intel-rules.md"),
+    "Antigravity"
+  );
+  if (antigravityResult.result === "installed") {
+    console.log("  \u2705  Google Antigravity rules installed (.agents/rules/code-intel-rules.md)");
+  } else if (antigravityResult.result === "already-present") {
+    console.log("  \u2705  Google Antigravity rules already present");
+  } else {
+    console.log(`  \u2139   Google Antigravity rules skipped: ${antigravityResult.reason}`);
+  }
+  const codexResult = installRulesFile(path39.join(cwd, "AGENTS.md"), "Codex");
+  if (codexResult.result === "installed") {
+    console.log("  \u2705  Codex CLI rules appended (AGENTS.md)");
+  } else if (codexResult.result === "already-present") {
+    console.log("  \u2705  Codex CLI rules already present (AGENTS.md)");
+  } else {
+    console.log(`  \u2139   Codex CLI rules skipped: ${codexResult.reason}`);
+  }
+  console.log("\n  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("\n  \u25C8  Setup complete. Run `code-intel analyze` to build the knowledge graph.\n");
 });
-program.command("analyze").description("Index a repository and build the knowledge graph").argument("[path]", "Path to the repository (default: current directory)", ".").option("--force", "Force full re-index, ignoring cached data").option("--incremental", "Only re-parse files changed since last analysis (git diff or mtime)").option("--parallel", "Use worker threads for parse + resolve phases (faster on multi-core)").option("--skills", "Generate .claude/skills/ SKILL.md files from detected clusters").option("--embeddings", "Build vector embeddings for semantic search (slower, recommended)").option("--skip-embeddings", "Skip embedding generation (faster, text-search only)").option("--skip-agents-md", "Preserve any custom edits inside AGENTS.md / CLAUDE.md").option("--skip-git", "Allow indexing directories that are not Git repositories").option("--verbose", "Log every file skipped due to missing parser support").option("--summarize", "Generate AI summaries for function/class/method/interface nodes (opt-in)").option("--llm-provider <provider>", "LLM provider for --summarize: openai | anthropic | ollama (default: ollama)").option("--llm-model <model>", "LLM model name (e.g. gpt-4o-mini, claude-haiku-4-5, llama3)").option("--llm-batch-size <n>", "Concurrent LLM calls per batch (default: 20)", "20").option("--llm-max-nodes <n>", "Max nodes to summarize per run (cost guard)").option("--no-group-sync", "Skip automatic group sync after analysis").option("--dry-run", "Preview files that would be scanned + estimated time; no DB write").option("--max-memory <MB>", "Limit graph memory (MB); spill node content to free RAM when exceeded").option("--profile", "Write per-phase profiling data to .code-intel/profile.json").addHelpText("after", `
+program.command("analyze").description("Index a repository and build the knowledge graph").argument("[path]", "Path to the repository (default: current directory)", ".").option("--force", "Force full re-index, ignoring cached data").option("--incremental", "Only re-parse files changed since last analysis (git diff or mtime)").option("--parallel", "Use worker threads for parse + resolve phases (faster on multi-core)").option("--skills", "Generate .claude/skills/ SKILL.md files from detected clusters").option("--embeddings", "Build vector embeddings for semantic search (slower, recommended)").option("--skip-embeddings", "Skip embedding generation (faster, text-search only)").option("--skip-agents-md", "Preserve any custom edits inside AGENTS.md / CLAUDE.md").option("--skip-git", "Allow indexing directories that are not Git repositories").option("--verbose", "Log every file skipped due to missing parser support").option("--summarize", "Generate AI summaries for function/class/method/interface nodes (opt-in)").option("--llm-provider <provider>", "LLM provider for --summarize: openai | anthropic | ollama | custom (default: ollama)").option("--llm-model <model>", "LLM model name (e.g. gpt-4o-mini, claude-haiku-4-5, llama3, mistral)").option("--llm-base-url <url>", "Base URL for custom OpenAI-compatible API (e.g. http://localhost:1234/v1)").option("--llm-api-key <key>", "API key/token for the LLM provider (custom or override)").option("--llm-batch-size <n>", "Concurrent LLM calls per batch (default: 20)", "20").option("--llm-max-nodes <n>", "Max nodes to summarize per run (cost guard)").option("--no-group-sync", "Skip automatic group sync after analysis").option("--dry-run", "Preview files that would be scanned + estimated time; no DB write").option("--max-memory <MB>", "Limit graph memory (MB); spill node content to free RAM when exceeded").option("--profile", "Write per-phase profiling data to .code-intel/profile.json").addHelpText("after", `
   Parses your source code with tree-sitter, builds a Knowledge Graph of
   symbols and their relationships, persists it to .code-intel/graph.db,
   and auto-generates AGENTS.md + CLAUDE.md context blocks.
@@ -16782,6 +17626,7 @@ program.command("analyze").description("Index a repository and build the knowled
     $ code-intel analyze --summarize            Generate AI summaries (uses Ollama by default)
     $ code-intel analyze --summarize --llm-provider openai --llm-model gpt-4o-mini
     $ code-intel analyze --summarize --llm-provider anthropic --llm-max-nodes 500
+    $ code-intel analyze --summarize --llm-provider custom --llm-base-url http://localhost:1234/v1 --llm-model mistral --llm-api-key mytoken
     $ code-intel analyze --dry-run             Preview files that would be scanned
 `).action(async (targetPath, opts) => {
   if (opts.dryRun) {
@@ -16828,6 +17673,8 @@ program.command("analyze").description("Index a repository and build the knowled
       const v = parseInt(opts.llmMaxNodes ?? "", 10);
       return Number.isFinite(v) && v >= 1 ? v : void 0;
     })(),
+    llmBaseUrl: opts.llmBaseUrl,
+    llmApiKey: opts.llmApiKey,
     maxMemoryMB: (() => {
       const v = parseInt(opts.maxMemory ?? "", 10);
       return Number.isFinite(v) && v >= 1 ? v : void 0;
@@ -16867,11 +17714,18 @@ program.command("mcp").description("Start MCP server over stdio \u2014 exposes a
     await startMcpStdio(graph, name, root);
   }
 });
-program.command("serve").description("Start the local HTTP server + web UI for graph exploration").argument("[path]", "Path to analyze (default: current directory)", ".").option("-p, --port <port>", "Port to listen on", "4747").option("--force", "Force re-analysis even if an index already exists").addHelpText("after", `
+program.command("serve").description("Start the local HTTP server + web UI for graph exploration").argument("[path]", "Path to analyze (default: current directory)", ".").option("-p, --port <port>", "Port to listen on", "4747").option("--force", "Force re-analysis even if an index already exists").option("-d, --detach", "Run server in background (detached); PID written to .code-intel/serve.pid").addHelpText("after", `
   If a .code-intel/graph.db index already exists for the path, the server
   loads the persisted graph directly and starts immediately \u2014 no re-analysis.
   Use --force to discard the existing index and re-analyze from scratch.
 
+  Background mode:
+    $ code-intel serve --detach          # start in background
+    $ code-intel serve --detach --port 8080
+    $ code-intel stop                    # stop the background server
+
+  PID file: <path>/.code-intel/serve.pid
+
   The web UI offers:
     \xB7 Force-directed Knowledge Graph with color-coded node types
     \xB7 BM25 text search + optional semantic (vector) search
@@ -16884,6 +17738,7 @@ program.command("serve").description("Start the local HTTP server + web UI for g
     $ code-intel serve ./my-project
     $ code-intel serve --port 8080
     $ code-intel serve --force
+    $ code-intel serve --detach
 `).action(async (targetPath, options) => {
   const workspaceRoot = path39.resolve(targetPath);
   const repoName = path39.basename(workspaceRoot);
@@ -16892,6 +17747,44 @@ program.command("serve").description("Start the local HTTP server + web UI for g
     console.error(`  \u2717  Path does not exist: ${workspaceRoot}`);
     process.exit(1);
   }
+  if (options.detach) {
+    const { spawn } = await import('child_process');
+    const pidDir = path39.join(workspaceRoot, ".code-intel");
+    const pidFile = path39.join(pidDir, "serve.pid");
+    if (fs39.existsSync(pidFile)) {
+      const existingPid = parseInt(fs39.readFileSync(pidFile, "utf-8").trim(), 10);
+      try {
+        process.kill(existingPid, 0);
+        console.log(`  \u26A0  Server already running (PID ${existingPid}). Stop it first with: code-intel stop`);
+        process.exit(0);
+      } catch {
+        fs39.unlinkSync(pidFile);
+      }
+    }
+    const selfArgs = ["serve", targetPath, "--port", options.port];
+    if (options.force) selfArgs.push("--force");
+    const logDir = path39.join(os18.homedir(), ".code-intel", "logs");
+    fs39.mkdirSync(logDir, { recursive: true });
+    const logFile = path39.join(logDir, `serve-${Date.now()}.log`);
+    const logFd = fs39.openSync(logFile, "a");
+    const child = spawn(process.execPath, [process.argv[1], ...selfArgs], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: process.env
+    });
+    child.unref();
+    fs39.mkdirSync(pidDir, { recursive: true });
+    fs39.writeFileSync(pidFile, String(child.pid), "utf-8");
+    console.log(`  \u2705  Server started in background`);
+    console.log(`      PID      : ${child.pid}`);
+    console.log(`      Port     : ${options.port}`);
+    console.log(`      URL      : http://localhost:${options.port}`);
+    console.log(`      Log      : ${logFile}`);
+    console.log(`      PID file : ${pidFile}`);
+    console.log(`
+  Stop with: code-intel stop`);
+    process.exit(0);
+  }
   const existingIndex = !options.force && fs39.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const meta = loadMetadata(workspaceRoot);
@@ -16911,10 +17804,81 @@ program.command("serve").description("Start the local HTTP server + web UI for g
       await startHttpServer(lazyGraph, repoName, parseInt(options.port, 10), workspaceRoot);
     }
   } else {
-    logger_default.warn(`  [serve] No index found for: ${workspaceRoot}`);
-    logger_default.warn(`  [serve] Run \`code-intel analyze\` first, then re-run \`code-intel serve\`.`);
+    console.log(`  \u2139  No index found for: ${workspaceRoot}`);
+    const registry = loadRegistry();
+    const available = registry.filter((r) => fs39.existsSync(getDbPath(r.path)) && loadMetadata(r.path) !== null).sort((a, b) => new Date(b.indexedAt).getTime() - new Date(a.indexedAt).getTime());
+    if (available.length > 0) {
+      const fallback = available[0];
+      console.log(`  \u25C8  Falling back to most recently indexed repo: ${fallback.path}`);
+      console.log(`     (${fallback.stats.nodes} nodes \xB7 ${fallback.stats.edges} edges \xB7 indexed ${fallback.indexedAt})`);
+      console.log(`  \u2139  To index this folder run: code-intel analyze
+`);
+      const fallbackMeta = loadMetadata(fallback.path);
+      const fallbackDbPath = getDbPath(fallback.path);
+      if (fallbackMeta.parser === "regex" || fallbackMeta.parser === void 0) {
+        console.log(`  \u26A0  Fallback index was built with regex parser. Starting with empty graph.`);
+        const emptyGraph = createKnowledgeGraph();
+        await startHttpServer(emptyGraph, fallback.name, parseInt(options.port, 10), fallback.path);
+      } else {
+        const lazyGraph = new LazyKnowledgeGraph();
+        const db = new DbManager(fallbackDbPath, true);
+        await db.init();
+        await lazyGraph.init(db, fallbackMeta.stats.nodes, fallbackMeta.stats.edges);
+        setImmediate(() => lazyGraph.warmTopNodes(500).catch(() => {
+        }));
+        await startHttpServer(lazyGraph, fallback.name, parseInt(options.port, 10), fallback.path);
+      }
+      if (available.length > 1) {
+        console.log(`
+  Other indexed repos available (switch via web UI or re-run serve with path):`);
+        for (const r of available.slice(1)) {
+          console.log(`    code-intel serve ${r.path}`);
+        }
+      }
+    } else {
+      console.log(`  \u2139  No indexed repositories found. Starting server with empty graph.`);
+      console.log(`     Run \`code-intel analyze\` to index a repository, then reload the UI.
+`);
+      const emptyGraph = createKnowledgeGraph();
+      await startHttpServer(emptyGraph, repoName, parseInt(options.port, 10), workspaceRoot);
+    }
+  }
+});
+program.command("stop").description("Stop a background server started with `code-intel serve --detach`").argument("[path]", "Project path whose server to stop (default: current directory)", ".").addHelpText("after", `
+  Reads the PID from <path>/.code-intel/serve.pid and sends SIGTERM.
+  The PID file is removed automatically after a successful stop.
+
+  Examples:
+    $ code-intel stop
+    $ code-intel stop ./my-project
+`).action((targetPath) => {
+  const workspaceRoot = path39.resolve(targetPath);
+  const pidFile = path39.join(workspaceRoot, ".code-intel", "serve.pid");
+  if (!fs39.existsSync(pidFile)) {
+    console.log(`  \u2139  No background server found for: ${workspaceRoot}`);
+    console.log(`     (PID file not present: ${pidFile})`);
+    process.exit(0);
+  }
+  const pid = parseInt(fs39.readFileSync(pidFile, "utf-8").trim(), 10);
+  if (isNaN(pid)) {
+    console.error(`  \u2717  Invalid PID file: ${pidFile}`);
+    fs39.unlinkSync(pidFile);
     process.exit(1);
   }
+  try {
+    process.kill(pid, "SIGTERM");
+    fs39.unlinkSync(pidFile);
+    console.log(`  \u2705  Stopped server (PID ${pid})`);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH") {
+      fs39.unlinkSync(pidFile);
+      console.log(`  \u2139  Server (PID ${pid}) was not running. Stale PID file removed.`);
+    } else {
+      console.error(`  \u2717  Failed to stop server (PID ${pid}): ${err.message}`);
+      process.exit(1);
+    }
+  }
 });
 program.command("watch").description("Start HTTP server + file watcher (auto-reindex on file changes)").argument("[path]", "Path to watch (default: current directory)", ".").option("-p, --port <port>", "Port to listen on", "4747").option("--force", "Force re-analysis even if an index already exists").addHelpText("after", `
   Starts the HTTP server and automatically re-indexes changed files.
@@ -18079,7 +19043,7 @@ program.command("migrate").description("Manage database schema migrations").opti
     $ code-intel migrate
     $ code-intel migrate --rollback
 `).action((opts) => {
-  const dbPath = opts.db ?? path39.join(os13.homedir(), ".code-intel", "users.db");
+  const dbPath = opts.db ?? path39.join(os18.homedir(), ".code-intel", "users.db");
   if (!fs39.existsSync(dbPath)) {
     console.error(`
   \u2717  Database not found: ${dbPath}
@@ -18195,7 +19159,7 @@ authCmd.command("login").description("Authenticate via OIDC device flow \u2014 o
   }
   try {
     const tokens = await pollDeviceFlow3(config, deviceResponse);
-    const tokenPath = path39.join(os13.homedir(), ".code-intel", "oidc-token.json");
+    const tokenPath = path39.join(os18.homedir(), ".code-intel", "oidc-token.json");
     const tokenData = {
       accessToken: tokens.accessToken,
       refreshToken: tokens.refreshToken,
@@ -18216,7 +19180,7 @@ authCmd.command("login").description("Authenticate via OIDC device flow \u2014 o
   }
 });
 authCmd.command("status").description("Show the current OIDC authentication status").action(() => {
-  const tokenPath = path39.join(os13.homedir(), ".code-intel", "oidc-token.json");
+  const tokenPath = path39.join(os18.homedir(), ".code-intel", "oidc-token.json");
   if (!fs39.existsSync(tokenPath)) {
     console.log("\n  Not authenticated via OIDC. Run: code-intel auth login\n");
     return;
@@ -18234,7 +19198,7 @@ authCmd.command("status").description("Show the current OIDC authentication stat
   }
 });
 authCmd.command("logout").description("Remove locally stored OIDC token").action(() => {
-  const tokenPath = path39.join(os13.homedir(), ".code-intel", "oidc-token.json");
+  const tokenPath = path39.join(os18.homedir(), ".code-intel", "oidc-token.json");
   if (fs39.existsSync(tokenPath)) {
     fs39.unlinkSync(tokenPath);
     console.log("\n  \u2705  OIDC token removed. You are now logged out.\n");
@@ -18390,7 +19354,7 @@ ${err instanceof Error ? err.message : err}
 });
 (function ensurePermissions() {
   try {
-    const dir = path39.join(os13.homedir(), ".code-intel");
+    const dir = path39.join(os18.homedir(), ".code-intel");
     secureMkdir(dir);
     tightenDbFiles(dir);
   } catch {
@@ -19195,6 +20159,35 @@ program.command("context").description("Build a token-efficient context document
     console.log("");
   }
 });
+{
+  const rewriteCmd = new Command("rewrite").description("Rewrite a shell command to its code-intel equivalent (used by hooks)").argument("<cmd>", "Raw shell command to check").addHelpText("after", `
+  Exit codes:
+    0  Rewrite found \u2014 rewritten command printed to stdout
+    1  No code-intel equivalent \u2014 pass through unchanged
+
+  Examples:
+    $ code-intel rewrite 'grep "AuthService" src/'
+    code-intel search "AuthService"
+
+    $ code-intel rewrite 'git status'
+    (no output, exit 1)
+`).action((cmd) => {
+    runRewrite(cmd);
+  });
+  program.addCommand(rewriteCmd, { hidden: true });
+}
+{
+  const hookCmd = new Command("hook").description("Run as a PreToolUse hook for an AI agent (reads/writes JSON on stdin/stdout)").argument("<agent>", "Agent type: claude").action((agent) => {
+    if (agent === "claude") {
+      runClaudeHook();
+    } else {
+      process.stderr.write(`[code-intel] Unknown hook agent: ${agent}
+`);
+      process.exit(0);
+    }
+  });
+  program.addCommand(hookCmd, { hidden: true });
+}
 program.parse();
 //# sourceMappingURL=main.js.map
 //# sourceMappingURL=main.js.map