@pugi/cli 0.1.0-beta.9 → 0.1.0-beta.91

package/dist/runtime/commands/codegraph-status.js

@@ -0,0 +1,227 @@
+/**
+ * `/codegraph-status` runner —  .
+ *
+ * Single source of truth for the codegraph adoption + index-freshness
+ * surface. Used by:
+ *
+ *  - REPL slash `/codegraph-status` (the discoverable surface)
+ *  - REPL slash `/codegraph`       (short alias)
+ *
+ * The runner is intentionally narrow — every information surface
+ * (installed? / index age / symbol count / last reindex / refresh CTA)
+ * is computed from the workspace-local `.pugi/codegraph-decision.json`
+ * + the live `.pugi/mcp.json` + the bounded scanner at
+ * `core/codegraph/detect-repo.ts`. NO network round-trip; everything
+ * runs offline so an air-gapped operator still gets the status table.
+ *
+ * Flags:
+ *  --install — merge codegraph into .pugi/mcp.json (accept decision)
+ *  --reindex — stamp lastIndexedAt now + hint operator к run
+ *              `codegraph index` from a fresh shell. Pugi does NOT
+ *              spawn codegraph itself (no upstream dep guarantee).
+ *  --offer  — surface the install prompt even after a decline,
+ *              useful when the operator declined three weeks ago and
+ *              wants to revisit без waiting for the 30-day cadence.
+ *
+ * Brand voice gate: ASCII output, no emoji, no decorative dividers.
+ */
+import { resolve } from 'node:path';
+import { detectRepo } from '../../core/codegraph/detect-repo.js';
+import { detectCodegraphInstalled, CODEGRAPH_DOCS_URL, } from '../../core/codegraph/install.js';
+import { readDecision, markIndexed, indexAgeDays, STALE_INDEX_DAYS, } from '../../core/codegraph/decision-store.js';
+import { evaluateOffer, applyOfferDecision, emitOfferShown, } from '../../core/codegraph/offer-hook.js';
+export function parseCodegraphStatusArgs(args) {
+    const out = {
+        install: false,
+        reindex: false,
+        offer: false,
+        unknown: null,
+    };
+    for (const arg of args) {
+        switch (arg) {
+            case '--install':
+            case '-i':
+                out.install = true;
+                break;
+            case '--reindex':
+            case '-r':
+                out.reindex = true;
+                break;
+            case '--offer':
+            case '-o':
+                out.offer = true;
+                break;
+            default:
+                out.unknown = arg;
+                return out;
+        }
+    }
+    return out;
+}
+/**
+ * Render the status table. Pure copy assembly — separates rendering
+ * from side effects so spec callers can pin the exact layout.
+ */
+export function renderStatusLines(input) {
+    const lines = ['Codegraph status:', ''];
+    lines.push(` Installed:       ${input.installed ? 'yes' : 'no'}`);
+    if (input.installed) {
+        lines.push(` Trust state:     ${input.trust ?? 'pending'}`);
+        lines.push(` Config path:     ${input.configPath}`);
+    }
+    if (input.primarySymbolCount !== null) {
+        lines.push(` Symbol count:    ~${input.primarySymbolCount} source files`);
+    }
+    if (input.languages && input.languages.length > 0) {
+        lines.push(` Languages:       ${input.languages.join(', ')}`);
+    }
+    if (input.sizeCategory) {
+        lines.push(` Size category:   ${input.sizeCategory}`);
+    }
+    if (input.installed) {
+        if (input.lastIndexedAt) {
+            lines.push(` Last indexed:    ${input.lastIndexedAt}${input.ageDays !== null ? ` (${input.ageDays} day${input.ageDays === 1 ? '' : 's'} ago)` : ''}`);
+        }
+        else {
+            lines.push(' Last indexed:    never recorded — run `codegraph index` and `/codegraph-status --reindex`');
+        }
+        if (input.staleNudge) {
+            lines.push('');
+            lines.push(` Index is ${input.ageDays} day${input.ageDays === 1 ? '' : 's'} old (threshold ${STALE_INDEX_DAYS}). ` +
+                'Run `codegraph index` then `/codegraph-status --reindex` to refresh.');
+        }
+    }
+    else {
+        lines.push('');
+        lines.push(` Docs: ${CODEGRAPH_DOCS_URL}`);
+        lines.push(' Install via `/codegraph-status --install` OR `pugi mcp install codegraph codegraph serve --mcp`.');
+    }
+    return lines;
+}
+/**
+ * Single entry-point used by the slash dispatch + (future) standalone
+ * `pugi codegraph status` shell command. Pure orchestration — every
+ * side effect lives behind one of the flag branches.
+ */
+export async function runCodegraphStatusCommand(args, ctx) {
+    const flags = parseCodegraphStatusArgs(args);
+    if (flags.unknown) {
+        ctx.writeOutput({ command: 'codegraph-status', error: 'unknown-flag', flag: flags.unknown }, `/codegraph-status: unknown flag "${flags.unknown}". Allowed: --install, --reindex, --offer.`);
+        return;
+    }
+    const workspaceRoot = resolve(ctx.workspaceRoot);
+    // --reindex — stamp lastIndexedAt + remind the operator how to actually
+    // refresh the index. We do NOT spawn `codegraph index` — that is the
+    // operator's call (upstream codegraph may or may not be installed; we
+    // refuse to silently spawn a binary we did not vet).
+    if (flags.reindex) {
+        const decision = markIndexed(workspaceRoot);
+        if (!decision) {
+            ctx.writeOutput({ command: 'codegraph-status', error: 'no-decision' }, '/codegraph-status --reindex: no decision recorded yet. Accept the install first via `--install`.');
+            return;
+        }
+        ctx.writeOutput({ command: 'codegraph-status', reindexed: true, lastIndexedAt: decision.lastIndexedAt }, [
+            `Codegraph index timestamp updated to ${decision.lastIndexedAt}.`,
+            'Run `codegraph index` from a fresh shell to actually rebuild the SQLite cache.',
+        ].join('\n'));
+        return;
+    }
+    // --install / --offer — surface the install prompt OR accept it
+    // directly. `--install` skips the prompt + writes the entry; `--offer`
+    // renders the prompt copy even after a decline (operator-initiated
+    // revisit). The two are mutually exclusive at runtime — `--install`
+    // wins when both are set.
+    if (flags.install || flags.offer) {
+        const evaluation = evaluateOffer({
+            workspaceRoot,
+            ...(ctx.nowIso ? { nowIso: ctx.nowIso } : {}),
+            ignorePriorDecision: flags.offer,
+        });
+        if (!evaluation.shouldPrompt) {
+            const detection = detectRepo(workspaceRoot);
+            // Already-installed is the success path for `--install`; treat
+            // it as PASS rather than ERROR so a re-run is idempotent.
+            if (evaluation.reason === 'already-installed') {
+                ctx.writeOutput({ command: 'codegraph-status', alreadyInstalled: true }, 'Codegraph is already declared in .pugi/mcp.json. Run `pugi mcp trust codegraph` if not yet trusted.');
+                return;
+            }
+            ctx.writeOutput({ command: 'codegraph-status', skipped: true, reason: evaluation.reason }, `/codegraph-status --${flags.install ? 'install' : 'offer'}: nothing to do (${evaluation.reason}).` +
+                (detection.isRepo
+                    ? ` Repo: ${detection.sizeCategory}, ${detection.primarySymbolCount} src files.`
+                    : ''));
+            return;
+        }
+        if (flags.install) {
+            const result = applyOfferDecision({
+                workspaceRoot,
+                accepted: true,
+                detection: evaluation.detection,
+                ...(ctx.nowIso ? { nowIso: ctx.nowIso } : {}),
+            });
+            if (result.kind === 'declined') {
+                // Defensive — applyOfferDecision with accepted=true cannot
+                // surface a `declined` verdict by construction. We still
+                // narrow the union so TS understands the safe path below.
+                ctx.writeOutput({ command: 'codegraph-status', installFailed: true, reason: 'unexpected-decline' }, '/codegraph-status --install: install path returned a decline verdict (internal bug).');
+                return;
+            }
+            if (result.kind === 'accepted-install-failed') {
+                ctx.writeOutput({ command: 'codegraph-status', installFailed: true, reason: result.install.reason }, `/codegraph-status --install failed: ${result.install.reason}`);
+                return;
+            }
+            ctx.writeOutput({
+                command: 'codegraph-status',
+                installed: true,
+                configPath: result.install.status === 'installed' ? result.install.configPath : null,
+                docsUrl: result.docsUrl,
+                trustCommand: result.trustCommand,
+            }, [
+                result.install.status === 'installed'
+                    ? `Codegraph added к .pugi/mcp.json. Trust gate: ${result.trustCommand}`
+                    : 'Codegraph already declared. Trust gate: ' + result.trustCommand,
+                `Docs: ${result.docsUrl}`,
+            ].join('\n'));
+            return;
+        }
+        // --offer path — surface the copy but do not install yet
+        emitOfferShown(evaluation.detection);
+        ctx.writeOutput({
+            command: 'codegraph-status',
+            offered: true,
+            copy: evaluation.promptCopy,
+            docsUrl: evaluation.docsUrl,
+        }, [
+            evaluation.promptCopy,
+            `Docs: ${evaluation.docsUrl}`,
+            'Accept: /codegraph-status --install',
+            'Decline: do nothing (the prompt re-appears in 30 days).',
+        ].join('\n'));
+        return;
+    }
+    // Bare invocation — render the status table.
+    const installed = detectCodegraphInstalled(workspaceRoot);
+    const detection = detectRepo(workspaceRoot);
+    const decision = readDecision(workspaceRoot);
+    const ageDays = decision ? indexAgeDays(decision, ctx.nowIso) : null;
+    const lines = renderStatusLines({
+        installed: installed.installed,
+        trust: installed.trust,
+        configPath: installed.configPath,
+        ageDays,
+        primarySymbolCount: detection.isRepo ? detection.primarySymbolCount : null,
+        languages: detection.isRepo ? detection.languages : null,
+        sizeCategory: detection.isRepo ? detection.sizeCategory : null,
+        lastIndexedAt: decision?.lastIndexedAt ?? null,
+        staleNudge: ageDays !== null && ageDays >= STALE_INDEX_DAYS,
+    });
+    ctx.writeOutput({
+        command: 'codegraph-status',
+        installed: installed.installed,
+        trust: installed.trust,
+        configPath: installed.configPath,
+        detection,
+        decision,
+        ageDays,
+    }, lines.join('\n'));
+}
+//# sourceMappingURL=codegraph-status.js.map

package/dist/runtime/commands/compact.js

@@ -0,0 +1,297 @@
+/**
+ * `pugi compact` — top-level command + companion to the REPL slash.
+ *
+ * Summarises older events from the most recent SessionStore session
+ * into a single boundary marker, freeing context budget for the next
+ * REPL session that resumes the same id.
+ *
+ * Wire: writeOutput contract matches every other dispatch in cli.ts
+ * (one structured payload + one human line). Exit code:
+ *  0 — boundary marker appended
+ *  1 — summarizer transport failed / store unavailable
+ *  2 — no events to compact / nothing to do
+ *
+ * The companion REPL slash dispatches through this same runner so the
+ * surface stays single-sourced.
+ */
+import { homedir } from 'node:os';
+import { loadRuntimeConfig } from '@pugi/sdk';
+import { AnvilEngineLoopClient } from '../../core/engine/anvil-client.js';
+import { SqliteSessionStore, resolveProjectStoreDir, } from '../../core/repl/store/session-store.js';
+import { appendCompactBoundary, isCompactBoundary, } from '../../core/compact/buffer-rewriter.js';
+import { summarizeEvents, SummarizerError } from '../../core/compact/summarizer.js';
+/** Number of tail turns preserved verbatim on every compaction. */
+export const KEPT_TAIL_TURNS = 5;
+/** Minimum source events before we accept a compaction. */
+const MIN_EVENTS_TO_COMPACT = 6;
+/**
+ * Entry point reused by the slash command + the top-level dispatcher.
+ *
+ * The function is exhaustive: every early-exit branch produces a
+ * structured `CompactCommandResult` for the JSON path AND a one-line
+ * human message for the TTY path. Tests assert on the returned shape;
+ * the top-level dispatcher forwards it to `writeOutput`.
+ */
+export async function runCompactCommand(_args, ctx) {
+    const trigger = ctx.trigger ?? 'manual';
+    // Resolve the target session id. When the caller supplied a store
+    // (REPL slash path, tests) we trust it has the session bound; the
+    // standalone CLI path needs to discover the most-recent id via the
+    // read-only view + then open the live store on that id.
+    let store = ctx.store ?? null;
+    let sessionId = ctx.sessionId ?? null;
+    if (store === null) {
+        sessionId = sessionId ?? (await pickMostRecentSessionIdReadOnly(ctx.workspaceRoot));
+        if (!sessionId) {
+            return emit(ctx, {
+                command: 'compact',
+                status: 'failed_no_session',
+                trigger,
+                reason: 'No active session to compact. Start a REPL with `pugi`.',
+            });
+        }
+        store = await openStoreForCwd(ctx.workspaceRoot, sessionId);
+        if (!store) {
+            return emit(ctx, {
+                command: 'compact',
+                status: 'failed_no_session',
+                trigger,
+                reason: 'Local session store unavailable (lock held by REPL?).',
+            });
+        }
+    }
+    else if (sessionId === null) {
+        // Caller supplied a store but no session id — try to discover one.
+        sessionId = await pickMostRecentSessionId(store, ctx.workspaceRoot);
+        if (!sessionId) {
+            return emit(ctx, {
+                command: 'compact',
+                status: 'failed_no_session',
+                trigger,
+                reason: 'No active session to compact.',
+            });
+        }
+    }
+    // Snapshot the events. We pass `coversUntilOffset` as the count of
+    // events at the moment of the snapshot so the marker's anchor is
+    // accurate even if other writers race afterwards.
+    let events;
+    try {
+        events = await store.loadEvents(sessionId);
+    }
+    catch (error) {
+        return emit(ctx, {
+            command: 'compact',
+            status: 'failed_store',
+            sessionId,
+            trigger,
+            reason: `Could not load events: ${errMsg(error)}`,
+        });
+    }
+    if (events.length < MIN_EVENTS_TO_COMPACT && ctx.force !== true) {
+        return emit(ctx, {
+            command: 'compact',
+            status: 'noop_empty',
+            sessionId,
+            trigger,
+            reason: `Only ${events.length} events on disk; need at least ${MIN_EVENTS_TO_COMPACT}. `
+                + 'Pass --force to compact anyway.',
+        });
+    }
+    // Locate the source slice: everything strictly after the latest
+    // compact-boundary, EXCLUDING the kept-tail window. If no prior
+    // boundary exists, walk from offset 0.
+    const lastBoundaryIdx = findLastCompactBoundaryIndex(events);
+    const sliceStart = lastBoundaryIdx === -1 ? 0 : lastBoundaryIdx + 1;
+    const sliceEnd = Math.max(sliceStart, events.length - KEPT_TAIL_TURNS);
+    const sourceSlice = events.slice(sliceStart, sliceEnd);
+    if (sourceSlice.length === 0) {
+        return emit(ctx, {
+            command: 'compact',
+            status: 'noop_recent_marker',
+            sessionId,
+            trigger,
+            reason: 'Conversation already compact — nothing new to fold.',
+        });
+    }
+    // Build the engine client. Production uses Anvil; tests inject a
+    // fixture client to avoid the network round-trip.
+    const engineClient = ctx.engineClient ?? buildAnvilClient();
+    if (!engineClient) {
+        return emit(ctx, {
+            command: 'compact',
+            status: 'failed_transport',
+            sessionId,
+            trigger,
+            reason: 'Could not build engine client (run `pugi login`).',
+        });
+    }
+    // Run the summariser.
+    let summary;
+    try {
+        summary = await summarizeEvents({
+            events: sourceSlice,
+            client: engineClient,
+            personaSlug: 'mira',
+        });
+    }
+    catch (error) {
+        const code = error instanceof SummarizerError ? error.code : 'unknown';
+        const message = error instanceof Error ? error.message : String(error);
+        return emit(ctx, {
+            command: 'compact',
+            status: 'failed_transport',
+            sessionId,
+            trigger,
+            reason: `Summarizer failed (${code}): ${message}`,
+        });
+    }
+    // Append the boundary marker. Recompute `coversUntilOffset` AFTER
+    // the summariser round-trip so any events that landed mid-flight
+    // fall into the kept-tail window — the operator does not lose work
+    // that arrived during compaction. The next event we append (the
+    // marker itself) lands at index `coversUntilOffset` in the on-disk
+    // log.
+    let postRoundTripEvents;
+    try {
+        postRoundTripEvents = await store.loadEvents(sessionId);
+    }
+    catch (error) {
+        return emit(ctx, {
+            command: 'compact',
+            status: 'failed_store',
+            sessionId,
+            trigger,
+            reason: `Could not refresh events: ${errMsg(error)}`,
+        });
+    }
+    const coversUntilOffset = postRoundTripEvents.length;
+    try {
+        await appendCompactBoundary({
+            store,
+            trigger,
+            summary: summary.summary,
+            summaryTokenCount: summary.tokensSummarised,
+            summaryTurnsBefore: summary.eventsSummarised,
+            keptTailTurns: KEPT_TAIL_TURNS,
+            coversUntilOffset,
+            ...(ctx.now !== undefined ? { now: ctx.now } : {}),
+        });
+    }
+    catch (error) {
+        return emit(ctx, {
+            command: 'compact',
+            status: 'failed_store',
+            sessionId,
+            trigger,
+            reason: `Could not append marker: ${errMsg(error)}`,
+        });
+    }
+    return emit(ctx, {
+        command: 'compact',
+        status: 'compacted',
+        sessionId,
+        trigger,
+        turnsBefore: summary.eventsSummarised,
+        tailKept: KEPT_TAIL_TURNS,
+        tokensSummarised: summary.tokensSummarised,
+    }, `Compacted ${summary.eventsSummarised} events (~${summary.tokensSummarised} tokens) into 1 summary. ` +
+        `Last ${KEPT_TAIL_TURNS} turns kept verbatim.`);
+}
+/* ------------------------------------------------------------------ */
+/* Helpers                                                           */
+/* ------------------------------------------------------------------ */
+/**
+ * Emit a payload through the context and return it for the caller. We
+ * keep the function exhaustive so every branch lands on the same
+ * writeOutput contract (JSON-mode + text-mode).
+ */
+function emit(ctx, payload, text) {
+    const human = text ?? payload.reason ?? `compact: ${payload.status}`;
+    ctx.writeOutput(payload, human);
+    return payload;
+}
+function findLastCompactBoundaryIndex(events) {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        if (isCompactBoundary(events[i]))
+            return i;
+    }
+    return -1;
+}
+function errMsg(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Open the SqliteSessionStore for the workspace's project slug and
+ * bind the active log to `sessionId`. Returns null when the open
+ * fails (lock contention, IO error, missing project dir).
+ *
+ * The PID lockfile contention is the expected failure mode here — a
+ * running REPL holds the lock, and `pugi compact` from a second
+ * terminal cannot grab it. The caller surfaces a clear message rather
+ * than crashing the dispatch.
+ */
+async function openStoreForCwd(workspaceRoot, sessionId) {
+    try {
+        const slug = projectSlugForCwd(workspaceRoot);
+        const store = new SqliteSessionStore({ projectSlug: slug, home: homedir() });
+        await store.open({
+            id: sessionId,
+            workspaceRoot,
+            projectSlug: slug,
+        });
+        return store;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read-only-view variant of `pickMostRecentSessionId` for the
+ * pre-open phase. Walks `~/.pugi/projects/<slug>/session.db` without
+ * taking the lockfile so a live REPL in another terminal does not
+ * make discovery fail.
+ */
+async function pickMostRecentSessionIdReadOnly(workspaceRoot) {
+    try {
+        const slug = projectSlugForCwd(workspaceRoot);
+        const dir = resolveProjectStoreDir(slug, homedir());
+        const view = await SqliteSessionStore.openReadOnly(dir);
+        try {
+            const rows = await view.list({ project: slug, limit: 1, status: 'active' });
+            return rows.length > 0 ? rows[0].id : null;
+        }
+        finally {
+            await view.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Locate the most recent active session for the workspace. Returns
+ * null when no session row exists.
+ */
+async function pickMostRecentSessionId(store, workspaceRoot) {
+    const slug = projectSlugForCwd(workspaceRoot);
+    const rows = await store.listSessions({ project: slug, limit: 1, status: 'active' });
+    if (rows.length === 0)
+        return null;
+    return rows[0].id;
+}
+function projectSlugForCwd(workspaceRoot) {
+    const base = workspaceRoot.split('/').filter((s) => s.length > 0).pop() ?? 'workspace';
+    return base.toLowerCase().replace(/[^a-z0-9-]/g, '-').slice(0, 64);
+}
+/**
+ * Construct an Anvil-backed engine client from env-resolved runtime
+ * config. Returns null when the operator is not authenticated.
+ */
+function buildAnvilClient() {
+    const config = loadRuntimeConfig();
+    if (!config)
+        return null;
+    return new AnvilEngineLoopClient(config);
+}
+//# sourceMappingURL=compact.js.map