@ctxo/lang-go 0.7.0 → 0.8.0-alpha.0

package/dist/index.js

@@ -1,3 +1,420 @@
+// src/analyzer/analyzer-adapter.ts
+import { relative } from "path";
+
+// src/logger.ts
+function enabledFor(namespace) {
+  const env = process.env["DEBUG"];
+  if (!env) return false;
+  const patterns = env.split(",").map((p) => p.trim()).filter(Boolean);
+  for (const pattern of patterns) {
+    if (pattern === "*" || pattern === namespace) return true;
+    if (pattern.endsWith("*") && namespace.startsWith(pattern.slice(0, -1))) return true;
+  }
+  return false;
+}
+function emit(namespace, level, message, args) {
+  const line = `[${namespace}] ${message}${args.length ? " " + args.map(String).join(" ") : ""}`;
+  if (level === "error") process.stderr.write(line + "\n");
+  else if (level === "warn") process.stderr.write(line + "\n");
+  else if (enabledFor(namespace)) process.stderr.write(line + "\n");
+}
+function createLogger(namespace) {
+  return {
+    debug: (msg, ...args) => emit(namespace, "debug", msg, args),
+    info: (msg, ...args) => emit(namespace, "info", msg, args),
+    warn: (msg, ...args) => emit(namespace, "warn", msg, args),
+    error: (msg, ...args) => emit(namespace, "error", msg, args)
+  };
+}
+
+// src/analyzer/toolchain-detect.ts
+import { execFileSync } from "child_process";
+var log = createLogger("ctxo:lang-go");
+var MIN_MAJOR = 1;
+var MIN_MINOR = 22;
+function detectGoToolchain() {
+  try {
+    const out = execFileSync("go", ["version"], { encoding: "utf-8", timeout: 1e4 }).trim();
+    const match = out.match(/go(\d+)\.(\d+)(?:\.(\d+))?/);
+    if (!match) {
+      log.info(`Could not parse go version output: ${out}`);
+      return { available: false };
+    }
+    const major = parseInt(match[1], 10);
+    const minor = parseInt(match[2], 10);
+    const version = match[3] ? `${major}.${minor}.${match[3]}` : `${major}.${minor}`;
+    if (major < MIN_MAJOR || major === MIN_MAJOR && minor < MIN_MINOR) {
+      log.info(`go ${version} found but >= ${MIN_MAJOR}.${MIN_MINOR} required`);
+      return { available: false, version };
+    }
+    return { available: true, version };
+  } catch {
+    return { available: false };
+  }
+}
+
+// src/analyzer/module-discovery.ts
+import { existsSync, readdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+var log2 = createLogger("ctxo:lang-go");
+var IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".ctxo", "vendor", "dist", "build"]);
+function discoverGoModule(rootDir) {
+  let dir = resolve(rootDir);
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(dir, "go.work"))) return dir;
+    if (existsSync(join(dir, "go.mod"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return findShallow(rootDir, 3);
+}
+function findShallow(dir, maxDepth, depth = 0) {
+  if (depth > maxDepth) return null;
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.isFile() && (e.name === "go.work" || e.name === "go.mod")) {
+        return dir;
+      }
+    }
+    for (const e of entries) {
+      if (e.isDirectory() && !IGNORE_DIRS.has(e.name) && !e.name.startsWith(".")) {
+        const found = findShallow(join(dir, e.name), maxDepth, depth + 1);
+        if (found) return found;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function findMonorepoRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 12; i++) {
+    if (existsSync(join(dir, "pnpm-workspace.yaml"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function findCtxoGoAnalyzerSource() {
+  const pkgRoot = findPackageRoot(import.meta.dirname);
+  const monorepoRoot = findMonorepoRoot(import.meta.dirname);
+  const candidates = [
+    ...pkgRoot ? [join(pkgRoot, "tools/ctxo-go-analyzer")] : [],
+    ...monorepoRoot ? [join(monorepoRoot, "packages/lang-go/tools/ctxo-go-analyzer")] : [],
+    join(import.meta.dirname, "../tools/ctxo-go-analyzer"),
+    join(import.meta.dirname, "../../tools/ctxo-go-analyzer"),
+    join(import.meta.dirname, "../../../tools/ctxo-go-analyzer"),
+    join(process.cwd(), "node_modules/@ctxo/lang-go/tools/ctxo-go-analyzer")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(join(candidate, "go.mod")) && existsSync(join(candidate, "main.go"))) {
+      return candidate;
+    }
+  }
+  log2.info("ctxo-go-analyzer source not found in any candidate location");
+  return null;
+}
+
+// src/analyzer/binary-build.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { createHash } from "crypto";
+import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync } from "fs";
+import { homedir, platform } from "os";
+import { join as join2 } from "path";
+var log3 = createLogger("ctxo:lang-go");
+var BINARY_NAME = platform() === "win32" ? "ctxo-go-analyzer.exe" : "ctxo-go-analyzer";
+var BUILD_TIMEOUT_MS = 18e4;
+function ensureAnalyzerBinary(sourceDir, goVersion) {
+  const key = `${hashSourceTree(sourceDir)}-go${goVersion}`;
+  const cacheDir = join2(homedir(), ".cache", "ctxo", "lang-go-analyzer", key);
+  const binaryPath = join2(cacheDir, BINARY_NAME);
+  if (existsSync2(binaryPath)) return binaryPath;
+  mkdirSync(cacheDir, { recursive: true });
+  log3.info(`Building ctxo-go-analyzer (first run): ${binaryPath}`);
+  try {
+    execFileSync2("go", ["build", "-trimpath", "-o", binaryPath, "."], {
+      cwd: sourceDir,
+      timeout: BUILD_TIMEOUT_MS,
+      stdio: ["ignore", "inherit", "inherit"]
+    });
+  } catch (err) {
+    throw new Error(`go build failed: ${err.message}`);
+  }
+  if (!existsSync2(binaryPath)) {
+    throw new Error("go build completed but expected binary is missing");
+  }
+  return binaryPath;
+}
+function hashSourceTree(dir) {
+  const hash = createHash("sha1");
+  const files = [];
+  walk(dir, (path) => {
+    if (path.endsWith(".go") || path.endsWith("go.mod") || path.endsWith("go.sum")) {
+      files.push(path);
+    }
+  });
+  files.sort();
+  for (const f of files) {
+    hash.update(f);
+    hash.update(readFileSync(f));
+  }
+  return hash.digest("hex").slice(0, 12);
+}
+function walk(dir, cb) {
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const path = join2(dir, String(entry.name));
+    if (entry.isDirectory()) walk(path, cb);
+    else if (entry.isFile()) cb(path);
+  }
+}
+
+// src/analyzer/analyzer-process.ts
+import { spawn } from "child_process";
+var log4 = createLogger("ctxo:lang-go");
+async function runBatchAnalyze(binaryPath, moduleRoot, timeoutMs = 12e4) {
+  return new Promise((resolve2) => {
+    const empty = {
+      files: [],
+      dead: [],
+      hasMain: false,
+      timeout: false,
+      totalFiles: 0,
+      elapsed: ""
+    };
+    const proc = spawn(binaryPath, ["--root", moduleRoot], {
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: timeoutMs
+    });
+    const files = [];
+    let dead = [];
+    let hasMain = false;
+    let timeout = false;
+    let totalFiles = 0;
+    let elapsed = "";
+    let stderr = "";
+    let buffer = "";
+    proc.stdout.on("data", (chunk) => {
+      buffer += chunk.toString();
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, nl).trim();
+        buffer = buffer.slice(nl + 1);
+        if (!line) continue;
+        try {
+          const obj = JSON.parse(line);
+          switch (obj.type) {
+            case "file":
+              files.push(obj);
+              break;
+            case "dead":
+              dead = Array.isArray(obj.symbolIds) ? obj.symbolIds : [];
+              hasMain = Boolean(obj.hasMain);
+              timeout = Boolean(obj.timeout);
+              break;
+            case "progress":
+              log4.info(String(obj.message ?? ""));
+              break;
+            case "summary":
+              totalFiles = Number(obj.totalFiles ?? 0);
+              elapsed = String(obj.elapsed ?? "");
+              break;
+          }
+        } catch {
+          log4.error(`Failed to parse JSONL line: ${line.slice(0, 120)}`);
+        }
+      }
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        log4.error(`ctxo-go-analyzer exited with code ${code}: ${stderr.trim().slice(0, 500)}`);
+        resolve2(empty);
+        return;
+      }
+      resolve2({ files, dead, hasMain, timeout, totalFiles, elapsed });
+    });
+    proc.on("error", (err) => {
+      log4.error(`ctxo-go-analyzer spawn error: ${err.message}`);
+      resolve2(empty);
+    });
+  });
+}
+
+// src/analyzer/analyzer-adapter.ts
+var log5 = createLogger("ctxo:lang-go");
+var VALID_SYMBOL_ID = /^.+::.+::.+$/;
+var GoAnalyzerAdapter = class {
+  extensions = [".go"];
+  tier = "full";
+  moduleRoot = null;
+  binaryPath = null;
+  modulePathPrefix = "";
+  cache = /* @__PURE__ */ new Map();
+  deadSymbolIds = /* @__PURE__ */ new Set();
+  hasMain = false;
+  timedOut = false;
+  batchPromise = null;
+  initialized = false;
+  isSupported(filePath) {
+    return filePath.endsWith(".go");
+  }
+  isReady() {
+    return this.initialized && this.binaryPath !== null && this.moduleRoot !== null;
+  }
+  async initialize(rootDir) {
+    const toolchain = detectGoToolchain();
+    if (!toolchain.available) {
+      log5.info(`Go analyzer unavailable: go ${toolchain.version ?? "not found"} (>= 1.22 required)`);
+      return;
+    }
+    const moduleRoot = discoverGoModule(rootDir);
+    if (!moduleRoot) {
+      log5.info("Go analyzer unavailable: no go.mod or go.work found");
+      return;
+    }
+    this.moduleRoot = moduleRoot;
+    const prefix = relative(rootDir, moduleRoot).replace(/\\/g, "/");
+    this.modulePathPrefix = prefix && prefix !== "." ? prefix : "";
+    const sourceDir = findCtxoGoAnalyzerSource();
+    if (!sourceDir) {
+      log5.info("Go analyzer unavailable: ctxo-go-analyzer source not located");
+      return;
+    }
+    try {
+      this.binaryPath = ensureAnalyzerBinary(sourceDir, toolchain.version);
+    } catch (err) {
+      log5.warn(`Go analyzer binary build failed: ${err.message}`);
+      return;
+    }
+    log5.info(`Go analyzer ready: go ${toolchain.version}, module ${moduleRoot}`);
+    this.initialized = true;
+  }
+  /**
+   * Returns the dead-symbol set emitted by the last batch run. Empty until
+   * extractSymbols/Edges has been called at least once. Consumed by cli's
+   * find_dead_code MCP tool via the composite delegate.
+   */
+  getDeadSymbolIds() {
+    return this.deadSymbolIds;
+  }
+  /** True when the analyzer ran in binary mode (precise dead-code). */
+  reachabilityHasMain() {
+    return this.hasMain;
+  }
+  /** True when reach analysis exceeded the deadline (degraded precision). */
+  reachabilityTimedOut() {
+    return this.timedOut;
+  }
+  async extractSymbols(filePath, _source) {
+    if (!this.isReady()) return [];
+    await this.ensureBatch();
+    const file = this.cache.get(this.normalizePath(filePath));
+    if (!file) return [];
+    return file.symbols.filter((s) => VALID_SYMBOL_ID.test(s.symbolId)).map((s) => ({
+      symbolId: s.symbolId,
+      name: s.name,
+      kind: s.kind,
+      startLine: s.startLine,
+      endLine: s.endLine,
+      ...s.startOffset != null ? { startOffset: s.startOffset } : {},
+      ...s.endOffset != null ? { endOffset: s.endOffset } : {}
+    }));
+  }
+  async extractEdges(filePath, _source) {
+    if (!this.isReady()) return [];
+    await this.ensureBatch();
+    const file = this.cache.get(this.normalizePath(filePath));
+    if (!file) return [];
+    return file.edges.filter((e) => VALID_SYMBOL_ID.test(e.from) && VALID_SYMBOL_ID.test(e.to)).map((e) => ({
+      from: e.from,
+      to: e.to,
+      kind: e.kind
+    }));
+  }
+  async extractComplexity(_filePath, _source) {
+    return [];
+  }
+  async dispose() {
+    this.cache.clear();
+    this.deadSymbolIds.clear();
+    this.batchPromise = null;
+    this.initialized = false;
+  }
+  async ensureBatch() {
+    if (this.batchPromise) return this.batchPromise;
+    this.batchPromise = this.runBatch();
+    return this.batchPromise;
+  }
+  async runBatch() {
+    if (!this.binaryPath || !this.moduleRoot) return;
+    const result = await runBatchAnalyze(this.binaryPath, this.moduleRoot);
+    this.absorbBatch(result);
+    log5.info(`Go analyzer batch: ${result.totalFiles} files in ${result.elapsed}, ${result.dead.length} dead`);
+  }
+  absorbBatch(result) {
+    this.cache.clear();
+    this.deadSymbolIds.clear();
+    this.hasMain = result.hasMain;
+    this.timedOut = result.timeout;
+    const rewrite = this.buildPathRewriter();
+    for (const file of result.files) {
+      const projectRel = rewrite(file.file);
+      this.cache.set(projectRel, {
+        ...file,
+        file: projectRel,
+        symbols: file.symbols.map((s) => ({ ...s, symbolId: rewriteId(s.symbolId, file.file, projectRel) })),
+        edges: file.edges.map((e) => ({
+          ...e,
+          from: rewriteId(e.from, file.file, projectRel),
+          to: rewriteIdAcrossModule(e.to, this.modulePathPrefix)
+        }))
+      });
+    }
+    for (const id of result.dead) {
+      this.deadSymbolIds.add(rewriteIdAcrossModule(id, this.modulePathPrefix));
+    }
+  }
+  normalizePath(filePath) {
+    return filePath.replace(/\\/g, "/");
+  }
+  buildPathRewriter() {
+    if (!this.modulePathPrefix) return (p) => p;
+    const prefix = this.modulePathPrefix;
+    return (p) => `${prefix}/${p}`;
+  }
+};
+function rewriteId(id, analyzerFile, projectFile) {
+  if (analyzerFile === projectFile) return id;
+  return id.startsWith(`${analyzerFile}::`) ? `${projectFile}${id.slice(analyzerFile.length)}` : id;
+}
+function rewriteIdAcrossModule(id, prefix) {
+  if (!prefix) return id;
+  const sepIdx = id.indexOf("::");
+  if (sepIdx <= 0) return id;
+  return `${prefix}/${id}`;
+}
+
 // src/go-adapter.ts
 import GoLanguage from "tree-sitter-go";
 
@@ -49,6 +466,7 @@ var TreeSitterAdapter = class {
 };
 
 // src/go-adapter.ts
+var log6 = createLogger("ctxo:lang-go");
 var GO_BRANCH_TYPES = [
   "if_statement",
   "for_statement",
@@ -72,7 +490,7 @@ var GoAdapter = class extends TreeSitterAdapter {
         const node = tree.rootNode.child(i);
         if (node.type === "function_declaration") {
           const name = node.childForFieldName("name")?.text;
-          if (!name || !this.isExported(name)) continue;
+          if (!name) continue;
           const range = this.nodeToLineRange(node);
           symbols.push({
             symbolId: this.buildSymbolId(filePath, name, "function"),
@@ -83,7 +501,7 @@ var GoAdapter = class extends TreeSitterAdapter {
         }
         if (node.type === "method_declaration") {
           const methodName = node.childForFieldName("name")?.text;
-          if (!methodName || !this.isExported(methodName)) continue;
+          if (!methodName) continue;
           const receiverType = this.extractReceiverType(node);
           const qualifiedName = receiverType ? `${receiverType}.${methodName}` : methodName;
           const range = this.nodeToLineRange(node);
@@ -100,7 +518,7 @@ var GoAdapter = class extends TreeSitterAdapter {
       }
       return symbols;
     } catch (err) {
-      console.error(`[ctxo:go] Symbol extraction failed for ${filePath}: ${err.message}`);
+      log6.error(`Symbol extraction failed for ${filePath}: ${err.message}`);
       return [];
     }
   }
@@ -118,7 +536,7 @@ var GoAdapter = class extends TreeSitterAdapter {
       }
       return edges;
     } catch (err) {
-      console.error(`[ctxo:go] Edge extraction failed for ${filePath}: ${err.message}`);
+      log6.error(`Edge extraction failed for ${filePath}: ${err.message}`);
       return [];
     }
   }
@@ -130,7 +548,7 @@ var GoAdapter = class extends TreeSitterAdapter {
         const node = tree.rootNode.child(i);
         if (node.type === "function_declaration") {
           const name = node.childForFieldName("name")?.text;
-          if (!name || !this.isExported(name)) continue;
+          if (!name) continue;
           metrics.push({
             symbolId: this.buildSymbolId(filePath, name, "function"),
             cyclomatic: this.countCyclomaticComplexity(node, GO_BRANCH_TYPES)
@@ -138,7 +556,7 @@ var GoAdapter = class extends TreeSitterAdapter {
         }
         if (node.type === "method_declaration") {
           const methodName = node.childForFieldName("name")?.text;
-          if (!methodName || !this.isExported(methodName)) continue;
+          if (!methodName) continue;
           const receiverType = this.extractReceiverType(node);
           const qualifiedName = receiverType ? `${receiverType}.${methodName}` : methodName;
           metrics.push({
@@ -149,7 +567,7 @@ var GoAdapter = class extends TreeSitterAdapter {
       }
       return metrics;
     } catch (err) {
-      console.error(`[ctxo:go] Complexity extraction failed for ${filePath}: ${err.message}`);
+      log6.error(`Complexity extraction failed for ${filePath}: ${err.message}`);
       return [];
     }
   }
@@ -235,22 +653,76 @@ var GoAdapter = class extends TreeSitterAdapter {
   }
 };
 
+// src/composite-adapter.ts
+var log7 = createLogger("ctxo:lang-go");
+var GoCompositeAdapter = class {
+  analyzer = null;
+  treeSitter;
+  constructor() {
+    this.treeSitter = new GoAdapter();
+  }
+  async initialize(rootDir) {
+    try {
+      const analyzer = new GoAnalyzerAdapter();
+      await analyzer.initialize(rootDir);
+      if (analyzer.isReady()) {
+        this.analyzer = analyzer;
+        log7.info("Go plugin: ctxo-go-analyzer full-tier active");
+        return;
+      }
+      await analyzer.dispose();
+    } catch (err) {
+      log7.warn(`Go analyzer unavailable: ${err.message}`);
+    }
+    log7.info("Go plugin: tree-sitter syntax-tier active (install Go 1.22+ for full tier)");
+  }
+  async dispose() {
+    if (this.analyzer) await this.analyzer.dispose();
+  }
+  extractSymbols(filePath, source) {
+    return (this.analyzer ?? this.treeSitter).extractSymbols(filePath, source);
+  }
+  extractEdges(filePath, source) {
+    return (this.analyzer ?? this.treeSitter).extractEdges(filePath, source);
+  }
+  extractComplexity(filePath, source) {
+    return this.treeSitter.extractComplexity(filePath, source);
+  }
+  isSupported(filePath) {
+    return filePath.toLowerCase().endsWith(".go");
+  }
+  setSymbolRegistry(registry) {
+    this.treeSitter.setSymbolRegistry?.(registry);
+  }
+  /** Exposed for cli optimizations. Null when running in syntax tier. */
+  getAnalyzerDelegate() {
+    return this.analyzer;
+  }
+  getTier() {
+    if (this.analyzer) return "full";
+    if (this.treeSitter) return "syntax";
+    return "unavailable";
+  }
+};
+
 // src/index.ts
-var VERSION = "0.7.0-alpha.0";
+var VERSION = "0.8.0-alpha.0";
 var plugin = {
   apiVersion: "1",
   id: "go",
-  name: "Go (tree-sitter)",
+  name: "Go (ctxo-go-analyzer + tree-sitter)",
   version: VERSION,
   extensions: [".go"],
-  tier: "syntax",
+  tier: "full",
   createAdapter(_ctx) {
-    return new GoAdapter();
+    return new GoCompositeAdapter();
   }
 };
 var index_default = plugin;
 export {
   GoAdapter,
+  GoAnalyzerAdapter,
+  GoCompositeAdapter,
   TreeSitterAdapter,
   index_default as default,
   plugin