chainlesschain 0.37.9 → 0.37.11

package/src/repl/agent-repl.js

@@ -24,6 +24,8 @@ import path from "path";
 import { execSync } from "child_process";
 import { fileURLToPath } from "url";
 import { logger } from "../lib/logger.js";
+import { getPlanModeManager, PlanState } from "../lib/plan-mode.js";
+import { CLISkillLoader } from "../lib/skill-loader.js";
 
 /**
  * Tool definitions for function calling
@@ -188,82 +190,34 @@ const TOOLS = [
 ];
 
 /**
- * Find and load bundled skills (shared with skill command)
+ * Shared multi-layer skill loader
  */
-const __agentDirname = path.dirname(fileURLToPath(import.meta.url));
-
-function findSkillsDir() {
-  const candidates = [
-    path.resolve(
-      __agentDirname,
-      "../../../../../desktop-app-vue/src/main/ai-engine/cowork/skills/builtin",
-    ),
-    path.resolve(
-      process.cwd(),
-      "desktop-app-vue/src/main/ai-engine/cowork/skills/builtin",
-    ),
-  ];
-  for (const dir of candidates) {
-    if (fs.existsSync(dir)) return dir;
-  }
-  return null;
-}
-
-function loadSkillList(skillsDir) {
-  const skills = [];
-  try {
-    const dirs = fs.readdirSync(skillsDir, { withFileTypes: true });
-    for (const dir of dirs) {
-      if (!dir.isDirectory()) continue;
-      const skillMd = path.join(skillsDir, dir.name, "SKILL.md");
-      if (!fs.existsSync(skillMd)) continue;
-      try {
-        const content = fs.readFileSync(skillMd, "utf8");
-        const lines = content.split("\n");
-        if (lines[0].trim() !== "---") continue;
-        let endIndex = -1;
-        for (let i = 1; i < lines.length; i++) {
-          if (lines[i].trim() === "---") {
-            endIndex = i;
-            break;
-          }
-        }
-        if (endIndex === -1) continue;
-        const data = {};
-        for (const line of lines.slice(1, endIndex)) {
-          const ci = line.indexOf(":");
-          if (ci > 0) {
-            const key = line.slice(0, ci).trim();
-            const val = line
-              .slice(ci + 1)
-              .trim()
-              .replace(/^['"]|['"]$/g, "");
-            data[key] = val;
-          }
-        }
-        skills.push({
-          id: data.name || dir.name,
-          description: data.description || "",
-          category: data.category || "uncategorized",
-          dirName: dir.name,
-          hasHandler: fs.existsSync(
-            path.join(skillsDir, dir.name, "handler.js"),
-          ),
-        });
-      } catch {
-        // Skip malformed skill files
-      }
-    }
-  } catch {
-    // Skills dir unreadable
-  }
-  return skills;
-}
+const skillLoader = new CLISkillLoader();
 
 /**
- * Execute a tool call
+ * Execute a tool call (with plan mode filtering)
  */
 async function executeTool(name, args) {
+  // Plan mode: check if tool is allowed
+  const planManager = getPlanModeManager();
+  if (planManager.isActive() && !planManager.isToolAllowed(name)) {
+    // In plan mode, log the blocked tool as a plan item
+    planManager.addPlanItem({
+      title: `${name}: ${formatToolArgs(name, args)}`,
+      tool: name,
+      params: args,
+      estimatedImpact:
+        name === "run_shell"
+          ? "high"
+          : name === "write_file"
+            ? "medium"
+            : "low",
+    });
+    return {
+      error: `[Plan Mode] Tool "${name}" is blocked during planning. It has been added to the plan. Use /plan approve to execute.`,
+    };
+  }
+
   switch (name) {
     case "read_file": {
       const filePath = path.resolve(args.path);
@@ -373,50 +327,28 @@ async function executeTool(name, args) {
     }
 
     case "run_skill": {
-      const skillsDir = findSkillsDir();
-      if (!skillsDir) {
+      const allSkills = skillLoader.getResolvedSkills();
+      if (allSkills.length === 0) {
         return {
           error:
-            "Skills directory not found. Make sure you're in the ChainlessChain project root.",
+            "No skills found. Make sure you're in the ChainlessChain project root or have skills installed.",
         };
       }
-      const handlerPath = path.join(skillsDir, args.skill_name, "handler.js");
-      if (!fs.existsSync(handlerPath)) {
-        // Try fuzzy match
-        const skills = loadSkillList(skillsDir);
-        const match = skills.find(
-          (s) => s.id === args.skill_name || s.dirName === args.skill_name,
-        );
-        if (match && match.hasHandler) {
-          const matchedPath = path.join(skillsDir, match.dirName, "handler.js");
-          try {
-            const handler = (
-              await import(`file://${matchedPath.replace(/\\/g, "/")}`)
-            ).default;
-            const task = {
-              params: { input: args.input },
-              input: args.input,
-              action: args.input,
-            };
-            const context = {
-              projectRoot: process.cwd(),
-              workspacePath: process.cwd(),
-            };
-            const result = await handler.execute(task, context);
-            return result;
-          } catch (err) {
-            return { error: `Skill execution failed: ${err.message}` };
-          }
-        }
+      const match = allSkills.find(
+        (s) => s.id === args.skill_name || s.dirName === args.skill_name,
+      );
+      if (!match || !match.hasHandler) {
         return {
           error: `Skill "${args.skill_name}" not found or has no handler. Use list_skills to see available skills.`,
         };
       }
       try {
-        const handler = (
-          await import(`file://${handlerPath.replace(/\\/g, "/")}`)
-        ).default;
-        if (handler.init) await handler.init({});
+        const handlerPath = path.join(match.skillDir, "handler.js");
+        const imported = await import(
+          `file://${handlerPath.replace(/\\/g, "/")}`
+        );
+        const handler = imported.default || imported;
+        if (handler.init) await handler.init(match);
         const task = {
           params: { input: args.input },
           input: args.input,
@@ -426,7 +358,7 @@ async function executeTool(name, args) {
           projectRoot: process.cwd(),
           workspacePath: process.cwd(),
         };
-        const result = await handler.execute(task, context);
+        const result = await handler.execute(task, context, match);
         return result;
       } catch (err) {
         return { error: `Skill execution failed: ${err.message}` };
@@ -434,11 +366,10 @@ async function executeTool(name, args) {
     }
 
     case "list_skills": {
-      const skillsDir = findSkillsDir();
-      if (!skillsDir) {
-        return { error: "Skills directory not found." };
+      let skills = skillLoader.getResolvedSkills();
+      if (skills.length === 0) {
+        return { error: "No skills found." };
       }
-      let skills = loadSkillList(skillsDir);
       if (args.category) {
         skills = skills.filter(
           (s) => s.category.toLowerCase() === args.category.toLowerCase(),
@@ -458,8 +389,9 @@ async function executeTool(name, args) {
         skills: skills.map((s) => ({
           id: s.id,
           category: s.category,
+          source: s.source,
           hasHandler: s.hasHandler,
-          description: s.description.substring(0, 80),
+          description: (s.description || "").substring(0, 80),
         })),
       };
     }
@@ -520,6 +452,9 @@ async function chatWithTools(messages, options) {
 
     const data = await response.json();
     // Normalize to Ollama-like format
+    if (!data.choices || !data.choices[0]) {
+      throw new Error("Invalid API response: no choices returned");
+    }
     const choice = data.choices[0];
     return {
       message: choice.message,
@@ -537,7 +472,11 @@ async function agentLoop(messages, options) {
 
   for (let i = 0; i < MAX_ITERATIONS; i++) {
     const result = await chatWithTools(messages, options);
-    const msg = result.message;
+    const msg = result?.message;
+
+    if (!msg) {
+      return "(No response from LLM)";
+    }
 
     // Check for tool calls
     const toolCalls = msg.tool_calls;
@@ -626,7 +565,7 @@ Key behaviors:
 - When asked to create something, use write_file to create it
 - When asked to run/test something, use run_shell to execute it
 - When asked about files or code, use read_file and search_files to find information
-- You have 138 built-in skills (code-review, summarize, translate, refactor, etc.) — use list_skills to discover them and run_skill to execute them
+- You have multi-layer skills (built-in, marketplace, global, project-level) — use list_skills to discover them and run_skill to execute them
 - Always explain what you're doing and show results
 - Be concise but thorough
 
@@ -643,10 +582,22 @@ export async function startAgentRepl(options = {}) {
 
   const messages = [{ role: "system", content: SYSTEM_PROMPT }];
 
+  const getPrompt = () => {
+    const planManager = getPlanModeManager();
+    if (planManager.isActive()) {
+      const state = planManager.state;
+      if (state === PlanState.APPROVED || state === PlanState.EXECUTING) {
+        return chalk.green("[plan:exec] > ");
+      }
+      return chalk.yellow("[plan] > ");
+    }
+    return chalk.green("> ");
+  };
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: chalk.green("> "),
+    prompt: getPrompt(),
     terminal: true,
   });
 
@@ -661,12 +612,16 @@ export async function startAgentRepl(options = {}) {
   );
   logger.log(chalk.gray("Type /exit to quit, /help for commands\n"));
 
-  rl.prompt();
+  const prompt = () => {
+    rl.setPrompt(getPrompt());
+    rl.prompt();
+  };
+  prompt();
 
   rl.on("line", async (input) => {
     const trimmed = input.trim();
     if (!trimmed) {
-      rl.prompt();
+      prompt();
       return;
     }
 
@@ -686,13 +641,24 @@ export async function startAgentRepl(options = {}) {
       logger.log(`  ${chalk.cyan("/provider")}   Show/change provider`);
       logger.log(`  ${chalk.cyan("/clear")}      Clear conversation`);
       logger.log(`  ${chalk.cyan("/compact")}    Keep only last 4 messages`);
+      logger.log(
+        `  ${chalk.cyan("/cowork")}     Multi-agent collaboration (debate, compare)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/plan")}       Enter plan mode (read-only analysis first)`,
+      );
+      logger.log(`  ${chalk.cyan("/plan show")}  Show current plan`);
+      logger.log(
+        `  ${chalk.cyan("/plan approve")} Approve and execute the plan`,
+      );
+      logger.log(`  ${chalk.cyan("/plan reject")}  Reject the plan`);
       logger.log(chalk.bold("\nCapabilities:"));
       logger.log("  Read, write, and edit files");
       logger.log("  Run shell commands (git, npm, etc.)");
       logger.log("  Search codebase by filename or content");
       logger.log("  Run 138 built-in skills (code-review, summarize, etc.)");
-      logger.log("  Answer questions about code\n");
-      rl.prompt();
+      logger.log("  Plan mode: analyze first, execute after approval\n");
+      prompt();
       return;
     }
 
@@ -704,7 +670,7 @@ export async function startAgentRepl(options = {}) {
       } else {
         logger.info(`Current model: ${chalk.cyan(model)}`);
       }
-      rl.prompt();
+      prompt();
       return;
     }
 
@@ -716,14 +682,14 @@ export async function startAgentRepl(options = {}) {
       } else {
         logger.info(`Current provider: ${chalk.cyan(provider)}`);
       }
-      rl.prompt();
+      prompt();
       return;
     }
 
     if (trimmed === "/clear") {
       messages.length = 1; // Keep system prompt
       logger.info("Conversation cleared");
-      rl.prompt();
+      prompt();
       return;
     }
 
@@ -736,7 +702,176 @@ export async function startAgentRepl(options = {}) {
         messages.push(systemMsg, ...recent);
         logger.info("Conversation compacted to last 4 messages");
       }
-      rl.prompt();
+      prompt();
+      return;
+    }
+
+    // Cowork commands
+    if (trimmed.startsWith("/cowork")) {
+      const coworkArgs = trimmed.slice(7).trim();
+      const [subCmd, ...rest] = coworkArgs.split(/\s+/);
+      const coworkInput = rest.join(" ");
+
+      if (!subCmd || subCmd === "help") {
+        logger.log(chalk.bold("\nCowork Commands:"));
+        logger.log(
+          `  ${chalk.cyan("/cowork debate <file>")}     Multi-perspective code review`,
+        );
+        logger.log(
+          `  ${chalk.cyan("/cowork compare <prompt>")}  A/B solution comparison`,
+        );
+        logger.log("");
+      } else if (subCmd === "debate" && coworkInput) {
+        try {
+          const { startDebate } =
+            await import("../lib/cowork/debate-review-cli.js");
+          let code = coworkInput;
+          let targetLabel = coworkInput;
+          const resolved = path.resolve(coworkInput);
+          if (fs.existsSync(resolved)) {
+            code = fs.readFileSync(resolved, "utf-8");
+            targetLabel = resolved;
+            if (code.length > 15000) {
+              code = code.substring(0, 15000) + "\n... (truncated)";
+            }
+          }
+          process.stdout.write(chalk.gray("\n  Running debate review...\n"));
+          const result = await startDebate({
+            target: targetLabel,
+            code,
+            llmOptions: { provider, model, baseUrl, apiKey },
+          });
+          for (const review of result.reviews) {
+            const vc =
+              review.verdict === "APPROVE"
+                ? chalk.green
+                : review.verdict === "REJECT"
+                  ? chalk.red
+                  : chalk.yellow;
+            process.stdout.write(
+              `  ${chalk.bold(review.role)}: ${vc(review.verdict)}\n`,
+            );
+          }
+          process.stdout.write(
+            `\n  ${chalk.bold("Verdict:")} ${result.verdict}  Consensus: ${result.consensusScore}%\n\n`,
+          );
+          // Add summary to conversation for context
+          messages.push({
+            role: "assistant",
+            content: `[Cowork Debate Result] ${result.verdict} (consensus: ${result.consensusScore}%)\n${result.summary.substring(0, 500)}`,
+          });
+        } catch (err) {
+          logger.error(`Debate failed: ${err.message}`);
+        }
+      } else if (subCmd === "compare" && coworkInput) {
+        try {
+          const { compare } =
+            await import("../lib/cowork/ab-comparator-cli.js");
+          process.stdout.write(chalk.gray("\n  Generating variants...\n"));
+          const result = await compare({
+            prompt: coworkInput,
+            llmOptions: { provider, model, baseUrl, apiKey },
+          });
+          for (const v of result.variants) {
+            process.stdout.write(
+              `  ${chalk.cyan(v.name)}: score ${v.totalScore}\n`,
+            );
+          }
+          process.stdout.write(
+            `\n  ${chalk.bold("Winner:")} ${chalk.green(result.winner)}\n\n`,
+          );
+          messages.push({
+            role: "assistant",
+            content: `[Cowork Compare Result] Winner: ${result.winner}. ${result.reason}`,
+          });
+        } catch (err) {
+          logger.error(`Compare failed: ${err.message}`);
+        }
+      } else {
+        logger.info(
+          "Usage: /cowork debate <file-or-topic> or /cowork compare <prompt>",
+        );
+      }
+
+      prompt();
+      return;
+    }
+
+    // Plan mode commands
+    if (trimmed.startsWith("/plan")) {
+      const planManager = getPlanModeManager();
+      const subCmd = trimmed.slice(5).trim();
+
+      if (!subCmd || subCmd === "enter") {
+        if (planManager.isActive()) {
+          logger.info(
+            "Already in plan mode. Use /plan show, /plan approve, or /plan reject.",
+          );
+        } else {
+          planManager.enterPlanMode({ title: "Agent Plan" });
+          logger.success(
+            "Entered plan mode. Write tools are blocked until you approve the plan.",
+          );
+          logger.info(
+            "The AI can still read files and search. Blocked tools become plan items.",
+          );
+          logger.info(
+            "Use /plan show to see the plan, /plan approve to execute.",
+          );
+          // Inject plan mode context into system prompt
+          messages.push({
+            role: "system",
+            content:
+              "[PLAN MODE ACTIVE] You are now in plan mode. You can read files, search, and analyze — but write/execute tools are blocked. Any blocked tool calls will be recorded as plan items. Analyze the task thoroughly, then the user will approve your plan.",
+          });
+        }
+      } else if (subCmd === "show") {
+        if (!planManager.isActive()) {
+          logger.info("Not in plan mode. Use /plan to enter.");
+        } else {
+          logger.log("\n" + planManager.generatePlanSummary() + "\n");
+        }
+      } else if (subCmd === "approve" || subCmd === "yes") {
+        if (!planManager.isActive()) {
+          logger.info("No plan to approve.");
+        } else if (planManager.currentPlan.items.length === 0) {
+          logger.info(
+            "Plan has no items yet. Let the AI analyze the task first.",
+          );
+        } else {
+          planManager.approvePlan();
+          logger.success(
+            `Plan approved! ${planManager.currentPlan.items.length} items ready for execution.`,
+          );
+          logger.info(
+            "Write/execute tools are now unlocked. The AI can proceed.",
+          );
+          messages.push({
+            role: "system",
+            content: `[PLAN APPROVED] The user has approved your plan with ${planManager.currentPlan.items.length} items. You can now use all tools including write_file, edit_file, run_shell, and run_skill. Execute the plan items in order.`,
+          });
+        }
+      } else if (subCmd === "reject" || subCmd === "no") {
+        if (!planManager.isActive()) {
+          logger.info("No plan to reject.");
+        } else {
+          planManager.rejectPlan("User rejected");
+          logger.info("Plan rejected. Exited plan mode.");
+        }
+      } else if (subCmd === "exit") {
+        if (planManager.isActive()) {
+          planManager.exitPlanMode({ savePlan: true });
+          logger.info("Exited plan mode.");
+        } else {
+          logger.info("Not in plan mode.");
+        }
+      } else {
+        logger.info(
+          "Unknown /plan subcommand. Try: /plan, /plan show, /plan approve, /plan reject, /plan exit",
+        );
+      }
+
+      prompt();
       return;
     }
 
@@ -773,7 +908,7 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
-    rl.prompt();
+    prompt();
   });
 
   rl.on("close", () => {