neuro-cli 4.1.0

package/dist/context/git-checkpoint.js

@@ -0,0 +1,240 @@
+// ============================================================
+// NeuroCLI - Git Auto-Commit & Checkpointing
+// (Like Aider's auto-commit + Gemini CLI's shadow repo)
+// ============================================================
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+export class GitCheckpointSystem {
+    workingDirectory;
+    shadowRepo;
+    autoCommit;
+    checkpoints = [];
+    constructor(workingDirectory, autoCommit = true) {
+        this.workingDirectory = workingDirectory;
+        this.autoCommit = autoCommit;
+        // Shadow repo for checkpointing (doesn't interfere with user's git)
+        const projectHash = this.hashString(workingDirectory);
+        this.shadowRepo = join(homedir(), '.neuro', 'checkpoints', projectHash);
+    }
+    /**
+     * Initialize the checkpoint system
+     */
+    initialize() {
+        if (!this.isGitRepo())
+            return false;
+        this.ensureShadowRepo();
+        return true;
+    }
+    /**
+     * Create a checkpoint before risky operations
+     */
+    createCheckpoint(message) {
+        const changedFiles = this.getChangedFiles();
+        if (changedFiles.length === 0) {
+            return null;
+        }
+        const checkpoint = {
+            id: `cp_${Date.now()}`,
+            timestamp: Date.now(),
+            message,
+            files: changedFiles,
+        };
+        // Option 1: Git stash-based checkpoint (quick)
+        if (this.autoCommit) {
+            try {
+                // Stage all changes
+                execSync('git add -A', { cwd: this.workingDirectory, encoding: 'utf-8' });
+                // Commit with checkpoint marker
+                const commitMsg = `neuro:checkpoint ${message}`;
+                execSync(`git commit -m "${commitMsg}" --no-gpg-sign`, {
+                    cwd: this.workingDirectory,
+                    encoding: 'utf-8',
+                });
+                const hash = execSync('git rev-parse HEAD', {
+                    cwd: this.workingDirectory,
+                    encoding: 'utf-8',
+                }).trim();
+                checkpoint.hash = hash;
+            }
+            catch {
+                // Nothing to commit or commit failed
+            }
+        }
+        // Option 2: Shadow repo snapshot
+        this.saveShadowSnapshot(checkpoint);
+        this.checkpoints.push(checkpoint);
+        return checkpoint;
+    }
+    /**
+     * Restore to a checkpoint
+     */
+    restore(checkpointId) {
+        const checkpoint = this.checkpoints.find(c => c.id === checkpointId);
+        if (!checkpoint)
+            return false;
+        // Try git restore first
+        if (checkpoint.hash) {
+            try {
+                execSync(`git reset --hard ${checkpoint.hash}`, {
+                    cwd: this.workingDirectory,
+                    encoding: 'utf-8',
+                });
+                return true;
+            }
+            catch { }
+        }
+        // Fallback: restore from shadow repo
+        return this.restoreShadowSnapshot(checkpoint);
+    }
+    /**
+     * Undo the last checkpoint
+     */
+    undo() {
+        if (this.checkpoints.length === 0)
+            return false;
+        const lastCheckpoint = this.checkpoints[this.checkpoints.length - 1];
+        return this.restore(lastCheckpoint.id);
+    }
+    /**
+     * List all checkpoints
+     */
+    listCheckpoints() {
+        return [...this.checkpoints];
+    }
+    /**
+     * Get changed files since last commit
+     */
+    getChangedFiles() {
+        try {
+            const status = execSync('git status --porcelain', {
+                cwd: this.workingDirectory,
+                encoding: 'utf-8',
+            });
+            return status.trim().split('\n')
+                .filter(l => l.trim())
+                .map(l => l.slice(3).trim());
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get diff of changes
+     */
+    getDiff() {
+        try {
+            return execSync('git diff', {
+                cwd: this.workingDirectory,
+                encoding: 'utf-8',
+            });
+        }
+        catch {
+            return '';
+        }
+    }
+    /**
+     * Auto-commit changes with a message
+     */
+    autoCommitChanges(message) {
+        if (!this.autoCommit)
+            return null;
+        if (!this.isGitRepo())
+            return null;
+        const changed = this.getChangedFiles();
+        if (changed.length === 0)
+            return null;
+        try {
+            execSync('git add -A', { cwd: this.workingDirectory, encoding: 'utf-8' });
+            execSync(`git commit -m "neuro: ${message}" --no-gpg-sign`, {
+                cwd: this.workingDirectory,
+                encoding: 'utf-8',
+            });
+            const hash = execSync('git rev-parse --short HEAD', {
+                cwd: this.workingDirectory,
+                encoding: 'utf-8',
+            }).trim();
+            return hash;
+        }
+        catch {
+            return null;
+        }
+    }
+    // ---- Private ----
+    isGitRepo() {
+        try {
+            execSync('git rev-parse --is-inside-work-tree', {
+                cwd: this.workingDirectory,
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    ensureShadowRepo() {
+        if (!existsSync(this.shadowRepo)) {
+            mkdirSync(this.shadowRepo, { recursive: true });
+        }
+        // Initialize shadow repo if needed
+        const gitDir = join(this.shadowRepo, '.git');
+        if (!existsSync(gitDir)) {
+            try {
+                execSync('git init', { cwd: this.shadowRepo, encoding: 'utf-8' });
+            }
+            catch { }
+        }
+    }
+    saveShadowSnapshot(checkpoint) {
+        const snapshotDir = join(this.shadowRepo, checkpoint.id);
+        if (!existsSync(snapshotDir)) {
+            mkdirSync(snapshotDir, { recursive: true });
+        }
+        // Save checkpoint metadata
+        writeFileSync(join(snapshotDir, 'meta.json'), JSON.stringify(checkpoint, null, 2), 'utf-8');
+        // Copy changed files to snapshot
+        for (const file of checkpoint.files) {
+            const src = join(this.workingDirectory, file);
+            const dst = join(snapshotDir, 'files', file);
+            if (existsSync(src)) {
+                try {
+                    mkdirSync(join(dst, '..'), { recursive: true });
+                    const { copyFileSync } = require('fs');
+                    copyFileSync(src, dst);
+                }
+                catch { }
+            }
+        }
+    }
+    restoreShadowSnapshot(checkpoint) {
+        const snapshotDir = join(this.shadowRepo, checkpoint.id, 'files');
+        if (!existsSync(snapshotDir))
+            return false;
+        for (const file of checkpoint.files) {
+            const src = join(snapshotDir, file);
+            const dst = join(this.workingDirectory, file);
+            if (existsSync(src)) {
+                try {
+                    const { copyFileSync } = require('fs');
+                    mkdirSync(join(dst, '..'), { recursive: true });
+                    copyFileSync(src, dst);
+                }
+                catch { }
+            }
+        }
+        return true;
+    }
+    hashString(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash |= 0;
+        }
+        return Math.abs(hash).toString(36);
+    }
+}
+//# sourceMappingURL=git-checkpoint.js.map

package/dist/context/neuro-md.d.ts

@@ -0,0 +1,48 @@
+export interface NeuroMdLayer {
+    scope: 'global' | 'user' | 'project' | 'local' | 'directory';
+    path: string;
+    content: string;
+    size: number;
+}
+export declare class NeuroMdSystem {
+    private workingDirectory;
+    private layers;
+    private watchers;
+    private onChange?;
+    constructor(workingDirectory: string, onChange?: () => void);
+    /**
+     * Load all NEURO.md layers in priority order
+     * Global → User → Project → Local → Directory
+     */
+    load(): NeuroMdLayer[];
+    /**
+     * Get the combined context from all NEURO.md layers
+     */
+    getCombinedContext(): string;
+    /**
+     * Get total size of all layers
+     */
+    getTotalSize(): number;
+    /**
+     * Initialize a new NEURO.md in the project
+     */
+    initProject(): string;
+    /**
+     * Watch NEURO.md files for changes
+     */
+    startWatching(): void;
+    /**
+     * Stop watching NEURO.md files
+     */
+    stopWatching(): void;
+    private tryLoadLayer;
+    private loadRulesDirectory;
+    /**
+     * Process @import references in NEURO.md
+     * e.g. @path/to/file.md → injects file contents
+     */
+    private processImports;
+    private detectTechStack;
+    private generateStarterMd;
+}
+//# sourceMappingURL=neuro-md.d.ts.map

package/dist/context/neuro-md.js

@@ -0,0 +1,202 @@
+// ============================================================
+// NeuroCLI - NEURO.md Persistent Context System
+// Hierarchical project instructions (like CLAUDE.md / GEMINI.md)
+// ============================================================
+import { readFileSync, existsSync, watchFile, unwatchFile } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+export class NeuroMdSystem {
+    workingDirectory;
+    layers = [];
+    watchers = [];
+    onChange;
+    constructor(workingDirectory, onChange) {
+        this.workingDirectory = workingDirectory;
+        this.onChange = onChange;
+    }
+    /**
+     * Load all NEURO.md layers in priority order
+     * Global → User → Project → Local → Directory
+     */
+    load() {
+        this.layers = [];
+        // 1. Global: ~/.neuro/NEURO.md
+        this.tryLoadLayer('global', join(homedir(), '.neuro', 'NEURO.md'));
+        // 2. User: ~/.neuro/NEURO.md (same as global for now)
+        // Already loaded above
+        // 3. Project: NEURO.md in project root
+        this.tryLoadLayer('project', join(this.workingDirectory, 'NEURO.md'));
+        // 4. Project (alt): .neuro/NEURO.md
+        this.tryLoadLayer('project', join(this.workingDirectory, '.neuro', 'NEURO.md'));
+        // 5. Local: NEURO.local.md (gitignored)
+        this.tryLoadLayer('local', join(this.workingDirectory, 'NEURO.local.md'));
+        // 6. Rules: .neuro/rules/*.md
+        this.loadRulesDirectory();
+        return this.layers;
+    }
+    /**
+     * Get the combined context from all NEURO.md layers
+     */
+    getCombinedContext() {
+        if (this.layers.length === 0)
+            return '';
+        const parts = [];
+        parts.push('## Project Context (NEURO.md)\n');
+        for (const layer of this.layers) {
+            parts.push(`### [${layer.scope}] ${layer.path}\n${layer.content}\n`);
+        }
+        return parts.join('\n');
+    }
+    /**
+     * Get total size of all layers
+     */
+    getTotalSize() {
+        return this.layers.reduce((sum, l) => sum + l.size, 0);
+    }
+    /**
+     * Initialize a new NEURO.md in the project
+     */
+    initProject() {
+        const { writeFileSync } = require('fs');
+        const projectMd = join(this.workingDirectory, 'NEURO.md');
+        if (existsSync(projectMd)) {
+            return `NEURO.md already exists at ${projectMd}`;
+        }
+        // Auto-detect tech stack
+        const techStack = this.detectTechStack();
+        const content = this.generateStarterMd(techStack);
+        writeFileSync(projectMd, content, 'utf-8');
+        return `Created NEURO.md at ${projectMd}`;
+    }
+    /**
+     * Watch NEURO.md files for changes
+     */
+    startWatching() {
+        this.stopWatching();
+        const paths = [
+            join(homedir(), '.neuro', 'NEURO.md'),
+            join(this.workingDirectory, 'NEURO.md'),
+            join(this.workingDirectory, '.neuro', 'NEURO.md'),
+            join(this.workingDirectory, 'NEURO.local.md'),
+        ];
+        for (const path of paths) {
+            if (existsSync(path)) {
+                try {
+                    watchFile(path, { interval: 5000 }, () => {
+                        this.load(); // Reload on change
+                        this.onChange?.();
+                    });
+                    this.watchers.push({ path, close: () => unwatchFile(path) });
+                }
+                catch { }
+            }
+        }
+    }
+    /**
+     * Stop watching NEURO.md files
+     */
+    stopWatching() {
+        for (const w of this.watchers) {
+            w.close();
+        }
+        this.watchers = [];
+    }
+    // ---- Private Methods ----
+    tryLoadLayer(scope, path) {
+        if (!existsSync(path))
+            return;
+        try {
+            const content = readFileSync(path, 'utf-8');
+            // Process @import references
+            const processed = this.processImports(content, path);
+            this.layers.push({ scope, path, content: processed, size: content.length });
+        }
+        catch { }
+    }
+    loadRulesDirectory() {
+        const rulesDir = join(this.workingDirectory, '.neuro', 'rules');
+        if (!existsSync(rulesDir))
+            return;
+        try {
+            const { readdirSync } = require('fs');
+            const files = readdirSync(rulesDir).filter((f) => f.endsWith('.md'));
+            for (const file of files) {
+                this.tryLoadLayer('directory', join(rulesDir, file));
+            }
+        }
+        catch { }
+    }
+    /**
+     * Process @import references in NEURO.md
+     * e.g. @path/to/file.md → injects file contents
+     */
+    processImports(content, basePath) {
+        const importRegex = /@([^\s\n]+\.(?:md|txt|json5?|yaml|yml))/g;
+        return content.replace(importRegex, (match, refPath) => {
+            const fullPath = refPath.startsWith('/')
+                ? refPath
+                : join(basePath, '..', refPath);
+            if (existsSync(fullPath)) {
+                try {
+                    return readFileSync(fullPath, 'utf-8');
+                }
+                catch {
+                    return match;
+                }
+            }
+            return match;
+        });
+    }
+    detectTechStack() {
+        const stack = [];
+        const checks = [
+            { file: 'package.json', tech: 'Node.js/JavaScript' },
+            { file: 'tsconfig.json', tech: 'TypeScript' },
+            { file: 'pyproject.toml', tech: 'Python' },
+            { file: 'Cargo.toml', tech: 'Rust' },
+            { file: 'go.mod', tech: 'Go' },
+            { file: 'pom.xml', tech: 'Java/Maven' },
+            { file: 'build.gradle', tech: 'Java/Gradle' },
+            { file: 'Dockerfile', tech: 'Docker' },
+            { file: 'docker-compose.yml', tech: 'Docker Compose' },
+            { file: '.github/workflows', tech: 'GitHub Actions' },
+            { file: 'Gemfile', tech: 'Ruby' },
+            { file: 'mix.exs', tech: 'Elixir' },
+            { file: 'composer.json', tech: 'PHP' },
+        ];
+        for (const { file, tech } of checks) {
+            if (existsSync(join(this.workingDirectory, file))) {
+                stack.push(tech);
+            }
+        }
+        return stack;
+    }
+    generateStarterMd(techStack) {
+        return `# NeuroCLI Project Context
+
+## Tech Stack
+${techStack.map(t => `- ${t}`).join('\n') || '- Auto-detected on first run'}
+
+## Project Structure
+<!-- Describe your project structure here -->
+
+## Conventions
+<!-- Add your coding conventions and preferences -->
+- Follow existing code style
+- Write tests for new features
+- Use meaningful variable names
+
+## Common Commands
+<!-- Add frequently used commands -->
+\`\`\`bash
+# Build
+# Test
+# Deploy
+\`\`\`
+
+## Important Notes
+<!-- Any important context for the AI assistant -->
+`;
+    }
+}
+//# sourceMappingURL=neuro-md.js.map

package/dist/context/neuroignore.d.ts

@@ -0,0 +1,102 @@
+export interface IgnoreRule {
+    pattern: string;
+    negated: boolean;
+    regex: RegExp;
+    source: string;
+}
+export declare class NeuroIgnore {
+    private rules;
+    private cache;
+    private projectRoot;
+    private loaded;
+    constructor(projectRoot: string);
+    /**
+     * Load ignore rules from all sources:
+     *   1. Default patterns
+     *   2. ~/.neuro/ignore  (global user rules)
+     *   3. .neuroignore     (project-root rules)
+     */
+    load(): void;
+    /**
+     * 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: string): boolean;
+    /**
+     * Filter an array of paths, removing those that are ignored.
+     */
+    filterPaths(paths: string[]): string[];
+    /**
+     * Dynamically add a rule at runtime.
+     */
+    addRule(pattern: string, source?: string): void;
+    /**
+     * Remove a rule by its original pattern string.
+     * Returns true if a rule was found and removed.
+     */
+    removeRule(pattern: string): boolean;
+    /**
+     * Return a shallow copy of the current rules list.
+     */
+    getRules(): IgnoreRule[];
+    /**
+     * Clear the result cache.
+     */
+    clearCache(): void;
+    /**
+     * Print all active rules to stdout (useful for debugging).
+     */
+    printRules(): void;
+    static readonly DEFAULT_IGNORED: string[];
+    /**
+     * Load rules from a single file. Lines starting with # are comments.
+     * Blank lines are skipped. Trailing whitespace is trimmed.
+     */
+    private loadFromFile;
+    /**
+     * Populate the default ignore rules.
+     */
+    private loadDefaultRules;
+    /**
+     * 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.
+     */
+    private patternToRegex;
+    /**
+     * Escape a string for use inside a RegExp.
+     */
+    private escapeRegex;
+    /**
+     * Ensure rules have been loaded before answering queries.
+     */
+    private ensureLoaded;
+    /**
+     * 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.
+     */
+    private toRelativePosix;
+    /**
+     * 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).
+     */
+    private autoDetectIgnorableDirs;
+}
+//# sourceMappingURL=neuroignore.d.ts.map