cowork-os 0.3.21

package/dist/electron/electron/agent/tools/glob-tools.js

@@ -0,0 +1,283 @@
+"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.GlobTools = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * GlobTools provides fast pattern-based file search
+ * Similar to Claude Code's Glob tool for finding files by pattern
+ */
+class GlobTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    /**
+     * Update the workspace for this tool
+     */
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+    }
+    /**
+     * Get tool definitions for Glob tools
+     */
+    static getToolDefinitions() {
+        return [
+            {
+                name: 'glob',
+                description: 'Fast file pattern matching tool. Use glob patterns like "**/*.ts" or "src/**/*.tsx" to find files. ' +
+                    'Returns matching file paths sorted by modification time (newest first). ' +
+                    'PREFERRED over search_files when you know the file pattern you want.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        pattern: {
+                            type: 'string',
+                            description: 'Glob pattern to match files (e.g., "**/*.ts", "src/**/*.test.ts", "*.{js,jsx,ts,tsx}")',
+                        },
+                        path: {
+                            type: 'string',
+                            description: 'Directory to search in (relative to workspace unless absolute path is allowed). Defaults to workspace root if not specified.',
+                        },
+                        maxResults: {
+                            type: 'number',
+                            description: 'Maximum number of results to return (default: 100)',
+                        },
+                    },
+                    required: ['pattern'],
+                },
+            },
+        ];
+    }
+    /**
+     * Execute glob pattern search
+     */
+    async glob(input) {
+        const { pattern, path: searchPath, maxResults = 100 } = input;
+        this.daemon.logEvent(this.taskId, 'log', {
+            message: `Glob search: ${pattern}${searchPath ? ` in ${searchPath}` : ''}`,
+        });
+        try {
+            const normalizedWorkspace = path.resolve(this.workspace.path);
+            const basePath = searchPath
+                ? (path.isAbsolute(searchPath)
+                    ? path.normalize(searchPath)
+                    : path.resolve(normalizedWorkspace, searchPath))
+                : normalizedWorkspace;
+            const isInsideWorkspace = this.isWithinWorkspace(basePath, normalizedWorkspace);
+            if (!isInsideWorkspace && !this.isPathAllowedOutsideWorkspace(basePath)) {
+                throw new Error('Search path must be within workspace');
+            }
+            if (!fs.existsSync(basePath)) {
+                throw new Error(`Path does not exist: ${searchPath || '.'}`);
+            }
+            // Parse the glob pattern
+            const matches = await this.findMatches(basePath, pattern);
+            // Sort by modification time (newest first)
+            matches.sort((a, b) => b.mtime - a.mtime);
+            // Truncate if needed
+            const truncated = matches.length > maxResults;
+            const limitedMatches = matches.slice(0, maxResults);
+            // Format results
+            const results = limitedMatches.map((m) => ({
+                path: isInsideWorkspace ? path.relative(normalizedWorkspace, m.path) : m.path,
+                size: m.size,
+                modified: new Date(m.mtime).toISOString(),
+            }));
+            this.daemon.logEvent(this.taskId, 'tool_result', {
+                tool: 'glob',
+                result: {
+                    pattern,
+                    matchCount: results.length,
+                    totalMatches: matches.length,
+                    truncated,
+                },
+            });
+            return {
+                success: true,
+                pattern,
+                matches: results,
+                totalMatches: matches.length,
+                truncated,
+            };
+        }
+        catch (error) {
+            this.daemon.logEvent(this.taskId, 'tool_result', {
+                tool: 'glob',
+                error: error.message,
+            });
+            return {
+                success: false,
+                pattern,
+                matches: [],
+                totalMatches: 0,
+                truncated: false,
+                error: error.message,
+            };
+        }
+    }
+    isWithinWorkspace(basePath, workspacePath) {
+        const relative = path.relative(workspacePath, basePath);
+        return !relative.startsWith('..') && !path.isAbsolute(relative);
+    }
+    isPathAllowedOutsideWorkspace(basePath) {
+        if (this.workspace.isTemp)
+            return true;
+        if (this.workspace.permissions.unrestrictedFileAccess)
+            return true;
+        const allowedPaths = this.workspace.permissions.allowedPaths;
+        if (!allowedPaths || allowedPaths.length === 0) {
+            return false;
+        }
+        const normalizedPath = path.normalize(basePath);
+        return allowedPaths.some(allowed => {
+            const normalizedAllowed = path.normalize(allowed);
+            return normalizedPath === normalizedAllowed ||
+                normalizedPath.startsWith(normalizedAllowed + path.sep);
+        });
+    }
+    /**
+     * Find files matching the glob pattern
+     */
+    async findMatches(basePath, pattern) {
+        const matches = [];
+        const regex = this.globToRegex(pattern);
+        await this.walkDirectory(basePath, basePath, regex, matches);
+        return matches;
+    }
+    /**
+     * Recursively walk directory and collect matches
+     */
+    async walkDirectory(currentPath, basePath, regex, matches, depth = 0) {
+        // Limit recursion depth to prevent infinite loops
+        if (depth > 50)
+            return;
+        // Skip common non-code directories
+        const dirName = path.basename(currentPath);
+        const skipDirs = [
+            'node_modules',
+            '.git',
+            '.svn',
+            '.hg',
+            'dist',
+            'build',
+            'coverage',
+            '.next',
+            '.nuxt',
+            '__pycache__',
+            '.pytest_cache',
+            'venv',
+            '.venv',
+            'env',
+            '.env',
+        ];
+        if (depth > 0 && skipDirs.includes(dirName)) {
+            return;
+        }
+        try {
+            const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentPath, entry.name);
+                const relativePath = path.relative(basePath, fullPath);
+                if (entry.isDirectory()) {
+                    await this.walkDirectory(fullPath, basePath, regex, matches, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    // Test against the pattern
+                    if (regex.test(relativePath) || regex.test(entry.name)) {
+                        try {
+                            const stats = fs.statSync(fullPath);
+                            matches.push({
+                                path: fullPath,
+                                size: stats.size,
+                                mtime: stats.mtimeMs,
+                            });
+                        }
+                        catch {
+                            // Skip files we can't stat
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip directories we can't read
+        }
+    }
+    /**
+     * Convert glob pattern to regex
+     */
+    globToRegex(pattern) {
+        // Handle brace expansion {a,b,c}
+        const expandedPatterns = this.expandBraces(pattern);
+        // Convert each pattern to regex
+        const regexParts = expandedPatterns.map((p) => {
+            let regex = p
+                // Escape special regex characters (except glob chars * and ?)
+                .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+                // ** matches any path (including /) - must be before single * replacement
+                .replace(/\*\*/g, '.*')
+                // * matches anything except /
+                .replace(/\*/g, '[^/]*')
+                // ? matches single character except /
+                .replace(/\?/g, '[^/]');
+            return regex;
+        });
+        // Combine patterns with OR
+        const combined = regexParts.length > 1 ? `(${regexParts.join('|')})` : regexParts[0];
+        return new RegExp(`^${combined}$`, 'i');
+    }
+    /**
+     * Expand brace patterns like {a,b,c}
+     */
+    expandBraces(pattern) {
+        const braceMatch = pattern.match(/\{([^}]+)\}/);
+        if (!braceMatch) {
+            return [pattern];
+        }
+        const [fullMatch, options] = braceMatch;
+        const optionList = options.split(',');
+        const results = [];
+        for (const option of optionList) {
+            const expanded = pattern.replace(fullMatch, option.trim());
+            // Recursively expand nested braces
+            results.push(...this.expandBraces(expanded));
+        }
+        return results;
+    }
+}
+exports.GlobTools = GlobTools;

package/dist/electron/electron/agent/tools/grep-tools.js

@@ -0,0 +1,387 @@
+"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.GrepTools = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * GrepTools provides powerful regex-based content search
+ * Similar to Claude Code's Grep tool (ripgrep-based)
+ */
+class GrepTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    /**
+     * Update the workspace for this tool
+     */
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+    }
+    /**
+     * Get tool definitions for Grep tools
+     */
+    static getToolDefinitions() {
+        return [
+            {
+                name: 'grep',
+                description: 'Powerful regex-based content search across files. ' +
+                    'Supports full regex syntax (e.g., "async function.*fetch", "class\\s+\\w+"). ' +
+                    'Use this to find code patterns, function definitions, imports, etc. ' +
+                    'PREFERRED over search_files for content search.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        pattern: {
+                            type: 'string',
+                            description: 'Regular expression pattern to search for in file contents',
+                        },
+                        path: {
+                            type: 'string',
+                            description: 'Directory or file to search in (relative to workspace). Defaults to workspace root.',
+                        },
+                        glob: {
+                            type: 'string',
+                            description: 'Glob pattern to filter files (e.g., "*.ts", "**/*.{js,jsx}")',
+                        },
+                        ignoreCase: {
+                            type: 'boolean',
+                            description: 'Case insensitive search (default: false)',
+                        },
+                        contextLines: {
+                            type: 'number',
+                            description: 'Number of context lines before and after match (default: 0)',
+                        },
+                        maxResults: {
+                            type: 'number',
+                            description: 'Maximum number of matches to return (default: 50)',
+                        },
+                        outputMode: {
+                            type: 'string',
+                            enum: ['content', 'files_only', 'count'],
+                            description: 'Output mode: "content" shows matching lines (default), "files_only" shows file paths, "count" shows match counts',
+                        },
+                    },
+                    required: ['pattern'],
+                },
+            },
+        ];
+    }
+    /**
+     * Execute grep search
+     */
+    async grep(input) {
+        const { pattern, path: searchPath, glob: globPattern, ignoreCase = false, contextLines = 0, maxResults = 50, outputMode = 'content', } = input;
+        this.daemon.logEvent(this.taskId, 'log', {
+            message: `Grep search: "${pattern}"${searchPath ? ` in ${searchPath}` : ''}${globPattern ? ` (${globPattern})` : ''}`,
+        });
+        try {
+            // Compile regex
+            let regex;
+            try {
+                regex = new RegExp(pattern, ignoreCase ? 'gi' : 'g');
+            }
+            catch (e) {
+                throw new Error(`Invalid regex pattern: ${e.message}`);
+            }
+            const basePath = searchPath
+                ? path.resolve(this.workspace.path, searchPath)
+                : this.workspace.path;
+            // Validate path is within workspace
+            if (!basePath.startsWith(this.workspace.path)) {
+                throw new Error('Search path must be within workspace');
+            }
+            if (!fs.existsSync(basePath)) {
+                throw new Error(`Path does not exist: ${searchPath || '.'}`);
+            }
+            // Find files to search
+            const files = await this.findFilesToSearch(basePath, globPattern);
+            const matches = [];
+            let totalMatches = 0;
+            let truncated = false;
+            // Search each file
+            for (const file of files) {
+                if (truncated)
+                    break;
+                try {
+                    const content = fs.readFileSync(file, 'utf-8');
+                    const lines = content.split('\n');
+                    const relativePath = path.relative(this.workspace.path, file);
+                    if (outputMode === 'count') {
+                        // Count matches in file
+                        const fileMatches = (content.match(regex) || []).length;
+                        if (fileMatches > 0) {
+                            totalMatches += fileMatches;
+                            matches.push({
+                                file: relativePath,
+                                count: fileMatches,
+                            });
+                        }
+                    }
+                    else if (outputMode === 'files_only') {
+                        // Just check if file has matches
+                        if (regex.test(content)) {
+                            totalMatches++;
+                            matches.push({ file: relativePath });
+                            if (matches.length >= maxResults) {
+                                truncated = true;
+                            }
+                        }
+                    }
+                    else {
+                        // Content mode - show matching lines
+                        for (let i = 0; i < lines.length; i++) {
+                            regex.lastIndex = 0; // Reset regex state
+                            if (regex.test(lines[i])) {
+                                totalMatches++;
+                                const match = {
+                                    file: relativePath,
+                                    line: i + 1,
+                                    content: lines[i].trim(),
+                                };
+                                // Add context lines if requested
+                                if (contextLines > 0) {
+                                    const beforeStart = Math.max(0, i - contextLines);
+                                    const afterEnd = Math.min(lines.length - 1, i + contextLines);
+                                    match.context = {
+                                        before: lines.slice(beforeStart, i).map((l) => l.trim()),
+                                        after: lines.slice(i + 1, afterEnd + 1).map((l) => l.trim()),
+                                    };
+                                }
+                                matches.push(match);
+                                if (matches.length >= maxResults) {
+                                    truncated = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Skip files we can't read (binary, permissions, etc.)
+                }
+            }
+            this.daemon.logEvent(this.taskId, 'tool_result', {
+                tool: 'grep',
+                result: {
+                    pattern,
+                    matchCount: matches.length,
+                    totalMatches,
+                    filesSearched: files.length,
+                    truncated,
+                },
+            });
+            return {
+                success: true,
+                pattern,
+                matches,
+                totalMatches,
+                filesSearched: files.length,
+                truncated,
+            };
+        }
+        catch (error) {
+            this.daemon.logEvent(this.taskId, 'tool_result', {
+                tool: 'grep',
+                error: error.message,
+            });
+            return {
+                success: false,
+                pattern,
+                matches: [],
+                totalMatches: 0,
+                filesSearched: 0,
+                truncated: false,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Find files to search based on path and glob pattern
+     */
+    async findFilesToSearch(basePath, globPattern) {
+        const files = [];
+        const globRegex = globPattern ? this.globToRegex(globPattern) : null;
+        await this.walkDirectory(basePath, basePath, files, globRegex);
+        return files;
+    }
+    /**
+     * Recursively walk directory and collect text files
+     */
+    async walkDirectory(currentPath, basePath, files, globRegex, depth = 0) {
+        // Limit recursion depth
+        if (depth > 50)
+            return;
+        // Skip common non-code directories
+        const dirName = path.basename(currentPath);
+        const skipDirs = [
+            'node_modules',
+            '.git',
+            '.svn',
+            '.hg',
+            'dist',
+            'build',
+            'coverage',
+            '.next',
+            '.nuxt',
+            '__pycache__',
+            '.pytest_cache',
+            'venv',
+            '.venv',
+        ];
+        if (depth > 0 && skipDirs.includes(dirName)) {
+            return;
+        }
+        try {
+            const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentPath, entry.name);
+                const relativePath = path.relative(basePath, fullPath);
+                if (entry.isDirectory()) {
+                    await this.walkDirectory(fullPath, basePath, files, globRegex, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    // Skip binary and large files
+                    if (this.isBinaryFile(entry.name))
+                        continue;
+                    try {
+                        const stats = fs.statSync(fullPath);
+                        // Skip files larger than 1MB
+                        if (stats.size > 1024 * 1024)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    // Apply glob filter if specified
+                    if (globRegex) {
+                        if (!globRegex.test(relativePath) && !globRegex.test(entry.name)) {
+                            continue;
+                        }
+                    }
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Skip directories we can't read
+        }
+    }
+    /**
+     * Check if file appears to be binary
+     */
+    isBinaryFile(filename) {
+        const binaryExtensions = [
+            '.png',
+            '.jpg',
+            '.jpeg',
+            '.gif',
+            '.bmp',
+            '.ico',
+            '.webp',
+            '.svg',
+            '.pdf',
+            '.doc',
+            '.docx',
+            '.xls',
+            '.xlsx',
+            '.ppt',
+            '.pptx',
+            '.zip',
+            '.tar',
+            '.gz',
+            '.rar',
+            '.7z',
+            '.exe',
+            '.dll',
+            '.so',
+            '.dylib',
+            '.bin',
+            '.dat',
+            '.db',
+            '.sqlite',
+            '.mp3',
+            '.mp4',
+            '.avi',
+            '.mov',
+            '.mkv',
+            '.wav',
+            '.flac',
+            '.woff',
+            '.woff2',
+            '.ttf',
+            '.eot',
+            '.otf',
+        ];
+        const ext = path.extname(filename).toLowerCase();
+        return binaryExtensions.includes(ext);
+    }
+    /**
+     * Convert glob pattern to regex
+     */
+    globToRegex(pattern) {
+        // Handle brace expansion
+        const expandedPatterns = this.expandBraces(pattern);
+        const regexParts = expandedPatterns.map((p) => {
+            let regex = p
+                .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+                .replace(/\\\*\\\*/g, '.*')
+                .replace(/\\\*/g, '[^/]*')
+                .replace(/\\\?/g, '[^/]');
+            return regex;
+        });
+        const combined = regexParts.length > 1 ? `(${regexParts.join('|')})` : regexParts[0];
+        return new RegExp(`^${combined}$`, 'i');
+    }
+    /**
+     * Expand brace patterns
+     */
+    expandBraces(pattern) {
+        const braceMatch = pattern.match(/\{([^}]+)\}/);
+        if (!braceMatch)
+            return [pattern];
+        const [fullMatch, options] = braceMatch;
+        const optionList = options.split(',');
+        const results = [];
+        for (const option of optionList) {
+            const expanded = pattern.replace(fullMatch, option.trim());
+            results.push(...this.expandBraces(expanded));
+        }
+        return results;
+    }
+}
+exports.GrepTools = GrepTools;