icopilot 2.2.0

package/dist/tools/grep.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+import { config } from '../config.js';
+import { assertSandbox } from './sandbox.js';
+export async function grepTool(args) {
+    const root = path.resolve(config.cwd, args.path || '.');
+    assertSandbox(root, config.cwd);
+    const maxResults = args.maxResults ?? 200;
+    const matcher = createMatcher(args.pattern, Boolean(args.regex), Boolean(args.ignoreCase));
+    const files = await fg('**/*', {
+        cwd: root,
+        onlyFiles: true,
+        dot: true,
+        ignore: ['**/node_modules/**', '**/dist/**', '**/.git/**'],
+    });
+    const matches = [];
+    let truncated = false;
+    for (const file of files) {
+        if (matches.length >= maxResults) {
+            truncated = true;
+            break;
+        }
+        const abs = path.join(root, file);
+        let content;
+        try {
+            content = fs.readFileSync(abs, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const lines = content.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i += 1) {
+            if (matcher(lines[i] || '')) {
+                matches.push({
+                    file: path.relative(config.cwd, abs),
+                    line: i + 1,
+                    text: lines[i] || '',
+                });
+                if (matches.length >= maxResults) {
+                    truncated = true;
+                    break;
+                }
+            }
+        }
+    }
+    return JSON.stringify({ matches, truncated });
+}
+function createMatcher(pattern, regex, ignoreCase) {
+    if (regex) {
+        const re = new RegExp(pattern, ignoreCase ? 'i' : '');
+        return (line) => re.test(line);
+    }
+    const needle = ignoreCase ? pattern.toLowerCase() : pattern;
+    return (line) => (ignoreCase ? line.toLowerCase() : line).includes(needle);
+}

package/dist/tools/image.js

@@ -0,0 +1,194 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from '../config.js';
+export const IMAGE_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg'];
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const MIME_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+};
+export function readImage(args) {
+    try {
+        const abs = path.resolve(config.cwd, args.path);
+        const ext = path.extname(abs).toLowerCase();
+        if (!IMAGE_EXTENSIONS.includes(ext)) {
+            return { error: `unsupported image extension: ${ext || '(none)'}` };
+        }
+        if (!fs.existsSync(abs)) {
+            return { error: `file not found: ${args.path}` };
+        }
+        const stat = fs.statSync(abs);
+        if (!stat.isFile()) {
+            return { error: `not a file: ${args.path}` };
+        }
+        if (stat.size > MAX_IMAGE_BYTES) {
+            return { error: `image exceeds 10MB limit: ${args.path}` };
+        }
+        const buffer = fs.readFileSync(abs);
+        const dimensions = getDimensions(buffer, ext);
+        return {
+            path: abs,
+            mimeType: MIME_TYPES[ext],
+            width: dimensions?.width,
+            height: dimensions?.height,
+            sizeBytes: stat.size,
+            base64: buffer.toString('base64'),
+        };
+    }
+    catch (e) {
+        return { error: e?.message || String(e) };
+    }
+}
+export const DESCRIBE_IMAGE_SCHEMA = {
+    type: 'function',
+    function: {
+        name: 'describe_image',
+        description: 'Read an image file and return its base64 content for visual analysis',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Path to the image file, relative to the current working directory.',
+                },
+                maxWidth: {
+                    type: 'number',
+                    description: 'Optional hint for downstream visual analysis pipelines.',
+                },
+            },
+            required: ['path'],
+        },
+    },
+};
+function getDimensions(buffer, ext) {
+    switch (ext) {
+        case '.png':
+            return readPngSize(buffer);
+        case '.jpg':
+        case '.jpeg':
+            return readJpegSize(buffer);
+        case '.gif':
+            return readGifSize(buffer);
+        case '.webp':
+            return readWebpSize(buffer);
+        case '.svg':
+            return readSvgSize(buffer);
+        default:
+            return undefined;
+    }
+}
+function readPngSize(buffer) {
+    if (buffer.length < 24)
+        return undefined;
+    if (buffer.toString('ascii', 1, 4) !== 'PNG')
+        return undefined;
+    return {
+        width: buffer.readUInt32BE(16),
+        height: buffer.readUInt32BE(20),
+    };
+}
+function readGifSize(buffer) {
+    if (buffer.length < 10)
+        return undefined;
+    const signature = buffer.toString('ascii', 0, 6);
+    if (signature !== 'GIF87a' && signature !== 'GIF89a')
+        return undefined;
+    return {
+        width: buffer.readUInt16LE(6),
+        height: buffer.readUInt16LE(8),
+    };
+}
+function readJpegSize(buffer) {
+    if (buffer.length < 4 || buffer[0] !== 0xff || buffer[1] !== 0xd8)
+        return undefined;
+    let offset = 2;
+    while (offset + 9 < buffer.length) {
+        if (buffer[offset] !== 0xff) {
+            offset += 1;
+            continue;
+        }
+        const marker = buffer[offset + 1];
+        if (marker === 0xd9 || marker === 0xda)
+            break;
+        if (offset + 4 > buffer.length)
+            break;
+        const length = buffer.readUInt16BE(offset + 2);
+        if (length < 2 || offset + 2 + length > buffer.length)
+            break;
+        if (isSofMarker(marker)) {
+            if (offset + 9 > buffer.length)
+                break;
+            return {
+                height: buffer.readUInt16BE(offset + 5),
+                width: buffer.readUInt16BE(offset + 7),
+            };
+        }
+        offset += 2 + length;
+    }
+    return undefined;
+}
+function isSofMarker(marker) {
+    return ((marker >= 0xc0 && marker <= 0xc3) ||
+        (marker >= 0xc5 && marker <= 0xc7) ||
+        (marker >= 0xc9 && marker <= 0xcb) ||
+        (marker >= 0xcd && marker <= 0xcf));
+}
+function readWebpSize(buffer) {
+    if (buffer.length < 30)
+        return undefined;
+    if (buffer.toString('ascii', 0, 4) !== 'RIFF' || buffer.toString('ascii', 8, 12) !== 'WEBP') {
+        return undefined;
+    }
+    const chunkType = buffer.toString('ascii', 12, 16);
+    if (chunkType === 'VP8X' && buffer.length >= 30) {
+        return {
+            width: 1 + buffer.readUIntLE(24, 3),
+            height: 1 + buffer.readUIntLE(27, 3),
+        };
+    }
+    if (chunkType === 'VP8 ' && buffer.length >= 30) {
+        return {
+            width: buffer.readUInt16LE(26) & 0x3fff,
+            height: buffer.readUInt16LE(28) & 0x3fff,
+        };
+    }
+    if (chunkType === 'VP8L' && buffer.length >= 25) {
+        const bits = buffer.readUInt32LE(21);
+        return {
+            width: (bits & 0x3fff) + 1,
+            height: ((bits >> 14) & 0x3fff) + 1,
+        };
+    }
+    return undefined;
+}
+function readSvgSize(buffer) {
+    const text = buffer.toString('utf8');
+    const width = parseSvgLength(text.match(/\bwidth\s*=\s*['"]([^'"]+)['"]/i)?.[1]);
+    const height = parseSvgLength(text.match(/\bheight\s*=\s*['"]([^'"]+)['"]/i)?.[1]);
+    if (width !== undefined || height !== undefined) {
+        return { width, height };
+    }
+    const viewBox = text.match(/\bviewBox\s*=\s*['"]([^'"]+)['"]/i)?.[1];
+    if (!viewBox)
+        return undefined;
+    const parts = viewBox
+        .trim()
+        .split(/[\s,]+/)
+        .map((part) => Number(part));
+    if (parts.length !== 4 || parts.some((part) => !Number.isFinite(part)))
+        return undefined;
+    return { width: parts[2], height: parts[3] };
+}
+function parseSvgLength(value) {
+    if (!value)
+        return undefined;
+    const match = value.trim().match(/^([0-9]*\.?[0-9]+)/);
+    if (!match)
+        return undefined;
+    const parsed = Number(match[1]);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}

package/dist/tools/list-directory.js

@@ -0,0 +1,228 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from '../config.js';
+import { assertSandbox } from './sandbox.js';
+const DEFAULT_MAX_DEPTH = 2;
+const MAX_ENTRIES = 200;
+const DEFAULT_IGNORES = new Set(['.git', 'node_modules', 'dist']);
+export const listDirectorySchema = {
+    type: 'function',
+    function: {
+        name: 'list_directory',
+        description: 'List directory contents as a formatted tree, respecting .gitignore and optional glob filters.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Directory path relative to the current working directory.',
+                },
+                recursive: {
+                    type: 'boolean',
+                    description: 'Whether to recursively include subdirectories.',
+                },
+                maxDepth: {
+                    type: 'number',
+                    default: DEFAULT_MAX_DEPTH,
+                    description: 'Maximum nested depth when recursive is enabled.',
+                },
+                pattern: {
+                    type: 'string',
+                    description: 'Optional glob pattern used to filter returned entries.',
+                },
+            },
+            required: ['path'],
+        },
+    },
+};
+export async function listDirectory(args) {
+    try {
+        const root = path.resolve(config.cwd, args.path || '.');
+        assertSandbox(root, config.cwd);
+        if (!fs.existsSync(root)) {
+            return `Error: directory not found: ${args.path}`;
+        }
+        const stat = fs.statSync(root);
+        if (!stat.isDirectory()) {
+            return `Error: not a directory: ${args.path}`;
+        }
+        const recursive = Boolean(args.recursive);
+        const maxDepth = recursive ? normalizeMaxDepth(args.maxDepth) : 1;
+        const ignorePatterns = readGitignorePatterns(config.cwd);
+        const matcher = createPatternMatcher(args.pattern);
+        const rootLabel = formatRootLabel(args.path, root);
+        const tree = collectEntries(root, root, 1, maxDepth, recursive, ignorePatterns, matcher);
+        const totalEntries = countEntries(tree);
+        const lines = [`${rootLabel}/`];
+        const emitted = { count: 0 };
+        renderTree(lines, tree, '', emitted);
+        if (totalEntries === 0) {
+            lines.push('(empty)');
+        }
+        else if (totalEntries > MAX_ENTRIES) {
+            lines.push(`… truncated ${totalEntries - MAX_ENTRIES} additional entr${totalEntries - MAX_ENTRIES === 1 ? 'y' : 'ies'} (showing first ${MAX_ENTRIES} of ${totalEntries})`);
+        }
+        return lines.join('\n');
+    }
+    catch (e) {
+        return `Error: ${e?.message || String(e)}`;
+    }
+}
+function collectEntries(currentDir, rootDir, depth, maxDepth, recursive, ignorePatterns, matcher) {
+    let entries;
+    try {
+        entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const nodes = [];
+    const sorted = entries
+        .slice()
+        .sort((left, right) => Number(right.isDirectory()) - Number(left.isDirectory()) ||
+        left.name.localeCompare(right.name));
+    for (const entry of sorted) {
+        const absolutePath = path.join(currentDir, entry.name);
+        const relativeToRoot = normalizeSlashes(path.relative(rootDir, absolutePath));
+        const relativeToCwd = normalizeSlashes(path.relative(config.cwd, absolutePath));
+        const isDirectory = entry.isDirectory();
+        if (shouldIgnore(relativeToCwd, isDirectory, ignorePatterns)) {
+            continue;
+        }
+        let stats;
+        try {
+            stats = fs.statSync(absolutePath);
+        }
+        catch {
+            continue;
+        }
+        const node = {
+            name: entry.name,
+            path: relativeToCwd || '.',
+            type: isDirectory ? 'dir' : 'file',
+            size: isDirectory ? undefined : stats.size,
+            modified: stats.mtime.toISOString(),
+        };
+        if (isDirectory && recursive && depth < maxDepth) {
+            node.children = collectEntries(absolutePath, rootDir, depth + 1, maxDepth, recursive, ignorePatterns, matcher);
+        }
+        const matches = matcher ? matcher(relativeToRoot, entry.name) : true;
+        if (isDirectory) {
+            if (matches || (node.children?.length ?? 0) > 0 || !matcher) {
+                nodes.push(node);
+            }
+        }
+        else if (matches) {
+            nodes.push(node);
+        }
+    }
+    return nodes;
+}
+function renderTree(lines, nodes, prefix, emitted) {
+    for (let index = 0; index < nodes.length; index += 1) {
+        if (emitted.count >= MAX_ENTRIES) {
+            return;
+        }
+        const node = nodes[index];
+        const isLast = index === nodes.length - 1;
+        const connector = isLast ? '└─ ' : '├─ ';
+        lines.push(`${prefix}${connector}${formatNode(node)}`);
+        emitted.count += 1;
+        if (node.type === 'dir' && node.children?.length) {
+            renderTree(lines, node.children, `${prefix}${isLast ? '   ' : '│  '}`, emitted);
+        }
+    }
+}
+function formatNode(node) {
+    const details = [
+        node.type,
+        ...(typeof node.size === 'number' ? [`${node.size} B`] : []),
+        ...(node.modified ? [`modified ${node.modified}`] : []),
+    ];
+    return `${node.name}${node.type === 'dir' ? '/' : ''} [${details.join(', ')}]`;
+}
+function formatRootLabel(inputPath, absolutePath) {
+    if (!inputPath || inputPath === '.')
+        return '.';
+    const relative = path.relative(config.cwd, absolutePath);
+    return relative ? normalizeSlashes(relative) : '.';
+}
+function countEntries(nodes) {
+    return nodes.reduce((total, node) => total + 1 + countEntries(node.children ?? []), 0);
+}
+function normalizeMaxDepth(maxDepth) {
+    if (typeof maxDepth !== 'number' || !Number.isFinite(maxDepth)) {
+        return DEFAULT_MAX_DEPTH;
+    }
+    return Math.max(1, Math.floor(maxDepth));
+}
+function readGitignorePatterns(cwd) {
+    const gitignorePath = path.join(cwd, '.gitignore');
+    if (!fs.existsSync(gitignorePath)) {
+        return [];
+    }
+    try {
+        return fs
+            .readFileSync(gitignorePath, 'utf8')
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith('#') && !line.startsWith('!'));
+    }
+    catch {
+        return [];
+    }
+}
+function shouldIgnore(relativePath, isDirectory, patterns) {
+    if (!relativePath || relativePath.startsWith('..')) {
+        return false;
+    }
+    const normalized = normalizeSlashes(relativePath);
+    const segments = normalized.split('/');
+    if (segments.some((segment) => DEFAULT_IGNORES.has(segment))) {
+        return true;
+    }
+    return patterns.some((pattern) => matchesGitignorePattern(normalized, segments, isDirectory, pattern));
+}
+function matchesGitignorePattern(normalizedPath, segments, isDirectory, pattern) {
+    const normalizedPattern = normalizeSlashes(pattern).replace(/^\/+/, '');
+    const directoryOnly = normalizedPattern.endsWith('/');
+    const barePattern = normalizedPattern.replace(/\/+$/, '');
+    if (directoryOnly && !isDirectory && barePattern === normalizedPath) {
+        return false;
+    }
+    if (!barePattern) {
+        return false;
+    }
+    if (!hasGlob(barePattern) && !barePattern.includes('/')) {
+        return segments.includes(barePattern);
+    }
+    if (!hasGlob(barePattern)) {
+        return normalizedPath === barePattern || normalizedPath.startsWith(`${barePattern}/`);
+    }
+    const regex = globToRegExp(barePattern);
+    return regex.test(normalizedPath);
+}
+function createPatternMatcher(pattern) {
+    if (!pattern?.trim()) {
+        return null;
+    }
+    const normalizedPattern = normalizeSlashes(pattern.trim());
+    const hasSlash = normalizedPattern.includes('/');
+    const regex = globToRegExp(normalizedPattern);
+    return (relativePath, name) => regex.test(hasSlash ? relativePath : name);
+}
+function hasGlob(value) {
+    return /[*?[\]]/.test(value);
+}
+function globToRegExp(pattern) {
+    const source = pattern
+        .replace(/[|\\{}()[\]^$+.]/g, '\\$&')
+        .replace(/\*\*/g, '::DOUBLE_STAR::')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/::DOUBLE_STAR::/g, '.*');
+    return new RegExp(`^${source}$`);
+}
+function normalizeSlashes(value) {
+    return value.split(path.sep).join('/');
+}

package/dist/tools/memory.js

@@ -0,0 +1,17 @@
+export class ToolMemory {
+    allowShell = new Set();
+    allowWritePath = new Set();
+    rememberShell(cmd) {
+        this.allowShell.add(cmd);
+    }
+    isShellRemembered(cmd) {
+        return this.allowShell.has(cmd);
+    }
+    rememberWrite(absPath) {
+        this.allowWritePath.add(absPath);
+    }
+    isWriteRemembered(absPath) {
+        return this.allowWritePath.has(absPath);
+    }
+}
+export const toolMemory = new ToolMemory();