chainlesschain 0.37.9 → 0.37.10

package/src/commands/instinct.js

@@ -0,0 +1,202 @@
+/**
+ * Instinct learning commands
+ * chainlesschain instinct show|reset|categories
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  getInstincts,
+  getStrongInstincts,
+  resetInstincts,
+  deleteInstinct,
+  decayInstincts,
+  generateInstinctPrompt,
+  INSTINCT_CATEGORIES,
+} from "../lib/instinct-manager.js";
+
+export function registerInstinctCommand(program) {
+  const instinct = program
+    .command("instinct")
+    .description("Instinct learning — learned user preferences");
+
+  // instinct show
+  instinct
+    .command("show", { isDefault: true })
+    .description("Show learned instincts")
+    .option("--category <cat>", "Filter by category")
+    .option("-n, --limit <n>", "Max entries", "30")
+    .option("--strong", "Show only high-confidence instincts (>= 70%)")
+    .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 instincts = options.strong
+          ? getStrongInstincts(db)
+          : getInstincts(db, {
+              category: options.category,
+              limit: parseInt(options.limit) || 30,
+            });
+
+        if (options.json) {
+          console.log(JSON.stringify(instincts, null, 2));
+        } else if (instincts.length === 0) {
+          logger.info(
+            "No instincts learned yet. Use the agent to build up preferences.",
+          );
+        } else {
+          logger.log(chalk.bold(`Learned Instincts (${instincts.length}):\n`));
+          for (const inst of instincts) {
+            const pct = (inst.confidence * 100).toFixed(0);
+            const bar =
+              "█".repeat(Math.round(inst.confidence * 10)) +
+              "░".repeat(10 - Math.round(inst.confidence * 10));
+            logger.log(
+              `  ${chalk.gray(inst.id.slice(0, 8))}  ${chalk.cyan(inst.category.padEnd(18))} ${bar} ${pct}%`,
+            );
+            logger.log(`    ${chalk.white(inst.pattern)}`);
+            logger.log(
+              `    ${chalk.gray(`seen ${inst.occurrences}x | last: ${inst.last_seen || "unknown"}`)}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // instinct categories
+  instinct
+    .command("categories")
+    .description("List instinct categories")
+    .action(async () => {
+      logger.log(chalk.bold("Instinct Categories:\n"));
+      for (const [key, value] of Object.entries(INSTINCT_CATEGORIES)) {
+        logger.log(`  ${chalk.cyan(value.padEnd(20))} ${chalk.gray(key)}`);
+      }
+    });
+
+  // instinct prompt
+  instinct
+    .command("prompt")
+    .description("Generate a system prompt from learned instincts")
+    .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 prompt = generateInstinctPrompt(db);
+
+        if (options.json) {
+          console.log(JSON.stringify({ prompt }, null, 2));
+        } else if (!prompt) {
+          logger.info("No strong instincts yet. Keep using the agent!");
+        } else {
+          logger.log(prompt);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // instinct delete
+  instinct
+    .command("delete")
+    .description("Delete an instinct by ID")
+    .argument("<id>", "Instinct 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 = deleteInstinct(db, id);
+        if (ok) {
+          logger.success("Instinct deleted");
+        } else {
+          logger.error(`Instinct not found: ${id}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // instinct reset
+  instinct
+    .command("reset")
+    .description("Reset all learned instincts")
+    .option("--force", "Skip confirmation")
+    .action(async (options) => {
+      try {
+        if (!options.force) {
+          const { confirm } = await import("@inquirer/prompts");
+          const ok = await confirm({
+            message: "Reset all learned instincts? This cannot be undone.",
+          });
+          if (!ok) {
+            logger.info("Cancelled");
+            return;
+          }
+        }
+
+        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 count = resetInstincts(db);
+        logger.success(`Reset ${count} instincts`);
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // instinct decay
+  instinct
+    .command("decay")
+    .description("Decay old instincts (reduce confidence of unused patterns)")
+    .option("--days <n>", "Days threshold", "30")
+    .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 decayed = decayInstincts(db, parseInt(options.days) || 30);
+        logger.success(`Decayed ${decayed} old instincts`);
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/llm.js

@@ -1,11 +1,16 @@
 /**
  * LLM management commands
- * chainlesschain llm list|test|models
+ * chainlesschain llm models|test|providers|add-provider|switch
  */
 
 import ora from "ora";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  BUILT_IN_PROVIDERS,
+  LLMProviderRegistry,
+} from "../lib/llm-providers.js";
 
 export function registerLlmCommand(program) {
   const llm = program.command("llm").description("LLM provider management");
@@ -44,9 +49,21 @@ export function registerLlmCommand(program) {
             }
           }
         } else {
-          spinner.fail(
-            `Model listing not supported for provider: ${options.provider}`,
-          );
+          // Show known models for non-Ollama providers
+          spinner.stop();
+          const provider = BUILT_IN_PROVIDERS[options.provider];
+          if (provider) {
+            if (options.json) {
+              console.log(JSON.stringify(provider.models, null, 2));
+            } else {
+              logger.log(chalk.bold(`${provider.displayName} Models:\n`));
+              for (const m of provider.models) {
+                logger.log(`  ${chalk.cyan(m)}`);
+              }
+            }
+          } else {
+            logger.error(`Unknown provider: ${options.provider}`);
+          }
         }
       } catch (err) {
         spinner.fail(`Failed to list models: ${err.message}`);
@@ -134,4 +151,138 @@ export function registerLlmCommand(program) {
         process.exit(1);
       }
     });
+
+  // llm providers - list all available providers
+  llm
+    .command("providers")
+    .description("List all available LLM providers")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          // Fall back to built-in list without DB
+          const providers = Object.values(BUILT_IN_PROVIDERS);
+          if (options.json) {
+            console.log(JSON.stringify(providers, null, 2));
+          } else {
+            logger.log(chalk.bold(`LLM Providers (${providers.length}):\n`));
+            for (const p of providers) {
+              const hasKey = p.apiKeyEnv
+                ? process.env[p.apiKeyEnv]
+                  ? chalk.green("✓")
+                  : chalk.red("✗")
+                : chalk.green("✓");
+              logger.log(
+                `  ${hasKey} ${chalk.cyan(p.name.padEnd(15))} ${p.displayName}`,
+              );
+              logger.log(`    ${chalk.gray("Models:")} ${p.models.join(", ")}`);
+            }
+          }
+          await shutdown();
+          return;
+        }
+
+        const db = ctx.db.getDatabase();
+        const registry = new LLMProviderRegistry(db);
+        const providers = registry.list();
+        const active = registry.getActive();
+
+        if (options.json) {
+          console.log(JSON.stringify({ active, providers }, null, 2));
+        } else {
+          logger.log(chalk.bold(`LLM Providers (${providers.length}):\n`));
+          for (const p of providers) {
+            const isActive = p.name === active ? chalk.green(" [active]") : "";
+            const keyStatus = p.hasApiKey
+              ? chalk.green("✓")
+              : chalk.red("✗ key missing");
+            const custom = p.custom ? chalk.yellow(" [custom]") : "";
+            logger.log(
+              `  ${keyStatus} ${chalk.cyan(p.name.padEnd(15))} ${p.displayName}${isActive}${custom}`,
+            );
+            logger.log(`    ${chalk.gray("Models:")} ${p.models.join(", ")}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // llm add-provider - add a custom provider
+  llm
+    .command("add-provider")
+    .description("Add a custom LLM provider")
+    .argument("<name>", "Provider name")
+    .requiredOption("-u, --base-url <url>", "API base URL")
+    .option("-d, --display-name <name>", "Display name")
+    .option("-k, --api-key-env <var>", "Environment variable for API key")
+    .option("-m, --models <models>", "Comma-separated model names")
+    .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 registry = new LLMProviderRegistry(db);
+        const provider = registry.addProvider(name, {
+          displayName: options.displayName || name,
+          baseUrl: options.baseUrl,
+          apiKeyEnv: options.apiKeyEnv,
+          models: options.models
+            ? options.models.split(",").map((m) => m.trim())
+            : [],
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(provider, null, 2));
+        } else {
+          logger.success(`Added provider ${chalk.cyan(name)}`);
+          logger.log(`  ${chalk.gray("URL:")} ${provider.baseUrl}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // llm switch - switch active provider
+  llm
+    .command("switch")
+    .description("Switch the active LLM provider")
+    .argument("<name>", "Provider name")
+    .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 registry = new LLMProviderRegistry(db);
+        const provider = registry.setActive(name);
+
+        if (options.json) {
+          console.log(JSON.stringify({ active: name, provider }, null, 2));
+        } else {
+          logger.success(`Switched to ${chalk.cyan(provider.displayName)}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }

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);
+      }
+    });
+}