@stan-chen/simple-cli 0.2.2 → 0.2.4

package/dist/tools/glob.js

@@ -1,165 +0,0 @@
-/**
- * Glob Tool - Find files matching patterns
- * Uses fast-glob for reliable glob matching (with fallback)
- */
-import { z } from 'zod';
-import { readdir } from 'fs/promises';
-import { join, relative } from 'path';
-// Input schema
-export const inputSchema = z.object({
-    pattern: z.string().describe('Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js")'),
-    cwd: z.string().optional().describe('Working directory to search in'),
-    maxResults: z.number().optional().default(100).describe('Maximum number of results'),
-    includeDirectories: z.boolean().optional().default(false).describe('Include directories in results'),
-    ignore: z.array(z.string()).optional().describe('Patterns to ignore'),
-});
-// Default ignore patterns
-const DEFAULT_IGNORE = [
-    '**/node_modules/**',
-    '**/.git/**',
-    '**/.svn/**',
-    '**/.hg/**',
-    '**/dist/**',
-    '**/build/**',
-    '**/coverage/**',
-    '**/.next/**',
-    '**/.nuxt/**',
-    '**/__pycache__/**',
-    '**/.pytest_cache/**',
-    '**/venv/**',
-    '**/.venv/**',
-    '**/env/**',
-    '**/.env',
-    '**/.idea/**',
-    '**/.vscode/**',
-    '**/*.pyc',
-    '**/*.pyo',
-    '**/.DS_Store',
-    '**/Thumbs.db',
-];
-// Simple ignore patterns for fallback (directory names)
-const FALLBACK_IGNORE = [
-    'node_modules', '.git', '.svn', '.hg', 'dist', 'build', 'coverage',
-    '.next', '.nuxt', '__pycache__', '.pytest_cache', 'venv', '.venv',
-    'env', '.idea', '.vscode',
-];
-// Cached fast-glob instance (typed as any to handle missing module)
-let fastGlob = null;
-let fgLoaded = false;
-async function loadFastGlob() {
-    if (!fgLoaded) {
-        fgLoaded = true;
-        try {
-            fastGlob = (await import('fast-glob')).default;
-        }
-        catch {
-            // fast-glob not installed
-        }
-    }
-    return fastGlob;
-}
-// Convert glob pattern to regex (for fallback)
-function globToRegex(pattern) {
-    let prefix = '';
-    let workPattern = pattern;
-    if (pattern.startsWith('**/')) {
-        prefix = '(?:^|.*/)?';
-        workPattern = pattern.slice(3);
-    }
-    let regex = workPattern
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*\*/g, '.*')
-        .replace(/\*/g, '[^/]*')
-        .replace(/\?/g, '[^/]');
-    return new RegExp(`${prefix}${regex}$`, 'i');
-}
-// Fallback: recursive file finder
-async function findFilesFallback(dir, pattern, options, results = []) {
-    if (results.length >= options.maxResults)
-        return results;
-    try {
-        const entries = await readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (results.length >= options.maxResults)
-                break;
-            // Check ignore
-            if (options.ignorePatterns.includes(entry.name))
-                continue;
-            if (entry.name.startsWith('.'))
-                continue;
-            const fullPath = join(dir, entry.name);
-            const relativePath = relative(options.baseDir, fullPath);
-            if (entry.isDirectory()) {
-                if (options.includeDirectories && pattern.test(relativePath)) {
-                    results.push(relativePath);
-                }
-                await findFilesFallback(fullPath, pattern, options, results);
-            }
-            else if (entry.isFile()) {
-                if (pattern.test(relativePath)) {
-                    results.push(relativePath);
-                }
-            }
-        }
-    }
-    catch {
-        // Ignore permission errors
-    }
-    return results;
-}
-// Execute glob search
-export async function execute(input) {
-    const { pattern, cwd = process.cwd(), maxResults, includeDirectories, ignore = [], } = inputSchema.parse(input);
-    const fg = await loadFastGlob();
-    if (fg) {
-        // Use fast-glob (preferred)
-        try {
-            const ignorePatterns = [...DEFAULT_IGNORE, ...ignore];
-            const matches = await fg(pattern, {
-                cwd,
-                ignore: ignorePatterns,
-                onlyFiles: !includeDirectories,
-                onlyDirectories: false,
-                dot: false,
-                absolute: false,
-                suppressErrors: true,
-            });
-            const sorted = matches.sort();
-            const truncated = sorted.length > maxResults;
-            const finalMatches = sorted.slice(0, maxResults);
-            return {
-                pattern,
-                matches: finalMatches,
-                count: finalMatches.length,
-                truncated,
-            };
-        }
-        catch {
-            // Fall through to fallback
-        }
-    }
-    // Fallback implementation
-    const regex = globToRegex(pattern);
-    const matches = await findFilesFallback(cwd, regex, {
-        maxResults: maxResults + 1,
-        includeDirectories,
-        ignorePatterns: FALLBACK_IGNORE,
-        baseDir: cwd,
-    });
-    const truncated = matches.length > maxResults;
-    const finalMatches = matches.slice(0, maxResults).sort();
-    return {
-        pattern,
-        matches: finalMatches,
-        count: finalMatches.length,
-        truncated,
-    };
-}
-// Tool definition
-export const tool = {
-    name: 'glob',
-    description: 'Find files matching a glob pattern. Supports ** for recursive matching, * for wildcards, and ? for single characters.',
-    inputSchema,
-    permission: 'read',
-    execute: async (args) => execute(args),
-};

package/dist/tools/grep.d.ts

@@ -1,53 +0,0 @@
-/**
- * Grep Tool - Search for patterns in files
- * Uses ripgrep when available, fast-glob + JS regex as fallback
- */
-import { z } from 'zod';
-import type { Tool } from '../registry.js';
-export declare const inputSchema: z.ZodObject<{
-    pattern: z.ZodString;
-    path: z.ZodOptional<z.ZodString>;
-    glob: z.ZodOptional<z.ZodString>;
-    ignoreCase: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    contextLines: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    filesOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    includeHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    pattern: string;
-    ignoreCase: boolean;
-    maxResults: number;
-    contextLines: number;
-    filesOnly: boolean;
-    includeHidden: boolean;
-    path?: string | undefined;
-    glob?: string | undefined;
-}, {
-    pattern: string;
-    path?: string | undefined;
-    glob?: string | undefined;
-    ignoreCase?: boolean | undefined;
-    maxResults?: number | undefined;
-    contextLines?: number | undefined;
-    filesOnly?: boolean | undefined;
-    includeHidden?: boolean | undefined;
-}>;
-type GrepInput = z.infer<typeof inputSchema>;
-interface GrepMatch {
-    file: string;
-    line: number;
-    column: number;
-    text: string;
-    match: string;
-    contextBefore?: string[];
-    contextAfter?: string[];
-}
-export declare function execute(input: GrepInput): Promise<{
-    pattern: string;
-    matches: GrepMatch[];
-    files: string[];
-    count: number;
-    truncated: boolean;
-}>;
-export declare const tool: Tool;
-export {};

package/dist/tools/grep.js

@@ -1,296 +0,0 @@
-/**
- * Grep Tool - Search for patterns in files
- * Uses ripgrep when available, fast-glob + JS regex as fallback
- */
-import { z } from 'zod';
-import { readFile, readdir, stat } from 'fs/promises';
-import { join, relative, extname } from 'path';
-import { spawnSync } from 'child_process';
-// Cached fast-glob instance (typed as any to handle missing module)
-let fg = null;
-let fgLoaded = false;
-async function loadFastGlob() {
-    if (!fgLoaded) {
-        fgLoaded = true;
-        try {
-            fg = (await import('fast-glob')).default;
-        }
-        catch {
-            // fast-glob not installed
-        }
-    }
-    return fg;
-}
-// Input schema
-export const inputSchema = z.object({
-    pattern: z.string().describe('Regular expression pattern to search for'),
-    path: z.string().optional().describe('File or directory to search in'),
-    glob: z.string().optional().describe('File pattern to filter (e.g., "*.ts")'),
-    ignoreCase: z.boolean().optional().default(false).describe('Case insensitive search'),
-    maxResults: z.number().optional().default(100).describe('Maximum number of matches'),
-    contextLines: z.number().optional().default(0).describe('Number of context lines before and after'),
-    filesOnly: z.boolean().optional().default(false).describe('Only return file names, not matches'),
-    includeHidden: z.boolean().optional().default(false).describe('Include hidden files'),
-});
-// Default ignore patterns
-const DEFAULT_IGNORE = [
-    'node_modules',
-    '.git',
-    'dist',
-    'build',
-    'coverage',
-    '__pycache__',
-    '.pytest_cache',
-    'venv',
-    '.venv',
-];
-// Text file glob patterns for searching
-const TEXT_FILE_PATTERNS = [
-    '**/*.{txt,md,json,yaml,yml,toml,xml,html,htm}',
-    '**/*.{css,scss,less,js,jsx,ts,tsx,vue,svelte}',
-    '**/*.{py,rb,php,java,c,cpp,h,hpp,cs,go,rs,swift,kt,scala}',
-    '**/*.{sh,bash,zsh,fish,sql,graphql,prisma}',
-    '**/{Makefile,Dockerfile,Containerfile,.gitignore,.dockerignore,.env}',
-    '**/.{editorconfig,eslintrc,prettierrc,babelrc}*',
-];
-// Search a single file
-async function searchFile(filePath, regex, contextLines) {
-    const matches = [];
-    try {
-        const content = await readFile(filePath, 'utf-8');
-        const lines = content.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            let match;
-            // Reset regex for global searches
-            regex.lastIndex = 0;
-            while ((match = regex.exec(line)) !== null) {
-                const result = {
-                    file: filePath,
-                    line: i + 1,
-                    column: match.index + 1,
-                    text: line,
-                    match: match[0],
-                };
-                if (contextLines > 0) {
-                    result.contextBefore = lines.slice(Math.max(0, i - contextLines), i);
-                    result.contextAfter = lines.slice(i + 1, Math.min(lines.length, i + 1 + contextLines));
-                }
-                matches.push(result);
-                // Don't find overlapping matches on same line
-                if (!regex.global)
-                    break;
-            }
-        }
-    }
-    catch {
-        // Ignore files that can't be read
-    }
-    return matches;
-}
-// Text file extensions for fallback matching
-const TEXT_EXTENSIONS = new Set([
-    '.txt', '.md', '.json', '.yaml', '.yml', '.toml', '.xml', '.html', '.htm',
-    '.css', '.scss', '.less', '.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte',
-    '.py', '.rb', '.php', '.java', '.c', '.cpp', '.h', '.hpp', '.cs', '.go',
-    '.rs', '.swift', '.kt', '.scala', '.sh', '.bash', '.zsh', '.fish',
-    '.sql', '.graphql', '.prisma', '',
-]);
-// Fallback: recursive directory search
-async function searchDirectoryFallback(dir, regex, options, results = []) {
-    if (results.length >= options.maxResults)
-        return results;
-    try {
-        const entries = await readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (results.length >= options.maxResults)
-                break;
-            const fullPath = join(dir, entry.name);
-            const relativePath = relative(options.baseDir, fullPath);
-            if (entry.isDirectory()) {
-                if (DEFAULT_IGNORE.includes(entry.name))
-                    continue;
-                if (!options.includeHidden && entry.name.startsWith('.'))
-                    continue;
-                await searchDirectoryFallback(fullPath, regex, options, results);
-            }
-            else if (entry.isFile()) {
-                const ext = extname(entry.name).toLowerCase();
-                if (!TEXT_EXTENSIONS.has(ext))
-                    continue;
-                if (!options.includeHidden && entry.name.startsWith('.'))
-                    continue;
-                const fileMatches = await searchFile(fullPath, regex, options.contextLines);
-                for (const match of fileMatches) {
-                    if (results.length >= options.maxResults)
-                        break;
-                    match.file = relativePath;
-                    results.push(match);
-                }
-            }
-        }
-    }
-    catch {
-        // Ignore permission errors
-    }
-    return results;
-}
-// Search directory using fast-glob for file discovery (with fallback)
-async function searchDirectory(dir, regex, options) {
-    const results = [];
-    const fastGlob = await loadFastGlob();
-    if (fastGlob) {
-        try {
-            // Build ignore patterns
-            const ignorePatterns = DEFAULT_IGNORE.map(d => `**/${d}/**`);
-            // Use user's glob pattern or default to text files
-            const patterns = options.glob ? [options.glob] : TEXT_FILE_PATTERNS;
-            // Find files using fast-glob
-            const files = await fastGlob(patterns, {
-                cwd: dir,
-                ignore: ignorePatterns,
-                dot: options.includeHidden,
-                absolute: true,
-                suppressErrors: true,
-            });
-            // Search each file
-            for (const fullPath of files) {
-                if (results.length >= options.maxResults)
-                    break;
-                const fileMatches = await searchFile(fullPath, regex, options.contextLines);
-                for (const match of fileMatches) {
-                    if (results.length >= options.maxResults)
-                        break;
-                    match.file = relative(options.baseDir, fullPath);
-                    results.push(match);
-                }
-            }
-            return results;
-        }
-        catch {
-            // Fall through to fallback
-        }
-    }
-    // Fallback to recursive directory search
-    return searchDirectoryFallback(dir, regex, options, results);
-}
-// Try to use ripgrep if available
-function tryRipgrep(input) {
-    try {
-        // Request one more than maxResults to detect truncation
-        const maxResults = input.maxResults || 100;
-        const args = [
-            '--json',
-            '--max-count', String(maxResults + 1),
-        ];
-        // Ignore common directories by default (matching DEFAULT_IGNORE)
-        for (const ignore of DEFAULT_IGNORE) {
-            args.push('-g', `!${ignore}`);
-            args.push('-g', `!${ignore}/**`);
-        }
-        if (input.ignoreCase) {
-            args.push('-i');
-        }
-        if (input.glob) {
-            args.push('-g', input.glob);
-        }
-        if (input.contextLines && input.contextLines > 0) {
-            args.push('-C', String(input.contextLines));
-        }
-        args.push(input.pattern);
-        if (input.path) {
-            args.push(input.path);
-        }
-        const result = spawnSync('rg', args, {
-            encoding: 'utf-8',
-            maxBuffer: 10 * 1024 * 1024,
-            timeout: 30000,
-        });
-        if (result.error) {
-            return null; // ripgrep not available
-        }
-        const matches = [];
-        const lines = result.stdout.split('\n').filter(Boolean);
-        for (const line of lines) {
-            try {
-                const json = JSON.parse(line);
-                if (json.type === 'match') {
-                    // Extract all submatches, not just the first one
-                    const submatches = json.data.submatches || [];
-                    for (const submatch of submatches) {
-                        matches.push({
-                            file: json.data.path.text,
-                            line: json.data.line_number,
-                            column: (submatch.start || 0) + 1,
-                            text: json.data.lines.text.replace(/\n$/, ''),
-                            match: submatch.match?.text || '',
-                        });
-                    }
-                }
-            }
-            catch {
-                // Skip invalid JSON lines
-            }
-        }
-        return matches;
-    }
-    catch {
-        return null;
-    }
-}
-// Execute grep search
-export async function execute(input) {
-    const { pattern, path = process.cwd(), glob, ignoreCase, maxResults, contextLines, filesOnly, includeHidden, } = inputSchema.parse(input);
-    // Try ripgrep first (but skip if context lines requested - ripgrep parsing doesn't support it)
-    if (!contextLines || contextLines === 0) {
-        const rgMatches = tryRipgrep(input);
-        if (rgMatches !== null && rgMatches.length > 0) {
-            const uniqueFiles = [...new Set(rgMatches.map(m => m.file))];
-            return {
-                pattern,
-                matches: filesOnly ? [] : rgMatches.slice(0, maxResults),
-                files: uniqueFiles,
-                count: rgMatches.length,
-                truncated: rgMatches.length > maxResults,
-            };
-        }
-    }
-    // Fall back to JavaScript implementation
-    const flags = ignoreCase ? 'gi' : 'g';
-    const regex = new RegExp(pattern, flags);
-    let matches;
-    const pathStat = await stat(path).catch(() => null);
-    if (pathStat?.isFile()) {
-        matches = await searchFile(path, regex, contextLines);
-    }
-    else if (pathStat?.isDirectory()) {
-        matches = await searchDirectory(path, regex, {
-            glob,
-            contextLines,
-            maxResults: maxResults + 1,
-            includeHidden,
-            baseDir: path,
-        });
-    }
-    else {
-        matches = [];
-    }
-    const truncated = matches.length > maxResults;
-    const finalMatches = matches.slice(0, maxResults);
-    const uniqueFiles = [...new Set(finalMatches.map(m => m.file))];
-    return {
-        pattern,
-        matches: filesOnly ? [] : finalMatches,
-        files: uniqueFiles,
-        count: finalMatches.length,
-        truncated,
-    };
-}
-// Tool definition
-export const tool = {
-    name: 'grep',
-    description: 'Search for a pattern in files using regular expressions. Uses ripgrep if available for better performance.',
-    inputSchema,
-    permission: 'read',
-    execute: async (args) => execute(args),
-};

package/dist/tools/linter.d.ts

@@ -1,35 +0,0 @@
-/**
- * Linter Tool - Checks code for syntax errors
- * Based on Aider's linter.py
- */
-import { z } from 'zod';
-import type { Tool } from '../registry.js';
-export declare const inputSchema: z.ZodObject<{
-    path: z.ZodString;
-    fix: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    fix: boolean;
-}, {
-    path: string;
-    fix?: boolean | undefined;
-}>;
-type LinterInput = z.infer<typeof inputSchema>;
-interface LintResult {
-    file: string;
-    language: string;
-    errors: LintError[];
-    warnings: LintError[];
-    passed: boolean;
-    output: string;
-}
-interface LintError {
-    line: number;
-    column?: number;
-    message: string;
-    rule?: string;
-    severity: 'error' | 'warning';
-}
-export declare function execute(input: LinterInput): Promise<LintResult>;
-export declare const tool: Tool;
-export {};