gitnexus 1.6.11-rc.8 → 1.6.11

package/dist/cli/watch.js

@@ -1,372 +1,6 @@
-import path from 'node:path';
-import fs from 'node:fs/promises';
-import { watch } from 'chokidar';
-import { createWatchIgnorePredicate } from '../config/ignore-service.js';
-import { analyzeFailureMayHaveMutatedLiveIndex, runFullAnalysis, } from '../core/run-analyze.js';
-import { getGitRoot, hasGitDir } from '../storage/git.js';
-import { GITNEXUS_DIR } from '../storage/repo-meta.js';
-import { loadAnalyzeConfigStrict, mergeAnalyzeOptions, validateBranchName, } from './analyze-config.js';
-import { ensureHeap } from './analyze.js';
-import { cliError, cliInfo, cliWarn } from './cli-message.js';
-import { WATCH_FULL_REFRESH_PATH, WatchRefreshQueue, } from './watch-queue.js';
-const DEFAULT_DEBOUNCE_MS = 300;
-const MAX_TIMER_DELAY_MS = 2_147_483_647;
-const MAX_FILE_SIZE_KB = 32 * 1024;
-const TRANSIENT_WATCH_ERROR_CODES = new Set(['EACCES', 'ENOENT', 'ENOTDIR', 'EPERM']);
-function posixWatchPath(filePath) {
-    return filePath.replace(/\\/g, '/').replace(/^\.\/+/, '');
-}
-export function isRelevantWatchPath(filePath) {
-    const normalized = posixWatchPath(filePath);
-    return (normalized.length > 0 &&
-        normalized !== '.' &&
-        !normalized.startsWith('../') &&
-        !path.posix.isAbsolute(normalized) &&
-        !path.win32.isAbsolute(filePath));
-}
-function isIgnoreControlPath(filePath) {
-    const normalized = posixWatchPath(filePath);
-    return normalized === '.gitignore' || normalized === '.gitnexusignore';
-}
-function isConfigControlPath(filePath) {
-    return posixWatchPath(filePath) === '.gitnexusrc';
-}
-function isAnalyzerOwnedWatchPath(filePath) {
-    const normalized = posixWatchPath(filePath).replace(/\/+$/, '');
-    return normalized === GITNEXUS_DIR || normalized.startsWith(`${GITNEXUS_DIR}/`);
-}
-function repoRelativeWatchPath(repoPath, candidate) {
-    const relative = path.relative(repoPath, candidate).replace(/\\/g, '/');
-    if (!relative || relative.startsWith('../') || path.isAbsolute(relative))
-        return null;
-    return relative;
-}
-function setEnvironment(name, value) {
-    if (value === undefined)
-        delete process.env[name];
-    else
-        process.env[name] = value;
-}
-function positiveInteger(value, flag, maximum) {
-    if (value === undefined)
-        return undefined;
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed < 1)
-        throw new Error(`${flag} must be a positive integer`);
-    if (maximum !== undefined && parsed > maximum) {
-        throw new Error(`${flag} must not exceed ${maximum}`);
-    }
-    return parsed;
-}
-export async function resolveWatchOptions(repoPath, cli, baseline, reportIgnoredConfig = () => { }) {
-    const config = (await loadAnalyzeConfigStrict(repoPath)) ?? {};
-    const merged = mergeAnalyzeOptions(cli, config);
-    const unsupported = [
-        ['--force', cli.force],
-        ['--repair-fts', cli.repairFts],
-        ['--embeddings', cli.embeddings],
-        ['--drop-embeddings', cli.dropEmbeddings],
-        ['--skills', cli.skills],
-        ['--default-branch', cli.defaultBranch],
-        ['--skip-agents-md', cli.skipAgentsMd],
-        ['--skip-skills', cli.skipSkills],
-        ['--no-stats', cli.stats === false],
-        ['--self-commit', cli.selfCommit],
-        ['--index-only', cli.indexOnly],
-        ['--skip-git', cli.skipGit],
-        ['walCheckpointThreshold', cli.walCheckpointThreshold],
-        ['embeddingThreads', cli.embeddingThreads],
-        ['embeddingBatchSize', cli.embeddingBatchSize],
-        ['embeddingSubBatchSize', cli.embeddingSubBatchSize],
-        ['embeddingDevice', cli.embeddingDevice],
-        ['embeddingBaseUrl', cli.embeddingBaseUrl],
-        ['embeddingModel', cli.embeddingModel],
-        ['--embedding-auth-token', cli.embeddingAuthToken],
-        ['--embedding-dims', cli.embeddingDims],
-    ].filter(([, value]) => value !== undefined && value !== false);
-    if (unsupported.length > 0) {
-        throw new Error(`analyze --watch does not support ${unsupported.map(([name]) => name).join(', ')}`);
-    }
-    reportIgnoredConfig([
-        ['embeddings', config.embeddings],
-        ['dropEmbeddings', config.dropEmbeddings],
-        ['defaultBranch', config.defaultBranch],
-        ['skipAgentsMd', config.skipAgentsMd !== undefined],
-        ['skipSkills', config.skipSkills !== undefined],
-        ['stats', config.stats !== undefined],
-        ['walCheckpointThreshold', config.walCheckpointThreshold],
-        ['embeddingThreads', config.embeddingThreads],
-        ['embeddingBatchSize', config.embeddingBatchSize],
-        ['embeddingSubBatchSize', config.embeddingSubBatchSize],
-        ['embeddingDevice', config.embeddingDevice],
-        ['embeddingBaseUrl', config.embeddingBaseUrl],
-        ['embeddingModel', config.embeddingModel],
-    ]
-        .filter(([, value]) => value !== undefined && value !== false)
-        .map(([name]) => String(name)));
-    const branch = merged.branch === undefined ? undefined : validateBranchName(merged.branch, '--branch');
-    const workerPoolSize = positiveInteger(merged.workers, '--workers');
-    const workerTimeoutSeconds = positiveInteger(merged.workerTimeout, 'workerTimeout');
-    const maxFileSize = positiveInteger(merged.maxFileSize, 'maxFileSize', MAX_FILE_SIZE_KB);
-    setEnvironment('GITNEXUS_MAX_FILE_SIZE', maxFileSize === undefined ? baseline.maxFileSize : String(maxFileSize));
-    if (workerTimeoutSeconds !== undefined) {
-        process.env.GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS = String(workerTimeoutSeconds * 1000);
-    }
-    else {
-        setEnvironment('GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS', baseline.workerTimeout);
-    }
-    setEnvironment('GITNEXUS_VERBOSE', merged.verbose ? '1' : baseline.verbose);
-    return {
-        pdg: merged.pdg,
-        branch,
-        registryName: merged.name,
-        allowDuplicateName: merged.allowDuplicateName,
-        workerPoolSize,
-        fetchWrappers: merged.fetchWrappers,
-        skipAgentsMd: true,
-        skipSkills: true,
-        noStats: true,
-        atomicIncremental: process.platform !== 'win32',
-    };
-}
-function refreshSummary(result, observedPaths, durationMs, lastSuccessfulRefreshAt) {
-    const measured = result.incrementalStats;
-    const changed = measured?.changedFiles ?? (result.alreadyUpToDate ? 0 : observedPaths.length);
-    const reparsed = measured?.reparsedFiles ??
-        (typeof result.pipelineResult?.reparsedFileCount === 'number'
-            ? result.pipelineResult.reparsedFileCount
-            : 0);
-    const dependents = measured?.affectedDependents ?? 0;
-    const mode = measured?.writeMode ?? (result.alreadyUpToDate ? 'no-op' : 'full');
-    return (`Refresh complete: ${changed} changed, ${reparsed} re-parsed, ` +
-        `${dependents} affected dependent(s), ${durationMs}ms, ${mode}; ` +
-        `last success ${lastSuccessfulRefreshAt}`);
-}
-async function waitUntilReady(watcher) {
-    await new Promise((resolve, reject) => {
-        const ready = () => {
-            watcher.off('error', failed);
-            resolve();
-        };
-        const failed = (error) => {
-            watcher.off('ready', ready);
-            reject(error);
-        };
-        watcher.once('ready', ready);
-        watcher.once('error', failed);
-    });
-}
-class WatchControlReloadError extends Error {
-    constructor(cause) {
-        super(cause instanceof Error ? cause.message : String(cause), { cause });
-        this.name = 'WatchControlReloadError';
-    }
-}
-export function shouldStopAfterWatchRefreshFailure(error, paths) {
-    return (paths.length > 0 &&
-        !(error instanceof WatchControlReloadError) &&
-        analyzeFailureMayHaveMutatedLiveIndex(error));
-}
-/** Start the real filesystem watcher with bounded, serialized refreshes. */
-export async function startWatchFileLoop(repoPath, debounceMs, refresh, onError, onWatcherError = (error) => onError(error, [])) {
-    let ignorePath = await createWatchIgnorePredicate(repoPath);
-    let ignoreControlValid = true;
-    const queue = new WatchRefreshQueue(async (paths) => {
-        if (paths.some(isIgnoreControlPath) || !ignoreControlValid) {
-            const retryingInvalidControls = !ignoreControlValid;
-            try {
-                ignorePath = await createWatchIgnorePredicate(repoPath);
-                ignoreControlValid = true;
-                watcher.add(repoPath);
-            }
-            catch (error) {
-                ignoreControlValid = false;
-                throw new WatchControlReloadError(retryingInvalidControls
-                    ? new Error('Ignore controls remain invalid; fix them before indexing more changes.', {
-                        cause: error,
-                    })
-                    : error);
-            }
-        }
-        await refresh(paths);
-    }, onError, debounceMs, {
-        maxWaitMs: Math.max(2_000, debounceMs * 10),
-        maxPendingPaths: 1_000,
-        holdEventsUntilInitialRefresh: true,
-        isPriorityPath: (filePath) => isIgnoreControlPath(filePath) || isConfigControlPath(filePath),
-    });
-    const watcher = watch(repoPath, {
-        ignoreInitial: true,
-        atomic: true,
-        followSymlinks: false,
-        awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 20 },
-        ignored: (candidate, stats) => {
-            const relative = repoRelativeWatchPath(repoPath, candidate);
-            if (relative !== null && isAnalyzerOwnedWatchPath(relative))
-                return true;
-            if (relative !== null && (isIgnoreControlPath(relative) || isConfigControlPath(relative))) {
-                return false;
-            }
-            return ignorePath(candidate, stats?.isDirectory() ?? false);
-        },
-    });
-    watcher.on('all', (event, changedPath) => {
-        if (event !== 'add' && event !== 'change' && event !== 'unlink')
-            return;
-        const relative = repoRelativeWatchPath(repoPath, changedPath);
-        if (relative && isRelevantWatchPath(relative) && !isAnalyzerOwnedWatchPath(relative)) {
-            queue.enqueue(relative);
-        }
-    });
-    watcher.on('error', (error) => {
-        // Chokidar can surface a transient EPERM on Windows while an ignored
-        // analyzer-owned path is replaced. Re-arm the root and force one bounded
-        // catch-up refresh so a missed event cannot leave the graph stale. Other
-        // watcher errors may mean coverage was lost and remain fatal.
-        if (TRANSIENT_WATCH_ERROR_CODES.has(error.code ?? '')) {
-            watcher.add(repoPath);
-            queue.enqueue(WATCH_FULL_REFRESH_PATH);
-            return;
-        }
-        onWatcherError(error);
-    });
-    try {
-        await waitUntilReady(watcher);
-        await queue.runInitial();
-    }
-    catch (error) {
-        await watcher.close();
-        await queue.close();
-        throw error;
-    }
-    return {
-        waitForIdle: () => queue.waitForIdle(),
-        close: async () => {
-            await watcher.close();
-            await queue.close();
-        },
-    };
-}
-export async function watchCommandWithRunnerIdentity(runnerIdentityAtBootstrap, inputPath, cliOptions = {}) {
-    if (await ensureHeap({ cleanForwardedTermination: true }))
-        return;
-    const requestedRepoPath = inputPath ? path.resolve(inputPath) : getGitRoot(process.cwd());
-    if (requestedRepoPath === null || !hasGitDir(requestedRepoPath)) {
-        cliError('  gitnexus analyze --watch requires a Git repository.');
-        process.exitCode = 1;
-        return;
-    }
-    const repoPath = await fs.realpath(requestedRepoPath);
-    const baselineEnvironment = {
-        maxFileSize: process.env.GITNEXUS_MAX_FILE_SIZE,
-        workerTimeout: process.env.GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS,
-        verbose: process.env.GITNEXUS_VERBOSE,
-    };
-    try {
-        let ignoredConfigSignature;
-        const reportIgnoredConfig = (names) => {
-            const signature = [...names].sort().join(',');
-            if (signature === ignoredConfigSignature)
-                return;
-            ignoredConfigSignature = signature;
-            if (names.length > 0) {
-                cliWarn(`Watch mode ignores unsupported .gitnexusrc settings: ${names.join(', ')}.`);
-            }
-        };
-        let debounceMs;
-        let analyzeOptions;
-        try {
-            debounceMs =
-                positiveInteger(cliOptions.debounce ?? String(DEFAULT_DEBOUNCE_MS), '--debounce', MAX_TIMER_DELAY_MS) ?? DEFAULT_DEBOUNCE_MS;
-            analyzeOptions = await resolveWatchOptions(repoPath, cliOptions, baselineEnvironment, reportIgnoredConfig);
-        }
-        catch (error) {
-            cliError(`  ${error instanceof Error ? error.message : String(error)}`);
-            process.exitCode = 1;
-            return;
-        }
-        let stopWatching;
-        const stopped = new Promise((resolve) => {
-            stopWatching = resolve;
-        });
-        const stop = () => stopWatching();
-        process.once('SIGINT', stop);
-        process.once('SIGTERM', stop);
-        try {
-            let loop;
-            let fatalRefreshError;
-            let configControlValid = true;
-            let lastSuccessfulRefreshAt;
-            try {
-                loop = await startWatchFileLoop(repoPath, debounceMs, async (paths) => {
-                    if (paths.some(isConfigControlPath) || !configControlValid) {
-                        const retryingInvalidConfig = !configControlValid;
-                        try {
-                            analyzeOptions = await resolveWatchOptions(repoPath, cliOptions, baselineEnvironment, reportIgnoredConfig);
-                            configControlValid = true;
-                        }
-                        catch (error) {
-                            configControlValid = false;
-                            throw new WatchControlReloadError(retryingInvalidConfig
-                                ? new Error('Configuration remains invalid; fix it before indexing more changes.', {
-                                    cause: error,
-                                })
-                                : error);
-                        }
-                    }
-                    const startedAt = Date.now();
-                    const result = await runFullAnalysis(repoPath, analyzeOptions, {
-                        onProgress: () => { },
-                        onLog: process.env.GITNEXUS_VERBOSE === '1'
-                            ? (message) => cliInfo(`  ${message}`)
-                            : undefined,
-                    }, runnerIdentityAtBootstrap);
-                    lastSuccessfulRefreshAt = new Date().toISOString();
-                    if (paths.length === 0) {
-                        cliInfo(result.alreadyUpToDate
-                            ? `Watching ${repoPath}; index is up to date.`
-                            : `Watching ${repoPath}; initial index ready in ${Date.now() - startedAt}ms.`);
-                    }
-                    else {
-                        cliInfo(refreshSummary(result, paths, Date.now() - startedAt, lastSuccessfulRefreshAt));
-                    }
-                }, (error, paths) => {
-                    const detail = paths.length > 0 ? ` (${paths.length} queued path(s))` : '';
-                    if (shouldStopAfterWatchRefreshFailure(error, paths)) {
-                        fatalRefreshError = error;
-                        cliError(`Refresh failed${detail}: ${error instanceof Error ? error.message : String(error)}. ` +
-                            'Watch mode is stopping because the live index may have been updated in place.');
-                        stopWatching();
-                        return;
-                    }
-                    const lastSuccess = lastSuccessfulRefreshAt ?? 'none yet';
-                    cliWarn(`Refresh failed${detail}: ${error instanceof Error ? error.message : String(error)}. ` +
-                        `Retry scheduled; last success ${lastSuccess}.`);
-                }, (error) => {
-                    fatalRefreshError = error;
-                    cliError(`Watcher failed: ${error instanceof Error ? error.message : String(error)}. ` +
-                        'Watch mode is stopping.');
-                    stopWatching();
-                });
-            }
-            catch (error) {
-                cliError(`  Unable to start watcher: ${error instanceof Error ? error.message : String(error)}`);
-                process.exitCode = 1;
-                return;
-            }
-            await stopped;
-            await loop.close();
-            if (fatalRefreshError !== undefined)
-                process.exitCode = 1;
-        }
-        finally {
-            process.removeListener('SIGINT', stop);
-            process.removeListener('SIGTERM', stop);
-        }
-    }
-    finally {
-        setEnvironment('GITNEXUS_MAX_FILE_SIZE', baselineEnvironment.maxFileSize);
-        setEnvironment('GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS', baselineEnvironment.workerTimeout);
-        setEnvironment('GITNEXUS_VERBOSE', baselineEnvironment.verbose);
-    }
+/** Reserved CLI verb: never starts either watch product. */
+import { t } from './i18n/index.js';
+export async function watchAmbiguousCommand(_action) {
+    process.stderr.write(t('error.watch.ambiguous'));
+    process.exitCode = 1;
 }

package/dist/core/analysis-feature-registry.d.ts

@@ -0,0 +1,2 @@
+/** Production registry of independently versioned analysis capabilities. */
+export declare const ANALYSIS_FEATURES: readonly [import("./analysis-features.js").AnalysisFeatureDescriptor, import("./analysis-features.js").AnalysisFeatureDescriptor, import("./analysis-features.js").AnalysisFeatureDescriptor, import("./analysis-features.js").AnalysisFeatureDescriptor, import("./analysis-features.js").AnalysisFeatureDescriptor, import("./analysis-features.js").AnalysisFeatureDescriptor, import("./analysis-features.js").AnalysisFeatureDescriptor, import("./analysis-features.js").AnalysisFeatureDescriptor, import("./analysis-features.js").AnalysisFeatureDescriptor];

package/dist/core/analysis-feature-registry.js

@@ -0,0 +1,15 @@
+import { CLASS_FRAMEWORK_ANNOTATIONS_FEATURE } from './analysis-features.js';
+import { SPRING_AOP_FEATURE, SPRING_BEAN_INVENTORY_FEATURE, SPRING_CONDITIONALS_FEATURE, SPRING_NON_HTTP_HANDLERS_FEATURE, SPRING_ROUTE_BINDINGS_FEATURE, } from './ingestion/frameworks/spring/analysis-features.js';
+import { JAVA_ENUM_INTERFACE_HERITAGE_FEATURE, JAVA_RECORD_COMPONENT_ACCESSORS_FEATURE, SPRING_CONFIG_BINDINGS_FEATURE, } from './ingestion/languages/java/analysis-features.js';
+/** Production registry of independently versioned analysis capabilities. */
+export const ANALYSIS_FEATURES = [
+    CLASS_FRAMEWORK_ANNOTATIONS_FEATURE,
+    SPRING_AOP_FEATURE,
+    SPRING_BEAN_INVENTORY_FEATURE,
+    SPRING_CONDITIONALS_FEATURE,
+    SPRING_NON_HTTP_HANDLERS_FEATURE,
+    SPRING_ROUTE_BINDINGS_FEATURE,
+    SPRING_CONFIG_BINDINGS_FEATURE,
+    JAVA_ENUM_INTERFACE_HERITAGE_FEATURE,
+    JAVA_RECORD_COMPONENT_ACCESSORS_FEATURE,
+];

package/dist/core/analyzer-identity.js

@@ -13,12 +13,13 @@
  * different entry files inside the same build tree; alternating between them
  * must not make an otherwise identical index stale.
  */
-import { closeSync, constants as fsConstants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { accessSync, closeSync, constants as fsConstants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { createHash, randomBytes } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { isDeepStrictEqual } from 'node:util';
 import os from 'node:os';
 import path from 'node:path';
+import { parseTruthyEnv } from './ingestion/utils/env.js';
 import { fileURLToPath } from 'node:url';
 export const ANALYZER_RUNNER_IDENTITY_SCHEMA_VERSION = 4;
 const BUILD_CANONICALIZATION = 'gitnexus-analyzer-build-v2';
@@ -1754,9 +1755,26 @@ function snapshotCacheGuardDirect(request) {
         return null;
     }
 }
-function snapshotCacheGuards(requests) {
+function installTreeUnwritable(packageRoot, buildRoot) {
+    for (const dir of [packageRoot, buildRoot]) {
+        try {
+            accessSync(dir, fsConstants.W_OK);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'EACCES' || code === 'EROFS')
+                return true;
+        }
+    }
+    return false;
+}
+function snapshotCacheGuards(requests, packageRoot, buildRoot) {
     if (requests.length < 128)
         return requests.map(snapshotCacheGuardDirect);
+    if (parseTruthyEnv(process.env.GITNEXUS_ANALYZER_IDENTITY_IN_PROCESS_GUARDS) ||
+        installTreeUnwritable(packageRoot, buildRoot)) {
+        return requests.map(snapshotCacheGuardDirect);
+    }
     try {
         const probe = spawnSync(process.execPath, ['--input-type=commonjs', '-e', CACHE_GUARD_PROBE_SCRIPT], {
             input: JSON.stringify(requests),
@@ -1857,7 +1875,7 @@ function validateIdentityCache(cache, options) {
         return { mode, absolutePath };
     });
     options.onCacheValidationPass?.({ guardCount: requests.length });
-    const actual = snapshotCacheGuards(requests);
+    const actual = snapshotCacheGuards(requests, cache.packageRoot, cache.buildRoot);
     const mismatch = actual.findIndex((result, index) => !isDeepStrictEqual(result, entries[index][1]));
     if (mismatch !== -1) {
         const [mode, absolutePath] = JSON.parse(entries[mismatch][0]);

package/dist/core/auto-sync/analysis-worker-launch.d.ts

@@ -0,0 +1,30 @@
+import { type ChildProcess } from 'node:child_process';
+import type { AnalyzeOptions, AnalyzeResult } from '../run-analyze.js';
+export type AutoSyncAnalysisRunner = (repoPath: string, options: AnalyzeOptions, timeoutMs: number, signal?: AbortSignal, onCancellationRequested?: () => void, concurrency?: number) => Promise<Pick<AnalyzeResult, 'stats'>>;
+interface AnalysisWorker extends Pick<ChildProcess, 'send' | 'on'> {
+    stdout?: Pick<NodeJS.ReadableStream, 'resume'> | null;
+    stderr?: Pick<NodeJS.ReadableStream, 'resume'> | null;
+    unref?: () => void;
+    channel?: {
+        unref(): void;
+    } | null;
+}
+export interface AutoSyncAnalysisLaunchDeps {
+    forkWorker: (workerPath: string, execArgv: string[]) => AnalysisWorker;
+    setTimeoutFn: typeof setTimeout;
+    clearTimeoutFn: typeof clearTimeout;
+    cancelGraceMs: number;
+}
+/**
+ * Per-worker V8 heap cap for one tick.
+ *
+ * `autoHeapCapMb()` is a whole-machine figure, so handing it to every fork
+ * over-commits memory by the parallelism factor. Admission already bounds
+ * parallelism to `floor(availableMemoryGB / 2)`, so dividing here keeps the sum
+ * of worker heaps inside the machine budget while leaving `max_concurrency`
+ * free to mean what it says. The two rules compose to a ~1.5GB per-worker floor.
+ */
+export declare function resolveWorkerHeapMb(concurrency?: number): number;
+export declare function createAutoSyncAnalysisRunner(overrides?: Partial<AutoSyncAnalysisLaunchDeps>): AutoSyncAnalysisRunner;
+export declare const runAutoSyncAnalysis: AutoSyncAnalysisRunner;
+export {};

package/dist/core/auto-sync/analysis-worker-launch.js

@@ -0,0 +1,166 @@
+import { fork } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { autoHeapCapMb } from '../ingestion/utils/effective-ram.js';
+const _require = createRequire(import.meta.url);
+/**
+ * How long the parent keeps waiting after asking a worker to cancel.
+ *
+ * Must stay below `stopAutoSyncWatch`'s process-exit budget, or a worker wedged
+ * past its safe point still turns `watch stop` into a timeout.
+ */
+const AUTO_SYNC_CANCEL_GRACE_MS = 5_000;
+const DEFAULT_DEPS = {
+    forkWorker: (workerPath, execArgv) => fork(workerPath, [], {
+        execArgv,
+        stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+    }),
+    setTimeoutFn: setTimeout,
+    clearTimeoutFn: clearTimeout,
+    cancelGraceMs: AUTO_SYNC_CANCEL_GRACE_MS,
+};
+/**
+ * Per-worker V8 heap cap for one tick.
+ *
+ * `autoHeapCapMb()` is a whole-machine figure, so handing it to every fork
+ * over-commits memory by the parallelism factor. Admission already bounds
+ * parallelism to `floor(availableMemoryGB / 2)`, so dividing here keeps the sum
+ * of worker heaps inside the machine budget while leaving `max_concurrency`
+ * free to mean what it says. The two rules compose to a ~1.5GB per-worker floor.
+ */
+export function resolveWorkerHeapMb(concurrency = 1) {
+    const slots = Number.isFinite(concurrency) && concurrency >= 1 ? Math.floor(concurrency) : 1;
+    return Math.max(1, Math.min(8192, Math.floor(autoHeapCapMb() / slots)));
+}
+export function createAutoSyncAnalysisRunner(overrides = {}) {
+    const deps = { ...DEFAULT_DEPS, ...overrides };
+    return (repoPath, options, timeoutMs, signal, onCancellationRequested, concurrency) => new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error('Analysis cancelled.'));
+            return;
+        }
+        const callerPath = fileURLToPath(import.meta.url);
+        const isDev = callerPath.endsWith('.ts');
+        const workerPath = path.join(path.dirname(callerPath), '../../server', isDev ? 'analyze-worker.ts' : 'analyze-worker.js');
+        if (!existsSync(workerPath)) {
+            reject(new Error(`Auto-sync analyze worker is missing: ${workerPath}`));
+            return;
+        }
+        const workerHeapMb = resolveWorkerHeapMb(concurrency);
+        const execArgv = isDev
+            ? [
+                '--import',
+                pathToFileURL(_require.resolve('tsx/esm')).href,
+                `--max-old-space-size=${workerHeapMb}`,
+            ]
+            : [`--max-old-space-size=${workerHeapMb}`];
+        const child = deps.forkWorker(workerPath, execArgv);
+        child.stdout?.resume();
+        child.stderr?.resume();
+        let terminalOutcome;
+        let terminationError;
+        let settled = false;
+        let graceTimer;
+        const cleanup = () => {
+            deps.clearTimeoutFn(timeout);
+            deps.clearTimeoutFn(graceTimer);
+            signal?.removeEventListener('abort', onAbort);
+        };
+        // Stop the parent owning a worker it has given up waiting for. An
+        // established IPC channel keeps this event loop alive even after unref,
+        // so both handles have to go. Never a kill: the child may be inside
+        // native work and is left to reach its own safe point.
+        const releaseChild = () => {
+            child.channel?.unref?.();
+            child.unref?.();
+        };
+        const settle = (error, result) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (error)
+                reject(error);
+            else
+                resolve(result);
+        };
+        const requestCancellation = (error) => {
+            if (settled || terminationError)
+                return;
+            terminationError = error;
+            deps.clearTimeoutFn(timeout);
+            onCancellationRequested?.();
+            // IPC has the same semantics on macOS and Windows. The worker exits only
+            // after reaching a JS-visible safe point; this parent keeps ownership until then.
+            try {
+                child.send({ type: 'cancel' });
+            }
+            catch {
+                // A closed IPC channel still has an exit/error path. Do not force-kill a
+                // worker that may be inside native code.
+            }
+            // Bounded wait. A worker stuck past its safe point would otherwise leave
+            // this promise pending forever, wedging `activeRun` so `stop()` — and the
+            // `watch stop` waiting on this process to exit — can never finish. Settle
+            // the parent's wait and drop the IPC channel's hold on this event loop;
+            // an established channel keeps the parent alive even after unref. The
+            // child is deliberately left running rather than killed mid-write.
+            graceTimer = deps.setTimeoutFn(() => {
+                if (settled)
+                    return;
+                releaseChild();
+                settle(new Error(`${error.message} The analyze worker did not exit within ${deps.cancelGraceMs}ms; ` +
+                    'it was left running so its native work is not interrupted.'));
+            }, deps.cancelGraceMs);
+        };
+        const timeout = deps.setTimeoutFn(() => requestCancellation(new Error(`Analysis timed out after ${timeoutMs}ms.`)), timeoutMs);
+        const onAbort = () => requestCancellation(new Error('Analysis cancelled.'));
+        signal?.addEventListener('abort', onAbort, { once: true });
+        child.on('message', (message) => {
+            // Once timeout/cancellation requested shutdown, its reason owns the
+            // result. A terminal IPC can already be queued behind cancellation.
+            if (message.type === 'progress' || terminalOutcome || terminationError)
+                return;
+            terminalOutcome = message;
+            deps.clearTimeoutFn(timeout);
+        });
+        child.on('error', (error) => {
+            const workerError = new Error(`Auto-sync analyze worker error: ${error.message}`);
+            requestCancellation(workerError);
+            // This settles immediately rather than waiting out the grace, so the
+            // grace timer that would otherwise have released the child is cleared
+            // by cleanup(). Release it here instead — an errored channel does not
+            // mean the worker stopped.
+            releaseChild();
+            settle(workerError);
+        });
+        child.on('exit', (code, childSignal) => {
+            if (settled)
+                return;
+            if (terminationError) {
+                settle(terminationError);
+                return;
+            }
+            if (terminalOutcome?.type === 'complete') {
+                settle(undefined, { stats: terminalOutcome.result.stats });
+                return;
+            }
+            if (terminalOutcome?.type === 'error') {
+                settle(new Error(terminalOutcome.message));
+                return;
+            }
+            settle(new Error(`Auto-sync analyze worker exited before completion (${childSignal ?? code ?? 'unknown'}).`));
+        });
+        try {
+            child.send({ type: 'start', repoPath, options });
+        }
+        catch (error) {
+            const startError = new Error(`Failed to start auto-sync analyze worker: ${error.message}`);
+            requestCancellation(startError);
+            settle(startError);
+        }
+    });
+}
+export const runAutoSyncAnalysis = createAutoSyncAnalysisRunner();