kyawthiha-nextjs-agent-cli 1.0.0

package/dist/agent/tools/file-tools.js

@@ -0,0 +1,199 @@
+/**
+ * File system tools for the AI Agent
+ */
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Tool: Read file contents
+ */
+export const readFileTool = {
+    name: 'read_file',
+    description: 'Read the contents of a file at the specified path. Use this to understand existing code before modifying.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'The file path to read'
+            }
+        },
+        required: ['path']
+    },
+    execute: async (input) => {
+        try {
+            const content = await fs.readFile(input.path, 'utf-8');
+            return content;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return `Error: File not found: ${input.path}`;
+            }
+            return `Error reading file: ${error.message}`;
+        }
+    }
+};
+/**
+ * Tool: Write file contents
+ */
+export const writeFileTool = {
+    name: 'write_file',
+    description: 'Write content to a file. Creates the file if it does not exist, or overwrites it if it does. Also creates parent directories if needed. ALWAYS write complete file content.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'The file path to write to'
+            },
+            content: {
+                type: 'string',
+                description: 'The COMPLETE content to write to the file'
+            }
+        },
+        required: ['path', 'content']
+    },
+    execute: async (input) => {
+        try {
+            // Ensure parent directory exists
+            const dir = path.dirname(input.path);
+            await fs.mkdir(dir, { recursive: true });
+            await fs.writeFile(input.path, input.content, 'utf-8');
+            return `Successfully wrote ${input.content.length} characters to ${input.path}`;
+        }
+        catch (error) {
+            return `Error writing file: ${error.message}`;
+        }
+    }
+};
+/**
+ * Tool: List files in directory
+ */
+export const listFilesTool = {
+    name: 'list_files',
+    description: 'List all files and directories at the specified path. Returns a JSON array of file/directory names.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'The directory path to list'
+            },
+            recursive: {
+                type: 'string',
+                description: 'Set to "true" to list files recursively (default: false)',
+                enum: ['true', 'false']
+            }
+        },
+        required: ['path']
+    },
+    execute: async (input) => {
+        try {
+            const targetPath = input.path;
+            const recursive = input.recursive === 'true';
+            const stat = await fs.stat(targetPath).catch(() => null);
+            if (!stat) {
+                return `Directory does not exist: ${targetPath}`;
+            }
+            if (!stat.isDirectory()) {
+                return `Not a directory: ${targetPath}`;
+            }
+            if (recursive) {
+                const files = [];
+                const walk = async (dir) => {
+                    const entries = await fs.readdir(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        // Skip node_modules and hidden directories
+                        if (entry.name.startsWith('.') || entry.name === 'node_modules') {
+                            continue;
+                        }
+                        const fullPath = path.join(dir, entry.name);
+                        const relativePath = path.relative(targetPath, fullPath);
+                        if (entry.isDirectory()) {
+                            files.push(relativePath + '/');
+                            await walk(fullPath);
+                        }
+                        else {
+                            files.push(relativePath);
+                        }
+                    }
+                };
+                await walk(targetPath);
+                return JSON.stringify(files, null, 2);
+            }
+            else {
+                const entries = await fs.readdir(targetPath, { withFileTypes: true });
+                const files = entries
+                    .filter(e => !e.name.startsWith('.'))
+                    .map(e => e.isDirectory() ? e.name + '/' : e.name);
+                return JSON.stringify(files, null, 2);
+            }
+        }
+        catch (error) {
+            return `Error listing files: ${error.message}`;
+        }
+    }
+};
+/**
+ * Tool: Create directory
+ */
+export const createDirectoryTool = {
+    name: 'create_directory',
+    description: 'Create a directory at the specified path. Creates parent directories if needed.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'The directory path to create'
+            }
+        },
+        required: ['path']
+    },
+    execute: async (input) => {
+        try {
+            await fs.mkdir(input.path, { recursive: true });
+            return `Successfully created directory: ${input.path}`;
+        }
+        catch (error) {
+            return `Error creating directory: ${error.message}`;
+        }
+    }
+};
+/**
+ * Tool: Check if file exists
+ */
+export const fileExistsTool = {
+    name: 'file_exists',
+    description: 'Check if a file or directory exists at the specified path.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'The file or directory path to check'
+            }
+        },
+        required: ['path']
+    },
+    execute: async (input) => {
+        try {
+            const stat = await fs.stat(input.path);
+            return `Exists: ${stat.isDirectory() ? 'directory' : 'file'}`;
+        }
+        catch {
+            return 'Does not exist';
+        }
+    }
+};
+/**
+ * Get all file tools
+ */
+export function getFileTools() {
+    return [
+        readFileTool,
+        writeFileTool,
+        listFilesTool,
+        createDirectoryTool,
+        fileExistsTool,
+    ];
+}

package/dist/agent/tools/index.js

@@ -0,0 +1,25 @@
+/**
+ * Tool registry - exports all tools for the agent
+ */
+export { getFileTools } from './file-tools.js';
+export { getCodeTools } from './code-tools.js';
+export { getSearchTools } from './search-tools.js';
+export { getAstTools } from './ast-tools.js';
+export { getShellTools } from './shell-tools.js';
+import { getFileTools } from './file-tools.js';
+import { getCodeTools } from './code-tools.js';
+import { getSearchTools } from './search-tools.js';
+import { getAstTools } from './ast-tools.js';
+import { getShellTools } from './shell-tools.js';
+/**
+ * Get all available tools
+ */
+export function getAllTools() {
+    return [
+        ...getFileTools(),
+        ...getCodeTools(),
+        ...getSearchTools(),
+        ...getAstTools(),
+        ...getShellTools(),
+    ];
+}

package/dist/agent/tools/search-tools.js

@@ -0,0 +1,404 @@
+/**
+ * Search tools for the AI Agent
+ * Uses ripgrep for fast pattern search across codebase
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import fs from 'fs/promises';
+const execAsync = promisify(exec);
+/**
+ * Check if ripgrep is available
+ */
+async function hasRipgrep() {
+    try {
+        await execAsync('rg --version');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if fd is available (faster file finder)
+ */
+async function hasFd() {
+    try {
+        await execAsync('fd --version');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Tool: Ripgrep Search
+ * Fast pattern search using ripgrep with context lines
+ */
+export const ripgrepSearchTool = {
+    name: 'ripgrep_search',
+    description: `Fast pattern search across codebase using ripgrep.
+Returns matches with file path, line number, and context.
+
+Output format:
+FILE:LINE: content
+FILE:LINE: content
+
+Best for:
+- Finding function/class definitions
+- Searching for specific text patterns
+- Finding usages of variables/imports`,
+    parameters: {
+        type: 'object',
+        properties: {
+            pattern: {
+                type: 'string',
+                description: 'Search pattern (supports regex)'
+            },
+            path: {
+                type: 'string',
+                description: 'Directory or file to search in'
+            },
+            fileType: {
+                type: 'string',
+                description: 'File type filter (e.g., "ts", "tsx", "js", "py")'
+            },
+            contextLines: {
+                type: 'string',
+                description: 'Number of context lines before/after match (default: 2)'
+            },
+            caseSensitive: {
+                type: 'string',
+                description: 'Case sensitive search',
+                enum: ['true', 'false']
+            },
+            wholeWord: {
+                type: 'string',
+                description: 'Match whole words only',
+                enum: ['true', 'false']
+            },
+            maxResults: {
+                type: 'string',
+                description: 'Maximum number of results (default: 50)'
+            }
+        },
+        required: ['pattern', 'path']
+    },
+    execute: async (input) => {
+        try {
+            const searchPath = input.path;
+            const pattern = input.pattern;
+            const fileType = input.fileType;
+            const contextLines = parseInt(input.contextLines || '2', 10);
+            const caseSensitive = input.caseSensitive === 'true';
+            const wholeWord = input.wholeWord === 'true';
+            const maxResults = parseInt(input.maxResults || '50', 10);
+            // Check if path exists
+            try {
+                await fs.access(searchPath);
+            }
+            catch {
+                return `Error: Path does not exist: ${searchPath}`;
+            }
+            // Check if ripgrep is available
+            if (!(await hasRipgrep())) {
+                return `Error: ripgrep (rg) is not installed.
+Install it:
+- Windows: winget install BurntSushi.ripgrep.MSVC
+- Mac: brew install ripgrep
+- Linux: apt install ripgrep`;
+            }
+            // Build ripgrep command
+            const args = [
+                '--line-number', // Show line numbers
+                '--no-heading', // Don't group by file
+                '--color=never', // No color codes
+                `--context=${contextLines}`,
+                `--max-count=${maxResults}`,
+            ];
+            // File type filter
+            if (fileType) {
+                args.push(`--type-add=custom:*.${fileType}`);
+                args.push('--type=custom');
+            }
+            // Case sensitivity
+            if (!caseSensitive) {
+                args.push('--ignore-case');
+            }
+            // Whole word
+            if (wholeWord) {
+                args.push('--word-regexp');
+            }
+            // Exclude common directories
+            args.push('--glob=!node_modules');
+            args.push('--glob=!.git');
+            args.push('--glob=!dist');
+            args.push('--glob=!.next');
+            args.push('--glob=!build');
+            args.push('--glob=!*.lock');
+            // Escape pattern for shell
+            const escapedPattern = pattern.replace(/"/g, '\\"');
+            const command = `rg ${args.join(' ')} "${escapedPattern}" "${searchPath}"`;
+            const shell = process.platform === 'win32' ? 'powershell.exe' : '/bin/bash';
+            const { stdout, stderr } = await execAsync(command, {
+                shell,
+                maxBuffer: 10 * 1024 * 1024, // 10MB
+                timeout: 30000
+            });
+            if (!stdout.trim()) {
+                return `No matches found for "${pattern}" in ${searchPath}`;
+            }
+            // Format output
+            const lines = stdout.trim().split('\n');
+            const output = [];
+            output.push(`Found ${lines.filter(l => !l.startsWith('--')).length} matches for "${pattern}"\n`);
+            // Group by file for cleaner output
+            let currentFile = '';
+            for (const line of lines.slice(0, maxResults * 3)) { // Account for context lines
+                if (line.startsWith('--')) {
+                    output.push('---');
+                    continue;
+                }
+                const match = line.match(/^(.+?):(\d+)[:-](.*)$/);
+                if (match) {
+                    const [, file, lineNum, content] = match;
+                    const relPath = path.relative(searchPath, file);
+                    if (file !== currentFile) {
+                        currentFile = file;
+                        output.push(`\n=== ${relPath} ===`);
+                    }
+                    output.push(`L${lineNum}: ${content}`);
+                }
+            }
+            return output.join('\n');
+        }
+        catch (error) {
+            // ripgrep returns exit code 1 when no matches found
+            if (error.code === 1 && !error.stderr) {
+                return `No matches found for "${input.pattern}"`;
+            }
+            return `Search error: ${error.message}`;
+        }
+    }
+};
+/**
+ * Tool: Find Files
+ * Find files by name pattern using fd or fallback
+ */
+export const findFilesTool = {
+    name: 'find_files',
+    description: `Find files by name pattern.
+Uses fd for speed if available, falls back to filesystem walk.
+
+Output: List of matching file paths`,
+    parameters: {
+        type: 'object',
+        properties: {
+            pattern: {
+                type: 'string',
+                description: 'File name pattern (supports glob)'
+            },
+            path: {
+                type: 'string',
+                description: 'Directory to search in'
+            },
+            type: {
+                type: 'string',
+                description: 'Filter by type',
+                enum: ['file', 'directory', 'all']
+            },
+            maxDepth: {
+                type: 'string',
+                description: 'Maximum directory depth (default: 10)'
+            },
+            extension: {
+                type: 'string',
+                description: 'Filter by file extension (e.g., "ts")'
+            }
+        },
+        required: ['pattern', 'path']
+    },
+    execute: async (input) => {
+        try {
+            const searchPath = input.path;
+            const pattern = input.pattern;
+            const fileType = input.type || 'all';
+            const maxDepth = parseInt(input.maxDepth || '10', 10);
+            const extension = input.extension;
+            // Check if path exists
+            try {
+                await fs.access(searchPath);
+            }
+            catch {
+                return `Error: Path does not exist: ${searchPath}`;
+            }
+            const shell = process.platform === 'win32' ? 'powershell.exe' : '/bin/bash';
+            // Try fd first (faster)
+            if (await hasFd()) {
+                const args = [
+                    '--max-depth', maxDepth.toString(),
+                    '--hidden',
+                    '--no-ignore-vcs',
+                    '--exclude', 'node_modules',
+                    '--exclude', '.git',
+                    '--exclude', 'dist',
+                    '--exclude', '.next',
+                ];
+                if (fileType === 'file')
+                    args.push('--type', 'f');
+                if (fileType === 'directory')
+                    args.push('--type', 'd');
+                if (extension)
+                    args.push('--extension', extension);
+                const command = `fd ${args.join(' ')} "${pattern}" "${searchPath}"`;
+                try {
+                    const { stdout } = await execAsync(command, { shell, timeout: 30000 });
+                    const files = stdout.trim().split('\n').filter(f => f);
+                    if (files.length === 0) {
+                        return `No files found matching "${pattern}"`;
+                    }
+                    return `Found ${files.length} files:\n${files.map(f => path.relative(searchPath, f)).join('\n')}`;
+                }
+                catch (error) {
+                    if (error.code === 1) {
+                        return `No files found matching "${pattern}"`;
+                    }
+                }
+            }
+            // Fallback: manual filesystem walk
+            const results = [];
+            const patternLower = pattern.toLowerCase();
+            const walk = async (dir, depth) => {
+                if (depth > maxDepth)
+                    return;
+                try {
+                    const entries = await fs.readdir(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.name === 'node_modules' ||
+                            entry.name === '.git' ||
+                            entry.name === 'dist' ||
+                            entry.name === '.next') {
+                            continue;
+                        }
+                        const fullPath = path.join(dir, entry.name);
+                        const matchesPattern = entry.name.toLowerCase().includes(patternLower);
+                        const matchesExt = !extension || entry.name.endsWith(`.${extension}`);
+                        if (entry.isDirectory()) {
+                            if (fileType !== 'file' && matchesPattern) {
+                                results.push(path.relative(searchPath, fullPath));
+                            }
+                            await walk(fullPath, depth + 1);
+                        }
+                        else if (fileType !== 'directory' && matchesPattern && matchesExt) {
+                            results.push(path.relative(searchPath, fullPath));
+                        }
+                    }
+                }
+                catch {
+                    // Skip unreadable directories
+                }
+            };
+            await walk(searchPath, 0);
+            if (results.length === 0) {
+                return `No files found matching "${pattern}"`;
+            }
+            return `Found ${results.length} files:\n${results.slice(0, 100).join('\n')}${results.length > 100 ? `\n... and ${results.length - 100} more` : ''}`;
+        }
+        catch (error) {
+            return `Error finding files: ${error.message}`;
+        }
+    }
+};
+/**
+ * Tool: Grep in File
+ * Search within a specific file with line numbers
+ */
+export const grepInFileTool = {
+    name: 'grep_in_file',
+    description: `Search for a pattern within a specific file.
+Returns matching lines with line numbers.
+
+Use this when you know the file and want to find specific content.`,
+    parameters: {
+        type: 'object',
+        properties: {
+            pattern: {
+                type: 'string',
+                description: 'Pattern to search for'
+            },
+            filePath: {
+                type: 'string',
+                description: 'Path to the file to search'
+            },
+            contextLines: {
+                type: 'string',
+                description: 'Lines of context (default: 2)'
+            }
+        },
+        required: ['pattern', 'filePath']
+    },
+    execute: async (input) => {
+        try {
+            const filePath = input.filePath;
+            const pattern = input.pattern.toLowerCase();
+            const contextLines = parseInt(input.contextLines || '2', 10);
+            // Read file
+            let content;
+            try {
+                content = await fs.readFile(filePath, 'utf-8');
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    return `Error: File not found: ${filePath}`;
+                }
+                return `Error reading file: ${error.message}`;
+            }
+            const lines = content.split('\n');
+            const matches = [];
+            const matchedLineNums = new Set();
+            // Find matching lines
+            lines.forEach((line, idx) => {
+                if (line.toLowerCase().includes(pattern)) {
+                    matchedLineNums.add(idx);
+                    // Add context lines
+                    for (let i = Math.max(0, idx - contextLines); i <= Math.min(lines.length - 1, idx + contextLines); i++) {
+                        if (!matchedLineNums.has(i) || i === idx) {
+                            matchedLineNums.add(i);
+                        }
+                    }
+                }
+            });
+            if (matchedLineNums.size === 0) {
+                return `No matches found for "${input.pattern}" in ${path.basename(filePath)}`;
+            }
+            // Build output
+            const output = [];
+            output.push(`Found matches in ${path.basename(filePath)}:\n`);
+            const sortedNums = Array.from(matchedLineNums).sort((a, b) => a - b);
+            let lastNum = -2;
+            for (const num of sortedNums) {
+                if (num > lastNum + 1) {
+                    output.push('---');
+                }
+                const isMatch = lines[num].toLowerCase().includes(pattern);
+                const prefix = isMatch ? '>' : ' ';
+                output.push(`${prefix} L${num + 1}: ${lines[num]}`);
+                lastNum = num;
+            }
+            return output.join('\n');
+        }
+        catch (error) {
+            return `Error: ${error.message}`;
+        }
+    }
+};
+/**
+ * Get all search tools
+ */
+export function getSearchTools() {
+    return [
+        ripgrepSearchTool,
+        findFilesTool,
+        grepInFileTool,
+    ];
+}