@cjhyy/code-shell 0.3.0 → 0.5.0-rc.2

package/dist/prompt/composer.d.ts

@@ -1,42 +0,0 @@
-/**
- * Prompt composer — assembles system prompt from sections.
- *
- * Following Claude Code's dual-chain architecture:
- *   system chain → API request "system" field
- *   messages chain → API request "messages" field (userContext prepended)
- */
-import type { ToolDefinition, Message } from "../types.js";
-import { type ScanOptions } from "./instruction-scanner.js";
-import { type AgentPreset } from "../preset/index.js";
-export interface ComposerOptions {
-    cwd: string;
-    model: string;
-    instructionOptions?: ScanOptions;
-    /** Resolved preset — used to load section-based prompt. */
-    preset?: AgentPreset;
-    customSystemPrompt?: string;
-    appendSystemPrompt?: string;
-}
-export declare class PromptComposer {
-    private readonly options;
-    private sectionCache;
-    private cachedInstructions;
-    constructor(options: ComposerOptions);
-    /**
-     * Build the system prompt from sections.
-     */
-    buildSystemPrompt(tools: ToolDefinition[]): Promise<string>;
-    /**
-     * Build the userContext prefix message (CLAUDE.md content as <system-reminder>).
-     */
-    buildUserContextMessage(): Message | null;
-    /**
-     * Build the systemContext (gitStatus etc.) to append to system prompt.
-     * Only injects git status if the resolved preset opts in.
-     */
-    buildSystemContext(): Promise<string>;
-    invalidateCache(sectionName?: string): void;
-    private getSections;
-    private getInstructions;
-    private getMemoryContext;
-}

package/dist/prompt/instruction-scanner.d.ts

@@ -1,54 +0,0 @@
-/**
- * Instruction scanner — discovers instruction files up the directory tree.
- *
- * Supports layered instruction files with priority ordering:
- *   1. managed  — shipped defaults (~/.code-shell/CODESHELL.md)
- *   2. user     — user-level (~/.code-shell/CODESHELL.md, ~/.code-shell/rules/)
- *   3. project  — project-level (from git root to cwd, walking down)
- *   4. local    — local overrides (CODESHELL.local.md, not version-controlled)
- *
- * Entries carry a `depth` field: 0 = git root / top-most, increasing toward cwd.
- * The scanner stops at the git repository root (not filesystem root).
- *
- * File name search order per directory:
- *   CODESHELL.md → .codeshell/CODESHELL.md → .codeshell/rules/*.md
- *   CLAUDE.md    → .claude/CLAUDE.md       → .claude/rules/*.md      (compat)
- */
-export interface InstructionEntry {
-    /** Absolute path to the file */
-    path: string;
-    /** Raw file content */
-    content: string;
-    /** Where the file came from */
-    source: "managed" | "user" | "project" | "local";
-    /**
-     * Depth relative to the project root.
-     * 0 = git root (or scan ceiling), increases toward cwd.
-     * user/managed entries have depth -1.
-     */
-    depth: number;
-}
-export interface ScanOptions {
-    /** Primary instruction file name (default: "CODESHELL.md") */
-    fileName?: string;
-    /** Extra directory names to probe alongside .codeshell/ */
-    scanDirs?: string[];
-    /** Compatibility file names to also look for (default: ["CLAUDE.md"]) */
-    compatFileNames?: string[];
-    /** If true, do NOT stop at git root — scan all the way to / */
-    ignoreGitBoundary?: boolean;
-}
-/**
- * Scan for instruction files from cwd up to the project root,
- * plus user-level and managed-level instructions.
- *
- * Returns entries ordered by priority: managed → user → project (root→cwd) → local.
- */
-export declare function scanInstructions(cwd: string, options?: ScanOptions): InstructionEntry[];
-/**
- * Combine all instruction entries into a single string.
- *
- * Entries are grouped by source with headers, making it clear
- * where each instruction block originates.
- */
-export declare function combineInstructions(entries: InstructionEntry[]): string;

package/dist/prompt/section-cache.d.ts

@@ -1,15 +0,0 @@
-/**
- * Per-section prompt caching.
- * Mirrors Claude Code's systemPromptSectionCache — each section cached independently.
- */
-export interface PromptSection {
-    name: string;
-    compute: () => string | Promise<string>;
-    cacheBreak?: boolean;
-}
-export declare class SectionCache {
-    private cache;
-    resolve(sections: PromptSection[]): Promise<string[]>;
-    invalidate(name?: string): void;
-    has(name: string): boolean;
-}

package/dist/prompt/section-loader.d.ts

@@ -1,26 +0,0 @@
-/**
- * Load prompt section markdown files.
- *
- * Sections are inlined as text strings at build time via tsup's .md loader,
- * so they work in both dev (tsx) and built output (dist/) without needing
- * to copy files. Custom sections registered at runtime are also supported.
- */
-/**
- * Register a custom prompt section at runtime.
- * This allows external presets to add their own sections.
- */
-export declare function registerSection(name: string, content: string): void;
-/**
- * Read a named prompt section. Returns the trimmed markdown content.
- * Looks up built-in sections first, then custom-registered sections.
- * Throws if the section name is not found.
- */
-export declare function loadSection(name: string): string;
-/**
- * Load multiple sections and join them with double newlines.
- */
-export declare function loadSections(names: readonly string[]): string;
-/**
- * List all available section names (built-in + custom).
- */
-export declare function availableSections(): string[];

package/dist/protocol/client.d.ts

@@ -1,64 +0,0 @@
-/**
- * AgentClient — the UI-side interface to the agent server.
- *
- * Replaces direct Engine usage in the UI. Communicates with AgentServer
- * over a Transport (in-process or cross-process).
- *
- * Usage:
- *   const client = new AgentClient({ transport });
- *   client.onStreamEvent((event) => { ... });
- *   client.onApprovalRequest((reqId, request) => { ... });
- *   const result = await client.run("fix the bug");
- */
-import type { Transport } from "./transport.js";
-import { type RunResult, type ConfigureParams, type QueryParams, type QueryResult } from "./types.js";
-import type { StreamEvent, ApprovalRequest, ApprovalResult } from "../types.js";
-export interface AgentClientEvents {
-    stream: (event: StreamEvent) => void;
-    approvalRequest: (requestId: string, request: ApprovalRequest) => void;
-    status: (status: string, message?: string) => void;
-}
-export declare class AgentClient {
-    private transport;
-    private emitter;
-    private pendingRequests;
-    constructor(options: {
-        transport: Transport;
-    });
-    /**
-     * Run an agent task. Resolves when the agent completes.
-     * Stream events arrive via the onStreamEvent callback.
-     */
-    run(task: string, sessionId?: string): Promise<RunResult>;
-    /**
-     * Respond to an approval request from the server.
-     */
-    approve(requestId: string, decision: ApprovalResult): Promise<void>;
-    /**
-     * Cancel a running agent.
-     */
-    cancel(reason?: string): Promise<void>;
-    /**
-     * Update runtime configuration on the server.
-     */
-    configure(params: ConfigureParams): Promise<Record<string, unknown>>;
-    /**
-     * Query server state.
-     */
-    query(type: QueryParams["type"], arg?: string | Record<string, unknown>, ...extra: unknown[]): Promise<QueryResult>;
-    /**
-     * Inject context into the session transcript without triggering a LLM turn.
-     * Used to make arena results, tool outputs, etc. visible to subsequent LLM calls.
-     */
-    inject(sessionId: string, content: string): Promise<void>;
-    onStreamEvent(handler: (event: StreamEvent) => void): void;
-    offStreamEvent(handler: (event: StreamEvent) => void): void;
-    onApprovalRequest(handler: (requestId: string, request: ApprovalRequest) => void): void;
-    offApprovalRequest(handler: (requestId: string, request: ApprovalRequest) => void): void;
-    onStatus(handler: (status: string, message?: string) => void): void;
-    offStatus(handler: (status: string, message?: string) => void): void;
-    private request;
-    private handleResponse;
-    private handleNotification;
-    close(): void;
-}

package/dist/protocol/helpers.d.ts

@@ -1,42 +0,0 @@
-/**
- * Helpers for spinning up an in-process AgentServer + AgentClient pair.
- *
- * All internal codeshell paths that want to run an engine should go through
- * the protocol layer (AgentServer wraps the engine, AgentClient is the
- * consumer-facing handle). This helper exists so callers don't repeat the
- * 6-line "create transport / new server / new client / wire onStream /
- * try-finally close" boilerplate at every call site.
- *
- * Existing call sites that should use this:
- *   - src/cli/commands/run.ts        (headless CLI)
- *   - src/run/EngineRunner.ts         (RunManager)
- *
- * The REPL builds its own server+client because it needs the long-lived
- * AgentClient instance to drive the React UI's lifecycle (subscribing to
- * stream events, approval requests, status changes). One-shot callers want
- * the simpler "give me a client, hand back close()" shape this helper
- * provides.
- */
-import type { Engine } from "../engine/engine.js";
-import type { StreamCallback } from "../types.js";
-import { AgentClient } from "./client.js";
-export interface InProcessClientHandle {
-    /** The client; pass to `client.run(task, sessionId)` to execute. */
-    readonly client: AgentClient;
-    /**
-     * Tear down server + client + transports. Call from a `finally` block.
-     * Safe to call multiple times; subsequent calls are no-ops.
-     */
-    close(): void;
-}
-export interface CreateInProcessClientOptions {
-    /** Stream callback to receive every event the server emits. */
-    onStream?: StreamCallback;
-}
-/**
- * Wrap an Engine in an in-process AgentServer and return a client handle.
- * The handle's `close()` tears the whole pair down in the correct order:
- * client first (so its pending requests reject cleanly), then server (which
- * aborts any active run and clears approval timers).
- */
-export declare function createInProcessClient(engine: Engine, options?: CreateInProcessClientOptions): InProcessClientHandle;

package/dist/protocol/index.d.ts

@@ -1,4 +0,0 @@
-export { AgentServer, type AgentServerOptions } from "./server.js";
-export { AgentClient } from "./client.js";
-export { createInProcessTransport, StdioTransport, type Transport } from "./transport.js";
-export { Methods, ErrorCodes, type RpcMessage, type RunResult } from "./types.js";

package/dist/protocol/server.d.ts

@@ -1,51 +0,0 @@
-/**
- * AgentServer — wraps Engine and exposes it over the protocol.
- *
- * Responsibilities:
- *   - Handles RPC requests from the client (run, approve, cancel, configure, query)
- *   - Forwards StreamEvents to the client as notifications
- *   - Manages approval flow: engine → server → client → server → engine
- *   - Owns all mutable runtime state (plan mode, bypass, etc.)
- */
-import type { Transport } from "./transport.js";
-import type { Engine } from "../engine/engine.js";
-export interface AgentServerOptions {
-    engine: Engine;
-    transport: Transport;
-}
-export declare class AgentServer {
-    private engine;
-    private transport;
-    private running;
-    private abortController;
-    /** Pending approval requests: requestId → resolve function */
-    private pendingApprovals;
-    /** Timers for approval timeouts */
-    private approvalTimers;
-    /** Default approval timeout: 5 minutes */
-    private static readonly APPROVAL_TIMEOUT_MS;
-    constructor(options: AgentServerOptions);
-    private handleRequest;
-    private handleRun;
-    private handleApprove;
-    private handleCancel;
-    private handleConfigure;
-    private handleQuery;
-    private handleInject;
-    /**
-     * Ask the client to approve a tool operation.
-     * Sends a notification, returns a promise that resolves when client responds.
-     */
-    private requestApprovalFromClient;
-    /**
-     * Ask the client to answer a question from the agent.
-     * Reuses the approval flow with a synthetic request. Optional `opts`
-     * carry multiple-choice options / header / multiSelect hints that the
-     * client UI may use to render a picker instead of a text input.
-     */
-    private requestAskUserFromClient;
-    private notify;
-    close(): void;
-    private clearApprovalTimer;
-    private clearAllApprovalTimers;
-}

package/dist/protocol/transport.d.ts

@@ -1,36 +0,0 @@
-/**
- * Transport layer — abstracts how messages travel between client and server.
- *
- * Two implementations:
- *   - InProcessTransport: direct function calls (same process, zero overhead)
- *   - StdioTransport: newline-delimited JSON over stdin/stdout (cross-process)
- */
-import type { RpcMessage } from "./types.js";
-import type { Readable, Writable } from "node:stream";
-export interface Transport {
-    /** Send a message to the other side. */
-    send(message: RpcMessage): void;
-    /** Register a handler for incoming messages. */
-    onMessage(handler: (message: RpcMessage) => void): void;
-    /** Clean up resources. */
-    close(): void;
-}
-/**
- * Creates a pair of linked transports for same-process use.
- * Messages sent on one side are received on the other instantly.
- */
-export declare function createInProcessTransport(): [Transport, Transport];
-/**
- * Transport over stdio streams (newline-delimited JSON).
- * Used for cross-process communication.
- */
-export declare class StdioTransport implements Transport {
-    private readonly input;
-    private readonly output;
-    private rl;
-    private handlers;
-    constructor(input: Readable, output: Writable);
-    send(message: RpcMessage): void;
-    onMessage(handler: (message: RpcMessage) => void): void;
-    close(): void;
-}

package/dist/protocol/types.d.ts

@@ -1,192 +0,0 @@
-/**
- * Agent protocol — JSON-RPC-style messages for client-server communication.
- *
- * The protocol separates the agent engine (server) from the UI (client).
- * Communication is bidirectional:
- *   Client → Server: requests (run, approve, cancel, configure, query)
- *   Server → Client: notifications (stream events, approval requests)
- *   Server → Client: responses (results of requests)
- */
-import type { StreamEvent, TokenUsage, TerminalReason, ApprovalRequest, ApprovalResult, PermissionMode } from "../types.js";
-export interface RpcRequest {
-    jsonrpc: "2.0";
-    id: string | number;
-    method: string;
-    params?: Record<string, unknown>;
-}
-export interface RpcResponse {
-    jsonrpc: "2.0";
-    id: string | number;
-    result?: unknown;
-    error?: RpcError;
-}
-export interface RpcNotification {
-    jsonrpc: "2.0";
-    method: string;
-    params?: Record<string, unknown>;
-}
-export interface RpcError {
-    code: number;
-    message: string;
-    data?: unknown;
-}
-export type RpcMessage = RpcRequest | RpcResponse | RpcNotification;
-export declare const ErrorCodes: {
-    readonly ParseError: -32700;
-    readonly InvalidRequest: -32600;
-    readonly MethodNotFound: -32601;
-    readonly InvalidParams: -32602;
-    readonly InternalError: -32603;
-    readonly EngineNotReady: -32001;
-    readonly SessionNotFound: -32002;
-    readonly AlreadyRunning: -32003;
-    readonly NotRunning: -32004;
-};
-/** Start an agent run with a user task. */
-export interface RunParams {
-    task: string;
-    sessionId?: string;
-}
-export interface RunResult {
-    text: string;
-    reason: TerminalReason;
-    sessionId: string;
-    turnCount: number;
-    usage: TokenUsage;
-}
-/** Respond to an approval request from the server. */
-export interface ApproveParams {
-    requestId: string;
-    decision: ApprovalResult;
-}
-/** Cancel a running agent. */
-export interface CancelParams {
-    reason?: string;
-}
-/** Inject context into a session transcript. */
-export interface InjectParams {
-    sessionId: string;
-    content: string;
-}
-/** Update runtime configuration. */
-export interface ConfigureParams {
-    permissionMode?: PermissionMode;
-    planMode?: boolean;
-    bypassPermissions?: boolean;
-    effort?: string;
-    /** Switch active model by pool key (e.g. "sonnet", "haiku", "gpt"). */
-    model?: string;
-    /**
-     * Re-read settings (providers[]/models[]) into the engine's ModelPool before
-     * any model switch. Set after onboarding/login persists new entries so the
-     * running engine picks them up without a process restart.
-     */
-    reloadModels?: boolean;
-}
-/** Query server state. */
-export interface QueryParams {
-    type: "sessions" | "tools" | "config" | "session_detail" | "compact" | "config_set" | "config_get" | "permission_set" | "models" | "providers" | "arena_status" | "provider_add" | "provider_refresh" | "provider_delete" | "model_add" | "model_delete";
-    sessionId?: string;
-    /** Used by config_set / permission_set: dotted key path or mode field */
-    key?: string;
-    /** Used by config_set / permission_set: new value */
-    value?: unknown;
-    /** Used by provider_add: full ProviderConfig payload */
-    provider?: unknown;
-    /** Used by model_add: the new model entry */
-    model?: unknown;
-}
-export interface QueryResult {
-    type: string;
-    data: unknown;
-}
-/** List / get session info. */
-export interface SessionListResult {
-    sessions: Array<{
-        sessionId: string;
-        cwd: string;
-        startedAt: number;
-        model: string;
-        status: string;
-        turnCount: number;
-    }>;
-}
-export interface ToolListResult {
-    tools: Array<{
-        name: string;
-        description: string;
-    }>;
-}
-/** Shape of a model-pool entry returned by query("models"). */
-export interface ProtocolModelEntry {
-    key: string;
-    label: string;
-    model: string;
-    /**
-     * Protocol the LLM client speaks ("openai" or "anthropic"). DeepSeek,
-     * Mistral, etc. all use "openai" since they're OpenAI-compatible.
-     * NOT the brand/vendor — that's providerKey below.
-     */
-    protocol: string;
-    /**
-     * Pool entry's reference into settings.providers[]. Used by ModelManager
-     * to derive each provider's modelCount client-side ("how many models
-     * point at me"). Optional because auto-populated entries (autoPopulatePool)
-     * don't go through the wizard and have no providers[] row.
-     */
-    providerKey?: string;
-    active: boolean;
-    /** Max output tokens (0 or undefined = unknown). */
-    maxOutputTokens?: number;
-    /** Max context window size (0 or undefined = unknown). */
-    maxContextTokens?: number;
-}
-export interface ProtocolProviderEntry {
-    key: string;
-    label: string;
-    kind: string;
-    modelCount: number;
-    cachedModels?: number;
-    cachedAt?: string;
-}
-export interface ConfigResult {
-    permissionMode: PermissionMode;
-    planMode: boolean;
-    preset?: string;
-    model: string;
-    cwd: string;
-    maxContextTokens?: number;
-}
-/** Stream event forwarded from the engine. */
-export interface StreamEventNotification {
-    event: StreamEvent;
-}
-/** Server requests approval from the client (UI). */
-export interface ApprovalRequestNotification {
-    requestId: string;
-    request: ApprovalRequest;
-}
-/** Server status changed. */
-export interface StatusNotification {
-    status: "ready" | "running" | "error" | "shutdown";
-    message?: string;
-}
-export declare const Methods: {
-    readonly Run: "agent/run";
-    readonly Approve: "agent/approve";
-    readonly Cancel: "agent/cancel";
-    readonly Configure: "agent/configure";
-    readonly Query: "agent/query";
-    /** Inject context into transcript without triggering LLM. */
-    readonly Inject: "agent/inject";
-    readonly StreamEvent: "agent/streamEvent";
-    readonly ApprovalRequest: "agent/approvalRequest";
-    readonly Status: "agent/status";
-};
-export declare function createRequest(method: string, params?: Record<string, unknown>): RpcRequest;
-export declare function createResponse(id: string | number, result: unknown): RpcResponse;
-export declare function createErrorResponse(id: string | number, code: number, message: string, data?: unknown): RpcResponse;
-export declare function createNotification(method: string, params?: Record<string, unknown>): RpcNotification;
-export declare function isRequest(msg: RpcMessage): msg is RpcRequest;
-export declare function isResponse(msg: RpcMessage): msg is RpcResponse;
-export declare function isNotification(msg: RpcMessage): msg is RpcNotification;

package/dist/react-compiler-runtime-shim.d.ts

@@ -1 +0,0 @@
-export declare function c(size: number): any[];

package/dist/remote/bridge.d.ts

@@ -1,37 +0,0 @@
-/**
- * Remote bridge — NDJSON over SSH for remote code-shell sessions.
- *
- * Architecture:
- *   Local terminal ←→ SSH ←→ Remote code-shell (NDJSON stdio mode)
- */
-export interface BridgeConfig {
-    host: string;
-    user?: string;
-    port?: number;
-    identityFile?: string;
-    remoteCommand?: string;
-}
-export declare class RemoteBridge {
-    private readonly config;
-    private ssh;
-    private connected;
-    constructor(config: BridgeConfig);
-    /**
-     * Connect to the remote host via SSH and start code-shell in NDJSON mode.
-     */
-    connect(): Promise<void>;
-    /**
-     * Send a message to the remote code-shell.
-     */
-    send(message: Record<string, unknown>): void;
-    /**
-     * Async iterator for messages from the remote code-shell.
-     */
-    messages(): AsyncGenerator<Record<string, unknown>>;
-    /**
-     * Disconnect from the remote host.
-     */
-    disconnect(): void;
-    get isConnected(): boolean;
-    private buildSSHArgs;
-}

package/dist/render/Ansi.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-/**
- * Component that parses ANSI escape codes and renders them using Text components.
- *
- * Use this as an escape hatch when you have pre-formatted ANSI strings from
- * external tools (like cli-highlight) that need to be rendered in Ink.
- *
- * Memoized to prevent re-renders when parent changes but children string is the same.
- */
-export declare const Ansi: React.NamedExoticComponent<object>;

package/dist/render/bidi.d.ts

@@ -1,15 +0,0 @@
-type ClusteredChar = {
-    value: string;
-    width: number;
-    styleId: number;
-    hyperlink: string | undefined;
-};
-/**
- * Reorder an array of ClusteredChars from logical order to visual order
- * using the Unicode Bidi Algorithm. Active on terminals that lack native
- * bidi support (Windows Terminal, conhost, WSL).
- *
- * Returns the same array on bidi-capable terminals (no-op).
- */
-export declare function reorderBidi(characters: ClusteredChar[]): ClusteredChar[];
-export {};

package/dist/render/clearTerminal.d.ts

@@ -1,19 +0,0 @@
-/**
- * Cross-platform terminal clearing with scrollback support.
- * Detects modern terminals that support ESC[3J for clearing scrollback.
- */
-/**
- * Returns the ANSI escape sequence to clear the terminal.
- *
- * `preserveScrollback=true` omits ERASE_SCROLLBACK (CSI 3J) so the user's
- * scrollback buffer (and scroll position) survives a mid-stream fullReset.
- * Used by log-update when emitting a flicker reset in flow mode — alt-screen
- * has no user-visible scrollback so the default (clear it) is fine there.
- */
-export declare function getClearTerminalSequence(options?: {
-    preserveScrollback?: boolean;
-}): string;
-/**
- * Clears the terminal screen. On supported terminals, also clears scrollback.
- */
-export declare const clearTerminal: string;

package/dist/render/colorize.d.ts

@@ -1,16 +0,0 @@
-import type { Color, TextStyles } from './styles.js';
-export declare const CHALK_BOOSTED_FOR_XTERMJS: boolean;
-export declare const CHALK_CLAMPED_FOR_TMUX: boolean;
-export type ColorType = 'foreground' | 'background';
-export declare const colorize: (str: string, color: string | undefined, type: ColorType) => string;
-/**
- * Apply TextStyles to a string using chalk.
- * This is the inverse of parsing ANSI codes - we generate them from structured styles.
- * Theme resolution happens at component layer, not here.
- */
-export declare function applyTextStyles(text: string, styles: TextStyles): string;
-/**
- * Apply a raw color value to text.
- * Theme resolution should happen at component layer, not here.
- */
-export declare function applyColor(text: string, color: Color | undefined): string;

package/dist/render/components/AlternateScreen.d.ts

@@ -1,21 +0,0 @@
-/**
- * Run children in the terminal's alternate screen buffer, constrained to
- * the viewport height. While mounted:
- *
- * - Enters the alt screen (DEC 1049), clears it, homes the cursor
- * - Constrains its own height to the terminal row count, so overflow must
- *   be handled via `overflow: scroll` / flexbox (no native scrollback)
- * - Optionally enables SGR mouse tracking (wheel + click/drag) — events
- *   surface as `ParsedKey` (wheel) and update the Ink instance's
- *   selection state (click/drag)
- *
- * On unmount, disables mouse tracking and exits the alt screen, restoring
- * the main screen's content. Safe for use in ctrl-o transcript overlays
- * and similar temporary fullscreen views — the main screen is preserved.
- *
- * Notifies the Ink instance via `setAltScreenActive()` so the renderer
- * keeps the cursor inside the viewport (preventing the cursor-restore LF
- * from scrolling content) and so signal-exit cleanup can exit the alt
- * screen if the component's own unmount doesn't run.
- */
-export declare function AlternateScreen(t0: any): any;