glitool 1.0.1 → 2.0.0

package/dist/llm/router.js

@@ -1,15 +1,26 @@
+import { classifyWithLlm } from './classifier.js';
+import { loadConfig } from '../config.js';
 const MODEL_BY_TIER = {
-    quick: 'gpt-4o-mini',
-    standard: 'gpt-4o-mini',
-    complex: 'gpt-4o-mini'
+    quick: 'meta-llama/Llama-3.3-70B-Instruct-Turbo',
+    standard: 'Qwen/Qwen2.5-Coder-72B-Instruct',
+    complex: 'deepseek-ai/DeepSeek-V3',
 };
+const ANAPHORA_PATTERNS = [
+    /\b(this|that|it|those|these)\b/i,
+    /\b(again|instead|previous|prior)\b/i,
+];
+const VAGUE_IMPERATIVES = [
+    /^(do it|fix it|redo|undo|keep going|continue|proceed|go ahead)\b/i,
+];
 const CHAT_PATTERNS = [
-    /^(hi|hello|hey|thanks|thank you|ok|sure|yes|no|great|awesome)\b/i,
+    /^(hi+|hello|hey|thanks|thank you|ok|sure|yes|no|great|awesome)\b/i,
     /^\/\w+/,
 ];
 const EXPLANATION_PATTERNS = [
     /^(explain|describe|what is|what are|tell me about|how does|why does|what does)\s/i,
     /^(what|who|when|where|how|why)\s.{0,60}\?$/i,
+    /^(read|show|open|cat|view|display|print)\s+\S+\.\w+/i,
+    /^(read|show|open|view)\s+(this|that|the)?\s*\S+/i,
 ];
 const CODING_PATTERNS = [
     /refactor|rewrite|redesign/i,
@@ -24,16 +35,123 @@ const PLANNING_PATTERNS = [
     /plan|roadmap|strategy|approach/i,
     /how should (i|we)|what.s the best way/i,
 ];
+const EXPLICIT_ROUTES = {
+    '/plan': { domain: 'planning', tier: 'complex' },
+    '/coder': { domain: 'coding', tier: 'standard' },
+    '/quick': { domain: 'chat', tier: 'quick' },
+    '/explain': { domain: 'explanation', tier: 'quick' },
+    '/debug': { domain: 'debugging', tier: 'standard' },
+    '/refactor': { domain: 'refactoring', tier: 'complex' },
+    '/review': { domain: 'review', tier: 'standard' },
+    '/git': { domain: 'git', tier: 'quick' },
+};
+const DEBUGGING_PATTERNS = [
+    /\berror:/i,
+    /\b(crash|crashes|crashed|crashing)\b/i,
+    /\b(fail|fails|failed|failing)\b/i,
+    /\b(broken|broke|breaks|breaking)\b/i,
+    /\bfix this\b/i,
+    /\b(exception|traceback|stack trace)\b/i,
+    /\bnot working\b/i,
+    /\bwhy (is|does|isn't|doesn't|did|won't)\b/i,
+];
+const REFACTORING_PATTERNS = [
+    /\brefactor(ed|ing|s)?\b/i,
+    /\bclean (this|it|up)\b/i,
+    /\bsimplif(y|ied|ying|ies)\b/i,
+    /\brestructur(e|ed|ing|es)\b/i,
+    /\brenam(e|ed|ing|es)\b/i,
+    /\bextract(ed|ing|s)?\b/i,
+    /\breduc(e|ed|ing|es) duplication\b/i,
+    /\bmake (this|it) more readable\b/i,
+];
+const REVIEW_PATTERNS = [
+    /\breview(ed|ing|s)?\b/i,
+    /\baudit(ed|ing|s)?\b/i,
+    /\bcheck for (issues|bugs|problems|errors)\b/i,
+    /\bis this (good|correct|right|ok|fine)\b/i,
+    /\bsecurity (check|review|audit)\b/i,
+    /\bcode review\b/i,
+    /\blook (over|at) (this|my)\b/i,
+];
+const GIT_PATTERNS = [
+    /\b(commit|commits|committed|committing)\b/i,
+    /\bgit\b/i,
+    /\bwhat (changed|was changed|got changed)\b/i,
+    /\bstage[ds]?\b/i,
+    /\bstaging\b/i,
+    /\bpush(ed|ing|es)?\b/i,
+    /\bpull(ed|ing|s)?\b/i,
+    /\bbranch(es|ing|ed)?\b/i,
+    /\bmerg(e|ed|ing|es)\b/i,
+    /\brebas(e|ed|ing|es)\b/i,
+    /\bcheckout\b/i,
+    /\bdiff\b/i,
+    /\bcommit message\b/i,
+    /\b(repo|repository)\b/i,
+];
+function hasAnaphora(prompt) {
+    return ANAPHORA_PATTERNS.some(p => p.test(prompt))
+        || VAGUE_IMPERATIVES.some(p => p.test(prompt));
+}
+export function parseExplicitRoute(prompt) {
+    const trimmed = prompt.trim();
+    for (const [cmd, route] of Object.entries(EXPLICIT_ROUTES)) {
+        if (trimmed.startsWith(cmd + ' ') || trimmed === cmd) {
+            return {
+                tier: route.tier,
+                domain: route.domain,
+                complexityScore: 0,
+                recommendedModel: getModel(route.tier),
+                reason: `explicit: ${cmd}`,
+                source: 'explicit',
+                confidence: 'high', // ← ADD
+            };
+        }
+    }
+    return null;
+}
+export function stripExplicitPrefix(prompt) {
+    const trimmed = prompt.trim();
+    for (const cmd of Object.keys(EXPLICIT_ROUTES)) {
+        if (trimmed.startsWith(cmd + ' ')) {
+            return trimmed.slice(cmd.length + 1).trim();
+        }
+        if (trimmed === cmd) {
+            return '';
+        }
+    }
+    return prompt;
+}
+function getModel(tier) {
+    const userPref = loadConfig().preferredModel;
+    // User preference applies ONLY to the quick tier (chat/explain).
+    // Coding, planning, refactoring always use the tier-appropriate strong model.
+    if (userPref && tier === 'quick')
+        return userPref;
+    return MODEL_BY_TIER[tier];
+}
+export function getModelForTier(tier) {
+    return MODEL_BY_TIER[tier];
+}
 function detectDomain(prompt) {
     if (CHAT_PATTERNS.some(p => p.test(prompt)))
-        return 'chat';
+        return { domain: 'chat', matched: true };
+    if (GIT_PATTERNS.some(p => p.test(prompt)))
+        return { domain: 'git', matched: true };
+    if (REVIEW_PATTERNS.some(p => p.test(prompt)))
+        return { domain: 'review', matched: true };
+    if (REFACTORING_PATTERNS.some(p => p.test(prompt)))
+        return { domain: 'refactoring', matched: true };
+    if (DEBUGGING_PATTERNS.some(p => p.test(prompt)))
+        return { domain: 'debugging', matched: true };
     if (EXPLANATION_PATTERNS.some(p => p.test(prompt)))
-        return 'explanation';
+        return { domain: 'explanation', matched: true };
     if (CODING_PATTERNS.some(p => p.test(prompt)))
-        return 'coding';
+        return { domain: 'coding', matched: true };
     if (PLANNING_PATTERNS.some(p => p.test(prompt)))
-        return 'planning';
-    return 'chat';
+        return { domain: 'planning', matched: true };
+    return { domain: 'chat', matched: false };
 }
 function scoreComplexity(prompt) {
     let score = 0;
@@ -50,28 +168,79 @@ function scoreComplexity(prompt) {
     return score;
 }
 function selectTier(domain, score) {
-    if (domain === 'chat')
+    if (domain === 'chat' || domain === 'git')
         return 'quick';
     if (domain === 'explanation' && score <= 1)
         return 'quick';
-    if (score >= 3 || domain === 'planning')
+    if (domain === 'planning' || domain === 'refactoring')
+        return 'complex';
+    if (score >= 3)
         return 'complex';
     return 'standard';
 }
-export function route(prompt) {
+function computeConfidence(matched, promptLength, anaphora) {
+    // Anaphora needs context — never high confidence without LLM lookup
+    if (anaphora)
+        return 'low';
+    // Very short prompts are usually clear: hi, ok, thanks
+    if (promptLength < 20)
+        return 'high';
+    // Pattern matched → we know what this is
+    if (matched)
+        return 'high';
+    // Long prompt, no pattern, no anaphora → we're guessing
+    return 'low';
+}
+export async function route(prompt, recentMessages = []) {
+    const start = Date.now();
+    const explicit = parseExplicitRoute(prompt);
+    if (explicit)
+        return { ...explicit, latency_ms: Date.now() - start };
     const trimmed = prompt.trim();
-    const domain = detectDomain(trimmed);
+    const { domain: regexDomain, matched } = detectDomain(trimmed);
     const complexityScore = scoreComplexity(trimmed);
-    const tier = selectTier(domain, complexityScore);
-    return {
+    const tier = selectTier(regexDomain, complexityScore);
+    const anaphora = hasAnaphora(trimmed);
+    const confidence = computeConfidence(matched, trimmed.length, anaphora);
+    const regexDecision = {
         tier,
-        domain,
+        domain: regexDomain,
         complexityScore,
-        recommendedModel: MODEL_BY_TIER[tier],
-        reason: `domain=${domain} score=${complexityScore} tier=${tier}`
+        recommendedModel: getModel(tier),
+        reason: `domain=${regexDomain} score=${complexityScore} tier=${tier} matched=${matched} anaphora=${anaphora}`,
+        source: 'regex',
+        confidence,
+        regex_said: regexDomain,
+        latency_ms: Date.now() - start,
     };
-}
-export function detectComplexity(message) {
-    const { domain, tier } = route(message);
-    return (domain === 'coding' || tier === 'complex') ? 'complex' : 'simple';
+    // Only escalate to LLM on low confidence
+    const config = loadConfig();
+    if (confidence === 'low' && config.routing.useLlmClassifier) {
+        const result = await classifyWithLlm(trimmed, recentMessages);
+        if (result) {
+            const llmTier = selectTier(result.domain, complexityScore);
+            return {
+                tier: llmTier,
+                domain: result.domain,
+                complexityScore,
+                recommendedModel: getModel(llmTier),
+                reason: result.reason,
+                source: 'llm',
+                confidence: result.confidence,
+                regex_said: regexDomain,
+                llm_said: result.domain,
+                escalation_reason: anaphora ? 'anaphora detected' : 'low regex confidence',
+                latency_ms: Date.now() - start,
+                classifier_tokens: result.tokens,
+            };
+        }
+        // LLM failed — fall back to regex result
+        return {
+            ...regexDecision,
+            source: 'regex-fallback',
+            escalation_reason: 'llm classifier failed',
+            latency_ms: Date.now() - start,
+        };
+    }
+    return regexDecision;
 }

package/dist/logger.js

@@ -0,0 +1,25 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const LOG_PATH = path.join(os.homedir(), '.glitool', 'debug.log');
+try {
+    fs.mkdirSync(path.dirname(LOG_PATH), { recursive: true });
+}
+catch { }
+export function log(event, data) {
+    const line = JSON.stringify({
+        t: new Date().toISOString().slice(11, 23),
+        event,
+        ...data,
+    });
+    try {
+        fs.appendFileSync(LOG_PATH, line + '\n');
+    }
+    catch { }
+}
+export function clearLog() {
+    try {
+        fs.writeFileSync(LOG_PATH, '');
+    }
+    catch { }
+}

package/dist/processEvents.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/bashTool.js

@@ -0,0 +1,90 @@
+import { tool } from "@langchain/core/tools";
+import { spawn } from "child_process";
+import { z } from "zod";
+import { requestConfirm } from "../confirmHandler.js";
+import { scoreShellRisk } from "../trust/riskScorer.js";
+import { registerProcess } from "./processRegistry.js";
+const MAX_OUTPUT = 10_000;
+const DEFAULT_TIMEOUT_MS = 30_000;
+export const bashTool = tool(async ({ command, timeout, runInBackground }) => {
+    // Risk check BEFORE spawn — block dangerous, confirm sensitive
+    const risk = scoreShellRisk(command);
+    if (risk === 'block') {
+        return `BLOCKED: This shell command is too dangerous to run: \`${command}\`. Try a safer alternative or ask the user to run it manually.`;
+    }
+    if (risk === 'confirm') {
+        const ok = await requestConfirm({
+            type: 'write',
+            filePath: `[shell] ${command}`,
+            content: command,
+            risk: 'medium',
+        });
+        if (!ok) {
+            return 'USER_CANCELLED: The user rejected this shell command. Do NOT retry.';
+        }
+    }
+    const proc = spawn(command, {
+        shell: true,
+        cwd: process.cwd(),
+        ...(runInBackground ? {} : { timeout: timeout ?? DEFAULT_TIMEOUT_MS }),
+    });
+    if (runInBackground) {
+        const handle = registerProcess(proc, command);
+        return `Background process started. Handle: ${handle}. Use the read_background_output with this handle to see output.`;
+    }
+    // Run the command
+    return new Promise((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        let truncated = false;
+        // const proc = spawn(command, {
+        //     shell: true,
+        //     cwd: process.cwd(),
+        //     timeout: timeout ?? DEFAULT_TIMEOUT_MS,
+        // });
+        proc.stdout?.on('data', (data) => {
+            if (stdout.length >= MAX_OUTPUT) {
+                truncated = true;
+                return;
+            }
+            stdout += data.toString();
+            if (stdout.length > MAX_OUTPUT) {
+                stdout = stdout.slice(0, MAX_OUTPUT);
+                truncated = true;
+            }
+        });
+        proc.stderr?.on('data', (data) => {
+            if (stderr.length >= MAX_OUTPUT) {
+                truncated = true;
+                return;
+            }
+            stderr += data.toString();
+            if (stderr.length > MAX_OUTPUT) {
+                stderr = stderr.slice(0, MAX_OUTPUT);
+                truncated = true;
+            }
+        });
+        proc.on('close', (code) => {
+            const parts = [];
+            if (stdout)
+                parts.push(`stdout:\n${stdout}`);
+            if (stderr)
+                parts.push(`stderr:\n${stderr}`);
+            parts.push(`exit code: ${code}`);
+            if (truncated)
+                parts.push('(output truncated at 10KB)');
+            resolve(parts.join('\n\n'));
+        });
+        proc.on('error', (err) => {
+            resolve(`Error running command: ${err.message}`);
+        });
+    });
+}, {
+    name: 'bash',
+    description: 'Run a shell command. Use runInBackground:true for dev servers and long-running tests — returns a handle immediately. Use read_background_output to read accumulating output. Dangerous commands (rm -rf, sudo, fork bombs) are blocked. Sensitive commands (git push, npm install/publish) require user confirmation.',
+    schema: z.object({
+        command: z.string().describe('Shell command to run'),
+        timeout: z.number().optional().describe('Timeout in ms for foreground commands (default 30000)'),
+        runInBackground: z.boolean().optional().describe('If true, run without waiting and return a handle'),
+    }),
+});

package/dist/tools/editFileTool.js

@@ -1,7 +1,8 @@
-import { tool } from "@langchain/core/tools";
+import { tool } from '@langchain/core/tools';
 import fs from 'fs';
 import path from 'path';
 import { z } from 'zod';
+import { requestConfirm } from '../confirmHandler.js';
 export const editFileTool = tool(async ({ filePath, oldString, newString }) => {
     const fullPath = path.resolve(process.cwd(), filePath);
     if (!fullPath.startsWith(process.cwd())) {
@@ -14,8 +15,18 @@ export const editFileTool = tool(async ({ filePath, oldString, newString }) => {
     if (!content.includes(oldString)) {
         throw new Error(`String not found in file. Make sure oldString matches exactly, including whitespace and case.`);
     }
-    const updated = content.replace(oldString, newString);
-    fs.writeFileSync(fullPath, updated, 'utf-8');
+    const ok = await requestConfirm({
+        type: 'edit',
+        filePath,
+        oldString,
+        newString,
+        risk: 'low',
+    });
+    if (!ok) {
+        return 'USER_CANCELLED: The user explicitly rejected this file edit. Do NOT retry. Inform the user the edit was cancelled.';
+    }
+    const update = content.split(oldString).join(newString);
+    fs.writeFileSync(fullPath, update, 'utf-8');
     return `Successfully edited ${filePath}`;
 }, {
     name: 'editFile',

package/dist/tools/index.js

@@ -1,7 +1,9 @@
 export { readProjectTool } from './readProject.js';
 export { writeFileTool } from './writeFileTool.js';
-export { analyzeProjectTool } from './analyzeProject.js';
 export { listFilesTool } from './listFilesTool.js';
 export { readFileTool } from './readFileTool.js';
 export { searchCodeTool } from './searchCodeTool.js';
 export { editFileTool } from './editFileTool.js';
+export { bashTool } from './bashTool.js';
+export { readBackgroundOutputTool } from './readBackgroundOutput.js';
+export { webFetchTool } from './webFetchTool.js';

package/dist/tools/listFilesTool.js

@@ -2,26 +2,24 @@ import { tool } from '@langchain/core/tools';
 import fs from 'fs';
 import path from 'path';
 import { z } from 'zod';
-const SKIP_DIRS = ['node_modules', '.git', 'dist', 'build', '.next'];
-function buildTree(dir, prefix = '') {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    const lines = [];
-    for (const entry of entries) {
-        if (SKIP_DIRS.includes(entry.name))
-            continue;
-        if (entry.isSymbolicLink())
-            continue;
-        lines.push(`${prefix}${entry.isDirectory() ? '📁' : '📄'} ${entry.name}`);
-        if (entry.isDirectory()) {
-            const sub = buildTree(path.join(dir, entry.name), prefix + '  ');
-            if (sub)
-                lines.push(sub);
-        }
-    }
-    return lines.join('\n');
-}
-export const listFilesTool = tool(async () => buildTree(process.cwd()), {
+import fg from 'fast-glob';
+const DEFAULT_IGNORE = ['node_modules/**', 'dist/**', 'build/**', '.git/**', '.next/**'];
+export const listFilesTool = tool(async ({ pattern, ignore }) => {
+    const files = await fg(pattern ?? '**/*', {
+        cwd: process.cwd(),
+        ignore: [...DEFAULT_IGNORE, ...(ignore ?? [])],
+        dot: false,
+        onlyFiles: false,
+        markDirectories: true
+    });
+    if (files.length === 0)
+        return 'No files matched.';
+    return files.join('\n');
+}, {
     name: 'listFiles',
-    description: 'Lists files and directories in the current working directory. It returns a tree-like structure with folders and files.',
-    schema: z.object({})
+    description: 'List files in the current project. Accepts a glob pattern (e.g. "src/**/*.ts") to filter results. Returns matching file paths, one per line. Directories end with /.',
+    schema: z.object({
+        pattern: z.string().optional().describe('Glob pattern to filter files (default: **/* — everything). Examples: "src/**/*.ts", "**/*.test.ts", "*.json"'),
+        ignore: z.array(z.string()).optional().describe('Additional glob patterns to ignore on top of the defaults (node_modules, dist, .git)')
+    })
 });

package/dist/tools/processRegistry.js

@@ -0,0 +1,36 @@
+const registry = new Map();
+let counter = 0;
+export function registerProcess(proc, command) {
+    const handle = `bg_${++counter}`;
+    const entry = {
+        proc, command, stdout: '', stderr: '', exitCode: null, startedAt: new Date()
+    };
+    proc.stdout?.on(`data`, (d) => { entry.stdout += d.toString(); });
+    proc.stderr?.on(`data`, (d) => { entry.stderr += d.toString(); });
+    proc.on(`close`, (code) => { entry.exitCode = code; });
+    registry.set(handle, entry);
+    return handle;
+}
+export function getProcess(handle) {
+    return registry.get(handle);
+}
+export function killProcess(handle) {
+    const entry = registry.get(handle);
+    if (!entry)
+        return false;
+    try {
+        entry.proc.kill();
+    }
+    catch { }
+    registry.delete(handle);
+    return true;
+}
+export function cleanupAll() {
+    for (const [, entry] of registry) {
+        try {
+            entry.proc.kill();
+        }
+        catch { }
+    }
+    registry.clear();
+}

package/dist/tools/readBackgroundOutput.js

@@ -0,0 +1,29 @@
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import { getProcess, killProcess } from "./processRegistry.js";
+export const readBackgroundOutputTool = tool(async ({ handle, kill }) => {
+    const entry = getProcess(handle);
+    if (!entry)
+        return `No background process with handle: ${handle}`;
+    const parts = [
+        `Command: ${entry.command}`,
+        `Started: ${entry.startedAt.toISOString()}`,
+        `Status: ${entry.exitCode !== null ? `exited (exit code ${entry.exitCode})` : `still runing`}`
+    ];
+    if (entry.stdout)
+        parts.push(`stdout:\n${entry.stdout}`);
+    if (entry.stderr)
+        parts.push(`stderr:\n${entry.stderr}`);
+    if (kill) {
+        killProcess(handle);
+        parts.push('process killed.');
+    }
+    return parts.join('\n\n');
+}, {
+    name: 'read_background_output',
+    description: 'Read accumulated stdout/stderr from a background process started with bash runInBackground:true. Use the handle returned at start time. Optionally kill the process.',
+    schema: z.object({
+        handle: z.string().describe('Handle returned when the process was started, e.g. "bg_1"'),
+        kill: z.boolean().optional().describe('If true, kill the process after reading its output')
+    })
+});

package/dist/tools/readFileTool.js

@@ -2,19 +2,74 @@ import { tool } from '@langchain/core/tools';
 import fs from 'fs';
 import path from 'path';
 import { z } from 'zod';
+import fg from 'fast-glob';
+const SEARCH_IGNORE = [
+    'node_modules/**',
+    'dist/**',
+    'build/**',
+    '.git/**',
+    '.next/**',
+    'coverage/**',
+];
+const MAX_BYTES = 40_000;
+async function resolveFilePath(filePath) {
+    const cwd = process.cwd();
+    // 1. Try the exact path the user gave us (against cwd).
+    const direct = path.resolve(cwd, filePath);
+    if (direct.startsWith(cwd) && fs.existsSync(direct) && fs.statSync(direct).isFile()) {
+        return { kind: 'ok', absPath: direct };
+    }
+    // 2. If the user passed a path with slashes, don't search — they meant a specific location.
+    if (filePath.includes('/') || filePath.includes('\\')) {
+        return { kind: 'not_found' };
+    }
+    // 3. Bare filename — search for it anywhere in the project.
+    const matches = await fg(`**/${filePath}`, {
+        cwd,
+        ignore: SEARCH_IGNORE,
+        dot: false,
+        onlyFiles: true,
+        suppressErrors: true,
+    });
+    if (matches.length === 0)
+        return { kind: 'not_found' };
+    if (matches.length === 1) {
+        return {
+            kind: 'ok',
+            absPath: path.resolve(cwd, matches[0]),
+            resolvedFrom: matches[0],
+        };
+    }
+    return { kind: 'ambiguous', matches };
+}
 export const readFileTool = tool(async ({ filePath }) => {
-    const fullPath = path.resolve(process.cwd(), filePath);
-    if (!fullPath.startsWith(process.cwd())) {
-        throw new Error('Access denied: outside of current working directory');
+    const resolved = await resolveFilePath(filePath);
+    if (resolved.kind === 'not_found') {
+        return `File not found: ${filePath}
+Current working directory: ${process.cwd()}
+Hint: try a bare filename (e.g. "agent.ts") to search the whole project, or use an absolute path.`;
+    }
+    if (resolved.kind === 'ambiguous') {
+        const list = resolved.matches.slice(0, 10).map(m => `  - ${m}`).join('\n');
+        const more = resolved.matches.length > 10
+            ? `\n  ...and ${resolved.matches.length - 10} more`
+            : '';
+        return `Multiple files match "${filePath}":\n${list}${more}\n\nCall readFile again with one of these specific paths.`;
+    }
+    const stat = fs.statSync(resolved.absPath);
+    if (stat.size > MAX_BYTES) {
+        return `File too large (${stat.size.toLocaleString()} bytes). Use searchCode to find specific symbols, or read smaller files.`;
     }
-    if (!fs.existsSync(fullPath)) {
-        throw new Error(`File not found: ${filePath}`);
+    const content = fs.readFileSync(resolved.absPath, 'utf-8');
+    // If we resolved a bare filename, tell the agent which path we used so future calls can be precise.
+    if (resolved.resolvedFrom) {
+        return `[resolved "${filePath}" → ${resolved.resolvedFrom}]\n\n${content}`;
     }
-    return fs.readFileSync(fullPath, 'utf-8');
+    return content;
 }, {
     name: 'readFile',
-    description: 'Reads the contents of a specific file. Use this tool to read the contents of a file in the current working directory. Provide the relative path to the file you want to read.',
+    description: 'Read the contents of a file. Accepts either a relative path from the project root (e.g. "src/foo.ts") or a bare filename (e.g. "foo.ts") — if a bare name is given, it searches the whole project. If multiple files match, the tool returns the list and you should call again with the specific path.',
     schema: z.object({
-        filePath: z.string().describe('Relative path to the file from the project root')
-    })
+        filePath: z.string().describe('Relative path from project root (e.g. "CLI/src/agent.ts") OR a bare filename (e.g. "agent.ts") to search for project-wide.'),
+    }),
 });

package/dist/tools/searchCodeTool.js

@@ -1,10 +1,20 @@
 import { tool } from "@langchain/core/tools";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { z } from "zod";
 export const searchCodeTool = tool(async ({ keyword }) => {
     try {
-        const result = execSync(`grep -rn "${keyword}" --include="*.ts" --include="*.js" --include="*.json" --exclude-dir=node_modules --exclude-dir=dist --exclude-dir=dist --exclude-dir=.git`, { cwd: process.cwd(), timeout: 10000, stdio: 'pipe' }).toString();
-        return result || 'No Matches found.';
+        const result = execFileSync('grep', [
+            '-rn',
+            keyword,
+            '--include=*.ts',
+            '--include=*.js',
+            '--include=*.json',
+            '--exclude-dir=node_modules',
+            '--exclude-dir=dist',
+            '--exclude-dir=.git',
+            '.'
+        ], { cwd: process.cwd(), timeout: 10000, stdio: 'pipe' }).toString();
+        return result || 'No matches found.';
     }
     catch {
         return 'No matches found.';
@@ -13,6 +23,6 @@ export const searchCodeTool = tool(async ({ keyword }) => {
     name: 'searchCode',
     description: 'Search for a keyword or function name across all project files. Returns file paths and line numbers where the keyword is found. Use this tool to quickly locate where a specific function or variable is used in the codebase.',
     schema: z.object({
-        keyword: z.string().describe('The Keyword, funtion name, or pattern to search for in the codebase')
+        keyword: z.string().describe('The keyword, function name, or pattern to search for in the codebase')
     })
 });