@optave/codegraph 3.4.0 → 3.4.1

package/src/domain/parser.ts

@@ -5,6 +5,7 @@ import type { Tree } from 'web-tree-sitter';
 import { Language, Parser, Query } from 'web-tree-sitter';
 import { debug, warn } from '../infrastructure/logger.js';
 import { getNative, getNativePackageVersion, loadNative } from '../infrastructure/native.js';
+import { toErrorMessage } from '../shared/errors.js';
 import type {
   EngineMode,
   ExtractorOutput,
@@ -69,7 +70,6 @@ interface ParseEngineOpts {
 
 interface ResolvedEngine {
   name: 'native' | 'wasm';
-  // biome-ignore lint/suspicious/noExplicitAny: native addon has no type declarations
   native: any;
 }
 
@@ -171,7 +171,6 @@ export function disposeParsers(): void {
   _queryCache.clear();
   if (_cachedLanguages) {
     for (const [id, lang] of _cachedLanguages) {
-      // biome-ignore lint/suspicious/noExplicitAny: .delete() exists at runtime on WASM Language objects but is missing from typings
       if (lang && typeof (lang as any).delete === 'function') {
         try {
           (lang as any).delete();
@@ -197,7 +196,6 @@ export function getParser(parsers: Map<string, Parser | null>, filePath: string)
  * don't each need to create parsers and re-parse independently.
  * Only parses files whose extension is in SUPPORTED_EXTENSIONS.
  */
-// biome-ignore lint/suspicious/noExplicitAny: fileSymbols values have dynamic shape from extractors
 export async function ensureWasmTrees(
   fileSymbols: Map<string, any>,
   rootDir: string,
@@ -274,7 +272,6 @@ function resolveEngine(opts: ParseEngineOpts = {}): ResolvedEngine {
  *  - Backward compat for older native binaries missing js_name annotations
  *  - dataflow argFlows/mutations bindingType -> binding wrapper
  */
-// biome-ignore lint/suspicious/noExplicitAny: native addon result has no type declarations
 function patchNativeResult(r: any): ExtractorOutput {
   // lineCount: napi(js_name) emits "lineCount"; older binaries may emit "line_count"
   r.lineCount = r.lineCount ?? r.line_count ?? null;
@@ -433,7 +430,6 @@ export const SUPPORTED_EXTENSIONS: Set<string> = new Set(_extToLang.keys());
  * matches inside comments and string literals.
  * TODO: Remove once all published native binaries include typeMap extraction (>= 3.2.0)
  */
-// biome-ignore lint/suspicious/noExplicitAny: return shape matches native result typeMap
 async function backfillTypeMap(
   filePath: string,
   source?: string,
@@ -442,7 +438,8 @@ async function backfillTypeMap(
   if (!code) {
     try {
       code = fs.readFileSync(filePath, 'utf-8');
-    } catch {
+    } catch (e) {
+      debug(`backfillTypeMap: failed to read ${filePath}: ${toErrorMessage(e)}`);
       return { typeMap: new Map(), backfilled: false };
     }
   }
@@ -458,7 +455,9 @@ async function backfillTypeMap(
     if (extracted?.tree && typeof extracted.tree.delete === 'function') {
       try {
         extracted.tree.delete();
-      } catch {}
+      } catch (e) {
+        debug(`backfillTypeMap: WASM tree cleanup failed: ${toErrorMessage(e)}`);
+      }
     }
   }
 }
@@ -488,7 +487,6 @@ function wasmExtractSymbols(
   if (!entry) return null;
   const query = _queryCache.get(entry.id) ?? undefined;
   // Query (web-tree-sitter) is structurally compatible with TreeSitterQuery at runtime
-  // biome-ignore lint/suspicious/noExplicitAny: thin WASM wrapper type mismatch
   const symbols = entry.extractor(tree as any, filePath, query as any);
   return symbols ? { symbols, tree, langId: entry.id } : null;
 }
@@ -571,14 +569,16 @@ export async function parseFilesAuto(
               symbols.typeMap = extracted.symbols.typeMap;
               symbols._typeMapBackfilled = true;
             }
-          } catch {
-            /* skip — typeMap is a best-effort backfill */
+          } catch (e) {
+            debug(`batchExtract: typeMap backfill failed: ${toErrorMessage(e)}`);
           } finally {
             // Free the WASM tree to prevent memory accumulation across repeated builds
             if (extracted?.tree && typeof extracted.tree.delete === 'function') {
               try {
                 extracted.tree.delete();
-              } catch {}
+              } catch (e) {
+                debug(`batchExtract: WASM tree cleanup failed: ${toErrorMessage(e)}`);
+              }
             }
           }
         }
@@ -638,7 +638,6 @@ export function getActiveEngine(opts: ParseEngineOpts = {}): {
  * Create a native ParseTreeCache for incremental parsing.
  * Returns null if the native engine is unavailable (WASM fallback).
  */
-// biome-ignore lint/suspicious/noExplicitAny: native ParseTreeCache has no type declarations
 export function createParseTreeCache(): any {
   const native = loadNative();
   if (!native || !native.ParseTreeCache) return null;
@@ -648,7 +647,6 @@ export function createParseTreeCache(): any {
 /**
  * Parse a file incrementally using the cache, or fall back to full parse.
  */
-// biome-ignore lint/suspicious/noExplicitAny: cache is native ParseTreeCache with no type declarations
 export async function parseFileIncremental(
   cache: any,
   filePath: string,

package/src/domain/queries.ts

@@ -8,6 +8,7 @@
 
 // ── Re-export from dedicated module for backward compat ───────────────────
 export { isTestFile, TEST_PATTERN } from '../infrastructure/test-filter.js';
+export { diffImpactMermaid } from '../presentation/diff-impact-mermaid.js';
 export { iterListFunctions, iterRoles, iterWhere } from '../shared/generators.js';
 // ── Kind/edge constants (canonical source: kinds.js) ─────────────────────
 export {
@@ -24,11 +25,10 @@ export {
 export { kindIcon, normalizeSymbol } from '../shared/normalize.js';
 export { briefData } from './analysis/brief.js';
 export { contextData, explainData } from './analysis/context.js';
-export { fileDepsData, fnDepsData, pathData } from './analysis/dependencies.js';
+export { fileDepsData, filePathData, fnDepsData, pathData } from './analysis/dependencies.js';
 export { exportsData } from './analysis/exports.js';
 export {
   diffImpactData,
-  diffImpactMermaid,
   fnImpactData,
   impactAnalysisData,
 } from './analysis/impact.js';

package/src/domain/search/generator.ts

@@ -1,10 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import type BetterSqlite3 from 'better-sqlite3';
 import { closeDb, findDbPath, openDb } from '../../db/index.js';
 import { warn } from '../../infrastructure/logger.js';
 import { DbError } from '../../shared/errors.js';
-import type { NodeRow } from '../../types.js';
+import type { BetterSqlite3Database, NodeRow } from '../../types.js';
 import { embed, getModelConfig } from './models.js';
 import { buildSourceText } from './strategies/source.js';
 import { buildStructuredText } from './strategies/structured.js';
@@ -17,7 +16,7 @@ export function estimateTokens(text: string): number {
   return Math.ceil(text.length / 4);
 }
 
-function initEmbeddingsSchema(db: BetterSqlite3.Database): void {
+function initEmbeddingsSchema(db: BetterSqlite3Database): void {
   db.exec(`
     CREATE TABLE IF NOT EXISTS embeddings (
       node_id INTEGER PRIMARY KEY,
@@ -71,7 +70,7 @@ export async function buildEmbeddings(
     );
   }
 
-  const db = openDb(dbPath) as BetterSqlite3.Database;
+  const db = openDb(dbPath) as BetterSqlite3Database;
   initEmbeddingsSchema(db);
 
   db.exec('DELETE FROM embeddings');

package/src/extractors/csharp.ts

@@ -6,7 +6,7 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+import { extractModifierVisibility, findChild, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from C# files.
@@ -333,7 +333,7 @@ function extractCSharpTypeMapDepth(
   ctx: ExtractorOutput,
   depth: number,
 ): void {
-  if (depth >= 200) return;
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // local_declaration_statement → variable_declaration → type + variable_declarator(s)
   if (node.type === 'variable_declaration') {

package/src/extractors/go.ts

@@ -6,7 +6,7 @@ import type {
   TreeSitterTree,
   TypeMapEntry,
 } from '../types.js';
-import { findChild, goVisibility, nodeEndLine } from './helpers.js';
+import { findChild, goVisibility, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from Go files.
@@ -233,7 +233,7 @@ function setIfHigher(
 }
 
 function extractGoTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, depth: number): void {
-  if (depth >= 200) return;
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // var x MyType = ... or var x, y MyType → var_declaration > var_spec (confidence 0.9)
   if (node.type === 'var_spec') {

package/src/extractors/helpers.ts

@@ -1,5 +1,11 @@
 import type { TreeSitterNode } from '../types.js';
 
+/**
+ * Maximum recursion depth for tree-sitter AST walkers.
+ * Shared across all language extractors to prevent stack overflow on deeply nested ASTs.
+ */
+export const MAX_WALK_DEPTH = 200;
+
 export function nodeEndLine(node: TreeSitterNode): number {
   return node.endPosition.row + 1;
 }

package/src/extractors/javascript.ts

@@ -12,7 +12,7 @@ import type {
   TreeSitterTree,
   TypeMapEntry,
 } from '../types.js';
-import { findChild, nodeEndLine } from './helpers.js';
+import { findChild, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
 
 /** Built-in globals that start with uppercase but are not user-defined types. */
 const BUILTIN_GLOBALS: Set<string> = new Set([
@@ -102,44 +102,42 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
     const c: Record<string, TreeSitterNode> = Object.create(null);
     for (const cap of match.captures) c[cap.name] = cap.node;
 
-    if (c['fn_node']) {
+    if (c.fn_node) {
       // function_declaration
-      const fnChildren = extractParameters(c['fn_node']);
+      const fnChildren = extractParameters(c.fn_node);
       definitions.push({
-        name: c['fn_name']!.text,
+        name: c.fn_name!.text,
         kind: 'function',
-        line: c['fn_node'].startPosition.row + 1,
-        endLine: nodeEndLine(c['fn_node']),
+        line: c.fn_node.startPosition.row + 1,
+        endLine: nodeEndLine(c.fn_node),
         children: fnChildren.length > 0 ? fnChildren : undefined,
       });
-    } else if (c['varfn_name']) {
+    } else if (c.varfn_name) {
       // variable_declarator with arrow_function / function_expression
-      const declNode = c['varfn_name'].parent?.parent;
-      const line = declNode
-        ? declNode.startPosition.row + 1
-        : c['varfn_name'].startPosition.row + 1;
-      const varFnChildren = extractParameters(c['varfn_value']!);
+      const declNode = c.varfn_name.parent?.parent;
+      const line = declNode ? declNode.startPosition.row + 1 : c.varfn_name.startPosition.row + 1;
+      const varFnChildren = extractParameters(c.varfn_value!);
       definitions.push({
-        name: c['varfn_name'].text,
+        name: c.varfn_name.text,
         kind: 'function',
         line,
-        endLine: nodeEndLine(c['varfn_value']!),
+        endLine: nodeEndLine(c.varfn_value!),
         children: varFnChildren.length > 0 ? varFnChildren : undefined,
       });
-    } else if (c['cls_node']) {
+    } else if (c.cls_node) {
       // class_declaration
-      const className = c['cls_name']!.text;
-      const startLine = c['cls_node'].startPosition.row + 1;
-      const clsChildren = extractClassProperties(c['cls_node']);
+      const className = c.cls_name!.text;
+      const startLine = c.cls_node.startPosition.row + 1;
+      const clsChildren = extractClassProperties(c.cls_node);
       definitions.push({
         name: className,
         kind: 'class',
         line: startLine,
-        endLine: nodeEndLine(c['cls_node']),
+        endLine: nodeEndLine(c.cls_node),
         children: clsChildren.length > 0 ? clsChildren : undefined,
       });
       const heritage =
-        c['cls_node'].childForFieldName('heritage') || findChild(c['cls_node'], 'class_heritage');
+        c.cls_node.childForFieldName('heritage') || findChild(c.cls_node, 'class_heritage');
       if (heritage) {
         const superName = extractSuperclass(heritage);
         if (superName) classes.push({ name: className, extends: superName, line: startLine });
@@ -148,58 +146,58 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
           classes.push({ name: className, implements: iface, line: startLine });
         }
       }
-    } else if (c['meth_node']) {
+    } else if (c.meth_node) {
       // method_definition
-      const methName = c['meth_name']!.text;
-      const parentClass = findParentClass(c['meth_node']);
+      const methName = c.meth_name!.text;
+      const parentClass = findParentClass(c.meth_node);
       const fullName = parentClass ? `${parentClass}.${methName}` : methName;
-      const methChildren = extractParameters(c['meth_node']);
-      const methVis = extractVisibility(c['meth_node']);
+      const methChildren = extractParameters(c.meth_node);
+      const methVis = extractVisibility(c.meth_node);
       definitions.push({
         name: fullName,
         kind: 'method',
-        line: c['meth_node'].startPosition.row + 1,
-        endLine: nodeEndLine(c['meth_node']),
+        line: c.meth_node.startPosition.row + 1,
+        endLine: nodeEndLine(c.meth_node),
         children: methChildren.length > 0 ? methChildren : undefined,
         visibility: methVis,
       });
-    } else if (c['iface_node']) {
+    } else if (c.iface_node) {
       // interface_declaration (TS/TSX only)
-      const ifaceName = c['iface_name']!.text;
+      const ifaceName = c.iface_name!.text;
       definitions.push({
         name: ifaceName,
         kind: 'interface',
-        line: c['iface_node'].startPosition.row + 1,
-        endLine: nodeEndLine(c['iface_node']),
+        line: c.iface_node.startPosition.row + 1,
+        endLine: nodeEndLine(c.iface_node),
       });
       const body =
-        c['iface_node'].childForFieldName('body') ||
-        findChild(c['iface_node'], 'interface_body') ||
-        findChild(c['iface_node'], 'object_type');
+        c.iface_node.childForFieldName('body') ||
+        findChild(c.iface_node, 'interface_body') ||
+        findChild(c.iface_node, 'object_type');
       if (body) extractInterfaceMethods(body, ifaceName, definitions);
-    } else if (c['type_node']) {
+    } else if (c.type_node) {
       // type_alias_declaration (TS/TSX only)
       definitions.push({
-        name: c['type_name']!.text,
+        name: c.type_name!.text,
         kind: 'type',
-        line: c['type_node'].startPosition.row + 1,
-        endLine: nodeEndLine(c['type_node']),
+        line: c.type_node.startPosition.row + 1,
+        endLine: nodeEndLine(c.type_node),
       });
-    } else if (c['imp_node']) {
+    } else if (c.imp_node) {
       // import_statement
-      const isTypeOnly = c['imp_node'].text.startsWith('import type');
-      const modPath = c['imp_source']!.text.replace(/['"]/g, '');
-      const names = extractImportNames(c['imp_node']);
+      const isTypeOnly = c.imp_node.text.startsWith('import type');
+      const modPath = c.imp_source!.text.replace(/['"]/g, '');
+      const names = extractImportNames(c.imp_node);
       imports.push({
         source: modPath,
         names,
-        line: c['imp_node'].startPosition.row + 1,
+        line: c.imp_node.startPosition.row + 1,
         typeOnly: isTypeOnly,
       });
-    } else if (c['exp_node']) {
+    } else if (c.exp_node) {
       // export_statement
-      const exportLine = c['exp_node'].startPosition.row + 1;
-      const decl = c['exp_node'].childForFieldName('declaration');
+      const exportLine = c.exp_node.startPosition.row + 1;
+      const decl = c.exp_node.childForFieldName('declaration');
       if (decl) {
         const declType = decl.type;
         const kindMap: Record<string, string> = {
@@ -214,12 +212,11 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
           if (n) exps.push({ name: n.text, kind: kind as Export['kind'], line: exportLine });
         }
       }
-      const source =
-        c['exp_node'].childForFieldName('source') || findChild(c['exp_node'], 'string');
+      const source = c.exp_node.childForFieldName('source') || findChild(c.exp_node, 'string');
       if (source && !decl) {
         const modPath = source.text.replace(/['"]/g, '');
-        const reexportNames = extractImportNames(c['exp_node']);
-        const nodeText = c['exp_node'].text;
+        const reexportNames = extractImportNames(c.exp_node);
+        const nodeText = c.exp_node.text;
         const isWildcard = nodeText.includes('export *') || nodeText.includes('export*');
         imports.push({
           source: modPath,
@@ -229,25 +226,25 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
           wildcardReexport: isWildcard && reexportNames.length === 0,
         });
       }
-    } else if (c['callfn_node']) {
+    } else if (c.callfn_node) {
       // call_expression with identifier function
       calls.push({
-        name: c['callfn_name']!.text,
-        line: c['callfn_node'].startPosition.row + 1,
+        name: c.callfn_name!.text,
+        line: c.callfn_node.startPosition.row + 1,
       });
-    } else if (c['callmem_node']) {
+    } else if (c.callmem_node) {
       // call_expression with member_expression function
-      const callInfo = extractCallInfo(c['callmem_fn']!, c['callmem_node']);
+      const callInfo = extractCallInfo(c.callmem_fn!, c.callmem_node);
       if (callInfo) calls.push(callInfo);
-      const cbDef = extractCallbackDefinition(c['callmem_node'], c['callmem_fn']);
+      const cbDef = extractCallbackDefinition(c.callmem_node, c.callmem_fn);
       if (cbDef) definitions.push(cbDef);
-    } else if (c['callsub_node']) {
+    } else if (c.callsub_node) {
       // call_expression with subscript_expression function
-      const callInfo = extractCallInfo(c['callsub_fn']!, c['callsub_node']);
+      const callInfo = extractCallInfo(c.callsub_fn!, c.callsub_node);
       if (callInfo) calls.push(callInfo);
-    } else if (c['assign_node']) {
+    } else if (c.assign_node) {
       // CommonJS: module.exports = require(...) / module.exports = { ...require(...) }
-      handleCommonJSAssignment(c['assign_left']!, c['assign_right']!, c['assign_node'], imports);
+      handleCommonJSAssignment(c.assign_left!, c.assign_right!, c.assign_node, imports);
     }
   }
 
@@ -929,7 +926,7 @@ function extractTypeMapWalk(rootNode: TreeSitterNode, typeMap: Map<string, TypeM
   }
 
   function walk(node: TreeSitterNode, depth: number): void {
-    if (depth >= 200) return;
+    if (depth >= MAX_WALK_DEPTH) return;
     const t = node.type;
     if (t === 'variable_declarator') {
       const nameN = node.childForFieldName('name');

package/src/extractors/php.ts

@@ -5,7 +5,7 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+import { extractModifierVisibility, findChild, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
 
 function extractPhpParameters(fnNode: TreeSitterNode): SubDeclaration[] {
   const params: SubDeclaration[] = [];
@@ -340,7 +340,7 @@ function extractPhpTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function extractPhpTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, depth: number): void {
-  if (depth >= 200) return;
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // Function/method parameters with type hints
   if (

package/src/extractors/python.ts

@@ -6,7 +6,7 @@ import type {
   TreeSitterTree,
   TypeMapEntry,
 } from '../types.js';
-import { findChild, nodeEndLine, pythonVisibility } from './helpers.js';
+import { findChild, MAX_WALK_DEPTH, nodeEndLine, pythonVisibility } from './helpers.js';
 
 /** Built-in globals that start with uppercase but are not user-defined types. */
 const BUILTIN_GLOBALS_PY: Set<string> = new Set([
@@ -365,7 +365,7 @@ function extractPythonTypeMapDepth(
   ctx: ExtractorOutput,
   depth: number,
 ): void {
-  if (depth >= 200) return;
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // typed_parameter: identifier : type (confidence 0.9)
   if (node.type === 'typed_parameter') {

package/src/extractors/rust.ts

@@ -5,7 +5,7 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { findChild, nodeEndLine, rustVisibility } from './helpers.js';
+import { findChild, MAX_WALK_DEPTH, nodeEndLine, rustVisibility } from './helpers.js';
 
 /**
  * Extract symbols from Rust files.
@@ -274,7 +274,7 @@ function extractRustTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function extractRustTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, depth: number): void {
-  if (depth >= 200) return;
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // let x: MyType = ...
   if (node.type === 'let_declaration') {

package/src/features/audit.ts

@@ -30,7 +30,7 @@ function resolveThresholds(
         const repoRoot = path.resolve(dbDir, '..');
         return loadConfig(repoRoot);
       })();
-    const userRules = (cfg as Record<string, unknown>)['manifesto'] || {};
+    const userRules = (cfg as Record<string, unknown>).manifesto || {};
     const resolved: Record<string, ThresholdEntry> = {};
     for (const def of FUNCTION_RULES) {
       const user = (userRules as Record<string, { warn?: number; fail?: number }>)[def.name];
@@ -163,7 +163,6 @@ export function auditData(
   const explained = explainData(target, customDbPath, { noTests, depth: 0 });
 
   // Apply --file and --kind filters for function targets
-  // biome-ignore lint/suspicious/noExplicitAny: explainData returns a union type that varies by kind
   let results: any[] = explained.results;
   if (explained.kind === 'function') {
     if (fileFilters.length > 0)

package/src/features/branch-compare.ts

@@ -6,13 +6,7 @@ import Database from 'better-sqlite3';
 import { buildGraph } from '../domain/graph/builder.js';
 import { kindIcon } from '../domain/queries.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
-import type { BetterSqlite3Database, EngineMode } from '../types.js';
-
-type DatabaseConstructor = new (
-  path: string,
-  opts?: Record<string, unknown>,
-) => BetterSqlite3Database;
-const Db = Database as unknown as DatabaseConstructor;
+import type { EngineMode } from '../types.js';
 
 // ─── Git Helpers ────────────────────────────────────────────────────────
 
@@ -111,7 +105,7 @@ function loadSymbolsFromDb(
   changedFiles: string[],
   noTests: boolean,
 ): Map<string, SymbolInfo> {
-  const db = new Db(dbPath, { readonly: true });
+  const db = new Database(dbPath, { readonly: true });
   try {
     const symbols = new Map<string, SymbolInfo>();
 
@@ -180,7 +174,7 @@ function loadCallersFromDb(
 ): CallerInfo[] {
   if (nodeIds.length === 0) return [];
 
-  const db = new Db(dbPath, { readonly: true });
+  const db = new Database(dbPath, { readonly: true });
   try {
     const allCallers = new Set<string>();
 

package/src/features/cfg.ts

@@ -62,8 +62,7 @@ export function buildFunctionCFG(functionNode: TreeSitterNode, langId: string):
   };
 
   const results = walkWithVisitors(functionNode, [visitor], langId, walkerOpts);
-  // biome-ignore lint/complexity/useLiteralKeys: noPropertyAccessFromIndexSignature requires bracket notation
-  const cfgResults = (results['cfg'] || []) as Array<{
+  const cfgResults = (results.cfg || []) as Array<{
     funcNode: TreeSitterNode;
     blocks: CfgBuildBlock[];
     edges: CfgBuildEdge[];
@@ -214,8 +213,7 @@ function buildVisitorCfgMap(
     },
   };
   const walkResults = walkWithVisitors(tree?.rootNode, [visitor], langId, walkerOpts);
-  // biome-ignore lint/complexity/useLiteralKeys: noPropertyAccessFromIndexSignature requires bracket notation
-  const cfgResults = (walkResults['cfg'] || []) as VisitorCfgResult[];
+  const cfgResults = (walkResults.cfg || []) as VisitorCfgResult[];
   const visitorCfgByLine = new Map<number, VisitorCfgResult[]>();
   for (const r of cfgResults) {
     if (r.funcNode) {

package/src/features/cochange.ts

@@ -472,10 +472,10 @@ function getCoChangeMeta(db: BetterSqlite3Database): CoChangeMeta | null {
       meta[row.key] = row.value;
     }
     return {
-      analyzedAt: meta['analyzed_at'] || null,
-      since: meta['since'] || null,
-      minSupport: meta['min_support'] ? parseInt(meta['min_support'], 10) : null,
-      lastCommit: meta['last_analyzed_commit'] || null,
+      analyzedAt: meta.analyzed_at || null,
+      since: meta.since || null,
+      minSupport: meta.min_support ? parseInt(meta.min_support, 10) : null,
+      lastCommit: meta.last_analyzed_commit || null,
     };
   } catch {
     return null;

package/src/features/communities.ts

@@ -50,12 +50,12 @@ function buildCommunityObjects(
     const memberData: CommunityMember[] = [];
     for (const key of members) {
       const attrs = graph.getNodeAttrs(key)!;
-      const dir = getDirectory(attrs['file'] as string);
+      const dir = getDirectory(attrs.file as string);
       dirCounts[dir] = (dirCounts[dir] || 0) + 1;
       memberData.push({
-        name: attrs['label'] as string,
-        file: attrs['file'] as string,
-        ...(attrs['kind'] ? { kind: attrs['kind'] as string } : {}),
+        name: attrs.label as string,
+        file: attrs.file as string,
+        ...(attrs.kind ? { kind: attrs.kind as string } : {}),
       });
     }