@chrisdudek/yg 4.0.0 → 4.0.2

package/dist/bin.js

@@ -2346,6 +2346,10 @@ function normalizeProjectRelativePath(projectRoot, rawPath) {
 function projectRootFromGraph(yggRootPath) {
   return path10.dirname(yggRootPath);
 }
+function resolveFileArg(cwd, repoRoot, rawPath) {
+  const absolute = path10.resolve(cwd, rawPath.trim());
+  return path10.relative(repoRoot, absolute).replace(/\\/g, "/").replace(/\/+$/, "");
+}
 
 // src/core/graph-loader.ts
 function toModelPath(absolutePath, modelDir) {
@@ -2910,8 +2914,160 @@ function formatFileContext(data) {
 }
 
 // src/core/validator.ts
-import { readdir as readdir5, stat as stat4 } from "fs/promises";
+import { readdir as readdir6 } from "fs/promises";
+import path14 from "path";
+
+// src/utils/hash.ts
+import { readFile as readFile14, readdir as readdir5, stat as stat4 } from "fs/promises";
 import path13 from "path";
+import { createHash } from "crypto";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var ignoreFactory = require2("ignore");
+async function hashFile(filePath) {
+  const content = await readFile14(filePath);
+  return createHash("sha256").update(content).digest("hex");
+}
+async function loadRootGitignoreStack(projectRoot) {
+  if (!projectRoot) return [];
+  try {
+    const content = await readFile14(path13.join(projectRoot, ".gitignore"), "utf-8");
+    const matcher = ignoreFactory();
+    matcher.add(content);
+    return [{ basePath: projectRoot, matcher }];
+  } catch {
+    return [];
+  }
+}
+function isIgnoredByStack(candidatePath, stack) {
+  for (const { basePath, matcher } of stack) {
+    const relativePath = path13.relative(basePath, candidatePath);
+    if (relativePath === "" || relativePath.startsWith("..")) continue;
+    if (matcher.ignores(relativePath) || matcher.ignores(relativePath + "/")) return true;
+  }
+  return false;
+}
+function hashString(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+async function hashTrackedFiles(projectRoot, trackedFiles, storedFileData, excludePrefixes) {
+  const fileHashes = {};
+  const fileMtimes = {};
+  const gitignoreStack = await loadRootGitignoreStack(projectRoot);
+  const allFiles = [];
+  for (const tf of trackedFiles) {
+    if (tf.syntheticHash) {
+      fileHashes[tf.path] = tf.syntheticHash;
+      continue;
+    }
+    const absPath = path13.join(projectRoot, tf.path);
+    try {
+      const st = await stat4(absPath);
+      if (st.isDirectory()) {
+        const dirEntries = await collectDirectoryFilePaths(absPath, absPath, {
+          projectRoot,
+          gitignoreStack
+        });
+        for (const entry of dirEntries) {
+          allFiles.push({
+            relPath: path13.join(tf.path, entry.relPath).replace(/\\/g, "/").replace(/\/+$/, ""),
+            absPath: entry.absPath,
+            mtimeMs: entry.mtimeMs
+          });
+        }
+      } else {
+        allFiles.push({ relPath: tf.path, absPath, mtimeMs: st.mtimeMs });
+      }
+    } catch {
+      continue;
+    }
+  }
+  const filtered = excludePrefixes?.length ? allFiles.filter((entry) => !excludePrefixes.some((prefix) => entry.relPath === prefix || entry.relPath.startsWith(prefix + "/"))) : allFiles;
+  const dirty = [];
+  for (const entry of filtered) {
+    const storedMtime = storedFileData?.mtimes[entry.relPath];
+    const storedHash = storedFileData?.hashes[entry.relPath];
+    if (storedMtime !== void 0 && storedHash !== void 0 && entry.mtimeMs === storedMtime) {
+      fileHashes[entry.relPath] = storedHash;
+    } else {
+      dirty.push(entry);
+    }
+    fileMtimes[entry.relPath] = entry.mtimeMs;
+  }
+  const BATCH_SIZE = 256;
+  for (let i = 0; i < dirty.length; i += BATCH_SIZE) {
+    const batch = dirty.slice(i, i + BATCH_SIZE);
+    const hashes = await Promise.all(batch.map((e) => hashFile(e.absPath)));
+    for (let j = 0; j < batch.length; j++) {
+      fileHashes[batch[j].relPath] = hashes[j];
+    }
+  }
+  const sorted = Object.entries(fileHashes).sort(([a], [b]) => a.localeCompare(b));
+  const digest = sorted.map(([p2, h]) => `${p2}:${h}`).join("\n");
+  const canonicalHash = hashString(digest);
+  return { canonicalHash, fileHashes, fileMtimes };
+}
+async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, options) {
+  let stack = options.gitignoreStack ?? [];
+  try {
+    const localContent = await readFile14(path13.join(directoryPath, ".gitignore"), "utf-8");
+    const localMatcher = ignoreFactory();
+    localMatcher.add(localContent);
+    stack = [...stack, { basePath: directoryPath, matcher: localMatcher }];
+  } catch {
+  }
+  const entries = await readdir5(directoryPath, { withFileTypes: true });
+  const dirs = [];
+  const files = [];
+  for (const entry of entries) {
+    const absoluteChildPath = path13.join(directoryPath, entry.name);
+    if (isIgnoredByStack(absoluteChildPath, stack)) continue;
+    if (entry.isDirectory()) dirs.push(absoluteChildPath);
+    else if (entry.isFile()) files.push(absoluteChildPath);
+  }
+  const [dirResults, fileStats] = await Promise.all([
+    Promise.all(dirs.map((d) => collectDirectoryFilePaths(d, rootDirectoryPath, {
+      projectRoot: options.projectRoot,
+      gitignoreStack: stack
+    }))),
+    Promise.all(files.map(async (f) => {
+      const fileStat = await stat4(f);
+      return {
+        relPath: path13.relative(rootDirectoryPath, f).replace(/\\/g, "/").replace(/\/+$/, ""),
+        absPath: f,
+        mtimeMs: fileStat.mtimeMs
+      };
+    }))
+  ]);
+  const result = [];
+  for (const nested of dirResults) result.push(...nested);
+  result.push(...fileStats);
+  return result;
+}
+async function expandMappingPaths(projectRoot, mappingPaths) {
+  const gitignoreStack = await loadRootGitignoreStack(projectRoot);
+  const result = [];
+  for (const mp of mappingPaths) {
+    const absPath = path13.join(projectRoot, mp);
+    try {
+      const st = await stat4(absPath);
+      if (st.isDirectory()) {
+        const dirEntries = await collectDirectoryFilePaths(absPath, absPath, {
+          projectRoot,
+          gitignoreStack
+        });
+        for (const entry of dirEntries) {
+          result.push(path13.join(mp, entry.relPath).replace(/\\/g, "/").replace(/\/+$/, ""));
+        }
+      } else {
+        result.push(mp);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return result;
+}
 
 // src/formatters/message-builder.ts
 function buildIssueMessage(msg) {
@@ -2972,10 +3128,11 @@ async function validate(graph, scope = "all") {
   issues.push(...checkOrphanedAspects(graph));
   let filtered = issues;
   let nodesScanned = graph.nodes.size;
-  if (scope !== "all" && scope.trim()) {
-    if (!graph.nodes.has(scope)) {
+  const normalizedScope = scope.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+  if (normalizedScope !== "all" && normalizedScope) {
+    if (!graph.nodes.has(normalizedScope)) {
       const parseError = (graph.nodeParseErrors ?? []).find(
-        (e) => e.nodePath === scope || scope.startsWith(e.nodePath + "/")
+        (e) => e.nodePath === normalizedScope || normalizedScope.startsWith(e.nodePath + "/")
       );
       if (parseError) {
         return {
@@ -2990,13 +3147,13 @@ async function validate(graph, scope = "all") {
         };
       }
       return {
-        issues: [{ severity: "error", rule: "invalid-scope", message: buildIssueMessage({ what: `Node not found: ${scope}`, why: "Validation scope references a node that does not exist in the graph.", next: "Check the node path and try again." }) }],
+        issues: [{ severity: "error", rule: "invalid-scope", message: buildIssueMessage({ what: `Node not found: ${normalizedScope}`, why: "Validation scope references a node that does not exist in the graph.", next: "Check the node path and try again." }) }],
         nodesScanned: 0
       };
     }
-    const scopePrefix = scope + "/";
-    filtered = issues.filter((i) => !i.nodePath || i.nodePath === scope || i.nodePath.startsWith(scopePrefix));
-    nodesScanned = [...graph.nodes.keys()].filter((p2) => p2 === scope || p2.startsWith(scopePrefix)).length;
+    const scopePrefix = normalizedScope + "/";
+    filtered = issues.filter((i) => !i.nodePath || i.nodePath === normalizedScope || i.nodePath.startsWith(scopePrefix));
+    nodesScanned = [...graph.nodes.keys()].filter((p2) => p2 === normalizedScope || p2.startsWith(scopePrefix)).length;
   }
   return { issues: filtered, nodesScanned };
 }
@@ -3313,12 +3470,12 @@ function checkMappingOverlap(graph) {
 }
 async function checkMappingPathsExist(graph) {
   const issues = [];
-  const projectRoot = path13.dirname(graph.rootPath);
+  const projectRoot = path14.dirname(graph.rootPath);
   const { access: access3 } = await import("fs/promises");
   for (const [nodePath, node] of graph.nodes) {
     const mappingPaths = normalizeMappingPaths(node.meta.mapping);
     for (const mp of mappingPaths) {
-      const absPath = path13.join(projectRoot, mp);
+      const absPath = path14.join(projectRoot, mp);
       try {
         await access3(absPath);
       } catch {
@@ -3362,13 +3519,13 @@ function checkBrokenFlowRefs(graph) {
 async function checkWideNodes(graph) {
   const issues = [];
   const maxFiles = graph.config.quality?.max_mapping_source_files ?? 10;
-  const projectRoot = path13.dirname(graph.rootPath);
+  const projectRoot = path14.dirname(graph.rootPath);
   for (const [nodePath, node] of graph.nodes) {
     const effectiveAspects = computeEffectiveAspects(node, graph);
     if (effectiveAspects.size === 0) continue;
     const mappingPaths = normalizeMappingPaths(node.meta.mapping);
     if (mappingPaths.length === 0) continue;
-    const sourceFiles = await expandMappingToFiles(projectRoot, mappingPaths);
+    const sourceFiles = await expandMappingPaths(projectRoot, mappingPaths);
     if (sourceFiles.length <= maxFiles) continue;
     issues.push({
       severity: "warning",
@@ -3483,9 +3640,9 @@ function checkSchemas(graph) {
 }
 async function checkDirectoriesHaveNodeYaml(graph) {
   const issues = [];
-  const modelDir = path13.join(graph.rootPath, "model");
+  const modelDir = path14.join(graph.rootPath, "model");
   async function scanDir(dirPath, segments) {
-    const entries = (await readdir5(dirPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+    const entries = (await readdir6(dirPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
     const hasNodeYaml = entries.some((e) => e.isFile() && e.name === "yg-node.yaml");
     const hasFiles = entries.some((e) => e.isFile());
     const graphPath = segments.join("/");
@@ -3507,47 +3664,20 @@ async function checkDirectoriesHaveNodeYaml(graph) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
-      await scanDir(path13.join(dirPath, entry.name), [...segments, entry.name]);
+      await scanDir(path14.join(dirPath, entry.name), [...segments, entry.name]);
     }
   }
   try {
-    const rootEntries = (await readdir5(modelDir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+    const rootEntries = (await readdir6(modelDir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of rootEntries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
-      await scanDir(path13.join(modelDir, entry.name), [entry.name]);
+      await scanDir(path14.join(modelDir, entry.name), [entry.name]);
     }
   } catch {
   }
   return issues;
 }
-async function expandMappingToFiles(projectRoot, mappingPaths) {
-  const files = [];
-  async function collectFiles(absPath) {
-    try {
-      const s = await stat4(absPath);
-      if (s.isFile()) {
-        files.push(absPath);
-      } else if (s.isDirectory()) {
-        const entries = await readdir5(absPath, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-          const entryPath = path13.join(absPath, entry.name);
-          if (entry.isFile()) {
-            files.push(entryPath);
-          } else if (entry.isDirectory()) {
-            await collectFiles(entryPath);
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  for (const mp of mappingPaths) {
-    await collectFiles(path13.join(projectRoot, mp));
-  }
-  return files;
-}
 function checkMissingDescriptions(graph) {
   const issues = [];
   for (const [nodePath, node] of graph.nodes) {
@@ -3815,7 +3945,7 @@ function checkOrphanedAspects(graph) {
 }
 
 // src/cli/owner.ts
-import path14 from "path";
+import path15 from "path";
 import { access } from "fs/promises";
 import chalk2 from "chalk";
 function normalizeForMatch(inputPath) {
@@ -3846,12 +3976,10 @@ function registerOwnerCommand(program2) {
       const graph = await loadGraph(cwd);
       initDebugLog(graph.rootPath, graph.config.debug ?? false);
       const repoRoot = projectRootFromGraph(graph.rootPath);
-      const rawPath = options.file.trim();
-      const absolute = path14.resolve(cwd, rawPath);
-      const repoRelative = path14.relative(repoRoot, absolute).replace(/\\/g, "/").replace(/\/+$/, "");
+      const repoRelative = resolveFileArg(cwd, repoRoot, options.file);
       const result = findOwner(graph, repoRoot, repoRelative);
       if (!result.nodePath) {
-        const absPath = path14.resolve(repoRoot, result.file);
+        const absPath = path15.resolve(repoRoot, result.file);
         let exists = true;
         try {
           await access(absPath);
@@ -3956,7 +4084,8 @@ function registerBuildCommand(program2) {
       let resolvedFilePath;
       if (options.file) {
         const repoRoot = projectRootFromGraph(graph.rootPath);
-        const result = findOwner(graph, repoRoot, options.file.trim());
+        const repoRelative = resolveFileArg(process.cwd(), repoRoot, options.file);
+        const result = findOwner(graph, repoRoot, repoRelative);
         if (!result.nodePath) {
           const candidates = findCandidateNodes(graph, result.file);
           if (candidates.length > 0) {
@@ -4024,17 +4153,15 @@ ${errorList}`
         process.stdout.write(formatFileContext(data));
       } else {
         const data = buildNodeContextData(graph, nodePath);
+        const projectRoot = projectRootFromGraph(graph.rootPath);
+        data.sourceFiles = await expandMappingPaths(projectRoot, data.sourceFiles);
         process.stdout.write(formatNodeContext(data));
       }
     } catch (error) {
       const err = error;
       if (err.code === "ENOENT") {
         process.stderr.write(
-          chalk3.red(buildIssueMessage({
-            what: "No .yggdrasil/ directory found.",
-            why: "Yggdrasil is not initialized in this project.",
-            next: "Run 'yg init' to initialize."
-          }) + "\n")
+          chalk3.red("Error: No .yggdrasil/ directory found. Run 'yg init' first.\n")
         );
       } else {
         process.stderr.write(chalk3.red(`Error: ${error.message}
@@ -4049,31 +4176,30 @@ ${errorList}`
 // src/cli/approve.ts
 import chalk4 from "chalk";
 import path20 from "path";
-import { readFile as readFile18 } from "fs/promises";
 
 // src/io/drift-state-store.ts
-import { readFile as readFile14, writeFile as writeFile5, stat as stat5, readdir as readdir6, mkdir as mkdir3, rm as rm2 } from "fs/promises";
-import path15 from "path";
+import { readFile as readFile15, writeFile as writeFile5, stat as stat5, readdir as readdir7, mkdir as mkdir3, rm as rm2 } from "fs/promises";
+import path16 from "path";
 var DRIFT_STATE_DIR = ".drift-state";
 function nodeStatePath(yggRoot, nodePath) {
-  return path15.join(yggRoot, DRIFT_STATE_DIR, `${nodePath}.json`);
+  return path16.join(yggRoot, DRIFT_STATE_DIR, `${nodePath}.json`);
 }
 async function scanJsonFiles(dir, baseDir) {
   const results = [];
   let entries;
   try {
-    entries = await readdir6(dir, { withFileTypes: true });
+    entries = await readdir7(dir, { withFileTypes: true });
   } catch (err) {
     debugWrite(`[drift-state-store] scanJsonFiles readdir: ${err.message}`);
     return results;
   }
   for (const entry of entries) {
-    const fullPath = path15.join(dir, entry.name);
+    const fullPath = path16.join(dir, entry.name);
     if (entry.isDirectory()) {
       const nested = await scanJsonFiles(fullPath, baseDir);
       results.push(...nested);
     } else if (entry.isFile() && entry.name.endsWith(".json")) {
-      const relPath = path15.relative(baseDir, fullPath);
+      const relPath = path16.relative(baseDir, fullPath);
       const nodePath = relPath.replace(/\\/g, "/").replace(/\.json$/, "");
       results.push(nodePath);
     }
@@ -4081,13 +4207,13 @@ async function scanJsonFiles(dir, baseDir) {
   return results;
 }
 async function removeEmptyParents(filePath, stopDir) {
-  let dir = path15.dirname(filePath);
+  let dir = path16.dirname(filePath);
   while (dir !== stopDir && dir.startsWith(stopDir)) {
     try {
-      const entries = await readdir6(dir);
+      const entries = await readdir7(dir);
       if (entries.length === 0) {
         await rm2(dir, { recursive: true });
-        dir = path15.dirname(dir);
+        dir = path16.dirname(dir);
       } else {
         break;
       }
@@ -4100,7 +4226,7 @@ async function removeEmptyParents(filePath, stopDir) {
 async function readNodeDriftState(yggRoot, nodePath) {
   try {
     const filePath = nodeStatePath(yggRoot, nodePath);
-    const content = await readFile14(filePath, "utf-8");
+    const content = await readFile15(filePath, "utf-8");
     const parsed = JSON.parse(content);
     return parsed;
   } catch (err) {
@@ -4110,12 +4236,12 @@ async function readNodeDriftState(yggRoot, nodePath) {
 }
 async function writeNodeDriftState(yggRoot, nodePath, nodeState) {
   const filePath = nodeStatePath(yggRoot, nodePath);
-  await mkdir3(path15.dirname(filePath), { recursive: true });
+  await mkdir3(path16.dirname(filePath), { recursive: true });
   const content = JSON.stringify(nodeState, null, 2) + "\n";
   await writeFile5(filePath, content, "utf-8");
 }
 async function garbageCollectDriftState(yggRoot, validNodePaths) {
-  const driftDir = path15.join(yggRoot, DRIFT_STATE_DIR);
+  const driftDir = path16.join(yggRoot, DRIFT_STATE_DIR);
   const allNodePaths = await scanJsonFiles(driftDir, driftDir);
   const removed = [];
   for (const nodePath of allNodePaths) {
@@ -4129,7 +4255,7 @@ async function garbageCollectDriftState(yggRoot, validNodePaths) {
   return removed.sort();
 }
 async function readDriftState(yggRoot) {
-  const driftPath = path15.join(yggRoot, DRIFT_STATE_DIR);
+  const driftPath = path16.join(yggRoot, DRIFT_STATE_DIR);
   let driftStat;
   try {
     driftStat = await stat5(driftPath);
@@ -4152,134 +4278,6 @@ async function readDriftState(yggRoot) {
   return state;
 }
 
-// src/utils/hash.ts
-import { readFile as readFile15, readdir as readdir7, stat as stat6 } from "fs/promises";
-import path16 from "path";
-import { createHash } from "crypto";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var ignoreFactory = require2("ignore");
-async function hashFile(filePath) {
-  const content = await readFile15(filePath);
-  return createHash("sha256").update(content).digest("hex");
-}
-async function loadRootGitignoreStack(projectRoot) {
-  if (!projectRoot) return [];
-  try {
-    const content = await readFile15(path16.join(projectRoot, ".gitignore"), "utf-8");
-    const matcher = ignoreFactory();
-    matcher.add(content);
-    return [{ basePath: projectRoot, matcher }];
-  } catch {
-    return [];
-  }
-}
-function isIgnoredByStack(candidatePath, stack) {
-  for (const { basePath, matcher } of stack) {
-    const relativePath = path16.relative(basePath, candidatePath);
-    if (relativePath === "" || relativePath.startsWith("..")) continue;
-    if (matcher.ignores(relativePath) || matcher.ignores(relativePath + "/")) return true;
-  }
-  return false;
-}
-function hashString(content) {
-  return createHash("sha256").update(content).digest("hex");
-}
-async function hashTrackedFiles(projectRoot, trackedFiles, storedFileData, excludePrefixes) {
-  const fileHashes = {};
-  const fileMtimes = {};
-  const gitignoreStack = await loadRootGitignoreStack(projectRoot);
-  const allFiles = [];
-  for (const tf of trackedFiles) {
-    if (tf.syntheticHash) {
-      fileHashes[tf.path] = tf.syntheticHash;
-      continue;
-    }
-    const absPath = path16.join(projectRoot, tf.path);
-    try {
-      const st = await stat6(absPath);
-      if (st.isDirectory()) {
-        const dirEntries = await collectDirectoryFilePaths(absPath, absPath, {
-          projectRoot,
-          gitignoreStack
-        });
-        for (const entry of dirEntries) {
-          allFiles.push({
-            relPath: path16.join(tf.path, entry.relPath).replace(/\\/g, "/").replace(/\/+$/, ""),
-            absPath: entry.absPath,
-            mtimeMs: entry.mtimeMs
-          });
-        }
-      } else {
-        allFiles.push({ relPath: tf.path, absPath, mtimeMs: st.mtimeMs });
-      }
-    } catch {
-      continue;
-    }
-  }
-  const filtered = excludePrefixes?.length ? allFiles.filter((entry) => !excludePrefixes.some((prefix) => entry.relPath === prefix || entry.relPath.startsWith(prefix + "/"))) : allFiles;
-  const dirty = [];
-  for (const entry of filtered) {
-    const storedMtime = storedFileData?.mtimes[entry.relPath];
-    const storedHash = storedFileData?.hashes[entry.relPath];
-    if (storedMtime !== void 0 && storedHash !== void 0 && entry.mtimeMs === storedMtime) {
-      fileHashes[entry.relPath] = storedHash;
-    } else {
-      dirty.push(entry);
-    }
-    fileMtimes[entry.relPath] = entry.mtimeMs;
-  }
-  const BATCH_SIZE = 256;
-  for (let i = 0; i < dirty.length; i += BATCH_SIZE) {
-    const batch = dirty.slice(i, i + BATCH_SIZE);
-    const hashes = await Promise.all(batch.map((e) => hashFile(e.absPath)));
-    for (let j = 0; j < batch.length; j++) {
-      fileHashes[batch[j].relPath] = hashes[j];
-    }
-  }
-  const sorted = Object.entries(fileHashes).sort(([a], [b]) => a.localeCompare(b));
-  const digest = sorted.map(([p2, h]) => `${p2}:${h}`).join("\n");
-  const canonicalHash = hashString(digest);
-  return { canonicalHash, fileHashes, fileMtimes };
-}
-async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, options) {
-  let stack = options.gitignoreStack ?? [];
-  try {
-    const localContent = await readFile15(path16.join(directoryPath, ".gitignore"), "utf-8");
-    const localMatcher = ignoreFactory();
-    localMatcher.add(localContent);
-    stack = [...stack, { basePath: directoryPath, matcher: localMatcher }];
-  } catch {
-  }
-  const entries = await readdir7(directoryPath, { withFileTypes: true });
-  const dirs = [];
-  const files = [];
-  for (const entry of entries) {
-    const absoluteChildPath = path16.join(directoryPath, entry.name);
-    if (isIgnoredByStack(absoluteChildPath, stack)) continue;
-    if (entry.isDirectory()) dirs.push(absoluteChildPath);
-    else if (entry.isFile()) files.push(absoluteChildPath);
-  }
-  const [dirResults, fileStats] = await Promise.all([
-    Promise.all(dirs.map((d) => collectDirectoryFilePaths(d, rootDirectoryPath, {
-      projectRoot: options.projectRoot,
-      gitignoreStack: stack
-    }))),
-    Promise.all(files.map(async (f) => {
-      const fileStat = await stat6(f);
-      return {
-        relPath: path16.relative(rootDirectoryPath, f).replace(/\\/g, "/").replace(/\/+$/, ""),
-        absPath: f,
-        mtimeMs: fileStat.mtimeMs
-      };
-    }))
-  ]);
-  const result = [];
-  for (const nested of dirResults) result.push(...nested);
-  result.push(...fileStats);
-  return result;
-}
-
 // src/core/context-files.ts
 import path17 from "path";
 import { createHash as createHash2 } from "crypto";
@@ -5760,14 +5758,13 @@ function registerApproveCommand(program2) {
           }
           const aspects = resolveAspects(node2, graph);
           const projectRoot = path20.dirname(graph.rootPath);
-          const sourceFiles = [];
-          for (const mp of node2.meta.mapping ?? []) {
-            try {
-              const content = await readFile18(path20.join(projectRoot, mp), "utf-8");
-              sourceFiles.push({ path: mp, content });
-            } catch {
-            }
-          }
+          const trackedFiles = collectTrackedFiles(node2, graph);
+          const { fileHashes } = await hashTrackedFiles(projectRoot, trackedFiles, void 0, []);
+          const sourceFilePaths = Object.keys(fileHashes).filter((f) => {
+            const normalized = f.replace(/\\/g, "/").replace(/\/+$/, "");
+            return !normalized.startsWith(yggPrefix);
+          });
+          const sourceFiles = await loadSourceFiles(sourceFilePaths, projectRoot);
           process.stdout.write(chalk4.bold(`
 --- Dry run: ${nodePath2} ---
 
@@ -6218,7 +6215,8 @@ function registerImpactCommand(program2) {
         initDebugLog(graph.rootPath, graph.config.debug ?? false);
         if (options.file) {
           const repoRoot = projectRootFromGraph(graph.rootPath);
-          const result = findOwner(graph, repoRoot, options.file.trim());
+          const repoRelative = resolveFileArg(process.cwd(), repoRoot, options.file);
+          const result = findOwner(graph, repoRoot, repoRelative);
           if (!result.nodePath) {
             process.stderr.write(chalk6.red(`${result.file} -> no graph coverage
 `));
@@ -6531,7 +6529,7 @@ function registerFlowsCommand(program2) {
 
 // src/cli/check.ts
 import chalk9 from "chalk";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import path21 from "path";
 function registerCheckCommand(program2) {
   program2.command("check").description("Unified graph gate \u2014 errors, drift, coverage, completeness").action(async () => {
@@ -6542,7 +6540,7 @@ function registerCheckCommand(program2) {
       let gitFiles = null;
       try {
         const projectRoot = path21.dirname(graph.rootPath);
-        const output = execSync("git ls-files .", {
+        const output = execFileSync("git", ["ls-files", "."], {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrisdudek/yg",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "Continuous architecture enforcement for AI-assisted development. Aspects, review, enforcement.",
   "type": "module",
   "bin": {