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

package/dist/tool-system/builtin/grep.js

@@ -0,0 +1,150 @@
+/**
+ * Built-in Grep content search tool.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { resolve, sep, isAbsolute } from "node:path";
+const execFileAsync = promisify(execFile);
+/**
+ * Strip the cwd prefix from each line so results display as relative
+ * paths (e.g. "src/ui/App.tsx" instead of an absolute path). Lines that
+ * don't start with the cwd are left untouched.
+ */
+function relativizeOutput(stdout, cwd) {
+    const root = resolve(cwd);
+    const prefix = root.endsWith(sep) ? root : root + sep;
+    return stdout
+        .split("\n")
+        .map((line) => (line.startsWith(prefix) ? line.slice(prefix.length) : line))
+        .join("\n");
+}
+/** rg and grep exit with code 1 when no matches found — that's not an error */
+function isNoMatchExit(err) {
+    const e = err;
+    return e?.code === 1 && (!e.stdout || e.stdout.trim() === "");
+}
+export const grepToolDef = {
+    name: "Grep",
+    description: "Search file contents using regex patterns. Uses ripgrep (rg) if available, falls back to grep. " +
+        "Default output_mode is 'files_with_matches' which only returns file paths — use this for broad searches. " +
+        "Use output_mode 'content' to see matching lines with context.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            pattern: { type: "string", description: "Regular expression pattern to search for" },
+            path: { type: "string", description: "File or directory to search in (default: cwd)" },
+            glob: { type: "string", description: 'Glob pattern to filter files (e.g. "*.ts")' },
+            context: { type: "number", description: "Lines of context around matches (only with output_mode content)" },
+            max_results: { type: "number", description: "Maximum number of results (default: 50)" },
+            output_mode: {
+                type: "string",
+                description: 'Output mode: "files_with_matches" (default, just file paths), "content" (matching lines), "count" (match counts per file)',
+            },
+            case_insensitive: { type: "boolean", description: "Case-insensitive search" },
+        },
+        required: ["pattern"],
+    },
+};
+export async function grepTool(args, ctx) {
+    const pattern = args.pattern;
+    if (!pattern)
+        return "Error: pattern is required";
+    // A4: resolve search path against ctx.cwd. Relative args.path is
+    // resolved against ctx.cwd; absolute args.path is used as-is.
+    const baseDir = ctx?.cwd ?? process.cwd();
+    const argPath = args.path;
+    const searchPath = argPath
+        ? isAbsolute(argPath)
+            ? argPath
+            : resolve(baseDir, argPath)
+        : baseDir;
+    const fileGlob = args.glob;
+    const context = args.context || 0;
+    const maxResults = args.max_results || 50;
+    const outputMode = args.output_mode || "files_with_matches";
+    const caseInsensitive = args.case_insensitive || false;
+    try {
+        return await runRipgrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive);
+    }
+    catch (rgErr) {
+        // rg/grep exit code 1 = no matches (not an error)
+        if (isNoMatchExit(rgErr))
+            return "No matches found.";
+        try {
+            return await runGrep(pattern, searchPath, context, maxResults, outputMode, caseInsensitive);
+        }
+        catch (grepErr) {
+            if (isNoMatchExit(grepErr))
+                return "No matches found.";
+            return `Error in search: ${grepErr.message}`;
+        }
+    }
+}
+async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive) {
+    const args = ["--color=never"];
+    if (caseInsensitive)
+        args.push("-i");
+    if (outputMode === "files_with_matches") {
+        args.push("--files-with-matches");
+    }
+    else if (outputMode === "count") {
+        args.push("--count");
+    }
+    else {
+        // content mode
+        args.push("--line-number", "--no-heading");
+        if (context > 0)
+            args.push("-C", String(context));
+    }
+    args.push("-m", String(maxResults));
+    if (fileGlob)
+        args.push("--glob", fileGlob);
+    // Ignore common non-source dirs
+    args.push("--glob", "!node_modules", "--glob", "!.git", "--glob", "!dist", "--glob", "!coverage");
+    args.push("--", pattern, path);
+    const { stdout } = await execFileAsync("rg", args, {
+        maxBuffer: 10 * 1024 * 1024,
+        timeout: 30_000,
+    });
+    const result = relativizeOutput(stdout, path).trim();
+    if (!result)
+        return "No matches found.";
+    // Limit output lines
+    const lines = result.split("\n");
+    if (lines.length > 200) {
+        return lines.slice(0, 200).join("\n") + `\n\n... ${lines.length - 200} more results`;
+    }
+    return result;
+}
+async function runGrep(pattern, path, context, maxResults, outputMode, caseInsensitive) {
+    const args = ["-r", "--color=never"];
+    if (caseInsensitive)
+        args.push("-i");
+    if (outputMode === "files_with_matches") {
+        args.push("-l");
+    }
+    else if (outputMode === "count") {
+        args.push("-c");
+    }
+    else {
+        args.push("-n");
+        if (context > 0)
+            args.push("-C", String(context));
+    }
+    args.push("-m", String(maxResults));
+    args.push("-E", pattern);
+    args.push("--exclude-dir=node_modules", "--exclude-dir=.git", "--exclude-dir=dist");
+    args.push(path);
+    const { stdout } = await execFileAsync("grep", args, {
+        maxBuffer: 10 * 1024 * 1024,
+        timeout: 30_000,
+    });
+    const result = relativizeOutput(stdout, path).trim();
+    if (!result)
+        return "No matches found.";
+    const lines = result.split("\n");
+    if (lines.length > 200) {
+        return lines.slice(0, 200).join("\n") + `\n\n... ${lines.length - 200} more results`;
+    }
+    return result;
+}

package/dist/tool-system/builtin/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Built-in tool registration.
+ */
+import type { RegisteredTool } from "../../types.js";
+/**
+ * Tool executor signature.
+ *
+ * Tools may inspect ctx for runtime services (askUser, llmConfig, modelPool,
+ * toolRegistry, subAgentSpawner). Tools that don't need any of these — Read,
+ * Write, Bash, Edit, Glob, Grep, etc. — may simply ignore the second arg.
+ *
+ * ctx is optional in the signature so legacy call sites (and tests) that
+ * pass only args still type-check; ToolRegistry always passes ctx at runtime.
+ */
+export type BuiltinToolFn = (args: Record<string, unknown>, ctx?: import("../context.js").ToolContext) => Promise<string>;
+export interface BuiltinTool {
+    definition: RegisteredTool;
+    execute: BuiltinToolFn;
+}
+export declare const BUILTIN_TOOLS: BuiltinTool[];

package/dist/tool-system/builtin/index.js

@@ -0,0 +1,449 @@
+/**
+ * Built-in tool registration.
+ */
+import { readToolDef, readTool } from "./read.js";
+import { writeToolDef, writeTool } from "./write.js";
+import { editToolDef, editTool } from "./edit.js";
+import { applyPatchToolDef, applyPatchTool } from "./apply-patch/index.js";
+import { globToolDef, globTool } from "./glob.js";
+import { grepToolDef, grepTool } from "./grep.js";
+import { bashToolDef, bashTool } from "./bash.js";
+import { webSearchToolDef, webSearchTool } from "./web-search.js";
+import { webFetchToolDef, webFetchTool } from "./web-fetch.js";
+import { askUserToolDef, askUserTool } from "./ask-user.js";
+import { agentToolDef, agentTool, agentStatusToolDef, agentStatusTool, agentCancelToolDef, agentCancelTool, } from "./agent.js";
+import { enterPlanModeToolDef, enterPlanModeTool, exitPlanModeToolDef, exitPlanModeTool } from "./plan.js";
+import { toolSearchToolDef, toolSearchTool } from "./tool-search.js";
+import { todoWriteToolDef, todoWriteTool } from "./task.js";
+import { enterWorktreeToolDef, enterWorktreeTool, exitWorktreeToolDef, exitWorktreeTool } from "./worktree.js";
+import { sendMessageToolDef, sendMessageTool } from "./send-message.js";
+import { sleepToolDef, sleepTool } from "./sleep.js";
+import { configToolDef, configTool } from "./config.js";
+import { notebookEditToolDef, notebookEditTool } from "./notebook-edit.js";
+import { lspToolDef, lspTool } from "./lsp.js";
+import { cronCreateToolDef, cronCreateTool, cronDeleteToolDef, cronDeleteTool, cronListToolDef, cronListTool } from "./cron.js";
+import { skillToolDef, skillTool } from "./skill.js";
+import { mcpToolDef, mcpToolExecute, listMcpResourcesToolDef, listMcpResourcesTool, readMcpResourceToolDef, readMcpResourceTool } from "./mcp-tools.js";
+import { remoteTriggerToolDef, remoteTriggerTool } from "./remote-trigger.js";
+import { replToolDef, replTool } from "./repl.js";
+import { briefToolDef, briefTool } from "./brief.js";
+import { powershellToolDef, powershellTool } from "./powershell.js";
+import { arenaToolDef, arenaTool } from "./arena.js";
+import { memoryListToolDef, memoryListTool, memoryReadToolDef, memoryReadTool, memorySaveToolDef, memorySaveTool, memoryDeleteToolDef, memoryDeleteTool, } from "./memory.js";
+export const BUILTIN_TOOLS = [
+    {
+        definition: {
+            ...readToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: readTool,
+    },
+    {
+        definition: {
+            ...writeToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: writeTool,
+    },
+    {
+        definition: {
+            ...editToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: editTool,
+    },
+    {
+        definition: {
+            ...applyPatchToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: applyPatchTool,
+    },
+    {
+        definition: {
+            ...globToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: globTool,
+    },
+    {
+        definition: {
+            ...grepToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: grepTool,
+    },
+    {
+        definition: {
+            ...bashToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+            timeoutMs: 3_600_000, // 1h — supports long-running shell loops (e.g. `until` polling)
+        },
+        execute: bashTool,
+    },
+    {
+        definition: {
+            ...webSearchToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: webSearchTool,
+    },
+    {
+        definition: {
+            ...webFetchToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: webFetchTool,
+    },
+    {
+        definition: {
+            ...askUserToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: false,
+            timeoutMs: 0, // 纯等待用户操作 — 不设超时，由用户 Esc/取消
+        },
+        execute: askUserTool,
+    },
+    {
+        definition: {
+            ...agentToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+            timeoutMs: 1_800_000, // 30min — sub-agent runs may execute many tool calls
+        },
+        execute: agentTool,
+    },
+    {
+        definition: {
+            ...agentStatusToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: agentStatusTool,
+    },
+    {
+        definition: {
+            ...agentCancelToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: agentCancelTool,
+    },
+    {
+        definition: {
+            ...enterPlanModeToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: false,
+        },
+        execute: enterPlanModeTool,
+    },
+    {
+        definition: {
+            ...exitPlanModeToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: false,
+        },
+        execute: exitPlanModeTool,
+    },
+    {
+        definition: {
+            ...toolSearchToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: toolSearchTool,
+    },
+    {
+        definition: {
+            ...todoWriteToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: todoWriteTool,
+    },
+    // ─── Phase 4: Multi-Agent + Worktree ───────────────────────────
+    {
+        definition: {
+            ...enterWorktreeToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: enterWorktreeTool,
+    },
+    {
+        definition: {
+            ...exitWorktreeToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: exitWorktreeTool,
+    },
+    {
+        definition: {
+            ...sendMessageToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: false,
+            isConcurrencySafe: true,
+        },
+        execute: sendMessageTool,
+    },
+    // ─── Phase 5: Utility Tools ────────────────────────────────────
+    {
+        definition: {
+            ...sleepToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: sleepTool,
+    },
+    {
+        definition: {
+            ...configToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: configTool,
+    },
+    {
+        definition: {
+            ...notebookEditToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: notebookEditTool,
+    },
+    // ─── Phase 6: LSP ─────────────────────────────────────────────
+    {
+        definition: {
+            ...lspToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: lspTool,
+    },
+    // ─── Cron Tools ────────────────────────────────────────────────
+    {
+        definition: {
+            ...cronCreateToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: cronCreateTool,
+    },
+    {
+        definition: {
+            ...cronDeleteToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: cronDeleteTool,
+    },
+    {
+        definition: {
+            ...cronListToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: cronListTool,
+    },
+    // ─── Phase 7: Missing tools from restored-src ─────────────────
+    {
+        definition: {
+            ...skillToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: skillTool,
+    },
+    {
+        definition: {
+            ...mcpToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: true,
+        },
+        execute: mcpToolExecute,
+    },
+    {
+        definition: {
+            ...listMcpResourcesToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: listMcpResourcesTool,
+    },
+    {
+        definition: {
+            ...readMcpResourceToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: readMcpResourceTool,
+    },
+    {
+        definition: {
+            ...remoteTriggerToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: remoteTriggerTool,
+    },
+    {
+        definition: {
+            ...replToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: replTool,
+    },
+    {
+        definition: {
+            ...briefToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: briefTool,
+    },
+    {
+        definition: {
+            ...powershellToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: powershellTool,
+    },
+    // ─── Arena: Multi-Model Collaborative Analysis ────────────────
+    {
+        definition: {
+            ...arenaToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: true,
+            isConcurrencySafe: false,
+            timeoutMs: 1_800_000, // 30min — multi-model debate rounds take time
+        },
+        execute: arenaTool,
+    },
+    // ─── Memory tools (persistent cross-session memory) ────────────
+    // Save/Delete default to "ask" so user-scope modifications go through a
+    // permission prompt; dream-scope is whitelisted via a PermissionRule in
+    // Engine.buildPermissionConfig so the LLM can freely manage its own
+    // workspace without prompting.
+    {
+        definition: {
+            ...memoryListToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: memoryListTool,
+    },
+    {
+        definition: {
+            ...memoryReadToolDef,
+            source: "builtin",
+            permissionDefault: "allow",
+            isReadOnly: true,
+            isConcurrencySafe: true,
+        },
+        execute: memoryReadTool,
+    },
+    {
+        definition: {
+            ...memorySaveToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: memorySaveTool,
+    },
+    {
+        definition: {
+            ...memoryDeleteToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: memoryDeleteTool,
+    },
+];

package/dist/tool-system/builtin/lsp.d.ts

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