@shrkcrft/inspector 0.1.0-alpha.1

package/dist/template-body-inference.js

@@ -0,0 +1,277 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+const DEFAULT_MAX_BYTES = 20_000;
+const DEFAULT_MAX_LINES = 200;
+/** Maximum count of single-letter / domain-y string literals before we bail. */
+const MAX_DOMAIN_LITERALS = 12;
+/**
+ * Read a sample file and produce a minimal, runnable draft template body by
+ * replacing concrete identifiers with `<name>` / `<className>` placeholders.
+ *
+ * Never throws — returns `{ scaffold: null, reason }` on any structural reason
+ * to skip. Callers should fall back to the non-scaffolded candidate.
+ */
+export function inferTemplateBody(options) {
+    const full = nodePath.isAbsolute(options.sample)
+        ? options.sample
+        : nodePath.join(options.projectRoot, options.sample);
+    if (!existsSync(full)) {
+        return { scaffold: null, reason: `sample not found: ${options.sample}` };
+    }
+    const stat = statSync(full);
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+    if (stat.size > maxBytes) {
+        return {
+            scaffold: null,
+            reason: `sample too large (${stat.size} > ${maxBytes} bytes)`,
+        };
+    }
+    const raw = readFileSync(full, 'utf8');
+    const lineCount = raw.split(/\r?\n/).length;
+    if (lineCount > maxLines) {
+        return {
+            scaffold: null,
+            reason: `sample too long (${lineCount} > ${maxLines} lines)`,
+        };
+    }
+    // ── Identify the construct token from filename. ────────────────────────
+    // file basename → "user.service.ts" → kebab name "user", construct "service".
+    const baseName = nodePath.basename(full);
+    const constructForKind = constructTokenForKind(options.kind);
+    const kebabName = extractKebabName(baseName, constructForKind);
+    if (!kebabName) {
+        return {
+            scaffold: null,
+            reason: `could not derive a base name from "${baseName}"`,
+        };
+    }
+    // ── Detect dominant class / function identifier. ────────────────────────
+    const classMatch = findFirstClass(raw);
+    const fnMatch = findFirstFunction(raw);
+    const componentMatch = findFirstComponent(raw);
+    const warnings = [];
+    // ── Domain-literal complexity guard. ────────────────────────────────────
+    const literals = countStringLiterals(raw);
+    if (literals > MAX_DOMAIN_LITERALS) {
+        return {
+            scaffold: null,
+            reason: `sample contains ${literals} string literals — too domain-specific to scaffold`,
+        };
+    }
+    // ── Complex-imports guard. ──────────────────────────────────────────────
+    const imports = extractImports(raw);
+    const safeImports = imports.every(isSafeImport);
+    if (!safeImports) {
+        warnings.push('Sample imports complex paths (relative or local aliases) — scaffold preserves them as TODOs.');
+    }
+    if (imports.length > 6) {
+        warnings.push(`Sample has ${imports.length} imports; scaffold keeps them with TODO placeholders.`);
+    }
+    // ── Build placeholder-substituted body. ────────────────────────────────
+    let body = raw;
+    const variables = [
+        {
+            name: 'name',
+            description: 'kebab-case base name (e.g. user, order, billing)',
+            default: kebabName,
+        },
+    ];
+    // Replace class name with <ClassName> placeholder if it exists.
+    if (classMatch) {
+        const ph = '<className>';
+        body = replaceWholeWord(body, classMatch.name, ph);
+        variables.push({
+            name: 'className',
+            description: 'PascalCase class identifier',
+            default: classMatch.name,
+        });
+    }
+    // For utilities: replace top-level function name with <fnName>.
+    if (options.kind === 'utility' && fnMatch && !classMatch) {
+        const ph = '<fnName>';
+        body = replaceWholeWord(body, fnMatch.name, ph);
+        variables.push({
+            name: 'fnName',
+            description: 'camelCase function identifier',
+            default: fnMatch.name,
+        });
+    }
+    // For components: replace component name with <ComponentName>.
+    if (options.kind === 'component' && componentMatch && !classMatch) {
+        const ph = '<componentName>';
+        body = replaceWholeWord(body, componentMatch.name, ph);
+        variables.push({
+            name: 'componentName',
+            description: 'PascalCase component identifier',
+            default: componentMatch.name,
+        });
+    }
+    // Replace kebab base name everywhere it appears as a whole token.
+    // Skip the construct token portion (e.g. "service") to avoid clobbering.
+    body = replaceWholeWord(body, kebabName, '<name>');
+    // ── Confidence ─────────────────────────────────────────────────────────
+    let confidence = 'high';
+    if (!classMatch && options.kind === 'service') {
+        confidence = 'medium';
+        warnings.push('No class declaration found in sample — service shape is a best guess.');
+    }
+    if (!fnMatch && options.kind === 'utility') {
+        confidence = 'medium';
+        warnings.push('No top-level function found in sample — utility shape is a best guess.');
+    }
+    if (!safeImports || imports.length > 6) {
+        confidence = confidence === 'high' ? 'medium' : confidence;
+    }
+    // ── Final scaffold ─────────────────────────────────────────────────────
+    const baseId = options.baseId ?? `inferred.typescript.${options.kind}`;
+    const targetPath = suggestedTargetPath(options.kind, constructForKind);
+    const name = displayNameForKind(options.kind);
+    const description = descriptionForKind(options.kind);
+    return {
+        scaffold: {
+            id: baseId,
+            name,
+            description,
+            variables,
+            targetPath,
+            content: body,
+            confidence,
+            sample: nodePath.relative(options.projectRoot, full),
+            warnings,
+        },
+    };
+}
+// ── Helpers ──────────────────────────────────────────────────────────────
+function constructTokenForKind(kind) {
+    switch (kind) {
+        case 'service':
+            return 'service';
+        case 'utility':
+            return 'util';
+        case 'test':
+            return 'spec';
+        case 'component':
+            return 'component';
+    }
+}
+function suggestedTargetPath(kind, construct) {
+    switch (kind) {
+        case 'service':
+            return `src/services/<name>.${construct}.ts`;
+        case 'utility':
+            return `src/utils/<name>.${construct}.ts`;
+        case 'test':
+            return `tests/<name>.${construct}.ts`;
+        case 'component':
+            return `src/components/<componentName>/<componentName>.${construct}.tsx`;
+    }
+}
+function displayNameForKind(kind) {
+    switch (kind) {
+        case 'service':
+            return 'TypeScript service';
+        case 'utility':
+            return 'TypeScript utility';
+        case 'test':
+            return 'TypeScript spec';
+        case 'component':
+            return 'TypeScript component';
+    }
+}
+function descriptionForKind(kind) {
+    switch (kind) {
+        case 'service':
+            return 'Generate a new service modeled on the most representative sample in src/services/.';
+        case 'utility':
+            return 'Generate a new utility module modeled on src/utils/.';
+        case 'test':
+            return 'Generate a new spec/test file modeled on the project test layout.';
+        case 'component':
+            return 'Generate a new UI component modeled on existing components.';
+    }
+}
+function extractKebabName(filename, construct) {
+    // Strip extension and the construct suffix.
+    // Accepts forms like:
+    //   user.service.ts → user
+    //   format-email.util.ts → format-email
+    //   user.spec.ts / user.test.ts → user
+    //   Greeting.component.tsx → greeting
+    const noExt = filename.replace(/\.(tsx?|jsx?)$/i, '');
+    let base = noExt;
+    if (construct === 'spec') {
+        base = base.replace(/\.(spec|test)$/i, '');
+    }
+    else {
+        const re = new RegExp(`\\.${construct}$`, 'i');
+        base = base.replace(re, '');
+    }
+    if (!base || base === noExt)
+        return null;
+    // Normalize to kebab-case for the default value.
+    const kebab = base
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/_+/g, '-')
+        .toLowerCase();
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(kebab))
+        return null;
+    return kebab;
+}
+function findFirstClass(src) {
+    const m = /\bclass\s+([A-Z][A-Za-z0-9_]*)/m.exec(src);
+    return m ? { name: m[1] } : null;
+}
+function findFirstFunction(src) {
+    // Try `export function name`, `export const name = (`, `function name`.
+    const exportFn = /\bexport\s+function\s+([a-zA-Z_][A-Za-z0-9_]*)/m.exec(src);
+    if (exportFn)
+        return { name: exportFn[1] };
+    const exportConst = /\bexport\s+const\s+([a-zA-Z_][A-Za-z0-9_]*)\s*=\s*(?:async\s*)?\(/m.exec(src);
+    if (exportConst)
+        return { name: exportConst[1] };
+    const plainFn = /\bfunction\s+([a-zA-Z_][A-Za-z0-9_]*)/m.exec(src);
+    if (plainFn)
+        return { name: plainFn[1] };
+    return null;
+}
+function findFirstComponent(src) {
+    // `export const Foo: FC = ` / `export function Foo(` / `export default function Foo`.
+    const m = /\bexport\s+(?:default\s+)?(?:function|const)\s+([A-Z][A-Za-z0-9_]*)/m.exec(src);
+    return m ? { name: m[1] } : null;
+}
+function countStringLiterals(src) {
+    let count = 0;
+    // Naive but bounded: count single/double/backtick strings of length > 2.
+    const re = /(['"`])(?:\\.|(?!\1).){3,}\1/g;
+    while (re.exec(src))
+        count += 1;
+    if (count > MAX_DOMAIN_LITERALS)
+        return count;
+    return count;
+}
+function extractImports(src) {
+    const out = [];
+    const re = /\bimport\s+(?:.|\n)*?from\s+['"]([^'"]+)['"]\s*;?/g;
+    let m;
+    while ((m = re.exec(src)))
+        out.push(m[1]);
+    return out;
+}
+function isSafeImport(spec) {
+    // Node built-ins, framework packages, and bare specifiers are safe.
+    // Relative imports / aliased imports require user attention.
+    if (spec.startsWith('.') || spec.startsWith('/'))
+        return false;
+    if (spec.startsWith('@') && spec.includes('/'))
+        return true;
+    if (/^[a-z][a-z0-9-]*(?:\/[^?]+)?$/i.test(spec))
+        return true;
+    return false;
+}
+function replaceWholeWord(src, needle, replacement) {
+    // Escape regex specials in `needle`, then replace whole-token matches.
+    const esc = needle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re = new RegExp(`\\b${esc}\\b`, 'g');
+    return src.replace(re, replacement);
+}

package/dist/template-drift.d.ts

@@ -0,0 +1,39 @@
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const TEMPLATE_DRIFT_SCHEMA = "sharkcraft.template-drift/v1";
+export declare enum TemplateDriftStatus {
+    Pass = "pass",
+    Warn = "warn",
+    Fail = "fail"
+}
+export interface ITemplateDriftIssue {
+    severity: 'info' | 'warning' | 'error';
+    code: string;
+    message: string;
+    suggestedFix?: string;
+}
+export interface ITemplateDriftEntry {
+    templateId: string;
+    templateName?: string;
+    status: TemplateDriftStatus;
+    samplePaths: readonly string[];
+    issues: ReadonlyArray<ITemplateDriftIssue>;
+}
+export interface ITemplateDriftReport {
+    schema: typeof TEMPLATE_DRIFT_SCHEMA;
+    generatedAt: string;
+    totalTemplates: number;
+    pass: number;
+    warn: number;
+    fail: number;
+    entries: ReadonlyArray<ITemplateDriftEntry>;
+}
+export interface ITemplateDriftCheckOptions {
+    /** When set, only the template with this id is verified. */
+    templateId?: string;
+    /** When set, only templates contributed by this pack are verified. */
+    packId?: string;
+    /** Sample variable values for templates with required vars (key→string). */
+    sampleVars?: Readonly<Record<string, string>>;
+}
+export declare function buildTemplateDriftReport(inspection: ISharkcraftInspection, options?: ITemplateDriftCheckOptions): ITemplateDriftReport;
+//# sourceMappingURL=template-drift.d.ts.map

package/dist/template-drift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-drift.d.ts","sourceRoot":"","sources":["../src/template-drift.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE,eAAO,MAAM,qBAAqB,iCAAiC,CAAC;AAEpE,oBAAY,mBAAmB;IAC7B,IAAI,SAAS;IACb,IAAI,SAAS;IACb,IAAI,SAAS;CACd;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,MAAM,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAC;CAC5C;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,OAAO,qBAAqB,CAAC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,0BAA0B;IACzC,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC/C;AAkSD,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,qBAAqB,EACjC,OAAO,GAAE,0BAA+B,GACvC,oBAAoB,CA8DtB"}

package/dist/template-drift.js

@@ -0,0 +1,353 @@
+/**
+ * Template drift verification.
+ *
+ * For each registered template (local + pack), produces a sample dry-run
+ * to verify:
+ *   - target paths align with the registered path conventions.
+ *   - no forbidden legacy patterns (templates declare these via
+ *     plugin contract templates).
+ *   - referenced barrels exist when an `export` op points at them.
+ *   - insert / replace anchors are non-empty (and exist when target is
+ *     also created in the same template).
+ *   - related construct / template / helper / playbook / policy ids
+ *     resolve.
+ *
+ * Read-only — no shell, no network, no source writes.
+ *
+ * Schema: sharkcraft.template-drift/v1
+ */
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+export const TEMPLATE_DRIFT_SCHEMA = 'sharkcraft.template-drift/v1';
+export var TemplateDriftStatus;
+(function (TemplateDriftStatus) {
+    TemplateDriftStatus["Pass"] = "pass";
+    TemplateDriftStatus["Warn"] = "warn";
+    TemplateDriftStatus["Fail"] = "fail";
+})(TemplateDriftStatus || (TemplateDriftStatus = {}));
+const SAMPLE_NAME = 'sample-feature';
+/**
+ * Templates can declare their own forbidden-path fragments via
+ * `template.metadata.forbiddenPathFragments` (optional). The engine no
+ * longer hardcodes per-template fragments.
+ */
+function buildSampleValues(template, override) {
+    const values = {};
+    for (const v of template.variables ?? []) {
+        const name = v.name ?? v.key ?? '';
+        if (!name)
+            continue;
+        if (override && override[name] !== undefined)
+            values[name] = override[name];
+        else if (v.default !== undefined) {
+            values[name] = String(v.default);
+        }
+        else if (name.toLowerCase() === 'name' || name === 'pluginName' || name === 'pluginKey') {
+            values[name] = SAMPLE_NAME;
+        }
+        else {
+            values[name] = 'sample';
+        }
+    }
+    return values;
+}
+function describeForbiddenPaths(template) {
+    const meta = template.metadata;
+    if (meta?.forbiddenPathFragments && Array.isArray(meta.forbiddenPathFragments)) {
+        return meta.forbiddenPathFragments;
+    }
+    return [];
+}
+function safeRender(template, values) {
+    const paths = [];
+    const warnings = [];
+    const ops = [];
+    try {
+        if (typeof template.files === 'function') {
+            const files = template.files(values);
+            for (const f of files) {
+                paths.push(f.targetPath);
+                ops.push({ kind: 'create', target: f.targetPath });
+            }
+        }
+        if (typeof template.changes === 'function') {
+            const changes = template.changes(values);
+            for (const c of changes) {
+                paths.push(c.targetPath);
+                ops.push({
+                    kind: c.operation.kind,
+                    target: c.targetPath,
+                    ...((c.operation.kind === 'insert-after' || c.operation.kind === 'insert-before')
+                        ? { anchor: c.operation.anchor }
+                        : {}),
+                    ...((c.operation.kind === 'export')
+                        ? { from: c.operation.from }
+                        : {}),
+                });
+            }
+        }
+        if (typeof template.files !== 'function' &&
+            typeof template.changes !== 'function' &&
+            template.targetPath) {
+            const tp = typeof template.targetPath === 'function' ? template.targetPath(values) : template.targetPath;
+            paths.push(tp);
+            ops.push({ kind: 'create', target: tp });
+        }
+    }
+    catch (e) {
+        warnings.push(`render threw: ${e.message}`);
+    }
+    return { paths, warnings, ops };
+}
+function checkPathConventions(inspection, paths) {
+    const issues = [];
+    // Path conventions are name patterns; we only flag a path that obviously
+    // mismatches every applicable convention. The conservative default: if no
+    // convention names match any sample path, emit one info issue per path.
+    const svc = inspection.pathService;
+    const conventions = svc && typeof svc.list === 'function' ? svc.list() : [];
+    if (conventions.length === 0)
+        return issues;
+    for (const p of paths) {
+        let matched = false;
+        for (const c of conventions) {
+            const pattern = c.pattern;
+            if (!pattern)
+                continue;
+            // very lightweight substring check — these are heuristics.
+            const cleaned = pattern.replace(/\{.*?\}/g, '').replace(/[.*+?^${}()|[\]\\]/g, '');
+            if (cleaned.length > 4 && p.includes(cleaned)) {
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            issues.push({
+                severity: 'info',
+                code: 'path-no-convention',
+                message: `Sample path "${p}" does not match any registered path convention.`,
+            });
+        }
+    }
+    return issues;
+}
+function checkForbiddenFragments(template, paths) {
+    const issues = [];
+    const forbidden = describeForbiddenPaths(template);
+    if (forbidden.length === 0)
+        return issues;
+    for (const p of paths) {
+        for (const frag of forbidden) {
+            if (p.includes(frag)) {
+                issues.push({
+                    severity: 'error',
+                    code: 'forbidden-legacy-path',
+                    message: `Sample path "${p}" contains forbidden legacy fragment "${frag}". Update the template to use canonical paths.`,
+                });
+            }
+        }
+    }
+    return issues;
+}
+function checkBarrelTargets(projectRoot, ops) {
+    const issues = [];
+    for (const op of ops) {
+        if (op.kind !== 'export')
+            continue;
+        const full = nodePath.join(projectRoot, op.target);
+        if (!existsSync(full)) {
+            issues.push({
+                severity: 'warning',
+                code: 'missing-barrel',
+                message: `export op references missing barrel "${op.target}".`,
+                suggestedFix: 'Create the barrel before applying, or update the template target.',
+            });
+        }
+    }
+    return issues;
+}
+function checkRelatedIds(inspection, template) {
+    const issues = [];
+    for (const id of template.related ?? []) {
+        // related ids are knowledge / construct / template / playbook — try
+        // them all.
+        const knowledge = inspection.index.get(id);
+        const tmpl = inspection.templates.find((t) => t.id === id);
+        if (!knowledge && !tmpl) {
+            issues.push({
+                severity: 'info',
+                code: 'related-id-unresolved',
+                message: `related id "${id}" not found in knowledge or template registries.`,
+            });
+        }
+    }
+    return issues;
+}
+function checkAnchorsNonEmpty(ops) {
+    const issues = [];
+    for (const op of ops) {
+        if ((op.kind === 'insert-after' || op.kind === 'insert-before') && !op.anchor) {
+            issues.push({
+                severity: 'error',
+                code: 'missing-anchor',
+                message: `${op.kind} op on "${op.target}" has no anchor.`,
+            });
+        }
+    }
+    return issues;
+}
+/**
+ * Verify the template's `producedAnchors[]` metadata is consistent with
+ * the rendered output. For every declared producer, the body of the target
+ * file must contain the anchor literal. Missing producers surface as
+ * `missing-produced-anchor` issues (warning by default).
+ */
+function checkProducedAnchors(template, values) {
+    const issues = [];
+    const declared = template.metadata?.producedAnchors;
+    if (!declared || declared.length === 0)
+        return issues;
+    const rendered = new Map(); // path → body
+    try {
+        if (typeof template.files === 'function') {
+            for (const f of template.files(values))
+                rendered.set(f.targetPath, f.content);
+        }
+    }
+    catch {
+        // render errors already surfaced by safeRender; skip here.
+    }
+    for (const decl of declared) {
+        // `in` may be a glob or a literal path. We do a substring/glob-ish match.
+        const candidates = [...rendered.entries()].filter(([p]) => pathMatchesPattern(p, decl.in));
+        if (candidates.length === 0) {
+            issues.push({
+                severity: 'warning',
+                code: 'produced-anchor-target-missing',
+                message: `producedAnchors entry "${decl.anchor}" refers to "${decl.in}", but the template did not render any file matching that pattern.`,
+            });
+            continue;
+        }
+        const anyMatch = candidates.some(([, body]) => body.includes(decl.anchor));
+        if (!anyMatch) {
+            issues.push({
+                severity: 'error',
+                code: 'missing-produced-anchor',
+                message: `Template declares producedAnchor "${decl.anchor}" in "${decl.in}", but the rendered file does not contain it.`,
+                suggestedFix: `Add the anchor literal to the rendered ${decl.in} or remove the declaration.`,
+            });
+        }
+    }
+    return issues;
+}
+/**
+ * Verify the template's `requiredAnchors[]` metadata against the union
+ * of all `producedAnchors[]` from every registered template (local + pack).
+ * Surfaces `missing-required-anchor` when no producer exists.
+ */
+function checkRequiredAnchors(template, allProduced) {
+    const issues = [];
+    const required = template.metadata?.requiredAnchors;
+    if (!required || required.length === 0)
+        return issues;
+    for (const decl of required) {
+        let found = false;
+        for (const [pattern, anchors] of allProduced) {
+            if (pathMatchesPattern(pattern, decl.in) || pathMatchesPattern(decl.in, pattern)) {
+                if (anchors.has(decl.anchor)) {
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if (!found) {
+            issues.push({
+                severity: 'warning',
+                code: 'missing-required-anchor',
+                message: `Template requires anchor "${decl.anchor}" in "${decl.in}", but no other template declares it as a producer.`,
+                suggestedFix: `Add producedAnchors metadata to the scaffold that creates "${decl.in}", or declare a registration hint.`,
+            });
+        }
+    }
+    return issues;
+}
+function pathMatchesPattern(path, pattern) {
+    if (pattern === path)
+        return true;
+    if (!pattern.includes('*'))
+        return path === pattern;
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+    return new RegExp(`^${escaped}$`).test(path);
+}
+function classify(issues) {
+    if (issues.some((i) => i.severity === 'error'))
+        return TemplateDriftStatus.Fail;
+    if (issues.some((i) => i.severity === 'warning'))
+        return TemplateDriftStatus.Warn;
+    return TemplateDriftStatus.Pass;
+}
+export function buildTemplateDriftReport(inspection, options = {}) {
+    const entries = [];
+    const all = inspection.templates;
+    const filtered = options.templateId ? all.filter((t) => t.id === options.templateId) : all;
+    // Build the cross-template anchor producer map ONCE so each entry
+    // can look up "is anchor X declared by some template?".
+    const allProduced = new Map();
+    for (const t of all) {
+        const declared = t.metadata?.producedAnchors;
+        if (!declared || declared.length === 0)
+            continue;
+        for (const decl of declared) {
+            const existing = allProduced.get(decl.in) ?? new Set();
+            const next = new Set(existing);
+            next.add(decl.anchor);
+            allProduced.set(decl.in, next);
+        }
+    }
+    for (const t of filtered) {
+        const values = buildSampleValues(t, options.sampleVars);
+        const { paths, warnings: renderWarnings, ops } = safeRender(t, values);
+        const renderIssues = renderWarnings.map((w) => ({
+            severity: 'warning',
+            code: 'render-warning',
+            message: w,
+        }));
+        const allIssues = [
+            ...renderIssues,
+            ...checkForbiddenFragments(t, paths),
+            ...checkPathConventions(inspection, paths),
+            ...checkBarrelTargets(inspection.projectRoot, ops),
+            ...checkRelatedIds(inspection, t),
+            ...checkAnchorsNonEmpty(ops),
+            ...checkProducedAnchors(t, values),
+            ...checkRequiredAnchors(t, allProduced),
+        ];
+        entries.push({
+            templateId: t.id,
+            templateName: t.name,
+            status: classify(allIssues),
+            samplePaths: paths,
+            issues: allIssues,
+        });
+    }
+    let pass = 0;
+    let warn = 0;
+    let fail = 0;
+    for (const e of entries) {
+        if (e.status === TemplateDriftStatus.Pass)
+            pass += 1;
+        else if (e.status === TemplateDriftStatus.Warn)
+            warn += 1;
+        else
+            fail += 1;
+    }
+    return {
+        schema: TEMPLATE_DRIFT_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        totalTemplates: filtered.length,
+        pass,
+        warn,
+        fail,
+        entries,
+    };
+}