neuro-cli 4.1.0

package/dist/context/neuroignore.js

@@ -0,0 +1,441 @@
+// ============================================================
+// NeuroCLI - .neuroignore System
+// Specifies files the AI should not access, with gitignore-style
+// pattern support, negation, caching, and auto-detection.
+// ============================================================
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join, relative, normalize, sep, isAbsolute } from 'path';
+import { homedir } from 'os';
+// -----------------------------------------------------------
+// Default patterns
+// -----------------------------------------------------------
+const DEFAULT_IGNORED_PATTERNS = [
+    'node_modules',
+    '.git',
+    '__pycache__',
+    '.env',
+    '.env.*',
+    '*.pyc',
+    '.DS_Store',
+    'dist',
+    'build',
+    '.next',
+    'coverage',
+    '.cache',
+    '*.log',
+    '.turbo',
+    'vendor',
+    'target',
+    'bin',
+    'obj',
+    '.venv',
+    'venv',
+    '.tox',
+    '.mypy_cache',
+    '.pytest_cache',
+    '*.min.js',
+    '*.min.css',
+    'bundle.js',
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+];
+// -----------------------------------------------------------
+// NeuroIgnore class
+// -----------------------------------------------------------
+export class NeuroIgnore {
+    rules = [];
+    cache = new Map();
+    projectRoot;
+    loaded = false;
+    constructor(projectRoot) {
+        this.projectRoot = normalize(projectRoot);
+    }
+    // ---------------------------------------------------------
+    // Public API
+    // ---------------------------------------------------------
+    /**
+     * Load ignore rules from all sources:
+     *   1. Default patterns
+     *   2. ~/.neuro/ignore  (global user rules)
+     *   3. .neuroignore     (project-root rules)
+     */
+    load() {
+        this.rules = [];
+        this.cache.clear();
+        // 1. Built-in defaults
+        this.loadDefaultRules();
+        // 2. Global user ignore file: ~/.neuro/ignore
+        const globalIgnorePath = join(homedir(), '.neuro', 'ignore');
+        this.loadFromFile(globalIgnorePath);
+        // 3. Project-root .neuroignore
+        const projectIgnorePath = join(this.projectRoot, '.neuroignore');
+        this.loadFromFile(projectIgnorePath);
+        // 4. Auto-detect common directories that should be ignored
+        this.autoDetectIgnorableDirs();
+        this.loaded = true;
+    }
+    /**
+     * Check whether a given file path should be ignored.
+     * The path may be absolute or relative to projectRoot.
+     *
+     * Evaluation order matters: later rules override earlier ones.
+     * Negated patterns (prefixed with !) un-ignore previously matched paths.
+     */
+    isIgnored(filePath) {
+        this.ensureLoaded();
+        // Normalise to a relative posix-style path from project root
+        const relativePath = this.toRelativePosix(filePath);
+        // Check cache first
+        const cached = this.cache.get(relativePath);
+        if (cached !== undefined) {
+            return cached;
+        }
+        let ignored = false;
+        for (const rule of this.rules) {
+            if (rule.negated) {
+                // A negation rule can only un-ignore something that was already ignored
+                if (ignored && rule.regex.test(relativePath)) {
+                    ignored = false;
+                }
+            }
+            else {
+                if (rule.regex.test(relativePath)) {
+                    ignored = true;
+                }
+            }
+        }
+        this.cache.set(relativePath, ignored);
+        return ignored;
+    }
+    /**
+     * Filter an array of paths, removing those that are ignored.
+     */
+    filterPaths(paths) {
+        return paths.filter((p) => !this.isIgnored(p));
+    }
+    /**
+     * Dynamically add a rule at runtime.
+     */
+    addRule(pattern, source = '<runtime>') {
+        const negated = pattern.startsWith('!');
+        const cleanPattern = negated ? pattern.slice(1) : pattern;
+        const regex = this.patternToRegex(cleanPattern);
+        this.rules.push({
+            pattern,
+            negated,
+            regex,
+            source,
+        });
+        // Invalidate cache because rules changed
+        this.cache.clear();
+    }
+    /**
+     * Remove a rule by its original pattern string.
+     * Returns true if a rule was found and removed.
+     */
+    removeRule(pattern) {
+        const index = this.rules.findIndex((r) => r.pattern === pattern);
+        if (index === -1) {
+            return false;
+        }
+        this.rules.splice(index, 1);
+        this.cache.clear();
+        return true;
+    }
+    /**
+     * Return a shallow copy of the current rules list.
+     */
+    getRules() {
+        return [...this.rules];
+    }
+    /**
+     * Clear the result cache.
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Print all active rules to stdout (useful for debugging).
+     */
+    printRules() {
+        const sources = new Set(this.rules.map((r) => r.source));
+        for (const source of sources) {
+            console.log(`\n[Source: ${source}]`);
+            for (const rule of this.rules.filter((r) => r.source === source)) {
+                const flag = rule.negated ? ' (NEGATED)' : '';
+                console.log(`  ${rule.pattern}${flag}`);
+            }
+        }
+        console.log(`\nTotal rules: ${this.rules.length}, Cache entries: ${this.cache.size}`);
+    }
+    // ---------------------------------------------------------
+    // Static defaults accessor
+    // ---------------------------------------------------------
+    static DEFAULT_IGNORED = [...DEFAULT_IGNORED_PATTERNS];
+    // ---------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------
+    /**
+     * Load rules from a single file. Lines starting with # are comments.
+     * Blank lines are skipped. Trailing whitespace is trimmed.
+     */
+    loadFromFile(filePath) {
+        if (!existsSync(filePath)) {
+            return;
+        }
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            const lines = content.split(/\r?\n/);
+            for (let raw of lines) {
+                // Strip comments
+                const commentIdx = raw.indexOf('#');
+                if (commentIdx !== -1) {
+                    raw = raw.slice(0, commentIdx);
+                }
+                const line = raw.trim();
+                if (line.length === 0) {
+                    continue;
+                }
+                this.addRule(line, filePath);
+            }
+        }
+        catch {
+            // Silently skip unreadable files
+        }
+    }
+    /**
+     * Populate the default ignore rules.
+     */
+    loadDefaultRules() {
+        for (const pattern of DEFAULT_IGNORED_PATTERNS) {
+            this.addRule(pattern, '<defaults>');
+        }
+    }
+    /**
+     * Convert a gitignore-style glob pattern into a RegExp.
+     *
+     * Supported features:
+     *   *        matches anything except /
+     *   **       matches anything including /
+     *   ?        matches any single character except /
+     *   [abc]    character class
+     *   [a-z]    character range
+     *   {a,b}    brace expansion (alternation)
+     *   !prefix  negation (handled separately before this method)
+     *
+     * A trailing / means the pattern only matches directories; we keep
+     * the regex flexible enough to match both for simplicity, but strip
+     * the trailing slash indicator.
+     */
+    patternToRegex(pattern) {
+        let p = pattern;
+        // Strip trailing slash (directory-only indicator) -- we match
+        // both files and directories for simplicity.
+        const dirOnly = p.endsWith('/');
+        if (dirOnly) {
+            p = p.slice(0, -1);
+        }
+        // Leading slash means anchored to project root
+        const anchored = p.startsWith('/');
+        if (anchored) {
+            p = p.slice(1);
+        }
+        // Escape regex-special characters (except those we handle as globs)
+        const ESCAPE_RE = /[.+^${}()|[\]\\]/g;
+        // We will build the regex manually
+        let regexStr = '';
+        let i = 0;
+        while (i < p.length) {
+            const ch = p[i];
+            if (ch === '*') {
+                // Check for **
+                if (i + 1 < p.length && p[i + 1] === '*') {
+                    // /**/ or **/ or /**
+                    if (i + 2 < p.length &&
+                        p[i + 2] === '/') {
+                        // /**/  -> match any path segment(s) including none
+                        regexStr += '(?:/|/.+/)';
+                        i += 3;
+                    }
+                    else if (i === 0 ||
+                        p[i - 1] === '/') {
+                        // ** at start or after / -> match any prefix
+                        regexStr += '(?:.*)';
+                        i += 2;
+                    }
+                    else {
+                        // Embedded ** (not at segment boundary) -- treat as literal
+                        regexStr += '\\*\\*';
+                        i += 2;
+                    }
+                }
+                else {
+                    // Single * -> match anything except /
+                    regexStr += '[^/]*';
+                    i += 1;
+                }
+            }
+            else if (ch === '?') {
+                regexStr += '[^/]';
+                i += 1;
+            }
+            else if (ch === '[') {
+                // Character class -- find closing ]
+                const closeIdx = p.indexOf(']', i + 1);
+                if (closeIdx === -1) {
+                    // No closing bracket -- escape
+                    regexStr += '\\[';
+                    i += 1;
+                }
+                else {
+                    const classContent = p.slice(i + 1, closeIdx);
+                    regexStr += '[' + classContent + ']';
+                    i = closeIdx + 1;
+                }
+            }
+            else if (ch === '{') {
+                // Brace expansion {a,b,c} -> (?:a|b|c)
+                const closeIdx = p.indexOf('}', i + 1);
+                if (closeIdx === -1) {
+                    regexStr += '\\{';
+                    i += 1;
+                }
+                else {
+                    const inner = p.slice(i + 1, closeIdx);
+                    const alternatives = inner.split(',').map((alt) => this.escapeRegex(alt));
+                    regexStr += '(?:' + alternatives.join('|') + ')';
+                    i = closeIdx + 1;
+                }
+            }
+            else if (ESCAPE_RE.test(ch)) {
+                regexStr += '\\' + ch;
+                i += 1;
+            }
+            else {
+                regexStr += ch;
+                i += 1;
+            }
+        }
+        // Build final regex
+        // - If anchored, match from start of relative path
+        // - If not anchored, the pattern can match anywhere in the path
+        //   (either as a complete segment or as a filename)
+        let finalRegex;
+        if (anchored) {
+            finalRegex = '^' + regexStr + '$';
+        }
+        else {
+            // Unanchored patterns match if:
+            //   - the entire relative path matches the pattern directly, OR
+            //   - the pattern matches a trailing segment (e.g. "dist" matches
+            //     "foo/bar/dist" and "dist")
+            finalRegex =
+                '^(?:' +
+                    '(?:.*/)?' +
+                    regexStr +
+                    ')$';
+        }
+        try {
+            return new RegExp(finalRegex);
+        }
+        catch {
+            // If the generated regex is invalid, fall back to a simple
+            // substring match so we never crash.
+            return new RegExp('^.*' + this.escapeRegex(pattern).replace(/\\\*/g, '.*') + '.*$');
+        }
+    }
+    /**
+     * Escape a string for use inside a RegExp.
+     */
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Ensure rules have been loaded before answering queries.
+     */
+    ensureLoaded() {
+        if (!this.loaded) {
+            this.load();
+        }
+    }
+    /**
+     * Convert a file path to a relative posix-style path from projectRoot.
+     * - Absolute paths are made relative to projectRoot.
+     * - Backslashes (Windows) are converted to forward slashes.
+     * - Leading ./ is stripped.
+     */
+    toRelativePosix(filePath) {
+        let rel;
+        if (isAbsolute(filePath)) {
+            rel = relative(this.projectRoot, filePath);
+        }
+        else {
+            rel = filePath;
+        }
+        // Normalise separators
+        rel = rel.split(sep).join('/');
+        // Strip leading ./
+        if (rel.startsWith('./')) {
+            rel = rel.slice(2);
+        }
+        return rel;
+    }
+    /**
+     * Auto-detect common directories in the project root that should
+     * typically be ignored (e.g. a large "vendor" or "dist" directory
+     * that was not already covered by default patterns).
+     */
+    autoDetectIgnorableDirs() {
+        const AUTODETECT_CANDIDATES = [
+            'node_modules',
+            '.git',
+            '__pycache__',
+            '.cache',
+            '.turbo',
+            'dist',
+            'build',
+            '.next',
+            'coverage',
+            'vendor',
+            'target',
+            'bin',
+            'obj',
+            '.venv',
+            'venv',
+            '.tox',
+            '.mypy_cache',
+            '.pytest_cache',
+            '.sass-cache',
+            '.idea',
+            '.vscode',
+            'out',
+            '.nuxt',
+            '.output',
+            '.svelte-kit',
+            '.angular',
+            'Pods',
+        ];
+        // Only scan if the project root exists
+        if (!existsSync(this.projectRoot)) {
+            return;
+        }
+        try {
+            const entries = readdirSync(this.projectRoot, { withFileTypes: true });
+            const existingDirs = new Set(entries.filter((e) => e.isDirectory()).map((e) => e.name));
+            for (const candidate of AUTODETECT_CANDIDATES) {
+                if (existingDirs.has(candidate)) {
+                    // Check whether we already have a rule for this directory
+                    const alreadyCovered = this.rules.some((r) => !r.negated && (r.pattern === candidate || r.pattern === candidate + '/'));
+                    if (!alreadyCovered) {
+                        this.addRule(candidate, '<auto-detect>');
+                    }
+                }
+            }
+        }
+        catch {
+            // Permission error or similar -- skip auto-detection
+        }
+    }
+}
+//# sourceMappingURL=neuroignore.js.map

package/dist/context/repo-map.d.ts

@@ -0,0 +1,38 @@
+export interface RepoMapEntry {
+    file: string;
+    language: string;
+    definitions: string[];
+    references: string[];
+    lineCount: number;
+}
+export interface RepoMap {
+    entries: RepoMapEntry[];
+    totalFiles: number;
+    totalLines: number;
+    languages: Record<string, number>;
+    summary: string;
+}
+export declare class RepositoryMapper {
+    private workingDirectory;
+    private cached;
+    constructor(workingDirectory: string);
+    /**
+     * Build a repository map
+     */
+    build(maxFiles?: number): RepoMap;
+    /**
+     * Get the repo map as a compact string for LLM context
+     */
+    getContextString(maxEntries?: number): string;
+    /**
+     * Invalidate cache
+     */
+    invalidate(): void;
+    private getSourceFiles;
+    private mapFile;
+    private extractDefinitions;
+    private extractReferences;
+    private getLanguage;
+    private buildSummary;
+}
+//# sourceMappingURL=repo-map.d.ts.map

package/dist/context/repo-map.js

@@ -0,0 +1,220 @@
+// ============================================================
+// NeuroCLI - Repository Map
+// Semantic codebase context (like Aider's repo map)
+// Builds a structural map of identifiers for large codebases
+// ============================================================
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join, extname, relative } from 'path';
+export class RepositoryMapper {
+    workingDirectory;
+    cached = null;
+    constructor(workingDirectory) {
+        this.workingDirectory = workingDirectory;
+    }
+    /**
+     * Build a repository map
+     */
+    build(maxFiles = 200) {
+        if (this.cached)
+            return this.cached;
+        const entries = [];
+        const languages = {};
+        let totalLines = 0;
+        // Get list of source files using ripgrep or git
+        const sourceFiles = this.getSourceFiles(maxFiles);
+        for (const file of sourceFiles) {
+            try {
+                const entry = this.mapFile(file);
+                if (entry) {
+                    entries.push(entry);
+                    totalLines += entry.lineCount;
+                    languages[entry.language] = (languages[entry.language] || 0) + 1;
+                }
+            }
+            catch { }
+        }
+        const summary = this.buildSummary(entries, languages, totalLines);
+        this.cached = {
+            entries,
+            totalFiles: entries.length,
+            totalLines,
+            languages,
+            summary,
+        };
+        return this.cached;
+    }
+    /**
+     * Get the repo map as a compact string for LLM context
+     */
+    getContextString(maxEntries = 100) {
+        const map = this.build();
+        const lines = [];
+        lines.push(`Repository Map: ${map.totalFiles} files, ${map.totalLines} lines`);
+        lines.push(`Languages: ${Object.entries(map.languages).map(([l, c]) => `${l}(${c})`).join(', ')}`);
+        lines.push('');
+        const entries = map.entries.slice(0, maxEntries);
+        for (const entry of entries) {
+            const relPath = relative(this.workingDirectory, entry.file);
+            const defs = entry.definitions.slice(0, 10).join(', ');
+            lines.push(`${relPath} (${entry.language}, ${entry.lineCount} lines)${defs ? `: ${defs}` : ''}`);
+        }
+        if (map.entries.length > maxEntries) {
+            lines.push(`... and ${map.entries.length - maxEntries} more files`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Invalidate cache
+     */
+    invalidate() {
+        this.cached = null;
+    }
+    // ---- Private Methods ----
+    getSourceFiles(maxFiles) {
+        const extensions = new Set([
+            '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+            '.py', '.pyx', '.pyi',
+            '.rs', '.go', '.java', '.kt', '.swift', '.c', '.cpp', '.h', '.hpp',
+            '.rb', '.php', '.cs', '.scala', '.clj',
+            '.sh', '.bash', '.zsh',
+            '.sql', '.graphql', '.prisma',
+            '.html', '.css', '.scss', '.less', '.vue', '.svelte',
+            '.yaml', '.yml', '.toml', '.json', '.json5',
+            '.md', '.txt',
+        ]);
+        try {
+            // Use ripgrep for fast file discovery
+            const result = execSync(`rg --files --max-count ${maxFiles} --color never "${this.workingDirectory}"`, { encoding: 'utf-8', timeout: 10000, cwd: this.workingDirectory });
+            return result.trim().split('\n').filter(f => {
+                const ext = extname(f);
+                return extensions.has(ext);
+            }).slice(0, maxFiles);
+        }
+        catch {
+            // Fallback: use git ls-files
+            try {
+                const result = execSync('git ls-files', {
+                    encoding: 'utf-8',
+                    cwd: this.workingDirectory,
+                    timeout: 10000,
+                });
+                return result.trim().split('\n')
+                    .filter(f => extensions.has(extname(f)))
+                    .map(f => join(this.workingDirectory, f))
+                    .slice(0, maxFiles);
+            }
+            catch {
+                return [];
+            }
+        }
+    }
+    mapFile(filePath) {
+        if (!existsSync(filePath))
+            return null;
+        const ext = extname(filePath);
+        const language = this.getLanguage(ext);
+        const content = readFileSync(filePath, 'utf-8');
+        const lineCount = content.split('\n').length;
+        // Extract definitions based on language
+        const definitions = this.extractDefinitions(content, language);
+        const references = this.extractReferences(content, language);
+        return {
+            file: filePath,
+            language,
+            definitions,
+            references,
+            lineCount,
+        };
+    }
+    extractDefinitions(content, language) {
+        const defs = [];
+        const maxDefs = 15;
+        const patterns = {
+            'TypeScript': [
+                /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)/gm,
+                /^(?:export\s+)?(?:default\s+)?class\s+(\w+)/gm,
+                /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[:=]/gm,
+                /^(?:export\s+)?interface\s+(\w+)/gm,
+                /^(?:export\s+)?type\s+(\w+)\s*=/gm,
+                /^(?:export\s+)?enum\s+(\w+)/gm,
+            ],
+            'Python': [
+                /^(?:async\s+)?def\s+(\w+)/gm,
+                /^class\s+(\w+)/gm,
+                /^(\w+)\s*=\s*/gm,
+            ],
+            'Rust': [
+                /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/gm,
+                /^(?:pub\s+)?struct\s+(\w+)/gm,
+                /^(?:pub\s+)?enum\s+(\w+)/gm,
+                /^(?:pub\s+)?trait\s+(\w+)/gm,
+                /^(?:pub\s+)?impl\s+(\w+)/gm,
+            ],
+            'Go': [
+                /^func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)/gm,
+                /^type\s+(\w+)\s+struct/gm,
+                /^type\s+(\w+)\s+interface/gm,
+                /^var\s+(\w+)\s*=/gm,
+            ],
+            'Java': [
+                /^(?:public|private|protected)?\s*(?:static\s+)?(?:final\s+)?(?:abstract\s+)?class\s+(\w+)/gm,
+                /^(?:public|private|protected)?\s*(?:static\s+)?(?:final\s+)?(?:abstract\s+)?interface\s+(\w+)/gm,
+                /^(?:public|private|protected)?\s*(?:static\s+)?(?:final\s+)?(?:abstract\s+)?(?:synchronized\s+)?(?:\w+(?:<[^>]+>)?\s+)+(\w+)\s*\(/gm,
+            ],
+        };
+        const langPatterns = patterns[language] || patterns['TypeScript'] || [];
+        for (const pattern of langPatterns) {
+            let match;
+            while ((match = pattern.exec(content)) !== null && defs.length < maxDefs) {
+                const name = match[1];
+                if (name && !defs.includes(name)) {
+                    defs.push(name);
+                }
+            }
+        }
+        return defs;
+    }
+    extractReferences(content, language) {
+        // Simple import/require detection
+        const refs = [];
+        const importRegex = /(?:import|require|from|use|include)\s+['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+            if (match[1] && refs.length < 20) {
+                refs.push(match[1]);
+            }
+        }
+        return refs;
+    }
+    getLanguage(ext) {
+        const map = {
+            '.ts': 'TypeScript', '.tsx': 'TypeScript',
+            '.js': 'JavaScript', '.jsx': 'JavaScript', '.mjs': 'JavaScript',
+            '.py': 'Python', '.pyx': 'Python', '.pyi': 'Python',
+            '.rs': 'Rust', '.go': 'Go', '.java': 'Java', '.kt': 'Kotlin',
+            '.swift': 'Swift', '.c': 'C', '.cpp': 'C++', '.h': 'C', '.hpp': 'C++',
+            '.rb': 'Ruby', '.php': 'PHP', '.cs': 'C#',
+            '.sh': 'Shell', '.bash': 'Shell',
+            '.sql': 'SQL', '.graphql': 'GraphQL',
+            '.html': 'HTML', '.css': 'CSS', '.scss': 'CSS',
+            '.yaml': 'YAML', '.yml': 'YAML', '.toml': 'TOML',
+            '.json': 'JSON', '.md': 'Markdown',
+        };
+        return map[ext] || 'Unknown';
+    }
+    buildSummary(entries, languages, totalLines) {
+        const topLangs = Object.entries(languages)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 5)
+            .map(([l, c]) => `${l}(${c} files)`)
+            .join(', ');
+        const topFiles = entries
+            .sort((a, b) => b.lineCount - a.lineCount)
+            .slice(0, 10)
+            .map(e => `${relative(this.workingDirectory, e.file)} (${e.lineCount} lines)`)
+            .join(', ');
+        return `Repository: ${entries.length} files, ${totalLines} lines. Languages: ${topLangs}. Largest files: ${topFiles}`;
+    }
+}
+//# sourceMappingURL=repo-map.js.map