@cilow/cli 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,416 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+var DEFAULT_API_URL = "https://cilow-gateway-c8ozzar9.uc.gateway.dev";
+function getConfig() {
+  const apiKey = process.env.CILOW_API_KEY;
+  const apiUrl = process.env.CILOW_API_URL || DEFAULT_API_URL;
+  if (!apiKey) {
+    console.error(chalk.red("Error: CILOW_API_KEY environment variable not set"));
+    console.error(chalk.dim("Get your API key at https://cilow.ai/dashboard"));
+    process.exit(1);
+  }
+  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}`;
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.apiKey.startsWith("cilow_")) {
+    headers["X-API-Key"] = config.apiKey;
+  } else {
+    headers["Authorization"] = `Bearer ${config.apiKey}`;
+  }
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!response.ok) {
+    const errText = await response.text();
+    throw new Error(`API Error (${response.status}): ${errText}`);
+  }
+  const text = await response.text();
+  return text ? JSON.parse(text) : null;
+}
+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) => {
+  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
+    });
+    spinner.succeed(chalk.green("Memory stored!"));
+    console.log(chalk.dim(`ID: ${result.memory_id}`));
+  } catch (err) {
+    spinner.fail(chalk.red("Failed to store memory"));
+    console.error(chalk.dim(String(err)));
+    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) => {
+  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
+    });
+    spinner.stop();
+    if (!result.results || result.results.length === 0) {
+      console.log(chalk.yellow("No memories found"));
+      return;
+    }
+    console.log(chalk.bold(`
+Found ${result.results.length} memories:
+`));
+    for (let i = 0; i < result.results.length; i++) {
+      const r = result.results[i];
+      const score = (r.similarity * 100).toFixed(1);
+      console.log(chalk.cyan(`${i + 1}. [${score}%]`) + ` ${r.content}`);
+      if (r.tags && r.tags.length > 0) {
+        console.log(chalk.dim(`   Tags: ${r.tags.join(", ")}`));
+      }
+      console.log();
+    }
+  } catch (err) {
+    spinner.fail(chalk.red("Search failed"));
+    console.error(chalk.dim(String(err)));
+    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) => {
+  const config = getConfig();
+  const spinner = ora("Thinking...").start();
+  try {
+    const result = await makeRequest(config, "POST", "/api/v1/memory/search", {
+      query: question,
+      limit: 5,
+      user_id: options.user
+    });
+    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);
+      }
+    }
+  } catch (err) {
+    spinner.fail(chalk.red("Recall failed"));
+    console.error(chalk.dim(String(err)));
+    process.exit(1);
+  }
+});
+program.command("health").description("Check API health").action(async () => {
+  const config = getConfig();
+  const spinner = ora("Checking...").start();
+  try {
+    await makeRequest(config, "GET", "/health");
+    spinner.succeed(chalk.green("Cilow API is healthy!"));
+  } catch (err) {
+    spinner.fail(chalk.red("API is not responding"));
+    console.error(chalk.dim(String(err)));
+    process.exit(1);
+  }
+});
+program.command("config").description("Show current configuration").action(() => {
+  const apiUrl = process.env.CILOW_API_URL || DEFAULT_API_URL;
+  const apiKey = process.env.CILOW_API_KEY || "";
+  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}`));
+        }
+      }
+    }
+  } 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) => {
+  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);
+  }
+});
+program.parse();

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@cilow/cli",
+  "version": "0.1.0",
+  "description": "CLI for Cilow - AI Memory Infrastructure",
+  "bin": {
+    "cilow": "./dist/cli.mjs"
+  },
+  "main": "dist/cli.mjs",
+  "module": "dist/cli.mjs",
+  "types": "dist/cli.d.mts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/cli.ts --format esm --dts --clean",
+    "dev": "tsup src/cli.ts --format esm --watch",
+    "start": "node dist/cli.js"
+  },
+  "keywords": [
+    "cilow",
+    "ai",
+    "memory",
+    "llm",
+    "cli"
+  ],
+  "author": "Cilow Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cilow-ai/cilow"
+  },
+  "homepage": "https://cilow.ai",
+  "dependencies": {
+    "commander": "^12.0.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.0",
+    "inquirer": "^9.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "tsup": "^8.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}