patchwarden 0.4.0 → 0.6.1

package/dist/runner/changeCapture.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { lstatSync, readFileSync, readdirSync, writeFileSync, } from "node:fs";
-import { join, relative, resolve } from "node:path";
+import { join, relative, resolve, isAbsolute } from "node:path";
 import { spawnSync } from "node:child_process";
 import { isSensitivePath } from "../security/sensitiveGuard.js";
 const MAX_HASH_BYTES = 5 * 1024 * 1024;
@@ -13,11 +13,51 @@ export function captureRepoSnapshot(repoPath) {
     let head = null;
     let status = "";
     let paths = [];
+    const trackedPaths = new Set();
+    const ignoredPaths = new Set();
+    const dirtyPaths = new Set();
     if (isGit) {
         const headResult = runGit(repoPath, ["rev-parse", "HEAD"]);
         if (headResult.status === 0)
             head = headResult.stdout.trim() || null;
         status = runGit(repoPath, ["status", "--porcelain=v1", "-uall"]).stdout.trimEnd();
+        // Parse git status --porcelain to collect all dirty paths
+        for (const line of status.split("\n")) {
+            if (line.length < 4)
+                continue;
+            const st = line.slice(0, 2); // XY status codes
+            const rawPath = line.slice(3);
+            // M=modified, A=added, D=deleted, ?=untracked, R=renamed, !=ignored
+            if (/[MAD\?R]/.test(st)) {
+                if (st.includes("R")) {
+                    // Rename: rawPath is "oldname -> newname"
+                    const parts = rawPath.split(" -> ");
+                    if (parts.length === 2) {
+                        dirtyPaths.add(normalizePath(parts[0]));
+                        dirtyPaths.add(normalizePath(parts[1]));
+                    }
+                    else {
+                        dirtyPaths.add(normalizePath(rawPath));
+                    }
+                }
+                else {
+                    dirtyPaths.add(normalizePath(rawPath));
+                }
+            }
+        }
+        const tracked = runGit(repoPath, ["ls-files", "-z"]);
+        if (tracked.status === 0) {
+            for (const path of tracked.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))
+                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) {
             paths = [...new Set([
@@ -40,7 +80,7 @@ export function captureRepoSnapshot(repoPath) {
     }
     const files = {};
     for (const inputPath of paths.sort()) {
-        const normalized = inputPath.replace(/\\/g, "/");
+        const normalized = normalizePath(inputPath);
         if (!normalized || normalized.startsWith(".patchwarden/") || isSensitivePath(normalized))
             continue;
         const absolutePath = resolve(repoPath, inputPath);
@@ -51,7 +91,12 @@ export function captureRepoSnapshot(repoPath) {
             const sha256 = stat.size <= MAX_HASH_BYTES
                 ? createHash("sha256").update(readFileSync(absolutePath)).digest("hex")
                 : `large-file:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
-            files[normalized] = { size: stat.size, sha256 };
+            files[normalized] = {
+                size: stat.size,
+                sha256,
+                tracked: trackedPaths.has(normalized),
+                ignored: !trackedPaths.has(normalized) && ignoredPaths.has(normalized),
+            };
         }
         catch {
             warnings.push(`could not fingerprint: ${normalized}`);
@@ -64,6 +109,7 @@ export function captureRepoSnapshot(repoPath) {
         status,
         workspace_dirty: status.trim().length > 0,
         files,
+        dirty_paths: [...dirtyPaths],
         warnings,
     };
 }
@@ -72,6 +118,7 @@ export function writeSnapshot(taskDir, filename, snapshot) {
 }
 export 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) {
@@ -122,6 +169,7 @@ export function buildChangeArtifacts(repoPath, before, after) {
                 ? "Git could not produce a textual patch for the changed files; hash evidence remains available."
                 : "Repository is not a Git worktree; only bounded hash evidence is available.")
             : null,
+        artifact_hygiene: artifactHygiene,
     };
 }
 function buildFileStats(repoPath, before, after, changedFiles) {
@@ -168,13 +216,13 @@ export function compareSnapshots(before, after) {
         const left = before.files[path];
         const right = after.files[path];
         if (!left && right) {
-            changed.push({ path, change: "added", before_sha256: null, after_sha256: right.sha256 });
+            changed.push(classifyChangedFile(path, "added", null, right));
         }
         else if (left && !right) {
-            changed.push({ path, change: "deleted", before_sha256: left.sha256, after_sha256: null });
+            changed.push(classifyChangedFile(path, "deleted", left, null));
         }
         else if (left.sha256 !== right.sha256) {
-            changed.push({ path, change: "modified", before_sha256: left.sha256, after_sha256: right.sha256 });
+            changed.push(classifyChangedFile(path, "modified", left, right));
         }
     }
     const deletedByHash = new Map();
@@ -198,11 +246,235 @@ export function compareSnapshots(before, after) {
             change: "renamed",
             before_sha256: source.before_sha256,
             after_sha256: file.after_sha256,
+            tracked: file.tracked || source.tracked,
+            ignored: file.ignored,
+            kind: classifyPathKind(file.path),
         });
     }
     return [...changed.filter((item) => !consumed.has(item)), ...renamed]
         .sort((left, right) => left.path.localeCompare(right.path));
 }
+export function emptyArtifactHygiene() {
+    return {
+        counts: {
+            source_changes: 0,
+            tracked_build_artifacts: 0,
+            ignored_untracked_artifacts: 0,
+            runtime_generated_files: 0,
+            suspicious_changes: 0,
+        },
+        source_changes: [],
+        tracked_build_artifacts: [],
+        ignored_untracked_artifacts: [],
+        runtime_generated_files: [],
+        suspicious_changes: [],
+    };
+}
+/**
+ * Extract files that are dirty in the workspace but outside the target repo.
+ * Used to establish a baseline before task execution.
+ */
+export function extractExternalDirtyFiles(workspaceSnapshot, repoPath, workspaceRoot) {
+    const dirtyFiles = [];
+    const dirtyPathSet = new Set(workspaceSnapshot.dirty_paths);
+    for (const [path, fingerprint] of Object.entries(workspaceSnapshot.files)) {
+        const absolutePath = resolve(workspaceRoot, path);
+        const rel = relative(repoPath, absolutePath);
+        // If the path is outside repoPath (starts with .. or is absolute)
+        if (rel.startsWith("..") || isAbsolute(rel)) {
+            // A file is "external dirty" if:
+            // 1. Git reports it as dirty (modified/added/deleted/untracked) via dirty_paths, OR
+            // 2. It's not tracked by git (untracked file), OR
+            // 3. It's explicitly ignored
+            const isDirty = dirtyPathSet.has(path);
+            const isUntracked = !fingerprint.tracked;
+            const isIgnored = fingerprint.ignored;
+            if (isDirty || isUntracked || isIgnored) {
+                dirtyFiles.push({
+                    path,
+                    change: isDirty ? "modified" : "added",
+                    before_sha256: fingerprint.sha256,
+                    after_sha256: null,
+                });
+            }
+        }
+    }
+    return dirtyFiles;
+}
+/**
+ * Compare external dirty files between baseline and post-task snapshots.
+ * Returns files that are NEW (not present in baseline) or CHANGED
+ * (same path but different sha256, meaning the task modified them).
+ */
+export function findNewExternalDirtyFiles(baseline, current) {
+    const baselineMap = new Map(baseline.map((f) => [f.path, f]));
+    return current.filter((f) => {
+        const baselineFile = baselineMap.get(f.path);
+        if (!baselineFile)
+            return true; // New path — definitely new
+        // Same path but content changed during task execution
+        if (baselineFile.before_sha256 !== f.before_sha256)
+            return true;
+        return false;
+    });
+}
+export function buildArtifactManifest(changedFiles, repoPath, taskId) {
+    const entries = [];
+    for (const file of changedFiles) {
+        if (file.kind !== "build_artifact")
+            continue;
+        const absolutePath = resolve(repoPath, file.path);
+        let size = 0;
+        let sha256 = file.after_sha256 || "unknown";
+        try {
+            const stat = lstatSync(absolutePath);
+            if (stat.isFile()) {
+                size = stat.size;
+                if (size <= MAX_HASH_BYTES) {
+                    sha256 = createHash("sha256").update(readFileSync(absolutePath)).digest("hex");
+                }
+            }
+        }
+        catch {
+            // File may have been deleted
+        }
+        entries.push({
+            path: file.path,
+            type: classifyArtifactType(file.path),
+            size,
+            sha256,
+            generated_by: "task_execution",
+            created_at: new Date().toISOString(),
+        });
+    }
+    return {
+        task_id: taskId || null,
+        generated_at: new Date().toISOString(),
+        artifacts: entries,
+    };
+}
+function classifyArtifactType(path) {
+    const normalized = normalizePath(path).toLowerCase();
+    const basename = normalized.split("/").pop() || "";
+    if (basename.endsWith(".exe"))
+        return "windows_exe";
+    if (basename.endsWith(".apk"))
+        return "android_apk";
+    if (basename.endsWith(".zip"))
+        return "zip";
+    if (basename.endsWith(".asar"))
+        return "asar";
+    if (basename.endsWith(".dll"))
+        return "dll";
+    if (basename.endsWith(".pak"))
+        return "pak";
+    return "release_directory_file";
+}
+export function groupChangedFiles(changedFiles) {
+    const groups = {
+        source_changes: [],
+        docs_changes: [],
+        config_changes: [],
+        test_changes: [],
+        release_artifacts: [],
+        runtime_generated_files: [],
+    };
+    for (const file of changedFiles) {
+        const normalized = normalizePath(file.path).toLowerCase();
+        const parts = normalized.split("/");
+        const basename = parts[parts.length - 1] || "";
+        // Check for docs
+        if (parts.some((p) => p === "docs") || /\.(md|rst|txt)$/.test(basename)) {
+            groups.docs_changes.push(file);
+            continue;
+        }
+        // Check for config
+        if (basename === "package.json" || basename === "tsconfig.json" || basename === ".gitignore" ||
+            basename.startsWith(".config") || basename.endsWith(".config.js") || basename.endsWith(".config.ts")) {
+            groups.config_changes.push(file);
+            continue;
+        }
+        // Check for test files
+        if (basename.includes(".test.") || basename.includes(".spec.") || parts.some((p) => p === "test" || p === "tests" || p === "__tests__")) {
+            groups.test_changes.push(file);
+            continue;
+        }
+        // Check for build artifacts / release
+        if (file.kind === "build_artifact") {
+            groups.release_artifacts.push(file);
+            continue;
+        }
+        // Check for runtime generated
+        if (file.kind === "runtime_generated") {
+            groups.runtime_generated_files.push(file);
+            continue;
+        }
+        // Default: source changes
+        groups.source_changes.push(file);
+    }
+    return groups;
+}
+function classifyChangedFile(path, change, before, after) {
+    return {
+        path,
+        change,
+        before_sha256: before?.sha256 || null,
+        after_sha256: after?.sha256 || null,
+        tracked: Boolean(after?.tracked || before?.tracked),
+        ignored: Boolean(after?.ignored ?? before?.ignored),
+        kind: classifyPathKind(path),
+    };
+}
+function classifyArtifactHygiene(changes) {
+    const hygiene = emptyArtifactHygiene();
+    const entries = changes.map((change) => ({
+        path: change.path,
+        change: change.change,
+        tracked: change.tracked,
+        ignored: change.ignored,
+        kind: change.kind,
+        reason: classificationReason(change),
+    }));
+    hygiene.source_changes = entries.filter((entry) => entry.kind === "source" && !entry.ignored);
+    hygiene.tracked_build_artifacts = entries.filter((entry) => entry.kind === "build_artifact" && entry.tracked);
+    hygiene.ignored_untracked_artifacts = entries.filter((entry) => entry.ignored && !entry.tracked);
+    hygiene.runtime_generated_files = entries.filter((entry) => entry.kind === "runtime_generated");
+    hygiene.suspicious_changes = entries.filter((entry) => (entry.kind === "build_artifact" || entry.kind === "runtime_generated") && !entry.ignored);
+    hygiene.counts = {
+        source_changes: hygiene.source_changes.length,
+        tracked_build_artifacts: hygiene.tracked_build_artifacts.length,
+        ignored_untracked_artifacts: hygiene.ignored_untracked_artifacts.length,
+        runtime_generated_files: hygiene.runtime_generated_files.length,
+        suspicious_changes: hygiene.suspicious_changes.length,
+    };
+    return hygiene;
+}
+function classifyPathKind(path) {
+    const normalized = normalizePath(path).toLowerCase();
+    const parts = normalized.split("/");
+    const basename = parts[parts.length - 1] || "";
+    if (basename === "sync-store.json" || /\.(log|tmp|temp|pid)$/.test(basename))
+        return "runtime_generated";
+    if (parts.some((part) => ["dist", "release", "build", "out", "coverage", ".next"].includes(part)))
+        return "build_artifact";
+    if (/\.(exe|dll|pak|bin|zip|tgz|tar\.gz)$/.test(basename))
+        return "build_artifact";
+    return "source";
+}
+function classificationReason(change) {
+    if (change.ignored)
+        return "untracked path is ignored by repository Git rules";
+    if (change.kind === "build_artifact" && change.tracked)
+        return "artifact-like path is tracked by Git and requires review";
+    if (change.kind === "build_artifact")
+        return "artifact-like path is not ignored and requires review";
+    if (change.kind === "runtime_generated")
+        return "runtime-generated path is not ignored and requires review";
+    return change.tracked ? "tracked source change" : "untracked source change";
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, "/");
+}
 function walkWorkspace(root) {
     const result = [];
     const visit = (directory) => {