patchwarden 0.4.0 → 0.6.1

package/src/runner/changeCapture.ts

@@ -7,7 +7,7 @@ import {
   statSync,
   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";
 
@@ -19,6 +19,8 @@ const SKIP_DIRECTORIES = new Set([".git", ".patchwarden", "node_modules"]);
 export interface FileFingerprint {
   size: number;
   sha256: string;
+  tracked: boolean;
+  ignored: boolean;
 }
 
 export interface RepoSnapshot {
@@ -28,6 +30,7 @@ export interface RepoSnapshot {
   status: string;
   workspace_dirty: boolean;
   files: Record<string, FileFingerprint>;
+  dirty_paths: string[]; // paths that git status --porcelain reports as modified/added/deleted/untracked/renamed
   warnings: string[];
 }
 
@@ -37,6 +40,33 @@ export interface ChangedFile {
   old_path?: string;
   before_sha256: string | null;
   after_sha256: string | null;
+  tracked: boolean;
+  ignored: boolean;
+  kind: "source" | "build_artifact" | "runtime_generated";
+}
+
+export interface ClassifiedChange {
+  path: string;
+  change: ChangedFile["change"];
+  tracked: boolean;
+  ignored: boolean;
+  kind: ChangedFile["kind"];
+  reason: string;
+}
+
+export interface ArtifactHygiene {
+  counts: {
+    source_changes: number;
+    tracked_build_artifacts: number;
+    ignored_untracked_artifacts: number;
+    runtime_generated_files: number;
+    suspicious_changes: number;
+  };
+  source_changes: ClassifiedChange[];
+  tracked_build_artifacts: ClassifiedChange[];
+  ignored_untracked_artifacts: ClassifiedChange[];
+  runtime_generated_files: ClassifiedChange[];
+  suspicious_changes: ClassifiedChange[];
 }
 
 export interface ChangeArtifacts {
@@ -57,6 +87,7 @@ export interface ChangeArtifacts {
   workspace_dirty_after: boolean;
   patch_mode: "textual" | "no_changes" | "hash_only";
   unavailable_reason: string | null;
+  artifact_hygiene: ArtifactHygiene;
 }
 
 export function captureRepoSnapshot(repoPath: string): RepoSnapshot {
@@ -65,11 +96,45 @@ export function captureRepoSnapshot(repoPath: string): RepoSnapshot {
   let head: string | null = null;
   let status = "";
   let paths: string[] = [];
+  const trackedPaths = new Set<string>();
+  const ignoredPaths = new Set<string>();
 
+  const dirtyPaths = new Set<string>();
   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([
@@ -92,7 +157,7 @@ export function captureRepoSnapshot(repoPath: string): RepoSnapshot {
 
   const files: Record<string, FileFingerprint> = {};
   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);
     try {
@@ -101,7 +166,12 @@ export function captureRepoSnapshot(repoPath: string): RepoSnapshot {
       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}`);
     }
@@ -114,6 +184,7 @@ export function captureRepoSnapshot(repoPath: string): RepoSnapshot {
     status,
     workspace_dirty: status.trim().length > 0,
     files,
+    dirty_paths: [...dirtyPaths],
     warnings,
   };
 }
@@ -128,6 +199,7 @@ export function buildChangeArtifacts(
   after: RepoSnapshot
 ): ChangeArtifacts {
   const changedFiles = compareSnapshots(before, after);
+  const artifactHygiene = classifyArtifactHygiene(changedFiles);
   const sections: string[] = [];
   const scopedPaths = [...new Set(changedFiles.flatMap((file) => file.old_path ? [file.old_path, file.path] : [file.path]))];
 
@@ -179,6 +251,7 @@ export function buildChangeArtifacts(
           ? "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,
   };
 }
 
@@ -232,11 +305,11 @@ export function compareSnapshots(before: RepoSnapshot, after: RepoSnapshot): Cha
     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<string, ChangedFile[]>();
@@ -260,6 +333,9 @@ export function compareSnapshots(before: RepoSnapshot, after: RepoSnapshot): Cha
       change: "renamed",
       before_sha256: source.before_sha256,
       after_sha256: file.after_sha256,
+      tracked: file.tracked || source.tracked,
+      ignored: file.ignored,
+      kind: classifyPathKind(file.path),
     });
   }
 
@@ -267,6 +343,276 @@ export function compareSnapshots(before: RepoSnapshot, after: RepoSnapshot): Cha
     .sort((left, right) => left.path.localeCompare(right.path));
 }
 
+export function emptyArtifactHygiene(): ArtifactHygiene {
+  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: [],
+  };
+}
+
+// ── Phase 4: External dirty file baseline ─────────────────────────
+
+export interface ExternalDirtyFile {
+  path: string;
+  change: ChangedFile["change"];
+  before_sha256: string | null;
+  after_sha256: string | null;
+}
+
+/**
+ * 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: RepoSnapshot,
+  repoPath: string,
+  workspaceRoot: string
+): ExternalDirtyFile[] {
+  const dirtyFiles: ExternalDirtyFile[] = [];
+  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: ExternalDirtyFile[],
+  current: ExternalDirtyFile[]
+): ExternalDirtyFile[] {
+  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;
+  });
+}
+
+// ── Phase 6: Artifact manifest ────────────────────────────────────
+
+export interface ArtifactManifestEntry {
+  path: string;
+  type: string;
+  size: number;
+  sha256: string;
+  generated_by: string;
+  created_at: string;
+}
+
+export interface ArtifactManifest {
+  task_id: string | null;
+  generated_at: string;
+  artifacts: ArtifactManifestEntry[];
+}
+
+export function buildArtifactManifest(
+  changedFiles: ChangedFile[],
+  repoPath: string,
+  taskId?: string
+): ArtifactManifest {
+  const entries: ArtifactManifestEntry[] = [];
+  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: string): string {
+  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";
+}
+
+// ── Phase 6: Changed file grouping ────────────────────────────────
+
+export interface ChangedFileGroups {
+  source_changes: ChangedFile[];
+  docs_changes: ChangedFile[];
+  config_changes: ChangedFile[];
+  test_changes: ChangedFile[];
+  release_artifacts: ChangedFile[];
+  runtime_generated_files: ChangedFile[];
+}
+
+export function groupChangedFiles(changedFiles: ChangedFile[]): ChangedFileGroups {
+  const groups: ChangedFileGroups = {
+    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: string,
+  change: ChangedFile["change"],
+  before: FileFingerprint | null,
+  after: FileFingerprint | null
+): ChangedFile {
+  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: ChangedFile[]): ArtifactHygiene {
+  const hygiene = emptyArtifactHygiene();
+  const entries = changes.map((change): ClassifiedChange => ({
+    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: string): ChangedFile["kind"] {
+  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: ChangedFile): string {
+  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: string): string {
+  return value.replace(/\\/g, "/");
+}
+
 function walkWorkspace(root: string): string[] {
   const result: string[] = [];
   const visit = (directory: string) => {