@cilow/cli 0.1.0 → 0.2.0

package/dist/cli.js

@@ -4,6 +4,8 @@
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
+import * as readline from "readline";
+var VERSION = "0.2.0";
 var DEFAULT_API_URL = "https://cilow-gateway-c8ozzar9.uc.gateway.dev";
 function getConfig() {
   const apiKey = process.env.CILOW_API_KEY;
@@ -15,18 +17,8 @@ function getConfig() {
   }
   return { apiUrl, apiKey };
 }
-async function makeRequest(config, method, path, body, queryParams) {
-  let url = `${config.apiUrl}${path}`;
-  if (queryParams) {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(queryParams)) {
-      if (value !== void 0) {
-        params.append(key, String(value));
-      }
-    }
-    const qs = params.toString();
-    if (qs) url += `?${qs}`;
-  }
+async function makeRequest(config, method, path, body) {
+  const url = `${config.apiUrl}${path}`;
   const headers = {
     "Content-Type": "application/json"
   };
@@ -47,18 +39,454 @@ async function makeRequest(config, method, path, body, queryParams) {
   const text = await response.text();
   return text ? JSON.parse(text) : null;
 }
+async function startChat(config, options) {
+  const messages = [];
+  const provider = options.provider || "anthropic";
+  const model = options.model || "claude-3-5-haiku-20241022";
+  console.log(chalk.bold.cyan("\n\u{1F9E0} Cilow AI Chat"));
+  console.log(chalk.dim("Your AI assistant with persistent memory\n"));
+  console.log(chalk.dim("Commands: /help, /memories, /clear, /exit\n"));
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const prompt = () => {
+    rl.question(chalk.green("You: "), async (input) => {
+      const trimmed = input.trim();
+      if (!trimmed) {
+        prompt();
+        return;
+      }
+      if (trimmed.startsWith("/")) {
+        await handleCommand(trimmed, config, messages);
+        prompt();
+        return;
+      }
+      messages.push({ role: "user", content: trimmed });
+      const spinner = ora({ text: "Thinking...", color: "cyan" }).start();
+      try {
+        const result = await makeRequest(config, "POST", "/api/v2/router", {
+          provider,
+          model,
+          messages,
+          auto_context: true
+        });
+        spinner.stop();
+        if (result.success && result.response) {
+          messages.push({ role: "assistant", content: result.response });
+          console.log(chalk.cyan("\nCilow: ") + result.response);
+          if (result.memories_used && result.memories_used > 0) {
+            console.log(chalk.dim(`  [${result.memories_used} memories used]`));
+          }
+          console.log();
+        } else {
+          console.log(chalk.red("\nError: ") + (result.error || "Unknown error"));
+          console.log();
+        }
+      } catch (err) {
+        spinner.stop();
+        console.log(chalk.red("\nError: ") + String(err));
+        console.log();
+      }
+      prompt();
+    });
+  };
+  rl.on("close", () => {
+    console.log(chalk.dim("\nGoodbye! Your memories are saved.\n"));
+    process.exit(0);
+  });
+  prompt();
+}
+async function handleCommand(cmd, config, messages) {
+  const parts = cmd.slice(1).split(" ");
+  const command = parts[0].toLowerCase();
+  switch (command) {
+    case "help":
+      console.log(chalk.bold("\nCommands:"));
+      console.log("  /memories  - Show relevant memories");
+      console.log("  /add <text> - Add a memory");
+      console.log("  /decide <decision> - Store a decision");
+      console.log("  /clear    - Clear conversation");
+      console.log("  /exit     - Exit chat");
+      console.log();
+      break;
+    case "memories":
+      const spinner = ora("Fetching memories...").start();
+      try {
+        const lastUserMsg = messages.filter((m) => m.role === "user").pop();
+        const query = lastUserMsg?.content || "recent memories";
+        const result = await makeRequest(config, "POST", "/api/v1/memory/search", {
+          query,
+          limit: 5
+        });
+        spinner.stop();
+        if (result.results && result.results.length > 0) {
+          console.log(chalk.bold("\nRelevant memories:"));
+          for (const m of result.results) {
+            console.log(chalk.dim("  \u2022 ") + m.content.substring(0, 100));
+          }
+          console.log();
+        } else {
+          console.log(chalk.yellow("\nNo memories found.\n"));
+        }
+      } catch (err) {
+        spinner.stop();
+        console.log(chalk.red("Failed to fetch memories\n"));
+      }
+      break;
+    case "add":
+      const content = parts.slice(1).join(" ");
+      if (content) {
+        try {
+          await makeRequest(config, "POST", "/api/v1/memory/add", { content });
+          console.log(chalk.green("Memory added!\n"));
+        } catch {
+          console.log(chalk.red("Failed to add memory\n"));
+        }
+      } else {
+        console.log(chalk.yellow("Usage: /add <memory content>\n"));
+      }
+      break;
+    case "decide":
+      const decision = parts.slice(1).join(" ");
+      if (decision) {
+        try {
+          await makeRequest(config, "POST", "/api/v2/memory", {
+            action: "add",
+            content: decision,
+            type: "decision",
+            tags: ["type:decision"]
+          });
+          console.log(chalk.green("Decision stored!\n"));
+        } catch {
+          console.log(chalk.red("Failed to store decision\n"));
+        }
+      } else {
+        console.log(chalk.yellow("Usage: /decide <your decision>\n"));
+      }
+      break;
+    case "clear":
+      messages.length = 0;
+      console.log(chalk.dim("Conversation cleared.\n"));
+      break;
+    case "exit":
+    case "quit":
+      console.log(chalk.dim("\nGoodbye!\n"));
+      process.exit(0);
+      break;
+    default:
+      console.log(chalk.yellow(`Unknown command: ${command}. Type /help for help.
+`));
+  }
+}
+async function initProject(options) {
+  console.log(chalk.bold.cyan("\n\u{1F680} Cilow Project Setup\n"));
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const question = (q) => new Promise((resolve) => rl.question(q, resolve));
+  try {
+    let apiKey = process.env.CILOW_API_KEY;
+    if (!apiKey) {
+      console.log(chalk.yellow("No CILOW_API_KEY found in environment.\n"));
+      apiKey = await question("Enter your Cilow API key (or press Enter to skip): ");
+    }
+    const fs = await import("fs");
+    const path = await import("path");
+    const cwd = process.cwd();
+    let framework = options.framework;
+    if (!framework) {
+      if (fs.existsSync(path.join(cwd, "package.json"))) {
+        const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"));
+        if (pkg.dependencies?.next || pkg.devDependencies?.next) {
+          framework = "nextjs";
+        } else if (pkg.dependencies?.react || pkg.devDependencies?.react) {
+          framework = "react";
+        } else if (pkg.dependencies?.express || pkg.devDependencies?.express) {
+          framework = "express";
+        } else {
+          framework = "node";
+        }
+      } else if (fs.existsSync(path.join(cwd, "requirements.txt")) || fs.existsSync(path.join(cwd, "pyproject.toml"))) {
+        framework = "python";
+      } else {
+        framework = "generic";
+      }
+      console.log(chalk.dim(`Detected framework: ${framework}`));
+    }
+    const envPath = path.join(cwd, ".env");
+    const envLocalPath = path.join(cwd, ".env.local");
+    if (apiKey && !fs.existsSync(envPath) && !fs.existsSync(envLocalPath)) {
+      const envContent = `# Cilow AI Memory
+CILOW_API_KEY=${apiKey}
+CILOW_API_URL=https://cilow-gateway-c8ozzar9.uc.gateway.dev
+`;
+      fs.writeFileSync(envLocalPath, envContent);
+      console.log(chalk.green("\u2713 Created .env.local with Cilow configuration"));
+    }
+    console.log(chalk.dim("\nInstalling @cilow/sdk..."));
+    const { execSync } = await import("child_process");
+    if (framework === "python") {
+      console.log(chalk.dim("  pip install cilow"));
+    } else {
+      try {
+        execSync("npm install @cilow/sdk", { stdio: "inherit" });
+        console.log(chalk.green("\u2713 Installed @cilow/sdk"));
+      } catch {
+        console.log(chalk.yellow("\u26A0 Could not install SDK automatically. Run: npm install @cilow/sdk"));
+      }
+    }
+    console.log(chalk.bold("\n\u{1F4DD} Example Usage:\n"));
+    if (framework === "nextjs" || framework === "react") {
+      console.log(chalk.dim(`// app/api/chat/route.ts (or pages/api/chat.ts)
+import { CilowClient } from '@cilow/sdk';
+
+const cilow = new CilowClient({
+  apiKey: process.env.CILOW_API_KEY,
+});
+
+export async function POST(req: Request) {
+  const { message, userId } = await req.json();
+
+  // Add to memory
+  await cilow.add(message, { userId });
+
+  // Get context-aware response
+  const response = await cilow.chat({
+    messages: [{ role: 'user', content: message }],
+    userId,
+  });
+
+  return Response.json(response);
+}`));
+    } else if (framework === "express" || framework === "node") {
+      console.log(chalk.dim(`// server.js
+import { CilowClient } from '@cilow/sdk';
+
+const cilow = new CilowClient({
+  apiKey: process.env.CILOW_API_KEY,
+});
+
+app.post('/chat', async (req, res) => {
+  const { message, userId } = req.body;
+
+  // Store in memory
+  await cilow.add(message, { userId });
+
+  // Get AI response with memory context
+  const response = await cilow.chat({
+    messages: [{ role: 'user', content: message }],
+    userId,
+  });
+
+  res.json(response);
+});`));
+    } else {
+      console.log(chalk.dim(`import { CilowClient } from '@cilow/sdk';
+
+const cilow = new CilowClient({
+  apiKey: process.env.CILOW_API_KEY,
+});
+
+// Add memory
+await cilow.add("User prefers dark mode");
+
+// Search with context
+const results = await cilow.search("user preferences");
+
+// Chat with memory-enhanced AI
+const response = await cilow.chat({
+  messages: [{ role: 'user', content: 'What are my preferences?' }],
+});`));
+    }
+    console.log(chalk.bold.green("\n\u2705 Cilow is ready!\n"));
+    console.log(chalk.dim("Next steps:"));
+    console.log('  1. Add memories: cilow add "Important information"');
+    console.log("  2. Chat with AI: cilow chat");
+    console.log("  3. View docs: https://docs.cilow.ai");
+    console.log();
+    rl.close();
+  } catch (err) {
+    rl.close();
+    console.error(chalk.red("Setup failed:"), err);
+    process.exit(1);
+  }
+}
+async function startMcpServer() {
+  console.log(chalk.bold.cyan("\u{1F50C} Cilow MCP Server\n"));
+  console.log(chalk.dim("Model Context Protocol server for Claude Code integration\n"));
+  const config = getConfig();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+  });
+  const sendResponse = (id, result) => {
+    const response = JSON.stringify({ jsonrpc: "2.0", id, result });
+    process.stdout.write(response + "\n");
+  };
+  const sendError = (id, code, message) => {
+    const response = JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } });
+    process.stdout.write(response + "\n");
+  };
+  const tools = [
+    {
+      name: "cilow_add_memory",
+      description: "Add information to Cilow memory for later recall",
+      inputSchema: {
+        type: "object",
+        properties: {
+          content: { type: "string", description: "The content to remember" },
+          tags: { type: "array", items: { type: "string" }, description: "Optional tags" }
+        },
+        required: ["content"]
+      }
+    },
+    {
+      name: "cilow_search",
+      description: "Search Cilow memory for relevant information",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query" },
+          limit: { type: "number", description: "Max results (default 5)" }
+        },
+        required: ["query"]
+      }
+    },
+    {
+      name: "cilow_decide",
+      description: "Store a decision with reasoning for future reference",
+      inputSchema: {
+        type: "object",
+        properties: {
+          decision: { type: "string", description: "The decision made" },
+          reasoning: { type: "string", description: "Why this decision was made" },
+          alternatives: { type: "array", items: { type: "string" }, description: "Alternatives considered" }
+        },
+        required: ["decision", "reasoning"]
+      }
+    },
+    {
+      name: "cilow_recall",
+      description: "Ask a question and get an answer based on stored memories",
+      inputSchema: {
+        type: "object",
+        properties: {
+          question: { type: "string", description: "Question to ask" }
+        },
+        required: ["question"]
+      }
+    },
+    {
+      name: "cilow_context",
+      description: "Get relevant context for an LLM prompt from Cilow memory",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Query to find relevant context for" },
+          max_tokens: { type: "number", description: "Maximum context tokens" }
+        },
+        required: ["query"]
+      }
+    }
+  ];
+  rl.on("line", async (line) => {
+    try {
+      const request = JSON.parse(line);
+      const { id, method, params } = request;
+      switch (method) {
+        case "initialize":
+          sendResponse(id, {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: { name: "cilow-mcp", version: VERSION }
+          });
+          break;
+        case "tools/list":
+          sendResponse(id, { tools });
+          break;
+        case "tools/call":
+          const { name, arguments: args } = params;
+          try {
+            let result;
+            switch (name) {
+              case "cilow_add_memory":
+                result = await makeRequest(config, "POST", "/api/v1/memory/add", {
+                  content: args.content,
+                  tags: args.tags
+                });
+                break;
+              case "cilow_search":
+                result = await makeRequest(config, "POST", "/api/v1/memory/search", {
+                  query: args.query,
+                  limit: args.limit || 5
+                });
+                break;
+              case "cilow_decide":
+                result = await makeRequest(config, "POST", "/api/v2/memory", {
+                  action: "add",
+                  content: args.decision,
+                  type: "decision",
+                  reasoning: args.reasoning,
+                  alternatives: args.alternatives,
+                  tags: ["type:decision"]
+                });
+                break;
+              case "cilow_recall":
+                const searchResult = await makeRequest(config, "POST", "/api/v1/memory/search", {
+                  query: args.question,
+                  limit: 5
+                });
+                result = {
+                  answer: searchResult.results?.map((r) => r.content).join("\n\n") || "No relevant memories found."
+                };
+                break;
+              case "cilow_context":
+                const contextResult = await makeRequest(config, "POST", "/api/v1/memory/search", {
+                  query: args.query,
+                  limit: 10
+                });
+                result = {
+                  context: contextResult.results?.map((r) => r.content).join("\n\n") || ""
+                };
+                break;
+              default:
+                throw new Error(`Unknown tool: ${name}`);
+            }
+            sendResponse(id, { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] });
+          } catch (err) {
+            sendError(id, -32603, String(err));
+          }
+          break;
+        default:
+          sendError(id, -32601, `Method not found: ${method}`);
+      }
+    } catch (err) {
+      console.error("MCP Error:", err);
+    }
+  });
+  console.log(chalk.green("MCP server running on stdio"));
+  console.log(chalk.dim("Add to Claude Code settings:"));
+  console.log(chalk.dim(`  "cilow": { "command": "npx", "args": ["@cilow/cli", "mcp"] }`));
+}
 var program = new Command();
-program.name("cilow").description("Cilow - AI Memory Infrastructure CLI").version("0.1.0");
-program.command("add <content>").description("Add a memory").option("-t, --tags <tags>", "Comma-separated tags").option("-u, --user <userId>", "User ID").option("--type <type>", "Memory type: hot, warm, cold").action(async (content, options) => {
+program.name("cilow").description("Cilow - AI Memory Infrastructure with persistent context").version(VERSION);
+program.command("chat").description("Start interactive AI chat with memory").option("-p, --provider <provider>", "LLM provider (anthropic, openai)", "anthropic").option("-m, --model <model>", "Model to use").action(async (options) => {
+  const config = getConfig();
+  await startChat(config, options);
+});
+program.command("init").description("Initialize Cilow in your project").option("-f, --framework <framework>", "Framework (nextjs, react, express, node, python)").action(initProject);
+program.command("mcp").description("Start MCP server for Claude Code integration").action(startMcpServer);
+program.command("add <content>").description("Add a memory").option("-t, --tags <tags>", "Comma-separated tags").action(async (content, options) => {
   const config = getConfig();
   const spinner = ora("Storing memory...").start();
   try {
     const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
     const result = await makeRequest(config, "POST", "/api/v1/memory/add", {
       content,
-      tags,
-      user_id: options.user,
-      type: options.type
+      tags
     });
     spinner.succeed(chalk.green("Memory stored!"));
     console.log(chalk.dim(`ID: ${result.memory_id}`));
@@ -68,16 +496,13 @@ program.command("add <content>").description("Add a memory").option("-t, --tags
     process.exit(1);
   }
 });
-program.command("search <query>").description("Search memories").option("-l, --limit <limit>", "Number of results", "5").option("-u, --user <userId>", "User ID").option("-t, --tags <tags>", "Filter by tags").action(async (query, options) => {
+program.command("search <query>").description("Search memories").option("-l, --limit <limit>", "Number of results", "5").action(async (query, options) => {
   const config = getConfig();
   const spinner = ora("Searching...").start();
   try {
-    const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : void 0;
     const result = await makeRequest(config, "POST", "/api/v1/memory/search", {
       query,
-      limit: parseInt(options.limit),
-      user_id: options.user,
-      tags
+      limit: parseInt(options.limit)
     });
     spinner.stop();
     if (!result.results || result.results.length === 0) {
@@ -102,58 +527,24 @@ Found ${result.results.length} memories:
     process.exit(1);
   }
 });
-program.command("list").description("List recent memories").option("-l, --limit <limit>", "Number of results", "20").option("-u, --user <userId>", "User ID").action(async (options) => {
-  const config = getConfig();
-  const spinner = ora("Fetching memories...").start();
-  try {
-    const result = await makeRequest(config, "POST", "/api/v1/memory/search", {
-      query: "user information personal data preferences",
-      limit: parseInt(options.limit),
-      user_id: options.user
-    });
-    spinner.stop();
-    if (!result.results || result.results.length === 0) {
-      console.log(chalk.yellow("No memories found"));
-      return;
-    }
-    console.log(chalk.bold(`
-${result.results.length} memories:
-`));
-    for (const m of result.results) {
-      const date = m.created_at ? new Date(m.created_at).toLocaleDateString() : "";
-      console.log(chalk.cyan(`[${date}]`) + ` ${m.content.substring(0, 80)}${m.content.length > 80 ? "..." : ""}`);
-      if (m.tags && m.tags.length > 0) {
-        console.log(chalk.dim(`  Tags: ${m.tags.slice(0, 5).join(", ")}${m.tags.length > 5 ? "..." : ""}`));
-      }
-    }
-  } catch (err) {
-    spinner.fail(chalk.red("Failed to list memories"));
-    console.error(chalk.dim(String(err)));
-    process.exit(1);
-  }
-});
-program.command("recall <question>").alias("ask").description("Ask about your memories in natural language").option("-u, --user <userId>", "User ID").action(async (question, options) => {
+program.command("decide <decision>").description("Store a decision with reasoning").requiredOption("-r, --reason <reason>", "Why you made this decision").option("-a, --alternatives <alternatives>", "Comma-separated alternatives").action(async (decision, options) => {
   const config = getConfig();
-  const spinner = ora("Thinking...").start();
+  const spinner = ora("Storing decision...").start();
   try {
-    const result = await makeRequest(config, "POST", "/api/v1/memory/search", {
-      query: question,
-      limit: 5,
-      user_id: options.user
+    const alternatives = options.alternatives ? options.alternatives.split(",").map((a) => a.trim()) : void 0;
+    await makeRequest(config, "POST", "/api/v2/memory", {
+      action: "add",
+      content: decision,
+      type: "decision",
+      reasoning: options.reason,
+      alternatives,
+      tags: ["type:decision"]
     });
-    spinner.stop();
-    if (!result.results || result.results.length === 0) {
-      console.log(chalk.yellow("I don't have any relevant memories for that."));
-      return;
-    }
-    console.log(chalk.bold("\nHere's what I remember:\n"));
-    for (const r of result.results) {
-      if (r.similarity > 0.3) {
-        console.log(chalk.green("\u2022 ") + r.content);
-      }
-    }
+    spinner.succeed(chalk.green("Decision stored!"));
+    console.log(chalk.dim(`Decision: ${decision}`));
+    console.log(chalk.dim(`Reason: ${options.reason}`));
   } catch (err) {
-    spinner.fail(chalk.red("Recall failed"));
+    spinner.fail(chalk.red("Failed to store decision"));
     console.error(chalk.dim(String(err)));
     process.exit(1);
   }
@@ -176,241 +567,21 @@ program.command("config").description("Show current configuration").action(() =>
   console.log(chalk.bold("\nCilow Configuration:\n"));
   console.log(`API URL:  ${chalk.cyan(apiUrl)}`);
   console.log(`API Key:  ${apiKey ? chalk.green(apiKey.substring(0, 20) + "...") : chalk.red("Not set")}`);
-  if (!apiKey) {
-    console.log(chalk.yellow("\nSet your API key:"));
-    console.log(chalk.dim("  export CILOW_API_KEY=your_api_key"));
-  }
-});
-program.command("chat").description("Interactive chat with memory (coming soon)").action(() => {
-  console.log(chalk.yellow("Interactive chat mode coming soon!"));
-  console.log(chalk.dim('For now, use "cilow recall" for memory queries.'));
-});
-program.command("decide <decision>").description("Store a decision with reasoning (Cilow's unique feature)").requiredOption("-r, --reason <reason>", "Why you made this decision").option("-a, --alternatives <alternatives>", "Comma-separated alternatives considered").option("-u, --user <userId>", "User ID").option("-s, --source <source>", "Source of decision (e.g., slack, meeting)").action(async (decision, options) => {
-  const config = getConfig();
-  const spinner = ora("Storing decision trace...").start();
-  try {
-    const alternatives = options.alternatives ? options.alternatives.split(",").map((a) => a.trim()) : void 0;
-    const result = await makeRequest(config, "POST", "/api/v2/memory", {
-      action: "add",
-      content: decision,
-      type: "decision",
-      reasoning: options.reason,
-      alternatives,
-      user_id: options.user,
-      source: options.source,
-      tags: ["type:decision"]
-    });
-    if (result.success) {
-      spinner.succeed(chalk.green("Decision traced!"));
-      console.log(chalk.dim(`ID: ${result.memory_id}`));
-      console.log(chalk.cyan(`Decision: ${decision}`));
-      console.log(chalk.dim(`Reasoning: ${options.reason}`));
-      if (alternatives) {
-        console.log(chalk.dim(`Alternatives: ${alternatives.join(", ")}`));
-      }
-    } else {
-      spinner.fail(chalk.red("Failed to store decision"));
-    }
-  } catch (err) {
-    spinner.fail(chalk.red("Failed to store decision"));
-    console.error(chalk.dim(String(err)));
-    process.exit(1);
-  }
-});
-program.command("simulate <question>").description('Ask "what if" questions based on past decisions').option("-u, --user <userId>", "User ID").action(async (question, options) => {
-  const config = getConfig();
-  const spinner = ora("Analyzing past decisions...").start();
-  try {
-    const result = await makeRequest(config, "POST", "/api/v2/memory", {
-      action: "search",
-      query: question,
-      tags: ["type:decision"],
-      limit: 5,
-      user_id: options.user
-    });
-    spinner.stop();
-    if (!result.success || !result.memories || result.memories.length === 0) {
-      console.log(chalk.yellow("No relevant decisions found for this question."));
-      console.log(chalk.dim('Try storing more decisions with: cilow decide "..." --reason "..."'));
-      return;
-    }
-    console.log(chalk.bold("\n\u{1F52E} World Model Simulation\n"));
-    console.log(chalk.dim(`Question: ${question}
-`));
-    console.log(chalk.cyan("Based on past decisions, here's what I found:\n"));
-    for (const m of result.memories) {
-      const lines = m.content.split("\n");
-      const decisionLine = lines.find((l) => l.startsWith("DECISION:")) || m.content;
-      const reasoningLine = lines.find((l) => l.startsWith("REASONING:"));
-      const alternativesLine = lines.find((l) => l.startsWith("ALTERNATIVES CONSIDERED:"));
-      console.log(chalk.green("\u2022 ") + chalk.bold(decisionLine.replace("DECISION: ", "")));
-      if (reasoningLine) {
-        console.log(chalk.dim(`  Why: ${reasoningLine.replace("REASONING: ", "")}`));
-      }
-      if (alternativesLine) {
-        console.log(chalk.dim(`  Alternatives: ${alternativesLine.replace("ALTERNATIVES CONSIDERED: ", "")}`));
-      }
-      console.log();
-    }
-    console.log(chalk.dim("\n\u{1F4A1} These past decisions may influence the answer to your question."));
-    console.log(chalk.dim('Use "cilow recall" for more detailed memory search.'));
-  } catch (err) {
-    spinner.fail(chalk.red("Simulation failed"));
-    console.error(chalk.dim(String(err)));
-    process.exit(1);
-  }
-});
-program.command("ingest <url>").description("Ingest content from a URL into memory").option("-u, --user <userId>", "User ID").option("-t, --tags <tags>", "Comma-separated tags").action(async (url, options) => {
-  const config = getConfig();
-  const spinner = ora("Ingesting URL content...").start();
-  try {
-    const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : void 0;
-    const result = await makeRequest(config, "POST", "/api/v2/memory", {
-      action: "add",
-      content: url,
-      // URL auto-detected and ingested
-      user_id: options.user,
-      tags
-    });
-    if (result.success) {
-      spinner.succeed(chalk.green("URL content ingested!"));
-      if (result.chunks_created) {
-        console.log(chalk.dim(`Created ${result.chunks_created} memory chunks from URL`));
-      }
-      if (result.source_url) {
-        console.log(chalk.dim(`Source: ${result.source_url}`));
-      }
-    } else {
-      spinner.fail(chalk.red("Failed to ingest URL"));
-    }
-  } catch (err) {
-    spinner.fail(chalk.red("Failed to ingest URL"));
-    console.error(chalk.dim(String(err)));
-    process.exit(1);
-  }
-});
-program.command("ask-llm <question>").description("Ask a question using LLM with memory context (Memory Router)").option("-p, --provider <provider>", "LLM provider: openai, anthropic, gemini, ollama", "openai").option("-m, --model <model>", "Model to use").option("-k, --api-key <key>", "API key for the LLM provider").option("-u, --user <userId>", "User ID for memory context").option("--store", "Store the conversation in memory").action(async (question, options) => {
-  const config = getConfig();
-  const spinner = ora(`Asking ${options.provider}...`).start();
-  try {
-    const result = await makeRequest(config, "POST", "/api/v2/router", {
-      provider: options.provider,
-      model: options.model,
-      api_key: options.apiKey,
-      messages: [{ role: "user", content: question }],
-      user_id: options.user,
-      store_response: options.store
-    });
-    spinner.stop();
-    if (result.success && result.response) {
-      console.log(chalk.bold("\n\u{1F4DD} Response:\n"));
-      console.log(result.response);
-      console.log();
-      console.log(chalk.dim(`Model: ${result.model} | Memories used: ${result.memories_used || 0} | Latency: ${result.latency_ms}ms`));
-    } else {
-      console.log(chalk.red("Error: " + (result.error || "Unknown error")));
-    }
-  } catch (err) {
-    spinner.fail(chalk.red("Request failed"));
-    console.error(chalk.dim(String(err)));
-    process.exit(1);
-  }
-});
-program.command("connectors").description("List available external connectors and their status").action(async () => {
-  const config = getConfig();
-  const spinner = ora("Fetching connectors...").start();
-  try {
-    const result = await makeRequest(config, "GET", "/api/v1/connectors");
-    spinner.stop();
-    if (!result.connectors || result.connectors.length === 0) {
-      console.log(chalk.yellow("No connectors available"));
-      return;
-    }
-    console.log(chalk.bold("\nAvailable Connectors:\n"));
-    for (const c of result.connectors) {
-      const statusIcon = c.connected ? chalk.green("\u25CF") : chalk.dim("\u25CB");
-      const statusText = c.connected ? chalk.green("Connected") : chalk.dim("Not connected");
-      console.log(`${statusIcon} ${chalk.bold(c.name)} (${c.connector_type})`);
-      console.log(`  Status: ${statusText}`);
-      if (c.connected) {
-        console.log(chalk.dim(`  Last sync: ${c.last_sync || "Never"}`));
-        console.log(chalk.dim(`  Items synced: ${c.items_synced}`));
-      }
-      console.log();
-    }
-    console.log(chalk.dim('Use "cilow connect <type>" to connect a service.'));
-  } catch (err) {
-    spinner.fail(chalk.red("Failed to list connectors"));
-    console.error(chalk.dim(String(err)));
-    process.exit(1);
-  }
-});
-program.command("connect <connector>").description("Connect to an external service (notion, google_drive, gmail, slack, discord, linear, github, jira, onedrive)").action(async (connector) => {
-  const config = getConfig();
-  const spinner = ora(`Getting authorization URL for ${connector}...`).start();
-  try {
-    const result = await makeRequest(config, "GET", `/api/v1/connectors/${connector}/auth`);
-    spinner.stop();
-    console.log(chalk.bold("\nAuthorize Cilow to access your data:\n"));
-    console.log(chalk.cyan(result.auth_url));
-    console.log();
-    console.log(chalk.dim("Open this URL in your browser to authorize."));
-    console.log(chalk.dim("After authorization, run: cilow sync " + connector));
-  } catch (err) {
-    spinner.fail(chalk.red(`Failed to get auth URL for ${connector}`));
-    console.error(chalk.dim(String(err)));
-    process.exit(1);
-  }
-});
-program.command("sync <connector>").description("Sync data from a connected service into memory").option("--full", "Perform a full sync (not incremental)").option("-l, --limit <limit>", "Maximum items to sync", "100").action(async (connector, options) => {
-  const config = getConfig();
-  const spinner = ora(`Syncing data from ${connector}...`).start();
-  try {
-    const result = await makeRequest(config, "POST", `/api/v1/connectors/${connector}/sync`, {
-      full_sync: options.full || false,
-      limit: parseInt(options.limit)
-    });
-    if (result.status === "success" || result.status === "partialsuccess") {
-      spinner.succeed(chalk.green(`Synced ${result.items_synced} items from ${connector}`));
-      if (result.items_skipped > 0) {
-        console.log(chalk.dim(`Skipped: ${result.items_skipped} items`));
-      }
-      if (result.has_more) {
-        console.log(chalk.yellow("More items available. Run sync again to continue."));
-      }
-      if (result.errors.length > 0) {
-        console.log(chalk.yellow("\nWarnings:"));
-        for (const err of result.errors.slice(0, 5)) {
-          console.log(chalk.dim(`  - ${err}`));
-        }
-        if (result.errors.length > 5) {
-          console.log(chalk.dim(`  ... and ${result.errors.length - 5} more`));
-        }
-      }
-    } else {
-      spinner.fail(chalk.red(`Sync failed: ${result.status}`));
-      if (result.errors.length > 0) {
-        for (const err of result.errors) {
-          console.log(chalk.dim(`  - ${err}`));
-        }
-      }
+  console.log(`Version:  ${chalk.dim(VERSION)}`);
+  console.log(chalk.bold("\nMCP Integration:"));
+  console.log(chalk.dim("Add to Claude Code ~/.claude/settings.json:"));
+  console.log(chalk.cyan(`{
+  "mcpServers": {
+    "cilow": {
+      "command": "npx",
+      "args": ["@cilow/cli", "mcp"],
+      "env": { "CILOW_API_KEY": "${apiKey || "your-api-key"}" }
     }
-  } catch (err) {
-    spinner.fail(chalk.red(`Failed to sync ${connector}`));
-    console.error(chalk.dim(String(err)));
-    process.exit(1);
   }
+}`));
 });
-program.command("disconnect <connector>").description("Disconnect an external service and revoke access").action(async (connector) => {
+program.action(async () => {
   const config = getConfig();
-  const spinner = ora(`Disconnecting ${connector}...`).start();
-  try {
-    await makeRequest(config, "DELETE", `/api/v1/connectors/${connector}`);
-    spinner.succeed(chalk.green(`Disconnected from ${connector}`));
-  } catch (err) {
-    spinner.fail(chalk.red(`Failed to disconnect ${connector}`));
-    console.error(chalk.dim(String(err)));
-    process.exit(1);
-  }
+  await startChat(config, {});
 });
 program.parse();

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@cilow/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "CLI for Cilow - AI Memory Infrastructure",
   "bin": {
-    "cilow": "./dist/cli.mjs"
+    "cilow": "./dist/cli.js"
   },
-  "main": "dist/cli.mjs",
-  "module": "dist/cli.mjs",
-  "types": "dist/cli.d.mts",
+  "main": "dist/cli.js",
+  "module": "dist/cli.js",
+  "types": "dist/cli.d.ts",
   "type": "module",
   "files": [
     "dist"