@stan-chen/simple-cli 0.2.2 → 0.2.4

package/dist/tools/linter.js

@@ -1,349 +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';
-// 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;
-}
-// 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 = '';
-    // Try Python syntax check
-    try {
-        const result = spawnSync('python3', ['-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(`python3 -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('python3', ['-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,
-            });
-            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,
-        });
-        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) {
-    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) {
-    const errors = [];
-    let output = '';
-    try {
-        const result = spawnSync('rustc', ['--emit=metadata', '-o', '/dev/null', 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 {
-        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;
-        }
-    }
-    // Try 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 not available
-    }
-    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/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 {};

package/dist/tools/memory.js

@@ -1,215 +0,0 @@
-/**
- * Memory Tool - Persistent context and memory management
- * Based on GeminiCLI's memoryTool.ts
- */
-import { z } from 'zod';
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { existsSync } from 'fs';
-import { join, dirname } from 'path';
-// Input schema
-export const inputSchema = z.object({
-    operation: z.enum(['get', 'set', 'delete', 'list', 'search', 'clear']).describe('Memory operation'),
-    key: z.string().optional().describe('Memory key'),
-    value: z.string().optional().describe('Value to store'),
-    query: z.string().optional().describe('Search query'),
-    namespace: z.string().optional().default('default').describe('Memory namespace'),
-});
-// Get memory file path
-function getMemoryPath() {
-    const baseDir = process.env.SIMPLE_CLI_DATA_DIR ||
-        join(process.env.HOME || '', '.config', 'simplecli');
-    return join(baseDir, 'memory.json');
-}
-// Load memory store
-async function loadMemory() {
-    const path = getMemoryPath();
-    if (!existsSync(path)) {
-        return { version: 1, entries: {} };
-    }
-    try {
-        const content = await readFile(path, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch {
-        return { version: 1, entries: {} };
-    }
-}
-// Save memory store
-async function saveMemory(store) {
-    const path = getMemoryPath();
-    // Ensure directory exists
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, JSON.stringify(store, null, 2));
-}
-// Generate unique key
-function generateKey(namespace, key) {
-    return `${namespace}:${key}`;
-}
-// Execute memory operation
-export async function execute(input) {
-    const { operation, key, value, query, namespace } = inputSchema.parse(input);
-    const store = await loadMemory();
-    try {
-        switch (operation) {
-            case 'get': {
-                if (!key) {
-                    return {
-                        operation,
-                        success: false,
-                        error: 'Key required for get operation',
-                    };
-                }
-                const fullKey = generateKey(namespace, key);
-                const entry = store.entries[fullKey];
-                if (!entry) {
-                    return {
-                        operation,
-                        success: true,
-                        data: null,
-                    };
-                }
-                return {
-                    operation,
-                    success: true,
-                    data: {
-                        key: entry.key,
-                        value: entry.value,
-                        timestamp: entry.timestamp,
-                    },
-                };
-            }
-            case 'set': {
-                if (!key || value === undefined) {
-                    return {
-                        operation,
-                        success: false,
-                        error: 'Key and value required for set operation',
-                    };
-                }
-                const fullKey = generateKey(namespace, key);
-                store.entries[fullKey] = {
-                    key,
-                    value,
-                    timestamp: Date.now(),
-                    namespace,
-                };
-                await saveMemory(store);
-                return {
-                    operation,
-                    success: true,
-                    data: { key, stored: true },
-                };
-            }
-            case 'delete': {
-                if (!key) {
-                    return {
-                        operation,
-                        success: false,
-                        error: 'Key required for delete operation',
-                    };
-                }
-                const fullKey = generateKey(namespace, key);
-                const existed = fullKey in store.entries;
-                delete store.entries[fullKey];
-                await saveMemory(store);
-                return {
-                    operation,
-                    success: true,
-                    data: { key, deleted: existed },
-                };
-            }
-            case 'list': {
-                const entries = Object.values(store.entries)
-                    .filter(e => e.namespace === namespace)
-                    .map(e => ({
-                    key: e.key,
-                    timestamp: e.timestamp,
-                    preview: e.value.slice(0, 100) + (e.value.length > 100 ? '...' : ''),
-                }))
-                    .sort((a, b) => b.timestamp - a.timestamp);
-                return {
-                    operation,
-                    success: true,
-                    data: {
-                        namespace,
-                        count: entries.length,
-                        entries,
-                    },
-                };
-            }
-            case 'search': {
-                if (!query) {
-                    return {
-                        operation,
-                        success: false,
-                        error: 'Query required for search operation',
-                    };
-                }
-                const queryLower = query.toLowerCase();
-                const matches = Object.values(store.entries)
-                    .filter(e => e.key.toLowerCase().includes(queryLower) ||
-                    e.value.toLowerCase().includes(queryLower))
-                    .map(e => ({
-                    key: e.key,
-                    namespace: e.namespace,
-                    timestamp: e.timestamp,
-                    preview: e.value.slice(0, 100) + (e.value.length > 100 ? '...' : ''),
-                }))
-                    .slice(0, 20);
-                return {
-                    operation,
-                    success: true,
-                    data: {
-                        query,
-                        count: matches.length,
-                        matches,
-                    },
-                };
-            }
-            case 'clear': {
-                const beforeCount = Object.keys(store.entries).length;
-                if (namespace === 'all') {
-                    store.entries = {};
-                }
-                else {
-                    for (const [k, entry] of Object.entries(store.entries)) {
-                        if (entry.namespace === namespace) {
-                            delete store.entries[k];
-                        }
-                    }
-                }
-                await saveMemory(store);
-                const afterCount = Object.keys(store.entries).length;
-                return {
-                    operation,
-                    success: true,
-                    data: {
-                        namespace,
-                        cleared: beforeCount - afterCount,
-                    },
-                };
-            }
-            default:
-                return {
-                    operation,
-                    success: false,
-                    error: `Unknown operation: ${operation}`,
-                };
-        }
-    }
-    catch (error) {
-        return {
-            operation,
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-// Tool definition
-export const tool = {
-    name: 'memory',
-    description: 'Store and retrieve persistent memory/context. Operations: get, set, delete, list, search, clear',
-    inputSchema,
-    permission: 'write',
-    execute: async (args) => execute(args),
-};