@itookit/dsht 0.5.1 → 0.5.2

package/dist/session/history-reader.d.ts

@@ -0,0 +1,32 @@
+import type { HostAccess } from '../transport/host.ts';
+import { Transcript } from './transcript.ts';
+import type { HistorySearch } from './types.ts';
+interface Selection {
+    sessionId: string;
+    revision: number;
+    record: Transcript;
+}
+/** History reads cannot navigate, change status, or write another domain's state. */
+export interface HistoryHost extends Pick<HostAccess, 'require' | 'online' | 'signal'> {
+    selected(): Selection;
+    current(selection: Selection): boolean;
+    owns(transcript: Transcript): boolean;
+    changed(): void;
+}
+export declare class HistoryReader {
+    private readonly host;
+    private readonly tasks;
+    constructor(host: HistoryHost);
+    /** A selection change cancels everything; closing one detached window cancels only its pages. */
+    cancel(source?: Transcript): void;
+    settle(): Promise<void>;
+    private read;
+    waitForHistory(signal: AbortSignal): Promise<void>;
+    older(signal?: AbortSignal, transcript?: Transcript): Promise<void>;
+    private page;
+    historyThrough(target: number | 'first', signal: AbortSignal): Promise<void>;
+    searchHistory(query: string, signal: AbortSignal): Promise<HistorySearch>;
+    /** The returned window belongs to the caller until it is installed as the reading view. */
+    historyAt(target: number, signal: AbortSignal): Promise<Transcript>;
+}
+export {};

package/dist/session/history-reader.js

@@ -0,0 +1,170 @@
+/** Selected-session history I/O, with cancellation tied to the record or window being read. */
+import { setTimeout as delay } from 'node:timers/promises';
+import { object } from "../json.js";
+import { toolLine } from "../text.js";
+import { Transcript } from "./transcript.js";
+const SEARCH_MATCH_LIMIT = 200;
+export class HistoryReader {
+    host;
+    tasks = new Set();
+    constructor(host) {
+        this.host = host;
+    }
+    /** A selection change cancels everything; closing one detached window cancels only its pages. */
+    cancel(source) {
+        for (const task of this.tasks)
+            if (source === undefined || task.source === source)
+                task.abort.abort();
+    }
+    async settle() { await Promise.allSettled([...this.tasks].map(task => task.promise)); }
+    read(caller, source, work, discard) {
+        const abort = new AbortController();
+        const signal = AbortSignal.any([abort.signal, this.host.signal(), ...(caller ? [caller] : [])]);
+        // Register before dispatch so even a synchronous observer can cancel this operation.
+        const task = { abort, source, promise: Promise.resolve() };
+        const promise = Promise.resolve().then(async () => {
+            signal.throwIfAborted();
+            const selected = this.host.selected();
+            const check = () => {
+                signal.throwIfAborted();
+                if (!this.host.online() || !this.host.current(selected))
+                    throw new Error('Session changed while reading history');
+                if (source !== undefined && !this.host.owns(source))
+                    throw new Error('History window closed');
+            };
+            check();
+            const value = await work({ ...selected, client: this.host.require(), signal, check });
+            try {
+                check();
+                return value;
+            }
+            catch (error) {
+                discard?.(value);
+                throw error;
+            }
+        }).finally(() => { this.tasks.delete(task); });
+        task.promise = promise;
+        this.tasks.add(task);
+        return promise;
+    }
+    waitForHistory(signal) {
+        return this.read(signal, undefined, async (context) => {
+            const deadline = Date.now() + context.client.timeoutMs;
+            while (!context.record.ready) {
+                context.check();
+                if (Date.now() >= deadline)
+                    throw new Error('Session snapshot timed out');
+                await delay(20, undefined, { signal: context.signal });
+            }
+            context.check();
+        });
+    }
+    older(signal, transcript) {
+        return this.read(signal, transcript, context => this.page(context, transcript ?? context.record));
+    }
+    async page(context, transcript) {
+        context.check();
+        if (!transcript.ready || !transcript.hasMore || transcript.beforeSeq === undefined)
+            return;
+        const before = transcript.beforeSeq;
+        const result = await context.client.call('session/page', { request: {
+                address: { kind: 'session', sessionId: context.sessionId }, throughSeq: transcript.cursor,
+                beforeSeq: before, maxMessages: 80,
+            } }, context.signal);
+        context.check();
+        if (!this.host.owns(transcript))
+            throw new Error('History window closed');
+        transcript.addPage(result);
+        this.host.changed();
+        if (transcript.hasMore && (transcript.beforeSeq === undefined || transcript.beforeSeq >= before)) {
+            throw new Error('Host history page did not advance');
+        }
+    }
+    historyThrough(target, signal) {
+        return this.read(signal, undefined, async (context) => {
+            const transcript = context.record;
+            if (!transcript.ready)
+                throw new Error('Wait for the session snapshot');
+            while (transcript.hasMore && (target === 'first' || transcript.beforeSeq !== undefined && transcript.beforeSeq > target)) {
+                await this.page(context, transcript);
+            }
+        });
+    }
+    searchHistory(query, signal) {
+        return this.read(signal, undefined, async (context) => {
+            const source = context.record;
+            if (!source.ready)
+                throw new Error('Wait for the session snapshot');
+            const throughSeq = source.readThrough;
+            const needle = query.toLowerCase();
+            const result = { items: [], truncated: false };
+            const scan = (transcript) => {
+                const messages = transcript.messages;
+                for (let index = messages.length - 1; index >= 0; index--) {
+                    context.check();
+                    const message = messages[index];
+                    if (message.role === 'Tool')
+                        continue;
+                    const text = message.text;
+                    const match = text.toLowerCase().indexOf(needle);
+                    if (match < 0)
+                        continue;
+                    if (result.items.length === SEARCH_MATCH_LIMIT) {
+                        result.truncated = true;
+                        return false;
+                    }
+                    result.items.push({ seq: message.seq, role: message.role,
+                        preview: Buffer.from(toolLine(text.slice(Math.max(0, match - 40), match + needle.length + 100), 160)).toString('utf8') });
+                }
+                return true;
+            };
+            if (!scan(source))
+                return result;
+            let beforeSeq = source.beforeSeq;
+            let hasMore = source.hasMore;
+            while (hasMore && beforeSeq !== undefined) {
+                const page = object(await context.client.call('session/page', { request: {
+                        address: { kind: 'session', sessionId: context.sessionId }, throughSeq, beforeSeq, maxMessages: 80,
+                    } }, context.signal));
+                context.check();
+                const temporary = new Transcript();
+                try {
+                    temporary.accept({ type: 'snapshot', cursor: throughSeq, assistantStream: { revision: 0 }, records: page.records, hasMore: page.hasMore });
+                    const next = temporary.beforeSeq;
+                    if (temporary.hasMore && (next === undefined || next >= beforeSeq))
+                        throw new Error('Host history page did not advance');
+                    if (!scan(temporary))
+                        return result;
+                    beforeSeq = next;
+                    hasMore = temporary.hasMore;
+                }
+                finally {
+                    temporary.dispose();
+                }
+            }
+            return result;
+        });
+    }
+    /** The returned window belongs to the caller until it is installed as the reading view. */
+    historyAt(target, signal) {
+        return this.read(signal, undefined, async (context) => {
+            const throughSeq = context.record.readThrough;
+            const page = object(await context.client.call('session/page', { request: {
+                    address: { kind: 'session', sessionId: context.sessionId }, throughSeq,
+                    beforeSeq: target + 1, maxMessages: 80,
+                } }, context.signal));
+            context.check();
+            const window = new Transcript();
+            try {
+                window.accept({ type: 'snapshot', cursor: throughSeq, assistantStream: { revision: 0 }, records: page.records, hasMore: page.hasMore });
+                if (!window.messages.some(message => message.seq === target))
+                    throw new Error('The host did not return the requested message');
+                return window;
+            }
+            catch (error) {
+                window.dispose();
+                throw error;
+            }
+        }, window => window.dispose());
+    }
+}

package/dist/session/index.d.ts

@@ -13,7 +13,7 @@ export type { QueuedInput } from './telemetry.ts';
 export { DEFAULT_HISTORY_LIMITS, historyLimits } from './memory.ts';
 export type { HistoryLimits } from './memory.ts';
 export { DEFAULT_PROMPT_LIMITS, promptText, PromptIndex, SessionInfo } from './info.ts';
-export type { InteractionState, ModelState, OptionState, PanelState, PromptEntry, PromptLimits, PromptRecord, } from './info.ts';
+export type { InteractionState, OptionState, PromptEntry, PromptLimits, PromptRecord, } from './info.ts';
 export { resolveTarget } from './navigation.ts';
 export { sessionLabel } from '../session-title.ts';
 export { fileReferences } from './references.ts';

package/dist/session/info.d.ts

@@ -1,11 +1,6 @@
-import { Transcript } from './transcript.ts';
-import type { AnswerValue, HistorySearch } from './types.ts';
-import type { ObjectValue } from '../transport/wire.ts';
-/** A durable user prompt as the transcript reports it, before retention. */
-export interface PromptRecord {
-    seq: number;
-    text: string;
-}
+import { Transcript, type PromptRecord } from './transcript.ts';
+export type { PromptRecord } from './transcript.ts';
+import type { AnswerValue } from './types.ts';
 /** One retained prompt: its text, plus the durable sequence when the host also recorded it. */
 export interface PromptEntry extends PromptRecord {
     durable: boolean;
@@ -19,36 +14,6 @@ export interface PromptLimits {
 export declare const DEFAULT_PROMPT_LIMITS: PromptLimits;
 /** Flatten one transcript prompt into the single line the composer recalls. */
 export declare function promptText(value: string): string;
-/** Model dialog step: the catalog plus the provider or model being inspected. */
-export interface ModelState {
-    catalog: ObjectValue;
-    provider?: string;
-    model?: ObjectValue;
-}
-/** Panels the reader opened; visibility and query text only, so the UI owns them.
- *
- * One container rather than one flag per call site, so the composition root has a single panel set
- * to gate keys, reset on a session switch and close from a command. Every session panel's rows come
- * from the selected record and its cursor is focus held by `Picker`; the one exception is `prompts`,
- * which lists a client-global file and is therefore not derived from the record.
- */
-export interface PanelState {
-    thoughts: boolean;
-    queue: boolean;
-    /** Saved shortcut prompts opened by `/prompt`; a client-global list, kept here for one registry. */
-    prompts?: boolean;
-    model?: ModelState;
-    history?: {
-        query: string;
-        contentSearch: boolean;
-        matches?: HistorySearch;
-    };
-    search?: {
-        query: string;
-        items: ObjectValue[];
-        hasMore: boolean;
-    };
-}
 /** Keyboard state of one pending question's options. */
 export interface OptionState {
     key: string;

package/dist/session/info.js

@@ -179,8 +179,16 @@ export class PromptIndex {
      * @returns How many entries were actually retained.
      */
     prepend(values) {
+        const oldest = this.oldest;
+        const seen = new Set();
         const older = values.map(value => ({ seq: value.seq, text: promptText(value.text), durable: true }))
-            .filter(value => !this.internal.has(value.text) && this.retainable(value));
+            .filter(value => {
+            if (oldest !== undefined && value.seq >= oldest || seen.has(value.seq)
+                || this.internal.has(value.text) || !this.retainable(value))
+                return false;
+            seen.add(value.seq);
+            return true;
+        });
         if (!older.length)
             return 0;
         this.entries = [...older, ...this.entries];
@@ -241,10 +249,15 @@ export class PromptIndex {
     }
     /** Drop the oldest entries until both budgets hold; a dropped prefix stays reloadable. */
     trim() {
+        let removed = 0;
         while (this.entries.length > this.limits.maxEntries || this.bytes > this.limits.maxBytes) {
             this.bytes -= this.entries.shift().text.length * 2;
+            removed++;
             this.shed = true;
+            this.complete = false;
         }
+        if (this.position !== undefined)
+            this.position = Math.max(0, this.position - removed);
     }
 }
 /** Bytes of prompt text the process keeps across sessions before evicting the least recently used. */

package/dist/session/interactions.d.ts

@@ -0,0 +1,26 @@
+/** Retained host requests and one response owner per interaction instance. */
+import type { HostEvent } from '../transport/events.ts';
+import type { Json } from '../json.ts';
+import type { AnswerValue, PendingInteraction } from './types.ts';
+export interface InteractionHost {
+    focused(): PendingInteraction | undefined;
+    admit(sessionId: string, dispatch: () => Promise<void>): Promise<void>;
+    reply(eventId: string, outcome: Json): Promise<void>;
+    changed(): void;
+}
+export declare class SessionInteractions {
+    private readonly host;
+    private readonly entries;
+    private readonly responding;
+    constructor(host: InteractionHost);
+    clear(): void;
+    settle(): Promise<void>;
+    pendingFor(sessionId: string | undefined): PendingInteraction[];
+    counts(): ReadonlyMap<string, number>;
+    accept(event: HostEvent): boolean;
+    cancelled(eventId: string): void;
+    answer(value: AnswerValue): Promise<void>;
+    approve(allowed: boolean): Promise<void>;
+    dismissQuestion(): Promise<void>;
+    private respond;
+}

package/dist/session/interactions.js

@@ -0,0 +1,75 @@
+export class SessionInteractions {
+    host;
+    entries = new Map();
+    responding = new Map();
+    constructor(host) {
+        this.host = host;
+    }
+    clear() { this.entries.clear(); }
+    async settle() { await Promise.allSettled(this.responding.values()); }
+    pendingFor(sessionId) {
+        return [...this.entries.values()].filter(frame => frame.sessionId === sessionId);
+    }
+    counts() {
+        const counts = new Map();
+        for (const frame of this.entries.values()) {
+            if (frame.sessionId !== '')
+                counts.set(frame.sessionId, (counts.get(frame.sessionId) ?? 0) + 1);
+        }
+        return counts;
+    }
+    accept(event) {
+        if (event.kind === 'approval-request') {
+            this.entries.set(event.eventId, { kind: 'approval', eventId: event.eventId, sessionId: event.sessionId, description: event.description });
+        }
+        else if (event.kind === 'question-request') {
+            this.entries.set(event.eventId, { kind: 'question', eventId: event.eventId, sessionId: event.sessionId, questions: event.questions });
+        }
+        else
+            return false;
+        this.host.changed();
+        return true;
+    }
+    cancelled(eventId) { this.entries.delete(eventId); this.host.changed(); }
+    async answer(value) {
+        const pending = this.host.focused();
+        if (pending?.kind !== 'question')
+            throw new Error('No pending question');
+        await this.respond(pending, { kind: 'result', value });
+    }
+    async approve(allowed) {
+        const pending = this.host.focused();
+        if (pending?.kind !== 'approval')
+            throw new Error('No pending approval');
+        await this.respond(pending, { kind: 'result', value: allowed ? 'allowed-once' : 'rejected' });
+    }
+    async dismissQuestion() {
+        const pending = this.host.focused();
+        if (pending?.kind !== 'question')
+            throw new Error('No pending question');
+        await this.respond(pending, { kind: 'rejected', error: {
+                name: 'UserQuestionError', message: 'the user cancelled ask_user_question', code: 'ASK_CANCELLED',
+            } });
+    }
+    respond(pending, outcome) {
+        const existing = this.responding.get(pending);
+        if (existing)
+            return existing;
+        // Reserve synchronously; the next Enter joins this response instead of issuing a conflicting one.
+        const response = Promise.resolve().then(() => this.host.admit(pending.sessionId, () => {
+            // Admission may have waited. Cancellation or a replayed request invalidates the captured object.
+            if (this.entries.get(pending.eventId) !== pending)
+                throw new Error('Interaction is no longer pending');
+            return this.host.reply(pending.eventId, outcome);
+        })).then(() => {
+            if (this.entries.get(pending.eventId) === pending) {
+                this.entries.delete(pending.eventId);
+                this.host.changed();
+            }
+        });
+        this.responding.set(pending, response);
+        const release = () => { this.responding.delete(pending); };
+        void response.then(release, release);
+        return response;
+    }
+}

package/dist/session/navigator.d.ts

@@ -0,0 +1,47 @@
+/** Workspace/session navigation owns view intent independently of background list refreshes. */
+import { type ObjectValue } from '../json.ts';
+import type { HostAccess } from '../transport/host.ts';
+export interface NavigationState {
+    screen: 'workspaces' | 'sessions' | 'chat' | 'path';
+    workspaces: ObjectValue[];
+    sessions: ObjectValue[];
+    showAllSessions: boolean;
+    workspaceId?: string;
+    sessionId?: string;
+}
+export interface NavigationHost extends HostAccess {
+    read(): Readonly<NavigationState>;
+    publish(patch: Partial<NavigationState>): void;
+    selection(): number;
+    leave(): void;
+    follow(sessionId: string): void;
+}
+export declare class SessionNavigator {
+    private readonly host;
+    private active?;
+    private readonly tasks;
+    private listsVersion;
+    private revision;
+    constructor(host: NavigationHost);
+    get intent(): number;
+    /** Leaving a view invalidates the request that intended to open it. */
+    cancel(): void;
+    reset(): void;
+    settle(): Promise<void>;
+    private run;
+    private load;
+    private publishLists;
+    refreshLists(): Promise<void>;
+    showPicker(screen: 'workspaces' | 'sessions', signal?: AbortSignal): Promise<void>;
+    showChat(): boolean;
+    enterPath(): void;
+    private commitWorkspace;
+    pickWorkspace(workspaceId?: string): void;
+    switchWorkspace(query?: string, signal?: AbortSignal): Promise<void>;
+    switchSession(query?: string, signal?: AbortSignal): Promise<void>;
+    createWorkspace(path: string, signal?: AbortSignal): Promise<void>;
+    createSession(signal?: AbortSignal): Promise<void>;
+    get visibleSessions(): ObjectValue[];
+    /** Longest registered path wins, with whole-segment matching for nested workspaces. */
+    adoptLocalWorkspace(directory: string): string | undefined;
+}

package/dist/session/navigator.js

@@ -0,0 +1,158 @@
+/** Workspace/session navigation owns view intent independently of background list refreshes. */
+import { array, object, string } from "../json.js";
+import { sessionLabel } from "../session-title.js";
+import { resolveTarget } from "./navigation.js";
+export class SessionNavigator {
+    host;
+    active;
+    tasks = new Map();
+    listsVersion = 0;
+    revision = 0;
+    constructor(host) {
+        this.host = host;
+    }
+    get intent() { return this.revision; }
+    /** Leaving a view invalidates the request that intended to open it. */
+    cancel() { this.revision++; this.active?.abort(); }
+    reset() { this.revision++; for (const abort of this.tasks.keys())
+        abort.abort(); }
+    async settle() { await Promise.allSettled(this.tasks.values()); }
+    run(caller, navigate, work) {
+        if (navigate)
+            this.cancel();
+        const abort = new AbortController();
+        if (navigate)
+            this.active = abort;
+        const selection = this.host.selection();
+        const signal = AbortSignal.any([abort.signal, this.host.signal(), ...(caller ? [caller] : [])]);
+        const task = Promise.resolve().then(async () => {
+            signal.throwIfAborted();
+            const client = this.host.require();
+            const check = () => {
+                signal.throwIfAborted();
+                if (client !== this.host.client() || navigate && selection !== this.host.selection()) {
+                    throw new Error('Navigation changed while loading');
+                }
+            };
+            check();
+            return work({ client, signal, check });
+        }).finally(() => {
+            abort.abort();
+            this.tasks.delete(abort);
+            if (this.active === abort)
+                this.active = undefined;
+        });
+        this.tasks.set(abort, task);
+        return task;
+    }
+    async load(context) {
+        const version = ++this.listsVersion;
+        const [workspaces, sessions] = await Promise.all([
+            context.client.listWorkspaces(context.signal), context.client.listSessions(undefined, context.signal),
+        ]);
+        context.check();
+        return { workspaces, sessions, version };
+    }
+    publishLists(lists) {
+        if (lists.version === this.listsVersion)
+            this.host.publish({ workspaces: lists.workspaces, sessions: lists.sessions });
+    }
+    refreshLists() {
+        return this.run(undefined, false, async (context) => { this.publishLists(await this.load(context)); });
+    }
+    showPicker(screen, signal) {
+        return this.run(signal, true, async (context) => {
+            const lists = await this.load(context);
+            this.publishLists(lists);
+            context.check();
+            this.host.publish({ screen });
+        });
+    }
+    showChat() {
+        if (this.host.read().sessionId === undefined)
+            return false;
+        this.cancel();
+        this.host.publish({ screen: 'chat' });
+        return true;
+    }
+    enterPath() { this.cancel(); this.host.publish({ screen: 'path' }); }
+    commitWorkspace(workspaceId) {
+        this.host.leave();
+        this.host.publish({ workspaceId, sessionId: undefined, showAllSessions: false, screen: 'sessions' });
+    }
+    pickWorkspace(workspaceId) { this.cancel(); this.commitWorkspace(workspaceId); }
+    switchWorkspace(query, signal) {
+        if (!query)
+            return this.showPicker('workspaces', signal);
+        return this.run(signal, true, async (context) => {
+            const lists = await this.load(context);
+            const workspace = resolveTarget(lists.workspaces, query, 'workspaceId', row => [string(row.title), string(row.path)]);
+            this.publishLists(lists);
+            context.check();
+            this.commitWorkspace(string(workspace.workspaceId));
+        });
+    }
+    switchSession(query, signal) {
+        return this.run(signal, true, async (context) => {
+            const lists = await this.load(context);
+            if (!query || query === 'all') {
+                this.publishLists(lists);
+                context.check();
+                this.host.publish({ screen: query === 'all' || this.host.read().workspaceId ? 'sessions' : 'workspaces', showAllSessions: query === 'all' });
+            }
+            else {
+                const session = resolveTarget(lists.sessions, query, 'sessionId', row => [sessionLabel(row)]);
+                this.publishLists(lists);
+                context.check();
+                this.host.follow(string(session.sessionId));
+            }
+        });
+    }
+    createWorkspace(path, signal) {
+        return this.run(signal, true, async (context) => {
+            const result = object(await context.client.call('workspace/create', { request: { path } }, context.signal));
+            context.check();
+            const lists = await this.load(context);
+            this.publishLists(lists);
+            context.check();
+            this.commitWorkspace(string(object(result.workspace).workspaceId));
+        });
+    }
+    createSession(signal) {
+        return this.run(signal, true, async (context) => {
+            const workspaceId = this.host.read().workspaceId;
+            if (!workspaceId)
+                throw new Error('Select a workspace before creating a session');
+            const result = object(await context.client.call('session/create', { request: { workspaceId } }, context.signal));
+            context.check();
+            this.host.follow(string(result.sessionId));
+        });
+    }
+    get visibleSessions() {
+        const state = this.host.read();
+        const sessions = state.sessions.filter(item => !this.host.client()?.archivedSessionIds.has(string(item.sessionId)));
+        if (state.showAllSessions || !state.workspaceId)
+            return sessions;
+        const workspace = state.workspaces.find(item => item.workspaceId === state.workspaceId);
+        const ids = new Set(array(workspace?.sessionIds ?? []).map(string));
+        return sessions.filter(item => ids.has(string(item.sessionId)));
+    }
+    /** Longest registered path wins, with whole-segment matching for nested workspaces. */
+    adoptLocalWorkspace(directory) {
+        const slashed = (value) => value.replace(/\\/g, '/').replace(/\/+$/, '');
+        const target = slashed(directory);
+        if (!target)
+            return undefined;
+        let best;
+        for (const workspace of this.host.read().workspaces) {
+            const path = slashed(string(workspace.path));
+            if (!path || target !== path && !target.startsWith(`${path}/`))
+                continue;
+            if (!best || path.length > best.length)
+                best = { id: string(workspace.workspaceId), length: path.length };
+        }
+        if (best)
+            this.pickWorkspace(best.id);
+        return best?.id;
+    }
+}

package/dist/session/prompt-backfill.d.ts

@@ -0,0 +1,23 @@
+import type { HostAccess } from '../transport/host.ts';
+import { Transcript } from './transcript.ts';
+import type { PromptCache, PromptIndex } from './info.ts';
+interface Selection {
+    sessionId: string;
+    revision: number;
+    record: Transcript;
+    prompts: PromptIndex;
+}
+interface BackfillHost extends Pick<HostAccess, 'require' | 'signal' | 'online'> {
+    current(selection: Selection): boolean;
+    changed(): void;
+}
+export declare class PromptBackfill {
+    private readonly host;
+    private readonly cache;
+    private readonly tasks;
+    constructor(host: BackfillHost, cache: PromptCache);
+    cancel(): void;
+    settle(): Promise<void>;
+    start(selection: Selection): void;
+}
+export {};