@chrisdudek/yg 5.0.0-alpha.2 → 5.0.0-alpha.4

package/dist/structure.d.ts

@@ -158,6 +158,12 @@ interface ReviewerConfig {
     /** At least one entry required; key is the tier name */
     tiers: Record<string, LlmConfig>;
 }
+interface CoverageConfig {
+    /** Roots (POSIX, from repo root; "/" = whole repo) where an uncovered file is an error. */
+    required: string[];
+    /** Roots where an uncovered file is silent (no issue). */
+    excluded: string[];
+}
 interface YggConfig {
     version?: string;
     quality?: QualityConfig;
@@ -167,6 +173,8 @@ interface YggConfig {
     reviewer?: ReviewerConfig;
     parallel?: number;
     debug?: boolean;
+    /** Coverage scope. Absent ⇒ DEFAULT_COVERAGE (whole repo required = today's behavior). */
+    coverage?: CoverageConfig;
 }
 interface ArchitectureNodeType {
     description: string;

package/dist/structure.js

@@ -28,9 +28,23 @@ import * as fs from "fs";
 import * as path2 from "path";
 
 // src/utils/mapping-path.ts
+import { minimatch } from "minimatch";
 function normalizeMappingPath(p) {
   return p.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
 }
+function isGlobPattern(entry) {
+  return entry.includes("*");
+}
+function globMatch(file, pattern) {
+  return minimatch(file, pattern, { dot: true });
+}
+function mappingEntryMatchesFile(entry, file) {
+  const e = normalizeMappingPath(entry);
+  const f = normalizeMappingPath(file);
+  if (e === "") return false;
+  if (isGlobPattern(e)) return globMatch(f, e);
+  return f === e || f.startsWith(e + "/");
+}
 
 // src/utils/posix.ts
 function toPosix(p) {
@@ -52,9 +66,8 @@ function isAllowed(p, set) {
   if (p === "") return false;
   if (set.has(p)) return true;
   for (const a of set) {
-    if (a === p) return true;
     if (a.startsWith(p + "/")) return true;
-    if (p.startsWith(a + "/")) return true;
+    if (mappingEntryMatchesFile(a, p)) return true;
   }
   return false;
 }
@@ -135,13 +148,7 @@ import * as path3 from "path";
 function isPathInMapping(candidate, mapping) {
   const c = normalizeMappingPath(candidate);
   if (c === "") return false;
-  for (const raw of mapping) {
-    const n = normalizeMappingPath(raw);
-    if (n === "") continue;
-    if (c === n) return true;
-    if (c.startsWith(n + "/")) return true;
-  }
-  return false;
+  return mapping.some((raw) => mappingEntryMatchesFile(raw, c));
 }
 
 // src/structure/ctx-graph.ts
@@ -181,15 +188,16 @@ function computeAllowedNodePaths(currentPath, graph) {
   return allowed;
 }
 function createCtxGraph(params) {
-  const { currentNodePath, graph, projectRoot, touchedFiles } = params;
+  const { currentNodePath, graph, projectRoot, touchedFiles, expandedFilesByNode } = params;
   const allowed = computeAllowedNodePaths(currentNodePath, graph);
   function assertAllowed(id) {
     if (!allowed.has(id)) throw new UndeclaredGraphReadError(id);
   }
   function toPublicNode(m) {
     const files = [];
-    for (const raw of m.meta.mapping ?? []) {
-      const p = normalizeMappingPath(raw);
+    const preExpanded = expandedFilesByNode?.get(m.path);
+    const candidatePaths = preExpanded ?? (m.meta.mapping ?? []).map(normalizeMappingPath);
+    for (const p of candidatePaths) {
       if (!p) continue;
       const abs = path3.resolve(projectRoot, p);
       try {
@@ -500,12 +508,16 @@ var GRAMMAR_DIRS = [
   path4.resolve(__dirname2, "grammars"),
   path4.resolve(__dirname2, "..", "grammars")
 ];
-var initialized = false;
+var initPromise = null;
 var langCache = /* @__PURE__ */ new Map();
-async function init() {
-  if (initialized) return;
-  await Parser.init();
-  initialized = true;
+function init() {
+  if (initPromise === null) {
+    initPromise = Parser.init();
+    initPromise.catch(() => {
+      initPromise = null;
+    });
+  }
+  return initPromise;
 }
 function resolveWasm(filename, pkg) {
   for (const dir of GRAMMAR_DIRS) {
@@ -528,12 +540,16 @@ async function getParser(extension) {
     throw new Error(`no parser for extension '${extension}'`);
   }
   const cacheKey = info.wasmFile;
-  let lang = langCache.get(cacheKey);
-  if (!lang) {
+  let langP = langCache.get(cacheKey);
+  if (langP === void 0) {
     const wasmPath = resolveWasm(info.wasmFile, info.wasmPackage);
-    lang = await Language.load(wasmPath);
-    langCache.set(cacheKey, lang);
+    langP = Language.load(wasmPath);
+    langCache.set(cacheKey, langP);
+    langP.catch(() => {
+      if (langCache.get(cacheKey) === langP) langCache.delete(cacheKey);
+    });
   }
+  const lang = await langP;
   const parser = new Parser();
   parser.setLanguage(lang);
   return parser;
@@ -764,26 +780,50 @@ async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, optio
   result.push(...fileStats);
   return result;
 }
+async function expandGlobEntry(projectRoot, glob, gitignoreStack) {
+  const segments = glob.split("/");
+  const firstGlobIdx = segments.findIndex((s) => isGlobPattern(s));
+  const baseSegments = firstGlobIdx > 0 ? segments.slice(0, firstGlobIdx) : [];
+  const baseDir = baseSegments.length > 0 ? path7.join(projectRoot, ...baseSegments) : projectRoot;
+  try {
+    const dirEntries = await collectDirectoryFilePaths(baseDir, projectRoot, {
+      projectRoot,
+      gitignoreStack
+    });
+    return dirEntries.filter((entry) => globMatch(entry.relPath, glob)).map((entry) => ({
+      relPath: toPosixPath(entry.relPath),
+      absPath: entry.absPath,
+      mtimeMs: entry.mtimeMs
+    }));
+  } catch {
+    return [];
+  }
+}
 async function expandMappingPaths(projectRoot, mappingPaths) {
   const gitignoreStack = await loadRootGitignoreStack2(projectRoot);
   const result = [];
   for (const mp of mappingPaths) {
-    const absPath = path7.join(projectRoot, mp);
-    try {
-      const st = await stat(absPath);
-      if (st.isDirectory()) {
-        const dirEntries = await collectDirectoryFilePaths(absPath, absPath, {
-          projectRoot,
-          gitignoreStack
-        });
-        for (const entry of dirEntries) {
-          result.push(toPosixPath(path7.join(mp, entry.relPath)));
+    if (isGlobPattern(mp)) {
+      const entries = await expandGlobEntry(projectRoot, mp, gitignoreStack);
+      for (const entry of entries) result.push(entry.relPath);
+    } else {
+      const absPath = path7.join(projectRoot, mp);
+      try {
+        const st = await stat(absPath);
+        if (st.isDirectory()) {
+          const dirEntries = await collectDirectoryFilePaths(absPath, absPath, {
+            projectRoot,
+            gitignoreStack
+          });
+          for (const entry of dirEntries) {
+            result.push(toPosixPath(path7.join(mp, entry.relPath)));
+          }
+        } else {
+          result.push(toPosixPath(mp));
         }
-      } else {
-        result.push(toPosixPath(mp));
+      } catch {
+        continue;
       }
-    } catch {
-      continue;
     }
   }
   return result;
@@ -831,8 +871,8 @@ var SuppressMarkerError = class extends Error {
   }
   code = "SUPPRESS_MARKER_MISSING_REASON";
 };
-var RE_SINGLE = /\byg-suppress\(\s*([^)]+?)\s*\)\s*(.+)?$/;
-var RE_DISABLE = /\byg-suppress-disable\(\s*([^)]+?)\s*\)\s*(.+)?$/;
+var RE_SINGLE = /\byg-suppress\(\s*([^)]+?)\s*\)\s*(.+)?$/m;
+var RE_DISABLE = /\byg-suppress-disable\(\s*([^)]+?)\s*\)\s*(.+)?$/m;
 var RE_ENABLE = /\byg-suppress-enable\(\s*([^)]+?)\s*\)/;
 function commentBody(text) {
   if (text.startsWith("//")) return text.slice(2).trim();
@@ -866,15 +906,23 @@ function parseMarker(commentText, line, file) {
   if (m) return makeMarker("single", m, line, file);
   return null;
 }
-function collectSuppressions(tree, file, totalLines) {
-  if (getLanguageForExtension(extname3(file)) === null) {
-    return [];
-  }
-  const comments = findComments({ path: file, ast: tree });
+function collectSuppressions(tree, file, totalLines, content) {
+  const hasGrammar = getLanguageForExtension(extname3(file)) !== null;
   const markers = [];
-  for (const c of comments) {
-    const m = parseMarker(c.text, c.startPosition.row + 1, file);
-    if (m) markers.push(m);
+  if (hasGrammar && tree) {
+    const comments = findComments({ path: file, ast: tree });
+    for (const c of comments) {
+      const m = parseMarker(c.text, c.startPosition.row + 1, file);
+      if (m) markers.push(m);
+    }
+  } else if (content !== void 0) {
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const m = parseMarker(lines[i], i + 1, file);
+      if (m) markers.push(m);
+    }
+  } else {
+    return [];
   }
   markers.sort((a, b) => a.line - b.line);
   const ranges = [];
@@ -1080,7 +1128,12 @@ async function runStructureAspect(params) {
   const checkFn = mod.check;
   const allowedSet = collectAllowedReadsForAspect(nodePath, graph);
   const ctxFs = createCtxFs({ allowedSet, projectRoot, touchedFiles });
-  const ctxGraph = createCtxGraph({ currentNodePath: nodePath, graph, projectRoot, touchedFiles });
+  const expandedFilesByNode = /* @__PURE__ */ new Map();
+  for (const id of computeAllowedNodePaths(nodePath, graph)) {
+    const m = graph.nodes.get(id);
+    if (m) expandedFilesByNode.set(id, await enumerateMappedFilesAsync(m.meta.mapping ?? [], projectRoot));
+  }
+  const ctxGraph = createCtxGraph({ currentNodePath: nodePath, graph, projectRoot, touchedFiles, expandedFilesByNode });
   const parsers = createCtxParsers({ allowedSet, projectRoot, touchedFiles, astCache });
   const ownFiles = await buildOwnFiles(node, projectRoot, touchedFiles);
   await prewarmupAstCache({ astCache, projectRoot, files: ownFiles });
@@ -1194,12 +1247,22 @@ ${err.stack ?? ""}`,
     }
     violations.push(vv);
   }
+  const contentByPath = /* @__PURE__ */ new Map();
+  for (const f of [...ownFiles, ...astInputSet]) {
+    contentByPath.set(normalizeMappingPath(f.path), f.content);
+  }
   const rangesByFile = /* @__PURE__ */ new Map();
   function rangesFor(filePath) {
     const existing = rangesByFile.get(filePath);
     if (existing !== void 0) return existing;
     const cached = astCache.get(filePath);
-    const ranges = cached ? collectSuppressions(cached.ast, filePath, cached.content.split("\n").length) : null;
+    let ranges;
+    if (cached) {
+      ranges = collectSuppressions(cached.ast, filePath, cached.content.split("\n").length, cached.content);
+    } else {
+      const content = contentByPath.get(filePath);
+      ranges = content !== void 0 ? collectSuppressions(void 0, filePath, content.split("\n").length, content) : null;
+    }
     rangesByFile.set(filePath, ranges);
     return ranges;
   }
@@ -1242,9 +1305,8 @@ function report(file, node, message) {
 }
 
 // src/ast/file-path.ts
-import { minimatch } from "minimatch";
 function inFile(file, pattern) {
-  if ("glob" in pattern) return minimatch(file.path, pattern.glob);
+  if ("glob" in pattern) return globMatch(file.path, pattern.glob);
   if ("regex" in pattern) return pattern.regex.test(file.path);
   if ("contains" in pattern) return file.path.includes(pattern.contains);
   return false;

package/graph-schemas/yg-architecture.yaml

@@ -10,7 +10,7 @@
 node_types:
   <type-id>:
     description: <string>                    # required — what this type is for, when to use it.
-                                             # Validator emits description-missing if absent.
+                                             # absence is a FATAL architecture-invalid error (the whole type system is rejected).
 
     when: <file-predicate>                   # optional — per-file classification.
                                              # Types WITH `when` are file-classifying: every file in

package/graph-schemas/yg-config.yaml

@@ -14,6 +14,12 @@ parallel: 1                       # optional — concurrency limit for batch app
 debug: false                      # optional — when true, appends all command output to .yggdrasil/.debug.log
                                   # Default: false (off). Log is append-only; rotate or delete manually.
 
+coverage:                         # optional — scopes the unmapped-files gate. Absent = whole repo required (today's behavior).
+  required: ["/"]                 #   roots where an uncovered tracked file is an ERROR (blocks). "/" = whole repo.
+  excluded: []                    #   roots where an uncovered file is SILENT (no warning).
+                                  # Files outside required and excluded are a non-blocking WARNING.
+                                  # Subtrees containing their own nested .yggdrasil/ are auto-skipped by every check.
+
 reviewer:                         # required — aspect verification during yg approve
   default: standard               # required when more than one tier is configured; optional with exactly one tier.
                                   #   Must reference one of the keys under reviewer.tiers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrisdudek/yg",
-  "version": "5.0.0-alpha.2",
+  "version": "5.0.0-alpha.4",
   "description": "Architecture rules your coding agent can't ignore. Written in Markdown, verified on every change, enforced in the agent's loop — not after on a PR. Works with Claude Code, Cursor, Copilot, Codex, Cline.",
   "type": "module",
   "bin": {