scip-query 0.1.0

package/src/queries/complexity.ts

@@ -0,0 +1,152 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ScipDatabase } from '../db.js';
+import { findFirstSymbolMatch, getCalleeRowsForSymbol } from '../query-support.js';
+import type { ComplexityResult } from '../types.js';
+import { shortenSymbol } from '../symbol-parser.js';
+
+/**
+ * Per-symbol complexity analysis combining source-level branch counting
+ * with index-level metrics (fan-in, fan-out, callee count).
+ *
+ * Branch counting uses language-aware regex. The language is read from
+ * the SCIP documents table, so it works for any indexed language.
+ */
+export function complexity(
+  db: ScipDatabase,
+  symbolPattern: string,
+): ComplexityResult | null {
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (!match) return null;
+
+  // Get language
+  const doc = db.get<{ language: string | null }>(
+    `SELECT language FROM documents WHERE relative_path = ?`,
+    match.relativePath,
+  );
+  const language = doc?.language ?? 'unknown';
+
+  // Read source for branch counting
+  const filePath = join(db.config.projectRoot, match.relativePath);
+  let source = '';
+  try {
+    const lines = readFileSync(filePath, 'utf-8').split('\n');
+    source = lines.slice(match.startLine, match.endLine + 1).join('\n');
+  } catch {
+    // If we can't read the file, just skip branch counting
+  }
+
+  const branches = countBranches(source, language);
+  const loc = match.endLine - match.startLine + 1;
+
+  // Callee count
+  const callees = getCalleeRowsForSymbol(db, match);
+  const uniqueCallees = new Set(callees.map((c) => c.symbol));
+
+  // Fan-in
+  const fanInRow = db.get<{ c: number }>(
+    `SELECT COUNT(DISTINCT c.document_id) AS c
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    WHERE m.symbol_id = ? AND m.role = 0`,
+    match.symbolId,
+  );
+
+  // Fan-out (callees in other files)
+  const fanOut = new Set(
+    callees.filter((c) => c.file !== match.relativePath).map((c) => c.symbol),
+  ).size;
+
+  return {
+    symbol: match.symbol,
+    shortName: shortenSymbol(match.symbol),
+    relativePath: match.relativePath,
+    startLine: match.startLine,
+    endLine: match.endLine,
+    loc,
+    branches,
+    cyclomaticEstimate: branches + 1,
+    calleeCount: uniqueCallees.size,
+    fanIn: fanInRow?.c ?? 0,
+    fanOut,
+  };
+}
+
+/**
+ * Count branch points in source code using language-aware regex.
+ * Works across all SCIP-supported languages.
+ */
+function countBranches(source: string, language: string): number {
+  // Strip comments and strings to avoid false positives
+  const stripped = stripCommentsAndStrings(source);
+  let count = 0;
+
+  // Universal branch keywords (work across most C-family languages)
+  const universalPatterns = [
+    /\bif\b/g,
+    /\belse\s+if\b/g,
+    /\belse\b/g,
+    /\bfor\b/g,
+    /\bwhile\b/g,
+    /\bswitch\b/g,
+    /\bcase\b/g,
+    /\bcatch\b/g,
+    /\?\s*[^?]/g,    // ternary (but not ??)
+    /&&/g,
+    /\|\|/g,
+  ];
+
+  for (const pattern of universalPatterns) {
+    const matches = stripped.match(pattern);
+    if (matches) count += matches.length;
+  }
+
+  // Language-specific patterns
+  if (language === 'python') {
+    const pyPatterns = [/\belif\b/g, /\bexcept\b/g, /\bfinally\b/g];
+    for (const p of pyPatterns) {
+      const m = stripped.match(p);
+      if (m) count += m.length;
+    }
+  } else if (language === 'rust') {
+    const rustPatterns = [/\bmatch\b/g, /=>/g, /\bloop\b/g];
+    for (const p of rustPatterns) {
+      const m = stripped.match(p);
+      if (m) count += m.length;
+    }
+  } else if (language === 'ruby') {
+    const rubyPatterns = [/\belsif\b/g, /\bunless\b/g, /\brescue\b/g, /\bwhen\b/g];
+    for (const p of rubyPatterns) {
+      const m = stripped.match(p);
+      if (m) count += m.length;
+    }
+  } else if (language === 'go') {
+    const goPatterns = [/\bselect\b/g, /\bdefer\b/g];
+    for (const p of goPatterns) {
+      const m = stripped.match(p);
+      if (m) count += m.length;
+    }
+  }
+
+  return count;
+}
+
+/**
+ * Rough strip of comments and string literals to reduce false positives
+ * in branch counting. Not perfect but good enough for estimation.
+ */
+function stripCommentsAndStrings(source: string): string {
+  return source
+    // Block comments
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    // Line comments
+    .replace(/\/\/.*/g, '')
+    // Python/Ruby line comments
+    .replace(/#.*/g, '')
+    // Double-quoted strings
+    .replace(/"(?:[^"\\]|\\.)*"/g, '""')
+    // Single-quoted strings
+    .replace(/'(?:[^'\\]|\\.)*'/g, "''")
+    // Template literals
+    .replace(/`(?:[^`\\]|\\.)*`/g, '``');
+}

package/src/queries/convergence.ts

@@ -0,0 +1,82 @@
+import type { ScipDatabase } from '../db.js';
+import { findFirstSymbolMatch, getCalleeRowsForSymbol } from '../query-support.js';
+import type { ConvergenceResult } from '../types.js';
+import { shortenSymbol } from '../symbol-parser.js';
+
+/**
+ * Given two similar symbols, show what a consolidated version would look like.
+ * The shared callee set becomes the common body. The unique callees become
+ * the parameterization points.
+ */
+export function convergence(
+  db: ScipDatabase,
+  symbolPatternA: string,
+  symbolPatternB: string,
+): ConvergenceResult | null {
+  const matchA = findFirstSymbolMatch(db, symbolPatternA);
+  const matchB = findFirstSymbolMatch(db, symbolPatternB);
+
+  if (!matchA || !matchB) return null;
+
+  const calleesA = new Set(
+    getCalleeRowsForSymbol(db, matchA).map((r) => r.symbol),
+  );
+  const calleesB = new Set(
+    getCalleeRowsForSymbol(db, matchB).map((r) => r.symbol),
+  );
+
+  const shared: string[] = [];
+  for (const c of calleesA) {
+    if (calleesB.has(c)) shared.push(c);
+  }
+
+  const uniqueA: string[] = [];
+  for (const c of calleesA) {
+    if (!calleesB.has(c)) uniqueA.push(c);
+  }
+
+  const uniqueB: string[] = [];
+  for (const c of calleesB) {
+    if (!calleesA.has(c)) uniqueB.push(c);
+  }
+
+  const union = new Set([...calleesA, ...calleesB]);
+  const similarity = union.size > 0 ? shared.length / union.size : 0;
+
+  // Generate a consolidation strategy description
+  let strategy: string;
+  if (uniqueA.length === 0 && uniqueB.length === 0) {
+    strategy = 'These functions have identical callee sets. One can replace the other directly.';
+  } else if (uniqueA.length === 0) {
+    strategy = `A is a subset of B. A can be replaced by calling B (B does everything A does plus more).`;
+  } else if (uniqueB.length === 0) {
+    strategy = `B is a subset of A. B can be replaced by calling A (A does everything B does plus more).`;
+  } else if (uniqueA.length <= 2 && uniqueB.length <= 2) {
+    strategy = `Create a shared function with the ${shared.length} common callees. Pass the ${uniqueA.length + uniqueB.length} divergent callees as parameters or strategy callbacks.`;
+  } else {
+    strategy = `Extract the ${shared.length} shared callees into a common helper. Each function calls the helper plus its own unique logic (${uniqueA.length} callees in A, ${uniqueB.length} in B).`;
+  }
+
+  const locA = matchA.endLine - matchA.startLine + 1;
+  const locB = matchB.endLine - matchB.startLine + 1;
+
+  return {
+    symbolA: {
+      symbol: matchA.symbol,
+      shortName: shortenSymbol(matchA.symbol),
+      file: matchA.relativePath,
+      loc: locA,
+    },
+    symbolB: {
+      symbol: matchB.symbol,
+      shortName: shortenSymbol(matchB.symbol),
+      file: matchB.relativePath,
+      loc: locB,
+    },
+    similarity,
+    sharedCallees: shared.map(shortenSymbol),
+    uniqueToA: uniqueA.map(shortenSymbol),
+    uniqueToB: uniqueB.map(shortenSymbol),
+    consolidationStrategy: strategy,
+  };
+}

package/src/queries/coupling.ts

@@ -0,0 +1,99 @@
+import type { ScipDatabase } from '../db.js';
+import type { CouplingResult } from '../types.js';
+
+/**
+ * Measure coupling between two files: how many symbols do they share
+ * (symbols defined in one and referenced in the other, or vice versa).
+ */
+export function coupling(
+  db: ScipDatabase,
+  file1: string,
+  file2: string,
+): CouplingResult {
+  const row = db.get<{ shared: number }>(
+    `SELECT COUNT(DISTINCT gs.id) AS shared
+    FROM global_symbols gs
+    WHERE (
+      -- Defined in file1, referenced in file2
+      EXISTS (
+        SELECT 1 FROM defn_enclosing_ranges der
+        JOIN documents d ON der.document_id = d.id
+        WHERE der.symbol_id = gs.id AND d.relative_path LIKE ?
+      )
+      AND EXISTS (
+        SELECT 1 FROM mentions m
+        JOIN chunks c ON m.chunk_id = c.id
+        JOIN documents d ON c.document_id = d.id
+        WHERE m.symbol_id = gs.id AND m.role = 0 AND d.relative_path LIKE ?
+      )
+    ) OR (
+      -- Defined in file2, referenced in file1
+      EXISTS (
+        SELECT 1 FROM defn_enclosing_ranges der
+        JOIN documents d ON der.document_id = d.id
+        WHERE der.symbol_id = gs.id AND d.relative_path LIKE ?
+      )
+      AND EXISTS (
+        SELECT 1 FROM mentions m
+        JOIN chunks c ON m.chunk_id = c.id
+        JOIN documents d ON c.document_id = d.id
+        WHERE m.symbol_id = gs.id AND m.role = 0 AND d.relative_path LIKE ?
+      )
+    )`,
+    `%${file1}%`, `%${file2}%`,
+    `%${file2}%`, `%${file1}%`,
+  );
+
+  return {
+    file1,
+    file2,
+    sharedSymbols: row?.shared ?? 0,
+  };
+}
+
+/**
+ * Find the most coupled file pairs in the codebase.
+ */
+export function topCoupling(
+  db: ScipDatabase,
+  opts: { limit?: number; scope?: string } = {},
+): CouplingResult[] {
+  const { limit = 20, scope } = opts;
+  const scopeFilter = scope
+    ? `AND d1.relative_path LIKE '%${scope}%' AND d2.relative_path LIKE '%${scope}%'`
+    : '';
+
+  // Find file pairs that share the most symbols (one defines, other references)
+  const rows = db.all<{
+    file1: string;
+    file2: string;
+    shared: number;
+  }>(
+    `SELECT
+      def_d.relative_path AS file1,
+      ref_d.relative_path AS file2,
+      COUNT(DISTINCT gs.id) AS shared
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents ref_d ON c.document_id = ref_d.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents def_d ON der.document_id = def_d.id
+    WHERE m.role = 0
+      AND def_d.id != ref_d.id
+      ${db.pathExclusionsFor('def_d', 'ref_d')}
+      ${scopeFilter}
+    GROUP BY def_d.id, ref_d.id
+    ORDER BY shared DESC
+    LIMIT ?`,
+    limit,
+  );
+
+  return rows
+    .filter((r) => !db.isIgnored(r.file1) && !db.isIgnored(r.file2))
+    .map((r) => ({
+      file1: r.file1,
+      file2: r.file2,
+      sharedSymbols: r.shared,
+    }));
+}

package/src/queries/cycles.ts

@@ -0,0 +1,78 @@
+import type { ScipDatabase } from '../db.js';
+import { buildFileDepGraph } from '../query-support.js';
+import type { CycleResult } from '../types.js';
+
+/**
+ * Detect circular dependency chains between files.
+ * A cycle exists when file A depends on B, B depends on C, and C depends on A.
+ *
+ * Uses the same dependency edges as the `deps` command (symbol definitions
+ * referenced across files), then runs DFS cycle detection.
+ */
+export function cycles(
+  db: ScipDatabase,
+  opts: { scope?: string; maxDepth?: number } = {},
+): CycleResult[] {
+  const { scope, maxDepth = 10 } = opts;
+  const graph = buildFileDepGraph(db, scope);
+
+  // DFS cycle detection
+  const allCycles: CycleResult[] = [];
+  const visited = new Set<string>();
+  const inStack = new Set<string>();
+  const stack: string[] = [];
+
+  function dfs(node: string, depth: number): void {
+    if (depth > maxDepth) return;
+    if (inStack.has(node)) {
+      // Found a cycle — extract it from the stack
+      const cycleStart = stack.indexOf(node);
+      if (cycleStart !== -1) {
+        const cyclePath = stack.slice(cycleStart).concat(node);
+        // Normalize: start from the lexicographically smallest file
+        const minIdx = cyclePath.indexOf(
+          cyclePath.reduce((a, b) => (a < b ? a : b)),
+        );
+        const normalized = [
+          ...cyclePath.slice(minIdx, -1),
+          ...cyclePath.slice(0, minIdx),
+          cyclePath[minIdx]!,
+        ];
+        // Deduplicate
+        const key = normalized.join(' -> ');
+        if (!seenCycles.has(key)) {
+          seenCycles.add(key);
+          allCycles.push({ path: normalized });
+        }
+      }
+      return;
+    }
+    if (visited.has(node)) return;
+
+    visited.add(node);
+    inStack.add(node);
+    stack.push(node);
+
+    const neighbors = graph.get(node);
+    if (neighbors) {
+      for (const neighbor of neighbors) {
+        dfs(neighbor, depth + 1);
+      }
+    }
+
+    stack.pop();
+    inStack.delete(node);
+  }
+
+  const seenCycles = new Set<string>();
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      dfs(node, 0);
+    }
+  }
+
+  // Sort by cycle length (shorter cycles are more actionable)
+  allCycles.sort((a, b) => a.path.length - b.path.length);
+
+  return allCycles;
+}

package/src/queries/dataflow.ts

@@ -0,0 +1,128 @@
+import type { ScipDatabase } from '../db.js';
+import { findFirstSymbolMatch } from '../query-support.js';
+import type { DataflowResult } from '../types.js';
+import { shortenSymbol } from '../symbol-parser.js';
+
+/**
+ * Reference-level dataflow analysis: where does data around this symbol
+ * come from and where does it go?
+ *
+ * This is not value-level dataflow (we can't trace x = foo(); bar(x);
+ * as a chain). Instead it shows:
+ * - Where the symbol is defined and used
+ * - What other symbols appear in the same enclosing scope (co-occurring data)
+ * - What feeds into the function that defines it (producers)
+ * - What consumes the function that uses it (consumers)
+ *
+ * Language-agnostic: works with any SCIP index.
+ */
+export function dataflow(
+  db: ScipDatabase,
+  symbolPattern: string,
+): DataflowResult | null {
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (!match) return null;
+
+  // Definition sites (role=1)
+  const defSites = db.all<{ file: string; line: number }>(
+    `SELECT d.relative_path AS file, c.start_line AS line
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d ON c.document_id = d.id
+    WHERE m.symbol_id = ? AND m.role = 1
+    ORDER BY d.relative_path, c.start_line`,
+    match.symbolId,
+  );
+
+  // Usage sites (role=0) with enclosing symbol
+  const usageSites = db.all<{
+    file: string;
+    line: number;
+    enclosing_symbol: string | null;
+  }>(
+    `SELECT d.relative_path AS file, c.start_line AS line,
+      (SELECT enc_gs.symbol
+       FROM defn_enclosing_ranges enc_der
+       JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
+       WHERE enc_der.document_id = d.id
+         AND enc_der.start_line <= c.start_line
+         AND enc_der.end_line >= c.end_line
+       ORDER BY (enc_der.end_line - enc_der.start_line) ASC
+       LIMIT 1
+      ) AS enclosing_symbol
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d ON c.document_id = d.id
+    WHERE m.symbol_id = ? AND m.role = 0
+      ${db.pathExclusionsFor('d')}
+    ORDER BY d.relative_path, c.start_line`,
+    match.symbolId,
+  );
+
+  // Producers: other symbols referenced within the same function that defines our target
+  const producers = db.all<{ symbol: string; file: string }>(
+    `SELECT DISTINCT other_gs.symbol, other_d.relative_path AS file
+    FROM mentions other_m
+    JOIN chunks other_c ON other_m.chunk_id = other_c.id
+    JOIN global_symbols other_gs ON other_m.symbol_id = other_gs.id
+    JOIN defn_enclosing_ranges other_der ON other_gs.id = other_der.symbol_id
+    JOIN documents other_d ON other_der.document_id = other_d.id
+    WHERE other_c.document_id = ?
+      AND other_c.start_line >= ? AND other_c.end_line <= ?
+      AND other_m.role = 0
+      AND other_gs.id != ?
+      ${db.symbolNoiseFor('other_gs')}
+      ${db.pathExclusionsFor('other_d')}
+    ORDER BY other_d.relative_path
+    LIMIT 30`,
+    match.documentId, match.startLine, match.endLine, match.symbolId,
+  );
+
+  // Consumers: symbols exported/defined by functions that reference our target
+  // (what does the data flow into after being used)
+  const consumers = db.all<{ symbol: string; file: string }>(
+    `SELECT DISTINCT consumer_gs.symbol, consumer_d.relative_path AS file
+    FROM mentions ref_m
+    JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
+    JOIN documents ref_d ON ref_c.document_id = ref_d.id
+    -- Find the enclosing function at each usage site
+    JOIN defn_enclosing_ranges enc_der
+      ON enc_der.document_id = ref_d.id
+      AND enc_der.start_line <= ref_c.start_line
+      AND enc_der.end_line >= ref_c.end_line
+    JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
+    -- Find other symbols defined by that enclosing function's file
+    JOIN mentions consumer_m ON consumer_m.symbol_id = enc_gs.id AND consumer_m.role = 0
+    JOIN chunks consumer_c ON consumer_m.chunk_id = consumer_c.id
+    JOIN documents consumer_d ON consumer_c.document_id = consumer_d.id
+    JOIN global_symbols consumer_gs ON consumer_m.symbol_id = consumer_gs.id
+    WHERE ref_m.symbol_id = ? AND ref_m.role = 0
+      AND consumer_d.id != ref_d.id
+      ${db.symbolNoiseFor('consumer_gs')}
+      ${db.pathExclusionsFor('consumer_d')}
+    ORDER BY consumer_d.relative_path
+    LIMIT 30`,
+    match.symbolId,
+  );
+
+  return {
+    symbol: match.symbol,
+    shortName: shortenSymbol(match.symbol),
+    relativePath: match.relativePath,
+    definitionSites: defSites.filter((s) => !db.isIgnored(s.file)),
+    usageSites: usageSites
+      .filter((s) => !db.isIgnored(s.file))
+      .map((s) => ({
+        file: s.file,
+        line: s.line,
+        enclosingSymbol: s.enclosing_symbol ?? '(top-level)',
+        enclosingShort: s.enclosing_symbol ? shortenSymbol(s.enclosing_symbol) : '(top-level)',
+      })),
+    producers: producers
+      .filter((p) => !db.isIgnored(p.file))
+      .map((p) => ({ symbol: p.symbol, shortName: shortenSymbol(p.symbol), file: p.file })),
+    consumers: consumers
+      .filter((c) => !db.isIgnored(c.file))
+      .map((c) => ({ symbol: c.symbol, shortName: shortenSymbol(c.symbol), file: c.file })),
+  };
+}

package/src/queries/dead.ts

@@ -0,0 +1,122 @@
+import type { ScipDatabase } from '../db.js';
+import { TEST_SUPPORT_PATH_PATTERNS, testFileExclusionSql } from '../query-support.js';
+import type { DeadOptions, DeadSymbolResult, DeadSummary } from '../types.js';
+import { shortenSymbol } from '../symbol-parser.js';
+
+/**
+ * Find dead exports: symbols defined locally with no cross-file references.
+ * Language-agnostic — works with any SCIP index.
+ */
+export function dead(db: ScipDatabase, opts: DeadOptions = {}): DeadSummary {
+  const {
+    scope,
+    minLoc = 1,
+    includeTests = false,
+    skipBarrels = false,
+    includeMembers = false,
+  } = opts;
+
+  const params: unknown[] = [minLoc];
+  let testFileExclusions = '';
+  let memberExclusion = '';
+
+  if (scope) {
+    params.push(`%${scope}%`);
+  }
+
+  if (!includeTests) {
+    testFileExclusions = `
+      AND ${testFileExclusionSql('d', TEST_SUPPORT_PATH_PATTERNS)}
+    `;
+  }
+
+  if (!includeMembers) {
+    memberExclusion = `AND gs.symbol NOT LIKE '%#%'`;
+  }
+
+  // Barrel file exclusion for the NOT EXISTS subquery
+  const barrelExclusions = skipBarrels
+    ? `AND ref_d.relative_path NOT LIKE '%/index.ts'
+       AND ref_d.relative_path NOT LIKE '%/index.js'
+       AND ref_d.relative_path NOT LIKE '%/mod.rs'
+       AND ref_d.relative_path NOT LIKE '%/__init__.py'`
+    : '';
+
+  const sql = `
+    SELECT
+      d.relative_path,
+      der.start_line,
+      der.end_line,
+      (der.end_line - der.start_line + 1) AS loc,
+      gs.symbol,
+      (SELECT COUNT(*) FROM mentions m2
+       JOIN chunks c2 ON m2.chunk_id = c2.id
+       WHERE m2.symbol_id = gs.id AND m2.role = 0 AND c2.document_id = d.id
+      ) AS same_file_refs
+    FROM global_symbols gs
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents d ON der.document_id = d.id
+    WHERE 1 = 1
+      ${db.pathExclusionsFor('d')}
+      ${db.symbolNoiseFor('gs')}
+      AND (der.end_line - der.start_line + 1) >= ?
+      ${scope ? 'AND d.relative_path LIKE ?' : ''}
+      ${testFileExclusions}
+      ${memberExclusion}
+      AND NOT EXISTS (
+        SELECT 1
+        FROM mentions ref_m
+        JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
+        JOIN documents ref_d ON ref_c.document_id = ref_d.id
+        WHERE ref_m.symbol_id = gs.id
+          AND ref_m.role = 0
+          AND ref_d.id != d.id
+          ${barrelExclusions}
+      )
+    ORDER BY (der.end_line - der.start_line + 1) DESC, d.relative_path, der.start_line
+  `;
+
+  const rows = db.all<{
+    relative_path: string;
+    start_line: number;
+    end_line: number;
+    loc: number;
+    symbol: string;
+    same_file_refs: number;
+  }>(sql, ...params);
+
+  let deadCodeCount = 0;
+  let fileInternalCount = 0;
+  let totalLoc = 0;
+
+  const symbols: DeadSymbolResult[] = rows
+    .filter((r) => !db.isIgnored(r.relative_path))
+    .map((r) => {
+      // dead-code: zero references anywhere (not even in same file) — safe to delete
+      // file-internal: referenced within same file but never cross-file —
+      //   may be a private helper (fine) or a forgotten export (needs review)
+      const kind = r.same_file_refs === 0 ? 'dead-code' : 'file-internal';
+      if (kind === 'dead-code') deadCodeCount++;
+      else fileInternalCount++;
+      totalLoc += r.loc;
+
+      return {
+        relativePath: r.relative_path,
+        startLine: r.start_line,
+        endLine: r.end_line,
+        loc: r.loc,
+        symbol: r.symbol,
+        shortName: shortenSymbol(r.symbol),
+        sameFileRefs: r.same_file_refs,
+        kind,
+      };
+    });
+
+  return {
+    symbols,
+    totalCount: symbols.length,
+    deadCodeCount,
+    fileInternalCount,
+    totalLoc,
+  };
+}