pulse-coder-engine 0.0.1-alpha.4 → 0.0.1-alpha.7

package/dist/built-in/index.js

@@ -233,10 +233,417 @@ var builtInSkillsPlugin = {
   }
 };
 
+// src/built-in/plan-mode-plugin/index.ts
+var PLANNING_POLICY = {
+  mode: "planning",
+  allowedCategories: ["read", "search", "other"],
+  disallowedCategories: ["write", "execute"],
+  notes: "Planning mode is prompt-constrained only. Disallowed tool attempts are observed and logged, not hard-blocked."
+};
+var EXECUTING_POLICY = {
+  mode: "executing",
+  allowedCategories: ["read", "search", "write", "execute", "other"],
+  disallowedCategories: []
+};
+var EXECUTE_PATTERNS = [
+  /开始执行/i,
+  /按这个计划做/i,
+  /可以改代码了/i,
+  /直接实现/i,
+  /go\s+ahead/i,
+  /proceed/i,
+  /implement\s+it/i,
+  /start\s+implement/i,
+  /start\s+coding/i
+];
+var NEGATIVE_PATTERNS = [
+  /先不(要)?执行/i,
+  /先别执行/i,
+  /不要执行/i,
+  /暂时不要执行/i,
+  /先别改代码/i,
+  /先不要改代码/i,
+  /先不要实现/i,
+  /not\s+now/i,
+  /hold\s+off/i,
+  /do\s+not\s+(start|execute|implement|proceed)/i,
+  /don't\s+(start|execute|implement|proceed)/i
+];
+var PLAN_PATTERNS = [/先计划/i, /先分析/i, /先出方案/i, /plan\s+first/i, /analysis\s+first/i];
+function appendSystemPrompt(base, append) {
+  if (!append.trim()) {
+    return base ?? { append: "" };
+  }
+  if (!base) {
+    return { append };
+  }
+  if (typeof base === "string") {
+    return `${base}
+
+${append}`;
+  }
+  if (typeof base === "function") {
+    return () => `${base()}
+
+${append}`;
+  }
+  const currentAppend = base.append.trim();
+  return {
+    append: currentAppend ? `${currentAppend}
+
+${append}` : append
+  };
+}
+var KNOWN_TOOL_META = {
+  read: {
+    category: "read",
+    risk: "low",
+    description: "Read file contents from the workspace."
+  },
+  ls: {
+    category: "read",
+    risk: "low",
+    description: "List files and directories."
+  },
+  grep: {
+    category: "search",
+    risk: "low",
+    description: "Search text content across files."
+  },
+  tavily: {
+    category: "search",
+    risk: "low",
+    description: "Search web results from external sources."
+  },
+  skill: {
+    category: "search",
+    risk: "low",
+    description: "Load procedural guidance from installed skills."
+  },
+  write: {
+    category: "write",
+    risk: "high",
+    description: "Create or overwrite file content."
+  },
+  edit: {
+    category: "write",
+    risk: "high",
+    description: "Modify existing files using exact replacements."
+  },
+  bash: {
+    category: "execute",
+    risk: "high",
+    description: "Execute shell commands."
+  },
+  clarify: {
+    category: "other",
+    risk: "low",
+    description: "Ask the user a targeted clarification question."
+  }
+};
+var BuiltInPlanModeService = class {
+  constructor(logger, eventEmitter, initialMode = "executing") {
+    this.logger = logger;
+    this.eventEmitter = eventEmitter;
+    this.mode = initialMode;
+    this.emitEvent("mode_entered", { reason: "initialize" });
+  }
+  mode;
+  events = [];
+  getMode() {
+    return this.mode;
+  }
+  setMode(mode, reason = "manual") {
+    if (this.mode === mode) {
+      return;
+    }
+    this.mode = mode;
+    this.emitEvent("mode_entered", { reason });
+  }
+  detectIntent(input) {
+    const text = input.trim();
+    if (!text) {
+      return "UNCLEAR";
+    }
+    if (NEGATIVE_PATTERNS.some((pattern) => pattern.test(text))) {
+      return "PLAN_ONLY";
+    }
+    if (EXECUTE_PATTERNS.some((pattern) => pattern.test(text))) {
+      return "EXECUTE_NOW";
+    }
+    if (PLAN_PATTERNS.some((pattern) => pattern.test(text))) {
+      return "PLAN_ONLY";
+    }
+    return "UNCLEAR";
+  }
+  processContextMessages(messages) {
+    const userInput = this.getLatestUserText(messages);
+    const modeBefore = this.mode;
+    if (!userInput) {
+      return {
+        modeBefore,
+        modeAfter: this.mode,
+        switched: false,
+        intent: "UNCLEAR",
+        userInput: ""
+      };
+    }
+    const intent = this.detectIntent(userInput);
+    if (intent === "EXECUTE_NOW") {
+      this.emitEvent("execution_intent_detected", { intent, userInput });
+      if (this.mode === "planning") {
+        this.mode = "executing";
+        this.emitEvent("mode_switched_by_intent", {
+          from: "planning",
+          to: "executing",
+          userInput
+        });
+        this.emitEvent("mode_entered", {
+          reason: "intent",
+          from: "planning"
+        });
+      }
+    }
+    return {
+      modeBefore,
+      modeAfter: this.mode,
+      switched: modeBefore !== this.mode,
+      intent,
+      userInput
+    };
+  }
+  getModePolicy(mode = this.mode) {
+    return mode === "planning" ? PLANNING_POLICY : EXECUTING_POLICY;
+  }
+  getToolMetadata(toolNames) {
+    return Array.from(new Set(toolNames)).sort().map((name) => this.inferToolMeta(name));
+  }
+  buildPromptAppend(toolNames, transition) {
+    const mode = this.mode;
+    const policy = this.getModePolicy(mode);
+    const toolMeta = this.getToolMetadata(toolNames);
+    const shownTools = toolMeta.slice(0, 40);
+    const omittedCount = toolMeta.length - shownTools.length;
+    const lines = [
+      "## Plan Mode Policy (Built-in Plugin)",
+      `Current mode: ${mode.toUpperCase()}`,
+      `Allowed tool categories: ${policy.allowedCategories.join(", ")}`,
+      `Disallowed tool categories: ${policy.disallowedCategories.join(", ") || "none"}`,
+      policy.notes ? `Policy notes: ${policy.notes}` : ""
+    ].filter(Boolean);
+    if (mode === "planning") {
+      lines.push(
+        "Planning objective: prioritize reading, analysis, and plan generation.",
+        "In planning mode, do not intentionally perform write/edit/execute actions.",
+        "If implementation is requested but intent is not explicit, ask for execution authorization.",
+        "Before each tool call in planning mode, self-check category compliance.",
+        "Plan format must include: goals, assumptions, steps, risks, validation approach."
+      );
+    } else {
+      lines.push(
+        "Executing objective: follow the agreed plan before broad exploration.",
+        "Make targeted edits and keep changes scoped.",
+        "Report what changed and how it was validated."
+      );
+    }
+    if (transition?.switched && transition.modeAfter === "executing") {
+      lines.push(
+        "Mode transition: the latest user message explicitly authorized execution.",
+        "In your next reply, acknowledge switching to EXECUTING mode before implementation details."
+      );
+    }
+    lines.push("Tool metadata (prompt-level policy reference):");
+    for (const meta of shownTools) {
+      lines.push(`- ${meta.name}: category=${meta.category}, risk=${meta.risk}, ${meta.description}`);
+    }
+    if (omittedCount > 0) {
+      lines.push(`- ... ${omittedCount} additional tool(s) omitted for brevity.`);
+    }
+    return lines.join("\n");
+  }
+  applyHooks(baseHooks) {
+    return {
+      onBeforeToolCall: async (name, input) => {
+        this.observePotentialPolicyViolation(name, input);
+        if (baseHooks?.onBeforeToolCall) {
+          const nextInput = await baseHooks.onBeforeToolCall(name, input);
+          return nextInput ?? input;
+        }
+        return input;
+      },
+      onAfterToolCall: async (name, input, output) => {
+        if (baseHooks?.onAfterToolCall) {
+          const nextOutput = await baseHooks.onAfterToolCall(name, input, output);
+          return nextOutput ?? output;
+        }
+        return output;
+      }
+    };
+  }
+  getEvents(limit = 50) {
+    return this.events.slice(-Math.max(0, limit));
+  }
+  observePotentialPolicyViolation(toolName, input) {
+    if (this.mode !== "planning") {
+      return;
+    }
+    const meta = this.inferToolMeta(toolName);
+    const policy = this.getModePolicy("planning");
+    if (!policy.disallowedCategories.includes(meta.category)) {
+      return;
+    }
+    this.emitEvent("disallowed_tool_attempt_in_planning", {
+      toolName,
+      category: meta.category,
+      risk: meta.risk,
+      input
+    });
+  }
+  inferToolMeta(name) {
+    const knownMeta = KNOWN_TOOL_META[name];
+    if (knownMeta) {
+      return {
+        name,
+        ...knownMeta
+      };
+    }
+    if (name.startsWith("mcp_")) {
+      return {
+        name,
+        category: "execute",
+        risk: "medium",
+        description: "MCP external tool invocation."
+      };
+    }
+    if (name.endsWith("_agent")) {
+      return {
+        name,
+        category: "execute",
+        risk: "high",
+        description: "Sub-agent task execution tool."
+      };
+    }
+    if (/read|list|cat/i.test(name)) {
+      return {
+        name,
+        category: "read",
+        risk: "low",
+        description: "Likely a read-only inspection tool inferred by name."
+      };
+    }
+    if (/search|find|query|grep/i.test(name)) {
+      return {
+        name,
+        category: "search",
+        risk: "low",
+        description: "Likely a search tool inferred by name."
+      };
+    }
+    if (/write|edit|patch|update|create|delete|remove/i.test(name)) {
+      return {
+        name,
+        category: "write",
+        risk: "high",
+        description: "Likely a file-modifying tool inferred by name."
+      };
+    }
+    if (/bash|exec|run|shell|deploy|build|test/i.test(name)) {
+      return {
+        name,
+        category: "execute",
+        risk: "high",
+        description: "Likely a command execution tool inferred by name."
+      };
+    }
+    return {
+      name,
+      category: "other",
+      risk: "low",
+      description: "Tool category could not be inferred with high confidence."
+    };
+  }
+  getLatestUserText(messages) {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+      const message = messages[i];
+      if (message.role !== "user") {
+        continue;
+      }
+      return this.messageContentToText(message.content);
+    }
+    return "";
+  }
+  messageContentToText(content) {
+    if (typeof content === "string") {
+      return content;
+    }
+    if (!Array.isArray(content)) {
+      return "";
+    }
+    const textParts = [];
+    for (const part of content) {
+      if (typeof part === "string") {
+        textParts.push(part);
+        continue;
+      }
+      if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+        textParts.push(part.text);
+      }
+    }
+    return textParts.join("\n");
+  }
+  emitEvent(name, payload) {
+    const event = {
+      name,
+      mode: this.mode,
+      timestamp: Date.now(),
+      payload
+    };
+    this.events.push(event);
+    if (this.events.length > 500) {
+      this.events.shift();
+    }
+    this.eventEmitter.emit(name, event);
+    this.eventEmitter.emit("plan_mode_event", event);
+    if (name === "disallowed_tool_attempt_in_planning") {
+      this.logger.warn("[PlanMode] Soft violation detected in planning mode", payload);
+      return;
+    }
+    this.logger.info(`[PlanMode] ${name}`, payload);
+  }
+};
+var builtInPlanModePlugin = {
+  name: "pulse-coder-engine/built-in-plan-mode",
+  version: "1.0.0",
+  async initialize(context) {
+    const service = new BuiltInPlanModeService(context.logger, context.events, "executing");
+    context.registerRunHook("plan-mode", ({ context: runContext, tools, systemPrompt, hooks }) => {
+      const mode = service.getMode();
+      if (mode === "executing") {
+        return {
+          systemPrompt,
+          hooks
+        };
+      }
+      const transition = service.processContextMessages(runContext.messages);
+      const append = service.buildPromptAppend(Object.keys(tools), transition);
+      const finalSystemPrompt = appendSystemPrompt(systemPrompt, append);
+      return {
+        systemPrompt: finalSystemPrompt,
+        hooks: service.applyHooks(hooks)
+      };
+    });
+    context.registerService("planMode", service);
+    context.registerService("planModeService", service);
+    context.logger.info("[PlanMode] Built-in plan mode plugin initialized", {
+      mode: service.getMode()
+    });
+  }
+};
+
 // src/built-in/sub-agent-plugin/index.ts
 import { z as z10 } from "zod";
-import { promises as fs } from "fs";
-import path2 from "path";
+import { promises as fs2 } from "fs";
+import path3 from "path";
 
 // src/ai/index.ts
 import { generateText, streamText } from "ai";
@@ -268,8 +675,9 @@ var CLARIFICATION_TIMEOUT = Number(process.env.CLARIFICATION_TIMEOUT ?? 3e5);
 var CLARIFICATION_ENABLED = process.env.CLARIFICATION_ENABLED !== "false";
 
 // src/prompt/system.ts
-var generateSystemPrompt = () => {
-  const basePrompt = `
+import fs from "fs";
+import path2 from "path";
+var DEFAULT_PROMPT = `
 You are Pulse Coder, the best coding agent on the planet.
 
 You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
@@ -349,7 +757,7 @@ Use the 'clarify' tool when you genuinely need information from the user to proc
 - Explain briefly what would change based on the answer
 
 Example usage: Call clarify with a question, optional context, and optional default answer. The tool will pause and wait for the user's response.
-- For substantial work, summarize clearly; follow final\u2011answer formatting.
+- For substantial work, summarize clearly; follow final-answer formatting.
 - Skip heavy formatting for simple confirmations.
 - Don't dump large files you've written; reference paths only.
 - No "save/copy this file" - User is on the same machine.
@@ -363,19 +771,19 @@ Example usage: Call clarify with a question, optional context, and optional defa
 ## Final answer structure and style guidelines
 
 - Plain text; CLI handles styling. Use structure only when it helps scanability.
-- Headers: optional; short Title Case (1-3 words) wrapped in **\u2026**; no blank line before the first bullet; add only if they truly help.
-- Bullets: use - ; merge related points; keep to one line when possible; 4\u20136 per list ordered by importance; keep phrasing consistent.
+- Headers: optional; short Title Case (1-3 words) wrapped in **...**; no blank line before the first bullet; add only if they truly help.
+- Bullets: use - ; merge related points; keep to one line when possible; 4-6 per list ordered by importance; keep phrasing consistent.
 - Monospace: backticks for commands/paths/env vars/code ids and inline examples; use for literal keyword bullets; never combine with **.
 - Code samples or multi-line snippets should be wrapped in fenced code blocks; include an info string as often as possible.
-- Structure: group related bullets; order sections general \u2192 specific \u2192 supporting; for subsections, start with a bolded keyword bullet, then items; match complexity to the task.
-- Tone: collaborative, concise, factual; present tense, active voice; self\u2011contained; no "above/below"; parallel wording.
-- Don'ts: no nested bullets/hierarchies; no ANSI codes; don't cram unrelated keywords; keep keyword lists short\u2014wrap/reformat if long; avoid naming formatting styles in answers.
-- Adaptation: code explanations \u2192 precise, structured with code refs; simple tasks \u2192 lead with outcome; big changes \u2192 logical walkthrough + rationale + next actions; casual one-offs \u2192 plain sentences, no headers/bullets.
+- Structure: group related bullets; order sections general -> specific -> supporting; for subsections, start with a bolded keyword bullet, then items; match complexity to the task.
+- Tone: collaborative, concise, factual; present tense, active voice; self-contained; no "above/below"; parallel wording.
+- Don'ts: no nested bullets/hierarchies; no ANSI codes; don't cram unrelated keywords; keep keyword lists short-wrap/reformat if long; avoid naming formatting styles in answers.
+- Adaptation: code explanations -> precise, structured with code refs; simple tasks -> lead with outcome; big changes -> logical walkthrough + rationale + next actions; casual one-offs -> plain sentences, no headers/bullets.
 - File References: When referencing files in your response follow the below rules:
   * Use inline code to make file paths clickable.
   * Each reference should have a stand alone path. Even if it's the same file.
-  * Accepted: absolute, workspace\u2011relative, a/ or b/ diff prefixes, or bare filename/suffix.
-  * Optionally include line/column (1\u2011based): :line[:column] or #Lline[Ccolumn] (column defaults to 1).
+  * Accepted: absolute, workspace-relative, a/ or b/ diff prefixes, or bare filename/suffix.
+  * Optionally include line/column (1-based): :line[:column] or #Lline[Ccolumn] (column defaults to 1).
   * Do not use URIs like file://, vscode://, or https://.
   * Do not provide range of lines
   * Examples: src/app.ts, src/app.ts:42, b/server/index.js#L10, C:\repoprojectmain.rs:12:5
@@ -389,7 +797,24 @@ Here is some useful information about the environment you are running in:
 <files>
 
 </files>`;
-  return basePrompt;
+var AGENTS_FILE_REGEX = /^agents\.md$/i;
+var loadAgentsPrompt = () => {
+  try {
+    const cwd = process.cwd();
+    const entries = fs.readdirSync(cwd, { withFileTypes: true });
+    const target = entries.find((entry) => entry.isFile() && AGENTS_FILE_REGEX.test(entry.name));
+    if (!target) {
+      return null;
+    }
+    const filePath = path2.join(cwd, target.name);
+    const content = fs.readFileSync(filePath, "utf8").trim();
+    return content.length > 0 ? content : null;
+  } catch {
+    return null;
+  }
+};
+var generateSystemPrompt = () => {
+  return loadAgentsPrompt() ?? DEFAULT_PROMPT;
 };
 
 // src/ai/index.ts
@@ -419,9 +844,10 @@ var streamTextAI = (messages, tools, options) => {
   const provider = options?.provider ?? CoderAI;
   const model = options?.model ?? DEFAULT_MODEL;
   const wrappedTools = options?.toolExecutionContext ? wrapToolsWithContext(tools, options.toolExecutionContext) : tools;
+  const finalSystemPrompt = resolveSystemPrompt(options?.systemPrompt);
   return streamText({
     model: provider(model),
-    system: resolveSystemPrompt(options?.systemPrompt),
+    system: finalSystemPrompt,
     messages,
     tools: wrappedTools,
     providerOptions,
@@ -864,7 +1290,7 @@ var GrepTool = {
   }),
   execute: async ({
     pattern,
-    path: path3 = ".",
+    path: path4 = ".",
     glob,
     type,
     outputMode = "files_with_matches",
@@ -899,11 +1325,11 @@ var GrepTool = {
     if (type) {
       args.push("--type", type);
     }
-    if (path3 && path3 !== ".") {
-      if (!existsSync5(path3)) {
-        throw new Error(`Path does not exist: ${path3}`);
+    if (path4 && path4 !== ".") {
+      if (!existsSync5(path4)) {
+        throw new Error(`Path does not exist: ${path4}`);
       }
-      args.push(path3);
+      args.push(path4);
     }
     let command = args.map((arg) => {
       if (arg.includes(" ") || arg.includes("$") || arg.includes("*")) {
@@ -958,8 +1384,8 @@ var LsTool = {
   inputSchema: z6.object({
     path: z6.string().optional().describe("The path to list files from (defaults to current directory)")
   }),
-  execute: async ({ path: path3 = "." }) => {
-    const files = readdirSync(path3);
+  execute: async ({ path: path4 = "." }) => {
+    const files = readdirSync(path4);
     return { files };
   }
 };
@@ -1130,8 +1556,8 @@ var ConfigLoader = class {
     const fileInfos = [];
     for (let configDir of configDirs) {
       try {
-        await fs.access(configDir);
-        const files = await fs.readdir(configDir);
+        await fs2.access(configDir);
+        const files = await fs2.readdir(configDir);
         fileInfos.push({ files, configDir });
       } catch {
         continue;
@@ -1148,7 +1574,7 @@ var ConfigLoader = class {
         const files = fileInfo.files;
         for (const file of files) {
           if (file.endsWith(".md")) {
-            const config = await this.parseConfig(path2.join(fileInfo.configDir, file));
+            const config = await this.parseConfig(path3.join(fileInfo.configDir, file));
             if (config) configs.push(config);
           }
         }
@@ -1160,7 +1586,7 @@ var ConfigLoader = class {
   }
   async parseConfig(filePath) {
     try {
-      const content = await fs.readFile(filePath, "utf-8");
+      const content = await fs2.readFile(filePath, "utf-8");
       const lines = content.split("\n");
       let name = "";
       let description = "";
@@ -1189,7 +1615,7 @@ var ConfigLoader = class {
         }
       }
       if (!name) {
-        name = path2.basename(filePath, ".md");
+        name = path3.basename(filePath, ".md");
       }
       return {
         name: name.trim(),
@@ -1228,20 +1654,15 @@ var SubAgentPlugin = class {
   async initialize(context) {
     try {
       const configs = await this.configLoader.loadAgentConfigs();
-      const tools = this.getAvailableTools(context);
       for (const config of configs) {
-        this.registerAgentTool(context, config, tools);
+        this.registerAgentTool(context, config);
       }
       context.logger.info(`SubAgentPlugin loaded ${configs.length} agents.`);
     } catch (error) {
       context.logger.error("Failed to initialize SubAgentPlugin", error);
     }
   }
-  getAvailableTools(context) {
-    const allTools = {};
-    return BuiltinToolsMap;
-  }
-  registerAgentTool(context, config, tools) {
+  registerAgentTool(context, config) {
     const toolName = `${config.name}_agent`;
     const tool2 = {
       description: config.description,
@@ -1250,6 +1671,7 @@ var SubAgentPlugin = class {
         context: z10.any().optional().describe("\u4EFB\u52A1\u4E0A\u4E0B\u6587\u4FE1\u606F")
       }),
       execute: async ({ task, context: taskContext }) => {
+        const tools = { ...BuiltinToolsMap, ...context.getTools() };
         try {
           context.logger.info(`Running agent ${config.name}: ${task}`);
           const result = await this.agentRunner.runAgent(config, task, taskContext, tools);
@@ -1272,13 +1694,16 @@ var SubAgentPlugin = class {
 var builtInPlugins = [
   builtInMCPPlugin,
   builtInSkillsPlugin,
+  builtInPlanModePlugin,
   new SubAgentPlugin()
 ];
 var built_in_default = builtInPlugins;
 export {
+  BuiltInPlanModeService,
   BuiltInSkillRegistry,
   SubAgentPlugin,
   builtInMCPPlugin,
+  builtInPlanModePlugin,
   builtInPlugins,
   builtInSkillsPlugin,
   built_in_default as default