devlensio 0.6.2 → 1.0.1

package/dist/pipeline/index.js

@@ -1,12 +1,8 @@
 import path from "path";
 import { createHash } from "crypto";
 import { execSync } from "child_process";
-import { analyzeFingerprint } from "../fingerprint/index.js";
-import { analyzeFilesystem } from "../filesystem/index.js";
-import { parseRepo } from "../parser/index.js";
-import { detectEdges } from "../graph/index.js";
-import { buildThirdPartyNodes } from "../graph/thirdPartyLibs.js";
 import { scoreAndFilter } from "../scoring/index.js";
+import { runExtractor } from "../extractors/runner.js";
 //  Helpers 
 // Deterministic graphId — same repo always produces same id
 // This ensures multiple analyses of the same repo go into the same folder
@@ -74,7 +70,7 @@ function mapToRecord(map) {
 // Naming convention:
 //   Next.js page/layout/API:  "GET /api/users"  → id = "app/api/users/route.ts::GET /api/users"
 //   Backend (Express etc.):   "POST /users"      → id = "src/routes/users.ts::POST /users"
-function routesToCodeNodes(routes, repoPath) {
+export function routesToCodeNodes(routes, repoPath) {
     const nodes = [];
     for (const route of routes) {
         // Make filePath relative — same as parser does for all other nodes
@@ -198,41 +194,33 @@ export async function analyzePipeline(repoPath, isGithubRepo, options) {
     console.log(`   Graph ID:   ${graphId}`);
     console.log(`   Commit:     ${gitInfo.commitHash} (${gitInfo.branch})`);
     console.log(`   Message:    ${gitInfo.message}`);
-    //  Step 1: Fingerprint 
-    console.log("\n[1/5] Fingerprinting project...");
-    const fingerprint = analyzeFingerprint(absoluteRepoPath);
-    console.log(`  Framework: ${fingerprint.framework}  |  Language: ${fingerprint.language}  |  Type: ${fingerprint.projectType}`);
-    //  Step 2: Filesystem / routes 
-    console.log("\n[2/5] Analyzing filesystem routes...");
-    const routes = analyzeFilesystem(absoluteRepoPath, fingerprint);
-    console.log(`  Routes found: ${routes.length}`);
-    // Convert routes -> CodeNodes so they join the graph as nodes as well
-    // It is important to add here before the detection of the edges
-    let routeNodes = routesToCodeNodes(routes, absoluteRepoPath);
-    console.log(`  Route nodes created: ${routeNodes.length}`);
-    //  Step 3: Parse source files into nodes 
-    console.log("\n[3/5] Parsing source files...");
-    const parserResult = parseRepo(absoluteRepoPath);
-    console.log(`  Files: ${parserResult.stats.totalFiles}  |  Nodes: ${parserResult.stats.totalNodes}  |  Skipped: ${parserResult.stats.skippedFiles}`);
-    //  Step 3.5: Build third-party nodes 
-    const thirdPartyNodes = options?.includedThirdPartyLibs?.length
-        ? buildThirdPartyNodes(absoluteRepoPath, options.includedThirdPartyLibs)
-        : [];
-    if (thirdPartyNodes.length) {
-        console.log(`  Third-party nodes: ${thirdPartyNodes.length}`);
-    }
-    //  Step 4: Detect edges 
-    console.log("\n[4/5] Detecting edges...");
-    const edgeResult = detectEdges([...parserResult.nodes, ...routeNodes, ...thirdPartyNodes], routes, absoluteRepoPath, fingerprint);
-    routeNodes = routeNodes.filter(routeNode => {
-        if (routeNode.metadata.routeNodeType === "API_ROUTE") {
-            const hasHandler = edgeResult.edges.some(edge => edge.type === "HANDLES" && edge.from === routeNode.id);
-            return hasHandler;
-        }
-        return true;
+    // ── Steps 1-4: Run the extractor (inline for JS/TS, subprocess for others)
+    //
+    // The extractor handles fingerprinting, filesystem/route detection, parsing,
+    // and edge detection. It returns nodes, edges, routes, and fingerprint
+    // all in one ExtractorResult.
+    //
+    // For JS/TS: runs inline via ts-morph (same code as before, no subprocess)
+    // For Python/Java/Go/Rust: spawns a child process
+    const extractorResult = await runExtractor(absoluteRepoPath, {
+        includeThirdPartyLibs: options?.includedThirdPartyLibs,
+        onStep: options?.onStep,
     });
-    const allNodes = [...parserResult.nodes, ...routeNodes, ...thirdPartyNodes, ...edgeResult.ghostNodes];
-    const allEdges = edgeResult.edges;
+    console.log(`  Framework: ${extractorResult.fingerprint.framework}  |  ` +
+        `Language: ${extractorResult.fingerprint.language}  |  ` +
+        `Type: ${extractorResult.fingerprint.projectType}`);
+    console.log(`  Files: ${extractorResult.stats.totalFiles}  |  ` +
+        `Nodes: ${extractorResult.stats.totalNodes}  |  ` +
+        `Skipped: ${extractorResult.stats.skippedFiles}`);
+    console.log(`  Edges: ${extractorResult.edges.length}`);
+    if (extractorResult.errors.length > 0) {
+        console.warn(`  ⚠ ${extractorResult.errors.length} files had errors:`);
+        for (const err of extractorResult.errors.slice(0, 5)) {
+            console.warn(`    - ${err.file}: ${err.error}`);
+        }
+    }
+    const allNodes = extractorResult.nodes;
+    const allEdges = extractorResult.edges;
     //  Step 5: Score and filter 
     console.log("\n[5/5] Scoring and filtering...");
     const scoringResult = scoreAndFilter(allNodes, allEdges, options?.thresholds);
@@ -249,8 +237,8 @@ export async function analyzePipeline(repoPath, isGithubRepo, options) {
         graphId,
         repoPath: absoluteRepoPath,
         analyzedAt,
-        fingerprint,
-        routes,
+        fingerprint: extractorResult.fingerprint,
+        routes: extractorResult.routes ?? [],
         nodes: scoringResult.filteredNodes,
         edges: scoringResult.filteredEdges,
         allNodes,

package/dist/scoring/index.js

@@ -2,8 +2,16 @@ import { countConnections } from "./connectionCounter.js";
 import { scoreNode } from "./nodeScorer.js";
 import { scoreFile } from "./fileScorer.js";
 import { filterNoise } from "./noiseFilter.js";
+import { pruneDisconnected } from "./pruneDisconnected.js";
 export function scoreAndFilter(nodes, edges, thresholds, existingScores // when provided, skip Passes 1-4
 ) {
+    // Pass 0 — Connected-only pruning (engine-wide). Drop zero-edge
+    // STRUCT/INTERFACE/ENUM/PACKAGE/TRAIT nodes so floating type declarations
+    // never reach the graph. Runs before scoring so profiles/scores only ever
+    // cover surviving nodes; idempotent for the refilter path.
+    const pruned = pruneDisconnected(nodes, edges);
+    nodes = pruned.nodes;
+    edges = pruned.edges;
     let nodeScores;
     if (existingScores) {
         // Re-filter only — reuse scores from a previous analysis run

package/dist/scoring/index.test.js

@@ -451,3 +451,46 @@ describe("scoreAndFilter", () => {
         expect(strict.filteredNodes.length).toBeLessThan(loose.filteredNodes.length);
     });
 });
+// ─── CLASS / METHOD scoring ──────────────────────────────────────────────────
+describe("CLASS / METHOD node scoring", () => {
+    const maxima = {
+        maxIncomingCalls: 10, maxOutgoingCalls: 10, maxIncomingReads: 10,
+        maxIncomingWrites: 10, maxIncomingProps: 10, maxOutgoingProps: 10,
+        maxImportedBy: 10, p75IncomingCalls: 3, p75OutgoingCalls: 3,
+        p75IncomingReads: 3, p75IncomingProps: 3,
+    };
+    const emptyProfile = {
+        incomingCalls: 0, outgoingCalls: 0, incomingReads: 0,
+        incomingWrites: 0, incomingProps: 0, outgoingProps: 0, importedBy: 0,
+    };
+    it("gives CLASS nodes a higher type bonus than FUNCTION nodes", () => {
+        const classNode = makeNode({ id: "c", name: "UserService", type: "CLASS", endLine: 50 });
+        const fnNode = makeNode({ id: "f", name: "doThing", type: "FUNCTION", endLine: 50 });
+        expect(scoreNode(classNode, emptyProfile, maxima))
+            .toBeGreaterThan(scoreNode(fnNode, emptyProfile, maxima));
+    });
+    it("gives METHOD nodes a modest bonus below FUNCTION", () => {
+        const methodNode = makeNode({ id: "m", name: "UserService.save", type: "METHOD", endLine: 50 });
+        const fnNode = makeNode({ id: "f", name: "doThing", type: "FUNCTION", endLine: 50 });
+        expect(scoreNode(methodNode, emptyProfile, maxima))
+            .toBeLessThan(scoreNode(fnNode, emptyProfile, maxima));
+        expect(scoreNode(methodNode, emptyProfile, maxima)).toBeGreaterThan(0);
+    });
+    it("keeps CLASS and METHOD nodes under default filter thresholds", () => {
+        const nodes = [
+            makeFileNode("src/svc.ts"),
+            makeNode({
+                id: "src/svc.ts::UserService", name: "UserService", type: "CLASS",
+                endLine: 50, parentFile: "file::src/svc.ts",
+            }),
+            makeNode({
+                id: "src/svc.ts::UserService.save", name: "UserService.save", type: "METHOD",
+                endLine: 40, parentFile: "file::src/svc.ts",
+            }),
+        ];
+        const result = scoreAndFilter(nodes, []);
+        const ids = result.filteredNodes.map((n) => n.id);
+        expect(ids).toContain("src/svc.ts::UserService");
+        expect(ids).toContain("src/svc.ts::UserService.save");
+    });
+});

package/dist/scoring/nodeScorer.js

@@ -65,6 +65,8 @@ function calcTypeBonus(node) {
         case "COMPONENT": return 0.75;
         case "HOOK": return 0.75;
         case "FUNCTION": return 0.5;
+        case "CLASS": return 1.0;
+        case "METHOD": return 0.4;
         case "ROUTE": return 2;
         case "TEST": return 0.3; //  low bonus because test files are secondary, do not play role in the logical part
         case "STORY": return 0.3;

package/dist/scoring/pruneDisconnected.d.ts

@@ -0,0 +1,8 @@
+import type { CodeNode, CodeEdge } from "../types.js";
+export declare const PRUNABLE_TYPES: Set<string>;
+export interface PruneResult {
+    nodes: CodeNode[];
+    edges: CodeEdge[];
+    removedNodeCount: number;
+}
+export declare function pruneDisconnected(nodes: CodeNode[], edges: CodeEdge[]): PruneResult;

package/dist/scoring/pruneDisconnected.js

@@ -0,0 +1,66 @@
+// ─── Connected-only node pruning (engine-wide) ─────────────────────────────
+//
+// Type-declaration nodes (STRUCT/INTERFACE/ENUM/PACKAGE/TRAIT) are emitted by
+// the language extractors as declarations, but a node with ZERO edge
+// participation renders as a floating dot — pure noise. This pass drops those
+// nodes from every language uniformly (Java INTERFACE/ENUM, Rust STRUCT/ENUM/
+// TRAIT, Go STRUCT/INTERFACE/ENUM; Python/JS are unaffected — they don't emit
+// these types, and CLASS stays always-on per the JS scope decision).
+//
+// Rule: a prunable node survives iff it is referenced by ≥1 edge (either
+// direction). A Go ENUM implementing an interface or a Rust ENUM with an impl
+// block is referenced → kept. Floating serializers/validators/enum constants →
+// dropped.
+//
+// Idempotent: refiltering an already-pruned stored graph is a no-op.
+export const PRUNABLE_TYPES = new Set([
+    "STRUCT",
+    "INTERFACE",
+    "ENUM",
+    "PACKAGE",
+    "TRAIT",
+]);
+export function pruneDisconnected(nodes, edges) {
+    const referenced = new Set();
+    for (const e of edges) {
+        referenced.add(e.from);
+        referenced.add(e.to);
+    }
+    const removed = new Set();
+    const kept = [];
+    for (const node of nodes) {
+        if (PRUNABLE_TYPES.has(node.type) && !referenced.has(node.id)) {
+            removed.add(node.id);
+            continue;
+        }
+        kept.push(node);
+    }
+    if (removed.size === 0) {
+        return { nodes: kept, edges, removedNodeCount: 0 };
+    }
+    // Clean FILE parents: drop pruned ids from childNodeIds + nodeCount so the
+    // frontend drill-down never references a node that isn't in the graph.
+    for (const node of kept) {
+        if (node.type === "FILE") {
+            const meta = node.metadata;
+            const childIds = meta.childNodeIds;
+            if (Array.isArray(childIds)) {
+                const clean = childIds.filter((id) => !removed.has(id));
+                if (clean.length !== childIds.length) {
+                    meta.childNodeIds = clean;
+                    meta.nodeCount = clean.length;
+                }
+            }
+        }
+        // Any node may carry resolvedCalls pointing at a pruned declaration
+        // (e.g. a call that resolved to an enum member) — drop the dangling refs.
+        const resolvedCalls = node.metadata.resolvedCalls;
+        if (Array.isArray(resolvedCalls)) {
+            const cleanCalls = resolvedCalls.filter((r) => !removed.has(r.nodeId ?? ""));
+            if (cleanCalls.length !== resolvedCalls.length) {
+                node.metadata.resolvedCalls = cleanCalls;
+            }
+        }
+    }
+    return { nodes: kept, edges, removedNodeCount: removed.size };
+}

package/dist/scoring/pruneDisconnected.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scoring/pruneDisconnected.test.js

@@ -0,0 +1,123 @@
+import { describe, expect, test } from "bun:test";
+import { pruneDisconnected, PRUNABLE_TYPES } from "./pruneDisconnected.js";
+// ─── Helpers ──────────────────────────────────────────────────────────────
+function makeNode(overrides) {
+    return {
+        type: "FUNCTION",
+        filePath: "src/test.go",
+        startLine: 1,
+        endLine: 10,
+        parentFile: "file::src/test.go",
+        metadata: {},
+        ...overrides,
+    };
+}
+function makeFileNode(filePath, childNodeIds = []) {
+    return {
+        id: `file::${filePath}`,
+        name: filePath.split("/").pop(),
+        type: "FILE",
+        filePath,
+        startLine: 0,
+        endLine: 100,
+        parentFile: `file::${filePath}`,
+        metadata: { nodeCount: childNodeIds.length, childNodeIds },
+    };
+}
+function makeEdge(from, to, type = "CALLS") {
+    return { from, to, type, metadata: {} };
+}
+// ─── pruneDisconnected ─────────────────────────────────────────────────────
+describe("pruneDisconnected", () => {
+    test("PRUNABLE_TYPES covers the 5 declaration types", () => {
+        expect([...PRUNABLE_TYPES].sort()).toEqual(["ENUM", "INTERFACE", "PACKAGE", "STRUCT", "TRAIT"]);
+    });
+    test("drops zero-edge STRUCT/INTERFACE/ENUM/PACKAGE/TRAIT nodes", () => {
+        const nodes = [
+            makeFileNode("a.go", ["a.go::Keep", "a.go::Drop"]),
+            makeNode({ id: "a.go::Keep", name: "Keep", type: "STRUCT", parentFile: "file::a.go" }),
+            makeNode({ id: "a.go::Drop", name: "Drop", type: "STRUCT", parentFile: "file::a.go" }),
+            makeNode({ id: "a.go::Iface", name: "Iface", type: "INTERFACE", parentFile: "file::a.go" }),
+            makeNode({ id: "a.go::Color", name: "Color", type: "ENUM", parentFile: "file::a.go" }),
+            makeNode({ id: "pkg::example.com/mod", name: "mod", type: "PACKAGE", filePath: "" }),
+            makeNode({ id: "a.go::Trait", name: "Trait", type: "TRAIT", parentFile: "file::a.go" }),
+            makeNode({ id: "a.go::fn", name: "fn", type: "FUNCTION", parentFile: "file::a.go" }),
+        ];
+        // Keep STRUCT is a CALLS target; everything else floats
+        const edges = [makeEdge("a.go::fn", "a.go::Keep")];
+        const { nodes: kept, removedNodeCount } = pruneDisconnected(nodes, edges);
+        expect(removedNodeCount).toBe(5);
+        const ids = kept.map((n) => n.id);
+        expect(ids).toContain("a.go::Keep");
+        expect(ids).toContain("a.go::fn");
+        expect(ids).not.toContain("a.go::Drop");
+        expect(ids).not.toContain("a.go::Iface");
+        expect(ids).not.toContain("a.go::Color");
+        expect(ids).not.toContain("pkg::example.com/mod");
+        expect(ids).not.toContain("a.go::Trait");
+    });
+    test("connected prunable nodes survive (edge in EITHER direction)", () => {
+        const nodes = [
+            makeNode({ id: "s.go::Impl", name: "Impl", type: "STRUCT", parentFile: "file::s.go" }),
+            makeNode({ id: "s.go::Iface", name: "Iface", type: "INTERFACE", parentFile: "file::s.go" }),
+            makeNode({ id: "s.go::Color", name: "Color", type: "ENUM", parentFile: "file::s.go" }),
+        ];
+        // STRUCT implements INTERFACE (source), ENUM is the CALLS target
+        const edges = [
+            makeEdge("s.go::Impl", "s.go::Iface", "IMPLEMENTS"),
+            makeEdge("s.go::fn", "s.go::Color"),
+        ];
+        const { nodes: kept, removedNodeCount } = pruneDisconnected(nodes, edges);
+        expect(removedNodeCount).toBe(0);
+        expect(kept.map((n) => n.id).sort()).toEqual(["s.go::Color", "s.go::Iface", "s.go::Impl"]);
+    });
+    test("cleans childNodeIds + nodeCount on FILE parents", () => {
+        const nodes = [
+            makeFileNode("a.go", ["a.go::Keep", "a.go::Drop", "a.go::fn"]),
+            makeNode({ id: "a.go::Keep", name: "Keep", type: "STRUCT", parentFile: "file::a.go" }),
+            makeNode({ id: "a.go::Drop", name: "Drop", type: "ENUM", parentFile: "file::a.go" }),
+            makeNode({ id: "a.go::fn", name: "fn", type: "FUNCTION", parentFile: "file::a.go" }),
+        ];
+        const edges = [makeEdge("a.go::fn", "a.go::Keep")];
+        const { nodes: kept } = pruneDisconnected(nodes, edges);
+        const file = kept.find((n) => n.type === "FILE");
+        expect(file.metadata.childNodeIds).toEqual(["a.go::Keep", "a.go::fn"]);
+        expect(file.metadata.nodeCount).toBe(2);
+    });
+    test("cleans resolvedCalls entries pointing at pruned nodes", () => {
+        const nodes = [
+            makeNode({
+                id: "a.go::fn", name: "fn", type: "FUNCTION", parentFile: "file::a.go",
+                metadata: { resolvedCalls: [{ name: "Color.Red", nodeId: "a.go::Color" }] },
+            }),
+            makeNode({ id: "a.go::Color", name: "Color", type: "ENUM", parentFile: "file::a.go" }),
+        ];
+        const { nodes: kept } = pruneDisconnected(nodes, []);
+        const fn = kept.find((n) => n.id === "a.go::fn");
+        expect(fn.metadata.resolvedCalls).toEqual([]);
+    });
+    test("idempotent — pruning an already-pruned graph is a no-op", () => {
+        const nodes = [
+            makeFileNode("a.go", ["a.go::fn"]),
+            makeNode({ id: "a.go::fn", name: "fn", type: "FUNCTION", parentFile: "file::a.go" }),
+            makeNode({ id: "a.go::Color", name: "Color", type: "ENUM", parentFile: "file::a.go" }),
+        ];
+        const edges = [makeEdge("a.go::fn", "a.go::Color")]; // enum connected → kept
+        const first = pruneDisconnected(nodes, edges);
+        const second = pruneDisconnected(first.nodes, first.edges);
+        expect(second.removedNodeCount).toBe(0);
+        expect(second.nodes.map((n) => n.id)).toEqual(first.nodes.map((n) => n.id));
+    });
+    test("CLASS/METHOD/FUNCTION/ROUTE/FILE/TEST are never pruned", () => {
+        const nodes = [
+            makeNode({ id: "c.go::K", name: "K", type: "CLASS", parentFile: "file::c.go" }),
+            makeNode({ id: "c.go::m", name: "m", type: "METHOD", parentFile: "file::c.go" }),
+            makeNode({ id: "c.go::f", name: "f", type: "FUNCTION", parentFile: "file::c.go" }),
+            makeNode({ id: "c.go::r", name: "r", type: "ROUTE", parentFile: "file::c.go" }),
+            makeNode({ id: "file::c_test.go", name: "c_test.go", type: "TEST", parentFile: "file::c_test.go" }),
+        ];
+        const { nodes: kept, removedNodeCount } = pruneDisconnected(nodes, []);
+        expect(removedNodeCount).toBe(0);
+        expect(kept).toHaveLength(5);
+    });
+});

package/dist/summarizer/prompts.d.ts

@@ -8,7 +8,7 @@ export interface RouteIndex {
     byFilePath: Map<string, RouteNode | BackendRouteNode>;
 }
 export declare function buildEdgeIndex(edges: CodeEdge[]): EdgeIndex;
-export declare function buildRouteIndex(routes: RouteNode[] | BackendRouteNode[]): RouteIndex;
+export declare function buildRouteIndex(routes: (RouteNode | BackendRouteNode)[]): RouteIndex;
 export interface PromptContext {
     node: CodeNode;
     allNodes: Map<string, CodeNode>;

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-export type Language = "javascript" | "typescript" | "python" | "unknown";
-export type Framework = "nextjs" | "react" | "express" | "fastify" | "koa" | "hono" | "elysia" | "bun" | "unknown";
+export type Language = "javascript" | "typescript" | "python" | "java" | "go" | "rust" | "unknown";
+export type Framework = "nextjs" | "react" | "express" | "fastify" | "koa" | "hono" | "elysia" | "bun" | "django" | "flask" | "fastapi" | "spring-boot" | "quarkus" | "gin" | "echo" | "fiber" | "net-http" | "actix-web" | "rocket" | "axum" | "unknown";
 export type FrontendFramework = "nextjs" | "react";
 export type BackendFramework = "express" | "fastify" | "koa" | "hono" | "elysia" | "bun";
 export type RouterType = "app" | "pages" | "app+pages" | "react-router" | "none";
@@ -38,7 +38,7 @@ export interface BackendRouteNode {
     filePath: string;
     httpMethod: string;
     handlerName?: string;
-    framework: BackendFramework;
+    framework: Framework;
     isDynamic: boolean;
     params?: string[];
     inlineHandler?: {
@@ -47,7 +47,7 @@ export interface BackendRouteNode {
         endLine: number;
     };
 }
-export type NodeType = "COMPONENT" | "HOOK" | "FUNCTION" | "STATE_STORE" | "UTILITY" | "FILE" | "GHOST" | "ROUTE" | "TEST" | "STORY" | "THIRD_PARTY";
+export type NodeType = "COMPONENT" | "HOOK" | "FUNCTION" | "STATE_STORE" | "UTILITY" | "FILE" | "GHOST" | "ROUTE" | "TEST" | "STORY" | "THIRD_PARTY" | "CLASS" | "METHOD" | "INTERFACE" | "ENUM" | "STRUCT" | "MODULE" | "TRAIT" | "IMPL_BLOCK" | "PACKAGE";
 export interface CodeNode {
     id: string;
     name: string;
@@ -70,7 +70,7 @@ export interface CodeNode {
     score?: Number;
     metadata: Record<string, unknown>;
 }
-export type EdgeType = "CALLS" | "IMPORTS" | "READS_FROM" | "WRITES_TO" | "PROP_PASS" | "EMITS" | "LISTENS" | "WRAPPED_BY" | "GUARDS" | "HANDLES" | "TESTS" | "USES" | "NEXTJS_API_CALL" | "NAVIGATES_TO";
+export type EdgeType = "CALLS" | "IMPORTS" | "READS_FROM" | "WRITES_TO" | "PROP_PASS" | "EMITS" | "LISTENS" | "WRAPPED_BY" | "GUARDS" | "HANDLES" | "TESTS" | "USES" | "NEXTJS_API_CALL" | "NAVIGATES_TO" | "IMPLEMENTS" | "EXTENDS" | "EXPORTS" | "THROWS";
 export interface CodeEdge {
     from: string;
     to: string;

package/extractors/go/build.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+// DevLens Go extractor — cross-compiled static binaries (Node script, so it
+// runs on Windows too; never bash).
+//
+// The Go extractor ships as per-platform static binaries inside the devlensio
+// tarball (files whitelist). This builds all targets with CGO_ENABLED=0 (pure
+// static). Node is guaranteed on every machine that installs an npm package;
+// the Go toolchain is a build-time dep (same class as JDK for java's build.mjs).
+//
+// Usage: node build.mjs   (idempotent — run from this directory)
+
+import { execFileSync } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+
+// Target matrix — the platforms the registry resolves per process.platform.
+const TARGETS = [
+  ["linux", "amd64"],
+  ["linux", "arm64"],
+  ["darwin", "amd64"],
+  ["darwin", "arm64"],
+  ["windows", "amd64"],
+];
+
+function run(cmd, args, opts = {}) {
+  execFileSync(cmd, args, { stdio: "inherit", ...opts });
+}
+
+const go = process.env.GO || "go";
+for (const [goos, goarch] of TARGETS) {
+  const outDir = join(HERE, "bin", `${goos}-${goarch}`);
+  mkdirSync(outDir, { recursive: true });
+  const exe = goos === "windows" ? "devlens_go_extractor.exe" : "devlens_go_extractor";
+  console.log(`==> building ${goos}/${goarch}`);
+  run(go, ["build", "-o", join(outDir, exe), "."], {
+    cwd: HERE,
+    env: { ...process.env, GOOS: goos, GOARCH: goarch, CGO_ENABLED: "0" },
+  });
+}
+console.log("==> Done: extractors/go/bin/<goos>-<goarch>/devlens_go_extractor[.exe]");