chainlesschain 0.45.81 → 0.47.0

package/src/lib/cowork-task-runner.js

@@ -7,14 +7,16 @@
  * @module cowork-task-runner
  */
 
-import { existsSync, mkdirSync, appendFileSync } from "node:fs";
+import { existsSync, mkdirSync, appendFileSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { SubAgentContext } from "./sub-agent-context.js";
-import { getTemplate } from "./cowork-task-templates.js";
+import { getTemplate, setUserTemplates } from "./cowork-task-templates.js";
+import { mountTemplateMcpTools } from "./cowork-mcp-tools.js";
+import { listUserTemplates } from "./cowork-template-marketplace.js";
 
 // ─── Dependencies (overridable for testing) ──────────────────────────────────
 
-export const _deps = { existsSync, mkdirSync, appendFileSync };
+export const _deps = { existsSync, mkdirSync, appendFileSync, readFileSync };
 
 // ─── Constants ────────────────────────────────────────────────────────────────
 
@@ -63,18 +65,53 @@ export async function runCoworkTask(options = {}) {
     }
   }
 
+  // Merge user-installed templates (marketplace) into the registry before resolving
+  try {
+    setUserTemplates(listUserTemplates(cwd));
+  } catch (_e) {
+    // Non-fatal — marketplace absence should not break task execution
+  }
+
   // Resolve template
   const template = getTemplate(templateId);
 
   // Build the task prompt with template context + files
   const taskParts = [template.systemPromptExtension];
 
+  // N2: apply learning-layer patch for this template if one exists
+  try {
+    const { loadUserTemplate } = await import("./cowork-learning.js");
+    const override = loadUserTemplate(cwd, template.id);
+    if (override?.systemPromptExtension) {
+      taskParts.push(
+        `\n## 历史学习补丁 (learning patch)\n${override.systemPromptExtension}`,
+      );
+    }
+  } catch (_e) {
+    // Non-fatal — learning overrides are optional
+  }
+
   if (files.length > 0) {
     taskParts.push(`\n## 用户提供的文件\n${files.join("\n")}`);
   }
 
   const task = taskParts.join("\n");
 
+  // Mount template-declared MCP servers (best-effort, failures are tolerated)
+  const mcp = await mountTemplateMcpTools(template, {
+    onWarn: (msg) => {
+      if (onProgress) onProgress({ type: "mcp-warning", message: msg });
+    },
+  });
+  if (onProgress && (mcp.mounted.length > 0 || mcp.skipped.length > 0)) {
+    onProgress({
+      type: "mcp-mounted",
+      mounted: mcp.mounted,
+      skipped: mcp.skipped.map((s) => s.name),
+      toolCount: mcp.extraToolDefinitions.length,
+    });
+  }
+
   // Create isolated sub-agent context
   const subAgent = SubAgentContext.create({
     role: `cowork-${template.id}`,
@@ -87,6 +124,10 @@ export async function runCoworkTask(options = {}) {
     cwd,
     onProgress,
     signal,
+    extraToolDefinitions: mcp.extraToolDefinitions,
+    externalToolDescriptors: mcp.externalToolDescriptors,
+    externalToolExecutors: mcp.externalToolExecutors,
+    mcpClient: mcp.mcpClient,
   });
 
   const taskId = subAgent.id;
@@ -128,6 +169,279 @@ export async function runCoworkTask(options = {}) {
     };
     _appendHistory(cwd, entry, userMessage);
     return entry;
+  } finally {
+    await mcp.cleanup();
+  }
+}
+
+// ─── Parallel Runner (Orchestrator) ──────────────────────────────────────────
+
+/**
+ * Run a cowork task using the Orchestrator for multi-agent parallel execution.
+ *
+ * @param {object} options - Same as runCoworkTask, plus:
+ * @param {number} [options.agents] - Number of parallel agents (default 3, max 10)
+ * @param {string} [options.strategy] - Routing strategy (default "round-robin")
+ * @param {function} [options.onProgress] - Progress callback
+ * @param {AbortSignal} [options.signal] - Cancellation signal
+ * @returns {Promise<{ taskId: string, status: string, result: object }>}
+ */
+export async function runCoworkTaskParallel(options = {}) {
+  const {
+    templateId = null,
+    userMessage,
+    files = [],
+    cwd = process.cwd(),
+    agents = 3,
+    strategy,
+    onProgress = null,
+    signal = null,
+  } = options;
+
+  if (!userMessage || typeof userMessage !== "string") {
+    throw new Error("userMessage is required");
+  }
+
+  if (files.length > 0) {
+    const missing = files.filter((f) => !_deps.existsSync(f));
+    if (missing.length > 0) {
+      throw new Error(`File(s) not found: ${missing.join(", ")}`);
+    }
+  }
+
+  const template = getTemplate(templateId);
+
+  // Build full task description for the orchestrator
+  const taskParts = [
+    `[Cowork Template: ${template.name}]`,
+    template.systemPromptExtension,
+    `\n## 用户需求\n${userMessage}`,
+  ];
+  if (files.length > 0) {
+    taskParts.push(`\n## 用户提供的文件\n${files.join("\n")}`);
+  }
+  const fullTask = taskParts.join("\n");
+
+  try {
+    const { Orchestrator, TASK_SOURCE } = await import("./orchestrator.js");
+
+    const orch = new Orchestrator({
+      cwd,
+      maxParallel: Math.min(parseInt(agents, 10) || 3, 10),
+      ciCommand: "echo ok",
+      agents: strategy ? { strategy } : undefined,
+      verbose: false,
+    });
+
+    // Wire progress events
+    if (onProgress) {
+      orch.on("task:added", (t) =>
+        onProgress({
+          type: "orchestrator-started",
+          taskId: t.id,
+          subtaskCount: 0,
+        }),
+      );
+      orch.on("task:decomposed", (t) =>
+        onProgress({
+          type: "orchestrator-decomposed",
+          taskId: t.id,
+          subtaskCount: t.subtasks?.length || 0,
+        }),
+      );
+      orch.on("agents:dispatched", (ev) =>
+        onProgress({
+          type: "agents-dispatched",
+          agentCount: ev.agents?.length || 0,
+        }),
+      );
+      orch.on("agent:output", (ev) =>
+        onProgress({
+          type: "agent-progress",
+          agentIndex: ev.agentIndex,
+          status: ev.status,
+          output: ev.output?.slice(0, 200),
+        }),
+      );
+    }
+
+    // Handle cancellation
+    if (signal) {
+      signal.addEventListener(
+        "abort",
+        () => {
+          orch.stopCronWatch();
+        },
+        { once: true },
+      );
+    }
+
+    const orchResult = await orch.addTask(fullTask, {
+      source: TASK_SOURCE.CLI,
+      cwd,
+      runCI: false,
+      notify: false,
+    });
+
+    const entry = {
+      taskId: orchResult.id,
+      status: orchResult.status === "completed" ? "completed" : "failed",
+      templateId: template.id,
+      templateName: template.name,
+      parallel: true,
+      agentCount: agents,
+      result: {
+        summary:
+          orchResult.agentResults
+            ?.map((r) => r.output?.slice(0, 500))
+            .join("\n---\n") || "Parallel execution completed",
+        artifacts: [],
+        tokenCount: 0,
+        toolsUsed: [],
+        iterationCount: orchResult.retries || 0,
+        subtaskCount: orchResult.subtasks?.length || 0,
+      },
+    };
+    _appendHistory(cwd, entry, userMessage);
+    return entry;
+  } catch (err) {
+    const entry = {
+      taskId: `cowork-parallel-${Date.now()}`,
+      status: "failed",
+      templateId: template.id,
+      templateName: template.name,
+      parallel: true,
+      result: {
+        summary: `Parallel task failed: ${err.message}`,
+        artifacts: [],
+        tokenCount: 0,
+        toolsUsed: [],
+        iterationCount: 0,
+        subtaskCount: 0,
+      },
+    };
+    _appendHistory(cwd, entry, userMessage);
+    return entry;
+  }
+}
+
+// ─── Debate Runner (Multi-perspective Review) ───────────────────────────────
+
+/**
+ * Run a cowork task in debate mode — multiple reviewer perspectives converge
+ * into a final verdict via moderator synthesis.
+ *
+ * @param {object} options
+ * @param {string|null} options.templateId - Should be "code-review" or null
+ * @param {string} options.userMessage - Target description / review instructions
+ * @param {string[]} [options.files] - File paths to review (concatenated as code body)
+ * @param {string[]} [options.perspectives] - Override template perspectives
+ * @param {string} [options.cwd] - Working directory for history
+ * @param {object} [options.llmOptions] - LLM provider/model/key
+ * @param {function} [options.onProgress] - Progress callback
+ * @returns {Promise<{ taskId, status, result }>}
+ */
+export async function runCoworkDebate(options = {}) {
+  const {
+    templateId = "code-review",
+    userMessage,
+    files = [],
+    perspectives,
+    cwd = process.cwd(),
+    llmOptions = {},
+    onProgress = null,
+  } = options;
+
+  if (!userMessage || typeof userMessage !== "string") {
+    throw new Error("userMessage is required");
+  }
+
+  if (files.length > 0) {
+    const missing = files.filter((f) => !_deps.existsSync(f));
+    if (missing.length > 0) {
+      throw new Error(`File(s) not found: ${missing.join(", ")}`);
+    }
+  }
+
+  const template = getTemplate(templateId);
+  const reviewPerspectives = perspectives ||
+    template.debatePerspectives || [
+      "performance",
+      "security",
+      "maintainability",
+    ];
+
+  // Build code body from files (or from userMessage if no files provided)
+  let code = "";
+  if (files.length > 0) {
+    const chunks = files.map((f) => {
+      try {
+        return `// ===== ${f} =====\n${_deps.readFileSync(f, "utf-8")}`;
+      } catch (err) {
+        return `// ===== ${f} (read error: ${err.message}) =====`;
+      }
+    });
+    code = chunks.join("\n\n");
+  } else {
+    code = userMessage;
+  }
+
+  const taskId = `cowork-debate-${Date.now()}`;
+
+  if (onProgress) {
+    onProgress({ type: "debate-started", perspectives: reviewPerspectives });
+  }
+
+  try {
+    const { startDebate } = await import("./cowork/debate-review-cli.js");
+    const debateResult = await startDebate({
+      target: userMessage,
+      code,
+      perspectives: reviewPerspectives,
+      llmOptions,
+    });
+
+    if (onProgress) {
+      onProgress({ type: "debate-completed", verdict: debateResult.verdict });
+    }
+
+    const entry = {
+      taskId,
+      status: "completed",
+      templateId: template.id,
+      templateName: template.name,
+      mode: "debate",
+      result: {
+        summary: debateResult.summary,
+        verdict: debateResult.verdict,
+        consensusScore: debateResult.consensusScore,
+        reviews: debateResult.reviews,
+        perspectives: debateResult.perspectives,
+        artifacts: [],
+        tokenCount: 0,
+        toolsUsed: [],
+        iterationCount: debateResult.reviews.length + 1,
+      },
+    };
+    _appendHistory(cwd, entry, userMessage);
+    return entry;
+  } catch (err) {
+    const entry = {
+      taskId,
+      status: "failed",
+      templateId: template.id,
+      templateName: template.name,
+      mode: "debate",
+      result: {
+        summary: `Debate failed: ${err.message}`,
+        artifacts: [],
+        tokenCount: 0,
+        toolsUsed: [],
+        iterationCount: 0,
+      },
+    };
+    _appendHistory(cwd, entry, userMessage);
+    return entry;
   }
 }
 

package/src/lib/cowork-task-templates.js

@@ -158,6 +158,7 @@ ${ERROR_RECOVERY_PROMPT}`,
     name: "数据分析",
     category: "data",
     acceptsFiles: true,
+    parallelStrategy: "auto",
     fileTypes: [".csv", ".xlsx", ".xls", ".json", ".tsv", ".sqlite", ".db"],
     systemPromptExtension: `你是数据分析专家。
 
@@ -194,6 +195,7 @@ ${ERROR_RECOVERY_PROMPT}`,
     category: "research",
     acceptsFiles: false,
     fileTypes: [],
+    parallelStrategy: "auto",
     shellPolicyOverrides: ["network-download"],
     systemPromptExtension: `你是信息检索与调研专家。
 
@@ -270,6 +272,7 @@ ${ERROR_RECOVERY_PROMPT}`,
     name: "代码辅助",
     category: "development",
     acceptsFiles: true,
+    parallelStrategy: "auto",
     fileTypes: [
       ".js",
       ".ts",
@@ -460,6 +463,32 @@ ${OPEN_SOURCE_FIRST_PROMPT}
 ${FILE_HANDLING_PROMPT}
 ${ERROR_RECOVERY_PROMPT}`,
   },
+
+  "code-review": {
+    id: "code-review",
+    name: "代码评审",
+    category: "development",
+    acceptsFiles: true,
+    fileTypes: [
+      ".js",
+      ".ts",
+      ".py",
+      ".go",
+      ".rs",
+      ".java",
+      ".kt",
+      ".cpp",
+      ".c",
+      ".rb",
+      ".php",
+      ".vue",
+    ],
+    mode: "debate",
+    debatePerspectives: ["performance", "security", "maintainability"],
+    systemPromptExtension: `你是多视角代码评审的协调者。
+将代码分发给多个专业评审员独立评审，最后综合输出裁决。
+`,
+  },
 };
 
 /**
@@ -467,23 +496,49 @@ ${ERROR_RECOVERY_PROMPT}`,
  * @param {string|null} templateId
  * @returns {object} Template definition
  */
+/**
+ * Extra template registry for installed user templates. The marketplace
+ * loader populates this at CLI startup via `setUserTemplates()`. Keeping
+ * it local lets `getTemplate()` / `getTemplatesForUI()` stay synchronous
+ * while still returning user-installed templates.
+ */
+let _userTemplates = {};
+
+/** Called by the marketplace / CLI to register installed user templates. */
+export function setUserTemplates(templates) {
+  _userTemplates = {};
+  if (Array.isArray(templates)) {
+    for (const tpl of templates) {
+      if (tpl?.id) _userTemplates[tpl.id] = tpl;
+    }
+  }
+}
+
+/** Read-only accessor for tests. */
+export function getUserTemplates() {
+  return { ..._userTemplates };
+}
+
 export function getTemplate(templateId) {
-  if (!templateId || !TASK_TEMPLATES[templateId]) {
-    return {
-      id: "free",
-      name: "自由模式",
-      category: "general",
-      acceptsFiles: true,
-      fileTypes: [],
-      systemPromptExtension: `你是一个全能助手，可以处理用户提出的任何日常任务。
+  if (templateId && TASK_TEMPLATES[templateId]) {
+    return TASK_TEMPLATES[templateId];
+  }
+  if (templateId && _userTemplates[templateId]) {
+    return _userTemplates[templateId];
+  }
+  return {
+    id: "free",
+    name: "自由模式",
+    category: "general",
+    acceptsFiles: true,
+    fileTypes: [],
+    systemPromptExtension: `你是一个全能助手，可以处理用户提出的任何日常任务。
 根据任务类型自动选择最合适的工具和方法。
 
 ${OPEN_SOURCE_FIRST_PROMPT}
 ${FILE_HANDLING_PROMPT}
 ${ERROR_RECOVERY_PROMPT}`,
-    };
-  }
-  return TASK_TEMPLATES[templateId];
+  };
 }
 
 /**
@@ -491,7 +546,7 @@ ${ERROR_RECOVERY_PROMPT}`,
  * @returns {string[]}
  */
 export function listTemplateIds() {
-  return Object.keys(TASK_TEMPLATES);
+  return [...Object.keys(TASK_TEMPLATES), ...Object.keys(_userTemplates)];
 }
 
 // ─── UI Metadata ─────────────────────────────────────────────────────────────
@@ -571,6 +626,15 @@ const UI_METADATA = {
     description: "文档翻译、内容总结、论文分析",
     examples: ["翻译 PDF 摘要", "总结长文档要点", "解释代码工作原理"],
   },
+  "code-review": {
+    icon: "SafetyCertificateOutlined",
+    description: "多视角评审（性能 / 安全 / 可维护性），综合裁决",
+    examples: [
+      "评审这个函数的安全问题",
+      "从性能角度审查这段代码",
+      "评审 PR 的可维护性",
+    ],
+  },
 };
 
 /**
@@ -580,8 +644,17 @@ const UI_METADATA = {
  * @returns {object[]}
  */
 export function getTemplatesForUI() {
-  return Object.values(TASK_TEMPLATES).map((tpl) => {
+  const builtIn = Object.values(TASK_TEMPLATES).map((tpl) => {
     const ui = UI_METADATA[tpl.id] || {};
+    return { tpl, ui, source: "builtin" };
+  });
+  const userInstalled = Object.values(_userTemplates).map((tpl) => ({
+    tpl,
+    // User templates carry their own ui metadata inline
+    ui: { icon: tpl.icon, description: tpl.description, examples: tpl.examples },
+    source: "user",
+  }));
+  return [...builtIn, ...userInstalled].map(({ tpl, ui, source }) => {
     return {
       id: tpl.id,
       name: tpl.name,
@@ -589,10 +662,25 @@ export function getTemplatesForUI() {
       category: tpl.category,
       description: ui.description || "",
       examples: ui.examples || [],
+      source,
       acceptsFiles: tpl.acceptsFiles,
+      parallelStrategy: tpl.parallelStrategy || "none",
+      mode: tpl.mode || "agent",
+      ...(tpl.debatePerspectives
+        ? { debatePerspectives: tpl.debatePerspectives }
+        : {}),
       ...(tpl.shellPolicyOverrides
         ? { shellPolicyOverrides: tpl.shellPolicyOverrides }
         : {}),
+      ...(Array.isArray(tpl.mcpServers) && tpl.mcpServers.length > 0
+        ? {
+            mcpServers: tpl.mcpServers.map((s) => ({
+              name: s.name,
+              command: s.command,
+              args: Array.isArray(s.args) ? s.args : [],
+            })),
+          }
+        : {}),
     };
   });
 }