@lotagate/cli 0.1.24 → 0.1.26

package/dist/infrastructure/tokens/tiktoken-token-estimator.d.ts

@@ -0,0 +1,18 @@
+import type { ChatUsage } from '../../ports/chat-model.js';
+export interface TokenEstimateInput {
+    model: string;
+    prompt: string;
+    response: string;
+}
+export interface TextTokenEstimateInput {
+    model: string;
+    text: string;
+}
+/**
+ * Estimates turn usage when an upstream provider does not include usage in the
+ * streaming protocol. The result is deliberately marked as estimated because
+ * providers may use a tokenizer different from the OpenAI tokenizer family.
+ */
+export declare function estimateTurnUsage(input: TokenEstimateInput): ChatUsage | undefined;
+/** Estimates one text payload with the same tokenizer used for turn fallback accounting. */
+export declare function estimateTextTokens(input: TextTokenEstimateInput): number;

package/dist/infrastructure/tokens/tiktoken-token-estimator.js

@@ -0,0 +1 @@
+import{encoding_for_model as c,get_encoding as d}from"tiktoken";import{FALLBACK_ENCODING as f}from"./token-constants.js";function m(e){try{const t=o(e.model);try{const n=t.encode(e.prompt).length,r=t.encode(e.response).length;return{promptTokens:n,completionTokens:r,totalTokens:n+r,estimated:!0}}finally{t.free()}}catch{return}}function a(e){try{const t=o(e.model);try{return t.encode(e.text).length}finally{t.free()}}catch{return Math.ceil(Buffer.byteLength(e.text,"utf8")/4)}}function o(e){try{return c(e)}catch{return d(f)}}export{a as estimateTextTokens,m as estimateTurnUsage};

package/dist/infrastructure/tokens/token-constants.d.ts

@@ -0,0 +1 @@
+export declare const FALLBACK_ENCODING = "o200k_base";

package/dist/infrastructure/tokens/token-constants.js

@@ -0,0 +1 @@
+const o="o200k_base";export{o as FALLBACK_ENCODING};

package/dist/infrastructure/workspace/workspace-settings-store.d.ts

@@ -0,0 +1,10 @@
+import { type WorkspaceSettings } from '../../domain/workspace/workspace-settings.js';
+export declare class WorkspaceSettingsStore {
+    ensureInitialized(cwd: string): Promise<void>;
+    load(cwd: string): Promise<WorkspaceSettings>;
+    /** Persist a user-approved rule in the ignored local project policy. */
+    rememberAllow(cwd: string, rule: string): Promise<void>;
+    private readOptional;
+    private readDocumentOptional;
+    private createIfMissing;
+}

package/dist/infrastructure/workspace/workspace-settings-store.js

@@ -0,0 +1,4 @@
+import n from"node:fs/promises";import d from"node:path";import{DEFAULT_WORKSPACE_SETTINGS as l,normalizePermissionRule as f}from"../../domain/workspace/workspace-settings.js";import{permissionsFromSettings as u,validateSettingsDocument as g}from"../../domain/settings/settings-document.js";import{resolveProjectConfigPaths as c}from"../platform/platform-paths.js";import{atomicWriteFile as w,withFileLock as h}from"../filesystem/atomic-file-store.js";import{isAlreadyExists as y,isFileNotFound as S}from"../filesystem/fs-errors.js";import{readJsonFileBounded as k}from"../filesystem/bounded-json-reader.js";import{RESOURCE_LIMITS as O}from"../../domain/runtime/resource-limits.js";class T{async ensureInitialized(t){const i=c(t);await n.mkdir(i.directory,{recursive:!0}),await Promise.all([i.skillsDir,i.pluginsDir,i.hooksDir].map(e=>n.mkdir(e,{recursive:!0}))),await this.createIfMissing(i.settings,l),await this.createIfMissing(i.localSettings,l),await this.createIfMissing(d.join(i.directory,".gitignore"),`settings.local.json
+`)}async load(t){const i=c(t),[e,r]=await Promise.all([this.readOptional(i.settings),this.readOptional(i.localSettings)]);return{schemaVersion:1,permissions:D(e?.permissions,r?.permissions)}}async rememberAllow(t,i){if(i.trim().length===0)return;const e=f(i),r=c(t);await n.mkdir(r.directory,{recursive:!0}),await h(r.localSettings,async()=>{const o=await this.readDocumentOptional(r.localSettings),a=o===void 0?l:{schemaVersion:1,permissions:u(o)};if(a.permissions.allow.includes(e))return;const p={...o?.config??{},permissions:{...a.permissions,allow:[...a.permissions.allow,e]}};await w(r.localSettings,`${JSON.stringify(p,null,2)}
+`)})}async readOptional(t){const i=await this.readDocumentOptional(t);if(i!==void 0)return{schemaVersion:1,permissions:u(i)}}async readDocumentOptional(t){try{return g(await k(t,O.workspaceSettingsBytes))}catch(i){if(S(i))return;throw i}}async createIfMissing(t,i){try{await n.writeFile(t,typeof i=="string"?i:`${JSON.stringify(i,null,2)}
+`,{encoding:"utf8",mode:384,flag:"wx"})}catch(e){if(!y(e))throw e}}}function D(s,t){return{allow:m(s?.allow,t?.allow),ask:m(s?.ask,t?.ask),deny:m(s?.deny,t?.deny)}}function m(...s){return[...new Set(s.flatMap(t=>t??[]))]}export{T as WorkspaceSettingsStore};

package/dist/main.d.ts

@@ -0,0 +1,7 @@
+import type { Readable, Writable } from 'node:stream';
+export { CLI_VERSION } from './version.js';
+export declare function main(argv: readonly string[], io?: {
+    stdin?: Readable;
+    stdout?: Writable;
+    stderr?: Writable;
+}): Promise<number>;

package/dist/main.js

@@ -0,0 +1,3 @@
+import{asCliError as S}from"./domain/errors/cli-error.js";import{createCompositionRoot as E}from"./bootstrap/composition-root.js";import{resolveStartupContext as x}from"./bootstrap/startup-sequence.js";import{parseGlobalCliOptions as O}from"./bootstrap/global-cli-options.js";import{TuiApplication as h}from"./presentation/tui/tui-application.js";import{formatCliErrorMessage as T}from"./application/commands/command-hints.js";import{COMMAND_REGISTRY as b}from"./application/commands/command-runtime.js";import{parseCommandInvocation as R}from"./application/commands/command-parser.js";import{executeApplicationCommand as v,executeInformationalCommand as G}from"./application/commands/application-command-executor.js";import{CLI_VERSION as B}from"./version.js";async function V(o,e={}){const y=e.stdin??process.stdin,n=e.stdout??process.stdout,u=e.stderr??process.stderr;let r;const i=new AbortController;let f=143;const p=()=>i.abort(new Error("Process termination requested."));let c;process.once("SIGTERM",p);try{const l=O(o),t=M(l.commandTokens);if(t.length===0){r=E({stderr:u,interactive:!0});const d=r.logger;d.info("Interactive session started.");const w=await new h(r,x(o).cwd,{output:n,signal:i.signal}).run();return d.info("Interactive session completed.",{exitCode:w}),w}const a=x(o).cwd,s=R(t,"direct",b),g=G(s,n);if(g!==void 0)return g;s.action.executor==="agent"&&(c=()=>{f=130,i.abort(new Error("Process interruption requested."))},process.once("SIGINT",c));const m=E({stderr:u});r=m;const C=m.logger;C.info("CLI command started.",{command:s.action.id,cwd:a});const I=await v(s,{runtime:m,cwd:a,output:n,stdin:y,writableOutput:n,signal:i.signal,resumeInteractive:async d=>new h(m,a,{output:n,sessionId:d,signal:i.signal}).run()});return C.info("CLI command completed.",{command:s.action.id,exitCode:I}),I}catch(l){if(i.signal.aborted)return f;const t=S(l);return r?.logger.error("CLI command failed.",{code:t.code,category:t.category}),N(o)?n.write(`${JSON.stringify({error:t.toJSON()})}
+`):r!==void 0?r.logger.error(T(t,"direct"),{code:t.code,category:t.category}):u.write(`[error] ${T(t,"direct")}
+`),t.exitCode}finally{process.off("SIGTERM",p),c!==void 0&&process.off("SIGINT",c),await r?.shutdown.shutdown()}}function N(o){return o.some(e=>e==="--json"||e.startsWith("--json="))}function M(o){return o.length===1&&(o[0]==="--help"||o[0]==="-h")?["help"]:o.length===1&&o[0]==="--version"?["version"]:o}export{B as CLI_VERSION,V as main};

package/dist/ports/cache-store.d.ts

@@ -0,0 +1,10 @@
+export interface CacheWriteOptions {
+    ttlMs: number;
+}
+export interface CacheStore {
+    get<T>(namespace: string, key: string): Promise<T | undefined>;
+    set<T>(namespace: string, key: string, value: T, options: CacheWriteOptions): Promise<void>;
+    delete(namespace: string, key: string): Promise<void>;
+    clear(namespace?: string): Promise<void>;
+    prune(): Promise<void>;
+}

package/dist/ports/chat-model.d.ts

@@ -0,0 +1,30 @@
+import type { AttachmentPayload } from '../domain/session/attachment.js';
+export interface ChatModelRequest {
+    model: string;
+    prompt: string;
+    reasoningEffort?: string;
+    attachments?: readonly AttachmentPayload[];
+    signal?: AbortSignal;
+}
+export interface ChatUsage {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    /** True when the CLI derived usage locally rather than receiving it from the provider. */
+    estimated?: boolean;
+}
+export type ChatModelEvent = {
+    type: 'activity';
+    state: 'connecting' | 'thinking' | 'writing' | 'completed';
+} | {
+    type: 'delta';
+    content: string;
+} | {
+    type: 'usage';
+    usage: ChatUsage;
+} | {
+    type: 'completed';
+};
+export interface ChatModelPort {
+    stream(request: ChatModelRequest): AsyncIterable<ChatModelEvent>;
+}

package/dist/ports/clipboard-adapter.d.ts

@@ -0,0 +1,7 @@
+export interface ClipboardImage {
+    bytes: Uint8Array;
+    mimeType: string;
+}
+export interface ClipboardAdapter {
+    readImage(): Promise<ClipboardImage | undefined>;
+}

package/dist/ports/clipboard-text-adapter.d.ts

@@ -0,0 +1,3 @@
+export interface ClipboardTextAdapter {
+    readText(): Promise<string | undefined>;
+}

package/dist/ports/credential-store.d.ts

@@ -0,0 +1,7 @@
+import type { AuthProfile, StoredCredential } from '../domain/auth/auth-profile.js';
+export interface CredentialStore {
+    list(): Promise<readonly AuthProfile[]>;
+    get(profileName: string): Promise<StoredCredential | undefined>;
+    set(credential: StoredCredential): Promise<void>;
+    delete(profileName: string): Promise<boolean>;
+}

package/dist/ports/goal-store.d.ts

@@ -0,0 +1,12 @@
+import type { CreateGoalInput, GoalEvaluation, GoalState, GoalUsageDelta } from '../domain/orchestration/goal.js';
+export interface GoalStore {
+    get(sessionId: string): Promise<GoalState | undefined>;
+    create(sessionId: string, input: CreateGoalInput): Promise<GoalState>;
+    replace(sessionId: string, input: CreateGoalInput): Promise<GoalState>;
+    pause(sessionId: string, reason?: string): Promise<GoalState>;
+    resume(sessionId: string): Promise<GoalState>;
+    recordTurn(sessionId: string): Promise<GoalState>;
+    recordUsage(sessionId: string, delta: GoalUsageDelta): Promise<GoalState>;
+    recordEvaluation(sessionId: string, evaluation: GoalEvaluation): Promise<GoalState>;
+    clear(sessionId: string, reason?: string): Promise<void>;
+}

package/dist/ports/logger.d.ts

@@ -0,0 +1,8 @@
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+export interface Logger {
+    error(message: string, details?: Record<string, unknown>): void;
+    warn(message: string, details?: Record<string, unknown>): void;
+    info(message: string, details?: Record<string, unknown>): void;
+    debug(message: string, details?: Record<string, unknown>): void;
+    trace(message: string, details?: Record<string, unknown>): void;
+}

package/dist/ports/media-gateway-client.d.ts

@@ -0,0 +1,60 @@
+import type { GeneratedImage, MediaBinary, VideoOperation } from '../domain/media/media-contract.js';
+export type SpeechStreamFormat = 'audio' | 'sse';
+export type SpeechStreamEvent = Readonly<Record<string, unknown>>;
+export interface MediaRequestOptions {
+    readonly signal?: AbortSignal | undefined;
+}
+export interface ImageGenerationInput {
+    readonly model: string;
+    readonly prompt: string;
+    readonly n?: number | undefined;
+    readonly size?: string | undefined;
+    readonly quality?: 'low' | 'medium' | 'high' | 'auto' | undefined;
+    readonly background?: 'transparent' | 'opaque' | 'auto' | undefined;
+    readonly outputFormat?: 'png' | 'jpeg' | 'webp' | undefined;
+    readonly outputCompression?: number | undefined;
+    readonly moderation?: string | undefined;
+    readonly user?: string | undefined;
+}
+export interface ImageEditInput extends ImageGenerationInput {
+    readonly images: Uint8Array[];
+    readonly mask?: Uint8Array | undefined;
+    readonly inputFidelity?: 'low' | 'high' | undefined;
+}
+export interface SpeechInput {
+    readonly model: string;
+    readonly input: string;
+    readonly voice: string;
+    readonly instructions?: string | undefined;
+    readonly responseFormat?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm' | undefined;
+    readonly speed?: number | undefined;
+    readonly streamFormat?: SpeechStreamFormat | undefined;
+}
+export interface AudioUploadInput {
+    readonly model: string;
+    readonly file: Uint8Array;
+    readonly filename: string;
+    readonly prompt?: string | undefined;
+    readonly responseFormat?: string | undefined;
+    readonly temperature?: number | undefined;
+    readonly language?: string | undefined;
+    readonly timestampGranularities?: readonly ('word' | 'segment')[] | undefined;
+    readonly include?: readonly string[] | undefined;
+}
+export interface MediaGatewayClient {
+    generateImage(input: ImageGenerationInput, options?: MediaRequestOptions): Promise<readonly GeneratedImage[]>;
+    editImage(input: ImageEditInput, options?: MediaRequestOptions): Promise<readonly GeneratedImage[]>;
+    createSpeech(input: SpeechInput, options?: MediaRequestOptions): Promise<MediaBinary>;
+    createSpeechStream(input: SpeechInput & {
+        readonly streamFormat: 'sse';
+    }, options?: MediaRequestOptions): AsyncIterable<SpeechStreamEvent>;
+    transcribe(input: AudioUploadInput, options?: MediaRequestOptions): Promise<string>;
+    translate(input: AudioUploadInput, options?: MediaRequestOptions): Promise<string>;
+    createVideo(input: {
+        model: string;
+        prompt: string;
+        parameters?: Record<string, unknown>;
+    }, options?: MediaRequestOptions): Promise<VideoOperation>;
+    getVideoOperation(id: string, options?: MediaRequestOptions): Promise<VideoOperation>;
+    downloadVideo(id: string, options?: MediaRequestOptions): Promise<MediaBinary>;
+}

package/dist/ports/memory-store.d.ts

@@ -0,0 +1,26 @@
+import type { MemoryBundle, MemoryDraft, MemoryRecord, MemoryState } from '../domain/memory/memory.js';
+import type { MemoryKind } from '../domain/memory/memory-kinds.js';
+import type { MemorySearchHit, MemorySearchQuery, MemorySemanticHit } from '../domain/memory/memory-search.js';
+export interface MemoryListOptions {
+    readonly kind?: MemoryKind;
+    readonly state?: MemoryState;
+}
+export interface MemoryStore {
+    list(cwd: string, options?: MemoryListOptions): Promise<readonly MemoryRecord[]>;
+    search(cwd: string, query: MemorySearchQuery): Promise<readonly MemorySearchHit[]>;
+    ensureSemanticIndex(cwd: string, model: string, embed: (texts: readonly string[], signal?: AbortSignal) => Promise<readonly number[][]>, signal?: AbortSignal): Promise<void>;
+    semanticSearch(cwd: string, model: string, vector: readonly number[], maximum: number): Promise<readonly MemorySemanticHit[]>;
+    get(cwd: string, id: string): Promise<MemoryRecord | undefined>;
+    consolidate(cwd: string, draft: MemoryDraft): Promise<{
+        record: MemoryRecord;
+        action: 'insert' | 'merge' | 'supersede' | 'ignore';
+    }>;
+    forget(cwd: string, id: string): Promise<boolean>;
+    clear(cwd: string): Promise<number>;
+    markRetrieved(cwd: string, ids: readonly string[]): Promise<void>;
+    export(cwd: string): Promise<MemoryBundle>;
+    import(cwd: string, bundle: MemoryBundle): Promise<{
+        imported: number;
+        skipped: number;
+    }>;
+}

package/dist/ports/model-completion-client.d.ts

@@ -0,0 +1,8 @@
+import type { ChatCompletionRequest, ChatCompletionResponse, RequestOptions } from '@lotagate/sdk';
+export interface ModelCompletionClient {
+    readonly chat: {
+        readonly completions: {
+            create(request: ChatCompletionRequest, options?: RequestOptions): Promise<ChatCompletionResponse>;
+        };
+    };
+}

package/dist/ports/model-diagnostics.d.ts

@@ -0,0 +1,17 @@
+import type { ChatUsage } from './chat-model.js';
+export interface ModelCallSummary {
+    model: string;
+    stream: boolean;
+    contentLength: number;
+    toolCallCount: number;
+    toolNames: readonly string[];
+    finishReason?: string | null;
+    usage?: ChatUsage;
+}
+export interface ModelUsageReport {
+    usage: ChatUsage;
+    modelCalls?: number;
+}
+export interface ModelCallObserver {
+    onComplete?: (summary: ModelCallSummary) => void;
+}

package/dist/ports/project-trust-store.d.ts

@@ -0,0 +1,12 @@
+export interface TrustedProject {
+    fingerprint: string;
+    canonicalPath: string;
+    grantedAt: string;
+    grantedBy: 'user';
+}
+export interface ProjectTrustStore {
+    list(): Promise<readonly TrustedProject[]>;
+    get(fingerprint: string): Promise<TrustedProject | undefined>;
+    grant(project: TrustedProject): Promise<void>;
+    revoke(fingerprint: string): Promise<boolean>;
+}

package/dist/ports/session-store.d.ts

@@ -0,0 +1,59 @@
+import type { Attachment } from '../domain/session/attachment.js';
+import type { SessionEvent, SessionMetadata, TranscriptEntry } from '../domain/session/session.js';
+export interface SessionBundle {
+    metadata: SessionMetadata;
+    events: readonly SessionEvent[];
+    transcript: readonly TranscriptEntry[];
+    attachments: readonly {
+        attachment: Attachment;
+        dataBase64: string;
+    }[];
+}
+export interface SessionRepairResult {
+    eventsRemoved: number;
+    transcriptRemoved: number;
+}
+export interface AppendEventOptions {
+    /** The caller already owns the session lock for an atomic read/modify/write operation. */
+    locked?: boolean;
+}
+export interface CompactSessionOptions {
+    turnId?: string;
+}
+/** A consistent transcript/event view derived from one journal snapshot. */
+export interface SessionHistory {
+    events: readonly SessionEvent[];
+    transcript: readonly TranscriptEntry[];
+}
+/** Ordered durable records to append under one session lock. */
+export type SessionJournalAppend = {
+    kind: 'event';
+    event: SessionEvent;
+} | {
+    kind: 'transcript';
+    entry: TranscriptEntry;
+};
+export interface SessionStore {
+    create(input: Omit<SessionMetadata, 'id' | 'createdAt' | 'updatedAt'>): Promise<SessionMetadata>;
+    get(sessionId: string): Promise<SessionMetadata | undefined>;
+    list(projectFingerprint?: string): Promise<readonly SessionMetadata[]>;
+    updateStatus(sessionId: string, status: SessionMetadata['status']): Promise<SessionMetadata>;
+    rename(sessionId: string, name: string): Promise<SessionMetadata>;
+    appendEvent(event: SessionEvent, options?: AppendEventOptions): Promise<void>;
+    appendTranscript(sessionId: string, entry: TranscriptEntry): Promise<void>;
+    appendJournal(sessionId: string, records: readonly SessionJournalAppend[]): Promise<void>;
+    readEvents(sessionId: string): Promise<readonly SessionEvent[]>;
+    readTranscript(sessionId: string): Promise<readonly TranscriptEntry[]>;
+    readHistory(sessionId: string): Promise<SessionHistory>;
+    delete(sessionId: string): Promise<boolean>;
+    fork(sessionId: string, overrides?: Partial<Pick<SessionMetadata, 'model' | 'profile'>>): Promise<SessionMetadata>;
+    compact(sessionId: string, summary: string, options?: CompactSessionOptions): Promise<void>;
+    export(sessionId: string): Promise<SessionBundle>;
+    import(bundle: SessionBundle, projectFingerprint: string, cwd: string): Promise<SessionMetadata>;
+    saveAttachment(sessionId: string, attachment: Attachment, bytes: Uint8Array): Promise<Attachment>;
+    deleteAttachment(sessionId: string, attachmentId: string): Promise<boolean>;
+    readAttachment(sessionId: string, attachmentId: string): Promise<Uint8Array | undefined>;
+    recoverStaleLock(sessionId: string): Promise<boolean>;
+    repair(sessionId: string): Promise<SessionRepairResult>;
+    withLock<T>(sessionId: string, action: () => Promise<T>): Promise<T>;
+}

package/dist/ports/subagent-lifecycle.d.ts

@@ -0,0 +1,31 @@
+import type { SubagentHandoff, SubagentMode, SubagentStatus } from '../domain/orchestration/subagent.js';
+export type SubagentLifecycleEventType = 'created' | 'started' | 'activity' | 'completed' | 'completed_with_warning' | 'failed' | 'cancelled';
+export type SubagentActionKind = 'filesystem' | 'shell' | 'mcp' | 'approval';
+/** A redacted, presentation-safe description of the child's current operation. */
+export interface SubagentLastAction {
+    readonly kind: SubagentActionKind;
+    readonly label: string;
+}
+/**
+ * CLI-owned lifecycle signal for presenting delegated work without coupling
+ * orchestration to a specific user interface.
+ */
+export interface SubagentLifecycleEvent {
+    readonly type: SubagentLifecycleEventType;
+    readonly sessionId: string;
+    readonly id: string;
+    readonly displayName: string;
+    readonly task: string;
+    readonly mode: SubagentMode;
+    readonly model: string;
+    readonly status: SubagentStatus;
+    readonly background: boolean;
+    readonly timestamp: number;
+    readonly durationMs?: number;
+    readonly summary?: string;
+    readonly lastAction?: SubagentLastAction;
+    readonly handoff?: SubagentHandoff;
+}
+export interface SubagentLifecycleObserver {
+    onSubagentLifecycle(event: SubagentLifecycleEvent): void | Promise<void>;
+}

package/dist/ports/tool-activity.d.ts

@@ -0,0 +1,13 @@
+export interface ToolActivityStart {
+    key: string;
+    toolName: string;
+    source?: string;
+    label: string;
+}
+export interface ToolActivityHandle {
+    complete(isError: boolean, metadata?: Readonly<Record<string, unknown>>): void;
+}
+/** Observes tool execution without making UI concerns part of tool executors. */
+export interface ToolActivityObserver {
+    start(activity: ToolActivityStart): ToolActivityHandle | undefined;
+}

package/dist/presentation/themes/theme.d.ts

@@ -0,0 +1,19 @@
+export interface CliTheme {
+    background: string;
+    surface: string;
+    surfaceRaised: string;
+    text: string;
+    muted: string;
+    accent: string;
+    border: string;
+    selection: string;
+    warning: string;
+    user: string;
+    error: string;
+    success: string;
+    diffAdded: string;
+    diffRemoved: string;
+    code: string;
+    link: string;
+}
+export declare const DARK_THEME: CliTheme;

package/dist/presentation/themes/theme.js

@@ -0,0 +1 @@
+const e={background:"#10151c",surface:"#171e27",surfaceRaised:"#202a36",text:"#e6edf3",accent:"#5ba7d8",border:"#3b424b",selection:"#2a3a4d",warning:"#d6b574",user:"#1b2b3d",error:"#e06c75",success:"#86c991",diffAdded:"#173323",diffRemoved:"#3a2028",code:"#d6b574",link:"#75b7e7",muted:"#8b949e"};export{e as DARK_THEME};

package/dist/presentation/tui/agent-initialization-renderer.d.ts

@@ -0,0 +1,4 @@
+import type { AgentEvent } from '@lotagate/agent-sdk';
+import type { InkTuiBridge } from './ink/tui-bridge.js';
+/** Reports only actionable MCP initialization failures; routine connects stay out of the transcript. */
+export declare function renderAgentInitialization(renderer: InkTuiBridge, events: readonly AgentEvent[]): void;

package/dist/presentation/tui/agent-initialization-renderer.js

@@ -0,0 +1 @@
+function c(t,s){const r=new Map;for(const e of s)if(e.type==="mcp.server.status"){const o=i(r,e.summary.serverId);o.status=e.summary.status,e.summary.protocolVersion!==void 0&&(o.protocolVersion=e.summary.protocolVersion)}else e.type==="mcp.tool.discovered"?i(r,e.tool.serverId).discovered+=1:e.type==="mcp.tool.catalog.updated"&&e.error!==void 0&&(i(r,e.serverId).discoveryError=e.error.message);for(const[e,o]of r){if(o.discoveryError===void 0&&(o.status===void 0||o.status==="connected"))continue;const n=[o.status==="connected"?void 0:o.status,...o.protocolVersion===void 0?[]:[`protocol ${o.protocolVersion}`],...o.discovered===0?[]:[`${o.discovered} tool${o.discovered===1?"":"s"} discovered`],...o.discoveryError===void 0?[]:[`tool discovery failed \xB7 ${o.discoveryError}`]].filter(d=>d!==void 0);t.initializationNotice(`mcp:${e}`,`MCP ${e}: ${n.join(" \xB7 ")||"initialized"}`)}}function i(t,s){const r=t.get(s);if(r!==void 0)return r;const e={discovered:0};return t.set(s,e),e}export{c as renderAgentInitialization};

package/dist/presentation/tui/context-display.d.ts

@@ -0,0 +1,21 @@
+export interface TuiContextSnapshot {
+    model: string | null;
+    contextWindow?: number;
+    usedTokens: number;
+    systemPromptTokens: number;
+    conversationTokens: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    otherTokens?: number;
+    transcriptEntries: number;
+    userMessages: number;
+    assistantMessages: number;
+    toolCalls: number;
+    compactions: number;
+    pendingAttachments: number;
+    toolNames: readonly string[];
+    mcpServers: number;
+    memoryFiles: number;
+}
+/** Renders durable and estimated context information as a human-readable TUI report. */
+export declare function formatContextSnapshot(snapshot: TuiContextSnapshot): string;

package/dist/presentation/tui/context-display.js

@@ -0,0 +1,2 @@
+import{formatCompactNumber as t}from"./formatters.js";function d(e){const o=e.contextWindow===void 0?"?":t(e.contextWindow),n=e.contextWindow===void 0?void 0:Math.max(0,e.contextWindow-e.usedTokens),i=e.contextWindow===void 0||e.contextWindow<=0?"?":`${Math.round(e.usedTokens/e.contextWindow*100)}%`;return["Context Usage",`Model          ${e.model??"not selected"}`,`Context        ${t(e.usedTokens)}/${o} tokens (${i})`,`System         ${t(e.systemPromptTokens)} tokens`,`Conversation   ${t(e.conversationTokens)} tokens`,...e.inputTokens===void 0?[]:[`  Input        ${t(e.inputTokens)} tokens`],...e.outputTokens===void 0?[]:[`  Output       ${t(e.outputTokens)} tokens`],...e.otherTokens===void 0?[]:[`  Other        ${t(e.otherTokens)} tokens`],`Free space     ${n===void 0?"?":t(n)} tokens`,"",`Local tools    ${e.toolNames.length}`,`MCP servers    ${e.mcpServers}`,"MCP tools      discovered when an agent run initializes the servers",`Memory files   ${e.memoryFiles}`,`Messages       ${e.transcriptEntries} (${e.userMessages} user \xB7 ${e.assistantMessages} assistant)`,`Tool calls     ${e.toolCalls}`,`Compactions    ${e.compactions}`,`Attachments    ${e.pendingAttachments}`,"","Token counts are estimated from persisted conversation context and the current system guidance; provider usage may differ."].join(`
+`)}export{d as formatContextSnapshot};

package/dist/presentation/tui/formatters.d.ts

@@ -0,0 +1,6 @@
+export { formatCompactNumber } from '../../application/formatting/compact-number.js';
+/** Estimates terminal column width without relying on a transitive dependency. */
+export declare function terminalTextWidth(value: string): number;
+export declare function wrapTerminalText(value: string, width: number): string[];
+export declare function truncateTerminalText(value: string, width: number, suffix?: string): string;
+export declare function formatContextUsage(usedTokens: number, contextWindow?: number): string;

package/dist/presentation/tui/formatters.js

@@ -0,0 +1 @@
+import{formatCompactNumber as n}from"../../application/formatting/compact-number.js";import{formatCompactNumber as g}from"../../application/formatting/compact-number.js";function m(r){let t=0;for(const x of r){const f=x.codePointAt(0)??0;h(f)||(t+=p(f)?2:1)}return t}function u(r,t){if(r.length===0)return[""];const x=[];let f="";for(const a of Array.from(r)){const e=`${f}${a}`;f.length>0&&m(e)>Math.max(1,t)?(x.push(f),f=a):f=e}return f.length>0&&x.push(f),x}function i(r,t,x="\u2026"){const f=Math.max(0,Math.floor(t));if(m(r)<=f)return r;if(f===0)return"";const a=m(x);return a>=f?Array.from(x).slice(0,f).join(""):`${u(r,f-a)[0]??""}${x}`}function l(r,t){return t===void 0?`${n(r)}/?`:`${n(r)}/${n(t)}`}function h(r){return r>=768&&r<=879||r===8205||r>=65024&&r<=65039}function p(r){return r>=4352&&(r<=4447||r===9001||r===9002||r>=11904&&r<=42191||r>=44032&&r<=55203||r>=63744&&r<=64255||r>=65040&&r<=65049||r>=65072&&r<=65135||r>=65280&&r<=65376||r>=65504&&r<=65510||r>=127744&&r<=129791)}export{g as formatCompactNumber,l as formatContextUsage,m as terminalTextWidth,i as truncateTerminalText,u as wrapTerminalText};

package/dist/presentation/tui/ink/choice-window.d.ts

@@ -0,0 +1,5 @@
+export interface ChoiceWindow<T> {
+    readonly start: number;
+    readonly entries: readonly T[];
+}
+export declare function choiceWindow<T>(choices: readonly T[], selected: number, maximumVisible: number): ChoiceWindow<T>;

package/dist/presentation/tui/ink/choice-window.js

@@ -0,0 +1 @@
+function h(n,e,o){const t=Math.max(1,o),a=Math.max(0,Math.min(e-Math.floor(t/2),Math.max(0,n.length-t)));return{start:a,entries:n.slice(a,a+t)}}export{h as choiceWindow};

package/dist/presentation/tui/ink/components/activity-animation.d.ts

@@ -0,0 +1,3 @@
+export declare const ACTIVITY_ANIMATION_INTERVAL_MS = 120;
+export declare const ACTIVITY_SPINNER_FRAMES: readonly ["◐", "◓", "◑", "◒"];
+export declare function activitySpinnerFrame(frame: number): string;

package/dist/presentation/tui/ink/components/activity-animation.js

@@ -0,0 +1 @@
+const I=120,t=["\u25D0","\u25D3","\u25D1","\u25D2"];function e(n){return t[n%t.length]??t[0]}export{I as ACTIVITY_ANIMATION_INTERVAL_MS,t as ACTIVITY_SPINNER_FRAMES,e as activitySpinnerFrame};

package/dist/presentation/tui/ink/components/activity-entry.d.ts

@@ -0,0 +1,6 @@
+import type { JSX } from 'react';
+import type { TuiMessage } from '../tui-bridge.js';
+export declare function ActivityEntry({ activity, showDetails }: {
+    activity: NonNullable<TuiMessage['activity']>;
+    showDetails?: boolean;
+}): JSX.Element;

package/dist/presentation/tui/ink/components/activity-entry.js

@@ -0,0 +1 @@
+import{jsxs as m,jsx as d}from"react/jsx-runtime";import{Box as $,Text as l,useAnimation as A,useStdout as g}from"ink";import{DARK_THEME as n}from"../../../themes/theme.js";import{terminalTextWidth as i,truncateTerminalText as h}from"../../formatters.js";import{ShimmerText as M}from"./shimmer-text.js";import{ACTIVITY_ANIMATION_INTERVAL_MS as _,activitySpinnerFrame as b}from"./activity-animation.js";function L({activity:e,showDetails:u=!1}){const{stdout:f}=g(),o=e.state==="pending",t=e.state==="running",a=A({interval:_,isActive:t}),p=t?Math.max(e.elapsedMs??0,Date.now()-e.startedAt):e.elapsedMs??0,r=o?"\u25CC":t?b(a.frame):e.state==="failed"?"!":"\u2713",c=`${o?"Run":t?"Running":e.state==="failed"?"Command failed":"Ran"} ${e.label.replace(/\s+/gu," ").trim()}`,s=` \xB7 ${I(p)}${u&&e.toolName!==void 0?` \xB7 ${e.toolName}${e.kind===void 0?"":` \xB7 ${e.kind}`}`:""}`,x=Math.max(1,(f.columns??80)-2-i(`${r} `)-i(s)),T=h(c,x,"....");return m($,{marginBottom:1,children:[m(l,{color:e.state==="failed"?n.error:t||o?n.warning:n.muted,children:[r," "]}),d(M,{value:T,active:t,frame:a.frame,color:t?n.warning:n.text}),d(l,{color:n.muted,children:s})]})}function I(e){return e<1e3?`${e}ms`:`${(e/1e3).toFixed(1)}s`}export{L as ActivityEntry};

package/dist/presentation/tui/ink/components/activity-status.d.ts

@@ -0,0 +1,10 @@
+import type { JSX } from 'react';
+import type { ChatUsage } from '../../../../ports/chat-model.js';
+export interface ActivityStatusProps {
+    status: string;
+    activityStartedAt?: number;
+    elapsedMs?: number;
+    usage?: ChatUsage;
+    paused?: boolean;
+}
+export declare function ActivityStatus({ status, activityStartedAt, elapsedMs, usage, paused }: ActivityStatusProps): JSX.Element;

package/dist/presentation/tui/ink/components/activity-status.js

@@ -0,0 +1 @@
+import{jsxs as i,jsx as x}from"react/jsx-runtime";import{Box as T,Text as l,useAnimation as h}from"ink";import{DARK_THEME as t}from"../../../themes/theme.js";import{ShimmerText as A}from"./shimmer-text.js";import{ACTIVITY_ANIMATION_INTERVAL_MS as v,activitySpinnerFrame as _}from"./activity-animation.js";function $({status:o,activityStartedAt:c,elapsedMs:a,usage:n,paused:m=!1}){const e=o!=="Done"&&o!=="Cancelled"&&o!=="Failed",s=h({interval:v,isActive:e&&!m}),p=e&&c!==void 0?Math.max(a??0,Date.now()-c):a??0,r=[j(p)],f=n?.completionTokens??n?.totalTokens;f!==void 0&&r.push(`${n?.estimated===!0?"~":""}${f} output tokens`),e&&r.push("Esc cancel");const u=e?_(s.frame):"\u25CF",d=o==="Failed"?t.error:e?t.warning:t.success;return i(T,{marginBottom:1,children:[i(l,{color:d,children:[u," "]}),x(A,{value:o,active:e&&!m,frame:s.frame}),i(l,{color:t.muted,children:["  ",r.join(" \xB7 ")]})]})}function j(o){return o<1e3?`${o}ms`:`${(o/1e3).toFixed(1)}s`}export{$ as ActivityStatus};

package/dist/presentation/tui/ink/components/choice-modal.d.ts

@@ -0,0 +1,11 @@
+import type { JSX } from 'react';
+import type { InkTuiBridge, TuiChoice } from '../tui-bridge.js';
+export interface ChoiceModalProps {
+    bridge: InkTuiBridge;
+    title: string;
+    choices: readonly TuiChoice[];
+    currentValue?: string;
+    detail?: string;
+    borderColor?: string;
+}
+export declare function ChoiceModal({ bridge, title, choices, currentValue, detail, borderColor }: ChoiceModalProps): JSX.Element;

package/dist/presentation/tui/ink/components/choice-modal.js

@@ -0,0 +1 @@
+import{jsx as a,jsxs as s}from"react/jsx-runtime";import{useState as M}from"react";import{Box as v,Text as r,useInput as A}from"ink";import{DARK_THEME as t}from"../../../themes/theme.js";import{choiceWindow as C}from"../choice-window.js";function b({bridge:i,title:x,choices:l,currentValue:p,detail:u,borderColor:w=t.accent}){const h=l.findIndex(e=>e.value===p),[c,m]=M(Math.max(0,h)),f=C(l,c,8);return A((e,n)=>{n.upArrow?m(o=>Math.max(0,o-1)):n.downArrow?m(o=>Math.min(Math.max(0,l.length-1),o+1)):n.return?i.resolveActiveModal(l[c]?.value):e.toLowerCase()==="y"&&l.some(o=>o.value==="allow")?i.resolveActiveModal("allow"):e.toLowerCase()==="n"&&l.some(o=>o.value==="deny")?i.resolveActiveModal("deny"):(n.escape||e==="q")&&i.resolveActiveModal(void 0)}),s(v,{borderStyle:"double",borderColor:w,flexDirection:"column",marginTop:1,paddingX:1,children:[a(r,{bold:!0,color:t.text,children:"Action required"}),a(r,{color:t.text,children:x}),u!==void 0&&a(r,{color:t.muted,children:u}),f.entries.map((e,n)=>{const o=f.start+n===c,d=o?{backgroundColor:t.selection}:{};return s(v,{width:"100%",alignSelf:"stretch",flexDirection:"row",...d,children:[a(r,{color:o?t.accent:t.muted,...d,children:"\u203A "}),a(r,{color:t.text,...d,children:e.label}),e.description!==void 0&&s(r,{color:t.muted,...d,children:["  ",e.description]})]},e.value)}),a(r,{color:t.muted,children:"\u2191\u2193 navigate \xB7 Enter select \xB7 Esc cancel"})]})}export{b as ChoiceModal};

package/dist/presentation/tui/ink/components/composer.d.ts

@@ -0,0 +1,40 @@
+import type { JSX } from 'react';
+import type { Attachment } from '../../../../domain/session/attachment.js';
+import type { InkTuiBridge, TuiChoice } from '../tui-bridge.js';
+export interface ComposerCursorPosition {
+    x: number;
+    y: number;
+}
+interface ComposerInputLayout {
+    x: number;
+    y: number;
+    width: number;
+}
+export declare function calculateComposerCursorPosition({ layout, value, cursor, terminalRows }: {
+    layout: ComposerInputLayout;
+    value: string;
+    cursor: number;
+    terminalRows?: number;
+}): ComposerCursorPosition | undefined;
+export declare function Composer({ bridge, enabled, activeRun, visible, clearBlockedUntil, footerNotice, contextUsage, attachments, fileChoices, onLayoutRowsChange }: {
+    bridge: InkTuiBridge;
+    enabled: boolean;
+    activeRun: boolean;
+    visible?: boolean;
+    clearBlockedUntil?: number;
+    footerNotice?: string;
+    contextUsage?: {
+        usedTokens: number;
+        contextWindow?: number;
+    };
+    attachments: readonly Attachment[];
+    fileChoices: readonly TuiChoice[];
+    onLayoutRowsChange?: (rows: number) => void;
+}): JSX.Element | null;
+export interface AtFileReference {
+    start: number;
+    query: string;
+}
+/** Returns the active unquoted @workspace-file token immediately before the cursor. */
+export declare function atFileReference(value: string, cursor: number): AtFileReference | undefined;
+export {};