@documentation-robotics/cli 0.1.0 → 0.1.7

package/dist/analyzers/registry.js

@@ -0,0 +1,124 @@
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import { CLIError, ErrorCategory } from "../utils/errors.js";
+import { CbmAnalyzer } from "./cbm-analyzer.js";
+import { MappingLoader } from "./mapping-loader.js";
+const ANALYZER_CLASSES = {
+  cbm: CbmAnalyzer
+};
+class AnalyzerRegistry {
+  static instance = null;
+  manifest = null;
+  mappers = /* @__PURE__ */ new Map();
+  analyzers = /* @__PURE__ */ new Map();
+  /**
+   * Get the singleton registry instance
+   */
+  static getInstance() {
+    return AnalyzerRegistry.instance || (AnalyzerRegistry.instance = new AnalyzerRegistry()), AnalyzerRegistry.instance;
+  }
+  /**
+   * Reset the registry singleton for testing
+   *
+   * This method clears the singleton instance and all cached state.
+   * Use this in test teardown to ensure a clean registry for each test.
+   *
+   * @internal For testing only
+   */
+  static resetForTesting() {
+    AnalyzerRegistry.instance = null;
+  }
+  constructor() {
+  }
+  /**
+   * Initialize the registry by loading the manifest
+   *
+   * @throws CLIError if manifest is missing or malformed
+   */
+  async initialize() {
+    this.manifest || await this.loadManifest();
+  }
+  /**
+   * Load the analyzer manifest from bundled schemas
+   *
+   * @private
+   * @throws CLIError if manifest is missing or malformed
+   */
+  async loadManifest() {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url)), manifestPath = path.join(currentDir, "../schemas/bundled/analyzers/manifest.json");
+    let content;
+    try {
+      const fileContent = await fs.readFile(manifestPath, "utf-8");
+      content = JSON.parse(fileContent);
+    } catch (error) {
+      const message = error instanceof Error && "code" in error && error.code === "ENOENT" ? `Analyzer manifest not found: ${manifestPath}` : `Failed to read analyzer manifest: ${error instanceof Error ? error.message : String(error)}`;
+      throw new CLIError(message, ErrorCategory.NOT_FOUND, [
+        "Run `npm run build:spec` to compile the analyzer artifacts",
+        "Check that spec/analyzers/ sources exist"
+      ]);
+    }
+    if (!content || typeof content != "object")
+      throw new CLIError("Invalid analyzer manifest structure: expected object", ErrorCategory.VALIDATION, ["Run `npm run build:spec` to recompile the analyzer artifacts"]);
+    const obj = content;
+    if (!Array.isArray(obj.analyzers))
+      throw new CLIError("Invalid analyzer manifest: analyzers must be an array", ErrorCategory.VALIDATION, ["Run `npm run build:spec` to recompile the analyzer artifacts"]);
+    if (typeof obj.specVersion != "string")
+      throw new CLIError("Invalid analyzer manifest: specVersion must be a string", ErrorCategory.VALIDATION, ["Run `npm run build:spec` to recompile the analyzer artifacts"]);
+    this.manifest = {
+      specVersion: obj.specVersion,
+      analyzers: obj.analyzers
+    };
+  }
+  /**
+   * Get an analyzer by name
+   *
+   * @param name Analyzer name (e.g., "cbm")
+   * @returns AnalyzerBackend instance, or undefined if not found
+   * @throws CLIError if manifest is not initialized or mapping cannot be loaded
+   */
+  async getAnalyzer(name) {
+    if (await this.initialize(), this.analyzers.has(name))
+      return this.analyzers.get(name);
+    if (!this.manifest.analyzers.find((a) => a.name === name))
+      return;
+    let mapper = this.mappers.get(name);
+    mapper || (mapper = await MappingLoader.load(name), this.mappers.set(name, mapper));
+    const AnalyzerClass = ANALYZER_CLASSES[name];
+    if (!AnalyzerClass)
+      throw new CLIError(`Unknown analyzer: ${name}`, ErrorCategory.NOT_FOUND, [
+        "Check the analyzer name is spelled correctly",
+        "Ensure the analyzer class is registered in ANALYZER_CLASSES in registry.ts",
+        "Use getAnalyzerNames() to list available analyzers"
+      ]);
+    const analyzer = new AnalyzerClass(mapper);
+    return this.analyzers.set(name, analyzer), analyzer;
+  }
+  /**
+   * Get all available analyzers
+   *
+   * @returns Array of all analyzer instances
+   * @throws CLIError if manifest is not initialized or mapping cannot be loaded
+   */
+  async getAllAnalyzers() {
+    const names = await this.getAnalyzerNames(), analyzers = [];
+    for (const name of names) {
+      const analyzer = await this.getAnalyzer(name);
+      analyzer && analyzers.push(analyzer);
+    }
+    return analyzers;
+  }
+  /**
+   * Get all available analyzer names
+   *
+   * @returns Array of analyzer names
+   * @throws CLIError if manifest cannot be loaded
+   */
+  async getAnalyzerNames() {
+    return await this.initialize(), this.manifest.analyzers.map((a) => a.name);
+  }
+}
+export {
+  AnalyzerRegistry
+};
+//# sourceMappingURL=registry.js.map

package/dist/analyzers/registry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/analyzers/registry.ts"],
+  "sourcesContent": ["/**\n * Analyzer Registry\n *\n * Reads the analyzer manifest from bundled schemas and constructs analyzer instances.\n * The registry maps analyzer names to their backend implementations and metadata.\n *\n * To add a new analyzer:\n * 1. Create a new class implementing AnalyzerBackend (e.g., NewAnalyzer)\n * 2. Create analyzer definition in spec/analyzers/{name}/analyzer.json\n * 3. Add mapping for the new analyzer class in the ANALYZER_CLASSES map below\n * 4. Run `npm run build:spec` to compile the analyzer artifacts\n * 5. Run `npm run build` in the cli/ directory to sync bundled schemas\n */\n\nimport fs from \"fs/promises\";\nimport path from \"path\";\nimport { fileURLToPath } from \"url\";\nimport { CLIError, ErrorCategory } from \"../utils/errors.js\";\nimport type { AnalyzerBackend } from \"./base-analyzer.js\";\nimport { CbmAnalyzer } from \"./cbm-analyzer.js\";\nimport { MappingLoader } from \"./mapping-loader.js\";\n\n/**\n * Type for analyzer class constructor\n */\ntype AnalyzerConstructor = new (mapper: MappingLoader) => AnalyzerBackend;\n\n/**\n * Mapping of analyzer names to their class implementations\n *\n * Add entries here when implementing a new analyzer.\n * The manifest (spec/dist/analyzers/manifest.json) defines which analyzers are available,\n * and this map provides the runtime bindings to construct instances.\n */\nconst ANALYZER_CLASSES: Record<string, AnalyzerConstructor> = {\n  cbm: CbmAnalyzer,\n};\n\n/**\n * Analyzer metadata from manifest\n */\ninterface AnalyzerMetadata {\n  name: string;\n  version: string;\n}\n\n/**\n * Analyzer registry manifest structure\n */\ninterface RegistryManifest {\n  specVersion: string;\n  analyzers: AnalyzerMetadata[];\n}\n\n/**\n * Analyzer Registry - constructs and manages analyzer instances\n */\nexport class AnalyzerRegistry {\n  private static instance: AnalyzerRegistry | null = null;\n  private manifest: RegistryManifest | null = null;\n  private mappers: Map<string, MappingLoader> = new Map();\n  private analyzers: Map<string, AnalyzerBackend> = new Map();\n\n  /**\n   * Get the singleton registry instance\n   */\n  static getInstance(): AnalyzerRegistry {\n    if (!AnalyzerRegistry.instance) {\n      AnalyzerRegistry.instance = new AnalyzerRegistry();\n    }\n    return AnalyzerRegistry.instance;\n  }\n\n  /**\n   * Reset the registry singleton for testing\n   *\n   * This method clears the singleton instance and all cached state.\n   * Use this in test teardown to ensure a clean registry for each test.\n   *\n   * @internal For testing only\n   */\n  static resetForTesting(): void {\n    AnalyzerRegistry.instance = null;\n  }\n\n  private constructor() {}\n\n  /**\n   * Initialize the registry by loading the manifest\n   *\n   * @throws CLIError if manifest is missing or malformed\n   */\n  async initialize(): Promise<void> {\n    if (this.manifest) {\n      return; // Already initialized\n    }\n\n    await this.loadManifest();\n  }\n\n  /**\n   * Load the analyzer manifest from bundled schemas\n   *\n   * @private\n   * @throws CLIError if manifest is missing or malformed\n   */\n  private async loadManifest(): Promise<void> {\n    const currentDir = path.dirname(fileURLToPath(import.meta.url));\n    const manifestPath = path.join(\n      currentDir,\n      \"../schemas/bundled/analyzers/manifest.json\"\n    );\n\n    let content: unknown;\n    try {\n      const fileContent = await fs.readFile(manifestPath, \"utf-8\");\n      content = JSON.parse(fileContent);\n    } catch (error) {\n      const message =\n        error instanceof Error && \"code\" in error && (error as { code: string }).code === \"ENOENT\"\n          ? `Analyzer manifest not found: ${manifestPath}`\n          : `Failed to read analyzer manifest: ${error instanceof Error ? error.message : String(error)}`;\n\n      throw new CLIError(message, ErrorCategory.NOT_FOUND, [\n        \"Run `npm run build:spec` to compile the analyzer artifacts\",\n        \"Check that spec/analyzers/ sources exist\",\n      ]);\n    }\n\n    if (!content || typeof content !== \"object\") {\n      throw new CLIError(\n        \"Invalid analyzer manifest structure: expected object\",\n        ErrorCategory.VALIDATION,\n        [\"Run `npm run build:spec` to recompile the analyzer artifacts\"]\n      );\n    }\n\n    const obj = content as Record<string, unknown>;\n    if (!Array.isArray(obj.analyzers)) {\n      throw new CLIError(\n        \"Invalid analyzer manifest: analyzers must be an array\",\n        ErrorCategory.VALIDATION,\n        [\"Run `npm run build:spec` to recompile the analyzer artifacts\"]\n      );\n    }\n\n    if (typeof obj.specVersion !== \"string\") {\n      throw new CLIError(\n        \"Invalid analyzer manifest: specVersion must be a string\",\n        ErrorCategory.VALIDATION,\n        [\"Run `npm run build:spec` to recompile the analyzer artifacts\"]\n      );\n    }\n\n    this.manifest = {\n      specVersion: obj.specVersion,\n      analyzers: obj.analyzers as AnalyzerMetadata[],\n    };\n  }\n\n  /**\n   * Get an analyzer by name\n   *\n   * @param name Analyzer name (e.g., \"cbm\")\n   * @returns AnalyzerBackend instance, or undefined if not found\n   * @throws CLIError if manifest is not initialized or mapping cannot be loaded\n   */\n  async getAnalyzer(name: string): Promise<AnalyzerBackend | undefined> {\n    await this.initialize();\n\n    // Check cache first\n    if (this.analyzers.has(name)) {\n      return this.analyzers.get(name);\n    }\n\n    // Check if analyzer exists in manifest\n    const metadata = this.manifest!.analyzers.find((a) => a.name === name);\n    if (!metadata) {\n      return undefined;\n    }\n\n    // Load the mapping\n    let mapper = this.mappers.get(name);\n    if (!mapper) {\n      mapper = await MappingLoader.load(name);\n      this.mappers.set(name, mapper);\n    }\n\n    // Construct the appropriate analyzer instance using the class map\n    const AnalyzerClass = ANALYZER_CLASSES[name];\n    if (!AnalyzerClass) {\n      throw new CLIError(\n        `Unknown analyzer: ${name}`,\n        ErrorCategory.NOT_FOUND,\n        [\n          \"Check the analyzer name is spelled correctly\",\n          \"Ensure the analyzer class is registered in ANALYZER_CLASSES in registry.ts\",\n          \"Use getAnalyzerNames() to list available analyzers\",\n        ]\n      );\n    }\n\n    const analyzer = new AnalyzerClass(mapper);\n    this.analyzers.set(name, analyzer);\n    return analyzer;\n  }\n\n  /**\n   * Get all available analyzers\n   *\n   * @returns Array of all analyzer instances\n   * @throws CLIError if manifest is not initialized or mapping cannot be loaded\n   */\n  async getAllAnalyzers(): Promise<AnalyzerBackend[]> {\n    const names = await this.getAnalyzerNames();\n    const analyzers: AnalyzerBackend[] = [];\n\n    for (const name of names) {\n      const analyzer = await this.getAnalyzer(name);\n      if (analyzer) {\n        analyzers.push(analyzer);\n      }\n    }\n\n    return analyzers;\n  }\n\n  /**\n   * Get all available analyzer names\n   *\n   * @returns Array of analyzer names\n   * @throws CLIError if manifest cannot be loaded\n   */\n  async getAnalyzerNames(): Promise<string[]> {\n    await this.initialize();\n\n    return this.manifest!.analyzers.map((a) => a.name);\n  }\n}\n"],
+  "mappings": "AAcA,OAAO,QAAQ;AACf,OAAO,UAAU;AACjB,SAAS,qBAAqB;AAC9B,SAAS,UAAU,qBAAqB;AAExC,SAAS,mBAAmB;AAC5B,SAAS,qBAAqB;AAc9B,MAAM,mBAAwD;EAC5D,KAAK;;AAsBD,MAAO,iBAAgB;EACnB,OAAO,WAAoC;EAC3C,WAAoC;EACpC,UAAsC,oBAAI,IAAG;EAC7C,YAA0C,oBAAI,IAAG;;;;EAKzD,OAAO,cAAW;AAChB,WAAK,iBAAiB,aACpB,iBAAiB,WAAW,IAAI,iBAAgB,IAE3C,iBAAiB;EAC1B;;;;;;;;;EAUA,OAAO,kBAAe;AACpB,qBAAiB,WAAW;EAC9B;EAEA,cAAA;EAAuB;;;;;;EAOvB,MAAM,aAAU;AACd,IAAI,KAAK,YAIT,MAAM,KAAK,aAAY;EACzB;;;;;;;EAQQ,MAAM,eAAY;AACxB,UAAM,aAAa,KAAK,QAAQ,cAAc,YAAY,GAAG,CAAC,GACxD,eAAe,KAAK,KACxB,YACA,4CAA4C;AAG9C,QAAI;AACJ,QAAI;AACF,YAAM,cAAc,MAAM,GAAG,SAAS,cAAc,OAAO;AAC3D,gBAAU,KAAK,MAAM,WAAW;IAClC,SAAS,OAAO;AACd,YAAM,UACJ,iBAAiB,SAAS,UAAU,SAAU,MAA2B,SAAS,WAC9E,gCAAgC,YAAY,KAC5C,qCAAqC,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC;AAEjG,YAAM,IAAI,SAAS,SAAS,cAAc,WAAW;QACnD;QACA;OACD;IACH;AAEA,QAAI,CAAC,WAAW,OAAO,WAAY;AACjC,YAAM,IAAI,SACR,wDACA,cAAc,YACd,CAAC,8DAA8D,CAAC;AAIpE,UAAM,MAAM;AACZ,QAAI,CAAC,MAAM,QAAQ,IAAI,SAAS;AAC9B,YAAM,IAAI,SACR,yDACA,cAAc,YACd,CAAC,8DAA8D,CAAC;AAIpE,QAAI,OAAO,IAAI,eAAgB;AAC7B,YAAM,IAAI,SACR,2DACA,cAAc,YACd,CAAC,8DAA8D,CAAC;AAIpE,SAAK,WAAW;MACd,aAAa,IAAI;MACjB,WAAW,IAAI;;EAEnB;;;;;;;;EASA,MAAM,YAAY,MAAY;AAI5B,QAHA,MAAM,KAAK,WAAU,GAGjB,KAAK,UAAU,IAAI,IAAI;AACzB,aAAO,KAAK,UAAU,IAAI,IAAI;AAKhC,QAAI,CADa,KAAK,SAAU,UAAU,KAAK,CAAC,MAAM,EAAE,SAAS,IAAI;AAEnE;AAIF,QAAI,SAAS,KAAK,QAAQ,IAAI,IAAI;AAClC,IAAK,WACH,SAAS,MAAM,cAAc,KAAK,IAAI,GACtC,KAAK,QAAQ,IAAI,MAAM,MAAM;AAI/B,UAAM,gBAAgB,iBAAiB,IAAI;AAC3C,QAAI,CAAC;AACH,YAAM,IAAI,SACR,qBAAqB,IAAI,IACzB,cAAc,WACd;QACE;QACA;QACA;OACD;AAIL,UAAM,WAAW,IAAI,cAAc,MAAM;AACzC,gBAAK,UAAU,IAAI,MAAM,QAAQ,GAC1B;EACT;;;;;;;EAQA,MAAM,kBAAe;AACnB,UAAM,QAAQ,MAAM,KAAK,iBAAgB,GACnC,YAA+B,CAAA;AAErC,eAAW,QAAQ,OAAO;AACxB,YAAM,WAAW,MAAM,KAAK,YAAY,IAAI;AAC5C,MAAI,YACF,UAAU,KAAK,QAAQ;IAE3B;AAEA,WAAO;EACT;;;;;;;EAQA,MAAM,mBAAgB;AACpB,iBAAM,KAAK,WAAU,GAEd,KAAK,SAAU,UAAU,IAAI,CAAC,MAAM,EAAE,IAAI;EACnD;;",
+  "names": []
+}

package/dist/analyzers/session-state.js

@@ -0,0 +1,176 @@
+import { promises as fs } from "fs";
+import * as path from "path";
+function validateAnalyzerName(analyzerName) {
+  if (!analyzerName)
+    throw new Error("Analyzer name cannot be empty");
+  if (analyzerName.includes("/") || analyzerName.includes("\\"))
+    throw new Error("Analyzer name cannot contain path separators (/ or \\)");
+  if (analyzerName.includes(".."))
+    throw new Error("Analyzer name cannot contain parent directory references (..)");
+}
+function validateSessionState(data) {
+  if (!data || typeof data != "object")
+    throw new Error("SessionState must be an object");
+  const obj = data;
+  if (typeof obj.active_analyzer != "string")
+    throw new Error("SessionState.active_analyzer must be a string");
+  if (typeof obj.selected_at != "string")
+    throw new Error("SessionState.selected_at must be a string");
+  return {
+    active_analyzer: obj.active_analyzer,
+    selected_at: obj.selected_at
+  };
+}
+function validateIndexMeta(data) {
+  if (!data || typeof data != "object")
+    throw new Error("IndexMeta must be an object");
+  const obj = data;
+  if (typeof obj.git_head != "string")
+    throw new Error("IndexMeta.git_head must be a string");
+  if (typeof obj.timestamp != "string")
+    throw new Error("IndexMeta.timestamp must be a string");
+  if (typeof obj.node_count != "number")
+    throw new Error("IndexMeta.node_count must be a number");
+  if (typeof obj.edge_count != "number")
+    throw new Error("IndexMeta.edge_count must be a number");
+  return {
+    git_head: obj.git_head,
+    timestamp: obj.timestamp,
+    node_count: obj.node_count,
+    edge_count: obj.edge_count
+  };
+}
+function validateAnalyzerStatus(data) {
+  if (!data || typeof data != "object")
+    throw new Error("AnalyzerStatus must be an object");
+  const obj = data;
+  if (!obj.detected || typeof obj.detected != "object")
+    throw new Error("AnalyzerStatus.detected must be an object");
+  const detected = obj.detected;
+  if (typeof detected.installed != "boolean")
+    throw new Error("AnalyzerStatus.detected.installed must be a boolean");
+  const installed = detected.installed;
+  if (installed) {
+    if (typeof detected.binary_path != "string")
+      throw new Error("AnalyzerStatus.detected.binary_path must be a string when installed: true");
+    if (detected.version !== void 0 && typeof detected.version != "string")
+      throw new Error("AnalyzerStatus.detected.version must be a string");
+    if (detected.mcp_registered !== void 0 && typeof detected.mcp_registered != "boolean")
+      throw new Error("AnalyzerStatus.detected.mcp_registered must be a boolean");
+    if (detected.contract_ok !== void 0 && typeof detected.contract_ok != "boolean")
+      throw new Error("AnalyzerStatus.detected.contract_ok must be a boolean");
+  } else if (detected.binary_path !== void 0)
+    throw new Error("AnalyzerStatus.detected.binary_path must not be present when installed: false");
+  if (typeof obj.indexed != "boolean")
+    throw new Error("AnalyzerStatus.indexed must be a boolean");
+  if (typeof obj.fresh != "boolean")
+    throw new Error("AnalyzerStatus.fresh must be a boolean");
+  if (obj.indexed) {
+    if (obj.index_meta === void 0)
+      throw new Error("AnalyzerStatus.index_meta must be present when indexed: true");
+    const validatedIndexMeta = validateIndexMeta(obj.index_meta);
+    if (obj.last_indexed !== void 0 && typeof obj.last_indexed != "string")
+      throw new Error("AnalyzerStatus.last_indexed must be a string");
+    return {
+      detected: installed ? {
+        installed: !0,
+        binary_path: detected.binary_path,
+        version: detected.version,
+        mcp_registered: detected.mcp_registered,
+        contract_ok: detected.contract_ok
+      } : {
+        installed: !1
+      },
+      indexed: !0,
+      index_meta: validatedIndexMeta,
+      fresh: obj.fresh,
+      last_indexed: obj.last_indexed
+    };
+  } else {
+    if (obj.index_meta !== void 0)
+      throw new Error("AnalyzerStatus.index_meta must not be present when indexed: false");
+    if (obj.last_indexed !== void 0 && typeof obj.last_indexed != "string")
+      throw new Error("AnalyzerStatus.last_indexed must be a string");
+    return {
+      detected: installed ? {
+        installed: !0,
+        binary_path: detected.binary_path,
+        version: detected.version,
+        mcp_registered: detected.mcp_registered,
+        contract_ok: detected.contract_ok
+      } : {
+        installed: !1
+      },
+      indexed: !1,
+      fresh: obj.fresh,
+      last_indexed: obj.last_indexed
+    };
+  }
+}
+function getStateDir(baseDir, analyzerName) {
+  const base = baseDir ?? process.cwd(), analyzersDir = path.join(base, ".dr", "analyzers");
+  return analyzerName !== void 0 ? (validateAnalyzerName(analyzerName), path.join(analyzersDir, analyzerName)) : analyzersDir;
+}
+async function ensureStateDir(baseDir, analyzerName) {
+  await fs.mkdir(getStateDir(baseDir, analyzerName), { recursive: !0 });
+}
+function getStatePath(filename, baseDir, analyzerName) {
+  return path.join(getStateDir(baseDir, analyzerName), filename);
+}
+async function readSession(baseDir) {
+  const filePath = getStatePath("session.json", baseDir);
+  try {
+    const content = await fs.readFile(filePath, "utf-8"), parsed = JSON.parse(content);
+    return validateSessionState(parsed);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+async function writeSession(state, baseDir) {
+  await ensureStateDir(baseDir);
+  const filePath = getStatePath("session.json", baseDir), content = JSON.stringify(state, null, 2);
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function readIndexMeta(baseDir, analyzerName) {
+  const filePath = getStatePath("index-meta.json", baseDir, analyzerName);
+  try {
+    const content = await fs.readFile(filePath, "utf-8"), parsed = JSON.parse(content);
+    return validateIndexMeta(parsed);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+async function writeIndexMeta(meta, baseDir, analyzerName) {
+  await ensureStateDir(baseDir, analyzerName);
+  const filePath = getStatePath("index-meta.json", baseDir, analyzerName), content = JSON.stringify(meta, null, 2);
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function readStatus(baseDir, analyzerName) {
+  const filePath = getStatePath("status.json", baseDir, analyzerName);
+  try {
+    const content = await fs.readFile(filePath, "utf-8"), parsed = JSON.parse(content);
+    return validateAnalyzerStatus(parsed);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+async function writeStatus(status, baseDir, analyzerName) {
+  await ensureStateDir(baseDir, analyzerName);
+  const filePath = getStatePath("status.json", baseDir, analyzerName), content = JSON.stringify(status, null, 2);
+  await fs.writeFile(filePath, content, "utf-8");
+}
+export {
+  readIndexMeta,
+  readSession,
+  readStatus,
+  writeIndexMeta,
+  writeSession,
+  writeStatus
+};
+//# sourceMappingURL=session-state.js.map

package/dist/analyzers/session-state.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/analyzers/session-state.ts"],
+  "sourcesContent": ["/**\n * Session state and metadata persistence\n *\n * Provides file-based storage for analyzer session state, index metadata,\n * and analyzer status information in `.dr/analyzers/` directory.\n *\n * Per-analyzer files (index-meta.json, status.json) are stored in subdirectories:\n * - `.dr/analyzers/{analyzerName}/index-meta.json`\n * - `.dr/analyzers/{analyzerName}/status.json`\n *\n * Global files (session.json) are stored at the base level:\n * - `.dr/analyzers/session.json`\n *\n * All operations are async and use JSON for serialization.\n * Missing files gracefully return null rather than throwing errors.\n * Read operations validate JSON structure and throw errors for corrupted files.\n */\n\nimport { promises as fs } from \"fs\";\nimport * as path from \"path\";\nimport type { SessionState, IndexMeta, AnalyzerStatus } from \"./types.js\";\n\n/**\n * Validate analyzer name to prevent path traversal attacks\n * Rejects names containing `/`, `\\`, or `..`\n *\n * @param analyzerName Analyzer name to validate\n * @throws Error if name contains path traversal characters\n */\nfunction validateAnalyzerName(analyzerName: string): void {\n  if (!analyzerName) {\n    throw new Error(\"Analyzer name cannot be empty\");\n  }\n\n  if (analyzerName.includes(\"/\") || analyzerName.includes(\"\\\\\")) {\n    throw new Error(\"Analyzer name cannot contain path separators (/ or \\\\)\");\n  }\n\n  if (analyzerName.includes(\"..\")) {\n    throw new Error(\"Analyzer name cannot contain parent directory references (..)\");\n  }\n}\n\n/**\n * Validate SessionState structure\n * @throws Error if data is missing required fields\n */\nfunction validateSessionState(data: unknown): SessionState {\n  if (!data || typeof data !== \"object\") {\n    throw new Error(\"SessionState must be an object\");\n  }\n\n  const obj = data as Record<string, unknown>;\n\n  if (typeof obj.active_analyzer !== \"string\") {\n    throw new Error(\"SessionState.active_analyzer must be a string\");\n  }\n\n  if (typeof obj.selected_at !== \"string\") {\n    throw new Error(\"SessionState.selected_at must be a string\");\n  }\n\n  return {\n    active_analyzer: obj.active_analyzer,\n    selected_at: obj.selected_at,\n  };\n}\n\n/**\n * Validate IndexMeta structure\n * @throws Error if data is missing required fields\n */\nfunction validateIndexMeta(data: unknown): IndexMeta {\n  if (!data || typeof data !== \"object\") {\n    throw new Error(\"IndexMeta must be an object\");\n  }\n\n  const obj = data as Record<string, unknown>;\n\n  if (typeof obj.git_head !== \"string\") {\n    throw new Error(\"IndexMeta.git_head must be a string\");\n  }\n\n  if (typeof obj.timestamp !== \"string\") {\n    throw new Error(\"IndexMeta.timestamp must be a string\");\n  }\n\n  if (typeof obj.node_count !== \"number\") {\n    throw new Error(\"IndexMeta.node_count must be a number\");\n  }\n\n  if (typeof obj.edge_count !== \"number\") {\n    throw new Error(\"IndexMeta.edge_count must be a number\");\n  }\n\n  return {\n    git_head: obj.git_head,\n    timestamp: obj.timestamp,\n    node_count: obj.node_count as number,\n    edge_count: obj.edge_count as number,\n  };\n}\n\n/**\n * Validate AnalyzerStatus structure\n * Enforces discriminated union constraints:\n * - When installed: true, binary_path must be present\n * - When installed: false, binary_path must not be present\n * - When indexed: true, index_meta must be present\n * - When indexed: false, index_meta must not be present\n *\n * @throws Error if data is missing required fields or violates discriminated union constraints\n */\nfunction validateAnalyzerStatus(data: unknown): AnalyzerStatus {\n  if (!data || typeof data !== \"object\") {\n    throw new Error(\"AnalyzerStatus must be an object\");\n  }\n\n  const obj = data as Record<string, unknown>;\n\n  if (!obj.detected || typeof obj.detected !== \"object\") {\n    throw new Error(\"AnalyzerStatus.detected must be an object\");\n  }\n\n  const detected = obj.detected as Record<string, unknown>;\n  if (typeof detected.installed !== \"boolean\") {\n    throw new Error(\"AnalyzerStatus.detected.installed must be a boolean\");\n  }\n\n  // Validate DetectionResult discriminated union\n  const installed = detected.installed as boolean;\n\n  if (installed) {\n    // When installed: true, binary_path is required\n    if (typeof detected.binary_path !== \"string\") {\n      throw new Error(\"AnalyzerStatus.detected.binary_path must be a string when installed: true\");\n    }\n\n    // Validate optional fields\n    if (detected.version !== undefined && typeof detected.version !== \"string\") {\n      throw new Error(\"AnalyzerStatus.detected.version must be a string\");\n    }\n\n    if (detected.mcp_registered !== undefined && typeof detected.mcp_registered !== \"boolean\") {\n      throw new Error(\"AnalyzerStatus.detected.mcp_registered must be a boolean\");\n    }\n\n    if (detected.contract_ok !== undefined && typeof detected.contract_ok !== \"boolean\") {\n      throw new Error(\"AnalyzerStatus.detected.contract_ok must be a boolean\");\n    }\n  } else {\n    // When installed: false, binary_path must not be present\n    if (detected.binary_path !== undefined) {\n      throw new Error(\"AnalyzerStatus.detected.binary_path must not be present when installed: false\");\n    }\n  }\n\n  if (typeof obj.indexed !== \"boolean\") {\n    throw new Error(\"AnalyzerStatus.indexed must be a boolean\");\n  }\n\n  if (typeof obj.fresh !== \"boolean\") {\n    throw new Error(\"AnalyzerStatus.fresh must be a boolean\");\n  }\n\n  // Validate AnalyzerStatus discriminated union\n  const indexed = obj.indexed as boolean;\n  if (indexed) {\n    // When indexed: true, index_meta is required\n    if (obj.index_meta === undefined) {\n      throw new Error(\"AnalyzerStatus.index_meta must be present when indexed: true\");\n    }\n    const validatedIndexMeta = validateIndexMeta(obj.index_meta);\n\n    // Validate optional last_indexed if present\n    if (obj.last_indexed !== undefined && typeof obj.last_indexed !== \"string\") {\n      throw new Error(\"AnalyzerStatus.last_indexed must be a string\");\n    }\n\n    // Build detected from validated detection data based on installed flag\n    const detectedResult = installed\n      ? {\n          installed: true,\n          binary_path: detected.binary_path as string,\n          version: detected.version as string | undefined,\n          mcp_registered: detected.mcp_registered as boolean | undefined,\n          contract_ok: detected.contract_ok as boolean | undefined,\n        }\n      : {\n          installed: false,\n        };\n\n    return {\n      detected: detectedResult,\n      indexed: true,\n      index_meta: validatedIndexMeta,\n      fresh: obj.fresh as boolean,\n      last_indexed: obj.last_indexed as string | undefined,\n    } as AnalyzerStatus;\n  } else {\n    // When indexed: false, index_meta must not be present\n    if (obj.index_meta !== undefined) {\n      throw new Error(\"AnalyzerStatus.index_meta must not be present when indexed: false\");\n    }\n\n    // Validate optional last_indexed if present\n    if (obj.last_indexed !== undefined && typeof obj.last_indexed !== \"string\") {\n      throw new Error(\"AnalyzerStatus.last_indexed must be a string\");\n    }\n\n    // Build detected from validated detection data based on installed flag\n    const detectedResult = installed\n      ? {\n          installed: true,\n          binary_path: detected.binary_path as string,\n          version: detected.version as string | undefined,\n          mcp_registered: detected.mcp_registered as boolean | undefined,\n          contract_ok: detected.contract_ok as boolean | undefined,\n        }\n      : {\n          installed: false,\n        };\n\n    return {\n      detected: detectedResult,\n      indexed: false,\n      fresh: obj.fresh as boolean,\n      last_indexed: obj.last_indexed as string | undefined,\n    } as AnalyzerStatus;\n  }\n}\n\n/**\n * Get the base directory for analyzer state files\n * Resolves to `.dr/analyzers/` (and optionally `{analyzerName}/` subdirectory)\n *\n * @param baseDir Optional base directory. Defaults to process.cwd()\n * @param analyzerName Optional analyzer name for per-analyzer subdirectory\n * @throws Error if analyzerName is provided but empty or contains path traversal characters\n */\nfunction getStateDir(baseDir?: string, analyzerName?: string): string {\n  const base = baseDir ?? process.cwd();\n  const analyzersDir = path.join(base, \".dr\", \"analyzers\");\n\n  if (analyzerName !== undefined) {\n    validateAnalyzerName(analyzerName);\n    return path.join(analyzersDir, analyzerName);\n  }\n\n  return analyzersDir;\n}\n\n/**\n * Ensure the state directory exists\n * Creates intermediate directories with recursive flag\n *\n * @param baseDir Optional base directory. Defaults to process.cwd()\n * @param analyzerName Optional analyzer name for per-analyzer subdirectory\n */\nasync function ensureStateDir(baseDir?: string, analyzerName?: string): Promise<void> {\n  await fs.mkdir(getStateDir(baseDir, analyzerName), { recursive: true });\n}\n\n/**\n * Get the full path to a state file\n *\n * @param filename Name of the state file\n * @param baseDir Optional base directory. Defaults to process.cwd()\n * @param analyzerName Optional analyzer name for per-analyzer subdirectory\n * @returns Full path to the file\n */\nfunction getStatePath(filename: string, baseDir?: string, analyzerName?: string): string {\n  return path.join(getStateDir(baseDir, analyzerName), filename);\n}\n\n/**\n * Read session state from `.dr/analyzers/session.json`\n *\n * @param baseDir Optional base directory. Defaults to process.cwd()\n * @returns Parsed and validated session state, or null if file does not exist\n * @throws Error if file exists but is malformed JSON or invalid structure\n */\nexport async function readSession(baseDir?: string): Promise<SessionState | null> {\n  const filePath = getStatePath(\"session.json\", baseDir);\n  try {\n    const content = await fs.readFile(filePath, \"utf-8\");\n    const parsed = JSON.parse(content);\n    return validateSessionState(parsed);\n  } catch (error) {\n    if (error instanceof Error && \"code\" in error && (error as NodeJS.ErrnoException).code === \"ENOENT\") {\n      return null;\n    }\n    throw error;\n  }\n}\n\n/**\n * Write session state to `.dr/analyzers/session.json`\n *\n * Creates the state directory if it does not exist.\n * Writes with pretty-printed JSON (2-space indentation).\n *\n * @param state Session state to persist\n * @param baseDir Optional base directory. Defaults to process.cwd()\n */\nexport async function writeSession(state: SessionState, baseDir?: string): Promise<void> {\n  await ensureStateDir(baseDir);\n  const filePath = getStatePath(\"session.json\", baseDir);\n  const content = JSON.stringify(state, null, 2);\n  await fs.writeFile(filePath, content, \"utf-8\");\n}\n\n/**\n * Read index metadata from `.dr/analyzers/{analyzerName}/index-meta.json`\n *\n * @param baseDir Optional base directory. Defaults to process.cwd()\n * @param analyzerName Analyzer name for per-analyzer subdirectory (required)\n * @returns Parsed and validated index metadata, or null if file does not exist\n * @throws Error if file exists but is malformed JSON or invalid structure\n */\nexport async function readIndexMeta(\n  baseDir: string | undefined,\n  analyzerName: string\n): Promise<IndexMeta | null> {\n  const filePath = getStatePath(\"index-meta.json\", baseDir, analyzerName);\n  try {\n    const content = await fs.readFile(filePath, \"utf-8\");\n    const parsed = JSON.parse(content);\n    return validateIndexMeta(parsed);\n  } catch (error) {\n    if (error instanceof Error && \"code\" in error && (error as NodeJS.ErrnoException).code === \"ENOENT\") {\n      return null;\n    }\n    throw error;\n  }\n}\n\n/**\n * Write index metadata to `.dr/analyzers/{analyzerName}/index-meta.json`\n *\n * Creates the state directory (including analyzer subdirectory) if it does not exist.\n * Writes with pretty-printed JSON (2-space indentation).\n *\n * @param meta Index metadata to persist\n * @param baseDir Optional base directory. Defaults to process.cwd()\n * @param analyzerName Analyzer name for per-analyzer subdirectory (required)\n */\nexport async function writeIndexMeta(\n  meta: IndexMeta,\n  baseDir: string | undefined,\n  analyzerName: string\n): Promise<void> {\n  await ensureStateDir(baseDir, analyzerName);\n  const filePath = getStatePath(\"index-meta.json\", baseDir, analyzerName);\n  const content = JSON.stringify(meta, null, 2);\n  await fs.writeFile(filePath, content, \"utf-8\");\n}\n\n/**\n * Read analyzer status from `.dr/analyzers/{analyzerName}/status.json`\n *\n * @param baseDir Optional base directory. Defaults to process.cwd()\n * @param analyzerName Analyzer name for per-analyzer subdirectory (required)\n * @returns Parsed and validated analyzer status, or null if file does not exist\n * @throws Error if file exists but is malformed JSON or invalid structure\n */\nexport async function readStatus(\n  baseDir: string | undefined,\n  analyzerName: string\n): Promise<AnalyzerStatus | null> {\n  const filePath = getStatePath(\"status.json\", baseDir, analyzerName);\n  try {\n    const content = await fs.readFile(filePath, \"utf-8\");\n    const parsed = JSON.parse(content);\n    return validateAnalyzerStatus(parsed);\n  } catch (error) {\n    if (error instanceof Error && \"code\" in error && (error as NodeJS.ErrnoException).code === \"ENOENT\") {\n      return null;\n    }\n    throw error;\n  }\n}\n\n/**\n * Write analyzer status to `.dr/analyzers/{analyzerName}/status.json`\n *\n * Creates the state directory (including analyzer subdirectory) if it does not exist.\n * Writes with pretty-printed JSON (2-space indentation).\n *\n * @param status Analyzer status to persist\n * @param baseDir Optional base directory. Defaults to process.cwd()\n * @param analyzerName Analyzer name for per-analyzer subdirectory (required)\n */\nexport async function writeStatus(\n  status: AnalyzerStatus,\n  baseDir: string | undefined,\n  analyzerName: string\n): Promise<void> {\n  await ensureStateDir(baseDir, analyzerName);\n  const filePath = getStatePath(\"status.json\", baseDir, analyzerName);\n  const content = JSON.stringify(status, null, 2);\n  await fs.writeFile(filePath, content, \"utf-8\");\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/analyzers/stdio-client.js

@@ -0,0 +1,208 @@
+import { spawn } from "child_process";
+class StdioClient {
+  proc = null;
+  requestId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  /**
+   * Spawn an analyzer process
+   *
+   * @param binaryPath Path to the analyzer binary
+   * @param args Optional command-line arguments (or env object for backwards compatibility)
+   * @param env Optional environment variables (merged with process.env)
+   * @throws Error if spawn fails
+   */
+  spawn(binaryPath, args, env) {
+    if (this.proc)
+      throw new Error("Process already spawned");
+    let actualArgs = [], actualEnv = process.env;
+    if (Array.isArray(args) ? (actualArgs = args, actualEnv = { ...actualEnv, ...env }) : args && typeof args == "object" && (actualEnv = { ...actualEnv, ...args }), this.proc = spawn(binaryPath, actualArgs, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: actualEnv
+    }), this.proc.stdout) {
+      this.proc.stdout.setEncoding("utf-8");
+      let buffer = "";
+      this.proc.stdout.on("data", (chunk) => {
+        buffer += chunk;
+        const lines = buffer.split(`
+`);
+        buffer = lines.pop() || "";
+        for (const line of lines)
+          if (line.trim())
+            try {
+              const message = JSON.parse(line);
+              this.handleMessage(message);
+            } catch {
+              const firstKey = this.pendingRequests.keys().next().value;
+              if (firstKey !== void 0) {
+                const pending = this.pendingRequests.get(firstKey);
+                pending && (clearTimeout(pending.timeout), this.pendingRequests.delete(firstKey), pending.reject(new Error(`Failed to parse JSON-RPC response from analyzer: ${line}`)));
+              } else
+                console.error(`Failed to parse JSON-RPC message from analyzer: ${line}`);
+            }
+      });
+    }
+    this.proc.stderr && (this.proc.stderr.setEncoding("utf-8"), this.proc.stderr.on("data", (chunk) => {
+      console.error(`[Analyzer stderr] ${chunk}`);
+    })), this.proc.on("exit", (code, signal) => {
+      this.proc = null;
+      for (const [, { reject, timeout }] of this.pendingRequests)
+        clearTimeout(timeout), reject(new Error(`Process exited with code ${code} (signal: ${signal})`));
+      this.pendingRequests.clear();
+    }), this.proc.on("error", (error) => {
+      for (const [, { reject, timeout }] of this.pendingRequests)
+        clearTimeout(timeout), reject(error);
+      this.pendingRequests.clear();
+    });
+  }
+  /**
+   * Initialize the analyzer with client information
+   *
+   * Sends an initialize request and waits for the response.
+   * Times out after 5 seconds if no response is received. Was 2 seconds,
+   * but that became too tight for slower analyzer binary cold starts
+   * (observed failing in CI against codebase-memory-mcp 0.10.x - see #802).
+   *
+   * @param clientInfo Client information object
+   * @throws Error if initialize times out or fails
+   */
+  async initialize(clientInfo) {
+    return this.callTool("initialize", clientInfo, { timeout: 5e3 });
+  }
+  /**
+   * Call a tool on the analyzer
+   *
+   * Sends a JSON-RPC request and waits for the response.
+   * Defaults to 30-second timeout for graph queries.
+   *
+   * @param name Tool name (method)
+   * @param params Tool parameters
+   * @param options Optional configuration (timeout in milliseconds)
+   * @returns Tool result
+   * @throws Error if tool call fails or times out
+   */
+  async callTool(name, params, options) {
+    if (!this.proc)
+      throw new Error("Process not spawned");
+    const timeout = options?.timeout ?? 3e4, id = ++this.requestId, request = {
+      jsonrpc: "2.0",
+      method: name,
+      params,
+      id
+    };
+    return new Promise((resolve, reject) => {
+      const timeoutHandle = setTimeout(() => {
+        this.pendingRequests.delete(id), reject(new Error(`Tool call '${name}' timed out after ${timeout}ms`));
+      }, timeout);
+      this.pendingRequests.set(id, { resolve, reject, timeout: timeoutHandle });
+      try {
+        const line = JSON.stringify(request) + `
+`;
+        if (!this.proc || !this.proc.stdin) {
+          clearTimeout(timeoutHandle), this.pendingRequests.delete(id), reject(new Error("Process or stdin closed before write could complete"));
+          return;
+        }
+        this.proc.stdin.write(line) || this.proc.stdin.once("drain", () => {
+        });
+      } catch (error) {
+        clearTimeout(timeoutHandle), this.pendingRequests.delete(id), reject(error);
+      }
+    });
+  }
+  /**
+   * Close the connection and clean up
+   *
+   * Sends a shutdown notification and terminates the process.
+   * Sends SIGTERM first, then escalates to SIGKILL after 1 second if needed.
+   * Cleans up all pending requests and event listeners.
+   */
+  /**
+   * Invoke a tool on the analyzer via the MCP tools/call protocol
+   *
+   * Sends a tools/call request with {name, arguments} and unwraps the
+   * MCP content envelope from the response (content[0].text parsed as JSON).
+   *
+   * Use this for all tool invocations. Use callTool() only for MCP protocol
+   * methods (initialize, tools/list).
+   *
+   * @param name Tool name (e.g., "search_graph", "index_repository")
+   * @param args Tool arguments to pass as the arguments field
+   * @param options Optional configuration (timeout in milliseconds)
+   * @returns Parsed tool result unwrapped from MCP content envelope
+   */
+  async invokeTool(name, args, options) {
+    const response = await this.callTool("tools/call", { name, arguments: args ?? {} }, options);
+    if (response?.content && Array.isArray(response.content) && response.content.length > 0) {
+      const first = response.content[0];
+      if (first.type === "text" && typeof first.text == "string")
+        try {
+          return JSON.parse(first.text);
+        } catch {
+          return first.text;
+        }
+    }
+    return response;
+  }
+  close() {
+    if (!this.proc)
+      return;
+    const procToClose = this.proc;
+    this.proc = null;
+    try {
+      const line = JSON.stringify({
+        jsonrpc: "2.0",
+        method: "shutdown"
+      }) + `
+`;
+      procToClose.stdin?.write(line);
+    } catch {
+    }
+    for (const [, { reject, timeout }] of this.pendingRequests)
+      clearTimeout(timeout), reject(new Error("Client closed"));
+    this.pendingRequests.clear(), procToClose.stdout && procToClose.stdout.removeAllListeners(), procToClose.stderr && procToClose.stderr.removeAllListeners(), procToClose.removeAllListeners();
+    try {
+      procToClose.stdin?.end(), procToClose.killed || (procToClose.kill("SIGTERM"), setTimeout(() => {
+        if (procToClose.exitCode === null)
+          try {
+            procToClose.kill("SIGKILL");
+          } catch {
+          }
+      }, 1e3).unref());
+    } catch {
+    }
+  }
+  /**
+   * Handle a JSON-RPC message from the analyzer
+   *
+   * Matches responses to pending requests by ID and resolves/rejects accordingly.
+   * Extracts error information from JSON-RPC error objects.
+   *
+   * @param message Parsed JSON-RPC message
+   */
+  handleMessage(message) {
+    if (!message || typeof message != "object")
+      return;
+    const msg = message;
+    if (!("id" in msg) || typeof msg.id != "number")
+      return;
+    const msgId = msg.id, pending = this.pendingRequests.get(msgId);
+    if (!pending) {
+      console.warn(`Received response with unmatched ID ${msgId} (type: ${typeof msgId}). Pending request IDs: [${Array.from(this.pendingRequests.keys()).join(", ")}]. This may indicate a type mismatch or stale response.`);
+      return;
+    }
+    const { resolve, reject, timeout } = pending;
+    if (clearTimeout(timeout), this.pendingRequests.delete(msgId), "error" in msg && msg.error !== null && typeof msg.error == "object") {
+      const error = msg.error, errMessage = error.message || "Unknown error", code = error.code ?? -1, data = error.data, errorMessage = data ? `${errMessage}: ${JSON.stringify(data)}` : errMessage;
+      reject(new Error(`[Error ${code}] ${errorMessage}`));
+      return;
+    }
+    if ("result" in msg) {
+      resolve(msg.result);
+      return;
+    }
+    reject(new Error("Invalid JSON-RPC response: no result or error field"));
+  }
+}
+export {
+  StdioClient
+};
+//# sourceMappingURL=stdio-client.js.map

package/dist/analyzers/stdio-client.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/analyzers/stdio-client.ts"],
+  "sourcesContent": ["/**\n * MCP JSON-RPC 2.0 stdio client\n *\n * Minimal implementation for communicating with analyzers via JSON-RPC over stdio.\n * Handles process spawning, request/response correlation, timeouts, and clean shutdown.\n *\n * Protocol: JSON-RPC 2.0 with line-delimited JSON framing.\n * - Each request/response is a complete JSON object on a single line\n * - Request IDs are integers for correlation\n * - Errors are extracted from JSON-RPC error response objects\n */\n\nimport { spawn, ChildProcess } from \"child_process\";\n\n/**\n * JSON-RPC 2.0 request structure\n */\ninterface JsonRpcRequest {\n  jsonrpc: \"2.0\";\n  method: string;\n  params?: unknown;\n  id: number;\n}\n\n/**\n * JSON-RPC notification (no id field)\n */\ninterface JsonRpcNotification {\n  jsonrpc: \"2.0\";\n  method: string;\n  params?: unknown;\n}\n\n/**\n * MCP client for communicating with analyzer backends via JSON-RPC 2.0 stdio\n */\nexport class StdioClient {\n  private proc: ChildProcess | null = null;\n  private requestId: number = 0;\n  private pendingRequests: Map<number, { resolve: (value: unknown) => void; reject: (reason: Error) => void; timeout: NodeJS.Timeout }> = new Map();\n\n  /**\n   * Spawn an analyzer process\n   *\n   * @param binaryPath Path to the analyzer binary\n   * @param args Optional command-line arguments (or env object for backwards compatibility)\n   * @param env Optional environment variables (merged with process.env)\n   * @throws Error if spawn fails\n   */\n  spawn(binaryPath: string, args?: string[] | Record<string, string>, env?: Record<string, string>): void {\n    if (this.proc) {\n      throw new Error(\"Process already spawned\");\n    }\n\n    // Handle backwards compatibility: if args is an object, treat it as env\n    let actualArgs: string[] = [];\n    let actualEnv = process.env as Record<string, string>;\n\n    if (Array.isArray(args)) {\n      actualArgs = args;\n      actualEnv = { ...actualEnv, ...env };\n    } else if (args && typeof args === \"object\") {\n      actualEnv = { ...actualEnv, ...args };\n    }\n\n    this.proc = spawn(binaryPath, actualArgs, {\n      stdio: [\"pipe\", \"pipe\", \"pipe\"],\n      env: actualEnv,\n    });\n\n    // Set up stdout listener for responses\n    if (this.proc.stdout) {\n      this.proc.stdout.setEncoding(\"utf-8\");\n      let buffer = \"\";\n\n      this.proc.stdout.on(\"data\", (chunk: string) => {\n        buffer += chunk;\n        const lines = buffer.split(\"\\n\");\n        buffer = lines.pop() || \"\";\n\n        for (const line of lines) {\n          if (!line.trim()) continue;\n\n          try {\n            const message = JSON.parse(line);\n            this.handleMessage(message);\n          } catch (error) {\n            // If we have pending requests, reject the oldest one since it likely\n            // sent the request that produced this invalid response\n            const firstKey = this.pendingRequests.keys().next().value;\n            if (firstKey !== undefined) {\n              const pending = this.pendingRequests.get(firstKey);\n              if (pending) {\n                clearTimeout(pending.timeout);\n                this.pendingRequests.delete(firstKey);\n                pending.reject(new Error(`Failed to parse JSON-RPC response from analyzer: ${line}`));\n              }\n            } else {\n              // No pending requests, just log the error\n              console.error(`Failed to parse JSON-RPC message from analyzer: ${line}`);\n            }\n          }\n        }\n      });\n    }\n\n    // Set up stderr listener\n    if (this.proc.stderr) {\n      this.proc.stderr.setEncoding(\"utf-8\");\n      this.proc.stderr.on(\"data\", (chunk: string) => {\n        console.error(`[Analyzer stderr] ${chunk}`);\n      });\n    }\n\n    // Handle process exit\n    this.proc.on(\"exit\", (code: number | null, signal: string | null) => {\n      this.proc = null;\n      // Reject all pending requests\n      for (const [, { reject, timeout }] of this.pendingRequests) {\n        clearTimeout(timeout);\n        reject(new Error(`Process exited with code ${code} (signal: ${signal})`));\n      }\n      this.pendingRequests.clear();\n    });\n\n    this.proc.on(\"error\", (error: Error) => {\n      // Reject all pending requests\n      for (const [, { reject, timeout }] of this.pendingRequests) {\n        clearTimeout(timeout);\n        reject(error);\n      }\n      this.pendingRequests.clear();\n    });\n  }\n\n  /**\n   * Initialize the analyzer with client information\n   *\n   * Sends an initialize request and waits for the response.\n   * Times out after 5 seconds if no response is received. Was 2 seconds,\n   * but that became too tight for slower analyzer binary cold starts\n   * (observed failing in CI against codebase-memory-mcp 0.10.x - see #802).\n   *\n   * @param clientInfo Client information object\n   * @throws Error if initialize times out or fails\n   */\n  async initialize(clientInfo: Record<string, unknown>): Promise<unknown> {\n    return this.callTool(\"initialize\", clientInfo, { timeout: 5000 });\n  }\n\n  /**\n   * Call a tool on the analyzer\n   *\n   * Sends a JSON-RPC request and waits for the response.\n   * Defaults to 30-second timeout for graph queries.\n   *\n   * @param name Tool name (method)\n   * @param params Tool parameters\n   * @param options Optional configuration (timeout in milliseconds)\n   * @returns Tool result\n   * @throws Error if tool call fails or times out\n   */\n  async callTool(\n    name: string,\n    params?: unknown,\n    options?: { timeout?: number }\n  ): Promise<unknown> {\n    if (!this.proc) {\n      throw new Error(\"Process not spawned\");\n    }\n\n    const timeout = options?.timeout ?? 30000;\n    const id = ++this.requestId;\n\n    const request: JsonRpcRequest = {\n      jsonrpc: \"2.0\",\n      method: name,\n      params,\n      id,\n    };\n\n    return new Promise((resolve, reject) => {\n      const timeoutHandle = setTimeout(() => {\n        this.pendingRequests.delete(id);\n        reject(new Error(`Tool call '${name}' timed out after ${timeout}ms`));\n      }, timeout);\n\n      this.pendingRequests.set(id, { resolve, reject, timeout: timeoutHandle });\n\n      try {\n        const line = JSON.stringify(request) + \"\\n\";\n        // Explicit null checks to prevent race condition with exit handler\n        if (!this.proc || !this.proc.stdin) {\n          clearTimeout(timeoutHandle);\n          this.pendingRequests.delete(id);\n          reject(new Error(\"Process or stdin closed before write could complete\"));\n          return;\n        }\n\n        if (!this.proc.stdin.write(line)) {\n          // Write returned false (backpressure), but data is already in the buffer.\n          // No action needed \u2014 the data will be flushed automatically.\n          this.proc.stdin.once(\"drain\", () => {\n            // Drain event listener registered but no action needed\n          });\n        }\n      } catch (error) {\n        clearTimeout(timeoutHandle);\n        this.pendingRequests.delete(id);\n        reject(error);\n      }\n    });\n  }\n\n  /**\n   * Close the connection and clean up\n   *\n   * Sends a shutdown notification and terminates the process.\n   * Sends SIGTERM first, then escalates to SIGKILL after 1 second if needed.\n   * Cleans up all pending requests and event listeners.\n   */\n\n  /**\n   * Invoke a tool on the analyzer via the MCP tools/call protocol\n   *\n   * Sends a tools/call request with {name, arguments} and unwraps the\n   * MCP content envelope from the response (content[0].text parsed as JSON).\n   *\n   * Use this for all tool invocations. Use callTool() only for MCP protocol\n   * methods (initialize, tools/list).\n   *\n   * @param name Tool name (e.g., \"search_graph\", \"index_repository\")\n   * @param args Tool arguments to pass as the arguments field\n   * @param options Optional configuration (timeout in milliseconds)\n   * @returns Parsed tool result unwrapped from MCP content envelope\n   */\n  async invokeTool(\n    name: string,\n    args?: unknown,\n    options?: { timeout?: number }\n  ): Promise<unknown> {\n    const response = await this.callTool(\n      \"tools/call\",\n      { name, arguments: args ?? {} },\n      options\n    ) as { content?: Array<{ type: string; text?: string }>; isError?: boolean };\n\n    // Unwrap MCP tools/call envelope: result is JSON-encoded in content[0].text\n    if (response?.content && Array.isArray(response.content) && response.content.length > 0) {\n      const first = response.content[0];\n      if (first.type === \"text\" && typeof first.text === \"string\") {\n        try {\n          return JSON.parse(first.text);\n        } catch {\n          return first.text;\n        }\n      }\n    }\n    return response;\n  }\n\n  close(): void {\n    if (!this.proc) {\n      return;\n    }\n\n    const procToClose = this.proc;\n    this.proc = null;\n\n    // Send shutdown notification\n    try {\n      const notification: JsonRpcNotification = {\n        jsonrpc: \"2.0\",\n        method: \"shutdown\",\n      };\n      const line = JSON.stringify(notification) + \"\\n\";\n      procToClose.stdin?.write(line);\n    } catch (error) {\n      // Ignore write errors during shutdown\n    }\n\n    // Clean up pending requests\n    for (const [, { reject, timeout }] of this.pendingRequests) {\n      clearTimeout(timeout);\n      reject(new Error(\"Client closed\"));\n    }\n    this.pendingRequests.clear();\n\n    // Remove listeners\n    if (procToClose.stdout) {\n      procToClose.stdout.removeAllListeners();\n    }\n    if (procToClose.stderr) {\n      procToClose.stderr.removeAllListeners();\n    }\n    procToClose.removeAllListeners();\n\n    // Terminate process with SIGKILL fallback\n    try {\n      procToClose.stdin?.end();\n      if (!procToClose.killed) {\n        procToClose.kill(\"SIGTERM\");\n\n        // Schedule SIGKILL fallback after 1 second if process doesn't exit\n        const killTimer = setTimeout(() => {\n          // Check if process has actually exited (exitCode is non-null once exit event fires)\n          if (procToClose.exitCode === null) {\n            try {\n              procToClose.kill(\"SIGKILL\");\n            } catch {\n              // Process may have already exited\n            }\n          }\n        }, 1000);\n\n        // Unreference the timer so it doesn't keep the event loop alive\n        killTimer.unref();\n      }\n    } catch (error) {\n      // Ignore errors during shutdown\n    }\n  }\n\n  /**\n   * Handle a JSON-RPC message from the analyzer\n   *\n   * Matches responses to pending requests by ID and resolves/rejects accordingly.\n   * Extracts error information from JSON-RPC error objects.\n   *\n   * @param message Parsed JSON-RPC message\n   */\n  private handleMessage(message: unknown): void {\n    if (!message || typeof message !== \"object\") {\n      return;\n    }\n\n    const msg = message as Record<string, unknown>;\n\n    // Ignore notifications (no id field)\n    if (!(\"id\" in msg) || typeof msg.id !== \"number\") {\n      return;\n    }\n\n    const msgId = msg.id as number;\n    const pending = this.pendingRequests.get(msgId);\n\n    if (!pending) {\n      // Log diagnostic information for unmatched response IDs\n      console.warn(\n        `Received response with unmatched ID ${msgId} (type: ${typeof msgId}). ` +\n        `Pending request IDs: [${Array.from(this.pendingRequests.keys()).join(\", \")}]. ` +\n        `This may indicate a type mismatch or stale response.`\n      );\n      return;\n    }\n\n    const { resolve, reject, timeout } = pending;\n    clearTimeout(timeout);\n    this.pendingRequests.delete(msgId);\n\n    // Check for error response\n    if (\"error\" in msg && msg.error !== null && typeof msg.error === \"object\") {\n      const error = msg.error as Record<string, unknown>;\n      const errMessage = (error.message as string) || \"Unknown error\";\n      const code = (error.code as number) ?? -1;\n      const data = error.data;\n\n      const errorMessage = data ? `${errMessage}: ${JSON.stringify(data)}` : errMessage;\n      reject(new Error(`[Error ${code}] ${errorMessage}`));\n      return;\n    }\n\n    // Success response\n    if (\"result\" in msg) {\n      resolve(msg.result);\n      return;\n    }\n\n    // Invalid response\n    reject(new Error(\"Invalid JSON-RPC response: no result or error field\"));\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/analyzers/types.js

@@ -0,0 +1,15 @@
+const VALID_HTTP_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+  "TRACE",
+  "CONNECT"
+];
+export {
+  VALID_HTTP_METHODS
+};
+//# sourceMappingURL=types.js.map