patchwarden 1.5.0 → 1.6.1

package/dist/tools/dispatch/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared types and helpers for the dispatch map.
+ *
+ * Each domain dispatch file exports a `ToolHandlerMap` whose handlers
+ * directly call the existing tool functions — no logic is rewritten.
+ */
+export type ToolHandler = (args: Record<string, unknown> | undefined) => Promise<{
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+}>;
+export type ToolHandlerMap = Record<string, ToolHandler>;
+/**
+ * Wrap a plain data value into the MCP CallToolResult content envelope.
+ * Mirrors the original `toResult` helper from registry.ts.
+ */
+export declare function toResult(data: unknown): {
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+};

package/dist/tools/dispatch/types.js

@@ -0,0 +1,15 @@
+/**
+ * Shared types and helpers for the dispatch map.
+ *
+ * Each domain dispatch file exports a `ToolHandlerMap` whose handlers
+ * directly call the existing tool functions — no logic is rewritten.
+ */
+/**
+ * Wrap a plain data value into the MCP CallToolResult content envelope.
+ * Mirrors the original `toResult` helper from registry.ts.
+ */
+export function toResult(data) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    };
+}

package/dist/tools/dispatch/validation.d.ts

@@ -0,0 +1,7 @@
+import type { PatchOperation } from "../../direct/directPatch.js";
+import type { ReleaseStage } from "../../release/releaseGate.js";
+import { type TaskTemplateName } from "../taskTemplates.js";
+export declare function parseOptionalTaskTemplate(value: unknown): TaskTemplateName | undefined;
+export declare function parseReleaseStage(value: unknown): ReleaseStage;
+export declare function parseTaskLogFile(value: unknown): "stdout" | "stderr" | "test" | "verify";
+export declare function parsePatchOperations(value: unknown): PatchOperation[];

package/dist/tools/dispatch/validation.js

@@ -0,0 +1,71 @@
+import { TASK_TEMPLATE_NAMES } from "../taskTemplates.js";
+const RELEASE_STAGES = new Set([
+    "local_ready",
+    "packed_ready",
+    "published_verified",
+    "github_release_verified",
+    "ci_verified",
+]);
+const PATCH_OPERATION_TYPES = new Set([
+    "replace_exact",
+    "insert_before",
+    "insert_after",
+    "replace_whole_file",
+]);
+const PATCH_OCCURRENCES = new Set(["first", "all", "exactly_once"]);
+const TASK_LOG_FILES = new Set(["stdout", "stderr", "test", "verify"]);
+export function parseOptionalTaskTemplate(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (typeof value !== "string" || !TASK_TEMPLATE_NAMES.includes(value)) {
+        throw new Error(`template must be one of: ${TASK_TEMPLATE_NAMES.join(", ")}`);
+    }
+    return value;
+}
+export function parseReleaseStage(value) {
+    const stage = value === undefined || value === null || value === ""
+        ? "local_ready"
+        : String(value);
+    if (!RELEASE_STAGES.has(stage)) {
+        throw new Error(`target_stage must be one of: ${[...RELEASE_STAGES].join(", ")}`);
+    }
+    return stage;
+}
+export function parseTaskLogFile(value) {
+    const file = value === undefined || value === null || value === "" ? "stdout" : String(value);
+    if (!TASK_LOG_FILES.has(file)) {
+        throw new Error(`file must be one of: ${[...TASK_LOG_FILES].join(", ")}`);
+    }
+    return file;
+}
+export function parsePatchOperations(value) {
+    if (!Array.isArray(value))
+        throw new Error("operations must be an array");
+    return value.map((entry, index) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            throw new Error(`operations[${index}] must be an object`);
+        }
+        const record = entry;
+        if (typeof record.type !== "string" || !PATCH_OPERATION_TYPES.has(record.type)) {
+            throw new Error(`operations[${index}].type is invalid`);
+        }
+        if (typeof record.new_text !== "string") {
+            throw new Error(`operations[${index}].new_text must be a string`);
+        }
+        if (record.old_text !== undefined && typeof record.old_text !== "string") {
+            throw new Error(`operations[${index}].old_text must be a string`);
+        }
+        if (record.occurrence !== undefined
+            && (typeof record.occurrence !== "string" || !PATCH_OCCURRENCES.has(record.occurrence))) {
+            throw new Error(`operations[${index}].occurrence is invalid`);
+        }
+        return {
+            type: record.type,
+            new_text: record.new_text,
+            ...(record.old_text === undefined ? {} : { old_text: record.old_text }),
+            ...(record.occurrence === undefined
+                ? {}
+                : { occurrence: record.occurrence }),
+        };
+    });
+}

package/dist/tools/{getPlan.js → goals/getPlan.js}

@@ -1,9 +1,9 @@
 import { readFileSync, existsSync } from "node:fs";
 import { resolve, join } from "node:path";
-import { getPlansDir, getConfig } from "../config.js";
-import { guardReadPath } from "../security/pathGuard.js";
-import { guardSensitivePath } from "../security/sensitiveGuard.js";
-import { redactSensitiveContent } from "../security/contentRedaction.js";
+import { getPlansDir, getConfig } from "../../config.js";
+import { guardReadPath } from "../../security/pathGuard.js";
+import { guardSensitivePath } from "../../security/sensitiveGuard.js";
+import { redactSensitiveContent } from "../../security/contentRedaction.js";
 export function getPlan(input) {
     const config = getConfig();
     const plansDir = getPlansDir(config);

package/dist/tools/{goalSubgoalTask.d.ts → goals/goalSubgoalTask.d.ts}

@@ -13,7 +13,7 @@
  *   - createSubgoalTask 强制 execution_mode 为 "execute"，因为 assess_only 不产生可关联的 task。
  *   - createTask 内部使用 getConfig()，因此 workspaceRoot 由全局配置决定。
  */
-import { type CreateTaskInput } from "./createTask.js";
+import { type CreateTaskInput } from "../tasks/createTask.js";
 export interface CreateSubgoalTaskInput {
     goal_id: string;
     subgoal_title: string;
@@ -48,4 +48,4 @@ export interface CreateSubgoalTaskOutput {
  * @throws PatchWardenError("invalid_dependency") 当 depends_on 引用不存在的 subgoal
  * @throws PatchWardenError("invalid_execution_mode") 当 execution_mode 为 "assess_only"
  */
-export declare function createSubgoalTask(input: CreateSubgoalTaskInput): CreateSubgoalTaskOutput;
+export declare function createSubgoalTask(input: CreateSubgoalTaskInput): Promise<CreateSubgoalTaskOutput>;

package/dist/tools/goals/goalSubgoalTask.js

@@ -0,0 +1,118 @@
+/**
+ * v0.8.0: createSubgoalTask — 原子地将一个新 subgoal 关联到一个新任务。
+ *
+ * 流程（原子语义）：
+ *   1. 读取 goal_status.json（不存在则抛 goal_not_found）
+ *   2. addSubgoal（校验 depends_on 引用已有 subgoal）
+ *   3. createTask 创建关联任务（写入 goal_id / subgoal_id 到 task status.json）
+ *   4. linkTaskToSubgoal（将 task_id 关联到 subgoal）
+ *   5. updateSubgoalStatus(running)（ready → running）
+ *   6. 写回 goal_status.json
+ *
+ * 注意：
+ *   - createSubgoalTask 强制 execution_mode 为 "execute"，因为 assess_only 不产生可关联的 task。
+ *   - createTask 内部使用 getConfig()，因此 workspaceRoot 由全局配置决定。
+ */
+import { mutateGoalStatusAsync } from "../../goal/goalStore.js";
+import { addSubgoal, linkTaskToSubgoal, updateSubgoalStatus } from "../../goal/goalStatus.js";
+import { createTask } from "../tasks/createTask.js";
+import { createWorktree, discardWorktree } from "../../goal/worktreeManager.js";
+import { getConfig } from "../../config.js";
+import { PatchWardenError } from "../../errors.js";
+import { guardWorkspacePath } from "../../security/pathGuard.js";
+import { resolve } from "node:path";
+// ── 函数实现 ──────────────────────────────────────────────────────
+/**
+ * 原子地创建一个 subgoal 并关联到一个新任务。
+ *
+ * @throws PatchWardenError("goal_not_found") 当 goal_id 不存在
+ * @throws PatchWardenError("invalid_dependency") 当 depends_on 引用不存在的 subgoal
+ * @throws PatchWardenError("invalid_execution_mode") 当 execution_mode 为 "assess_only"
+ */
+export async function createSubgoalTask(input) {
+    // assess_only 不产生 task，无法关联到 subgoal
+    if (input.execution_mode === "assess_only") {
+        throw new PatchWardenError("invalid_execution_mode", "createSubgoalTask does not support execution_mode \"assess_only\"", "Use execution_mode \"execute\" (default) so a task is created and linked to the subgoal.", true, { goal_id: input.goal_id, execution_mode: input.execution_mode });
+    }
+    const config = getConfig();
+    return mutateGoalStatusAsync(input.goal_id, async (goalStatus) => {
+        if (goalStatus.status !== "active") {
+            throw new PatchWardenError("goal_not_active", `Goal "${input.goal_id}" is ${goalStatus.status} and cannot accept new subgoals.`, "Create a new Goal Session for additional work.", true, { goal_id: input.goal_id, status: goalStatus.status });
+        }
+        const goalRepoPath = guardWorkspacePath(goalStatus.repo_path, config.workspaceRoot);
+        const requestedRepoPath = guardWorkspacePath(input.repo_path, config.workspaceRoot);
+        const sameRepo = process.platform === "win32"
+            ? resolve(goalRepoPath).toLowerCase() === resolve(requestedRepoPath).toLowerCase()
+            : resolve(goalRepoPath) === resolve(requestedRepoPath);
+        if (!sameRepo) {
+            throw new PatchWardenError("goal_repo_mismatch", `Subgoal repo_path does not match Goal "${input.goal_id}".`, "Use the repo_path recorded on the Goal Session.", true, { goal_id: input.goal_id });
+        }
+        // 2. addSubgoal（校验 depends_on）
+        const { goalStatus: withSubgoal, subgoalId } = addSubgoal(goalStatus, input.subgoal_title, input.depends_on ?? []);
+        // 2.5 Worktree 隔离（默认开启）：为该 subgoal task 创建独立 git worktree，
+        //     用 worktree 路径作为 createTask 的 repo_path，避免并发 task 互相污染。
+        //     isolate_worktree === false 时退化为原行为（使用 input.repo_path）。
+        const isolate = input.isolate_worktree !== false;
+        let repoPathForTask = goalRepoPath;
+        let worktreeId = null;
+        if (isolate) {
+            const wt = createWorktree(input.goal_id, subgoalId, goalRepoPath);
+            repoPathForTask = wt.worktreePath;
+            worktreeId = wt.worktreeId;
+        }
+        // 3. 调用 createTask 创建关联任务（强制 execute 模式，确保返回 CreateTaskOutput）
+        let taskId;
+        try {
+            const taskResult = await createTask({
+                plan_id: input.plan_id,
+                inline_plan: input.inline_plan,
+                plan_title: input.plan_title,
+                template: input.template,
+                goal: input.goal,
+                agent: input.agent,
+                repo_path: repoPathForTask,
+                test_command: input.test_command,
+                verify_commands: input.verify_commands,
+                timeout_seconds: input.timeout_seconds,
+                execution_mode: "execute",
+                assessment_id: input.assessment_id,
+                scope: input.scope,
+                forbidden: input.forbidden,
+                verification: input.verification,
+                done_evidence: input.done_evidence,
+                goal_id: input.goal_id,
+                subgoal_id: subgoalId,
+            });
+            // execution_mode 为 "execute"，createTask 返回 CreateTaskOutput（含 task_id）
+            taskId = taskResult.task_id;
+        }
+        catch (createTaskErr) {
+            // createTask 失败：清理已创建的隔离 worktree，避免遗留半成品（best effort）
+            if (isolate && worktreeId) {
+                try {
+                    discardWorktree(worktreeId, goalRepoPath);
+                }
+                catch { /* ignore cleanup failure，向上抛出原始 createTask 错误 */ }
+            }
+            throw createTaskErr;
+        }
+        // 4. linkTaskToSubgoal + updateSubgoalStatus(running)
+        const withTask = linkTaskToSubgoal(withSubgoal, subgoalId, taskId);
+        let withRunning = updateSubgoalStatus(withTask, subgoalId, "running");
+        // 4.5 隔离模式下，把 worktree_id 记录到 subgoal 对象（写入 goal_status.json）
+        if (isolate && worktreeId) {
+            const newSubgoals = withRunning.subgoals.map((s) => s.id === subgoalId
+                ? { ...s, worktree_id: worktreeId }
+                : s);
+            withRunning = { ...withRunning, subgoals: newSubgoals };
+        }
+        return {
+            next: withRunning,
+            result: {
+                subgoal_id: subgoalId,
+                task_id: taskId,
+                subgoal_status: "running",
+            },
+        };
+    });
+}

package/dist/tools/goals/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./getPlan.js";
+export * from "./goalSubgoalTask.js";
+export * from "./savePlan.js";

package/dist/tools/goals/index.js

@@ -0,0 +1,3 @@
+export * from "./getPlan.js";
+export * from "./goalSubgoalTask.js";
+export * from "./savePlan.js";

package/dist/tools/{savePlan.js → goals/savePlan.js}

@@ -1,9 +1,14 @@
-import { mkdirSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { mkdirSync, existsSync, readFileSync, statSync } from "node:fs";
 import { resolve, join, relative } from "node:path";
-import { getPlansDir, getConfig } from "../config.js";
-import { guardPath } from "../security/pathGuard.js";
-import { guardPlanContent } from "../security/planGuard.js";
-import { PatchWardenError } from "../errors.js";
+import { randomBytes } from "node:crypto";
+import { getPlansDir, getConfig } from "../../config.js";
+import { guardPath } from "../../security/pathGuard.js";
+import { guardPlanContent } from "../../security/planGuard.js";
+import { PatchWardenError } from "../../errors.js";
+import { redactSensitiveContent } from "../../security/contentRedaction.js";
+import { atomicWriteFileSync } from "../../utils/atomicFile.js";
+const MAX_PLAN_BYTES = 1024 * 1024;
+const MAX_PLAN_TITLE_CHARS = 500;
 export function savePlan(input) {
     const config = getConfig();
     const plansDir = getPlansDir(config);
@@ -22,6 +27,10 @@ export function savePlan(input) {
         if (!existsSync(targetPath)) {
             throw new PatchWardenError("plan_ref_not_found", `plan_ref file not found: "${input.plan_ref}".`, "Place the plan file under .patchwarden/plans/ first, then reference it.", true, { plan_ref: input.plan_ref });
         }
+        const planMetadata = statSync(targetPath);
+        if (!planMetadata.isFile() || planMetadata.size > MAX_PLAN_BYTES) {
+            throw new PatchWardenError("plan_content_too_large", `plan_ref must point to a regular file no larger than ${MAX_PLAN_BYTES} bytes.`, "Use a smaller plan file under .patchwarden/plans/.");
+        }
         content = readFileSync(targetPath, "utf-8");
         if (!title || title.trim() === "") {
             title = "Plan from file";
@@ -38,14 +47,25 @@ export function savePlan(input) {
         title = "Inline plan";
     }
     guardPlanContent(title, content);
-    const planId = `plan_${Date.now()}_${sanitizeTitle(title)}`;
+    if (Buffer.byteLength(content, "utf-8") > MAX_PLAN_BYTES) {
+        throw new PatchWardenError("plan_content_too_large", `Plan content exceeds the ${MAX_PLAN_BYTES}-byte limit.`, "Split the work into smaller plans.");
+    }
+    title = redactSensitiveContent(title)
+        .content
+        .replace(/[\r\n\t]+/g, " ")
+        .trim()
+        .slice(0, MAX_PLAN_TITLE_CHARS) || "Inline plan";
+    content = redactSensitiveContent(content).content;
+    const planId = `plan_${Date.now()}_${sanitizeTitle(title)}_${randomBytes(4).toString("hex")}`;
     const planDir = resolve(plansDir, planId);
     // Guards: plan dir & file must stay inside workspace
+    guardPath(plansDir, config.workspaceRoot, config.plansDir);
+    mkdirSync(plansDir, { recursive: true });
     guardPath(planDir, config.workspaceRoot, config.plansDir);
-    mkdirSync(planDir, { recursive: true });
+    mkdirSync(planDir);
     const planFile = join(planDir, "plan.md");
     const header = `# ${title}\n\n> Plan ID: ${planId}\n> Created: ${new Date().toISOString()}\n\n`;
-    writeFileSync(planFile, header + content, "utf-8");
+    atomicWriteFileSync(planFile, header + content);
     return {
         plan_id: planId,
         path: planFile,

package/dist/tools/registry.d.ts

@@ -1,24 +1,20 @@
 /**
  * Shared tool registry for PatchWarden MCP server.
  * Used by both stdio (index.ts) and HTTP (httpServer.ts) transports.
+ *
+ * ToolDef interface and getToolDefs() live in ./definitions/toolDefs.ts.
+ * They are re-exported here so existing callers that import from
+ * "./registry.js" continue to work after the Task 4 split.
  */
 import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { type ToolCatalogSnapshot } from "./toolCatalog.js";
-export interface ToolDef {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: Record<string, unknown>;
-        required?: string[];
-    };
-}
-export declare function getToolDefs(): ToolDef[];
+import { type ToolCatalogSnapshot } from "./catalog/toolCatalog.js";
+import { getToolDefs, type ToolDef } from "./definitions/toolDefs.js";
+export { getToolDefs, type ToolDef };
 export declare function getToolCatalogSnapshot(): ToolCatalogSnapshot;
 export declare function handleToolCall(name: string, args: Record<string, unknown> | undefined): Promise<{
-    content: {
-        type: "text";
+    content: Array<{
+        type: string;
         text: string;
-    }[];
+    }>;
 }>;
 export declare function registerTools(server: Server): void;