@chrisdudek/yg 5.4.0 → 5.4.2

package/dist/bin.js

@@ -17,6 +17,17 @@ var DEFAULT_CONFIG = `version: "5.1.0"
 quality:
   max_direct_relations: 10
 
+# Coverage \u2014 which files must belong to a node.
+# Fresh projects start in "require nothing" mode: every unmapped file surfaces as
+# a NON-blocking warning (not a blocking error), so your very first \`yg check\` is
+# green while you adopt incrementally. Add a path prefix to \`required\` (e.g.
+# "src/") to make that area blocking once you start mapping it. NOTE: an ABSENT
+# coverage block defaults to requiring the WHOLE repo \u2014 this explicit empty list
+# is what opts a fresh project into require-nothing.
+coverage:
+  required: []
+  excluded: []
+
 # Reviewer configuration added by: yg init
 # (see yg schemas read config + yg knowledge read configuration)
 
@@ -3890,6 +3901,13 @@ async function ensureYggdrasilGitignore(yggRoot) {
 }
 var API_PROVIDERS = ["anthropic", "openai", "google", "openai-compatible", "ollama"];
 var CLI_PROVIDERS = ["claude-code", "codex", "gemini-cli"];
+var ALL_PROVIDERS = [...CLI_PROVIDERS, ...API_PROVIDERS];
+var API_KEY_ENV = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  google: "GOOGLE_API_KEY",
+  "openai-compatible": "OPENAI_API_KEY"
+};
 var CLAUDE_CODE_ALIASES = [
   { value: "haiku", label: "haiku" },
   { value: "sonnet", label: "sonnet" },
@@ -3984,15 +4002,16 @@ async function promptModelText(provider) {
 async function runReviewerConfigFlow() {
   const provider = await p.select({
     message: "Which provider should verify your code?",
+    initialValue: "claude-code",
     options: [
-      { value: "anthropic", label: "Anthropic", hint: "API \u2014 Claude models" },
-      { value: "openai", label: "OpenAI", hint: "API \u2014 GPT models" },
-      { value: "google", label: "Google", hint: "API \u2014 Gemini models" },
-      { value: "ollama", label: "Ollama", hint: "Local \u2014 no API costs" },
-      { value: "openai-compatible", label: "OpenAI-compatible", hint: "API \u2014 custom endpoint" },
-      { value: "claude-code", label: "Claude Code", hint: "CLI \u2014 uses installed claude" },
-      { value: "codex", label: "Codex", hint: "CLI \u2014 uses installed codex" },
-      { value: "gemini-cli", label: "Gemini CLI", hint: "CLI \u2014 uses installed gemini" }
+      { value: "claude-code", label: "Claude Code", hint: "CLI \u2014 free, no API key; uses installed claude" },
+      { value: "codex", label: "Codex", hint: "CLI \u2014 free, no API key; uses installed codex" },
+      { value: "gemini-cli", label: "Gemini CLI", hint: "CLI \u2014 free, no API key; uses installed gemini" },
+      { value: "ollama", label: "Ollama", hint: "Local \u2014 no API costs; needs a local install" },
+      { value: "anthropic", label: "Anthropic", hint: "API key \u2014 Claude models" },
+      { value: "openai", label: "OpenAI", hint: "API key \u2014 GPT models" },
+      { value: "google", label: "Google", hint: "API key \u2014 Gemini models" },
+      { value: "openai-compatible", label: "OpenAI-compatible", hint: "API key \u2014 custom endpoint" }
     ]
   });
   assertNotCancelled(provider);
@@ -4123,9 +4142,9 @@ async function freshInit(projectRoot) {
   const yggRoot = path14.join(projectRoot, ".yggdrasil");
   if (!isTTY()) {
     process.stderr.write(chalk2.red(`Error: ${buildIssueMessage({
-      what: "yg init requires an interactive terminal.",
-      why: "Setup requires interactive prompts to configure platform and reviewer.",
-      next: "Run yg init in an interactive terminal session."
+      what: "yg init requires an interactive terminal (no --provider given).",
+      why: "The interactive wizard needs prompts to configure platform and reviewer. Docker, devcontainer, and CI runs have no TTY.",
+      next: `Run yg init in an interactive terminal, OR bootstrap non-interactively: yg init --platform <name> --provider <name> [--model <m>] [--endpoint <url>]. Supported providers: ${ALL_PROVIDERS.join(", ")}.`
     })}
 `));
     process.exit(1);
@@ -4139,7 +4158,7 @@ async function freshInit(projectRoot) {
   const platform = await promptPlatform();
   p.log.step("Step 2: Reviewer provider");
   p.log.info(
-    "The reviewer checks your source code against aspect rules during yg check --approve.\n  API providers make HTTP calls. CLI providers delegate to an installed agent.\n  For local review without API costs, use Ollama."
+    "The reviewer checks your source code against aspect rules during yg check --approve.\n  If you already run an agent CLI (Claude Code, Codex, Gemini), pick it \u2014 the\n  reviewer then needs no API key and adds no separate API bill. Ollama runs\n  locally with no API cost. API providers (Anthropic, OpenAI, Google) need a key."
   );
   const reviewerConfig = await runReviewerConfigFlow();
   await createYggdrasilStructure(projectRoot, yggRoot, platform);
@@ -4159,6 +4178,54 @@ async function createYggdrasilStructure(projectRoot, yggRoot, platform) {
   await ensureYggdrasilGitignore(yggRoot);
   await installRulesForPlatform(projectRoot, platform);
 }
+async function freshInitNonInteractive(projectRoot, yggRoot, opts) {
+  const { platform, provider } = opts;
+  const model = opts.model?.trim();
+  if (!model) {
+    process.stderr.write(chalk2.red(`Error: ${buildIssueMessage({
+      what: "--model is required for non-interactive init.",
+      why: "Non-interactive init records the reviewer model verbatim and applies no default \u2014 the model must be named explicitly.",
+      next: `Re-run naming a model: yg init --platform ${platform} --provider ${provider} --model <name>.`
+    })}
+`));
+    process.exit(1);
+  }
+  let endpoint = opts.endpoint?.trim() || void 0;
+  if (needsEndpoint(provider) && !endpoint) {
+    if (provider === "ollama") {
+      endpoint = "http://localhost:11434";
+    } else {
+      process.stderr.write(chalk2.red(`Error: ${buildIssueMessage({
+        what: `--endpoint is required for provider '${provider}'.`,
+        why: "An OpenAI-compatible provider has no default base URL \u2014 the reviewer needs an endpoint to call.",
+        next: `Re-run naming an endpoint: yg init --platform ${platform} --provider ${provider} --model ${model} --endpoint <url>.`
+      })}
+`));
+      process.exit(1);
+    }
+  }
+  await createYggdrasilStructure(projectRoot, yggRoot, platform);
+  await writeReviewerConfig(yggRoot, { provider, model, endpoint });
+  if (needsApiKey(provider)) {
+    const envVar = API_KEY_ENV[provider];
+    const apiKey = (envVar ? process.env[envVar] : void 0)?.trim();
+    if (apiKey) {
+      await writeSecretsFile(yggRoot, apiKey);
+    } else {
+      process.stdout.write(chalk2.yellow(`${buildIssueMessage({
+        what: `No API key found${envVar ? ` in $${envVar}` : ""}; wrote the config without one.`,
+        why: "An API provider needs a key before the reviewer can run; init records the config anyway so setup is not blocked.",
+        next: `Set ${envVar ?? "the provider API key environment variable"} (or add the key to .yggdrasil/yg-secrets.yaml) before running yg check --approve.`
+      })}
+`));
+    }
+  }
+  await ensureGitattributes(projectRoot);
+  process.stdout.write(chalk2.green(
+    `Yggdrasil initialized (platform: ${platform}, provider: ${provider}, model: ${model}). Run yg check to get started.
+`
+  ));
+}
 async function runVersionUpgrade2(projectRoot, yggRoot, platform) {
   const { migrationActions, migrationWarnings, withheld } = await runVersionUpgrade({
     yggRoot,
@@ -4249,7 +4316,7 @@ async function existingInit(projectRoot) {
   }
 }
 function registerInitCommand(program2) {
-  program2.command("init").description("Initialize Yggdrasil graph in current project").option("--upgrade", "Non-interactive: refresh rules").option("--platform <name>", `Platform for rules file (${PLATFORMS.join(", ")})`).action(async (options) => {
+  program2.command("init").description("Initialize Yggdrasil graph in current project").option("--upgrade", "Non-interactive: refresh rules").option("--platform <name>", `Platform for rules file (${PLATFORMS.join(", ")})`).option("--provider <name>", `Non-interactive fresh init: reviewer provider (${ALL_PROVIDERS.join(", ")})`).option("--model <name>", "Non-interactive fresh init: reviewer model (required)").option("--endpoint <url>", "Non-interactive fresh init: reviewer endpoint (ollama / openai-compatible)").action(async (options) => {
     try {
       const projectRoot = process.cwd();
       const yggRoot = path14.join(projectRoot, ".yggdrasil");
@@ -4359,6 +4426,40 @@ function registerInitCommand(program2) {
       }
       if (exists) {
         await existingInit(projectRoot);
+      } else if (options.provider) {
+        if (!options.platform) {
+          process.stderr.write(chalk2.red(`Error: ${buildIssueMessage({
+            what: "--provider requires --platform for non-interactive init.",
+            why: "A fresh graph must install the rules file for a specific agent platform; there is no prompt to ask in non-interactive mode.",
+            next: `Pass --platform <name>. Supported: ${PLATFORMS.join(", ")}.`
+          })}
+`));
+          process.exit(1);
+        }
+        if (!PLATFORMS.includes(options.platform)) {
+          process.stderr.write(chalk2.red(`Error: ${buildIssueMessage({
+            what: `Unknown platform '${options.platform}'.`,
+            why: "The --platform value must match one of the supported agent platforms.",
+            next: `Use one of: ${PLATFORMS.join(", ")}`
+          })}
+`));
+          process.exit(1);
+        }
+        if (!ALL_PROVIDERS.includes(options.provider)) {
+          process.stderr.write(chalk2.red(`Error: ${buildIssueMessage({
+            what: `Unknown provider '${options.provider}'.`,
+            why: "The --provider value must match one of the supported reviewer providers.",
+            next: `Use one of: ${ALL_PROVIDERS.join(", ")}`
+          })}
+`));
+          process.exit(1);
+        }
+        await freshInitNonInteractive(projectRoot, yggRoot, {
+          platform: options.platform,
+          provider: options.provider,
+          model: options.model,
+          endpoint: options.endpoint
+        });
       } else {
         await freshInit(projectRoot);
       }
@@ -16056,6 +16157,7 @@ async function runFill(graph, opts) {
   }
   const detPairs = unverifiedPairs.filter((p2) => p2.kind === "deterministic");
   const llmPairs = onlyDeterministic ? [] : unverifiedPairs.filter((p2) => p2.kind === "llm");
+  const skippedLlmPairs = onlyDeterministic ? unverifiedPairs.filter((p2) => p2.kind === "llm").length : 0;
   const aspectById = /* @__PURE__ */ new Map();
   for (const a of graph.aspects) aspectById.set(a.id, a);
   const deterministicAspectIds = new Set(
@@ -16073,6 +16175,12 @@ async function runFill(graph, opts) {
     `Filling ${unverifiedPairs.length} unverified pairs across ${nodeSet.size} nodes \u2014 ${detPairs.length} deterministic (no cost), ${reviewerCallBudget} reviewer calls (consensus included)
 `
   );
+  if (skippedLlmPairs > 0) {
+    write(
+      `  Deterministic-only mode \u2014 ${skippedLlmPairs} LLM pair${skippedLlmPairs === 1 ? "" : "s"} will NOT be reviewed this run; run \`yg check --approve\` to review ${skippedLlmPairs === 1 ? "it" : "them"}.
+`
+    );
+  }
   if (dryRun) {
     const byNode = /* @__PURE__ */ new Map();
     for (const p2 of unverifiedPairs) {
@@ -16113,7 +16221,7 @@ async function runFill(graph, opts) {
     return writeChain;
   };
   const setEntry = async (aspectId, unitKey, entry) => {
-    (lock.verdicts[aspectId] ??= {})[unitKey] = entry;
+    (lock.verdicts[aspectId] ??= {})[toPosixPath(unitKey)] = entry;
     await persistLock();
   };
   const blockedNodes = /* @__PURE__ */ new Set();
@@ -16274,7 +16382,14 @@ async function runFill(graph, opts) {
   }
   await garbageCollectAndRewrite(graph, lock, persistLock);
   if (reviewerCallsMade === 0 && infraFailures === 0 && runtimeErrors === 0 && companionRuntimeErrors === 0) {
-    write("0 reviewer calls made \u2014 all expected pairs hold valid verdicts\n");
+    if (skippedLlmPairs > 0) {
+      write(
+        `0 reviewer calls made \u2014 deterministic-only mode; ${skippedLlmPairs} LLM pair${skippedLlmPairs === 1 ? "" : "s"} left unverified. Run \`yg check --approve\` to review ${skippedLlmPairs === 1 ? "it" : "them"}.
+`
+      );
+    } else {
+      write("0 reviewer calls made \u2014 all expected pairs hold valid verdicts\n");
+    }
   }
   if (infraFailures > 0) {
     const providers = [...new Set(infraReport.map((r) => r.provider).filter(Boolean))].join(", ");
@@ -16608,6 +16723,10 @@ function resolveTopValue(raw) {
   if (Number.isNaN(n) || n < 1) return null;
   return n;
 }
+function nextPointer(next) {
+  const firstLine = next.split("\n")[0];
+  return firstLine.trimEnd().endsWith(":") ? next : firstLine;
+}
 function residualAfterNext(result) {
   if (!result.suggestedNext?.startsWith("yg check --approve")) return "";
   const errors = result.issues.filter((i) => i.severity === "error");
@@ -16656,7 +16775,7 @@ function formatOutput(result, view = { kind: "full" }, autoFilled = false, emoji
     }
     const firstFiltered = [...filteredErrors, ...filteredWarnings][0];
     if (firstFiltered?.messageData.next) {
-      const nextCmd = firstFiltered.messageData.next.split("\n")[0];
+      const nextCmd = nextPointer(firstFiltered.messageData.next);
       sections.push("");
       sections.push(`Next (this group): ${nextCmd}`);
       sections.push("");
@@ -16686,7 +16805,7 @@ function formatOutput(result, view = { kind: "full" }, autoFilled = false, emoji
     }
   }
   if (result.suggestedNext) {
-    const nextCmd = result.suggestedNext.split("\n")[0];
+    const nextCmd = nextPointer(result.suggestedNext);
     const residual = view.kind === "full" || view.kind === "details" ? residualAfterNext(result) : "";
     sections.push("");
     sections.push(`Next: ${nextCmd}${residual}`);
@@ -21045,8 +21164,11 @@ cached and FINAL for unchanged inputs. Interrupting is safe \u2014 finished pair
 persist, the next run resumes.
 
 When nothing was unverified, the summary says \`0 reviewer calls made \u2014 all
-expected pairs hold valid verdicts\`. Use \`yg impact\` to predict cost before
-editing.
+expected pairs hold valid verdicts\`. Under \`--only-deterministic\` the header and
+summary instead name the LLM pairs left unverified \u2014 they are skipped by design,
+not reviewed \u2014 and point at a full \`yg check --approve\` to review them, so a
+deterministic-only run never reads as if it verified everything. Use \`yg impact\`
+to predict cost before editing.
 
 \`--dry-run\` (with \`--approve\`) is a free cost preview: it runs the same
 structural gate, pair classification, and budget computation, prints the
@@ -23135,16 +23257,6 @@ async function computePortalFreshness(graph, lock) {
 }
 
 // src/portal/derive-node-state.ts
-var PAIR_RANK = {
-  refused: 4,
-  unverified: 3,
-  warning: 2,
-  verified: 1,
-  "n/a": 0
-};
-function worstPairState(states) {
-  return states.reduce((worst, s) => PAIR_RANK[s] > PAIR_RANK[worst] ? s : worst, "verified");
-}
 var STATE_RANK = {
   refused: 4,
   unverified: 3,
@@ -23196,6 +23308,18 @@ function computeNotApplicable(node, graph, effectiveIds) {
   return out;
 }
 
+// src/portal/derive-pair-state.ts
+var PAIR_RANK = {
+  refused: 4,
+  unverified: 3,
+  warning: 2,
+  verified: 1,
+  "n/a": 0
+};
+function worstPairState(states) {
+  return states.reduce((worst, s) => PAIR_RANK[s] > PAIR_RANK[worst] ? s : worst, "verified");
+}
+
 // src/portal/derive-nodes.ts
 function displayPairState(rawKind, status) {
   if (rawKind === "verified") return "verified";
@@ -23513,28 +23637,6 @@ function buildTypes(graph) {
 }
 
 // src/portal/derive-rest.ts
-function buildBoundary(input) {
-  if (input === null) {
-    return { phantom: [], declaredOnly: [], forbiddenType: [], unknown: true };
-  }
-  return {
-    phantom: dedupeEdges(input.phantom),
-    declaredOnly: dedupeEdges(input.declaredOnly),
-    forbiddenType: dedupeEdges(input.forbiddenType),
-    unknown: false
-  };
-}
-function dedupeEdges(edges) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const e of edges) {
-    const key = `${e.source}\0${e.target}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(e);
-  }
-  return out.sort((a, b) => a.source.localeCompare(b.source, "en") || a.target.localeCompare(b.target, "en"));
-}
 function buildSuppressions(markers) {
   return markers.map((m) => ({
     aspectId: m.aspectId,
@@ -23576,6 +23678,30 @@ function buildWorklist(check) {
   }));
 }
 
+// src/portal/derive-boundary.ts
+function buildBoundary(input) {
+  if (input === null) {
+    return { phantom: [], declaredOnly: [], forbiddenType: [], unknown: true };
+  }
+  return {
+    phantom: dedupeEdges(input.phantom),
+    declaredOnly: dedupeEdges(input.declaredOnly),
+    forbiddenType: dedupeEdges(input.forbiddenType),
+    unknown: false
+  };
+}
+function dedupeEdges(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const e of edges) {
+    const key = `${e.source}\0${e.target}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(e);
+  }
+  return out.sort((a, b) => a.source.localeCompare(b.source, "en") || a.target.localeCompare(b.target, "en"));
+}
+
 // src/portal/extract.ts
 async function extractPortalData(projectRoot, opts) {
   const graph = await loadPortalGraph(projectRoot);
@@ -23829,6 +23955,78 @@ async function readPortalAsset(relPath) {
 // src/portal/server/server.ts
 import { createServer } from "http";
 
+// src/portal/server/boot-pages.ts
+var BOOT_PAGE_CSS = `
+:root{color-scheme:light dark;--yg-bg:#fcfcfd;--yg-surface:#f9f9fb;--yg-fg:#1c2024;--yg-muted:#60646c;--yg-accent:#0090ff;--yg-border:#cdced6}
+@media (prefers-color-scheme:dark){:root{--yg-bg:#111113;--yg-surface:#18191b;--yg-fg:#edeef0;--yg-muted:#b0b4ba;--yg-accent:#3b9eff;--yg-border:#43484e}}
+html,body{height:100%}
+body{margin:0;background:var(--yg-bg);color:var(--yg-fg);font:15px/1.5 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;display:grid;place-items:center;padding:24px;box-sizing:border-box}
+.yg-box{display:flex;flex-direction:column;align-items:center;gap:14px;text-align:center;max-width:56ch}
+.yg-title{font-weight:600;font-size:16px}
+.yg-sub{color:var(--yg-muted);font-size:13.5px;max-width:46ch}
+.yg-sub code,.yg-detail{font-family:ui-monospace,SFMono-Regular,Menlo,monospace}
+.yg-sub code{font-size:12px;background:var(--yg-surface);border:1px solid var(--yg-border);border-radius:4px;padding:1px 5px}`;
+function renderLoadingShell() {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Yggdrasil Portal</title>
+<style>${BOOT_PAGE_CSS}
+.yg-spinner{width:34px;height:34px;border-radius:50%;border:3px solid var(--yg-border);border-top-color:var(--yg-accent);animation:yg-spin .8s linear infinite}
+@keyframes yg-spin{to{transform:rotate(360deg)}}
+@media (prefers-reduced-motion:reduce){.yg-spinner{animation-duration:2.4s}}
+</style>
+</head>
+<body>
+<div class="yg-box" id="yg-boot">
+<div class="yg-spinner" role="status" aria-label="Loading"></div>
+<div class="yg-title">Reading your architecture\u2026</div>
+<div class="yg-sub">Checking the graph and rendering the portal. This can take a moment on a large project.</div>
+</div>
+<script>
+(function(){
+  fetch('/render' + location.search, { headers: { accept: 'text/html' } })
+    .then(function(r){ return r.text(); })
+    .then(function(html){ document.open(); document.write(html); document.close(); })
+    .catch(function(){
+      var b = document.getElementById('yg-boot');
+      if (b) { b.innerHTML =
+        '<div class="yg-title">Couldn\\u2019t reach the portal</div>' +
+        '<div class="yg-sub">The local portal process may have stopped. Restart it in your terminal, then reload this page.</div>'; }
+    });
+})();
+</script>
+</body>
+</html>
+`;
+}
+function renderErrorPage(message) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Yggdrasil Portal \u2014 couldn\u2019t load</title>
+<style>${BOOT_PAGE_CSS}
+.yg-detail{margin-top:4px;max-width:74ch;text-align:left;white-space:pre-wrap;word-break:break-word;font-size:12px;line-height:1.5;color:var(--yg-muted);background:var(--yg-surface);border:1px solid var(--yg-border);border-radius:8px;padding:12px 14px}
+</style>
+</head>
+<body>
+<div class="yg-box">
+<div class="yg-title">The portal couldn\u2019t load your architecture</div>
+<div class="yg-sub">Something went wrong while reading the graph and building the page. Make sure this is a project with a <code>.yggdrasil/</code> graph, then reload. If it keeps happening, run <code>yg check</code> in your terminal to see the underlying problem.</div>
+<div class="yg-detail">${escapeHtmlText(message)}</div>
+</div>
+</body>
+</html>
+`;
+}
+function escapeHtmlText(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
 // src/portal/server/page.ts
 async function freshPortalData(projectRoot, writeEnabled) {
   return extractPortalData(projectRoot, { writeEnabled });
@@ -23836,6 +24034,12 @@ async function freshPortalData(projectRoot, writeEnabled) {
 async function renderLivePage(data) {
   return renderPortalPage(data);
 }
+function loadingShell() {
+  return renderLoadingShell();
+}
+function errorPage(message) {
+  return renderErrorPage(message);
+}
 async function readStaticAsset(relPath) {
   return readPortalAsset(relPath);
 }
@@ -23927,9 +24131,18 @@ async function handleRequest(req, res, config) {
   const pathname = url.pathname;
   try {
     if (method === "GET" && pathname === "/") {
-      const data = await freshPortalData(config.projectRoot, config.writeEnabled);
-      const html = await renderLivePage(data);
-      sendText(res, 200, "text/html; charset=utf-8", html);
+      sendText(res, 200, "text/html; charset=utf-8", loadingShell());
+      return;
+    }
+    if (method === "GET" && pathname === "/render") {
+      try {
+        const data = await freshPortalData(config.projectRoot, config.writeEnabled);
+        const html = await renderLivePage(data);
+        sendText(res, 200, "text/html; charset=utf-8", html);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        sendText(res, 500, "text/html; charset=utf-8", errorPage(message));
+      }
       return;
     }
     if (method === "GET" && pathname === "/data") {