@pugi/cli 0.1.0-alpha.9 → 0.1.0-beta.2

package/dist/core/agents/loader.js

@@ -0,0 +1,104 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { assertValidSlug, parseSkillMarkdown } from '../skills/loader.js';
+export function globalAgentsDir() {
+    const home = process.env.PUGI_HOME ?? resolve(homedir(), '.pugi');
+    return join(home, 'agents');
+}
+export function workspaceAgentsDir(workspaceRoot) {
+    return join(workspaceRoot, '.pugi', 'agents');
+}
+export function globalAgentPath(slug) {
+    assertValidSlug(slug, 'agent');
+    return join(globalAgentsDir(), `${slug}.md`);
+}
+export function workspaceAgentPath(workspaceRoot, slug) {
+    assertValidSlug(slug, 'agent');
+    return join(workspaceAgentsDir(workspaceRoot), `${slug}.md`);
+}
+export function listAgents(scope, workspaceRoot) {
+    const dir = scope === 'global' ? globalAgentsDir() : workspaceAgentsDir(workspaceRoot);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((name) => name.endsWith('.md'))
+        .sort((a, b) => a.localeCompare(b))
+        .map((name) => loadAgent(join(dir, name), scope))
+        .filter((agent) => agent !== null);
+}
+function loadAgent(filePath, scope) {
+    try {
+        const source = readFileSync(filePath, 'utf8');
+        const parsed = parseSkillMarkdown(source);
+        // Files under `<scope>/.pugi/agents/` are agents by construction;
+        // the loader override here forces metadata.type=agent even when the
+        // upstream frontmatter (e.g. Anthropic flat dialect) omitted the
+        // declaration. We never mis-categorise a `<dir>/.pugi/agents/foo.md`
+        // file as a skill.
+        if (parsed.frontmatter.metadata.type !== 'agent' &&
+            parsed.frontmatter.metadata.type !== 'skill') {
+            return null;
+        }
+        const slug = filePath.split('/').pop()?.replace(/\.md$/, '') ?? parsed.frontmatter.name;
+        // Filenames on disk are produced by installAgent (which validates)
+        // OR placed manually by the operator. Validate before exposing the
+        // slug to the rest of the system so trust keys + log lines never
+        // carry a hostile string.
+        assertValidSlug(slug, 'agent');
+        const frontmatter = {
+            ...parsed.frontmatter,
+            metadata: { ...parsed.frontmatter.metadata, type: 'agent' },
+        };
+        return {
+            slug,
+            scope,
+            filePath,
+            frontmatter,
+            body: parsed.body,
+            source,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function installAgent(input) {
+    // Fail-closed before any filesystem mutation. assertValidSlug also
+    // runs inside globalAgentPath/workspaceAgentPath but we surface it
+    // explicitly here so the error fires before mkdirSync.
+    assertValidSlug(input.slug, 'agent');
+    const target = input.scope === 'global'
+        ? globalAgentPath(input.slug)
+        : workspaceAgentPath(input.workspaceRoot, input.slug);
+    mkdirSync(dirname(target), { recursive: true });
+    const srcFile = pickAgentFile(input.payloadDir);
+    writeFileSync(target, readFileSync(srcFile), { mode: 0o600 });
+    return target;
+}
+function pickAgentFile(payloadDir) {
+    const stat = statSync(payloadDir);
+    if (stat.isFile())
+        return payloadDir;
+    const entries = readdirSync(payloadDir).filter((name) => name.toLowerCase().endsWith('.md'));
+    if (entries.length === 0) {
+        throw new Error('AGENT_INSTALL: payload directory contains no .md file');
+    }
+    if (entries.length > 1) {
+        throw new Error(`AGENT_INSTALL: payload directory contains ${entries.length} .md files (expected exactly 1)`);
+    }
+    const first = entries[0];
+    if (!first) {
+        throw new Error('AGENT_INSTALL: payload directory contains no .md file');
+    }
+    return join(payloadDir, first);
+}
+export function removeAgent(slug, scope, workspaceRoot) {
+    assertValidSlug(slug, 'agent');
+    const target = scope === 'global' ? globalAgentPath(slug) : workspaceAgentPath(workspaceRoot, slug);
+    if (!existsSync(target))
+        return false;
+    rmSync(target, { force: true });
+    return true;
+}
+//# sourceMappingURL=loader.js.map

package/dist/core/agents/registry.js

@@ -34,7 +34,7 @@ function requirePersona(slug) {
  * pipeline already merges the two surfaces.
  */
 export const SUBAGENT_REGISTRY = [
-    { role: 'orchestrator', persona: requirePersona('main') }, // Mira (Pug)
+    { role: 'orchestrator', persona: requirePersona('main') }, // Pugi (Pug)
     { role: 'architect', persona: requirePersona('architect') }, // Marcus (Owl)
     { role: 'coder', persona: requirePersona('dev') }, // Hiroshi (Wolf)
     { role: 'verifier', persona: requirePersona('qa') }, // Vera (Fox)

package/dist/core/consensus/anvil-fanout.js

@@ -0,0 +1,276 @@
+/**
+ * Anvil fan-out — `pugi review --consensus` (α6.7).
+ *
+ * Posts the captured diff to Anvil's consensus endpoint and consumes the
+ * SSE stream that interleaves per-reviewer events (`type:"verdict"`) and
+ * the final consensus event (`type:"consensus"`).
+ *
+ * Endpoint contract (admin-api side, ships as α6.7.1 follow-up):
+ *
+ *   POST {apiUrl}/api/pugi/review-consensus
+ *   Authorization: Bearer {apiKey}
+ *   Content-Type: application/json
+ *   Body: { diff, context: { branch, commit, title } }
+ *   Response: text/event-stream
+ *     data: { reviewer: "codex"|"claude"|"deepseek", type:"started" }
+ *     data: { reviewer, type:"verdict", severity:"P0|P1|P2|P3|CLEAN",
+ *             rawContent:"<reviewer text>", latencyMs, error? }
+ *     data: { type:"consensus", rubric_verdict, reasoning }
+ *
+ * The CLI side does NOT trust the server's `rubric_verdict` — we recompute
+ * it locally from the per-reviewer verdicts so a malformed / forged server
+ * cannot weaken the gate. The server-side verdict comes through as a
+ * cross-check (logged when it disagrees with the client rubric).
+ *
+ * Graceful degradation:
+ *
+ *   - 404 from runtime  → "endpoint_missing" (admin-api endpoint pending,
+ *                         α6.7 ships CLI-only). Caller falls back to the
+ *                         legacy `pugi review --triple --remote` flow OR
+ *                         prints a "backend not deployed" notice depending
+ *                         on the operator's invocation.
+ *   - 401/403 / 429     → matching status with an actionable message.
+ *   - 5xx / timeout     → "failed" with the truncated body.
+ *
+ * Local-first contract (ADR-0037): this module never touches the disk,
+ * never logs the diff payload, and never retries on transient errors.
+ */
+/**
+ * Dispatch the consensus request and stream events back through `sink`
+ * until the SSE stream closes OR a transport error occurs.
+ *
+ * Returns the collected reviewer events plus the server's final consensus
+ * event (if it sent one). The caller computes the authoritative rubric
+ * locally from the reviewer events.
+ */
+export async function dispatchConsensus(config, request, sink) {
+    const url = `${config.apiUrl.replace(/\/+$/, '')}/api/pugi/review-consensus`;
+    const controller = new AbortController();
+    // Idle timeout: aborts the request when no SSE chunk has been
+    // received for `timeoutMs`. A one-shot setTimeout from request-start
+    // would kill long-running reviewers (codex ~30s, claude ~60s) even
+    // though the server is actively streaming events every few seconds.
+    // `resetIdleTimeout` is called from `parseSseStream` on each chunk.
+    let idleTimer = null;
+    const resetIdleTimeout = () => {
+        if (idleTimer)
+            clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => controller.abort(), config.timeoutMs);
+    };
+    resetIdleTimeout();
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                accept: 'text/event-stream',
+                authorization: `Bearer ${config.apiKey}`,
+                'user-agent': 'pugi-cli-consensus/0.1.0',
+            },
+            body: JSON.stringify(request),
+            signal: controller.signal,
+        });
+        const code = res.status;
+        if (code === 404) {
+            return {
+                status: 'endpoint_missing',
+                code,
+                message: 'POST /api/pugi/review-consensus not deployed on this runtime (α6.7.1 follow-up).',
+            };
+        }
+        if (code === 401 || code === 403) {
+            return {
+                status: 'unauthenticated',
+                code,
+                message: `runtime rejected credentials (HTTP ${code})`,
+            };
+        }
+        if (code === 429) {
+            const header = res.headers.get('retry-after');
+            const retryAfterMs = header ? Number.parseInt(header, 10) * 1000 : 60_000;
+            return {
+                status: 'rate_limited',
+                code,
+                retryAfterMs: Number.isFinite(retryAfterMs) ? retryAfterMs : 60_000,
+                message: 'runtime rate limit reached for this tenant',
+            };
+        }
+        if (code !== 200) {
+            const text = await safeText(res);
+            return {
+                status: 'failed',
+                code,
+                message: `runtime returned HTTP ${code}${text ? `: ${text.slice(0, 200)}` : ''}`,
+            };
+        }
+        // 200 — consume the SSE stream. Surface a graceful failure if the
+        // body is missing (some intermediaries strip it on long-poll).
+        if (!res.body) {
+            return {
+                status: 'failed',
+                code,
+                message: 'runtime returned 200 but no SSE body',
+            };
+        }
+        const reviewerEvents = [];
+        let serverVerdict = null;
+        for await (const event of parseSseStream(res.body, resetIdleTimeout)) {
+            if (event.type === 'consensus') {
+                serverVerdict = event;
+                sink(event);
+            }
+            else {
+                reviewerEvents.push(event);
+                sink(event);
+            }
+        }
+        return { status: 'ok', serverVerdict, reviewerEvents };
+    }
+    catch (error) {
+        const message = error instanceof Error
+            ? error.name === 'AbortError'
+                ? `runtime call idle for more than ${config.timeoutMs}ms`
+                : error.message
+            : 'unknown error';
+        return { status: 'failed', code: 0, message };
+    }
+    finally {
+        if (idleTimer)
+            clearTimeout(idleTimer);
+    }
+}
+/**
+ * Async-iterable SSE parser. Spec'd against the
+ * [HTML SSE spec](https://html.spec.whatwg.org/multipage/server-sent-events.html):
+ *
+ *   - Events are delimited by a blank line.
+ *   - Each line is `field:value` (whitespace after `:` stripped).
+ *   - Multiple `data:` lines in one event concatenate with `\n`.
+ *   - We only care about `data:` payloads carrying JSON; everything
+ *     else (event:, id:, retry:) is ignored.
+ *
+ * The parser tolerates JSON-parse failures by dropping the malformed
+ * event and continuing; a single bad event must not block the consensus
+ * gate. Errors are surfaced to the sink as an `error` reviewer event
+ * with `reviewer:"stream"`.
+ */
+export async function* parseSseStream(body, onChunk) {
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+    // Bridge Node ReadableStream and web ReadableStream. The web type has
+    // `getReader()`; the Node type is an `AsyncIterable<Buffer>`. Detect
+    // by feature so the parser works regardless of which fetch impl wrote
+    // the body.
+    const chunks = toAsyncIterable(body);
+    for await (const chunk of chunks) {
+        // Signal liveness so the dispatcher can reset its idle timeout. Any
+        // bytes received counts: even a heartbeat comment line keeps the
+        // connection alive from our perspective.
+        if (onChunk)
+            onChunk();
+        buffer += decoder.decode(chunk, { stream: true });
+        // SSE event boundary is a blank line. The spec allows either LF
+        // (`\n\n`) OR CRLF (`\r\n\r\n`). nginx, CDNs, and some load
+        // balancers rewrite to CRLF, so we accept both and find whichever
+        // delimiter appears first in the buffer.
+        let boundary = findNextEventBoundary(buffer);
+        while (boundary !== null) {
+            const rawEvent = buffer.slice(0, boundary.start);
+            buffer = buffer.slice(boundary.end);
+            const parsed = parseSseEvent(rawEvent);
+            if (parsed)
+                yield parsed;
+            boundary = findNextEventBoundary(buffer);
+        }
+    }
+    // Flush trailing event if the server omitted the final blank line.
+    const tail = buffer.trim();
+    if (tail.length > 0) {
+        const parsed = parseSseEvent(tail);
+        if (parsed)
+            yield parsed;
+    }
+}
+/**
+ * Find the next SSE event boundary in `buffer`. Returns the start
+ * index of the delimiter and the index where the next event begins,
+ * or `null` if no complete boundary has been buffered yet.
+ *
+ * Accepts both `\n\n` (Unix-style streams) and `\r\n\r\n` (CRLF, as
+ * emitted by nginx, Cloudflare, and some Node intermediaries). Picks
+ * whichever appears FIRST so a stream that mixes both styles parses
+ * deterministically.
+ */
+function findNextEventBoundary(buffer) {
+    const lfIdx = buffer.indexOf('\n\n');
+    const crlfIdx = buffer.indexOf('\r\n\r\n');
+    if (lfIdx === -1 && crlfIdx === -1)
+        return null;
+    if (crlfIdx === -1)
+        return { start: lfIdx, end: lfIdx + 2 };
+    if (lfIdx === -1)
+        return { start: crlfIdx, end: crlfIdx + 4 };
+    if (lfIdx < crlfIdx)
+        return { start: lfIdx, end: lfIdx + 2 };
+    return { start: crlfIdx, end: crlfIdx + 4 };
+}
+function parseSseEvent(raw) {
+    const dataLines = [];
+    for (const line of raw.split(/\r?\n/)) {
+        // The SSE spec strips one leading space after the colon if present.
+        // We do the same so payloads written `data: {...}` parse correctly.
+        if (!line.startsWith('data:'))
+            continue;
+        const value = line.slice('data:'.length);
+        dataLines.push(value.startsWith(' ') ? value.slice(1) : value);
+    }
+    if (dataLines.length === 0)
+        return null;
+    const payload = dataLines.join('\n').trim();
+    if (payload.length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(payload);
+        if (parsed && typeof parsed === 'object' && typeof parsed['type'] === 'string') {
+            // Trust shape coming from the server enough to forward it; the
+            // command handler treats unknown fields defensively.
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function toAsyncIterable(body) {
+    // Web ReadableStream → iterate via reader.read() loop bridged to async-iter.
+    if (typeof body.getReader === 'function') {
+        return webStreamToAsyncIterable(body);
+    }
+    // Node Readable: already async-iterable.
+    return body;
+}
+async function* webStreamToAsyncIterable(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            if (value)
+                yield value;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+async function safeText(res) {
+    try {
+        return await res.text();
+    }
+    catch {
+        return '';
+    }
+}
+//# sourceMappingURL=anvil-fanout.js.map