gitnexus 1.6.6-rc.50 → 1.6.6-rc.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.50",
+  "version": "1.6.6-rc.51",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",
@@ -48,6 +48,8 @@
     "test:integration": "vitest run test/integration",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
+    "test:parity": "tsx scripts/run-parity.ts",
+    "test:cross-platform": "tsx scripts/run-cross-platform.ts",
     "postinstall": "node scripts/materialize-vendor-grammars.cjs && node scripts/build-tree-sitter-dart.cjs && node scripts/build-tree-sitter-proto.cjs && node scripts/build-tree-sitter-swift.cjs",
     "prepare": "node scripts/build.js",
     "prepack": "node scripts/build.js"

package/scripts/cross-platform-tests.ts

@@ -0,0 +1,131 @@
+/**
+ * Cross-platform test subset runner.
+ *
+ * Runs only the tests that exercise platform-sensitive behavior on
+ * Windows and macOS. The full suite runs on Ubuntu; this narrows the
+ * cross-platform matrix to tests that actually vary across OSes.
+ *
+ * Categories included:
+ *   - Platform-specific logic (path.sep, process.platform guards)
+ *   - Native addon loading (LadybugDB, tree-sitter)
+ *   - Process spawning and shell behavior
+ *   - Filesystem locking and temp-dir behavior
+ *   - Worker threads (real, not mocked)
+ *   - CLI end-to-end tests
+ *
+ * When adding a new test that uses platform-varying APIs (native addons,
+ * child_process with real spawning, filesystem locking, path.sep), add
+ * it to the appropriate section below.
+ *
+ * Usage:
+ *   npx vitest run $(npx tsx scripts/cross-platform-tests.ts)
+ *   # or via the package script:
+ *   npm run test:cross-platform
+ */
+
+// Platform-specific logic tests — contain explicit process.platform guards
+// or test behavior that differs across operating systems
+const PLATFORM_LOGIC = [
+  'test/unit/setup.test.ts',
+  'test/unit/setup-jsonc.test.ts',
+  'test/unit/setup-codex.test.ts',
+  'test/unit/platform-capabilities.test.ts',
+  'test/unit/worker-pool-windows-quarantine.test.ts',
+  'test/unit/lbug-pool-win-fts-probe.test.ts',
+  'test/unit/repo-manager.test.ts',
+  'test/unit/repo-manager-finalize-invariant.test.ts',
+  'test/unit/hooks.test.ts',
+  'test/unit/cursor-hook.test.ts',
+  'test/unit/sidecar-recovery.test.ts',
+  'test/unit/pool-wal-recovery.test.ts',
+  'test/unit/detect-changes-worktree.test.ts',
+  'test/unit/eval-server-bind-restriction.test.ts',
+  'test/unit/ignore-service.test.ts',
+  'test/unit/group/bridge-db.test.ts',
+  'test/unit/group/bridge-db-edge.test.ts',
+];
+
+// Native LadybugDB integration tests — exercise the @ladybugdb/core
+// N-API addon which has known platform-specific behavior (Windows
+// file-lock lag after close, macOS N-API destructor segfaults)
+const LBUG_NATIVE = [
+  'test/integration/lbug-core-adapter.test.ts',
+  'test/integration/lbug-vector-extension.test.ts',
+  'test/integration/lbug-pool.test.ts',
+  'test/integration/lbug-pool-stability.test.ts',
+  'test/integration/lbug-lock-retry.test.ts',
+  'test/integration/lbug-open-retry.test.ts',
+  'test/integration/lbug-close-handle-release.test.ts',
+  'test/integration/lbug-orphan-sidecar-recovery.test.ts',
+  'test/integration/lbug-readonly-init.test.ts',
+  'test/integration/local-backend.test.ts',
+  'test/integration/local-backend-calltool.test.ts',
+  'test/integration/search-core.test.ts',
+  'test/integration/search-pool.test.ts',
+  'test/integration/staleness-and-stability.test.ts',
+  'test/integration/analyze-wal-checkpoint-failure.test.ts',
+];
+
+// Process spawning and CLI tests — exercise child_process with real
+// process spawning, which behaves differently across platforms (shell
+// quoting, path resolution, signal handling)
+const SPAWN_CLI = [
+  'test/integration/cli-e2e.test.ts',
+  'test/integration/hooks-e2e.test.ts',
+  'test/integration/skills-e2e.test.ts',
+  'test/integration/server-http-startup.test.ts',
+  'test/integration/mcp/server-startup.test.ts',
+  'test/integration/analyze-heap-oom-e2e.test.ts',
+  'test/integration/group/group-cli.test.ts',
+  'test/integration/cli/tool-no-index-stderr.test.ts',
+  'test/integration/setup-skills.test.ts',
+];
+
+// Worker threads tests — exercise real worker_threads which have
+// platform-specific behavior (thread spawning, IPC, exit handling)
+const WORKER_THREADS = [
+  'test/integration/worker-pool.test.ts',
+  'test/integration/parse-impl-quarantine-cache-skip.test.ts',
+];
+
+// Tree-sitter native addon smoke tests — verify that native grammars
+// load correctly on each platform (binary compatibility, .node loading)
+const NATIVE_ADDON_SMOKE = [
+  'test/integration/tree-sitter-languages.test.ts',
+  'test/integration/parsing.test.ts',
+  'test/integration/pipeline.test.ts',
+  'test/integration/pipeline-graph-golden.test.ts',
+  'test/unit/parser-loader.test.ts',
+];
+
+// Filesystem behavior tests — exercise operations that vary across
+// platforms (CRLF, symlinks, permissions, temp dirs)
+const FILESYSTEM = [
+  'test/integration/filesystem-walker.test.ts',
+  'test/integration/markdown-processor-crlf.test.ts',
+  'test/integration/ignore-and-skip-e2e.test.ts',
+];
+
+const ALL_CROSS_PLATFORM = [
+  ...PLATFORM_LOGIC,
+  ...LBUG_NATIVE,
+  ...SPAWN_CLI,
+  ...WORKER_THREADS,
+  ...NATIVE_ADDON_SMOKE,
+  ...FILESYSTEM,
+];
+
+// When invoked directly, print the file list for vitest consumption
+if (process.argv[1]?.endsWith('cross-platform-tests.ts')) {
+  console.log(ALL_CROSS_PLATFORM.join('\n'));
+}
+
+export {
+  ALL_CROSS_PLATFORM,
+  PLATFORM_LOGIC,
+  LBUG_NATIVE,
+  SPAWN_CLI,
+  WORKER_THREADS,
+  NATIVE_ADDON_SMOKE,
+  FILESYSTEM,
+};

package/scripts/run-cross-platform.ts

@@ -0,0 +1,44 @@
+/**
+ * Cross-platform test runner.
+ *
+ * Runs the platform-sensitive test subset defined in cross-platform-tests.ts
+ * via vitest. Used by `npm run test:cross-platform` and by the CI cross-
+ * platform matrix (ci-tests.yml).
+ *
+ * The main vitest.config.ts is used, so lbug-db project files get
+ * sequential execution and other safety constraints are preserved.
+ */
+
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { ALL_CROSS_PLATFORM } from './cross-platform-tests.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+
+// Verify all files exist
+const missing = ALL_CROSS_PLATFORM.filter((f) => !fs.existsSync(path.resolve(ROOT, f)));
+if (missing.length > 0) {
+  console.error(`Cross-platform test files not found (${missing.length}):`);
+  for (const f of missing) console.error(`  ${f}`);
+  console.error('\nUpdate scripts/cross-platform-tests.ts if files were moved or removed.');
+  process.exit(1);
+}
+
+console.log(`Running ${ALL_CROSS_PLATFORM.length} platform-sensitive tests...\n`);
+
+try {
+  execFileSync('npx', ['vitest', 'run', ...ALL_CROSS_PLATFORM], {
+    cwd: ROOT,
+    stdio: 'inherit',
+    timeout: 15 * 60 * 1000,
+    shell: true,
+  });
+} catch (err: any) {
+  if (err.killed || err.signal) {
+    console.error('vitest timed out after 15 minutes');
+  }
+  process.exit(1);
+}

package/scripts/run-parity.ts

@@ -0,0 +1,128 @@
+/**
+ * Consolidated scope-resolution parity runner.
+ *
+ * Replaces the per-language matrix in ci-scope-parity.yml with a single
+ * job that runs all migrated languages sequentially in one process. This
+ * eliminates 8× redundant checkout + npm ci + build cycles (the old
+ * workflow created a separate GitHub Actions job per language).
+ *
+ * For each language in MIGRATED_LANGUAGES:
+ *   1. Run its resolver test with REGISTRY_PRIMARY_<LANG>=0 (legacy DAG)
+ *   2. Run its resolver test with REGISTRY_PRIMARY_<LANG>=1 (registry-primary)
+ *
+ * Both modes must pass. Failures are collected and reported at the end
+ * so all regressions are visible in a single CI run (equivalent to the
+ * old workflow's fail-fast: false behavior).
+ *
+ * Vitest output streams to the console in real time (stdio: 'inherit')
+ * so CI logs show the actual test output directly. No per-invocation
+ * timeout — the CI job-level timeout (30 min) is the outer guard.
+ *
+ * Usage:
+ *   npx tsx scripts/run-parity.ts
+ *   npx tsx scripts/run-parity.ts --language python   # single language
+ */
+
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { MIGRATED_LANGUAGES } from '../src/core/ingestion/registry-primary-flag.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+
+interface ParityFailure {
+  lang: string;
+  mode: 'legacy' | 'registry-primary';
+}
+
+function envVarName(slug: string): string {
+  return `REGISTRY_PRIMARY_${slug.toUpperCase().replace(/-/g, '_')}`;
+}
+
+function testFilePath(slug: string): string {
+  return `test/integration/resolvers/${slug}.test.ts`;
+}
+
+function runVitest(testFile: string, env: Record<string, string>): boolean {
+  try {
+    execFileSync('npx', ['vitest', 'run', testFile], {
+      cwd: ROOT,
+      env: { ...process.env, ...env },
+      stdio: 'inherit',
+      shell: true,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Parse CLI args
+const args = process.argv.slice(2);
+const langFlag = args.indexOf('--language');
+const singleLang = langFlag >= 0 ? args[langFlag + 1] : undefined;
+
+if (langFlag >= 0 && singleLang === undefined) {
+  console.error('--language requires a value');
+  process.exit(1);
+}
+
+const languages = singleLang ? [singleLang] : [...MIGRATED_LANGUAGES].map(String);
+
+// Verify test files exist before running
+const missingFiles: string[] = [];
+for (const lang of languages) {
+  const file = path.resolve(ROOT, testFilePath(lang));
+  try {
+    fs.accessSync(file);
+  } catch {
+    missingFiles.push(`${testFilePath(lang)} (${lang})`);
+  }
+}
+
+if (missingFiles.length > 0) {
+  console.error('Missing resolver test files:');
+  for (const f of missingFiles) console.error(`  ${f}`);
+  process.exit(1);
+}
+
+console.log(`Scope-resolution parity: ${languages.length} language(s)`);
+console.log(`Languages: ${languages.join(', ')}\n`);
+
+const failures: ParityFailure[] = [];
+
+for (const lang of languages) {
+  const file = testFilePath(lang);
+  const envVar = envVarName(lang);
+
+  console.log(`\n── ${lang} — legacy DAG (${envVar}=0) ──`);
+  if (!runVitest(file, { [envVar]: '0' })) {
+    failures.push({ lang, mode: 'legacy' });
+  }
+
+  console.log(`\n── ${lang} — registry-primary (${envVar}=1) ──`);
+  if (!runVitest(file, { [envVar]: '1' })) {
+    failures.push({ lang, mode: 'registry-primary' });
+  }
+}
+
+// Summary
+const total = languages.length * 2;
+const passed = total - failures.length;
+
+console.log('\n═══════════════════════════════════════');
+console.log('PARITY SUMMARY');
+console.log('═══════════════════════════════════════');
+console.log(`Passed: ${passed}/${total}`);
+
+if (failures.length > 0) {
+  console.log(`\nFAILURES (${failures.length}):`);
+  for (const f of failures) {
+    console.log(`  ✗ ${f.lang} [${f.mode}]`);
+  }
+  process.exit(1);
+}
+
+console.log('\nAll parity checks passed.');