@vpxa/kb 0.1.13 → 0.1.16

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

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

@@ -0,0 +1,35 @@
+; TypeScript import extraction queries
+; Captures: @node (full import statement), @source (module path string)
+
+; === ES module imports ===
+
+; import { foo } from './module'
+; import type { IFoo } from './types'
+; import Def from 'pkg'
+; import * as ns from 'pkg'
+(import_statement
+  source: (string
+    (string_fragment) @source)) @node
+
+; === CommonJS require ===
+
+; const x = require('./mod')
+; const { a, b } = require('./mod')
+(lexical_declaration
+  (variable_declarator
+    value: (call_expression
+      function: (identifier) @_fn
+      arguments: (arguments
+        (string
+          (string_fragment) @source))))
+  (#eq? @_fn "require")) @node
+
+; === Dynamic import ===
+
+; const x = await import('./dynamic')
+; import('./dynamic').then(...)
+(call_expression
+  function: (import)
+  arguments: (arguments
+    (string
+      (string_fragment) @source))) @node

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

@@ -0,0 +1,47 @@
+; TypeScript pattern detection queries
+; Captures: @node (pattern site), @name (identifier or function name)
+
+; === Singleton: private constructor or cached instances ===
+
+; class Foo { private constructor() {} }
+(class_declaration
+  name: (type_identifier) @name
+  body: (class_body
+    (method_definition
+      (accessibility_modifier) @_access
+      name: (property_identifier) @_ctor)
+    (#eq? @_access "private")
+    (#eq? @_ctor "constructor"))) @node
+
+; === 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
+
+; === Decorator patterns ===
+; @Injectable() / @Component() etc.
+(decorator
+  (call_expression
+    function: (identifier) @name
+    (#match? @name "^(Injectable|Component|Service|Controller|Module)$"))) @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/typescript/symbols.scm

@@ -0,0 +1,79 @@
+; TypeScript symbol extraction queries
+; Captures: @node (full declaration), @name (identifier), @kind (implicit from pattern)
+
+; === Exported declarations ===
+
+; export function foo() {}
+; export async function foo() {}
+(export_statement
+  (function_declaration
+    name: (identifier) @name) @node) @exported
+
+; export class Foo {}
+(export_statement
+  (class_declaration
+    name: (type_identifier) @name) @node) @exported
+
+; export interface IFoo {}
+(export_statement
+  (interface_declaration
+    name: (type_identifier) @name) @node) @exported
+
+; export type MyType = ...
+(export_statement
+  (type_alias_declaration
+    name: (type_identifier) @name) @node) @exported
+
+; export enum Color {}
+(export_statement
+  (enum_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: (type_identifier) @name) @node) @exported
+
+; === Non-exported declarations ===
+
+; function foo() {}
+(function_declaration
+  name: (identifier) @name) @node
+
+; class Foo {}
+(class_declaration
+  name: (type_identifier) @name) @node
+
+; interface IFoo {}
+(interface_declaration
+  name: (type_identifier) @name) @node
+
+; type MyType = ...
+(type_alias_declaration
+  name: (type_identifier) @name) @node
+
+; enum Color {}
+(enum_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 / readonly foo: Type
+(public_field_definition
+  name: (property_identifier) @name) @node