@chrisdudek/yg 4.0.0 → 4.0.1

package/dist/bin.js

@@ -3891,6 +3891,158 @@ function registerOwnerCommand(program2) {
   });
 }
 
+// src/utils/hash.ts
+import { readFile as readFile14, readdir as readdir6, stat as stat5 } from "fs/promises";
+import path15 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(path15.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 = path15.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 = path15.join(projectRoot, tf.path);
+    try {
+      const st = await stat5(absPath);
+      if (st.isDirectory()) {
+        const dirEntries = await collectDirectoryFilePaths(absPath, absPath, {
+          projectRoot,
+          gitignoreStack
+        });
+        for (const entry of dirEntries) {
+          allFiles.push({
+            relPath: path15.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(path15.join(directoryPath, ".gitignore"), "utf-8");
+    const localMatcher = ignoreFactory();
+    localMatcher.add(localContent);
+    stack = [...stack, { basePath: directoryPath, matcher: localMatcher }];
+  } catch {
+  }
+  const entries = await readdir6(directoryPath, { withFileTypes: true });
+  const dirs = [];
+  const files = [];
+  for (const entry of entries) {
+    const absoluteChildPath = path15.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 stat5(f);
+      return {
+        relPath: path15.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 = path15.join(projectRoot, mp);
+    try {
+      const st = await stat5(absPath);
+      if (st.isDirectory()) {
+        const dirEntries = await collectDirectoryFilePaths(absPath, absPath, {
+          projectRoot,
+          gitignoreStack
+        });
+        for (const entry of dirEntries) {
+          result.push(path15.join(mp, entry.relPath).replace(/\\/g, "/").replace(/\/+$/, ""));
+        }
+      } else {
+        result.push(mp);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return result;
+}
+
 // src/cli/build-context.ts
 function findCandidateNodes(graph, unmappedFile) {
   const dir = unmappedFile.replace(/\/[^/]+$/, "");
@@ -4024,17 +4176,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 +4199,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 stat6, 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 +4230,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 +4249,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 +4259,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,10 +4278,10 @@ 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);
+    driftStat = await stat6(driftPath);
   } catch (err) {
     debugWrite(`[drift-state-store] readDriftState stat: ${err.message}`);
     return {};
@@ -4152,134 +4301,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 +5781,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} ---
 
@@ -6531,7 +6551,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 +6562,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.1",
   "description": "Continuous architecture enforcement for AI-assisted development. Aspects, review, enforcement.",
   "type": "module",
   "bin": {