@suco/su-auggie-mcp 0.1.0

package/dist/file-indexer.js

@@ -0,0 +1,587 @@
+/**
+ * FileIndexer - Centralized file indexing with file-level error handling.
+ *
+ * Single entry point for ALL file indexing operations:
+ * - Initial discovery indexing
+ * - File watcher changes
+ * - Retry (tier 1 & tier 2)
+ *
+ * Errors are handled at FILE level, not BATCH level.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { BlobTooLargeError, APIError } from '@augmentcode/auggie-sdk';
+import PQueue from 'p-queue';
+import { INDEXING_CONFIG, PERSISTENCE_CONFIG, isPersistenceEnabled } from './config.js';
+import { createLogger } from './logger.js';
+import { sendLogToClient } from './mcp-notifications.js';
+import { AdaptiveBatcher } from './adaptive-batcher.js';
+const logger = createLogger('FileIndexer');
+/**
+ * Classify an error at the FILE level.
+ * Returns: skip | retryable | permanent | fatal
+ * @internal Exported for testing
+ */
+export function classifyFileError(err) {
+    // Skip - file cannot be indexed (not a failure)
+    if (err instanceof BlobTooLargeError)
+        return 'skip';
+    const msg = err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
+    if (msg.includes('too large'))
+        return 'skip';
+    if (msg.includes('enoent') || msg.includes('not found'))
+        return 'skip';
+    if (msg.includes('eacces') || msg.includes('permission denied'))
+        return 'skip';
+    if (msg.includes('eisdir') || msg.includes('is a directory'))
+        return 'skip';
+    // Fatal - stop everything
+    if (err instanceof APIError) {
+        if (err.status === 401 || err.status === 403)
+            return 'fatal';
+        // Rate limit or server errors are retryable
+        if (err.status === 429 || err.status >= 500)
+            return 'retryable';
+        // Other client errors are permanent
+        if (err.status >= 400)
+            return 'permanent';
+    }
+    // Network/timeout errors are retryable
+    if (msg.includes('fetch failed') || msg.includes('network'))
+        return 'retryable';
+    if (msg.includes('timeout') || msg.includes('econnreset'))
+        return 'retryable';
+    if (msg.includes('rate') || msg.includes('throttl'))
+        return 'retryable';
+    // Default to retryable (optimistic)
+    return 'retryable';
+}
+/**
+ * Check if a file is binary (non-text).
+ * Uses null byte detection in first 8KB.
+ * @internal Exported for testing
+ */
+export function isBinaryFile(buffer) {
+    const checkLength = Math.min(buffer.length, 8192);
+    for (let i = 0; i < checkLength; i++) {
+        if (buffer[i] === 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * Calculate exponential backoff delay with jitter.
+ * @internal Exported for testing
+ */
+export function calculateBackoff(attempt) {
+    const base = INDEXING_CONFIG.RETRY_BASE_DELAY_MS;
+    const max = INDEXING_CONFIG.RETRY_MAX_DELAY_MS;
+    const exponential = base * Math.pow(2, attempt);
+    const jitter = Math.random() * base * 0.5;
+    return Math.min(exponential + jitter, max);
+}
+/**
+ * FileIndexer - centralized indexing with file-level error handling.
+ */
+export class FileIndexer {
+    context;
+    root;
+    batcher;
+    indexQueue;
+    // Tier 1: Immediate retry queue (in-memory)
+    retryQueue = [];
+    // Tier 2: Cooldown queue (persisted)
+    cooldownQueue = [];
+    cooldownTimer = null;
+    cooldownNextRetryAt = null;
+    // Statistics
+    stats = {
+        indexed: 0,
+        skipped: 0,
+        recovered: 0,
+        failed: 0,
+    };
+    constructor(context, root) {
+        this.context = context;
+        this.root = root;
+        this.batcher = new AdaptiveBatcher();
+        this.indexQueue = new PQueue({ concurrency: this.batcher.getConcurrency() });
+        this.loadCooldownQueue();
+    }
+    /** Get current statistics */
+    getStats() {
+        const currentCycle = this.cooldownQueue.length > 0
+            ? Math.max(...this.cooldownQueue.map(e => e.cooldownCycle))
+            : 0;
+        return {
+            indexed: this.stats.indexed,
+            skipped: this.stats.skipped,
+            pendingRetry: this.retryQueue.length,
+            pendingCooldown: this.cooldownQueue.length,
+            recovered: this.stats.recovered,
+            failed: this.stats.failed,
+            cooldownCycle: currentCycle,
+            cooldownNextRetryAt: this.cooldownNextRetryAt?.toISOString() ?? null,
+        };
+    }
+    /** Get batcher metrics */
+    getBatcherMetrics() {
+        return this.batcher.getMetrics();
+    }
+    /** Get batcher for external access */
+    getBatcher() {
+        return this.batcher;
+    }
+    /**
+     * Pre-filter a file before reading contents.
+     * Returns null if file should be skipped, or file entry if valid.
+     */
+    preFilterFile(absolutePath) {
+        try {
+            const stat = fs.statSync(absolutePath);
+            // Size check
+            if (stat.size > INDEXING_CONFIG.MAX_FILE_SIZE) {
+                logger.debug(`Skip: too large (${stat.size} bytes): ${absolutePath}`);
+                this.stats.skipped++;
+                return null;
+            }
+            // Empty file check
+            if (stat.size === 0) {
+                logger.debug(`Skip: empty file: ${absolutePath}`);
+                this.stats.skipped++;
+                return null;
+            }
+            // Read file
+            const buffer = fs.readFileSync(absolutePath);
+            // Binary check
+            if (isBinaryFile(buffer)) {
+                logger.debug(`Skip: binary file: ${absolutePath}`);
+                this.stats.skipped++;
+                return null;
+            }
+            const contents = buffer.toString('utf-8');
+            const relativePath = path.relative(this.root, absolutePath);
+            return {
+                entry: { path: relativePath, contents },
+                metadata: { mtimeMs: stat.mtimeMs, size: stat.size },
+            };
+        }
+        catch (err) {
+            const errorType = classifyFileError(err);
+            if (errorType === 'skip') {
+                logger.debug(`Skip: ${err instanceof Error ? err.message : err}: ${absolutePath}`);
+                this.stats.skipped++;
+            }
+            return null;
+        }
+    }
+    /**
+     * Index a batch of files with error isolation.
+     * On batch failure, isolates problematic files and retries good ones.
+     */
+    async indexBatchWithIsolation(files, _metadata) {
+        const succeeded = [];
+        const failed = [];
+        if (files.length === 0)
+            return { succeeded, failed };
+        const batchStart = Date.now();
+        try {
+            await this.context.addToIndex(files, { waitForIndexing: false });
+            // All succeeded
+            succeeded.push(...files.map(f => f.path));
+            this.stats.indexed += files.length;
+            const batchTime = Date.now() - batchStart;
+            this.batcher.recordBatchComplete(batchTime, files.length, files.reduce((sum, f) => sum + Buffer.byteLength(f.contents, 'utf-8'), 0), false, false);
+            this.indexQueue.concurrency = this.batcher.getConcurrency();
+        }
+        catch (err) {
+            const errorType = classifyFileError(err);
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            if (errorType === 'fatal') {
+                // Fatal error - mark all as failed and re-throw
+                for (const f of files) {
+                    failed.push({ path: f.path, error: 'fatal', message: errorMsg });
+                }
+                throw err;
+            }
+            // Batch failed - isolate problematic files
+            if (files.length === 1) {
+                // Single file batch - this file is the problem
+                failed.push({ path: files[0].path, error: errorType, message: errorMsg });
+            }
+            else {
+                // Multi-file batch - try one by one to isolate
+                logger.info(`Batch failed, isolating ${files.length} files...`);
+                for (const file of files) {
+                    try {
+                        await this.context.addToIndex([file], { waitForIndexing: false });
+                        succeeded.push(file.path);
+                        this.stats.indexed++;
+                    }
+                    catch (fileErr) {
+                        const fileErrorType = classifyFileError(fileErr);
+                        const fileErrorMsg = fileErr instanceof Error ? fileErr.message : String(fileErr);
+                        if (fileErrorType === 'fatal') {
+                            // Fatal during isolation - fail remaining and throw
+                            failed.push({ path: file.path, error: 'fatal', message: fileErrorMsg });
+                            throw fileErr;
+                        }
+                        failed.push({ path: file.path, error: fileErrorType, message: fileErrorMsg });
+                    }
+                }
+            }
+            const batchTime = Date.now() - batchStart;
+            this.batcher.recordBatchComplete(batchTime, files.length, files.reduce((sum, f) => sum + Buffer.byteLength(f.contents, 'utf-8'), 0), true, errorType === 'retryable');
+            this.indexQueue.concurrency = this.batcher.getConcurrency();
+        }
+        return { succeeded, failed };
+    }
+    /**
+     * Route failed files to appropriate tier based on error type.
+     */
+    routeFailedFiles(failures) {
+        for (const f of failures) {
+            if (f.error === 'skip') {
+                // Already counted in preFilter, nothing to do
+                continue;
+            }
+            if (f.error === 'permanent') {
+                this.stats.failed++;
+                logger.warn(`Permanent failure: ${f.path}: ${f.message}`);
+                continue;
+            }
+            if (f.error === 'retryable') {
+                // Check if already in retry queue
+                const existing = this.retryQueue.find(e => e.path === f.path);
+                if (existing) {
+                    existing.attempts++;
+                    existing.lastError = f.message;
+                    existing.nextRetryAt = new Date(Date.now() + calculateBackoff(existing.attempts));
+                    // Check if exhausted tier 1
+                    if (existing.attempts > INDEXING_CONFIG.MAX_RETRIES) {
+                        this.retryQueue = this.retryQueue.filter(e => e.path !== f.path);
+                        this.addToCooldown(f.path, f.message);
+                    }
+                }
+                else {
+                    // New retry entry
+                    this.retryQueue.push({
+                        path: f.path,
+                        attempts: 1,
+                        lastError: f.message,
+                        nextRetryAt: new Date(Date.now() + calculateBackoff(0)),
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Add a file to cooldown queue (tier 2).
+     */
+    addToCooldown(filePath, lastError) {
+        const existing = this.cooldownQueue.find(e => e.path === filePath);
+        if (existing) {
+            existing.lastError = lastError;
+            existing.lastRetryAt = new Date().toISOString();
+        }
+        else {
+            this.cooldownQueue.push({
+                path: filePath,
+                cooldownCycle: 0,
+                lastError,
+                addedAt: new Date().toISOString(),
+                lastRetryAt: null,
+            });
+        }
+        this.saveCooldownQueue();
+        this.scheduleCooldownRetry();
+    }
+    /**
+     * Process tier 1 retry queue.
+     */
+    async processRetryQueue() {
+        if (this.retryQueue.length === 0)
+            return;
+        const pending = [...this.retryQueue];
+        this.retryQueue = [];
+        logger.info(`Processing ${pending.length} files in retry queue`);
+        for (const entry of pending) {
+            // Wait until retry time
+            const now = Date.now();
+            if (entry.nextRetryAt.getTime() > now) {
+                await new Promise(resolve => setTimeout(resolve, entry.nextRetryAt.getTime() - now));
+            }
+            // Re-read file
+            const absolutePath = path.join(this.root, entry.path);
+            const filtered = this.preFilterFile(absolutePath);
+            if (!filtered) {
+                // File no longer valid - skip
+                continue;
+            }
+            const { succeeded, failed } = await this.indexBatchWithIsolation([filtered.entry], { [filtered.entry.path]: filtered.metadata });
+            if (succeeded.length > 0) {
+                this.stats.recovered++;
+                logger.info(`Recovered: ${entry.path}`);
+            }
+            if (failed.length > 0) {
+                // Update attempt count and re-route
+                const updatedFailure = { ...failed[0], attempts: entry.attempts + 1 };
+                if (updatedFailure.attempts > INDEXING_CONFIG.MAX_RETRIES) {
+                    this.addToCooldown(updatedFailure.path, updatedFailure.message);
+                    logger.info(`Moved to cooldown: ${updatedFailure.path}`);
+                }
+                else {
+                    this.retryQueue.push({
+                        path: updatedFailure.path,
+                        attempts: updatedFailure.attempts,
+                        lastError: updatedFailure.message,
+                        nextRetryAt: new Date(Date.now() + calculateBackoff(updatedFailure.attempts)),
+                    });
+                }
+            }
+        }
+        // Process any remaining retries
+        if (this.retryQueue.length > 0) {
+            await this.processRetryQueue();
+        }
+    }
+    /**
+     * Schedule cooldown retry if not already scheduled.
+     */
+    scheduleCooldownRetry() {
+        if (this.cooldownQueue.length === 0 || this.cooldownTimer)
+            return;
+        const delayMs = INDEXING_CONFIG.COOLDOWN_PERIOD_MS;
+        this.cooldownNextRetryAt = new Date(Date.now() + delayMs);
+        const delayMinutes = Math.round(delayMs / 60000);
+        logger.info(`Cooldown retry scheduled in ${delayMinutes} min (${this.cooldownQueue.length} files)`);
+        sendLogToClient('info', `Cooldown retry in ${delayMinutes} min for ${this.cooldownQueue.length} files`);
+        this.cooldownTimer = setTimeout(() => {
+            this.cooldownTimer = null;
+            this.processCooldownQueue().catch(err => {
+                logger.error('Cooldown processing failed', err);
+            });
+        }, delayMs);
+    }
+    /**
+     * Process cooldown queue (tier 2).
+     */
+    async processCooldownQueue() {
+        if (this.cooldownQueue.length === 0)
+            return;
+        const currentCycle = Math.max(...this.cooldownQueue.map(e => e.cooldownCycle)) + 1;
+        logger.info(`Cooldown cycle ${currentCycle}/${INDEXING_CONFIG.MAX_COOLDOWN_CYCLES}: ${this.cooldownQueue.length} files`);
+        sendLogToClient('info', `Cooldown retry cycle ${currentCycle}/${INDEXING_CONFIG.MAX_COOLDOWN_CYCLES}: ${this.cooldownQueue.length} files`);
+        const succeeded = [];
+        const stillFailed = [];
+        for (const entry of this.cooldownQueue) {
+            // Re-read file
+            const absolutePath = path.join(this.root, entry.path);
+            const filtered = this.preFilterFile(absolutePath);
+            if (!filtered) {
+                // File no longer valid - remove from cooldown
+                continue;
+            }
+            try {
+                await this.context.addToIndex([filtered.entry], { waitForIndexing: false });
+                succeeded.push(entry.path);
+                this.stats.recovered++;
+            }
+            catch (err) {
+                const errorType = classifyFileError(err);
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                if (errorType === 'fatal') {
+                    throw err;
+                }
+                if (errorType === 'skip' || errorType === 'permanent') {
+                    this.stats.failed++;
+                    logger.warn(`Cooldown permanent fail: ${entry.path}: ${errorMsg}`);
+                    continue;
+                }
+                // Still retryable - check cycle limit
+                if (currentCycle >= INDEXING_CONFIG.MAX_COOLDOWN_CYCLES) {
+                    this.stats.failed++;
+                    logger.warn(`Cooldown exhausted: ${entry.path}`);
+                }
+                else {
+                    stillFailed.push({
+                        ...entry,
+                        cooldownCycle: currentCycle,
+                        lastError: errorMsg,
+                        lastRetryAt: new Date().toISOString(),
+                    });
+                }
+            }
+        }
+        this.cooldownQueue = stillFailed;
+        this.cooldownNextRetryAt = null;
+        this.saveCooldownQueue();
+        if (succeeded.length > 0) {
+            logger.info(`Cooldown recovered ${succeeded.length} files`);
+            sendLogToClient('info', `Cooldown recovered ${succeeded.length} files`);
+        }
+        // Schedule next cycle if needed
+        this.scheduleCooldownRetry();
+    }
+    /**
+     * Main entry point: Index a list of file paths.
+     * Handles batching, pre-filtering, error isolation, and retry routing.
+     */
+    async indexFiles(absolutePaths, onProgress) {
+        const metadata = {};
+        const validFiles = [];
+        let skippedCount = 0;
+        // Pre-filter all files
+        for (const absPath of absolutePaths) {
+            const result = this.preFilterFile(absPath);
+            if (result) {
+                validFiles.push(result.entry);
+                metadata[result.entry.path] = result.metadata;
+            }
+            else {
+                skippedCount++;
+            }
+        }
+        if (validFiles.length === 0) {
+            return { metadata, indexed: 0, skipped: skippedCount };
+        }
+        // Create batches (generator -> array)
+        const batches = [...this.batcher.createBatches(validFiles)];
+        let indexedCount = 0;
+        let batchNum = 0;
+        const totalBatches = batches.length;
+        // Process batches with concurrency
+        const batchPromises = batches.map(batch => {
+            return this.indexQueue.add(async () => {
+                batchNum++;
+                const { succeeded, failed } = await this.indexBatchWithIsolation(batch.files, metadata);
+                indexedCount += succeeded.length;
+                // Route failures
+                this.routeFailedFiles(failed);
+                if (onProgress) {
+                    onProgress(indexedCount, validFiles.length, `Batch ${batchNum}/${totalBatches}`);
+                }
+            });
+        });
+        await Promise.all(batchPromises);
+        // Process any immediate retries
+        if (this.retryQueue.length > 0) {
+            await this.processRetryQueue();
+        }
+        return { metadata, indexed: indexedCount, skipped: skippedCount };
+    }
+    /**
+     * Index a single file (for watcher events).
+     */
+    async indexSingleFile(absolutePath) {
+        const result = this.preFilterFile(absolutePath);
+        if (!result)
+            return false;
+        const { succeeded, failed } = await this.indexBatchWithIsolation([result.entry], { [result.entry.path]: result.metadata });
+        this.routeFailedFiles(failed);
+        return succeeded.length > 0;
+    }
+    /**
+     * Remove files from index.
+     */
+    async removeFiles(relativePaths) {
+        if (relativePaths.length === 0)
+            return;
+        try {
+            await this.context.removeFromIndex(relativePaths);
+            logger.debug(`Removed ${relativePaths.length} files from index`);
+        }
+        catch (err) {
+            logger.error('Failed to remove files from index', err);
+        }
+    }
+    /**
+     * Load cooldown queue from disk.
+     */
+    loadCooldownQueue() {
+        if (!isPersistenceEnabled())
+            return;
+        const stateDir = path.join(this.root, PERSISTENCE_CONFIG.STATE_DIR);
+        const cooldownPath = path.join(stateDir, PERSISTENCE_CONFIG.COOLDOWN_FILE);
+        try {
+            if (fs.existsSync(cooldownPath)) {
+                const data = JSON.parse(fs.readFileSync(cooldownPath, 'utf-8'));
+                this.cooldownQueue = data.entries;
+                if (data.nextRetryAt) {
+                    this.cooldownNextRetryAt = new Date(data.nextRetryAt);
+                }
+                logger.info(`Loaded ${this.cooldownQueue.length} files from cooldown queue`);
+                this.scheduleCooldownRetry();
+            }
+        }
+        catch (err) {
+            logger.warn('Failed to load cooldown queue', err);
+        }
+    }
+    /**
+     * Save cooldown queue to disk.
+     */
+    saveCooldownQueue() {
+        if (!isPersistenceEnabled())
+            return;
+        const stateDir = path.join(this.root, PERSISTENCE_CONFIG.STATE_DIR);
+        const cooldownPath = path.join(stateDir, PERSISTENCE_CONFIG.COOLDOWN_FILE);
+        try {
+            if (!fs.existsSync(stateDir)) {
+                fs.mkdirSync(stateDir, { recursive: true });
+            }
+            const data = {
+                version: 1,
+                savedAt: new Date().toISOString(),
+                nextRetryAt: this.cooldownNextRetryAt?.toISOString() ?? null,
+                entries: this.cooldownQueue,
+            };
+            fs.writeFileSync(cooldownPath, JSON.stringify(data, null, 2));
+        }
+        catch (err) {
+            logger.warn('Failed to save cooldown queue', err);
+        }
+    }
+    /**
+     * Stop the indexer and clean up.
+     */
+    stop() {
+        if (this.cooldownTimer) {
+            clearTimeout(this.cooldownTimer);
+            this.cooldownTimer = null;
+        }
+        this.indexQueue.clear();
+        this.saveCooldownQueue();
+    }
+    /**
+     * Reset statistics (for reindex).
+     */
+    resetStats() {
+        this.stats = { indexed: 0, skipped: 0, recovered: 0, failed: 0 };
+        this.retryQueue = [];
+        // Don't clear cooldown queue - it persists across reindex
+    }
+    /**
+     * Close the indexer (alias for stop).
+     */
+    close() {
+        this.stop();
+    }
+    /**
+     * Trigger retry if conditions are met (no pending work, has failed files).
+     * This is a "hit and run" call - triggers async retry and returns immediately.
+     * Used by tool calls to opportunistically retry failed files.
+     */
+    triggerRetryIfNeeded() {
+        // Check conditions: no pending work and has failed files in cooldown
+        const hasPending = this.retryQueue.length > 0 || this.indexQueue.pending > 0;
+        const hasFailedInCooldown = this.cooldownQueue.length > 0;
+        if (!hasPending && hasFailedInCooldown) {
+            logger.info(`Triggering retry: ${this.cooldownQueue.length} files in cooldown`);
+            // Fire and forget - don't await
+            this.processCooldownQueue().catch(err => {
+                logger.error(`Cooldown retry failed: ${err instanceof Error ? err.message : err}`);
+            });
+        }
+    }
+}

package/dist/ignore-filter.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ignore filter using .gitignore and .augmentignore patterns
+ */
+import { Ignore } from 'ignore';
+/** Create an ignore filter for a workspace */
+export declare function createIgnoreFilter(workspaceRoot: string): Ignore;
+/** Check if a relative path should be ignored */
+export declare function shouldIgnore(ig: Ignore, relativePath: string): boolean;

package/dist/ignore-filter.js

@@ -0,0 +1,88 @@
+/**
+ * Ignore filter using .gitignore and .augmentignore patterns
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import ignore from 'ignore';
+import { createLogger } from './logger.js';
+const logger = createLogger('IgnoreFilter');
+/** Load ignore patterns from a file if it exists */
+function loadIgnoreFile(filePath) {
+    try {
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return content
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line && !line.startsWith('#'));
+        }
+    }
+    catch (err) {
+        logger.warn(`Failed to read ignore file: ${filePath}`, err);
+    }
+    return [];
+}
+/** Recursively find all .gitignore files in workspace */
+function findGitignoreFiles(workspaceRoot) {
+    const gitignores = [];
+    function walk(dir) {
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    // Skip .git directory
+                    if (entry.name !== '.git') {
+                        walk(fullPath);
+                    }
+                }
+                else if (entry.name === '.gitignore') {
+                    gitignores.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Ignore permission errors
+        }
+    }
+    walk(workspaceRoot);
+    return gitignores;
+}
+/** Create an ignore filter for a workspace */
+export function createIgnoreFilter(workspaceRoot) {
+    const ig = ignore();
+    // Always ignore .git directory and our own state directory
+    ig.add('.git');
+    ig.add('.suco-auggie');
+    // Load root .gitignore
+    const rootGitignore = path.join(workspaceRoot, '.gitignore');
+    const rootPatterns = loadIgnoreFile(rootGitignore);
+    if (rootPatterns.length > 0) {
+        logger.debug(`Loaded ${rootPatterns.length} patterns from ${rootGitignore}`);
+        ig.add(rootPatterns);
+    }
+    // Load nested .gitignore files
+    const nestedGitignores = findGitignoreFiles(workspaceRoot).filter((p) => p !== rootGitignore);
+    for (const gitignorePath of nestedGitignores) {
+        const relativePath = path.relative(workspaceRoot, path.dirname(gitignorePath));
+        const patterns = loadIgnoreFile(gitignorePath);
+        // Prefix patterns with relative directory
+        const prefixedPatterns = patterns.map((p) => p.startsWith('/') ? path.join(relativePath, p.slice(1)) : path.join(relativePath, p));
+        if (prefixedPatterns.length > 0) {
+            logger.debug(`Loaded ${prefixedPatterns.length} patterns from ${gitignorePath}`);
+            ig.add(prefixedPatterns);
+        }
+    }
+    // Load .augmentignore
+    const augmentignore = path.join(workspaceRoot, '.augmentignore');
+    const augmentPatterns = loadIgnoreFile(augmentignore);
+    if (augmentPatterns.length > 0) {
+        logger.debug(`Loaded ${augmentPatterns.length} patterns from ${augmentignore}`);
+        ig.add(augmentPatterns);
+    }
+    return ig;
+}
+/** Check if a relative path should be ignored */
+export function shouldIgnore(ig, relativePath) {
+    return ig.ignores(relativePath);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * suco-auggie-mcp CLI
+ * MCP server exposing Augment Code context engine capabilities
+ */
+/** CLI options passed to server */
+export interface CLIOptions {
+    workspaces: string[];
+    ignoreRoots: boolean;
+}