codecortex-ai 0.3.2 → 0.4.0

package/dist/cli/index.js

@@ -24,7 +24,7 @@ import {
   writeManifest,
   writeModuleDoc,
   writeSession
-} from "../chunk-HGPK53UQ.js";
+} from "../chunk-OJAMBNHJ.js";
 
 // src/cli/index.ts
 import { createRequire as createRequire2 } from "module";
@@ -2317,9 +2317,324 @@ function pad3(str, len) {
   return str.length >= len ? str : str + " ".repeat(len - str.length);
 }
 
+// src/cli/commands/hook.ts
+import { resolve as resolve9, join as join3 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { readFile as readFile4, writeFile as writeFile2, chmod, unlink } from "fs/promises";
+import simpleGit3 from "simple-git";
+var HOOK_START = "# --- codecortex-hook-start ---";
+var HOOK_END = "# --- codecortex-hook-end ---";
+var HOOK_TYPES = ["post-commit", "post-merge"];
+var HOOK_SCRIPT = `
+${HOOK_START}
+# Auto-update CodeCortex knowledge after git operations
+# Installed by: codecortex hook install
+(
+  if command -v codecortex >/dev/null 2>&1; then
+    codecortex update >/dev/null 2>&1
+  elif command -v npx >/dev/null 2>&1; then
+    npx codecortex-ai update >/dev/null 2>&1
+  fi
+) &
+${HOOK_END}
+`.trimStart();
+function hasCodeCortexHook(content) {
+  return content.includes(HOOK_START);
+}
+function removeCodeCortexHook(content) {
+  const startIdx = content.indexOf(HOOK_START);
+  if (startIdx === -1) return content;
+  const endIdx = content.indexOf(HOOK_END);
+  if (endIdx === -1) return content;
+  const before = content.slice(0, startIdx);
+  const after = content.slice(endIdx + HOOK_END.length);
+  return before + after.replace(/^\n/, "");
+}
+function isEmptyHook(content) {
+  const stripped = content.split("\n").filter((line) => {
+    const trimmed = line.trim();
+    return trimmed !== "" && !trimmed.startsWith("#!") && !trimmed.startsWith("#");
+  }).join("");
+  return stripped.length === 0;
+}
+async function getGitHooksDir(root) {
+  const git = simpleGit3(root);
+  const gitDir = (await git.revparse(["--git-dir"])).trim();
+  const resolved = resolve9(root, gitDir);
+  return join3(resolved, "hooks");
+}
+async function isCodeCortexIgnored(root) {
+  const gitignorePath = join3(root, ".gitignore");
+  if (!existsSync11(gitignorePath)) return false;
+  try {
+    const content = await readFile4(gitignorePath, "utf-8");
+    return content.split("\n").some((line) => {
+      const trimmed = line.trim();
+      return trimmed === ".codecortex" || trimmed === ".codecortex/" || trimmed === ".codecortex/**";
+    });
+  } catch {
+    return false;
+  }
+}
+async function hookInstallCommand(opts) {
+  const root = resolve9(opts.root);
+  if (!await isGitRepo(root)) {
+    console.error("Error: not a git repository.");
+    process.exitCode = 1;
+    return;
+  }
+  if (process.platform === "win32") {
+    console.warn("Warning: shell-based git hooks may not work natively on Windows.");
+    console.warn("Consider using WSL or Git Bash.");
+  }
+  const hooksDir = await getGitHooksDir(root);
+  if (await isCodeCortexIgnored(root)) {
+    console.warn("Warning: .codecortex is in .gitignore \u2014 knowledge won't be shared.");
+    console.warn("Remove .codecortex from .gitignore to commit it alongside code.");
+    console.log("");
+  }
+  for (const hookType of HOOK_TYPES) {
+    const hookPath = join3(hooksDir, hookType);
+    let status;
+    if (existsSync11(hookPath)) {
+      const content = await readFile4(hookPath, "utf-8");
+      if (hasCodeCortexHook(content)) {
+        status = "already installed";
+      } else {
+        const newContent = content.trimEnd() + "\n\n" + HOOK_SCRIPT;
+        await writeFile2(hookPath, newContent, "utf-8");
+        await chmod(hookPath, 493);
+        status = "installed";
+      }
+    } else {
+      const content = "#!/bin/sh\n\n" + HOOK_SCRIPT;
+      await writeFile2(hookPath, content, "utf-8");
+      await chmod(hookPath, 493);
+      status = "installed";
+    }
+    console.log(`  ${hookType}: ${status}`);
+  }
+  const allNew = true;
+  console.log("");
+  console.log("Knowledge will auto-update after every commit and merge.");
+}
+async function hookUninstallCommand(opts) {
+  const root = resolve9(opts.root);
+  if (!await isGitRepo(root)) {
+    console.error("Error: not a git repository.");
+    process.exitCode = 1;
+    return;
+  }
+  const hooksDir = await getGitHooksDir(root);
+  for (const hookType of HOOK_TYPES) {
+    const hookPath = join3(hooksDir, hookType);
+    let status;
+    if (!existsSync11(hookPath)) {
+      status = "not installed";
+    } else {
+      const content = await readFile4(hookPath, "utf-8");
+      if (!hasCodeCortexHook(content)) {
+        status = "not installed";
+      } else {
+        const cleaned = removeCodeCortexHook(content);
+        if (isEmptyHook(cleaned)) {
+          await unlink(hookPath);
+        } else {
+          await writeFile2(hookPath, cleaned, "utf-8");
+        }
+        status = "removed";
+      }
+    }
+    console.log(`  ${hookType}: ${status}`);
+  }
+}
+async function hookStatusCommand(opts) {
+  const root = resolve9(opts.root);
+  if (!await isGitRepo(root)) {
+    console.error("Error: not a git repository.");
+    process.exitCode = 1;
+    return;
+  }
+  const hooksDir = await getGitHooksDir(root);
+  for (const hookType of HOOK_TYPES) {
+    const hookPath = join3(hooksDir, hookType);
+    let installed = false;
+    if (existsSync11(hookPath)) {
+      const content = await readFile4(hookPath, "utf-8");
+      installed = hasCodeCortexHook(content);
+    }
+    console.log(`  ${hookType}: ${installed ? "installed" : "not installed"}`);
+  }
+  const manifest = await readManifest(root);
+  if (manifest) {
+    const lastUpdated = new Date(manifest.lastUpdated);
+    const ageHours = Math.floor((Date.now() - lastUpdated.getTime()) / (1e3 * 60 * 60));
+    const ageLabel = ageHours < 1 ? "just now" : ageHours < 24 ? `${ageHours} hour${ageHours === 1 ? "" : "s"} ago` : `${Math.floor(ageHours / 24)} day${Math.floor(ageHours / 24) === 1 ? "" : "s"} ago`;
+    console.log(`  Knowledge: last updated ${ageLabel}`);
+  } else {
+    console.log("  Knowledge: not initialized (run codecortex init)");
+  }
+}
+
+// src/cli/commands/upgrade.ts
+import { execSync as execSync2 } from "child_process";
+
+// src/cli/utils/version-check.ts
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+import { readFileSync, writeFileSync } from "fs";
+var CACHE_FILE = join4(tmpdir(), "codecortex-update-check.json");
+var CACHE_TTL = 24 * 60 * 60 * 1e3;
+var REGISTRY_URL = "https://registry.npmjs.org/codecortex-ai/latest";
+var FETCH_TIMEOUT = 3e3;
+function readCache() {
+  try {
+    const raw = readFileSync(CACHE_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data === "object" && data !== null && "latest" in data && typeof data.latest === "string" && "lastCheck" in data && typeof data.lastCheck === "number") {
+      return data;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeCache(latest) {
+  try {
+    writeFileSync(CACHE_FILE, JSON.stringify({ latest, lastCheck: Date.now() }));
+  } catch {
+  }
+}
+function compareVersions(current, latest) {
+  const parse = (v) => v.replace(/^v/, "").split(".").map(Number);
+  const c = parse(current);
+  const l = parse(latest);
+  const cMaj = c[0] ?? 0, cMin = c[1] ?? 0, cPatch = c[2] ?? 0;
+  const lMaj = l[0] ?? 0, lMin = l[1] ?? 0, lPatch = l[2] ?? 0;
+  if (lMaj !== cMaj) return lMaj > cMaj;
+  if (lMin !== cMin) return lMin > cMin;
+  return lPatch > cPatch;
+}
+async function fetchLatestVersion() {
+  try {
+    const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(FETCH_TIMEOUT) });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdate(currentVersion) {
+  const cached = readCache();
+  if (cached && Date.now() - cached.lastCheck < CACHE_TTL) {
+    return {
+      current: currentVersion,
+      latest: cached.latest,
+      isOutdated: compareVersions(currentVersion, cached.latest)
+    };
+  }
+  const latest = await fetchLatestVersion();
+  if (!latest) return null;
+  writeCache(latest);
+  return {
+    current: currentVersion,
+    latest,
+    isOutdated: compareVersions(currentVersion, latest)
+  };
+}
+function detectPackageManager() {
+  const ua = process.env.npm_config_user_agent ?? "";
+  if (ua.startsWith("yarn")) return "yarn";
+  if (ua.startsWith("pnpm")) return "pnpm";
+  if (ua.startsWith("bun")) return "bun";
+  const bin = process.argv[1] ?? "";
+  if (bin.includes("yarn")) return "yarn";
+  if (bin.includes("pnpm")) return "pnpm";
+  if (bin.includes("bun")) return "bun";
+  return "npm";
+}
+function getUpgradeCommand() {
+  const pm = detectPackageManager();
+  switch (pm) {
+    case "yarn":
+      return "yarn global add codecortex-ai@latest";
+    case "pnpm":
+      return "pnpm add -g codecortex-ai@latest";
+    case "bun":
+      return "bun add -g codecortex-ai@latest";
+    default:
+      return "npm install -g codecortex-ai@latest";
+  }
+}
+function shouldNotify() {
+  if (process.env.CI || process.env.BUILD_NUMBER || process.env.RUN_ID) return false;
+  if (process.env.NO_UPDATE_NOTIFIER) return false;
+  if (process.env.NODE_ENV === "test") return false;
+  if (!process.stderr.isTTY) return false;
+  return true;
+}
+function renderUpdateNotification(current, latest) {
+  const cmd = getUpgradeCommand();
+  const yellow = "\x1B[33m";
+  const cyan = "\x1B[36m";
+  const dim = "\x1B[2m";
+  const reset = "\x1B[0m";
+  const bold = "\x1B[1m";
+  const line1Text = `Update available: ${current} \u2192 ${latest}`;
+  const line2Text = `Run ${cmd}`;
+  const contentWidth = Math.max(line1Text.length, line2Text.length);
+  const innerWidth = contentWidth + 6;
+  const rpad = (text) => " ".repeat(Math.max(0, contentWidth - text.length + 3));
+  const msg = [
+    "",
+    `${dim}\u256D${"\u2500".repeat(innerWidth)}\u256E${reset}`,
+    `${dim}\u2502${reset}${" ".repeat(innerWidth)}${dim}\u2502${reset}`,
+    `${dim}\u2502${reset}   ${yellow}Update available:${reset} ${dim}${current}${reset} \u2192 ${cyan}${bold}${latest}${reset}${rpad(line1Text)}${dim}\u2502${reset}`,
+    `${dim}\u2502${reset}   Run ${cyan}${cmd}${reset}${rpad(line2Text)}${dim}\u2502${reset}`,
+    `${dim}\u2502${reset}${" ".repeat(innerWidth)}${dim}\u2502${reset}`,
+    `${dim}\u2570${"\u2500".repeat(innerWidth)}\u256F${reset}`,
+    ""
+  ].join("\n");
+  process.stderr.write(msg);
+}
+
+// src/cli/commands/upgrade.ts
+async function upgradeCommand(currentVersion) {
+  console.log("Checking for updates...");
+  console.log("");
+  const result = await checkForUpdate(currentVersion);
+  if (!result) {
+    console.log("Could not reach the npm registry. Check your internet connection.");
+    return;
+  }
+  if (!result.isOutdated) {
+    console.log(`Already on the latest version (${result.current}).`);
+    return;
+  }
+  const cmd = getUpgradeCommand();
+  console.log(`Update available: ${result.current} \u2192 ${result.latest}`);
+  console.log("");
+  console.log(`Running: ${cmd}`);
+  console.log("");
+  try {
+    execSync2(cmd, { stdio: "inherit" });
+    console.log("");
+    console.log(`Successfully upgraded to ${result.latest}!`);
+  } catch {
+    console.error("");
+    console.error("Upgrade failed. Try running manually:");
+    console.error(`  ${cmd}`);
+    console.error("");
+    console.error("If you get a permission error, try:");
+    console.error(`  sudo ${cmd}`);
+  }
+}
+
 // src/cli/index.ts
 var require3 = createRequire2(import.meta.url);
 var { version } = require3("../../package.json");
+var updateCheckPromise = shouldNotify() ? checkForUpdate(version).catch(() => null) : Promise.resolve(null);
 var program = new Command();
 program.name("codecortex").description("Persistent, AI-powered codebase knowledge layer").version(version);
 program.command("init").description("Initialize codebase knowledge: discover files, extract symbols, analyze git history").option("-r, --root <path>", "Project root directory", process.cwd()).option("-d, --days <number>", "Days of git history to analyze", "90").action(initCommand);
@@ -2330,5 +2645,21 @@ program.command("symbols [query]").description("Browse and filter the symbol ind
 program.command("search <query>").description("Search across all CodeCortex knowledge files").option("-r, --root <path>", "Project root directory", process.cwd()).option("-l, --limit <number>", "Max results", "20").action((query, opts) => searchCommand(query, opts));
 program.command("modules [name]").description("List modules or deep-dive into a specific module").option("-r, --root <path>", "Project root directory", process.cwd()).action((name, opts) => modulesCommand(name, opts));
 program.command("hotspots").description("Show files ranked by risk: churn + coupling + bug history").option("-r, --root <path>", "Project root directory", process.cwd()).option("-l, --limit <number>", "Number of files to show", "15").action(hotspotsCommand);
-program.parse();
+var hook = program.command("hook").description("Manage git hooks for auto-updating knowledge");
+hook.command("install").description("Install post-commit and post-merge hooks").option("-r, --root <path>", "Project root directory", process.cwd()).action(hookInstallCommand);
+hook.command("uninstall").description("Remove CodeCortex hooks (preserves other hooks)").option("-r, --root <path>", "Project root directory", process.cwd()).action(hookUninstallCommand);
+hook.command("status").description("Show hook installation state and knowledge freshness").option("-r, --root <path>", "Project root directory", process.cwd()).action(hookStatusCommand);
+program.command("upgrade").description("Check for and install the latest version of CodeCortex").action(() => upgradeCommand(version));
+async function main() {
+  await program.parseAsync();
+  const commandName = program.args[0];
+  if (commandName !== "serve" && commandName !== "upgrade") {
+    const result = await updateCheckPromise;
+    if (result?.isOutdated) {
+      renderUpdateNotification(result.current, result.latest);
+    }
+  }
+}
+main().catch(() => {
+});
 //# sourceMappingURL=index.js.map