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

package/dist/bin.js

@@ -570,9 +570,25 @@ async function collectFiles(dir, projectRoot, stack) {
   }
   return results;
 }
+function excludeNestedGraphSubtrees(relPaths) {
+  const seg = `/${YGGDRASIL_DIRNAME}/`;
+  const nestedRoots = /* @__PURE__ */ new Set();
+  for (const p2 of relPaths) {
+    const idx = p2.indexOf(seg);
+    if (idx > 0) nestedRoots.add(p2.slice(0, idx));
+  }
+  if (nestedRoots.size === 0) return relPaths;
+  return relPaths.filter((p2) => {
+    for (const root of nestedRoots) {
+      if (p2 === root || p2.startsWith(root + "/")) return false;
+    }
+    return true;
+  });
+}
 async function walkRepoFiles(projectRoot) {
   const stack = await loadRootGitignoreStack(projectRoot);
-  return collectFiles(projectRoot, projectRoot, stack);
+  const files = await collectFiles(projectRoot, projectRoot, stack);
+  return excludeNestedGraphSubtrees(files);
 }
 var require2, ignoreFactory, YGGDRASIL_DIRNAME;
 var init_repo_scanner = __esm({
@@ -5677,6 +5693,50 @@ var DEFAULT_QUALITY = {
   max_direct_relations: 10,
   max_node_chars: 4e4
 };
+var DEFAULT_COVERAGE = { required: ["/"], excluded: [] };
+function parseStringArray(raw, field, filename) {
+  if (raw === void 0) return [];
+  if (!Array.isArray(raw) || raw.some((x) => typeof x !== "string")) {
+    throw new ConfigParseError({
+      what: `${filename}: ${field} must be a list of strings (got ${JSON.stringify(raw)}).`,
+      why: "Coverage roots are repo-relative path prefixes; a non-list value cannot be matched against files.",
+      next: `Set ${field} to a YAML list, e.g.
+  ${field.split(".").pop()}:
+    - services/`
+    }, "config-invalid");
+  }
+  return raw;
+}
+function parseCoverage(raw, filename) {
+  if (raw === void 0) return DEFAULT_COVERAGE;
+  if (typeof raw !== "object" || Array.isArray(raw) || raw === null) {
+    throw new ConfigParseError({
+      what: `${filename}: coverage must be a mapping`,
+      why: "coverage holds the required/excluded root lists",
+      next: 'replace with `coverage: { required: ["/"], excluded: [] }`'
+    }, "config-invalid");
+  }
+  const cov = raw;
+  const required = cov.required === void 0 ? ["/"] : parseStringArray(cov.required, "coverage.required", filename);
+  const excluded = parseStringArray(cov.excluded, "coverage.excluded", filename);
+  if (required.length === 0) {
+    throw new ConfigParseError({
+      what: `${filename}: coverage.required must list at least one root.`,
+      why: "An empty required list silently turns every unmapped file into a non-blocking warning, disabling coverage enforcement.",
+      next: "Omit the coverage block to require the whole repo, or list real roots (e.g. - services/)."
+    }, "config-invalid");
+  }
+  for (const root of [...required, ...excluded]) {
+    if (root.split("/").includes("..")) {
+      throw new ConfigParseError({
+        what: `${filename}: coverage root '${root}' contains a '..' segment.`,
+        why: "'..' is not a valid repo-relative prefix and will never match any git-tracked path, silently mis-scoping coverage enforcement.",
+        next: 'Use a repo-relative path prefix without any ".." segments (e.g. - services/ instead of - services/../other/).'
+      }, "config-invalid");
+    }
+  }
+  return { required, excluded };
+}
 function parseMaxNodeChars(raw, filename) {
   if (raw === void 0) return DEFAULT_QUALITY.max_node_chars ?? 4e4;
   if (typeof raw !== "number" || !Number.isInteger(raw) || raw <= 0) {
@@ -5754,7 +5814,8 @@ async function parseConfig(filePath) {
     quality,
     reviewer,
     parallel,
-    debug
+    debug,
+    coverage: parseCoverage(raw.coverage, filename)
   };
 }
 function parseReviewer(raw, filename) {
@@ -11757,6 +11818,88 @@ var COMPLETENESS_CODES = /* @__PURE__ */ new Set(["description-missing"]);
 // src/core/check.ts
 init_log_format();
 init_posix();
+init_repo_scanner();
+
+// src/core/check-coverage-tiers.ts
+init_posix();
+function normalizeRoot(root) {
+  return toPosixPath(root.trim()).replace(/^\/+/, "").replace(/\/+$/, "").replace(/\/{2,}/g, "/");
+}
+function matchesRoot(file, normRoot) {
+  return normRoot === "" || file === normRoot || file.startsWith(normRoot + "/");
+}
+function partitionByCoverageTier(uncovered, coverage) {
+  const req = coverage.required.map(normalizeRoot);
+  const exc = coverage.excluded.map(normalizeRoot);
+  const required = [];
+  const middle = [];
+  for (const f of uncovered) {
+    let best = { len: -1, tier: "middle" };
+    for (const r of req) if (matchesRoot(f, r) && r.length > best.len) best = { len: r.length, tier: "required" };
+    for (const r of exc) if (matchesRoot(f, r) && r.length >= best.len) best = { len: r.length, tier: "excluded" };
+    if (best.tier === "required") required.push(f);
+    else if (best.tier === "middle") middle.push(f);
+  }
+  return { required, middle };
+}
+function buildCoverageIssue(uncoveredFiles, totalGitFiles) {
+  if (uncoveredFiles.length === 0) return null;
+  const sampleSize = 5;
+  const sample = uncoveredFiles.slice(0, sampleSize);
+  const remaining = uncoveredFiles.length - sample.length;
+  const coveragePct = totalGitFiles > 0 ? (totalGitFiles - uncoveredFiles.length) / totalGitFiles * 100 : 100;
+  let coverageMd;
+  if (uncoveredFiles.length <= sampleSize) {
+    coverageMd = {
+      what: `${uncoveredFiles.length} source file${uncoveredFiles.length === 1 ? "" : "s"} not covered by any node.
+${sample.map((f) => "  " + f).join("\n")}`,
+      why: "Files without graph coverage cannot be modified under the protocol.",
+      next: `Check ownership candidates: yg context --file <path>
+Then: add to existing node mapping, or create a new node.`
+    };
+  } else {
+    const guidance = coveragePct < 50 ? "Establish coverage: create nodes for active areas first, expand coverage incrementally." : "Add to an existing node mapping, or create a new node.";
+    coverageMd = {
+      what: `${uncoveredFiles.length} source files have no graph coverage.
+Examples:
+${sample.map((f) => "  " + f).join("\n")}
+... and ${remaining} more`,
+      why: "Files without graph coverage cannot be modified under the protocol.",
+      next: `${guidance}
+Check ownership candidates: yg context --file <path>`
+    };
+  }
+  return {
+    severity: "error",
+    code: "unmapped-files",
+    rule: "unmapped-file",
+    messageData: coverageMd,
+    uncoveredFiles,
+    uncoveredCount: uncoveredFiles.length
+  };
+}
+function buildCoverageAdvisoryIssue(uncoveredFiles) {
+  if (uncoveredFiles.length === 0) return null;
+  const sample = uncoveredFiles.slice(0, 5);
+  const remaining = uncoveredFiles.length - sample.length;
+  const body = uncoveredFiles.length <= 5 ? sample.map((f) => "  " + f).join("\n") : `${sample.map((f) => "  " + f).join("\n")}
+... and ${remaining} more`;
+  return {
+    severity: "warning",
+    code: "uncovered-advisory",
+    rule: "uncovered-advisory",
+    messageData: {
+      what: `${uncoveredFiles.length} tracked file${uncoveredFiles.length === 1 ? "" : "s"} outside any required coverage root.
+${body}`,
+      why: "Not under a coverage.required root \u2014 visible but non-blocking. Bring an area under graph coverage to enforce it.",
+      next: "Map these files to a node, or add their root to coverage.required to make this an error."
+    },
+    uncoveredFiles,
+    uncoveredCount: uncoveredFiles.length
+  };
+}
+
+// src/core/check.ts
 async function classifyDrift(graph) {
   const projectRoot = path34.dirname(graph.rootPath);
   const issues = [];
@@ -12012,7 +12155,8 @@ function scanUncoveredFiles(graph, gitTrackedFiles) {
   const projectRoot = path34.dirname(graph.rootPath);
   const yggPrefix = toPosixPath(path34.relative(projectRoot, graph.rootPath));
   const uncovered = [];
-  for (const file of gitTrackedFiles) {
+  const tracked = excludeNestedGraphSubtrees(gitTrackedFiles);
+  for (const file of tracked) {
     const normalized = toPosixPath(file.trim());
     if (normalized.startsWith(yggPrefix + "/") || normalized === yggPrefix) continue;
     let covered = false;
@@ -12029,42 +12173,6 @@ function scanUncoveredFiles(graph, gitTrackedFiles) {
   }
   return uncovered.sort();
 }
-function buildCoverageIssue(uncoveredFiles, totalGitFiles) {
-  if (uncoveredFiles.length === 0) return null;
-  const sampleSize = 5;
-  const sample = uncoveredFiles.slice(0, sampleSize);
-  const remaining = uncoveredFiles.length - sample.length;
-  const coveragePct = totalGitFiles > 0 ? (totalGitFiles - uncoveredFiles.length) / totalGitFiles * 100 : 100;
-  let coverageMd;
-  if (uncoveredFiles.length <= sampleSize) {
-    coverageMd = {
-      what: `${uncoveredFiles.length} source file${uncoveredFiles.length === 1 ? "" : "s"} not covered by any node.
-${sample.map((f) => "  " + f).join("\n")}`,
-      why: "Files without graph coverage cannot be modified under the protocol.",
-      next: `Check ownership candidates: yg context --file <path>
-Then: add to existing node mapping, or create a new node.`
-    };
-  } else {
-    const guidance = coveragePct < 50 ? "Establish coverage: create nodes for active areas first, expand coverage incrementally." : "Add to an existing node mapping, or create a new node.";
-    coverageMd = {
-      what: `${uncoveredFiles.length} source files have no graph coverage.
-Examples:
-${sample.map((f) => "  " + f).join("\n")}
-... and ${remaining} more`,
-      why: "Files without graph coverage cannot be modified under the protocol.",
-      next: `${guidance}
-Check ownership candidates: yg context --file <path>`
-    };
-  }
-  return {
-    severity: "error",
-    code: "unmapped-files",
-    rule: "unmapped-file",
-    messageData: coverageMd,
-    uncoveredFiles,
-    uncoveredCount: uncoveredFiles.length
-  };
-}
 async function detectOrphanedDriftState(graph) {
   const driftState = await readDriftState(graph.rootPath);
   const validNodePaths = new Set(graph.nodes.keys());
@@ -12074,20 +12182,25 @@ async function runCheck(graph, gitTrackedFiles) {
   const validation = await validate(graph);
   const validationIssues = validation.issues.filter((vi) => vi.code).map((vi) => ({ ...vi, code: vi.code }));
   const driftIssues = await classifyDrift(graph);
-  let coverageIssue = null;
+  let coverageIssues = [];
   let coveredFiles = 0;
   let totalFiles = 0;
   if (gitTrackedFiles !== null) {
     const projectRoot = path34.dirname(graph.rootPath);
     const yggPrefix = toPosixPath(path34.relative(projectRoot, graph.rootPath));
-    const sourceFiles = gitTrackedFiles.filter((f) => {
+    const sourceFiles = excludeNestedGraphSubtrees(gitTrackedFiles).filter((f) => {
       const normalized = toPosixPath(f.trim());
       return !normalized.startsWith(yggPrefix + "/") && normalized !== yggPrefix;
     });
     totalFiles = sourceFiles.length;
     const uncovered = scanUncoveredFiles(graph, gitTrackedFiles);
-    coveredFiles = totalFiles - uncovered.length;
-    coverageIssue = buildCoverageIssue(uncovered, totalFiles);
+    const coverage = graph.config.coverage ?? DEFAULT_COVERAGE;
+    const tiers = partitionByCoverageTier(uncovered, coverage);
+    coveredFiles = totalFiles - (tiers.required.length + tiers.middle.length);
+    coverageIssues = [
+      buildCoverageIssue(tiers.required, totalFiles),
+      buildCoverageAdvisoryIssue(tiers.middle)
+    ].filter((x) => x !== null);
   }
   const orphanedPaths = await detectOrphanedDriftState(graph);
   await garbageCollectDriftState(
@@ -12116,7 +12229,7 @@ async function runCheck(graph, gitTrackedFiles) {
   const allIssues = [
     ...driftIssues,
     ...validationIssues,
-    ...coverageIssue ? [coverageIssue] : [],
+    ...coverageIssues,
     ...orphanWarnings
   ];
   const nodeTypeCounts = /* @__PURE__ */ new Map();
@@ -14017,10 +14130,16 @@ function renderErrorSection(errors) {
 }
 function renderWarningSection(warnings) {
   const lines = [chalk8.yellow(`Warnings (${warnings.length}):`)];
-  for (const issue of sortByNodePath(warnings)) {
+  const coverage = warnings.filter((i) => i.code === "uncovered-advisory");
+  const rest = warnings.filter((i) => i.code !== "uncovered-advisory");
+  for (const issue of sortByNodePath(rest)) {
     lines.push("");
     renderIssueBlock(issue, lines, "warning");
   }
+  for (const issue of coverage) {
+    lines.push("");
+    renderUnmappedBlock(issue, lines, "uncovered");
+  }
   return lines.join("\n");
 }
 function renderIssueBlock(issue, lines, mode) {
@@ -14038,14 +14157,12 @@ function renderIssueBlock(issue, lines, mode) {
     lines.push(`            Fix: ${md.next}${fixSuffix}`);
   }
 }
-function renderUnmappedBlock(issue, lines) {
+function renderUnmappedBlock(issue, lines, label = "unmapped") {
   const md = issue.messageData;
   const files = issue.uncoveredFiles ?? [];
-  const whatFirstLine = md.what.split("\n")[0];
-  const countMatch = whatFirstLine.match(/^(\d[\d,]*)/);
   const count = issue.uncoveredCount ?? files.length;
-  const countLabel = countMatch ? countMatch[1] : String(count);
-  lines.push(`  unmapped (${countLabel})`);
+  const countLabel = String(count);
+  lines.push(`  ${label} (${countLabel})`);
   const shown = files.slice(0, 10);
   for (const f of shown) {
     lines.push(`            ${f}`);
@@ -17044,6 +17161,11 @@ reviewer:
       #   max_bytes_per_file: 65536         # default: 64 KiB per reference file
       #   max_total_bytes_per_aspect: 262144  # default: 256 KiB total per aspect
 
+coverage:                           # Optional \u2014 controls which files must be mapped
+  required:                         # Unmapped files under these roots are a blocking error
+    - "/"                           # Default: whole repo (previous always-map-everything behavior)
+  excluded: []                      # Files under these roots are silently ignored
+
 quality:
   max_direct_relations: 10        # Max out-edges per node before high-fan-out warning
   max_node_chars: 40000           # Per-node character budget (source + aspect refs) before oversized-node error
@@ -17179,6 +17301,24 @@ the provider's standard \`*_API_KEY\`) as a fallback when not present in
 \`yg-config.yaml\` itself must never contain credentials. Commit it to the
 repository \u2014 it is safe to share.
 
+## Coverage config
+
+\`\`\`yaml
+coverage:
+  required:
+    - src/       # unmapped files under src/ are a blocking error
+  excluded:
+    - vendor/    # silently ignored
+\`\`\`
+
+Controls which git-tracked files must be mapped to a node.
+
+- \`required\` \u2014 path roots where unmapped files are a blocking \`unmapped-files\` error. Default: \`["/"]\` (whole repo \u2014 the previous always-map-everything behavior).
+- \`excluded\` \u2014 path roots that are silently ignored. Default: \`[]\`.
+- Files that match neither a required nor an excluded root produce a non-blocking \`uncovered-advisory\` warning.
+- Subtrees containing their own nested \`.yggdrasil/\` are auto-skipped by all repo-walking checks (they are governed by their own graph).
+- Longest-match wins; on a tie between required and excluded, excluded wins.
+
 ## Quality thresholds
 
 \`\`\`yaml

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/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.3",
   "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": {