@cjhyy/code-shell 0.1.0-alpha.0

package/dist/ink/useTerminalNotification.d.ts

@@ -0,0 +1,28 @@
+import { type Progress } from './terminal.js';
+type WriteRaw = (data: string) => void;
+export declare const TerminalWriteContext: import("react").Context<WriteRaw | null>;
+export declare const TerminalWriteProvider: import("react").Provider<WriteRaw | null>;
+export type TerminalNotification = {
+    notifyITerm2: (opts: {
+        message: string;
+        title?: string;
+    }) => void;
+    notifyKitty: (opts: {
+        message: string;
+        title: string;
+        id: number;
+    }) => void;
+    notifyGhostty: (opts: {
+        message: string;
+        title: string;
+    }) => void;
+    notifyBell: () => void;
+    /**
+     * Report progress to the terminal via OSC 9;4 sequences.
+     * Supported terminals: ConEmu, Ghostty 1.2.0+, iTerm2 3.6.6+
+     * Pass state=null to clear progress.
+     */
+    progress: (state: Progress['state'] | null, percentage?: number) => void;
+};
+export declare function useTerminalNotification(): TerminalNotification;
+export {};

package/dist/ink/warn.d.ts

@@ -0,0 +1 @@
+export declare function ifNotInteger(value: number | undefined, name: string): void;

package/dist/ink/widest-line.d.ts

@@ -0,0 +1 @@
+export declare function widestLine(string: string): number;

package/dist/ink/wrap-text.d.ts

@@ -0,0 +1,2 @@
+import type { Styles } from './styles.js';
+export default function wrapText(text: string, maxWidth: number, wrapType: Styles['textWrap']): string;

package/dist/ink/wrapAnsi.d.ts

@@ -0,0 +1,7 @@
+type WrapAnsiOptions = {
+    hard?: boolean;
+    wordWrap?: boolean;
+    trim?: boolean;
+};
+declare const wrapAnsi: (input: string, columns: number, options?: WrapAnsiOptions) => string;
+export { wrapAnsi };

package/dist/llm/client-base.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Abstract base class for all LLM provider clients.
+ */
+import type { LLMConfig, LLMResponse, TokenUsage } from "../types.js";
+import type { CreateMessageOptions, LLMUsageTracker } from "./types.js";
+export declare abstract class LLMClientBase {
+    protected readonly config: LLMConfig;
+    readonly provider: string;
+    readonly model: string;
+    readonly temperature: number;
+    readonly maxTokens: number;
+    readonly timeout: number;
+    readonly retryMaxAttempts: number;
+    readonly enableStreaming: boolean;
+    protected usage: LLMUsageTracker;
+    constructor(config: LLMConfig);
+    protected abstract initClient(): void;
+    abstract createMessage(options: CreateMessageOptions): Promise<LLMResponse>;
+    protected recordUsage(usage: TokenUsage): void;
+    getUsage(): LLMUsageTracker;
+    protected withRetry<T>(fn: () => Promise<T>, maxAttempts?: number): Promise<T>;
+}

package/dist/llm/client-factory.d.ts

@@ -0,0 +1,10 @@
+/**
+ * LLM provider factory with registry pattern.
+ */
+import type { LLMConfig } from "../types.js";
+import type { LLMClientBase } from "./client-base.js";
+type ProviderConstructor = new (config: LLMConfig) => LLMClientBase;
+declare const PROVIDER_REGISTRY: Map<string, ProviderConstructor>;
+export declare function registerProvider(name: string, cls: ProviderConstructor): void;
+export declare function createLLMClient(config: LLMConfig): Promise<LLMClientBase>;
+export { PROVIDER_REGISTRY };

package/dist/llm/model-pool.d.ts

@@ -0,0 +1,60 @@
+/**
+ * ModelPool — runtime model registry.
+ *
+ * Holds all available models loaded from settings. Provides:
+ *   - `get(key?)` — retrieve a model config by key, or the active one
+ *   - `switch(key)` — change the active model
+ *   - `list()` — list all available models
+ *   - `register(entry)` — add a model at runtime
+ *
+ * Consumers:
+ *   - Engine/TurnLoop: `pool.get()` for the active model
+ *   - Arena: `pool.get("sonnet")` to resolve participants by key
+ *   - /model command: `pool.switch("haiku")` for hot-swap
+ */
+import type { LLMConfig } from "../types.js";
+export interface ModelEntry {
+    /** Short alias: "claude", "sonnet", "haiku", "gpt", "deepseek" */
+    key: string;
+    /** Human-readable label. Auto-generated from model path if not provided. */
+    label?: string;
+    provider: string;
+    /** Full model path: "anthropic/claude-opus-4-6" */
+    model: string;
+    baseUrl?: string;
+    apiKey?: string;
+    maxOutputTokens?: number;
+}
+export declare class ModelPool {
+    private models;
+    private activeKey;
+    /**
+     * Build a pool from an array of model entries.
+     * The first entry (or the one matching `defaultKey`) becomes active.
+     */
+    constructor(entries?: ModelEntry[], defaultKey?: string);
+    /** Register a model at runtime. */
+    register(entry: ModelEntry): void;
+    /** Switch the active model. Throws if key not found. */
+    switch(key: string): ModelEntry;
+    /** Get a model by key. No key = active model. Returns undefined if not found. */
+    get(key?: string): ModelEntry | undefined;
+    /** Get the active model key. */
+    getActiveKey(): string | undefined;
+    /** List all registered models. */
+    list(): ModelEntry[];
+    /** Number of registered models. */
+    get size(): number;
+    /** Check if a key exists. */
+    has(key: string): boolean;
+    /**
+     * Build an LLMConfig for a given model entry, merging with a base config
+     * (inherits apiKey, baseUrl, etc. from the base if not set on the entry).
+     */
+    toLLMConfig(entry: ModelEntry, base?: Partial<LLMConfig>): LLMConfig;
+    /**
+     * Build an LLMConfig for the active model (or a specific key),
+     * merging with a base config.
+     */
+    resolveLLMConfig(key?: string, base?: Partial<LLMConfig>): LLMConfig | undefined;
+}

package/dist/llm/providers/anthropic.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Anthropic Claude provider using @anthropic-ai/sdk.
+ */
+import type { LLMConfig, LLMResponse } from "../../types.js";
+import type { CreateMessageOptions } from "../types.js";
+import { LLMClientBase } from "../client-base.js";
+export declare class AnthropicClient extends LLMClientBase {
+    private _client;
+    constructor(config: LLMConfig);
+    protected initClient(): void;
+    private get client();
+    createMessage(options: CreateMessageOptions): Promise<LLMResponse>;
+    private nonStreamMessage;
+    private streamMessage;
+    private processResponse;
+    private buildMessages;
+    private convertTools;
+    private handleApiError;
+}

package/dist/llm/providers/openai.d.ts

@@ -0,0 +1,19 @@
+/**
+ * OpenAI GPT provider using openai SDK.
+ */
+import type { LLMConfig, LLMResponse } from "../../types.js";
+import type { CreateMessageOptions } from "../types.js";
+import { LLMClientBase } from "../client-base.js";
+export declare class OpenAIClient extends LLMClientBase {
+    private _client;
+    constructor(config: LLMConfig);
+    protected initClient(): void;
+    private get client();
+    createMessage(options: CreateMessageOptions): Promise<LLMResponse>;
+    private nonStreamMessage;
+    private streamMessage;
+    private processChoice;
+    private buildMessages;
+    private convertTools;
+    private handleApiError;
+}

package/dist/llm/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * LLM-specific internal types.
+ */
+import type { Message, ToolDefinition, LLMStreamChunk, TokenUsage } from "../types.js";
+export interface CreateMessageOptions {
+    systemPrompt: string;
+    messages: Message[];
+    tools?: ToolDefinition[];
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+    onChunk?: (chunk: LLMStreamChunk) => void;
+    signal?: AbortSignal;
+}
+export interface LLMUsageTracker {
+    records: TokenUsage[];
+    totalPromptTokens: number;
+    totalCompletionTokens: number;
+    totalTokens: number;
+    requestCount: number;
+}

package/dist/loader-DXFSUB4R.cjs

@@ -0,0 +1,91 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/plugins/loader.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var _fs = require('fs');
+var _path = require('path');
+var _os = require('os');
+var PluginLoader = (_class = class {constructor() { _class.prototype.__init.call(this); }
+  __init() {this.plugins = /* @__PURE__ */ new Map()}
+  /**
+   * Scan plugin directories and load manifests.
+   */
+  scan(cwd) {
+    const dirs = [
+      _path.join.call(void 0, _os.homedir.call(void 0, ), ".code-shell", "plugins"),
+      _path.join.call(void 0, cwd, ".code-shell", "plugins")
+    ];
+    for (const dir of dirs) {
+      if (!_fs.existsSync.call(void 0, dir)) continue;
+      try {
+        const entries = _fs.readdirSync.call(void 0, dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          const pluginDir = _path.join.call(void 0, dir, entry.name);
+          this.loadPlugin(pluginDir);
+        }
+      } catch (e) {
+      }
+    }
+    return this.list();
+  }
+  /**
+   * Load a single plugin from a directory.
+   */
+  loadPlugin(pluginDir) {
+    const manifestPath = _path.join.call(void 0, pluginDir, "manifest.json");
+    if (!_fs.existsSync.call(void 0, manifestPath)) {
+      const pkgPath = _path.join.call(void 0, pluginDir, "package.json");
+      if (!_fs.existsSync.call(void 0, pkgPath)) return;
+      try {
+        const pkg = JSON.parse(_fs.readFileSync.call(void 0, pkgPath, "utf-8"));
+        if (!pkg.codeShellPlugin) return;
+        this.registerPlugin(pluginDir, pkg.codeShellPlugin);
+      } catch (e2) {
+      }
+      return;
+    }
+    try {
+      const manifest = JSON.parse(_fs.readFileSync.call(void 0, manifestPath, "utf-8"));
+      this.registerPlugin(pluginDir, manifest);
+    } catch (err) {
+      this.plugins.set(pluginDir, {
+        manifest: { name: pluginDir, version: "?", description: "Failed to load" },
+        path: pluginDir,
+        enabled: false,
+        error: err.message
+      });
+    }
+  }
+  registerPlugin(path, manifest) {
+    this.plugins.set(manifest.name, {
+      manifest,
+      path,
+      enabled: manifest.enabled !== false
+    });
+  }
+  /** Get a plugin by name. */
+  get(name) {
+    return this.plugins.get(name);
+  }
+  /** List all discovered plugins. */
+  list() {
+    return [...this.plugins.values()];
+  }
+  /** Enable/disable a plugin. */
+  setEnabled(name, enabled) {
+    const plugin = this.plugins.get(name);
+    if (!plugin) return false;
+    plugin.enabled = enabled;
+    return true;
+  }
+  /** Get all enabled plugins. */
+  getEnabled() {
+    return [...this.plugins.values()].filter((p) => p.enabled);
+  }
+}, _class);
+
+
+exports.PluginLoader = PluginLoader;

package/dist/loader-J5UID6CV.js

@@ -0,0 +1,91 @@
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/plugins/loader.ts
+init_esm_shims();
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var PluginLoader = class {
+  plugins = /* @__PURE__ */ new Map();
+  /**
+   * Scan plugin directories and load manifests.
+   */
+  scan(cwd) {
+    const dirs = [
+      join(homedir(), ".code-shell", "plugins"),
+      join(cwd, ".code-shell", "plugins")
+    ];
+    for (const dir of dirs) {
+      if (!existsSync(dir)) continue;
+      try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          const pluginDir = join(dir, entry.name);
+          this.loadPlugin(pluginDir);
+        }
+      } catch {
+      }
+    }
+    return this.list();
+  }
+  /**
+   * Load a single plugin from a directory.
+   */
+  loadPlugin(pluginDir) {
+    const manifestPath = join(pluginDir, "manifest.json");
+    if (!existsSync(manifestPath)) {
+      const pkgPath = join(pluginDir, "package.json");
+      if (!existsSync(pkgPath)) return;
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (!pkg.codeShellPlugin) return;
+        this.registerPlugin(pluginDir, pkg.codeShellPlugin);
+      } catch {
+      }
+      return;
+    }
+    try {
+      const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+      this.registerPlugin(pluginDir, manifest);
+    } catch (err) {
+      this.plugins.set(pluginDir, {
+        manifest: { name: pluginDir, version: "?", description: "Failed to load" },
+        path: pluginDir,
+        enabled: false,
+        error: err.message
+      });
+    }
+  }
+  registerPlugin(path, manifest) {
+    this.plugins.set(manifest.name, {
+      manifest,
+      path,
+      enabled: manifest.enabled !== false
+    });
+  }
+  /** Get a plugin by name. */
+  get(name) {
+    return this.plugins.get(name);
+  }
+  /** List all discovered plugins. */
+  list() {
+    return [...this.plugins.values()];
+  }
+  /** Enable/disable a plugin. */
+  setEnabled(name, enabled) {
+    const plugin = this.plugins.get(name);
+    if (!plugin) return false;
+    plugin.enabled = enabled;
+    return true;
+  }
+  /** Get all enabled plugins. */
+  getEnabled() {
+    return [...this.plugins.values()].filter((p) => p.enabled);
+  }
+};
+export {
+  PluginLoader
+};

package/dist/logging/logger.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Simple file logger for debug/runtime logs.
+ *
+ * Logs go to ~/.code-shell/logs/YYYY-MM-DD.log
+ */
+export type LogLevel = "debug" | "info" | "warn" | "error";
+declare class Logger {
+    private logDir;
+    private minLevel;
+    private enabled;
+    constructor();
+    debug(msg: string, data?: Record<string, unknown>): void;
+    info(msg: string, data?: Record<string, unknown>): void;
+    warn(msg: string, data?: Record<string, unknown>): void;
+    error(msg: string, data?: Record<string, unknown>): void;
+    private log;
+}
+export declare const logger: Logger;
+export {};

package/dist/lsp/client.d.ts

@@ -0,0 +1,41 @@
+/**
+ * LSP client — JSON-RPC over stdio communication with language servers.
+ */
+import { EventEmitter } from "node:events";
+export interface LSPRequest {
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface LSPResponse {
+    id: number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+export interface LSPNotification {
+    method: string;
+    params?: Record<string, unknown>;
+}
+export declare class LSPClient extends EventEmitter {
+    private readonly command;
+    private readonly args;
+    private readonly cwd?;
+    private process;
+    private nextId;
+    private pending;
+    private buffer;
+    private contentLength;
+    private initialized;
+    constructor(command: string, args?: string[], cwd?: string | undefined);
+    start(): Promise<void>;
+    initialize(rootUri: string): Promise<unknown>;
+    request(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+    shutdown(): Promise<void>;
+    get isInitialized(): boolean;
+    get isAlive(): boolean;
+    private handleData;
+    private rejectAll;
+}

package/dist/lsp/manager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * LSP Server Manager — manages lifecycle of language server instances.
+ * Lazy initialization: servers start only when needed.
+ */
+import { LSPClient } from "./client.js";
+type ServerState = "stopped" | "starting" | "ready" | "error";
+export declare class LSPServerManager {
+    private servers;
+    private rootUri;
+    constructor(cwd: string);
+    /**
+     * Get or start a language server by name.
+     */
+    getClient(serverName: string): Promise<LSPClient | undefined>;
+    /**
+     * Start a specific language server.
+     */
+    private startServer;
+    /**
+     * Check if any LSP server is connected.
+     */
+    isConnected(): boolean;
+    /**
+     * List server statuses.
+     */
+    listServers(): Array<{
+        name: string;
+        language: string;
+        state: ServerState;
+        error?: string;
+    }>;
+    /**
+     * Shutdown all servers.
+     */
+    shutdownAll(): Promise<void>;
+    private isCommandAvailable;
+}
+export declare function initializeLSPManager(cwd: string): LSPServerManager;
+export declare function getLSPManager(): LSPServerManager | undefined;
+export {};

package/dist/lsp/servers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Built-in language server configurations.
+ */
+export interface LSPServerConfig {
+    name: string;
+    language: string;
+    extensions: string[];
+    command: string;
+    args: string[];
+    installHint: string;
+}
+export declare const BUILTIN_LSP_SERVERS: LSPServerConfig[];
+/**
+ * Detect which LSP server to use based on file extension.
+ */
+export declare function detectLSPServer(filePath: string): LSPServerConfig | undefined;

package/dist/manager-ETWDOCHN.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkFGZGCFJXcjs = require('./chunk-FGZGCFJX.cjs');
+require('./chunk-IJSHQGMP.cjs');
+_chunkFGZGCFJXcjs.init_manager.call(void 0, );
+
+
+exports.SettingsManager = _chunkFGZGCFJXcjs.SettingsManager;

package/dist/manager-HGMQNEJB.cjs

@@ -0,0 +1,11 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkJT2WSQSRcjs = require('./chunk-JT2WSQSR.cjs');
+require('./chunk-IJSHQGMP.cjs');
+
+
+
+
+exports.LSPServerManager = _chunkJT2WSQSRcjs.LSPServerManager; exports.getLSPManager = _chunkJT2WSQSRcjs.getLSPManager; exports.initializeLSPManager = _chunkJT2WSQSRcjs.initializeLSPManager;

package/dist/manager-HUAQOORS.js

@@ -0,0 +1,9 @@
+import {
+  SettingsManager,
+  init_manager
+} from "./chunk-6ZIROYXX.js";
+import "./chunk-DI7RDLOS.js";
+init_manager();
+export {
+  SettingsManager
+};

package/dist/manager-VJIZ2CQC.js

@@ -0,0 +1,11 @@
+import {
+  LSPServerManager,
+  getLSPManager,
+  initializeLSPManager
+} from "./chunk-OG4MIQJ6.js";
+import "./chunk-DI7RDLOS.js";
+export {
+  LSPServerManager,
+  getLSPManager,
+  initializeLSPManager
+};

package/dist/mcp-manager-G4G2QASE.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkBMH65OVBcjs = require('./chunk-BMH65OVB.cjs');
+require('./chunk-IMMTBZ33.cjs');
+require('./chunk-IJSHQGMP.cjs');
+
+
+exports.MCPManager = _chunkBMH65OVBcjs.MCPManager;

package/dist/mcp-manager-OKXHHWYR.js

@@ -0,0 +1,8 @@
+import {
+  MCPManager
+} from "./chunk-BE6IPRDM.js";
+import "./chunk-X4HAERTQ.js";
+import "./chunk-DI7RDLOS.js";
+export {
+  MCPManager
+};

package/dist/memory-AP747G5H.js

@@ -0,0 +1,7 @@
+import {
+  MemoryManager
+} from "./chunk-4PKZPFCD.js";
+import "./chunk-DI7RDLOS.js";
+export {
+  MemoryManager
+};

package/dist/memory-BH3BYUN5.cjs

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