chainlesschain 0.42.2 → 0.43.0

package/README.md

@@ -9,6 +9,20 @@ npm install -g chainlesschain
 chainlesschain setup
 ```
 
+After installation, three equivalent commands are available:
+
+| Command          | Description                                                       |
+| ---------------- | ----------------------------------------------------------------- |
+| `chainlesschain` | Full name                                                         |
+| `cc`             | Shortest alias, recommended for daily use                         |
+| `clc`            | ChainLessChain abbreviation, avoids `cc` conflict with C compiler |
+| `clchain`        | chainlesschain abbreviation, easy to recognize                    |
+
+```bash
+cc setup       # equivalent to: chainlesschain setup
+clchain start  # equivalent to: chainlesschain start
+```
+
 ## Requirements
 
 - **Node.js** >= 22.12.0

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "chainlesschain",
-  "version": "0.42.2",
+  "version": "0.43.0",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {
-    "chainlesschain": "./bin/chainlesschain.js"
+    "chainlesschain": "./bin/chainlesschain.js",
+    "cc": "./bin/chainlesschain.js",
+    "clc": "./bin/chainlesschain.js",
+    "clchain": "./bin/chainlesschain.js"
   },
   "main": "src/index.js",
   "scripts": {

package/src/commands/agent.js

@@ -7,6 +7,7 @@
  */
 
 import { startAgentRepl } from "../repl/agent-repl.js";
+import { loadConfig } from "../lib/config-manager.js";
 
 export function registerAgentCommand(program) {
   program
@@ -15,21 +16,21 @@ export function registerAgentCommand(program) {
     .description(
       "Start an agentic AI session (reads/writes files, runs commands)",
     )
-    .option("--model <model>", "Model name", "qwen2:7b")
+    .option("--model <model>", "Model name")
     .option(
       "--provider <provider>",
       "LLM provider (ollama, openai, volcengine, deepseek, ...)",
-      "ollama",
     )
     .option("--base-url <url>", "API base URL")
     .option("--api-key <key>", "API key")
     .option("--session <id>", "Resume a previous agent session")
     .action(async (options) => {
+      const config = loadConfig();
       await startAgentRepl({
-        model: options.model,
-        provider: options.provider,
-        baseUrl: options.baseUrl,
-        apiKey: options.apiKey,
+        model: options.model || config.llm?.model || "qwen2:7b",
+        provider: options.provider || config.llm?.provider || "ollama",
+        baseUrl: options.baseUrl || config.llm?.baseUrl,
+        apiKey: options.apiKey || config.llm?.apiKey,
         sessionId: options.session,
       });
     });

package/src/commands/ask.js

@@ -1,12 +1,13 @@
 /**
  * Single-shot AI question command
- * chainlesschain ask "What is..." [--model qwen2:7b] [--provider ollama] [--json]
+ * chainlesschain ask "What is..." [--model] [--provider] [--json]
  */
 
 import ora from "ora";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { BUILT_IN_PROVIDERS } from "../lib/llm-providers.js";
+import { loadConfig } from "../lib/config-manager.js";
 
 /**
  * Send a single question to an LLM provider
@@ -84,24 +85,25 @@ export function registerAskCommand(program) {
     .command("ask")
     .description("Ask a question to the AI (single-shot)")
     .argument("<question>", "The question to ask")
-    .option("--model <model>", "Model name", "qwen2:7b")
+    .option("--model <model>", "Model name")
     .option(
       "--provider <provider>",
       "LLM provider (ollama, openai, volcengine, deepseek, ...)",
-      "ollama",
     )
     .option("--base-url <url>", "API base URL")
     .option("--api-key <key>", "API key")
     .option("--json", "Output as JSON")
     .action(async (question, options) => {
+      const config = loadConfig();
+      const resolvedOptions = {
+        model: options.model || config.llm?.model || "qwen2:7b",
+        provider: options.provider || config.llm?.provider || "ollama",
+        baseUrl: options.baseUrl || config.llm?.baseUrl,
+        apiKey: options.apiKey || config.llm?.apiKey,
+      };
       const spinner = ora("Thinking...").start();
       try {
-        const answer = await queryLLM(question, {
-          model: options.model,
-          provider: options.provider,
-          baseUrl: options.baseUrl,
-          apiKey: options.apiKey,
-        });
+        const answer = await queryLLM(question, resolvedOptions);
 
         spinner.stop();
 

package/src/commands/chat.js

@@ -1,20 +1,20 @@
 /**
  * Interactive AI chat command
- * chainlesschain chat [--model qwen2:7b] [--provider ollama] [--agent]
+ * chainlesschain chat [--model] [--provider] [--agent]
  */
 
 import { startChatRepl } from "../repl/chat-repl.js";
 import { startAgentRepl } from "../repl/agent-repl.js";
+import { loadConfig } from "../lib/config-manager.js";
 
 export function registerChatCommand(program) {
   program
     .command("chat")
     .description("Start an interactive AI chat session")
-    .option("--model <model>", "Model name", "qwen2:7b")
+    .option("--model <model>", "Model name")
     .option(
       "--provider <provider>",
       "LLM provider (ollama, openai, volcengine, deepseek, ...)",
-      "ollama",
     )
     .option("--base-url <url>", "API base URL")
     .option("--api-key <key>", "API key")
@@ -24,11 +24,12 @@ export function registerChatCommand(program) {
     )
     .option("--session <id>", "Resume a previous session (agent mode)")
     .action(async (options) => {
+      const config = loadConfig();
       const replOptions = {
-        model: options.model,
-        provider: options.provider,
-        baseUrl: options.baseUrl,
-        apiKey: options.apiKey,
+        model: options.model || config.llm?.model || "qwen2:7b",
+        provider: options.provider || config.llm?.provider || "ollama",
+        baseUrl: options.baseUrl || config.llm?.baseUrl,
+        apiKey: options.apiKey || config.llm?.apiKey,
         sessionId: options.session,
       };
 

package/src/commands/init.js

@@ -82,7 +82,7 @@ const TEMPLATES = {
     skills: ["summarize"],
     persona: {
       name: "智能分诊助手",
-      role: "你是一个医疗分诊AI助手，帮助诊所工作人员根据症状和紧急��度对患者进行优先级分类。",
+      role: "你是一个医疗分诊AI助手，帮助诊所工作人员根据症状和紧急程度对患者进行优先级分类。",
       behaviors: [
         "始终先询问患者症状再给出建议",
         "使用标准分诊分类 (ESI 1-5)",

package/src/commands/update.js

@@ -8,7 +8,7 @@ import logger from "../lib/logger.js";
 
 async function selfUpdateCli(targetVersion) {
   if (VERSION === targetVersion) {
-    return; // Already at the target version
+    return true; // Already at the target version
   }
 
   try {
@@ -17,12 +17,31 @@ async function selfUpdateCli(targetVersion) {
       encoding: "utf-8",
       stdio: "pipe",
     });
-    logger.success(`CLI updated to v${targetVersion}`);
+    // Verify the update actually took effect
+    try {
+      const newVersion = execSync("chainlesschain --version", {
+        encoding: "utf-8",
+        stdio: "pipe",
+      }).trim();
+      if (newVersion === targetVersion) {
+        logger.success(`CLI updated to v${targetVersion}`);
+        return true;
+      }
+      logger.warn(
+        `CLI update ran but version is still ${newVersion}. Please run manually:\n  npm install -g chainlesschain@${targetVersion}`,
+      );
+      return false;
+    } catch (_verifyErr) {
+      // Cannot verify, assume success
+      logger.success(`CLI updated to v${targetVersion}`);
+      return true;
+    }
   } catch (_err) {
     // npm global install may fail due to permissions; guide the user
     logger.warn(
       `CLI self-update failed. Please run manually:\n  npm install -g chainlesschain@${targetVersion}`,
     );
+    return false;
   }
 }
 
@@ -85,11 +104,21 @@ export function registerUpdateCommand(program) {
         }
 
         await downloadRelease(result.latestVersion, { force: options.force });
+        logger.success("Application already installed");
 
         // Self-update the CLI npm package
-        await selfUpdateCli(result.latestVersion);
+        const cliUpdated = await selfUpdateCli(result.latestVersion);
 
-        logger.success(`Updated to v${result.latestVersion}`);
+        if (cliUpdated) {
+          logger.success(`Updated to v${result.latestVersion}`);
+        } else {
+          logger.warn(
+            `Application binary updated, but CLI version remains at ${VERSION}.`,
+          );
+          logger.info(
+            `To complete the update, run:\n  npm install -g chainlesschain@${result.latestVersion}`,
+          );
+        }
         logger.info("Restart ChainlessChain to use the new version.");
       } catch (err) {
         if (err.name === "ExitPromptError") {

package/src/lib/agent-coordinator.js

@@ -6,6 +6,7 @@
  */
 
 import crypto from "crypto";
+import { SubAgentContext } from "./sub-agent-context.js";
 
 /**
  * Keyword map for agent type detection.
@@ -271,3 +272,113 @@ export function estimateComplexity(task) {
     estimatedSubtasks: Math.max(1, matchedTypes),
   };
 }
+
+// ─── Role-based tool whitelist ──────────────────────────────────────────
+
+export const ROLE_TOOL_WHITELIST = {
+  "code-review": ["read_file", "search_files", "list_dir"],
+  "code-generation": [
+    "read_file",
+    "write_file",
+    "edit_file",
+    "run_shell",
+    "search_files",
+    "list_dir",
+  ],
+  "data-analysis": [
+    "read_file",
+    "search_files",
+    "list_dir",
+    "run_code",
+    "run_shell",
+  ],
+  document: ["read_file", "write_file", "search_files", "list_dir"],
+  testing: [
+    "read_file",
+    "write_file",
+    "edit_file",
+    "run_shell",
+    "search_files",
+    "list_dir",
+    "run_code",
+  ],
+  general: null, // all tools
+};
+
+/**
+ * Execute a decomposed task using isolated sub-agent contexts.
+ * Each subtask gets its own SubAgentContext with role-appropriate tool whitelist.
+ *
+ * @param {{ taskId: string, subtasks: Array }} decomposition - From decomposeTask()
+ * @param {object} [options]
+ * @param {string} [options.cwd] - Working directory
+ * @param {object} [options.db] - Database instance
+ * @param {object} [options.llmOptions] - LLM provider options
+ * @param {string} [options.parentContext] - Condensed context from parent
+ * @returns {Promise<{ taskId: string, status: string, results: Array, summary: string }>}
+ */
+export async function executeDecomposedTask(decomposition, options = {}) {
+  const { subtasks } = decomposition;
+  if (!subtasks || subtasks.length === 0) {
+    return {
+      taskId: decomposition.taskId,
+      status: "empty",
+      results: [],
+      summary: "No subtasks to execute",
+    };
+  }
+
+  const maxConcurrency = options.maxConcurrency || 3;
+
+  // Run subtasks in parallel batches with concurrency limit
+  const results = [];
+  for (let i = 0; i < subtasks.length; i += maxConcurrency) {
+    const batch = subtasks.slice(i, i + maxConcurrency);
+    const batchPromises = batch.map(async (subtask) => {
+      const allowedTools = ROLE_TOOL_WHITELIST[subtask.agentType] || null;
+
+      const subCtx = SubAgentContext.create({
+        role: subtask.agentType,
+        task: subtask.description,
+        inheritedContext: options.parentContext || null,
+        allowedTools,
+        cwd: options.cwd || process.cwd(),
+        db: options.db || null,
+        llmOptions: options.llmOptions || {},
+      });
+
+      try {
+        const result = await subCtx.run(subtask.description);
+        subtask.status = "completed";
+        subtask.result = result.summary;
+        return {
+          id: subtask.id,
+          agentType: subtask.agentType,
+          status: "completed",
+          summary: result.summary,
+          toolsUsed: result.toolsUsed,
+        };
+      } catch (err) {
+        subtask.status = "failed";
+        subtask.result = err.message;
+        return {
+          id: subtask.id,
+          agentType: subtask.agentType,
+          status: "failed",
+          error: err.message,
+        };
+      }
+    });
+
+    const batchResults = await Promise.all(batchPromises);
+    results.push(...batchResults);
+  }
+
+  const aggregated = aggregateResults(subtasks);
+  return {
+    taskId: decomposition.taskId,
+    status: aggregated.status,
+    results,
+    summary: aggregated.summary,
+  };
+}

package/src/lib/agent-core.js

@@ -23,6 +23,7 @@ import { CLISkillLoader } from "./skill-loader.js";
 import { executeHooks, HookEvents } from "./hook-manager.js";
 import { detectPython } from "./cli-anything-bridge.js";
 import { findProjectRoot, loadProjectConfig } from "./project-detector.js";
+import { SubAgentContext } from "./sub-agent-context.js";
 
 // ─── Tool definitions ────────────────────────────────────────────────────
 
@@ -212,6 +213,40 @@ export const AGENT_TOOLS = [
       },
     },
   },
+  {
+    type: "function",
+    function: {
+      name: "spawn_sub_agent",
+      description:
+        "Spawn an isolated sub-agent to handle a subtask. The sub-agent has its own context and message history, and only returns a summary result. Use this for tasks that benefit from focused, independent execution (e.g. code review, summarization, translation).",
+      parameters: {
+        type: "object",
+        properties: {
+          role: {
+            type: "string",
+            description:
+              "Sub-agent role (e.g. code-review, summarizer, translator, debugger)",
+          },
+          task: {
+            type: "string",
+            description: "Task description for the sub-agent",
+          },
+          context: {
+            type: "string",
+            description:
+              "Optional condensed context from the parent agent to pass to the sub-agent",
+          },
+          tools: {
+            type: "array",
+            items: { type: "string" },
+            description:
+              'Optional tool whitelist for the sub-agent (e.g. ["read_file", "search_files"]). If omitted, all tools are available.',
+          },
+        },
+        required: ["role", "task"],
+      },
+    },
+  },
 ];
 
 // ─── Shared skill loader ──────────────────────────────────────────────────
@@ -326,6 +361,16 @@ When the user's problem involves data processing, calculations, file operations,
 
 You are not just a chatbot — you are a capable coding agent. Think step by step, write code when needed, and deliver real results.
 
+## Sub-Agent Isolation
+When a task involves multiple distinct roles (e.g. code review + code generation), or when you need
+focused analysis without polluting your current context, use the spawn_sub_agent tool. Examples:
+- Code review as a separate perspective while you're implementing
+- Summarizing a large file before incorporating it into your response
+- Running a focused analysis (security, performance) on specific code
+- Translating or reformatting content independently
+The sub-agent has its own message history and only returns a summary — your context stays clean.
+Do NOT spawn sub-agents for trivial tasks that you can handle directly.
+
 ## Environment
 ${envLines.join("\n")}
 
@@ -512,7 +557,11 @@ export async function executeTool(name, args, context = {}) {
 
   let toolResult;
   try {
-    toolResult = await executeToolInner(name, args, { skillLoader, cwd });
+    toolResult = await executeToolInner(name, args, {
+      skillLoader,
+      cwd,
+      parentMessages: context.parentMessages,
+    });
   } catch (err) {
     if (hookDb) {
       try {
@@ -550,7 +599,11 @@ export async function executeTool(name, args, context = {}) {
 /**
  * Inner tool execution — no hooks, no plan-mode checks.
  */
-async function executeToolInner(name, args, { skillLoader, cwd }) {
+async function executeToolInner(
+  name,
+  args,
+  { skillLoader, cwd, parentMessages },
+) {
   switch (name) {
     case "read_file": {
       const filePath = path.resolve(cwd, args.path);
@@ -613,6 +666,10 @@ async function executeToolInner(name, args, { skillLoader, cwd }) {
       return _executeRunCode(args, cwd);
     }
 
+    case "spawn_sub_agent": {
+      return _executeSpawnSubAgent(args, { skillLoader, cwd, parentMessages });
+    }
+
     case "search_files": {
       const dir = args.directory ? path.resolve(cwd, args.directory) : cwd;
       try {
@@ -676,6 +733,31 @@ async function executeToolInner(name, args, { skillLoader, cwd }) {
           error: `Skill "${args.skill_name}" not found or has no handler. Use list_skills to see available skills.`,
         };
       }
+
+      // Check if skill requests isolation (via SKILL.md frontmatter)
+      const skillIsolation = match.isolation === true;
+      if (skillIsolation) {
+        // Run skill through isolated sub-agent context
+        const subCtx = SubAgentContext.create({
+          role: `skill-${args.skill_name}`,
+          task: `Execute the "${args.skill_name}" skill with input: ${(args.input || "").substring(0, 200)}`,
+          allowedTools: ["read_file", "search_files", "list_dir"],
+          cwd,
+        });
+        try {
+          const result = await subCtx.run(args.input);
+          return {
+            success: true,
+            isolated: true,
+            skill: args.skill_name,
+            summary: result.summary,
+            toolsUsed: result.toolsUsed,
+          };
+        } catch (err) {
+          return { error: `Isolated skill execution failed: ${err.message}` };
+        }
+      }
+
       try {
         const handlerPath = path.join(match.skillDir, "handler.js");
         const imported = await import(
@@ -953,6 +1035,86 @@ async function _executeRunCode(args, cwd) {
   }
 }
 
+// ─── spawn_sub_agent implementation ──────────────────────────────────────
+
+/**
+ * Execute a spawn_sub_agent tool call.
+ * Creates an isolated SubAgentContext, runs it, and returns only the summary.
+ *
+ * @param {object} args - { role, task, context?, tools? }
+ * @param {object} ctx - { skillLoader, cwd }
+ * @returns {Promise<object>}
+ */
+async function _executeSpawnSubAgent(args, ctx) {
+  const { role, task, context: inheritedContext, tools: allowedTools } = args;
+
+  if (!role || !task) {
+    return { error: "Both 'role' and 'task' are required for spawn_sub_agent" };
+  }
+
+  // Auto-condense parent context if caller didn't provide explicit context
+  let resolvedContext = inheritedContext || null;
+  if (!resolvedContext && Array.isArray(ctx.parentMessages)) {
+    const recentMsgs = ctx.parentMessages
+      .filter((m) => m.role === "assistant" && typeof m.content === "string")
+      .slice(-3)
+      .map((m) => m.content.substring(0, 200));
+    if (recentMsgs.length > 0) {
+      resolvedContext = recentMsgs.join("\n---\n");
+    }
+  }
+
+  const subCtx = SubAgentContext.create({
+    role,
+    task,
+    inheritedContext: resolvedContext,
+    allowedTools: allowedTools || null,
+    cwd: ctx.cwd,
+  });
+
+  try {
+    // Notify registry if available
+    const { SubAgentRegistry } = await import("./sub-agent-registry.js").catch(
+      () => ({ SubAgentRegistry: null }),
+    );
+    if (SubAgentRegistry) {
+      try {
+        SubAgentRegistry.getInstance().register(subCtx);
+      } catch (_err) {
+        // Registry not available — non-critical
+      }
+    }
+
+    const result = await subCtx.run(task);
+
+    // Complete in registry
+    if (SubAgentRegistry) {
+      try {
+        SubAgentRegistry.getInstance().complete(subCtx.id, result);
+      } catch (_err) {
+        // Non-critical
+      }
+    }
+
+    return {
+      success: true,
+      subAgentId: subCtx.id,
+      role: subCtx.role,
+      summary: result.summary,
+      toolsUsed: result.toolsUsed,
+      iterationCount: result.iterationCount,
+      artifactCount: result.artifacts.length,
+    };
+  } catch (err) {
+    subCtx.forceComplete(err.message);
+    return {
+      error: `Sub-agent failed: ${err.message}`,
+      subAgentId: subCtx.id,
+      role: subCtx.role,
+    };
+  }
+}
+
 // ─── LLM chat with tools ─────────────────────────────────────────────────
 
 /**
@@ -1157,6 +1319,7 @@ export async function* agentLoop(messages, options) {
     hookDb: options.hookDb || null,
     skillLoader: options.skillLoader || _defaultSkillLoader,
     cwd: options.cwd || process.cwd(),
+    parentMessages: messages, // pass parent messages for sub-agent auto-condensation
   };
 
   // ── Slot-filling phase ──────────────────────────────────────────────
@@ -1292,6 +1455,8 @@ export function formatToolArgs(name, args) {
       return args.category || args.query || "all";
     case "run_code":
       return `${args.language} (${(args.code || "").length} chars)`;
+    case "spawn_sub_agent":
+      return `[${args.role}] ${(args.task || "").substring(0, 60)}`;
     default:
       return JSON.stringify(args).substring(0, 60);
   }