@mycontxt/cli 0.1.0

package/dist/contxt.js

@@ -0,0 +1,3068 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/bin/contxt.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { mkdirSync } from "fs";
+import { basename } from "path";
+import { SQLiteDatabase as SQLiteDatabase2 } from "@mycontxt/adapters/sqlite";
+
+// src/utils/project.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { SQLiteDatabase } from "@mycontxt/adapters/sqlite";
+import { MemoryEngine } from "@mycontxt/core";
+function getContxtDir(cwd = process.cwd()) {
+  return join(cwd, ".contxt");
+}
+function getDbPath(cwd = process.cwd()) {
+  return join(getContxtDir(cwd), "local.db");
+}
+function isContxtProject(cwd = process.cwd()) {
+  const dbPath = getDbPath(cwd);
+  return existsSync(dbPath);
+}
+async function loadProject(cwd = process.cwd()) {
+  if (!isContxtProject(cwd)) {
+    throw new Error(
+      'Not a Contxt project. Run "contxt init" to initialize.'
+    );
+  }
+  const dbPath = getDbPath(cwd);
+  const db = new SQLiteDatabase(dbPath);
+  await db.initialize();
+  const project = await db.getProjectByPath(cwd);
+  if (!project) {
+    throw new Error("Project not found in database");
+  }
+  const engine = new MemoryEngine(db);
+  return {
+    db,
+    engine,
+    projectId: project.id,
+    projectPath: cwd
+  };
+}
+async function getProjectDb(cwd = process.cwd()) {
+  if (!isContxtProject(cwd)) {
+    throw new Error(
+      'Not a Contxt project. Run "contxt init" to initialize.'
+    );
+  }
+  const dbPath = getDbPath(cwd);
+  const db = new SQLiteDatabase(dbPath);
+  await db.initialize();
+  return db;
+}
+function formatDate(date) {
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - date.getTime();
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  return "just now";
+}
+
+// src/utils/output.ts
+import chalk from "chalk";
+function success(message) {
+  console.log(chalk.green("\u2713"), message);
+}
+function error(message) {
+  console.error(chalk.red("\u2717"), message);
+}
+function info(message) {
+  console.log(chalk.blue("\u2139"), message);
+}
+function formatEntry(entry) {
+  const lines = [];
+  lines.push(chalk.bold(entry.title));
+  lines.push(
+    chalk.dim(
+      `${entry.type} \u2022 ${entry.id.substring(0, 8)} \u2022 ${formatDate(entry.updatedAt)}`
+    )
+  );
+  lines.push("");
+  lines.push(entry.content);
+  if (Object.keys(entry.metadata).length > 0) {
+    lines.push("");
+    lines.push(chalk.dim("Metadata:"));
+    for (const [key, value] of Object.entries(entry.metadata)) {
+      if (Array.isArray(value) && value.length > 0) {
+        lines.push(chalk.dim(`  ${key}: ${value.join(", ")}`));
+      } else if (value) {
+        lines.push(chalk.dim(`  ${key}: ${value}`));
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function formatEntryList(entries) {
+  if (entries.length === 0) {
+    return chalk.dim("No entries found");
+  }
+  return entries.map((entry) => {
+    const id = chalk.dim(entry.id.substring(0, 8));
+    const time = chalk.dim(formatDate(entry.updatedAt));
+    const title = entry.title;
+    return `  ${id}  ${title} ${time}`;
+  }).join("\n");
+}
+function section(title) {
+  return chalk.bold.underline(title);
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  try {
+    const cwd = process.cwd();
+    if (isContxtProject(cwd)) {
+      error("This directory is already a Contxt project");
+      process.exit(1);
+    }
+    const contxtDir = getContxtDir(cwd);
+    mkdirSync(contxtDir, { recursive: true });
+    const dbPath = getDbPath(cwd);
+    const db = new SQLiteDatabase2(dbPath);
+    await db.initialize();
+    const projectName = options.name || basename(cwd);
+    const project = await db.initProject({
+      name: projectName,
+      path: cwd,
+      stack: []
+      // TODO: Auto-detect stack
+    });
+    success(`Initialized Contxt project: ${project.name}`);
+    info(`Project ID: ${project.id}`);
+    info(`Database: ${dbPath}`);
+    console.log();
+    console.log("Get started:");
+    console.log('  contxt decision add -t "..." -r "..."');
+    console.log('  contxt pattern add -t "..." -c "..."');
+    console.log("  contxt status");
+    await db.close();
+  } catch (err) {
+    error(`Failed to initialize project: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/decision.ts
+async function add(options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const input = {
+      title: options.title,
+      rationale: options.rationale,
+      alternatives: options.alternatives,
+      consequences: options.consequences,
+      tags: options.tags
+    };
+    const entry = await engine.addDecision(projectId, input);
+    success(`Added decision: ${entry.title}`);
+    console.log(`ID: ${entry.id}`);
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function list(options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const decisions = await engine.listDecisions(projectId, options.branch);
+    console.log(section("Decisions"));
+    console.log();
+    console.log(formatEntryList(decisions));
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function show(id) {
+  try {
+    const { engine, db } = await loadProject();
+    const decision2 = await engine.getDecision(id);
+    console.log(formatEntry(decision2));
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+var decisionCommand = {
+  add,
+  list,
+  show
+};
+
+// src/commands/pattern.ts
+async function add2(options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const input = {
+      title: options.title,
+      content: options.content,
+      category: options.category,
+      tags: options.tags
+    };
+    const entry = await engine.addPattern(projectId, input);
+    success(`Added pattern: ${entry.title}`);
+    console.log(`ID: ${entry.id}`);
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function list2(options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const patterns = await engine.listPatterns(projectId, options.branch);
+    console.log(section("Patterns"));
+    console.log();
+    console.log(formatEntryList(patterns));
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function show2(id) {
+  try {
+    const { engine, db } = await loadProject();
+    const pattern2 = await engine.getPattern(id);
+    console.log(formatEntry(pattern2));
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+var patternCommand = {
+  add: add2,
+  list: list2,
+  show: show2
+};
+
+// src/commands/context.ts
+async function set(options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const input = {
+      feature: options.feature,
+      blockers: options.blockers,
+      nextSteps: options.next,
+      activeFiles: options.files
+    };
+    const entry = await engine.setContext(projectId, input);
+    success("Updated project context");
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function show3() {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const context2 = await engine.getContext(projectId);
+    if (!context2) {
+      info('No context set. Use "contxt context set" to set context.');
+      await db.close();
+      return;
+    }
+    console.log(formatEntry(context2));
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function clear() {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const context2 = await engine.getContext(projectId);
+    if (context2) {
+      await engine.deleteEntry(context2.id);
+      success("Cleared project context");
+    } else {
+      info("No context to clear");
+    }
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+var contextCommand = {
+  set,
+  show: show3,
+  clear
+};
+
+// src/commands/status.ts
+import chalk2 from "chalk";
+async function statusCommand() {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const project = await db.getProject(projectId);
+    if (!project) {
+      throw new Error("Project not found");
+    }
+    const activeBranch = await db.getActiveBranch(projectId);
+    const branches = await db.listBranches(projectId);
+    const decisions = await engine.listDecisions(projectId);
+    const patterns = await engine.listPatterns(projectId);
+    const documents = await engine.listDocuments(projectId);
+    const sessions = await engine.listSessions(projectId);
+    const context2 = await engine.getContext(projectId);
+    const unsynced = await db.getUnsyncedEntries(projectId);
+    console.log();
+    console.log(section("Project Status"));
+    console.log();
+    console.log(chalk2.bold("Name:"), project.name);
+    console.log(chalk2.bold("Path:"), project.path);
+    console.log(chalk2.bold("ID:"), project.id);
+    console.log();
+    console.log(section("Branches"));
+    console.log();
+    for (const branch2 of branches) {
+      const marker = branch2.name === activeBranch ? chalk2.green("\u25CF") : " ";
+      console.log(`  ${marker} ${branch2.name}`);
+    }
+    console.log();
+    console.log(section("Memory Entries"));
+    console.log();
+    console.log(`  Decisions:  ${decisions.length}`);
+    console.log(`  Patterns:   ${patterns.length}`);
+    console.log(`  Documents:  ${documents.length}`);
+    console.log(`  Sessions:   ${sessions.length}`);
+    console.log(`  Total:      ${decisions.length + patterns.length + documents.length + sessions.length}`);
+    console.log();
+    if (context2) {
+      console.log(section("Current Context"));
+      console.log();
+      if (context2.metadata.feature) {
+        console.log(chalk2.bold("Feature:"), context2.metadata.feature);
+      }
+      if (context2.metadata.blockers?.length > 0) {
+        console.log(chalk2.bold("Blockers:"));
+        context2.metadata.blockers.forEach((b) => console.log(`  - ${b}`));
+      }
+      if (context2.metadata.nextSteps?.length > 0) {
+        console.log(chalk2.bold("Next Steps:"));
+        context2.metadata.nextSteps.forEach((s) => console.log(`  - ${s}`));
+      }
+      console.log();
+    }
+    if (unsynced.length > 0) {
+      console.log(chalk2.yellow(`\u26A0 ${unsynced.length} unsynced entries`));
+      console.log(chalk2.dim('  Run "contxt push" to sync'));
+      console.log();
+    }
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/doc.ts
+import { readFileSync } from "fs";
+async function add3(options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    let content = options.content || "";
+    if (options.file) {
+      try {
+        content = readFileSync(options.file, "utf-8");
+      } catch (err) {
+        error(`Failed to read file: ${err.message}`);
+        process.exit(1);
+      }
+    }
+    if (!content) {
+      error("Either --content or --file is required");
+      process.exit(1);
+    }
+    const input = {
+      title: options.title,
+      content,
+      url: options.url,
+      tags: options.tags
+    };
+    const entry = await engine.addDocument(projectId, input);
+    success(`Added document: ${entry.title}`);
+    console.log(`ID: ${entry.id}`);
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function list3(options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const documents = await engine.listDocuments(projectId, options.branch);
+    console.log(section("Documents"));
+    console.log();
+    console.log(formatEntryList(documents));
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function show4(id) {
+  try {
+    const { engine, db } = await loadProject();
+    const document = await engine.getDocument(id);
+    console.log(formatEntry(document));
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+var docCommand = {
+  add: add3,
+  list: list3,
+  show: show4
+};
+
+// src/commands/session.ts
+async function start(options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const input = {
+      feature: options.feature,
+      description: options.description
+    };
+    const session2 = await engine.startSession(projectId, input);
+    success(`Started session: ${session2.title}`);
+    console.log(`ID: ${session2.id}`);
+    info('Run "contxt session end" when done');
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function end(options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const session2 = await engine.endSession(projectId, options.summary);
+    success(`Ended session: ${session2.title}`);
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function list4(options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const sessions = await engine.listSessions(projectId, options.branch);
+    console.log(section("Sessions"));
+    console.log();
+    console.log(formatEntryList(sessions));
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function current() {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const session2 = await engine.getActiveSession(projectId);
+    if (!session2) {
+      info("No active session");
+      await db.close();
+      return;
+    }
+    console.log(formatEntry(session2));
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+var sessionCommand = {
+  start,
+  end,
+  list: list4,
+  current
+};
+
+// src/commands/search.ts
+async function searchCommand(query, options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const results = await engine.searchEntries(projectId, query, {
+      branch: options.branch,
+      type: options.type
+    });
+    const limited = options.limit ? results.slice(0, options.limit) : results;
+    console.log(section(`Search Results for "${query}"`));
+    console.log();
+    console.log(formatEntryList(limited));
+    console.log();
+    console.log(`Found ${results.length} result(s)`);
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/export.ts
+import { writeFileSync, readFileSync as readFileSync2 } from "fs";
+async function exportCommand(options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    const entries = await engine.getAllEntries({
+      projectId,
+      branch: options.branch,
+      isArchived: false
+    });
+    const exportData = {
+      version: "1.0",
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectId,
+      branch: options.branch || "main",
+      entries: entries.map((e) => ({
+        id: e.id,
+        type: e.type,
+        title: e.title,
+        content: e.content,
+        metadata: e.metadata,
+        branch: e.branch,
+        createdAt: e.createdAt.toISOString(),
+        updatedAt: e.updatedAt.toISOString()
+      }))
+    };
+    const json = JSON.stringify(exportData, null, 2);
+    if (options.output) {
+      writeFileSync(options.output, json, "utf-8");
+      success(`Exported ${entries.length} entries to ${options.output}`);
+    } else {
+      console.log(json);
+    }
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function importCommand(options) {
+  try {
+    const { engine, projectId, db } = await loadProject();
+    let data;
+    try {
+      const json = readFileSync2(options.file, "utf-8");
+      data = JSON.parse(json);
+    } catch (err) {
+      error(`Failed to read import file: ${err.message}`);
+      process.exit(1);
+    }
+    if (!data.entries || !Array.isArray(data.entries)) {
+      error("Invalid import file format");
+      process.exit(1);
+    }
+    info(`Importing ${data.entries.length} entries...`);
+    let imported = 0;
+    for (const entry of data.entries) {
+      try {
+        await db.createEntry({
+          projectId,
+          type: entry.type,
+          title: entry.title,
+          content: entry.content,
+          metadata: entry.metadata,
+          branch: entry.branch
+        });
+        imported++;
+      } catch (err) {
+        console.error(`Failed to import entry "${entry.title}": ${err.message}`);
+      }
+    }
+    success(`Imported ${imported} of ${data.entries.length} entries`);
+    await db.close();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/auth.ts
+import { SupabaseAuth } from "@mycontxt/adapters/supabase-auth";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync3 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/config.ts
+var SUPABASE_URL = "";
+var SUPABASE_ANON_KEY = "";
+function getSupabaseConfig() {
+  if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
+    throw new Error(
+      "Contxt is not configured for cloud sync.\nIf you installed via npm, please reinstall the latest version.\nIf building locally, set CONTXT_SUPABASE_URL and CONTXT_SUPABASE_ANON_KEY before running `pnpm build`."
+    );
+  }
+  return { url: SUPABASE_URL, anonKey: SUPABASE_ANON_KEY };
+}
+
+// src/commands/auth.ts
+var CONFIG_DIR = join2(homedir(), ".contxt");
+var AUTH_FILE = join2(CONFIG_DIR, "auth.json");
+function saveAuthData(data) {
+  if (!existsSync3(CONFIG_DIR)) {
+    mkdirSync2(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync2(AUTH_FILE, JSON.stringify(data, null, 2), "utf-8");
+}
+function loadAuthData() {
+  if (!existsSync3(AUTH_FILE)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(AUTH_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+var authCommand = {
+  async login(options) {
+    try {
+      const config = getSupabaseConfig();
+      const auth2 = new SupabaseAuth(config);
+      console.log("\u{1F510} Contxt Authentication\n");
+      if (options.email) {
+        await auth2.loginWithMagicLink(options.email);
+        console.log("\n\u2705 Magic link sent! Check your email and click the link.");
+        console.log("   Then run `contxt auth status` to verify.");
+      } else {
+        console.log("Opening browser for GitHub authentication...\n");
+        const result = await auth2.loginWithGitHub();
+        saveAuthData({
+          accessToken: result.accessToken,
+          userId: result.user.id,
+          email: result.user.email,
+          githubUsername: result.user.githubUsername
+        });
+        console.log("\n\u2705 Successfully authenticated!");
+        console.log(`   Email: ${result.user.email}`);
+        if (result.user.githubUsername) {
+          console.log(`   GitHub: @${result.user.githubUsername}`);
+        }
+        console.log("\nYou can now use `contxt push` and `contxt pull` to sync your memory.");
+      }
+    } catch (error2) {
+      console.error(
+        "\u274C Authentication failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  },
+  async logout() {
+    try {
+      const config = getSupabaseConfig();
+      const auth2 = new SupabaseAuth(config);
+      await auth2.logout();
+      if (existsSync3(AUTH_FILE)) {
+        const fs = await import("fs/promises");
+        await fs.unlink(AUTH_FILE);
+      }
+      console.log("\u2705 Logged out successfully");
+    } catch (error2) {
+      console.error(
+        "\u274C Logout failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  },
+  async status() {
+    try {
+      const authData = loadAuthData();
+      if (!authData) {
+        console.log("\u274C Not authenticated");
+        console.log("\nRun `contxt auth login` to authenticate.");
+        process.exit(1);
+      }
+      console.log("\u2705 Authenticated");
+      console.log(`   Email: ${authData.email}`);
+      if (authData.githubUsername) {
+        console.log(`   GitHub: @${authData.githubUsername}`);
+      }
+      console.log(`   User ID: ${authData.userId}`);
+      const config = getSupabaseConfig();
+      const auth2 = new SupabaseAuth(config);
+      try {
+        await auth2.refreshSession();
+        console.log("\n\u2705 Session is valid");
+      } catch {
+        console.log("\n\u26A0\uFE0F  Session expired. Run `contxt auth login` to re-authenticate.");
+      }
+    } catch (error2) {
+      console.error(
+        "\u274C Status check failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  }
+};
+function getAccessToken() {
+  const authData = loadAuthData();
+  return authData?.accessToken || null;
+}
+
+// src/commands/sync.ts
+import { SQLiteDatabase as SQLiteDatabase3 } from "@mycontxt/adapters/sqlite";
+import { SupabaseDatabase } from "@mycontxt/adapters/supabase";
+import { SyncEngine } from "@mycontxt/core";
+var syncCommand = {
+  /**
+   * Push local changes to cloud
+   */
+  async push(options) {
+    try {
+      const accessToken = getAccessToken();
+      if (!accessToken) {
+        console.error("\u274C Not authenticated. Run `contxt auth login` first.");
+        process.exit(1);
+      }
+      const dbPath = getDbPath();
+      const localDb = new SQLiteDatabase3(dbPath);
+      await localDb.initialize();
+      try {
+        const cwd = process.cwd();
+        const project = await localDb.getProjectByPath(cwd);
+        if (!project) {
+          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          process.exit(1);
+        }
+        const supabaseConfig = getSupabaseConfig();
+        const remoteDb = new SupabaseDatabase({
+          ...supabaseConfig,
+          accessToken
+        });
+        await remoteDb.initialize();
+        const syncEngine = new SyncEngine(localDb, remoteDb);
+        console.log("\u{1F504} Pushing local changes to cloud...\n");
+        const result = await syncEngine.push(project.id, {
+          force: options.force,
+          dryRun: options.dryRun
+        });
+        if (result.errors.length > 0) {
+          console.error("\u274C Push failed:");
+          result.errors.forEach((err) => console.error(`   ${err}`));
+          process.exit(1);
+        }
+        if (options.dryRun) {
+          console.log(`\u{1F4CB} Dry run - would push ${result.pushed} entries`);
+        } else {
+          console.log(`\u2705 Successfully pushed ${result.pushed} entries`);
+        }
+        if (result.conflicts > 0) {
+          console.log(
+            `\u26A0\uFE0F  ${result.conflicts} conflict(s) detected. Use --force to override.`
+          );
+        }
+        await remoteDb.close();
+      } finally {
+        await localDb.close();
+      }
+    } catch (error2) {
+      console.error(
+        "\u274C Push failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  },
+  /**
+   * Pull remote changes to local
+   */
+  async pull(options) {
+    try {
+      const accessToken = getAccessToken();
+      if (!accessToken) {
+        console.error("\u274C Not authenticated. Run `contxt auth login` first.");
+        process.exit(1);
+      }
+      const dbPath = getDbPath();
+      const localDb = new SQLiteDatabase3(dbPath);
+      await localDb.initialize();
+      try {
+        const cwd = process.cwd();
+        const project = await localDb.getProjectByPath(cwd);
+        if (!project) {
+          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          process.exit(1);
+        }
+        const supabaseConfig = getSupabaseConfig();
+        const remoteDb = new SupabaseDatabase({
+          ...supabaseConfig,
+          accessToken
+        });
+        await remoteDb.initialize();
+        const syncEngine = new SyncEngine(localDb, remoteDb);
+        console.log("\u{1F504} Pulling remote changes to local...\n");
+        const result = await syncEngine.pull(project.id, {
+          force: options.force,
+          dryRun: options.dryRun
+        });
+        if (result.errors.length > 0) {
+          console.error("\u274C Pull failed:");
+          result.errors.forEach((err) => console.error(`   ${err}`));
+          process.exit(1);
+        }
+        if (options.dryRun) {
+          console.log(`\u{1F4CB} Dry run - would pull ${result.pulled} entries`);
+        } else {
+          console.log(`\u2705 Successfully pulled ${result.pulled} entries`);
+        }
+        if (result.conflicts > 0) {
+          console.log(
+            `\u26A0\uFE0F  ${result.conflicts} conflict(s) detected. Use --force to override.`
+          );
+        }
+        await remoteDb.close();
+      } finally {
+        await localDb.close();
+      }
+    } catch (error2) {
+      console.error(
+        "\u274C Pull failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  },
+  /**
+   * Full bidirectional sync
+   */
+  async sync(options) {
+    try {
+      const accessToken = getAccessToken();
+      if (!accessToken) {
+        console.error("\u274C Not authenticated. Run `contxt auth login` first.");
+        process.exit(1);
+      }
+      const dbPath = getDbPath();
+      const localDb = new SQLiteDatabase3(dbPath);
+      await localDb.initialize();
+      try {
+        const cwd = process.cwd();
+        const project = await localDb.getProjectByPath(cwd);
+        if (!project) {
+          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          process.exit(1);
+        }
+        const supabaseConfig = getSupabaseConfig();
+        const remoteDb = new SupabaseDatabase({
+          ...supabaseConfig,
+          accessToken
+        });
+        await remoteDb.initialize();
+        const syncEngine = new SyncEngine(localDb, remoteDb);
+        console.log("\u{1F504} Syncing with cloud (pull + push)...\n");
+        const result = await syncEngine.sync(project.id, {
+          force: options.force,
+          dryRun: options.dryRun
+        });
+        if (result.errors.length > 0) {
+          console.error("\u274C Sync failed:");
+          result.errors.forEach((err) => console.error(`   ${err}`));
+          process.exit(1);
+        }
+        if (options.dryRun) {
+          console.log(
+            `\u{1F4CB} Dry run - would pull ${result.pulled} and push ${result.pushed} entries`
+          );
+        } else {
+          console.log(`\u2705 Successfully synced`);
+          console.log(`   Pulled: ${result.pulled} entries`);
+          console.log(`   Pushed: ${result.pushed} entries`);
+        }
+        if (result.conflicts > 0) {
+          console.log(
+            `\u26A0\uFE0F  ${result.conflicts} conflict(s) detected. Use --force to override.`
+          );
+        }
+        await remoteDb.close();
+      } finally {
+        await localDb.close();
+      }
+    } catch (error2) {
+      console.error(
+        "\u274C Sync failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  }
+};
+
+// src/commands/branch.ts
+import { SQLiteDatabase as SQLiteDatabase4 } from "@mycontxt/adapters/sqlite";
+var branchCommand = {
+  /**
+   * Create a new branch
+   */
+  async create(name, options) {
+    try {
+      const dbPath = getDbPath();
+      const db = new SQLiteDatabase4(dbPath);
+      await db.initialize();
+      try {
+        const cwd = process.cwd();
+        const project = await db.getProjectByPath(cwd);
+        if (!project) {
+          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          process.exit(1);
+        }
+        const fromBranch = options.from || await db.getActiveBranch(project.id);
+        await db.createBranch(project.id, name, fromBranch);
+        console.log(`\u2705 Created branch '${name}' from '${fromBranch}'`);
+      } finally {
+        await db.close();
+      }
+    } catch (error2) {
+      console.error(
+        "\u274C Branch create failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  },
+  /**
+   * List all branches
+   */
+  async list() {
+    try {
+      const dbPath = getDbPath();
+      const db = new SQLiteDatabase4(dbPath);
+      await db.initialize();
+      try {
+        const cwd = process.cwd();
+        const project = await db.getProjectByPath(cwd);
+        if (!project) {
+          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          process.exit(1);
+        }
+        const branches = await db.listBranches(project.id);
+        const activeBranch = await db.getActiveBranch(project.id);
+        console.log("Branches:");
+        for (const branch2 of branches) {
+          const prefix = branch2.name === activeBranch ? "* " : "  ";
+          const parent = branch2.parentBranch ? ` (from ${branch2.parentBranch})` : "";
+          console.log(`${prefix}${branch2.name}${parent}`);
+        }
+      } finally {
+        await db.close();
+      }
+    } catch (error2) {
+      console.error(
+        "\u274C Branch list failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  },
+  /**
+   * Switch to a different branch
+   */
+  async switch(name) {
+    try {
+      const dbPath = getDbPath();
+      const db = new SQLiteDatabase4(dbPath);
+      await db.initialize();
+      try {
+        const cwd = process.cwd();
+        const project = await db.getProjectByPath(cwd);
+        if (!project) {
+          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          process.exit(1);
+        }
+        await db.switchBranch(project.id, name);
+        console.log(`\u2705 Switched to branch '${name}'`);
+      } finally {
+        await db.close();
+      }
+    } catch (error2) {
+      console.error(
+        "\u274C Branch switch failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  },
+  /**
+   * Delete a branch
+   */
+  async delete(name) {
+    try {
+      const dbPath = getDbPath();
+      const db = new SQLiteDatabase4(dbPath);
+      await db.initialize();
+      try {
+        const cwd = process.cwd();
+        const project = await db.getProjectByPath(cwd);
+        if (!project) {
+          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          process.exit(1);
+        }
+        const activeBranch = await db.getActiveBranch(project.id);
+        if (name === activeBranch) {
+          console.error("\u274C Cannot delete active branch. Switch to another branch first.");
+          process.exit(1);
+        }
+        if (name === "main") {
+          console.error("\u274C Cannot delete main branch.");
+          process.exit(1);
+        }
+        await db.deleteBranch(project.id, name);
+        console.log(`\u2705 Deleted branch '${name}'`);
+      } finally {
+        await db.close();
+      }
+    } catch (error2) {
+      console.error(
+        "\u274C Branch delete failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  },
+  /**
+   * Merge a branch into current branch
+   */
+  async merge(sourceBranch) {
+    try {
+      const dbPath = getDbPath();
+      const db = new SQLiteDatabase4(dbPath);
+      await db.initialize();
+      try {
+        const cwd = process.cwd();
+        const project = await db.getProjectByPath(cwd);
+        if (!project) {
+          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          process.exit(1);
+        }
+        const targetBranch = await db.getActiveBranch(project.id);
+        if (sourceBranch === targetBranch) {
+          console.error("\u274C Cannot merge a branch into itself.");
+          process.exit(1);
+        }
+        const sourceEntries = await db.listEntries({
+          projectId: project.id,
+          branch: sourceBranch,
+          isArchived: false
+        });
+        if (sourceEntries.length === 0) {
+          console.log(`No entries to merge from '${sourceBranch}'.`);
+          process.exit(0);
+        }
+        let merged = 0;
+        for (const entry of sourceEntries) {
+          const existing = await db.getEntry(entry.id);
+          if (!existing || existing.branch !== targetBranch) {
+            await db.createEntry({
+              id: entry.id,
+              projectId: entry.projectId,
+              type: entry.type,
+              title: entry.title,
+              content: entry.content,
+              metadata: entry.metadata,
+              branch: targetBranch
+            });
+            merged++;
+          } else if (entry.updatedAt > existing.updatedAt) {
+            await db.updateEntry(entry.id, {
+              title: entry.title,
+              content: entry.content,
+              metadata: entry.metadata,
+              updatedAt: entry.updatedAt
+            });
+            merged++;
+          }
+        }
+        console.log(
+          `\u2705 Merged ${merged} entries from '${sourceBranch}' into '${targetBranch}'`
+        );
+      } finally {
+        await db.close();
+      }
+    } catch (error2) {
+      console.error(
+        "\u274C Branch merge failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  }
+};
+
+// src/commands/history.ts
+import { SQLiteDatabase as SQLiteDatabase5 } from "@mycontxt/adapters/sqlite";
+var historyCommand = {
+  /**
+   * Show version history for an entry
+   */
+  async show(entryId) {
+    try {
+      const dbPath = getDbPath();
+      const db = new SQLiteDatabase5(dbPath);
+      await db.initialize();
+      try {
+        const entry = await db.getEntry(entryId);
+        if (!entry) {
+          console.error("\u274C Entry not found.");
+          process.exit(1);
+        }
+        const versions = await db.getVersionHistory(entryId);
+        console.log(`\u{1F4DC} Version History: ${entry.title}
+`);
+        console.log(`Current (v${entry.version}):`);
+        console.log(`  Updated: ${entry.updatedAt.toLocaleString()}`);
+        console.log(`  Title: ${entry.title}`);
+        console.log(`  Content: ${entry.content.substring(0, 100)}${entry.content.length > 100 ? "..." : ""}
+`);
+        if (versions.length > 0) {
+          console.log("Previous versions:");
+          for (const version of versions) {
+            console.log(`
+v${version.version}:`);
+            console.log(`  Updated: ${version.updatedAt.toLocaleString()}`);
+            console.log(`  Title: ${version.title}`);
+            console.log(
+              `  Content: ${version.content.substring(0, 100)}${version.content.length > 100 ? "..." : ""}`
+            );
+          }
+        } else {
+          console.log("No previous versions.");
+        }
+      } finally {
+        await db.close();
+      }
+    } catch (error2) {
+      console.error(
+        "\u274C History failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  },
+  /**
+   * Restore an entry to a previous version
+   */
+  async restore(entryId, options) {
+    try {
+      const dbPath = getDbPath();
+      const db = new SQLiteDatabase5(dbPath);
+      await db.initialize();
+      try {
+        const restored = await db.restoreVersion(entryId, options.version);
+        console.log(`\u2705 Restored '${restored.title}' to version ${options.version}`);
+        console.log(`   Current version is now: v${restored.version}`);
+      } finally {
+        await db.close();
+      }
+    } catch (error2) {
+      console.error(
+        "\u274C Restore failed:",
+        error2 instanceof Error ? error2.message : error2
+      );
+      process.exit(1);
+    }
+  }
+};
+
+// src/commands/load.ts
+import { SQLiteDatabase as SQLiteDatabase6 } from "@mycontxt/adapters/sqlite";
+import { buildContextPayload, buildContextSummary } from "@mycontxt/core";
+async function loadCommand(options) {
+  try {
+    const dbPath = getDbPath();
+    const db = new SQLiteDatabase6(dbPath);
+    await db.initialize();
+    try {
+      const cwd = process.cwd();
+      const project = await db.getProjectByPath(cwd);
+      if (!project) {
+        console.error("\u274C No Contxt project found. Run `contxt init` first.");
+        process.exit(1);
+      }
+      const branch2 = await db.getActiveBranch(project.id);
+      const entries = await db.listEntries({
+        projectId: project.id,
+        branch: branch2,
+        isArchived: false
+      });
+      if (entries.length === 0) {
+        console.log("No memory entries found. Add some context first!");
+        process.exit(0);
+      }
+      if (options.summary) {
+        const summary = buildContextSummary(entries);
+        console.log(`\u{1F4CA} Context Summary
+`);
+        console.log(`Total entries: ${summary.totalEntries}`);
+        console.log(`Branch: ${branch2}
+`);
+        console.log("By type:");
+        for (const [type, count] of Object.entries(summary.byType)) {
+          console.log(`  ${type}: ${count}`);
+        }
+        if (summary.recentActivity.length > 0) {
+          console.log(`
+Recent activity:`);
+          summary.recentActivity.forEach((activity) => {
+            console.log(`  \u2022 ${activity}`);
+          });
+        }
+        if (summary.oldestEntry && summary.newestEntry) {
+          console.log(
+            `
+Date range: ${summary.oldestEntry.toLocaleDateString()} - ${summary.newestEntry.toLocaleDateString()}`
+          );
+        }
+        process.exit(0);
+      }
+      let mode = "all";
+      if (options.task) {
+        mode = "task";
+      } else if (options.files && options.files.length > 0) {
+        mode = "files";
+      } else if (options.all) {
+        mode = "all";
+      }
+      const result = buildContextPayload(entries, {
+        projectId: project.id,
+        type: mode,
+        taskDescription: options.task,
+        activeFiles: options.files,
+        maxTokens: options.maxTokens || 4e3,
+        includeTypes: options.type ? [options.type] : void 0
+      });
+      console.log(result.context);
+      console.error(
+        `
+\u{1F4E6} Context: ${result.entriesIncluded} entries, ${result.tokensUsed}/${result.budget} tokens`
+      );
+    } finally {
+      await db.close();
+    }
+  } catch (error2) {
+    console.error(
+      "\u274C Load failed:",
+      error2 instanceof Error ? error2.message : error2
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/scan.ts
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+import { join as join3, relative } from "path";
+import chalk3 from "chalk";
+import ora from "ora";
+import { parseFile, scanCommentToEntry } from "@mycontxt/core";
+import { glob } from "glob";
+async function scanCommand(options = {}) {
+  const spinner = ora("Scanning project...").start();
+  try {
+    const db = await getProjectDb();
+    const project = await db.getProjectByPath(process.cwd());
+    if (!project) {
+      spinner.fail("Not a Contxt project. Run `contxt init` first.");
+      return;
+    }
+    const patterns = [
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.py",
+      "**/*.rb",
+      "**/*.go",
+      "**/*.rs",
+      "**/*.sql",
+      "**/*.sh"
+    ];
+    const ignore = [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.next/**",
+      "**/*.min.js",
+      "**/*.lock",
+      ".contxt/**"
+    ];
+    const contxtIgnorePath = join3(process.cwd(), ".contxtignore");
+    if (existsSync4(contxtIgnorePath)) {
+      const contxtIgnore = readFileSync4(contxtIgnorePath, "utf-8").split("\n").filter((line) => line.trim() && !line.startsWith("#"));
+      ignore.push(...contxtIgnore);
+    }
+    const searchPath = options.path || process.cwd();
+    const files = await glob(patterns, {
+      cwd: searchPath,
+      ignore,
+      absolute: true,
+      nodir: true
+    });
+    spinner.text = `Scanning ${files.length} files...`;
+    const allComments = [];
+    for (const file of files) {
+      const content = readFileSync4(file, "utf-8");
+      const comments = parseFile(content, relative(process.cwd(), file));
+      allComments.push(...comments);
+    }
+    spinner.succeed(`Found ${allComments.length} tagged comments across ${files.length} files`);
+    if (allComments.length === 0) {
+      console.log(chalk3.gray("\nNo tagged comments found. Try adding @decision, @pattern, or @context tags to your code."));
+      return;
+    }
+    const existingEntries = await db.listEntries({
+      projectId: project.id,
+      branch: await db.getActiveBranch(project.id)
+    });
+    const existingHashes = new Map(
+      existingEntries.filter((e) => e.metadata.source === "scan" && e.metadata.hash).map((e) => [e.metadata.hash, e])
+    );
+    const newComments = [];
+    const updatedComments = [];
+    const unchangedComments = [];
+    for (const comment of allComments) {
+      const existing = existingHashes.get(comment.hash);
+      if (!existing) {
+        newComments.push(comment);
+      } else {
+        const entry = scanCommentToEntry(comment, project.id);
+        if (existing.title !== entry.title || existing.content !== entry.content) {
+          updatedComments.push(comment);
+        } else {
+          unchangedComments.push(comment);
+        }
+        existingHashes.delete(comment.hash);
+      }
+    }
+    const staleEntries = Array.from(existingHashes.values());
+    console.log("");
+    if (newComments.length > 0) {
+      console.log(chalk3.bold("NEW"));
+      for (const comment of newComments) {
+        const icon = getTypeIcon(comment.tag);
+        console.log(
+          `  ${chalk3.green("+")} ${icon} ${chalk3.bold(comment.title.substring(0, 50))}  ${chalk3.gray(comment.file + ":" + comment.line)}`
+        );
+      }
+      console.log("");
+    }
+    if (updatedComments.length > 0) {
+      console.log(chalk3.bold("UPDATED"));
+      for (const comment of updatedComments) {
+        const icon = getTypeIcon(comment.tag);
+        console.log(
+          `  ${chalk3.yellow("~")} ${icon} ${chalk3.bold(comment.title.substring(0, 50))}  ${chalk3.gray(comment.file + ":" + comment.line)}`
+        );
+      }
+      console.log("");
+    }
+    if (unchangedComments.length > 0) {
+      console.log(chalk3.bold("UNCHANGED"));
+      for (const comment of unchangedComments.slice(0, 3)) {
+        const icon = getTypeIcon(comment.tag);
+        console.log(
+          `  ${chalk3.gray("\xB7")} ${icon} ${chalk3.gray(comment.title.substring(0, 50))}  ${chalk3.gray(comment.file + ":" + comment.line)}`
+        );
+      }
+      if (unchangedComments.length > 3) {
+        console.log(chalk3.gray(`  ... and ${unchangedComments.length - 3} more`));
+      }
+      console.log("");
+    }
+    if (staleEntries.length > 0) {
+      console.log(chalk3.bold("STALE (source comment removed)"));
+      for (const entry of staleEntries) {
+        const icon = getTypeIcon(entry.type);
+        console.log(
+          `  ${chalk3.red("?")} ${icon} ${chalk3.gray(entry.title.substring(0, 50))}  ${chalk3.gray("was: " + entry.metadata.file + ":" + entry.metadata.line)}`
+        );
+      }
+      console.log("");
+    }
+    if (options.dryRun) {
+      console.log(chalk3.yellow("Dry run - no changes saved."));
+      return;
+    }
+    const toSave = [...newComments, ...updatedComments];
+    if (toSave.length > 0) {
+      const saveSpinner = ora("Saving entries...").start();
+      for (const comment of toSave) {
+        const entry = scanCommentToEntry(comment, project.id);
+        const existing = existingHashes.get(comment.hash);
+        if (existing) {
+          await db.updateEntry(existing.id, {
+            title: entry.title,
+            content: entry.content,
+            metadata: entry.metadata
+          });
+        } else {
+          await db.createEntry({
+            projectId: project.id,
+            type: entry.type,
+            title: entry.title,
+            content: entry.content,
+            metadata: entry.metadata,
+            status: options.autoConfirm ? "active" : "draft"
+          });
+        }
+      }
+      saveSpinner.succeed(
+        options.autoConfirm ? `Saved ${toSave.length} entries.` : `${toSave.length} new entries saved as drafts.`
+      );
+    }
+    if (staleEntries.length > 0) {
+      for (const entry of staleEntries) {
+        await db.updateEntry(entry.id, { status: "stale" });
+      }
+      console.log(chalk3.gray(`Marked ${staleEntries.length} entries as stale.`));
+    }
+    if (!options.autoConfirm && toSave.length > 0) {
+      console.log("");
+      console.log(chalk3.cyan(`Run ${chalk3.bold("contxt review")} to confirm drafts.`));
+    }
+    await db.close();
+  } catch (error2) {
+    spinner.fail("Scan failed");
+    console.error(chalk3.red(error2 instanceof Error ? error2.message : String(error2)));
+    process.exit(1);
+  }
+}
+function getTypeIcon(type) {
+  const icons = {
+    decision: chalk3.blue("DECISION"),
+    pattern: chalk3.magenta("PATTERN"),
+    context: chalk3.green("CONTEXT")
+  };
+  return icons[type] || type.toUpperCase();
+}
+
+// src/commands/review.ts
+import chalk4 from "chalk";
+import inquirer from "inquirer";
+import ora2 from "ora";
+async function reviewCommand(options = {}) {
+  try {
+    const db = await getProjectDb();
+    const project = await db.getProjectByPath(process.cwd());
+    if (!project) {
+      console.log(chalk4.red("Not a Contxt project. Run `contxt init` first."));
+      return;
+    }
+    let drafts = await db.listEntries({
+      projectId: project.id,
+      branch: await db.getActiveBranch(project.id)
+    });
+    drafts = drafts.filter((e) => e.status === "draft");
+    if (options.source) {
+      drafts = drafts.filter((e) => {
+        const source = e.metadata.source || "";
+        return source.includes(options.source);
+      });
+    }
+    if (drafts.length === 0) {
+      console.log(chalk4.green("\u2713 No drafts pending review"));
+      return;
+    }
+    if (options.count) {
+      console.log(`${drafts.length} drafts pending review`);
+      return;
+    }
+    console.log(chalk4.bold(`
+${drafts.length} drafts pending review
+`));
+    if (options.confirmAll) {
+      const spinner = ora2("Confirming all drafts...").start();
+      for (const draft of drafts) {
+        await db.updateEntry(draft.id, { status: "active" });
+      }
+      spinner.succeed(`Confirmed ${drafts.length} drafts`);
+      await db.close();
+      return;
+    }
+    if (options.discardAll) {
+      const { confirm } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: `Discard all ${drafts.length} drafts?`,
+          default: false
+        }
+      ]);
+      if (confirm) {
+        const spinner = ora2("Discarding all drafts...").start();
+        for (const draft of drafts) {
+          await db.deleteEntry(draft.id);
+        }
+        spinner.succeed(`Discarded ${drafts.length} drafts`);
+      }
+      await db.close();
+      return;
+    }
+    let confirmed = 0;
+    let discarded = 0;
+    let skipped = 0;
+    for (const draft of drafts) {
+      console.log(chalk4.gray("\u2500".repeat(50)));
+      console.log("");
+      displayDraft(draft);
+      console.log("");
+      const { action } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "action",
+          message: "Action?",
+          choices: [
+            { name: "Confirm", value: "confirm" },
+            { name: "Edit then confirm", value: "edit" },
+            { name: "Discard", value: "discard" },
+            { name: "Skip (review later)", value: "skip" }
+          ]
+        }
+      ]);
+      if (action === "confirm") {
+        await db.updateEntry(draft.id, { status: "active" });
+        console.log(chalk4.green("\u2713 Confirmed"));
+        confirmed++;
+      } else if (action === "edit") {
+        const edited = await editDraft(draft);
+        await db.updateEntry(draft.id, {
+          title: edited.title,
+          content: edited.content,
+          metadata: edited.metadata,
+          status: "active"
+        });
+        console.log(chalk4.green("\u2713 Edited and confirmed"));
+        confirmed++;
+      } else if (action === "discard") {
+        await db.deleteEntry(draft.id);
+        console.log(chalk4.red("\u2717 Discarded"));
+        discarded++;
+      } else {
+        console.log(chalk4.gray("\u25CB Skipped"));
+        skipped++;
+      }
+      console.log("");
+    }
+    console.log(chalk4.gray("\u2500".repeat(50)));
+    console.log("");
+    console.log(chalk4.bold("Review complete"));
+    console.log(`  ${chalk4.green(confirmed)} confirmed`);
+    console.log(`  ${chalk4.red(discarded)} discarded`);
+    console.log(`  ${chalk4.gray(skipped)} skipped`);
+    console.log("");
+    await db.close();
+  } catch (error2) {
+    console.error(chalk4.red(error2 instanceof Error ? error2.message : String(error2)));
+    process.exit(1);
+  }
+}
+function displayDraft(draft) {
+  const icon = getTypeIcon2(draft.type);
+  const source = draft.metadata.source || "unknown";
+  const file = draft.metadata.file ? ` \xB7 ${draft.metadata.file}:${draft.metadata.line}` : "";
+  const timeAgo = getTimeAgo(draft.createdAt);
+  console.log(`  ${icon}  ${chalk4.bold(draft.title)}`);
+  console.log(`  ${chalk4.gray(`Source: ${source}${file} \xB7 ${timeAgo}`)}`);
+  const contentPreview = draft.content.split("\n")[0].substring(0, 80);
+  if (contentPreview) {
+    console.log(`  ${chalk4.gray(contentPreview)}${draft.content.length > 80 ? "..." : ""}`);
+  }
+  if (draft.type === "decision") {
+    if (draft.metadata.rationale) {
+      console.log(`  ${chalk4.dim("Rationale:")} ${draft.metadata.rationale.substring(0, 60)}...`);
+    }
+    if (draft.metadata.alternatives) {
+      console.log(`  ${chalk4.dim("Alternatives:")} ${draft.metadata.alternatives}`);
+    }
+  }
+  if (draft.type === "pattern") {
+    if (draft.metadata.when) {
+      console.log(`  ${chalk4.dim("When:")} ${draft.metadata.when}`);
+    }
+  }
+}
+async function editDraft(draft) {
+  console.log(chalk4.cyan("\nEdit mode (press Enter to keep current value):\n"));
+  const { title, content } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "title",
+      message: "Title:",
+      default: draft.title
+    },
+    {
+      type: "input",
+      name: "content",
+      message: "Content:",
+      default: draft.content
+    }
+  ]);
+  return {
+    title: title || draft.title,
+    content: content || draft.content,
+    metadata: draft.metadata
+  };
+}
+function getTypeIcon2(type) {
+  const icons = {
+    decision: chalk4.blue("DECISION"),
+    pattern: chalk4.magenta("PATTERN"),
+    context: chalk4.green("CONTEXT"),
+    document: chalk4.yellow("DOCUMENT"),
+    session: chalk4.cyan("SESSION")
+  };
+  return icons[type] || type.toUpperCase();
+}
+function getTimeAgo(date) {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
+  if (seconds < 60) return "just now";
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+
+// src/commands/rules.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
+import chalk5 from "chalk";
+import ora3 from "ora";
+import { parseRulesFile, generateRulesFile } from "@mycontxt/core";
+async function syncCommand2(options = {}) {
+  const spinner = ora3("Reading rules.md...").start();
+  try {
+    const db = await getProjectDb();
+    const project = await db.getProjectByPath(process.cwd());
+    if (!project) {
+      spinner.fail("Not a Contxt project. Run `contxt init` first.");
+      return;
+    }
+    const rulesPath = join4(process.cwd(), ".contxt", "rules.md");
+    if (!existsSync5(rulesPath)) {
+      spinner.fail("No rules.md file found. Run `contxt rules generate` to create one.");
+      return;
+    }
+    const content = readFileSync5(rulesPath, "utf-8");
+    const parsed = parseRulesFile(content);
+    spinner.text = "Processing entries...";
+    let added = 0;
+    let updated = 0;
+    let unchanged = 0;
+    const existingEntries = await db.listEntries({
+      projectId: project.id,
+      branch: await db.getActiveBranch(project.id)
+    });
+    const existingByTitle = new Map(
+      existingEntries.map((e) => [e.title, e])
+    );
+    for (const decision2 of parsed.decisions) {
+      const existing = existingByTitle.get(decision2.title);
+      if (!existing) {
+        if (!options.dryRun) {
+          await db.createEntry({
+            projectId: project.id,
+            type: "decision",
+            title: decision2.title,
+            content: decision2.content,
+            metadata: decision2.metadata,
+            status: "active"
+          });
+        }
+        added++;
+      } else if (existing.content !== decision2.content) {
+        if (!options.dryRun) {
+          await db.updateEntry(existing.id, {
+            content: decision2.content,
+            metadata: decision2.metadata
+          });
+        }
+        updated++;
+      } else {
+        unchanged++;
+      }
+    }
+    for (const pattern2 of parsed.patterns) {
+      const existing = existingByTitle.get(pattern2.title);
+      if (!existing) {
+        if (!options.dryRun) {
+          await db.createEntry({
+            projectId: project.id,
+            type: "pattern",
+            title: pattern2.title,
+            content: pattern2.content,
+            metadata: pattern2.metadata,
+            status: "active"
+          });
+        }
+        added++;
+      } else if (existing.content !== pattern2.content) {
+        if (!options.dryRun) {
+          await db.updateEntry(existing.id, {
+            content: pattern2.content,
+            metadata: pattern2.metadata
+          });
+        }
+        updated++;
+      } else {
+        unchanged++;
+      }
+    }
+    if (parsed.context) {
+      const existing = existingEntries.find((e) => e.type === "context" && e.metadata.source === "rules");
+      if (!existing) {
+        if (!options.dryRun) {
+          await db.createEntry({
+            projectId: project.id,
+            type: "context",
+            title: parsed.context.title,
+            content: parsed.context.content,
+            metadata: parsed.context.metadata,
+            status: "active"
+          });
+        }
+        added++;
+      } else if (existing.content !== parsed.context.content) {
+        if (!options.dryRun) {
+          await db.updateEntry(existing.id, {
+            content: parsed.context.content
+          });
+        }
+        updated++;
+      } else {
+        unchanged++;
+      }
+    }
+    for (const doc2 of parsed.documents) {
+      const existing = existingByTitle.get(doc2.title);
+      if (!existing) {
+        if (!options.dryRun) {
+          await db.createEntry({
+            projectId: project.id,
+            type: "document",
+            title: doc2.title,
+            content: doc2.content,
+            metadata: doc2.metadata,
+            status: "active"
+          });
+        }
+        added++;
+      } else if (existing.content !== doc2.content) {
+        if (!options.dryRun) {
+          await db.updateEntry(existing.id, {
+            content: doc2.content,
+            metadata: doc2.metadata
+          });
+        }
+        updated++;
+      } else {
+        unchanged++;
+      }
+    }
+    if (parsed.stack.length > 0 && !options.dryRun) {
+      await db.updateProject(project.id, {
+        stack: parsed.stack
+      });
+    }
+    spinner.succeed(
+      options.dryRun ? `Dry run: Would add ${added}, update ${updated}, leave ${unchanged} unchanged` : `Synced rules.md: ${added} added, ${updated} updated, ${unchanged} unchanged`
+    );
+    await db.close();
+  } catch (error2) {
+    spinner.fail("Sync failed");
+    console.error(chalk5.red(error2 instanceof Error ? error2.message : String(error2)));
+    process.exit(1);
+  }
+}
+async function generateCommand(options = {}) {
+  const spinner = ora3("Loading memory entries...").start();
+  try {
+    const db = await getProjectDb();
+    const project = await db.getProjectByPath(process.cwd());
+    if (!project) {
+      spinner.fail("Not a Contxt project. Run `contxt init` first.");
+      return;
+    }
+    const rulesPath = join4(process.cwd(), ".contxt", "rules.md");
+    if (existsSync5(rulesPath) && !options.force) {
+      spinner.fail("rules.md already exists. Use --force to overwrite.");
+      return;
+    }
+    const branch2 = await db.getActiveBranch(project.id);
+    const allEntries = await db.listEntries({
+      projectId: project.id,
+      branch: branch2
+    });
+    const decisions = allEntries.filter((e) => e.type === "decision" && e.status === "active");
+    const patterns = allEntries.filter((e) => e.type === "pattern" && e.status === "active");
+    const context2 = allEntries.filter((e) => e.type === "context" && e.status === "active");
+    const documents = allEntries.filter((e) => e.type === "document" && e.status === "active");
+    spinner.text = "Generating rules.md...";
+    const rulesContent = generateRulesFile({
+      stack: project.stack || [],
+      decisions: decisions.map((d) => ({
+        title: d.title,
+        content: d.content,
+        metadata: d.metadata
+      })),
+      patterns: patterns.map((p) => ({
+        title: p.title,
+        content: p.content,
+        metadata: p.metadata
+      })),
+      context: context2.map((c) => ({
+        content: c.content
+      })),
+      documents: documents.map((d) => ({
+        title: d.title,
+        content: d.content
+      }))
+    });
+    if (options.dryRun) {
+      spinner.succeed("Generated rules.md (dry run):");
+      console.log("");
+      console.log(chalk5.gray(rulesContent));
+    } else {
+      writeFileSync3(rulesPath, rulesContent, "utf-8");
+      spinner.succeed(`Generated ${rulesPath}`);
+    }
+    await db.close();
+  } catch (error2) {
+    spinner.fail("Generate failed");
+    console.error(chalk5.red(error2 instanceof Error ? error2.message : String(error2)));
+    process.exit(1);
+  }
+}
+async function diffCommand() {
+  const spinner = ora3("Comparing rules.md with memory...").start();
+  try {
+    const db = await getProjectDb();
+    const project = await db.getProjectByPath(process.cwd());
+    if (!project) {
+      spinner.fail("Not a Contxt project. Run `contxt init` first.");
+      return;
+    }
+    const rulesPath = join4(process.cwd(), ".contxt", "rules.md");
+    if (!existsSync5(rulesPath)) {
+      spinner.fail("No rules.md file found.");
+      return;
+    }
+    const content = readFileSync5(rulesPath, "utf-8");
+    const parsed = parseRulesFile(content);
+    const branch2 = await db.getActiveBranch(project.id);
+    const allEntries = await db.listEntries({
+      projectId: project.id,
+      branch: branch2
+    });
+    const existingByTitle = new Map(
+      allEntries.map((e) => [e.title, e])
+    );
+    spinner.stop();
+    const toAdd = [];
+    const toUpdate = [];
+    const inSync = [];
+    for (const decision2 of parsed.decisions) {
+      const existing = existingByTitle.get(decision2.title);
+      if (!existing) {
+        toAdd.push(`${chalk5.blue("DECISION")} ${decision2.title}`);
+      } else if (existing.content !== decision2.content) {
+        toUpdate.push(`${chalk5.blue("DECISION")} ${decision2.title}`);
+      } else {
+        inSync.push(`${chalk5.blue("DECISION")} ${decision2.title}`);
+      }
+    }
+    for (const pattern2 of parsed.patterns) {
+      const existing = existingByTitle.get(pattern2.title);
+      if (!existing) {
+        toAdd.push(`${chalk5.magenta("PATTERN")} ${pattern2.title}`);
+      } else if (existing.content !== pattern2.content) {
+        toUpdate.push(`${chalk5.magenta("PATTERN")} ${pattern2.title}`);
+      } else {
+        inSync.push(`${chalk5.magenta("PATTERN")} ${pattern2.title}`);
+      }
+    }
+    for (const doc2 of parsed.documents) {
+      const existing = existingByTitle.get(doc2.title);
+      if (!existing) {
+        toAdd.push(`${chalk5.cyan("DOCUMENT")} ${doc2.title}`);
+      } else if (existing.content !== doc2.content) {
+        toUpdate.push(`${chalk5.cyan("DOCUMENT")} ${doc2.title}`);
+      } else {
+        inSync.push(`${chalk5.cyan("DOCUMENT")} ${doc2.title}`);
+      }
+    }
+    console.log("");
+    if (toAdd.length > 0) {
+      console.log(chalk5.bold("TO ADD (in rules.md, not in memory):"));
+      for (const item of toAdd) {
+        console.log(`  ${chalk5.green("+")} ${item}`);
+      }
+      console.log("");
+    }
+    if (toUpdate.length > 0) {
+      console.log(chalk5.bold("TO UPDATE (content differs):"));
+      for (const item of toUpdate) {
+        console.log(`  ${chalk5.yellow("~")} ${item}`);
+      }
+      console.log("");
+    }
+    if (inSync.length > 0) {
+      console.log(chalk5.bold("IN SYNC:"));
+      for (const item of inSync.slice(0, 5)) {
+        console.log(`  ${chalk5.gray("\xB7")} ${chalk5.gray(item)}`);
+      }
+      if (inSync.length > 5) {
+        console.log(chalk5.gray(`  ... and ${inSync.length - 5} more`));
+      }
+      console.log("");
+    }
+    if (toAdd.length > 0 || toUpdate.length > 0) {
+      console.log(chalk5.cyan(`Run ${chalk5.bold("contxt rules sync")} to apply changes.`));
+    } else {
+      console.log(chalk5.green("\u2713 Everything in sync!"));
+    }
+    await db.close();
+  } catch (error2) {
+    spinner.fail("Diff failed");
+    console.error(chalk5.red(error2 instanceof Error ? error2.message : String(error2)));
+    process.exit(1);
+  }
+}
+var rulesCommand = {
+  sync: syncCommand2,
+  generate: generateCommand,
+  diff: diffCommand
+};
+
+// src/commands/capture.ts
+import { readFileSync as readFileSync6, existsSync as existsSync6, readdirSync } from "fs";
+import { join as join5, basename as basename2 } from "path";
+import chalk6 from "chalk";
+import ora4 from "ora";
+async function captureCommand(options = {}) {
+  const spinner = ora4("Scanning project files...").start();
+  try {
+    const db = await getProjectDb();
+    const project = await db.getProjectByPath(process.cwd());
+    if (!project) {
+      spinner.fail("Not a Contxt project. Run `contxt init` first.");
+      return;
+    }
+    const entries = [];
+    const sources = options.source === "all" || !options.source ? ["readme", "cursor", "claude", "adr", "commits", "package"] : [options.source];
+    for (const source of sources) {
+      spinner.text = `Importing from ${source}...`;
+      switch (source) {
+        case "readme":
+          entries.push(...importReadme());
+          break;
+        case "cursor":
+          entries.push(...importCursor());
+          break;
+        case "claude":
+          entries.push(...importClaude());
+          break;
+        case "adr":
+          entries.push(...importADR());
+          break;
+        case "commits":
+          entries.push(...importCommits(options.limit || 50));
+          break;
+        case "package":
+          entries.push(...importPackageFiles());
+          break;
+      }
+    }
+    spinner.succeed(`Found ${entries.length} entries across ${sources.length} source(s)`);
+    if (entries.length === 0) {
+      console.log(chalk6.gray("\\nNo entries found to import."));
+      return;
+    }
+    console.log("");
+    const grouped = groupBy(entries, "source");
+    for (const [source, items] of Object.entries(grouped)) {
+      console.log(chalk6.bold(`${source.toUpperCase()} (${items.length})`));
+      for (const item of items.slice(0, 3)) {
+        const icon = getTypeIcon3(item.type);
+        console.log(`  ${icon} ${chalk6.bold(item.title.substring(0, 60))}`);
+      }
+      if (items.length > 3) {
+        console.log(chalk6.gray(`  ... and ${items.length - 3} more`));
+      }
+      console.log("");
+    }
+    if (options.dryRun) {
+      console.log(chalk6.yellow("Dry run - no entries saved."));
+      return;
+    }
+    const saveSpinner = ora4("Saving entries...").start();
+    let saved = 0;
+    for (const entry of entries) {
+      await db.createEntry({
+        projectId: project.id,
+        type: entry.type,
+        title: entry.title,
+        content: entry.content,
+        metadata: {
+          ...entry.metadata,
+          source: `import:${entry.source}`
+        },
+        status: options.autoConfirm ? "active" : "draft"
+      });
+      saved++;
+    }
+    saveSpinner.succeed(
+      options.autoConfirm ? `Saved ${saved} entries.` : `${saved} entries saved as drafts.`
+    );
+    if (!options.autoConfirm) {
+      console.log("");
+      console.log(chalk6.cyan(`Run ${chalk6.bold("contxt review")} to confirm drafts.`));
+    }
+    await db.close();
+  } catch (error2) {
+    spinner.fail("Import failed");
+    console.error(chalk6.red(error2 instanceof Error ? error2.message : String(error2)));
+    process.exit(1);
+  }
+}
+function importReadme() {
+  const readmePath = join5(process.cwd(), "README.md");
+  if (!existsSync6(readmePath)) return [];
+  try {
+    const content = readFileSync6(readmePath, "utf-8");
+    const lines = content.split("\\n");
+    const entries = [];
+    let currentSection = null;
+    let currentContent = [];
+    for (const line of lines) {
+      const headingMatch = line.match(/^#+\\s+(.+)/);
+      if (headingMatch) {
+        if (currentSection && currentContent.length > 0) {
+          const sectionContent = currentContent.join("\\n").trim();
+          if (sectionContent.length > 50) {
+            entries.push({
+              type: "document",
+              title: `README: ${currentSection}`,
+              content: sectionContent,
+              metadata: { section: currentSection },
+              source: "readme"
+            });
+          }
+        }
+        currentSection = headingMatch[1].trim();
+        currentContent = [];
+        continue;
+      }
+      if (currentSection) {
+        currentContent.push(line);
+      }
+    }
+    if (currentSection && currentContent.length > 0) {
+      const sectionContent = currentContent.join("\\n").trim();
+      if (sectionContent.length > 50) {
+        entries.push({
+          type: "document",
+          title: `README: ${currentSection}`,
+          content: sectionContent,
+          metadata: { section: currentSection },
+          source: "readme"
+        });
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function importCursor() {
+  const entries = [];
+  const cursorrulesPath = join5(process.cwd(), ".cursorrules");
+  if (existsSync6(cursorrulesPath)) {
+    try {
+      const content = readFileSync6(cursorrulesPath, "utf-8").trim();
+      if (content.length > 0) {
+        entries.push({
+          type: "document",
+          title: "Cursor Rules",
+          content,
+          metadata: { file: ".cursorrules" },
+          source: "cursor"
+        });
+      }
+    } catch {
+    }
+  }
+  const cursorRulesPath = join5(process.cwd(), ".cursor", "rules");
+  if (existsSync6(cursorRulesPath)) {
+    try {
+      const content = readFileSync6(cursorRulesPath, "utf-8").trim();
+      if (content.length > 0) {
+        entries.push({
+          type: "document",
+          title: "Cursor Rules",
+          content,
+          metadata: { file: ".cursor/rules" },
+          source: "cursor"
+        });
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function importClaude() {
+  const entries = [];
+  const claudePath = join5(process.cwd(), ".claude", "CLAUDE.md");
+  if (existsSync6(claudePath)) {
+    try {
+      const content = readFileSync6(claudePath, "utf-8");
+      const lines = content.split("\\n");
+      let currentSection = null;
+      let currentContent = [];
+      for (const line of lines) {
+        const headingMatch = line.match(/^#+\\s+(.+)/);
+        if (headingMatch) {
+          if (currentSection && currentContent.length > 0) {
+            const sectionContent = currentContent.join("\\n").trim();
+            if (sectionContent.length > 50) {
+              entries.push({
+                type: "document",
+                title: `Claude: ${currentSection}`,
+                content: sectionContent,
+                metadata: { section: currentSection },
+                source: "claude"
+              });
+            }
+          }
+          currentSection = headingMatch[1].trim();
+          currentContent = [];
+          continue;
+        }
+        if (currentSection) {
+          currentContent.push(line);
+        }
+      }
+      if (currentSection && currentContent.length > 0) {
+        const sectionContent = currentContent.join("\\n").trim();
+        if (sectionContent.length > 50) {
+          entries.push({
+            type: "document",
+            title: `Claude: ${currentSection}`,
+            content: sectionContent,
+            metadata: { section: currentSection },
+            source: "claude"
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function importADR() {
+  const entries = [];
+  const adrDirs = [
+    join5(process.cwd(), "docs", "adr"),
+    join5(process.cwd(), "docs", "architecture"),
+    join5(process.cwd(), "adr")
+  ];
+  for (const adrDir of adrDirs) {
+    if (!existsSync6(adrDir)) continue;
+    try {
+      const files = readdirSync(adrDir).filter((f) => f.endsWith(".md")).map((f) => join5(adrDir, f));
+      for (const file of files) {
+        try {
+          const content = readFileSync6(file, "utf-8");
+          const title = extractADRTitle(content, basename2(file, ".md"));
+          entries.push({
+            type: "decision",
+            title,
+            content: content.trim(),
+            metadata: { file: file.replace(process.cwd(), ".") },
+            source: "adr"
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function extractADRTitle(content, fallback) {
+  const titleMatch = content.match(/^#\\s+(.+)/m);
+  if (titleMatch) return titleMatch[1].trim();
+  const titleLineMatch = content.match(/^Title:\\s+(.+)/m);
+  if (titleLineMatch) return titleLineMatch[1].trim();
+  return fallback.replace(/^\\d+-/, "").replace(/-/g, " ").replace(/\\b\\w/g, (l) => l.toUpperCase());
+}
+function importCommits(limit) {
+  try {
+    const { execSync: execSync4 } = __require("child_process");
+    const output = execSync4(
+      `git log --pretty=format:"%H|%an|%ai|%s|%b" -n ${limit}`,
+      { cwd: process.cwd(), encoding: "utf-8" }
+    ).trim();
+    if (!output) return [];
+    const entries = [];
+    const commits = output.split("\\n");
+    for (const commit of commits) {
+      const [hash, author, date, subject, body] = commit.split("|");
+      if (subject.startsWith("Merge ") || subject.length < 10) continue;
+      const keywords = ["feat", "feature", "add", "implement", "refactor", "breaking", "major"];
+      const isSignificant = keywords.some(
+        (kw) => subject.toLowerCase().includes(kw)
+      );
+      if (isSignificant) {
+        entries.push({
+          type: "session",
+          title: subject.trim(),
+          content: body?.trim() || subject.trim(),
+          metadata: {
+            commit: hash.substring(0, 8),
+            author,
+            date
+          },
+          source: "commits"
+        });
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function importPackageFiles() {
+  const entries = [];
+  const packagePath = join5(process.cwd(), "package.json");
+  if (existsSync6(packagePath)) {
+    try {
+      const pkg = JSON.parse(readFileSync6(packagePath, "utf-8"));
+      if (pkg.description) {
+        entries.push({
+          type: "document",
+          title: "Project Description",
+          content: pkg.description,
+          metadata: { source_file: "package.json" },
+          source: "package"
+        });
+      }
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      const majorDeps = Object.keys(deps).filter(
+        (dep) => ["react", "vue", "angular", "express", "fastify", "next", "nuxt"].includes(dep)
+      );
+      if (majorDeps.length > 0) {
+        entries.push({
+          type: "context",
+          title: "Tech Stack",
+          content: `Using: ${majorDeps.join(", ")}`,
+          metadata: { dependencies: majorDeps },
+          source: "package"
+        });
+      }
+    } catch {
+    }
+  }
+  const requirementsPath = join5(process.cwd(), "requirements.txt");
+  if (existsSync6(requirementsPath)) {
+    try {
+      const content = readFileSync6(requirementsPath, "utf-8");
+      const packages = content.split("\\n").filter((line) => line.trim() && !line.startsWith("#")).map((line) => line.split("==")[0].split(">=")[0].trim());
+      if (packages.length > 0) {
+        entries.push({
+          type: "context",
+          title: "Python Dependencies",
+          content: `Python packages: ${packages.slice(0, 10).join(", ")}${packages.length > 10 ? "..." : ""}`,
+          metadata: { packages: packages.slice(0, 20) },
+          source: "package"
+        });
+      }
+    } catch {
+    }
+  }
+  const cargoPath = join5(process.cwd(), "Cargo.toml");
+  if (existsSync6(cargoPath)) {
+    try {
+      const content = readFileSync6(cargoPath, "utf-8");
+      const nameMatch = content.match(/name\\s*=\\s*"([^"]+)"/);
+      const descMatch = content.match(/description\\s*=\\s*"([^"]+)"/);
+      if (descMatch) {
+        entries.push({
+          type: "document",
+          title: `Rust Project: ${nameMatch?.[1] || "Unknown"}`,
+          content: descMatch[1],
+          metadata: { source_file: "Cargo.toml" },
+          source: "package"
+        });
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function groupBy(arr, key) {
+  return arr.reduce((acc, item) => {
+    const group = String(item[key]);
+    if (!acc[group]) acc[group] = [];
+    acc[group].push(item);
+    return acc;
+  }, {});
+}
+function getTypeIcon3(type) {
+  const icons = {
+    decision: chalk6.blue("DECISION"),
+    pattern: chalk6.magenta("PATTERN"),
+    context: chalk6.green("CONTEXT"),
+    document: chalk6.cyan("DOCUMENT"),
+    session: chalk6.yellow("SESSION")
+  };
+  return icons[type] || type.toUpperCase();
+}
+
+// src/commands/hook.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync8, chmodSync, mkdirSync as mkdirSync3 } from "fs";
+import { join as join7 } from "path";
+import chalk7 from "chalk";
+
+// src/hooks/post-commit.ts
+import { execSync } from "child_process";
+var DECISION_KEYWORDS = [
+  "decided",
+  "decision",
+  "switched to",
+  "migrated to",
+  "migrated from",
+  "replaced",
+  "chose",
+  "using .+ instead of",
+  "instead of",
+  "over .+ because",
+  "picked"
+];
+var DECISION_PATTERN = new RegExp(DECISION_KEYWORDS.join("|"), "i");
+var CONTEXT_PREFIXES = ["feat", "fix", "refactor", "arch", "build", "ci", "chore"];
+var CONTEXT_PATTERN = new RegExp(`^(${CONTEXT_PREFIXES.join("|")})(\\(.+\\))?:`, "i");
+async function runPostCommit() {
+  try {
+    const db = await getProjectDb();
+    const project = await db.getProjectByPath(process.cwd());
+    if (!project) return;
+    const message = execSync("git log -1 --pretty=%B", {
+      encoding: "utf-8",
+      timeout: 1e3
+    }).trim();
+    if (!message) return;
+    const firstLine = message.split("\n")[0].trim();
+    let changedFiles = [];
+    try {
+      changedFiles = execSync("git diff-tree --no-commit-id -r --name-only HEAD", {
+        encoding: "utf-8",
+        timeout: 1e3
+      }).trim().split("\n").filter(Boolean);
+    } catch {
+    }
+    const commitHash = execSync("git rev-parse --short HEAD", {
+      encoding: "utf-8",
+      timeout: 1e3
+    }).trim();
+    const branch2 = await db.getActiveBranch(project.id);
+    if (DECISION_PATTERN.test(firstLine)) {
+      await db.createEntry({
+        projectId: project.id,
+        type: "decision",
+        title: stripConventionalPrefix(firstLine),
+        content: message,
+        metadata: {
+          source: "hooks:post-commit",
+          commit: commitHash,
+          files: changedFiles
+        },
+        status: "draft"
+      });
+      process.stdout.write(`contxt: draft saved \u2014 "${firstLine}" (decision)
+`);
+    } else if (CONTEXT_PATTERN.test(firstLine)) {
+      const existing = await db.listEntries({
+        projectId: project.id,
+        branch: branch2,
+        type: "context"
+      });
+      const activeContext = existing.find((e) => e.status === "active");
+      if (activeContext && changedFiles.length > 0) {
+        const currentFiles = activeContext.metadata.files || [];
+        const mergedFiles = Array.from(/* @__PURE__ */ new Set([...currentFiles, ...changedFiles])).slice(0, 20);
+        await db.updateEntry(activeContext.id, {
+          metadata: {
+            ...activeContext.metadata,
+            files: mergedFiles,
+            lastCommit: commitHash
+          }
+        });
+      }
+    }
+    await db.close();
+  } catch {
+  }
+}
+function stripConventionalPrefix(msg) {
+  return msg.replace(/^(feat|fix|refactor|arch|build|ci|chore)(\(.+\))?:\s*/i, "").trim();
+}
+
+// src/hooks/pre-push.ts
+import { execSync as execSync2 } from "child_process";
+import { readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
+import { join as join6 } from "path";
+async function runPrePush() {
+  try {
+    const db = await getProjectDb();
+    const project = await db.getProjectByPath(process.cwd());
+    if (!project) return;
+    let commitCount = 0;
+    let changedFiles = [];
+    try {
+      const unpushed = execSync2("git cherry -v @{upstream} 2>/dev/null || git log --oneline origin/HEAD..HEAD 2>/dev/null", {
+        encoding: "utf-8",
+        timeout: 2e3
+      }).trim();
+      commitCount = unpushed ? unpushed.split("\n").filter(Boolean).length : 0;
+    } catch {
+      try {
+        commitCount = parseInt(
+          execSync2("git rev-list --count HEAD", { encoding: "utf-8", timeout: 1e3 }).trim(),
+          10
+        );
+      } catch {
+        commitCount = 0;
+      }
+    }
+    try {
+      changedFiles = execSync2("git diff --name-only @{upstream}..HEAD 2>/dev/null", {
+        encoding: "utf-8",
+        timeout: 2e3
+      }).trim().split("\n").filter(Boolean);
+    } catch {
+    }
+    const branch2 = await db.getActiveBranch(project.id);
+    const existing = await db.listEntries({
+      projectId: project.id,
+      branch: branch2,
+      type: "context"
+    });
+    const activeContext = existing.find((e) => e.status === "active");
+    if (activeContext) {
+      await db.updateEntry(activeContext.id, {
+        metadata: {
+          ...activeContext.metadata,
+          lastPush: (/* @__PURE__ */ new Date()).toISOString(),
+          commitsPushed: (activeContext.metadata.commitsPushed || 0) + commitCount,
+          filesPushed: changedFiles
+        }
+      });
+    }
+    process.stdout.write(
+      `contxt: session updated \u2014 ${commitCount} commit${commitCount !== 1 ? "s" : ""}, ${changedFiles.length} files changed
+`
+    );
+    const configPath = join6(process.cwd(), ".contxt", "config.json");
+    if (existsSync7(configPath)) {
+      try {
+        const config = JSON.parse(readFileSync7(configPath, "utf-8"));
+        if (config.hooks?.auto_push_on_push) {
+          process.stdout.write("contxt: syncing to cloud...\n");
+          execSync2("contxt push --quiet 2>/dev/null", {
+            timeout: 1e4,
+            encoding: "utf-8"
+          });
+          process.stdout.write("contxt: \u2713 synced\n");
+        }
+      } catch {
+      }
+    }
+    await db.close();
+  } catch {
+  }
+}
+
+// src/hooks/post-checkout.ts
+import { execSync as execSync3 } from "child_process";
+async function runPostCheckout() {
+  try {
+    const isBranchCheckout = process.argv[4] === "1";
+    if (!isBranchCheckout) return;
+    const db = await getProjectDb();
+    const project = await db.getProjectByPath(process.cwd());
+    if (!project) return;
+    const gitBranch = execSync3("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8",
+      timeout: 1e3
+    }).trim();
+    const branches = await db.listBranches(project.id);
+    const contxtBranch = branches.find((b) => b.name === gitBranch);
+    if (contxtBranch) {
+      await db.switchBranch(project.id, gitBranch);
+      const entryCount = await db.countEntries({ projectId: project.id, branch: gitBranch });
+      process.stdout.write(`contxt: switched to branch ${gitBranch} (${entryCount} entries)
+`);
+    } else {
+      const currentBranch = await db.getActiveBranch(project.id);
+      process.stdout.write(`contxt: no memory branch for ${gitBranch}, using ${currentBranch}
+`);
+    }
+    await db.close();
+  } catch {
+  }
+}
+
+// src/hooks/prepare-commit-msg.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+async function runPrepareCommitMsg() {
+  try {
+    const commitMsgFile = process.argv[4];
+    const source = process.argv[5];
+    if (source && source !== "template" && source !== "") return;
+    if (!commitMsgFile) return;
+    const db = await getProjectDb();
+    const project = await db.getProjectByPath(process.cwd());
+    if (!project) return;
+    const branch2 = await db.getActiveBranch(project.id);
+    const entries = await db.listEntries({
+      projectId: project.id,
+      branch: branch2
+    });
+    const context2 = entries.find((e) => e.type === "context" && e.status === "active");
+    const recentDecisions = entries.filter((e) => e.type === "decision" && e.status === "active").sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()).slice(0, 3);
+    if (!context2 && recentDecisions.length === 0) {
+      await db.close();
+      return;
+    }
+    const lines = [
+      "",
+      "# --- Contxt ---"
+    ];
+    if (context2) {
+      const feature = context2.metadata.feature || context2.content.split("\n")[0];
+      lines.push(`# Feature: ${feature}`);
+      if (context2.metadata.blockers?.length) {
+        lines.push(`# Blockers: ${context2.metadata.blockers.join(", ")}`);
+      }
+    }
+    if (recentDecisions.length > 0) {
+      const decisionList = recentDecisions.map((d) => d.title).join(", ");
+      lines.push(`# Recent decisions: ${decisionList}`);
+    }
+    const draftCount = entries.filter((e) => e.status === "draft").length;
+    if (draftCount > 0) {
+      lines.push(`# ${draftCount} drafts pending \u2014 run \`contxt review\``);
+    }
+    lines.push("#");
+    const existing = readFileSync8(commitMsgFile, "utf-8");
+    writeFileSync4(commitMsgFile, existing + lines.join("\n") + "\n", "utf-8");
+    await db.close();
+  } catch {
+  }
+}
+
+// src/commands/hook.ts
+var CONTXT_BLOCK_START = "# --- contxt hook start ---";
+var CONTXT_BLOCK_END = "# --- contxt hook end ---";
+var ALL_HOOKS = ["post-commit", "pre-push", "post-checkout", "prepare-commit-msg"];
+async function installCommand(options = {}) {
+  const gitHooksDir = join7(process.cwd(), ".git", "hooks");
+  if (!existsSync8(join7(process.cwd(), ".git"))) {
+    console.error(chalk7.red("Not a git repository."));
+    process.exit(1);
+  }
+  mkdirSync3(gitHooksDir, { recursive: true });
+  const hooksToInstall = options.hooks ? options.hooks.split(",").map((h) => h.trim()) : [...ALL_HOOKS];
+  let installed = 0;
+  let updated = 0;
+  for (const hookName of hooksToInstall) {
+    const hookPath = join7(gitHooksDir, hookName);
+    const contxtLine = `contxt hook run ${hookName} "$@"`;
+    const contxtBlock = `${CONTXT_BLOCK_START}
+${contxtLine}
+${CONTXT_BLOCK_END}`;
+    if (existsSync8(hookPath)) {
+      const content = readFileSync9(hookPath, "utf-8");
+      if (content.includes(CONTXT_BLOCK_START)) {
+        const updated_content = content.replace(
+          new RegExp(`${escapeRegex(CONTXT_BLOCK_START)}[\\s\\S]*?${escapeRegex(CONTXT_BLOCK_END)}`),
+          contxtBlock
+        );
+        writeFileSync5(hookPath, updated_content, "utf-8");
+        updated++;
+      } else {
+        const newContent = content.trimEnd() + "\n\n" + contxtBlock + "\n";
+        writeFileSync5(hookPath, newContent, "utf-8");
+        installed++;
+      }
+    } else {
+      const newContent = `#!/bin/sh
+
+${contxtBlock}
+`;
+      writeFileSync5(hookPath, newContent, "utf-8");
+      installed++;
+    }
+    chmodSync(hookPath, "755");
+    console.log(chalk7.green("\u2713"), `${hookName}`);
+  }
+  console.log("");
+  if (installed > 0) console.log(chalk7.green(`Installed ${installed} hook${installed !== 1 ? "s" : ""}.`));
+  if (updated > 0) console.log(chalk7.yellow(`Updated ${updated} existing hook${updated !== 1 ? "s" : ""}.`));
+  console.log("");
+  console.log(chalk7.gray("Hooks will capture context from your git workflow automatically."));
+}
+async function uninstallCommand(options = {}) {
+  const gitHooksDir = join7(process.cwd(), ".git", "hooks");
+  if (!existsSync8(join7(process.cwd(), ".git"))) {
+    console.error(chalk7.red("Not a git repository."));
+    process.exit(1);
+  }
+  const hooksToRemove = options.hooks ? options.hooks.split(",").map((h) => h.trim()) : [...ALL_HOOKS];
+  let removed = 0;
+  for (const hookName of hooksToRemove) {
+    const hookPath = join7(gitHooksDir, hookName);
+    if (!existsSync8(hookPath)) continue;
+    const content = readFileSync9(hookPath, "utf-8");
+    if (!content.includes(CONTXT_BLOCK_START)) continue;
+    const cleaned = content.replace(
+      new RegExp(`\\n*${escapeRegex(CONTXT_BLOCK_START)}[\\s\\S]*?${escapeRegex(CONTXT_BLOCK_END)}\\n*`),
+      "\n"
+    ).trim();
+    if (cleaned === "#!/bin/sh" || cleaned === "") {
+      writeFileSync5(hookPath, "#!/bin/sh\n", "utf-8");
+    } else {
+      writeFileSync5(hookPath, cleaned + "\n", "utf-8");
+    }
+    removed++;
+    console.log(chalk7.gray("\u2717"), hookName);
+  }
+  if (removed > 0) {
+    console.log("");
+    console.log(chalk7.green(`Removed ${removed} hook${removed !== 1 ? "s" : ""}.`));
+  } else {
+    console.log(chalk7.gray("No Contxt hooks found to remove."));
+  }
+}
+async function statusCommand2() {
+  const gitHooksDir = join7(process.cwd(), ".git", "hooks");
+  if (!existsSync8(join7(process.cwd(), ".git"))) {
+    console.error(chalk7.red("Not a git repository."));
+    process.exit(1);
+  }
+  console.log("");
+  console.log(chalk7.bold("Git Hook Status"));
+  console.log("");
+  for (const hookName of ALL_HOOKS) {
+    const hookPath = join7(gitHooksDir, hookName);
+    const fileExists = existsSync8(hookPath);
+    let isInstalled = false;
+    if (fileExists) {
+      const content = readFileSync9(hookPath, "utf-8");
+      isInstalled = content.includes(CONTXT_BLOCK_START);
+    }
+    const statusIcon = isInstalled ? chalk7.green("\u2713") : chalk7.gray("\u25CB");
+    const label = isInstalled ? chalk7.green(hookName) : chalk7.gray(hookName);
+    const note = !fileExists ? chalk7.gray(" (no hook file)") : isInstalled ? chalk7.gray(" installed") : chalk7.yellow(" not installed");
+    console.log(`  ${statusIcon} ${label}${note}`);
+  }
+  console.log("");
+  const installedCount = ALL_HOOKS.filter((h) => {
+    const hookPath = join7(gitHooksDir, h);
+    return existsSync8(hookPath) && readFileSync9(hookPath, "utf-8").includes(CONTXT_BLOCK_START);
+  }).length;
+  if (installedCount === 0) {
+    console.log(chalk7.cyan(`Run ${chalk7.bold("contxt hook install")} to enable automatic context capture.`));
+  }
+}
+async function runCommand(hookName) {
+  switch (hookName) {
+    case "post-commit":
+      await runPostCommit();
+      break;
+    case "pre-push":
+      await runPrePush();
+      break;
+    case "post-checkout":
+      await runPostCheckout();
+      break;
+    case "prepare-commit-msg":
+      await runPrepareCommitMsg();
+      break;
+    default:
+  }
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var hookCommand = {
+  install: installCommand,
+  uninstall: uninstallCommand,
+  status: statusCommand2,
+  run: runCommand
+};
+
+// src/commands/watch.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync9, unlinkSync } from "fs";
+import { join as join8, relative as relative2 } from "path";
+import { spawn } from "child_process";
+import chalk8 from "chalk";
+import chokidar from "chokidar";
+import { parseFile as parseFile2, scanCommentToEntry as scanCommentToEntry2 } from "@mycontxt/core";
+var PID_FILE = ".contxt/.watch.pid";
+var LOG_FILE = ".contxt/watch.log";
+var SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEBOUNCE_MS = 3e4;
+async function startCommand(options = {}) {
+  if (options.daemon) {
+    return startDaemon();
+  }
+  return runWatcher();
+}
+async function stopCommand() {
+  const pidFile = join8(process.cwd(), PID_FILE);
+  if (!existsSync9(pidFile)) {
+    console.log(chalk8.gray("No watch daemon running."));
+    return;
+  }
+  const pid = parseInt(readFileSync10(pidFile, "utf-8").trim(), 10);
+  try {
+    process.kill(pid, "SIGTERM");
+    unlinkSync(pidFile);
+    console.log(chalk8.green("Watch daemon stopped."));
+  } catch {
+    console.log(chalk8.yellow("Daemon not found \u2014 removing stale PID file."));
+    unlinkSync(pidFile);
+  }
+}
+async function statusCommand3() {
+  const pidFile = join8(process.cwd(), PID_FILE);
+  if (!existsSync9(pidFile)) {
+    console.log(chalk8.gray("Watch daemon: not running"));
+    return;
+  }
+  const pid = parseInt(readFileSync10(pidFile, "utf-8").trim(), 10);
+  try {
+    process.kill(pid, 0);
+    console.log(chalk8.green(`Watch daemon: running (PID ${pid})`));
+  } catch {
+    console.log(chalk8.yellow("Watch daemon: stale PID file (process not found)"));
+    unlinkSync(pidFile);
+  }
+}
+function startDaemon() {
+  const pidFile = join8(process.cwd(), PID_FILE);
+  if (existsSync9(pidFile)) {
+    const pid = parseInt(readFileSync10(pidFile, "utf-8").trim(), 10);
+    try {
+      process.kill(pid, 0);
+      console.log(chalk8.yellow(`Watch daemon already running (PID ${pid}).`));
+      return;
+    } catch {
+    }
+  }
+  const logPath = join8(process.cwd(), LOG_FILE);
+  const logStream = __require("fs").openSync(logPath, "a");
+  const child = spawn(process.execPath, [process.argv[1], "watch"], {
+    env: { ...process.env, CONTXT_WATCH_DAEMON: "1" },
+    detached: true,
+    stdio: ["ignore", logStream, logStream],
+    cwd: process.cwd()
+  });
+  child.unref();
+  writeFileSync6(pidFile, String(child.pid), "utf-8");
+  console.log(chalk8.green(`Watch daemon started (PID ${child.pid}).`));
+  console.log(chalk8.gray(`Logs: ${logPath}`));
+}
+async function runWatcher() {
+  const cwd = process.cwd();
+  const isDaemon = process.env.CONTXT_WATCH_DAEMON === "1";
+  const db = await getProjectDb(cwd);
+  const project = await db.getProjectByPath(cwd);
+  if (!project) {
+    if (!isDaemon) console.error(chalk8.red("Not a Contxt project."));
+    return;
+  }
+  const branch2 = await db.getActiveBranch(project.id);
+  if (!isDaemon) {
+    console.log(chalk8.bold(`contxt watch`) + ` \u2014 monitoring ${project.name} (${branch2})`);
+    console.log("");
+  }
+  const pendingFiles = /* @__PURE__ */ new Set();
+  let flushTimer = null;
+  let sessionStart = null;
+  let lastActivityAt = null;
+  let sessionTimer = null;
+  const watchPatterns = [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.jsx",
+    "**/*.py",
+    "**/*.rb",
+    "**/*.go",
+    "**/*.rs",
+    "**/*.sql"
+  ];
+  const ignored = [
+    /(^|[/\\])\../,
+    // dotfiles
+    /node_modules/,
+    /\.contxt/,
+    /dist/,
+    /build/,
+    /\.next/,
+    /\.min\.js$/
+  ];
+  const watcher = chokidar.watch(watchPatterns, {
+    cwd,
+    ignored,
+    ignoreInitial: true,
+    persistent: true,
+    usePolling: false,
+    interval: 1e3
+  });
+  const rulesPath = join8(cwd, ".contxt", "rules.md");
+  const rulesWatcher = chokidar.watch(rulesPath, { ignoreInitial: true });
+  const gitHeadPath = join8(cwd, ".git", "HEAD");
+  const gitWatcher = chokidar.watch(gitHeadPath, { ignoreInitial: true });
+  watcher.on("change", (filePath) => {
+    pendingFiles.add(filePath);
+    touchSession();
+    scheduleFlush();
+  });
+  watcher.on("add", (filePath) => {
+    pendingFiles.add(filePath);
+    touchSession();
+    scheduleFlush();
+  });
+  rulesWatcher.on("change", async () => {
+    log("rules", "rules.md changed \u2014 syncing...");
+    try {
+      const { parseRulesFile: parseRulesFile2 } = await import("@mycontxt/core");
+      const content = readFileSync10(rulesPath, "utf-8");
+      const parsed = parseRulesFile2(content);
+      let synced = 0;
+      const existing = await db.listEntries({ projectId: project.id, branch: branch2 });
+      const byTitle = new Map(existing.map((e) => [e.title, e]));
+      for (const decision2 of parsed.decisions) {
+        const ex = byTitle.get(decision2.title);
+        if (!ex) {
+          await db.createEntry({ projectId: project.id, type: "decision", title: decision2.title, content: decision2.content, metadata: decision2.metadata, status: "active" });
+          synced++;
+        } else if (ex.content !== decision2.content) {
+          await db.updateEntry(ex.id, { content: decision2.content });
+          synced++;
+        }
+      }
+      log("rules", `synced ${synced} update${synced !== 1 ? "s" : ""}`);
+    } catch {
+      log("rules", "sync failed");
+    }
+  });
+  gitWatcher.on("change", async () => {
+    try {
+      const headContent = readFileSync10(gitHeadPath, "utf-8").trim();
+      const branchMatch = headContent.match(/^ref: refs\/heads\/(.+)$/);
+      if (!branchMatch) return;
+      const newBranch = branchMatch[1];
+      const currentBranch = await db.getActiveBranch(project.id);
+      if (newBranch === currentBranch) return;
+      const branches = await db.listBranches(project.id);
+      const has = branches.some((b) => b.name === newBranch);
+      if (has) {
+        await db.switchBranch(project.id, newBranch);
+        const count = await db.countEntries({ projectId: project.id, branch: newBranch });
+        log("branch", `switched to ${newBranch} (${count} entries)`);
+      }
+    } catch {
+    }
+  });
+  async function flush() {
+    if (pendingFiles.size === 0) return;
+    const files = Array.from(pendingFiles);
+    pendingFiles.clear();
+    try {
+      const entries = await db.listEntries({ projectId: project.id, branch: branch2, type: "context" });
+      const activeCtx = entries.find((e) => e.status === "active");
+      if (activeCtx) {
+        const currentFiles = activeCtx.metadata.files || [];
+        const relFiles = files.map((f) => relative2(cwd, join8(cwd, f)));
+        const merged = Array.from(/* @__PURE__ */ new Set([...currentFiles, ...relFiles])).slice(0, 30);
+        await db.updateEntry(activeCtx.id, { metadata: { ...activeCtx.metadata, files: merged } });
+      }
+    } catch {
+    }
+    let newDrafts = 0;
+    for (const file of files) {
+      try {
+        const absPath = join8(cwd, file);
+        if (!existsSync9(absPath)) continue;
+        const content = readFileSync10(absPath, "utf-8");
+        const comments = parseFile2(content, file);
+        if (comments.length === 0) continue;
+        const existing = await db.listEntries({ projectId: project.id, branch: branch2 });
+        const hashes = new Set(existing.filter((e) => e.metadata.hash).map((e) => e.metadata.hash));
+        for (const comment of comments) {
+          if (!hashes.has(comment.hash)) {
+            const entry = scanCommentToEntry2(comment, project.id);
+            await db.createEntry({ projectId: project.id, type: entry.type, title: entry.title, content: entry.content, metadata: entry.metadata, status: "draft" });
+            newDrafts++;
+          }
+        }
+      } catch {
+      }
+    }
+    log("files", `${files.length} file${files.length !== 1 ? "s" : ""} ${newDrafts > 0 ? `\xB7 +${newDrafts} draft${newDrafts !== 1 ? "s" : ""}` : ""}`);
+  }
+  function scheduleFlush() {
+    if (flushTimer) clearTimeout(flushTimer);
+    flushTimer = setTimeout(flush, DEBOUNCE_MS);
+  }
+  function touchSession() {
+    const now = /* @__PURE__ */ new Date();
+    lastActivityAt = now;
+    if (!sessionStart) {
+      sessionStart = now;
+      log("session", `started`);
+    }
+    if (sessionTimer) clearTimeout(sessionTimer);
+    sessionTimer = setTimeout(endSession, SESSION_TIMEOUT_MS);
+  }
+  function endSession() {
+    if (!sessionStart || !lastActivityAt) return;
+    const durationMin = Math.round((lastActivityAt.getTime() - sessionStart.getTime()) / 6e4);
+    log("session", `ended \u2014 ${durationMin} min`);
+    sessionStart = null;
+    lastActivityAt = null;
+  }
+  function log(type, message) {
+    const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" });
+    const line = `${time}  ${type.padEnd(8)} ${message}`;
+    if (!isDaemon) {
+      console.log(`  ${chalk8.gray(time)}  ${chalk8.cyan(type.padEnd(8))} ${message}`);
+    } else {
+      try {
+        __require("fs").appendFileSync(join8(cwd, LOG_FILE), line + "\n");
+      } catch {
+      }
+    }
+  }
+  const shutdown = async () => {
+    if (flushTimer) clearTimeout(flushTimer);
+    await flush();
+    watcher.close();
+    rulesWatcher.close();
+    gitWatcher.close();
+    await db.close();
+    const pidFile = join8(cwd, PID_FILE);
+    if (existsSync9(pidFile)) unlinkSync(pidFile);
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  if (!isDaemon) {
+    console.log(chalk8.gray("Watching for file changes. Ctrl+C to stop.\n"));
+  }
+}
+var watchCommand = {
+  start: startCommand,
+  stop: stopCommand,
+  status: statusCommand3
+};
+
+// src/bin/contxt.ts
+var program = new Command();
+program.name("contxt").description("GitHub for AI Context - Persistent memory for AI coding agents").version("0.1.0");
+program.command("init").description("Initialize a Contxt project in the current directory").option("-n, --name <name>", "Project name").action(initCommand);
+program.command("status").description("Show project status and memory summary").action(statusCommand);
+var decision = program.command("decision").description("Manage architectural decisions");
+decision.command("add").description("Add a new decision").requiredOption("-t, --title <title>", "Decision title").requiredOption("-r, --rationale <rationale>", "Decision rationale").option("-a, --alternatives <alternatives...>", "Alternative approaches considered").option("-c, --consequences <consequences...>", "Consequences of this decision").option("--tags <tags...>", "Tags for categorization").action(decisionCommand.add);
+decision.command("list").description("List all decisions").option("-b, --branch <branch>", "Filter by branch").action(decisionCommand.list);
+decision.command("show <id>").description("Show a specific decision").action(decisionCommand.show);
+var pattern = program.command("pattern").description("Manage code patterns and conventions");
+pattern.command("add").description("Add a new pattern").requiredOption("-t, --title <title>", "Pattern title").requiredOption("-c, --content <content>", "Pattern content/code").option("--category <category>", "Pattern category").option("--tags <tags...>", "Tags for categorization").action(patternCommand.add);
+pattern.command("list").description("List all patterns").option("-b, --branch <branch>", "Filter by branch").action(patternCommand.list);
+pattern.command("show <id>").description("Show a specific pattern").action(patternCommand.show);
+var context = program.command("context").description("Manage project working context");
+context.command("set").description("Set current working context").option("-f, --feature <feature>", "Current feature being worked on").option("-b, --blockers <blockers...>", "Current blockers").option("-n, --next <steps...>", "Next steps").option("--files <files...>", "Active files").action(contextCommand.set);
+context.command("show").description("Show current context").action(contextCommand.show);
+context.command("clear").description("Clear current context").action(contextCommand.clear);
+var doc = program.command("doc").description("Manage documentation and reference materials");
+doc.command("add").description("Add a new document").requiredOption("-t, --title <title>", "Document title").option("-c, --content <content>", "Document content").option("-f, --file <file>", "Read content from file").option("-u, --url <url>", "Source URL").option("--tags <tags...>", "Tags for categorization").action(docCommand.add);
+doc.command("list").description("List all documents").option("-b, --branch <branch>", "Filter by branch").action(docCommand.list);
+doc.command("show <id>").description("Show a specific document").action(docCommand.show);
+var session = program.command("session").description("Manage development sessions");
+session.command("start").description("Start a new development session").requiredOption("-f, --feature <feature>", "Feature being worked on").option("-d, --description <description>", "Session description").action(sessionCommand.start);
+session.command("end").description("End the current session").option("-s, --summary <summary>", "Session summary").action(sessionCommand.end);
+session.command("list").description("List all sessions").option("-b, --branch <branch>", "Filter by branch").action(sessionCommand.list);
+session.command("current").description("Show current active session").action(sessionCommand.current);
+program.command("search <query>").description("Search memory entries").option("-b, --branch <branch>", "Filter by branch").option("-t, --type <type>", "Filter by type (decision, pattern, context, document, session)").option("-l, --limit <limit>", "Limit number of results", parseInt).action(searchCommand);
+program.command("export").description("Export memory entries to JSON").option("-o, --output <file>", "Output file (defaults to stdout)").option("-b, --branch <branch>", "Export specific branch").action(exportCommand);
+program.command("import").description("Import memory entries from JSON").requiredOption("-f, --file <file>", "Input file to import").option("-m, --merge", "Merge with existing entries (default: replace)").action(importCommand);
+var auth = program.command("auth").description("Manage authentication");
+auth.command("login").description("Authenticate with GitHub or email").option("-e, --email <email>", "Login with magic link (email)").action(authCommand.login);
+auth.command("logout").description("Logout from Contxt").action(authCommand.logout);
+auth.command("status").description("Check authentication status").action(authCommand.status);
+program.command("push").description("Push local changes to cloud").option("-f, --force", "Force push (override conflicts)").option("-d, --dry-run", "Show what would be pushed without actually pushing").action(syncCommand.push);
+program.command("pull").description("Pull remote changes to local").option("-f, --force", "Force pull (override conflicts)").option("-d, --dry-run", "Show what would be pulled without actually pulling").action(syncCommand.pull);
+program.command("sync").description("Full bidirectional sync (pull + push)").option("-f, --force", "Force sync (override conflicts)").option("-d, --dry-run", "Show what would be synced without actually syncing").action(syncCommand.sync);
+var branch = program.command("branch").description("Manage branches");
+branch.command("create <name>").description("Create a new branch").option("-f, --from <branch>", "Create from specific branch").action(branchCommand.create);
+branch.command("list").description("List all branches").action(branchCommand.list);
+branch.command("switch <name>").description("Switch to a different branch").action(branchCommand.switch);
+branch.command("delete <name>").description("Delete a branch").action(branchCommand.delete);
+branch.command("merge <source>").description("Merge a branch into current branch").action(branchCommand.merge);
+var history = program.command("history").description("View and restore version history");
+history.command("show <entry-id>").description("Show version history for an entry").action(historyCommand.show);
+history.command("restore <entry-id>").description("Restore an entry to a previous version").requiredOption("-v, --version <version>", "Version number to restore", parseInt).action(historyCommand.restore);
+program.command("load").description("Generate context payload for AI prompts").option("-t, --task <description>", "Task-based context (smart relevance ranking)").option("-f, --files <files...>", "File-based context (filter by file mentions)").option("-a, --all", "All context (everything, sorted by recency)").option("--max-tokens <tokens>", "Maximum tokens for context", parseInt).option("--type <type>", "Filter by entry type (decision, pattern, etc.)").option("-s, --summary", "Show context summary instead of full context").action(loadCommand);
+program.command("scan").description("Scan codebase for tagged comments (@decision, @pattern, @context)").option("--path <path>", "Specific directory to scan").option("--dry-run", "Show what would be captured without saving").option("--auto-confirm", "Skip draft queue, save directly as active").action(scanCommand);
+program.command("review").description("Review and confirm draft entries").option("--source <source>", "Filter by source (scan, hooks, mcp, import)").option("--confirm-all", "Confirm all pending drafts").option("--discard-all", "Discard all pending drafts").option("--count", "Show draft count only").action(reviewCommand);
+var rules = program.command("rules").description("Manage .contxt/rules.md file");
+rules.command("sync").description("Sync rules.md into memory store").option("--dry-run", "Show what would be synced without saving").option("-f, --force", "Force sync even if conflicts exist").action(rulesCommand.sync);
+rules.command("generate").description("Generate rules.md from memory store").option("--dry-run", "Show what would be generated without writing").option("-f, --force", "Overwrite existing rules.md").action(rulesCommand.generate);
+rules.command("diff").description("Show differences between rules.md and memory").action(rulesCommand.diff);
+program.command("capture").description("Extract context from existing project files").option("--source <source>", "Source to capture from (readme, cursor, claude, adr, commits, package, all)").option("--dry-run", "Show what would be captured without saving").option("--auto-confirm", "Skip draft queue, save directly as active").option("--limit <limit>", "Limit number of commits to scan (default: 50)", parseInt).action(captureCommand);
+var hook = program.command("hook").description("Manage git hooks for automatic context capture");
+hook.command("install").description("Install git hooks").option("--hooks <hooks>", "Comma-separated hooks to install (post-commit, pre-push, post-checkout, prepare-commit-msg)").action(hookCommand.install);
+hook.command("uninstall").description("Uninstall git hooks").option("--hooks <hooks>", "Comma-separated hooks to remove").action(hookCommand.uninstall);
+hook.command("status").description("Show installed hook status").action(hookCommand.status);
+hook.command("run <hook-name>").description("Run a specific hook (called internally by git)").action(hookCommand.run);
+program.command("watch").description("Start background file watcher for passive context capture").option("--daemon", "Run as background process").action(watchCommand.start);
+program.command("watch:stop").description("Stop the background watch daemon").action(watchCommand.stop);
+program.command("watch:status").description("Show watch daemon status").action(watchCommand.status);
+program.parse();
+//# sourceMappingURL=contxt.js.map