@documentation-robotics/cli 0.1.0 → 0.1.5

package/dist/commands/analyzer.js

@@ -0,0 +1,511 @@
+import { intro, outro, select, isCancel } from "@clack/prompts";
+import ansis from "ansis";
+import { promises as fs } from "fs";
+import * as path from "path";
+import { AnalyzerRegistry } from "../analyzers/registry.js";
+import { MappingLoader } from "../analyzers/mapping-loader.js";
+import { readSession, writeSession, writeStatus, readIndexMeta } from "../analyzers/session-state.js";
+import { CLIError, ModelNotFoundError, ErrorCategory, categorizeError } from "../utils/errors.js";
+import { findProjectRoot } from "../utils/project-paths.js";
+import { performDiscover } from "./discover-logic.js";
+import { formatVerifyReport } from "../export/verify-formatters.js";
+function analyzerCommands(program) {
+  const analyzer = program.command("analyzer").description("Manage analyzer discovery and indexing");
+  analyzer.command("discover").description("Discover and select an analyzer").option("--json", "Output as JSON").option("--reselect", "Force re-selection even if analyzer already selected").addHelpText("after", `
+Examples:
+  $ dr analyzer discover                    # Scan and select analyzer
+  $ dr analyzer discover --reselect         # Force re-selection
+  $ dr analyzer discover --json             # Output discovery results as JSON`).action(async (options) => {
+    try {
+      const projectRoot = await findProjectRoot() || process.cwd(), registry = AnalyzerRegistry.getInstance();
+      if (await registry.initialize(), !options.reselect) {
+        const session = await readSession(projectRoot);
+        if (session)
+          if (options.json) {
+            const analyzerNames = await registry.getAnalyzerNames(), analyzerOptions2 = [];
+            for (const name of analyzerNames)
+              try {
+                const backend = await registry.getAnalyzer(name);
+                if (!backend)
+                  continue;
+                const detection = await backend.detect(), metadata = (await MappingLoader.load(name)).getAnalyzerMetadata();
+                analyzerOptions2.push({ backend, detection, metadata });
+              } catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.error(`Failed to discover analyzer "${name}": ${errorMsg}`);
+              }
+            const installed2 = analyzerOptions2.filter((a) => a.detection.installed), discoveryResult2 = {
+              found: analyzerOptions2.map((a) => ({
+                name: a.backend.name,
+                display_name: a.backend.displayName,
+                description: a.metadata?.description || "",
+                homepage: a.metadata?.homepage || "",
+                installed: a.detection.installed
+              })),
+              installed_count: installed2.length,
+              selected: session.active_analyzer
+            };
+            console.log(JSON.stringify(discoveryResult2, null, 2));
+            return;
+          } else {
+            console.log(ansis.green(`\u2713 Using analyzer: ${session.active_analyzer} (use --reselect to change)`));
+            return;
+          }
+      }
+      const discoverResult = await performDiscover(registry, {
+        json: options.json,
+        reselect: options.reselect,
+        isTTY: process.stdin.isTTY
+      }), { discoveryResult, installed, analyzerOptions, selectedAnalyzer, shouldWriteSession } = discoverResult;
+      if (options.json) {
+        if (selectedAnalyzer && shouldWriteSession) {
+          const state = {
+            active_analyzer: selectedAnalyzer,
+            selected_at: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          await writeSession(state, projectRoot), discoveryResult.selected = selectedAnalyzer;
+        }
+        console.log(JSON.stringify(discoveryResult, null, 2));
+        return;
+      }
+      if (installed.length === 0) {
+        intro(ansis.blue("\u{1F4CA} Analyzer Discovery")), console.log(""), console.log(ansis.yellow("No analyzers installed. Install one of the following:")), console.log("");
+        for (const opt of analyzerOptions) {
+          const name = ansis.bold(opt.backend.displayName), homepage = opt.metadata?.homepage || "(homepage not available)";
+          console.log(`  ${name} ${ansis.dim(`(${homepage})`)}`);
+        }
+        console.log(""), outro(ansis.dim("To install: follow the links above or use your package manager"));
+        return;
+      }
+      if (intro(ansis.blue("\u{1F4CA} Analyzer Selection")), process.stdin.isTTY) {
+        const selectedName = await select({
+          message: "Select an analyzer",
+          options: installed.map((a) => ({
+            value: a.backend.name,
+            label: a.backend.displayName,
+            hint: a.metadata?.description || ""
+          }))
+        });
+        if (isCancel(selectedName)) {
+          outro(ansis.dim("Cancelled"));
+          return;
+        }
+        const state = {
+          active_analyzer: selectedName,
+          selected_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await writeSession(state, projectRoot), outro(ansis.green(`\u2713 Selected analyzer: ${selectedName} (saved to .dr/analyzers/session.json)`));
+      } else if (selectedAnalyzer) {
+        const state = {
+          active_analyzer: selectedAnalyzer,
+          selected_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await writeSession(state, projectRoot), console.log(ansis.green(`\u2713 Selected analyzer: ${selectedAnalyzer} (non-interactive mode)`)), outro(ansis.dim("Saved to .dr/analyzers/session.json"));
+      }
+    } catch (error) {
+      if (error instanceof CLIError)
+        throw error;
+      const category = categorizeError(error), cliError = new CLIError(error instanceof Error ? error.message : String(error), category);
+      throw error instanceof Error && (cliError.cause = error), cliError;
+    }
+  }), analyzer.command("status").description("Check analyzer detection and project index status").option("--name <n>", "Analyzer name (defaults to active from session.json)").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ dr analyzer status              # Show status of active analyzer
+  $ dr analyzer status --name cbm   # Show status of specific analyzer
+  $ dr analyzer status --json       # Output as JSON`).action(async (options) => {
+    try {
+      const projectRoot = await findProjectRoot() || process.cwd();
+      let analyzerName = options.name;
+      if (!analyzerName) {
+        const session = await readSession(projectRoot);
+        if (!session)
+          throw new CLIError("No analyzer selected. Run `dr analyzer discover` first.", ErrorCategory.USER);
+        analyzerName = session.active_analyzer;
+      }
+      const registry = AnalyzerRegistry.getInstance();
+      await registry.initialize();
+      const backend = await registry.getAnalyzer(analyzerName);
+      if (!backend)
+        throw new CLIError(`Analyzer not found: ${analyzerName}`, ErrorCategory.NOT_FOUND, ["Check the analyzer name with `dr analyzer discover`"]);
+      const actualProjectRoot = await findProjectRoot();
+      let status;
+      if (actualProjectRoot ? status = await backend.status(actualProjectRoot) : status = {
+        detected: await backend.detect(),
+        indexed: !1,
+        fresh: !1
+      }, options.json) {
+        console.log(JSON.stringify(status, null, 2)), actualProjectRoot && await writeStatus(status, actualProjectRoot, analyzerName);
+        return;
+      }
+      console.log(""), console.log(ansis.bold("Analyzer Status")), console.log(ansis.dim("\u2500".repeat(40))), console.log(`Installed: ${status.detected.installed ? ansis.green("\u2713 Yes") : ansis.red("\u2717 No")}`), status.detected.binary_path && console.log(`Binary: ${ansis.dim(status.detected.binary_path)}`), status.detected.version && console.log(`Version: ${ansis.dim(status.detected.version)}`), status.detected.installed && (console.log(`MCP Registered: ${status.detected.mcp_registered ? ansis.green("\u2713 Yes") : ansis.yellow("\u2717 No")}`), console.log(`Contract Valid: ${status.detected.contract_ok ? ansis.green("\u2713 Yes") : ansis.yellow("\u2717 No")}`)), actualProjectRoot && (console.log(`Indexed: ${status.indexed ? ansis.green("\u2713 Yes") : ansis.yellow("\u2717 No")}`), status.indexed ? (console.log(`Fresh: ${status.fresh ? ansis.green("\u2713 Yes") : ansis.yellow("\u2717 No (use --force to reindex)")}`), status.last_indexed && console.log(`Last indexed: ${ansis.dim(status.last_indexed)}`)) : console.log(ansis.dim("Run `dr analyzer index` to index the project"))), console.log(""), actualProjectRoot && await writeStatus(status, actualProjectRoot, analyzerName);
+    } catch (error) {
+      if (error instanceof CLIError)
+        throw error;
+      const category = categorizeError(error), cliError = new CLIError(error instanceof Error ? error.message : String(error), category);
+      throw error instanceof Error && (cliError.cause = error), cliError;
+    }
+  }), analyzer.command("index").description("Index the current project with the analyzer").option("--name <n>", "Analyzer name (defaults to active from session.json)").option("--force", "Force re-indexing even if index is fresh").addHelpText("after", `
+Examples:
+  $ dr analyzer index              # Index with active analyzer
+  $ dr analyzer index --force      # Force re-index
+  $ dr analyzer index --name cbm   # Index with specific analyzer`).action(async (options) => {
+    try {
+      const projectRoot = await findProjectRoot();
+      if (!projectRoot)
+        throw new ModelNotFoundError();
+      let analyzerName = options.name;
+      if (!analyzerName) {
+        const session = await readSession(projectRoot);
+        if (!session)
+          throw new CLIError("No analyzer selected. Run `dr analyzer discover` first.", ErrorCategory.USER);
+        analyzerName = session.active_analyzer;
+      }
+      const registry = AnalyzerRegistry.getInstance();
+      await registry.initialize();
+      const backend = await registry.getAnalyzer(analyzerName);
+      if (!backend)
+        throw new CLIError(`Analyzer not found: ${analyzerName}`, ErrorCategory.NOT_FOUND, ["Check the analyzer name with `dr analyzer discover`"]);
+      if (!(await backend.detect()).installed) {
+        const homepageUrl = (await MappingLoader.load(analyzerName)).getAnalyzerMetadata()?.homepage || "https://github.com/search?q=codebase-memory";
+        throw new CLIError(`Analyzer not installed: ${analyzerName}`, ErrorCategory.USER, [
+          "Run `dr analyzer discover` to find available analyzers and installation instructions",
+          `Visit: ${homepageUrl}`
+        ]);
+      }
+      console.log(`Indexing project with ${analyzerName}...`);
+      const result = await backend.index(projectRoot, { force: options.force });
+      console.log(ansis.green("\u2713 Indexing complete")), console.log(`  Nodes: ${result.node_count}`), console.log(`  Edges: ${result.edge_count}`), console.log(`  Git HEAD: ${result.git_head}`);
+    } catch (error) {
+      if (error instanceof CLIError || error instanceof ModelNotFoundError)
+        throw error;
+      const cliError = new CLIError(error instanceof Error ? error.message : String(error), ErrorCategory.SYSTEM);
+      throw error instanceof Error && (cliError.cause = error), cliError;
+    }
+  }), analyzer.command("endpoints").description("List discovered API endpoints from indexed project").option("--name <n>", "Analyzer name (defaults to active from session.json)").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ dr analyzer endpoints              # List endpoints from active analyzer
+  $ dr analyzer endpoints --json       # Output as JSON
+  $ dr analyzer endpoints --name cbm   # List endpoints from specific analyzer`).action(async (options) => {
+    try {
+      const projectRoot = await findProjectRoot();
+      if (!projectRoot)
+        throw new ModelNotFoundError();
+      let analyzerName = options.name;
+      if (!analyzerName) {
+        const session = await readSession(projectRoot);
+        if (!session)
+          throw new CLIError("No analyzer selected. Run `dr analyzer discover` first.", ErrorCategory.USER);
+        analyzerName = session.active_analyzer;
+      }
+      const registry = AnalyzerRegistry.getInstance();
+      await registry.initialize();
+      const backend = await registry.getAnalyzer(analyzerName);
+      if (!backend)
+        throw new CLIError(`Analyzer not found: ${analyzerName}`, ErrorCategory.NOT_FOUND);
+      if (!(await backend.status(projectRoot)).indexed)
+        throw new CLIError("Project not indexed", ErrorCategory.USER, ["Run `dr analyzer index` to index the project first"]);
+      const endpoints = await backend.endpoints(projectRoot);
+      if (options.json) {
+        console.log(JSON.stringify(endpoints, null, 2));
+        return;
+      }
+      if (endpoints.length === 0) {
+        console.log(ansis.yellow("No endpoints found"));
+        return;
+      }
+      console.log(""), console.log(ansis.bold(`API Endpoints (${endpoints.length} found):`)), console.log(ansis.dim("\u2500".repeat(135)));
+      const methodWidth = 8, pathWidth = 20, nameWidth = 18, idFragmentWidth = 18, symbolWidth = 18, confidenceWidth = 12, fileWidth = 25;
+      console.log(ansis.cyan(`${"Method".padEnd(methodWidth)} ${"Path".padEnd(pathWidth)} ${"Name".padEnd(nameWidth)} ${"ID Fragment".padEnd(idFragmentWidth)} ${"Symbol".padEnd(symbolWidth)} ${"Confidence".padEnd(confidenceWidth)} File`)), console.log(ansis.dim("\u2500".repeat(135)));
+      for (const endpoint of endpoints) {
+        const method = endpoint.http_method.padEnd(methodWidth), path2 = endpoint.http_path.substring(0, pathWidth).padEnd(pathWidth), name = endpoint.suggested_name.substring(0, nameWidth).padEnd(nameWidth), idFragment = endpoint.suggested_id_fragment.substring(0, idFragmentWidth).padEnd(idFragmentWidth), symbol = endpoint.source_symbol.substring(0, symbolWidth).padEnd(symbolWidth), confidence = endpoint.confidence.toUpperCase().padEnd(confidenceWidth), file = endpoint.source_file.substring(0, fileWidth);
+        console.log(`${method} ${path2} ${name} ${idFragment} ${symbol} ${confidence} ${ansis.dim(file)}`);
+      }
+      console.log(ansis.dim("\u2500".repeat(135))), console.log(ansis.dim(`Total: ${endpoints.length} endpoint(s)`)), console.log("");
+    } catch (error) {
+      if (error instanceof CLIError || error instanceof ModelNotFoundError)
+        throw error;
+      const cliError = new CLIError(error instanceof Error ? error.message : String(error), categorizeError(error));
+      throw error instanceof Error && (cliError.cause = error), cliError;
+    }
+  }), analyzer.command("services").description("Query for services/components in the indexed project").option("--name <n>", "Analyzer name (defaults to active from session.json)").option("--layer <layer>", "Filter by layer (e.g., 'application')").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ dr analyzer services              # List all services
+  $ dr analyzer services --layer application
+  $ dr analyzer services --json       # Output as JSON`).action(async (options) => {
+    try {
+      const projectRoot = await findProjectRoot();
+      if (!projectRoot)
+        throw new ModelNotFoundError();
+      let analyzerName = options.name;
+      if (!analyzerName) {
+        const session = await readSession(projectRoot);
+        if (!session)
+          throw new CLIError("No analyzer selected. Run `dr analyzer discover` first.", ErrorCategory.USER);
+        analyzerName = session.active_analyzer;
+      }
+      const registry = AnalyzerRegistry.getInstance();
+      await registry.initialize();
+      const backend = await registry.getAnalyzer(analyzerName);
+      if (!backend)
+        throw new CLIError(`Analyzer not found: ${analyzerName}`, ErrorCategory.NOT_FOUND);
+      if (!await readIndexMeta(projectRoot, analyzerName))
+        throw new CLIError("Project not indexed", ErrorCategory.USER, ["Run `dr analyzer index` first"]);
+      let services = await backend.services(projectRoot);
+      if (options.layer && (services = services.filter((s) => s.suggested_layer === options.layer)), options.json) {
+        console.log(JSON.stringify(services, null, 2));
+        return;
+      }
+      if (services.length === 0) {
+        console.log(ansis.yellow("No services found"));
+        return;
+      }
+      console.log(""), console.log(ansis.bold(`Services (${services.length} found):`)), console.log(ansis.dim("\u2500".repeat(120)));
+      const nameWidth = 20, layerWidth = 15, typeWidth = 18, symbolWidth = 20, confidenceWidth = 12, fileWidth = 25;
+      console.log(ansis.cyan(`${"Name".padEnd(nameWidth)} ${"Layer".padEnd(layerWidth)} ${"Type".padEnd(typeWidth)} ${"Symbol".padEnd(symbolWidth)} ${"Confidence".padEnd(confidenceWidth)} File`)), console.log(ansis.dim("\u2500".repeat(120)));
+      for (const service of services) {
+        const name = service.suggested_name.substring(0, nameWidth).padEnd(nameWidth), layer = service.suggested_layer.substring(0, layerWidth).padEnd(layerWidth), type = service.suggested_element_type.substring(0, typeWidth).padEnd(typeWidth), symbol = service.source_symbol.substring(0, symbolWidth).padEnd(symbolWidth), confidence = service.confidence.toUpperCase().padEnd(confidenceWidth), file = service.source_file.substring(0, fileWidth);
+        console.log(`${name} ${layer} ${type} ${symbol} ${confidence} ${ansis.dim(file)}`);
+      }
+      console.log(ansis.dim("\u2500".repeat(120))), console.log(ansis.dim(`Total: ${services.length} service(s)`)), console.log("");
+    } catch (error) {
+      if (error instanceof CLIError || error instanceof ModelNotFoundError)
+        throw error;
+      const cliError = new CLIError(error instanceof Error ? error.message : String(error), categorizeError(error));
+      throw error instanceof Error && (cliError.cause = error), cliError;
+    }
+  }), analyzer.command("datastores").description("Query for datastores/databases inferred from code analysis").option("--name <n>", "Analyzer name (defaults to active from session.json)").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ dr analyzer datastores        # List all inferred datastores
+  $ dr analyzer datastores --json # Output as JSON`).action(async (options) => {
+    try {
+      const projectRoot = await findProjectRoot();
+      if (!projectRoot)
+        throw new ModelNotFoundError();
+      let analyzerName = options.name;
+      if (!analyzerName) {
+        const session = await readSession(projectRoot);
+        if (!session)
+          throw new CLIError("No analyzer selected. Run `dr analyzer discover` first.", ErrorCategory.USER);
+        analyzerName = session.active_analyzer;
+      }
+      const registry = AnalyzerRegistry.getInstance();
+      await registry.initialize();
+      const backend = await registry.getAnalyzer(analyzerName);
+      if (!backend)
+        throw new CLIError(`Analyzer not found: ${analyzerName}`, ErrorCategory.NOT_FOUND);
+      if (!await readIndexMeta(projectRoot, analyzerName))
+        throw new CLIError("Project not indexed", ErrorCategory.USER, ["Run `dr analyzer index` first"]);
+      const datastores = await backend.datastores(projectRoot);
+      if (options.json) {
+        console.log(JSON.stringify(datastores, null, 2));
+        return;
+      }
+      if (datastores.length === 0) {
+        console.log(ansis.yellow("No datastores found"));
+        return;
+      }
+      console.log(""), console.log(ansis.bold(`Datastores (${datastores.length} found):`)), console.log(ansis.dim("\u2500".repeat(100)));
+      for (const ds of datastores) {
+        console.log(`  ${ansis.cyan(ds.suggested_name)}`), console.log("    Inferred from:");
+        for (const evidence of ds.inferred_from)
+          console.log(`      - ${evidence.source_file}: ${evidence.import_pattern}`);
+        ds.notes && console.log(`    Notes: ${ds.notes}`), console.log("");
+      }
+      console.log(ansis.dim(`Total: ${datastores.length} datastore(s)`)), console.log("");
+    } catch (error) {
+      if (error instanceof CLIError || error instanceof ModelNotFoundError)
+        throw error;
+      const cliError = new CLIError(error instanceof Error ? error.message : String(error), categorizeError(error));
+      throw error instanceof Error && (cliError.cause = error), cliError;
+    }
+  }), analyzer.command("callers <qualified-name>").description("Query for callers of a specific function or symbol").option("--name <n>", "Analyzer name (defaults to active from session.json)").option("--depth <n>", "Maximum depth for call graph traversal (default: 3, max: 10)", "3").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ dr analyzer callers com.example.Service.handleRequest
+  $ dr analyzer callers com.example.Service.handleRequest --depth 5
+  $ dr analyzer callers com.example.Service.handleRequest --json`).action(async (qualifiedName, options) => {
+    try {
+      const depth = parseInt(options.depth, 10);
+      if (isNaN(depth) || depth < 1)
+        throw new CLIError("Invalid --depth value: must be a positive integer", ErrorCategory.USER);
+      const projectRoot = await findProjectRoot();
+      if (!projectRoot)
+        throw new ModelNotFoundError();
+      let analyzerName = options.name;
+      if (!analyzerName) {
+        const session = await readSession(projectRoot);
+        if (!session)
+          throw new CLIError("No analyzer selected. Run `dr analyzer discover` first.", ErrorCategory.USER);
+        analyzerName = session.active_analyzer;
+      }
+      const registry = AnalyzerRegistry.getInstance();
+      await registry.initialize();
+      const backend = await registry.getAnalyzer(analyzerName);
+      if (!backend)
+        throw new CLIError(`Analyzer not found: ${analyzerName}`, ErrorCategory.NOT_FOUND);
+      if (!await readIndexMeta(projectRoot, analyzerName))
+        throw new CLIError("Project not indexed", ErrorCategory.USER, ["Run `dr analyzer index` first"]);
+      const callers = await backend.callers(projectRoot, qualifiedName, depth);
+      if (options.json) {
+        console.log(JSON.stringify(callers, null, 2));
+        return;
+      }
+      if (callers.length === 0) {
+        console.log(ansis.yellow(`No callers found for ${qualifiedName}`));
+        return;
+      }
+      console.log(""), console.log(ansis.bold(`Callers of ${ansis.cyan(qualifiedName)} (${callers.length} found):`)), console.log(ansis.dim("\u2500".repeat(100)));
+      for (const caller of callers)
+        console.log(`  ${ansis.bold(caller.qualified_name)}`), console.log(`    File: ${caller.source_file}`), console.log(`    Symbol: ${caller.source_symbol}`), console.log(`    Depth: ${caller.depth}`), console.log(`    Edge: ${caller.edge_type}`), console.log("");
+      console.log(ansis.dim(`Total: ${callers.length} caller(s)`)), console.log("");
+    } catch (error) {
+      if (error instanceof CLIError || error instanceof ModelNotFoundError)
+        throw error;
+      const cliError = new CLIError(error instanceof Error ? error.message : String(error), categorizeError(error));
+      throw error instanceof Error && (cliError.cause = error), cliError;
+    }
+  }), analyzer.command("callees <qualified-name>").description("Query for callees of a specific function or symbol").option("--name <n>", "Analyzer name (defaults to active from session.json)").option("--depth <n>", "Maximum depth for call graph traversal (default: 3, max: 10)", "3").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ dr analyzer callees com.example.Service.handleRequest
+  $ dr analyzer callees com.example.Service.handleRequest --depth 5
+  $ dr analyzer callees com.example.Service.handleRequest --json`).action(async (qualifiedName, options) => {
+    try {
+      const depth = parseInt(options.depth, 10);
+      if (isNaN(depth) || depth < 1)
+        throw new CLIError("Invalid --depth value: must be a positive integer", ErrorCategory.USER);
+      const projectRoot = await findProjectRoot();
+      if (!projectRoot)
+        throw new ModelNotFoundError();
+      let analyzerName = options.name;
+      if (!analyzerName) {
+        const session = await readSession(projectRoot);
+        if (!session)
+          throw new CLIError("No analyzer selected. Run `dr analyzer discover` first.", ErrorCategory.USER);
+        analyzerName = session.active_analyzer;
+      }
+      const registry = AnalyzerRegistry.getInstance();
+      await registry.initialize();
+      const backend = await registry.getAnalyzer(analyzerName);
+      if (!backend)
+        throw new CLIError(`Analyzer not found: ${analyzerName}`, ErrorCategory.NOT_FOUND);
+      if (!await readIndexMeta(projectRoot, analyzerName))
+        throw new CLIError("Project not indexed", ErrorCategory.USER, ["Run `dr analyzer index` first"]);
+      const callees = await backend.callees(projectRoot, qualifiedName, depth);
+      if (options.json) {
+        console.log(JSON.stringify(callees, null, 2));
+        return;
+      }
+      if (callees.length === 0) {
+        console.log(ansis.yellow(`No callees found for ${qualifiedName}`));
+        return;
+      }
+      console.log(""), console.log(ansis.bold(`Callees of ${ansis.cyan(qualifiedName)} (${callees.length} found):`)), console.log(ansis.dim("\u2500".repeat(100)));
+      for (const callee of callees)
+        console.log(`  ${ansis.bold(callee.qualified_name)}`), console.log(`    File: ${callee.source_file}`), console.log(`    Symbol: ${callee.source_symbol}`), console.log(`    Depth: ${callee.depth}`), console.log(`    Edge: ${callee.edge_type}`), console.log("");
+      console.log(ansis.dim(`Total: ${callees.length} callee(s)`)), console.log("");
+    } catch (error) {
+      if (error instanceof CLIError || error instanceof ModelNotFoundError)
+        throw error;
+      const cliError = new CLIError(error instanceof Error ? error.message : String(error), categorizeError(error));
+      throw error instanceof Error && (cliError.cause = error), cliError;
+    }
+  }), analyzer.command("query <cypher>").description("Execute a raw Cypher query against the analyzer graph (advanced escape hatch)").option("--name <n>", "Analyzer name (defaults to active from session.json)").option("--json", "Output as JSON (default format for query results)").addHelpText("before", `Advanced Escape Hatch: This command directly executes graph queries without validation or wrapping.
+Use for advanced analysis when standard commands don't meet your needs.
+`).addHelpText("after", `
+Query syntax depends on the analyzer backend (e.g., Cypher for graph analyzers).
+Results are always output as JSON.
+
+Examples:
+  $ dr analyzer query "MATCH (n) RETURN n LIMIT 10"
+  $ dr analyzer query "MATCH (n:Service) RETURN n.name"
+  $ dr analyzer query "MATCH (n) RETURN n LIMIT 10" --json`).action(async (cypher, options) => {
+    try {
+      const projectRoot = await findProjectRoot();
+      if (!projectRoot)
+        throw new ModelNotFoundError();
+      let analyzerName = options.name;
+      if (!analyzerName) {
+        const session = await readSession(projectRoot);
+        if (!session)
+          throw new CLIError("No analyzer selected. Run `dr analyzer discover` first.", ErrorCategory.USER);
+        analyzerName = session.active_analyzer;
+      }
+      const registry = AnalyzerRegistry.getInstance();
+      await registry.initialize();
+      const backend = await registry.getAnalyzer(analyzerName);
+      if (!backend)
+        throw new CLIError(`Analyzer not found: ${analyzerName}`, ErrorCategory.NOT_FOUND);
+      if (!await readIndexMeta(projectRoot, analyzerName))
+        throw new CLIError("Project not indexed", ErrorCategory.USER, ["Run `dr analyzer index` first"]);
+      const result = await backend.query(projectRoot, cypher);
+      options.json, console.log(JSON.stringify(result, null, 2));
+    } catch (error) {
+      if (error instanceof CLIError || error instanceof ModelNotFoundError)
+        throw error;
+      const cliError = new CLIError(error instanceof Error ? error.message : String(error), categorizeError(error));
+      throw error instanceof Error && (cliError.cause = error), cliError;
+    }
+  }), analyzer.command("verify").description("Verify that graph-discovered routes align with model endpoints").option("--name <n>", "Analyzer name (defaults to active from session.json)").option("--layer <layer>", "Layer(s) to verify (can be used multiple times)", (value, previous) => previous ? [...previous, value] : [value]).option("--json", "Output as JSON").option("--format <format>", "Output format: text, json, markdown (default: text)").option("--output <path>", "Write report to file").addHelpText("after", `
+Examples:
+  $ dr analyzer verify                       # Verify api layer (default)
+  $ dr analyzer verify --layer api           # Explicitly specify api layer
+  $ dr analyzer verify --json                # Output as JSON to stdout
+  $ dr analyzer verify --format markdown     # Output as Markdown to stdout
+  $ dr analyzer verify --output report.json  # Save report to file (format inferred as JSON)
+  $ dr analyzer verify --output report.md    # Save report as Markdown`).action(async (options) => {
+    try {
+      let format = "text";
+      if (options.json)
+        options.format && console.warn(ansis.yellow(`\u26A0 Both --json and --format "${options.format}" were provided. Using --json format (--format is ignored).`)), format = "json";
+      else if (options.format) {
+        const validFormats = ["text", "json", "markdown"];
+        if (!validFormats.includes(options.format))
+          throw new CLIError(`Invalid format: "${options.format}". Valid values are: ${validFormats.join(", ")}.`, ErrorCategory.USER);
+        format = options.format;
+      } else if (options.output) {
+        const ext = path.extname(options.output).toLowerCase();
+        ext === ".json" ? format = "json" : ext === ".md" ? format = "markdown" : ext && console.warn(ansis.yellow(`\u26A0 Unrecognized file extension "${ext}" in --output. Using text format by default.`));
+      }
+      const projectRoot = await findProjectRoot();
+      if (!projectRoot)
+        throw new ModelNotFoundError();
+      const requestedLayers = options.layer || ["api"], apiLayers = requestedLayers.filter((layer) => layer === "api"), nonApiLayers = requestedLayers.filter((layer) => layer !== "api");
+      for (const layer of nonApiLayers)
+        console.log(ansis.dim(`No verification available for layer '${layer}'`));
+      if (apiLayers.length === 0)
+        return;
+      let analyzerName = options.name;
+      if (!analyzerName) {
+        const session = await readSession(projectRoot);
+        if (!session)
+          throw new CLIError("No analyzer selected. Run `dr analyzer discover` first.", ErrorCategory.USER);
+        analyzerName = session.active_analyzer;
+      }
+      const registry = AnalyzerRegistry.getInstance();
+      await registry.initialize();
+      const backend = await registry.getAnalyzer(analyzerName);
+      if (!backend)
+        throw new CLIError(`Analyzer not found: ${analyzerName}`, ErrorCategory.NOT_FOUND);
+      if (!await readIndexMeta(projectRoot, analyzerName))
+        throw new CLIError("Project not indexed", ErrorCategory.USER, ["Run `dr analyzer index` first"]);
+      const report = await backend.verify(projectRoot, {
+        layers: apiLayers,
+        changesetAware: !0
+      }), formatted = formatVerifyReport(report, { format });
+      if (options.output) {
+        const outputPath = path.resolve(options.output);
+        await fs.writeFile(outputPath, formatted, "utf-8"), console.log(ansis.green(`\u2713 Report written to ${outputPath}`));
+        return;
+      }
+      console.log(formatted);
+    } catch (error) {
+      if (error instanceof CLIError || error instanceof ModelNotFoundError)
+        throw error;
+      const cliError = new CLIError(error instanceof Error ? error.message : String(error), categorizeError(error));
+      throw error instanceof Error && (cliError.cause = error), cliError;
+    }
+  });
+}
+export {
+  analyzerCommands
+};
+//# sourceMappingURL=analyzer.js.map