@yagni-app/code 1.0.0 → 1.0.1

package/dist/extension/toolRuns.js

@@ -0,0 +1,201 @@
+/**
+ * Run model for the condensed tool transcript (Claude Code-style).
+ *
+ * A "run" is a maximal stretch of consecutive QUIET tool rows (reads, searches,
+ * listings, successful shell commands, scratchpad edits) uninterrupted by an
+ * assistant/user message or a visible row (errors, project writes/edits, image
+ * reads). Collapsed, every row in a completed run renders zero lines except the
+ * run's tail, which paints one summary line: "Read 2 files, ran 2 shell
+ * commands". Expanded (ctrl+o) bypasses this model entirely.
+ *
+ * The tracker is built purely from render calls (idempotent upserts keyed by
+ * toolCallId, in first-render order, which matches display order both live and
+ * on session replay). Message boundaries arrive via {@link ToolRunTracker.markBreak}
+ * from live `message_start` events only — after a resume, runs that were
+ * separated by prose may merge into one summary. That is a deliberate trade:
+ * render-derived state is the only state that survives replay.
+ *
+ * Everything here is PURE (no pi imports) so tests run against plain objects;
+ * the pi wiring lives in condensedTools.ts.
+ */
+const KIND_BY_TOOL = {
+    read: "read",
+    bash: "shell",
+    grep: "search",
+    find: "list",
+    ls: "list",
+    write: "write",
+    edit: "edit",
+};
+/** Aggregation kind for a built-in tool name (undefined for non-built-ins). */
+export function kindForTool(toolName) {
+    return KIND_BY_TOOL[toolName];
+}
+/**
+ * Whether a row folds into a run summary. Reads, searches, listings, and
+ * successful shell commands always do; writes/edits only when they target the
+ * scratchpad (project mutations must stay visible). Errors and image-bearing
+ * results are always visible.
+ */
+export function isQuiet(row) {
+    if (row.error || row.images)
+        return false;
+    if (row.kind === "write" || row.kind === "edit")
+        return row.scratchpad;
+    return true;
+}
+function plural(n, singular, pluralForm = `${singular}s`) {
+    return n === 1 ? singular : pluralForm;
+}
+/**
+ * One summary line for a completed run, phrases in first-occurrence order:
+ * "Read 2 files, ran 2 shell commands, made 1 scratchpad edit +20".
+ */
+export function summarizeRun(rows) {
+    const order = [];
+    const counts = new Map();
+    for (const row of rows) {
+        const category = row.kind === "write" || row.kind === "edit" ? "scratch" : row.kind;
+        let entry = counts.get(category);
+        if (!entry) {
+            entry = { n: 0, added: 0 };
+            counts.set(category, entry);
+            order.push(category);
+        }
+        entry.n += 1;
+        entry.added += row.added;
+    }
+    const phrases = order.map((category) => {
+        const { n, added } = counts.get(category);
+        switch (category) {
+            case "read":
+                return `read ${n} ${plural(n, "file")}`;
+            case "shell":
+                return `ran ${n} shell ${plural(n, "command")}`;
+            case "search":
+                return `searched for ${n} ${plural(n, "pattern")}`;
+            case "list":
+                return `listed ${n} ${plural(n, "path")}`;
+            default:
+                return `made ${n} scratchpad ${plural(n, "edit")}${added > 0 ? ` +${added}` : ""}`;
+        }
+    });
+    const line = phrases.join(", ");
+    return line.charAt(0).toUpperCase() + line.slice(1);
+}
+/**
+ * Ordered row registry. Upserts are idempotent and diff-aware: only a change
+ * invalidates the affected run's tail (the one component whose output depends
+ * on neighbors), so repaints converge instead of looping.
+ */
+export class ToolRunTracker {
+    rows = [];
+    indexById = new Map();
+    breakPending = true;
+    /** Record an assistant/user message boundary; the next new row starts a fresh run. */
+    markBreak() {
+        this.breakPending = true;
+    }
+    get(id) {
+        const i = this.indexById.get(id);
+        return i === undefined ? undefined : this.rows[i];
+    }
+    upsert(id, patch) {
+        const existingIndex = this.indexById.get(id);
+        if (existingIndex === undefined) {
+            const row = {
+                id,
+                kind: patch.kind ?? "shell",
+                scratchpad: patch.scratchpad ?? false,
+                error: patch.error ?? false,
+                images: patch.images ?? false,
+                final: patch.final ?? false,
+                added: patch.added ?? 0,
+                breakBefore: this.breakPending,
+                ...(patch.invalidate ? { invalidate: patch.invalidate } : {}),
+            };
+            this.breakPending = false;
+            this.indexById.set(id, this.rows.length);
+            this.rows.push(row);
+            // The previous row may have been its run's tail (painting a summary);
+            // now that the run extends past it, repaint it as a hidden member.
+            // (invalidateTailOf(prev) would be wrong here: prev's run now includes
+            // this new row, so its tail is the row currently painting, not prev.)
+            const prev = this.rows[this.rows.length - 2];
+            if (prev && isQuiet(prev) && !row.breakBefore)
+                this.scheduleInvalidate(prev);
+            return row;
+        }
+        const row = this.rows[existingIndex];
+        if (patch.invalidate)
+            row.invalidate = patch.invalidate;
+        let changed = false;
+        for (const key of ["kind", "scratchpad", "error", "images", "final", "added"]) {
+            const next = patch[key];
+            if (next !== undefined && row[key] !== next) {
+                row[key] = next;
+                changed = true;
+            }
+        }
+        if (changed)
+            this.invalidateTailOf(row);
+        return row;
+    }
+    /**
+     * The one summary line for `id`, present only when `id` is the tail of a
+     * fully-final quiet run. Every other member of the run gets undefined.
+     */
+    summaryFor(id) {
+        const row = this.get(id);
+        if (!row || !isQuiet(row) || !row.final)
+            return undefined;
+        const run = this.runOf(row);
+        if (run[run.length - 1] !== row)
+            return undefined;
+        if (run.some((r) => !r.final))
+            return undefined;
+        return summarizeRun(run);
+    }
+    /** The contiguous quiet run containing `row` (just `[row]` when visible). */
+    runOf(row) {
+        if (!isQuiet(row))
+            return [row];
+        const i = this.indexById.get(row.id);
+        let start = i;
+        while (start > 0 && !this.rows[start].breakBefore && isQuiet(this.rows[start - 1]))
+            start--;
+        let end = i;
+        while (end < this.rows.length - 1 &&
+            !this.rows[end + 1].breakBefore &&
+            isQuiet(this.rows[end + 1])) {
+            end++;
+        }
+        return this.rows.slice(start, end + 1);
+    }
+    invalidateTailOf(row) {
+        const run = this.runOf(row);
+        const tail = run[run.length - 1];
+        if (tail)
+            this.scheduleInvalidate(tail);
+    }
+    /**
+     * Defer a row's repaint to a microtask, deduped per row. Upserts run INSIDE
+     * pi's synchronous `updateDisplay` pass (renderers call them), and the
+     * component's `invalidate()` re-enters `updateDisplay` immediately — a
+     * synchronous call from a renderer would rebuild the container while the
+     * outer frame is still appending to it, stacking duplicate children.
+     * Deferring means every repaint runs as its own clean top-level pass; it
+     * still cannot loop, because the diff-aware upsert only schedules on an
+     * actual change.
+     */
+    scheduleInvalidate(row) {
+        if (row.invalidatePending)
+            return;
+        row.invalidatePending = true;
+        queueMicrotask(() => {
+            row.invalidatePending = false;
+            row.invalidate?.();
+        });
+    }
+}
+//# sourceMappingURL=toolRuns.js.map

package/dist/extension/webFetchTool.js

@@ -44,6 +44,8 @@ export function makeWebFetchTool(opts) {
             "Use web_fetch to read a URL's content instead of bash + curl when you need a page or a summary of it.",
         ],
         parameters,
+        // Self-framed: the condensed transcript look has no tinted tool boxes.
+        renderShell: "self",
         renderCall(args, theme) {
             const t = theme;
             const url = clipLine(args?.url ?? "…", 80);

package/dist/extension/workingLine.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The Claude Code-style streaming status line: `Shaping… (12m 54s · ↓ 47.5k
+ * tokens)` in place of pi's static "Working...".
+ *
+ * One manager owns `ctx.ui.setWorkingMessage` for the whole session so the
+ * verb, the elapsed clock, and the token counter never fight the subagent /
+ * advisor progress text: those tools publish their activity line through
+ * {@link WorkingLineHandle.setActivity} (instead of calling setWorkingMessage
+ * directly), and the manager splices it in as the head of the same composed
+ * message. Elapsed time spans the whole agent loop (agent_start → agent_end);
+ * the token counter accumulates assistant output tokens across the loop's
+ * messages (message_end), which is when pi learns usage — subagent tokens live
+ * in the subagent's own activity text, not this counter.
+ *
+ * TUI-only by the agent_start guard; a headless /go child or desktop surface
+ * never gets a working line. Everything is fail-soft: a status line must never
+ * break a turn.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+/** What subagents/advisor publish instead of calling setWorkingMessage. */
+export interface WorkingLineHandle {
+    setActivity(text?: string): void;
+}
+/** A no-op handle for callers wired without a manager (tests, children). */
+export declare const NULL_WORKING_LINE: WorkingLineHandle;
+/**
+ * The verb pool. Neutral gerunds — one is picked per agent loop, so long
+ * sessions read as a person at work rather than a stuck spinner.
+ */
+export declare const WORKING_VERBS: readonly string[];
+/** Pulse frames for the streaming indicator (pi renders them verbatim). */
+export declare const WORKING_INDICATOR_FRAMES: string[];
+export interface ComposeWorkingOpts {
+    /** Override head from a running subagent/advisor (verb used when absent). */
+    activity?: string | undefined;
+    verb: string;
+    elapsedMs: number;
+    outputTokens: number;
+}
+/** `Shaping… (12m 54s · ↓ 47.5k tokens)` — pure, exported for tests. */
+export declare function composeWorkingMessage(opts: ComposeWorkingOpts): string;
+export interface RegisterWorkingLineDeps {
+    now?: () => number;
+    pickVerb?: (verbs: readonly string[]) => string;
+    /** Refresh cadence for the elapsed clock. */
+    tickMs?: number;
+}
+export declare function registerWorkingLine(pi: ExtensionAPI, deps?: RegisterWorkingLineDeps): WorkingLineHandle;
+//# sourceMappingURL=workingLine.d.ts.map

package/dist/extension/workingLine.js

@@ -0,0 +1,116 @@
+/**
+ * The Claude Code-style streaming status line: `Shaping… (12m 54s · ↓ 47.5k
+ * tokens)` in place of pi's static "Working...".
+ *
+ * One manager owns `ctx.ui.setWorkingMessage` for the whole session so the
+ * verb, the elapsed clock, and the token counter never fight the subagent /
+ * advisor progress text: those tools publish their activity line through
+ * {@link WorkingLineHandle.setActivity} (instead of calling setWorkingMessage
+ * directly), and the manager splices it in as the head of the same composed
+ * message. Elapsed time spans the whole agent loop (agent_start → agent_end);
+ * the token counter accumulates assistant output tokens across the loop's
+ * messages (message_end), which is when pi learns usage — subagent tokens live
+ * in the subagent's own activity text, not this counter.
+ *
+ * TUI-only by the agent_start guard; a headless /go child or desktop surface
+ * never gets a working line. Everything is fail-soft: a status line must never
+ * break a turn.
+ */
+import { usageFromMessage } from "./costHud.js";
+import { formatDuration, formatTokens } from "./subagentRender.js";
+/** A no-op handle for callers wired without a manager (tests, children). */
+export const NULL_WORKING_LINE = { setActivity: () => { } };
+/**
+ * The verb pool. Neutral gerunds — one is picked per agent loop, so long
+ * sessions read as a person at work rather than a stuck spinner.
+ */
+export const WORKING_VERBS = [
+    "Working",
+    "Thinking",
+    "Exploring",
+    "Tracing",
+    "Shaping",
+    "Wiring",
+    "Weighing",
+    "Sketching",
+    "Assembling",
+    "Distilling",
+    "Untangling",
+    "Polishing",
+];
+/** Pulse frames for the streaming indicator (pi renders them verbatim). */
+export const WORKING_INDICATOR_FRAMES = ["·", "✢", "✳", "✶", "✳", "✢"];
+/** `Shaping… (12m 54s · ↓ 47.5k tokens)` — pure, exported for tests. */
+export function composeWorkingMessage(opts) {
+    const head = opts.activity ?? `${opts.verb}…`;
+    const stats = [
+        formatDuration(opts.elapsedMs),
+        opts.outputTokens > 0 ? `↓ ${formatTokens(opts.outputTokens)} tokens` : undefined,
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    return `${head} (${stats})`;
+}
+export function registerWorkingLine(pi, deps = {}) {
+    const now = deps.now ?? (() => Date.now());
+    const pickVerb = deps.pickVerb ?? ((verbs) => verbs[Math.floor(Math.random() * verbs.length)]);
+    const tickMs = deps.tickMs ?? 1_000;
+    let ui;
+    let timer;
+    let startedAt;
+    let outputTokens = 0;
+    let verb = WORKING_VERBS[0];
+    let activity;
+    const refresh = () => {
+        if (!ui || startedAt === undefined)
+            return;
+        try {
+            ui.setWorkingMessage?.(composeWorkingMessage({ activity, verb, elapsedMs: now() - startedAt, outputTokens }));
+        }
+        catch {
+            // The status line must never break a turn.
+        }
+    };
+    const stop = () => {
+        if (timer)
+            clearInterval(timer);
+        timer = undefined;
+        startedAt = undefined;
+        activity = undefined;
+        try {
+            ui?.setWorkingMessage?.();
+        }
+        catch {
+            // Restoring the default label is best-effort.
+        }
+    };
+    pi.on("agent_start", (_event, ctx) => {
+        if (ctx.mode !== "tui" || !ctx.hasUI)
+            return;
+        ui = ctx.ui;
+        startedAt = now();
+        outputTokens = 0;
+        activity = undefined;
+        verb = pickVerb(WORKING_VERBS);
+        refresh();
+        if (timer)
+            clearInterval(timer);
+        timer = setInterval(refresh, tickMs);
+        timer.unref?.();
+    });
+    pi.on("agent_end", () => stop());
+    pi.on("message_end", (event) => {
+        const message = event.message;
+        if (message?.role !== "assistant")
+            return;
+        outputTokens += usageFromMessage(message).output;
+        refresh();
+    });
+    return {
+        setActivity(text) {
+            activity = text;
+            refresh();
+        },
+    };
+}
+//# sourceMappingURL=workingLine.js.map

package/dist/feedback.d.ts

@@ -0,0 +1,77 @@
+/**
+ * `yagni feedback [sessionId]` — file a bug report from the shell (YAG-592).
+ *
+ * A shortcut to trigger what `/feedback` does inside a session, but from
+ * outside the TUI. Two modes:
+ *
+ *   Case A (no session arg): list the 10 most recent sessions for the current
+ *     cwd, let the user pick, prompt for a description, confirm, submit.
+ *   Case B (session ID provided): skip the list, go straight to description
+ *     prompt → confirm → submit.
+ *
+ * Self-contained: no cross-package imports. The scrub (`scrubSecrets`) and the
+ * error-trail reader (`readSessionTrail`) are local copies of the extension's
+ * logic — keep in sync with `pi-extension-yagni/src/pipeline/scrubSecrets.ts`
+ * and `pi-extension-yagni/src/errorSink.ts`. The backend re-scrubs server-side
+ * (`backend/src/yagniCode/feedback.ts`), so the client-side scrub is the first
+ * line of defense, not the only one.
+ */
+export interface FeedbackDeps {
+    loadCredentials?: () => Promise<{
+        token?: string;
+        baseUrl: string;
+        name: string;
+    }>;
+    fetchImpl?: typeof fetch;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    /** Override the agent dir (sessions live under `<agentDir>/sessions/...`). */
+    agentDirPath?: string;
+    /** Override the state dir (error sink lives under `<stateDir>/logs/...`). */
+    stateDir?: string;
+    writeOut?: (line: string) => void;
+    writeErr?: (line: string) => void;
+    /** Seam for readline — tests inject a fake that returns scripted answers. */
+    readline?: {
+        question: (q: string) => Promise<string>;
+        close: () => void;
+    };
+}
+export interface SessionInfo {
+    id: string;
+    filePath: string;
+    startTime: string;
+    durationMs: number | null;
+    firstMessage: string;
+}
+/**
+ * Encode a cwd into pi's session directory name format:
+ * `/Users/foo/bar` → `--Users-foo-bar--`
+ * Mirrors pi's `migrations.js`: `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`
+ */
+export declare function encodeCwd(cwd: string): string;
+/**
+ * List the most recent sessions for the current cwd.
+ * Scans `<agentDir>/sessions/<encoded-cwd>/*.jsonl`, sorted by start time desc.
+ */
+export declare function listRecentSessions(agentDirPath: string, cwd: string, limit?: number, termCols?: number): SessionInfo[];
+/**
+ * Find a session file by UUID across all project dirs.
+ */
+export declare function findSessionById(agentDirPath: string, sessionId: string): {
+    filePath: string;
+    startTime: string;
+} | null;
+/**
+ * Read the durable transcript, clamped by byte size. Returns empty on any
+ * failure or when too large. Mirrors the extension's `readTranscript`.
+ */
+export declare function readTranscript(sessionFile: string | undefined): string;
+/**
+ * Read the session-scoped error trail from today's error sink file.
+ * Filters by sessionId and excludes debug-level entries. Scrubs each line.
+ * Mirrors the extension's `readSessionTrail` — keep in sync.
+ */
+export declare function readSessionTrail(sessionId: string, stateDir: string, maxBytes?: number): string;
+export declare function feedbackCommand(args: string[], deps?: FeedbackDeps, cliVersion?: string): Promise<number>;
+//# sourceMappingURL=feedback.d.ts.map