@vpxa/kb 0.1.15 → 0.1.16

package/packages/chunker/src/queries/go/entry-points.scm

@@ -0,0 +1,20 @@
+; Go entry-point detection queries
+; Captures: @node (declaration), @name (function name)
+
+; func main()
+(function_declaration
+  name: (identifier) @name
+  (#eq? @name "main")) @node
+
+; func init()
+(function_declaration
+  name: (identifier) @name
+  (#eq? @name "init")) @node
+
+; http.HandleFunc / http.Handle
+(call_expression
+  function: (selector_expression
+    operand: (identifier) @_pkg
+    field: (field_identifier) @name
+    (#eq? @_pkg "http")
+    (#match? @name "^Handle"))) @node

package/packages/chunker/src/queries/go/imports.scm

@@ -0,0 +1,6 @@
+; Go import extraction queries
+; Captures: @node (import spec), @source (path string)
+
+; Each individual import spec (works for both single and block imports)
+(import_spec
+  path: (interpreted_string_literal) @source) @node

package/packages/chunker/src/queries/go/patterns.scm

@@ -0,0 +1,25 @@
+; Go pattern detection queries
+; Captures: @node (pattern site), @name (identifier)
+
+; Interface type definition
+(type_declaration
+  (type_spec
+    name: (type_identifier) @name
+    type: (interface_type))) @node
+
+; Goroutine launch
+(go_statement
+  (call_expression
+    function: (identifier) @name)) @node
+
+; Channel creation: make(chan T)
+(call_expression
+  function: (identifier) @name
+  (#eq? @name "make")) @node
+
+; sync primitives (field of type sync.Mutex, sync.WaitGroup, etc.)
+(field_declaration
+  type: (qualified_type
+    package: (package_identifier) @_pkg
+    name: (type_identifier) @name
+    (#eq? @_pkg "sync"))) @node

package/packages/chunker/src/queries/go/symbols.scm

@@ -0,0 +1,26 @@
+; Go symbol extraction queries
+; Captures: @node (declaration), @name (identifier)
+; Export convention: uppercase first letter = exported (checked by extractor)
+
+; Function declaration
+(function_declaration
+  name: (identifier) @name) @node
+
+; Method declaration (receiver function)
+(method_declaration
+  name: (field_identifier) @name) @node
+
+; Type declaration (struct, interface, type alias)
+(type_declaration
+  (type_spec
+    name: (type_identifier) @name)) @node
+
+; Const declaration
+(const_declaration
+  (const_spec
+    name: (identifier) @name)) @node
+
+; Var declaration
+(var_declaration
+  (var_spec
+    name: (identifier) @name)) @node

package/packages/chunker/src/queries/java/calls.scm

@@ -0,0 +1,10 @@
+; Java call extraction queries
+; Captures: @node (call), @callee (method/constructor name)
+
+; foo(args) / this.foo(args) / obj.method(args)
+(method_invocation
+  name: (identifier) @callee) @node
+
+; new Foo(args)
+(object_creation_expression
+  type: (type_identifier) @callee) @node

package/packages/chunker/src/queries/java/entry-points.scm

@@ -0,0 +1,27 @@
+; Java entry-point detection queries
+; Captures: @node (declaration), @name (class/method name)
+
+; public static void main(String[] args)
+(method_declaration
+  (modifiers) @_mods
+  type: (void_type)
+  name: (identifier) @name
+  (#eq? @name "main")
+  (#match? @_mods "public")
+  (#match? @_mods "static")) @node
+
+; @SpringBootApplication class
+(class_declaration
+  (modifiers
+    (marker_annotation
+      name: (identifier) @_ann
+      (#eq? @_ann "SpringBootApplication")))
+  name: (identifier) @name) @node
+
+; @RestController / @Controller class
+(class_declaration
+  (modifiers
+    (marker_annotation
+      name: (identifier) @_ann
+      (#match? @_ann "^(RestController|Controller)$")))
+  name: (identifier) @name) @node

package/packages/chunker/src/queries/java/imports.scm

@@ -0,0 +1,11 @@
+; Java import extraction queries
+; Captures: @node (import), @source (fully qualified path)
+
+; import com.example.Foo;
+; import static com.example.Foo.bar;
+(import_declaration
+  (scoped_identifier) @source) @node
+
+; import Foo; (single identifier, rare)
+(import_declaration
+  (identifier) @source) @node

package/packages/chunker/src/queries/java/patterns.scm

@@ -0,0 +1,27 @@
+; Java pattern detection queries
+; Captures: @node (pattern site), @name (identifier)
+
+; Singleton: private constructor
+(class_declaration
+  name: (identifier) @name
+  body: (class_body
+    (constructor_declaration
+      (modifiers) @_mods
+      (#match? @_mods "private")))) @node
+
+; Factory: static method named create/build/of/from
+(method_declaration
+  (modifiers) @_mods
+  name: (identifier) @name
+  (#match? @_mods "static")
+  (#match? @name "^(create|build|of|from|new)")) @node
+
+; Builder class
+(class_declaration
+  name: (identifier) @name
+  (#match? @name "Builder")) @node
+
+; DI/framework annotations
+(marker_annotation
+  name: (identifier) @name
+  (#match? @name "^(Singleton|Component|Service|Repository|Controller|Bean)$")) @node

package/packages/chunker/src/queries/java/symbols.scm

@@ -0,0 +1,28 @@
+; Java symbol extraction queries
+; Captures: @node (declaration), @name (identifier)
+; Export convention: 'public' modifier = exported (checked by extractor)
+
+; Class declaration
+(class_declaration
+  name: (identifier) @name) @node
+
+; Interface declaration
+(interface_declaration
+  name: (identifier) @name) @node
+
+; Enum declaration
+(enum_declaration
+  name: (identifier) @name) @node
+
+; Method declaration
+(method_declaration
+  name: (identifier) @name) @node
+
+; Constructor declaration
+(constructor_declaration
+  name: (identifier) @name) @node
+
+; Field declaration
+(field_declaration
+  declarator: (variable_declarator
+    name: (identifier) @name)) @node

package/packages/chunker/src/queries/javascript/calls.scm

@@ -0,0 +1,21 @@
+; JavaScript call extraction queries
+; Identical to TypeScript calls (same node types)
+
+; === Direct function calls ===
+
+; foo(args)
+(call_expression
+  function: (identifier) @callee) @node
+
+; === Method calls ===
+
+; obj.method(args)
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @callee)) @node
+
+; === Constructor calls ===
+
+; new Foo(args)
+(new_expression
+  constructor: (identifier) @callee) @node

package/packages/chunker/src/queries/javascript/entry-points.scm

@@ -0,0 +1,31 @@
+; JavaScript entry-point detection queries
+; Same structure as TypeScript but uses identifier (not type_identifier) for classes
+
+; === Lambda/serverless handler exports ===
+
+(export_statement
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      (#match? @name "^(handler|main|lambdaHandler)$")))) @node
+
+; === Exported handler functions ===
+
+(export_statement
+  (function_declaration
+    name: (identifier) @name
+    (#match? @name "^(handler|main|lambdaHandler)$"))) @node
+
+; === Express/Hono/Fastify app exports ===
+
+(export_statement
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      (#match? @name "^(app|server|router)$")))) @node
+
+; === Default export ===
+
+(export_statement
+  "default"
+  (identifier) @name) @node

package/packages/chunker/src/queries/javascript/imports.scm

@@ -0,0 +1,32 @@
+; JavaScript import extraction queries
+; Same as TypeScript (no type-only imports in JS grammar)
+
+; === ES module imports ===
+
+; import { foo } from './module'
+; import Def from 'pkg'
+; import * as ns from 'pkg'
+(import_statement
+  source: (string
+    (string_fragment) @source)) @node
+
+; === CommonJS require ===
+
+; const x = require('./mod')
+(lexical_declaration
+  (variable_declarator
+    value: (call_expression
+      function: (identifier) @_fn
+      arguments: (arguments
+        (string
+          (string_fragment) @source))))
+  (#eq? @_fn "require")) @node
+
+; === Dynamic import ===
+
+; import('./dynamic')
+(call_expression
+  function: (import)
+  arguments: (arguments
+    (string
+      (string_fragment) @source))) @node

package/packages/chunker/src/queries/javascript/patterns.scm

@@ -0,0 +1,28 @@
+; JavaScript pattern detection queries
+; Subset of TypeScript patterns (no decorators, no accessibility modifiers)
+
+; === Factory: export function create*() ===
+
+(export_statement
+  (function_declaration
+    name: (identifier) @name
+    (#match? @name "^create[A-Z]"))) @node
+
+; === Dependency Injection markers ===
+
+; container.register(...) / container.bind(...)
+(call_expression
+  function: (member_expression
+    object: (identifier) @_obj
+    property: (property_identifier) @_method)
+  (#eq? @_obj "container")
+  (#match? @_method "^(register|bind)$")) @node
+
+; === Cached instance: new Map() / new WeakMap() ===
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (new_expression
+      constructor: (identifier) @_cls
+      (#match? @_cls "^(Map|WeakMap|Set)$")))) @node

package/packages/chunker/src/queries/javascript/symbols.scm

@@ -0,0 +1,52 @@
+; JavaScript symbol extraction queries
+; Same as TypeScript but without interface, type alias, and enum nodes.
+; JS uses `identifier` for class names (not `type_identifier`).
+
+; === Exported declarations ===
+
+; export function foo() {}
+(export_statement
+  (function_declaration
+    name: (identifier) @name) @node) @exported
+
+; export class Foo {}
+(export_statement
+  (class_declaration
+    name: (identifier) @name) @node) @exported
+
+; export const FOO = ...
+(export_statement
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name)) @node) @exported
+
+; export default class Foo {}
+(export_statement
+  "default"
+  (class_declaration
+    name: (identifier) @name) @node) @exported
+
+; === Non-exported declarations ===
+
+; function foo() {}
+(function_declaration
+  name: (identifier) @name) @node
+
+; class Foo {}
+(class_declaration
+  name: (identifier) @name) @node
+
+; const foo = ...
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name)) @node
+
+; === Class members ===
+
+; class methods: foo() {} / async foo() {} / static foo() {}
+(method_definition
+  name: (property_identifier) @name) @node
+
+; class properties: foo = value
+(field_definition
+  property: (property_identifier) @name) @node

package/packages/chunker/src/queries/python/calls.scm

@@ -0,0 +1,11 @@
+; Python call extraction queries
+; Captures: @node (call expression), @callee (function/method name)
+
+; foo(args) — direct function call
+(call
+  function: (identifier) @callee) @node
+
+; obj.method(args) — attribute/method call
+(call
+  function: (attribute
+    attribute: (identifier) @callee)) @node

package/packages/chunker/src/queries/python/entry-points.scm

@@ -0,0 +1,21 @@
+; Python entry-point detection queries
+; Captures: @node (entry point), @name (identifier)
+
+; if __name__ == "__main__":
+(if_statement
+  condition: (comparison_operator
+    (identifier) @name
+    (#eq? @name "__name__"))) @node
+
+; Flask/FastAPI/Sanic app creation
+; app = Flask(__name__) / app = FastAPI()
+(assignment
+  left: (identifier) @name
+  right: (call
+    function: (identifier) @_cls
+    (#match? @_cls "^(Flask|FastAPI|Sanic|Quart)$"))) @node
+
+; Django urlpatterns
+(assignment
+  left: (identifier) @name
+  (#eq? @name "urlpatterns")) @node

package/packages/chunker/src/queries/python/imports.scm

@@ -0,0 +1,14 @@
+; Python import extraction queries
+; Captures: @node (import statement), @source (module path)
+
+; import foo / import foo.bar
+(import_statement
+  name: (dotted_name) @source) @node
+
+; from foo import bar
+(import_from_statement
+  module_name: (dotted_name) @source) @node
+
+; from . import foo (relative import)
+(import_from_statement
+  module_name: (relative_import) @source) @node

package/packages/chunker/src/queries/python/patterns.scm

@@ -0,0 +1,25 @@
+; Python pattern detection queries
+; Captures: @node (pattern site), @name (identifier)
+
+; Singleton: __new__ override
+(function_definition
+  name: (identifier) @name
+  (#eq? @name "__new__")) @node
+
+; Decorator pattern (direct decorator call)
+(decorated_definition
+  (decorator
+    (call
+      function: (identifier) @name))) @node
+
+; Decorator pattern (attribute decorator like @app.route)
+(decorated_definition
+  (decorator
+    (call
+      function: (attribute
+        attribute: (identifier) @name)))) @node
+
+; Context manager class (__enter__)
+(function_definition
+  name: (identifier) @name
+  (#eq? @name "__enter__")) @node

package/packages/chunker/src/queries/python/symbols.scm

@@ -0,0 +1,17 @@
+; Python symbol extraction queries
+; Captures: @node (declaration), @name (identifier)
+; No explicit export in Python — extractor uses name prefix (_ = private)
+
+; Function definition
+(function_definition
+  name: (identifier) @name) @node
+
+; Class definition
+(class_definition
+  name: (identifier) @name) @node
+
+; Module-level assignment (constants/variables)
+(module
+  (expression_statement
+    (assignment
+      left: (identifier) @name)) @node)

package/packages/chunker/src/queries/rust/calls.scm

@@ -0,0 +1,20 @@
+; Rust call extraction queries
+; Captures: @node (call), @callee (function/method name)
+
+; foo(args) — direct function call
+(call_expression
+  function: (identifier) @callee) @node
+
+; path::to::func(args) — qualified call
+(call_expression
+  function: (scoped_identifier
+    name: (identifier) @callee)) @node
+
+; obj.method(args) — method call
+(call_expression
+  function: (field_expression
+    field: (field_identifier) @callee)) @node
+
+; println!("...") — macro invocation
+(macro_invocation
+  macro: (identifier) @callee) @node

package/packages/chunker/src/queries/rust/entry-points.scm

@@ -0,0 +1,7 @@
+; Rust entry-point detection queries
+; Captures: @node (declaration), @name (function name)
+
+; fn main()
+(function_item
+  name: (identifier) @name
+  (#eq? @name "main")) @node

package/packages/chunker/src/queries/rust/imports.scm

@@ -0,0 +1,26 @@
+; Rust import extraction queries
+; Captures: @node (use declaration), @source (path)
+
+; use std::collections::HashMap
+(use_declaration
+  argument: (scoped_identifier) @source) @node
+
+; use foo::bar::{A, B}
+(use_declaration
+  argument: (scoped_use_list) @source) @node
+
+; use foo::*
+(use_declaration
+  argument: (use_wildcard) @source) @node
+
+; use foo as bar
+(use_declaration
+  argument: (use_as_clause) @source) @node
+
+; use foo
+(use_declaration
+  argument: (identifier) @source) @node
+
+; extern crate foo
+(extern_crate_declaration
+  name: (identifier) @source) @node

package/packages/chunker/src/queries/rust/patterns.scm

@@ -0,0 +1,18 @@
+; Rust pattern detection queries
+; Captures: @node (pattern site), @name (identifier)
+
+; impl Trait for Type (trait implementation)
+(impl_item
+  trait: (type_identifier) @name) @node
+
+; Derive macro attribute
+(attribute_item
+  (attribute
+    (identifier) @name
+    (#eq? @name "derive"))) @node
+
+; Test attribute
+(attribute_item
+  (attribute
+    (identifier) @name
+    (#eq? @name "test"))) @node

package/packages/chunker/src/queries/rust/symbols.scm

@@ -0,0 +1,73 @@
+; Rust symbol extraction queries
+; Captures: @node (declaration), @name (identifier), @exported (visibility_modifier)
+
+; === Exported (pub) declarations ===
+
+; pub fn foo() {}
+(function_item
+  (visibility_modifier) @exported
+  name: (identifier) @name) @node
+
+; pub struct Foo {}
+(struct_item
+  (visibility_modifier) @exported
+  name: (type_identifier) @name) @node
+
+; pub enum Color {}
+(enum_item
+  (visibility_modifier) @exported
+  name: (type_identifier) @name) @node
+
+; pub trait MyTrait {}
+(trait_item
+  (visibility_modifier) @exported
+  name: (type_identifier) @name) @node
+
+; pub const FOO: i32 = 42
+(const_item
+  (visibility_modifier) @exported
+  name: (identifier) @name) @node
+
+; pub static FOO: i32 = 42
+(static_item
+  (visibility_modifier) @exported
+  name: (identifier) @name) @node
+
+; pub type Alias = ...
+(type_item
+  (visibility_modifier) @exported
+  name: (type_identifier) @name) @node
+
+; === Non-exported declarations ===
+
+; fn foo() {}
+(function_item
+  name: (identifier) @name) @node
+
+; struct Foo {}
+(struct_item
+  name: (type_identifier) @name) @node
+
+; enum Color {}
+(enum_item
+  name: (type_identifier) @name) @node
+
+; trait MyTrait {}
+(trait_item
+  name: (type_identifier) @name) @node
+
+; impl Foo {}
+(impl_item
+  type: (type_identifier) @name) @node
+
+; const FOO: i32 = 42
+(const_item
+  name: (identifier) @name) @node
+
+; static FOO: i32 = 42
+(static_item
+  name: (identifier) @name) @node
+
+; type Alias = ...
+(type_item
+  name: (type_identifier) @name) @node

package/packages/chunker/src/queries/typescript/calls.scm

@@ -0,0 +1,21 @@
+; TypeScript call extraction queries
+; Captures: @node (full call/new expression), @callee (function/method name)
+
+; === Direct function calls ===
+
+; foo(args)
+(call_expression
+  function: (identifier) @callee) @node
+
+; === Method calls ===
+
+; obj.method(args)
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @callee)) @node
+
+; === Constructor calls ===
+
+; new Foo(args)
+(new_expression
+  constructor: (identifier) @callee) @node

package/packages/chunker/src/queries/typescript/entry-points.scm

@@ -0,0 +1,48 @@
+; TypeScript entry-point detection queries
+; Captures: @node (full declaration), @name (entry point function/class name)
+
+; === Lambda/serverless handler exports ===
+
+; export const handler = ...
+; export const main = ...
+(export_statement
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      (#match? @name "^(handler|main|lambdaHandler)$")))) @node
+
+; === Exported handler functions ===
+
+; export function handler() {}
+; export async function handler() {}
+(export_statement
+  (function_declaration
+    name: (identifier) @name
+    (#match? @name "^(handler|main|lambdaHandler)$"))) @node
+
+; === CDK Construct / Stack classes ===
+
+; export class MyStack extends Stack {}
+(export_statement
+  (class_declaration
+    name: (type_identifier) @name
+    (class_heritage
+      (extends_clause
+        value: (identifier) @_parent
+        (#match? @_parent "^(Construct|Stack|NestedStack|Stage)$"))))) @node
+
+; === Express/Hono/Fastify app exports ===
+
+; export const app = express() / new Hono() / new App()
+(export_statement
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      (#match? @name "^(app|server|router)$")))) @node
+
+; === Default export of app/handler ===
+
+; export default app
+(export_statement
+  "default"
+  (identifier) @name) @node