fix: add CI gate and pre-release check for napi export verification

Prevents stale `@altimateai/altimate-core` platform binaries from
reaching production. Two new defense layers:

1. **CI test** (`napi-exports.test.ts`): verifies all 40+ expected
   function exports exist in the installed binary. Fails CI if a
   version bump doesn't update the lock file.

2. **Pre-release check** (step 2b): validates 17 critical napi exports
   before `bun run pre-release` passes. Blocks release tagging when
   the binary is stale.

Together with the runtime validation in altimate-core-internal PR #113,
this creates 3 layers of defense:
  - Build-time: validate-exports.js patches index.js (core-internal)
  - CI: napi-exports.test.ts fails on missing exports (altimate-code)
  - Pre-release: pre-release-check.ts blocks stale binaries (altimate-code)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: anandgupta42

packages/opencode/script/pre-release-check.ts

@@ -36,7 +36,7 @@ function fail(msg: string) {
 // ---------------------------------------------------------------------------
 // Check 1: Required externals are in package.json dependencies
 // ---------------------------------------------------------------------------
-console.log("\n[1/4] Checking required externals in package.json...")
+console.log("\n[1/5] Checking required externals in package.json...")
 
 const requiredExternals = ["@altimateai/altimate-core"]
 
@@ -51,7 +51,7 @@ for (const ext of requiredExternals) {
 // ---------------------------------------------------------------------------
 // Check 2: Required externals are resolvable in node_modules
 // ---------------------------------------------------------------------------
-console.log("\n[2/4] Checking required externals are installed...")
+console.log("\n[2/5] Checking required externals are installed...")
 
 for (const ext of requiredExternals) {
   try {
@@ -62,10 +62,37 @@ for (const ext of requiredExternals) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Check 2b: Verify altimate-core napi binary has all expected exports
+// ---------------------------------------------------------------------------
+console.log("\n[2b/5] Verifying altimate-core napi exports...")
+
+const CRITICAL_EXPORTS = [
+  "getStatementTypes", "formatSql", "lint", "validate", "transpile",
+  "extractMetadata", "columnLineage", "trackLineage", "diffSchemas",
+  "importDdl", "exportDdl", "optimizeContext", "pruneSchema",
+  "compareQueries", "classifyPii", "checkQueryPii", "parseDbtProject",
+]
+
+try {
+  const core = require("@altimateai/altimate-core")
+  const missing = CRITICAL_EXPORTS.filter((name) => typeof core[name] !== "function")
+  if (missing.length > 0) {
+    fail(
+      `altimate-core binary is missing ${missing.length} export(s): ${missing.join(", ")}.\n` +
+        `    The platform binary may be stale. Fix: rm -rf node_modules && bun install`,
+    )
+  } else {
+    pass(`All ${CRITICAL_EXPORTS.length} critical napi exports verified`)
+  }
+} catch (e: any) {
+  fail(`altimate-core failed to load: ${e.message}`)
+}
+
 // ---------------------------------------------------------------------------
 // Check 3: Build and smoke-test the binary
 // ---------------------------------------------------------------------------
-console.log("\n[3/4] Building local binary...")
+console.log("\n[3/5] Building local binary...")
 
 const buildResult = spawnSync("bun", ["run", "build:local"], {
   cwd: pkgDir,
@@ -105,7 +132,7 @@ if (buildResult.status !== 0) {
   if (!binaryPath) {
     fail("No binary found in dist/ after build")
   } else {
-    console.log("\n[4/4] Smoke-testing compiled binary...")
+    console.log("\n[4/5] Smoke-testing compiled binary...")
 
     // Resolve NODE_PATH like the bin wrapper does — start from pkgDir
     // to include workspace-level node_modules where NAPI modules live

packages/opencode/test/altimate/napi-exports.test.ts

@@ -0,0 +1,121 @@
+/**
+ * CI gate: verify @altimateai/altimate-core napi binary exports.
+ *
+ * This test fails when the installed altimate-core binary is missing expected
+ * function exports. Catches:
+ *   - Stale platform binary from a cached npm install
+ *   - Version bump in package.json without updating the lock file
+ *   - Broken napi build that silently drops exports
+ *
+ * Maintenance: when adding new #[napi] functions in altimate-core-internal,
+ * add them to EXPECTED_EXPORTS below.
+ */
+
+import { describe, test, expect } from "bun:test"
+
+// Every function exported by @altimateai/altimate-core that altimate-code uses.
+// This list must be kept in sync with the Rust source at:
+//   altimate-core-internal/crates/altimate-core-node/src/*.rs (#[napi] functions)
+const EXPECTED_EXPORTS = [
+  // polyglot.rs
+  "transpile",
+  "formatSql",
+  "extractMetadata",
+  "extractOutputColumns",
+  "getStatementTypes",
+  "compareQueries",
+  // context.rs
+  "optimizeContext",
+  "optimizeForQuery",
+  "pruneSchema",
+  "diffSchemas",
+  "importDdl",
+  "exportDdl",
+  "schemaFingerprint",
+  "introspectionSql",
+  // safety.rs
+  "lint",
+  "scanSql",
+  "isSafe",
+  "classifyPii",
+  "checkQueryPii",
+  "resolveTerm",
+  "analyzeTags",
+  // lineage.rs
+  "columnLineage",
+  "diffLineage",
+  "trackLineage",
+  // tools.rs
+  "complete",
+  "rewrite",
+  "generateTests",
+  "analyzeMigration",
+  "parseDbtProject",
+  // intelligence.rs (via tools)
+  "correct",
+  "evaluate",
+  "explain",
+  "fix",
+  "validate",
+  "checkEquivalence",
+  "checkPolicy",
+  "checkSemantics",
+  // sdk.rs
+  "initSdk",
+  "resetSdk",
+  "flushSdk",
+] as const
+
+describe("@altimateai/altimate-core napi exports", () => {
+  let core: Record<string, unknown>
+
+  test("module loads without error", () => {
+    core = require("@altimateai/altimate-core")
+    expect(core).toBeDefined()
+  })
+
+  test("all expected function exports exist", () => {
+    if (!core) return // skip if module failed to load
+
+    const missing: string[] = []
+    for (const name of EXPECTED_EXPORTS) {
+      if (typeof core[name] !== "function") {
+        missing.push(name)
+      }
+    }
+
+    if (missing.length > 0) {
+      throw new Error(
+        `@altimateai/altimate-core is missing ${missing.length} expected export(s):\n` +
+          `  ${missing.join(", ")}\n\n` +
+          `This usually means the platform binary is stale. Fix:\n` +
+          `  rm -rf node_modules && bun install\n\n` +
+          `If you added new #[napi] exports in altimate-core-internal,\n` +
+          `publish a new version and update the dependency in package.json.`,
+      )
+    }
+  })
+
+  test("Schema class is exported", () => {
+    if (!core) return
+    expect(typeof core.Schema).toBe("function")
+  })
+
+  test("getStatementTypes returns expected shape", () => {
+    if (!core || typeof core.getStatementTypes !== "function") return
+    const result = (core.getStatementTypes as (sql: string) => any)("SELECT 1")
+    expect(result).toHaveProperty("statements")
+    expect(result).toHaveProperty("statement_count")
+    expect(result).toHaveProperty("types")
+    expect(result).toHaveProperty("categories")
+    expect(result.statement_count).toBe(1)
+    expect(result.categories).toContain("query")
+  })
+
+  test("no unexpected exports removed (detect accidental deletion)", () => {
+    if (!core) return
+    const actual = Object.keys(core).filter((k) => typeof core[k] === "function").sort()
+    // Should have at least as many exports as expected
+    expect(actual.length).toBeGreaterThanOrEqual(EXPECTED_EXPORTS.length)
+  })
+})