chainlesschain 0.37.8 → 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

@@ -0,0 +1,288 @@
+/**
+ * LLM management commands
+ * 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");
+
+  // llm models - list available models
+  llm
+    .command("models")
+    .description("List available models from the current provider")
+    .option("--provider <provider>", "LLM provider", "ollama")
+    .option("--base-url <url>", "API base URL", "http://localhost:11434")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      const spinner = ora("Fetching models...").start();
+      try {
+        if (options.provider === "ollama") {
+          const response = await fetch(`${options.baseUrl}/api/tags`);
+          if (!response.ok) {
+            throw new Error(`Ollama not reachable: ${response.status}`);
+          }
+          const data = await response.json();
+          spinner.stop();
+
+          if (options.json) {
+            console.log(JSON.stringify(data.models, null, 2));
+          } else {
+            if (!data.models || data.models.length === 0) {
+              logger.info("No models installed. Run: ollama pull qwen2:7b");
+            } else {
+              logger.log(chalk.bold(`Models (${data.models.length}):\n`));
+              for (const m of data.models) {
+                const size = m.size
+                  ? chalk.gray(`(${(m.size / 1e9).toFixed(1)}GB)`)
+                  : "";
+                logger.log(`  ${chalk.cyan(m.name.padEnd(30))} ${size}`);
+              }
+            }
+          }
+        } else {
+          // 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}`);
+        process.exit(1);
+      }
+    });
+
+  // llm test - test connectivity
+  llm
+    .command("test")
+    .description("Test LLM provider connectivity")
+    .option("--provider <provider>", "LLM provider", "ollama")
+    .option("--model <model>", "Model to test", "qwen2:7b")
+    .option("--base-url <url>", "API base URL", "http://localhost:11434")
+    .option("--api-key <key>", "API key")
+    .action(async (options) => {
+      const spinner = ora(`Testing ${options.provider}...`).start();
+      try {
+        const start = Date.now();
+
+        if (options.provider === "ollama") {
+          const response = await fetch(`${options.baseUrl}/api/generate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              model: options.model,
+              prompt: "Say hi in one word.",
+              stream: false,
+            }),
+          });
+
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+          }
+
+          const data = await response.json();
+          const elapsed = Date.now() - start;
+
+          spinner.succeed(
+            `${chalk.green("Connected")} to Ollama (${options.model}) in ${elapsed}ms`,
+          );
+          logger.log(
+            `  Response: ${chalk.gray(data.response.trim().substring(0, 100))}`,
+          );
+        } else if (options.provider === "openai") {
+          const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+          if (!apiKey) throw new Error("API key required");
+
+          const url =
+            options.baseUrl !== "http://localhost:11434"
+              ? options.baseUrl
+              : "https://api.openai.com/v1";
+
+          const response = await fetch(`${url}/chat/completions`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+              model: options.model || "gpt-4o-mini",
+              messages: [{ role: "user", content: "Say hi in one word." }],
+              max_tokens: 10,
+            }),
+          });
+
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+          }
+
+          const data = await response.json();
+          const elapsed = Date.now() - start;
+
+          spinner.succeed(
+            `${chalk.green("Connected")} to OpenAI (${options.model || "gpt-4o-mini"}) in ${elapsed}ms`,
+          );
+          logger.log(
+            `  Response: ${chalk.gray(data.choices[0].message.content.trim())}`,
+          );
+        } else {
+          spinner.fail(`Unknown provider: ${options.provider}`);
+        }
+      } catch (err) {
+        spinner.fail(`Test failed: ${err.message}`);
+        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);
+      }
+    });
+}