@stan-chen/simple-cli 0.2.3 → 0.2.5

package/dist/tools/linter.js

@@ -1,407 +0,0 @@
-/**
- * Linter Tool - Checks code for syntax errors
- * Based on Aider's linter.py
- */
-import { z } from 'zod';
-import { execSync, spawnSync } from 'child_process';
-import { readFileSync, existsSync } from 'fs';
-import { extname, basename } from 'path';
-import { platform } from 'os';
-// Input schema
-export const inputSchema = z.object({
-    path: z.string().describe('Path to file to lint'),
-    fix: z.boolean().optional().default(false).describe('Attempt to auto-fix issues'),
-});
-// Language detection based on file extension
-const LANGUAGE_MAP = {
-    '.py': 'python',
-    '.js': 'javascript',
-    '.jsx': 'javascript',
-    '.ts': 'typescript',
-    '.tsx': 'typescript',
-    '.rb': 'ruby',
-    '.go': 'go',
-    '.rs': 'rust',
-    '.java': 'java',
-    '.c': 'c',
-    '.cpp': 'cpp',
-    '.h': 'c',
-    '.hpp': 'cpp',
-    '.cs': 'csharp',
-    '.php': 'php',
-    '.swift': 'swift',
-    '.kt': 'kotlin',
-    '.scala': 'scala',
-    '.sh': 'shell',
-    '.bash': 'shell',
-    '.zsh': 'shell',
-};
-// Detect language from file
-function detectLanguage(filePath) {
-    const ext = extname(filePath).toLowerCase();
-    return LANGUAGE_MAP[ext] || null;
-}
-// Detect if a binary exists in PATH
-function detectBinary(bin) {
-    try {
-        const isWin = platform() === 'win32';
-        const cmd = isWin ? 'where' : 'which';
-        execSync(`${cmd} ${bin}`, { stdio: 'ignore' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// Get correct python binary
-function getPythonBinary() {
-    if (detectBinary('python3'))
-        return 'python3';
-    if (detectBinary('python'))
-        return 'python';
-    return null;
-}
-// Platform agnostic /dev/null
-function getNullDevice() {
-    return platform() === 'win32' ? 'NUL' : '/dev/null';
-}
-// Parse error output for line numbers
-function parseErrors(output, filePath) {
-    const errors = [];
-    const fileName = basename(filePath);
-    const escapedFileName = fileName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const escapedFilePath = filePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    // Common patterns for error messages: file:line:col: message
-    // groups: [lineIndex, columnIndex (or -1), messageIndex (or -1)]
-    const patterns = [
-        // Python/flake8/eslint style: file.py:10:5: E501 line too long
-        { regex: new RegExp(`(?:${escapedFileName}|${escapedFilePath}):(\\d+)(?::(\\d+))?:\\s*(.+)`, 'gm'), groups: [1, 2, 3] },
-        // TypeScript/tsc style: file.ts(10,5): error TS1234: message
-        { regex: new RegExp(`(?:${escapedFileName}|${escapedFilePath})\\((\\d+),(\\d+)\\):\\s*(\\w+)\\s+(.+)`, 'gm'), groups: [1, 2, 4] },
-        // Python py_compile style: File "file.py", line 10
-        { regex: /File\s+"[^"]+",\s+line\s+(\d+)/gim, groups: [1, -1, -1] },
-        // Generic line number: line 10: message
-        { regex: /line\s+(\d+):\s*(.+)/gim, groups: [1, -1, 2] },
-    ];
-    // Also capture standalone error messages like "SyntaxError: ..."
-    const syntaxErrorMatch = output.match(/(SyntaxError|IndentationError|TabError):\s*(.+)/i);
-    const syntaxErrorMessage = syntaxErrorMatch ? `${syntaxErrorMatch[1]}: ${syntaxErrorMatch[2]}` : null;
-    for (const { regex, groups } of patterns) {
-        let match;
-        while ((match = regex.exec(output)) !== null) {
-            const [lineIdx, colIdx, msgIdx] = groups;
-            const line = parseInt(match[lineIdx], 10);
-            const column = colIdx >= 0 && match[colIdx] ? parseInt(match[colIdx], 10) : undefined;
-            let message = msgIdx >= 0 && match[msgIdx] ? match[msgIdx].trim() : '';
-            // Use syntax error message if we found one and this pattern doesn't have a message
-            if (!message && syntaxErrorMessage) {
-                message = syntaxErrorMessage;
-            }
-            if (line > 0) {
-                errors.push({
-                    line,
-                    column,
-                    message: message || 'Syntax error',
-                    severity: 'error',
-                });
-            }
-        }
-    }
-    // Deduplicate errors by line number
-    const seen = new Set();
-    return errors.filter(e => {
-        if (seen.has(e.line))
-            return false;
-        seen.add(e.line);
-        return true;
-    });
-}
-// Python syntax check using compile
-function lintPython(filePath, code) {
-    const errors = [];
-    let output = '';
-    const pythonBin = getPythonBinary();
-    if (!pythonBin) {
-        return {
-            file: filePath,
-            language: 'python',
-            errors: [],
-            warnings: [],
-            passed: true, // skipped
-            output: 'Python binary not found, skipping lint.',
-        };
-    }
-    // Try Python syntax check
-    try {
-        const result = spawnSync(pythonBin, ['-m', 'py_compile', filePath], {
-            encoding: 'utf-8',
-            timeout: 10000,
-        });
-        if (result.status !== 0) {
-            output = result.stderr || result.stdout || '';
-            errors.push(...parseErrors(output, filePath));
-        }
-    }
-    catch {
-        // Fall back to basic syntax check
-        try {
-            execSync(`${pythonBin} -c "compile(open('${filePath}').read(), '${filePath}', 'exec')"`, {
-                encoding: 'utf-8',
-                timeout: 10000,
-            });
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                output = e.message;
-                errors.push(...parseErrors(output, filePath));
-            }
-        }
-    }
-    // Try flake8 for additional checks
-    try {
-        const result = spawnSync(pythonBin, ['-m', 'flake8', '--select=E9,F821,F823,F831,F406,F407,F701,F702,F704,F706', filePath], {
-            encoding: 'utf-8',
-            timeout: 10000,
-        });
-        if (result.stdout) {
-            output += '\n' + result.stdout;
-            errors.push(...parseErrors(result.stdout, filePath));
-        }
-    }
-    catch {
-        // flake8 not available, skip
-    }
-    return {
-        file: filePath,
-        language: 'python',
-        errors: errors.filter(e => e.severity === 'error'),
-        warnings: errors.filter(e => e.severity === 'warning'),
-        passed: errors.filter(e => e.severity === 'error').length === 0,
-        output: output.trim(),
-    };
-}
-// JavaScript/TypeScript linting
-function lintJavaScript(filePath, code, isTypeScript) {
-    const errors = [];
-    let output = '';
-    const language = isTypeScript ? 'typescript' : 'javascript';
-    // Basic syntax check using Node.js
-    try {
-        if (isTypeScript) {
-            // Try tsc for TypeScript
-            const result = spawnSync('npx', ['tsc', '--noEmit', '--skipLibCheck', filePath], {
-                encoding: 'utf-8',
-                timeout: 30000,
-                shell: platform() === 'win32' // Required for npx on Windows
-            });
-            if (result.status !== 0) {
-                output = (result.stdout || '') + (result.stderr || '');
-                errors.push(...parseErrors(output, filePath));
-            }
-        }
-        else {
-            // Use Node's vm module for JavaScript syntax check
-            const result = spawnSync('node', ['--check', filePath], {
-                encoding: 'utf-8',
-                timeout: 10000,
-            });
-            if (result.status !== 0) {
-                output = result.stderr || '';
-                errors.push(...parseErrors(output, filePath));
-            }
-        }
-    }
-    catch (e) {
-        if (e instanceof Error) {
-            output = e.message;
-        }
-    }
-    // Try ESLint
-    try {
-        const result = spawnSync('npx', ['eslint', '--format', 'compact', filePath], {
-            encoding: 'utf-8',
-            timeout: 30000,
-            shell: platform() === 'win32'
-        });
-        if (result.stdout) {
-            output += '\n' + result.stdout;
-            errors.push(...parseErrors(result.stdout, filePath));
-        }
-    }
-    catch {
-        // ESLint not available
-    }
-    return {
-        file: filePath,
-        language,
-        errors: errors.filter(e => e.severity === 'error'),
-        warnings: errors.filter(e => e.severity === 'warning'),
-        passed: errors.filter(e => e.severity === 'error').length === 0,
-        output: output.trim(),
-    };
-}
-// Go linting
-function lintGo(filePath) {
-    if (!detectBinary('go')) {
-        return {
-            file: filePath, language: 'go', errors: [], warnings: [], passed: true, output: 'Go not found'
-        };
-    }
-    const errors = [];
-    let output = '';
-    try {
-        const result = spawnSync('go', ['vet', filePath], {
-            encoding: 'utf-8',
-            timeout: 30000,
-        });
-        output = result.stderr + result.stdout;
-        if (result.status !== 0) {
-            errors.push(...parseErrors(output, filePath));
-        }
-    }
-    catch (e) {
-        if (e instanceof Error) {
-            output = e.message;
-        }
-    }
-    return {
-        file: filePath,
-        language: 'go',
-        errors: errors.filter(e => e.severity === 'error'),
-        warnings: errors.filter(e => e.severity === 'warning'),
-        passed: errors.filter(e => e.severity === 'error').length === 0,
-        output: output.trim(),
-    };
-}
-// Rust linting
-function lintRust(filePath) {
-    if (!detectBinary('rustc')) {
-        return {
-            file: filePath, language: 'rust', errors: [], warnings: [], passed: true, output: 'Rustc not found'
-        };
-    }
-    const errors = [];
-    let output = '';
-    try {
-        const result = spawnSync('rustc', ['--emit=metadata', '-o', getNullDevice(), filePath], {
-            encoding: 'utf-8',
-            timeout: 30000,
-        });
-        output = result.stderr + result.stdout;
-        if (result.status !== 0) {
-            errors.push(...parseErrors(output, filePath));
-        }
-    }
-    catch (e) {
-        if (e instanceof Error) {
-            output = e.message;
-        }
-    }
-    return {
-        file: filePath,
-        language: 'rust',
-        errors: errors.filter(e => e.severity === 'error'),
-        warnings: errors.filter(e => e.severity === 'warning'),
-        passed: errors.filter(e => e.severity === 'error').length === 0,
-        output: output.trim(),
-    };
-}
-// Generic shell linting
-function lintShell(filePath) {
-    const errors = [];
-    let output = '';
-    // Try shellcheck first (cross platform)
-    if (detectBinary('shellcheck')) {
-        try {
-            const result = spawnSync('shellcheck', ['-f', 'gcc', filePath], {
-                encoding: 'utf-8',
-                timeout: 10000,
-            });
-            if (result.stdout) {
-                output += '\n' + result.stdout;
-                errors.push(...parseErrors(result.stdout, filePath));
-            }
-        }
-        catch {
-            // shellcheck error
-        }
-    }
-    else if (detectBinary('bash')) {
-        // Fallback to bash -n, works on Windows if Git Bash / WSL is in path, or Linux/Mac
-        try {
-            const result = spawnSync('bash', ['-n', filePath], {
-                encoding: 'utf-8',
-                timeout: 10000,
-            });
-            output = result.stderr + result.stdout;
-            if (result.status !== 0) {
-                errors.push(...parseErrors(output, filePath));
-            }
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                output = e.message;
-            }
-        }
-    }
-    else {
-        return {
-            file: filePath, language: 'shell', errors: [], warnings: [], passed: true, output: 'No shell linter found (bash/shellcheck missing)'
-        };
-    }
-    return {
-        file: filePath,
-        language: 'shell',
-        errors: errors.filter(e => e.severity === 'error'),
-        warnings: errors.filter(e => e.severity === 'warning'),
-        passed: errors.filter(e => e.severity === 'error').length === 0,
-        output: output.trim(),
-    };
-}
-// Execute linting
-export async function execute(input) {
-    const { path: filePath } = inputSchema.parse(input);
-    if (!existsSync(filePath)) {
-        return {
-            file: filePath,
-            language: 'unknown',
-            errors: [{ line: 0, message: 'File not found', severity: 'error' }],
-            warnings: [],
-            passed: false,
-            output: 'File not found',
-        };
-    }
-    const language = detectLanguage(filePath);
-    const code = readFileSync(filePath, 'utf-8');
-    switch (language) {
-        case 'python':
-            return lintPython(filePath, code);
-        case 'javascript':
-            return lintJavaScript(filePath, code, false);
-        case 'typescript':
-            return lintJavaScript(filePath, code, true);
-        case 'go':
-            return lintGo(filePath);
-        case 'rust':
-            return lintRust(filePath);
-        case 'shell':
-            return lintShell(filePath);
-        default:
-            return {
-                file: filePath,
-                language: language || 'unknown',
-                errors: [],
-                warnings: [],
-                passed: true,
-                output: `No linter available for ${language || 'unknown language'}`,
-            };
-    }
-}
-// Tool definition
-export const tool = {
-    name: 'lint',
-    description: 'Check a source file for syntax errors and code quality issues. Supports Python, JavaScript, TypeScript, Go, Rust, and shell scripts.',
-    inputSchema,
-    permission: 'read',
-    execute: async (args) => execute(args),
-};

package/dist/tools/listDir.d.ts

@@ -1,29 +0,0 @@
-/**
- * Tool: listDir
- * List the contents of a directory (files and subdirectories)
- */
-import { z } from 'zod';
-export declare const name = "listDir";
-export declare const description = "List the contents of a directory, showing file sizes and directory indicators";
-export declare const permission: "read";
-export declare const schema: z.ZodObject<{
-    path: z.ZodOptional<z.ZodString>;
-    recursive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-}, "strip", z.ZodTypeAny, {
-    recursive: boolean;
-    depth: number;
-    path?: string | undefined;
-}, {
-    recursive?: boolean | undefined;
-    path?: string | undefined;
-    depth?: number | undefined;
-}>;
-interface EntryInfo {
-    name: string;
-    isDir: boolean;
-    size?: number;
-    childrenCount?: number;
-}
-export declare const execute: (args: Record<string, unknown>) => Promise<EntryInfo[]>;
-export {};

package/dist/tools/listDir.js

@@ -1,50 +0,0 @@
-/**
- * Tool: listDir
- * List the contents of a directory (files and subdirectories)
- */
-import { readdir, stat } from 'fs/promises';
-import { join } from 'path';
-import { z } from 'zod';
-export const name = 'listDir';
-export const description = 'List the contents of a directory, showing file sizes and directory indicators';
-export const permission = 'read';
-export const schema = z.object({
-    path: z.string().optional().describe('Directory path to list (default: current directory)'),
-    recursive: z.boolean().optional().default(false).describe('Whether to list recursively'),
-    depth: z.number().optional().default(1).describe('Max depth for recursive listing')
-});
-export const execute = async (args) => {
-    const parsed = schema.parse(args);
-    const rootPath = parsed.path || process.cwd();
-    try {
-        const entries = await readdir(rootPath, { withFileTypes: true });
-        const result = [];
-        for (const entry of entries) {
-            // Basic ignores
-            if (['node_modules', '.git', 'dist', 'build'].includes(entry.name))
-                continue;
-            const fullPath = join(rootPath, entry.name);
-            const isDir = entry.isDirectory();
-            let entryInfo = {
-                name: entry.name,
-                isDir
-            };
-            if (!isDir) {
-                try {
-                    const s = await stat(fullPath);
-                    entryInfo.size = s.size;
-                }
-                catch { }
-            }
-            else if (parsed.recursive && (parsed.depth || 0) > 0) {
-                // We don't actually do recursion here to keep it simple and flat
-                // but it's a placeholder for future if needed.
-            }
-            result.push(entryInfo);
-        }
-        return result;
-    }
-    catch (error) {
-        throw new Error(`Failed to list directory ${rootPath}: ${error instanceof Error ? error.message : error}`);
-    }
-};

package/dist/tools/list_dir.d.ts

@@ -1,29 +0,0 @@
-/**
- * Tool: listDir
- * List the contents of a directory (files and subdirectories)
- */
-import { z } from 'zod';
-export declare const name = "list_dir";
-export declare const description = "List the contents of a directory, showing file sizes and directory indicators";
-export declare const permission: "read";
-export declare const schema: z.ZodObject<{
-    path: z.ZodOptional<z.ZodString>;
-    recursive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-}, "strip", z.ZodTypeAny, {
-    recursive: boolean;
-    depth: number;
-    path?: string | undefined;
-}, {
-    recursive?: boolean | undefined;
-    path?: string | undefined;
-    depth?: number | undefined;
-}>;
-interface EntryInfo {
-    name: string;
-    isDir: boolean;
-    size?: number;
-    childrenCount?: number;
-}
-export declare const execute: (args: Record<string, unknown>) => Promise<EntryInfo[]>;
-export {};

package/dist/tools/list_dir.js

@@ -1,50 +0,0 @@
-/**
- * Tool: listDir
- * List the contents of a directory (files and subdirectories)
- */
-import { readdir, stat } from 'fs/promises';
-import { join } from 'path';
-import { z } from 'zod';
-export const name = 'list_dir';
-export const description = 'List the contents of a directory, showing file sizes and directory indicators';
-export const permission = 'read';
-export const schema = z.object({
-    path: z.string().optional().describe('Directory path to list (default: current directory)'),
-    recursive: z.boolean().optional().default(false).describe('Whether to list recursively'),
-    depth: z.number().optional().default(1).describe('Max depth for recursive listing')
-});
-export const execute = async (args) => {
-    const parsed = schema.parse(args);
-    const rootPath = parsed.path || process.cwd();
-    try {
-        const entries = await readdir(rootPath, { withFileTypes: true });
-        const result = [];
-        for (const entry of entries) {
-            // Basic ignores
-            if (['node_modules', '.git', 'dist', 'build'].includes(entry.name))
-                continue;
-            const fullPath = join(rootPath, entry.name);
-            const isDir = entry.isDirectory();
-            let entryInfo = {
-                name: entry.name,
-                isDir
-            };
-            if (!isDir) {
-                try {
-                    const s = await stat(fullPath);
-                    entryInfo.size = s.size;
-                }
-                catch { }
-            }
-            else if (parsed.recursive && (parsed.depth || 0) > 0) {
-                // We don't actually do recursion here to keep it simple and flat
-                // but it's a placeholder for future if needed.
-            }
-            result.push(entryInfo);
-        }
-        return result;
-    }
-    catch (error) {
-        throw new Error(`Failed to list directory ${rootPath}: ${error instanceof Error ? error.message : error}`);
-    }
-};

package/dist/tools/memory.d.ts

@@ -1,34 +0,0 @@
-/**
- * Memory Tool - Persistent context and memory management
- * Based on GeminiCLI's memoryTool.ts
- */
-import { z } from 'zod';
-import type { Tool } from '../registry.js';
-export declare const inputSchema: z.ZodObject<{
-    operation: z.ZodEnum<["get", "set", "delete", "list", "search", "clear"]>;
-    key: z.ZodOptional<z.ZodString>;
-    value: z.ZodOptional<z.ZodString>;
-    query: z.ZodOptional<z.ZodString>;
-    namespace: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-}, "strip", z.ZodTypeAny, {
-    operation: "search" | "list" | "set" | "clear" | "get" | "delete";
-    namespace: string;
-    value?: string | undefined;
-    key?: string | undefined;
-    query?: string | undefined;
-}, {
-    operation: "search" | "list" | "set" | "clear" | "get" | "delete";
-    value?: string | undefined;
-    key?: string | undefined;
-    query?: string | undefined;
-    namespace?: string | undefined;
-}>;
-type MemoryInput = z.infer<typeof inputSchema>;
-export declare function execute(input: MemoryInput): Promise<{
-    operation: string;
-    success: boolean;
-    data?: unknown;
-    error?: string;
-}>;
-export declare const tool: Tool;
-export {};