@stan-chen/simple-cli 0.2.1

package/dist/tools/linter.js

@@ -0,0 +1,349 @@
+/**
+ * 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

@@ -0,0 +1,29 @@
+/**
+ * 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

@@ -0,0 +1,50 @@
+/**
+ * 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

@@ -0,0 +1,34 @@
+/**
+ * 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

@@ -0,0 +1,215 @@
+/**
+ * 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),
+};