@pugi/cli 0.1.0-beta.99 → 1.0.0-alpha.2

package/dist/core/policy-limits/etag-store.js

@@ -1,122 +0,0 @@
-/**
- * ETag-cached policy limits store .
- *
- * Enterprise customers expose a `policyLimits` document at a stable URL
- * (tool allowlist, network egress rules, per-tenant token caps, secret
- * patterns, etc.). Re-fetching this document на every engine call
- * burns latency и bandwidth даже когда content has not changed.
- * CC's pattern (per audit memo): cache by ETag и conditional-GET via
- * `If-None-Match` header. Server returns 304 — Pugi keeps using the
- * cached document.
- *
- * This module is the pure cache layer. Caller supplies a transport
- * function (mockable) that performs the actual HTTP request и returns
- * `{ status, etag, body }`. We handle:
- *
- *  - Initial fetch (200 → cache body + etag)
- *  - Conditional refresh (304 → reuse cached)
- *  - Forced refresh (skip If-None-Match)
- *  - TTL fallback (refresh после maxAgeSec even на 304-friendly URL)
- *  - Stale-while-revalidate semantics — return cached immediately,
- *    refresh in background, never block caller
- *
- * Pure-ish: state lives в the store instance, no globals.
- */
-const DEFAULT_MAX_AGE_SEC = 600;
-export class PolicyLimitsStore {
-    options;
-    cached = null;
-    inFlight = null;
-    maxAgeMs;
-    constructor(options) {
-        this.options = options;
-        const sec = options.maxAgeSec ?? DEFAULT_MAX_AGE_SEC;
-        if (sec < 0)
-            throw new RangeError(`maxAgeSec must be >= 0, got ${sec}`);
-        this.maxAgeMs = sec * 1000;
-    }
-    /**
-     * Return the current policy doc, refreshing когда the cache is empty
-     * or TTL expired. Concurrent calls share a single in-flight fetch.
-     */
-    async get() {
-        if (this.cached && !this.isExpired(this.cached)) {
-            return this.cached.body;
-        }
-        return (await this.refreshInternal()).body;
-    }
-    /** Force a network refresh, bypassing ETag и TTL. */
-    async forceRefresh() {
-        this.cached = null;
-        return (await this.refreshInternal()).body;
-    }
-    /**
-     * Stale-while-revalidate: return cached body immediately когда present,
-     * fire a background refresh без awaiting. First call (no cache) still
-     * blocks для initial fetch.
-     */
-    async getStaleWhileRevalidate() {
-        if (this.cached) {
-            if (this.isExpired(this.cached) && !this.inFlight) {
-                // Fire-and-forget refresh — ignore rejection (next get() retries)
-                void this.refreshInternal().catch(() => { });
-            }
-            return this.cached.body;
-        }
-        return (await this.refreshInternal()).body;
-    }
-    /** Peek the cached entry without triggering a refresh. */
-    peek() {
-        return this.cached;
-    }
-    /** Drop the cache. Next get() will hit the transport unconditionally. */
-    invalidate() {
-        this.cached = null;
-    }
-    isExpired(entry) {
-        if (this.maxAgeMs === 0)
-            return false;
-        return Date.now() - entry.cachedAt > this.maxAgeMs;
-    }
-    async refreshInternal() {
-        if (this.inFlight)
-            return this.inFlight;
-        this.inFlight = this.doFetch();
-        try {
-            return await this.inFlight;
-        }
-        finally {
-            this.inFlight = null;
-        }
-    }
-    async doFetch() {
-        const ifNoneMatch = this.cached?.etag ?? null;
-        const response = await this.options.transport({ ifNoneMatch });
-        if (response.status === 304) {
-            if (!this.cached) {
-                throw new Error('transport returned 304 без cached entry — server bug or initial-fetch race');
-            }
-            // Refresh cachedAt so TTL window slides forward
-            const refreshed = {
-                etag: this.cached.etag,
-                body: this.cached.body,
-                cachedAt: Date.now(),
-            };
-            this.cached = refreshed;
-            this.options.onRefresh?.(refreshed);
-            return refreshed;
-        }
-        if (response.status !== 200 || response.body === undefined) {
-            throw new Error(`transport returned unexpected response: status=${response.status}`);
-        }
-        const entry = {
-            etag: response.etag ?? '',
-            body: response.body,
-            cachedAt: Date.now(),
-        };
-        this.cached = entry;
-        this.options.onRefresh?.(entry);
-        return entry;
-    }
-}
-//# sourceMappingURL=etag-store.js.map

package/dist/core/prd-check/parser.js

@@ -1,215 +0,0 @@
-/**
- * PRD parser — Pugi  (`/prd-check`).
- *
- * Reads a markdown PRD file and extracts the acceptance-criteria
- * section into a list of verifiable criteria. The parser is
- * intentionally narrow: it owns ONE function, accepts raw markdown
- * source as a string (no fs I/O), and returns a structured list the
- * verifier module can fan out over.
- *
- * Why two phases (parse → verify) instead of a single pass:
- *
- *  - keeps the parser deterministic + fast (pure string in, JSON
- *    out — trivial to unit-test without touching the filesystem)
- *
- *  - lets the reporter render the criterion list even when every
- *    verifier fails, so operators see WHAT failed before WHY
- *
- *  - mirrors the L17 doctor split: `probe-runner` runs a set of
- *    probe descriptors → identical contract here, just for PRD
- *    acceptance items instead of environment probes
- *
- * Heading recognition is tolerant by design: PRD authors use both
- * `## Acceptance Criteria` and `## Success Criteria`, sometimes with
- * a trailing colon, sometimes inside an h3. We accept any h2/h3
- * matching either label (case-insensitive). The first matching
- * section wins; subsequent matches are ignored so a PRD with both
- * sections does not double-count items.
- *
- * Item recognition supports two shapes documented in the wave-6
- * spec:
- *
- *  1. numbered lists     `1. <text>` / `1) <text>`
- *  2. markdown checklists `- [ ] <text>` / `- [x] <text>`
- *
- * Either shape may include inline mentions the verifier extracts:
- * file paths (`apps/foo/bar.ts`), test specs (`*.spec.ts`),
- * route declarations (`GET /api/x`), CLI commands (`pugi prd-check`),
- * and doc references (`docs/foo.md`). The parser captures these
- * verbatim into `mentions` so the verifier module can fan checks
- * without re-tokenising the prose.
- */
-const ACCEPTANCE_HEADING_RE = /^(#{2,3})\s+(acceptance criteria|success criteria|deliverables)\b\s*:?\s*$/i;
-const ANY_HEADING_RE = /^(#{1,6})\s+\S/;
-const TITLE_HEADING_RE = /^#\s+(.+?)\s*$/;
-const NUMBERED_ITEM_RE = /^(\s*)(\d+)[\.)]\s+(.+?)\s*$/;
-const CHECKLIST_ITEM_RE = /^(\s*)-\s+\[([ xX])\]\s+(.+?)\s*$/;
-/**
- * Public entry: parse a markdown PRD source into `ParsedPrd`. Pure
- * function — no filesystem, no logging. The CLI handler is
- * responsible for reading the file and forwarding the contents.
- */
-export function parsePrd(source) {
-    const lines = source.split(/\r?\n/);
-    const title = extractTitle(lines);
-    const range = findAcceptanceRange(lines);
-    if (!range) {
-        return { title, hasAcceptanceSection: false, criteria: [] };
-    }
-    const sectionLines = lines.slice(range.start, range.end);
-    const criteria = extractCriteria(sectionLines);
-    return { title, hasAcceptanceSection: true, criteria };
-}
-/**
- * Extract verifiable mentions from a criterion text. Exported for
- * the verifier spec so tests can drive mention classification
- * without running the full parser.
- */
-export function extractMentions(text) {
-    const mentions = [];
-    const seen = new Set();
-    const push = (key, mention) => {
-        if (seen.has(key))
-            return;
-        seen.add(key);
-        mentions.push(mention);
-    };
-    // 1) Routes — `GET /api/path`, `POST /foo`, etc. Recognised
-    //   BEFORE file paths because the trailing `/` could otherwise
-    //   be mis-classified.
-    const routeRe = /\b(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(\/[A-Za-z0-9_./:\-]+)/g;
-    for (const match of text.matchAll(routeRe)) {
-        const method = match[1].toUpperCase();
-        const path = match[2];
-        push(`route:${method} ${path}`, { kind: 'route', method, path });
-    }
-    // 2) Backtick-wrapped tokens — most reliable signal. The parser
-    //   inspects each token and decides whether it is a path, a test
-    //   spec, a CLI command, or a route.
-    const backtickRe = /`([^`\n]+)`/g;
-    for (const match of text.matchAll(backtickRe)) {
-        const raw = match[1].trim();
-        classifyToken(raw, push);
-    }
-    // 3) Bare paths with at least one slash + an extension. Authors
-    //   sometimes forget the backticks; we still surface the file
-    //   so the verifier can attempt the check.
-    const barePathRe = /(?<![A-Za-z0-9])((?:[a-zA-Z0-9_.\-]+\/)+[a-zA-Z0-9_.\-]+\.[a-zA-Z0-9]{1,6})/g;
-    for (const match of text.matchAll(barePathRe)) {
-        const path = match[1];
-        classifyPath(path, push);
-    }
-    return mentions;
-}
-function classifyToken(raw, push) {
-    const trimmed = raw.replace(/[,;.]+$/u, '').trim();
-    if (trimmed.length === 0)
-        return;
-    // Route shape inside backticks (`GET /api/x`).
-    const routeMatch = trimmed.match(/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(\/[A-Za-z0-9_./:\-]+)$/u);
-    if (routeMatch) {
-        const method = routeMatch[1].toUpperCase();
-        const path = routeMatch[2];
-        push(`route:${method} ${path}`, { kind: 'route', method, path });
-        return;
-    }
-    // Pugi command — `pugi <name>` or `/<name>`. Slash form covers
-    // REPL slash commands; pugi form covers shell commands.
-    const pugiCmdMatch = trimmed.match(/^pugi\s+([a-z][a-z0-9-]*)(?:\s+.*)?$/u);
-    if (pugiCmdMatch) {
-        const name = pugiCmdMatch[1];
-        push(`command:${name}`, { kind: 'command', name });
-        return;
-    }
-    const slashCmdMatch = trimmed.match(/^\/([a-z][a-z0-9-]*)$/u);
-    if (slashCmdMatch) {
-        const name = slashCmdMatch[1];
-        push(`command:${name}`, { kind: 'command', name });
-        return;
-    }
-    // Path shape — must contain at least one `/` AND an extension.
-    if (trimmed.includes('/') && /\.[a-zA-Z0-9]{1,6}$/.test(trimmed)) {
-        classifyPath(trimmed, push);
-    }
-}
-function classifyPath(path, push) {
-    if (/\.spec\.[a-z]+$|\.test\.[a-z]+$/u.test(path)) {
-        push(`test:${path}`, { kind: 'test', path });
-        return;
-    }
-    if (/^docs?\//u.test(path) || /\.md$/u.test(path)) {
-        push(`doc:${path}`, { kind: 'doc', path });
-        return;
-    }
-    push(`file:${path}`, { kind: 'file', path });
-}
-function extractTitle(lines) {
-    for (const line of lines) {
-        const match = line.match(TITLE_HEADING_RE);
-        if (match) {
-            return match[1].trim();
-        }
-    }
-    return null;
-}
-function findAcceptanceRange(lines) {
-    let startIdx = -1;
-    let startHeadingLevel = 0;
-    for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i];
-        const match = line.match(ACCEPTANCE_HEADING_RE);
-        if (match) {
-            startIdx = i + 1;
-            startHeadingLevel = match[1].length;
-            break;
-        }
-    }
-    if (startIdx === -1)
-        return null;
-    let endIdx = lines.length;
-    for (let i = startIdx; i < lines.length; i += 1) {
-        const line = lines[i];
-        const headingMatch = line.match(ANY_HEADING_RE);
-        if (!headingMatch)
-            continue;
-        const level = headingMatch[1].length;
-        if (level <= startHeadingLevel) {
-            endIdx = i;
-            break;
-        }
-    }
-    return { start: startIdx, end: endIdx };
-}
-function extractCriteria(sectionLines) {
-    const out = [];
-    let index = 0;
-    for (const line of sectionLines) {
-        const checklistMatch = line.match(CHECKLIST_ITEM_RE);
-        if (checklistMatch) {
-            index += 1;
-            const marker = checklistMatch[2].toLowerCase();
-            const text = checklistMatch[3];
-            out.push({
-                index,
-                text,
-                preChecked: marker === 'x',
-                mentions: extractMentions(text),
-            });
-            continue;
-        }
-        const numberedMatch = line.match(NUMBERED_ITEM_RE);
-        if (numberedMatch) {
-            index += 1;
-            const text = numberedMatch[3];
-            out.push({
-                index,
-                text,
-                preChecked: false,
-                mentions: extractMentions(text),
-            });
-            continue;
-        }
-    }
-    return out;
-}
-//# sourceMappingURL=parser.js.map

package/dist/core/prd-check/reporter.js

@@ -1,127 +0,0 @@
-/**
- * PRD-check reporter — Pugi  (`/prd-check`).
- *
- * Turns a list of `VerifiedCriterion` into either a plain-text
- * table (matches the L17 doctor renderer layout for visual
- * consistency) OR a structured JSON envelope for scripted callers.
- *
- * The reporter is intentionally render-only — it does not perform
- * any verification work. The verifier module decides PASS / FAIL /
- * SKIPPED; the reporter only formats those verdicts. This keeps
- * the JSON envelope deterministic + diff-friendly between runs.
- *
- * Exit-code policy:
- *
- *  - `healthy` -> every criterion PASS or SKIPPED. exit 0.
- *  - `failing` -> at least one FAIL. exit 1.
- *  - `unparsed` -> the PRD had no acceptance section. exit 2
- *                  (operator authored a stub but never filled it
- *                  in — distinct signal from "criteria don't
- *                  verify yet" so CI can route differently).
- */
-/**
- * Build the JSON envelope. Pure transform — no fs, no clock. The
- * CLI handler wraps this in the writeOutput sink.
- */
-export function buildEnvelope(input) {
-    const counts = {
-        pass: 0,
-        fail: 0,
-        skipped: 0,
-    };
-    for (const v of input.verified) {
-        counts[v.status] += 1;
-    }
-    const overall = computeOverall(input.hasAcceptanceSection, counts);
-    return {
-        command: 'prd-check',
-        prdPath: input.prdPath,
-        title: input.title,
-        overall,
-        counts,
-        criteria: input.verified.map((v) => ({
-            index: v.criterion.index,
-            text: v.criterion.text,
-            status: v.status,
-            results: v.results.map((r) => ({
-                kind: r.mention.kind,
-                target: mentionTarget(r.mention),
-                status: r.status,
-                evidence: r.evidence,
-            })),
-        })),
-    };
-}
-/** Exit code for the resolved overall verdict. */
-export function exitCodeFor(overall) {
-    switch (overall) {
-        case 'healthy':
-            return 0;
-        case 'failing':
-            return 1;
-        case 'unparsed':
-            return 2;
-    }
-}
-/**
- * Plain-text renderer. Mirrors the L17 doctor table for visual
- * consistency — 4 columns: # / STATUS / CRITERION / EVIDENCE. The
- * criterion column is truncated to 60 chars so narrow terminals
- * stay readable; the full text lives in the JSON envelope for
- * scripted callers that want every byte.
- */
-export function renderTable(envelope) {
-    const lines = [];
-    const titlePart = envelope.title ? ` — ${envelope.title}` : '';
-    lines.push(`Pugi PRD-check${titlePart}`);
-    lines.push('='.repeat(50));
-    lines.push(`Source: ${envelope.prdPath}`);
-    lines.push('');
-    if (envelope.overall === 'unparsed') {
-        lines.push('No acceptance-criteria section found in PRD.');
-        lines.push('');
-        lines.push('Expected one of:');
-        lines.push(' ## Acceptance Criteria');
-        lines.push(' ## Success Criteria');
-        lines.push(' ## Deliverables');
-        return lines.join('\n');
-    }
-    if (envelope.criteria.length === 0) {
-        lines.push('Acceptance section present but contains 0 items.');
-        return lines.join('\n');
-    }
-    for (const c of envelope.criteria) {
-        const status = c.status.toUpperCase().padEnd(7, ' ');
-        const truncated = c.text.length > 60 ? `${c.text.slice(0, 57)}...` : c.text;
-        lines.push(`#${String(c.index).padStart(2, ' ')} ${status} ${truncated}`);
-        for (const r of c.results) {
-            const subStatus = r.status.toUpperCase().padEnd(7, ' ');
-            lines.push(`       ${subStatus} ${r.evidence}`);
-        }
-    }
-    lines.push('');
-    const { pass, fail, skipped } = envelope.counts;
-    const summary = envelope.overall === 'healthy' ? 'HEALTHY' : envelope.overall === 'failing' ? 'FAILING' : 'UNPARSED';
-    lines.push(`${fail} fail · ${pass} pass · ${skipped} skipped. Overall: ${summary}`);
-    return lines.join('\n');
-}
-function computeOverall(hasAcceptanceSection, counts) {
-    if (!hasAcceptanceSection)
-        return 'unparsed';
-    if (counts.fail > 0)
-        return 'failing';
-    return 'healthy';
-}
-function mentionTarget(mention) {
-    switch (mention.kind) {
-        case 'file':
-        case 'test':
-        case 'doc':
-            return mention.path;
-        case 'command':
-            return mention.name;
-        case 'route':
-            return `${mention.method} ${mention.path}`;
-    }
-}
-//# sourceMappingURL=reporter.js.map