@calliopelabs/cli 2.0.6 → 2.1.1

package/dist/tools.js

@@ -14,6 +14,7 @@ import { getPluginTools, isPluginTool, executePluginTool } from './plugins.js';
 import config from './config.js';
 import { applySkin, applyPalette, listSkins, listPalettes } from './hud/api.js';
 import { listCompanions } from './companions.js';
+import { generateDiff as generateFileDiff } from './diff.js';
 /**
  * Available tools for the agent
  */
@@ -197,6 +198,76 @@ export const TOOLS = [
             required: ['operation'],
         },
     },
+    {
+        name: 'edit_file',
+        description: 'Edit a file by replacing an exact string. Prefer this over write_file for modifications. Fails if old_string is not found or appears multiple times (use replace_all for intentional multi-replace).',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'The path to the file to edit',
+                },
+                old_string: {
+                    type: 'string',
+                    description: 'The exact string to find and replace',
+                },
+                new_string: {
+                    type: 'string',
+                    description: 'The string to replace old_string with',
+                },
+                replace_all: {
+                    type: 'boolean',
+                    description: 'If true, replace all occurrences. If false (default), fails when multiple matches exist.',
+                },
+            },
+            required: ['path', 'old_string', 'new_string'],
+        },
+    },
+    {
+        name: 'glob',
+        description: 'Find files matching a glob pattern (e.g. **/*.ts, src/**/*.json). Returns paths relative to cwd, sorted.',
+        parameters: {
+            type: 'object',
+            properties: {
+                pattern: {
+                    type: 'string',
+                    description: 'Glob pattern to match files against (e.g. **/*.ts, src/**/*.json)',
+                },
+                cwd: {
+                    type: 'string',
+                    description: 'Directory to search in (default: current working directory)',
+                },
+            },
+            required: ['pattern'],
+        },
+    },
+    {
+        name: 'grep',
+        description: 'Search file contents for a pattern. Returns matching lines with file path and line number.',
+        parameters: {
+            type: 'object',
+            properties: {
+                pattern: {
+                    type: 'string',
+                    description: 'The regex or literal string pattern to search for',
+                },
+                path: {
+                    type: 'string',
+                    description: 'Directory or file to search in (default: ".")',
+                },
+                glob: {
+                    type: 'string',
+                    description: 'Filter files by glob pattern (e.g. "*.ts")',
+                },
+                case_insensitive: {
+                    type: 'boolean',
+                    description: 'If true, perform case-insensitive matching',
+                },
+            },
+            required: ['pattern'],
+        },
+    },
     {
         name: 'configure',
         description: `Read, set, or list Calliope configuration options. Use this when the user asks to change settings, switch themes, providers, models, companions, or any preference through natural conversation. Always use action "list" first if you need to show available options.
@@ -560,6 +631,38 @@ export async function executeTool(toolCall, cwd, timeout = 60000, onOutput) {
                 result = generateMermaidDiagram(diagramType, args.content, title);
                 break;
             }
+            case 'edit_file': {
+                if (typeof args.path !== 'string') {
+                    return { toolCallId: id, result: 'Error: path must be a string', isError: true };
+                }
+                if (typeof args.old_string !== 'string') {
+                    return { toolCallId: id, result: 'Error: old_string must be a string', isError: true };
+                }
+                if (typeof args.new_string !== 'string') {
+                    return { toolCallId: id, result: 'Error: new_string must be a string', isError: true };
+                }
+                const replaceAll = args.replace_all === true;
+                result = await editFile(args.path, args.old_string, args.new_string, replaceAll, cwd);
+                break;
+            }
+            case 'glob': {
+                if (typeof args.pattern !== 'string') {
+                    return { toolCallId: id, result: 'Error: pattern must be a string', isError: true };
+                }
+                const globCwd = typeof args.cwd === 'string' ? args.cwd : cwd;
+                result = await globFiles(args.pattern, globCwd);
+                break;
+            }
+            case 'grep': {
+                if (typeof args.pattern !== 'string') {
+                    return { toolCallId: id, result: 'Error: pattern must be a string', isError: true };
+                }
+                const grepPath = typeof args.path === 'string' ? args.path : '.';
+                const grepGlob = typeof args.glob === 'string' ? args.glob : undefined;
+                const caseInsensitive = args.case_insensitive === true;
+                result = await grepFiles(args.pattern, grepPath, cwd, grepGlob, caseInsensitive);
+                break;
+            }
             default:
                 return { toolCallId: id, result: `Unknown tool: ${name}`, isError: true };
         }
@@ -836,7 +939,16 @@ async function readFile(filePath, cwd) {
     if (stats.size > 1024 * 1024) {
         throw new Error(`File too large (${Math.round(stats.size / 1024)}KB). Max 1MB.`);
     }
-    return fs.readFileSync(absPath, 'utf-8');
+    const content = fs.readFileSync(absPath, 'utf-8');
+    // Inline file preview header (#119)
+    const PREVIEW_CAP = 20;
+    const allLines = content.split('\n');
+    const totalLines = allLines.length;
+    const previewLines = allLines.slice(0, PREVIEW_CAP);
+    const header = `[file: ${filePath} \u2014 ${totalLines} line${totalLines !== 1 ? 's' : ''}]\n${'─'.repeat(40)}`;
+    const previewBody = previewLines.join('\n');
+    const footer = totalLines > PREVIEW_CAP ? `\n... (${totalLines - PREVIEW_CAP} more lines)` : '';
+    return `${header}\n${previewBody}${footer}\n\n${content}`;
 }
 /**
  * Generate a simple line-diff between old and new content
@@ -934,24 +1046,42 @@ async function writeFile(filePath, content, cwd) {
         }
     }
     fs.writeFileSync(absPath, content);
-    // Generate diff output
+    // Generate diff output (#119)
+    const DIFF_CAP = 50;
+    const header = `[wrote: ${filePath}]\n${'─'.repeat(Math.min(filePath.length + 9, 60))}`;
     if (isNewFile) {
         const allLines = content.split('\n');
-        const lines = allLines.slice(0, 10);
-        const lineNumWidth = Math.max(4, allLines.length.toString().length);
-        const padNum = (n) => String(n).padStart(lineNumWidth, ' ');
-        const preview = lines.map((l, i) => `${padNum(i + 1)} +  ${l}`).join('\n');
-        const more = allLines.length > 10 ? '\n  ... (new file truncated)' : '';
-        return `DIFF:NEW_FILE:${absPath}\n⎿  Added ${allLines.length} lines\n${preview}${more}`;
+        const previewLines = allLines.slice(0, DIFF_CAP);
+        const diffLines = previewLines.map(l => `+${l}`);
+        const more = allLines.length > DIFF_CAP ? `\n... (${allLines.length - DIFF_CAP} more lines)` : '';
+        return `${header}\n[new file: ${filePath}]\n--- /dev/null\n+++ b/${filePath}\n${diffLines.join('\n')}${more}`;
     }
     else {
-        const diff = generateDiff(oldContent, content);
-        if (diff.trim()) {
-            return `DIFF:${absPath}\n${diff}`;
+        const fileDiff = generateFileDiff(oldContent, content, filePath);
+        const diffParts = [
+            `--- a/${filePath}`,
+            `+++ b/${filePath}`,
+        ];
+        const diffLines = fileDiff.lines.filter(l => l.type !== 'header');
+        let lineCount = 0;
+        let truncated = false;
+        for (const line of diffLines) {
+            if (line.type === 'context')
+                continue; // skip context for compact output
+            if (lineCount >= DIFF_CAP) {
+                truncated = true;
+                break;
+            }
+            const prefix = line.type === 'add' ? '+' : '-';
+            diffParts.push(`${prefix}${line.content}`);
+            lineCount++;
         }
-        else {
-            return `File unchanged: ${absPath}`;
+        if (truncated)
+            diffParts.push(`... (diff truncated at ${DIFF_CAP} lines)`);
+        if (lineCount === 0) {
+            return `File unchanged: ${filePath}`;
         }
+        return `${header}\n${diffParts.join('\n')}`;
     }
 }
 /**
@@ -1213,4 +1343,258 @@ ${content}
 \`\`\``;
     return `MERMAID_DIAGRAM:\n${diagram}\n\nTo view this diagram, paste the mermaid code into https://mermaid.live or a markdown viewer that supports Mermaid.`;
 }
+/**
+ * Edit a file by replacing an exact string (in-place edit).
+ * Supports single-occurrence enforcement or replace_all mode.
+ */
+async function editFile(filePath, oldString, newString, replaceAll, cwd) {
+    const absPath = validatePath(filePath, cwd);
+    if (!fs.existsSync(absPath)) {
+        throw new Error(`File not found: ${absPath}`);
+    }
+    const stats = fs.statSync(absPath);
+    if (stats.isDirectory()) {
+        throw new Error(`Path is a directory: ${absPath}`);
+    }
+    const content = fs.readFileSync(absPath, 'utf-8');
+    // Helper to build a compact edit diff from old_string/new_string (#119)
+    const buildEditDiff = (oldStr, newStr, fPath, count) => {
+        const DIFF_CAP = 50;
+        const label = count === 1 ? '1 occurrence' : `${count} occurrences`;
+        const header = `[edited: ${fPath} — replaced ${label}]\n${'─'.repeat(Math.min(fPath.length + 10, 60))}`;
+        const oldLines = oldStr.split('\n');
+        const newLines = newStr.split('\n');
+        const diffParts = [
+            `--- a/${fPath}`,
+            `+++ b/${fPath}`,
+        ];
+        let lineCount = 0;
+        let truncated = false;
+        for (const line of oldLines) {
+            if (lineCount >= DIFF_CAP) {
+                truncated = true;
+                break;
+            }
+            diffParts.push(`-${line}`);
+            lineCount++;
+        }
+        if (!truncated) {
+            for (const line of newLines) {
+                if (lineCount >= DIFF_CAP) {
+                    truncated = true;
+                    break;
+                }
+                diffParts.push(`+${line}`);
+                lineCount++;
+            }
+        }
+        if (truncated)
+            diffParts.push(`... (diff truncated at ${DIFF_CAP} lines)`);
+        return `${header}\n${diffParts.join('\n')}`;
+    };
+    if (replaceAll) {
+        const updated = content.replaceAll(oldString, newString);
+        const count = (content.split(oldString).length - 1);
+        if (count === 0) {
+            throw new Error(`old_string not found in file: ${absPath}`);
+        }
+        fs.writeFileSync(absPath, updated);
+        return buildEditDiff(oldString, newString, filePath, count);
+    }
+    // Count occurrences
+    const occurrences = content.split(oldString).length - 1;
+    if (occurrences === 0) {
+        throw new Error(`old_string not found in file: ${absPath}`);
+    }
+    if (occurrences > 1) {
+        throw new Error(`old_string matches ${occurrences} occurrences — use replace_all: true or make it more specific`);
+    }
+    const updated = content.replace(oldString, newString);
+    fs.writeFileSync(absPath, updated);
+    return buildEditDiff(oldString, newString, filePath, 1);
+}
+/**
+ * Convert a glob pattern to a RegExp.
+ * Supports: *, **, ?, {a,b} syntax.
+ */
+function globToRegex(pattern) {
+    let regexStr = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                // ** matches any path segment including slashes
+                regexStr += '.*';
+                i += 2;
+                // Consume optional trailing slash
+                if (pattern[i] === '/')
+                    i++;
+            }
+            else {
+                // * matches anything except /
+                regexStr += '[^/]*';
+                i++;
+            }
+        }
+        else if (ch === '?') {
+            regexStr += '[^/]';
+            i++;
+        }
+        else if (ch === '{') {
+            // {a,b,c} → (a|b|c)
+            const end = pattern.indexOf('}', i);
+            if (end === -1) {
+                regexStr += '\\{';
+                i++;
+            }
+            else {
+                const options = pattern.slice(i + 1, end).split(',').map(s => s.replace(/[.+^$[\]\\(){}|]/g, '\\$&'));
+                regexStr += `(?:${options.join('|')})`;
+                i = end + 1;
+            }
+        }
+        else if ('.+^$[]\\(){}|'.includes(ch)) {
+            regexStr += '\\' + ch;
+            i++;
+        }
+        else {
+            regexStr += ch;
+            i++;
+        }
+    }
+    return new RegExp(`^${regexStr}$`);
+}
+/**
+ * Recursively walk a directory and collect all file paths relative to the base.
+ */
+function walkDir(dir, base, results) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relPath = path.relative(base, fullPath);
+        if (entry.isDirectory()) {
+            walkDir(fullPath, base, results);
+        }
+        else {
+            results.push(relPath);
+        }
+    }
+}
+/**
+ * Find files matching a glob pattern.
+ */
+async function globFiles(pattern, searchCwd) {
+    const absCwd = path.isAbsolute(searchCwd)
+        ? path.resolve(searchCwd)
+        : path.resolve(searchCwd);
+    let exists = false;
+    try {
+        exists = fs.existsSync(absCwd) && fs.statSync(absCwd).isDirectory();
+    }
+    catch {
+        exists = false;
+    }
+    if (!exists) {
+        throw new Error(`Directory not found: ${absCwd}`);
+    }
+    const regex = globToRegex(pattern);
+    const allFiles = [];
+    walkDir(absCwd, absCwd, allFiles);
+    // Normalize to forward slashes for matching (glob convention)
+    const matched = allFiles
+        .filter(f => regex.test(f.replace(/\\/g, '/')))
+        .sort();
+    if (matched.length === 0) {
+        return `No files matched pattern: ${pattern}`;
+    }
+    return matched.join('\n');
+}
+/**
+ * Search file contents using a regex pattern (or literal string fallback).
+ */
+async function grepFiles(pattern, searchPath, cwd, globPattern, caseInsensitive) {
+    // Resolve search path relative to cwd
+    const absSearchPath = path.isAbsolute(searchPath)
+        ? path.resolve(searchPath)
+        : path.resolve(cwd, searchPath);
+    // Validate access
+    try {
+        validatePath(absSearchPath, cwd);
+    }
+    catch {
+        throw new Error(`Access denied: ${searchPath} is outside allowed scope`);
+    }
+    if (!fs.existsSync(absSearchPath)) {
+        throw new Error(`Path not found: ${absSearchPath}`);
+    }
+    // Build the regex, fallback to literal if invalid
+    let regex;
+    try {
+        regex = new RegExp(pattern, caseInsensitive ? 'i' : '');
+    }
+    catch {
+        // Treat as literal string
+        const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        regex = new RegExp(escaped, caseInsensitive ? 'i' : '');
+    }
+    // Collect files to search
+    let filesToSearch;
+    const stat = fs.statSync(absSearchPath);
+    if (stat.isFile()) {
+        filesToSearch = [absSearchPath];
+    }
+    else {
+        const all = [];
+        walkDir(absSearchPath, absSearchPath, all);
+        filesToSearch = all.map(f => path.join(absSearchPath, f));
+    }
+    // Apply glob filter if provided
+    if (globPattern) {
+        const globRegex = globToRegex(globPattern);
+        filesToSearch = filesToSearch.filter(f => {
+            const basename = path.basename(f);
+            return globRegex.test(basename) || globRegex.test(f.replace(/\\/g, '/'));
+        });
+    }
+    const results = [];
+    const MAX_RESULTS = 200;
+    for (const filePath of filesToSearch) {
+        if (results.length >= MAX_RESULTS)
+            break;
+        let content;
+        try {
+            const fileStat = fs.statSync(filePath);
+            if (fileStat.size > 5 * 1024 * 1024)
+                continue; // skip files > 5MB
+            content = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const lines = content.split('\n');
+        const relPath = path.relative(cwd, filePath);
+        for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+            if (results.length >= MAX_RESULTS)
+                break;
+            if (regex.test(lines[lineIdx])) {
+                results.push(`${relPath}:${lineIdx + 1}: ${lines[lineIdx]}`);
+            }
+        }
+    }
+    if (results.length === 0) {
+        return 'No matches found';
+    }
+    let output = results.join('\n');
+    if (results.length >= MAX_RESULTS) {
+        output += `\n(results truncated at ${MAX_RESULTS} matches)`;
+    }
+    return output;
+}
 //# sourceMappingURL=tools.js.map