@chrisdudek/yg 5.2.5 → 5.2.6

package/dist/bin.js

@@ -10084,6 +10084,14 @@ async function parseFile(filePath, content20) {
   }
   return tree;
 }
+async function withParsedFile(filePath, content20, fn) {
+  const tree = await parseFile(filePath, content20);
+  try {
+    return await fn(tree);
+  } finally {
+    tree.delete();
+  }
+}
 
 // src/structure/ctx-parsers.ts
 var ParseAstNotPrewarmedError = class extends Error {
@@ -10706,94 +10714,99 @@ function companionInfra(what, why, next) {
 }
 async function runCompanionHook(params) {
   const { aspectDir, aspectId, nodePath, graph, projectRoot, subjectScope } = params;
+  const ownCache = !params.parseCache;
   const astCache = params.parseCache ?? /* @__PURE__ */ new Map();
   const touchedFiles = [];
-  let mod;
   try {
-    mod = await loadHookModule({
-      aspectDir,
-      projectRoot,
-      filename: "companion.mjs",
-      resolveFailedCode: "COMPANION_LOADER_RESOLVE_FAILED"
-    });
-  } catch (err) {
-    if (err instanceof StructureRunnerError) {
-      return { kind: "infra", messageData: err.messageData };
-    }
-    return companionInfra(
-      `Failed to load companion.mjs for aspect '${aspectId}': ${err.message}`,
-      `The runner dynamically imports the aspect's companion.mjs before resolving companions.`,
-      `Ensure companion.mjs exists at the aspect directory and has no unresolved imports.`
-    );
-  }
-  const fn = mod.companion;
-  if (typeof fn !== "function") {
-    return companionInfra(
-      `companion.mjs does not export a function named 'companion' (aspect '${aspectId}'; got ${typeof fn}).`,
-      `The runner imports the named export 'companion' and calls companion(ctx).`,
-      `Add 'export function companion(ctx) { ... }' to companion.mjs (it may be async).`
-    );
-  }
-  let built;
-  try {
-    built = await buildUnitCtx({ aspectId, nodePath, graph, projectRoot, astCache, touchedFiles, subjectScope });
-  } catch (err) {
-    if (err instanceof StructureRunnerError) {
-      return { kind: "infra", messageData: err.messageData };
+    let mod;
+    try {
+      mod = await loadHookModule({
+        aspectDir,
+        projectRoot,
+        filename: "companion.mjs",
+        resolveFailedCode: "COMPANION_LOADER_RESOLVE_FAILED"
+      });
+    } catch (err) {
+      if (err instanceof StructureRunnerError) {
+        return { kind: "infra", messageData: err.messageData };
+      }
+      return companionInfra(
+        `Failed to load companion.mjs for aspect '${aspectId}': ${err.message}`,
+        `The runner dynamically imports the aspect's companion.mjs before resolving companions.`,
+        `Ensure companion.mjs exists at the aspect directory and has no unresolved imports.`
+      );
     }
-    throw err;
-  }
-  const { ctx, recorder } = built;
-  let out;
-  try {
-    out = await fn(ctx);
-  } catch (err) {
-    if (err instanceof UndeclaredFsReadError || err instanceof UndeclaredGraphReadError || err instanceof ParseAstNotPrewarmedError) {
+    const fn = mod.companion;
+    if (typeof fn !== "function") {
       return companionInfra(
-        `companion.mjs for aspect '${aspectId}' read an undeclared path or node: ${err.message}`,
-        `A companion resolves the prompt only \u2014 it cannot judge code, so an undeclared read is an infrastructure fault, not a code violation.`,
-        `Declare a relation in yg-node.yaml to the node owning that path, or read only relation-reachable files.`
+        `companion.mjs does not export a function named 'companion' (aspect '${aspectId}'; got ${typeof fn}).`,
+        `The runner imports the named export 'companion' and calls companion(ctx).`,
+        `Add 'export function companion(ctx) { ... }' to companion.mjs (it may be async).`
       );
     }
-    return companionInfra(
-      `companion hook threw while resolving companions (aspect '${aspectId}'): ${err.message}`,
-      `${err.stack ?? ""}`,
-      `Fix the bug in companion.mjs, then re-run: yg check --approve`
-    );
-  }
-  if (!Array.isArray(out)) {
-    return companionInfra(
-      `companion.mjs returned ${typeof out}, expected an array of { path: string, label?: string } (aspect '${aspectId}').`,
-      `The runner attaches each returned path to the reviewer prompt; a non-array return cannot be interpreted.`,
-      `Return [] or { path, label? }[] from companion.`
-    );
-  }
-  const descriptors = [];
-  for (const d of out) {
-    if (typeof d !== "object" || d === null || typeof d.path !== "string") {
+    let built;
+    try {
+      built = await buildUnitCtx({ aspectId, nodePath, graph, projectRoot, astCache, touchedFiles, subjectScope });
+    } catch (err) {
+      if (err instanceof StructureRunnerError) {
+        return { kind: "infra", messageData: err.messageData };
+      }
+      throw err;
+    }
+    const { ctx, recorder } = built;
+    let out;
+    try {
+      out = await fn(ctx);
+    } catch (err) {
+      if (err instanceof UndeclaredFsReadError || err instanceof UndeclaredGraphReadError || err instanceof ParseAstNotPrewarmedError) {
+        return companionInfra(
+          `companion.mjs for aspect '${aspectId}' read an undeclared path or node: ${err.message}`,
+          `A companion resolves the prompt only \u2014 it cannot judge code, so an undeclared read is an infrastructure fault, not a code violation.`,
+          `Declare a relation in yg-node.yaml to the node owning that path, or read only relation-reachable files.`
+        );
+      }
       return companionInfra(
-        `companion.mjs returned an entry that is not { path: string, label?: string } (aspect '${aspectId}').`,
-        `Each companion descriptor must carry a string 'path' (and an optional string 'label').`,
-        `Return objects shaped { path: string, label?: string } from companion.`
+        `companion hook threw while resolving companions (aspect '${aspectId}'): ${err.message}`,
+        `${err.stack ?? ""}`,
+        `Fix the bug in companion.mjs, then re-run: yg check --approve`
       );
     }
-    const dd = d;
-    if (dd.label !== void 0 && typeof dd.label !== "string") {
+    if (!Array.isArray(out)) {
       return companionInfra(
-        `companion.mjs returned an entry whose 'label' is not a string (aspect '${aspectId}'; got ${typeof dd.label}).`,
-        `A companion descriptor's optional 'label' is a human tag and must be a string when present.`,
-        `Omit 'label' or set it to a string in companion.`
+        `companion.mjs returned ${typeof out}, expected an array of { path: string, label?: string } (aspect '${aspectId}').`,
+        `The runner attaches each returned path to the reviewer prompt; a non-array return cannot be interpreted.`,
+        `Return [] or { path, label? }[] from companion.`
       );
     }
-    descriptors.push({ path: dd.path, ...dd.label !== void 0 ? { label: dd.label } : {} });
+    const descriptors = [];
+    for (const d of out) {
+      if (typeof d !== "object" || d === null || typeof d.path !== "string") {
+        return companionInfra(
+          `companion.mjs returned an entry that is not { path: string, label?: string } (aspect '${aspectId}').`,
+          `Each companion descriptor must carry a string 'path' (and an optional string 'label').`,
+          `Return objects shaped { path: string, label?: string } from companion.`
+        );
+      }
+      const dd = d;
+      if (dd.label !== void 0 && typeof dd.label !== "string") {
+        return companionInfra(
+          `companion.mjs returned an entry whose 'label' is not a string (aspect '${aspectId}'; got ${typeof dd.label}).`,
+          `A companion descriptor's optional 'label' is a human tag and must be a string when present.`,
+          `Omit 'label' or set it to a string in companion.`
+        );
+      }
+      descriptors.push({ path: dd.path, ...dd.label !== void 0 ? { label: dd.label } : {} });
+    }
+    return {
+      kind: "ok",
+      descriptors,
+      touchedFiles,
+      observations: recorder.snapshot(),
+      observationsTainted: recorder.tainted
+    };
+  } finally {
+    if (ownCache) destroyParseCache(astCache);
   }
-  return {
-    kind: "ok",
-    descriptors,
-    touchedFiles,
-    observations: recorder.snapshot(),
-    observationsTainted: recorder.tainted
-  };
 }
 
 // src/structure/runner.ts
@@ -10951,13 +10964,12 @@ async function resolveSuppressedRangesForPrompt(subjects, aspectId) {
   for (const subject of subjects) {
     const content20 = subject.bytes.toString("utf8");
     const hasGrammar = getLanguageForExtension(extname5(subject.path).toLowerCase()) !== null;
-    let tree;
-    if (hasGrammar) {
-      tree = await parseFile(subject.path, content20);
-    }
     const totalLines = content20.split("\n").length;
-    const all = collectSuppressions(tree, subject.path, totalLines, content20);
-    tree?.delete();
+    const all = hasGrammar ? await withParsedFile(
+      subject.path,
+      content20,
+      (tree) => collectSuppressions(tree, subject.path, totalLines, content20)
+    ) : collectSuppressions(void 0, subject.path, totalLines, content20);
     const ranges = formatSuppressedRangesForAspect(all, aspectId);
     if (ranges.length > 0) {
       byFile.push({ path: subject.path, ranges });
@@ -12144,22 +12156,14 @@ async function runRelationPass(graph, projectRoot, deps) {
     }
   }
   const ownerIndex = buildOwnerIndex(graph.nodes);
-  const parseCache = /* @__PURE__ */ new Map();
-  async function getParsed(record) {
-    if (parseCache.has(record.path)) return parseCache.get(record.path) ?? null;
-    if (!record.language) {
-      parseCache.set(record.path, null);
-      return null;
-    }
-    let parsed;
+  async function parseSingle(record) {
+    if (!record.language) return null;
     try {
       const tree = await parseFile(record.path, record.content);
-      parsed = { path: record.path, content: record.content, tree, language: record.language };
+      return { path: record.path, content: record.content, tree, language: record.language };
     } catch {
-      parsed = null;
+      return null;
     }
-    parseCache.set(record.path, parsed);
-    return parsed;
   }
   const symbolTable = new SymbolTable();
   const recordsByLanguage = /* @__PURE__ */ new Map();
@@ -12183,11 +12187,15 @@ async function runRelationPass(graph, projectRoot, deps) {
     }
     const symbols = [];
     for (const record of records) {
-      const parsed = await getParsed(record);
+      const parsed = await parseSingle(record);
       if (!parsed) continue;
-      for (const decl of extractor.declarations(parsed)) {
-        symbols.push([decl.symbolKey, record.path]);
-        symbolTable.declare(language, decl.symbolKey, record.path);
+      try {
+        for (const decl of extractor.declarations(parsed)) {
+          symbols.push([decl.symbolKey, record.path]);
+          symbolTable.declare(language, decl.symbolKey, record.path);
+        }
+      } finally {
+        parsed.tree.delete();
       }
     }
     const toPersist = { builtFrom, symbols };
@@ -12197,10 +12205,14 @@ async function runRelationPass(graph, projectRoot, deps) {
   const projectGlobalUsings = /* @__PURE__ */ new Set();
   const projectGlobalUsingAliases = /* @__PURE__ */ new Map();
   for (const record of csharpRecords) {
-    const parsed = await getParsed(record);
+    const parsed = await parseSingle(record);
     if (!parsed) continue;
-    for (const prefix of collectGlobalUsings(parsed)) projectGlobalUsings.add(prefix);
-    for (const [name, fqn] of collectGlobalUsingAliases(parsed)) projectGlobalUsingAliases.set(name, fqn);
+    try {
+      for (const prefix of collectGlobalUsings(parsed)) projectGlobalUsings.add(prefix);
+      for (const [name, fqn] of collectGlobalUsingAliases(parsed)) projectGlobalUsingAliases.set(name, fqn);
+    } finally {
+      parsed.tree.delete();
+    }
   }
   const csharpGlobalUsings = [...projectGlobalUsings];
   const csharpGlobalUsingAliases = [...projectGlobalUsingAliases.entries()];
@@ -12235,17 +12247,21 @@ async function runRelationPass(graph, projectRoot, deps) {
       if (!record.language) continue;
       const extractor = deps.extractorFor(record.language);
       if (!extractor) continue;
-      const parsed = await getParsed(record);
+      const parsed = await parseSingle(record);
       if (!parsed) continue;
-      const detected = record.language === "csharp" ? csharpUses(parsed, {
-        projectGlobalUsings: csharpGlobalUsings,
-        projectGlobalUsingAliases: csharpGlobalUsingAliases
-      }) : extractor.uses(parsed);
-      for (const dep of detected) {
-        const ownerNode = resolveCandidateGroup(dep.candidates, resolver, record.path, record.language);
-        if (ownerNode !== void 0) {
-          resolvedDeps.push({ fromFile: record.path, line: dep.line, ownerNode });
+      try {
+        const detected = record.language === "csharp" ? csharpUses(parsed, {
+          projectGlobalUsings: csharpGlobalUsings,
+          projectGlobalUsingAliases: csharpGlobalUsingAliases
+        }) : extractor.uses(parsed);
+        for (const dep of detected) {
+          const ownerNode = resolveCandidateGroup(dep.candidates, resolver, record.path, record.language);
+          if (ownerNode !== void 0) {
+            resolvedDeps.push({ fromFile: record.path, line: dep.line, ownerNode });
+          }
         }
+      } finally {
+        parsed.tree.delete();
       }
     }
     const violations = verifyNodeDeps(nodeId, resolvedDeps, graphView);
@@ -12256,9 +12272,6 @@ async function runRelationPass(graph, projectRoot, deps) {
       violationsByNode.set(nodeId, { verdict: "approved", violations: [] });
     }
   }
-  for (const entry of parseCache.values()) {
-    if (entry) entry.tree.delete();
-  }
   return { violationsByNode };
 }
 
@@ -15818,21 +15831,7 @@ async function runFill(graph, opts) {
 }
 
 // src/cli/check.ts
-import { execFileSync } from "child_process";
 import path48 from "path";
-function collectGitFiles(projectRoot) {
-  try {
-    const output = execFileSync("git", ["ls-files", "."], {
-      cwd: projectRoot,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return output.trim().split("\n").filter((f) => f.length > 0);
-  } catch (e) {
-    debugWrite(`[check] git ls-files failed: ${e instanceof Error ? e.message : String(e)}`);
-    return null;
-  }
-}
 function registerCheckCommand(program2) {
   program2.command("check").description("Unified graph gate \u2014 verification, coverage, completeness").option("--approve", "Fill every unverified pair (deterministic first, then LLM), then report").option("--only-deterministic", "With --approve: fill ONLY deterministic pairs (keyless, free); committed locks stay untouched. For CI and pre-commit.").option("--dry-run", "With --approve: free cost preview \u2014 print the budget + per-node/per-aspect breakdown, then exit 0 WITHOUT writing anything or calling the reviewer.").option("--top [n]", "Read-only triage: print only the N highest-priority issue blocks (bare --top = just the single suggestedNext block). Header counts + exit code stay TRUE.").option("--summary", "Read-only triage: print per-node counts only (no per-issue blocks). Header counts + exit code stay TRUE.").action(async (opts) => {
     try {
@@ -15840,7 +15839,7 @@ function registerCheckCommand(program2) {
       const graph = await loadGraphOrAbort(cwd, { tolerateInvalidConfig: true });
       initDebugLog(graph.rootPath, graph.config.debug ?? false, appendToDebugLog);
       const projectRoot = path48.dirname(graph.rootPath);
-      const gitFiles = collectGitFiles(projectRoot);
+      const gitFiles = await walkRepoFiles(projectRoot);
       const wantsTop = opts.top !== void 0;
       if (wantsTop && opts.summary) {
         process.stderr.write(chalk8.red(buildIssueMessage({
@@ -16259,6 +16258,9 @@ async function runAstAspect(params) {
           next: `Reinstall the CLI.`
         });
       }
+      if (!params.parseCache) {
+        localTrees.push(ast);
+      }
       if (ast.rootNode.hasError) {
         const err = findFirstErrorNode(ast.rootNode);
         throw new AstRunnerError("AST_SOURCE_PARSE_ERROR", {
@@ -16269,8 +16271,6 @@ async function runAstAspect(params) {
       }
       if (params.parseCache) {
         params.parseCache.set(f.path, { content: content20, ast });
-      } else {
-        localTrees.push(ast);
       }
       sourceFiles.push({ path: f.path, content: content20, ast });
     }
@@ -21823,7 +21823,6 @@ function registerSchemasCommand(program2) {
 // src/cli/suppressions.ts
 import chalk14 from "chalk";
 import { readFileSync as readFileSync8, existsSync as existsSync9 } from "fs";
-import { execFileSync as execFileSync2 } from "child_process";
 import path57 from "path";
 function isBinaryContent(buf) {
   const checkLen = Math.min(buf.length, 8192);
@@ -21852,10 +21851,11 @@ async function scanMarkersForFile(relFile, text2) {
     return scanSuppressionMarkers(text2);
   }
   try {
-    const tree = await parseFile(relFile, text2);
-    const result = scanSuppressionMarkersInComments(tree, relFile);
-    tree.delete();
-    return result;
+    return await withParsedFile(
+      relFile,
+      text2,
+      (tree) => scanSuppressionMarkersInComments(tree, relFile)
+    );
   } catch (error) {
     debugWrite(`[suppressions] parse fallback (raw scan): ${relFile}: ${error instanceof Error ? error.message : String(error)}`);
     return scanSuppressionMarkers(text2);
@@ -21974,17 +21974,7 @@ function registerSuppressionsCommand(program2) {
       const graph = await loadGraphOrAbort(cwd);
       initDebugLog(graph.rootPath, graph.config.debug ?? false, appendToDebugLog);
       const projectRoot = path57.dirname(graph.rootPath);
-      let gitFiles = [];
-      try {
-        const output = execFileSync2("git", ["ls-files", "."], {
-          cwd: projectRoot,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        gitFiles = output.trim().split("\n").filter((f) => f.length > 0);
-      } catch (error) {
-        debugWrite(`[suppressions] git ls-files fallback: ${error instanceof Error ? error.message : String(error)}`);
-      }
+      const gitFiles = await walkRepoFiles(projectRoot);
       const knownAspectIds = new Set(graph.aspects.map((a) => a.id));
       const report2 = await runSuppressionsScan(projectRoot, gitFiles, knownAspectIds);
       process.stdout.write(formatSuppressionsOutput(report2));

package/dist/structure.js

@@ -606,6 +606,14 @@ async function parseFile(filePath, content) {
   }
   return tree;
 }
+async function withParsedFile(filePath, content, fn) {
+  const tree = await parseFile(filePath, content);
+  try {
+    return await fn(tree);
+  } finally {
+    tree.delete();
+  }
+}
 
 // src/structure/ctx-parsers.ts
 var ParseAstNotPrewarmedError = class extends Error {
@@ -1599,13 +1607,12 @@ async function resolveSuppressedRangesForPrompt(subjects, aspectId) {
   for (const subject of subjects) {
     const content = subject.bytes.toString("utf8");
     const hasGrammar = getLanguageForExtension(extname5(subject.path).toLowerCase()) !== null;
-    let tree;
-    if (hasGrammar) {
-      tree = await parseFile(subject.path, content);
-    }
     const totalLines = content.split("\n").length;
-    const all = collectSuppressions(tree, subject.path, totalLines, content);
-    tree?.delete();
+    const all = hasGrammar ? await withParsedFile(
+      subject.path,
+      content,
+      (tree) => collectSuppressions(tree, subject.path, totalLines, content)
+    ) : collectSuppressions(void 0, subject.path, totalLines, content);
     const ranges = formatSuppressedRangesForAspect(all, aspectId);
     if (ranges.length > 0) {
       byFile.push({ path: subject.path, ranges });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrisdudek/yg",
-  "version": "5.2.5",
+  "version": "5.2.6",
   "description": "Architecture rules your AI coding agent can't ignore. It gets the rules for a file before it edits, and every change is checked — by a free local script or an LLM reviewer — before it moves on. Works with Claude Code, Cursor, Copilot, Codex, Cline.",
   "type": "module",
   "bin": {