@minko-ai/minko 0.1.0 → 0.1.1

package/dist/lsp/client.js

@@ -0,0 +1,340 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { decodeOutput } from "../tools/shell.js";
+const INIT_TIMEOUT_MS = 15_000;
+const REQUEST_TIMEOUT_MS = 20_000;
+/** Minimal LSP client using Content-Length framed JSON-RPC over stdio. */
+export class LspClient {
+    options;
+    child = null;
+    buffer = Buffer.alloc(0);
+    nextId = 0;
+    pending = new Map();
+    documents = new Set();
+    stderr = '';
+    closed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        const launch = chooseSpawn(this.options.command);
+        const child = spawn(launch.command, this.options.args ?? [], {
+            cwd: this.options.cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+            shell: launch.shell,
+        });
+        this.child = child;
+        child.stdout.on('data', (chunk) => this.onData(chunk));
+        child.stderr.on('data', (chunk) => {
+            // cmd.exe writes its own errors in the console code page (GBK on zh-CN).
+            this.stderr = (this.stderr + decodeOutput(chunk)).slice(-4_000);
+        });
+        child.stdin.on('error', () => { });
+        child.on('error', (error) => this.failAll('LSP 进程启动失败：' + error.message));
+        child.on('exit', (code) => {
+            if (!this.closed) {
+                const detail = this.stderr.trim();
+                this.failAll('LSP 进程退出（code ' + String(code) + '）' + (detail ? '：' + detail : ''));
+            }
+        });
+        const rootUri = pathToFileURL(this.options.cwd).href;
+        await this.request('initialize', {
+            processId: process.pid,
+            rootUri,
+            capabilities: {
+                textDocument: {
+                    definition: {},
+                    references: {},
+                    hover: {},
+                    documentSymbol: {},
+                },
+            },
+            workspaceFolders: [{ uri: rootUri, name: path.basename(this.options.cwd) || 'workspace' }],
+        }, INIT_TIMEOUT_MS);
+        this.notify('initialized', {});
+    }
+    async openDocument(file, languageId) {
+        const resolved = path.resolve(file);
+        if (this.documents.has(resolved)) {
+            return;
+        }
+        const text = await fs.promises.readFile(resolved, 'utf8');
+        const uri = pathToFileURL(resolved).href;
+        this.documents.add(resolved);
+        this.notify('textDocument/didOpen', {
+            textDocument: { uri, languageId, version: 1, text },
+        });
+    }
+    async definition(file, languageId, line, column) {
+        await this.openDocument(file, languageId);
+        const result = await this.request('textDocument/definition', {
+            textDocument: { uri: pathToFileURL(path.resolve(file)).href },
+            position: { line: Math.max(0, line - 1), character: Math.max(0, column - 1) },
+        });
+        return normalizeLocations(result);
+    }
+    async references(file, languageId, line, column) {
+        await this.openDocument(file, languageId);
+        const result = await this.request('textDocument/references', {
+            textDocument: { uri: pathToFileURL(path.resolve(file)).href },
+            position: { line: Math.max(0, line - 1), character: Math.max(0, column - 1) },
+            context: { includeDeclaration: true },
+        });
+        return normalizeLocations(result);
+    }
+    async hover(file, languageId, line, column) {
+        await this.openDocument(file, languageId);
+        const result = await this.request('textDocument/hover', {
+            textDocument: { uri: pathToFileURL(path.resolve(file)).href },
+            position: { line: Math.max(0, line - 1), character: Math.max(0, column - 1) },
+        });
+        if (result === null || typeof result !== 'object') {
+            return '';
+        }
+        return renderHover(result.contents);
+    }
+    async symbols(file, languageId) {
+        await this.openDocument(file, languageId);
+        const result = await this.request('textDocument/documentSymbol', {
+            textDocument: { uri: pathToFileURL(path.resolve(file)).href },
+        });
+        return flattenSymbols(result);
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        try {
+            await this.request('shutdown', null, 2_000);
+        }
+        catch {
+            // The server may already be gone.
+        }
+        this.closed = true;
+        try {
+            this.notify('exit', null);
+        }
+        catch { /* ignore */ }
+        const child = this.child;
+        this.child = null;
+        if (child) {
+            try {
+                child.kill();
+            }
+            catch { /* already gone */ }
+        }
+        this.failAll('LSP 已关闭');
+    }
+    request(method, params, timeoutMs = REQUEST_TIMEOUT_MS) {
+        if (!this.child || this.closed) {
+            return Promise.reject(new Error('LSP 未连接'));
+        }
+        const id = this.nextId + 1;
+        this.nextId = id;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error('LSP 请求超时：' + method));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.write({ jsonrpc: '2.0', id, method, params });
+        });
+    }
+    notify(method, params) {
+        this.write({ jsonrpc: '2.0', method, params });
+    }
+    write(message) {
+        const child = this.child;
+        if (!child || this.closed || !child.stdin) {
+            return;
+        }
+        const body = JSON.stringify(message);
+        child.stdin.write('Content-Length: ' + Buffer.byteLength(body, 'utf8') + '\r\n\r\n' + body);
+    }
+    onData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        for (;;) {
+            const headerEnd = this.buffer.indexOf('\r\n\r\n');
+            if (headerEnd < 0) {
+                return;
+            }
+            const header = this.buffer.subarray(0, headerEnd).toString('utf8');
+            const match = /Content-Length:\s*(\d+)/i.exec(header);
+            if (!match) {
+                this.buffer = this.buffer.subarray(headerEnd + 4);
+                continue;
+            }
+            const length = Number(match[1]);
+            const start = headerEnd + 4;
+            if (this.buffer.length < start + length) {
+                return;
+            }
+            const body = this.buffer.subarray(start, start + length).toString('utf8');
+            this.buffer = this.buffer.subarray(start + length);
+            this.onMessage(body);
+        }
+    }
+    onMessage(body) {
+        let message;
+        try {
+            message = JSON.parse(body);
+        }
+        catch {
+            return;
+        }
+        if (typeof message.id === 'number' && this.pending.has(message.id)) {
+            const entry = this.pending.get(message.id);
+            if (!entry) {
+                return;
+            }
+            this.pending.delete(message.id);
+            clearTimeout(entry.timer);
+            if (message.error) {
+                entry.reject(new Error('LSP 错误：' + message.error.message));
+            }
+            else {
+                entry.resolve(message.result);
+            }
+            return;
+        }
+        // Server-to-client request: answer so it does not hang.
+        if (message.method !== undefined && message.id !== undefined) {
+            this.write({
+                jsonrpc: '2.0',
+                id: message.id,
+                error: { code: -32601, message: 'method not found' },
+            });
+        }
+    }
+    failAll(message) {
+        for (const [id, entry] of this.pending) {
+            clearTimeout(entry.timer);
+            entry.reject(new Error(message));
+            this.pending.delete(id);
+        }
+    }
+}
+function normalizeLocations(value) {
+    const items = Array.isArray(value) ? value : value ? [value] : [];
+    const locations = [];
+    for (const item of items) {
+        if (item === null || typeof item !== 'object') {
+            continue;
+        }
+        const record = item;
+        const uri = typeof record.uri === 'string'
+            ? record.uri
+            : typeof record.targetUri === 'string' ? record.targetUri : '';
+        const range = record.range ?? record.targetSelectionRange ?? record.targetRange;
+        if (uri.length === 0 || range === null || typeof range !== 'object') {
+            continue;
+        }
+        const start = range.start;
+        const end = range.end;
+        const startRecord = start !== null && typeof start === 'object'
+            ? start : {};
+        const endRecord = end !== null && typeof end === 'object'
+            ? end : {};
+        locations.push({
+            path: uriToPath(uri),
+            line: numberOr(startRecord.line, 0) + 1,
+            column: numberOr(startRecord.character, 0) + 1,
+            endLine: numberOr(endRecord.line, 0) + 1,
+            endColumn: numberOr(endRecord.character, 0) + 1,
+        });
+    }
+    return locations;
+}
+function flattenSymbols(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const symbols = [];
+    const walk = (items) => {
+        for (const item of items) {
+            if (item === null || typeof item !== 'object') {
+                continue;
+            }
+            const record = item;
+            if (typeof record.name === 'string') {
+                const range = record.selectionRange ?? record.range ?? record.location;
+                let line = 1;
+                let column = 1;
+                if (range !== null && typeof range === 'object') {
+                    const rangeRecord = range;
+                    const start = rangeRecord.start;
+                    const location = rangeRecord.range;
+                    if (start !== null && typeof start === 'object') {
+                        const startRecord = start;
+                        line = numberOr(startRecord.line, 0) + 1;
+                        column = numberOr(startRecord.character, 0) + 1;
+                    }
+                    else if (location !== null && typeof location === 'object') {
+                        const locationRecord = location;
+                        const locationStart = locationRecord.start;
+                        if (locationStart !== null && typeof locationStart === 'object') {
+                            const startRecord = locationStart;
+                            line = numberOr(startRecord.line, 0) + 1;
+                            column = numberOr(startRecord.character, 0) + 1;
+                        }
+                    }
+                }
+                symbols.push({
+                    name: record.name,
+                    kind: numberOr(record.kind, 0),
+                    line,
+                    column,
+                });
+            }
+            if (Array.isArray(record.children)) {
+                walk(record.children);
+            }
+        }
+    };
+    walk(value);
+    return symbols;
+}
+function renderHover(contents) {
+    if (typeof contents === 'string') {
+        return contents.trim();
+    }
+    if (Array.isArray(contents)) {
+        return contents.map((item) => renderHover(item)).filter((item) => item.length > 0).join('\n');
+    }
+    if (contents !== null && typeof contents === 'object') {
+        const record = contents;
+        if (typeof record.value === 'string') {
+            return record.value.trim();
+        }
+    }
+    return '';
+}
+function uriToPath(uri) {
+    if (!uri.startsWith('file://')) {
+        return uri;
+    }
+    try {
+        return fileURLToPath(uri);
+    }
+    catch {
+        return uri;
+    }
+}
+function numberOr(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function chooseSpawn(command) {
+    if (process.platform !== 'win32') {
+        return { command, shell: false };
+    }
+    if (/\.(cmd|bat)$/i.test(command)) {
+        return { command, shell: true };
+    }
+    if (!command.includes('/') && !command.includes('\\')) {
+        return { command, shell: true };
+    }
+    return { command, shell: false };
+}

package/dist/lsp/tool.js

@@ -0,0 +1,177 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { LspClient } from "./client.js";
+const clients = new Map();
+const DEFAULT_SERVERS = {
+    typescript: { command: 'typescript-language-server', args: ['--stdio'] },
+    javascript: { command: 'typescript-language-server', args: ['--stdio'] },
+    python: { command: 'pyright-langserver', args: ['--stdio'] },
+    rust: { command: 'rust-analyzer', args: [] },
+    go: { command: 'gopls', args: [] },
+};
+const INSTALL_HINTS = {
+    typescript: 'npm install -g typescript-language-server typescript',
+    javascript: 'npm install -g typescript-language-server typescript',
+    python: 'npm install -g pyright（或 pip install pyright）',
+    rust: 'rustup component add rust-analyzer',
+    go: 'go install golang.org/x/tools/gopls@latest',
+};
+/**
+ * Code navigation through a language server. Read-only and safe for plan mode
+ * and workers. Servers are started lazily and reused per workspace/language.
+ */
+export const lspTool = {
+    readOnly: true,
+    spec: {
+        name: 'lsp',
+        description: '用语言服务器查定义、引用、悬停信息和文件符号。需要可用的 language server；可在 lsp.servers 配置命令。',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['definition', 'references', 'hover', 'symbols'],
+                },
+                path: { type: 'string', description: '文件路径，相对于工作目录' },
+                line: { type: 'number', description: '1-based 行号' },
+                column: { type: 'number', description: '1-based 列号' },
+            },
+            required: ['action', 'path'],
+            additionalProperties: false,
+        },
+    },
+    async run(args, ctx) {
+        const action = typeof args.action === 'string' ? args.action : '';
+        const rawPath = typeof args.path === 'string' ? args.path.trim() : '';
+        if (rawPath.length === 0) {
+            throw new Error('缺少 path 参数');
+        }
+        const file = path.resolve(ctx.cwd, rawPath);
+        if (!fs.existsSync(file)) {
+            throw new Error('文件不存在：' + rawPath);
+        }
+        const languageId = languageIdFor(file);
+        if (!languageId) {
+            throw new Error('不支持的语言：' + path.extname(file)
+                + '（可在 ~/.minko/config.json 的 lsp.servers 配置）');
+        }
+        const server = ctx.config?.lsp?.servers?.[languageId] ?? DEFAULT_SERVERS[languageId];
+        if (!server) {
+            throw new Error('没有为 ' + languageId + ' 配置语言服务器（lsp.servers）');
+        }
+        const client = await lspClient(server, languageId, ctx.cwd);
+        const line = positiveInt(args.line, 0);
+        const column = positiveInt(args.column, 0);
+        if (action === 'symbols') {
+            const symbols = await client.symbols(file, languageId);
+            return formatSymbols(symbols, displayPath(ctx.cwd, file));
+        }
+        if (action !== 'definition' && action !== 'references' && action !== 'hover') {
+            throw new Error('不支持的操作：' + action);
+        }
+        if (line === 0) {
+            throw new Error('这个操作需要 line 和 column（从 1 开始）');
+        }
+        if (action === 'definition') {
+            const locations = await client.definition(file, languageId, line, column || 1);
+            return locations.length === 0
+                ? '没有找到定义。'
+                : '定义位置：\n' + formatLocations(locations, ctx.cwd);
+        }
+        if (action === 'references') {
+            const locations = await client.references(file, languageId, line, column || 1);
+            return locations.length === 0
+                ? '没有找到引用。'
+                : '引用（' + locations.length + '）：\n' + formatLocations(locations, ctx.cwd);
+        }
+        const hover = await client.hover(file, languageId, line, column || 1);
+        return hover.length === 0 ? '没有悬停信息。' : '悬停信息：\n' + hover;
+    },
+};
+/** Closes every language server started in this process. */
+export async function closeLspClients() {
+    const all = [...clients.values()];
+    clients.clear();
+    await Promise.all(all.map((client) => client.close().catch(() => { })));
+}
+async function lspClient(server, languageId, cwd) {
+    const key = path.resolve(cwd) + '|' + languageId + '|' + server.command + '|'
+        + (server.args ?? []).join(' ');
+    const existing = clients.get(key);
+    if (existing) {
+        return existing;
+    }
+    // Spawning through cmd.exe on Windows makes a missing server look like a
+    // crashed one ("不是内部或外部命令"). Check first and give an install hint.
+    if (!commandExists(server.command)) {
+        throw new Error('没有找到语言服务器 ' + server.command + '。安装：'
+            + (INSTALL_HINTS[languageId] ?? '请安装 ' + languageId + ' 的 language server')
+            + '；或在 ~/.minko/config.json 的 lsp.servers 里指定 command。');
+    }
+    const client = new LspClient({ ...server, cwd });
+    try {
+        await client.start();
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error('启动 LSP 失败（' + server.command + '）：' + reason
+            + '。可在 ~/.minko/config.json 的 lsp.servers 配置命令。');
+    }
+    clients.set(key, client);
+    return client;
+}
+function commandExists(command) {
+    if (/[\\/]/.test(command)) {
+        return fs.existsSync(command);
+    }
+    const probe = process.platform === 'win32' ? 'where.exe' : 'which';
+    const result = spawnSync(probe, [command], { stdio: 'ignore', windowsHide: true });
+    return result.status === 0;
+}
+function languageIdFor(file) {
+    switch (path.extname(file).toLowerCase()) {
+        case '.ts':
+        case '.tsx':
+        case '.mts':
+        case '.cts':
+            return 'typescript';
+        case '.js':
+        case '.jsx':
+        case '.mjs':
+        case '.cjs':
+            return 'javascript';
+        case '.py':
+        case '.pyi':
+            return 'python';
+        case '.rs':
+            return 'rust';
+        case '.go':
+            return 'go';
+        default:
+            return null;
+    }
+}
+function formatLocations(locations, cwd) {
+    return locations.map((location) => '- ' + displayPath(cwd, location.path)
+        + ':' + location.line + ':' + location.column).join('\n');
+}
+function formatSymbols(symbols, file) {
+    if (symbols.length === 0) {
+        return '没有找到符号。';
+    }
+    return '符号（' + symbols.length + '）：\n'
+        + symbols.map((symbol) => '- ' + symbol.name + ' (kind ' + symbol.kind + ') @ '
+            + file + ':' + symbol.line + ':' + symbol.column).join('\n');
+}
+function displayPath(cwd, file) {
+    const relative = path.relative(path.resolve(cwd), file);
+    const shown = relative.length > 0 && !relative.startsWith('..') ? relative : file;
+    return shown.split(path.sep).join('/');
+}
+function positiveInt(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0
+        ? Math.floor(value)
+        : fallback;
+}