@kkeve/suite 0.0.1

package/dist/tools/bash.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Bash Tool — shell command execution with scope-based permission control
+ *
+ * Scope patterns (aligned with keve-agent SKILL.md allowed-tools):
+ *   Bash(git:*)   → only git commands allowed
+ *   Bash(npx:*)   → only npx commands allowed
+ *   Bash(npm:*)   → only npm commands allowed
+ *   Bash(node:*)  → only node commands allowed
+ *   Bash(shell:*)  → any command allowed
+ *
+ * When LLM calls bash tool, the 'scope' parameter is validated against
+ * the skill's allowed-tools list by the ToolCaller.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bashTool = exports.BashInputSchema = void 0;
+exports.isCommandInScope = isCommandInScope;
+exports.parseBashScopes = parseBashScopes;
+exports.checkReadOnlyPathWrite = checkReadOnlyPathWrite;
+const v4_1 = require("zod/v4");
+const node_child_process_1 = require("node:child_process");
+// ===== Schema =====
+exports.BashInputSchema = v4_1.z.object({
+    /** The shell command to execute */
+    command: v4_1.z.string().describe('Shell command to execute'),
+    /** Scope constraint (e.g., 'git', 'npx', 'npm', 'node', 'shell') */
+    scope: v4_1.z.string().default('shell').describe('Command scope: git/npx/npm/node/shell'),
+    /** Working directory */
+    cwd: v4_1.z.string().optional().describe('Working directory for command execution'),
+    /** Timeout in milliseconds */
+    timeout: v4_1.z.number().default(30_000).describe('Execution timeout in ms'),
+});
+// ===== Scope Validation =====
+/**
+ * Validate that a command matches the allowed scope.
+ * Extracts the first word (the binary name) and checks against scope.
+ *
+ * @param command - The shell command to validate
+ * @param allowedScopes - Array of allowed scopes (e.g., ['git', 'npx', 'shell'])
+ * @returns true if command is within allowed scopes
+ */
+function isCommandInScope(command, allowedScopes) {
+    // 'shell' scope allows everything
+    if (allowedScopes.includes('shell'))
+        return true;
+    // Extract the first word (binary name)
+    const firstWord = command.trim().split(/\s+/)[0];
+    // Handle path-like commands: extract basename
+    const binaryName = firstWord.split('/').pop() ?? firstWord;
+    // Check if the binary matches any allowed scope
+    return allowedScopes.some(scope => binaryName === scope);
+}
+/**
+ * Parse Bash(scope:*) patterns from allowed-tools list.
+ * Input: ['Bash(git:*)', 'Bash(npx:*)', 'codegraph_impact']
+ * Output: ['git', 'npx']
+ */
+function parseBashScopes(allowedTools) {
+    const scopes = [];
+    for (const tool of allowedTools) {
+        const match = tool.match(/^Bash\((\w+):\*\)$/);
+        if (match) {
+            scopes.push(match[1]);
+        }
+    }
+    return scopes;
+}
+// ===== Read-Only Path Protection =====
+/**
+ * Write patterns that indicate a command is trying to modify files.
+ * These are checked against readOnlyPaths to prevent writes to protected directories.
+ */
+const WRITE_PATTERNS = [
+    // sed -i (in-place edit)
+    { pattern: /\bsed\s+(-[^-]*i|--in-place)\b/, description: 'sed -i (in-place edit)' },
+    // Redirect overwrite: > file (but not >>, > /dev/null, > &)
+    { pattern: /[^>]>[^>]/, description: '> redirect (file overwrite)' },
+    // Redirect append: >> file (allowed in general, but block if target is readOnly)
+    // Actually >> is also a write, let's block it too for readOnly paths
+    { pattern: />>/, description: '>> redirect (file append)' },
+    // tee command
+    { pattern: /\btee\b/, description: 'tee (write to file)' },
+    // mv / cp with write target
+    { pattern: /\b(mv|cp)\s+/, description: 'mv/cp (move/copy file)' },
+    // rm
+    { pattern: /\brm\s+/, description: 'rm (delete file)' },
+    // chmod / chown
+    { pattern: /\b(chmod|chown)\s+/, description: 'chmod/chown (change permissions)' },
+    // patch
+    { pattern: /\bpatch\s+/, description: 'patch (apply diff)' },
+    // npm install / pnpm install / yarn (adds node_modules)
+    { pattern: /\b(npm|pnpm|yarn)\s+(install|i|add)\b/, description: 'npm/pnpm/yarn install (add dependencies)' },
+    // npx playwright install
+    { pattern: /\bnpx\s+playwright\s+install\b/, description: 'npx playwright install (installs browsers)' },
+    // pip install
+    { pattern: /\bpip\d*\s+install\b/, description: 'pip install (add Python packages)' },
+    // echo > redirect
+    { pattern: /\becho\s+.*>\s*/, description: 'echo > redirect (write to file)' },
+    // cat > redirect
+    { pattern: /\bcat\b.*[^>]>[^>]/, description: 'cat > redirect (write to file)' },
+    // dd
+    { pattern: /\bdd\s+/, description: 'dd (disk write)' },
+    // install command (copy files)
+    { pattern: /\binstall\s+/, description: 'install (copy files)' },
+];
+/**
+ * Check if a command attempts to write to a read-only path.
+ * Uses static analysis of the command string.
+ *
+ * @param command - The shell command to check
+ * @param readOnlyPaths - Array of directory paths that are read-only
+ * @returns Error message if write is detected, or null if command is safe
+ */
+function checkReadOnlyPathWrite(command, readOnlyPaths) {
+    if (!readOnlyPaths.length)
+        return null;
+    // Step 1: Check if command contains any write pattern
+    const matchedPattern = WRITE_PATTERNS.find(p => p.pattern.test(command));
+    if (!matchedPattern)
+        return null;
+    // Step 2: Check if the write target falls under a readOnlyPath
+    // Normalize readOnly paths (resolve home, remove trailing slash)
+    const normalizedROPaths = readOnlyPaths.map(p => {
+        const expanded = p.replace(/^~/, process.env.HOME || '/tmp');
+        return expanded.replace(/\/+$/, '');
+    });
+    // Extract potential target paths from the command
+    // Simple heuristic: any absolute path or relative path in the command
+    // that starts with or contains a readOnlyPath prefix
+    const commandHasReadOnlyTarget = normalizedROPaths.some(roPath => {
+        // Direct path reference in command
+        if (command.includes(roPath + '/') || command.includes(roPath + ' ') || command.endsWith(roPath)) {
+            return true;
+        }
+        // If cwd might be a readOnlyPath and command uses relative paths
+        // (covered by the general pattern match above — if write pattern
+        //  matches AND readOnlyPath is in the command, we block it)
+        return false;
+    });
+    if (commandHasReadOnlyTarget) {
+        return `[BLOCKED] Write operation blocked: "${matchedPattern.description}" targets read-only path. ` +
+            `Protected paths: ${normalizedROPaths.join(', ')}. ` +
+            `Write your output to workspaceDir instead.`;
+    }
+    // Even if no explicit path target, some commands are inherently dangerous
+    // when executed inside a readOnly directory (e.g., `cd /readOnly && sed -i file`)
+    // Check if cwd might be a readOnlyPath
+    const cwdInCommand = command.match(/cd\s+(['"]?)(.+?)\1\s+&&/);
+    if (cwdInCommand) {
+        const cwdPath = cwdInCommand[2].replace(/^~/, process.env.HOME || '/tmp');
+        if (normalizedROPaths.some(ro => cwdPath.startsWith(ro))) {
+            return `[BLOCKED] Write operation blocked: "${matchedPattern.description}" executed in read-only directory "${cwdPath}". ` +
+                `Protected paths: ${normalizedROPaths.join(', ')}. ` +
+                `Write your output to workspaceDir instead.`;
+        }
+    }
+    return null;
+}
+// ===== Tool Definition =====
+exports.bashTool = {
+    name: 'bash',
+    description: `Execute a shell command with scope-based permission control.
+
+Scope patterns:
+- Bash(git:*): only git commands
+- Bash(npx:*): only npx commands  
+- Bash(npm:*): only npm commands
+- Bash(node:*): only node commands
+- Bash(shell:*): any command
+
+The scope parameter is validated against the skill's allowed-tools list.
+
+Read-only path protection:
+- If readOnlyPaths is set in context, commands that write to those paths will be blocked.
+- This prevents accidental modification of source code repositories.`,
+    inputSchema: exports.BashInputSchema,
+    customJsonSchema: {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: 'Shell command to execute' },
+            scope: { type: 'string', description: 'Command scope: git/npx/npm/node/shell', default: 'shell' },
+            cwd: { type: 'string', description: 'Working directory' },
+            timeout: { type: 'number', description: 'Timeout in ms', default: 30000 },
+        },
+        required: ['command'],
+    },
+    async execute(args, context) {
+        const { command, scope = 'shell', cwd, timeout = 30_000 } = args;
+        // 🆕 Read-only path protection
+        if (context?.readOnlyPaths?.length) {
+            const blockReason = checkReadOnlyPathWrite(command, context.readOnlyPaths);
+            if (blockReason) {
+                return { ok: false, stdout: '', stderr: blockReason, exitCode: 126 };
+            }
+        }
+        try {
+            const stdout = (0, node_child_process_1.execSync)(command, {
+                cwd,
+                timeout,
+                encoding: 'utf-8',
+                maxBuffer: 1024 * 1024, // 1MB
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return { ok: true, stdout: stdout.trim(), stderr: '', exitCode: 0 };
+        }
+        catch (err) {
+            const stdout = err.stdout?.trim() ?? '';
+            const stderr = err.stderr?.trim() ?? '';
+            const exitCode = err.status ?? 1;
+            return { ok: false, stdout, stderr, exitCode };
+        }
+    },
+};

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

@@ -0,0 +1,9 @@
+import { z } from 'zod/v4';
+import type { ToolDefinition } from '../agent-loop/types';
+export declare const EditFileInputSchema: z.ZodObject<{
+    path: z.ZodString;
+    oldString: z.ZodString;
+    newString: z.ZodString;
+    replaceAll: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const editFileTool: ToolDefinition;

package/dist/tools/edit-file.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editFileTool = exports.EditFileInputSchema = void 0;
+/**
+ * edit_file tool — precise string replacement editing
+ *
+ * Reference: gemini-cli EditTool (replace oldString → newString)
+ */
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const v4_1 = require("zod/v4");
+exports.EditFileInputSchema = v4_1.z.object({
+    path: v4_1.z.string().describe('File path'),
+    oldString: v4_1.z.string().describe('Original text to replace (must match exactly)'),
+    newString: v4_1.z.string().describe('New text to replace with'),
+    replaceAll: v4_1.z.boolean().default(false).describe('Replace all occurrences (default: first only)'),
+});
+exports.editFileTool = {
+    name: 'edit_file',
+    description: 'Edit file by precise string replacement. oldString must match exactly, replaced with newString.',
+    inputSchema: exports.EditFileInputSchema,
+    execute: async (args, context) => {
+        const cwd = context?.cwd ?? process.cwd();
+        const filePath = path.isAbsolute(args.path) ? args.path : path.resolve(cwd, args.path);
+        const content = await fs.readFile(filePath, 'utf-8');
+        // Check if oldString exists
+        if (!content.includes(args.oldString)) {
+            return { ok: false, error: `oldString not found in ${filePath}` };
+        }
+        // Check uniqueness (if not replaceAll)
+        if (!args.replaceAll) {
+            const count = content.split(args.oldString).length - 1;
+            if (count > 1) {
+                return { ok: false, error: `oldString found ${count} times in ${filePath}, but replaceAll=false. Provide more context to make it unique.` };
+            }
+        }
+        const newContent = args.replaceAll
+            ? content.split(args.oldString).join(args.newString)
+            : content.replace(args.oldString, args.newString);
+        await fs.writeFile(filePath, newContent, 'utf-8');
+        return { ok: true, path: filePath, replaced: args.oldString.length };
+    },
+};

package/dist/tools/glob.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod/v4';
+import type { ToolDefinition } from '../agent-loop/types';
+export declare const GlobInputSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    maxResults: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const globTool: ToolDefinition;

package/dist/tools/glob.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globTool = exports.GlobInputSchema = void 0;
+/**
+ * glob tool — file search with glob pattern matching
+ *
+ * Reference: gemini-cli GlobTool
+ */
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const v4_1 = require("zod/v4");
+exports.GlobInputSchema = v4_1.z.object({
+    pattern: v4_1.z.string().describe('Glob pattern (e.g. **/*.vue, src/**/*.ts)'),
+    cwd: v4_1.z.string().optional().describe('Root directory to search in'),
+    maxResults: v4_1.z.number().default(100).describe('Maximum number of results'),
+});
+exports.globTool = {
+    name: 'glob',
+    description: 'Search files using glob patterns. Supports **/*.vue, src/**/*.ts etc. Returns matching file paths.',
+    inputSchema: exports.GlobInputSchema,
+    execute: async (args, context) => {
+        const searchDir = args.cwd ?? context?.cwd ?? process.cwd();
+        // Simple glob using Node.js fs
+        // Production: replace with fast-glob / glob package
+        const results = [];
+        const pattern = args.pattern;
+        async function walk(dir, depth) {
+            if (depth > 10 || results.length >= args.maxResults)
+                return;
+            let entries;
+            try {
+                entries = await fs.readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (results.length >= args.maxResults)
+                    break;
+                const fullPath = path.join(dir, entry.name);
+                // Skip node_modules, .git, dist
+                if (entry.isDirectory() && ['node_modules', '.git', 'dist', '.next', '.nuxt'].includes(entry.name))
+                    continue;
+                if (entry.isDirectory()) {
+                    await walk(fullPath, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    const relativePath = path.relative(searchDir, fullPath);
+                    if (matchGlob(relativePath, pattern)) {
+                        results.push(relativePath);
+                    }
+                }
+            }
+        }
+        await walk(searchDir, 0);
+        return results.sort();
+    },
+};
+/** Simple glob matching — supports **, *, ? */
+function matchGlob(filePath, pattern) {
+    const regex = pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*\*/g, '{{GLOBSTAR}}')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/{{GLOBSTAR}}/g, '.*');
+    return new RegExp(`^${regex}$`).test(filePath);
+}

package/dist/tools/grep.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod/v4';
+import type { ToolDefinition } from '../agent-loop/types';
+export declare const GrepInputSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    include: z.ZodOptional<z.ZodString>;
+    maxResults: z.ZodDefault<z.ZodNumber>;
+    contextLines: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const grepTool: ToolDefinition;

package/dist/tools/grep.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grepTool = exports.GrepInputSchema = void 0;
+/**
+ * grep tool — content search with regex
+ *
+ * Reference: gemini-cli GrepTool / ripgrep
+ */
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const v4_1 = require("zod/v4");
+exports.GrepInputSchema = v4_1.z.object({
+    pattern: v4_1.z.string().describe('Regex pattern to search for'),
+    path: v4_1.z.string().optional().describe('Directory to search in'),
+    include: v4_1.z.string().optional().describe('File filter pattern (e.g. *.vue, *.ts)'),
+    maxResults: v4_1.z.number().default(50).describe('Maximum number of matches to return'),
+    contextLines: v4_1.z.number().default(2).describe('Number of context lines around matches'),
+});
+exports.grepTool = {
+    name: 'grep',
+    description: 'Search file contents with regex. Returns matching file paths, line numbers, and content.',
+    inputSchema: exports.GrepInputSchema,
+    execute: async (args, context) => {
+        const searchDir = args.path ?? context?.cwd ?? process.cwd();
+        const absPath = path.isAbsolute(searchDir) ? searchDir : path.resolve(context?.cwd ?? process.cwd(), searchDir);
+        const includeFlag = args.include ? `--include="${args.include}"` : '';
+        const contextFlag = args.contextLines > 0 ? `-C ${args.contextLines}` : '';
+        const maxCount = args.maxResults > 0 ? `-m ${args.maxResults}` : '';
+        try {
+            const result = (0, node_child_process_1.execSync)(`grep -rn ${contextFlag} ${maxCount} ${includeFlag} -E "${args.pattern.replace(/"/g, '\\"')}" "${absPath}" 2>/dev/null || true`, { encoding: 'utf-8', timeout: 15_000, maxBuffer: 1024 * 1024 }).trim();
+            if (!result)
+                return { matches: [], count: 0 };
+            const lines = result.split('\n').filter(Boolean);
+            return {
+                matches: lines.slice(0, args.maxResults),
+                count: lines.length,
+            };
+        }
+        catch {
+            return { matches: [], count: 0 };
+        }
+    },
+};

package/dist/tools/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Tool registry factory — general tools
+ *
+ * General tools (gemini-cli aligned):
+ * - bash, read_files, write_file, edit_file, glob, grep, ask_user
+ *
+ * Business tools (keve, record_step_result) have been moved to agent package.
+ * MCP browser tools (pw_*) have been removed — use keve-suite or agent package instead.
+ */
+import { ToolRegistry } from '../agent-loop/types';
+import type { RuntimeEnvironment } from '../agent-loop/runtime';
+import { bashTool } from './bash';
+import { readFilesTool } from './read-files';
+import { writeFileTool } from './write-file';
+import { editFileTool } from './edit-file';
+import { globTool } from './glob';
+import { grepTool } from './grep';
+import { askUserTool } from './ask-user';
+export { bashTool, readFilesTool, writeFileTool, editFileTool, globTool, grepTool, askUserTool };
+/**
+ * Create default tool registry — general tools only
+ */
+export declare function createDefaultToolRegistry(runtime: RuntimeEnvironment): ToolRegistry;
+export declare function getBuiltinToolNames(): string[];

package/dist/tools/index.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Tool registry factory — general tools
+ *
+ * General tools (gemini-cli aligned):
+ * - bash, read_files, write_file, edit_file, glob, grep, ask_user
+ *
+ * Business tools (keve, record_step_result) have been moved to agent package.
+ * MCP browser tools (pw_*) have been removed — use keve-suite or agent package instead.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askUserTool = exports.grepTool = exports.globTool = exports.editFileTool = exports.writeFileTool = exports.readFilesTool = exports.bashTool = void 0;
+exports.createDefaultToolRegistry = createDefaultToolRegistry;
+exports.getBuiltinToolNames = getBuiltinToolNames;
+const types_1 = require("../agent-loop/types");
+const bash_1 = require("./bash");
+Object.defineProperty(exports, "bashTool", { enumerable: true, get: function () { return bash_1.bashTool; } });
+const read_files_1 = require("./read-files");
+Object.defineProperty(exports, "readFilesTool", { enumerable: true, get: function () { return read_files_1.readFilesTool; } });
+const write_file_1 = require("./write-file");
+Object.defineProperty(exports, "writeFileTool", { enumerable: true, get: function () { return write_file_1.writeFileTool; } });
+const edit_file_1 = require("./edit-file");
+Object.defineProperty(exports, "editFileTool", { enumerable: true, get: function () { return edit_file_1.editFileTool; } });
+const glob_1 = require("./glob");
+Object.defineProperty(exports, "globTool", { enumerable: true, get: function () { return glob_1.globTool; } });
+const grep_1 = require("./grep");
+Object.defineProperty(exports, "grepTool", { enumerable: true, get: function () { return grep_1.grepTool; } });
+const ask_user_1 = require("./ask-user");
+Object.defineProperty(exports, "askUserTool", { enumerable: true, get: function () { return ask_user_1.askUserTool; } });
+/**
+ * Create default tool registry — general tools only
+ */
+function createDefaultToolRegistry(runtime) {
+    globalThis.__runtime = runtime;
+    const registry = new types_1.ToolRegistry();
+    registry.register(bash_1.bashTool);
+    registry.register(read_files_1.readFilesTool);
+    registry.register(write_file_1.writeFileTool);
+    registry.register(edit_file_1.editFileTool);
+    registry.register(glob_1.globTool);
+    registry.register(grep_1.grepTool);
+    registry.register(ask_user_1.askUserTool);
+    return registry;
+}
+function getBuiltinToolNames() {
+    return ['bash', 'read_files', 'write_file', 'edit_file', 'glob', 'grep', 'ask_user'];
+}

package/dist/tools/read-files.d.ts

@@ -0,0 +1,8 @@
+/**
+ * read_files Tool — multi-file reader (reference: gemini-cli ReadManyFilesTool)
+ *
+ * Reads multiple files at once, with content truncation.
+ * Used by skills to read code, configs, wiki content, etc.
+ */
+import type { ToolDefinition } from '../agent-loop/types';
+export declare const readFilesTool: ToolDefinition;

package/dist/tools/read-files.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * read_files Tool — multi-file reader (reference: gemini-cli ReadManyFilesTool)
+ *
+ * Reads multiple files at once, with content truncation.
+ * Used by skills to read code, configs, wiki content, etc.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFilesTool = void 0;
+const v4_1 = require("zod/v4");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const ReadFilesSchema = v4_1.z.object({
+    /** File paths to read (absolute or relative to cwd) */
+    paths: v4_1.z.array(v4_1.z.string()).describe('Array of file paths to read'),
+    /** Base directory for resolving relative paths */
+    cwd: v4_1.z.string().optional().describe('Base directory for relative paths'),
+    /** Max bytes per file (prevents OOM on large files) */
+    maxBytes: v4_1.z.number().default(50_000).describe('Max bytes per file (truncated if larger)'),
+});
+exports.readFilesTool = {
+    name: 'read_files',
+    description: `Read multiple files at once. Returns file contents with path headers.
+Files larger than maxBytes are truncated. Non-existent files produce an error message.`,
+    inputSchema: ReadFilesSchema,
+    async execute(args) {
+        const { paths, cwd, maxBytes = 50_000 } = args;
+        const baseDir = cwd ?? process.cwd();
+        const results = [];
+        for (const filePath of paths) {
+            const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(baseDir, filePath);
+            const header = `\n=== ${filePath} ===`;
+            try {
+                const content = await fs.readFile(absPath, 'utf-8');
+                if (content.length > maxBytes) {
+                    results.push(`${header}\n${content.slice(0, maxBytes)}\n... [truncated at ${maxBytes} chars]`);
+                }
+                else {
+                    results.push(`${header}\n${content}`);
+                }
+            }
+            catch (err) {
+                results.push(`${header}\n[Error: ${err.message}]`);
+            }
+        }
+        return results.join('\n');
+    },
+};

package/dist/tools/write-file.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod/v4';
+import type { ToolDefinition } from '../agent-loop/types';
+export declare const WriteFileInputSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    createDirs: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const writeFileTool: ToolDefinition;