amness 0.0.0-stage → 0.1.2

package/dist/cli/tui/app.d.ts

@@ -0,0 +1,328 @@
+import { type Plugin } from "../../src/index.ts";
+import { Budget, MemoryStore, Snapshots, Tracer, type Profile, type Roles, createCodeAgent, Hooks, Permissions, startLive, type Approve, type Event, type Message, type Model, type PermMode, type Tool } from "../../src/index.ts";
+import { type Config } from "../config.ts";
+import { BlockStore } from "./blocks.ts";
+import { type Cmd } from "./commands.ts";
+import { FullView } from "./full.ts";
+import { FileIndex, type Suggestion, type Token } from "./complete.ts";
+import { Editor } from "./editor.ts";
+import { KeyParser, type Key } from "./keys.ts";
+import { type Overlay, type PickItem } from "./overlays.ts";
+import { Pager } from "./pager.ts";
+import { Screen, type Out } from "./screen.ts";
+import { SessionStore, type SessionData } from "./session.ts";
+type Ev = Event & {
+    agent?: string;
+};
+type EditEv = Extract<Event, {
+    kind: "edit";
+}>;
+export type AppOptions = {
+    cfg: Config;
+    cwd: string;
+    version: string;
+    input?: any;
+    output?: Out & {
+        on?: (e: string, f: () => void) => void;
+    };
+    makeModel?: (cfg: Config) => Model;
+    resume?: "last" | string;
+    prompt?: string;
+    persist?: boolean; /** idle ms before a cache keep-alive ping (default 270000) */
+    keepWarmMs?: number;
+    /** "full" = the full-screen UI (alternate screen, mouse, sidebar); "inline" = the classic scrollback UI. */
+    ui?: "full" | "inline";
+};
+export type TraceStep = {
+    n: number;
+    t0: number;
+    ms: number;
+    prompt: number;
+    completion: number;
+    cached?: number;
+    parallel?: number;
+    tools: {
+        name: string;
+        args: string;
+        ms: number;
+        ok: boolean;
+    }[];
+    notes: string[];
+};
+export declare class App {
+    cfg: Config;
+    cwd: string;
+    version: string;
+    persist: boolean;
+    io: {
+        input: any;
+        output: Out & {
+            on?: (e: string, f: () => void) => void;
+        };
+    };
+    screen: Screen;
+    keys: KeyParser;
+    editor: Editor;
+    files: FileIndex;
+    mode: PermMode;
+    shRules: Set<string>;
+    toolRules: Set<string>;
+    model: Model;
+    agent: ReturnType<typeof createCodeAgent>;
+    budget: Budget;
+    store: SessionStore;
+    session: SessionData;
+    edits: EditEv[];
+    verify: string | undefined;
+    check: string | undefined;
+    trimmed: number;
+    cacheBreaks: number;
+    runSeries: number[];
+    thinkBuf: string;
+    phase: {
+        phase: string;
+        step: number;
+        max: number;
+        n?: number;
+    } | undefined;
+    activity: {
+        name: string;
+        args: string;
+        ms: number;
+        ok: boolean;
+    }[];
+    /** One entry per loop iteration of the conversation so far, for /loop. */
+    trace: TraceStep[];
+    running: boolean;
+    ac: AbortController | undefined;
+    runStart: number;
+    runTokens: number;
+    lastPrompt: number;
+    inflight: Map<string, {
+        name: string;
+        args: string;
+        t0: number;
+        agent?: string;
+        parent?: string;
+    }>;
+    pendingEdits: Map<string, {
+        kind: "edit";
+        path: string;
+        created: boolean;
+        added: number;
+        removed: number;
+        diff: string;
+        before?: string | null;
+    }>;
+    streamBuf: string;
+    msgOpen: boolean;
+    streamedThisMsg: boolean;
+    todos: {
+        content: string;
+        status: string;
+    }[];
+    queued: {
+        text: string;
+        full: string;
+    }[];
+    overlay: Overlay | null;
+    pager: Pager | null;
+    sugg: {
+        items: Suggestion[];
+        sel: number;
+        token: Token;
+        kind: Token["kind"];
+    } | null;
+    suggOff: string;
+    private builtin;
+    private customAt;
+    private customCmds;
+    mcp: {
+        cmd: string;
+        tools: Tool[];
+        close: () => void;
+    }[];
+    notice: string;
+    noticeUntil: number;
+    pendingContext: string[];
+    modeNotice: string;
+    branch: string | undefined;
+    live: Awaited<ReturnType<typeof startLive>> | undefined;
+    private out;
+    private timer;
+    private flushT;
+    private renderT;
+    private escAt;
+    private ctrlcAt;
+    frame: number;
+    private stopped;
+    /** The structured transcript the full-screen UI draws (kept in both modes so switching never loses history). */
+    blocks: BlockStore;
+    ui: "full" | "inline";
+    full?: FullView;
+    private opts;
+    done: Promise<number>;
+    private resolveDone;
+    constructor(o: AppOptions);
+    private warnedShadow;
+    /** Built-in commands plus the user's own (.amness/commands/*.md). Built-ins win name clashes. */
+    get cmds(): Cmd[];
+    buildAgent(): void;
+    get width(): number;
+    get ctxPct(): number | null;
+    get cost(): string;
+    start(): Promise<number>;
+    private recount;
+    private replay;
+    restore: () => void;
+    exit(code?: number): void;
+    /** Raw pre-styled lines: scrollback in the inline UI, a "raw" block in the full-screen UI. */
+    commit(lines: string[]): void;
+    /** Scrollback-only output for things the full-screen UI draws from structured blocks instead. */
+    private inlineOnly;
+    private notify;
+    private addUser;
+    say(text: string | string[], paint?: (s: string) => string): void;
+    note(text: string, ms?: number): void;
+    render: () => void;
+    schedule(): void;
+    private styleInput;
+    private hint;
+    setTitle(t: string): void;
+    private suggLines;
+    private tick;
+    private ensureTimer;
+    private idleTimer;
+    onData: (d: Buffer | string) => void;
+    handleKey(k: Key): void;
+    private after;
+    private updateSugg;
+    acceptSuggPublic(fromEnter: boolean): void;
+    private acceptSugg;
+    private escape;
+    private ctrlC;
+    cycleMode(): void;
+    setMode(m: PermMode): void;
+    submit(): Promise<void>;
+    dispatch(text: string): Promise<void>;
+    runCommand(text: string): Promise<void>;
+    private drainQueue;
+    bash(cmd: string): Promise<undefined>;
+    remember(note: string): void;
+    turn(text: string): Promise<void>;
+    private stepNow;
+    /** The session's trace (local JSONL file, plus an OpenTelemetry collector when AMNESS_OTLP is set). */
+    tracer?: Tracer;
+    private tracerFor;
+    private trace_;
+    onEvent(e: Ev): void;
+    /** Stream assistant text: complete paragraphs are committed to scrollback immediately; the unfinished tail stays in the live region. */
+    flushStream(final: boolean): void;
+    approve: Approve;
+    private shAllowed;
+    pick<T>(title: string, items: PickItem<T>[], initial?: number, onMove?: (v: T | undefined) => void): Promise<T | undefined>;
+    askText(prompt: string, o?: {
+        secret?: boolean;
+        initial?: string;
+    }): Promise<string | undefined>;
+    showText(lines: string[], title?: string): Promise<void>;
+    openPager(lines: string[], title?: string, start?: "top" | "bottom"): void;
+    openTranscript(): void;
+    /** Ctrl+P: every command in a filterable list. Commands that need an argument are typed into the input instead of run. */
+    openPalette(): Promise<void>;
+    openRewind(): Promise<void>;
+    rewindTo(idx: number): Promise<void>;
+    /** Fork the conversation after turn `idx`. The current conversation is saved as it is; the working tree is put back to how it was at that point. */
+    branchAfter(idx: number): Promise<void>;
+    /** Switch UI mode live. History is kept in the block store, so nothing is lost either way. */
+    switchUi(to: "full" | "inline"): void;
+    private rebuildBlocksIfEmpty;
+    rebuildBlocks(): void;
+    resumeById(id: string): Promise<void>;
+    newConversation(): void;
+    loadSession(s: SessionData): void;
+    saveSession(): void;
+    saveHistory(): void;
+    saveConfig(): void;
+    /** Put text on the clipboard (OSC 52 plus the platform tool). */
+    copyText(text: string): void;
+    private warmTimer?;
+    private warmCount;
+    private lastCached;
+    stopWarm(): void;
+    private scheduleWarm;
+    /** Project hooks run commands on this machine, so a cloned repo's hooks only run after the user approves this exact file. */
+    policyLog: string[];
+    hooks: Hooks;
+    rules: Permissions;
+    roles: Roles;
+    lastRoute: string;
+    loadHooks(): {
+        fp: string | undefined;
+        trusted: boolean;
+    };
+    plugins: Plugin[];
+    private statusAt;
+    private statusLines;
+    /** one line per plugin that has a `status` function, cached for a second; a failing plugin shows nothing */
+    pluginStatus(): string[];
+    /** loaded plugins plus the loop strategy chosen with /strategy and the prompt chosen with /prompt */
+    activePlugins(): Plugin[];
+    /** Load plugins: yours always, the project's only once you approved exactly these files. */
+    loadPluginsNow(): Promise<{
+        r: import("../../src/plugins.ts").Loaded;
+        fp: string | undefined;
+    }>;
+    askPluginTrust(): Promise<void>;
+    private askHookTrust;
+    /** Shell snapshots: before the first command of a turn that may change files, remember the working tree so /undo can put it back. */
+    snaps: Snapshots;
+    beforeShell(cmd: string): Promise<void>;
+    /** The harness profile for the current model (guards switched off, limits retuned): .amness/profile.json and ~/.amness/profile.json. */
+    profile: {
+        profile: Profile;
+        sources: string[];
+    };
+    private profileOptions;
+    setCheck(cmd: string | undefined): void;
+    setVerify(cmd: string | undefined): void;
+    ensureLive(): Promise<{
+        url: string;
+        onEvent(e: Event & {
+            agent?: string;
+        }): void;
+        close: () => Promise<void>;
+    }>;
+    providerInfo(): {
+        readonly label: "Anthropic (Claude)";
+        readonly baseUrl: "https://api.anthropic.com";
+        readonly model: "claude-opus-5-5";
+        readonly needsKey: true;
+    } | {
+        readonly label: "OpenAI";
+        readonly baseUrl: "https://api.openai.com/v1";
+        readonly model: "gpt-6.1-sol";
+        readonly needsKey: true;
+    } | {
+        readonly label: "OpenRouter";
+        readonly baseUrl: "https://openrouter.ai/api/v1";
+        readonly model: "openai/gpt-4.1";
+        readonly needsKey: true;
+    } | {
+        readonly label: "Ollama (local)";
+        readonly baseUrl: "http://localhost:11434/v1";
+        readonly model: "qwen2.5-coder:7b";
+        readonly needsKey: false;
+    } | {
+        readonly label: "Custom OpenAI-compatible";
+        readonly baseUrl: "http://localhost:8000/v1";
+        readonly model: "my-model";
+        readonly needsKey: false;
+    };
+    refreshBranch(): void;
+    get memory(): MemoryStore | undefined;
+    get messagesForExport(): Message[];
+    get hasFile(): (p: string) => boolean;
+}
+export declare function shPrefix(cmd: string): string;
+export {};