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

package/dist/core/session.js

@@ -1,377 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
-import { resolve } from 'node:path';
-export function openSession(root) {
-    const pugiDir = resolve(root, '.pugi');
-    const enabled = existsSync(pugiDir);
-    const id = `local-${Date.now()}-${randomUUID()}`;
-    const eventsPath = resolve(pugiDir, 'events.jsonl');
-    if (enabled) {
-        mkdirSync(pugiDir, { recursive: true });
-        appendEvent({ id: randomUUID(), sessionId: id, timestamp: now(), type: 'session', name: 'created' }, eventsPath);
-    }
-    return {
-        id,
-        root,
-        pugiDir,
-        eventsPath,
-        enabled,
-        verificationLedger: [],
-    };
-}
-/**
- * PUGI-VERIFY-GATE — append a verification ledger entry. Mutates
- * `session.verificationLedger` in place AND mirrors the entry to
- * the JSONL audit log when the session is enabled. Pure helper
- * (no I/O on disabled sessions); safe to call from sync code
- * paths.
- *
- * The bash tool dispatcher calls this after every shell exec whose
- * head matches a `VERIFICATION_PATTERNS` entry.
- */
-export function recordVerificationCall(session, entry) {
-    session.verificationLedger.push(entry);
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'verification',
-        name: 'call_recorded',
-        tool: entry.tool,
-        command: entry.command,
-        exitCode: entry.exitCode,
-        tailStderrLen: entry.tailStderr.length,
-    }, session.eventsPath);
-}
-/**
- * MVP — fire the `SessionStart` lifecycle event for all hooks
- * declared in `~/.pugi/hooks-mvp.json`. Single-call surface; the REPL
- * boot path invokes this once after `openSession`. Best-effort: any
- * failure (missing config, hook spawn error) is swallowed so a
- * misconfigured hook can never crash the REPL.
- *
- * Returns the number of hooks that fired (0 when no config / no
- * matching hooks). Tests assert on the return value as the
- * single-call invariant.
- */
-export async function fireSessionStartMvp(session) {
-    try {
-        const { loadHooksConfig, fireHooks } = await import('./hooks/index.js');
-        // Defense-in-depth: `loadHooksConfig` is contractually non-null
-        // (returns `HooksConfig.empty(path)` when the file is absent), but
-        // the dynamic import boundary above can in principle return an
-        // unexpected shape if the module is mis-resolved at runtime. Guard
-        // the optional-chained `isEmpty()` call so a malformed loader can
-        // never raise `TypeError: Cannot read properties of undefined` and
-        // crash the REPL boot path. Belt-and-suspenders with the
-        // surrounding try/catch — the catch still swallows everything else.
-        const config = loadHooksConfig();
-        if (!config || config.isEmpty())
-            return 0;
-        const outcome = await fireHooks({
-            config,
-            event: 'SessionStart',
-            payload: {
-                event: 'SessionStart',
-                sessionId: session.id,
-                workspaceRoot: session.root,
-                startedAt: new Date().toISOString(),
-            },
-            workspaceRoot: session.root,
-        });
-        return outcome.results.length;
-    }
-    catch {
-        // SessionStart is never blocking — log nothing, return 0. A
-        // broken `hooks-mvp.json` is surfaced via `pugi hooks doctor`.
-        return 0;
-    }
-}
-/**
- * P1 — fire the v2 `SessionStart` event from `~/.pugi/hooks.json`
- * (global) + `<workspaceRoot>/.pugi/hooks.json` (project). Companion to
- * `fireSessionStartMvp`; both surfaces run because they read different
- * config files.
- *
- * Headless by default (no trust prompt) — the v2 trust ledger gates
- * first-run executions. Operators with no prior trust decision will see
- * the SessionStart hook skipped with a `denied by trust ledger` stderr
- * note; running `pugi hooks trust allow <command>` enrolls it.
- *
- * Returns the number of hooks that ran (excluding trust-denied skips).
- * Never throws.
- */
-export async function fireSessionStartV2(session) {
-    try {
-        const { fireSessionStart } = await import('./hooks/v2/index.js');
-        const outcome = await fireSessionStart({
-            sessionId: session.id,
-            workspaceRoot: session.root,
-            transcriptPath: session.eventsPath,
-            permissionMode: 'ask',
-        });
-        return outcome.results.filter((r) => r.exitCode !== -1).length;
-    }
-    catch {
-        return 0;
-    }
-}
-/**
- * P1 — fire the v2 `SessionEnd` event. Called by the REPL
- * teardown path. Companion to `fireSessionStartV2`.
- */
-export async function fireSessionEndV2(session) {
-    try {
-        const { fireSessionEnd } = await import('./hooks/v2/index.js');
-        const outcome = await fireSessionEnd({
-            sessionId: session.id,
-            workspaceRoot: session.root,
-            transcriptPath: session.eventsPath,
-            permissionMode: 'ask',
-        });
-        return outcome.results.filter((r) => r.exitCode !== -1).length;
-    }
-    catch {
-        return 0;
-    }
-}
-export function recordCommandStarted(session, command) {
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'session',
-        name: 'command_started',
-        command,
-    }, session.eventsPath);
-}
-export function recordCommandCompleted(session, command, status) {
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'session',
-        name: 'command_completed',
-        command,
-        status,
-    }, session.eventsPath);
-}
-export function recordToolCall(session, tool, inputSummary) {
-    const id = randomUUID();
-    if (!session.enabled)
-        return id;
-    appendEvent({
-        id,
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'tool_call',
-        tool,
-        inputSummary,
-    }, session.eventsPath);
-    return id;
-}
-export function recordToolResult(session, toolCallId, status, outputSummary) {
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'tool_result',
-        toolCallId,
-        status,
-        outputSummary,
-    }, session.eventsPath);
-}
-export function recordFileMutation(session, input) {
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'file_mutation',
-        ...input,
-    }, session.eventsPath);
-}
-export function recordHookInvoked(session, input) {
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'hook.invoked',
-        event: input.event,
-        matchSummary: input.matchSummary,
-        runSummary: input.runSummary,
-    }, session.eventsPath);
-}
-export function recordHookResult(session, input) {
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'hook.result',
-        event: input.event,
-        ok: input.ok,
-        exitCode: input.exitCode,
-        elapsedMs: input.elapsedMs,
-        stdoutLen: input.stdoutLen,
-        stderrLen: input.stderrLen,
-    }, session.eventsPath);
-}
-export function recordHookSkipped(session, input) {
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'hook.skipped',
-        event: input.event,
-        reason: input.reason,
-    }, session.eventsPath);
-}
-/**
- * Record a `subagent.spawned` event in the session audit log. Inputs
- * arrive untyped (the dispatcher emits JSON to stay decoupled from this
- * module); the recorder validates the role and isolation at the typed
- * audit-event union boundary, so a malformed role would fail at the
- * `AuditEvent` cast site rather than silently writing garbage. The cast
- * itself is the load-bearing check: `assertSubagentRole` and
- * `assertSubagentIsolation` narrow at runtime.
- */
-export function recordSubagentSpawned(session, input) {
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'subagent.spawned',
-        taskId: input.taskId,
-        role: assertSubagentRole(input.role),
-        personaSlug: input.personaSlug,
-        parentSessionId: input.parentSessionId,
-        isolation: assertSubagentIsolation(input.isolation),
-    }, session.eventsPath);
-}
-export function recordSubagentToolCall(session, input) {
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'subagent.tool_call',
-        taskId: input.taskId,
-        role: assertSubagentRole(input.role),
-        personaSlug: input.personaSlug,
-        toolName: input.toolName,
-        toolCallId: input.toolCallId,
-    }, session.eventsPath);
-}
-export function recordSubagentCompleted(session, input) {
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'subagent.completed',
-        taskId: input.taskId,
-        role: assertSubagentRole(input.role),
-        personaSlug: input.personaSlug,
-        toolCallCount: input.toolCallCount,
-        tokensIn: input.tokensIn,
-        tokensOut: input.tokensOut,
-        durationMs: input.durationMs,
-    }, session.eventsPath);
-}
-export function recordSubagentBlocked(session, input) {
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'subagent.blocked',
-        taskId: input.taskId,
-        role: assertSubagentRole(input.role),
-        personaSlug: input.personaSlug,
-        reason: assertSubagentBlockedReason(input.reason),
-        detail: input.detail,
-    }, session.eventsPath);
-}
-export function recordSubagentFailed(session, input) {
-    if (!session.enabled)
-        return;
-    appendEvent({
-        id: randomUUID(),
-        sessionId: session.id,
-        timestamp: now(),
-        type: 'subagent.failed',
-        taskId: input.taskId,
-        role: assertSubagentRole(input.role),
-        personaSlug: input.personaSlug,
-        error: input.error,
-    }, session.eventsPath);
-}
-const SUBAGENT_ROLES = new Set([
-    'orchestrator',
-    'architect',
-    'coder',
-    'verifier',
-    'reviewer',
-    'researcher',
-    'release',
-    'devops',
-    'design_qa',
-]);
-const SUBAGENT_ISOLATIONS = new Set([
-    'prompt_only',
-    'shared_fs_readonly',
-    'shared_fs_serialized',
-    'worktree',
-    'remote_vm',
-]);
-const SUBAGENT_BLOCKED_REASONS = new Set([
-    'budget_exhausted',
-    'plan_mode_refused',
-    'permission_denied',
-    'tool_unavailable',
-]);
-function assertSubagentRole(value) {
-    if (!SUBAGENT_ROLES.has(value)) {
-        throw new Error(`recordSubagent*: unknown role '${value}'`);
-    }
-    return value;
-}
-function assertSubagentIsolation(value) {
-    if (!SUBAGENT_ISOLATIONS.has(value)) {
-        throw new Error(`recordSubagent*: unknown isolation '${value}'`);
-    }
-    return value;
-}
-function assertSubagentBlockedReason(value) {
-    if (!SUBAGENT_BLOCKED_REASONS.has(value)) {
-        throw new Error(`recordSubagent*: unknown blocked reason '${value}'`);
-    }
-    return value;
-}
-function appendEvent(event, eventsPath) {
-    appendFileSync(eventsPath, `${JSON.stringify(event)}\n`, { encoding: 'utf8', mode: 0o600 });
-}
-function now() {
-    return new Date().toISOString();
-}
-//# sourceMappingURL=session.js.map