64875
Mc
mini-coder / files
mini-coder / src / tools / snapshot.ts
5.4 KB
1import { type Dirent, lstatSync, readFileSync, readdirSync, type Stats } from "node:fs"; 2import { join, relative } from "node:path"; 3import { createTwoFilesPatch } from "diff"; 4import type { FileDiff } from "./common.ts"; 5 6const MAX_FILE_BYTES = 1 << 20; 7const MAX_TOTAL_BYTES = 32 << 20; 8const BINARY_SNIFF = 8192; 9 10const IGNORED_DIRS = new Set([ 11 ".git", 12 ".hg", 13 ".svn", 14 "node_modules", 15 ".venv", 16 "venv", 17 "__pycache__", 18 ".mypy_cache", 19 ".pytest_cache", 20]); 21 22type Kind = "text" | "binary" | "large" | "link" | "untracked"; 23 24interface FileState { 25 size: number; 26 mtimeMs: number; 27 ino: number; 28 kind: Kind; 29 content: string | null; 30} 31 32/** Relpath -> state. A shallow copy, safe against later captures. */ 33export type Tree = Map<string, FileState>; 34 35interface Entry { 36 rel: string; 37 abs: string; 38 size: number; 39 mtimeMs: number; 40 ino: number; 41 link: boolean; 42} 43 44function* walk(): Generator<Entry> { 45 const root = process.cwd(); 46 const stack = [root]; 47 while (stack.length > 0) { 48 const dir = stack.pop()!; 49 let entries: Dirent[]; 50 try { 51 entries = readdirSync(dir, { withFileTypes: true }); 52 } catch { 53 continue; 54 } 55 for (const dirent of entries) { 56 const abs = join(dir, dirent.name); 57 if (dirent.isDirectory()) { 58 if (!IGNORED_DIRS.has(dirent.name)) stack.push(abs); 59 continue; 60 } 61 const link = dirent.isSymbolicLink(); 62 if (!link && !dirent.isFile()) continue; 63 let stat: Stats; 64 try { 65 stat = lstatSync(abs); 66 } catch { 67 continue; 68 } 69 yield { rel: relative(root, abs), abs, size: stat.size, mtimeMs: stat.mtimeMs, ino: stat.ino, link }; 70 } 71 } 72} 73 74function build(entry: Entry, overBudget: boolean): FileState { 75 const base = { size: entry.size, mtimeMs: entry.mtimeMs, ino: entry.ino }; 76 if (entry.size > MAX_FILE_BYTES) return { ...base, kind: "large", content: null }; 77 if (overBudget) return { ...base, kind: "untracked", content: null }; 78 let buffer; 79 try { 80 buffer = readFileSync(entry.abs); 81 } catch { 82 return { ...base, kind: "untracked", content: null }; 83 } 84 if (buffer.subarray(0, BINARY_SNIFF).includes(0)) return { ...base, kind: "binary", content: null }; 85 return { ...base, kind: "text", content: buffer.toString("utf8") }; 86} 87 88type StatKey = Pick<FileState, "size" | "mtimeMs" | "ino">; 89 90function sameStat(a: StatKey, b: StatKey): boolean { 91 return a.size === b.size && a.mtimeMs === b.mtimeMs && a.ino === b.ino; 92} 93 94/** 95 * Caches file content across calls, keyed by the stat triple `(size, mtimeMs, 96 * ino)`, so a second capture only reads what the stat walk shows as changed. 97 */ 98class SnapshotCache { 99 private cache = new Map<string, FileState>(); 100 101 capture(forceSinceMs?: number): Tree { 102 const next: Tree = new Map(); 103 let total = 0; 104 for (const entry of walk()) { 105 const cached = this.cache.get(entry.rel); 106 const forced = forceSinceMs !== undefined && entry.mtimeMs >= forceSinceMs; 107 const reuse = !entry.link && !forced && cached !== undefined && sameStat(cached, entry); 108 const state = reuse 109 ? cached! 110 : entry.link 111 ? { size: entry.size, mtimeMs: entry.mtimeMs, ino: entry.ino, kind: "link" as const, content: null } 112 : build(entry, total >= MAX_TOTAL_BYTES); 113 if (state.content !== null) total += state.size; 114 next.set(entry.rel, state); 115 } 116 this.cache = next; 117 return new Map(next); 118 } 119} 120 121let cache: SnapshotCache | undefined; 122 123/** Captures the working tree, re-reading content only when its stat key moved. */ 124export function snapshot(forceSinceMs?: number): Tree { 125 cache ??= new SnapshotCache(); 126 return cache.capture(forceSinceMs); 127} 128 129function patch(path: string, before: string, after: string): string { 130 return createTwoFilesPatch(path, path, before, after, "", "", { context: 3 }); 131} 132 133function noteFor(kind: Kind, verb: string): string { 134 if (kind === "binary") return `binary file ${verb}`; 135 if (kind === "large") return `large file ${verb}`; 136 return `file not tracked (${verb})`; 137} 138 139function diffOne(path: string, before: FileState | undefined, after: FileState | undefined): FileDiff | null { 140 if (before === undefined) { 141 if (after!.kind === "link") return { path, note: "symlink created" }; 142 return after!.content === null 143 ? { path, note: noteFor(after!.kind, "created") } 144 : { path, patch: patch(path, "", after!.content) }; 145 } 146 if (after === undefined) { 147 if (before.kind === "link") return { path, note: "symlink removed" }; 148 return before.content === null 149 ? { path, note: noteFor(before.kind, "deleted") } 150 : { path, patch: patch(path, before.content, "") }; 151 } 152 if (before.kind === "link" || after.kind === "link") { 153 return sameStat(before, after) ? null : { path, note: "symlink changed" }; 154 } 155 if (before.content !== null && after.content !== null) { 156 return before.content === after.content ? null : { path, patch: patch(path, before.content, after.content) }; 157 } 158 if (sameStat(before, after)) return null; 159 return { path, note: noteFor(after.content === null ? after.kind : before.kind, "changed") }; 160} 161 162/** The files that differ between two captures, sorted for stable output. */ 163export function diffTrees(before: Tree, after: Tree): FileDiff[] { 164 const paths = new Set([...before.keys(), ...after.keys()]); 165 const diffs: FileDiff[] = []; 166 for (const path of [...paths].sort()) { 167 const diff = diffOne(path, before.get(path), after.get(path)); 168 if (diff !== null) diffs.push(diff); 169 } 170 return diffs; 171}