ai-maestro 1.0.0

package/src/workspace-diff.mjs

@@ -0,0 +1,228 @@
+import fs from 'fs/promises';
+import { createHash } from 'crypto';
+import path from 'path';
+import { execFileRaw } from './shell.mjs';
+
+const IGNORED_DIRS = new Set(['.memory', '.maestro', 'node_modules', '.venv', 'dist', 'build', '.git']);
+const IGNORED_LOG_PATTERN = /\.log$/i;
+
+function isIgnoredPath(relPath) {
+  const normalized = relPath.replace(/\\/g, '/');
+  if (IGNORED_LOG_PATTERN.test(normalized)) {
+    return true;
+  }
+  return normalized.split('/').some(segment => IGNORED_DIRS.has(segment));
+}
+
+async function isGitRepo(root) {
+  const result = await execFileRaw('git', ['rev-parse', '--is-inside-work-tree'], { cwd: root, quiet: true });
+  return result.code === 0 && result.stdout.trim() === 'true';
+}
+
+async function gitStatusPorcelain(root) {
+  const result = await execFileRaw('git', ['status', '--porcelain'], { cwd: root, quiet: true });
+  return result.code === 0 ? result.stdout.split(/\r?\n/).filter(Boolean) : [];
+}
+
+function parsePorcelainLine(line) {
+  const code = line.slice(0, 2);
+  let rawPath = line.slice(3).trim();
+  if (rawPath.startsWith('"') && rawPath.endsWith('"')) {
+    rawPath = rawPath.slice(1, -1);
+  }
+  const arrowIndex = rawPath.indexOf(' -> ');
+  const filePath = arrowIndex >= 0 ? rawPath.slice(arrowIndex + 4) : rawPath;
+  return { code, path: filePath };
+}
+
+function normalizePath(relPath) {
+  return relPath.replace(/\\/g, '/');
+}
+
+function snapshotLines(snapshot) {
+  if (Array.isArray(snapshot?.lines)) {
+    return snapshot.lines;
+  }
+  if (!Array.isArray(snapshot?.entries)) {
+    return [];
+  }
+  return snapshot.entries
+    .map(entry => {
+      if (typeof entry === 'string') {
+        return entry;
+      }
+      return typeof entry?.line === 'string' ? entry.line : null;
+    })
+    .filter(Boolean);
+}
+
+function snapshotEntries(snapshot) {
+  const entries = new Map();
+  for (const line of snapshotLines(snapshot)) {
+    const parsed = parsePorcelainLine(line);
+    entries.set(normalizePath(parsed.path), { ...parsed, path: normalizePath(parsed.path), line });
+  }
+  if (entries.size > 0 || !Array.isArray(snapshot?.entries)) {
+    return entries;
+  }
+  for (const entry of snapshot.entries) {
+    if (!entry || typeof entry !== 'object' || typeof entry.path !== 'string') {
+      continue;
+    }
+    const filePath = normalizePath(entry.path);
+    entries.set(filePath, {
+      code: typeof entry.code === 'string' ? entry.code : '',
+      path: filePath,
+      line: typeof entry.line === 'string' ? entry.line : null
+    });
+  }
+  return entries;
+}
+
+function snapshotSignature(snapshot, relPath) {
+  const signatures = snapshot?.signatures;
+  if (!signatures) {
+    return null;
+  }
+  if (signatures instanceof Map) {
+    return signatures.get(relPath) ?? null;
+  }
+  return typeof signatures[relPath] === 'string' ? signatures[relPath] : null;
+}
+
+function sameSnapshotEntry(beforeEntry, afterEntry) {
+  if (beforeEntry.line && afterEntry.line) {
+    return beforeEntry.line === afterEntry.line;
+  }
+  return beforeEntry.code === afterEntry.code;
+}
+
+async function fileContentSignature(root, relPath) {
+  const content = await fs.readFile(path.join(root, relPath));
+  return createHash('sha256').update(content).digest('hex');
+}
+
+async function gitDirtySignatures(root, lines) {
+  const signatures = {};
+  for (const line of lines) {
+    const { code, path: parsedPath } = parsePorcelainLine(line);
+    const filePath = normalizePath(parsedPath);
+    if (isIgnoredPath(filePath) || code.includes('D')) {
+      continue;
+    }
+    try {
+      signatures[filePath] = await fileContentSignature(root, filePath);
+    } catch (error) {
+      // The path may be a directory or may have disappeared between status and read.
+    }
+  }
+  return signatures;
+}
+
+async function walkFiles(root, base, acc) {
+  let entries;
+  try {
+    entries = await fs.readdir(base, { withFileTypes: true });
+  } catch (error) {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (IGNORED_DIRS.has(entry.name)) {
+        continue;
+      }
+      await walkFiles(root, path.join(base, entry.name), acc);
+    } else if (entry.isFile()) {
+      const fullPath = path.join(base, entry.name);
+      const rel = path.relative(root, fullPath).replace(/\\/g, '/');
+      if (isIgnoredPath(rel)) {
+        continue;
+      }
+      try {
+        const stat = await fs.stat(fullPath);
+        acc.set(rel, { size: stat.size, mtimeMs: stat.mtimeMs });
+      } catch (error) {
+        // unreadable between readdir and stat; skip
+      }
+    }
+  }
+}
+
+export async function snapshotWorkspace(root = process.cwd()) {
+  if (await isGitRepo(root)) {
+    const lines = await gitStatusPorcelain(root);
+    return { kind: 'git', root, lines, signatures: await gitDirtySignatures(root, lines) };
+  }
+  const files = new Map();
+  await walkFiles(root, root, files);
+  return { kind: 'fs', root, files };
+}
+
+function classifyOutOfScope(changedFiles, createdFiles, deletedFiles, scopeFiles) {
+  if (!scopeFiles || scopeFiles.length === 0) {
+    return [];
+  }
+  const scopeSet = new Set(scopeFiles.map(file => file.replace(/\\/g, '/')));
+  return [...changedFiles, ...createdFiles, ...deletedFiles].filter(file => !scopeSet.has(file));
+}
+
+export function diffWorkspace(before, after, { scopeFiles = [] } = {}) {
+  const changedFiles = [];
+  const createdFiles = [];
+  const deletedFiles = [];
+  const pushUnique = (list, filePath) => {
+    if (!list.includes(filePath)) {
+      list.push(filePath);
+    }
+  };
+
+  if (before.kind === 'git' && after.kind === 'git') {
+    const beforeEntries = snapshotEntries(before);
+    for (const afterEntry of snapshotEntries(after).values()) {
+      const { code, path: filePath } = afterEntry;
+      if (isIgnoredPath(filePath)) {
+        continue;
+      }
+      const beforeEntry = beforeEntries.get(filePath);
+      if (beforeEntry && sameSnapshotEntry(beforeEntry, afterEntry)) {
+        const beforeSignature = snapshotSignature(before, filePath);
+        const afterSignature = snapshotSignature(after, filePath);
+        if (beforeSignature && afterSignature && beforeSignature !== afterSignature) {
+          pushUnique(changedFiles, filePath);
+        }
+        continue;
+      }
+      if (code.includes('D')) {
+        pushUnique(deletedFiles, filePath);
+      } else if (code === '??') {
+        pushUnique(createdFiles, filePath);
+      } else {
+        pushUnique(changedFiles, filePath);
+      }
+    }
+  } else {
+    const beforeFiles = before.files || new Map();
+    const afterFiles = after.files || new Map();
+    for (const [relPath, afterMeta] of afterFiles) {
+      const beforeMeta = beforeFiles.get(relPath);
+      if (!beforeMeta) {
+        createdFiles.push(relPath);
+      } else if (beforeMeta.size !== afterMeta.size || beforeMeta.mtimeMs !== afterMeta.mtimeMs) {
+        changedFiles.push(relPath);
+      }
+    }
+    for (const relPath of beforeFiles.keys()) {
+      if (!afterFiles.has(relPath)) {
+        deletedFiles.push(relPath);
+      }
+    }
+  }
+
+  return {
+    workspaceChanged: changedFiles.length > 0 || createdFiles.length > 0 || deletedFiles.length > 0,
+    changedFiles,
+    createdFiles,
+    deletedFiles,
+    outOfScopeChanges: classifyOutOfScope(changedFiles, createdFiles, deletedFiles, scopeFiles)
+  };
+}