@kodus/kodus-graph 0.2.8 → 0.2.9

package/src/commands/analyze.ts

@@ -1,128 +0,0 @@
-import { readFileSync, writeFileSync } from 'fs';
-import { resolve, relative } from 'path';
-import { computeBlastRadius } from '../analysis/blast-radius';
-import { computeRiskScore } from '../analysis/risk-score';
-import { findTestGaps } from '../analysis/test-gaps';
-import { buildGraphData } from '../graph/builder';
-import { mergeGraphs } from '../graph/merger';
-import type { AnalysisOutput, ImportEdge, MainGraphInput } from '../graph/types';
-import { parseBatch } from '../parser/batch';
-import { discoverFiles } from '../parser/discovery';
-import { resolveAllCalls } from '../resolver/call-resolver';
-import { createImportMap } from '../resolver/import-map';
-import { loadTsconfigAliases, resolveImport } from '../resolver/import-resolver';
-import { buildReExportMap } from '../resolver/re-export-resolver';
-import { createSymbolTable } from '../resolver/symbol-table';
-import { computeFileHash } from '../shared/file-hash';
-import { log } from '../shared/logger';
-import { GraphInputSchema } from '../shared/schemas';
-
-interface AnalyzeOptions {
-  repoDir: string;
-  files: string[];
-  graph?: string;
-  out: string;
-}
-
-export async function executeAnalyze(opts: AnalyzeOptions): Promise<void> {
-  const repoDir = resolve(opts.repoDir);
-
-  // Load main graph if provided
-  let mainGraph: MainGraphInput | null = null;
-  if (opts.graph) {
-    let raw: unknown;
-    try {
-      raw = JSON.parse(readFileSync(opts.graph, 'utf-8'));
-    } catch (_err) {
-      process.stderr.write(`Error: Failed to read --graph file: ${opts.graph}\n`);
-      process.exit(1);
-    }
-    const validated = GraphInputSchema.safeParse(raw);
-    if (!validated.success) {
-      process.stderr.write(`Error: Invalid graph JSON: ${validated.error.message}\n`);
-      process.exit(1);
-    }
-    mainGraph = {
-      repo_id: '',
-      sha: '',
-      nodes: validated.data.nodes,
-      edges: validated.data.edges,
-    };
-  }
-
-  // Parse changed files locally
-  const localFiles = discoverFiles(repoDir, opts.files);
-  const rawGraph = await parseBatch(localFiles, repoDir);
-
-  // Resolve imports
-  const tsconfigAliases = loadTsconfigAliases(repoDir);
-  const symbolTable = createSymbolTable();
-  const importMap = createImportMap();
-  const importEdges: ImportEdge[] = [];
-
-  for (const f of rawGraph.functions) symbolTable.add(f.file, f.name, f.qualified);
-  for (const c of rawGraph.classes) symbolTable.add(c.file, c.name, c.qualified);
-  for (const i of rawGraph.interfaces) symbolTable.add(i.file, i.name, i.qualified);
-
-  // Pre-resolve re-exports so barrel imports follow through to actual definitions
-  const barrelMap = buildReExportMap(rawGraph.reExports, repoDir, tsconfigAliases);
-
-  for (const imp of rawGraph.imports) {
-    const langKey = imp.lang === 'python' ? 'python' : imp.lang === 'ruby' ? 'ruby' : 'typescript';
-    const resolved = resolveImport(resolve(repoDir, imp.file), imp.module, langKey, repoDir, tsconfigAliases);
-    const resolvedRel = resolved ? relative(repoDir, resolved) : null;
-    importEdges.push({
-      source: imp.file,
-      target: resolvedRel || imp.module,
-      resolved: !!resolvedRel,
-      line: imp.line,
-    });
-    const target = resolvedRel || imp.module;
-    for (const name of imp.names) {
-      let finalTarget = target;
-      if (resolvedRel) {
-        const reExportedFiles = barrelMap.get(resolvedRel);
-        if (reExportedFiles) {
-          for (const reFile of reExportedFiles) {
-            if (symbolTable.lookupExact(reFile, name)) {
-              finalTarget = reFile;
-              break;
-            }
-          }
-        }
-      }
-      importMap.add(imp.file, name, finalTarget);
-    }
-  }
-
-  // Resolve calls
-  const { callEdges } = resolveAllCalls(rawGraph.rawCalls, rawGraph.diMaps, symbolTable, importMap);
-
-  // Build graph with file hashes
-  const fileHashes = new Map<string, string>();
-  for (const f of localFiles) {
-    try {
-      fileHashes.set(relative(repoDir, f), computeFileHash(f));
-    } catch (err) {
-      log.warn('Failed to compute file hash', { file: f, error: String(err) });
-    }
-  }
-
-  const localGraphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes);
-
-  // Merge with main graph (or use local only)
-  const mergedGraph = mainGraph ? mergeGraphs(mainGraph, localGraphData, opts.files) : localGraphData;
-
-  // Analyze
-  const blastRadius = computeBlastRadius(mergedGraph, opts.files);
-  const riskScore = computeRiskScore(mergedGraph, opts.files, blastRadius);
-  const testGaps = findTestGaps(mergedGraph, opts.files);
-
-  const output: AnalysisOutput = {
-    blast_radius: blastRadius,
-    risk_score: riskScore,
-    test_gaps: testGaps,
-  };
-
-  writeFileSync(opts.out, JSON.stringify(output, null, 2));
-}

package/src/commands/communities.ts

@@ -1,19 +0,0 @@
-import { writeFileSync } from 'fs';
-import { detectCommunities } from '../analysis/communities';
-import { loadGraph } from '../graph/loader';
-
-interface CommunitiesCommandOptions {
-  graph: string;
-  out: string;
-  minSize: number;
-  depth: number;
-}
-
-export function executeCommunities(opts: CommunitiesCommandOptions): void {
-  const graph = loadGraph(opts.graph);
-  const result = detectCommunities(graph, { depth: opts.depth, minSize: opts.minSize });
-  writeFileSync(opts.out, JSON.stringify(result, null, 2));
-  process.stderr.write(
-    `Communities: ${result.summary.total_communities} detected, avg cohesion ${result.summary.avg_cohesion}, ${result.summary.high_coupling_pairs} high-coupling pairs\n`,
-  );
-}

package/src/commands/context.ts

@@ -1,182 +0,0 @@
-import { readFileSync, rmSync, writeFileSync } from 'fs';
-import { resolve } from 'path';
-import { buildContextV2 } from '../analysis/context-builder';
-import { formatPrompt } from '../analysis/prompt-formatter';
-import { mergeGraphs } from '../graph/merger';
-import type { GraphData, MainGraphInput } from '../graph/types';
-import { log } from '../shared/logger';
-import { GraphInputSchema } from '../shared/schemas';
-import { createSecureTempFile } from '../shared/temp';
-import { executeParse } from './parse';
-
-interface ContextOptions {
-  repoDir: string;
-  files: string[];
-  graph?: string;
-  out: string;
-  minConfidence: number;
-  maxDepth: number;
-  format: 'json' | 'prompt';
-}
-
-export async function executeContext(opts: ContextOptions): Promise<void> {
-  const repoDir = resolve(opts.repoDir);
-
-  log.info('context: starting', {
-    files: opts.files,
-    repoDir,
-    graph: opts.graph ?? null,
-    format: opts.format,
-    minConfidence: opts.minConfidence,
-    maxDepth: opts.maxDepth,
-  });
-
-  // Parse changed files using secure temp
-  const tmp = createSecureTempFile('ctx');
-  try {
-    await executeParse({
-      repoDir,
-      files: opts.files,
-      all: false,
-      out: tmp.filePath,
-    });
-    const parseResult = JSON.parse(readFileSync(tmp.filePath, 'utf-8'));
-
-    log.info('context: parse done', {
-      nodes: parseResult.nodes?.length ?? 0,
-      edges: parseResult.edges?.length ?? 0,
-    });
-
-    // Load and merge with main graph if provided
-    let mergedGraph: GraphData;
-    let oldGraph: GraphData | null = null;
-
-    if (opts.graph) {
-      let raw: unknown;
-      try {
-        raw = JSON.parse(readFileSync(opts.graph, 'utf-8'));
-      } catch (_err) {
-        process.stderr.write(`Error: Failed to read --graph file: ${opts.graph}\n`);
-        process.exit(1);
-      }
-      const validated = GraphInputSchema.safeParse(raw);
-      if (!validated.success) {
-        process.stderr.write(`Error: Invalid graph JSON: ${validated.error.message}\n`);
-        process.exit(1);
-      }
-      const changedSet = new Set(opts.files);
-      const sameBranch = detectSameBranch(validated.data.nodes, parseResult.nodes, changedSet);
-
-      log.info('context: baseline graph loaded', {
-        graphNodes: validated.data.nodes.length,
-        graphEdges: validated.data.edges.length,
-        sameBranch,
-      });
-
-      if (sameBranch) {
-        // --graph was built from the same commit (e.g. kodus-ai's parse --all on PR branch).
-        // Exclude changed files from oldGraph so diff detects their functions as "added"
-        // instead of falsely marking everything "unchanged".
-        oldGraph = {
-          nodes: validated.data.nodes.filter((n: { file_path: string }) => !changedSet.has(n.file_path)),
-          edges: validated.data.edges.filter((e: { file_path: string }) => !changedSet.has(e.file_path)),
-        };
-        log.debug('Same-branch detected: excluding changed files from baseline', {
-          changedFiles: opts.files.length,
-        });
-      } else {
-        oldGraph = { nodes: validated.data.nodes, edges: validated.data.edges };
-      }
-
-      const mainGraph: MainGraphInput = {
-        repo_id: '',
-        sha: '',
-        nodes: validated.data.nodes,
-        edges: validated.data.edges,
-      };
-      mergedGraph = mergeGraphs(mainGraph, parseResult, opts.files);
-    } else {
-      mergedGraph = { nodes: parseResult.nodes, edges: parseResult.edges };
-    }
-
-    // Build V2 context
-    const output = buildContextV2({
-      mergedGraph,
-      oldGraph,
-      changedFiles: opts.files,
-      minConfidence: opts.minConfidence,
-      maxDepth: opts.maxDepth,
-    });
-
-    log.info('context: analysis done', {
-      changedFunctions: output.analysis.changed_functions.length,
-      diff: output.analysis.structural_diff.summary,
-      blastRadius: output.analysis.blast_radius.total_functions,
-      risk: `${output.analysis.risk.level} (${output.analysis.risk.score})`,
-      testGaps: output.analysis.test_gaps.length,
-      affectedFlows: output.analysis.affected_flows.length,
-      duration_ms: output.analysis.metadata.duration_ms,
-    });
-
-    if (opts.format === 'prompt') {
-      writeFileSync(opts.out, formatPrompt(output));
-    } else {
-      writeFileSync(opts.out, JSON.stringify(output, null, 2));
-    }
-  } finally {
-    try {
-      rmSync(tmp.dir, { recursive: true, force: true });
-    } catch (err) {
-      log.debug('Failed to clean up temp dir', { dir: tmp.dir, error: String(err) });
-    }
-  }
-}
-
-/**
- * Detect if --graph was built from the same commit as the current repo.
- * Compares file_hash values for changed files between the graph and the fresh parse.
- * When hashes match, the graph can't serve as a baseline for diff — it IS the new state.
- */
-function detectSameBranch(
-  graphNodes: Array<{ file_path: string; file_hash: string }>,
-  parseNodes: Array<{ file_path: string; file_hash: string }>,
-  changedFiles: Set<string>,
-): boolean {
-  const graphHashes = new Map<string, string>();
-  for (const n of graphNodes) {
-    if (changedFiles.has(n.file_path) && n.file_hash && !graphHashes.has(n.file_path)) {
-      graphHashes.set(n.file_path, n.file_hash);
-    }
-  }
-
-  // No overlap means graph has no nodes for changed files — not same-branch scenario
-  if (graphHashes.size === 0) {
-    log.debug('detectSameBranch: no graph hashes for changed files');
-    return false;
-  }
-
-  const parseHashes = new Map<string, string>();
-  for (const n of parseNodes) {
-    if (n.file_hash && !parseHashes.has(n.file_path)) {
-      parseHashes.set(n.file_path, n.file_hash);
-    }
-  }
-
-  // If any overlapping file has different hash → different branch
-  for (const [file, hash] of graphHashes) {
-    const parseHash = parseHashes.get(file);
-    if (parseHash && parseHash !== hash) {
-      log.debug('detectSameBranch: hash mismatch → different branch', {
-        file,
-        graphHash: hash.substring(0, 8),
-        parseHash: parseHash.substring(0, 8),
-      });
-      return false;
-    }
-  }
-
-  log.debug('detectSameBranch: all hashes match → same branch', {
-    filesCompared: graphHashes.size,
-  });
-  return true;
-}

package/src/commands/diff.ts

@@ -1,96 +0,0 @@
-import { execSync } from 'child_process';
-import { existsSync, writeFileSync } from 'fs';
-import { relative, resolve } from 'path';
-import { performance } from 'perf_hooks';
-import { computeStructuralDiff } from '../analysis/diff';
-import { buildGraphData } from '../graph/builder';
-import { loadGraph } from '../graph/loader';
-import type { ImportEdge } from '../graph/types';
-import { parseBatch } from '../parser/batch';
-import { discoverFiles } from '../parser/discovery';
-import { resolveAllCalls } from '../resolver/call-resolver';
-import { createImportMap } from '../resolver/import-map';
-import { loadTsconfigAliases, resolveImport } from '../resolver/import-resolver';
-import { createSymbolTable } from '../resolver/symbol-table';
-import { computeFileHash } from '../shared/file-hash';
-
-interface DiffCommandOptions {
-  repoDir: string;
-  base?: string;
-  files?: string[];
-  graph: string;
-  out: string;
-}
-
-export async function executeDiff(opts: DiffCommandOptions): Promise<void> {
-  const t0 = performance.now();
-  const repoDir = resolve(opts.repoDir);
-
-  // Resolve changed files
-  let changedFiles: string[];
-  if (opts.base) {
-    try {
-      const output = execSync(`git diff --name-only ${opts.base}`, { cwd: repoDir, encoding: 'utf-8' });
-      changedFiles = output.trim().split('\n').filter(Boolean);
-    } catch (err) {
-      process.stderr.write(`Error: failed to run git diff with base "${opts.base}": ${String(err)}\n`);
-      process.exit(1);
-    }
-  } else {
-    changedFiles = opts.files!;
-  }
-
-  process.stderr.write(`[1/4] ${changedFiles.length} changed files\n`);
-
-  // Load old graph
-  const graphPath = resolve(opts.graph);
-  if (!existsSync(graphPath)) {
-    process.stderr.write(`Error: graph file not found: ${graphPath}\n`);
-    process.exit(1);
-  }
-  const oldGraph = loadGraph(graphPath);
-  process.stderr.write(`[2/4] Loaded previous graph (${oldGraph.nodes.length} nodes)\n`);
-
-  // Re-parse changed files
-  const absFiles = discoverFiles(repoDir, changedFiles);
-  const rawGraph = await parseBatch(absFiles, repoDir);
-
-  const tsconfigAliases = loadTsconfigAliases(repoDir);
-  const symbolTable = createSymbolTable();
-  const importMap = createImportMap();
-  const importEdges: ImportEdge[] = [];
-
-  for (const f of rawGraph.functions) symbolTable.add(f.file, f.name, f.qualified);
-  for (const c of rawGraph.classes) symbolTable.add(c.file, c.name, c.qualified);
-  for (const i of rawGraph.interfaces) symbolTable.add(i.file, i.name, i.qualified);
-
-  for (const imp of rawGraph.imports) {
-    const langKey = imp.lang === 'python' ? 'python' : imp.lang === 'ruby' ? 'ruby' : 'typescript';
-    const resolved = resolveImport(resolve(repoDir, imp.file), imp.module, langKey, repoDir, tsconfigAliases);
-    const resolvedRel = resolved ? relative(repoDir, resolved) : null;
-    importEdges.push({ source: imp.file, target: resolvedRel || imp.module, resolved: !!resolvedRel, line: imp.line });
-    const target = resolvedRel || imp.module;
-    for (const name of imp.names) importMap.add(imp.file, name, target);
-  }
-
-  const { callEdges } = resolveAllCalls(rawGraph.rawCalls, rawGraph.diMaps, symbolTable, importMap);
-
-  const fileHashes = new Map<string, string>();
-  for (const f of absFiles) {
-    try {
-      fileHashes.set(relative(repoDir, f), computeFileHash(f));
-    } catch {}
-  }
-
-  const newGraphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes);
-  process.stderr.write(`[3/4] Re-parsed ${absFiles.length} files (${newGraphData.nodes.length} nodes)\n`);
-
-  // Compute diff
-  const relChangedFiles = changedFiles.map((f) => (f.startsWith('/') ? relative(repoDir, f) : f));
-  const result = computeStructuralDiff(oldGraph, newGraphData.nodes, newGraphData.edges, relChangedFiles);
-  process.stderr.write(
-    `[4/4] Diff: +${result.summary.added} -${result.summary.removed} ~${result.summary.modified} nodes (${Math.round(performance.now() - t0)}ms)\n`,
-  );
-
-  writeFileSync(opts.out, JSON.stringify(result, null, 2));
-}

package/src/commands/flows.ts

@@ -1,19 +0,0 @@
-import { writeFileSync } from 'fs';
-import { detectFlows } from '../analysis/flows';
-import { loadGraph } from '../graph/loader';
-
-interface FlowsCommandOptions {
-  graph: string;
-  out: string;
-  maxDepth: number;
-  type: 'test' | 'http' | 'all';
-}
-
-export function executeFlows(opts: FlowsCommandOptions): void {
-  const graph = loadGraph(opts.graph);
-  const result = detectFlows(graph, { maxDepth: opts.maxDepth, type: opts.type });
-  writeFileSync(opts.out, JSON.stringify(result, null, 2));
-  process.stderr.write(
-    `Flows: ${result.summary.total_flows} detected (test:${result.summary.by_type.test} http:${result.summary.by_type.http}), avg depth ${result.summary.avg_depth}\n`,
-  );
-}

package/src/commands/parse.ts

@@ -1,124 +0,0 @@
-import { resolve, relative } from 'path';
-import { performance } from 'perf_hooks';
-import { buildGraphData } from '../graph/builder';
-import { writeGraphJSON } from '../graph/json-writer';
-import type { ImportEdge } from '../graph/types';
-import { parseBatch } from '../parser/batch';
-import { discoverFiles } from '../parser/discovery';
-import { resolveAllCalls } from '../resolver/call-resolver';
-import { createImportMap } from '../resolver/import-map';
-import { loadTsconfigAliases, resolveImport } from '../resolver/import-resolver';
-import { buildReExportMap } from '../resolver/re-export-resolver';
-import { createSymbolTable } from '../resolver/symbol-table';
-import { computeFileHash } from '../shared/file-hash';
-import { log } from '../shared/logger';
-
-export interface ParseOptions {
-  repoDir: string;
-  files?: string[];
-  all: boolean;
-  out: string;
-  include?: string[];
-  exclude?: string[];
-}
-
-export async function executeParse(opts: ParseOptions): Promise<void> {
-  const t0 = performance.now();
-  const repoDir = resolve(opts.repoDir);
-
-  // Phase 1: Discover files
-  const files = discoverFiles(repoDir, opts.all ? undefined : opts.files, opts.include, opts.exclude);
-  process.stderr.write(`[1/5] Discovered ${files.length} files\n`);
-
-  // Phase 2: Parse + extract
-  let rawGraph = await parseBatch(files, repoDir);
-  process.stderr.write(
-    `[2/5] Parsed ${rawGraph.functions.length} functions, ${rawGraph.classes.length} classes, ${rawGraph.rawCalls.length} call sites\n`,
-  );
-
-  // Phase 3: Resolve imports
-  const tsconfigAliases = loadTsconfigAliases(repoDir);
-  let symbolTable = createSymbolTable();
-  let importMap = createImportMap();
-  let importEdges: ImportEdge[] = [];
-
-  for (const f of rawGraph.functions) symbolTable.add(f.file, f.name, f.qualified);
-  for (const c of rawGraph.classes) symbolTable.add(c.file, c.name, c.qualified);
-  for (const i of rawGraph.interfaces) symbolTable.add(i.file, i.name, i.qualified);
-
-  // Pre-resolve re-exports so barrel imports follow through to actual definitions
-  const barrelMap = buildReExportMap(rawGraph.reExports, repoDir, tsconfigAliases);
-
-  for (const imp of rawGraph.imports) {
-    const langKey = imp.lang === 'python' ? 'python' : imp.lang === 'ruby' ? 'ruby' : 'typescript';
-    const resolved = resolveImport(resolve(repoDir, imp.file), imp.module, langKey, repoDir, tsconfigAliases);
-    const resolvedRel = resolved ? relative(repoDir, resolved) : null;
-    importEdges.push({
-      source: imp.file,
-      target: resolvedRel || imp.module,
-      resolved: !!resolvedRel,
-      line: imp.line,
-    });
-    const target = resolvedRel || imp.module;
-    for (const name of imp.names) {
-      // If target is a barrel file, follow re-exports to find the actual definition
-      let finalTarget = target;
-      if (resolvedRel) {
-        const reExportedFiles = barrelMap.get(resolvedRel);
-        if (reExportedFiles) {
-          for (const reFile of reExportedFiles) {
-            if (symbolTable.lookupExact(reFile, name)) {
-              finalTarget = reFile;
-              break;
-            }
-          }
-        }
-      }
-      importMap.add(imp.file, name, finalTarget);
-    }
-  }
-
-  process.stderr.write(
-    `[3/5] Resolved ${importEdges.filter((e) => e.resolved).length}/${importEdges.length} imports\n`,
-  );
-
-  // Phase 4: Resolve calls
-  let { callEdges, stats } = resolveAllCalls(rawGraph.rawCalls, rawGraph.diMaps, symbolTable, importMap);
-  process.stderr.write(
-    `[4/5] Resolved ${callEdges.length} calls (DI:${stats.di} same:${stats.same} import:${stats.import} unique:${stats.unique} ambiguous:${stats.ambiguous} noise:${stats.noise})\n`,
-  );
-
-  // Phase 5: Build output
-  const fileHashes = new Map<string, string>();
-  for (const f of files) {
-    try {
-      fileHashes.set(relative(repoDir, f), computeFileHash(f));
-    } catch (err) {
-      log.warn('Failed to compute file hash', { file: f, error: String(err) });
-    }
-  }
-
-  const parseErrors = rawGraph.parseErrors;
-  const extractErrors = rawGraph.extractErrors;
-  const graphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes);
-  process.stderr.write(`[5/5] Built graph: ${graphData.nodes.length} nodes, ${graphData.edges.length} edges\n`);
-
-  // Release intermediaries — no longer needed after buildGraphData
-  rawGraph = null as any;
-  symbolTable = null as any;
-  importMap = null as any;
-  callEdges = null as any;
-  importEdges = null as any;
-
-  const metadata = {
-    repo_dir: repoDir,
-    files_parsed: files.length,
-    total_nodes: graphData.nodes.length,
-    total_edges: graphData.edges.length,
-    duration_ms: Math.round(performance.now() - t0),
-    parse_errors: parseErrors,
-    extract_errors: extractErrors,
-  };
-
-  writeGraphJSON(opts.out, metadata, graphData.nodes, graphData.edges);
-}

package/src/commands/search.ts

@@ -1,41 +0,0 @@
-import { writeFileSync } from 'fs';
-import { findCallees, findCallers, searchNodes } from '../analysis/search';
-import { loadGraph } from '../graph/loader';
-import type { GraphNode } from '../graph/types';
-
-interface SearchCommandOptions {
-  graph: string;
-  query?: string;
-  kind?: string;
-  file?: string;
-  callersOf?: string;
-  calleesOf?: string;
-  limit: number;
-  out?: string;
-}
-
-export function executeSearch(opts: SearchCommandOptions): void {
-  const graph = loadGraph(opts.graph);
-
-  let results: GraphNode[];
-  let queryInfo: Record<string, string | null>;
-
-  if (opts.callersOf) {
-    results = findCallers(graph, opts.callersOf);
-    queryInfo = { callers_of: opts.callersOf, kind: null, file: null };
-  } else if (opts.calleesOf) {
-    results = findCallees(graph, opts.calleesOf);
-    queryInfo = { callees_of: opts.calleesOf, kind: null, file: null };
-  } else {
-    results = searchNodes(graph, { query: opts.query, kind: opts.kind, file: opts.file, limit: opts.limit });
-    queryInfo = { pattern: opts.query || null, kind: opts.kind || null, file: opts.file || null };
-  }
-
-  const output = JSON.stringify({ results, total: results.length, query: queryInfo }, null, 2);
-
-  if (opts.out) {
-    writeFileSync(opts.out, output);
-  } else {
-    process.stdout.write(`${output}\n`);
-  }
-}