@lzehrung/codegraph 2.1.0

package/dist/session.js

@@ -0,0 +1,858 @@
+/**
+ * Session management for conversation-aware caching
+ * Maintains warm caches across multiple queries for better agent UX
+ */
+import fs from "node:fs";
+import path from "node:path";
+import {} from "./indexer/types.js";
+import { buildProjectIndex, buildProjectIndexIncremental } from "./indexer/build-index.js";
+import { normalizeLanguageExtensions } from "./indexer/build-cache.js";
+import { findReferences, goToDefinition } from "./indexer/navigation.js";
+import { analyzeImpactFromDiff, } from "./impact/index.js";
+import { analyzeImpactStreaming } from "./impact/streaming.js";
+import { getSessionPreset, mergePreset } from "./presets.js";
+import { hasDiscoveryOptions, loadCodegraphConfig, mergeDiscoveryOptions, mergeGraphOptions } from "./config.js";
+import { normalizePath, resolveFilePathWithinRoot } from "./util/paths.js";
+import { listProjectFiles } from "./util/projectFiles.js";
+function normalizeStringArray(values) {
+    if (!values?.length)
+        return undefined;
+    return [...values].sort();
+}
+function normalizeBuildOptions(options) {
+    if (!options)
+        return undefined;
+    return {
+        cache: options.cache,
+        cacheDir: options.cacheDir ? path.resolve(options.cacheDir) : undefined,
+        cacheStrict: options.cacheStrict,
+        useBloomFilters: options.useBloomFilters,
+        graph: options.graph
+            ? {
+                fast: options.graph.fast,
+                resolveNodeModules: options.graph.resolveNodeModules,
+                dynamicImportHeuristics: options.graph.dynamicImportHeuristics,
+                native: options.graph.native,
+                logLevel: options.graph.logLevel,
+                resolutionHints: normalizeStringArray(options.graph.resolutionHints),
+                fastRegexDisabledLanguages: normalizeStringArray(options.graph.fastRegexDisabledLanguages),
+            }
+            : undefined,
+        native: options.native,
+        cacheVerify: options.cacheVerify,
+        incrementalStrict: options.incrementalStrict,
+        parsedCacheMaxEntries: options.parsedCacheMaxEntries,
+        logLevel: options.logLevel,
+        keepParsed: options.keepParsed,
+        useNativeWorkers: options.useNativeWorkers,
+        nativeThreads: options.nativeThreads,
+        threads: options.threads,
+        discovery: options.discovery
+            ? {
+                includeGlobs: normalizeStringArray(options.discovery.includeGlobs),
+                ignoreGlobs: normalizeStringArray(options.discovery.ignoreGlobs),
+                useGitignore: options.discovery.useGitignore,
+                gitignoreRoot: options.discovery.gitignoreRoot ? path.resolve(options.discovery.gitignoreRoot) : undefined,
+            }
+            : undefined,
+        languageExtensions: normalizeLanguageExtensions(options.languageExtensions),
+    };
+}
+function resolveSessionIdentity(options) {
+    if (options.preset) {
+        const presetOpts = getSessionPreset(options.preset, options.root);
+        const buildOptions = options.buildOptions
+            ? mergePreset(presetOpts.buildOptions ?? {}, options.buildOptions)
+            : presetOpts.buildOptions;
+        const normalizedBuildOptions = normalizeBuildOptions(buildOptions);
+        return {
+            root: path.resolve(options.root),
+            timeout: options.timeout ?? presetOpts.timeout ?? 30 * 60 * 1000,
+            incremental: options.incremental ?? presetOpts.incremental ?? true,
+            ...(normalizedBuildOptions ? { buildOptions: normalizedBuildOptions } : {}),
+        };
+    }
+    const normalizedBuildOptions = normalizeBuildOptions(options.buildOptions);
+    return {
+        root: path.resolve(options.root),
+        timeout: options.timeout ?? 30 * 60 * 1000,
+        incremental: options.incremental ?? true,
+        ...(normalizedBuildOptions ? { buildOptions: normalizedBuildOptions } : {}),
+    };
+}
+function sessionIdentityFingerprint(identity) {
+    return JSON.stringify(identity);
+}
+function resolveSessionFileInput(root, file, label) {
+    return resolveFilePathWithinRoot(root, file, label);
+}
+function requireSessionImpactProvider(options) {
+    if (!options.provider) {
+        throw new Error("Impact provider is required. Set provider to 'git', 'github', or 'raw'.");
+    }
+}
+/**
+ * A code review session that maintains warm caches
+ * Use this to avoid rebuilding the index for multiple queries
+ */
+export class CodeReviewSession {
+    static STALE_CHECK_INTERVAL_MS = 5_000;
+    index = null;
+    buildReport;
+    status = "initializing";
+    lastActivity = Date.now();
+    timeout;
+    root;
+    buildOptions;
+    incremental;
+    initPromise = null;
+    refreshPromise = null;
+    identityFingerprint;
+    lifecycleVersion = 0;
+    trackedFileSignatures = new Map();
+    configSignature;
+    trackedDirectorySignatures = new Map();
+    staleReason;
+    forceFullRefreshOnNextStaleCheck = false;
+    lastStaleCheckAt = 0;
+    lastTrackedFileScanAt = 0;
+    lastImpactProjectDriftCheckAt = 0;
+    lastPassiveStaleCheckAt = 0;
+    lastRefreshAt;
+    lastRefreshReason;
+    constructor(options) {
+        const identity = resolveSessionIdentity(options);
+        this.root = identity.root;
+        if (options.preset) {
+            const presetBuildOptions = getSessionPreset(options.preset, options.root).buildOptions;
+            this.buildOptions = options.buildOptions
+                ? mergePreset(presetBuildOptions ?? {}, options.buildOptions)
+                : presetBuildOptions;
+        }
+        else {
+            this.buildOptions = options.buildOptions;
+        }
+        this.timeout = identity.timeout;
+        this.incremental = identity.incremental;
+        this.identityFingerprint = sessionIdentityFingerprint(identity);
+    }
+    matchesOptions(options) {
+        return this.identityFingerprint === sessionIdentityFingerprint(resolveSessionIdentity(options));
+    }
+    getRoot() {
+        return this.root;
+    }
+    async currentBuildOptions() {
+        const config = await loadCodegraphConfig(this.root);
+        const discovery = mergeDiscoveryOptions(config.discovery, this.buildOptions?.discovery);
+        const graph = mergeGraphOptions(config.graph, this.buildOptions?.graph);
+        const languageExtensions = normalizeLanguageExtensions(this.buildOptions?.languageExtensions) ?? config.languages?.extensions;
+        if (!hasDiscoveryOptions(discovery) && !config.graph && !this.buildOptions?.graph && !languageExtensions) {
+            return this.buildOptions;
+        }
+        return {
+            ...this.buildOptions,
+            ...(hasDiscoveryOptions(discovery) ? { discovery } : {}),
+            ...(config.graph || this.buildOptions?.graph ? { graph } : {}),
+            ...(languageExtensions ? { languageExtensions } : {}),
+        };
+    }
+    async buildIndex(options = {}) {
+        const currentBuildOptions = await this.currentBuildOptions();
+        if (options.forceFull && this.incremental) {
+            const projectFiles = await this.currentProjectFiles(currentBuildOptions);
+            const report = { timings: {} };
+            const buildOptions = { ...currentBuildOptions, files: projectFiles, report };
+            const index = await buildProjectIndexIncremental(this.root, buildOptions);
+            return { index, report: index.buildReport ?? report, projectFiles };
+        }
+        if (options.forceFull) {
+            const report = { timings: {} };
+            const buildOptions = { ...currentBuildOptions, report };
+            const index = await buildProjectIndex(this.root, buildOptions);
+            const projectFiles = this.indexedProjectFiles(index);
+            return { index, report: index.buildReport ?? report, projectFiles };
+        }
+        const report = { timings: {} };
+        const buildOptions = { ...currentBuildOptions, report };
+        const index = this.incremental
+            ? await buildProjectIndexIncremental(this.root, buildOptions)
+            : await buildProjectIndex(this.root, buildOptions);
+        const projectFiles = this.indexedProjectFiles(index);
+        const buildReport = index.buildReport ?? report;
+        return { index, report: buildReport, projectFiles };
+    }
+    createDisposedDuringOperationError(operation) {
+        return new Error(`Session was disposed during ${operation}.`);
+    }
+    assertLifecycleVersion(expectedLifecycleVersion, operation) {
+        if (this.lifecycleVersion !== expectedLifecycleVersion) {
+            throw this.createDisposedDuringOperationError(operation);
+        }
+    }
+    trackedSignatureFromManifest(sig) {
+        const parts = sig.split(":");
+        if (parts.length >= 2) {
+            return `${parts[0]}:${parts[1]}`;
+        }
+        return sig;
+    }
+    statSignature(file) {
+        try {
+            const stat = fs.statSync(file);
+            return `${stat.mtimeMs}:${stat.size}`;
+        }
+        catch {
+            return "0:0";
+        }
+    }
+    directorySignature(directory) {
+        return this.statSignature(directory);
+    }
+    configFilePath() {
+        return path.join(this.root, "codegraph.config.json");
+    }
+    async currentProjectFiles(buildOptions) {
+        const discoveryOptions = {
+            ...buildOptions?.discovery,
+            ...(buildOptions?.logLevel ? { logLevel: buildOptions.logLevel } : {}),
+        };
+        return await listProjectFiles(this.root, undefined, discoveryOptions);
+    }
+    indexedProjectFiles(index) {
+        const files = index.manifestEntries
+            ? [...index.manifestEntries.keys()]
+            : Array.from(index.byFile.values(), (module) => module.file);
+        return files.map((file) => {
+            if (path.isAbsolute(file)) {
+                return file;
+            }
+            return path.resolve(this.root, file);
+        });
+    }
+    isPathInsideRoot(candidate) {
+        const relative = path.relative(this.root, candidate);
+        return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative));
+    }
+    directoriesForProjectFiles(files) {
+        const directories = new Set([this.root]);
+        for (const file of files) {
+            let directory = path.dirname(path.resolve(file));
+            while (this.isPathInsideRoot(directory)) {
+                directories.add(directory);
+                if (directory === this.root)
+                    break;
+                const parent = path.dirname(directory);
+                if (parent === directory)
+                    break;
+                directory = parent;
+            }
+        }
+        return directories;
+    }
+    directorySignatures(files) {
+        const signatures = new Map();
+        for (const directory of this.directoriesForProjectFiles(files)) {
+            signatures.set(directory, this.directorySignature(directory));
+        }
+        return signatures;
+    }
+    projectDirectoriesChanged() {
+        if (!this.trackedDirectorySignatures.size) {
+            return true;
+        }
+        for (const [directory, signature] of this.trackedDirectorySignatures) {
+            if (this.directorySignature(directory) !== signature) {
+                return true;
+            }
+        }
+        return false;
+    }
+    captureFreshnessBaseline(index, reason, projectFiles) {
+        const trackedEntries = index.manifestEntries?.size
+            ? [...index.manifestEntries].map(([file, entry]) => [file, this.trackedSignatureFromManifest(entry.sig)])
+            : [...index.byFile.values()].map((module) => [module.file, this.statSignature(module.file)]);
+        this.trackedFileSignatures = new Map(trackedEntries);
+        this.trackedDirectorySignatures = this.directorySignatures(projectFiles);
+        this.configSignature = this.statSignature(this.configFilePath());
+        this.staleReason = undefined;
+        this.lastStaleCheckAt = Date.now();
+        this.lastPassiveStaleCheckAt = 0;
+        this.lastTrackedFileScanAt = 0;
+        this.lastImpactProjectDriftCheckAt = 0;
+        this.lastRefreshAt = this.lastStaleCheckAt;
+        this.lastRefreshReason = reason;
+    }
+    refreshNeededFromTrackedFiles() {
+        if (!this.trackedFileSignatures.size) {
+            const configSignature = this.statSignature(this.configFilePath());
+            if (configSignature !== this.configSignature) {
+                return "config_changed";
+            }
+            return undefined;
+        }
+        for (const [file, signature] of this.trackedFileSignatures) {
+            if (this.statSignature(file) !== signature) {
+                return "tracked_files_changed";
+            }
+        }
+        const configSignature = this.statSignature(this.configFilePath());
+        if (configSignature !== this.configSignature) {
+            return "config_changed";
+        }
+        return undefined;
+    }
+    refreshNeededFromTrackedFile(file) {
+        const resolved = normalizePath(path.resolve(file));
+        const signature = this.trackedFileSignatures.get(resolved) ?? this.trackedFileSignatures.get(file);
+        if (!signature) {
+            return undefined;
+        }
+        return this.statSignature(resolved) !== signature ? "tracked_files_changed" : undefined;
+    }
+    checkForStaleness(options = {}) {
+        if (this.status !== "ready" || !this.index)
+            return;
+        const now = Date.now();
+        if (!options.force && now - this.lastPassiveStaleCheckAt < CodeReviewSession.STALE_CHECK_INTERVAL_MS)
+            return;
+        this.lastPassiveStaleCheckAt = now;
+        const configSignature = this.statSignature(this.configFilePath());
+        if (configSignature !== this.configSignature) {
+            this.staleReason = "config_changed";
+            this.forceFullRefreshOnNextStaleCheck = false;
+            return;
+        }
+        const projectFilesChanged = this.projectDirectoriesChanged();
+        this.staleReason = projectFilesChanged ? "tracked_files_changed" : undefined;
+        this.forceFullRefreshOnNextStaleCheck = projectFilesChanged;
+    }
+    checkForStalenessNow(options = {}) {
+        if (this.status !== "ready" || !this.index)
+            return;
+        const now = Date.now();
+        const targetReason = options.file ? this.refreshNeededFromTrackedFile(options.file) : undefined;
+        if (targetReason) {
+            this.lastStaleCheckAt = now;
+            this.staleReason = targetReason;
+            this.forceFullRefreshOnNextStaleCheck = false;
+            return;
+        }
+        const trackedScanDue = options.force ||
+            (options.scanTrackedFiles && now - this.lastTrackedFileScanAt >= CodeReviewSession.STALE_CHECK_INTERVAL_MS);
+        const navigationProjectDriftDue = options.force ||
+            (!options.scanTrackedFiles && now - this.lastStaleCheckAt >= CodeReviewSession.STALE_CHECK_INTERVAL_MS);
+        const impactProjectDriftDue = options.force ||
+            (options.scanTrackedFiles &&
+                now - this.lastImpactProjectDriftCheckAt >= CodeReviewSession.STALE_CHECK_INTERVAL_MS);
+        if (!trackedScanDue && !navigationProjectDriftDue && !impactProjectDriftDue)
+            return;
+        if (trackedScanDue) {
+            this.lastTrackedFileScanAt = now;
+            const trackedReason = this.refreshNeededFromTrackedFiles();
+            if (trackedReason) {
+                this.staleReason = trackedReason;
+                this.forceFullRefreshOnNextStaleCheck = false;
+                return;
+            }
+        }
+        if (!navigationProjectDriftDue && !impactProjectDriftDue)
+            return;
+        if (navigationProjectDriftDue) {
+            this.lastStaleCheckAt = now;
+        }
+        if (impactProjectDriftDue) {
+            this.lastImpactProjectDriftCheckAt = now;
+        }
+        const configSignature = this.statSignature(this.configFilePath());
+        if (configSignature !== this.configSignature) {
+            this.staleReason = "config_changed";
+            this.forceFullRefreshOnNextStaleCheck = false;
+            return;
+        }
+        const projectFilesChanged = this.projectDirectoriesChanged();
+        this.staleReason = projectFilesChanged ? "tracked_files_changed" : undefined;
+        this.forceFullRefreshOnNextStaleCheck = projectFilesChanged;
+    }
+    commitReadyIndex(index, reason, report, projectFiles) {
+        this.index = index;
+        this.buildReport = report;
+        this.status = "ready";
+        this.captureFreshnessBaseline(index, reason, projectFiles);
+        this.forceFullRefreshOnNextStaleCheck = false;
+        this.touch();
+    }
+    /**
+     * Initialize the session (builds the index)
+     */
+    async init() {
+        if (this.status === "ready" && this.index) {
+            return;
+        }
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        const lifecycleVersion = this.lifecycleVersion;
+        const initState = { promise: null };
+        const initPromise = (async () => {
+            const previousStatus = this.status;
+            try {
+                this.status = "initializing";
+                const nextBuild = await this.buildIndex();
+                this.assertLifecycleVersion(lifecycleVersion, "initialization");
+                this.commitReadyIndex(nextBuild.index, "initialization", nextBuild.report, nextBuild.projectFiles);
+            }
+            catch (error) {
+                if (this.lifecycleVersion === lifecycleVersion) {
+                    this.status = previousStatus === "expired" ? "expired" : "error";
+                }
+                throw error;
+            }
+            finally {
+                if (this.initPromise === initState.promise) {
+                    this.initPromise = null;
+                }
+            }
+        })();
+        initState.promise = initPromise;
+        this.initPromise = initPromise;
+        return this.initPromise;
+    }
+    /**
+     * Check if session is ready
+     */
+    isReady() {
+        this.checkExpiration();
+        this.checkForStaleness();
+        return this.status === "ready";
+    }
+    /**
+     * Get the current status
+     */
+    getStatus() {
+        this.checkExpiration();
+        this.checkForStaleness();
+        return this.status;
+    }
+    /**
+     * Update last activity timestamp
+     */
+    touch() {
+        this.lastActivity = Date.now();
+    }
+    /**
+     * Check if session has expired
+     */
+    checkExpiration() {
+        if (this.status === "ready" && Date.now() - this.lastActivity > this.timeout) {
+            this.status = "expired";
+            this.index = null;
+        }
+    }
+    /**
+     * Get the project index (throws if not ready)
+     */
+    getIndex() {
+        this.checkExpiration();
+        if (this.status !== "ready" || !this.index) {
+            throw new Error(`Session not ready (status: ${this.status})`);
+        }
+        this.touch();
+        return this.index;
+    }
+    async ensureFreshIndex(options = {}) {
+        this.checkExpiration();
+        if (this.refreshPromise) {
+            await this.refreshPromise;
+            return this.getIndex();
+        }
+        this.checkForStalenessNow(options);
+        const index = this.getIndex();
+        if (!this.staleReason) {
+            return index;
+        }
+        await this.refreshInternal("stale_check");
+        return this.getIndex();
+    }
+    async refreshForExistingUnindexedFile(file) {
+        if (!fs.existsSync(file)) {
+            return undefined;
+        }
+        this.staleReason = "tracked_files_changed";
+        this.forceFullRefreshOnNextStaleCheck = true;
+        await this.refreshInternal("stale_check");
+        return this.getIndex();
+    }
+    /**
+     * Analyze impact from a diff
+     * Results are cached in the warm index
+     */
+    async analyzeImpact(options) {
+        const index = await this.ensureFreshIndex({ scanTrackedFiles: true });
+        requireSessionImpactProvider(options);
+        return await analyzeImpactFromDiff(this.root, index, options, { buildReport: this.buildReport });
+    }
+    /**
+     * Stream impact analysis results
+     * Better for agents as they can start processing immediately
+     */
+    async *analyzeImpactStream(options) {
+        const index = await this.ensureFreshIndex({ scanTrackedFiles: true });
+        requireSessionImpactProvider(options);
+        yield* analyzeImpactStreaming(this.root, index, options, { buildReport: this.buildReport });
+    }
+    /**
+     * Find references to a symbol
+     */
+    async findReferences(params) {
+        const resolved = resolveSessionFileInput(this.root, params.file, "Session file");
+        if (resolved.status === "error") {
+            return resolved;
+        }
+        const index = await this.ensureFreshIndex({ file: resolved.file });
+        const result = await findReferences(index, {
+            ...params,
+            file: resolved.file,
+        });
+        if (result.status === "not_found" && result.reason === "File not indexed") {
+            const refreshedIndex = await this.refreshForExistingUnindexedFile(resolved.file);
+            if (refreshedIndex) {
+                return await findReferences(refreshedIndex, {
+                    ...params,
+                    file: resolved.file,
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * Go to definition of a symbol
+     */
+    async goToDefinition(params) {
+        const resolved = resolveSessionFileInput(this.root, params.file, "Session file");
+        if (resolved.status === "error") {
+            return resolved;
+        }
+        const index = await this.ensureFreshIndex({ file: resolved.file });
+        const result = await goToDefinition(index, {
+            ...params,
+            file: resolved.file,
+        });
+        if (result.status === "not_found" && result.reason === "File not indexed") {
+            const refreshedIndex = await this.refreshForExistingUnindexedFile(resolved.file);
+            if (refreshedIndex) {
+                return await goToDefinition(refreshedIndex, {
+                    ...params,
+                    file: resolved.file,
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * Refresh the index (manual full rebuild; stale checks full rebuild only after file-set drift)
+     */
+    async refreshInternal(refreshReason) {
+        if (this.refreshPromise) {
+            await this.refreshPromise;
+            return;
+        }
+        const refreshPromise = this.performRefresh(refreshReason);
+        this.refreshPromise = refreshPromise;
+        try {
+            await refreshPromise;
+        }
+        finally {
+            if (this.refreshPromise === refreshPromise) {
+                this.refreshPromise = null;
+            }
+        }
+    }
+    async performRefresh(refreshReason) {
+        const previousIndex = this.index;
+        const previousStatus = this.status;
+        const lifecycleVersion = this.lifecycleVersion;
+        this.status = "initializing";
+        try {
+            const forceFull = refreshReason === "manual" || (refreshReason === "stale_check" && this.forceFullRefreshOnNextStaleCheck);
+            const nextBuild = await this.buildIndex({ forceFull });
+            this.assertLifecycleVersion(lifecycleVersion, "refresh");
+            this.commitReadyIndex(nextBuild.index, refreshReason, nextBuild.report, nextBuild.projectFiles);
+        }
+        catch (error) {
+            if (this.lifecycleVersion !== lifecycleVersion) {
+                throw error;
+            }
+            if (previousIndex && previousStatus === "ready") {
+                this.index = previousIndex;
+                this.status = "ready";
+            }
+            else {
+                this.status = "error";
+            }
+            throw error;
+        }
+    }
+    async refresh() {
+        await this.refreshInternal("manual");
+    }
+    /**
+     * Dispose of the session and free resources
+     */
+    dispose() {
+        this.lifecycleVersion += 1;
+        this.status = "expired";
+        this.index = null;
+        this.initPromise = null;
+    }
+    /**
+     * Get session statistics
+     */
+    getStats() {
+        this.checkExpiration();
+        this.checkForStaleness();
+        const index = this.index;
+        const fileCount = index?.byFile.size ?? 0;
+        const symbolCount = index ? Array.from(index.byFile.values()).reduce((sum, mod) => sum + mod.locals.length, 0) : 0;
+        const ready = this.status === "ready";
+        const staleReason = ready ? this.staleReason : undefined;
+        return {
+            status: this.status,
+            fileCount,
+            symbolCount,
+            lastActivity: new Date(this.lastActivity),
+            timeUntilExpiration: this.status === "ready" ? Math.max(0, this.timeout - (Date.now() - this.lastActivity)) : 0,
+            stale: !!staleReason,
+            ...(staleReason ? { staleReason } : {}),
+            ...(this.lastRefreshAt ? { lastRefreshAt: new Date(this.lastRefreshAt) } : {}),
+            ...(this.lastRefreshReason ? { lastRefreshReason: this.lastRefreshReason } : {}),
+        };
+    }
+}
+/**
+ * Session manager for multiple concurrent sessions
+ * Useful for agents handling multiple repositories or PRs
+ */
+export class SessionManager {
+    sessions = new Map();
+    pendingSessions = new Map();
+    createSessionConfigurationError(sessionId, existing, options) {
+        return new Error(`Session "${sessionId}" already exists for a different configuration (existing root: ${existing.getRoot()}, requested root: ${path.resolve(options.root)}). Use a different session id or dispose the existing session first.`);
+    }
+    ensureSessionIdCompatible(sessionId, options) {
+        const existing = this.sessions.get(sessionId);
+        if (!existing)
+            return undefined;
+        if (!existing.matchesOptions(options)) {
+            throw this.createSessionConfigurationError(sessionId, existing, options);
+        }
+        return existing;
+    }
+    getPendingCompatibleSession(sessionId, options) {
+        const pending = this.pendingSessions.get(sessionId);
+        if (!pending)
+            return undefined;
+        const requestedFingerprint = sessionIdentityFingerprint(resolveSessionIdentity(options));
+        if (pending.fingerprint !== requestedFingerprint) {
+            const existing = this.sessions.get(sessionId);
+            if (existing) {
+                throw this.createSessionConfigurationError(sessionId, existing, options);
+            }
+            throw new Error(`Session "${sessionId}" is already initializing with a different configuration.`);
+        }
+        return pending.promise;
+    }
+    trackSession(sessionId, options, session, retainPending, onReady) {
+        const fingerprint = sessionIdentityFingerprint(resolveSessionIdentity(options));
+        const pendingSession = {
+            cancelled: false,
+            fingerprint,
+            retainPending,
+            promise: Promise.resolve(session),
+        };
+        const promise = (async () => {
+            try {
+                await session.init();
+                if (pendingSession.cancelled) {
+                    session.dispose();
+                    throw new Error(`Session "${sessionId}" was disposed during initialization.`);
+                }
+                onReady(session);
+                return session;
+            }
+            catch (error) {
+                session.dispose();
+                throw error;
+            }
+        })();
+        pendingSession.promise = promise;
+        this.pendingSessions.set(sessionId, pendingSession);
+        promise
+            .finally(() => {
+            const pending = this.pendingSessions.get(sessionId);
+            if (pending?.promise === promise && !pending.retainPending) {
+                this.pendingSessions.delete(sessionId);
+            }
+        })
+            .catch(() => { });
+        return promise;
+    }
+    /**
+     * Create or get a session for a repository
+     */
+    async getOrCreateSession(sessionId, options) {
+        const pending = this.getPendingCompatibleSession(sessionId, options);
+        if (pending) {
+            return await pending;
+        }
+        let session = this.ensureSessionIdCompatible(sessionId, options);
+        if (!session) {
+            session = new CodeReviewSession(options);
+            return await this.trackSession(sessionId, options, session, false, (readySession) => {
+                this.sessions.set(sessionId, readySession);
+            });
+        }
+        else if (!session.isReady()) {
+            try {
+                await session.init();
+            }
+            catch (error) {
+                this.sessions.delete(sessionId);
+                session.dispose();
+                throw error;
+            }
+        }
+        return session;
+    }
+    /**
+     * Get an existing session
+     */
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    /**
+     * Dispose of a session
+     */
+    disposeSession(sessionId) {
+        const pending = this.pendingSessions.get(sessionId);
+        if (pending) {
+            pending.cancelled = true;
+            this.pendingSessions.delete(sessionId);
+        }
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.dispose();
+            this.sessions.delete(sessionId);
+        }
+    }
+    /**
+     * Dispose of all sessions
+     */
+    disposeAll() {
+        for (const pending of this.pendingSessions.values()) {
+            pending.cancelled = true;
+        }
+        this.pendingSessions.clear();
+        for (const session of this.sessions.values()) {
+            session.dispose();
+        }
+        this.sessions.clear();
+    }
+    /**
+     * Get all session IDs
+     */
+    getSessionIds() {
+        return Array.from(this.sessions.keys());
+    }
+    /**
+     * Clean up expired sessions
+     */
+    cleanupExpired() {
+        const toRemove = [];
+        for (const [id, session] of this.sessions.entries()) {
+            if (session.getStatus() === "expired") {
+                toRemove.push(id);
+            }
+        }
+        for (const id of toRemove) {
+            this.disposeSession(id);
+        }
+    }
+    /**
+     * Get statistics for all sessions
+     */
+    getAllStats() {
+        const stats = {};
+        for (const [id, session] of this.sessions.entries()) {
+            stats[id] = session.getStats();
+        }
+        return stats;
+    }
+    /**
+     * Pre-warm sessions for faster initial queries.
+     * Useful for Lambda/serverless cold start optimization.
+     * @param sessions - Array of session configs to pre-warm
+     */
+    async warmup(sessions) {
+        const requestedFingerprints = new Map();
+        const replacementSessions = [];
+        const warmupPromises = [];
+        try {
+            for (const { id, options } of sessions) {
+                const requestedFingerprint = sessionIdentityFingerprint(resolveSessionIdentity(options));
+                const existingFingerprint = requestedFingerprints.get(id);
+                if (existingFingerprint && existingFingerprint !== requestedFingerprint) {
+                    throw new Error(`Warmup requested conflicting configurations for session "${id}".`);
+                }
+                if (existingFingerprint === requestedFingerprint) {
+                    continue;
+                }
+                requestedFingerprints.set(id, requestedFingerprint);
+                const pending = this.getPendingCompatibleSession(id, options);
+                if (pending) {
+                    warmupPromises.push(pending);
+                    continue;
+                }
+                const existing = this.ensureSessionIdCompatible(id, options);
+                if (existing?.isReady()) {
+                    continue;
+                }
+                const session = new CodeReviewSession(options);
+                replacementSessions.push(existing ? { id, existing, session } : { id, session });
+                warmupPromises.push(this.trackSession(id, options, session, true, () => { }));
+            }
+            await Promise.all(warmupPromises);
+        }
+        catch (error) {
+            for (const replacement of replacementSessions) {
+                const pending = this.pendingSessions.get(replacement.id);
+                if (pending) {
+                    pending.cancelled = true;
+                    this.pendingSessions.delete(replacement.id);
+                }
+                replacement.session.dispose();
+            }
+            throw error;
+        }
+        for (const replacement of replacementSessions) {
+            const pending = this.pendingSessions.get(replacement.id);
+            if (!pending || pending.cancelled) {
+                replacement.session.dispose();
+                continue;
+            }
+            replacement.existing?.dispose();
+            this.sessions.set(replacement.id, replacement.session);
+            this.pendingSessions.delete(replacement.id);
+        }
+    }
+}
+/**
+ * Create a new code review session
+ * Convenience function for creating a session
+ */
+export async function createCodeReviewSession(options) {
+    const session = new CodeReviewSession(options);
+    await session.init();
+    return session;
+}
+//# sourceMappingURL=session.js.map