@getmikk/core 2.0.14 → 2.0.15

package/src/parser/tree-sitter/queries.ts

@@ -66,9 +66,10 @@ export const JAVA_QUERIES = `
 `;
 
 export const KOTLIN_QUERIES = `
-(class_declaration name: (type_identifier) @name) @definition.class
-(object_declaration name: (type_identifier) @name) @definition.class
-(function_declaration name: (simple_identifier) @name) @definition.function
+; Kotlin uses type_identifier as child node, not as a named field
+(class_declaration (type_identifier) @name) @definition.class
+(object_declaration (type_identifier) @name) @definition.class
+(function_declaration (simple_identifier) @name) @definition.function
 (property_declaration (variable_declaration (simple_identifier) @name)) @definition.property
 (type_alias (type_identifier) @name) @definition.type
 (import_header (identifier) @import.source) @import
@@ -175,13 +176,11 @@ export const RUST_QUERIES = `
 
 export const PHP_QUERIES = `
 (namespace_definition name: (namespace_name) @name) @definition.namespace
-(class_declaration name: (name) @name) @definition.class
-(interface_declaration name: (name) @name) @definition.interface
-(trait_declaration name: (name) @name) @definition.trait
-(enum_declaration name: (name) @name) @definition.enum
-(function_definition name: (name) @name) @definition.function
-(method_declaration name: (name) @name) @definition.method
-(property_declaration (property_element (variable_name (name) @name))) @definition.property
+(class_declaration (name) @name) @definition.class
+(interface_declaration (name) @name) @definition.interface
+(trait_declaration (name) @name) @definition.trait
+(enum_declaration (name) @name) @definition.enum
+(method_declaration (name) @name) @definition.method
 (namespace_use_declaration (namespace_use_clause (qualified_name) @import.source)) @import
 (function_call_expression function: (name) @call.name) @call
 (member_call_expression name: (name) @call.name) @call
@@ -292,3 +291,100 @@ export const RAILS_ROUTE_QUERIES = `
   arguments: (argument_list (string (string_content) @route.path)))
 ) @route.def
 `;
+
+// Scala queries - uses class_definition and function_definition
+export const SCALA_QUERIES = `
+(class_definition (identifier) @name) @definition.class
+(object_definition (identifier) @name) @definition.class
+(function_definition (identifier) @name) @definition.function
+(function_definition (identifier) @call.name) @call
+`;
+
+// Dart queries - reuse Swift queries  
+export const DART_QUERIES = SWIFT_QUERIES;
+
+// Zig queries - uses function_declaration
+export const ZIG_QUERIES = `
+(function_declaration (identifier) @name) @definition.function
+(variable_declaration (identifier) @name) @definition.const
+`;
+
+// Haskell queries
+export const HASKELL_QUERIES = `
+(class_declaration name: (type) @name) @definition.class
+(function_declaration name: (variable) @name) @definition.function
+(type_signature (variable) @name) @definition.function
+(import_statement (qualified_module) @import.source) @import
+(import_statement (module) @import.source) @import
+(call_expression (variable) @call.name) @call
+(call_expression (qualified_method) @call.name) @call
+`;
+
+// Elixir queries - uses call nodes for everything
+export const ELIXIR_QUERIES = `
+(call (identifier) @name) @definition.function
+(call (identifier) @call.name) @call
+`;
+
+// Clojure queries
+export const CLOJURE_QUERIES = `
+(namespaceDeclaration name: (symbol) @name) @definition.namespace
+(defn name: (symbol) @name) @definition.function
+(def name: (symbol) @name) @definition.var
+(require :refer (symbol) @import.source) @import
+`;
+
+// F# queries
+export const FSHARP_QUERIES = `
+(type_definition name: (type) @name) @definition.type
+(function_definition name: (identifier) @name) @definition.function
+(binding name: (identifier) @name) @definition.var
+(openStatement (identifier) @import.source) @import
+`;
+
+// OCaml queries - uses value_definition and value_name
+export const OCAML_QUERIES = `
+(value_definition (let_binding (value_name) @name)) @definition.function
+`;
+
+// Perl queries
+export const PERL_QUERIES = `
+(package_declaration name: (package) @name) @definition.package
+(subroutine_definition name: (identifier) @name) @definition.function
+`;
+
+// R queries
+export const R_QUERIES = `
+(function_definition name: (identifier) @name) @definition.function
+(assignment_left name: (identifier) @name) @definition.var
+`;
+
+// Julia queries
+export const JULIA_QUERIES = `
+(function_definition name: (identifier) @name) @definition.function
+(struct_definition name: (identifier) @name) @definition.struct
+(import_statement (identifier) @import.source) @import
+`;
+
+// Lua queries - uses function_definition_statement
+export const LUA_QUERIES = `
+(function_definition_statement (identifier) @name) @definition.function
+(variable_assignment (variable_list (identifier) @name)) @definition.var
+(local_variable_declaration (variable_list (identifier) @name)) @definition.local
+`;
+
+// SQL queries
+export const SQL_QUERIES = `
+(create_table (identifier) @name) @definition.table
+(create_index (identifier) @name) @definition.index
+`;
+
+// HCL (Terraform) queries - reuse generic
+export const HCL_QUERIES = `
+(block (identifier) @name) @definition.block
+`;
+
+// Bash/Shell queries
+export const BASH_QUERIES = `
+(function_definition name: (word) @name) @definition.function
+`;

package/src/parser/types.ts

@@ -2,6 +2,8 @@
  * Parser types — data shapes that flow through the entire Mikk system.
  */
 
+import type { ParsedFileLanguage } from '../utils/language-registry.js';
+
 /** A single parameter in a function signature */
 export interface ParsedParam {
   name: string;
@@ -38,6 +40,20 @@ export interface ParsedFunction {
   edgeCasesHandled: string[];
   errorHandling: { line: number; type: 'try-catch' | 'throw'; detail: string }[];
   detailedLines: { startLine: number; endLine: number; blockType: string }[];
+  decorators?: string[];
+}
+
+/** A single import specifier with alias support */
+export interface ImportSpecifier {
+  imported: string;
+  local: string;
+}
+
+/** A re-export statement (export { X } from './source') */
+export interface ReExport {
+  name: string;
+  source: string;
+  sourceResolved?: string;
 }
 
 /** A single import statement */
@@ -45,6 +61,7 @@ export interface ParsedImport {
   source: string;
   resolvedPath: string;
   names: string[];
+  specifiers?: ImportSpecifier[];
   isDefault: boolean;
   isDynamic: boolean;
 }
@@ -66,6 +83,7 @@ export interface ParsedVariable {
   isExported: boolean;
   isStatic?: boolean;
   purpose?: string;
+  decorators?: string[];
 }
 
 /** A parsed class */
@@ -116,13 +134,14 @@ export interface ParsedRoute {
 /** Everything extracted from a single file */
 export interface ParsedFile {
   path: string;            // normalized absolute path
-  language: 'python' | 'go' | 'typescript' | 'javascript' | 'java' | 'kotlin' | 'swift' | 'c' | 'cpp' | 'csharp' | 'rust' | 'php' | 'ruby' | 'unknown';
+  language: ParsedFileLanguage;
   functions: ParsedFunction[];
   classes: ParsedClass[];
   variables: ParsedVariable[];
   generics: ParsedGeneric[];
   imports: ParsedImport[];
   exports: ParsedExport[];
+  reexports?: ReExport[];
   routes: ParsedRoute[];
   calls: CallExpression[]; // module-level calls
   hash: string;

package/src/search/bm25.ts

@@ -188,7 +188,7 @@ export function tokenize(text: string): string[] {
 }
 
 /**
- * Build search tokens for a function — combines name, purpose, params, file path.
+ * Build search tokens for a function — combines name, purpose, params, file path, and body.
  * This gives BM25 rich content to index beyond just the function name.
  */
 export function buildFunctionTokens(fn: {
@@ -197,25 +197,22 @@ export function buildFunctionTokens(fn: {
     purpose?: string
     params?: { name: string; type: string }[]
     returnType?: string
+    body?: string
 }): string[] {
     const parts: string[] = []
 
-    // Function name tokens (highest signal)
     parts.push(...tokenize(fn.name))
     parts.push(...tokenize(fn.name))
-    parts.push(...tokenize(fn.name)) // Triple-weight the name
+    parts.push(...tokenize(fn.name))
     parts.push(`name_exact:${fn.name.toLowerCase()}`)
 
-    // File path tokens
     const filename = fn.file.split('/').pop() ?? fn.file
-    parts.push(...tokenize(filename.replace(/\.[^.]+$/, ''))) // Strip extension
+    parts.push(...tokenize(filename.replace(/\.[^.]+$/, '')))
 
-    // Purpose tokens
     if (fn.purpose) {
         parts.push(...tokenize(fn.purpose))
     }
 
-    // Parameter name tokens
     if (fn.params) {
         for (const p of fn.params) {
             parts.push(...tokenize(p.name))
@@ -223,10 +220,26 @@ export function buildFunctionTokens(fn: {
         }
     }
 
-    // Return type tokens
     if (fn.returnType) {
         parts.push(...tokenize(fn.returnType))
     }
 
+    if (fn.body) {
+        const cleanedBody = cleanCodeForTokens(fn.body)
+        const bodyTokens = tokenize(cleanedBody).slice(0, 50)
+        parts.push(...bodyTokens)
+    }
+
     return parts
 }
+
+function cleanCodeForTokens(code: string): string {
+    return code
+        .replace(/\/\*\*[\s\S]*?\*\//g, ' ')
+        .replace(/\/\/[^\n]*/g, ' ')
+        .replace(/#.*$/gm, ' ')
+        .replace(/['"`][^'"`]*['"`]/g, ' ')
+        .replace(/\d+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+}