chainlesschain 0.37.9 → 0.37.11

package/src/commands/mcp.js

@@ -0,0 +1,302 @@
+/**
+ * MCP (Model Context Protocol) commands
+ * chainlesschain mcp servers|connect|disconnect|tools|call
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import { MCPClient, MCPServerConfig } from "../lib/mcp-client.js";
+
+// Singleton MCP client for session reuse
+let mcpClient = null;
+
+function getClient() {
+  if (!mcpClient) mcpClient = new MCPClient();
+  return mcpClient;
+}
+
+export function registerMcpCommand(program) {
+  const mcp = program
+    .command("mcp")
+    .description("MCP server management and tool execution");
+
+  // mcp servers — list configured servers
+  mcp
+    .command("servers")
+    .description("List configured MCP servers")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+
+        const db = ctx.db.getDatabase();
+        const config = new MCPServerConfig(db);
+        const servers = config.list();
+
+        if (options.json) {
+          console.log(JSON.stringify(servers, null, 2));
+        } else if (servers.length === 0) {
+          logger.info("No MCP servers configured. Use 'mcp add' to add one.");
+        } else {
+          logger.log(chalk.bold(`MCP Servers (${servers.length}):\n`));
+          for (const s of servers) {
+            const auto = s.autoConnect ? chalk.green(" [auto]") : "";
+            logger.log(`  ${chalk.cyan(s.name)}${auto}`);
+            logger.log(
+              `    ${chalk.gray("Command:")} ${s.command} ${s.args.join(" ")}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mcp add — add/update a server config
+  mcp
+    .command("add")
+    .description("Add or update an MCP server configuration")
+    .argument("<name>", "Server name")
+    .requiredOption("-c, --command <cmd>", "Server command to run")
+    .option("-a, --args <args>", "Command arguments (comma-separated)")
+    .option("--auto-connect", "Auto-connect on startup")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+
+        const db = ctx.db.getDatabase();
+        const config = new MCPServerConfig(db);
+        const args = options.args
+          ? options.args.split(",").map((a) => a.trim())
+          : [];
+
+        config.add(name, {
+          command: options.command,
+          args,
+          autoConnect: !!options.autoConnect,
+        });
+
+        if (options.json) {
+          console.log(
+            JSON.stringify({
+              name,
+              command: options.command,
+              args,
+              autoConnect: !!options.autoConnect,
+            }),
+          );
+        } else {
+          logger.success(`MCP server "${chalk.cyan(name)}" configured`);
+          logger.log(
+            `  ${chalk.gray("Command:")} ${options.command} ${args.join(" ")}`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mcp remove — remove a server config
+  mcp
+    .command("remove")
+    .description("Remove an MCP server configuration")
+    .argument("<name>", "Server name")
+    .action(async (name) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+
+        const db = ctx.db.getDatabase();
+        const config = new MCPServerConfig(db);
+        const removed = config.remove(name);
+
+        if (removed) {
+          logger.success(`MCP server "${name}" removed`);
+        } else {
+          logger.error(`Server "${name}" not found`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mcp connect — connect to a server
+  mcp
+    .command("connect")
+    .description("Connect to an MCP server")
+    .argument("<name>", "Server name (configured or command)")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+
+        const db = ctx.db.getDatabase();
+        const config = new MCPServerConfig(db);
+        const serverConfig = config.get(name);
+
+        if (!serverConfig) {
+          logger.error(`Server "${name}" not configured. Use 'mcp add' first.`);
+          process.exit(1);
+        }
+
+        const spinner = ora(`Connecting to ${name}...`).start();
+        const client = getClient();
+
+        const result = await client.connect(name, serverConfig);
+        spinner.stop();
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success(`Connected to ${chalk.cyan(name)}`);
+          logger.log(`  ${chalk.gray("Tools:")} ${result.tools.length}`);
+          logger.log(
+            `  ${chalk.gray("Resources:")} ${result.resources.length}`,
+          );
+          if (result.serverInfo?.name) {
+            logger.log(`  ${chalk.gray("Server:")} ${result.serverInfo.name}`);
+          }
+        }
+
+        // Don't shutdown — keep connection alive for subsequent calls
+      } catch (err) {
+        logger.error(`Connection failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mcp disconnect — disconnect from a server
+  mcp
+    .command("disconnect")
+    .description("Disconnect from an MCP server")
+    .argument("<name>", "Server name")
+    .action(async (name) => {
+      try {
+        const client = getClient();
+        const ok = await client.disconnect(name);
+        if (ok) {
+          logger.success(`Disconnected from ${name}`);
+        } else {
+          logger.error(`Server "${name}" not connected`);
+        }
+      } catch (err) {
+        logger.error(`Disconnect failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mcp tools — list available tools
+  mcp
+    .command("tools")
+    .description("List available MCP tools")
+    .option("-s, --server <name>", "Filter by server name")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const client = getClient();
+        const tools = client.listTools(options.server);
+
+        if (options.json) {
+          console.log(JSON.stringify(tools, null, 2));
+        } else if (tools.length === 0) {
+          logger.info("No tools available. Connect to a server first.");
+        } else {
+          logger.log(chalk.bold(`MCP Tools (${tools.length}):\n`));
+          for (const t of tools) {
+            logger.log(
+              `  ${chalk.cyan(t.name)} ${chalk.gray(`[${t.server}]`)}`,
+            );
+            if (t.description) {
+              logger.log(`    ${chalk.gray(t.description)}`);
+            }
+          }
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mcp call — call a tool
+  mcp
+    .command("call")
+    .description("Call an MCP tool")
+    .argument("<tool>", "Tool name")
+    .option("-s, --server <name>", "Server name")
+    .option("-a, --args <json>", "Tool arguments as JSON")
+    .option("--json", "Output as JSON")
+    .action(async (tool, options) => {
+      try {
+        const client = getClient();
+
+        // Find which server has this tool
+        let serverName = options.server;
+        if (!serverName) {
+          const allTools = client.listTools();
+          const match = allTools.find((t) => t.name === tool);
+          if (!match) {
+            logger.error(
+              `Tool "${tool}" not found. Run 'mcp tools' to see available tools.`,
+            );
+            process.exit(1);
+          }
+          serverName = match.server;
+        }
+
+        const args = options.args ? JSON.parse(options.args) : {};
+        const spinner = ora(`Calling ${tool}...`).start();
+
+        const result = await client.callTool(serverName, tool, args);
+        spinner.stop();
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          // Display content blocks
+          if (result?.content) {
+            for (const block of result.content) {
+              if (block.type === "text") {
+                logger.log(block.text);
+              } else if (block.type === "image") {
+                logger.log(chalk.gray(`[Image: ${block.mimeType || "image"}]`));
+              } else {
+                logger.log(JSON.stringify(block, null, 2));
+              }
+            }
+          } else {
+            logger.log(JSON.stringify(result, null, 2));
+          }
+        }
+      } catch (err) {
+        logger.error(`Tool call failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/memory.js

@@ -0,0 +1,282 @@
+/**
+ * Persistent memory management commands
+ * chainlesschain memory show|add|search|daily|file
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  getMemoryDir,
+  addMemory,
+  searchMemory,
+  listMemory,
+  deleteMemory,
+  appendDailyNote,
+  getDailyNote,
+  listDailyNotes,
+  getMemoryFile,
+  updateMemoryFile,
+} from "../lib/memory-manager.js";
+
+export function registerMemoryCommand(program) {
+  const memory = program
+    .command("memory")
+    .description("Persistent memory and daily notes");
+
+  // memory show
+  memory
+    .command("show", { isDefault: true })
+    .description("Show memory entries")
+    .option("-n, --limit <n>", "Max entries", "20")
+    .option("--category <cat>", "Filter by category")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const entries = listMemory(db, {
+          limit: Math.max(1, parseInt(options.limit) || 20),
+          category: options.category,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(entries, null, 2));
+        } else if (entries.length === 0) {
+          logger.info("No memory entries. Use 'memory add' to create one.");
+        } else {
+          logger.log(chalk.bold(`Memory (${entries.length} entries):\n`));
+          for (const e of entries) {
+            const stars =
+              "★".repeat(e.importance) + "☆".repeat(5 - e.importance);
+            logger.log(
+              `  ${chalk.gray(e.id.slice(0, 12))}  ${chalk.yellow(stars)}  ${chalk.cyan(e.category)}`,
+            );
+            logger.log(
+              `    ${chalk.white(e.content.substring(0, 120).replace(/\n/g, " "))}`,
+            );
+            logger.log(`    ${chalk.gray(e.created_at)}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // memory add
+  memory
+    .command("add")
+    .description("Add a memory entry")
+    .argument("<text>", "Memory content")
+    .option("--category <cat>", "Category", "general")
+    .option("--importance <n>", "Importance 1-5", "3")
+    .option("--json", "Output as JSON")
+    .action(async (text, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const entry = addMemory(db, text, {
+          category: options.category,
+          importance: Math.max(
+            1,
+            Math.min(5, parseInt(options.importance) || 3),
+          ),
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(entry, null, 2));
+        } else {
+          logger.success(
+            `Memory added: ${chalk.gray(entry.id.slice(0, 12))} [${chalk.cyan(entry.category)}]`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // memory search
+  memory
+    .command("search")
+    .description("Search memory entries")
+    .argument("<query>", "Search query")
+    .option("-n, --limit <n>", "Max results", "20")
+    .option("--json", "Output as JSON")
+    .action(async (query, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const results = searchMemory(db, query, {
+          limit: Math.max(1, parseInt(options.limit) || 20),
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+        } else if (results.length === 0) {
+          logger.info(`No memory entries matching "${query}"`);
+        } else {
+          logger.log(
+            chalk.bold(
+              `Memory search "${query}" (${results.length} results):\n`,
+            ),
+          );
+          for (const e of results) {
+            logger.log(
+              `  ${chalk.gray(e.id.slice(0, 12))}  ${chalk.cyan(e.category)}  ${chalk.gray(e.created_at)}`,
+            );
+            logger.log(
+              `    ${chalk.white(e.content.substring(0, 120).replace(/\n/g, " "))}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // memory delete
+  memory
+    .command("delete")
+    .description("Delete a memory entry")
+    .argument("<id>", "Entry ID (or prefix)")
+    .action(async (id) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const ok = deleteMemory(db, id);
+        if (ok) {
+          logger.success("Memory entry deleted");
+        } else {
+          logger.error(`Memory entry not found: ${id}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // memory daily
+  memory
+    .command("daily")
+    .description("View or append to daily notes")
+    .argument("[date]", "Date (YYYY-MM-DD, default: today)")
+    .option("-a, --append <text>", "Append text to daily note")
+    .option("--list", "List available daily notes")
+    .option("--json", "Output as JSON")
+    .action(async (date, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const memoryDir = getMemoryDir(ctx.env.dataDir);
+
+        if (options.list) {
+          const notes = listDailyNotes(memoryDir);
+          if (options.json) {
+            console.log(JSON.stringify(notes, null, 2));
+          } else if (notes.length === 0) {
+            logger.info("No daily notes yet");
+          } else {
+            logger.log(chalk.bold("Daily Notes:\n"));
+            for (const n of notes) {
+              logger.log(
+                `  ${chalk.cyan(n.date)}  ${chalk.gray(n.size + " bytes")}`,
+              );
+            }
+          }
+          await shutdown();
+          return;
+        }
+
+        if (options.append) {
+          const result = appendDailyNote(memoryDir, options.append);
+          logger.success(`Added to daily note: ${chalk.cyan(result.date)}`);
+          await shutdown();
+          return;
+        }
+
+        // Show daily note
+        const targetDate = date || new Date().toISOString().slice(0, 10);
+        const content = getDailyNote(memoryDir, targetDate);
+
+        if (!content) {
+          logger.info(`No daily note for ${targetDate}`);
+        } else if (options.json) {
+          console.log(JSON.stringify({ date: targetDate, content }, null, 2));
+        } else {
+          logger.log(content);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // memory file
+  memory
+    .command("file")
+    .description("View or edit the long-term MEMORY.md file")
+    .option("--edit", "Open in $EDITOR")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const memoryDir = getMemoryDir(ctx.env.dataDir);
+        const content = getMemoryFile(memoryDir);
+
+        if (options.edit) {
+          const { execSync } = await import("child_process");
+          const editor = process.env.EDITOR || process.env.VISUAL || "nano";
+          const filePath = `${memoryDir}/MEMORY.md`;
+          try {
+            execSync(`${editor} "${filePath}"`, { stdio: "inherit" });
+            logger.success("Memory file updated");
+          } catch {
+            logger.error(
+              `Failed to open editor. Set $EDITOR environment variable.`,
+            );
+          }
+        } else if (options.json) {
+          console.log(JSON.stringify({ content }, null, 2));
+        } else if (!content) {
+          logger.info(
+            "MEMORY.md is empty. Use 'memory file --edit' to add content.",
+          );
+        } else {
+          logger.log(content);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}