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

package/dist/structure.js

@@ -1,6 +1,6 @@
 // src/structure/runner.ts
 import * as fs4 from "fs";
-import * as path6 from "path";
+import * as path8 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/ast/loader-hook.ts
@@ -36,12 +36,15 @@ function normalizeMappingPath(p) {
 function toPosix(p) {
   return p.replace(/\\/g, "/");
 }
+function toPosixPath(p) {
+  return p.replace(/\\/g, "/").replace(/\/+$/, "");
+}
 
 // src/structure/ctx-fs.ts
 var UndeclaredFsReadError = class extends Error {
-  constructor(path7) {
-    super(`structure-aspect-undeclared-fs-read: ${path7}`);
-    this.path = path7;
+  constructor(path9) {
+    super(`structure-aspect-undeclared-fs-read: ${path9}`);
+    this.path = path9;
     this.name = "UndeclaredFsReadError";
   }
 };
@@ -101,8 +104,8 @@ function createCtxFs(params) {
       const p = assertAllowed(raw);
       const abs = path2.resolve(projectRoot, p);
       try {
-        const stat = fs.statSync(abs);
-        return stat.isDirectory() ? "dir" : stat.isFile() ? "file" : false;
+        const stat2 = fs.statSync(abs);
+        return stat2.isDirectory() ? "dir" : stat2.isFile() ? "file" : false;
       } catch {
         return false;
       }
@@ -127,6 +130,21 @@ function createCtxFs(params) {
 // src/structure/ctx-graph.ts
 import * as fs2 from "fs";
 import * as path3 from "path";
+
+// src/structure/expand-mapping-sync.ts
+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;
+}
+
+// src/structure/ctx-graph.ts
 var UndeclaredGraphReadError = class extends Error {
   constructor(nodePath) {
     super(`structure-aspect-undeclared-graph-read: ${nodePath}`);
@@ -175,8 +193,8 @@ function createCtxGraph(params) {
       if (!p) continue;
       const abs = path3.resolve(projectRoot, p);
       try {
-        const stat = fs2.statSync(abs);
-        if (stat.isFile()) {
+        const stat2 = fs2.statSync(abs);
+        if (stat2.isFile()) {
           const content = fs2.readFileSync(abs, "utf8");
           files.push({ path: p, content });
           touchedFiles.push(p);
@@ -665,6 +683,144 @@ function collectAllowedReadsForAspect(nodePath, graph) {
   return allowed;
 }
 
+// src/io/hash.ts
+import { readFile as readFile2, readdir as readdir2, stat } from "fs/promises";
+import path7 from "path";
+import { createHash } from "crypto";
+import { createRequire as createRequire3 } from "module";
+
+// src/io/repo-scanner.ts
+import { readFile, readdir } from "fs/promises";
+import { join, relative as relative2, sep } from "path";
+import { createRequire as createRequire2 } from "module";
+
+// src/utils/debug-log.ts
+import path6 from "path";
+
+// src/io/repo-scanner.ts
+var require2 = createRequire2(import.meta.url);
+var ignoreFactory = require2("ignore");
+
+// src/io/hash.ts
+var require3 = createRequire3(import.meta.url);
+var ignoreFactory2 = require3("ignore");
+async function loadRootGitignoreStack2(projectRoot) {
+  if (!projectRoot) return [];
+  try {
+    const content = await readFile2(path7.join(projectRoot, ".gitignore"), "utf-8");
+    const matcher = ignoreFactory2();
+    matcher.add(content);
+    return [{ basePath: projectRoot, matcher }];
+  } catch {
+    return [];
+  }
+}
+function isIgnoredByStack2(candidatePath, stack) {
+  for (const { basePath, matcher } of stack) {
+    const relativePath = toPosix(path7.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");
+}
+var EMPTY_IDENTITY = { ownSubset: hashString(""), ports: {}, aspects: {} };
+async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, options) {
+  let stack = options.gitignoreStack ?? [];
+  try {
+    const localContent = await readFile2(path7.join(directoryPath, ".gitignore"), "utf-8");
+    const localMatcher = ignoreFactory2();
+    localMatcher.add(localContent);
+    stack = [...stack, { basePath: directoryPath, matcher: localMatcher }];
+  } catch {
+  }
+  const entries = await readdir2(directoryPath, { withFileTypes: true });
+  const dirs = [];
+  const files = [];
+  for (const entry of entries) {
+    const absoluteChildPath = path7.join(directoryPath, entry.name);
+    if (isIgnoredByStack2(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 stat(f);
+      return {
+        relPath: toPosixPath(path7.relative(rootDirectoryPath, f)),
+        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 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)));
+        }
+      } else {
+        result.push(toPosixPath(mp));
+      }
+    } catch {
+      continue;
+    }
+  }
+  return result;
+}
+
+// src/ast/suppress.ts
+import { extname as extname3 } from "path";
+
+// src/ast/find-comments.ts
+import { extname as extname2 } from "path";
+function findComments(target) {
+  const hasAst = "ast" in target;
+  const hasRootNode = "rootNode" in target;
+  if (hasAst && hasRootNode) {
+    throw new Error("AST_FINDCOMMENTS_AMBIGUOUS_TARGET: pass either ast or rootNode, not both");
+  }
+  let language = "language" in target ? target.language : void 0;
+  if (language === void 0 && "path" in target) {
+    language = getLanguageForExtension(extname2(target.path)) ?? void 0;
+  }
+  if (language === void 0) {
+    throw new Error(
+      "AST_FINDCOMMENTS_NO_LANGUAGE: pass a SourceFile whose path has a known extension, or an explicit { language }"
+    );
+  }
+  const def = LANGUAGES[language];
+  if (def === void 0) {
+    throw new Error(`AST_FINDCOMMENTS_UNKNOWN_LANGUAGE: '${language}' not in registry`);
+  }
+  const root = hasAst ? target.ast.rootNode : target.rootNode;
+  const out = [];
+  for (const type of def.commentTypes) {
+    out.push(...root.descendantsOfType(type));
+  }
+  return out;
+}
+
 // src/ast/suppress.ts
 var SuppressMarkerError = class extends Error {
   constructor(message, file, line) {
@@ -711,7 +867,10 @@ function parseMarker(commentText, line, file) {
   return null;
 }
 function collectSuppressions(tree, file, totalLines) {
-  const comments = tree.rootNode.descendantsOfType("comment");
+  if (getLanguageForExtension(extname3(file)) === null) {
+    return [];
+  }
+  const comments = findComments({ path: file, ast: tree });
   const markers = [];
   for (const c of comments) {
     const m = parseMarker(c.text, c.startPosition.row + 1, file);
@@ -827,64 +986,64 @@ ${data.next}`);
   }
   messageData;
 };
-function buildOwnFiles(node, projectRoot, touchedFiles) {
-  const childMappings = /* @__PURE__ */ new Set();
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".gif",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".webp",
+  ".bmp",
+  ".ico",
+  ".svgz",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".zip",
+  ".gz",
+  ".tgz",
+  ".tar",
+  ".bz2",
+  ".7z",
+  ".pdf",
+  ".mp4",
+  ".mov",
+  ".webm",
+  ".mp3",
+  ".wav",
+  ".wasm",
+  ".bin"
+]);
+async function buildOwnFiles(node, projectRoot, touchedFiles) {
+  const childMappingEntries = [];
   for (const child of node.children) {
     for (const raw of child.meta.mapping ?? []) {
       const p = normalizeMappingPath(raw);
-      if (p) childMappings.add(p);
+      if (p) childMappingEntries.push(p);
     }
   }
+  const rawMapping = (node.meta.mapping ?? []).map(normalizeMappingPath).filter((p) => p !== "");
+  const expanded = await expandMappingPaths(projectRoot, rawMapping);
   const result = [];
-  for (const raw of node.meta.mapping ?? []) {
-    const p = normalizeMappingPath(raw);
-    if (!p || childMappings.has(p)) continue;
-    const abs = path6.resolve(projectRoot, p);
+  for (const p of expanded) {
+    if (childMappingEntries.length > 0 && isPathInMapping(p, childMappingEntries)) continue;
+    if (BINARY_EXTENSIONS.has(path8.extname(p).toLowerCase())) continue;
+    const abs = path8.resolve(projectRoot, p);
+    let content;
     try {
-      const stat = fs4.statSync(abs);
-      if (stat.isFile()) {
-        const content = fs4.readFileSync(abs, "utf8");
-        result.push({ path: p, content });
-        touchedFiles.push(p);
-      }
+      content = fs4.readFileSync(abs, "utf8");
     } catch {
+      continue;
     }
+    result.push({ path: p, content });
+    touchedFiles.push(p);
   }
   return result;
 }
-function enumerateMappedFilesSync(mappingPaths, projectRoot) {
-  const out = [];
-  for (const raw of mappingPaths) {
-    const rel = normalizeMappingPath(raw);
-    if (!rel) continue;
-    const abs = path6.resolve(projectRoot, rel);
-    try {
-      const stat = fs4.statSync(abs);
-      if (stat.isFile()) {
-        out.push(rel);
-      } else if (stat.isDirectory()) {
-        for (const sub of walkDirSync(abs)) {
-          const relSub = path6.relative(projectRoot, sub).split(/[\\/]/).join("/");
-          out.push(relSub);
-        }
-      }
-    } catch {
-    }
-  }
-  return out;
-}
-function* walkDirSync(dir) {
-  let entries;
-  try {
-    entries = fs4.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const e of entries) {
-    const child = path6.join(dir, e.name);
-    if (e.isDirectory()) yield* walkDirSync(child);
-    else if (e.isFile()) yield child;
-  }
+async function enumerateMappedFilesAsync(mappingPaths, projectRoot) {
+  const normalized = mappingPaths.map(normalizeMappingPath).filter((p) => p !== "");
+  return expandMappingPaths(projectRoot, normalized);
 }
 async function runStructureAspect(params) {
   ensureLoaderRegistered();
@@ -899,8 +1058,8 @@ async function runStructureAspect(params) {
       next: `Pass an existing node path, or add the node to the graph.`
     });
   }
-  const aspectDirAbs = path6.isAbsolute(aspectDir) ? aspectDir : path6.resolve(projectRoot, aspectDir);
-  const checkPath = path6.join(aspectDirAbs, "check.mjs");
+  const aspectDirAbs = path8.isAbsolute(aspectDir) ? aspectDir : path8.resolve(projectRoot, aspectDir);
+  const checkPath = path8.join(aspectDirAbs, "check.mjs");
   let mod;
   try {
     mod = await import(pathToFileURL2(checkPath).href);
@@ -923,7 +1082,7 @@ async function runStructureAspect(params) {
   const ctxFs = createCtxFs({ allowedSet, projectRoot, touchedFiles });
   const ctxGraph = createCtxGraph({ currentNodePath: nodePath, graph, projectRoot, touchedFiles });
   const parsers = createCtxParsers({ allowedSet, projectRoot, touchedFiles, astCache });
-  const ownFiles = buildOwnFiles(node, projectRoot, touchedFiles);
+  const ownFiles = await buildOwnFiles(node, projectRoot, touchedFiles);
   await prewarmupAstCache({ astCache, projectRoot, files: ownFiles });
   const ownFilesEnriched = enrichFilesWithAst(ownFiles, astCache);
   const ctx = {
@@ -946,8 +1105,8 @@ async function runStructureAspect(params) {
   for (const rel of node.meta.relations ?? []) {
     const target = graph.nodes.get(rel.target);
     if (!target) continue;
-    for (const p of enumerateMappedFilesSync(target.meta.mapping ?? [], projectRoot)) {
-      const abs = path6.resolve(projectRoot, p);
+    for (const p of await enumerateMappedFilesAsync(target.meta.mapping ?? [], projectRoot)) {
+      const abs = path8.resolve(projectRoot, p);
       try {
         const content = fs4.readFileSync(abs, "utf8");
         astInputSet.push({ path: p, content });
@@ -1090,35 +1249,6 @@ function inFile(file, pattern) {
   if ("contains" in pattern) return file.path.includes(pattern.contains);
   return false;
 }
-
-// src/ast/find-comments.ts
-import { extname as extname2 } from "path";
-function findComments(target) {
-  const hasAst = "ast" in target;
-  const hasRootNode = "rootNode" in target;
-  if (hasAst && hasRootNode) {
-    throw new Error("AST_FINDCOMMENTS_AMBIGUOUS_TARGET: pass either ast or rootNode, not both");
-  }
-  let language = "language" in target ? target.language : void 0;
-  if (language === void 0 && "path" in target) {
-    language = getLanguageForExtension(extname2(target.path)) ?? void 0;
-  }
-  if (language === void 0) {
-    throw new Error(
-      "AST_FINDCOMMENTS_NO_LANGUAGE: pass a SourceFile whose path has a known extension, or an explicit { language }"
-    );
-  }
-  const def = LANGUAGES[language];
-  if (def === void 0) {
-    throw new Error(`AST_FINDCOMMENTS_UNKNOWN_LANGUAGE: '${language}' not in registry`);
-  }
-  const root = hasAst ? target.ast.rootNode : target.rootNode;
-  const out = [];
-  for (const type of def.commentTypes) {
-    out.push(...root.descendantsOfType(type));
-  }
-  return out;
-}
 export {
   StructureRunnerError,
   closest,

package/graph-schemas/yg-aspect.yaml

@@ -15,16 +15,35 @@ name: CrossCuttingRequirementName  # required — display name
 description: "Short description"   # required — shown in yg aspects output and context packages.
                                    # Validator emits description-missing if absent.
 
-reviewer:                          # required — which reviewer verifies this aspect
-  type: llm                        #   required: 'llm' or 'deterministic'
-                                   #     llm           — aspect ships content.md; an LLM reads it and judges the code.
-                                   #     deterministic — aspect ships check.mjs; the structure runner executes it
-                                   #                     locally with graph-aware ctx (files, fs, graph, parsers).
-                                   #                     Language-agnostic. No LLM call, zero token cost.
-  # tier: deep                     #   optional, only when type: llm.
+# reviewer:                        # OPTIONAL — reviewer kind is inferred from rule-file presence:
+                                   #
+                                   #   content.md present          → llm
+                                   #   check.mjs present           → deterministic
+                                   #   neither + implies declared  → aggregate
+                                   #
+                                   # The reviewer: block is only required when you need to declare
+                                   # reviewer.tier: for an LLM aspect. When present, an explicit
+                                   # reviewer.type must agree with the inferred kind (validator
+                                   # error otherwise).
+                                   #
+                                   # Three kinds:
+                                   #   llm           — aspect ships content.md; an LLM reads it and
+                                   #                   judges the code against the rule.
+                                   #   deterministic — aspect ships check.mjs; the runner executes it
+                                   #                   locally with graph-aware ctx (files, fs, graph,
+                                   #                   parsers). Language-agnostic. No LLM call, zero
+                                   #                   token cost.
+                                   #   aggregate     — aspect ships neither rule source but declares
+                                   #                   implies:. A named bundle — expands its implied
+                                   #                   aspects onto every node where effective. Has no
+                                   #                   own reviewer and produces no own verdict. An
+                                   #                   aspect with neither rule source and no implies:
+                                   #                   is rejected (aspect-empty).
+  # type: llm                      #   optional; must be 'llm', 'deterministic', or 'aggregate' if set.
+  # tier: deep                     #   optional, only when type: llm (or inferred llm).
                                    #     If omitted, the aspect uses reviewer.default from yg-config.yaml.
                                    #     If present, must reference a key under reviewer.tiers in the config.
-                                   #     Forbidden when type is 'deterministic'.
+                                   #     Forbidden when type is 'deterministic' or 'aggregate'.
 
 status: enforced                   # optional — aspect-level default. enum: draft | advisory | enforced.
                                    # Absent → 'enforced'.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrisdudek/yg",
-  "version": "5.0.0-alpha.1",
+  "version": "5.0.0-alpha.2",
   "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": {
@@ -10,6 +10,7 @@
     "dist/**/*.js",
     "dist/**/*.d.ts",
     "dist/**/*.wasm",
+    "dist/**/*.node-types.json",
     "graph-schemas/"
   ],
   "engines": {
@@ -87,7 +88,7 @@
     "@tree-sitter-grammars/tree-sitter-yaml": "^0.7.1",
     "@types/node": "^25.9.1",
     "@types/semver": "^7.7.1",
-    "@vitest/coverage-v8": "^4.1.7",
+    "@vitest/coverage-v8": "^4.1.8",
     "eslint": "^10.4.1",
     "prettier": "^3.8.3",
     "tree-sitter-c": "^0.24.1",
@@ -105,6 +106,6 @@
     "tsup": "^8.5.1",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.60.0",
-    "vitest": "^4.1.7"
+    "vitest": "^4.1.8"
   }
 }