chainlesschain 0.37.9 → 0.37.11

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/lowcode.js

@@ -0,0 +1,320 @@
+/**
+ * Low-Code Platform commands
+ * chainlesschain lowcode create|list|preview|publish|components|datasource|versions|rollback|export|deploy
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureLowcodeTables,
+  createApp,
+  saveDesign,
+  previewApp,
+  publishApp,
+  listComponents,
+  addDataSource,
+  getVersions,
+  rollbackApp,
+  exportApp,
+  listApps,
+} from "../lib/app-builder.js";
+
+export function registerLowcodeCommand(program) {
+  const lowcode = program
+    .command("lowcode")
+    .description("Low-code application platform");
+
+  // lowcode create <name>
+  lowcode
+    .command("create")
+    .description("Create a new low-code application")
+    .argument("<name>", "Application name")
+    .option("--description <desc>", "Application description", "")
+    .option(
+      "--platform <platform>",
+      "Target platform (web|desktop|mobile|all)",
+      "web",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      const spinner = ora("Creating application...").start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        const result = createApp(db, {
+          name,
+          description: options.description,
+          platform: options.platform,
+        });
+
+        spinner.stop();
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(
+            chalk.green(`Application created: ${chalk.bold(result.name)}`),
+          );
+          logger.log(`  ID:     ${chalk.cyan(result.id)}`);
+          logger.log(`  Status: ${result.status}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // lowcode list
+  lowcode
+    .command("list")
+    .description("List all low-code applications")
+    .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();
+        ensureLowcodeTables(db);
+
+        const apps = listApps(db);
+
+        if (options.json) {
+          console.log(JSON.stringify(apps, null, 2));
+        } else if (apps.length === 0) {
+          logger.info(
+            'No applications found. Create one with "chainlesschain lowcode create <name>"',
+          );
+        } else {
+          logger.log(chalk.bold(`Applications (${apps.length}):\n`));
+          for (const app of apps) {
+            const status =
+              app.status === "published"
+                ? chalk.green(app.status)
+                : chalk.yellow(app.status);
+            logger.log(
+              `  ${chalk.cyan(app.name)} [${status}] v${app.version} (${app.platform})`,
+            );
+            if (app.description)
+              logger.log(`    ${chalk.gray(app.description)}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // lowcode preview <app-id>
+  lowcode
+    .command("preview")
+    .description("Preview application info")
+    .argument("<app-id>", "Application ID")
+    .action(async (appId) => {
+      try {
+        const preview = previewApp(appId);
+
+        logger.log(chalk.bold("Application Preview:"));
+        logger.log(`  App ID:      ${chalk.cyan(preview.appId)}`);
+        logger.log(`  Platform:    ${preview.platform}`);
+        logger.log(`  Preview URL: ${chalk.underline(preview.previewUrl)}`);
+        logger.log(
+          `  Components:  ${(preview.design.components || []).length}`,
+        );
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // lowcode publish <app-id>
+  lowcode
+    .command("publish")
+    .description("Publish an application")
+    .argument("<app-id>", "Application ID")
+    .action(async (appId) => {
+      const spinner = ora("Publishing application...").start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        const result = publishApp(db, appId);
+        spinner.succeed(`Application ${chalk.cyan(appId)} published`);
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // lowcode components
+  lowcode
+    .command("components")
+    .description("List available built-in components")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const components = listComponents();
+
+      if (options.json) {
+        console.log(JSON.stringify(components, null, 2));
+      } else {
+        logger.log(chalk.bold(`Built-in Components (${components.length}):\n`));
+        const categories = [...new Set(components.map((c) => c.category))];
+        for (const cat of categories) {
+          logger.log(chalk.yellow(`  [${cat}]`));
+          for (const comp of components.filter((c) => c.category === cat)) {
+            logger.log(
+              `    ${chalk.cyan(comp.name)} — props: ${comp.props.join(", ")}`,
+            );
+          }
+        }
+      }
+    });
+
+  // lowcode datasource <app-id> <name> <type>
+  lowcode
+    .command("datasource")
+    .description("Add a data source to an application")
+    .argument("<app-id>", "Application ID")
+    .argument("<name>", "Data source name")
+    .argument("<type>", "Data source type (rest|graphql|database|csv)")
+    .option("--config <json>", "Configuration as JSON string", "{}")
+    .action(async (appId, name, type, options) => {
+      const spinner = ora("Adding data source...").start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        let config;
+        try {
+          config = JSON.parse(options.config);
+        } catch (_err) {
+          // Intentionally ignore parse error — use empty config
+          config = {};
+        }
+
+        const result = addDataSource(db, appId, name, type, config);
+        spinner.succeed(`Data source "${chalk.cyan(name)}" added (${type})`);
+        logger.log(`  ID: ${chalk.gray(result.id)}`);
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // lowcode versions <app-id>
+  lowcode
+    .command("versions")
+    .description("Show version history for an application")
+    .argument("<app-id>", "Application ID")
+    .option("--json", "Output as JSON")
+    .action((appId, options) => {
+      const versions = getVersions(appId);
+
+      if (options.json) {
+        console.log(JSON.stringify(versions, null, 2));
+      } else if (versions.length === 0) {
+        logger.info("No versions found for this application");
+      } else {
+        logger.log(chalk.bold(`Version History (${versions.length}):\n`));
+        for (const v of versions) {
+          logger.log(`  v${v.version} — ${v.created_at || "unknown date"}`);
+        }
+      }
+    });
+
+  // lowcode rollback <app-id> <version>
+  lowcode
+    .command("rollback")
+    .description("Rollback application to a previous version")
+    .argument("<app-id>", "Application ID")
+    .argument("<version>", "Version number to restore")
+    .action(async (appId, version) => {
+      const spinner = ora(`Rolling back to version ${version}...`).start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        const result = rollbackApp(db, appId, parseInt(version, 10));
+
+        if (result.restored) {
+          spinner.succeed(`Rolled back to version ${version}`);
+        } else {
+          spinner.fail(`Version ${version} not found`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // lowcode export <app-id>
+  lowcode
+    .command("export")
+    .description("Export application definition")
+    .argument("<app-id>", "Application ID")
+    .option("--json", "Output as JSON")
+    .action((appId, options) => {
+      const result = exportApp(appId);
+
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        logger.log(chalk.bold("Application Export:"));
+        logger.log(`  App ID:       ${chalk.cyan(result.appId)}`);
+        logger.log(
+          `  App:          ${result.app ? result.app.name : "not found"}`,
+        );
+        logger.log(`  Data Sources: ${result.dataSources.length}`);
+        logger.log(`  Versions:     ${result.versions.length}`);
+      }
+    });
+
+  // lowcode deploy <app-id>
+  lowcode
+    .command("deploy")
+    .description("Deploy application (placeholder)")
+    .argument("<app-id>", "Application ID")
+    .action(async (appId) => {
+      logger.log(
+        chalk.yellow(
+          `Deploy for app ${chalk.cyan(appId)} is a placeholder. ` +
+            "Full deployment support coming in a future release.",
+        ),
+      );
+    });
+}