@pentoshi/clai 2.0.62 → 3.5.1

package/dist/app/controllers/disposable.d.ts

@@ -0,0 +1,15 @@
+export interface Disposable {
+    dispose(): void;
+}
+/**
+ * Owns a set of disposables and tears them down in reverse creation order
+ * (ARCHITECTURE.md lifecycle). Disposal is idempotent (REL-001): a second call
+ * is a no-op, and one throwing disposer does not prevent the rest from running.
+ */
+export declare class CompositeDisposable implements Disposable {
+    private readonly items;
+    private disposed;
+    add<T extends Disposable>(item: T): T;
+    get isDisposed(): boolean;
+    dispose(): void;
+}

package/dist/app/controllers/disposable.js

@@ -0,0 +1,38 @@
+/**
+ * Owns a set of disposables and tears them down in reverse creation order
+ * (ARCHITECTURE.md lifecycle). Disposal is idempotent (REL-001): a second call
+ * is a no-op, and one throwing disposer does not prevent the rest from running.
+ */
+export class CompositeDisposable {
+    items = [];
+    disposed = false;
+    add(item) {
+        if (this.disposed) {
+            item.dispose();
+            return item;
+        }
+        this.items.push(item);
+        return item;
+    }
+    get isDisposed() {
+        return this.disposed;
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        const errors = [];
+        for (let i = this.items.length - 1; i >= 0; i -= 1) {
+            try {
+                this.items[i]?.dispose();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        this.items.length = 0;
+        if (errors.length > 0)
+            throw errors[0];
+    }
+}
+//# sourceMappingURL=disposable.js.map

package/dist/app/controllers/disposable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposable.js","sourceRoot":"","sources":["../../../src/app/controllers/disposable.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,MAAM,OAAO,mBAAmB;IACb,KAAK,GAAiB,EAAE,CAAC;IAClC,QAAQ,GAAG,KAAK,CAAC;IAEzB,GAAG,CAAuB,IAAO;QAC/B,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,OAAO;QACL,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO;QAC1B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YACnD,IAAI,CAAC;gBACH,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC;YAC3B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QACtB,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,MAAM,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;CACF"}

package/dist/app/controllers/job-controller.d.ts

@@ -0,0 +1,22 @@
+import type { ToolResult } from "../../types.js";
+import type { BackgroundJob, JobsPort } from "../ports/jobs-port.js";
+import type { Disposable } from "./disposable.js";
+/**
+ * Thin lifecycle wrapper over `JobsPort` (CORE-004). Jobs live in the core
+ * manager and survive UI rerenders; this controller only observes and commands.
+ */
+export declare class JobController implements Disposable {
+    private readonly jobs;
+    constructor(jobs: JobsPort);
+    list(): ToolResult;
+    running(): BackgroundJob[];
+    get(id: string): BackgroundJob | undefined;
+    tail(id: string, bytes?: number): Promise<ToolResult>;
+    stop(id: string): ToolResult;
+    start(command: string, options?: {
+        cwd?: string | undefined;
+        name?: string | undefined;
+    }): Promise<ToolResult>;
+    hasRunning(): boolean;
+    dispose(): void;
+}

package/dist/app/controllers/job-controller.js

@@ -0,0 +1,35 @@
+/**
+ * Thin lifecycle wrapper over `JobsPort` (CORE-004). Jobs live in the core
+ * manager and survive UI rerenders; this controller only observes and commands.
+ */
+export class JobController {
+    jobs;
+    constructor(jobs) {
+        this.jobs = jobs;
+    }
+    list() {
+        return this.jobs.list();
+    }
+    running() {
+        return this.jobs.running();
+    }
+    get(id) {
+        return this.jobs.get(id);
+    }
+    tail(id, bytes) {
+        return this.jobs.tail(id, bytes);
+    }
+    stop(id) {
+        return this.jobs.stop(id);
+    }
+    start(command, options) {
+        return this.jobs.start(command, options);
+    }
+    hasRunning() {
+        return this.running().length > 0;
+    }
+    dispose() {
+        // Jobs intentionally outlive the UI; nothing to tear down here.
+    }
+}
+//# sourceMappingURL=job-controller.js.map

package/dist/app/controllers/job-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-controller.js","sourceRoot":"","sources":["../../../src/app/controllers/job-controller.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,OAAO,aAAa;IACK;IAA7B,YAA6B,IAAc;QAAd,SAAI,GAAJ,IAAI,CAAU;IAAG,CAAC;IAE/C,IAAI;QACF,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IAC1B,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAED,GAAG,CAAC,EAAU;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC3B,CAAC;IAED,IAAI,CAAC,EAAU,EAAE,KAAc;QAC7B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IAED,IAAI,CAAC,EAAU;QACb,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;IAED,KAAK,CACH,OAAe,EACf,OAAiE;QAEjE,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC3C,CAAC;IAED,UAAU;QACR,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;IACnC,CAAC;IAED,OAAO;QACL,gEAAgE;IAClE,CAAC;CACF"}

package/dist/app/controllers/plan-controller.d.ts

@@ -0,0 +1,31 @@
+import type { SessionPlan } from "../../store/plan.js";
+import type { AnyAppEvent } from "../events/app-event.js";
+import type { PersistencePort } from "../ports/persistence-port.js";
+import type { Disposable } from "./disposable.js";
+export type PlanListener = () => void;
+/**
+ * Holds the one current plan entity and keeps it in sync with the event stream
+ * (PLAN-003: mutate the existing plan, never append duplicates). Approval and
+ * discard mutate persisted status through the persistence port. Observable so
+ * the UI can bind reactively without polling (PLAN-002).
+ */
+export declare class PlanController implements Disposable {
+    private readonly persistence;
+    private plan;
+    private readonly listeners;
+    constructor(persistence: PersistencePort);
+    current(): SessionPlan | undefined;
+    subscribe(listener: PlanListener): () => void;
+    observe(event: AnyAppEvent): void;
+    /**
+     * Load the plan for `sessionId` from disk into memory. Clears the in-memory
+     * plan when none is stored (so switching sessions never leaves a stale card).
+     */
+    load(sessionId: string): Promise<SessionPlan | undefined>;
+    /** Drop the in-memory plan without touching disk. */
+    clear(): void;
+    approve(): Promise<SessionPlan | undefined>;
+    discard(): Promise<void>;
+    dispose(): void;
+    private notify;
+}

package/dist/app/controllers/plan-controller.js

@@ -0,0 +1,69 @@
+/**
+ * Holds the one current plan entity and keeps it in sync with the event stream
+ * (PLAN-003: mutate the existing plan, never append duplicates). Approval and
+ * discard mutate persisted status through the persistence port. Observable so
+ * the UI can bind reactively without polling (PLAN-002).
+ */
+export class PlanController {
+    persistence;
+    plan;
+    listeners = new Set();
+    constructor(persistence) {
+        this.persistence = persistence;
+    }
+    current() {
+        return this.plan;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    observe(event) {
+        if (event.type === "plan-updated") {
+            this.plan = event.payload.plan;
+            this.notify();
+        }
+    }
+    /**
+     * Load the plan for `sessionId` from disk into memory. Clears the in-memory
+     * plan when none is stored (so switching sessions never leaves a stale card).
+     */
+    async load(sessionId) {
+        this.plan = await this.persistence.loadPlan(sessionId);
+        this.notify();
+        return this.plan;
+    }
+    /** Drop the in-memory plan without touching disk. */
+    clear() {
+        if (!this.plan)
+            return;
+        this.plan = undefined;
+        this.notify();
+    }
+    async approve() {
+        if (!this.plan)
+            return undefined;
+        const next = { ...this.plan, status: "approved" };
+        this.plan = next;
+        await this.persistence.savePlan(next);
+        this.notify();
+        return next;
+    }
+    async discard() {
+        if (!this.plan)
+            return;
+        const { sessionId } = this.plan;
+        this.plan = undefined;
+        await this.persistence.deletePlan(sessionId);
+        this.notify();
+    }
+    dispose() {
+        this.plan = undefined;
+        this.listeners.clear();
+    }
+    notify() {
+        for (const listener of this.listeners)
+            listener();
+    }
+}
+//# sourceMappingURL=plan-controller.js.map

package/dist/app/controllers/plan-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-controller.js","sourceRoot":"","sources":["../../../src/app/controllers/plan-controller.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,MAAM,OAAO,cAAc;IAII;IAHrB,IAAI,CAA0B;IACrB,SAAS,GAAG,IAAI,GAAG,EAAgB,CAAC;IAErD,YAA6B,WAA4B;QAA5B,gBAAW,GAAX,WAAW,CAAiB;IAAG,CAAC;IAE7D,OAAO;QACL,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED,SAAS,CAAC,QAAsB;QAC9B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC7B,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC/C,CAAC;IAED,OAAO,CAAC,KAAkB;QACxB,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;YAClC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;YAC/B,IAAI,CAAC,MAAM,EAAE,CAAC;QAChB,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,IAAI,CAAC,SAAiB;QAC1B,IAAI,CAAC,IAAI,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QACvD,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED,qDAAqD;IACrD,KAAK;QACH,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO;QACvB,IAAI,CAAC,IAAI,GAAG,SAAS,CAAC;QACtB,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAED,KAAK,CAAC,OAAO;QACX,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO,SAAS,CAAC;QACjC,MAAM,IAAI,GAAgB,EAAE,GAAG,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;QAC/D,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAED,KAAK,CAAC,OAAO;QACX,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO;QACvB,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC;QAChC,IAAI,CAAC,IAAI,GAAG,SAAS,CAAC;QACtB,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAED,OAAO;QACL,IAAI,CAAC,IAAI,GAAG,SAAS,CAAC;QACtB,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;IACzB,CAAC;IAEO,MAAM;QACZ,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,SAAS;YAAE,QAAQ,EAAE,CAAC;IACpD,CAAC;CACF"}

package/dist/app/controllers/session-controller.d.ts

@@ -0,0 +1,167 @@
+import type { ChatMessage, Mode, ProviderId } from "../../types.js";
+import { type CompactResult } from "../../agent/context-manager.js";
+import type { TranscriptItem as ClassicTranscriptItem } from "../../tui/state.js";
+import { type AnyAppEvent, type SessionId, type TurnId } from "../events/app-event.js";
+import { type Clock, type IdFactory } from "../events/sequencer.js";
+import { OutputSpool } from "../events/event-buffer.js";
+import type { AgentPort } from "../ports/agent-port.js";
+import type { PersistencePort } from "../ports/persistence-port.js";
+import type { ConfirmationPort } from "../ports/confirm-port.js";
+import type { SecretPort } from "../ports/secret-port.js";
+import { type TurnResult } from "./turn-controller.js";
+import { type Disposable } from "./disposable.js";
+export interface SessionState {
+    readonly sessionId: SessionId;
+    readonly mode: Mode;
+    readonly provider: ProviderId | undefined;
+    readonly model: string | undefined;
+    readonly running: boolean;
+    /** True while /compact is awaiting the summarizer (status strip). */
+    readonly compacting: boolean;
+    readonly historyLength: number;
+    readonly queued: readonly string[];
+    /** AI-generated (or last known) display name for this session. */
+    readonly title: string | undefined;
+}
+export type NoticeLevel = "info" | "warn";
+export interface SessionControllerDeps {
+    readonly agent: AgentPort;
+    readonly persistence: PersistencePort;
+    readonly emit: (event: AnyAppEvent) => void;
+    readonly sessionId?: string | undefined;
+    readonly provider?: ProviderId | undefined;
+    readonly model?: string | undefined;
+    readonly mode?: Mode | undefined;
+    readonly confirm?: ConfirmationPort | undefined;
+    readonly requestSecret?: SecretPort["request"] | undefined;
+    readonly idFactory?: IdFactory | undefined;
+    readonly clock?: Clock | undefined;
+    readonly mintTurnId?: (() => TurnId) | undefined;
+    /**
+     * Optional snapshot of the visual transcript for history.db (classic shape).
+     * When provided, completed turns upsert session + transcript so /history
+     * can restore tools and prompts, not only ChatMessage[].
+     */
+    readonly getTranscriptSnapshot?: (() => ClassicTranscriptItem[] | undefined) | undefined;
+    /** When true, never persist sessions or generate AI titles (CLI --no-history). */
+    readonly noHistory?: boolean | undefined;
+}
+/**
+ * Owns session-level state (mode, provider/model, cumulative history, queued
+ * drafts) and runs turns through a single `TurnController`. Cumulative history
+ * follows the current runner contract: `onMessages` hands back the full
+ * conversation for the turn (prior context + this turn), which replaces the
+ * stored history and is persisted on completion.
+ */
+export type TurnEndListener = (result: TurnResult) => void;
+export type SessionStateListener = () => void;
+export declare class SessionController implements Disposable {
+    private readonly deps;
+    readonly spool: OutputSpool;
+    private sessionIdValue;
+    private readonly sequencer;
+    private readonly turn;
+    private policy;
+    private readonly disposables;
+    private readonly turnEndListeners;
+    private readonly stateListeners;
+    private history;
+    private readonly queue;
+    /**
+     * Prompt promoted by "Send now" while a turn was running. After the abort
+     * settles, {@link continueQueue} runs this before any remaining queue items.
+     */
+    private priorityPrompt;
+    /** Re-entrancy guard for {@link continueQueue}. */
+    private continuingQueue;
+    private provider;
+    private model;
+    private mode;
+    private compactingFlag;
+    /** Display name written into history.db (AI title or explicit /save name). */
+    private sessionTitle;
+    /** User-message count at last successful AI title (classic refresh cadence). */
+    private titledAtUserCount;
+    private titleInFlight;
+    constructor(deps: SessionControllerDeps);
+    get sessionId(): SessionId;
+    getState(): SessionState;
+    get messages(): readonly ChatMessage[];
+    /** Subscribe to transient UI state such as running/queue status. */
+    subscribe(listener: SessionStateListener): () => void;
+    setProvider(provider: ProviderId | undefined): void;
+    setModel(model: string | undefined): void;
+    setMode(mode: Mode): void;
+    /**
+     * Replace model history (and optionally rebind the session id so later
+     * autosaves update the resumed history row).
+     */
+    loadHistory(messages: readonly ChatMessage[], options?: {
+        sessionId?: string;
+        title?: string | undefined;
+    }): void;
+    notice(level: NoticeLevel, text: string): void;
+    allowTool(name: string): void;
+    disallowTool(name: string): void;
+    allowedTools(): readonly string[];
+    /**
+     * Clear conversation state. When `mintNewId` is true (for `/new`/`/clean`),
+     * remint the session id so subsequent autosave does not overwrite the prior
+     * history row.
+     */
+    reset(options?: {
+        mintNewId?: boolean;
+    }): void;
+    compact(sessionTranscript?: string, keepRecent?: number, signal?: AbortSignal): Promise<CompactResult>;
+    /** Persist current messages (+ optional visual transcript) under this session id. */
+    persistNow(name?: string): Promise<void>;
+    /**
+     * Ask the model for a short conversation title and upsert it into history.
+     * Cadence matches classic TUI: first completed exchange, then every +2 user
+     * turns so the name tracks the evolving topic.
+     */
+    maybeRefreshTitle(): Promise<void>;
+    estimateContext(): {
+        messages: number;
+        tokens: number;
+    };
+    enqueue(prompt: string): void;
+    queued(): readonly string[];
+    removeQueued(index: number): void;
+    /**
+     * Remove a queued draft and return its text (for "Edit" → composer).
+     * Returns undefined when the index is out of range.
+     */
+    takeQueued(index: number): string | undefined;
+    /** Edit a queued draft in place before it runs (INPUT-007). */
+    editQueued(index: number, text: string): void;
+    /** Move a queued draft to a new position before it runs (INPUT-007). */
+    reorderQueued(fromIndex: number, toIndex: number): void;
+    /**
+     * Send a queued prompt immediately. If a turn is running, abort it first;
+     * the chosen prompt runs next (ahead of any remaining queue). If idle,
+     * submit it now.
+     */
+    sendQueuedNow(index: number): void;
+    abort(): void;
+    /**
+     * After a turn settles, run any "send now" priority prompt, then drain the
+     * queue one-by-one. Safe to call from onTurnEnd (re-entrancy guarded).
+     */
+    continueQueue(): Promise<void>;
+    /** In-memory plan-approval flag consumed by the agent gate (CORE-005). */
+    setPlanApproved(value: boolean): void;
+    isPlanApproved(): boolean;
+    /** Fires after every turn settles (completed/aborted/error), including drain. */
+    onTurnEnd(listener: TurnEndListener): () => void;
+    submit(prompt: string): Promise<TurnResult>;
+    /**
+     * Runs queued prompts one at a time while idle; stops on first
+     * non-completion. Prefer {@link continueQueue} from the UI so priority
+     * ("send now") prompts are honored too.
+     */
+    drain(): Promise<TurnResult[]>;
+    private runTurn;
+    dispose(): void;
+    private notifyState;
+}