@cjhyy/code-shell-capability-coding 0.8.0

package/dist/tools/lsp.d.ts

@@ -0,0 +1,6 @@
+/**
+ * LSPTool — language server protocol operations for code intelligence.
+ */
+import type { ToolContext, ToolDefinition } from "@cjhyy/code-shell-core/extension";
+export declare const lspToolDef: ToolDefinition;
+export declare function lspTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/tools/lsp.js

@@ -0,0 +1,220 @@
+/**
+ * LSPTool — language server protocol operations for code intelligence.
+ */
+import { getLSPManager } from "../lsp/manager.js";
+import { detectLSPServer } from "../lsp/servers.js";
+import { pathToFileURL } from "node:url";
+import { isAbsolute, resolve } from "node:path";
+/**
+ * How long to wait for `textDocument/publishDiagnostics` after opening a file.
+ *
+ * A cold server has to index the project first, so this is a deadline rather
+ * than an expected duration — timing out reports "still indexing" instead of
+ * silently claiming the file is clean.
+ */
+const DIAGNOSTICS_TIMEOUT_MS = 10_000;
+const DIAGNOSTIC_SEVERITY = {
+    1: "error",
+    2: "warning",
+    3: "info",
+    4: "hint",
+};
+export const lspToolDef = {
+    name: "LSP",
+    description: "Use Language Server Protocol for code intelligence operations. " +
+        "Available actions: goToDefinition, findReferences, hover, getDiagnostics, getSymbols. " +
+        "Requires a language server to be installed for the target language.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                enum: ["goToDefinition", "findReferences", "hover", "getDiagnostics", "getSymbols"],
+                description: "The LSP operation to perform",
+            },
+            file_path: {
+                type: "string",
+                description: "Absolute path to the file",
+            },
+            line: {
+                type: "number",
+                description: "Line number (0-based). Required for goToDefinition, findReferences, hover.",
+            },
+            character: {
+                type: "number",
+                description: "Character offset (0-based). Required for goToDefinition, findReferences, hover.",
+            },
+        },
+        required: ["action", "file_path"],
+    },
+};
+export async function lspTool(args, ctx) {
+    const action = args.action;
+    const rawPath = args.file_path;
+    const line = args.line ?? 0;
+    const character = args.character ?? 0;
+    if (!rawPath)
+        return "Error: file_path is required";
+    const cwd = ctx?.cwd ?? process.cwd();
+    const filePath = isAbsolute(rawPath) ? rawPath : resolve(cwd, rawPath);
+    // Lazily create the manager for THIS workspace. Previously this read a
+    // process-wide singleton that no host ever initialized, so the tool was
+    // advertised to the agent but always answered "LSP is not initialized".
+    const manager = getLSPManager(cwd);
+    if (!manager)
+        return "Error: LSP is not initialized. Language servers are not available.";
+    // Detect the appropriate server
+    const serverConfig = detectLSPServer(filePath);
+    if (!serverConfig)
+        return `Error: No language server configured for ${filePath}`;
+    const client = await manager.getClient(serverConfig.name);
+    if (!client) {
+        return `Error: Language server "${serverConfig.name}" is not available. Install: ${serverConfig.installHint}`;
+    }
+    const uri = pathToFileURL(filePath).href;
+    const position = { line, character };
+    try {
+        switch (action) {
+            case "goToDefinition": {
+                const result = await client.request("textDocument/definition", {
+                    textDocument: { uri },
+                    position,
+                });
+                return formatLocationResult(result, "Definition");
+            }
+            case "findReferences": {
+                const result = await client.request("textDocument/references", {
+                    textDocument: { uri },
+                    position,
+                    context: { includeDeclaration: true },
+                });
+                return formatLocationResult(result, "References");
+            }
+            case "hover": {
+                const result = (await client.request("textDocument/hover", {
+                    textDocument: { uri },
+                    position,
+                }));
+                if (!result)
+                    return "No hover information available.";
+                const content = typeof result.contents === "string"
+                    ? result.contents
+                    : (result.contents?.value ?? JSON.stringify(result.contents));
+                return `Hover:\n${content}`;
+            }
+            case "getDiagnostics": {
+                // Collect the ACTUAL diagnostics for this file.
+                //
+                // This used to open the document, sleep 2s, and return "Diagnostics
+                // requested. Check LSP notifications for results." — nobody was
+                // subscribed to those notifications, so the agent got a status string
+                // and never any findings. Subscribe first, then open, then wait for the
+                // matching publishDiagnostics (with a deadline, since a clean file may
+                // legitimately produce none).
+                const { readFileSync } = await import("node:fs");
+                const text = readFileSync(filePath, "utf-8");
+                const diagnostics = await new Promise((resolveWait) => {
+                    let settled = false;
+                    const finish = (value) => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        client.off?.("notification", onNotification);
+                        clearTimeout(timer);
+                        resolveWait(value);
+                    };
+                    const onNotification = (message) => {
+                        if (message?.method !== "textDocument/publishDiagnostics")
+                            return;
+                        const params = message.params;
+                        // Servers report per-URI; ignore other files opened in the session.
+                        if (params?.uri !== uri)
+                            return;
+                        finish(params.diagnostics ?? []);
+                    };
+                    const timer = setTimeout(() => finish(undefined), DIAGNOSTICS_TIMEOUT_MS);
+                    client.on?.("notification", onNotification);
+                    void client.notify("textDocument/didOpen", {
+                        textDocument: { uri, languageId: serverConfig.language, version: 1, text },
+                    });
+                });
+                if (diagnostics === undefined) {
+                    return `No diagnostics published within ${DIAGNOSTICS_TIMEOUT_MS}ms. The server may still be indexing.`;
+                }
+                if (diagnostics.length === 0)
+                    return "No diagnostics — the file is clean.";
+                const lines = diagnostics.slice(0, 100).map((diagnostic) => {
+                    const severity = DIAGNOSTIC_SEVERITY[diagnostic.severity ?? 1] ?? "info";
+                    const start = diagnostic.range?.start;
+                    const at = start ? `${start.line + 1}:${start.character + 1}` : "?";
+                    const source = diagnostic.source ? ` [${diagnostic.source}]` : "";
+                    return `  ${severity} ${at}${source} ${diagnostic.message}`;
+                });
+                const more = diagnostics.length > 100 ? `\n  … ${diagnostics.length - 100} more` : "";
+                return `Diagnostics (${diagnostics.length}):\n${lines.join("\n")}${more}`;
+            }
+            case "getSymbols": {
+                const result = (await client.request("textDocument/documentSymbol", {
+                    textDocument: { uri },
+                }));
+                if (!result?.length)
+                    return "No symbols found.";
+                const lines = result.map((s) => {
+                    const kind = SYMBOL_KINDS[s.kind] ?? `kind:${s.kind}`;
+                    const range = s.range ?? s.location?.range;
+                    const loc = range ? `:${range.start.line + 1}` : "";
+                    return `  ${kind} ${s.name}${loc}`;
+                });
+                return `Symbols in ${filePath}:\n${lines.join("\n")}`;
+            }
+            default:
+                return `Unknown action: ${action}`;
+        }
+    }
+    catch (err) {
+        return `LSP error: ${err.message}`;
+    }
+}
+function formatLocationResult(result, label) {
+    if (!result)
+        return `No ${label.toLowerCase()} found.`;
+    const locations = Array.isArray(result) ? result : [result];
+    if (locations.length === 0)
+        return `No ${label.toLowerCase()} found.`;
+    const lines = locations.map((loc) => {
+        const uri = loc.uri ?? loc.targetUri ?? "";
+        const range = loc.range ?? loc.targetRange ?? {};
+        const path = uri.replace("file://", "");
+        const line = (range.start?.line ?? 0) + 1;
+        return `  ${path}:${line}`;
+    });
+    return `${label} (${locations.length}):\n${lines.join("\n")}`;
+}
+const SYMBOL_KINDS = {
+    1: "File",
+    2: "Module",
+    3: "Namespace",
+    4: "Package",
+    5: "Class",
+    6: "Method",
+    7: "Property",
+    8: "Field",
+    9: "Constructor",
+    10: "Enum",
+    11: "Interface",
+    12: "Function",
+    13: "Variable",
+    14: "Constant",
+    15: "String",
+    16: "Number",
+    17: "Boolean",
+    18: "Array",
+    19: "Object",
+    20: "Key",
+    21: "Null",
+    22: "EnumMember",
+    23: "Struct",
+    24: "Event",
+    25: "Operator",
+    26: "TypeParameter",
+};

package/dist/tools/notebook-edit.d.ts

@@ -0,0 +1,6 @@
+/**
+ * NotebookEditTool — read and edit Jupyter notebook (.ipynb) cells.
+ */
+import type { ToolContext, ToolDefinition } from "@cjhyy/code-shell-core/extension";
+export declare const notebookEditToolDef: ToolDefinition;
+export declare function notebookEditTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/tools/notebook-edit.js

@@ -0,0 +1,127 @@
+/**
+ * NotebookEditTool — read and edit Jupyter notebook (.ipynb) cells.
+ */
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+export const notebookEditToolDef = {
+    name: "NotebookEdit",
+    description: "Edit a Jupyter notebook (.ipynb) file. Supports actions: " +
+        "'read' to view cells, 'insert' to add a cell, 'replace' to update a cell, " +
+        "'delete' to remove a cell.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            file_path: {
+                type: "string",
+                description: "Path to the .ipynb file",
+            },
+            action: {
+                type: "string",
+                enum: ["read", "insert", "replace", "delete"],
+                description: "Operation to perform",
+            },
+            cell_index: {
+                type: "number",
+                description: "Cell index (0-based). Required for replace and delete.",
+            },
+            cell_type: {
+                type: "string",
+                enum: ["code", "markdown", "raw"],
+                description: "Cell type for insert/replace (default: 'code')",
+            },
+            source: {
+                type: "string",
+                description: "Cell content for insert/replace",
+            },
+        },
+        required: ["file_path", "action"],
+    },
+};
+export async function notebookEditTool(args, ctx) {
+    const rawPath = args.file_path;
+    const action = args.action;
+    if (!rawPath)
+        return "Error: file_path is required";
+    const cwd = ctx?.cwd ?? process.cwd();
+    const filePath = isAbsolute(rawPath) ? rawPath : resolve(cwd, rawPath);
+    if (!filePath.endsWith(".ipynb"))
+        return "Error: file must be a .ipynb file";
+    if (action === "read") {
+        if (!existsSync(filePath))
+            return `Error: File not found: ${filePath}`;
+        const nb = readNotebook(filePath);
+        const lines = [`Notebook: ${filePath} (${nb.cells.length} cells)\n`];
+        nb.cells.forEach((cell, i) => {
+            const source = cell.source.join("");
+            const preview = source.slice(0, 200);
+            lines.push(`[${i}] ${cell.cell_type}: ${preview}${source.length > 200 ? "..." : ""}`);
+        });
+        return lines.join("\n");
+    }
+    if (action === "insert") {
+        const nb = existsSync(filePath) ? readNotebook(filePath) : createEmptyNotebook();
+        const cellType = args.cell_type ?? "code";
+        const source = args.source ?? "";
+        const index = args.cell_index ?? nb.cells.length;
+        const newCell = createCell(cellType, source);
+        nb.cells.splice(index, 0, newCell);
+        writeNotebook(filePath, nb);
+        return `Inserted ${cellType} cell at index ${index}.`;
+    }
+    if (action === "replace") {
+        if (!existsSync(filePath))
+            return `Error: File not found: ${filePath}`;
+        const nb = readNotebook(filePath);
+        const index = args.cell_index;
+        if (index === undefined || index < 0 || index >= nb.cells.length) {
+            return `Error: Invalid cell_index ${index}. Notebook has ${nb.cells.length} cells.`;
+        }
+        const cellType = args.cell_type ?? nb.cells[index].cell_type;
+        const source = args.source ?? "";
+        nb.cells[index] = createCell(cellType, source);
+        writeNotebook(filePath, nb);
+        return `Replaced cell ${index} with ${cellType} cell.`;
+    }
+    if (action === "delete") {
+        if (!existsSync(filePath))
+            return `Error: File not found: ${filePath}`;
+        const nb = readNotebook(filePath);
+        const index = args.cell_index;
+        if (index === undefined || index < 0 || index >= nb.cells.length) {
+            return `Error: Invalid cell_index ${index}. Notebook has ${nb.cells.length} cells.`;
+        }
+        nb.cells.splice(index, 1);
+        writeNotebook(filePath, nb);
+        return `Deleted cell ${index}. Notebook now has ${nb.cells.length} cells.`;
+    }
+    return `Unknown action: ${action}`;
+}
+function readNotebook(filePath) {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+}
+function writeNotebook(filePath, nb) {
+    writeFileSync(filePath, JSON.stringify(nb, null, 1) + "\n", "utf-8");
+}
+function createEmptyNotebook() {
+    return {
+        cells: [],
+        metadata: {
+            kernelspec: { display_name: "Python 3", language: "python", name: "python3" },
+            language_info: { name: "python", version: "3.10.0" },
+        },
+        nbformat: 4,
+        nbformat_minor: 5,
+    };
+}
+function createCell(type, source) {
+    const cell = {
+        cell_type: type,
+        source: source.split("\n").map((line, i, arr) => (i < arr.length - 1 ? line + "\n" : line)),
+        metadata: {},
+    };
+    if (type === "code") {
+        cell.outputs = [];
+        cell.execution_count = null;
+    }
+    return cell;
+}

package/dist/tools/worktree.d.ts

@@ -0,0 +1,10 @@
+/**
+ * EnterWorktree / ExitWorktree tools — switch a session between git workspaces.
+ */
+import type { ToolContext, ToolDefinition } from "@cjhyy/code-shell-core/extension";
+export declare const switchSessionWorkspaceToolDef: ToolDefinition;
+export declare function switchSessionWorkspaceTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
+export declare const enterWorktreeToolDef: ToolDefinition;
+export declare function enterWorktreeTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
+export declare const exitWorktreeToolDef: ToolDefinition;
+export declare function exitWorktreeTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;