conare 0.0.1

package/dist/index.js

@@ -0,0 +1,1094 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/detect.ts
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+function countJsonlFiles(dir) {
+  let count = 0;
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        count += countJsonlFiles(join(dir, entry.name));
+      } else if (entry.name.endsWith(".jsonl")) {
+        count++;
+      }
+    }
+  } catch {}
+  return count;
+}
+function detect() {
+  const home = homedir();
+  const tools = [];
+  const claudeDir = join(home, ".claude", "projects");
+  if (existsSync(claudeDir)) {
+    const sessionCount = countJsonlFiles(claudeDir);
+    tools.push({
+      name: "Claude Code",
+      available: sessionCount > 0,
+      path: claudeDir,
+      sessionCount
+    });
+  } else {
+    tools.push({ name: "Claude Code", available: false, path: claudeDir, sessionCount: 0 });
+  }
+  const codexHistory = join(home, ".codex", "history.jsonl");
+  const codexSessions = join(home, ".codex", "sessions");
+  if (existsSync(codexHistory) || existsSync(codexSessions)) {
+    let sessionCount = 0;
+    if (existsSync(codexHistory)) {
+      try {
+        const { readFileSync } = __require("node:fs");
+        const lines = readFileSync(codexHistory, "utf-8").split(`
+`).filter(Boolean);
+        const sessions = new Set(lines.map((l) => {
+          try {
+            return JSON.parse(l).session_id;
+          } catch {
+            return null;
+          }
+        }));
+        sessions.delete(null);
+        sessionCount = sessions.size;
+      } catch {}
+    }
+    tools.push({
+      name: "Codex",
+      available: true,
+      path: existsSync(codexHistory) ? codexHistory : codexSessions,
+      sessionCount
+    });
+  } else {
+    tools.push({ name: "Codex", available: false, path: codexHistory, sessionCount: 0 });
+  }
+  const os = platform();
+  let cursorDbPath;
+  if (os === "darwin") {
+    cursorDbPath = join(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+  } else if (os === "win32") {
+    cursorDbPath = join(process.env.APPDATA || join(home, "AppData", "Roaming"), "Cursor", "User", "globalStorage", "state.vscdb");
+  } else {
+    cursorDbPath = join(home, ".config", "Cursor", "User", "globalStorage", "state.vscdb");
+  }
+  tools.push({
+    name: "Cursor",
+    available: existsSync(cursorDbPath),
+    path: cursorDbPath,
+    sessionCount: 0
+  });
+  return tools;
+}
+
+// src/ingest/claude.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join3, basename } from "node:path";
+import { homedir as homedir3 } from "node:os";
+
+// src/ingest/shared.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+var MANIFEST_PATH = join2(homedir2(), ".conare", "ingested.json");
+function cleanText(raw) {
+  let text = raw;
+  text = text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "");
+  text = text.replace(/<attached-context[\s\S]*?<\/attached-context>/g, "");
+  return text.trim();
+}
+function getIngested() {
+  try {
+    if (existsSync2(MANIFEST_PATH)) {
+      return JSON.parse(readFileSync(MANIFEST_PATH, "utf-8"));
+    }
+  } catch {}
+  return {};
+}
+function markIngested(source, sessionIds) {
+  const manifest = getIngested();
+  const existing = new Set(manifest[source] || []);
+  for (const id of sessionIds)
+    existing.add(id);
+  manifest[source] = [...existing];
+  const dir = join2(homedir2(), ".conare");
+  if (!existsSync2(dir))
+    mkdirSync(dir, { recursive: true });
+  writeFileSync(MANIFEST_PATH, JSON.stringify(manifest, null, 2));
+}
+function isIngested(source, sessionId) {
+  const manifest = getIngested();
+  return (manifest[source] || []).includes(sessionId);
+}
+function clearIngested(source) {
+  const manifest = getIngested();
+  if (source) {
+    delete manifest[source];
+  } else {
+    for (const key of Object.keys(manifest))
+      delete manifest[key];
+  }
+  const dir = join2(homedir2(), ".conare");
+  if (!existsSync2(dir))
+    mkdirSync(dir, { recursive: true });
+  writeFileSync(MANIFEST_PATH, JSON.stringify(manifest, null, 2));
+}
+
+// src/ingest/claude.ts
+var MAX_CONTENT = 48000;
+var MIN_TURN_LEN = 50;
+function extractText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join(`
+`);
+}
+function parseSession(lines) {
+  const messages = [];
+  let date = null;
+  for (const line of lines) {
+    if (!line.trim())
+      continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!date && obj.timestamp)
+      date = obj.timestamp.slice(0, 10);
+    if (obj.type === "user" || obj.type === "assistant") {
+      const text = cleanText(extractText(obj.message?.content));
+      if (text.length >= MIN_TURN_LEN) {
+        messages.push({ role: obj.type, text });
+      }
+    }
+  }
+  const turns = [];
+  for (let i = 0;i < messages.length - 1; i++) {
+    if (messages[i].role === "user" && messages[i + 1].role === "assistant") {
+      turns.push({ user: messages[i].text, assistant: messages[i + 1].text });
+      i++;
+    }
+  }
+  return { turns, date };
+}
+function ingestClaude() {
+  const projectsDir = join3(homedir3(), ".claude", "projects");
+  const memories = [];
+  const sessionIds = [];
+  let skipped = 0;
+  let projectDirs;
+  try {
+    projectDirs = readdirSync2(projectsDir);
+  } catch {
+    return { memories, sessionIds, skipped };
+  }
+  for (const projDir of projectDirs) {
+    const projPath = join3(projectsDir, projDir);
+    const project = projDir.replace(/^-Users-[^-]+-/, "").replace(/-/g, "/") || projDir;
+    let files;
+    try {
+      files = readdirSync2(projPath).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const sessionId = basename(file, ".jsonl");
+      if (isIngested("claude", sessionId)) {
+        skipped++;
+        continue;
+      }
+      const raw = readFileSync2(join3(projPath, file), "utf-8");
+      const { turns, date } = parseSession(raw.split(`
+`));
+      if (turns.length === 0) {
+        skipped++;
+        continue;
+      }
+      const header = `# Chat: ${project}${date ? ` | ${date}` : ""}`;
+      const body = turns.map((t) => {
+        const q = t.user.length > 300 ? t.user.slice(0, 300) + "..." : t.user;
+        return `## Q: ${q}
+
+${t.assistant}`;
+      }).join(`
+
+---
+
+`);
+      let content = `${header}
+
+${body}`;
+      if (content.length > MAX_CONTENT)
+        content = content.slice(0, MAX_CONTENT) + `
+
+[truncated]`;
+      memories.push({
+        content,
+        containerTag: "claude-chats",
+        metadata: { source: "claude-code", sessionId, project, date: date || "unknown" }
+      });
+      sessionIds.push(sessionId);
+    }
+  }
+  return { memories, sessionIds, skipped };
+}
+
+// src/ingest/codex.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync3 } from "node:fs";
+import { join as join4, basename as basename2 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+var MAX_CONTENT2 = 48000;
+function ingestCodex() {
+  const memories = [];
+  const sessionIds = [];
+  let skipped = 0;
+  const historyPath = join4(homedir4(), ".codex", "history.jsonl");
+  if (existsSync3(historyPath)) {
+    try {
+      const lines = readFileSync3(historyPath, "utf-8").split(`
+`).filter(Boolean);
+      const sessions = new Map;
+      for (const line of lines) {
+        try {
+          const obj = JSON.parse(line);
+          if (!obj.session_id || !obj.text)
+            continue;
+          if (!sessions.has(obj.session_id))
+            sessions.set(obj.session_id, []);
+          sessions.get(obj.session_id).push({ ts: obj.ts, text: obj.text });
+        } catch {
+          continue;
+        }
+      }
+      for (const [sessionId, entries] of sessions) {
+        if (isIngested("codex", sessionId)) {
+          skipped++;
+          continue;
+        }
+        entries.sort((a, b) => a.ts - b.ts);
+        const date = new Date(entries[0].ts * 1000).toISOString().slice(0, 10);
+        const body = entries.map((e) => {
+          const text = cleanText(e.text);
+          return text.length > 300 ? text.slice(0, 300) + "..." : text;
+        }).filter(Boolean).join(`
+
+---
+
+`);
+        let content = `# Codex Chat | ${date}
+
+${body}`;
+        if (content.length > MAX_CONTENT2)
+          content = content.slice(0, MAX_CONTENT2) + `
+
+[truncated]`;
+        if (content.length < 100) {
+          skipped++;
+          continue;
+        }
+        memories.push({
+          content,
+          containerTag: "codex-chats",
+          metadata: { source: "codex", sessionId, date }
+        });
+        sessionIds.push(sessionId);
+      }
+    } catch {}
+  }
+  const sessionsDir = join4(homedir4(), ".codex", "sessions");
+  if (existsSync3(sessionsDir)) {
+    try {
+      walkCodexSessions(sessionsDir, memories, sessionIds, skipped);
+    } catch {}
+  }
+  return { memories, sessionIds, skipped };
+}
+function walkCodexSessions(dir, memories, sessionIds, skipped) {
+  try {
+    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        walkCodexSessions(join4(dir, entry.name), memories, sessionIds, skipped);
+      } else if (entry.name.endsWith(".jsonl")) {
+        const sessionId = basename2(entry.name, ".jsonl");
+        if (isIngested("codex", sessionId) || sessionIds.includes(sessionId))
+          continue;
+        try {
+          const lines = readFileSync3(join4(dir, entry.name), "utf-8").split(`
+`).filter(Boolean);
+          const turns = [];
+          let date = null;
+          for (const line of lines) {
+            try {
+              const obj = JSON.parse(line);
+              if (!date && obj.timestamp)
+                date = obj.timestamp.slice(0, 10);
+              if (obj.type === "response_item" && obj.payload?.role === "user") {
+                const content2 = obj.payload.content;
+                if (Array.isArray(content2)) {
+                  for (const block of content2) {
+                    if (block.type === "input_text" && block.text) {
+                      const text = cleanText(block.text);
+                      if (text.length > 50)
+                        turns.push(text);
+                    }
+                  }
+                }
+              }
+            } catch {
+              continue;
+            }
+          }
+          if (turns.length === 0)
+            continue;
+          const body = turns.map((t) => t.length > 500 ? t.slice(0, 500) + "..." : t).join(`
+
+---
+
+`);
+          let content = `# Codex Session | ${date || "unknown"}
+
+${body}`;
+          if (content.length > MAX_CONTENT2)
+            content = content.slice(0, MAX_CONTENT2) + `
+
+[truncated]`;
+          memories.push({
+            content,
+            containerTag: "codex-chats",
+            metadata: { source: "codex-session", sessionId, date: date || "unknown" }
+          });
+          sessionIds.push(sessionId);
+        } catch {}
+      }
+    }
+  } catch {}
+}
+
+// src/ingest/cursor.ts
+import { readFileSync as readFileSync4, statSync } from "node:fs";
+import { join as join5 } from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+var MAX_CONTENT3 = 48000;
+var MAX_DB_SIZE = 2 * 1024 * 1024 * 1024;
+var WARN_DB_SIZE = 500 * 1024 * 1024;
+var MIN_TURN_LEN2 = 50;
+function loadSqlJs(wasmDir) {
+  try {
+    if (wasmDir) {
+      const require2 = createRequire2(join5(wasmDir, "sql.js", "package.json"));
+      return require2("sql.js");
+    } else {
+      const require2 = createRequire2(import.meta.url);
+      return require2("sql.js");
+    }
+  } catch {
+    return null;
+  }
+}
+function openDb(initSqlJs, dbPath, wasmDir) {
+  const locateOpts = {};
+  if (wasmDir) {
+    locateOpts.locateFile = (file) => join5(wasmDir, "sql.js", "dist", file);
+  }
+  return initSqlJs(locateOpts).then((SQL) => {
+    const buffer = readFileSync4(dbPath);
+    return new SQL.Database(buffer);
+  });
+}
+function extractTurns(db, composerId, bubbleHeaders) {
+  const turns = [];
+  let pendingUser = null;
+  for (const header of bubbleHeaders) {
+    let text = "";
+    try {
+      const result = db.exec(`SELECT value FROM cursorDiskKV WHERE key = 'bubbleId:${composerId}:${header.bubbleId}'`);
+      if (result.length > 0) {
+        const bubble = JSON.parse(result[0].values[0][0]);
+        text = cleanText(bubble.text || "");
+      }
+    } catch {
+      continue;
+    }
+    if (text.length < MIN_TURN_LEN2)
+      continue;
+    if (header.type === 1) {
+      pendingUser = text;
+    } else if (header.type === 2 && pendingUser) {
+      turns.push({ user: pendingUser, assistant: text });
+      pendingUser = null;
+    }
+  }
+  return turns;
+}
+async function ingestCursor(dbPath, wasmDir) {
+  const memories = [];
+  const sessionIds = [];
+  let skipped = 0;
+  let fileSize;
+  try {
+    fileSize = statSync(dbPath).size;
+  } catch {
+    console.log("  Skipping Cursor: database not accessible");
+    return { memories, sessionIds, skipped };
+  }
+  if (fileSize > MAX_DB_SIZE) {
+    console.log(`  Skipping Cursor: database too large (${(fileSize / 1024 / 1024 / 1024).toFixed(1)}GB)`);
+    return { memories, sessionIds, skipped };
+  }
+  if (fileSize > WARN_DB_SIZE) {
+    console.log(`  Warning: large database (${(fileSize / 1024 / 1024).toFixed(0)}MB), loading into memory...`);
+  }
+  const initSqlJs = loadSqlJs(wasmDir);
+  if (!initSqlJs) {
+    console.log("  Skipping Cursor: sql.js not available");
+    return { memories, sessionIds, skipped };
+  }
+  let db;
+  try {
+    db = await openDb(initSqlJs, dbPath, wasmDir);
+  } catch (e) {
+    console.log(`  Skipping Cursor: cannot open database (${e.message})`);
+    return { memories, sessionIds, skipped };
+  }
+  try {
+    let rows = [];
+    try {
+      const results = db.exec("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'");
+      if (results.length > 0)
+        rows = results[0].values;
+    } catch {}
+    for (const [key, value] of rows) {
+      const composerId = key.replace("composerData:", "");
+      if (isIngested("cursor", composerId)) {
+        skipped++;
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== "object") {
+          skipped++;
+          continue;
+        }
+      } catch {
+        skipped++;
+        continue;
+      }
+      const bubbleHeaders = parsed.fullConversationHeadersOnly;
+      if (!Array.isArray(bubbleHeaders) || bubbleHeaders.length === 0) {
+        skipped++;
+        continue;
+      }
+      const turns = extractTurns(db, composerId, bubbleHeaders);
+      if (turns.length === 0) {
+        skipped++;
+        continue;
+      }
+      const sessionName = parsed.name || "Cursor Chat";
+      const date = parsed.createdAt ? new Date(parsed.createdAt).toISOString().slice(0, 10) : "unknown";
+      const header = `# ${sessionName} | ${date}`;
+      const body = turns.map((t) => {
+        const q = t.user.length > 300 ? t.user.slice(0, 300) + "..." : t.user;
+        return `## Q: ${q}
+
+${t.assistant}`;
+      }).join(`
+
+---
+
+`);
+      let content = `${header}
+
+${body}`;
+      if (content.length > MAX_CONTENT3)
+        content = content.slice(0, MAX_CONTENT3) + `
+
+[truncated]`;
+      memories.push({
+        content,
+        containerTag: "cursor-chats",
+        metadata: { source: "cursor", sessionId: composerId, name: sessionName, date }
+      });
+      sessionIds.push(composerId);
+    }
+  } catch (e) {
+    console.log(`  Cursor ingestion error: ${e.message}`);
+  } finally {
+    db.close();
+  }
+  return { memories, sessionIds, skipped };
+}
+
+// src/ingest/codebase.ts
+import { createHash } from "node:crypto";
+import { readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync2, existsSync as existsSync4 } from "node:fs";
+import { join as join6, relative, extname, resolve } from "node:path";
+var DEFAULT_IGNORE = new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".nuxt",
+  ".output",
+  "dist",
+  "build",
+  ".cache",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "vendor",
+  "target",
+  ".turbo",
+  ".DS_Store",
+  ".claude",
+  ".conare"
+]);
+var IGNORE_FILES = new Set([
+  "package-lock.json",
+  "bun.lockb",
+  "yarn.lock",
+  "pnpm-lock.yaml"
+]);
+var CODE_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".swift",
+  ".c",
+  ".cpp",
+  ".h",
+  ".css",
+  ".scss",
+  ".less",
+  ".html",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".md",
+  ".mdx",
+  ".txt",
+  ".sql",
+  ".graphql",
+  ".prisma",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".lua",
+  ".zig",
+  ".ex",
+  ".exs"
+]);
+var SPECIAL_FILES = new Set([
+  "Dockerfile",
+  "Makefile",
+  "Procfile",
+  "Justfile",
+  ".gitignore",
+  ".dockerignore",
+  "CLAUDE.md",
+  "AGENTS.md",
+  "README.md",
+  "ARCHITECTURE.md",
+  "wrangler.toml",
+  "wrangler.json"
+]);
+var MAX_FILE_SIZE = 1e5;
+function parseGitignore(rootPath) {
+  const patterns = new Set;
+  const gitignorePath = join6(rootPath, ".gitignore");
+  if (!existsSync4(gitignorePath))
+    return patterns;
+  try {
+    const content = readFileSync5(gitignorePath, "utf-8");
+    for (const line of content.split(`
+`)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#"))
+        continue;
+      patterns.add(trimmed.replace(/\/$/, ""));
+    }
+  } catch {}
+  return patterns;
+}
+function shouldIgnore(name, ignorePatterns) {
+  if (DEFAULT_IGNORE.has(name))
+    return true;
+  if (IGNORE_FILES.has(name))
+    return true;
+  if (name.startsWith(".env"))
+    return true;
+  if (ignorePatterns.has(name))
+    return true;
+  return false;
+}
+function langFromExt(ext) {
+  const map = {
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".js": "javascript",
+    ".jsx": "jsx",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".vue": "vue",
+    ".svelte": "svelte",
+    ".astro": "astro",
+    ".py": "python",
+    ".rb": "ruby",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".swift": "swift",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".h": "c",
+    ".css": "css",
+    ".scss": "scss",
+    ".less": "less",
+    ".html": "html",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".md": "markdown",
+    ".mdx": "mdx",
+    ".sql": "sql",
+    ".graphql": "graphql",
+    ".prisma": "prisma",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "zsh",
+    ".lua": "lua",
+    ".zig": "zig",
+    ".ex": "elixir",
+    ".exs": "elixir"
+  };
+  return map[ext] || ext.slice(1);
+}
+function formatFile(relPath, content, ext) {
+  const lang = langFromExt(ext);
+  return `# File: ${relPath}
+
+\`\`\`${lang}
+${content}
+\`\`\``;
+}
+function indexCodebase(rootPath) {
+  const absRoot = resolve(rootPath);
+  const gitignorePatterns = parseGitignore(absRoot);
+  const memories = [];
+  let fileCount = 0;
+  let skipped = 0;
+  function walk(dir) {
+    let entries;
+    try {
+      entries = readdirSync4(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (shouldIgnore(entry.name, gitignorePatterns))
+        continue;
+      const fullPath = join6(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      const ext = extname(entry.name).toLowerCase();
+      if (!CODE_EXTENSIONS.has(ext) && !SPECIAL_FILES.has(entry.name))
+        continue;
+      let stat;
+      try {
+        stat = statSync2(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.size > MAX_FILE_SIZE || stat.size === 0) {
+        skipped++;
+        continue;
+      }
+      let raw;
+      try {
+        raw = readFileSync5(fullPath, "utf-8");
+      } catch {
+        skipped++;
+        continue;
+      }
+      if (raw.includes("\x00")) {
+        skipped++;
+        continue;
+      }
+      const relPath = relative(absRoot, fullPath);
+      const contentHash = createHash("sha256").update(raw).digest("hex").slice(0, 16);
+      const fileHash = `${relPath}:${contentHash}`;
+      if (isIngested("codebase", fileHash)) {
+        skipped++;
+        continue;
+      }
+      const content = formatFile(relPath, raw, ext);
+      memories.push({
+        content,
+        containerTag: "codebase",
+        metadata: {
+          source: "codebase-index",
+          filePath: relPath,
+          fileHash,
+          language: langFromExt(ext)
+        }
+      });
+      fileCount++;
+    }
+  }
+  walk(absRoot);
+  return { memories, fileCount, skipped };
+}
+
+// src/api.ts
+var API_URL = "https://mcp.conare.ai";
+function createUploadBatches(memories, maxItems = 5, maxChars = 120000) {
+  const batches = [];
+  let current = [];
+  let currentChars = 0;
+  let startIndex = 0;
+  for (let i = 0;i < memories.length; i++) {
+    const item = memories[i];
+    const itemChars = item.content.length;
+    const exceedsBatch = current.length > 0 && (current.length >= maxItems || currentChars + itemChars > maxChars);
+    if (exceedsBatch) {
+      batches.push({ startIndex, items: current });
+      current = [];
+      currentChars = 0;
+      startIndex = i;
+    }
+    current.push(item);
+    currentChars += itemChars;
+  }
+  if (current.length > 0) {
+    batches.push({ startIndex, items: current });
+  }
+  return batches;
+}
+async function validateKey(apiKey) {
+  try {
+    const res = await fetch(`${API_URL}/api/auth/me`, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    if (!res.ok)
+      return { valid: false };
+    const data = await res.json();
+    return { valid: true, email: data.user.email, name: data.user.name };
+  } catch {
+    return { valid: false };
+  }
+}
+async function uploadItems(apiKey, items) {
+  let retries = 4;
+  while (retries > 0) {
+    try {
+      const res = await fetch(`${API_URL}/api/memories/bulk`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(items)
+      });
+      if (res.status === 429) {
+        retries--;
+        await new Promise((r) => setTimeout(r, 5000));
+        continue;
+      }
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`HTTP ${res.status}: ${body.slice(0, 120)}`);
+      }
+      const data = await res.json();
+      if (!Array.isArray(data.results) || data.results.length !== items.length) {
+        throw new Error("Unexpected bulk upload response");
+      }
+      return data.results;
+    } catch (error) {
+      retries--;
+      if (retries === 0) {
+        return items.map(() => ({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        }));
+      }
+      await new Promise((r) => setTimeout(r, 2000));
+    }
+  }
+  return items.map(() => ({ success: false, error: "Upload failed" }));
+}
+async function uploadBulk(apiKey, memories, onProgress) {
+  let success = 0;
+  let failed = 0;
+  const total = memories.length;
+  const results = [];
+  for (const batch of createUploadBatches(memories)) {
+    let batchResults = await uploadItems(apiKey, batch.items);
+    if (batch.items.length > 1 && batchResults.some((result) => !result.success)) {
+      const retriedResults = [];
+      for (let i = 0;i < batch.items.length; i++) {
+        const result = batchResults[i];
+        if (result.success) {
+          retriedResults.push(result);
+          continue;
+        }
+        const [singleResult] = await uploadItems(apiKey, [batch.items[i]]);
+        retriedResults.push(singleResult);
+      }
+      batchResults = retriedResults;
+    }
+    for (let i = 0;i < batchResults.length; i++) {
+      const result = batchResults[i];
+      results.push({
+        index: batch.startIndex + i,
+        success: result.success,
+        deduped: result.deduped,
+        error: result.error
+      });
+      if (result.success)
+        success++;
+      else
+        failed++;
+    }
+    onProgress?.(success + failed, total, failed);
+  }
+  return { success, failed, results };
+}
+
+// src/index.ts
+function getDedupKey(memory) {
+  const metadata = memory.metadata;
+  return metadata?.sessionId || metadata?.fileHash || null;
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let key = "";
+  let dryRun = false;
+  let force = false;
+  let source;
+  let wasmDir;
+  let indexPath;
+  for (let i = 0;i < args.length; i++) {
+    if (args[i] === "--key" && args[i + 1]) {
+      key = args[++i];
+    } else if (args[i] === "--dry-run") {
+      dryRun = true;
+    } else if (args[i] === "--force") {
+      force = true;
+    } else if (args[i] === "--source" && args[i + 1]) {
+      source = args[++i];
+    } else if (args[i] === "--wasm-dir" && args[i + 1]) {
+      wasmDir = args[++i];
+    } else if (args[i] === "--index") {
+      indexPath = args[i + 1] && !args[i + 1].startsWith("--") ? args[++i] : ".";
+    } else if (args[i] === "--ingest-only") {} else if (args[i] === "--config-only") {} else if (args[i] === "--help" || args[i] === "-h") {
+      console.log(`
+conare — Ingest AI chat history into Conare
+
+Usage:
+  conare --key <api_key>                    Ingest chat history
+  conare --key <api_key> --index [path]     Index codebase
+
+Options:
+  --key <key>         Your Conare API key (required, starts with cmem_)
+  --index [path]      Index codebase at path (default: current directory)
+  --dry-run           Preview what would be uploaded
+  --force             Re-ingest all / re-index all (bypass dedup)
+  --source <name>     Only ingest from: claude, codex, cursor
+  --wasm-dir <path>   Path to sql.js module (for Cursor ingestion)
+
+Get your API key at https://mcp.conare.ai
+`);
+      process.exit(0);
+    }
+  }
+  if (!key) {
+    console.error("Error: --key is required. Get your API key at https://mcp.conare.ai");
+    process.exit(1);
+  }
+  if (!key.startsWith("cmem_")) {
+    console.error("Error: API key must start with cmem_");
+    process.exit(1);
+  }
+  return { key, dryRun, force, source, wasmDir, indexPath };
+}
+async function main() {
+  const opts = parseArgs();
+  process.stdout.write("Validating API key... ");
+  const auth = await validateKey(opts.key);
+  if (!auth.valid) {
+    console.error("INVALID. Check your key at https://mcp.conare.ai");
+    process.exit(1);
+  }
+  console.log(`OK (${auth.email})`);
+  console.log();
+  if (opts.indexPath !== undefined) {
+    const { resolve: resolve2 } = await import("node:path");
+    const absPath = resolve2(opts.indexPath);
+    console.log(`Indexing codebase: ${absPath}`);
+    if (opts.force) {
+      clearIngested("codebase");
+      process.stdout.write("Clearing existing codebase index... ");
+      try {
+        await fetch("https://mcp.conare.ai/api/containers/codebase", {
+          method: "DELETE",
+          headers: { Authorization: `Bearer ${opts.key}` }
+        });
+        console.log("done");
+      } catch {
+        console.log("skipped (no existing index)");
+      }
+    }
+    process.stdout.write("Scanning files... ");
+    const { memories, fileCount, skipped } = indexCodebase(absPath);
+    console.log(`${fileCount} files found, ${skipped} skipped`);
+    if (memories.length === 0) {
+      console.log(`
+Nothing new to index.`);
+    } else if (opts.dryRun) {
+      console.log(`
+[DRY RUN] Would upload ${memories.length} files`);
+      for (const m of memories.slice(0, 10)) {
+        const meta = m.metadata;
+        console.log(`  ${meta.language.padEnd(12)} ${meta.filePath}`);
+      }
+      if (memories.length > 10)
+        console.log(`  ... and ${memories.length - 10} more`);
+    } else {
+      const barWidth = 20;
+      const { success, failed, results } = await uploadBulk(opts.key, memories, (uploaded, total, _failed) => {
+        const pct = (uploaded / total * 100).toFixed(1);
+        const filled = Math.round(uploaded / total * barWidth);
+        const bar = "█".repeat(filled) + "░".repeat(barWidth - filled);
+        process.stdout.write(`\r  Uploading [\x1B[36m${bar}\x1B[0m] ${uploaded}/${total} (${pct}%)`);
+      });
+      process.stdout.write(`\r  \x1B[32m✓\x1B[0m ${success} files indexed, ${failed} failed${" ".repeat(20)}
+`);
+      const fileHashes = results.filter((result) => result.success).map((result) => getDedupKey(memories[result.index])).filter((key) => !!key);
+      markIngested("codebase", fileHashes);
+    }
+    console.log();
+    console.log("Done! Your codebase is now searchable via recall.");
+    return;
+  }
+  if (opts.force) {
+    if (opts.source) {
+      clearIngested(opts.source);
+      console.log(`Cleared ingestion history for ${opts.source}`);
+    } else {
+      clearIngested();
+      console.log("Cleared all ingestion history");
+    }
+    console.log();
+  }
+  const tools = detect();
+  console.log("Detected AI tools:");
+  for (const t of tools) {
+    if (t.available) {
+      console.log(`  + ${t.name}${t.sessionCount ? ` — ${t.sessionCount} sessions` : ""}`);
+    } else {
+      console.log(`  - ${t.name} (not found)`);
+    }
+  }
+  console.log();
+  const allMemories = [];
+  const shouldIngest = (name) => !opts.source || opts.source === name;
+  if (shouldIngest("claude") && tools.find((t) => t.name === "Claude Code")?.available) {
+    process.stdout.write("Ingesting Claude Code... ");
+    const { memories, skipped } = ingestClaude();
+    allMemories.push(...memories);
+    console.log(`${memories.length} new, ${skipped} skipped`);
+  }
+  if (shouldIngest("codex") && tools.find((t) => t.name === "Codex")?.available) {
+    process.stdout.write("Ingesting Codex... ");
+    const { memories, skipped } = ingestCodex();
+    allMemories.push(...memories);
+    console.log(`${memories.length} new, ${skipped} skipped`);
+  }
+  if (shouldIngest("cursor") && tools.find((t) => t.name === "Cursor")?.available) {
+    process.stdout.write("Ingesting Cursor... ");
+    const cursorTool = tools.find((t) => t.name === "Cursor");
+    const { memories, skipped } = await ingestCursor(cursorTool.path, opts.wasmDir);
+    allMemories.push(...memories);
+    console.log(`${memories.length} new, ${skipped} skipped`);
+  }
+  console.log();
+  if (allMemories.length === 0) {
+    console.log("Nothing new to upload.");
+  } else if (opts.dryRun) {
+    console.log(`[DRY RUN] Would upload ${allMemories.length} memories`);
+    for (const m of allMemories.slice(0, 5)) {
+      console.log(`  ${m.containerTag} | ${m.content.length} chars | ${m.metadata?.sessionId?.slice(0, 12) || "?"}`);
+    }
+    if (allMemories.length > 5)
+      console.log(`  ... and ${allMemories.length - 5} more`);
+  } else {
+    const barWidth = 20;
+    const { success, failed, results } = await uploadBulk(opts.key, allMemories, (uploaded, total, _failed) => {
+      const pct = (uploaded / total * 100).toFixed(1);
+      const filled = Math.round(uploaded / total * barWidth);
+      const bar = "█".repeat(filled) + "░".repeat(barWidth - filled);
+      process.stdout.write(`\r  Uploading [\x1B[33m${bar}\x1B[0m] ${uploaded}/${total} (${pct}%)`);
+    });
+    process.stdout.write(`\r  \x1B[32m✓\x1B[0m ${success} uploaded, ${failed} failed${" ".repeat(20)}
+`);
+    if (failed > 0) {
+      console.log(`  Re-run with --force to retry failed memories.`);
+    }
+    const successfulKeysBySource = {
+      claude: [],
+      codex: [],
+      cursor: []
+    };
+    for (const result of results) {
+      if (!result.success)
+        continue;
+      const memory = allMemories[result.index];
+      const key = getDedupKey(memory);
+      if (!key)
+        continue;
+      switch (memory.containerTag) {
+        case "claude-chats":
+          successfulKeysBySource.claude.push(key);
+          break;
+        case "codex-chats":
+          successfulKeysBySource.codex.push(key);
+          break;
+        case "cursor-chats":
+          successfulKeysBySource.cursor.push(key);
+          break;
+      }
+    }
+    for (const [source, ids] of Object.entries(successfulKeysBySource)) {
+      if (ids.length > 0)
+        markIngested(source, ids);
+    }
+  }
+  console.log();
+  console.log("Done! MCP will be configured by the install script.");
+}
+main().catch((e) => {
+  console.error("Error:", e.message || e);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "conare",
+  "version": "0.0.1",
+  "description": "Conare CLI for ingesting AI chat history and configuring memory at conare.ai",
+  "type": "module",
+  "bin": {
+    "conare": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node --format esm --external sql.js && cp dist/index.js ../public/install.mjs",
+    "prepublishOnly": "bun run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": ["conare", "ai", "memory", "mcp", "claude", "cursor", "codex", "context"],
+  "homepage": "https://conare.ai",
+  "license": "MIT",
+  "dependencies": {
+    "sql.js": "^1.12.0"
+  }
+}