chainlesschain 0.45.75 → 0.45.76

package/README.md

@@ -183,7 +183,7 @@ chainlesschain llm models               # List installed Ollama models
 chainlesschain llm models --json        # JSON output
 chainlesschain llm test                 # Test Ollama connectivity
 chainlesschain llm test --provider openai --api-key sk-...
-chainlesschain llm providers            # List 8 built-in LLM providers
+chainlesschain llm providers            # List 10 built-in LLM providers
 chainlesschain llm add-provider <name>  # Add custom provider
 chainlesschain llm switch <name>        # Switch active provider
 ```
@@ -198,7 +198,7 @@ chainlesschain a --model llama3         # Short alias
 chainlesschain agent --provider openai --api-key sk-...
 ```
 
-Built-in tools: `read_file`, `write_file`, `edit_file`, `run_shell`, `search_files`, `list_dir`, `run_skill`, `list_skills`, `run_code`
+Built-in tools (12): `read_file`, `write_file`, `edit_file`, `edit_file_hashed`, `run_shell`, `git`, `search_files`, `list_dir`, `run_skill`, `list_skills`, `run_code`, `spawn_sub_agent`
 
 Agent slash commands: `/plan` (plan mode), `/plan interactive <request>` (LLM-driven planning with skill recommendations), `/model`, `/provider`, `/clear`, `/compact`, `/task`, `/session`, `/stats`, `/auto` (autonomous agent), `/cowork` (multi-agent collaboration), `/sub-agents` (show active/completed sub-agents)
 
@@ -701,6 +701,38 @@ chainlesschain evolution learn --domain nlp            # Incremental learning
 chainlesschain evolution status                        # Evolution status
 ```
 
+### `chainlesschain learning <action>`
+
+Autonomous learning loop — tracks execution trajectories, auto-synthesizes skills from successful patterns, and performs periodic self-reflection.
+
+```bash
+chainlesschain learning stats                          # Learning loop statistics overview
+chainlesschain learning stats --json                   # JSON output
+chainlesschain learning trajectories                   # Recent 20 execution trajectories
+chainlesschain learning trajectories -n 50             # Specify count
+chainlesschain learning trajectories --session <id>    # Filter by session
+chainlesschain learning trajectories --json            # JSON output
+chainlesschain learning reflect                        # Manual self-reflection trigger
+chainlesschain learning reflect --json                 # JSON reflection report
+chainlesschain learning synthesize                     # Scan and synthesize new skills
+chainlesschain learning synthesize --json              # JSON output
+chainlesschain learning cleanup                        # Clean up trajectories older than 90 days
+chainlesschain learning cleanup --days 30              # Custom retention period
+chainlesschain learning cleanup --json                 # JSON output
+```
+
+**Core modules** (7 files in `src/lib/learning/`):
+
+| Module               | Description                                                                          |
+| -------------------- | ------------------------------------------------------------------------------------ |
+| **TrajectoryStore**  | Records complete execution trajectories (intent → tool chain → result → response)    |
+| **OutcomeFeedback**  | Auto-scoring + user feedback + correction detection (Chinese & English)              |
+| **SkillSynthesizer** | Extracts reusable patterns from complex successful trajectories into SKILL.md        |
+| **SkillImprover**    | Three improvement triggers: error repair, user correction, better trajectory compare |
+| **ReflectionEngine** | Periodic self-review with tool stats, score trends, error-prone tool identification  |
+| **LearningHooks**    | REPL lifecycle integration — captures prompts, tool calls, responses, session events |
+| **LearningTables**   | SQLite schema creation for trajectories, tags, and improvement logs                  |
+
 ---
 
 ## Phase 8: Blockchain & Enterprise Analytics
@@ -1139,17 +1171,19 @@ Configuration is stored at `~/.chainlesschain/config.json`. The CLI creates and
 
 ### Supported LLM Providers
 
-| Provider               | Default Model     | API Key Required |
-| ---------------------- | ----------------- | ---------------- |
-| Ollama (Local)         | qwen2.5:7b        | No               |
-| OpenAI                 | gpt-4o            | Yes              |
-| Anthropic              | claude-sonnet-4-6 | Yes              |
-| DashScope (Alibaba)    | qwen-max          | Yes              |
-| DeepSeek               | deepseek-chat     | Yes              |
-| Gemini (Google)        | gemini-pro        | Yes              |
-| Mistral                | mistral-large     | Yes              |
-| Volcengine (ByteDance) | doubao-1.5-pro    | Yes              |
-| Custom                 | —                 | Yes              |
+| Provider                   | Default Model          | API Key Required |
+| -------------------------- | ---------------------- | ---------------- |
+| Ollama (Local)             | qwen2.5:7b             | No               |
+| OpenAI                     | gpt-4o                 | Yes              |
+| Anthropic                  | claude-opus-4-6        | Yes              |
+| DeepSeek                   | deepseek-chat          | Yes              |
+| DashScope (Alibaba)        | qwen-turbo             | Yes              |
+| Google Gemini              | gemini-2.0-flash       | Yes              |
+| Mistral AI                 | mistral-large-latest   | Yes              |
+| Volcengine (火山引擎/豆包) | doubao-seed-1-6-251015 | Yes              |
+| Kimi (月之暗面)            | moonshot-v1-auto       | Yes              |
+| MiniMax (海螺AI)           | MiniMax-Text-01        | Yes              |
+| Custom                     | —                      | Yes              |
 
 ## File Structure
 
@@ -1168,7 +1202,7 @@ Configuration is stored at `~/.chainlesschain/config.json`. The CLI creates and
 ```bash
 cd packages/cli
 npm install
-npm test                # Run all tests (5200+ tests across 133+ files)
+npm test                # Run all tests (5400+ tests across 201+ files)
 npm run test:unit       # Unit tests only
 npm run test:integration # Integration tests
 npm run test:e2e        # End-to-end tests
@@ -1185,16 +1219,19 @@ npm run test:e2e        # End-to-end tests
 | Unit — Skill Packs        | 2       | 57+      | All passing     |
 | Unit — AI Templates       | 2       | 130+     | All passing     |
 | Unit — Web UI             | 1       | 46       | All passing     |
+| Unit — Learning           | 7       | 177      | All passing     |
 | Integration               | 13      | 230+     | All passing     |
 | Integration — WS session  | 1       | 12       | All passing     |
 | Integration — AI Handlers | 2       | 100+     | All passing     |
 | Integration — Web UI      | 1       | 29       | All passing     |
+| Integration — Learning    | 1       | 12       | All passing     |
 | E2E                       | 15      | 260+     | All passing     |
 | E2E — Skill Packs         | 1       | 23+      | All passing     |
 | E2E — AI Templates        | 4       | 65+      | All passing     |
 | E2E — Web UI              | 1       | 24       | All passing     |
+| E2E — Learning            | 1       | 16       | All passing     |
 | Core packages (external)  | —       | 118      | All passing     |
-| **CLI Total**             | **133** | **3155** | **All passing** |
+| **CLI Total**             | **201** | **3360** | **All passing** |
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.45.75",
+  "version": "0.45.76",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {

package/src/commands/learning.js

@@ -0,0 +1,273 @@
+/**
+ * Autonomous Learning Loop commands
+ * chainlesschain learning stats|trajectories|reflect|synthesize|improve|cleanup
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+
+export function registerLearningCommand(program) {
+  const learning = program
+    .command("learning")
+    .description(
+      "Autonomous learning loop — trajectories, reflection, skill synthesis",
+    );
+
+  // learning stats
+  learning
+    .command("stats")
+    .description("Show learning loop 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 { TrajectoryStore } =
+          await import("../lib/learning/trajectory-store.js");
+        const store = new TrajectoryStore(db);
+        const stats = store.getStats();
+
+        if (options.json) {
+          console.log(JSON.stringify(stats, null, 2));
+        } else {
+          logger.log(chalk.bold("Learning Loop Statistics"));
+          logger.log(`  Total trajectories:   ${chalk.cyan(stats.total)}`);
+          logger.log(`  Complex (6+ tools):   ${chalk.cyan(stats.complex)}`);
+          logger.log(`  Scored:               ${chalk.cyan(stats.scored)}`);
+          logger.log(
+            `  Skills synthesized:   ${chalk.cyan(stats.synthesized)}`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // learning trajectories
+  learning
+    .command("trajectories")
+    .description("List recent trajectories")
+    .option("-n, --limit <n>", "Number of trajectories", "20")
+    .option("--session <id>", "Filter by session ID")
+    .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 { TrajectoryStore } =
+          await import("../lib/learning/trajectory-store.js");
+        const store = new TrajectoryStore(db);
+
+        const trajs = store.getRecent({
+          limit: parseInt(options.limit, 10),
+          sessionId: options.session,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(trajs, null, 2));
+        } else {
+          if (trajs.length === 0) {
+            logger.log(chalk.gray("No trajectories recorded yet."));
+          } else {
+            logger.log(chalk.bold(`Recent Trajectories (${trajs.length})`));
+            for (const t of trajs) {
+              const scoreStr =
+                t.outcomeScore != null
+                  ? chalk.cyan(t.outcomeScore.toFixed(2))
+                  : chalk.gray("unscored");
+              const synthStr = t.synthesizedSkill
+                ? chalk.green(` → ${t.synthesizedSkill}`)
+                : "";
+              logger.log(
+                `  ${chalk.dim(t.id.slice(0, 8))} | ${t.complexityLevel.padEnd(8)} | ` +
+                  `${t.toolCount} tools | score: ${scoreStr}${synthStr}`,
+              );
+              if (t.userIntent) {
+                logger.log(`    ${chalk.dim(t.userIntent.slice(0, 80))}`);
+              }
+            }
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // learning reflect
+  learning
+    .command("reflect")
+    .description("Run a reflection cycle and generate report")
+    .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 { TrajectoryStore } =
+          await import("../lib/learning/trajectory-store.js");
+        const { ReflectionEngine } =
+          await import("../lib/learning/reflection-engine.js");
+        const store = new TrajectoryStore(db);
+        const engine = new ReflectionEngine(db, null, store);
+
+        const spinner = ora("Running reflection...").start();
+        const report = await engine.reflect();
+        spinner.succeed("Reflection complete");
+
+        if (options.json) {
+          console.log(JSON.stringify(report, null, 2));
+        } else {
+          logger.log(chalk.bold("Reflection Report"));
+          logger.log(`  Period:         ${chalk.dim(report.timestamp)}`);
+          logger.log(
+            `  Trajectories:   ${chalk.cyan(report.totalTrajectories)}`,
+          );
+          logger.log(
+            `  Avg score:      ${chalk.cyan(report.avgScore?.toFixed(2) || "N/A")}`,
+          );
+
+          const trendColor =
+            report.trend === "improving"
+              ? chalk.green
+              : report.trend === "declining"
+                ? chalk.red
+                : chalk.gray;
+          logger.log(`  Trend:          ${trendColor(report.trend)}`);
+
+          if (report.topTools && report.topTools.length > 0) {
+            logger.log(chalk.bold("\n  Top Tools:"));
+            for (const t of report.topTools.slice(0, 5)) {
+              logger.log(
+                `    ${t.tool}: ${t.count}x (${(t.errorRate * 100).toFixed(0)}% error)`,
+              );
+            }
+          }
+
+          if (report.errorProneTools && report.errorProneTools.length > 0) {
+            logger.log(chalk.bold("\n  Error-prone Tools:"));
+            for (const t of report.errorProneTools) {
+              logger.log(
+                `    ${chalk.red(t.tool)}: ${(t.errorRate * 100).toFixed(0)}% error rate`,
+              );
+            }
+          }
+
+          if (report.note) {
+            logger.log(chalk.gray(`\n  Note: ${report.note}`));
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // learning synthesize
+  learning
+    .command("synthesize")
+    .description("Synthesize new skills from eligible trajectories")
+    .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 { TrajectoryStore } =
+          await import("../lib/learning/trajectory-store.js");
+        const { SkillSynthesizer } =
+          await import("../lib/learning/skill-synthesizer.js");
+        const store = new TrajectoryStore(db);
+        const synthesizer = new SkillSynthesizer(db, null, store);
+
+        const spinner = ora("Scanning for synthesizable patterns...").start();
+        const result = await synthesizer.synthesize();
+        spinner.succeed("Synthesis complete");
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          if (result.created.length > 0) {
+            logger.log(
+              chalk.green(`Created ${result.created.length} skill(s):`),
+            );
+            for (const name of result.created) {
+              logger.log(`  ${chalk.cyan(name)}`);
+            }
+          } else {
+            logger.log(chalk.gray("No new skills synthesized."));
+          }
+
+          if (result.skipped.length > 0) {
+            logger.log(
+              chalk.dim(`\nSkipped ${result.skipped.length} candidate(s)`),
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // learning cleanup
+  learning
+    .command("cleanup")
+    .description("Delete old trajectories beyond retention period")
+    .option("--days <n>", "Retention days", "90")
+    .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 { TrajectoryStore } =
+          await import("../lib/learning/trajectory-store.js");
+        const store = new TrajectoryStore(db);
+
+        const days = parseInt(options.days, 10);
+        const spinner = ora(
+          `Cleaning up trajectories older than ${days} days...`,
+        ).start();
+        const deleted = store.cleanup(days);
+        spinner.succeed(`Cleanup complete: ${deleted} trajectories deleted`);
+
+        if (options.json) {
+          console.log(JSON.stringify({ deleted, retentionDays: days }));
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/lowcode.js

@@ -19,6 +19,7 @@ import {
   rollbackApp,
   exportApp,
   listApps,
+  deployApp,
 } from "../lib/app-builder.js";
 
 export function registerLowcodeCommand(program) {
@@ -307,14 +308,28 @@ export function registerLowcodeCommand(program) {
   // lowcode deploy <app-id>
   lowcode
     .command("deploy")
-    .description("Deploy application (placeholder)")
+    .description("Deploy application as static HTML bundle")
     .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.",
-        ),
-      );
+    .option("-o, --output <dir>", "Output directory for the deploy bundle")
+    .action(async (appId, options) => {
+      const spinner = ora("Deploying application...").start();
+      let ctx;
+      try {
+        ctx = await bootstrap();
+        ensureLowcodeTables(ctx.db);
+        const result = deployApp(ctx.db, appId, {
+          outputDir: options.output || undefined,
+        });
+        spinner.succeed(
+          chalk.green(`App ${chalk.cyan(appId)} deployed successfully`),
+        );
+        logger.log(`  Output:    ${chalk.cyan(result.outputDir)}`);
+        logger.log(`  Files:     ${result.files.join(", ")}`);
+        logger.log(`  Deployed:  ${result.deployedAt}`);
+      } catch (err) {
+        spinner.fail(chalk.red(`Deploy failed: ${err.message}`));
+      } finally {
+        if (ctx) await shutdown(ctx);
+      }
     });
 }

package/src/gateways/discord/discord-formatter.js

@@ -0,0 +1,89 @@
+/**
+ * Discord Formatter — converts agent responses to Discord-compatible markup.
+ *
+ * Discord supports a broad subset of Markdown. Main limit is 2000 chars per message.
+ *
+ * @module discord-formatter
+ */
+
+const DISCORD_MAX_LENGTH = 2000;
+
+/**
+ * Format an agent response for Discord.
+ * Discord natively supports Markdown, so minimal conversion needed.
+ * @param {string} response
+ * @param {object} [options]
+ * @param {number} [options.maxLength=2000]
+ * @returns {string}
+ */
+export function formatForDiscord(response, options = {}) {
+  if (!response) return "";
+  const maxLength = options.maxLength || DISCORD_MAX_LENGTH;
+
+  let text = response;
+
+  if (text.length > maxLength) {
+    text = text.substring(0, maxLength - 3) + "...";
+  }
+
+  return text;
+}
+
+/**
+ * Split a response into Discord-sized chunks.
+ * Tries to split at code block or newline boundaries.
+ * @param {string} text
+ * @param {number} [maxLength=2000]
+ * @returns {string[]}
+ */
+export function splitForDiscord(text, maxLength = DISCORD_MAX_LENGTH) {
+  if (!text || text.length <= maxLength) return [text || ""];
+
+  const chunks = [];
+  let remaining = text;
+
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+
+    // Try to split at code block boundary
+    let splitIdx = remaining.lastIndexOf("\n```", maxLength);
+    if (splitIdx > maxLength * 0.3) {
+      splitIdx += 1; // Include the newline
+    } else {
+      // Try to split at newline
+      splitIdx = remaining.lastIndexOf("\n", maxLength);
+      if (splitIdx < maxLength * 0.3) {
+        splitIdx = maxLength;
+      }
+    }
+
+    chunks.push(remaining.substring(0, splitIdx));
+    remaining = remaining.substring(splitIdx).trimStart();
+  }
+
+  return chunks;
+}
+
+/**
+ * Format a code block for Discord with syntax highlighting.
+ * @param {string} code
+ * @param {string} [language=""]
+ * @returns {string}
+ */
+export function codeBlock(code, language = "") {
+  return `\`\`\`${language}\n${code}\n\`\`\``;
+}
+
+/**
+ * Format an embed-like block for Discord (using quote blocks).
+ * @param {string} title
+ * @param {string} content
+ * @returns {string}
+ */
+export function quoteBlock(title, content) {
+  const lines = content.split("\n").map((l) => `> ${l}`);
+  return `**${title}**\n${lines.join("\n")}`;
+}