@webpresso/agent-kit 0.21.0

package/dist/esm/audit/bucket-boundary.js

@@ -0,0 +1,330 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+/**
+ * Strip // line comments and trailing commas from JSONC so JSON.parse works.
+ * No external dep.
+ */
+function parseJsonc(text) {
+    // Remove single-line comments (// ...) — but not inside strings
+    // Simple two-pass approach: safe for wrangler configs (no unusual strings)
+    const withoutComments = text.replace(/("(?:[^"\\]|\\.)*")|\/\/[^\n]*/g, (match, quoted) => quoted !== undefined ? quoted : '');
+    // Remove trailing commas before } or ]
+    const withoutTrailingCommas = withoutComments.replace(/,(\s*[}\]])/g, '$1');
+    return JSON.parse(withoutTrailingCommas);
+}
+function readJsonSafe(filePath) {
+    try {
+        const text = readFileSync(filePath, 'utf8');
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function readJsoncSafe(filePath) {
+    try {
+        const text = readFileSync(filePath, 'utf8');
+        const parsed = parseJsonc(text);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse pnpm-workspace.yaml globs and discover matching package directories.
+ * Minimal parser — supports `packages:` list with glob patterns.
+ */
+function discoverPackageDirs(root) {
+    const workspaceFile = join(root, 'pnpm-workspace.yaml');
+    if (!existsSync(workspaceFile))
+        return [];
+    const text = readFileSync(workspaceFile, 'utf8');
+    const lines = text.split('\n');
+    // Collect patterns under "packages:" key
+    let inPackages = false;
+    const patterns = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === 'packages:') {
+            inPackages = true;
+            continue;
+        }
+        if (inPackages) {
+            if (trimmed.startsWith('- ')) {
+                const pattern = trimmed.slice(2).replace(/['"]/g, '').trim();
+                patterns.push(pattern);
+            }
+            else if (trimmed && !trimmed.startsWith('#')) {
+                // New top-level key
+                break;
+            }
+        }
+    }
+    // Resolve glob patterns — support simple `dir/*` and `dir/**` forms
+    const dirs = [];
+    for (const pattern of patterns) {
+        if (pattern.endsWith('/*') || pattern.endsWith('/**')) {
+            const parentGlob = pattern.replace(/\/\*\*?$/, '');
+            const parentDir = join(root, parentGlob);
+            if (!existsSync(parentDir))
+                continue;
+            const entries = readdirSync(parentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    dirs.push(join(parentDir, entry.name));
+                }
+            }
+        }
+        else {
+            // Exact dir
+            const dir = join(root, pattern);
+            if (existsSync(dir))
+                dirs.push(dir);
+        }
+    }
+    return dirs;
+}
+function resolveWranglerName(dir) {
+    // Try wrangler.jsonc first, then wrangler.toml
+    const jsoncPath = join(dir, 'wrangler.jsonc');
+    if (existsSync(jsoncPath)) {
+        const parsed = readJsoncSafe(jsoncPath);
+        const name = parsed?.['name'];
+        return typeof name === 'string' ? name : undefined;
+    }
+    const tomlPath = join(dir, 'wrangler.toml');
+    if (existsSync(tomlPath)) {
+        const text = readFileSync(tomlPath, 'utf8');
+        const match = text.match(/^name\s*=\s*["']?([^"'\s\n]+)["']?/m);
+        return match ? match[1] : undefined;
+    }
+    return undefined;
+}
+function collectPackages(root) {
+    const dirs = discoverPackageDirs(root);
+    const packages = [];
+    for (const dir of dirs) {
+        const pkgPath = join(dir, 'package.json');
+        if (!existsSync(pkgPath))
+            continue;
+        const pkg = readJsonSafe(pkgPath);
+        if (!pkg)
+            continue;
+        const name = typeof pkg['name'] === 'string' ? pkg['name'] : undefined;
+        if (!name)
+            continue;
+        const webpresso = pkg['webpresso'];
+        let bucket;
+        if (webpresso && typeof webpresso === 'object' && !Array.isArray(webpresso)) {
+            const bucketVal = webpresso['bucket'];
+            if (bucketVal === 'platform' ||
+                bucketVal === 'tenant-orchestration' ||
+                bucketVal === 'tenant-artifacts') {
+                bucket = bucketVal;
+            }
+        }
+        const deps = pkg['dependencies'] ?? {};
+        const devDeps = pkg['devDependencies'] ?? {};
+        const wranglerName = resolveWranglerName(dir);
+        packages.push({ name, dir, bucket, dependencies: deps, devDependencies: devDeps, wranglerName });
+    }
+    return packages;
+}
+/**
+ * Code-level rule: tenant-orchestration must not depend on platform.
+ */
+function checkCodeLevel(packages, bucketByName, _options) {
+    const violations = [];
+    for (const pkg of packages) {
+        if (pkg.bucket !== 'tenant-orchestration')
+            continue;
+        const allDeps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+        };
+        for (const depName of Object.keys(allDeps)) {
+            const depBucket = bucketByName.get(depName);
+            if (depBucket === 'platform') {
+                violations.push({
+                    package: pkg.name,
+                    rule: 'code-level',
+                    description: `"${pkg.name}" (tenant-orchestration) depends on "${depName}" (platform) — cross-bucket code dependency forbidden`,
+                    severity: 'error',
+                });
+            }
+        }
+    }
+    return violations;
+}
+function readWranglerServices(dir) {
+    // Try wrangler.jsonc
+    const jsoncPath = join(dir, 'wrangler.jsonc');
+    let parsed = null;
+    if (existsSync(jsoncPath)) {
+        parsed = readJsoncSafe(jsoncPath);
+    }
+    else {
+        // wrangler.toml — minimal TOML parsing for [[services]]
+        const tomlPath = join(dir, 'wrangler.toml');
+        if (!existsSync(tomlPath))
+            return { services: [], crossBucketAllowlist: [] };
+        // Skip TOML services parsing (complex) — only JSONC supported for now
+        return { services: [], crossBucketAllowlist: [] };
+    }
+    if (!parsed)
+        return { services: [], crossBucketAllowlist: [] };
+    const rawServices = parsed['services'];
+    const services = [];
+    if (Array.isArray(rawServices)) {
+        for (const s of rawServices) {
+            if (s && typeof s === 'object' && typeof s['service'] === 'string') {
+                services.push({
+                    binding: typeof s['binding'] === 'string' ? s['binding'] : '',
+                    service: s['service'],
+                });
+            }
+        }
+    }
+    // Read optional crossBucketBindings allowlist from webpresso config in wrangler
+    const wranglerWebpresso = parsed['webpresso'];
+    let crossBucketAllowlist = [];
+    if (wranglerWebpresso &&
+        typeof wranglerWebpresso === 'object' &&
+        !Array.isArray(wranglerWebpresso)) {
+        const list = wranglerWebpresso['crossBucketBindings'];
+        if (Array.isArray(list)) {
+            crossBucketAllowlist = list.filter((x) => typeof x === 'string');
+        }
+    }
+    return { services, crossBucketAllowlist };
+}
+/**
+ * Wrangler-level rule: a Worker in bucket X must not service-bind to a Worker
+ * in a different bucket (unless in crossBucketBindings allowlist).
+ */
+function checkWranglerBindings(packages, bucketByWranglerName, _options) {
+    const violations = [];
+    for (const pkg of packages) {
+        if (!pkg.bucket)
+            continue;
+        if (!pkg.wranglerName)
+            continue;
+        const { services, crossBucketAllowlist } = readWranglerServices(pkg.dir);
+        for (const svc of services) {
+            const targetBucket = bucketByWranglerName.get(svc.service);
+            if (!targetBucket)
+                continue; // unknown service — skip
+            if (targetBucket === pkg.bucket)
+                continue; // same bucket — OK
+            const isAllowlisted = crossBucketAllowlist.includes(svc.service);
+            // crossBucketBindings in wrangler.jsonc is an explicit developer declaration —
+            // always treated as a warning, even in --strict mode.
+            // --strict only controls whether the baseline file suppressions apply.
+            const severity = isAllowlisted ? 'warning' : 'error';
+            violations.push({
+                package: pkg.name,
+                rule: 'wrangler-binding',
+                description: `"${pkg.wranglerName}" (${pkg.bucket}) service-binds to "${svc.service}" (${targetBucket}) — cross-bucket Wrangler binding${isAllowlisted ? ' [allowlisted, warning only]' : ''}`,
+                severity,
+            });
+        }
+    }
+    return violations;
+}
+/**
+ * Filter to packages touched by git diff when --changed-only is set.
+ */
+async function filterChangedPackages(packages, root) {
+    const { execSync } = await import('node:child_process');
+    let changedFiles;
+    try {
+        const output = execSync('git diff --name-only origin/main', { cwd: root, encoding: 'utf8' });
+        changedFiles = output
+            .split('\n')
+            .filter(Boolean)
+            .map((f) => resolve(root, f));
+    }
+    catch {
+        return packages;
+    }
+    return packages.filter((pkg) => changedFiles.some((f) => f.startsWith(pkg.dir + '/') || f.startsWith(pkg.dir + '\\')));
+}
+/**
+ * Load violation descriptions from .webpresso/baseline/bucket-violations.md.
+ * Any violation whose description appears in the baseline is treated as a warning
+ * (not an error) in non-strict mode.
+ */
+function loadBaselineDescriptions(root) {
+    const baselinePath = join(root, '.webpresso/baseline/bucket-violations.md');
+    if (!existsSync(baselinePath))
+        return new Set();
+    const text = readFileSync(baselinePath, 'utf8');
+    const descriptions = new Set();
+    for (const line of text.split('\n')) {
+        // Table rows: | `pkg` | rule | description |
+        const match = line.match(/^\|\s*`[^`]+`\s*\|\s*\S+\s*\|\s*(.+?)\s*\|/);
+        if (match?.[1])
+            descriptions.add(match[1].trim());
+    }
+    return descriptions;
+}
+/**
+ * Main audit entry point.
+ */
+export async function auditBucketBoundary(root, options = {}) {
+    const resolvedRoot = resolve(root);
+    const baselineDescriptions = options.strict
+        ? new Set()
+        : loadBaselineDescriptions(resolvedRoot);
+    let packages = collectPackages(resolvedRoot);
+    const annotatedPackages = packages.filter((p) => p.bucket !== undefined);
+    if (options.changedOnly) {
+        packages = await filterChangedPackages(packages, resolvedRoot);
+    }
+    // Build lookup maps
+    const bucketByName = new Map();
+    const bucketByWranglerName = new Map();
+    for (const pkg of annotatedPackages) {
+        if (pkg.bucket) {
+            bucketByName.set(pkg.name, pkg.bucket);
+            if (pkg.wranglerName) {
+                bucketByWranglerName.set(pkg.wranglerName, pkg.bucket);
+            }
+        }
+    }
+    const workingSet = options.changedOnly
+        ? packages.filter((p) => p.bucket !== undefined)
+        : annotatedPackages;
+    const codeViolations = checkCodeLevel(workingSet, bucketByName, options);
+    const wranglerViolations = checkWranglerBindings(workingSet, bucketByWranglerName, options);
+    const allBucketViolations = [...codeViolations, ...wranglerViolations].map((v) => {
+        // Downgrade baseline violations to warnings in non-strict mode
+        if (v.severity === 'error' && baselineDescriptions.has(v.description)) {
+            return { ...v, severity: 'warning' };
+        }
+        return v;
+    });
+    // In non-strict mode, warning-severity violations don't fail the audit
+    const hasErrors = allBucketViolations.some((v) => v.severity === 'error');
+    const violations = allBucketViolations.map((v) => ({
+        file: undefined,
+        message: `[${v.severity}] [${v.rule}] ${v.description}`,
+    }));
+    const title = 'Bucket boundary audit';
+    const checked = workingSet.length;
+    return {
+        ok: !hasErrors,
+        title,
+        checked,
+        violations,
+    };
+}
+//# sourceMappingURL=bucket-boundary.js.map

package/dist/esm/audit/commit-message-lore.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Lore commit-message trailer validator.
+ *
+ * Validates the presence and values of Lore trailers in a commit message.
+ *
+ * Trailer schema (from AGENTS.md):
+ *   Constraint:     - external constraint (free text, at least one required)
+ *   Rejected:       - alternative considered (free text)
+ *   Confidence:     low | medium | high
+ *   Scope-risk:     narrow | moderate | broad
+ *   Reversibility:  clean | messy | irreversible (optional)
+ *   Directive:      - forward-looking instruction (free text)
+ *   Tested:         - what verification was performed
+ *   Not-tested:     - known gaps
+ *   Related:        - links (optional)
+ *
+ * Required (hard-fail in --require-lore mode):
+ *   - Confidence: with a valid value
+ *   - At least one of: Constraint:, Rejected:, Directive:
+ *
+ * Enum trailers always fail on invalid values regardless of mode.
+ */
+export interface LoreValidationOptions {
+    requireLore?: boolean;
+    loreWarn?: boolean;
+}
+export interface LoreValidationResult {
+    valid: boolean;
+    violations: string[];
+    warnings: string[];
+}
+/**
+ * Validate Lore trailers in a commit message.
+ *
+ * - `requireLore: true` — hard-fail on missing required trailers (exit non-zero)
+ * - `loreWarn: true` — warn-only on missing trailers, always valid=true; but
+ *   malformed enum values (e.g. `Confidence: yolo`) always fail regardless of mode
+ * - neither flag — no-op, returns valid=true with no violations or warnings
+ */
+export declare function validateLoreTrailers(message: string, options: LoreValidationOptions): LoreValidationResult;
+//# sourceMappingURL=commit-message-lore.d.ts.map

package/dist/esm/audit/commit-message-lore.js

@@ -0,0 +1,113 @@
+/**
+ * Lore commit-message trailer validator.
+ *
+ * Validates the presence and values of Lore trailers in a commit message.
+ *
+ * Trailer schema (from AGENTS.md):
+ *   Constraint:     - external constraint (free text, at least one required)
+ *   Rejected:       - alternative considered (free text)
+ *   Confidence:     low | medium | high
+ *   Scope-risk:     narrow | moderate | broad
+ *   Reversibility:  clean | messy | irreversible (optional)
+ *   Directive:      - forward-looking instruction (free text)
+ *   Tested:         - what verification was performed
+ *   Not-tested:     - known gaps
+ *   Related:        - links (optional)
+ *
+ * Required (hard-fail in --require-lore mode):
+ *   - Confidence: with a valid value
+ *   - At least one of: Constraint:, Rejected:, Directive:
+ *
+ * Enum trailers always fail on invalid values regardless of mode.
+ */
+const CONFIDENCE_VALUES = ['low', 'medium', 'high'];
+const SCOPE_RISK_VALUES = ['narrow', 'moderate', 'broad'];
+const REVERSIBILITY_VALUES = ['clean', 'messy', 'irreversible'];
+/**
+ * Extract trailers from a commit message using a regex fallback.
+ * Supports both "git interpret-trailers" format and manual detection.
+ *
+ * Trailers are `Key: value` lines at the end of the commit message,
+ * separated from the body by a blank line.
+ */
+function extractTrailers(message) {
+    const trailers = new Map();
+    // Split into lines and scan for trailer-like patterns (Key: value)
+    // A trailer key: starts with a capital letter or known multi-word key,
+    // followed by ': ', followed by content.
+    const TRAILER_PATTERN = /^([A-Za-z][A-Za-z0-9-]*): (.+)$/;
+    for (const line of message.split(/\r?\n/)) {
+        const match = TRAILER_PATTERN.exec(line.trim());
+        if (match?.[1] && match[2] !== undefined) {
+            const key = match[1];
+            const value = match[2].trim();
+            const existing = trailers.get(key) ?? [];
+            existing.push(value);
+            trailers.set(key, existing);
+        }
+    }
+    return trailers;
+}
+/**
+ * Validate Lore trailers in a commit message.
+ *
+ * - `requireLore: true` — hard-fail on missing required trailers (exit non-zero)
+ * - `loreWarn: true` — warn-only on missing trailers, always valid=true; but
+ *   malformed enum values (e.g. `Confidence: yolo`) always fail regardless of mode
+ * - neither flag — no-op, returns valid=true with no violations or warnings
+ */
+export function validateLoreTrailers(message, options) {
+    const { requireLore = false, loreWarn = false } = options;
+    // If neither flag is set, Lore validation is off
+    if (!requireLore && !loreWarn) {
+        return { valid: true, violations: [], warnings: [] };
+    }
+    const trailers = extractTrailers(message);
+    const violations = [];
+    const warnings = [];
+    // --- Enum value validation (always hard-fail regardless of mode) ---
+    const confidenceValues = trailers.get('Confidence') ?? [];
+    for (const val of confidenceValues) {
+        if (!CONFIDENCE_VALUES.includes(val)) {
+            violations.push(`Confidence: '${val}' is not valid. Must be one of: ${CONFIDENCE_VALUES.join(', ')}`);
+        }
+    }
+    const scopeRiskValues = trailers.get('Scope-risk') ?? [];
+    for (const val of scopeRiskValues) {
+        if (!SCOPE_RISK_VALUES.includes(val)) {
+            violations.push(`Scope-risk: '${val}' is not valid. Must be one of: ${SCOPE_RISK_VALUES.join(', ')}`);
+        }
+    }
+    const reversibilityValues = trailers.get('Reversibility') ?? [];
+    for (const val of reversibilityValues) {
+        if (!REVERSIBILITY_VALUES.includes(val)) {
+            violations.push(`Reversibility: '${val}' is not valid. Must be one of: ${REVERSIBILITY_VALUES.join(', ')}`);
+        }
+    }
+    // --- Required trailer presence checks ---
+    // Missing trailers: hard-fail in requireLore mode, warnings in loreWarn mode.
+    const hasConfidence = confidenceValues.length > 0;
+    const hasConstraintOrRejectedOrDirective = trailers.has('Constraint') || trailers.has('Rejected') || trailers.has('Directive');
+    if (!hasConfidence) {
+        const msg = 'Lore commits must include a Confidence: trailer (low|medium|high)';
+        if (requireLore) {
+            violations.push(msg);
+        }
+        else {
+            warnings.push(msg);
+        }
+    }
+    if (!hasConstraintOrRejectedOrDirective) {
+        const msg = 'Lore commits must include at least one of: Constraint:, Rejected:, Directive: trailer';
+        if (requireLore) {
+            violations.push(msg);
+        }
+        else {
+            warnings.push(msg);
+        }
+    }
+    // In loreWarn mode, only enum validation errors make it invalid
+    const isValid = loreWarn ? violations.length === 0 : violations.length === 0;
+    return { valid: isValid, violations, warnings };
+}
+//# sourceMappingURL=commit-message-lore.js.map

package/dist/esm/audit/compile-drift.d.ts

@@ -0,0 +1,3 @@
+import type { RepoAuditResult } from './repo-guardrails.js';
+export declare function auditCompileDrift(cwd: string): Promise<RepoAuditResult>;
+//# sourceMappingURL=compile-drift.d.ts.map

package/dist/esm/audit/compile-drift.js

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { hashAgentDir } from '#cli/commands/compile';
+function readManifest(manifestPath) {
+    if (!existsSync(manifestPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export async function auditCompileDrift(cwd) {
+    const agentDir = join(cwd, '.agent');
+    const manifestPath = join(agentDir, '.compile-manifest.json');
+    const violations = [];
+    const manifest = readManifest(manifestPath);
+    if (manifest === null) {
+        // No manifest yet — not an error, just not compiled
+        return {
+            ok: true,
+            title: 'compile drift',
+            checked: 0,
+            violations: [],
+        };
+    }
+    const currentHash = hashAgentDir(agentDir);
+    if (manifest.sourceHash !== currentHash) {
+        violations.push({
+            file: '.agent/.compile-manifest.json',
+            message: `Compile drift detected — .agent/ has changed since last \`wp compile\` (stored hash: ${manifest.sourceHash.slice(0, 12)}…, current: ${currentHash.slice(0, 12)}…). Run \`wp compile\` to regenerate.`,
+        });
+    }
+    return {
+        ok: violations.length === 0,
+        title: 'compile drift',
+        checked: 1,
+        violations,
+    };
+}
+//# sourceMappingURL=compile-drift.js.map

package/dist/esm/audit/cross-repo-correlation.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `wp audit cross-repo-correlation`
+ *
+ * Wraps `auditCrossRepoCorrelation` from the blueprint cross-repo module into
+ * the standard `RepoAuditResult` shape used by the audit registry.
+ *
+ * FAIL LOUD: any leak or missing allowlist produces a non-zero exit via the
+ * audit framework. The audit does NOT auto-mutate anything.
+ *
+ * Alpha gate: only runs meaningful checks when WP_USE_SQL_AUDITS=1.
+ */
+import type { RepoAuditResult } from './repo-guardrails.js';
+export declare function auditCrossRepoCorrelationAsRepoResult(cwd: string): Promise<RepoAuditResult>;
+//# sourceMappingURL=cross-repo-correlation.d.ts.map

package/dist/esm/audit/cross-repo-correlation.js

@@ -0,0 +1,50 @@
+/**
+ * `wp audit cross-repo-correlation`
+ *
+ * Wraps `auditCrossRepoCorrelation` from the blueprint cross-repo module into
+ * the standard `RepoAuditResult` shape used by the audit registry.
+ *
+ * FAIL LOUD: any leak or missing allowlist produces a non-zero exit via the
+ * audit framework. The audit does NOT auto-mutate anything.
+ *
+ * Alpha gate: only runs meaningful checks when WP_USE_SQL_AUDITS=1.
+ */
+import { auditCrossRepoCorrelation } from '#cross-repo/audit.js';
+export async function auditCrossRepoCorrelationAsRepoResult(cwd) {
+    if (!process.env['WP_USE_SQL_AUDITS']) {
+        return {
+            ok: true,
+            title: 'Cross-repo correlation (SQL) — disabled (set WP_USE_SQL_AUDITS=1)',
+            checked: 0,
+            violations: [],
+        };
+    }
+    const result = await auditCrossRepoCorrelation(cwd);
+    const violations = [];
+    for (const leak of result.leaks) {
+        violations.push({
+            file: leak.blueprintSlug,
+            message: `LEAK: public blueprint '${leak.blueprintSlug}' has unredacted reference to` +
+                ` private slug '${leak.targetSlug}' in repo '${leak.targetRepo}'.` +
+                ` Run 'wp fix cross-repo-leak ${leak.blueprintSlug}' to remediate.`,
+        });
+    }
+    for (const missing of result.missingAllowlists) {
+        const sides = missing.missingSides.join(' and ');
+        violations.push({
+            file: missing.blueprintSlug,
+            message: `MISSING ALLOWLIST: cross-org dep from '${missing.sourceOrg}' → '${missing.targetOrg}'` +
+                ` in blueprint '${missing.blueprintSlug}' (target: ${missing.targetRepo}).` +
+                ` Missing allowlist on ${sides} side(s).` +
+                ` Add mutual entries to .agent/correlate.allow.yaml in both repos.`,
+        });
+    }
+    const checked = result.leaks.length + result.missingAllowlists.length;
+    return {
+        ok: result.pass,
+        title: 'Cross-repo correlation',
+        checked: Math.max(checked, 1),
+        violations,
+    };
+}
+//# sourceMappingURL=cross-repo-correlation.js.map

package/dist/esm/audit/gitignore-agent-surfaces.d.ts

@@ -0,0 +1,3 @@
+import type { RepoAuditResult } from './repo-guardrails.js';
+export declare function auditGitignoreAgentSurfaces(cwd: string): Promise<RepoAuditResult>;
+//# sourceMappingURL=gitignore-agent-surfaces.d.ts.map

package/dist/esm/audit/gitignore-agent-surfaces.js

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { GENERATED_PATHS_BLOCK } from '#cli/commands/init/gitignore-patcher';
+const EXPECTED_PATHS = GENERATED_PATHS_BLOCK.patterns.filter((line) => !line.startsWith('#'));
+function lastMatchingRule(lines, expected) {
+    let last;
+    const negatedPrefix = `!${expected}`;
+    for (const line of lines) {
+        if (line === expected || line === `!${expected}` || line.startsWith(negatedPrefix)) {
+            last = line;
+        }
+    }
+    return last;
+}
+export async function auditGitignoreAgentSurfaces(cwd) {
+    const gitignorePath = join(cwd, '.gitignore');
+    const violations = [];
+    if (!existsSync(gitignorePath)) {
+        return {
+            ok: false,
+            title: 'gitignore agent surfaces',
+            checked: EXPECTED_PATHS.length,
+            violations: [
+                { file: '.gitignore', message: '.gitignore not found — run `wp setup` to scaffold it' },
+            ],
+        };
+    }
+    let content;
+    try {
+        content = readFileSync(gitignorePath, 'utf-8');
+    }
+    catch {
+        return {
+            ok: false,
+            title: 'gitignore agent surfaces',
+            checked: EXPECTED_PATHS.length,
+            violations: [{ file: '.gitignore', message: 'failed to read .gitignore' }],
+        };
+    }
+    const lines = content
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((line) => line.length > 0 && !line.startsWith('#'));
+    const lineSet = new Set(lines);
+    for (const expected of EXPECTED_PATHS) {
+        if (!lineSet.has(expected)) {
+            violations.push({
+                file: '.gitignore',
+                message: `Missing gitignore entry: ${expected} — run \`wp setup\` to add generated agent surface paths`,
+            });
+            continue;
+        }
+        const last = lastMatchingRule(lines, expected);
+        if (last?.startsWith('!')) {
+            violations.push({
+                file: '.gitignore',
+                message: `Gitignore entry ${expected} is overridden by later exception ${last} — run \`wp setup\` to move the generated surface block to the end`,
+            });
+        }
+    }
+    return {
+        ok: violations.length === 0,
+        title: 'gitignore agent surfaces',
+        checked: EXPECTED_PATHS.length,
+        violations,
+    };
+}
+//# sourceMappingURL=gitignore-agent-surfaces.js.map