patchwarden 1.5.0 → 1.5.1

package/dist/index.js

@@ -11,14 +11,17 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { loadConfig } from "./config.js";
 import { registerTools } from "./tools/registry.js";
 import { PATCHWARDEN_VERSION } from "./version.js";
+import { logger } from "./logging.js";
 const config = loadConfig();
-console.error(`[patchwarden] Workspace: ${config.workspaceRoot}`);
-console.error(`[patchwarden] Transport: stdio`);
+logger.info(`[patchwarden] Workspace: ${config.workspaceRoot}`);
+logger.info("[patchwarden] Transport: stdio");
 const server = new Server({ name: "patchwarden", version: PATCHWARDEN_VERSION }, { capabilities: { tools: {} } });
 registerTools(server);
 const transport = new StdioServerTransport();
 server.connect(transport).catch((err) => {
-    console.error("[patchwarden] Fatal:", err);
+    logger.fatal("[patchwarden] Fatal", {
+        error: err instanceof Error ? err.message : String(err),
+    });
     process.exit(1);
 });
-console.error("[patchwarden] MCP server ready on stdio");
+logger.info("[patchwarden] MCP server ready on stdio");

package/dist/logging.d.ts

@@ -1,4 +1,4 @@
-export type LogLevel = "info" | "warn" | "error" | "audit";
+export type LogLevel = "info" | "warn" | "error" | "fatal" | "audit";
 export interface LogEntry {
     timestamp: string;
     level: LogLevel;
@@ -39,6 +39,12 @@ export declare class Logger {
     info(message: string, context?: Record<string, unknown>): void;
     warn(message: string, context?: Record<string, unknown>): void;
     error(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Emit a fatal-level log entry. Use this immediately before a process
+     * exits with a non-zero status, to record the unrecoverable condition.
+     * Level is higher than `error`.
+     */
+    fatal(message: string, context?: Record<string, unknown>): void;
     /**
      * Emit a tool-call audit log entry.
      *

package/dist/logging.js

@@ -51,6 +51,14 @@ export class Logger {
     error(message, context) {
         emit({ timestamp: new Date().toISOString(), level: "error", message, ...context });
     }
+    /**
+     * Emit a fatal-level log entry. Use this immediately before a process
+     * exits with a non-zero status, to record the unrecoverable condition.
+     * Level is higher than `error`.
+     */
+    fatal(message, context) {
+        emit({ timestamp: new Date().toISOString(), level: "fatal", message, ...context });
+    }
     /**
      * Emit a tool-call audit log entry.
      *

package/dist/runner/changeCapture.d.ts

@@ -66,9 +66,9 @@ export interface ChangeArtifacts {
     unavailable_reason: string | null;
     artifact_hygiene: ArtifactHygiene;
 }
-export declare function captureRepoSnapshot(repoPath: string): RepoSnapshot;
+export declare function captureRepoSnapshot(repoPath: string): Promise<RepoSnapshot>;
 export declare function writeSnapshot(taskDir: string, filename: string, snapshot: RepoSnapshot): void;
-export declare function buildChangeArtifacts(repoPath: string, before: RepoSnapshot, after: RepoSnapshot): ChangeArtifacts;
+export declare function buildChangeArtifacts(repoPath: string, before: RepoSnapshot, after: RepoSnapshot): Promise<ChangeArtifacts>;
 export declare function compareSnapshots(before: RepoSnapshot, after: RepoSnapshot): ChangedFile[];
 export declare function emptyArtifactHygiene(): ArtifactHygiene;
 export interface ExternalDirtyFile {
@@ -101,7 +101,7 @@ export interface ArtifactManifest {
     generated_at: string;
     artifacts: ArtifactManifestEntry[];
 }
-export declare function buildArtifactManifest(changedFiles: ChangedFile[], repoPath: string, taskId?: string): ArtifactManifest;
+export declare function buildArtifactManifest(changedFiles: ChangedFile[], repoPath: string, taskId?: string): Promise<ArtifactManifest>;
 export interface ChangedFileGroups {
     source_changes: ChangedFile[];
     docs_changes: ChangedFile[];

package/dist/runner/changeCapture.js

@@ -1,15 +1,16 @@
 import { createHash } from "node:crypto";
-import { lstatSync, readFileSync, readdirSync, writeFileSync, } from "node:fs";
+import { createReadStream, lstatSync, readFileSync, readdirSync, writeFileSync, } from "node:fs";
 import { join, relative, resolve, isAbsolute } from "node:path";
-import { spawnSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import { isSensitivePath } from "../security/sensitiveGuard.js";
 const MAX_HASH_BYTES = 5 * 1024 * 1024;
 const MAX_SNAPSHOT_FILES = 5000;
 const MAX_DIFF_BYTES = 20 * 1024 * 1024;
 const SKIP_DIRECTORIES = new Set([".git", ".patchwarden", "node_modules"]);
-export function captureRepoSnapshot(repoPath) {
+export async function captureRepoSnapshot(repoPath) {
     const warnings = [];
-    const isGit = runGit(repoPath, ["rev-parse", "--is-inside-work-tree"]).stdout.trim() === "true";
+    const isGitResult = await runGit(repoPath, ["rev-parse", "--is-inside-work-tree"]);
+    const isGit = isGitResult.stdout.trim() === "true";
     let head = null;
     let status = "";
     let paths = [];
@@ -17,10 +18,17 @@ export function captureRepoSnapshot(repoPath) {
     const ignoredPaths = new Set();
     const dirtyPaths = new Set();
     if (isGit) {
-        const headResult = runGit(repoPath, ["rev-parse", "HEAD"]);
+        // The following five git calls are independent of each other and can run in parallel.
+        const [headResult, statusResult, trackedResult, ignoredResult, listedResult] = await Promise.all([
+            runGit(repoPath, ["rev-parse", "HEAD"]),
+            runGit(repoPath, ["status", "--porcelain=v1", "-uall"]),
+            runGit(repoPath, ["ls-files", "-z"]),
+            runGit(repoPath, ["ls-files", "-o", "-i", "--exclude-standard", "-z"]),
+            runGit(repoPath, ["ls-files", "-co", "--exclude-standard", "-z"]),
+        ]);
         if (headResult.status === 0)
             head = headResult.stdout.trim() || null;
-        status = runGit(repoPath, ["status", "--porcelain=v1", "-uall"]).stdout.trimEnd();
+        status = statusResult.stdout.trimEnd();
         // Parse git status --porcelain to collect all dirty paths
         for (const line of status.split("\n")) {
             if (line.length < 4)
@@ -45,23 +53,20 @@ export function captureRepoSnapshot(repoPath) {
                 }
             }
         }
-        const tracked = runGit(repoPath, ["ls-files", "-z"]);
-        if (tracked.status === 0) {
-            for (const path of tracked.stdout.split("\0").filter(Boolean))
+        if (trackedResult.status === 0) {
+            for (const path of trackedResult.stdout.split("\0").filter(Boolean))
                 trackedPaths.add(normalizePath(path));
         }
-        const ignored = runGit(repoPath, ["ls-files", "-o", "-i", "--exclude-standard", "-z"]);
-        if (ignored.status === 0) {
-            for (const path of ignored.stdout.split("\0").filter(Boolean))
+        if (ignoredResult.status === 0) {
+            for (const path of ignoredResult.stdout.split("\0").filter(Boolean))
                 ignoredPaths.add(normalizePath(path));
         }
         else {
             warnings.push("git ignored-file discovery failed; ignored classification may be incomplete");
         }
-        const listed = runGit(repoPath, ["ls-files", "-co", "--exclude-standard", "-z"]);
-        if (listed.status === 0) {
+        if (listedResult.status === 0) {
             paths = [...new Set([
-                    ...listed.stdout.split("\0").filter(Boolean),
+                    ...listedResult.stdout.split("\0").filter(Boolean),
                     ...walkWorkspace(repoPath),
                 ])];
         }
@@ -116,26 +121,26 @@ export function captureRepoSnapshot(repoPath) {
 export function writeSnapshot(taskDir, filename, snapshot) {
     writeFileSync(join(taskDir, filename), JSON.stringify(snapshot, null, 2), "utf-8");
 }
-export function buildChangeArtifacts(repoPath, before, after) {
+export async function buildChangeArtifacts(repoPath, before, after) {
     const changedFiles = compareSnapshots(before, after);
     const artifactHygiene = classifyArtifactHygiene(changedFiles);
     const sections = [];
     const scopedPaths = [...new Set(changedFiles.flatMap((file) => file.old_path ? [file.old_path, file.path] : [file.path]))];
     if (before.is_git && after.is_git && scopedPaths.length > 0) {
         if (before.head && after.head && before.head !== after.head) {
-            const committed = runGit(repoPath, ["diff", "--no-color", "--binary", before.head, after.head, "--", ...scopedPaths]);
+            const committed = await runGit(repoPath, ["diff", "--no-color", "--binary", before.head, after.head, "--", ...scopedPaths]);
             if (committed.stdout.trim())
                 sections.push("# Changes committed during task\n", committed.stdout.trimEnd());
         }
         const base = after.head || "HEAD";
-        const working = runGit(repoPath, ["diff", "--no-color", "--binary", base, "--", ...scopedPaths]);
+        const working = await runGit(repoPath, ["diff", "--no-color", "--binary", base, "--", ...scopedPaths]);
         if (working.stdout.trim())
             sections.push("# Staged and unstaged changes\n", working.stdout.trimEnd());
         for (const file of changedFiles.filter((item) => item.change === "added").slice(0, 100)) {
-            const tracked = runGit(repoPath, ["ls-files", "--error-unmatch", "--", file.path]);
+            const tracked = await runGit(repoPath, ["ls-files", "--error-unmatch", "--", file.path]);
             if (tracked.status === 0)
                 continue;
-            const untracked = runGit(repoPath, ["diff", "--no-index", "--no-color", "--binary", "--", "/dev/null", file.path]);
+            const untracked = await runGit(repoPath, ["diff", "--no-index", "--no-color", "--binary", "--", "/dev/null", file.path]);
             if (untracked.stdout.trim())
                 sections.push("# Untracked file\n", untracked.stdout.trimEnd());
         }
@@ -151,7 +156,7 @@ export function buildChangeArtifacts(repoPath, before, after) {
     const fullDiff = `${evidence}\n\n${body || (changedFiles.length ? "(textual patch unavailable; see changed-files.json for hash evidence)" : "(no task file changes detected)")}\n`;
     const additions = fullDiff.split(/\r?\n/).filter((line) => line.startsWith("+") && !line.startsWith("+++")).length;
     const deletions = fullDiff.split(/\r?\n/).filter((line) => line.startsWith("-") && !line.startsWith("---")).length;
-    const fileStats = buildFileStats(repoPath, before, after, changedFiles);
+    const fileStats = await buildFileStats(repoPath, before, after, changedFiles);
     return {
         changed_files: changedFiles,
         diff: fullDiff,
@@ -172,8 +177,8 @@ export function buildChangeArtifacts(repoPath, before, after) {
         artifact_hygiene: artifactHygiene,
     };
 }
-function buildFileStats(repoPath, before, after, changedFiles) {
-    return changedFiles.map((file) => {
+async function buildFileStats(repoPath, before, after, changedFiles) {
+    const results = await Promise.all(changedFiles.map(async (file) => {
         let additions = 0;
         let deletions = 0;
         const paths = file.old_path ? [file.old_path, file.path] : [file.path];
@@ -183,8 +188,8 @@ function buildFileStats(repoPath, before, after, changedFiles) {
                 ranges.push([before.head, after.head]);
             }
             ranges.push([after.head || "HEAD"]);
-            for (const range of ranges) {
-                const result = runGit(repoPath, ["diff", "--numstat", ...range, "--", ...paths]);
+            const rangeResults = await Promise.all(ranges.map((range) => runGit(repoPath, ["diff", "--numstat", ...range, "--", ...paths])));
+            for (const result of rangeResults) {
                 for (const line of result.stdout.split(/\r?\n/).filter(Boolean)) {
                     const [added, removed] = line.split(/\s+/);
                     if (/^\d+$/.test(added))
@@ -199,10 +204,11 @@ function buildFileStats(repoPath, before, after, changedFiles) {
                 const content = readFileSync(resolve(repoPath, file.path), "utf-8");
                 additions = countLines(content);
             }
-            catch { }
+            catch { } // probe failure handled by return value (additions stays 0)
         }
         return { path: file.path, status: file.change, additions, deletions };
-    });
+    }));
+    return results;
 }
 function countLines(content) {
     if (content.length === 0)
@@ -318,7 +324,7 @@ export function findNewExternalDirtyFiles(baseline, current) {
         return false;
     });
 }
-export function buildArtifactManifest(changedFiles, repoPath, taskId) {
+export async function buildArtifactManifest(changedFiles, repoPath, taskId) {
     const entries = [];
     for (const file of changedFiles) {
         if (file.kind !== "build_artifact")
@@ -331,7 +337,7 @@ export function buildArtifactManifest(changedFiles, repoPath, taskId) {
             if (stat.isFile()) {
                 size = stat.size;
                 if (size <= MAX_HASH_BYTES) {
-                    sha256 = createHash("sha256").update(readFileSync(absolutePath)).digest("hex");
+                    sha256 = await hashFileAsync(absolutePath);
                 }
             }
         }
@@ -503,15 +509,33 @@ function walkWorkspace(root) {
     return result;
 }
 function runGit(repoPath, args) {
-    const result = spawnSync("git", args, {
-        cwd: repoPath,
-        encoding: "utf-8",
-        timeout: 30_000,
-        maxBuffer: MAX_DIFF_BYTES,
+    return new Promise((resolve) => {
+        execFile("git", args, {
+            cwd: repoPath,
+            encoding: "utf-8",
+            timeout: 30_000,
+            maxBuffer: MAX_DIFF_BYTES,
+        }, (err, stdout, stderr) => {
+            let status;
+            if (err) {
+                // err.code is the exit code (number) when the process exited with a non-zero status;
+                // it is a string (e.g. "ENOENT") when spawning failed or the buffer limit was hit.
+                status = typeof err.code === "number" ? err.code : null;
+            }
+            else {
+                status = 0;
+            }
+            resolve({ status, stdout: stdout || "", stderr: stderr || "" });
+        });
+    });
+}
+function hashFileAsync(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = createHash("sha256");
+        const stream = createReadStream(filePath);
+        stream.on("error", reject);
+        hash.on("error", reject);
+        hash.on("finish", () => resolve(hash.digest("hex")));
+        stream.pipe(hash);
     });
-    return {
-        status: result.status,
-        stdout: result.stdout || "",
-        stderr: result.stderr || "",
-    };
 }

package/dist/runner/cli.js

@@ -8,19 +8,20 @@
  */
 import { runTask } from "./runTask.js";
 import { loadConfig } from "../config.js";
+import { logger } from "../logging.js";
 // Load config early
 loadConfig();
 const taskId = process.argv[2] || process.env.PATCHWARDEN_TASK_ID;
 if (!taskId) {
-    console.error("Usage: node dist/runner/cli.js <task_id>");
-    console.error("   or: npm run runner -- <task_id>");
+    logger.info("Usage: node dist/runner/cli.js <task_id>");
+    logger.info("   or: npm run runner -- <task_id>");
     process.exit(1);
 }
-console.error(`[runner] Starting task: ${taskId}`);
+logger.info(`[runner] Starting task: ${taskId}`);
 const result = await runTask(taskId);
-console.error(`[runner] Task ${result.task_id}: ${result.status}`);
+logger.info(`[runner] Task ${result.task_id}: ${result.status}`);
 if (result.error) {
-    console.error(`[runner] Error: ${result.error}`);
+    logger.fatal(`[runner] Error: ${result.error}`);
     process.exit(1);
 }
-console.error("[runner] Done.");
+logger.info("[runner] Done.");

package/dist/runner/postTaskCleanup.js

@@ -1,6 +1,30 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { platform } from "node:os";
+const isWindows = platform() === "win32";
+/**
+ * Remove a file or directory, working around Node.js fs.rmSync issues on Windows
+ * where recursive directory deletion silently fails (Node v22+).
+ * Falls back to `rmdir /s /q` on Windows if rmSync doesn't remove the path.
+ */
+function safeRemoveSync(targetPath) {
+    rmSync(targetPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    if (isWindows && existsSync(targetPath)) {
+        try {
+            const stat = statSync(targetPath);
+            if (stat.isDirectory()) {
+                execFileSync("cmd", ["/c", "rmdir", "/s", "/q", targetPath], { windowsHide: true });
+            }
+            else {
+                execFileSync("cmd", ["/c", "del", "/f", "/q", targetPath], { windowsHide: true });
+            }
+        }
+        catch {
+            // Best effort — caller will verify via existsSync if needed
+        }
+    }
+}
 const EXCLUDED_DIRS = new Set([".git", ".patchwarden", ".venv", "node_modules", "samples", "docs"]);
 const CLEANUP_DIRS = new Set(["__pycache__", "dist", "release_packages", "temp_files"]);
 const CLEANUP_FILES = [/\.pyc$/i];
@@ -28,7 +52,7 @@ export function runPostTaskCleanup(repoPath, taskDir) {
             continue;
         }
         try {
-            rmSync(candidate.path, { recursive: true, force: true });
+            safeRemoveSync(candidate.path);
             report.removed.push({ path: rel, reason: candidate.reason });
         }
         catch (error) {