patchwarden 0.6.4 → 1.5.0

package/src/tools/listTasks.ts

@@ -3,7 +3,7 @@ import { resolve, join } from "node:path";
 import { getTasksDir, getPlansDir, getConfig } from "../config.js";
 import { guardPath } from "../security/pathGuard.js";
 import { readTaskRuntime } from "../taskRuntime.js";
-import type { TaskPhase, TaskStatus } from "./createTask.js";
+import type { TaskPhase, TaskStatus, AcceptanceStatus } from "./createTask.js";
 import {
   derivePendingReason,
   readWatcherStatus,
@@ -19,6 +19,7 @@ export interface TaskEntry {
   agent: string;
   status: TaskStatus;
   phase: TaskPhase;
+  acceptance_status: AcceptanceStatus;
   created_at: string;
   updated_at: string;
   workspace_root: string;
@@ -38,6 +39,7 @@ export interface ListTasksInput {
   status?: string;
   repo_path?: string;
   active_only?: boolean;
+  acceptance_status?: string;
   limit?: number;
 }
 
@@ -54,6 +56,7 @@ export function listTasks(input?: ListTasksInput): ListTasksOutput {
   const plansDir = getPlansDir(config);
   const limit = input?.limit && input.limit > 0 ? Math.min(input.limit, 100) : 20;
   const filterStatus = input?.status || null;
+  const filterAcceptance = input?.acceptance_status || null;
   const filterRepo = input?.repo_path?.trim().replace(/\\/g, "/") || null;
   const watcher = readWatcherStatus(config);
 
@@ -88,7 +91,13 @@ export function listTasks(input?: ListTasksInput): ListTasksOutput {
       const data = JSON.parse(readFileSync(statusFile, "utf-8"));
       const runtime = readTaskRuntime(taskDir);
       if (filterStatus && data.status !== filterStatus) continue;
-      if (input?.active_only && data.status !== "pending" && data.status !== "running") continue;
+      if (filterAcceptance) {
+        const taskAcceptance = data.status === "done_by_agent"
+          ? (typeof data.acceptance_status === "string" ? data.acceptance_status : "pending")
+          : null;
+        if (taskAcceptance !== filterAcceptance) continue;
+      }
+      if (input?.active_only && !["pending", "running", "collecting_artifacts"].includes(String(data.status))) continue;
       const normalizedRepo = String(data.repo_path || ".").replace(/\\/g, "/");
       const normalizedResolvedRepo = String(data.resolved_repo_path || "").replace(/\\/g, "/");
       if (filterRepo && normalizedRepo !== filterRepo && normalizedResolvedRepo !== filterRepo) continue;
@@ -109,6 +118,10 @@ export function listTasks(input?: ListTasksInput): ListTasksOutput {
       }
 
       const phase = runtime.phase || data.phase || "queued";
+      const VALID_ACCEPTANCE = ["pending", "accepted", "rejected", "needs_fix", "blocked"];
+      const acceptanceStatus: AcceptanceStatus = data.status === "done_by_agent"
+        ? (typeof data.acceptance_status === "string" && VALID_ACCEPTANCE.includes(data.acceptance_status) ? data.acceptance_status : "pending")
+        : null;
       tasks.push({
         task_id: taskId,
         plan_id: data.plan_id || "",
@@ -116,6 +129,7 @@ export function listTasks(input?: ListTasksInput): ListTasksOutput {
         agent: data.agent || "",
         status: data.status || "pending",
         phase,
+        acceptance_status: acceptanceStatus,
         created_at: data.created_at || "",
         updated_at: data.updated_at || "",
         workspace_root: data.workspace_root || config.workspaceRoot,

package/src/tools/listWorkspace.ts

@@ -1,71 +1,71 @@
-import { readdirSync, statSync, existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { getConfig } from "../config.js";
-import { guardPath } from "../security/pathGuard.js";
-import { guardSensitivePath } from "../security/sensitiveGuard.js";
-
-export interface ListEntry {
-  name: string;
-  type: "file" | "directory";
-  size?: number;
-}
-
-export interface ListWorkspaceOutput {
-  path: string;
-  entries: ListEntry[];
-}
-
-const MAX_LIST_FILES = 200;
-
-export function listWorkspace(relativePath?: string): ListWorkspaceOutput {
-  const config = getConfig();
-  const targetPath = relativePath
-    ? resolve(config.workspaceRoot, relativePath)
-    : config.workspaceRoot;
-
-  const guarded = guardPath(targetPath, config.workspaceRoot);
-
-  if (!existsSync(guarded)) {
-    throw new Error(`Path not found: "${relativePath || "."}"`);
-  }
-
-  const stat = statSync(guarded);
-  if (!stat.isDirectory()) {
-    throw new Error(`Not a directory: "${relativePath || "."}"`);
-  }
-
-  const entries: ListEntry[] = [];
-  const raw = readdirSync(guarded);
-
-  for (const name of raw) {
-    // Skip hidden files and sensitive paths
-    const fullPath = resolve(guarded, name);
-    try {
-      guardSensitivePath(fullPath);
-    } catch {
-      continue; // skip sensitive files silently
-    }
-
-    try {
-      const s = statSync(fullPath);
-      entries.push({
-        name,
-        type: s.isDirectory() ? "directory" : "file",
-        size: s.isFile() ? s.size : undefined,
-      });
-    } catch {
-      // can't stat, skip
-    }
-
-    if (entries.length >= MAX_LIST_FILES) break;
-  }
-
-  return {
-    path: relativePath || ".",
-    entries: entries.sort((a, b) => {
-      // directories first, then alphabetically
-      if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
-      return a.name.localeCompare(b.name);
-    }),
-  };
-}
+import { readdirSync, statSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { getConfig } from "../config.js";
+import { guardPath } from "../security/pathGuard.js";
+import { guardSensitivePath } from "../security/sensitiveGuard.js";
+
+export interface ListEntry {
+  name: string;
+  type: "file" | "directory";
+  size?: number;
+}
+
+export interface ListWorkspaceOutput {
+  path: string;
+  entries: ListEntry[];
+}
+
+const MAX_LIST_FILES = 200;
+
+export function listWorkspace(relativePath?: string): ListWorkspaceOutput {
+  const config = getConfig();
+  const targetPath = relativePath
+    ? resolve(config.workspaceRoot, relativePath)
+    : config.workspaceRoot;
+
+  const guarded = guardPath(targetPath, config.workspaceRoot);
+
+  if (!existsSync(guarded)) {
+    throw new Error(`Path not found: "${relativePath || "."}"`);
+  }
+
+  const stat = statSync(guarded);
+  if (!stat.isDirectory()) {
+    throw new Error(`Not a directory: "${relativePath || "."}"`);
+  }
+
+  const entries: ListEntry[] = [];
+  const raw = readdirSync(guarded);
+
+  for (const name of raw) {
+    // Skip hidden files and sensitive paths
+    const fullPath = resolve(guarded, name);
+    try {
+      guardSensitivePath(fullPath);
+    } catch {
+      continue; // skip sensitive files silently
+    }
+
+    try {
+      const s = statSync(fullPath);
+      entries.push({
+        name,
+        type: s.isDirectory() ? "directory" : "file",
+        size: s.isFile() ? s.size : undefined,
+      });
+    } catch {
+      // can't stat, skip
+    }
+
+    if (entries.length >= MAX_LIST_FILES) break;
+  }
+
+  return {
+    path: relativePath || ".",
+    entries: entries.sort((a, b) => {
+      // directories first, then alphabetically
+      if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    }),
+  };
+}

package/src/tools/mergeWorktree.ts

@@ -0,0 +1,42 @@
+/**
+ * v1.0.0 Part B: merge_worktree MCP 工具 handler — 把隔离 worktree 的 branch
+ * 合并回主工作区，并将 worktree 状态置为 "merged"。
+ *
+ * 参考 src/tools/auditTask.ts 的导出/返回风格。
+ */
+
+import { getConfig } from "../config.js";
+import { guardWorkspacePath } from "../security/pathGuard.js";
+import { mergeWorktree } from "../goal/worktreeManager.js";
+
+export interface MergeWorktreeInput {
+  worktree_id: string;
+  repo_path: string;
+}
+
+export interface MergeWorktreeOutput {
+  worktree_id: string;
+  status: "merged";
+  merged_at: string;
+}
+
+/**
+ * 合并指定 worktree 的 branch 回 repo_path（主工作区）。
+ *
+ * @throws PatchWardenError("workspace_path_escape") 当 repo_path 逃逸出 workspaceRoot
+ * @throws PatchWardenError("worktree_not_found") 当 worktree 不存在
+ * @throws PatchWardenError("invalid_worktree_state") 当 worktree 非 active
+ * @throws PatchWardenError("worktree_merge_failed") 当 git merge 失败
+ */
+export function mergeWorktreeTool(input: MergeWorktreeInput): MergeWorktreeOutput {
+  const config = getConfig();
+  const repoPathSafe = guardWorkspacePath(input.repo_path, config.workspaceRoot);
+
+  mergeWorktree(input.worktree_id, repoPathSafe);
+
+  return {
+    worktree_id: input.worktree_id,
+    status: "merged",
+    merged_at: new Date().toISOString(),
+  };
+}

package/src/tools/recommendAgentForTask.ts

@@ -0,0 +1,79 @@
+import { getConfig } from "../config.js";
+import { guardWorkspacePath } from "../security/pathGuard.js";
+import { routeAgent } from "../agents/agentRouter.js";
+
+export interface RecommendAgentForTaskInput {
+  repo_path: string;
+  goal: string;
+  scope_files?: string[];
+  template?: string;
+  risk_hint?: string;
+}
+
+export interface RecommendAgentForTaskOutput {
+  repo_path: string;
+  resolved_repo_path: string;
+  recommended_agent: string;
+  fallback_agent: string | null;
+  fallback: boolean;
+  reason: string;
+  risk_notes: string[];
+  suggested_verify_commands: string[];
+  bounded: true;
+}
+
+export function recommendAgentForTask(input: RecommendAgentForTaskInput): RecommendAgentForTaskOutput {
+  const config = getConfig();
+  const repoPath = String(input.repo_path || "").trim();
+  const goal = String(input.goal || "").trim();
+  if (!repoPath) throw new Error("repo_path is required.");
+  if (!goal) throw new Error("goal is required.");
+
+  const resolvedRepoPath = guardWorkspacePath(repoPath, config.workspaceRoot);
+  const configuredAgents = Object.keys(config.agents);
+  const route = routeAgent({
+    goal,
+    scope: normalizeScope(input.scope_files),
+    inline_plan: input.risk_hint,
+    template: input.template,
+    configuredAgents,
+  });
+
+  return {
+    repo_path: repoPath,
+    resolved_repo_path: resolvedRepoPath,
+    recommended_agent: route.recommended_agent,
+    fallback_agent: route.fallback ? route.recommended_agent : configuredAgents.find((name) => name !== route.recommended_agent) || null,
+    fallback: route.fallback,
+    reason: route.reason,
+    risk_notes: buildRiskNotes(goal, input.risk_hint),
+    suggested_verify_commands: suggestVerifyCommands(config.allowedTestCommands),
+    bounded: true,
+  };
+}
+
+function normalizeScope(value: string[] | undefined): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  return value.map((entry) => String(entry).trim()).filter(Boolean).slice(0, 50);
+}
+
+function buildRiskNotes(goal: string, riskHint: string | undefined): string[] {
+  const text = `${goal} ${riskHint || ""}`.toLowerCase();
+  const notes: string[] = [];
+  if (/release|publish|push|tag|npm/.test(text)) {
+    notes.push("release_or_remote_write_language_detected");
+  }
+  if (/secret|token|cookie|\.env|ssh/.test(text)) {
+    notes.push("sensitive_file_language_detected");
+  }
+  if (/refactor|rewrite|redesign|migration/.test(text)) {
+    notes.push("broad_change_language_detected");
+  }
+  return notes.slice(0, 8);
+}
+
+function suggestVerifyCommands(commands: string[]): string[] {
+  const preferred = ["npm test", "npm run test", "npm run build", "npm run lint"];
+  const configured = new Set(commands);
+  return preferred.filter((command) => configured.has(command)).slice(0, 4);
+}