@supermodeltools/mcp-server 0.8.1 → 0.9.0

package/dist/cache/graph-cache.js

@@ -2,13 +2,59 @@
 /**
  * LRU Cache for indexed graphs
  * Stores raw API responses + derived indexes for fast query execution
+ * Supports disk persistence for pre-computed graphs
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.graphCache = exports.GraphCache = void 0;
 exports.buildIndexes = buildIndexes;
 exports.normalizePath = normalizePath;
-exports.toNodeDescriptor = toNodeDescriptor;
+exports.saveCacheToDisk = saveCacheToDisk;
+exports.loadCacheFromDisk = loadCacheFromDisk;
+exports.sanitizeFileName = sanitizeFileName;
+exports.setRepoMap = setRepoMap;
+exports.setNoApiFallback = setNoApiFallback;
+exports.resolveOrFetchGraph = resolveOrFetchGraph;
+exports.precacheForDirectory = precacheForDirectory;
 const constants_1 = require("../constants");
+const api_helpers_1 = require("../utils/api-helpers");
+const zip_repository_1 = require("../utils/zip-repository");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const buffer_1 = require("buffer");
+const logger = __importStar(require("../utils/logger"));
 /**
  * Build indexes from raw SupermodelIR response
  */
@@ -179,21 +225,6 @@ function buildIndexes(raw, cacheKey) {
 function normalizePath(path) {
     return path.replace(/\\/g, '/');
 }
-/**
- * Convert full node to lightweight descriptor
- */
-function toNodeDescriptor(node) {
-    const props = node.properties || {};
-    return {
-        id: node.id,
-        labels: node.labels || [],
-        name: props.name,
-        filePath: props.filePath,
-        startLine: props.startLine,
-        endLine: props.endLine,
-        kind: props.kind,
-    };
-}
 /**
  * LRU Cache for indexed graphs
  */
@@ -285,5 +316,286 @@ class GraphCache {
     }
 }
 exports.GraphCache = GraphCache;
+/**
+ * Save a SupermodelIR to disk for later use as a pre-computed cache.
+ * Stores as JSON with a metadata wrapper.
+ */
+async function saveCacheToDisk(cacheDir, repoName, raw, commitHash) {
+    await fs_1.promises.mkdir(cacheDir, { recursive: true });
+    const fileName = `${sanitizeFileName(repoName)}.json`;
+    const filePath = (0, path_1.join)(cacheDir, fileName);
+    const payload = {
+        version: 1,
+        repoName,
+        commitHash: commitHash || null,
+        savedAt: new Date().toISOString(),
+        raw,
+    };
+    await fs_1.promises.writeFile(filePath, JSON.stringify(payload));
+    return filePath;
+}
+/**
+ * Load all pre-computed graphs from a cache directory into the GraphCache.
+ * Returns a Map of repoName -> IndexedGraph for repo auto-detection.
+ */
+async function loadCacheFromDisk(cacheDir, cache) {
+    const repoMap = new Map();
+    let entries;
+    try {
+        entries = await fs_1.promises.readdir(cacheDir);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            logger.debug('Cache directory does not exist:', cacheDir);
+            return repoMap;
+        }
+        throw error;
+    }
+    const jsonFiles = entries.filter(e => e.endsWith('.json'));
+    logger.debug(`Found ${jsonFiles.length} cache files in ${cacheDir}`);
+    for (const file of jsonFiles) {
+        try {
+            const filePath = (0, path_1.join)(cacheDir, file);
+            const content = await fs_1.promises.readFile(filePath, 'utf-8');
+            const payload = JSON.parse(content);
+            if (!payload.raw || !payload.repoName) {
+                logger.warn(`Skipping invalid cache file: ${file}`);
+                continue;
+            }
+            const repoName = payload.repoName;
+            const cacheKey = `precache:${repoName}`;
+            const graph = buildIndexes(payload.raw, cacheKey);
+            cache.set(cacheKey, graph);
+            repoMap.set(repoName.toLowerCase(), graph);
+            // Index by commit hash for exact matching (e.g. "commit:abc1234")
+            const commitHash = payload.commitHash;
+            if (commitHash) {
+                repoMap.set(`commit:${commitHash}`, graph);
+            }
+            // Also store common variants of the repo name for matching
+            // e.g. "django" for "django__django", "astropy" for "astropy__astropy"
+            const parts = repoName.toLowerCase().split(/[_\-\/]/);
+            for (const part of parts) {
+                if (part && part.length > 2 && !repoMap.has(part)) {
+                    repoMap.set(part, graph);
+                }
+            }
+            logger.debug(`Loaded pre-computed graph for ${repoName} (commit: ${commitHash || 'unknown'}): ${graph.summary.nodeCount} nodes`);
+        }
+        catch (error) {
+            logger.warn(`Failed to load cache file ${file}: ${error.message}`);
+        }
+    }
+    return repoMap;
+}
+/**
+ * Detect which pre-computed graph matches a given directory.
+ * Tries: git remote name, directory basename, parent directory name.
+ */
+function detectRepo(directory, repoMap) {
+    if (repoMap.size === 0)
+        return null;
+    // Strategy 0 (highest priority): Match by exact commit hash
+    try {
+        const { execSync } = require('child_process');
+        const commitHash = execSync('git rev-parse --short HEAD', {
+            cwd: directory, encoding: 'utf-8', timeout: 2000,
+        }).trim();
+        if (commitHash && repoMap.has(`commit:${commitHash}`)) {
+            return repoMap.get(`commit:${commitHash}`);
+        }
+    }
+    catch {
+        // Not a git repo
+    }
+    // Strategy 1: Try directory basename
+    const dirName = (0, path_1.basename)(directory).toLowerCase();
+    if (repoMap.has(dirName)) {
+        return repoMap.get(dirName);
+    }
+    // Strategy 2: Try git remote (sync, best-effort)
+    try {
+        const { execSync } = require('child_process');
+        const remote = execSync('git remote get-url origin', {
+            cwd: directory,
+            encoding: 'utf-8',
+            timeout: 2000,
+        }).trim();
+        // Extract repo name from URL: "https://github.com/django/django.git" -> "django"
+        const match = remote.match(/\/([^\/]+?)(?:\.git)?$/);
+        if (match) {
+            const repoName = match[1].toLowerCase();
+            if (repoMap.has(repoName)) {
+                return repoMap.get(repoName);
+            }
+        }
+        // Try org/repo format: "django/django" -> try "django"
+        const orgMatch = remote.match(/\/([^\/]+)\/([^\/]+?)(?:\.git)?$/);
+        if (orgMatch) {
+            const orgName = orgMatch[1].toLowerCase();
+            const repoName = orgMatch[2].toLowerCase();
+            // Try "org__repo" format (swe-bench style)
+            const sweKey = `${orgName}__${repoName}`;
+            if (repoMap.has(sweKey)) {
+                return repoMap.get(sweKey);
+            }
+            if (repoMap.has(orgName)) {
+                return repoMap.get(orgName);
+            }
+            if (repoMap.has(repoName)) {
+                return repoMap.get(repoName);
+            }
+        }
+    }
+    catch {
+        // Not a git repo or git not available -- that's fine
+    }
+    // Strategy 3: If there's only one cached graph, use it (common in SWE-bench)
+    if (repoMap.size <= 3) {
+        // Small map likely has only one real repo with name variants
+        const uniqueGraphs = new Set([...repoMap.values()]);
+        if (uniqueGraphs.size === 1) {
+            return [...uniqueGraphs][0];
+        }
+    }
+    return null;
+}
+function sanitizeFileName(name) {
+    return name.replace(/[^a-zA-Z0-9_\-]/g, '_');
+}
+/**
+ * Detect the repo name from a directory (git remote or basename).
+ */
+function detectRepoName(directory) {
+    try {
+        const { execSync } = require('child_process');
+        const remote = execSync('git remote get-url origin', {
+            cwd: directory,
+            encoding: 'utf-8',
+            timeout: 2000,
+        }).trim();
+        const match = remote.match(/\/([^\/]+?)(?:\.git)?$/);
+        if (match)
+            return match[1];
+    }
+    catch {
+        // Not a git repo
+    }
+    return (0, path_1.basename)(directory);
+}
 // Global cache instance
 exports.graphCache = new GraphCache();
+// Repo map for pre-computed graphs (populated at startup)
+let _repoMap = new Map();
+let _noApiFallback = false;
+function setRepoMap(map) {
+    _repoMap = map;
+}
+function setNoApiFallback(enabled) {
+    _noApiFallback = enabled;
+}
+/**
+ * Resolve a graph for a directory: pre-computed cache → LRU cache → API fallback.
+ * When --no-api-fallback is set, throws instead of calling the API.
+ */
+async function resolveOrFetchGraph(client, directory) {
+    // 1. Pre-computed cache
+    const precomputed = detectRepo(directory, _repoMap);
+    if (precomputed)
+        return precomputed;
+    // 2. LRU cache
+    const idempotencyKey = (0, api_helpers_1.generateIdempotencyKey)(directory);
+    const cached = exports.graphCache.get(idempotencyKey);
+    if (cached)
+        return cached;
+    // 3. Fast-fail when API fallback is disabled (e.g. SWE-bench)
+    if (_noApiFallback) {
+        throw {
+            response: null,
+            request: null,
+            message: 'No pre-computed graph available for this repository. Use grep, find, and file reading to explore the codebase instead.',
+            code: 'NO_CACHE',
+        };
+    }
+    // 4. API fallback
+    console.error('[Supermodel] Generating codebase graph (this may take a few minutes)...');
+    const zipResult = await (0, zip_repository_1.zipRepository)(directory);
+    let progressInterval = null;
+    let elapsed = 0;
+    progressInterval = setInterval(() => {
+        elapsed += 15;
+        console.error(`[Supermodel] Analysis in progress... (${elapsed}s elapsed)`);
+    }, 15000);
+    try {
+        const fileBuffer = await fs_1.promises.readFile(zipResult.path);
+        const fileBlob = new buffer_1.Blob([fileBuffer], { type: 'application/zip' });
+        const response = await client.graphs.generateSupermodelGraph(fileBlob, { idempotencyKey });
+        const graph = buildIndexes(response, idempotencyKey);
+        exports.graphCache.set(idempotencyKey, graph);
+        console.error('[Supermodel] Analysis complete.');
+        return graph;
+    }
+    finally {
+        if (progressInterval)
+            clearInterval(progressInterval);
+        await zipResult.cleanup();
+    }
+}
+/**
+ * Pre-compute and cache a graph for a directory during server startup.
+ * If a cache already exists (in repoMap or on disk), this is a no-op.
+ * Otherwise calls the API, saves to cacheDir for cross-container persistence,
+ * and updates the in-memory repoMap.
+ *
+ * The Supermodel API has server-side idempotency caching, so repeated calls
+ * with the same idempotency key (same repo + commit) return instantly.
+ */
+async function precacheForDirectory(client, directory, cacheDir) {
+    // Already cached?
+    if (detectRepo(directory, _repoMap)) {
+        logger.debug('Graph already cached for', directory);
+        return;
+    }
+    logger.info('Pre-computing graph for', directory, '(first run for this repo; subsequent runs will be instant)...');
+    const idempotencyKey = (0, api_helpers_1.generateIdempotencyKey)(directory);
+    const repoName = detectRepoName(directory);
+    const zipResult = await (0, zip_repository_1.zipRepository)(directory);
+    let progressInterval = null;
+    let elapsed = 0;
+    progressInterval = setInterval(() => {
+        elapsed += 15;
+        logger.info(`Analysis in progress... (${elapsed}s elapsed)`);
+    }, 15000);
+    try {
+        const fileBuffer = await fs_1.promises.readFile(zipResult.path);
+        const fileBlob = new buffer_1.Blob([fileBuffer], { type: 'application/zip' });
+        const response = await client.graphs.generateSupermodelGraph(fileBlob, { idempotencyKey });
+        const graph = buildIndexes(response, `precache:${repoName}`);
+        // Update in-memory caches
+        exports.graphCache.set(idempotencyKey, graph);
+        _repoMap.set(repoName.toLowerCase(), graph);
+        const parts = repoName.toLowerCase().split(/[_\-\/]/);
+        for (const part of parts) {
+            if (part && part.length > 2 && !_repoMap.has(part)) {
+                _repoMap.set(part, graph);
+            }
+        }
+        // Persist to disk for cross-container reuse
+        if (cacheDir) {
+            try {
+                const savedPath = await saveCacheToDisk(cacheDir, repoName, response);
+                logger.info('Saved graph to:', savedPath);
+            }
+            catch (err) {
+                // Non-fatal: cache dir might be read-only or full
+                logger.warn('Failed to persist graph to disk:', err.message);
+            }
+        }
+        logger.info(`Pre-compute complete: ${graph.summary.nodeCount} nodes, ${graph.summary.relationshipCount} relationships`);
+    }
+    finally {
+        if (progressInterval)
+            clearInterval(progressInterval);
+        await zipResult.cleanup();
+    }
+}

package/dist/cache/graph-types.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Type definitions for Supermodel IR graph data
- * Mirrors the API response schema
+ * Re-export graph types from the SDK.
+ * No local copies -- single source of truth.
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/constants.js

@@ -4,7 +4,7 @@
  * Single source of truth for configuration values
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_NEIGHBORHOOD_DEPTH = exports.DEFAULT_QUERY_LIMIT = exports.DEFAULT_CACHE_TTL_MS = exports.DEFAULT_MAX_NODES = exports.DEFAULT_MAX_GRAPHS = exports.MAX_ZIP_SIZE_BYTES = exports.ZIP_CLEANUP_AGE_MS = exports.CONNECTION_TIMEOUT_MS = exports.DEFAULT_API_TIMEOUT_MS = void 0;
+exports.MAX_SYMBOL_RELATED = exports.MAX_SYMBOL_CALLEES = exports.MAX_SYMBOL_CALLERS = exports.MAX_OVERVIEW_HUB_FUNCTIONS = exports.MAX_OVERVIEW_DOMAINS = exports.DEFAULT_CACHE_TTL_MS = exports.DEFAULT_MAX_NODES = exports.DEFAULT_MAX_GRAPHS = exports.MAX_ZIP_SIZE_BYTES = exports.ZIP_CLEANUP_AGE_MS = exports.CONNECTION_TIMEOUT_MS = exports.DEFAULT_API_TIMEOUT_MS = void 0;
 // HTTP timeout configuration
 exports.DEFAULT_API_TIMEOUT_MS = 900_000; // 15 minutes (complex repos can take 10+ min)
 exports.CONNECTION_TIMEOUT_MS = 30_000; // 30 seconds to establish connection
@@ -15,6 +15,10 @@ exports.MAX_ZIP_SIZE_BYTES = 500 * 1024 * 1024; // 500MB default
 exports.DEFAULT_MAX_GRAPHS = 20; // Maximum number of graphs to cache
 exports.DEFAULT_MAX_NODES = 1_000_000; // Maximum total nodes across all cached graphs
 exports.DEFAULT_CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour - time-to-live for cached graphs
-// Query defaults
-exports.DEFAULT_QUERY_LIMIT = 200; // Default result limit for queries
-exports.MAX_NEIGHBORHOOD_DEPTH = 3; // Maximum traversal depth for neighborhood queries
+// Overview tool output limits
+exports.MAX_OVERVIEW_DOMAINS = 10; // Top N domains to show in overview
+exports.MAX_OVERVIEW_HUB_FUNCTIONS = 10; // Top N hub functions to show
+// Symbol context tool output limits
+exports.MAX_SYMBOL_CALLERS = 10; // Top N callers to show
+exports.MAX_SYMBOL_CALLEES = 10; // Top N callees to show
+exports.MAX_SYMBOL_RELATED = 8; // Related symbols in same file

package/dist/index.js

@@ -36,26 +36,184 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Entry point for the Supermodel MCP Server.
- * Starts the MCP server with optional default working directory.
+ *
+ * Usage:
+ *   node dist/index.js [workdir] [--no-api-fallback]  -- Start MCP server
+ *   node dist/index.js precache <dir> [--output-dir <dir>]  -- Pre-compute graph for a repo
+ *
  * @module index
  */
 const server_1 = require("./server");
 const logger = __importStar(require("./utils/logger"));
-/**
- * Main entry point that initializes and starts the MCP server.
- * Accepts an optional workdir argument from the command line.
- */
 async function main() {
-    // Parse command-line arguments to get optional default workdir
-    // Usage: node dist/index.js [workdir]
     const args = process.argv.slice(2);
-    const defaultWorkdir = args.length > 0 ? args[0] : undefined;
+    // Handle precache subcommand
+    if (args[0] === 'precache') {
+        await handlePrecache(args.slice(1));
+        return;
+    }
+    // Normal MCP server mode — parse flags
+    let defaultWorkdir;
+    let noApiFallback = !!process.env.SUPERMODEL_NO_API_FALLBACK;
+    let precache = false;
+    for (const arg of args) {
+        if (arg === '--no-api-fallback') {
+            noApiFallback = true;
+        }
+        else if (arg === '--precache') {
+            precache = true;
+        }
+        else if (!arg.startsWith('--')) {
+            defaultWorkdir = arg;
+        }
+    }
     if (defaultWorkdir) {
         logger.debug('Default workdir:', defaultWorkdir);
     }
-    const server = new server_1.Server(defaultWorkdir);
+    if (noApiFallback) {
+        logger.debug('API fallback disabled (cache-only mode)');
+    }
+    if (precache) {
+        logger.debug('Startup precaching enabled');
+    }
+    const server = new server_1.Server(defaultWorkdir, { noApiFallback, precache });
     await server.start();
 }
+async function handlePrecache(args) {
+    if (args.length === 0) {
+        console.error('Usage: supermodel-mcp precache <directory> [--output-dir <dir>] [--name <repo-name>]');
+        console.error('');
+        console.error('Pre-compute a code graph for a repository and save it to disk.');
+        console.error('');
+        console.error('Options:');
+        console.error('  --output-dir <dir>   Directory to save the cache file (default: ./supermodel-cache)');
+        console.error('  --name <name>        Repository name for the cache key (default: directory basename)');
+        console.error('');
+        console.error('Environment:');
+        console.error('  SUPERMODEL_API_KEY   Required. API key for the Supermodel service.');
+        console.error('  SUPERMODEL_CACHE_DIR Alternative to --output-dir.');
+        process.exit(1);
+    }
+    // Parse args
+    let directory = '';
+    let outputDir = process.env.SUPERMODEL_CACHE_DIR || './supermodel-cache';
+    let repoName = '';
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--output-dir' && i + 1 < args.length) {
+            outputDir = args[++i];
+        }
+        else if (args[i] === '--name' && i + 1 < args.length) {
+            repoName = args[++i];
+        }
+        else if (!args[i].startsWith('--')) {
+            directory = args[i];
+        }
+    }
+    if (!directory) {
+        console.error('Error: directory argument is required');
+        process.exit(1);
+    }
+    if (!process.env.SUPERMODEL_API_KEY) {
+        console.error('Error: SUPERMODEL_API_KEY environment variable is required');
+        process.exit(1);
+    }
+    const { resolve, basename, join } = require('path');
+    const { execSync } = require('child_process');
+    const { existsSync } = require('fs');
+    const resolvedDir = resolve(directory);
+    // Detect repo name from git remote, falling back to directory basename
+    let detectedName = basename(resolvedDir);
+    try {
+        const remote = execSync('git remote get-url origin', {
+            cwd: resolvedDir, encoding: 'utf-8', timeout: 2000,
+        }).trim();
+        const match = remote.match(/\/([^\/]+?)(?:\.git)?$/);
+        if (match)
+            detectedName = match[1];
+    }
+    catch { }
+    // Get commit hash for commit-specific caching
+    let commitHash = '';
+    try {
+        commitHash = execSync('git rev-parse --short HEAD', {
+            cwd: resolvedDir, encoding: 'utf-8', timeout: 2000,
+        }).trim();
+    }
+    catch { }
+    const name = repoName || (commitHash ? `${detectedName}_${commitHash}` : detectedName);
+    // Check if cache file already exists (skip redundant API calls)
+    const { saveCacheToDisk, buildIndexes, sanitizeFileName } = require('./cache/graph-cache');
+    const expectedPath = join(outputDir, `${sanitizeFileName(name)}.json`);
+    if (existsSync(expectedPath)) {
+        console.error(`Cache already exists: ${expectedPath}`);
+        console.error('Skipping precache (graph already generated for this commit).');
+        return;
+    }
+    console.error(`Pre-computing graph for: ${resolvedDir}`);
+    console.error(`Repository name: ${detectedName}, commit: ${commitHash || 'unknown'}`);
+    console.error(`Cache file: ${expectedPath}`);
+    console.error('');
+    // Import what we need
+    const { Configuration, DefaultApi, SupermodelClient } = require('@supermodeltools/sdk');
+    const { zipRepository } = require('./utils/zip-repository');
+    const { readFile } = require('fs/promises');
+    const { Blob } = require('buffer');
+    const { generateIdempotencyKey } = require('./utils/api-helpers');
+    const { Agent } = require('undici');
+    const { DEFAULT_API_TIMEOUT_MS, CONNECTION_TIMEOUT_MS } = require('./constants');
+    const parsedTimeout = parseInt(process.env.SUPERMODEL_TIMEOUT_MS || '', 10);
+    const timeoutMs = Number.isFinite(parsedTimeout) && parsedTimeout > 0
+        ? parsedTimeout
+        : DEFAULT_API_TIMEOUT_MS;
+    const httpAgent = new Agent({
+        headersTimeout: timeoutMs,
+        bodyTimeout: timeoutMs,
+        connectTimeout: CONNECTION_TIMEOUT_MS,
+    });
+    const fetchWithTimeout = (url, init) => {
+        return fetch(url, { ...init, dispatcher: httpAgent });
+    };
+    const config = new Configuration({
+        basePath: process.env.SUPERMODEL_BASE_URL || 'https://api.supermodeltools.com',
+        apiKey: process.env.SUPERMODEL_API_KEY,
+        fetchApi: fetchWithTimeout,
+    });
+    const api = new DefaultApi(config);
+    const client = new SupermodelClient(api);
+    // Step 1: Zip
+    console.error('Step 1/3: Creating ZIP archive...');
+    const zipResult = await zipRepository(resolvedDir);
+    console.error(`  ZIP created: ${zipResult.fileCount} files, ${(zipResult.sizeBytes / 1024 / 1024).toFixed(1)} MB`);
+    // Step 2: API call
+    console.error('Step 2/3: Analyzing codebase (this may take several minutes)...');
+    const idempotencyKey = generateIdempotencyKey(resolvedDir);
+    let progressInterval = null;
+    let elapsed = 0;
+    progressInterval = setInterval(() => {
+        elapsed += 15;
+        console.error(`  Analysis in progress... (${elapsed}s elapsed)`);
+    }, 15000);
+    let response;
+    try {
+        const fileBuffer = await readFile(zipResult.path);
+        const fileBlob = new Blob([fileBuffer], { type: 'application/zip' });
+        response = await client.generateSupermodelGraph(fileBlob, { idempotencyKey });
+    }
+    finally {
+        if (progressInterval)
+            clearInterval(progressInterval);
+        await zipResult.cleanup();
+    }
+    const graph = buildIndexes(response, `precache:${name}`);
+    console.error(`  Analysis complete: ${graph.summary.nodeCount} nodes, ${graph.summary.relationshipCount} relationships`);
+    console.error(`  Files: ${graph.summary.filesProcessed}, Functions: ${graph.summary.functions}, Classes: ${graph.summary.classes}`);
+    // Step 3: Save to disk
+    console.error('Step 3/3: Saving to disk...');
+    const savedPath = await saveCacheToDisk(outputDir, name, response, commitHash || undefined);
+    console.error(`  Saved to: ${savedPath}`);
+    console.error('');
+    console.error('Done! To use this cache, set SUPERMODEL_CACHE_DIR=' + outputDir);
+}
 main().catch((error) => {
     logger.error('Fatal error:', error);
     process.exit(1);