conare 0.0.1 → 0.0.3

package/dist/index.js

@@ -2,6 +2,10 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/index.ts
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join9 } from "node:path";
+
 // src/detect.ts
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
@@ -876,16 +880,201 @@ async function uploadBulk(apiKey, memories, onProgress) {
   return { success, failed, results };
 }
 
+// src/configure.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname, join as join7 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { spawnSync } from "node:child_process";
+var CONARE_URL = "https://mcp.conare.ai";
+var SERVER_NAME = "conare-memory";
+var MCP_TARGETS = [
+  { id: "claude", label: "Claude Code" },
+  { id: "cursor", label: "Cursor" },
+  { id: "codex", label: "Codex" }
+];
+function readJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync6(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeJsonFile(path, data) {
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync2(path, JSON.stringify(data, null, 2) + `
+`);
+}
+function getServerConfig(apiKey) {
+  return {
+    type: "http",
+    url: `${CONARE_URL}/mcp`,
+    headers: {
+      Authorization: `Bearer ${apiKey}`
+    }
+  };
+}
+function upsertMcpServer(path, apiKey) {
+  const config = readJsonFile(path);
+  if (!config.mcpServers || typeof config.mcpServers !== "object") {
+    config.mcpServers = {};
+  }
+  config.mcpServers[SERVER_NAME] = getServerConfig(apiKey);
+  writeJsonFile(path, config);
+}
+function configureClaude(apiKey) {
+  const claudeConfigPath = join7(homedir5(), ".claude.json");
+  const claudeMcpPath = join7(homedir5(), ".claude", "mcp.json");
+  if (spawnSync("claude", ["mcp", "add-json", SERVER_NAME, "--scope", "user", JSON.stringify(getServerConfig(apiKey))], {
+    stdio: "ignore"
+  }).status === 0) {
+    return "Claude Code configured via `claude mcp add-json`";
+  }
+  upsertMcpServer(claudeConfigPath, apiKey);
+  if (existsSync5(join7(homedir5(), ".claude"))) {
+    upsertMcpServer(claudeMcpPath, apiKey);
+  }
+  return `Claude Code configured at ${claudeConfigPath}`;
+}
+function configureJsonClient(path, apiKey, label) {
+  upsertMcpServer(path, apiKey);
+  return `${label} configured at ${path}`;
+}
+function configureMcp(apiKey, targets = ["claude", "cursor", "codex"]) {
+  const results = [];
+  if (targets.includes("claude")) {
+    results.push(configureClaude(apiKey));
+  }
+  if (targets.includes("cursor")) {
+    results.push(configureJsonClient(join7(homedir5(), ".cursor", "mcp.json"), apiKey, "Cursor"));
+  }
+  if (targets.includes("codex")) {
+    results.push(configureJsonClient(join7(homedir5(), ".codex", "mcp.json"), apiKey, "Codex"));
+  }
+  return results;
+}
+
+// src/config.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join8 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+var CONFIG_DIR = join8(homedir6(), ".conare");
+var CONFIG_PATH = join8(CONFIG_DIR, "config.json");
+function readConfig() {
+  try {
+    if (!existsSync6(CONFIG_PATH))
+      return {};
+    return JSON.parse(readFileSync7(CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveApiKey(apiKey) {
+  mkdirSync3(CONFIG_DIR, { recursive: true });
+  writeFileSync3(CONFIG_PATH, JSON.stringify({ apiKey }, null, 2) + `
+`);
+}
+function getSavedApiKey() {
+  return readConfig().apiKey;
+}
+
+// src/interactive.ts
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+function normalizeYesNo(value, defaultValue) {
+  const normalized = value.trim().toLowerCase();
+  if (!normalized)
+    return defaultValue;
+  if (["y", "yes"].includes(normalized))
+    return true;
+  if (["n", "no"].includes(normalized))
+    return false;
+  return defaultValue;
+}
+async function runInteractiveSetup(options) {
+  const rl = createInterface({ input, output });
+  try {
+    output.write(`
+Conare setup
+
+`);
+    const apiKeyPrompt = options.savedApiKey ? `API key [press enter to use saved key ending in ${options.savedApiKey.slice(-6)}]: ` : "API key: ";
+    const apiKeyAnswer = await rl.question(apiKeyPrompt);
+    const apiKey = apiKeyAnswer.trim() || options.savedApiKey;
+    output.write(`
+Clients to configure:
+`);
+    options.detectedTargets.forEach((target, index) => {
+      const availability = target.available === false ? " (not detected locally)" : "";
+      const recommendation = target.recommended ? " [default]" : "";
+      output.write(`  ${index + 1}. ${target.label}${recommendation}${availability}
+`);
+    });
+    const defaultSelection = options.detectedTargets.map((target, index) => target.recommended ? String(index + 1) : null).filter((value) => !!value).join(",");
+    const targetAnswer = await rl.question(`Select clients [${defaultSelection || "none"}]: `);
+    const selectedIndexes = (targetAnswer.trim() || defaultSelection).split(",").map((part) => parseInt(part.trim(), 10)).filter((value) => Number.isFinite(value) && value >= 1 && value <= options.detectedTargets.length);
+    const configureTargets = [...new Set(selectedIndexes)].map((index) => options.detectedTargets[index - 1]?.id).filter((value) => !!value);
+    const ingestChats = normalizeYesNo(await rl.question("Ingest chat history? [Y/n]: "), true);
+    const indexCodebase2 = normalizeYesNo(await rl.question("Index current codebase too? [y/N]: "), false);
+    let indexPath;
+    if (indexCodebase2) {
+      const pathAnswer = await rl.question("Codebase path [.]: ");
+      indexPath = pathAnswer.trim() || ".";
+    }
+    output.write(`
+`);
+    return {
+      apiKey,
+      configureTargets,
+      ingestChats,
+      indexCodebase: indexCodebase2,
+      indexPath
+    };
+  } finally {
+    rl.close();
+  }
+}
+
 // src/index.ts
 function getDedupKey(memory) {
   const metadata = memory.metadata;
   return metadata?.sessionId || metadata?.fileHash || null;
 }
+function printMissingKeyError() {
+  console.error("Error: no API key configured.");
+  console.error("");
+  console.error("Run one of these:");
+  console.error("  bunx conare@latest --key YOUR_API_KEY");
+  console.error("  npx conare@latest --key YOUR_API_KEY");
+  console.error("");
+  console.error("For a built-in command, install globally:");
+  console.error("  bun add -g conare");
+  console.error("  npm i -g conare");
+  console.error("");
+  console.error("Get your API key at https://mcp.conare.ai");
+}
+function printFailureSummary(results, memories) {
+  const failures = results.map((result, index) => ({ ...result, memory: memories[index] })).filter((result) => !result.success);
+  if (failures.length === 0)
+    return;
+  console.log("");
+  console.log("  Failure summary:");
+  for (const failure of failures.slice(0, 3)) {
+    const metadata = failure.memory.metadata;
+    const label = metadata?.filePath || metadata?.sessionId || failure.memory.containerTag;
+    console.log(`  - ${label}: ${failure.error || "Upload failed"}`);
+  }
+  if (failures.length > 3) {
+    console.log(`  - ... and ${failures.length - 3} more`);
+  }
+}
 function parseArgs() {
   const args = process.argv.slice(2);
   let key = "";
   let dryRun = false;
   let force = false;
+  let ingestOnly = false;
+  let configOnly = false;
+  let interactive = false;
   let source;
   let wasmDir;
   let indexPath;
@@ -902,7 +1091,13 @@ function parseArgs() {
       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") {
+    } else if (args[i] === "--ingest-only") {
+      ingestOnly = true;
+    } else if (args[i] === "--config-only") {
+      configOnly = true;
+    } else if (args[i] === "--interactive") {
+      interactive = true;
+    } else if (args[i] === "--help" || args[i] === "-h") {
       console.log(`
 conare — Ingest AI chat history into Conare
 
@@ -915,6 +1110,9 @@ Options:
   --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)
+  --ingest-only       Ingest memories without MCP configuration
+  --config-only       Configure MCP only, skip ingestion
+  --interactive       Run guided setup prompts
   --source <name>     Only ingest from: claude, codex, cursor
   --wasm-dir <path>   Path to sql.js module (for Cursor ingestion)
 
@@ -923,29 +1121,86 @@ 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");
+  if (key && !key.startsWith("cmem_")) {
+    console.error("Error: API key must start with cmem_");
     process.exit(1);
   }
-  if (!key.startsWith("cmem_")) {
-    console.error("Error: API key must start with cmem_");
+  if (ingestOnly && configOnly) {
+    console.error("Error: --ingest-only and --config-only cannot be used together");
     process.exit(1);
   }
-  return { key, dryRun, force, source, wasmDir, indexPath };
+  return { key, dryRun, force, ingestOnly, configOnly, interactive, source, wasmDir, indexPath };
 }
 async function main() {
   const opts = parseArgs();
+  const savedApiKey = getSavedApiKey();
+  const shouldRunInteractive = (opts.interactive || process.argv.slice(2).length === 0 || process.argv.slice(2).length <= 2 && !!opts.key) && !opts.dryRun && !opts.force && !opts.source && !opts.indexPath && !opts.configOnly && !opts.ingestOnly && !!process.stdin.isTTY && !!process.stdout.isTTY;
+  let selectedTargets = MCP_TARGETS.map((target) => target.id);
+  let effectiveConfigOnly = opts.configOnly;
+  let effectiveIngestOnly = opts.ingestOnly;
+  let effectiveIndexPath = opts.indexPath;
+  let postIngestIndexPath;
+  let apiKey = opts.key || process.env.CONARE_API_KEY || savedApiKey;
+  if (shouldRunInteractive) {
+    const detectedTools = detect();
+    const answers = await runInteractiveSetup({
+      savedApiKey,
+      detectedTargets: MCP_TARGETS.map((target) => {
+        const detected = detectedTools.find((tool) => target.id === "claude" && tool.name === "Claude Code" || target.id === "cursor" && tool.name === "Cursor" || target.id === "codex" && tool.name === "Codex");
+        return {
+          id: target.id,
+          label: target.label,
+          available: detected?.available,
+          recommended: detected?.available !== false
+        };
+      })
+    });
+    apiKey = answers.apiKey || apiKey;
+    selectedTargets = answers.configureTargets.length > 0 ? answers.configureTargets : [];
+    effectiveConfigOnly = !answers.ingestChats && !answers.indexCodebase;
+    effectiveIngestOnly = answers.ingestChats && answers.configureTargets.length === 0;
+    effectiveIndexPath = !answers.ingestChats && answers.indexCodebase ? answers.indexPath || "." : undefined;
+    postIngestIndexPath = answers.ingestChats && answers.indexCodebase ? answers.indexPath || "." : undefined;
+  }
+  if (!apiKey) {
+    printMissingKeyError();
+    process.exit(1);
+  }
+  console.log("");
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log("  Conare Installer");
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log("");
   process.stdout.write("Validating API key... ");
-  const auth = await validateKey(opts.key);
+  const auth = await validateKey(apiKey);
   if (!auth.valid) {
     console.error("INVALID. Check your key at https://mcp.conare.ai");
     process.exit(1);
   }
-  console.log(`OK (${auth.email})`);
+  console.log(auth.email ? `OK (${auth.email})` : "OK");
+  saveApiKey(apiKey);
   console.log();
-  if (opts.indexPath !== undefined) {
+  if (!opts.wasmDir && existsSync7(join9(process.cwd(), "node_modules", "sql.js"))) {
+    opts.wasmDir = join9(process.cwd(), "node_modules");
+  }
+  if (effectiveConfigOnly) {
+    if (!opts.dryRun) {
+      console.log("─── Configuring MCP ───");
+      console.log("");
+      for (const line of configureMcp(apiKey, selectedTargets)) {
+        console.log(`  ✓ ${line}`);
+      }
+      console.log("");
+    }
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log("  ✓ Done! Conare MCP is configured.");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log("");
+    return;
+  }
+  if (effectiveIndexPath !== undefined) {
     const { resolve: resolve2 } = await import("node:path");
-    const absPath = resolve2(opts.indexPath);
+    const absPath = resolve2(effectiveIndexPath);
     console.log(`Indexing codebase: ${absPath}`);
     if (opts.force) {
       clearIngested("codebase");
@@ -953,7 +1208,7 @@ async function main() {
       try {
         await fetch("https://mcp.conare.ai/api/containers/codebase", {
           method: "DELETE",
-          headers: { Authorization: `Bearer ${opts.key}` }
+          headers: { Authorization: `Bearer ${apiKey}` }
         });
         console.log("done");
       } catch {
@@ -977,7 +1232,7 @@ Nothing new to index.`);
         console.log(`  ... and ${memories.length - 10} more`);
     } else {
       const barWidth = 20;
-      const { success, failed, results } = await uploadBulk(opts.key, memories, (uploaded, total, _failed) => {
+      const { success, failed, results } = await uploadBulk(apiKey, 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);
@@ -987,8 +1242,17 @@ Nothing new to index.`);
 `);
       const fileHashes = results.filter((result) => result.success).map((result) => getDedupKey(memories[result.index])).filter((key) => !!key);
       markIngested("codebase", fileHashes);
+      printFailureSummary(results, memories);
     }
     console.log();
+    if (!opts.dryRun && !effectiveIngestOnly) {
+      console.log("─── Configuring MCP ───");
+      console.log("");
+      for (const line of configureMcp(apiKey, selectedTargets)) {
+        console.log(`  ✓ ${line}`);
+      }
+      console.log("");
+    }
     console.log("Done! Your codebase is now searchable via recall.");
     return;
   }
@@ -1045,7 +1309,7 @@ Nothing new to index.`);
       console.log(`  ... and ${allMemories.length - 5} more`);
   } else {
     const barWidth = 20;
-    const { success, failed, results } = await uploadBulk(opts.key, allMemories, (uploaded, total, _failed) => {
+    const { success, failed, results } = await uploadBulk(apiKey, 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);
@@ -1056,6 +1320,7 @@ Nothing new to index.`);
     if (failed > 0) {
       console.log(`  Re-run with --force to retry failed memories.`);
     }
+    printFailureSummary(results, allMemories);
     const successfulKeysBySource = {
       claude: [],
       codex: [],
@@ -1086,7 +1351,46 @@ Nothing new to index.`);
     }
   }
   console.log();
-  console.log("Done! MCP will be configured by the install script.");
+  if (!opts.dryRun && !effectiveIngestOnly) {
+    console.log("─── Configuring MCP ───");
+    console.log("");
+    for (const line of configureMcp(apiKey, selectedTargets)) {
+      console.log(`  ✓ ${line}`);
+    }
+    console.log("");
+  }
+  if (postIngestIndexPath) {
+    const { resolve: resolve2 } = await import("node:path");
+    const absPath = resolve2(postIngestIndexPath);
+    console.log("─── Indexing codebase ───");
+    console.log("");
+    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 {
+      const barWidth = 20;
+      const { success, failed, results } = await uploadBulk(apiKey, 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);
+      printFailureSummary(results, memories);
+    }
+    console.log("");
+  }
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log("  ✓ Done! Every new conversation now starts with context.");
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log("  Next time you can run `conare` after a global install.");
+  console.log("");
 }
 main().catch((e) => {
   console.error("Error:", e.message || e);

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "conare",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "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",
+    "build": "bun build src/index.ts --outdir dist --target node --format esm --external sql.js",
     "prepublishOnly": "bun run build"
   },
   "files": [