patchwarden 0.6.4 → 1.5.0

package/dist/tools/mergeWorktree.js

@@ -0,0 +1,27 @@
+/**
+ * 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";
+/**
+ * 合并指定 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) {
+    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/dist/tools/recommendAgentForTask.d.ts

@@ -0,0 +1,19 @@
+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 declare function recommendAgentForTask(input: RecommendAgentForTaskInput): RecommendAgentForTaskOutput;

package/dist/tools/recommendAgentForTask.js

@@ -0,0 +1,56 @@
+import { getConfig } from "../config.js";
+import { guardWorkspacePath } from "../security/pathGuard.js";
+import { routeAgent } from "../agents/agentRouter.js";
+export function recommendAgentForTask(input) {
+    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) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.map((entry) => String(entry).trim()).filter(Boolean).slice(0, 50);
+}
+function buildRiskNotes(goal, riskHint) {
+    const text = `${goal} ${riskHint || ""}`.toLowerCase();
+    const notes = [];
+    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) {
+    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);
+}

package/dist/tools/reconcileTasks.d.ts

@@ -0,0 +1,41 @@
+import { type PatchWardenConfig } from "../config.js";
+import { type DiagnosisType, type DiagnosisConfidence, type SafeAction } from "./diagnoseTask.js";
+export type ReconcileMode = "report_only" | "safe_fix";
+export interface ReconcileTasksInput {
+    max_age_minutes?: number;
+    mode?: ReconcileMode;
+    include_done_candidates?: boolean;
+}
+export interface ReconcileTaskReport {
+    task_id: string;
+    status: string;
+    phase: string | null;
+    diagnosis: DiagnosisType;
+    confidence: DiagnosisConfidence;
+    reasons: string[];
+    safe_actions: SafeAction[];
+    age_seconds: number | null;
+    action_taken: "left_unchanged" | "marked_failed_stale" | "marked_orphaned" | "marked_done_by_agent";
+    previous_status: string | null;
+    new_status: string | null;
+    applied_at: string | null;
+    applied_by: string | null;
+    evidence_summary: {
+        heartbeat_age_seconds: number | null;
+        stdout_age_seconds: number | null;
+        child_pid: number | null;
+        child_pid_alive: boolean | null;
+        watcher_owns_task: boolean;
+    };
+}
+export interface ReconcileTasksOutput {
+    mode: ReconcileMode;
+    scanned: number;
+    candidates: number;
+    reconciled: number;
+    skipped_low_confidence: number;
+    skipped_active_watcher: number;
+    reports: ReconcileTaskReport[];
+    reconcile_log_path: string | null;
+}
+export declare function reconcileTasks(input?: ReconcileTasksInput, config?: PatchWardenConfig): ReconcileTasksOutput;

package/dist/tools/reconcileTasks.js

@@ -0,0 +1,352 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, mkdirSync, statSync, } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { getTasksDir, getConfig } from "../config.js";
+import { diagnoseTask } from "./diagnoseTask.js";
+import { syncSubgoalOnTaskDone, readTaskGoalMeta } from "../goal/subgoalSync.js";
+// ── Defaults ────────────────────────────────────────────────────────
+const DEFAULT_MAX_AGE_MINUTES = 30;
+const RECONCILE_LOG_NAME = "reconcile.log";
+// ── Main entry point ──────────────────────────────────────────────
+export function reconcileTasks(input = {}, config = getConfig()) {
+    const mode = input.mode === "safe_fix" ? "safe_fix" : "report_only";
+    const maxAgeMinutes = typeof input.max_age_minutes === "number" && input.max_age_minutes > 0
+        ? Math.min(input.max_age_minutes, 24 * 60)
+        : DEFAULT_MAX_AGE_MINUTES;
+    const includeDoneCandidates = input.include_done_candidates !== false; // default true
+    const maxAgeSeconds = maxAgeMinutes * 60;
+    const tasksDir = getTasksDir(config);
+    const reports = [];
+    let scanned = 0;
+    let candidates = 0;
+    let reconciled = 0;
+    let skippedLowConfidence = 0;
+    let skippedActiveWatcher = 0;
+    const nowMs = Date.now();
+    if (!existsSync(tasksDir)) {
+        return {
+            mode,
+            scanned: 0,
+            candidates: 0,
+            reconciled: 0,
+            skipped_low_confidence: 0,
+            skipped_active_watcher: 0,
+            reports: [],
+            reconcile_log_path: null,
+        };
+    }
+    let entries = [];
+    try {
+        entries = readdirSync(tasksDir, { withFileTypes: true });
+    }
+    catch {
+        return {
+            mode,
+            scanned: 0,
+            candidates: 0,
+            reconciled: 0,
+            skipped_low_confidence: 0,
+            skipped_active_watcher: 0,
+            reports: [],
+            reconcile_log_path: null,
+        };
+    }
+    const taskDirs = entries.filter((e) => e.isDirectory());
+    for (const entry of taskDirs) {
+        scanned += 1;
+        const taskId = entry.name;
+        const taskDir = resolve(tasksDir, taskId);
+        const statusFile = join(taskDir, "status.json");
+        if (!existsSync(statusFile))
+            continue;
+        let statusData;
+        try {
+            statusData = JSON.parse(readFileSync(statusFile, "utf-8"));
+        }
+        catch {
+            continue; // corrupted status, skip
+        }
+        const statusStr = typeof statusData.status === "string" ? statusData.status : "unknown";
+        // Filter: only running / collecting_artifacts / (optionally) done_by_agent candidates
+        const isCandidate = statusStr === "running" ||
+            statusStr === "collecting_artifacts" ||
+            (includeDoneCandidates && statusStr === "done_by_agent");
+        if (!isCandidate)
+            continue;
+        // Filter by age — use the oldest reliable timestamp on the task
+        const ageSeconds = taskAgeSeconds(taskDir, statusData, nowMs);
+        if (ageSeconds !== null && ageSeconds < maxAgeSeconds)
+            continue;
+        candidates += 1;
+        // Diagnose the task
+        let diagnosis;
+        try {
+            diagnosis = diagnoseTask({ task_id: taskId }, config);
+        }
+        catch {
+            continue; // diagnosis failed — skip
+        }
+        const report = {
+            task_id: taskId,
+            status: diagnosis.status,
+            phase: diagnosis.phase,
+            diagnosis: diagnosis.diagnosis,
+            confidence: diagnosis.confidence,
+            reasons: diagnosis.reasons,
+            safe_actions: diagnosis.safe_actions,
+            age_seconds: ageSeconds,
+            action_taken: "left_unchanged",
+            previous_status: null,
+            new_status: null,
+            applied_at: null,
+            applied_by: null,
+            evidence_summary: {
+                heartbeat_age_seconds: diagnosis.evidence.heartbeat_age_seconds,
+                stdout_age_seconds: diagnosis.evidence.stdout_age_seconds,
+                child_pid: diagnosis.evidence.child_pid,
+                child_pid_alive: diagnosis.evidence.child_pid_alive,
+                watcher_owns_task: diagnosis.evidence.watcher_owns_task,
+            },
+        };
+        // ── safe_fix rules ──
+        //
+        // safe_fix is ONLY applied when:
+        //   1. mode === "safe_fix"
+        //   2. diagnosis.confidence === "high"
+        //   3. The task is NOT still owned by an active watcher (we must not
+        //      touch tasks the live watcher is executing).
+        //   4. The diagnosis type maps to a reconcilable action.
+        //
+        // Anything else is left_unchanged and recorded for audit.
+        if (mode === "safe_fix" && diagnosis.confidence === "high") {
+            if (diagnosis.evidence.watcher_owns_task) {
+                // Hard rule: do not touch tasks the live watcher still owns.
+                skippedActiveWatcher += 1;
+                report.reasons = [
+                    ...report.reasons,
+                    "safe_fix skipped: task is still owned by an active watcher instance",
+                ];
+            }
+            else {
+                const fixResult = applySafeFix(taskDir, taskId, statusData, diagnosis.diagnosis, diagnosis.reasons, diagnosis.evidence, config);
+                if (fixResult.applied) {
+                    report.action_taken = fixResult.action_taken;
+                    report.previous_status = fixResult.previous_status;
+                    report.new_status = fixResult.new_status;
+                    report.applied_at = fixResult.applied_at;
+                    report.applied_by = "reconcile_tasks";
+                    reconciled += 1;
+                }
+                else {
+                    // Diagnosis type does not map to a safe_fix action — leave unchanged
+                    report.reasons = [
+                        ...report.reasons,
+                        `safe_fix skipped: diagnosis "${diagnosis.diagnosis}" has no automatic safe_fix action`,
+                    ];
+                    skippedLowConfidence += 1;
+                }
+            }
+        }
+        else if (mode === "safe_fix" && diagnosis.confidence !== "high") {
+            skippedLowConfidence += 1;
+            report.reasons = [
+                ...report.reasons,
+                `safe_fix skipped: confidence is "${diagnosis.confidence}", only "high" is eligible`,
+            ];
+        }
+        if (reports.length < 200) {
+            reports.push(report);
+        }
+        if (reports.length >= 200)
+            break;
+    }
+    // ── Write reconcile.log when safe_fix applied any change ──
+    let reconcileLogPath = null;
+    if (mode === "safe_fix" && reconciled > 0) {
+        reconcileLogPath = writeReconcileLog(tasksDir, config, reports.filter((r) => r.action_taken !== "left_unchanged"));
+    }
+    return {
+        mode,
+        scanned,
+        candidates,
+        reconciled,
+        skipped_low_confidence: skippedLowConfidence,
+        skipped_active_watcher: skippedActiveWatcher,
+        reports,
+        reconcile_log_path: reconcileLogPath,
+    };
+}
+function applySafeFix(taskDir, taskId, currentStatus, diagnosis, reasons, evidence, config) {
+    // Map diagnosis type to new status. Only high-confidence, well-understood
+    // diagnoses are eligible. "possibly_stale_running" and "unknown" are NOT
+    // eligible even if confidence were high (which they never are).
+    const previousStatus = typeof currentStatus.status === "string" ? currentStatus.status : "unknown";
+    let newStatus = null;
+    let actionTaken = "left_unchanged";
+    switch (diagnosis) {
+        case "stale_running":
+            newStatus = "failed_stale";
+            actionTaken = "marked_failed_stale";
+            break;
+        case "orphaned_running":
+            newStatus = "orphaned";
+            actionTaken = "marked_orphaned";
+            break;
+        case "done_candidate":
+            newStatus = "done_by_agent";
+            actionTaken = "marked_done_by_agent";
+            break;
+        case "artifact_collection_stuck":
+            // Treat as failed_stale — artifact collection should not hang.
+            newStatus = "failed_stale";
+            actionTaken = "marked_failed_stale";
+            break;
+        default:
+            // active_running, possibly_stale_running, unknown, terminal — not eligible
+            return {
+                applied: false,
+                action_taken: "left_unchanged",
+                previous_status: previousStatus,
+                new_status: previousStatus,
+                applied_at: new Date().toISOString(),
+            };
+    }
+    const appliedAt = new Date().toISOString();
+    const statusFile = join(taskDir, "status.json");
+    const backupFile = join(taskDir, "status.json.bak");
+    // 1. Write status.json.bak with current contents (overwrite any prior backup)
+    try {
+        const currentRaw = readFileSync(statusFile, "utf-8");
+        writeFileSync(backupFile, currentRaw, "utf-8");
+    }
+    catch {
+        // If we cannot back up, refuse to apply the fix.
+        return {
+            applied: false,
+            action_taken: "left_unchanged",
+            previous_status: previousStatus,
+            new_status: previousStatus,
+            applied_at: appliedAt,
+        };
+    }
+    // 2. Build the new status record with full audit trail
+    const next = {
+        ...currentStatus,
+        status: newStatus,
+        phase: newStatus,
+        updated_at: appliedAt,
+        last_heartbeat_at: appliedAt,
+        finished_at: appliedAt,
+        // v0.7.0 audit fields
+        previous_status: previousStatus,
+        diagnosis: {
+            type: diagnosis,
+            confidence: "high",
+            applied_by: "reconcile_tasks",
+            applied_at: appliedAt,
+            reasons,
+            evidence: {
+                heartbeat_age_seconds: evidence.heartbeat_age_seconds,
+                stdout_age_seconds: evidence.stdout_age_seconds,
+                child_pid: evidence.child_pid,
+                child_pid_alive: evidence.child_pid_alive,
+                watcher_instance_id: evidence.watcher_instance_id,
+                current_watcher_instance_id: evidence.current_watcher_instance_id,
+            },
+        },
+    };
+    // For done_by_agent, set acceptance_status=pending (per roadmap 3.6)
+    if (newStatus === "done_by_agent") {
+        next.acceptance_status = "pending";
+        next.legacy_status = "done";
+    }
+    // 3. Atomic write: write to temp file then rename
+    const tmpFile = join(taskDir, "status.json.tmp");
+    try {
+        writeFileSync(tmpFile, JSON.stringify(next, null, 2), "utf-8");
+        renameSync(tmpFile, statusFile);
+    }
+    catch {
+        // Best-effort cleanup of temp file
+        try {
+            if (existsSync(tmpFile)) {
+                unlinkSync(tmpFile);
+            }
+        }
+        catch { /* ignore */ }
+        return {
+            applied: false,
+            action_taken: "left_unchanged",
+            previous_status: previousStatus,
+            new_status: previousStatus,
+            applied_at: appliedAt,
+        };
+    }
+    // v0.8.0: 当状态变为 done_by_agent 时，同步关联 subgoal 状态（running → done_by_agent）
+    if (newStatus === "done_by_agent") {
+        const goalMeta = readTaskGoalMeta(taskDir);
+        if (goalMeta.subgoal_id) {
+            syncSubgoalOnTaskDone(taskId, goalMeta, config.workspaceRoot);
+        }
+    }
+    return {
+        applied: true,
+        action_taken: actionTaken,
+        previous_status: previousStatus,
+        new_status: newStatus,
+        applied_at: appliedAt,
+    };
+}
+// ── reconcile.log writer ───────────────────────────────────────────
+function writeReconcileLog(tasksDir, config, appliedReports) {
+    // The reconcile.log lives at the .patchwarden/ root (parent of tasksDir),
+    // so it captures every reconcile run across all tasks.
+    const logDir = dirname(tasksDir);
+    const logPath = join(logDir, RECONCILE_LOG_NAME);
+    try {
+        mkdirSync(logDir, { recursive: true });
+    }
+    catch { /* ignore */ }
+    const lines = [];
+    for (const report of appliedReports) {
+        lines.push(JSON.stringify({
+            timestamp: report.applied_at,
+            task_id: report.task_id,
+            previous_status: report.previous_status,
+            new_status: report.new_status,
+            diagnosis: report.diagnosis,
+            confidence: report.confidence,
+            applied_by: report.applied_by,
+            reasons: report.reasons,
+            evidence: report.evidence_summary,
+        }));
+    }
+    // Append — do not overwrite history
+    const existing = existsSync(logPath) ? readFileSync(logPath, "utf-8") : "";
+    const nextContent = existing + (existing && !existing.endsWith("\n") ? "\n" : "") + lines.join("\n") + "\n";
+    try {
+        writeFileSync(logPath, nextContent, "utf-8");
+    }
+    catch {
+        // If we cannot write the log, the status change still happened —
+        // the status.json itself contains the diagnosis audit fields.
+    }
+    return logPath;
+}
+// ── Task age helper ────────────────────────────────────────────────
+function taskAgeSeconds(taskDir, status, nowMs) {
+    // Prefer created_at; fall back to status.json mtime.
+    const createdStr = typeof status.created_at === "string" ? status.created_at : null;
+    if (createdStr) {
+        const ms = Date.parse(createdStr);
+        if (Number.isFinite(ms)) {
+            return Math.max(0, Math.round((nowMs - ms) / 1000));
+        }
+    }
+    try {
+        const stat = statSync(join(taskDir, "status.json"));
+        return Math.max(0, Math.round((nowMs - stat.mtimeMs) / 1000));
+    }
+    catch {
+        return null;
+    }
+}