@timurproko/a1 0.1.8-dev.50ebb19 → 0.1.8-dev.510

package/dist/app/session-shell/prompt-history-controller.js

@@ -0,0 +1,170 @@
+import { randomUUID } from "node:crypto";
+import { PROMPT_HISTORY_MAX_TEXT_BYTES } from "../../contracts/owned-ui/index.js";
+/** Merges bounded recall snapshots; the editor alone owns browsing, draft, cursor, and undo state. */
+export class PromptHistoryController {
+    #local = new Map();
+    #unsubscribe;
+    #snapshot;
+    #fallback;
+    #rehydrateCache;
+    #disposed = false;
+    #generation = 0;
+    #unsubscribeSnapshot;
+    #unsubscribeFailure;
+    #closeFailed = false;
+    #closePromise;
+    options;
+    constructor(options) {
+        this.options = options;
+        if (options.editor.recall === undefined)
+            throw new Error("The selected editor does not expose typed history");
+        this.#snapshot = { revision: 0, limit: options.limit, entries: [] };
+        this.#rehydrateCache = new Map();
+        this.#fallback = boundedTexts([...options.fallback].reverse(), options.limit);
+        this.#unsubscribeSnapshot = this.#subscribeSnapshot();
+        this.#unsubscribeFailure = options.store.onFailure(() => {
+            if (this.#disposed)
+                this.#closeFailed = true;
+        });
+        this.#unsubscribe = [
+            options.editor.recall.observe(() => {
+                if (this.#disposed)
+                    return;
+                if (options.editor.recall.position().index === -1)
+                    this.synchronize();
+                options.store.refresh();
+            }),
+        ];
+        this.synchronize();
+    }
+    start() { this.options.store.start(); }
+    capture(text, kind, cwd, sessionId) {
+        const canonical = text.trim();
+        if (!canonical || this.#disposed)
+            return;
+        const id = randomUUID();
+        const generation = this.#generation;
+        this.#local.set(id, { text: canonical, committed: false });
+        this.#boundLocal();
+        this.synchronize();
+        void this.options.store.record({ id, text: canonical, timestamp: Date.now(), kind, cwd, sessionId }).then(outcome => {
+            if (this.#disposed || generation !== this.#generation)
+                return;
+            const local = this.#local.get(id);
+            if (local === undefined || outcome !== "committed")
+                return;
+            local.committed = true;
+            if (this.#snapshot.entries.some(entry => entry.submissionId === id))
+                this.#local.delete(id);
+            this.synchronize();
+        }).catch(() => { });
+    }
+    rememberRecovery(text) {
+        if (this.#disposed || !text.trim())
+            return;
+        const canonical = text.trim();
+        if ([...this.#local.values()].some(item => item.text === canonical)
+            || this.#snapshot.entries.some(item => item.text === canonical))
+            return;
+        this.#local.set(randomUUID(), { text: canonical, committed: false });
+        this.#boundLocal();
+        this.synchronize();
+    }
+    synchronize() {
+        if (this.#disposed || !this.options.active())
+            return;
+        const local = [...this.#local.values()].reverse().map(item => item.text);
+        const saved = this.#snapshot.entries.map(item => item.text);
+        const values = this.#rehydrateAll(local.concat(saved, this.#fallback));
+        this.options.editor.recall.replace(boundedTexts(values, this.#snapshot.limit));
+        this.options.render();
+    }
+    #rehydrateAll(values) {
+        const rehydrate = this.options.rehydrate;
+        if (rehydrate === undefined)
+            return [...values];
+        const cache = this.#rehydrateCache;
+        const results = [];
+        for (const value of values) {
+            const cached = cache.get(value);
+            if (cached !== undefined) {
+                results.push(cached);
+                continue;
+            }
+            const rendered = rehydrate(value);
+            cache.set(value, rendered);
+            results.push(rendered);
+        }
+        if (cache.size > 512) {
+            // Performance: keep the cache bounded so long sessions cannot grow it without limit.
+            const keys = [...cache.keys()].slice(0, cache.size - 256);
+            for (const key of keys)
+                cache.delete(key);
+        }
+        return results;
+    }
+    reset(fallback) {
+        this.#generation++;
+        this.#unsubscribeSnapshot();
+        this.#unsubscribeSnapshot = this.#subscribeSnapshot();
+        this.#fallback = boundedTexts([...fallback].reverse(), this.options.limit);
+        this.#local.clear();
+        this.#rehydrateCache.clear();
+        this.options.editor.recall.reset();
+        this.synchronize();
+        this.options.store.refresh();
+    }
+    close() {
+        if (this.#closePromise !== undefined)
+            return this.#closePromise;
+        this.#disposed = true;
+        this.#unsubscribeSnapshot();
+        for (const unsubscribe of this.#unsubscribe)
+            unsubscribe();
+        this.#local.clear();
+        this.#fallback = [];
+        this.#closePromise = this.options.store.close().then(() => !this.#closeFailed, () => false)
+            .finally(() => this.#unsubscribeFailure());
+        return this.#closePromise;
+    }
+    #subscribeSnapshot() {
+        const generation = this.#generation;
+        return this.options.store.onSnapshot(snapshot => {
+            if (this.#disposed || generation !== this.#generation || snapshot.revision < this.#snapshot.revision)
+                return;
+            this.#snapshot = snapshot;
+            for (const [id, entry] of this.#local) {
+                if (entry.committed || snapshot.entries.some(saved => saved.submissionId === id))
+                    this.#local.delete(id);
+            }
+            this.synchronize();
+        });
+    }
+    #boundLocal() {
+        let bytes = [...this.#local.values()].reduce((sum, item) => sum + Buffer.byteLength(item.text), 0);
+        while (this.#local.size > this.options.limit || bytes > PROMPT_HISTORY_MAX_TEXT_BYTES) {
+            const id = this.#local.keys().next().value;
+            bytes -= Buffer.byteLength(this.#local.get(id).text);
+            this.#local.delete(id);
+        }
+    }
+}
+function boundedTexts(values, limit) {
+    const result = [];
+    const seen = new Set();
+    let bytes = 0;
+    for (const value of values) {
+        const text = value.trim();
+        if (!text || seen.has(text))
+            continue;
+        const size = Buffer.byteLength(text);
+        if (bytes + size > PROMPT_HISTORY_MAX_TEXT_BYTES)
+            continue;
+        result.push(text);
+        seen.add(text);
+        bytes += size;
+        if (result.length >= limit)
+            break;
+    }
+    return result;
+}

package/dist/app/session-shell/prompt-suggestion-controller.d.ts

@@ -0,0 +1,37 @@
+import { type OwnedUiPromptSuggestionGeneratorPort, type OwnedUiPromptSuggestionIdentity, type OwnedUiPromptSuggestionState, type SuggestionDecision, type SuggestionDecisionReason, type SuggestionDiagnosticObserver } from "../../contracts/owned-ui/index.js";
+export interface ContextualPromptSuggestionSurface {
+    canPresent(identity: OwnedUiPromptSuggestionIdentity): boolean;
+    presentationBlockReason?(identity: OwnedUiPromptSuggestionIdentity): SuggestionDecision;
+    present(text: string): boolean;
+    clear(): void;
+    requestRender(): void;
+}
+export interface ContextualPromptSuggestionControllerOptions {
+    readonly generator: OwnedUiPromptSuggestionGeneratorPort;
+    readonly surface: ContextualPromptSuggestionSurface;
+    readonly enabled: boolean;
+    readonly timeoutMs?: number;
+    readonly diagnostics?: SuggestionDiagnosticObserver;
+    readonly now?: () => number;
+}
+type DecisionIdentity = Omit<OwnedUiPromptSuggestionIdentity, "model"> & {
+    readonly model: OwnedUiPromptSuggestionIdentity["model"] | null;
+};
+/** Prefetches one inert candidate; owns retirement even when a provider ignores abort. */
+export declare class ContextualPromptSuggestionController {
+    #private;
+    readonly options: ContextualPromptSuggestionControllerOptions;
+    constructor(options: ContextualPromptSuggestionControllerOptions);
+    get state(): OwnedUiPromptSuggestionState;
+    setEnabled(enabled: boolean): void;
+    skip(identity: DecisionIdentity, reason: SuggestionDecisionReason): void;
+    consider(identity: OwnedUiPromptSuggestionIdentity, decision: boolean | SuggestionDecision): void;
+    settle(identity: OwnedUiPromptSuggestionIdentity): void;
+    accept(): void;
+    invalidate(): void;
+    /** Retires only a generating request; a prepared or available suggestion survives the draft edit. */
+    abortPending(): void;
+    dispose(): void;
+}
+export declare function samePromptSuggestionIdentity(left: OwnedUiPromptSuggestionIdentity, right: OwnedUiPromptSuggestionIdentity): boolean;
+export {};

package/dist/app/session-shell/prompt-suggestion-controller.js

@@ -0,0 +1,219 @@
+import { assertOwnedUiPromptSuggestionResult, normalizePromptSuggestionCandidate, } from "../../contracts/owned-ui/index.js";
+/** Prefetches one inert candidate; owns retirement even when a provider ignores abort. */
+export class ContextualPromptSuggestionController {
+    #state = { status: "idle" };
+    #request = null;
+    #lastConsidered = "";
+    #enabled;
+    #disposed = false;
+    #sessionKey = "";
+    #sessionSequence = 0;
+    #requestSequence = 0;
+    #timeoutMs;
+    #now;
+    options;
+    constructor(options) {
+        this.options = options;
+        this.#enabled = options.enabled;
+        this.#timeoutMs = options.timeoutMs ?? 15_000;
+        this.#now = options.now ?? Date.now;
+    }
+    get state() { return this.#state; }
+    setEnabled(enabled) {
+        if (this.#enabled === enabled)
+            return;
+        this.#enabled = enabled;
+        this.invalidate();
+    }
+    skip(identity, reason) {
+        this.invalidate();
+        this.#emit(this.#metadata(identity), "skipped", reason);
+    }
+    consider(identity, decision) {
+        const key = identityKey(identity);
+        if (key === this.#lastConsidered)
+            return;
+        this.#lastConsidered = key;
+        this.invalidate();
+        const reason = this.#disposed ? "disposed" : !this.#enabled ? "disabled"
+            : decision === false ? "ineligible" : decision === true ? null : decision;
+        if (reason !== null) {
+            this.#emit(this.#metadata(identity), "skipped", reason);
+            return;
+        }
+        let reasoning = "unavailable";
+        try {
+            reasoning = this.options.generator.suggestionReasoningPolicy?.() ?? "unavailable";
+        }
+        catch { /* Security: isolate diagnostic metadata failure. */ }
+        const request = {
+            identity,
+            metadata: { ...this.#metadata(identity), request: ++this.#requestSequence, reasoning },
+            abort: new AbortController(), startedAt: this.#now(), terminal: false,
+        };
+        this.#request = request;
+        this.#state = { status: "generating", identity, settled: false };
+        this.#emit(request.metadata, "started");
+        request.timer = setTimeout(() => {
+            if (this.#request !== request || this.#state.status !== "generating")
+                return;
+            this.#finish(request, "timeout");
+            this.#state = { status: "idle" };
+            this.#request = null;
+            request.abort.abort();
+        }, this.#timeoutMs);
+        request.timer.unref?.();
+        try {
+            void this.options.generator.generate({ identity, signal: request.abort.signal })
+                .then(result => this.#receive(request, result), () => this.#failed(request))
+                .finally(() => clearTimeout(request.timer));
+        }
+        catch {
+            this.#failed(request);
+        }
+    }
+    settle(identity) {
+        if (this.#disposed || !this.#enabled || this.#state.status === "idle")
+            return;
+        if (!samePromptSuggestionIdentity(this.#state.identity, identity)) {
+            if (this.#request)
+                this.#finish(this.#request, "stale-result", "stale-identity");
+            this.invalidate();
+            return;
+        }
+        if (this.#state.status === "generating")
+            this.#state = { ...this.#state, settled: true };
+        else if (this.#state.status === "prepared" && this.#request)
+            this.#show(this.#request, this.#state.text);
+    }
+    accept() { this.#invalidate(false); }
+    invalidate() { this.#invalidate(true); }
+    /** Retires only a generating request; a prepared or available suggestion survives the draft edit. */
+    abortPending() {
+        if (this.#state.status !== "generating")
+            return;
+        const request = this.#request;
+        this.#request = null;
+        this.#state = { status: "idle" };
+        if (request === null)
+            return;
+        this.#finish(request, "cancelled");
+        request.abort.abort();
+    }
+    dispose() {
+        this.#disposed = true;
+        this.invalidate();
+        this.#lastConsidered = "";
+        this.#sessionKey = "";
+    }
+    #invalidate(clearSurface) {
+        const hadVisibleSuggestion = this.#state.status === "available";
+        const request = this.#request;
+        if (request)
+            this.#finish(request, "cancelled");
+        this.#request = null;
+        this.#state = { status: "idle" };
+        request?.abort.abort();
+        if (clearSurface && hadVisibleSuggestion) {
+            this.options.surface.clear();
+            this.options.surface.requestRender();
+        }
+    }
+    #failed(request) {
+        if (this.#request !== request || request.terminal) {
+            this.#late(request);
+            return;
+        }
+        this.#finish(request, "provider-failure");
+        this.#request = null;
+        this.#state = { status: "idle" };
+    }
+    #receive(request, result) {
+        if (this.#disposed || this.#request !== request || request.terminal || this.#state.status !== "generating") {
+            this.#late(request);
+            return;
+        }
+        try {
+            assertOwnedUiPromptSuggestionResult(result);
+        }
+        catch {
+            this.#finish(request, "rejected");
+            this.invalidate();
+            return;
+        }
+        if (!samePromptSuggestionIdentity(request.identity, result.identity)) {
+            this.#finish(request, "stale-result", "stale-identity");
+            this.invalidate();
+            return;
+        }
+        if (result.outcome !== "candidate") {
+            this.#finish(request, result.outcome);
+            this.invalidate();
+            return;
+        }
+        const text = normalizePromptSuggestionCandidate(result.text);
+        if (text === null) {
+            this.#finish(request, "rejected");
+            this.invalidate();
+            return;
+        }
+        clearTimeout(request.timer);
+        if (this.#state.settled)
+            this.#show(request, text);
+        else
+            this.#state = { status: "prepared", identity: request.identity, text };
+    }
+    #show(request, text) {
+        const reason = this.options.surface.presentationBlockReason?.(request.identity)
+            ?? (this.options.surface.canPresent(request.identity) ? null : "presentation-unavailable");
+        if (reason !== null || !this.options.surface.present(text)) {
+            this.#finish(request, "presentation-blocked", reason ?? "presentation-unavailable");
+            this.invalidate();
+            return;
+        }
+        this.#state = { status: "available", identity: request.identity, text };
+        this.#finish(request, "displayed");
+        this.options.surface.requestRender();
+    }
+    #finish(request, event, reason) {
+        if (request.terminal)
+            return;
+        // Concurrency: retire before notifying observers or aborting; neither may rewrite the winner.
+        request.terminal = true;
+        clearTimeout(request.timer);
+        this.#emit({ ...request.metadata, elapsedMs: Math.max(0, this.#now() - request.startedAt) }, event, reason);
+    }
+    #late(request) {
+        if (!this.#disposed)
+            this.#emit({ ...request.metadata, elapsedMs: Math.max(0, this.#now() - request.startedAt) }, "late-result-discarded");
+    }
+    #metadata(identity) {
+        const key = `${identity.sessionId}\0${identity.sessionGeneration}`;
+        if (this.#sessionKey !== key) {
+            this.#sessionKey = key;
+            this.#sessionSequence++;
+        }
+        return {
+            event: "skipped", session: this.#sessionSequence, run: identity.runSequence, response: identity.responseSequence,
+            request: 0, provider: identity.model?.providerId ?? "", model: identity.model?.modelId ?? "",
+            reasoning: "unavailable", elapsedMs: 0,
+        };
+    }
+    #emit(metadata, event, reason) {
+        try {
+            this.options.diagnostics?.record({ ...metadata, event, ...(reason === undefined ? {} : { reason }) });
+        }
+        catch { /* Security: diagnostics never own input or lifecycle. */ }
+    }
+}
+export function samePromptSuggestionIdentity(left, right) {
+    return left.sessionId === right.sessionId
+        && left.sessionGeneration === right.sessionGeneration
+        && left.runSequence === right.runSequence
+        && left.responseSequence === right.responseSequence
+        && left.model.providerId === right.model.providerId
+        && left.model.modelId === right.model.modelId;
+}
+function identityKey(identity) {
+    return `${identity.sessionId}\0${identity.sessionGeneration}\0${identity.runSequence}\0${identity.responseSequence}\0${identity.model.providerId}\0${identity.model.modelId}`;
+}

package/dist/app/session-shell/quit-outro-effects.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Deterministic quit-outro effect plans, ported from the v2 sketch.
+ *
+ * Each effect turns the captured frame's per-row visible widths and a seed into
+ * two sorted schedules over unit playback progress: sparkles paint a glyph at a
+ * cell from `start`, and clears blank a cell at `end`. The player consumes both
+ * in order, so a fixed seed yields a byte-stable animation.
+ */
+export interface QuitOutroCell {
+    readonly row: number;
+    readonly col: number;
+    /** Progress at which the sparkle glyph is painted. */
+    readonly start: number;
+    /** Progress at which the cell is cleared. */
+    readonly end: number;
+    readonly glyph: string;
+    readonly color: string;
+}
+export interface QuitOutroPlan {
+    /** Sorted by `start`. */
+    readonly sparkles: readonly QuitOutroCell[];
+    /** Sorted by `end`. */
+    readonly clears: readonly QuitOutroCell[];
+}
+export declare const QUIT_OUTRO_EFFECTS: readonly ["fall", "dissolve", "starburst", "waves"];
+export type QuitOutroEffect = (typeof QUIT_OUTRO_EFFECTS)[number];
+export declare function isQuitOutroEffect(value: unknown): value is QuitOutroEffect;
+/** Builds the selected effect's deterministic plan for the captured row widths. */
+export declare function createQuitOutroPlan(effect: QuitOutroEffect, rowWidths: readonly number[], seed: number): QuitOutroPlan;