@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/lsp/client.js

@@ -0,0 +1,166 @@
+/**
+ * LSP client — JSON-RPC over stdio communication with language servers.
+ */
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+export class LSPClient extends EventEmitter {
+    command;
+    args;
+    cwd;
+    process;
+    nextId = 1;
+    pending = new Map();
+    buffer = "";
+    contentLength = -1;
+    initialized = false;
+    constructor(command, args = [], cwd) {
+        super();
+        this.command = command;
+        this.args = args;
+        this.cwd = cwd;
+    }
+    async start() {
+        this.process = spawn(this.command, this.args, {
+            cwd: this.cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.process.stdout?.on("data", (data) => this.handleData(data.toString()));
+        this.process.stderr?.on("data", (_data) => {
+            // LSP servers often log to stderr — ignore
+        });
+        this.process.on("exit", (code) => {
+            this.emit("exit", code);
+            this.rejectAll(new Error(`LSP server exited with code ${code}`));
+        });
+        // Don't keep the event loop alive solely for the LSP child.
+        // Call after listeners are wired so event registration doesn't re-ref.
+        this.process.unref();
+    }
+    async initialize(rootUri) {
+        const result = await this.request("initialize", {
+            processId: process.pid,
+            rootUri,
+            capabilities: {
+                textDocument: {
+                    definition: { dynamicRegistration: false },
+                    references: { dynamicRegistration: false },
+                    hover: { contentFormat: ["plaintext", "markdown"] },
+                    documentSymbol: { dynamicRegistration: false },
+                    completion: { dynamicRegistration: false },
+                },
+                workspace: {
+                    symbol: { dynamicRegistration: false },
+                },
+            },
+        });
+        await this.notify("initialized", {});
+        this.initialized = true;
+        return result;
+    }
+    async request(method, params) {
+        if (!this.process?.stdin)
+            throw new Error("LSP server not started");
+        const id = this.nextId++;
+        const message = { jsonrpc: "2.0", id, method, params };
+        const content = JSON.stringify(message);
+        const header = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n`;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`LSP request "${method}" timed out`));
+                }
+            }, 30000);
+            // Don't let the timer keep the event loop alive by itself
+            timer.unref?.();
+            this.pending.set(id, {
+                resolve: (value) => { clearTimeout(timer); resolve(value); },
+                reject: (err) => { clearTimeout(timer); reject(err); },
+            });
+            this.process.stdin.write(header + content);
+        });
+    }
+    async notify(method, params) {
+        if (!this.process?.stdin)
+            throw new Error("LSP server not started");
+        const message = { jsonrpc: "2.0", method, params };
+        const content = JSON.stringify(message);
+        const header = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n`;
+        this.process.stdin.write(header + content);
+    }
+    async shutdown() {
+        if (!this.process)
+            return;
+        try {
+            await this.request("shutdown", {});
+            await this.notify("exit", {});
+        }
+        catch {
+            // Force kill
+        }
+        this.process.stdout?.removeAllListeners();
+        this.process.stderr?.removeAllListeners();
+        this.process.removeAllListeners();
+        this.process.kill();
+        this.process = undefined;
+        // Drain pending requests
+        for (const { reject } of this.pending.values()) {
+            reject(new Error("LSP server shut down"));
+        }
+        this.pending.clear();
+    }
+    get isInitialized() {
+        return this.initialized;
+    }
+    get isAlive() {
+        return this.process !== undefined && !this.process.killed;
+    }
+    handleData(data) {
+        this.buffer += data;
+        while (true) {
+            if (this.contentLength < 0) {
+                const headerEnd = this.buffer.indexOf("\r\n\r\n");
+                if (headerEnd < 0)
+                    break;
+                const header = this.buffer.slice(0, headerEnd);
+                const match = header.match(/Content-Length:\s*(\d+)/i);
+                if (!match) {
+                    this.buffer = this.buffer.slice(headerEnd + 4);
+                    continue;
+                }
+                this.contentLength = parseInt(match[1], 10);
+                this.buffer = this.buffer.slice(headerEnd + 4);
+            }
+            if (this.buffer.length < this.contentLength)
+                break;
+            const content = this.buffer.slice(0, this.contentLength);
+            this.buffer = this.buffer.slice(this.contentLength);
+            this.contentLength = -1;
+            try {
+                const message = JSON.parse(content);
+                if ("id" in message && this.pending.has(message.id)) {
+                    const { resolve, reject } = this.pending.get(message.id);
+                    this.pending.delete(message.id);
+                    if (message.error) {
+                        reject(new Error(`LSP error: ${message.error.message}`));
+                    }
+                    else {
+                        resolve(message.result);
+                    }
+                }
+                else if ("method" in message && !("id" in message)) {
+                    this.emit("notification", message);
+                }
+            }
+            catch {
+                // Skip malformed messages
+            }
+        }
+    }
+    rejectAll(error) {
+        for (const { reject } of this.pending.values()) {
+            reject(error);
+        }
+        this.pending.clear();
+    }
+}

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/manager.js

@@ -0,0 +1,124 @@
+/**
+ * LSP Server Manager — manages lifecycle of language server instances.
+ * Lazy initialization: servers start only when needed.
+ */
+import { LSPClient } from "./client.js";
+import { BUILTIN_LSP_SERVERS } from "./servers.js";
+import { execSync } from "node:child_process";
+import { pathToFileURL } from "node:url";
+export class LSPServerManager {
+    servers = new Map();
+    rootUri;
+    constructor(cwd) {
+        this.rootUri = pathToFileURL(cwd).href;
+        // Register all built-in servers
+        for (const config of BUILTIN_LSP_SERVERS) {
+            this.servers.set(config.name, { config, client: undefined, state: "stopped" });
+        }
+    }
+    /**
+     * Get or start a language server by name.
+     */
+    async getClient(serverName) {
+        const managed = this.servers.get(serverName);
+        if (!managed)
+            return undefined;
+        if (managed.state === "ready" && managed.client?.isAlive) {
+            return managed.client;
+        }
+        if (managed.state === "starting") {
+            // Wait for it to be ready
+            await new Promise((r) => setTimeout(r, 2000));
+            return managed.client;
+        }
+        // Try to start
+        return this.startServer(serverName);
+    }
+    /**
+     * Start a specific language server.
+     */
+    async startServer(name) {
+        const managed = this.servers.get(name);
+        if (!managed)
+            return undefined;
+        // Check if command is available
+        if (!this.isCommandAvailable(managed.config.command)) {
+            managed.state = "error";
+            managed.error = `${managed.config.command} not found. Install: ${managed.config.installHint}`;
+            return undefined;
+        }
+        managed.state = "starting";
+        try {
+            const client = new LSPClient(managed.config.command, managed.config.args, this.rootUri.replace("file://", ""));
+            await client.start();
+            await client.initialize(this.rootUri);
+            managed.client = client;
+            managed.state = "ready";
+            return client;
+        }
+        catch (err) {
+            managed.state = "error";
+            managed.error = err.message;
+            return undefined;
+        }
+    }
+    /**
+     * Check if any LSP server is connected.
+     */
+    isConnected() {
+        for (const server of this.servers.values()) {
+            if (server.state === "ready" && server.client?.isAlive)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * List server statuses.
+     */
+    listServers() {
+        return [...this.servers.values()].map((s) => ({
+            name: s.config.name,
+            language: s.config.language,
+            state: s.state,
+            error: s.error,
+        }));
+    }
+    /**
+     * Shutdown all servers.
+     */
+    async shutdownAll() {
+        for (const server of this.servers.values()) {
+            if (server.client?.isAlive) {
+                try {
+                    await server.client.shutdown();
+                }
+                catch {
+                    // Force killed
+                }
+            }
+            server.state = "stopped";
+            server.client = undefined;
+        }
+    }
+    isCommandAvailable(command) {
+        try {
+            execSync(`which ${command} 2>/dev/null || where ${command} 2>nul`, {
+                encoding: "utf-8",
+                timeout: 5000,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+// Singleton
+let _manager;
+export function initializeLSPManager(cwd) {
+    _manager = new LSPServerManager(cwd);
+    return _manager;
+}
+export function getLSPManager() {
+    return _manager;
+}

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/lsp/servers.js

@@ -0,0 +1,60 @@
+/**
+ * Built-in language server configurations.
+ */
+export const BUILTIN_LSP_SERVERS = [
+    {
+        name: "typescript",
+        language: "typescript",
+        extensions: [".ts", ".tsx", ".js", ".jsx"],
+        command: "typescript-language-server",
+        args: ["--stdio"],
+        installHint: "npm install -g typescript-language-server typescript",
+    },
+    {
+        name: "python",
+        language: "python",
+        extensions: [".py"],
+        command: "pylsp",
+        args: [],
+        installHint: "pip install python-lsp-server",
+    },
+    {
+        name: "go",
+        language: "go",
+        extensions: [".go"],
+        command: "gopls",
+        args: ["serve"],
+        installHint: "go install golang.org/x/tools/gopls@latest",
+    },
+    {
+        name: "rust",
+        language: "rust",
+        extensions: [".rs"],
+        command: "rust-analyzer",
+        args: [],
+        installHint: "rustup component add rust-analyzer",
+    },
+    {
+        name: "json",
+        language: "json",
+        extensions: [".json"],
+        command: "vscode-json-languageserver",
+        args: ["--stdio"],
+        installHint: "npm install -g vscode-langservers-extracted",
+    },
+    {
+        name: "css",
+        language: "css",
+        extensions: [".css", ".scss", ".less"],
+        command: "vscode-css-languageserver",
+        args: ["--stdio"],
+        installHint: "npm install -g vscode-langservers-extracted",
+    },
+];
+/**
+ * Detect which LSP server to use based on file extension.
+ */
+export function detectLSPServer(filePath) {
+    const ext = filePath.slice(filePath.lastIndexOf("."));
+    return BUILTIN_LSP_SERVERS.find((s) => s.extensions.includes(ext));
+}

package/dist/migrate-models.d.ts

@@ -0,0 +1,45 @@
+/**
+ * One-shot migration of legacy flat models[] into providers[] + models[].
+ *
+ * Pure function — takes a snapshot, returns the new snapshot plus a flag.
+ * The caller (settings load path) is responsible for writing settings.json
+ * and the .bak backup.
+ */
+import type { ProviderConfig } from "./llm/provider-catalog.js";
+interface LegacyModel {
+    key: string;
+    label?: string;
+    provider?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    model: string;
+    maxOutputTokens?: number;
+    maxContextTokens?: number;
+    providerKey?: string;
+}
+export interface MigrationInput {
+    providers: ProviderConfig[];
+    models: LegacyModel[];
+}
+export interface MigrationOutput {
+    providers: ProviderConfig[];
+    models: Array<{
+        key: string;
+        label?: string;
+        providerKey: string;
+        model: string;
+        /**
+         * Self-describing legacy fields. Kept (rather than stripped) so model
+         * entries stay valid standalone — the engine can read credentials
+         * straight off the entry without a ProviderCatalog round-trip.
+         */
+        provider?: string;
+        baseUrl?: string;
+        apiKey?: string;
+        maxOutputTokens?: number;
+        maxContextTokens?: number;
+    }>;
+    changed: boolean;
+}
+export declare function migrateModels(input: MigrationInput): MigrationOutput;
+export {};

package/dist/migrate-models.js

@@ -0,0 +1,179 @@
+/**
+ * One-shot migration of legacy flat models[] into providers[] + models[].
+ *
+ * Pure function — takes a snapshot, returns the new snapshot plus a flag.
+ * The caller (settings load path) is responsible for writing settings.json
+ * and the .bak backup.
+ */
+const BASEURL_KIND_PATTERNS = [
+    [/deepseek\.com/i, "deepseek"],
+    [/z\.ai/i, "zai"],
+    [/anthropic\.com/i, "anthropic"],
+    [/openai\.com/i, "openai"],
+    [/x\.ai/i, "xai"],
+    [/mistral\.ai/i, "mistral"],
+    [/groq\.com/i, "groq"],
+    [/generativelanguage\.googleapis/i, "google"],
+    [/openrouter\.ai/i, "openrouter"],
+    [/localhost:11434|127\.0\.0\.1:11434/i, "ollama"],
+];
+function inferKind(baseUrl) {
+    if (!baseUrl)
+        return "custom";
+    for (const [re, kind] of BASEURL_KIND_PATTERNS) {
+        if (re.test(baseUrl))
+            return kind;
+    }
+    return "custom";
+}
+function makeFingerprint(m) {
+    return `${m.provider ?? ""}|${m.baseUrl ?? ""}|${m.apiKey ?? ""}`;
+}
+function deriveKey(base, used) {
+    if (!used.has(base))
+        return base;
+    for (let i = 2;; i++) {
+        const candidate = `${base}-${i}`;
+        if (!used.has(candidate))
+            return candidate;
+    }
+}
+/**
+ * Generate `<provider>-<model-id>` style pool key. Mirrors the
+ * `deriveModelPoolKey` helper in onboarding.ts — kept inline here to avoid
+ * an import cycle (settings/manager.ts → migrate-models.ts → ...).
+ */
+function deriveProviderModelKey(providerKind, modelId, used) {
+    const slash = modelId.lastIndexOf("/");
+    const base = slash >= 0 ? modelId.slice(slash + 1) : modelId;
+    const prefix = providerKind.toLowerCase();
+    const candidate = base.toLowerCase().startsWith(`${prefix}-`) ? base : `${prefix}-${base}`;
+    if (!used.has(candidate))
+        return candidate;
+    for (let i = 2;; i++) {
+        const k = `${candidate}-${i}`;
+        if (!used.has(k))
+            return k;
+    }
+}
+export function migrateModels(input) {
+    if (input.models.length === 0) {
+        return {
+            providers: input.providers,
+            models: [],
+            changed: false,
+        };
+    }
+    const hasProvidersSection = input.providers.length > 0;
+    // Per-entry check (replaces the old "providers non-empty → skip everything"
+    // shortcut, which left legacy entries from the previous run forever
+    // un-migrated and bleeding key collisions like the two "deepseek" entries
+    // that motivated this rewrite).
+    //   - Needs migration if: no providerKey set, OR
+    //   - Needs migration if: the entry's `key` collides with a sibling (the
+    //     old modelKey() helper folded v4-flash + v4-pro to "deepseek").
+    const keyCounts = new Map();
+    for (const m of input.models)
+        keyCounts.set(m.key, (keyCounts.get(m.key) ?? 0) + 1);
+    const needsMigration = input.models.some((m) => !m.providerKey || (keyCounts.get(m.key) ?? 0) > 1);
+    if (!needsMigration) {
+        return {
+            providers: input.providers,
+            models: input.models.map((m) => ({
+                key: m.key,
+                label: m.label,
+                providerKey: m.providerKey ?? "",
+                model: m.model,
+                maxOutputTokens: m.maxOutputTokens,
+                maxContextTokens: m.maxContextTokens,
+                provider: m.provider,
+                baseUrl: m.baseUrl,
+                apiKey: m.apiKey,
+            })),
+            changed: false,
+        };
+    }
+    // Build providerKey map from fingerprint (provider|baseUrl|apiKey). Each
+    // unique fingerprint becomes one provider entry. Existing providers[] are
+    // preserved; new ones are appended.
+    const fingerprintToKey = new Map();
+    const newProviders = [];
+    const usedProviderKeys = new Set(input.providers.map((p) => p.key));
+    // Pre-seed: if existing providers[] match a model's fingerprint already,
+    // reuse them instead of minting a new key.
+    for (const p of input.providers) {
+        const fp = `${""}|${p.baseUrl}|${p.apiKey ?? ""}`;
+        fingerprintToKey.set(fp, p.key);
+    }
+    for (const m of input.models) {
+        const fp = makeFingerprint(m);
+        // Also try matching against existing providers by baseUrl only — the
+        // legacy "provider" field on models is a generic kind ("openai") that
+        // doesn't disambiguate, so the fingerprint above won't match if the
+        // user added the provider via the wizard but kept legacy model entries.
+        const existingByUrl = input.providers.find((p) => p.baseUrl === (m.baseUrl ?? ""));
+        if (existingByUrl) {
+            fingerprintToKey.set(fp, existingByUrl.key);
+            continue;
+        }
+        if (fingerprintToKey.has(fp))
+            continue;
+        const kind = inferKind(m.baseUrl);
+        const key = deriveKey(kind, usedProviderKeys);
+        usedProviderKeys.add(key);
+        fingerprintToKey.set(fp, key);
+        newProviders.push({
+            key,
+            kind,
+            baseUrl: m.baseUrl ?? "",
+            apiKey: m.apiKey,
+        });
+    }
+    // Re-key models: any entry whose key collides with a sibling gets a fresh
+    // `<provider>-<model-id>` key. Entries that already have a unique key are
+    // left alone so user-customized aliases survive migration.
+    const usedModelKeys = new Set();
+    const newModels = input.models.map((m) => {
+        const providerKey = fingerprintToKey.get(makeFingerprint(m));
+        const collides = (keyCounts.get(m.key) ?? 0) > 1;
+        let key = m.key;
+        if (collides) {
+            const kind = inferKind(m.baseUrl);
+            key = deriveProviderModelKey(kind, m.model, usedModelKeys);
+        }
+        if (usedModelKeys.has(key)) {
+            // Defensive: if the user's original key happens to collide with a
+            // freshly minted one, re-derive too.
+            const kind = inferKind(m.baseUrl);
+            key = deriveProviderModelKey(kind, m.model, usedModelKeys);
+        }
+        usedModelKeys.add(key);
+        return {
+            key,
+            label: m.label,
+            providerKey,
+            provider: m.provider,
+            model: m.model,
+            baseUrl: m.baseUrl,
+            apiKey: m.apiKey,
+            maxOutputTokens: m.maxOutputTokens,
+            maxContextTokens: m.maxContextTokens,
+        };
+    });
+    // De-duplicate: if migration produced two entries with the same key + model
+    // (e.g. legacy duplicate that re-keys to the same canonical form), keep
+    // only the first.
+    const seen = new Set();
+    const deduped = newModels.filter((m) => {
+        const fp = `${m.key}|${m.model}`;
+        if (seen.has(fp))
+            return false;
+        seen.add(fp);
+        return true;
+    });
+    return {
+        providers: hasProvidersSection ? [...input.providers, ...newProviders] : newProviders,
+        models: deduped,
+        changed: true,
+    };
+}