@supermodeltools/mcp-server 0.4.4 → 0.4.6

package/dist/utils/zip-repository.js

@@ -1,8 +1,41 @@
 "use strict";
 /**
- * Automatic repository zipping with gitignore support
+ * Automatic repository zipping with gitignore and dockerignore support
  * Creates temporary ZIP files for codebase analysis
  */
+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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -15,9 +48,11 @@ const os_1 = require("os");
 const archiver_1 = __importDefault(require("archiver"));
 const ignore_1 = __importDefault(require("ignore"));
 const crypto_1 = require("crypto");
+const constants_1 = require("../constants");
+const logger = __importStar(require("./logger"));
 /**
  * Standard exclusions for security and size optimization
- * These patterns are applied in addition to .gitignore
+ * These patterns are applied in addition to .gitignore and .dockerignore
  */
 const STANDARD_EXCLUSIONS = [
     // Version control
@@ -82,34 +117,69 @@ const STANDARD_EXCLUSIONS = [
     '*.dmg',
 ];
 /**
- * Create a ZIP archive of a directory with gitignore support
+ * Create a ZIP archive of a directory with gitignore and dockerignore support
+ *
+ * @param directoryPath - Path to the directory to archive
+ * @param options - Configuration options for ZIP creation
+ * @param options.maxSizeBytes - Maximum ZIP size in bytes (default: 500MB)
+ * @param options.additionalExclusions - Custom patterns to exclude
+ * @param options.includeGitignore - Whether to include .gitignore files (default: true)
+ * @param options.onProgress - Optional callback to track progress
+ * @param options.progressInterval - Files to process between progress callbacks (default: 100)
+ * @returns Promise resolving to ZipResult with path, cleanup function, and metadata
+ *
+ * @example
+ * // Create ZIP excluding .gitignore files with progress tracking
+ * const result = await zipRepository('/path/to/repo', {
+ *   includeGitignore: false,
+ *   maxSizeBytes: 100 * 1024 * 1024, // 100MB
+ *   onProgress: (stats) => console.log(`${stats.filesProcessed} files`)
+ * });
  */
 async function zipRepository(directoryPath, options = {}) {
-    const maxSizeBytes = options.maxSizeBytes || 500 * 1024 * 1024; // 500MB default
+    const maxSizeBytes = options.maxSizeBytes || constants_1.MAX_ZIP_SIZE_BYTES;
     // Validate directory exists
     try {
         const stats = await fs_1.promises.stat(directoryPath);
         if (!stats.isDirectory()) {
-            throw new Error(`Path is not a directory: ${directoryPath}`);
+            const errorMsg = `Path is not a directory: ${directoryPath}`;
+            logger.error(errorMsg);
+            throw new Error(errorMsg);
         }
     }
     catch (error) {
         if (error.code === 'ENOENT') {
-            throw new Error(`Directory does not exist: ${directoryPath}`);
+            const errorMsg = `Directory does not exist: ${directoryPath}`;
+            logger.error(errorMsg);
+            throw new Error(errorMsg);
         }
         if (error.code === 'EACCES') {
-            throw new Error(`Permission denied accessing directory: ${directoryPath}`);
+            const errorMsg = `Permission denied accessing directory: ${directoryPath}`;
+            logger.error(errorMsg);
+            throw new Error(errorMsg);
         }
+        // Re-throw unknown errors with logging
+        logger.error('Failed to validate directory:', directoryPath);
+        logger.error('Error:', error.message);
         throw error;
     }
     // Parse gitignore files
-    const ignoreFilter = await buildIgnoreFilter(directoryPath, options.additionalExclusions);
+    const ignoreFilter = await buildIgnoreFilter(directoryPath, options.additionalExclusions, options.includeGitignore);
+    // Estimate directory size before starting ZIP creation
+    logger.debug('Estimating directory size...');
+    const estimatedSize = await estimateDirectorySize(directoryPath, ignoreFilter);
+    logger.debug('Estimated size:', formatBytes(estimatedSize));
+    // Check if estimated size exceeds limit
+    if (estimatedSize > maxSizeBytes) {
+        throw new Error(`Directory size (${formatBytes(estimatedSize)}) exceeds maximum allowed size (${formatBytes(maxSizeBytes)}). ` +
+            `Consider excluding more directories or analyzing a subdirectory.`);
+    }
     // Create temp file path
     const tempDir = (0, os_1.tmpdir)();
     const zipFileName = `supermodel-${(0, crypto_1.randomBytes)(8).toString('hex')}.zip`;
     const zipPath = (0, path_1.join)(tempDir, zipFileName);
-    console.error('[DEBUG] Creating ZIP:', zipPath);
-    console.error('[DEBUG] Source directory:', directoryPath);
+    logger.debug('Creating ZIP:', zipPath);
+    logger.debug('Source directory:', directoryPath);
     // Create ZIP archive
     let fileCount = 0;
     let totalSize = 0;
@@ -120,14 +190,15 @@ async function zipRepository(directoryPath, options = {}) {
     // Track errors
     let archiveError = null;
     archive.on('error', (err) => {
+        logger.error('Archive error:', err.message);
         archiveError = err;
     });
     archive.on('warning', (err) => {
         if (err.code === 'ENOENT') {
-            console.error('[WARN] File not found (skipping):', err.message);
+            logger.warn('File not found (skipping):', err.message);
         }
         else {
-            console.error('[WARN] Archive warning:', err.message);
+            logger.warn('Archive warning:', err.message);
         }
     });
     // Track progress
@@ -136,16 +207,22 @@ async function zipRepository(directoryPath, options = {}) {
         totalSize += entry.stats?.size || 0;
         // Check size limit
         if (totalSize > maxSizeBytes) {
-            archive.abort();
-            archiveError = new Error(`ZIP size exceeds limit (${formatBytes(maxSizeBytes)}). ` +
+            const errorMsg = `ZIP size exceeds limit (${formatBytes(maxSizeBytes)}). ` +
                 `Current size: ${formatBytes(totalSize)}. ` +
-                `Consider excluding more directories or analyzing a subdirectory.`);
+                `Consider excluding more directories or analyzing a subdirectory.`;
+            logger.error(errorMsg);
+            archive.abort();
+            archiveError = new Error(errorMsg);
         }
     });
     // Pipe to file
     archive.pipe(output);
     // Add files recursively with filtering
-    await addFilesRecursively(archive, directoryPath, directoryPath, ignoreFilter);
+    // Initialize progress state if progress callback is provided
+    const progressState = options.onProgress
+        ? { filesProcessed: 0, bytesProcessed: 0, lastReportedCount: 0, lastFile: '' }
+        : undefined;
+    await addFilesRecursively(archive, directoryPath, directoryPath, ignoreFilter, options, progressState);
     // Finalize archive
     await archive.finalize();
     // Wait for output stream to finish
@@ -158,10 +235,14 @@ async function zipRepository(directoryPath, options = {}) {
                 resolve();
             }
         });
-        output.on('error', reject);
+        output.on('error', (err) => {
+            logger.error('Output stream error:', err.message);
+            reject(err);
+        });
     });
     // Check for errors during archiving
     if (archiveError) {
+        logger.error('Archiving failed, cleaning up partial ZIP');
         // Clean up partial ZIP
         await fs_1.promises.unlink(zipPath).catch(() => { });
         throw archiveError;
@@ -169,18 +250,18 @@ async function zipRepository(directoryPath, options = {}) {
     // Get final file size
     const zipStats = await fs_1.promises.stat(zipPath);
     const zipSizeBytes = zipStats.size;
-    console.error('[DEBUG] ZIP created successfully');
-    console.error('[DEBUG] Files included:', fileCount);
-    console.error('[DEBUG] ZIP size:', formatBytes(zipSizeBytes));
+    logger.debug('ZIP created successfully');
+    logger.debug('Files included:', fileCount);
+    logger.debug('ZIP size:', formatBytes(zipSizeBytes));
     // Create cleanup function
     const cleanup = async () => {
         try {
             await fs_1.promises.unlink(zipPath);
-            console.error('[DEBUG] Cleaned up ZIP:', zipPath);
+            logger.debug('Cleaned up ZIP:', zipPath);
         }
         catch (error) {
             if (error.code !== 'ENOENT') {
-                console.error('[WARN] Failed to cleanup ZIP:', error.message);
+                logger.warn('Failed to cleanup ZIP:', error.message);
             }
         }
     };
@@ -192,9 +273,76 @@ async function zipRepository(directoryPath, options = {}) {
     };
 }
 /**
- * Build ignore filter from .gitignore files and standard exclusions
+ * Estimate total size of directory with ignore filters applied
+ * Returns total size in bytes of files that would be included in the ZIP
  */
-async function buildIgnoreFilter(rootDir, additionalExclusions = []) {
+async function estimateDirectorySize(rootDir, ignoreFilter) {
+    let totalSize = 0;
+    async function walkDirectory(currentDir) {
+        let entries;
+        try {
+            entries = await fs_1.promises.readdir(currentDir);
+        }
+        catch (error) {
+            if (error.code === 'EACCES') {
+                logger.warn('Permission denied:', currentDir);
+                return;
+            }
+            throw error;
+        }
+        for (const entry of entries) {
+            const fullPath = (0, path_1.join)(currentDir, entry);
+            const relativePath = (0, path_1.relative)(rootDir, fullPath);
+            // Normalize path for ignore matching (use forward slashes)
+            const normalizedRelativePath = relativePath.split(path_1.sep).join('/');
+            // Check if ignored
+            if (ignoreFilter.ignores(normalizedRelativePath)) {
+                continue;
+            }
+            let stats;
+            try {
+                stats = await fs_1.promises.lstat(fullPath);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    // File disappeared, skip
+                    continue;
+                }
+                logger.warn('Failed to stat:', fullPath, error.message);
+                continue;
+            }
+            // Skip symlinks to prevent following links outside the repository
+            if (stats.isSymbolicLink()) {
+                continue;
+            }
+            if (stats.isDirectory()) {
+                // Check if directory itself should be ignored
+                const dirPath = normalizedRelativePath + '/';
+                if (ignoreFilter.ignores(dirPath)) {
+                    continue;
+                }
+                // Recurse into directory
+                await walkDirectory(fullPath);
+            }
+            else if (stats.isFile()) {
+                // Add file size to total
+                totalSize += stats.size;
+            }
+            // Skip other special files (sockets, FIFOs, etc.)
+        }
+    }
+    await walkDirectory(rootDir);
+    return totalSize;
+}
+/**
+ * Build ignore filter from .gitignore, .dockerignore files and standard exclusions
+ * Recursively finds and parses .gitignore files in subdirectories
+ *
+ * @param rootDir - Root directory to build filter for
+ * @param additionalExclusions - Additional patterns to exclude
+ * @param includeGitignore - Whether to include .gitignore files in the archive (default: true)
+ */
+async function buildIgnoreFilter(rootDir, additionalExclusions = [], includeGitignore = true) {
     const ig = (0, ignore_1.default)();
     // Add standard exclusions
     ig.add(STANDARD_EXCLUSIONS);
@@ -202,39 +350,142 @@ async function buildIgnoreFilter(rootDir, additionalExclusions = []) {
     if (additionalExclusions.length > 0) {
         ig.add(additionalExclusions);
     }
-    // Parse .gitignore in root
-    const gitignorePath = (0, path_1.join)(rootDir, '.gitignore');
+    // Exclude .gitignore files if requested
+    if (includeGitignore === false) {
+        ig.add(['.gitignore', '**/.gitignore']);
+        logger.debug('Excluding .gitignore files from archive');
+    }
+    // Recursively find and parse all .gitignore files
+    const gitignoreFiles = await findGitignoreFiles(rootDir);
+    for (const gitignorePath of gitignoreFiles) {
+        try {
+            const gitignoreContent = await fs_1.promises.readFile(gitignorePath, 'utf-8');
+            const patterns = gitignoreContent
+                .split('\n')
+                .map(line => line.trim())
+                .filter(line => line && !line.startsWith('#'));
+            if (patterns.length > 0) {
+                // Get the directory containing this .gitignore
+                const gitignoreDir = gitignorePath.substring(0, gitignorePath.length - '.gitignore'.length);
+                const relativeDir = (0, path_1.relative)(rootDir, gitignoreDir);
+                // Scope patterns to their directory
+                const scopedPatterns = patterns.map(pattern => {
+                    // If pattern starts with '/', it's relative to the .gitignore location
+                    if (pattern.startsWith('/')) {
+                        const patternWithoutSlash = pattern.substring(1);
+                        return relativeDir ? `${relativeDir}/${patternWithoutSlash}` : patternWithoutSlash;
+                    }
+                    // If pattern starts with '!', handle negation
+                    else if (pattern.startsWith('!')) {
+                        const negatedPattern = pattern.substring(1);
+                        if (negatedPattern.startsWith('/')) {
+                            const patternWithoutSlash = negatedPattern.substring(1);
+                            return relativeDir ? `!${relativeDir}/${patternWithoutSlash}` : `!${patternWithoutSlash}`;
+                        }
+                        // For non-rooted negation patterns, prefix with directory
+                        return relativeDir ? `!${relativeDir}/${negatedPattern}` : `!${negatedPattern}`;
+                    }
+                    // For non-rooted patterns, prefix with the directory path
+                    else {
+                        return relativeDir ? `${relativeDir}/${pattern}` : pattern;
+                    }
+                });
+                ig.add(scopedPatterns);
+                const location = relativeDir ? `in ${relativeDir}/` : 'in root';
+                logger.debug(`Loaded .gitignore ${location} with ${patterns.length} patterns`);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.warn('Failed to read .gitignore at', gitignorePath, ':', error.message);
+            }
+        }
+    }
+    // Parse .dockerignore in root
+    const dockerignorePath = (0, path_1.join)(rootDir, '.dockerignore');
     try {
-        const gitignoreContent = await fs_1.promises.readFile(gitignorePath, 'utf-8');
-        const patterns = gitignoreContent
+        const dockerignoreContent = await fs_1.promises.readFile(dockerignorePath, 'utf-8');
+        const patterns = dockerignoreContent
             .split('\n')
             .map(line => line.trim())
             .filter(line => line && !line.startsWith('#'));
         if (patterns.length > 0) {
             ig.add(patterns);
-            console.error('[DEBUG] Loaded .gitignore with', patterns.length, 'patterns');
+            console.error('[DEBUG] Loaded .dockerignore with', patterns.length, 'patterns');
         }
     }
     catch (error) {
         if (error.code !== 'ENOENT') {
-            console.error('[WARN] Failed to read .gitignore:', error.message);
+            console.error('[WARN] Failed to read .dockerignore:', error.message);
         }
     }
     return ig;
 }
+/**
+ * Recursively find all .gitignore files in a directory tree
+ */
+async function findGitignoreFiles(rootDir) {
+    const gitignoreFiles = [];
+    async function searchDirectory(dir) {
+        let entries;
+        try {
+            entries = await fs_1.promises.readdir(dir);
+        }
+        catch (error) {
+            if (error.code === 'EACCES') {
+                logger.warn('Permission denied:', dir);
+                return;
+            }
+            return;
+        }
+        for (const entry of entries) {
+            // Skip .git directory and other version control directories
+            if (entry === '.git' || entry === '.svn' || entry === '.hg') {
+                continue;
+            }
+            const fullPath = (0, path_1.join)(dir, entry);
+            // If this is a .gitignore file, add it to the list
+            if (entry === '.gitignore') {
+                gitignoreFiles.push(fullPath);
+                continue;
+            }
+            // If it's a directory, recurse into it
+            try {
+                const stats = await fs_1.promises.lstat(fullPath);
+                if (stats.isDirectory() && !stats.isSymbolicLink()) {
+                    await searchDirectory(fullPath);
+                }
+            }
+            catch (error) {
+                // Skip files we can't access
+                continue;
+            }
+        }
+    }
+    await searchDirectory(rootDir);
+    // Sort so root .gitignore is processed first
+    gitignoreFiles.sort((a, b) => {
+        const aDepth = a.split(path_1.sep).length;
+        const bDepth = b.split(path_1.sep).length;
+        return aDepth - bDepth;
+    });
+    return gitignoreFiles;
+}
 /**
  * Recursively add files to archive with filtering
  */
-async function addFilesRecursively(archive, rootDir, currentDir, ignoreFilter) {
+async function addFilesRecursively(archive, rootDir, currentDir, ignoreFilter, options, progressState) {
     let entries;
     try {
         entries = await fs_1.promises.readdir(currentDir);
     }
     catch (error) {
         if (error.code === 'EACCES') {
-            console.error('[WARN] Permission denied:', currentDir);
+            logger.warn('Permission denied:', currentDir);
             return;
         }
+        logger.error('Failed to read directory:', currentDir);
+        logger.error('Error:', error.message);
         throw error;
     }
     for (const entry of entries) {
@@ -248,16 +499,21 @@ async function addFilesRecursively(archive, rootDir, currentDir, ignoreFilter) {
         }
         let stats;
         try {
-            stats = await fs_1.promises.stat(fullPath);
+            stats = await fs_1.promises.lstat(fullPath);
         }
         catch (error) {
             if (error.code === 'ENOENT') {
-                // Symlink pointing to non-existent file, skip
+                // File disappeared, skip
                 continue;
             }
             console.error('[WARN] Failed to stat:', fullPath, error.message);
             continue;
         }
+        // Skip symlinks to prevent following links outside the repository
+        if (stats.isSymbolicLink()) {
+            logger.warn('Skipping symlink:', fullPath);
+            continue;
+        }
         if (stats.isDirectory()) {
             // Check if directory itself should be ignored
             const dirPath = normalizedRelativePath + '/';
@@ -265,18 +521,48 @@ async function addFilesRecursively(archive, rootDir, currentDir, ignoreFilter) {
                 continue;
             }
             // Recurse into directory
-            await addFilesRecursively(archive, rootDir, fullPath, ignoreFilter);
+            await addFilesRecursively(archive, rootDir, fullPath, ignoreFilter, options, progressState);
         }
         else if (stats.isFile()) {
             // Add file to archive
             try {
                 archive.file(fullPath, { name: normalizedRelativePath });
+                // Track progress if callback is provided
+                if (progressState && options?.onProgress) {
+                    progressState.filesProcessed++;
+                    progressState.bytesProcessed += stats.size;
+                    progressState.lastFile = normalizedRelativePath;
+                    const progressInterval = options.progressInterval || 100;
+                    // Report progress every N files
+                    if (progressState.filesProcessed - progressState.lastReportedCount >= progressInterval) {
+                        logger.debug(`Progress: ${progressState.filesProcessed} files, ${formatBytes(progressState.bytesProcessed)}`);
+                        options.onProgress({
+                            filesProcessed: progressState.filesProcessed,
+                            currentFile: normalizedRelativePath,
+                            bytesProcessed: progressState.bytesProcessed,
+                        });
+                        progressState.lastReportedCount = progressState.filesProcessed;
+                    }
+                }
             }
             catch (error) {
-                console.error('[WARN] Failed to add file:', fullPath, error.message);
+                logger.warn('Failed to add file:', fullPath, error.message);
             }
         }
-        // Skip symlinks, sockets, etc.
+        // Skip other special files (sockets, FIFOs, etc.)
+    }
+    // Report final progress if we have a callback and there are unreported files
+    // Only report at the root level (when currentDir === rootDir)
+    if (currentDir === rootDir &&
+        progressState &&
+        options?.onProgress &&
+        progressState.filesProcessed > progressState.lastReportedCount) {
+        logger.debug(`Final progress: ${progressState.filesProcessed} files, ${formatBytes(progressState.bytesProcessed)}`);
+        options.onProgress({
+            filesProcessed: progressState.filesProcessed,
+            currentFile: progressState.lastFile,
+            bytesProcessed: progressState.bytesProcessed,
+        });
     }
 }
 /**
@@ -295,7 +581,7 @@ function formatBytes(bytes) {
  * Clean up old ZIP files from temp directory
  * Removes ZIPs older than the specified age
  */
-async function cleanupOldZips(maxAgeMs = 24 * 60 * 60 * 1000) {
+async function cleanupOldZips(maxAgeMs = constants_1.ZIP_CLEANUP_AGE_MS) {
     const tempDir = (0, os_1.tmpdir)();
     const now = Date.now();
     try {
@@ -318,15 +604,15 @@ async function cleanupOldZips(maxAgeMs = 24 * 60 * 60 * 1000) {
             catch (error) {
                 // File might have been deleted already, ignore
                 if (error.code !== 'ENOENT') {
-                    console.error('[WARN] Failed to cleanup:', fullPath, error.message);
+                    logger.warn('Failed to cleanup:', fullPath, error.message);
                 }
             }
         }
         if (removedCount > 0) {
-            console.error('[DEBUG] Cleaned up', removedCount, 'old ZIP files');
+            logger.debug('Cleaned up', removedCount, 'old ZIP files');
         }
     }
     catch (error) {
-        console.error('[WARN] Failed to cleanup temp directory:', error.message);
+        logger.warn('Failed to cleanup temp directory:', error.message);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supermodeltools/mcp-server",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "MCP server for Supermodel API - code graph generation for AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,7 +13,10 @@
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "test:watch": "jest --watch"
   },
   "repository": {
     "type": "git",
@@ -39,11 +42,16 @@
     "archiver": "^7.0.1",
     "ignore": "^7.0.5",
     "jq-web": "^0.6.2",
+    "undici": "^7.18.2",
     "zod": "^3.22.4"
   },
   "devDependencies": {
+    "@jest/globals": "^30.2.0",
     "@types/archiver": "^7.0.0",
+    "@types/jest": "^30.0.0",
     "@types/node": "^20.11.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.3.3"
   }
 }