chainlesschain 0.37.10 → 0.37.12

package/src/commands/evolution.js

@@ -0,0 +1,398 @@
+/**
+ * Self-Evolving System commands
+ * chainlesschain evolution assess|learn|diagnose|repair|predict|growth|stats|export
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  assessCapability,
+  trainIncremental,
+  selfDiagnose,
+  selfRepair,
+  predictBehavior,
+  getGrowthLog,
+  getCapabilities,
+  getModels,
+  exportModel,
+} from "../lib/evolution-system.js";
+
+export function registerEvolutionCommand(program) {
+  const evolution = program
+    .command("evolution")
+    .description("Self-evolving AI system — capabilities, learning, diagnosis");
+
+  // evolution assess <name> <score>
+  evolution
+    .command("assess")
+    .description("Assess and track a capability")
+    .argument("<name>", "Capability name")
+    .argument("<score>", "Score (0-1)")
+    .option("--category <cat>", "Capability category", "general")
+    .option("--json", "Output as JSON")
+    .action(async (name, score, 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 spinner = ora(`Assessing capability: ${name}...`).start();
+
+        const result = assessCapability(
+          db,
+          name,
+          parseFloat(score),
+          options.category,
+        );
+        spinner.succeed("Capability assessed");
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          const trendIcon =
+            result.trend === "improving"
+              ? chalk.green("improving")
+              : result.trend === "declining"
+                ? chalk.red("declining")
+                : chalk.gray("stable");
+          logger.log(chalk.bold(`Capability: ${result.name}`));
+          logger.log(`  Score:    ${chalk.cyan(result.score)}`);
+          logger.log(`  Trend:    ${trendIcon}`);
+          logger.log(`  History:  ${result.history.length} assessments`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // evolution learn <model-id>
+  evolution
+    .command("learn")
+    .description("Train a model with incremental data")
+    .argument("<model-id>", "Model ID to train")
+    .option("--data <json>", "Training data as JSON array")
+    .option(
+      "--type <type>",
+      "Model type (classification|regression)",
+      "classification",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (modelId, 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 spinner = ora(`Training model: ${modelId}...`).start();
+
+        let data = [{ sample: true }];
+        if (options.data) {
+          try {
+            data = JSON.parse(options.data);
+          } catch (_err) {
+            // Use data string as single data point
+            data = [options.data];
+          }
+        }
+
+        const result = trainIncremental(db, modelId, data, {
+          type: options.type,
+        });
+        spinner.succeed("Model trained");
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(chalk.bold(`Model: ${result.name}`));
+          logger.log(`  Type:       ${result.type}`);
+          logger.log(`  Accuracy:   ${chalk.cyan(result.accuracy.toFixed(4))}`);
+          logger.log(`  Data Points: ${result.dataPoints}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // evolution diagnose
+  evolution
+    .command("diagnose")
+    .description("Run self-diagnosis on the system")
+    .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 spinner = ora("Running self-diagnosis...").start();
+
+        const result = selfDiagnose(db);
+        spinner.succeed("Diagnosis complete");
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          const statusColor =
+            result.overallStatus === "healthy" ? chalk.green : chalk.yellow;
+          logger.log(
+            chalk.bold(`Overall Status: ${statusColor(result.overallStatus)}`),
+          );
+
+          logger.log(chalk.bold("\nComponents:"));
+          for (const c of result.components) {
+            const icon =
+              c.status === "healthy" ? chalk.green("OK") : chalk.yellow("WARN");
+            logger.log(`  ${icon} ${c.name}`);
+          }
+
+          if (result.issues.length > 0) {
+            logger.log(chalk.bold("\nIssues:"));
+            for (const issue of result.issues) {
+              logger.log(`  - ${chalk.yellow(issue.type)}: ${issue.details}`);
+            }
+          }
+
+          if (result.recommendations.length > 0) {
+            logger.log(chalk.bold("\nRecommendations:"));
+            for (const rec of result.recommendations) {
+              logger.log(`  - ${rec}`);
+            }
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // evolution repair <issue>
+  evolution
+    .command("repair")
+    .description("Self-repair a diagnosed issue")
+    .argument("<issue>", "Issue type (high-memory|stale-cache|degraded-model)")
+    .option("--json", "Output as JSON")
+    .action(async (issue, 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 spinner = ora(`Repairing: ${issue}...`).start();
+
+        const result = selfRepair(db, issue);
+        spinner.succeed("Repair complete");
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(chalk.bold(`Repaired: ${result.issue}`));
+          logger.log(chalk.bold("Actions taken:"));
+          for (const action of result.actions) {
+            logger.log(`  - ${chalk.green(action)}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // evolution predict [user-id]
+  evolution
+    .command("predict")
+    .description("Predict user behavior")
+    .argument("[user-id]", "User ID (optional)")
+    .option("--json", "Output as JSON")
+    .action(async (userId, 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 spinner = ora("Predicting behavior...").start();
+
+        const result = predictBehavior(db, userId);
+        spinner.succeed("Prediction complete");
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(
+            chalk.bold(`Behavior Prediction (user: ${result.userId})`),
+          );
+          logger.log(`  Confidence: ${chalk.cyan(result.confidence)}`);
+          logger.log(`  Based on:   ${result.basedOnEvents} events\n`);
+
+          if (result.predictions.length > 0) {
+            logger.log(chalk.bold("  Predicted Actions:"));
+            for (const p of result.predictions) {
+              const bar = "=".repeat(Math.round(p.probability * 20));
+              logger.log(
+                `    ${p.action.padEnd(25)} ${chalk.cyan(bar)} ${(p.probability * 100).toFixed(1)}%`,
+              );
+            }
+          } else {
+            logger.log(chalk.gray("  No predictions available yet."));
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // evolution growth
+  evolution
+    .command("growth")
+    .description("Show growth log")
+    .option("--type <filter>", "Filter by event type")
+    .option("--limit <n>", "Limit entries", parseInt)
+    .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 = getGrowthLog(db, {
+          type: options.type,
+          limit: options.limit,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(entries, null, 2));
+        } else if (entries.length === 0) {
+          logger.info("No growth events recorded yet.");
+        } else {
+          logger.log(chalk.bold(`Growth Log (${entries.length} entries):\n`));
+          for (const e of entries) {
+            const ts = chalk.gray(e.timestamp);
+            const type = chalk.yellow(e.eventType);
+            logger.log(`  ${ts}  ${type}`);
+            logger.log(`    ${e.description}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // evolution stats
+  evolution
+    .command("stats")
+    .description("Show capabilities and models overview")
+    .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 caps = getCapabilities(db);
+        const mdls = getModels(db);
+
+        if (options.json) {
+          console.log(
+            JSON.stringify({ capabilities: caps, models: mdls }, null, 2),
+          );
+        } else {
+          logger.log(chalk.bold(`Capabilities (${caps.length}):\n`));
+          if (caps.length === 0) {
+            logger.log(chalk.gray("  No capabilities tracked yet."));
+          }
+          for (const c of caps) {
+            const trendColor =
+              c.trend === "improving"
+                ? chalk.green
+                : c.trend === "declining"
+                  ? chalk.red
+                  : chalk.gray;
+            logger.log(
+              `  ${chalk.cyan(c.name.padEnd(20))} score=${c.score.toFixed(2)}  trend=${trendColor(c.trend)}  [${c.category}]`,
+            );
+          }
+
+          logger.log(chalk.bold(`\nModels (${mdls.length}):\n`));
+          if (mdls.length === 0) {
+            logger.log(chalk.gray("  No models registered yet."));
+          }
+          for (const m of mdls) {
+            logger.log(
+              `  ${chalk.cyan(m.id.padEnd(20))} type=${m.type}  accuracy=${m.accuracy.toFixed(4)}  data=${m.dataPoints}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // evolution export <model-id>
+  evolution
+    .command("export")
+    .description("Export a model for portability")
+    .argument("<model-id>", "Model ID to export")
+    .option("--json", "Output as JSON")
+    .action(async (modelId, 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 result = exportModel(db, modelId);
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(chalk.bold(`Exported Model: ${result.name}`));
+          logger.log(`  ID:         ${result.id}`);
+          logger.log(`  Type:       ${result.type}`);
+          logger.log(`  Accuracy:   ${result.accuracy.toFixed(4)}`);
+          logger.log(`  Data Points: ${result.dataPoints}`);
+          logger.log(`  Exported:   ${result.exportedAt}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/hmemory.js

@@ -0,0 +1,273 @@
+/**
+ * Hierarchical Memory 2.0 commands
+ * chainlesschain hmemory store|recall|consolidate|search|stats|share|prune
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  storeMemory,
+  recallMemory,
+  consolidateMemory,
+  searchEpisodic,
+  searchSemantic,
+  getMemoryStats,
+  shareMemory,
+  pruneMemory,
+} from "../lib/hierarchical-memory.js";
+
+export function registerHmemoryCommand(program) {
+  const hmemory = program
+    .command("hmemory")
+    .description("Hierarchical Memory 2.0 — four-layer memory system");
+
+  // hmemory store <content>
+  hmemory
+    .command("store")
+    .description("Store a memory at the appropriate layer")
+    .argument("<content>", "Memory content")
+    .option("--importance <n>", "Importance 0.0-1.0", "0.5")
+    .option("--type <type>", "Memory type (episodic|semantic)", "episodic")
+    .option("--core", "Force store as core memory (importance=1.0)")
+    .option("--json", "Output as JSON")
+    .action(async (content, 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 importance = options.core
+          ? 1.0
+          : parseFloat(options.importance) || 0.5;
+        const entry = storeMemory(db, content, {
+          importance,
+          type: options.type,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(entry, null, 2));
+        } else {
+          logger.success(
+            `Memory stored: ${chalk.gray(entry.id.slice(0, 16))} → ${chalk.cyan(entry.layer)}`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // hmemory recall <query>
+  hmemory
+    .command("recall")
+    .description("Recall memories with forgetting curve")
+    .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 = recallMemory(db, query, {
+          limit: parseInt(options.limit) || 20,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+        } else if (results.length === 0) {
+          logger.info(`No memories matching "${query}" above recall threshold`);
+        } else {
+          logger.log(chalk.bold(`Recalled ${results.length} memories:\n`));
+          for (const r of results) {
+            const retention = (r.retention * 100).toFixed(0);
+            logger.log(
+              `  ${chalk.gray(r.id.slice(0, 16))} [${chalk.cyan(r.layer)}] retention=${chalk.yellow(retention + "%")}`,
+            );
+            logger.log(
+              `    ${chalk.white(r.content.substring(0, 120).replace(/\n/g, " "))}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // hmemory consolidate
+  hmemory
+    .command("consolidate")
+    .description("Promote and forget memories across layers")
+    .action(async () => {
+      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 spinner = ora("Consolidating memories...").start();
+        const result = consolidateMemory(db);
+        spinner.succeed(
+          `Consolidation complete: ${chalk.green(result.promoted)} promoted, ${chalk.red(result.forgotten)} forgotten`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // hmemory search <query>
+  hmemory
+    .command("search")
+    .description("Search memories by type")
+    .argument("<query>", "Search query")
+    .option("--type <type>", "Memory type (episodic|semantic)", "episodic")
+    .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 searchFn =
+          options.type === "semantic" ? searchSemantic : searchEpisodic;
+        const results = searchFn(db, query, {
+          limit: parseInt(options.limit) || 20,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+        } else if (results.length === 0) {
+          logger.info(`No ${options.type} memories matching "${query}"`);
+        } else {
+          logger.log(
+            chalk.bold(`${options.type} search (${results.length} results):\n`),
+          );
+          for (const r of results) {
+            logger.log(
+              `  ${chalk.gray(r.id.slice(0, 16))} [${chalk.cyan(r.layer)}] importance=${chalk.yellow(r.importance)}`,
+            );
+            logger.log(
+              `    ${chalk.white(r.content.substring(0, 120).replace(/\n/g, " "))}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // hmemory stats
+  hmemory
+    .command("stats")
+    .description("Show memory statistics")
+    .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 stats = getMemoryStats(db);
+
+        if (options.json) {
+          console.log(JSON.stringify(stats, null, 2));
+        } else {
+          logger.log(chalk.bold("Hierarchical Memory Stats:\n"));
+          logger.log(`  Working:    ${chalk.yellow(stats.working)}`);
+          logger.log(`  Short-term: ${chalk.yellow(stats.shortTerm)}`);
+          logger.log(`  Long-term:  ${chalk.yellow(stats.longTerm)}`);
+          logger.log(`  Core:       ${chalk.yellow(stats.core)}`);
+          logger.log(`  Shared:     ${chalk.yellow(stats.shared)}`);
+          logger.log(
+            `  ${chalk.bold("Total:")}      ${chalk.green(stats.total)}`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // hmemory share <id> <agent-id>
+  hmemory
+    .command("share")
+    .description("Share a memory with another agent")
+    .argument("<id>", "Memory ID")
+    .argument("<agent-id>", "Target agent ID")
+    .option("--privacy <level>", "Privacy level (full|filtered)", "filtered")
+    .option("--json", "Output as JSON")
+    .action(async (id, agentId, 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 result = shareMemory(db, id, agentId, options.privacy);
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success(
+            `Memory ${chalk.gray(id.slice(0, 16))} shared with ${chalk.cyan(agentId)} [${options.privacy}]`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // hmemory prune
+  hmemory
+    .command("prune")
+    .description("Remove weak old memories")
+    .option("--max-age <hours>", "Maximum age in hours", "720")
+    .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 spinner = ora("Pruning stale memories...").start();
+        const result = pruneMemory(db, { maxAge: options.maxAge });
+        spinner.succeed(`Pruned ${chalk.red(result.pruned)} stale memories`);
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}