@optave/codegraph 3.3.0 → 3.4.0

package/src/extractors/{hcl.js → hcl.ts}

@@ -1,10 +1,18 @@
+import type {
+  Definition,
+  ExtractorOutput,
+  Import,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
 import { nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from HCL (Terraform) files.
  */
-export function extractHCLSymbols(tree, _filePath) {
-  const ctx = { definitions: [], imports: [] };
+export function extractHCLSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: { definitions: Definition[]; imports: Import[] } = { definitions: [], imports: [] };
 
   walkHclNode(tree.rootNode, ctx);
   return {
@@ -13,39 +21,53 @@ export function extractHCLSymbols(tree, _filePath) {
     imports: ctx.imports,
     classes: [],
     exports: [],
-  };
+    typeMap: new Map(),
+  } as ExtractorOutput;
 }
 
-function walkHclNode(node, ctx) {
+function walkHclNode(
+  node: TreeSitterNode,
+  ctx: { definitions: Definition[]; imports: Import[] },
+): void {
   if (node.type === 'block') {
     handleHclBlock(node, ctx);
   }
 
-  for (let i = 0; i < node.childCount; i++) walkHclNode(node.child(i), ctx);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkHclNode(child, ctx);
+  }
 }
 
-function handleHclBlock(node, ctx) {
-  const children = [];
-  for (let i = 0; i < node.childCount; i++) children.push(node.child(i));
+function handleHclBlock(
+  node: TreeSitterNode,
+  ctx: { definitions: Definition[]; imports: Import[] },
+): void {
+  const children: TreeSitterNode[] = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) children.push(child);
+  }
 
   const identifiers = children.filter((c) => c.type === 'identifier');
   const strings = children.filter((c) => c.type === 'string_lit');
 
-  if (identifiers.length === 0) return;
-  const blockType = identifiers[0].text;
+  const firstIdent = identifiers[0];
+  if (!firstIdent) return;
+  const blockType = firstIdent.text;
   const name = resolveHclBlockName(blockType, strings);
 
   if (name) {
-    let blockChildren;
+    let blockChildren: SubDeclaration[] | undefined;
     if (blockType === 'variable' || blockType === 'output') {
       blockChildren = extractHclAttributes(children);
     }
     ctx.definitions.push({
       name,
-      kind: blockType,
+      kind: blockType as Definition['kind'],
       line: node.startPosition.row + 1,
       endLine: nodeEndLine(node),
-      children: blockChildren?.length > 0 ? blockChildren : undefined,
+      children: blockChildren?.length ? blockChildren : undefined,
     });
   }
 
@@ -54,30 +76,29 @@ function handleHclBlock(node, ctx) {
   }
 }
 
-function resolveHclBlockName(blockType, strings) {
-  if (blockType === 'resource' && strings.length >= 2) {
-    return `${strings[0].text.replace(/"/g, '')}.${strings[1].text.replace(/"/g, '')}`;
+function resolveHclBlockName(blockType: string, strings: TreeSitterNode[]): string {
+  const s0 = strings[0];
+  const s1 = strings[1];
+  if (blockType === 'resource' && s0 && s1) {
+    return `${s0.text.replace(/"/g, '')}.${s1.text.replace(/"/g, '')}`;
   }
-  if (blockType === 'data' && strings.length >= 2) {
-    return `data.${strings[0].text.replace(/"/g, '')}.${strings[1].text.replace(/"/g, '')}`;
+  if (blockType === 'data' && s0 && s1) {
+    return `data.${s0.text.replace(/"/g, '')}.${s1.text.replace(/"/g, '')}`;
   }
-  if (
-    (blockType === 'variable' || blockType === 'output' || blockType === 'module') &&
-    strings.length >= 1
-  ) {
-    return `${blockType}.${strings[0].text.replace(/"/g, '')}`;
+  if ((blockType === 'variable' || blockType === 'output' || blockType === 'module') && s0) {
+    return `${blockType}.${s0.text.replace(/"/g, '')}`;
   }
   if (blockType === 'locals') return 'locals';
   if (blockType === 'terraform' || blockType === 'provider') {
     let name = blockType;
-    if (strings.length >= 1) name += `.${strings[0].text.replace(/"/g, '')}`;
+    if (s0) name += `.${s0.text.replace(/"/g, '')}`;
     return name;
   }
   return '';
 }
 
-function extractHclAttributes(children) {
-  const attrs = [];
+function extractHclAttributes(children: TreeSitterNode[]): SubDeclaration[] {
+  const attrs: SubDeclaration[] = [];
   const body = children.find((c) => c.type === 'body');
   if (!body) return attrs;
   for (let j = 0; j < body.childCount; j++) {
@@ -92,7 +113,11 @@ function extractHclAttributes(children) {
   return attrs;
 }
 
-function extractHclModuleSource(children, _node, ctx) {
+function extractHclModuleSource(
+  children: TreeSitterNode[],
+  _node: TreeSitterNode,
+  ctx: { definitions: Definition[]; imports: Import[] },
+): void {
   const body = children.find((c) => c.type === 'body');
   if (!body) return;
   for (let i = 0; i < body.childCount; i++) {

package/src/extractors/{helpers.js → helpers.ts}

@@ -1,11 +1,13 @@
-export function nodeEndLine(node) {
+import type { TreeSitterNode } from '../types.js';
+
+export function nodeEndLine(node: TreeSitterNode): number {
   return node.endPosition.row + 1;
 }
 
-export function findChild(node, type) {
+export function findChild(node: TreeSitterNode, type: string): TreeSitterNode | null {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
-    if (child.type === type) return child;
+    if (child && child.type === type) return child;
   }
   return null;
 }
@@ -17,18 +19,18 @@ export function findChild(node, type) {
  * @param {Set<string>} [modifierTypes] - node types that indicate modifiers
  * @returns {'public'|'private'|'protected'|undefined}
  */
-const DEFAULT_MODIFIER_TYPES = new Set([
+const DEFAULT_MODIFIER_TYPES: Set<string> = new Set([
   'modifiers',
   'modifier',
   'visibility_modifier',
   'accessibility_modifier',
 ]);
-const VISIBILITY_KEYWORDS = new Set(['public', 'private', 'protected']);
+const VISIBILITY_KEYWORDS: Set<string> = new Set(['public', 'private', 'protected']);
 
 /**
  * Python convention: __name → private, _name → protected, else undefined.
  */
-export function pythonVisibility(name) {
+export function pythonVisibility(name: string): 'public' | 'private' | 'protected' | undefined {
   if (name.startsWith('__') && name.endsWith('__')) return undefined; // dunder — public
   if (name.startsWith('__')) return 'private';
   if (name.startsWith('_')) return 'protected';
@@ -38,20 +40,20 @@ export function pythonVisibility(name) {
 /**
  * Go convention: uppercase first letter → public, lowercase → private.
  */
-export function goVisibility(name) {
+export function goVisibility(name: string): 'public' | 'private' | 'protected' | undefined {
   if (!name) return undefined;
   // Strip receiver prefix (e.g., "Receiver.Method" → check "Method")
-  const bare = name.includes('.') ? name.split('.').pop() : name;
+  const bare = name.includes('.') ? (name.split('.').pop() ?? name) : name;
   if (!bare) return undefined;
-  return bare[0] === bare[0].toUpperCase() && bare[0] !== bare[0].toLowerCase()
-    ? 'public'
-    : 'private';
+  const first = bare[0];
+  if (!first) return undefined;
+  return first === first.toUpperCase() && first !== first.toLowerCase() ? 'public' : 'private';
 }
 
 /**
  * Rust: check for `visibility_modifier` child (pub, pub(crate), etc.).
  */
-export function rustVisibility(node) {
+export function rustVisibility(node: TreeSitterNode): 'public' | 'private' {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
@@ -62,19 +64,22 @@ export function rustVisibility(node) {
   return 'private';
 }
 
-export function extractModifierVisibility(node, modifierTypes = DEFAULT_MODIFIER_TYPES) {
+export function extractModifierVisibility(
+  node: TreeSitterNode,
+  modifierTypes: Set<string> = DEFAULT_MODIFIER_TYPES,
+): 'public' | 'private' | 'protected' | undefined {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
     // Direct keyword match (e.g., PHP visibility_modifier = "public")
     if (modifierTypes.has(child.type)) {
       const text = child.text;
-      if (VISIBILITY_KEYWORDS.has(text)) return text;
+      if (VISIBILITY_KEYWORDS.has(text)) return text as 'public' | 'private' | 'protected';
       // C# 'private protected' — accessible to derived types in same assembly → protected
       if (text === 'private protected') return 'protected';
       // Compound modifiers node (Java: "public static") — scan its text for a keyword
       for (const kw of VISIBILITY_KEYWORDS) {
-        if (text.includes(kw)) return kw;
+        if (text.includes(kw)) return kw as 'public' | 'private' | 'protected';
       }
     }
   }

package/src/extractors/{java.js → java.ts}

@@ -1,10 +1,18 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+  TypeMapEntry,
+} from '../types.js';
 import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from Java files.
  */
-export function extractJavaSymbols(tree, _filePath) {
-  const ctx = {
+export function extractJavaSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
     definitions: [],
     calls: [],
     imports: [],
@@ -17,7 +25,7 @@ export function extractJavaSymbols(tree, _filePath) {
   return ctx;
 }
 
-function walkJavaNode(node, ctx) {
+function walkJavaNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
   switch (node.type) {
     case 'class_declaration':
       handleJavaClassDecl(node, ctx);
@@ -48,12 +56,15 @@ function walkJavaNode(node, ctx) {
       break;
   }
 
-  for (let i = 0; i < node.childCount; i++) walkJavaNode(node.child(i), ctx);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkJavaNode(child, ctx);
+  }
 }
 
 // ── Walk-path per-node-type handlers ────────────────────────────────────────
 
-function handleJavaClassDecl(node, ctx) {
+function handleJavaClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const classChildren = extractClassFields(node);
@@ -93,7 +104,12 @@ function handleJavaClassDecl(node, ctx) {
   }
 }
 
-function extractJavaInterfaces(interfaces, className, line, ctx) {
+function extractJavaInterfaces(
+  interfaces: TreeSitterNode,
+  className: string,
+  line: number,
+  ctx: ExtractorOutput,
+): void {
   for (let i = 0; i < interfaces.childCount; i++) {
     const child = interfaces.child(i);
     if (
@@ -122,7 +138,7 @@ function extractJavaInterfaces(interfaces, className, line, ctx) {
   }
 }
 
-function handleJavaInterfaceDecl(node, ctx) {
+function handleJavaInterfaceDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   ctx.definitions.push({
@@ -150,7 +166,7 @@ function handleJavaInterfaceDecl(node, ctx) {
   }
 }
 
-function handleJavaEnumDecl(node, ctx) {
+function handleJavaEnumDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const enumChildren = extractEnumConstants(node);
@@ -163,7 +179,7 @@ function handleJavaEnumDecl(node, ctx) {
   });
 }
 
-function handleJavaMethodDecl(node, ctx) {
+function handleJavaMethodDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // Skip interface methods already emitted by handleJavaInterfaceDecl
   if (node.parent?.parent?.type === 'interface_declaration') return;
   const nameNode = node.childForFieldName('name');
@@ -181,7 +197,7 @@ function handleJavaMethodDecl(node, ctx) {
   });
 }
 
-function handleJavaConstructorDecl(node, ctx) {
+function handleJavaConstructorDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const parentClass = findJavaParentClass(node);
@@ -197,12 +213,12 @@ function handleJavaConstructorDecl(node, ctx) {
   });
 }
 
-function handleJavaImportDecl(node, ctx) {
+function handleJavaImportDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (child && (child.type === 'scoped_identifier' || child.type === 'identifier')) {
       const fullPath = child.text;
-      const lastName = fullPath.split('.').pop();
+      const lastName = fullPath.split('.').pop() ?? fullPath;
       ctx.imports.push({
         source: fullPath,
         names: [lastName],
@@ -217,16 +233,16 @@ function handleJavaImportDecl(node, ctx) {
   }
 }
 
-function handleJavaMethodInvocation(node, ctx) {
+function handleJavaMethodInvocation(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const obj = node.childForFieldName('object');
-  const call = { name: nameNode.text, line: node.startPosition.row + 1 };
+  const call: Call = { name: nameNode.text, line: node.startPosition.row + 1 };
   if (obj) call.receiver = obj.text;
   ctx.calls.push(call);
 }
 
-function handleJavaLocalVarDecl(node, ctx) {
+function handleJavaLocalVarDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const typeNode = node.childForFieldName('type');
   if (!typeNode) return;
   const typeName = typeNode.type === 'generic_type' ? typeNode.child(0)?.text : typeNode.text;
@@ -235,19 +251,19 @@ function handleJavaLocalVarDecl(node, ctx) {
     const child = node.child(i);
     if (child?.type === 'variable_declarator') {
       const nameNode = child.childForFieldName('name');
-      if (nameNode) ctx.typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
+      if (nameNode) ctx.typeMap?.set(nameNode.text, { type: typeName, confidence: 0.9 });
     }
   }
 }
 
-function handleJavaObjectCreation(node, ctx) {
+function handleJavaObjectCreation(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const typeNode = node.childForFieldName('type');
   if (!typeNode) return;
   const typeName = typeNode.type === 'generic_type' ? typeNode.child(0)?.text : typeNode.text;
   if (typeName) ctx.calls.push({ name: typeName, line: node.startPosition.row + 1 });
 }
 
-function findJavaParentClass(node) {
+function findJavaParentClass(node: TreeSitterNode): string | null {
   let current = node.parent;
   while (current) {
     if (
@@ -265,8 +281,11 @@ function findJavaParentClass(node) {
 
 // ── Child extraction helpers ────────────────────────────────────────────────
 
-function extractJavaParameters(paramListNode, typeMap) {
-  const params = [];
+function extractJavaParameters(
+  paramListNode: TreeSitterNode | null,
+  typeMap?: Map<string, TypeMapEntry>,
+): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
   if (!paramListNode) return params;
   for (let i = 0; i < paramListNode.childCount; i++) {
     const param = paramListNode.child(i);
@@ -289,8 +308,8 @@ function extractJavaParameters(paramListNode, typeMap) {
   return params;
 }
 
-function extractClassFields(classNode) {
-  const fields = [];
+function extractClassFields(classNode: TreeSitterNode): SubDeclaration[] {
+  const fields: SubDeclaration[] = [];
   const body = classNode.childForFieldName('body') || findChild(classNode, 'class_body');
   if (!body) return fields;
   for (let i = 0; i < body.childCount; i++) {
@@ -313,8 +332,8 @@ function extractClassFields(classNode) {
   return fields;
 }
 
-function extractEnumConstants(enumNode) {
-  const constants = [];
+function extractEnumConstants(enumNode: TreeSitterNode): SubDeclaration[] {
+  const constants: SubDeclaration[] = [];
   const body = enumNode.childForFieldName('body') || findChild(enumNode, 'enum_body');
   if (!body) return constants;
   for (let i = 0; i < body.childCount; i++) {