@optave/codegraph 3.3.1 → 3.4.0

package/src/presentation/queries-cli/{impact.js → impact.ts}

@@ -9,9 +9,123 @@ import {
 } from '../../domain/queries.js';
 import { outputResult } from '../../infrastructure/result-formatter.js';
 
-export function fileDeps(file, customDbPath, opts = {}) {
-  const data = fileDepsData(file, customDbPath, opts);
-  if (outputResult(data, 'results', opts)) return;
+interface SymbolRef {
+  kind: string;
+  name: string;
+  file: string;
+  line: number;
+}
+
+interface FileDepsImport {
+  file: string;
+  typeOnly?: boolean;
+}
+
+interface FileDepsResult {
+  file: string;
+  imports: FileDepsImport[];
+  importedBy: { file: string }[];
+  definitions: SymbolRef[];
+}
+
+interface FileDepsData {
+  results: FileDepsResult[];
+}
+
+interface CallerRef extends SymbolRef {
+  viaHierarchy?: string;
+}
+
+interface FnDepsResult extends SymbolRef {
+  callees: SymbolRef[];
+  callers: CallerRef[];
+  transitiveCallers: Record<string, SymbolRef[]>;
+}
+
+interface FnDepsData {
+  results: FnDepsResult[];
+}
+
+interface ImpactNode {
+  file: string;
+}
+
+interface ImpactData {
+  sources: string[];
+  levels: Record<string, ImpactNode[]>;
+  totalDependents: number;
+}
+
+interface FnImpactResult extends SymbolRef {
+  levels: Record<string, SymbolRef[]>;
+  totalDependents: number;
+}
+
+interface FnImpactData {
+  results: FnImpactResult[];
+}
+
+interface AffectedFunction extends SymbolRef {
+  transitiveCallers: number;
+}
+
+interface CoupledFile {
+  file: string;
+  coupledWith: string;
+  jaccard: number;
+  commitCount: number;
+}
+
+interface BoundaryViolation {
+  name: string;
+  file: string;
+  targetFile: string;
+  message?: string;
+}
+
+interface DiffSummary {
+  functionsChanged: number;
+  callersAffected: number;
+  filesAffected: number;
+  historicallyCoupledCount: number;
+  ownersAffected: number;
+  boundaryViolationCount: number;
+}
+
+interface DiffImpactData {
+  error?: string;
+  changedFiles: number;
+  affectedFunctions: AffectedFunction[];
+  historicallyCoupled?: CoupledFile[];
+  ownership?: {
+    affectedOwners: string[];
+    suggestedReviewers: string[];
+  };
+  boundaryViolations?: BoundaryViolation[];
+  boundaryViolationCount?: number;
+  summary?: DiffSummary;
+}
+
+interface OutputOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  csv?: boolean;
+  table?: boolean;
+  noTests?: boolean;
+  limit?: number;
+  offset?: number;
+  depth?: number;
+  format?: string;
+  staged?: boolean;
+  ref?: string;
+  file?: string;
+  kind?: string;
+  [key: string]: unknown;
+}
+
+export function fileDeps(file: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = fileDepsData(file, customDbPath, opts) as unknown as FileDepsData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
 
   if (data.results.length === 0) {
     console.log(`No file matching "${file}" in graph`);
@@ -37,9 +151,9 @@ export function fileDeps(file, customDbPath, opts = {}) {
   }
 }
 
-export function fnDeps(name, customDbPath, opts = {}) {
-  const data = fnDepsData(name, customDbPath, opts);
-  if (outputResult(data, 'results', opts)) return;
+export function fnDeps(name: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = fnDepsData(name, customDbPath, opts) as unknown as FnDepsData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
 
   if (data.results.length === 0) {
     console.log(`No function/method/class matching "${name}"`);
@@ -77,9 +191,9 @@ export function fnDeps(name, customDbPath, opts = {}) {
   }
 }
 
-export function impactAnalysis(file, customDbPath, opts = {}) {
-  const data = impactAnalysisData(file, customDbPath, opts);
-  if (outputResult(data, 'sources', opts)) return;
+export function impactAnalysis(file: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = impactAnalysisData(file, customDbPath, opts) as unknown as ImpactData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'sources', opts)) return;
 
   if (data.sources.length === 0) {
     console.log(`No file matching "${file}" in graph`);
@@ -93,8 +207,8 @@ export function impactAnalysis(file, customDbPath, opts = {}) {
   if (Object.keys(levels).length === 0) {
     console.log(`  No dependents found.`);
   } else {
-    for (const level of Object.keys(levels).sort((a, b) => a - b)) {
-      const nodes = levels[level];
+    for (const level of Object.keys(levels).sort((a, b) => Number(a) - Number(b))) {
+      const nodes = levels[level]!;
       console.log(
         `\n  ${'--'.repeat(parseInt(level, 10))} Level ${level} (${nodes.length} files):`,
       );
@@ -106,9 +220,9 @@ export function impactAnalysis(file, customDbPath, opts = {}) {
   console.log(`\n  Total: ${data.totalDependents} files transitively depend on "${file}"\n`);
 }
 
-export function fnImpact(name, customDbPath, opts = {}) {
-  const data = fnImpactData(name, customDbPath, opts);
-  if (outputResult(data, 'results', opts)) return;
+export function fnImpact(name: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = fnImpactData(name, customDbPath, opts) as unknown as FnImpactData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
 
   if (data.results.length === 0) {
     console.log(`No function/method/class matching "${name}"`);
@@ -120,7 +234,9 @@ export function fnImpact(name, customDbPath, opts = {}) {
     if (Object.keys(r.levels).length === 0) {
       console.log(`  No callers found.`);
     } else {
-      for (const [level, fns] of Object.entries(r.levels).sort((a, b) => a[0] - b[0])) {
+      for (const [level, fns] of Object.entries(r.levels).sort(
+        (a, b) => Number(a[0]) - Number(b[0]),
+      )) {
         const l = parseInt(level, 10);
         console.log(`  ${'--'.repeat(l)} Level ${level} (${fns.length} functions):`);
         for (const f of fns.slice(0, 20))
@@ -132,7 +248,7 @@ export function fnImpact(name, customDbPath, opts = {}) {
   }
 }
 
-function printDiffFunctions(data) {
+function printDiffFunctions(data: DiffImpactData): void {
   console.log(`\ndiff-impact: ${data.changedFiles} files changed\n`);
   console.log(`  ${data.affectedFunctions.length} functions changed:\n`);
   for (const fn of data.affectedFunctions) {
@@ -141,7 +257,7 @@ function printDiffFunctions(data) {
   }
 }
 
-function printDiffCoupled(data) {
+function printDiffCoupled(data: DiffImpactData): void {
   if (!data.historicallyCoupled?.length) return;
   console.log('\n  Historically coupled (not in static graph):\n');
   for (const c of data.historicallyCoupled) {
@@ -152,13 +268,13 @@ function printDiffCoupled(data) {
   }
 }
 
-function printDiffOwnership(data) {
+function printDiffOwnership(data: DiffImpactData): void {
   if (!data.ownership) return;
   console.log(`\n  Affected owners: ${data.ownership.affectedOwners.join(', ')}`);
   console.log(`  Suggested reviewers: ${data.ownership.suggestedReviewers.join(', ')}`);
 }
 
-function printDiffBoundaries(data) {
+function printDiffBoundaries(data: DiffImpactData): void {
   if (!data.boundaryViolations?.length) return;
   console.log(`\n  Boundary violations (${data.boundaryViolationCount}):\n`);
   for (const v of data.boundaryViolations) {
@@ -167,7 +283,7 @@ function printDiffBoundaries(data) {
   }
 }
 
-function printDiffSummary(summary) {
+function printDiffSummary(summary: DiffSummary | undefined): void {
   if (!summary) return;
   let line = `\n  Summary: ${summary.functionsChanged} functions changed -> ${summary.callersAffected} callers affected across ${summary.filesAffected} files`;
   if (summary.historicallyCoupledCount > 0) {
@@ -182,14 +298,14 @@ function printDiffSummary(summary) {
   console.log(`${line}\n`);
 }
 
-export function diffImpact(customDbPath, opts = {}) {
+export function diffImpact(customDbPath: string, opts: OutputOpts = {}): void {
   if (opts.format === 'mermaid') {
     console.log(diffImpactMermaid(customDbPath, opts));
     return;
   }
-  const data = diffImpactData(customDbPath, opts);
+  const data = diffImpactData(customDbPath, opts) as unknown as DiffImpactData;
   if (opts.format === 'json') opts = { ...opts, json: true };
-  if (outputResult(data, 'affectedFunctions', opts)) return;
+  if (outputResult(data as unknown as Record<string, unknown>, 'affectedFunctions', opts)) return;
 
   if (data.error) {
     console.log(data.error);

package/src/presentation/queries-cli/{inspect.js → inspect.ts}

@@ -10,9 +10,182 @@ import {
 } from '../../domain/queries.js';
 import { outputResult } from '../../infrastructure/result-formatter.js';
 
-export function where(target, customDbPath, opts = {}) {
-  const data = whereData(target, customDbPath, opts);
-  if (outputResult(data, 'results', opts)) return;
+interface SymbolRef {
+  kind: string;
+  name: string;
+  file: string;
+  line: number;
+}
+
+interface OutputOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  csv?: boolean;
+  table?: boolean;
+  noTests?: boolean;
+  limit?: number;
+  offset?: number;
+  depth?: number;
+  noSource?: boolean;
+  file?: string | boolean;
+  kind?: string;
+  [key: string]: unknown;
+}
+
+interface WhereSymbolResult {
+  kind: string;
+  name: string;
+  file: string;
+  line: number;
+  role?: string;
+  exported?: boolean;
+  uses: { file: string; line: number }[];
+}
+
+interface WhereFileResult {
+  file: string;
+  symbols: { name: string; line: number }[];
+  imports: string[];
+  importedBy: string[];
+  exported: string[];
+}
+
+interface WhereData {
+  mode: 'symbol' | 'file';
+  results: (WhereSymbolResult | WhereFileResult)[];
+}
+
+interface QueryNameCallee {
+  name: string;
+  edgeKind: string;
+  file: string;
+  line: number;
+}
+
+interface QueryNameResult extends SymbolRef {
+  callees: QueryNameCallee[];
+  callers: QueryNameCallee[];
+}
+
+interface QueryNameData {
+  results: QueryNameResult[];
+}
+
+interface ChildRef {
+  kind: string;
+  name: string;
+  line: number;
+}
+
+interface CallerRef extends SymbolRef {
+  viaHierarchy?: string;
+}
+
+interface CalleeRef extends SymbolRef {
+  summary?: string;
+  source?: string;
+}
+
+interface ContextResult extends SymbolRef {
+  endLine?: number;
+  role?: string;
+  signature?: { params?: string; returnType?: string };
+  children: ChildRef[];
+  complexity?: {
+    cognitive: number;
+    cyclomatic: number;
+    maxNesting: number;
+    maintainabilityIndex?: number;
+  };
+  source?: string;
+  callees: CalleeRef[];
+  callers: CallerRef[];
+  implementors?: SymbolRef[];
+  implements?: SymbolRef[];
+  relatedTests: {
+    file: string;
+    testCount: number;
+    testNames: string[];
+    source?: string;
+  }[];
+}
+
+interface ContextData {
+  results: ContextResult[];
+}
+
+interface ChildrenResult extends SymbolRef {
+  children: ChildRef[];
+}
+
+interface ChildrenData {
+  results: ChildrenResult[];
+}
+
+interface ExplainSymbol {
+  kind: string;
+  name: string;
+  line: number;
+  role?: string;
+  signature?: { params?: string; returnType?: string };
+  summary?: string;
+}
+
+interface FileExplainResult {
+  file: string;
+  lineCount?: number;
+  symbolCount: number;
+  publicApi: ExplainSymbol[];
+  internal: ExplainSymbol[];
+  imports: { file: string }[];
+  importedBy: { file: string }[];
+  dataFlow: { caller: string; callees: string[] }[];
+}
+
+interface FunctionExplainResult extends SymbolRef {
+  endLine?: number;
+  lineCount?: number;
+  summary?: string;
+  role?: string;
+  _depth?: number;
+  signature?: { params?: string; returnType?: string };
+  complexity?: {
+    cognitive: number;
+    cyclomatic: number;
+    maxNesting: number;
+    maintainabilityIndex?: number;
+  };
+  callees: SymbolRef[];
+  callers: SymbolRef[];
+  relatedTests: { file: string }[];
+  depDetails?: FunctionExplainResult[];
+}
+
+interface ExplainData {
+  kind: 'file' | 'function';
+  // biome-ignore lint/suspicious/noExplicitAny: union of file/function results
+  results: any[];
+}
+
+interface ImplementationsResult extends SymbolRef {
+  implementors: SymbolRef[];
+}
+
+interface ImplementationsData {
+  results: ImplementationsResult[];
+}
+
+interface InterfacesResult extends SymbolRef {
+  interfaces: SymbolRef[];
+}
+
+interface InterfacesData {
+  results: InterfacesResult[];
+}
+
+export function where(target: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = whereData(target, customDbPath, opts as Record<string, unknown>) as WhereData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
 
   if (data.results.length === 0) {
     console.log(
@@ -24,7 +197,7 @@ export function where(target, customDbPath, opts = {}) {
   }
 
   if (data.mode === 'symbol') {
-    for (const r of data.results) {
+    for (const r of data.results as WhereSymbolResult[]) {
       const roleTag = r.role ? ` [${r.role}]` : '';
       const tag = r.exported ? '  (exported)' : '';
       console.log(`\n${kindIcon(r.kind)} ${r.name}${roleTag}  ${r.file}:${r.line}${tag}`);
@@ -36,7 +209,7 @@ export function where(target, customDbPath, opts = {}) {
       }
     }
   } else {
-    for (const r of data.results) {
+    for (const r of data.results as WhereFileResult[]) {
       console.log(`\n# ${r.file}`);
       if (r.symbols.length > 0) {
         const symStrs = r.symbols.map((s) => `${s.name}:${s.line}`);
@@ -56,13 +229,13 @@ export function where(target, customDbPath, opts = {}) {
   console.log();
 }
 
-export function queryName(name, customDbPath, opts = {}) {
+export function queryName(name: string, customDbPath: string, opts: OutputOpts = {}): void {
   const data = queryNameData(name, customDbPath, {
     noTests: opts.noTests,
     limit: opts.limit,
     offset: opts.offset,
-  });
-  if (outputResult(data, 'results', opts)) return;
+  }) as QueryNameData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
 
   if (data.results.length === 0) {
     console.log(`No results for "${name}"`);
@@ -88,9 +261,9 @@ export function queryName(name, customDbPath, opts = {}) {
   }
 }
 
-export function context(name, customDbPath, opts = {}) {
-  const data = contextData(name, customDbPath, opts);
-  if (outputResult(data, 'results', opts)) return;
+export function context(name: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = contextData(name, customDbPath, opts as Record<string, unknown>) as ContextData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
 
   if (data.results.length === 0) {
     console.log(`No function/method/class matching "${name}"`);
@@ -102,9 +275,9 @@ export function context(name, customDbPath, opts = {}) {
   }
 }
 
-export function children(name, customDbPath, opts = {}) {
-  const data = childrenData(name, customDbPath, opts);
-  if (outputResult(data, 'results', opts)) return;
+export function children(name: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = childrenData(name, customDbPath, opts as Record<string, unknown>) as ChildrenData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
 
   if (data.results.length === 0) {
     console.log(`No symbol matching "${name}"`);
@@ -122,7 +295,7 @@ export function children(name, customDbPath, opts = {}) {
   }
 }
 
-function renderContextResult(r) {
+function renderContextResult(r: ContextResult): void {
   const lineRange = r.endLine ? `${r.line}-${r.endLine}` : `${r.line}`;
   const roleTag = r.role ? ` [${r.role}]` : '';
   console.log(`\n# ${r.name} (${r.kind})${roleTag} — ${r.file}:${lineRange}\n`);
@@ -222,7 +395,7 @@ function renderContextResult(r) {
   }
 }
 
-function renderFileExplain(r) {
+function renderFileExplain(r: FileExplainResult): void {
   const publicCount = r.publicApi.length;
   const internalCount = r.internal.length;
   const lineInfo = r.lineCount ? `${r.lineCount} lines, ` : '';
@@ -267,7 +440,7 @@ function renderFileExplain(r) {
   console.log();
 }
 
-function renderFunctionExplain(r, indent = '') {
+function renderFunctionExplain(r: FunctionExplainResult, indent = ''): void {
   const lineRange = r.endLine ? `${r.line}-${r.endLine}` : `${r.line}`;
   const lineInfo = r.lineCount ? `${r.lineCount} lines` : '';
   const summaryPart = r.summary ? ` | ${r.summary}` : '';
@@ -326,9 +499,9 @@ function renderFunctionExplain(r, indent = '') {
   console.log();
 }
 
-export function explain(target, customDbPath, opts = {}) {
-  const data = explainData(target, customDbPath, opts);
-  if (outputResult(data, 'results', opts)) return;
+export function explain(target: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = explainData(target, customDbPath, opts as Record<string, unknown>) as ExplainData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
 
   if (data.results.length === 0) {
     console.log(`No ${data.kind === 'file' ? 'file' : 'function/symbol'} matching "${target}"`);
@@ -337,18 +510,22 @@ export function explain(target, customDbPath, opts = {}) {
 
   if (data.kind === 'file') {
     for (const r of data.results) {
-      renderFileExplain(r);
+      renderFileExplain(r as FileExplainResult);
     }
   } else {
     for (const r of data.results) {
-      renderFunctionExplain(r);
+      renderFunctionExplain(r as FunctionExplainResult);
     }
   }
 }
 
-export function implementations(name, customDbPath, opts = {}) {
-  const data = implementationsData(name, customDbPath, opts);
-  if (outputResult(data, 'results', opts)) return;
+export function implementations(name: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = implementationsData(
+    name,
+    customDbPath,
+    opts as Record<string, unknown>,
+  ) as ImplementationsData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
 
   if (data.results.length === 0) {
     console.log(`No symbol matching "${name}"`);
@@ -369,9 +546,13 @@ export function implementations(name, customDbPath, opts = {}) {
   console.log();
 }
 
-export function interfaces(name, customDbPath, opts = {}) {
-  const data = interfacesData(name, customDbPath, opts);
-  if (outputResult(data, 'results', opts)) return;
+export function interfaces(name: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = interfacesData(
+    name,
+    customDbPath,
+    opts as Record<string, unknown>,
+  ) as InterfacesData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
 
   if (data.results.length === 0) {
     console.log(`No symbol matching "${name}"`);