@cjhyy/code-shell 0.1.0-alpha.0

package/dist/cli/onboarding.d.ts

@@ -0,0 +1,26 @@
+/**
+ * First-run onboarding — interactive API key setup with arrow-key navigation.
+ *
+ * Features:
+ * - Arrow-key (↑/↓) selection for providers and models
+ * - ESC to go back to previous step
+ * - Multi-provider configuration for Arena
+ * - API key validation before saving
+ */
+interface OnboardingResult {
+    provider: string;
+    model: string;
+    apiKey: string;
+    baseUrl: string;
+}
+export declare function hasApiKey(): boolean;
+/**
+ * Run the full onboarding wizard. Supports ESC to go back at every step.
+ */
+export declare function runOnboarding(): Promise<OnboardingResult>;
+/**
+ * Re-run onboarding from REPL (/login command).
+ * Clears existing config first.
+ */
+export declare function reconfigure(): Promise<OnboardingResult>;
+export {};

package/dist/cli/output/renderer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Output renderers for different formats.
+ */
+import type { StreamEvent, TerminalReason } from "../../types.js";
+export type OutputFormat = "text" | "json" | "jsonl" | "stream-json";
+export interface OutputRenderer {
+    onEvent(event: StreamEvent): void;
+    onComplete(text: string, reason: TerminalReason, meta: Record<string, unknown>): void;
+}
+export declare class TextRenderer implements OutputRenderer {
+    private activeAgents;
+    onEvent(event: StreamEvent): void;
+    onComplete(_text: string, reason: TerminalReason): void;
+}
+export declare class JsonRenderer implements OutputRenderer {
+    private text;
+    onEvent(event: StreamEvent): void;
+    onComplete(text: string, reason: TerminalReason, meta: Record<string, unknown>): void;
+}
+export declare class JsonlRenderer implements OutputRenderer {
+    onEvent(event: StreamEvent): void;
+    onComplete(text: string, reason: TerminalReason, meta: Record<string, unknown>): void;
+}
+export declare class StreamJsonRenderer implements OutputRenderer {
+    onEvent(event: StreamEvent): void;
+    onComplete(text: string, reason: TerminalReason, meta: Record<string, unknown>): void;
+}
+export declare function createRenderer(format: OutputFormat): OutputRenderer;

package/dist/cli/output/terminal-ui.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Terminal UI utilities — spinners, markdown rendering, styled output.
+ */
+import { type Ora } from "ora";
+/**
+ * Render markdown text to styled terminal output.
+ * Falls back to raw text if rendering fails.
+ */
+export declare function renderMarkdown(text: string): string;
+/**
+ * Highlight a code block with syntax coloring.
+ */
+export declare function highlightCode(code: string, lang?: string): string;
+export interface SpinnerHandle {
+    update(text: string): void;
+    succeed(text: string): void;
+    fail(text: string): void;
+    stop(): void;
+    instance: Ora;
+}
+/**
+ * Create a spinner for long-running operations.
+ */
+export declare function createSpinner(text: string): SpinnerHandle;
+/**
+ * Print a styled banner box.
+ */
+export declare function printBanner(lines: {
+    label: string;
+    value: string;
+}[]): void;
+/**
+ * Format a tool call start line.
+ */
+export declare function formatToolStart(toolName: string, args: Record<string, unknown>): string;
+/**
+ * Format a tool result line.
+ */
+export declare function formatToolResult(toolName: string, result?: string, error?: string): string;
+export interface TaskDisplayInfo {
+    id: string;
+    subject: string;
+    activeForm?: string;
+    status: "pending" | "in_progress" | "completed" | "stopped";
+}
+/**
+ * Render the task list as a compact terminal block.
+ * Returns the formatted string (caller handles printing).
+ */
+export declare function renderTaskList(tasks: TaskDisplayInfo[]): string;

package/dist/cli/updater.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Auto-update checker — non-blocking check for newer versions on npm.
+ */
+/**
+ * Check if a newer version is available (non-blocking).
+ * Call this on startup and read the result later.
+ */
+export declare function checkForUpdate(packageName?: string): void;
+export declare function getUpdateAvailable(): string | undefined;
+export declare function getCurrentVersion(): string;

package/dist/compaction-44I55TLI.cjs

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkLRAY5IYCcjs = require('./chunk-LRAY5IYC.cjs');
+require('./chunk-HD7MT5XU.cjs');
+require('./chunk-IJSHQGMP.cjs');
+_chunkLRAY5IYCcjs.init_compaction.call(void 0, );
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.adjustIndexToPreserveAPIInvariants = _chunkLRAY5IYCcjs.adjustIndexToPreserveAPIInvariants; exports.applySummaryCompaction = _chunkLRAY5IYCcjs.applySummaryCompaction; exports.applyToolResultBudget = _chunkLRAY5IYCcjs.applyToolResultBudget; exports.buildSummarizationPrompt = _chunkLRAY5IYCcjs.buildSummarizationPrompt; exports.dropOldestRounds = _chunkLRAY5IYCcjs.dropOldestRounds; exports.estimateTokens = _chunkLRAY5IYCcjs.estimateTokens; exports.extractReferencedFilePaths = _chunkLRAY5IYCcjs.extractReferencedFilePaths; exports.groupMessagesByApiRound = _chunkLRAY5IYCcjs.groupMessagesByApiRound; exports.microcompact = _chunkLRAY5IYCcjs.microcompact; exports.snipCompact = _chunkLRAY5IYCcjs.snipCompact; exports.truncateToolResult = _chunkLRAY5IYCcjs.truncateToolResult; exports.windowCompact = _chunkLRAY5IYCcjs.windowCompact;

package/dist/compaction-CCHWA4G6.js

@@ -0,0 +1,32 @@
+import {
+  adjustIndexToPreserveAPIInvariants,
+  applySummaryCompaction,
+  applyToolResultBudget,
+  buildSummarizationPrompt,
+  dropOldestRounds,
+  estimateTokens,
+  extractReferencedFilePaths,
+  groupMessagesByApiRound,
+  init_compaction,
+  microcompact,
+  snipCompact,
+  truncateToolResult,
+  windowCompact
+} from "./chunk-J5XW6UYL.js";
+import "./chunk-4RRUP4MM.js";
+import "./chunk-DI7RDLOS.js";
+init_compaction();
+export {
+  adjustIndexToPreserveAPIInvariants,
+  applySummaryCompaction,
+  applyToolResultBudget,
+  buildSummarizationPrompt,
+  dropOldestRounds,
+  estimateTokens,
+  extractReferencedFilePaths,
+  groupMessagesByApiRound,
+  microcompact,
+  snipCompact,
+  truncateToolResult,
+  windowCompact
+};

package/dist/context/compaction.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Context compaction strategies.
+ *
+ * Tier 0: truncateToolResult — truncate oversized individual results
+ * Tier 1: microcompact — zero-cost, clears old tool_result content
+ * Tier 2: LLM summary — generates summary via model call (async)
+ * Tier 3: window compact — keeps first + last N messages (sync fallback)
+ * Emergency: dropOldestRounds — progressive API-round-based truncation
+ *
+ * All slicing functions use adjustIndexToPreserveAPIInvariants()
+ * to prevent splitting tool_use / tool_result pairs.
+ */
+import type { Message } from "../types.js";
+/**
+ * Estimate token count from messages.
+ * Uses per-block-type estimation with 33% overhead padding.
+ */
+export declare function estimateTokens(messages: Message[]): number;
+/**
+ * Expand a slice start-index backwards so that every tool_result in the
+ * kept range has its corresponding tool_use in the kept range too.
+ *
+ * Without this, windowCompact / applySummaryCompaction can produce
+ * messages where tool_result references a tool_use_id that was
+ * compacted away, causing an API validation error.
+ */
+export declare function adjustIndexToPreserveAPIInvariants(messages: Message[], startIndex: number): number;
+/**
+ * Snip strategy: keep first N + last M messages, replace middle with a marker.
+ * Less aggressive than windowCompact — preserves initial context AND recent history.
+ * Uses adjustIndexToPreserveAPIInvariants on both boundaries.
+ */
+export declare function snipCompact(messages: Message[], keepFirstN?: number, keepLastM?: number): Message[];
+/**
+ * Window strategy: keep first message + last N messages.
+ * Uses adjustIndexToPreserveAPIInvariants to avoid splitting tool pairs.
+ */
+export declare function windowCompact(messages: Message[], keepLastN: number): Message[];
+/**
+ * Remove old tool_result content (microcompact).
+ * Replaces tool_result content with "[Old tool result cleared]" for messages
+ * older than keepRecentN tool rounds.
+ */
+export declare function microcompact(messages: Message[], keepRecentN?: number): Message[];
+/**
+ * Apply aggregate per-message tool result budget.
+ * When total tool_result content in a single message exceeds maxTotalChars,
+ * truncates the largest results first with a notice.
+ */
+export declare function applyToolResultBudget(messages: Message[], maxTotalChars?: number): Message[];
+/**
+ * Truncate a single tool result if it exceeds the character limit.
+ * Returns the truncated string with a notice.
+ */
+export declare function truncateToolResult(result: string, maxChars?: number): string;
+/**
+ * Build a structured summarization prompt from messages to be compacted.
+ * Produces a 9-section summary preserving key details.
+ */
+export declare function buildSummarizationPrompt(messagesToSummarize: Message[]): string;
+/**
+ * Apply LLM-generated summary compaction (hybrid mode).
+ *
+ * Instead of eagerly restoring file contents (wastes tokens), gives the
+ * model a summary + the transcript path so it can Read on demand.
+ * Also lists recently-referenced files so the model knows what to re-read.
+ */
+export declare function applySummaryCompaction(messages: Message[], summary: string, keepRecentN: number, transcriptPath?: string): Message[];
+/**
+ * Group messages by API round-trip boundaries.
+ * Each group represents one complete assistant response + its tool results.
+ */
+export declare function groupMessagesByApiRound(messages: Message[]): Message[][];
+/**
+ * Drop the oldest API rounds from messages, preserving tool pairs.
+ * Used for progressive prompt-too-long recovery.
+ */
+export declare function dropOldestRounds(messages: Message[], roundsToDrop: number): Message[];
+/**
+ * Extract file paths that were referenced (Read/Edit/Write) in compacted
+ * messages. Returns paths only — the model uses Read tool on demand.
+ */
+export declare function extractReferencedFilePaths(messages: Message[]): string[];

package/dist/context/manager.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Context manager — three-tier context management.
+ *
+ * Tier 1: microcompact (sync, zero-cost) — clear old tool_result content
+ * Tier 2: LLM summary (async) — generate summary of older messages via model call
+ * Tier 3: window compact (sync, emergency) — aggressive truncation fallback
+ */
+import type { Message } from "../types.js";
+export interface ContextManagerConfig {
+    maxTokens: number;
+    compactAtRatio: number;
+    summarizeAtRatio: number;
+    maxToolResultChars: number;
+}
+/**
+ * Async function type for LLM summarization calls.
+ * Injected by the Engine so the ContextManager doesn't depend on LLM directly.
+ */
+export type SummarizeFn = (prompt: string) => Promise<string>;
+export declare class ContextManager {
+    private config;
+    private toolCallHashes;
+    private summarizeFn;
+    private consecutiveSummaryFailures;
+    private lastSummary;
+    /** Last known actual token count from API usage data. */
+    private lastActualTokens;
+    /** Message count at the time lastActualTokens was recorded. */
+    private lastActualAtMessageCount;
+    /** Path to session transcript — passed to summary compaction for on-demand access. */
+    private transcriptPath;
+    constructor(config?: Partial<ContextManagerConfig>);
+    /**
+     * Record actual token usage from API response.
+     * Used for hybrid estimation: actual + estimate for new messages.
+     */
+    recordActualUsage(inputTokens: number, messageCount: number): void;
+    /**
+     * Best-effort token estimate: uses actual API usage as base if available,
+     * plus estimation for messages added since the last API call.
+     */
+    private estimateTokensHybrid;
+    /**
+     * Set the summarize function (injected by Engine).
+     */
+    setSummarizeFn(fn: SummarizeFn): void;
+    /**
+     * Set the transcript path so compaction can reference it.
+     */
+    setTranscriptPath(path: string): void;
+    /**
+     * Apply progressive context management (sync path).
+     * For Tier 2 (LLM summary), call manageAsync instead.
+     */
+    manage(messages: Message[]): Message[];
+    /**
+     * Async context management — attempts LLM summarization before falling back.
+     * Call this when you have access to the LLM (between turns).
+     */
+    manageAsync(messages: Message[]): Promise<Message[]>;
+    /**
+     * Truncate oversized tool results in messages.
+     */
+    private truncateToolResults;
+    /**
+     * Reactive compaction check — call during streaming to detect if
+     * token usage is approaching the limit mid-turn.
+     * Returns true if emergency compaction should be triggered.
+     */
+    shouldReactiveCompact(messages: Message[], currentResponseTokens: number): boolean;
+    /**
+     * Check if context is approaching limits.
+     */
+    checkLimits(messages: Message[]): {
+        tokens: number;
+        ratio: number;
+        needsCompact: boolean;
+        needsEmergency: boolean;
+    };
+    /**
+     * Deduplicate tool calls by hashing arguments.
+     */
+    deduplicateToolCalls(calls: Array<{
+        toolName: string;
+        args: Record<string, unknown>;
+    }>): {
+        toExecute: typeof calls;
+        cached: Array<{
+            toolName: string;
+            args: Record<string, unknown>;
+            result: string;
+        }>;
+    };
+    /**
+     * Record a tool call result for dedup tracking.
+     */
+    recordToolResult(toolName: string, args: Record<string, unknown>, result: string): void;
+    private hashCall;
+}

package/dist/context/token-counter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Token counter — more accurate token estimation.
+ *
+ * Uses a character-based heuristic tuned per language/content type,
+ * with cache-aware accounting for prompt caching.
+ */
+import type { Message } from "../types.js";
+/**
+ * Estimate token count for a string, detecting content type.
+ */
+export declare function estimateStringTokens(text: string): number;
+/**
+ * Estimate token count for a message array.
+ */
+export declare function estimateMessagesTokens(messages: Message[]): number;
+/**
+ * Context window usage report.
+ */
+export interface ContextUsage {
+    usedTokens: number;
+    maxTokens: number;
+    usagePercent: number;
+    systemPromptTokens: number;
+    messagesTokens: number;
+    headroom: number;
+}
+export declare function calculateContextUsage(messages: Message[], systemPrompt: string, maxTokens: number): ContextUsage;

package/dist/coordinator-5HY7ALO2.js

@@ -0,0 +1,7 @@
+import {
+  agentCoordinator
+} from "./chunk-C7JBCO5V.js";
+import "./chunk-DI7RDLOS.js";
+export {
+  agentCoordinator
+};

package/dist/coordinator-INDLPVMF.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkXHC2JMECcjs = require('./chunk-XHC2JMEC.cjs');
+require('./chunk-IJSHQGMP.cjs');
+
+
+exports.agentCoordinator = _chunkXHC2JMECcjs.agentCoordinator;

package/dist/cost-tracker-IWYAUPXH.js

@@ -0,0 +1,9 @@
+import {
+  CostTracker,
+  costTracker
+} from "./chunk-ZRSSGYA5.js";
+import "./chunk-DI7RDLOS.js";
+export {
+  CostTracker,
+  costTracker
+};

package/dist/cost-tracker-JXTJQQWE.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk5LHVI777cjs = require('./chunk-5LHVI777.cjs');
+require('./chunk-IJSHQGMP.cjs');
+
+
+
+exports.CostTracker = _chunk5LHVI777cjs.CostTracker; exports.costTracker = _chunk5LHVI777cjs.costTracker;

package/dist/cron/scheduler.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Cron scheduler — schedule and manage recurring agent tasks.
+ *
+ * Supports simple cron-like intervals. Each job runs the Engine
+ * with a predefined prompt on schedule.
+ */
+export interface CronJob {
+    id: string;
+    name: string;
+    schedule: string;
+    prompt: string;
+    enabled: boolean;
+    lastRun?: number;
+    nextRun?: number;
+    runCount: number;
+    createdAt: number;
+}
+declare class CronScheduler {
+    private jobs;
+    private timers;
+    private nextId;
+    private onExecute?;
+    setExecutor(fn: (job: CronJob) => Promise<void>): void;
+    create(name: string, schedule: string, prompt: string): CronJob;
+    delete(id: string): boolean;
+    list(): CronJob[];
+    get(id: string): CronJob | undefined;
+    pause(id: string): boolean;
+    resume(id: string): boolean;
+    stopAll(): void;
+    private startTimer;
+}
+export declare const cronScheduler: CronScheduler;
+export {};

package/dist/devtools-KIY3LWQJ.js

@@ -0,0 +1,6 @@
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/ink/devtools.ts
+init_esm_shims();

package/dist/devtools-LRP47DDV.cjs

@@ -0,0 +1,6 @@
+"use strict";
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/ink/devtools.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );

package/dist/engine/cost-store.d.ts

@@ -0,0 +1,22 @@
+/**
+ * CostStateStore — an opaque snapshot/restore hook that Engine uses to
+ * persist session-level cost state across `run({ sessionId })` calls.
+ *
+ * Engine itself doesn't compute prices or format summaries; it just hands
+ * the state blob to whatever store was injected. The CLI's `costTracker`
+ * is one concrete implementation; a SaaS backend might implement this
+ * against a database instead.
+ *
+ * Default: no store is injected, and cost state is not persisted. Engine
+ * continues to report per-run token usage via `EngineResult.usage` and
+ * `LLMClientBase.getUsage()` — this hook is only for the
+ * "resume-and-keep-counting" scenario.
+ */
+/** Arbitrary serializable snapshot — opaque to Engine. */
+export type CostStateSnapshot = unknown;
+export interface CostStateStore {
+    /** Serialize current cost state for persistence. */
+    serialize(): CostStateSnapshot;
+    /** Restore previously-serialized cost state. */
+    restore(state: CostStateSnapshot): void;
+}

package/dist/engine/engine.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Engine — the main facade that wires all components together.
+ */
+import type { LLMConfig, StreamCallback, TerminalReason, TokenUsage } from "../types.js";
+import { ToolRegistry } from "../tool-system/registry.js";
+import { type ApprovalBackend } from "../tool-system/permission.js";
+import { HookRegistry } from "../hooks/registry.js";
+import { SessionManager } from "../session/session-manager.js";
+import type { CostStateStore } from "./cost-store.js";
+import { type AskUserFn } from "../tool-system/builtin/ask-user.js";
+import { type AgentPresetName } from "../preset/index.js";
+import { ModelPool, type ModelEntry } from "../llm/model-pool.js";
+export interface EngineConfig {
+    llm: LLMConfig;
+    cwd?: string;
+    maxTurns?: number;
+    maxToolCallsPerTurn?: number;
+    permissionMode?: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan";
+    preset?: AgentPresetName;
+    enabledBuiltinTools?: string[];
+    disabledBuiltinTools?: string[];
+    customSystemPrompt?: string;
+    appendSystemPrompt?: string;
+    sessionStorageDir?: string;
+    maxContextTokens?: number;
+    approvalBackend?: ApprovalBackend;
+    askUser?: AskUserFn;
+    mcpServers?: Record<string, import("../types.js").MCPServerConfig>;
+    /**
+     * Optional opaque store for per-session cost/usage state. When provided,
+     * Engine calls `restore()` on session resume and `serialize()` at the end
+     * of each `run()` and stores the blob on the session. Without this the
+     * Engine doesn't persist cost state — it's a UI concern.
+     */
+    costStore?: CostStateStore;
+}
+export interface EngineResult {
+    text: string;
+    reason: TerminalReason;
+    sessionId: string;
+    turnCount: number;
+    usage: TokenUsage;
+}
+export declare class Engine {
+    private config;
+    private readonly preset;
+    private toolRegistry;
+    private hooks;
+    private sessionManager;
+    private mcpManager;
+    private modelPool;
+    constructor(config: EngineConfig);
+    /**
+     * Register a custom tool (from product adapter) into the tool registry.
+     * Must be called before run().
+     */
+    registerCustomTool(definition: import("../types.js").RegisteredTool, executor: (args: Record<string, unknown>) => Promise<string>): void;
+    /**
+     * Run a task from start to finish.
+     */
+    run(task: string, options?: {
+        onStream?: StreamCallback;
+        signal?: AbortSignal;
+        sessionId?: string;
+    }): Promise<EngineResult>;
+    getToolRegistry(): ToolRegistry;
+    /**
+     * Switch the active model by pool key. Takes effect on the next run() call.
+     * Returns the new model entry.
+     */
+    switchModel(key: string): ModelEntry;
+    /** Get the model pool. */
+    getModelPool(): ModelPool;
+    /** Get the current model name (full path). */
+    getCurrentModel(): string;
+    getHookRegistry(): HookRegistry;
+    getSessionManager(): SessionManager;
+    getConfig(): EngineConfig;
+    /**
+     * Inject context into a session's transcript without triggering a LLM turn.
+     * The injected content appears as an assistant message so the LLM can see it
+     * in subsequent conversations. The transcript auto-flushes to disk.
+     */
+    injectContext(sessionId: string, content: string): void;
+    /**
+     * Force context compaction on the current session.
+     * Returns token stats before/after.
+     */
+    forceCompact(): {
+        before: number;
+        after: number;
+        strategy: string;
+    };
+    /**
+     * Update a config setting at runtime.
+     */
+    updateConfig(key: string, value: unknown): void;
+    /** Track last context manager and messages for /compact support. */
+    private lastContextManager;
+    private lastMessages;
+}

package/dist/engine/model-facade.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Model call facade — wraps LLM client with transcript integration.
+ */
+import type { LLMClientBase } from "../llm/client-base.js";
+import type { Message, ToolDefinition, LLMResponse, StreamCallback } from "../types.js";
+import { Transcript } from "../session/transcript.js";
+export declare class ModelFacade {
+    private readonly client;
+    private readonly transcript;
+    constructor(client: LLMClientBase, transcript: Transcript);
+    call(systemPrompt: string, messages: Message[], tools: ToolDefinition[], onStream?: StreamCallback, signal?: AbortSignal): Promise<LLMResponse>;
+    /**
+     * Call without streaming — used as fallback when streaming fails.
+     */
+    callWithoutStreaming(systemPrompt: string, messages: Message[], tools: ToolDefinition[], signal?: AbortSignal): Promise<LLMResponse>;
+    /** Record API timing and token usage to bootstrap state. */
+    private recordUsage;
+    /** Optional summarize function for tool use summaries. */
+    summarize?: (systemPrompt: string, userMessage: string) => Promise<string>;
+    /** Get cumulative output tokens (for token budget). */
+    getOutputTokens?(): number;
+    private recordResponse;
+    getUsage(): import("../llm/types.js").LLMUsageTracker;
+}