overai 1.4.0

package/dist/cli/features/repo-map.js

@@ -0,0 +1,350 @@
+"use strict";
+/**
+ * Repo Map - Repository structure visualization and symbol extraction
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepoMap = exports.DEFAULT_IGNORE_PATTERNS = void 0;
+exports.createRepoMap = createRepoMap;
+exports.getRepoTree = getRepoTree;
+/**
+ * Default ignore patterns
+ */
+exports.DEFAULT_IGNORE_PATTERNS = [
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '.next',
+    '.nuxt',
+    'coverage',
+    '.cache',
+    '__pycache__',
+    '.pytest_cache',
+    'venv',
+    '.venv',
+    '*.pyc',
+    '*.pyo',
+    '.DS_Store',
+    'Thumbs.db',
+    '*.log',
+    '*.lock'
+];
+/**
+ * RepoMap class for repository analysis
+ */
+class RepoMap {
+    constructor(config) {
+        this.config = {
+            maxDepth: 10,
+            ignorePatterns: exports.DEFAULT_IGNORE_PATTERNS,
+            includeSymbols: true,
+            maxFiles: 1000,
+            ...config
+        };
+    }
+    /**
+     * Generate repository map
+     */
+    async generate() {
+        this.fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        this.path = await Promise.resolve().then(() => __importStar(require('path')));
+        const tree = await this.scanDirectory(this.config.rootPath, 0);
+        const { files, directories } = this.countItems(tree);
+        const symbols = this.config.includeSymbols ? this.collectSymbols(tree) : [];
+        return {
+            root: this.config.rootPath,
+            tree,
+            totalFiles: files,
+            totalDirectories: directories,
+            symbols,
+            summary: this.generateSummary(tree, files, directories, symbols.length)
+        };
+    }
+    /**
+     * Scan a directory recursively
+     */
+    async scanDirectory(dirPath, depth) {
+        const relativePath = this.path.relative(this.config.rootPath, dirPath);
+        const stats = await this.fs.stat(dirPath);
+        const info = {
+            path: dirPath,
+            relativePath: relativePath || '.',
+            size: stats.size,
+            isDirectory: stats.isDirectory()
+        };
+        if (!stats.isDirectory() || depth >= (this.config.maxDepth || 10)) {
+            return info;
+        }
+        const entries = await this.fs.readdir(dirPath, { withFileTypes: true });
+        info.children = [];
+        for (const entry of entries) {
+            if (this.shouldIgnore(entry.name))
+                continue;
+            const entryPath = this.path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                const child = await this.scanDirectory(entryPath, depth + 1);
+                info.children.push(child);
+            }
+            else {
+                const fileStats = await this.fs.stat(entryPath).catch(() => null);
+                if (!fileStats)
+                    continue;
+                const fileInfo = {
+                    path: entryPath,
+                    relativePath: this.path.relative(this.config.rootPath, entryPath),
+                    size: fileStats.size,
+                    isDirectory: false
+                };
+                if (this.config.includeSymbols && this.isCodeFile(entry.name)) {
+                    fileInfo.symbols = await this.extractSymbols(entryPath);
+                }
+                info.children.push(fileInfo);
+            }
+        }
+        // Sort: directories first, then files alphabetically
+        info.children.sort((a, b) => {
+            if (a.isDirectory !== b.isDirectory) {
+                return a.isDirectory ? -1 : 1;
+            }
+            return a.relativePath.localeCompare(b.relativePath);
+        });
+        return info;
+    }
+    /**
+     * Check if path should be ignored
+     */
+    shouldIgnore(name) {
+        for (const pattern of this.config.ignorePatterns || []) {
+            if (pattern.startsWith('*')) {
+                if (name.endsWith(pattern.slice(1)))
+                    return true;
+            }
+            else if (name === pattern) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if file is a code file
+     */
+    isCodeFile(name) {
+        const codeExtensions = ['.ts', '.tsx', '.js', '.jsx', '.py', '.go', '.rs', '.java', '.rb', '.php'];
+        return codeExtensions.some(ext => name.endsWith(ext));
+    }
+    /**
+     * Extract symbols from a file
+     */
+    async extractSymbols(filePath) {
+        try {
+            const content = await this.fs.readFile(filePath, 'utf-8');
+            const ext = this.path.extname(filePath);
+            switch (ext) {
+                case '.ts':
+                case '.tsx':
+                case '.js':
+                case '.jsx':
+                    return this.extractJSSymbols(content);
+                case '.py':
+                    return this.extractPythonSymbols(content);
+                default:
+                    return [];
+            }
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Extract symbols from JavaScript/TypeScript
+     */
+    extractJSSymbols(content) {
+        const symbols = [];
+        const lines = content.split('\n');
+        const patterns = [
+            { regex: /^export\s+(?:async\s+)?function\s+(\w+)/m, type: 'function', exported: true },
+            { regex: /^export\s+class\s+(\w+)/m, type: 'class', exported: true },
+            { regex: /^export\s+interface\s+(\w+)/m, type: 'interface', exported: true },
+            { regex: /^export\s+type\s+(\w+)/m, type: 'type', exported: true },
+            { regex: /^export\s+const\s+(\w+)/m, type: 'variable', exported: true },
+            { regex: /^(?:async\s+)?function\s+(\w+)/m, type: 'function' },
+            { regex: /^class\s+(\w+)/m, type: 'class' },
+            { regex: /^interface\s+(\w+)/m, type: 'interface' },
+            { regex: /^type\s+(\w+)/m, type: 'type' },
+            { regex: /^const\s+(\w+)\s*=/m, type: 'variable' },
+        ];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            for (const { regex, type, exported } of patterns) {
+                const match = line.match(regex);
+                if (match) {
+                    symbols.push({
+                        name: match[1],
+                        type,
+                        line: i + 1,
+                        exported
+                    });
+                    break;
+                }
+            }
+        }
+        return symbols;
+    }
+    /**
+     * Extract symbols from Python
+     */
+    extractPythonSymbols(content) {
+        const symbols = [];
+        const lines = content.split('\n');
+        const patterns = [
+            { regex: /^def\s+(\w+)\s*\(/m, type: 'function' },
+            { regex: /^async\s+def\s+(\w+)\s*\(/m, type: 'function' },
+            { regex: /^class\s+(\w+)/m, type: 'class' },
+        ];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip indented definitions (methods)
+            if (line.startsWith(' ') || line.startsWith('\t'))
+                continue;
+            for (const { regex, type } of patterns) {
+                const match = line.match(regex);
+                if (match) {
+                    symbols.push({
+                        name: match[1],
+                        type,
+                        line: i + 1
+                    });
+                    break;
+                }
+            }
+        }
+        return symbols;
+    }
+    /**
+     * Count files and directories
+     */
+    countItems(tree) {
+        let files = 0;
+        let directories = 0;
+        const count = (node) => {
+            if (node.isDirectory) {
+                directories++;
+                for (const child of node.children || []) {
+                    count(child);
+                }
+            }
+            else {
+                files++;
+            }
+        };
+        count(tree);
+        return { files, directories };
+    }
+    /**
+     * Collect all symbols from tree
+     */
+    collectSymbols(tree) {
+        const symbols = [];
+        const collect = (node) => {
+            if (node.symbols) {
+                symbols.push(...node.symbols);
+            }
+            for (const child of node.children || []) {
+                collect(child);
+            }
+        };
+        collect(tree);
+        return symbols;
+    }
+    /**
+     * Generate text summary
+     */
+    generateSummary(tree, files, directories, symbolCount) {
+        const lines = [];
+        lines.push(`Repository: ${this.config.rootPath}`);
+        lines.push(`Files: ${files}, Directories: ${directories}, Symbols: ${symbolCount}`);
+        lines.push('');
+        lines.push(this.renderTree(tree, ''));
+        return lines.join('\n');
+    }
+    /**
+     * Render tree as text
+     */
+    renderTree(node, prefix) {
+        const lines = [];
+        const name = this.path.basename(node.path);
+        if (node.isDirectory) {
+            lines.push(`${prefix}${name}/`);
+            const children = node.children || [];
+            for (let i = 0; i < children.length; i++) {
+                const isLast = i === children.length - 1;
+                const childPrefix = prefix + (isLast ? '└── ' : '├── ');
+                const nextPrefix = prefix + (isLast ? '    ' : '│   ');
+                lines.push(this.renderTree(children[i], childPrefix).replace(childPrefix, ''));
+                // Add children lines with proper prefix
+                const childLines = this.renderTree(children[i], nextPrefix).split('\n').slice(1);
+                lines.push(...childLines);
+            }
+        }
+        else {
+            const symbolCount = node.symbols?.length || 0;
+            const symbolSuffix = symbolCount > 0 ? ` (${symbolCount} symbols)` : '';
+            lines.push(`${prefix}${name}${symbolSuffix}`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Get tree as simple text format
+     */
+    async getTreeText() {
+        const result = await this.generate();
+        return result.summary;
+    }
+}
+exports.RepoMap = RepoMap;
+/**
+ * Create a repo map instance
+ */
+function createRepoMap(config) {
+    return new RepoMap(config);
+}
+/**
+ * Quick function to get repo tree
+ */
+async function getRepoTree(rootPath, maxDepth) {
+    const map = createRepoMap({ rootPath, maxDepth, includeSymbols: false });
+    return map.getTreeText();
+}

package/dist/cli/features/sandbox-executor.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Sandbox Executor - Safe command execution with restrictions
+ */
+export type SandboxMode = 'disabled' | 'basic' | 'strict' | 'network-isolated';
+export interface SandboxConfig {
+    mode: SandboxMode;
+    allowedCommands?: string[];
+    blockedCommands?: string[];
+    blockedPaths?: string[];
+    timeout?: number;
+    maxOutputSize?: number;
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface ExecutionResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+    truncated?: boolean;
+}
+/**
+ * Default blocked commands (dangerous operations)
+ */
+export declare const DEFAULT_BLOCKED_COMMANDS: string[];
+/**
+ * Default blocked paths
+ */
+export declare const DEFAULT_BLOCKED_PATHS: string[];
+/**
+ * Command validator
+ */
+export declare class CommandValidator {
+    private blockedCommands;
+    private blockedPaths;
+    private allowedCommands?;
+    constructor(config?: Partial<SandboxConfig>);
+    /**
+     * Validate a command
+     */
+    validate(command: string): {
+        valid: boolean;
+        reason?: string;
+    };
+}
+/**
+ * Sandbox Executor class
+ */
+export declare class SandboxExecutor {
+    private config;
+    private validator;
+    constructor(config?: Partial<SandboxConfig>);
+    /**
+     * Execute a command in the sandbox
+     */
+    execute(command: string): Promise<ExecutionResult>;
+    /**
+     * Spawn the command
+     */
+    private spawn;
+    /**
+     * Build environment variables based on sandbox mode
+     */
+    private buildEnv;
+    /**
+     * Check if a command would be allowed
+     */
+    wouldAllow(command: string): {
+        allowed: boolean;
+        reason?: string;
+    };
+    /**
+     * Get current sandbox mode
+     */
+    getMode(): SandboxMode;
+    /**
+     * Update sandbox mode
+     */
+    setMode(mode: SandboxMode): void;
+}
+/**
+ * Create a sandbox executor
+ */
+export declare function createSandboxExecutor(config?: Partial<SandboxConfig>): SandboxExecutor;
+/**
+ * Quick execute with default sandbox
+ */
+export declare function sandboxExec(command: string, config?: Partial<SandboxConfig>): Promise<ExecutionResult>;