brainclaw 1.16.0 → 1.18.0

package/dist/core/code-map/lang/ruby/index.js

@@ -0,0 +1,198 @@
+/**
+ * Code Map langs batch 2 — RubyProvider (provider #6).
+ *
+ * Owns `.rb` (runtime lang `ruby`). `extractDraft` delegates to the generic
+ * query-runtime; the curated `tags.scm`/`imports.scm` (this dir) drive extraction.
+ *
+ * Definitions (verified via dogfood against tree-sitter-ruby):
+ *  - `class`  -> class      (name: a `constant`)
+ *  - `module` -> namespace  (name: a `constant`; Ruby modules are namespaces/mixins)
+ *  - `method` (def)              -> method (uniform capture)
+ *  - `singleton_method` (def self.x) -> method (always a member method)
+ *  - constant assignment (`FOO = ...`, left is a bare `constant`) -> constant
+ *
+ * refine() carries what the structural query CANNOT express (mirrors Python's
+ * dynamic-language refine):
+ *  - a `method` whose enclosing scope is NOT a class/module (a TOP-LEVEL `def`, or a
+ *    def nested inside another def/block) -> reclassified `function` (Ruby's
+ *    module-level-function analog). A `method` directly in a class/module body stays
+ *    `method`. `singleton_method` stays `method` regardless of location.
+ *  - import sources: strip the surrounding quotes from the required string
+ *    (`'sinatra'` -> `sinatra`). Defensive/idempotent — the query-runtime already
+ *    strips quotes; kept to match the Go provider's documented pattern.
+ *
+ * Imports: Ruby has NO static import statement — `require`/`require_relative` are
+ * method CALLS. imports.scm captures those calls (a `#any-of?` predicate limits the
+ * match to the require family) and the module node `name` is the required string.
+ * Best-effort T2 only: no path resolution (T3 = none). NO exports edges — Ruby has
+ * no export statement (capabilities: T1.definitions + T2.imports).
+ *
+ * Identity is owned by the CORE finalizer — this provider mints NO ids. The grammar
+ * loads through the SHARED engine glue (`loadGrammarWasm`), never a fresh
+ * `web-tree-sitter` import (trp_8df65ab7).
+ */
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadGrammarWasm, grammarHashForWasm } from '../../wasm-loader.js';
+import { extractWithQueries } from '../query-runtime.js';
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const RUBY_WASM_BASENAME = 'tree-sitter-ruby.wasm';
+const RUBY_WASM_NODE_MODULES_SPEC = 'tree-sitter-wasms/out/tree-sitter-ruby.wasm';
+const RUBY_GRAMMAR_NAME = 'tree-sitter-ruby';
+/** Resolve a vendored `.scm` next to this module (dist) or from the source tree. */
+function readScm(basename) {
+    const local = path.join(HERE, basename);
+    if (fs.existsSync(local))
+        return fs.readFileSync(local, 'utf-8');
+    let dir = HERE;
+    for (let i = 0; i < 12; i++) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            const fromSrc = path.join(dir, 'src', 'core', 'code-map', 'lang', 'ruby', basename);
+            if (fs.existsSync(fromSrc))
+                return fs.readFileSync(fromSrc, 'utf-8');
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error(`code-map: could not locate query asset ${basename} (from ${HERE})`);
+}
+function sha256(s) {
+    return `sha256:${crypto.createHash('sha256').update(s, 'utf-8').digest('hex')}`;
+}
+const TAGS = readScm('tags.scm');
+const IMPORTS = readScm('imports.scm');
+const TAGS_HASH = sha256(TAGS);
+const IMPORTS_HASH = sha256(IMPORTS);
+const parser = {
+    grammarForLang: () => loadGrammarWasm(RUBY_WASM_BASENAME, RUBY_WASM_NODE_MODULES_SPEC),
+    grammarNameForLang: () => RUBY_GRAMMAR_NAME,
+    grammarHashForLang: () => grammarHashForWasm(RUBY_WASM_BASENAME, RUBY_WASM_NODE_MODULES_SPEC),
+};
+const queries = {
+    tags: { name: 'tags', sourceForLang: () => TAGS, hashForLang: () => TAGS_HASH },
+    imports: { name: 'imports', sourceForLang: () => IMPORTS, hashForLang: () => IMPORTS_HASH },
+    // Ruby has no import statement — the require CALL is the span/ordinal anchor.
+    enclosingStatementNodeTypes: ['call'],
+    captureMap: [
+        { capture: 'definition.class.node', field: 'node', subtype: 'class' },
+        { capture: 'definition.class.name', field: 'name' },
+        { capture: 'definition.namespace.node', field: 'node', subtype: 'namespace' },
+        { capture: 'definition.namespace.name', field: 'name' },
+        { capture: 'definition.method.node', field: 'node', subtype: 'method' },
+        { capture: 'definition.method.name', field: 'name' },
+        { capture: 'definition.constant.node', field: 'node', subtype: 'constant' },
+        { capture: 'definition.constant.name', field: 'name' },
+        { capture: 'import.source', field: 'source' },
+    ],
+};
+const vocabulary = {
+    nodeSubtypes: ['class', 'namespace', 'method', 'function', 'constant'],
+    edgeKinds: ['contains', 'defines', 'imports'],
+    captureMap: queries.captureMap,
+};
+const capabilities = {
+    tiers: ['T1.definitions', 'T2.imports'],
+    proven: {
+        'T1.definitions': true,
+        'T2.imports': true,
+        'T3.import_resolution': false,
+        'T4.tests_for': false,
+    },
+};
+/** Strip the surrounding quotes from a required-string import path. */
+function stripQuotes(s) {
+    return s.replace(/^['"`]/, '').replace(/['"`]$/, '');
+}
+function isDefSourceNode(v) {
+    return (typeof v === 'object' &&
+        v !== null &&
+        'node' in v &&
+        typeof v.node === 'object');
+}
+/**
+ * True iff `defNode` (a `method`) is a member of a class/module — i.e. directly owned
+ * by a class/module body. tree-sitter-ruby nests a def's statements under a
+ * `body_statement` whose parent is the enclosing `class`/`module`/`singleton_class`;
+ * a TOP-LEVEL def's parent is `program` (no body_statement wrapper), and a def nested
+ * in another def/block has a `body_statement` whose parent is that def/block (not a
+ * class/module). So a member method is exactly: parent `body_statement` whose parent
+ * is `class` | `module` | `singleton_class`.
+ */
+function isClassOrModuleMember(defNode) {
+    const owner = defNode.parent;
+    if (!owner || owner.type !== 'body_statement')
+        return false;
+    const container = owner.parent;
+    if (!container)
+        return false;
+    return (container.type === 'class' ||
+        container.type === 'module' ||
+        container.type === 'singleton_class');
+}
+export class RubyProvider {
+    id = 'ruby';
+    displayName = 'Ruby';
+    languages = ['ruby'];
+    extensions = ['.rb'];
+    priority = 0;
+    version = '0.1.0';
+    parser = parser;
+    queries = queries;
+    vocabulary = vocabulary;
+    capabilities = capabilities;
+    langForPath(_p) {
+        return 'ruby';
+    }
+    async extractDraft(input, _services) {
+        return extractWithQueries({
+            providerId: this.id,
+            lang: input.lang,
+            source: input.source,
+            sizeBytes: input.sizeBytes,
+            maxParseFileBytes: input.maxParseFileBytes,
+            maxQueryWaitMs: input.maxQueryWaitMs,
+            path: input.path,
+            grammarForLang: this.parser.grammarForLang,
+            tagsSource: TAGS,
+            tagsHash: TAGS_HASH,
+            importsSource: IMPORTS,
+            importsHash: IMPORTS_HASH,
+            enclosingStatementNodeTypes: queries.enclosingStatementNodeTypes,
+        });
+    }
+    /**
+     * Drafts-only refinement:
+     *  - a `method` def whose enclosing scope is NOT a class/module body -> `function`
+     *    (top-level defs + defs nested in another def/block); `singleton_method` and
+     *    class/module-body `method`s stay `method`.
+     *  - strip the surrounding quotes from each import source (defensive/idempotent).
+     */
+    refine(draft, _ctx) {
+        const definitions = draft.definitions.map((d) => {
+            if (d.subtype !== 'method')
+                return d;
+            const src = isDefSourceNode(d.sourceNode) ? d.sourceNode : null;
+            if (!src)
+                return d;
+            // singleton_method (def self.x) is always a member method.
+            if (src.node.type === 'singleton_method')
+                return d;
+            // A plain `method` (def) is a `function` unless it is a class/module member.
+            return isClassOrModuleMember(src.node) ? d : setSubtype(d, 'function');
+        });
+        const imports = draft.imports.length === 0
+            ? draft.imports
+            : draft.imports.map((im) => ({ ...im, source: stripQuotes(im.source) }));
+        return { ...draft, definitions, imports };
+    }
+}
+function setSubtype(d, subtype) {
+    return d.subtype === subtype ? d : { ...d, subtype };
+}
+export const rubyProvider = new RubyProvider();
+//# sourceMappingURL=index.js.map

package/dist/core/code-map/lang/ruby/tags.scm

@@ -0,0 +1,49 @@
+; Code Map — Ruby definitions (tags.scm). Provider #6 (langs batch 2).
+;
+; Capture-name convention (query-runtime.ts is the contract):
+;   @definition.<subtype>.node = identity-span anchor (the declaration)
+;   @definition.<subtype>.name = the symbol name node
+;
+; Subtype mapping (verified against tree-sitter-ruby via dogfood):
+;   class   -> class      (name: a (constant))
+;   module  -> namespace  (name: a (constant); Ruby modules are namespaces/mixins)
+;   method (def ...)          -> method  (name: any node — identifier/operator/setter)
+;   singleton_method (def self.x) -> method  (always a member method)
+;   constant assignment (FOO = ...) -> constant  (left is a bare (constant))
+;
+; TOP-LEVEL vs CLASS/MODULE def: `method` is captured UNIFORMLY as
+; @definition.method (like Python captures every function_definition as function).
+; The provider's refine() reclassifies a `method` whose enclosing scope is NOT a
+; class/module body (i.e. a top-level `def`, or a def nested in another def/block)
+; to `function` — mirroring Python's module-level-function analog. `singleton_method`
+; stays `method` regardless of location (def self.x is a member method by intent).
+; refine() must do this because the structural query cannot inspect the enclosing
+; scope chain (query-runtime nests every def under a `body_statement`).
+;
+; The method `name:` field is captured with `(_)` (any node) so operator/setter
+; methods (`def <=>`, `def []`, `def foo=`) are captured too, not just identifiers.
+;
+; NAMESPACED constant assignments (`Foo::BAR = 1`, left is a `scope_resolution`,
+; NOT a bare `constant`) are intentionally NOT captured in v1 — low value and the
+; bare-constant pattern below deliberately does not match them.
+
+(class
+  name: (constant) @definition.class.name) @definition.class.node
+
+(module
+  name: (constant) @definition.namespace.name) @definition.namespace.node
+
+; def foo / def <=> / def foo= — captured uniformly; refine() may narrow a
+; non-class/module-body method to `function`.
+(method
+  name: (_) @definition.method.name) @definition.method.node
+
+; def self.foo — a singleton (class-level) method; always `method`.
+(singleton_method
+  name: (_) @definition.method.name) @definition.method.node
+
+; FOO = ... — a constant assignment (left is a bare constant). Captured at ANY depth
+; (top-level, class body, module body) — a Ruby constant is a meaningful symbol
+; wherever it is declared (parity with Go's const capture).
+(assignment
+  left: (constant) @definition.constant.name) @definition.constant.node

package/dist/core/code-map/lang/rust/imports.scm

@@ -0,0 +1,44 @@
+; Code Map — Rust imports (imports.scm). Provider #6 (langs batch 2).
+;
+; enclosingStatementNodeTypes = [use_declaration] (the import span/ordinal anchor).
+; Rust `use` paths are bare `a::b::c` (NO quotes) so — unlike Go — nothing to strip,
+; and the common use-tree shapes expand STRUCTURALLY in the query (no refine()):
+;   use a::b::c;            -> module a::b::c
+;   use foo;                -> module foo
+;   use a::b::{c, d};       -> module a::b   + imported names c, d   (group-use)
+;   use a::b as c;          -> module a::b   + imported name  c      (alias)
+;   use a::b::*;            -> module a::b   + imported name  '*'     (wildcard)
+; Grouping is keyed by the captured @import.source NODE (query-runtime), so the two
+; matches a `{c, d}` list produces share one source node -> one module with names
+; [c, d].
+;
+; v1 limitations (documented, not bugs): NESTED use-trees `use a::{b, c::{d}}` capture
+; only the top path `a` + the direct-identifier members (the nested `c::{…}` subtree
+; is dropped); `use a::{self, b}` drops the `self`; `pub use` re-exports are treated
+; as plain imports (NO exports edge — Rust re-export modelling deferred, capabilities
+; declare T2 imports only).
+
+; use a::b::c;  /  use foo;  (direct scoped/plain path is the module source)
+(use_declaration
+  argument: [
+    (scoped_identifier)
+    (identifier)
+  ] @import.source)
+
+; use a::b::{c, d};  -> source a::b, imported names c, d
+(use_declaration
+  argument: (scoped_use_list
+    path: [(scoped_identifier) (identifier)] @import.source
+    list: (use_list (identifier) @import.named.name)))
+
+; use a::b as c;  -> source a::b, imported name c
+(use_declaration
+  argument: (use_as_clause
+    path: [(scoped_identifier) (identifier)] @import.source
+    alias: (identifier) @import.named.name))
+
+; use a::b::*;  -> source a::b, imported name '*'
+(use_declaration
+  argument: (use_wildcard
+    [(scoped_identifier) (identifier)] @import.source
+    "*" @import.namespace.name))

package/dist/core/code-map/lang/rust/index.js

@@ -0,0 +1,136 @@
+/**
+ * Code Map langs batch 2 — RustProvider (provider #6).
+ *
+ * Owns `.rs` (runtime lang `rust`). `extractDraft` delegates to the generic
+ * query-runtime; the curated `tags.scm`/`imports.scm` (this dir) drive extraction.
+ * Definition subtypes are fixed by the query (struct→class, enum/function/constant/
+ * type/macro/namespace universal, `trait`→namespaced `rust.trait`). Rust methods are
+ * `function_item` nodes nested in an impl/trait body — the SAME node type as a free
+ * `fn` — so v1 maps ALL `function_item`→function (no `method` subtype; tree-sitter
+ * can't express "not inside an impl").
+ *
+ * NO `refine()` — Rust `use` paths are bare `a::b::c` (no quotes to strip), and the
+ * common use-tree shapes (group `{a,b}`, `as` alias, `*` wildcard) expand
+ * STRUCTURALLY in imports.scm via the runtime's per-`@import.source`-node grouping.
+ *
+ * NO exports edges — `pub use` re-export modelling is deferred (capabilities: T2 =
+ * imports). Identity is owned by the CORE finalizer — this provider mints NO ids.
+ * The grammar loads through the SHARED engine glue (`loadGrammarWasm`), never a
+ * fresh `web-tree-sitter` import (trp_8df65ab7).
+ */
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadGrammarWasm, grammarHashForWasm } from '../../wasm-loader.js';
+import { extractWithQueries } from '../query-runtime.js';
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const RUST_WASM_BASENAME = 'tree-sitter-rust.wasm';
+const RUST_WASM_NODE_MODULES_SPEC = 'tree-sitter-wasms/out/tree-sitter-rust.wasm';
+const RUST_GRAMMAR_NAME = 'tree-sitter-rust';
+/** Resolve a vendored `.scm` next to this module (dist) or from the source tree. */
+function readScm(basename) {
+    const local = path.join(HERE, basename);
+    if (fs.existsSync(local))
+        return fs.readFileSync(local, 'utf-8');
+    let dir = HERE;
+    for (let i = 0; i < 12; i++) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            const fromSrc = path.join(dir, 'src', 'core', 'code-map', 'lang', 'rust', basename);
+            if (fs.existsSync(fromSrc))
+                return fs.readFileSync(fromSrc, 'utf-8');
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error(`code-map: could not locate query asset ${basename} (from ${HERE})`);
+}
+function sha256(s) {
+    return `sha256:${crypto.createHash('sha256').update(s, 'utf-8').digest('hex')}`;
+}
+const TAGS = readScm('tags.scm');
+const IMPORTS = readScm('imports.scm');
+const TAGS_HASH = sha256(TAGS);
+const IMPORTS_HASH = sha256(IMPORTS);
+const parser = {
+    grammarForLang: () => loadGrammarWasm(RUST_WASM_BASENAME, RUST_WASM_NODE_MODULES_SPEC),
+    grammarNameForLang: () => RUST_GRAMMAR_NAME,
+    grammarHashForLang: () => grammarHashForWasm(RUST_WASM_BASENAME, RUST_WASM_NODE_MODULES_SPEC),
+};
+const queries = {
+    tags: { name: 'tags', sourceForLang: () => TAGS, hashForLang: () => TAGS_HASH },
+    imports: { name: 'imports', sourceForLang: () => IMPORTS, hashForLang: () => IMPORTS_HASH },
+    enclosingStatementNodeTypes: ['use_declaration'],
+    captureMap: [
+        { capture: 'definition.function.node', field: 'node', subtype: 'function' },
+        { capture: 'definition.function.name', field: 'name' },
+        { capture: 'definition.class.node', field: 'node', subtype: 'class' },
+        { capture: 'definition.class.name', field: 'name' },
+        { capture: 'definition.enum.node', field: 'node', subtype: 'enum' },
+        { capture: 'definition.enum.name', field: 'name' },
+        { capture: 'definition.rust.trait.node', field: 'node', subtype: 'rust.trait' },
+        { capture: 'definition.rust.trait.name', field: 'name' },
+        { capture: 'definition.namespace.node', field: 'node', subtype: 'namespace' },
+        { capture: 'definition.namespace.name', field: 'name' },
+        { capture: 'definition.constant.node', field: 'node', subtype: 'constant' },
+        { capture: 'definition.constant.name', field: 'name' },
+        { capture: 'definition.type.node', field: 'node', subtype: 'type' },
+        { capture: 'definition.type.name', field: 'name' },
+        { capture: 'definition.macro.node', field: 'node', subtype: 'macro' },
+        { capture: 'definition.macro.name', field: 'name' },
+        { capture: 'import.source', field: 'source' },
+        { capture: 'import.named.name', field: 'name' },
+        { capture: 'import.namespace.name', field: 'name' },
+    ],
+};
+const vocabulary = {
+    nodeSubtypes: ['function', 'class', 'enum', 'rust.trait', 'namespace', 'constant', 'type', 'macro'],
+    edgeKinds: ['contains', 'defines', 'imports'],
+    captureMap: queries.captureMap,
+};
+const capabilities = {
+    tiers: ['T1.definitions', 'T2.imports'],
+    proven: {
+        'T1.definitions': true,
+        'T2.imports': true,
+        'T3.import_resolution': false,
+        'T4.tests_for': false,
+    },
+};
+export class RustProvider {
+    id = 'rust';
+    displayName = 'Rust';
+    languages = ['rust'];
+    extensions = ['.rs'];
+    priority = 0;
+    version = '0.1.0';
+    parser = parser;
+    queries = queries;
+    vocabulary = vocabulary;
+    capabilities = capabilities;
+    langForPath(_p) {
+        return 'rust';
+    }
+    async extractDraft(input, _services) {
+        return extractWithQueries({
+            providerId: this.id,
+            lang: input.lang,
+            source: input.source,
+            sizeBytes: input.sizeBytes,
+            maxParseFileBytes: input.maxParseFileBytes,
+            maxQueryWaitMs: input.maxQueryWaitMs,
+            path: input.path,
+            grammarForLang: this.parser.grammarForLang,
+            tagsSource: TAGS,
+            tagsHash: TAGS_HASH,
+            importsSource: IMPORTS,
+            importsHash: IMPORTS_HASH,
+            enclosingStatementNodeTypes: queries.enclosingStatementNodeTypes,
+        });
+    }
+}
+export const rustProvider = new RustProvider();
+//# sourceMappingURL=index.js.map

package/dist/core/code-map/lang/rust/tags.scm

@@ -0,0 +1,47 @@
+; Code Map — Rust definitions (tags.scm). Provider #6 (langs batch 2).
+;
+; Capture-name convention (query-runtime.ts is the contract):
+;   @definition.<subtype>.node = identity-span anchor (the whole declaration)
+;   @definition.<subtype>.name = the symbol name node
+; Subtypes: function/enum/namespace/constant/type/macro are universal; a Rust
+; struct maps to `class` (the named aggregate devs search for like a class), and a
+; `trait` has no clean universal equal (it carries default methods + associated
+; types/consts, unlike a plain interface) so it is NAMESPACED as `rust.trait`
+; (guide §"when to namespace" cites this exact case).
+;
+; METHOD caveat (v1): Rust methods are `function_item` nodes nested in an
+; `impl_item` (or `trait_item`) body — the SAME node type as a free `fn`. Tree-sitter
+; queries can't express "function_item NOT inside an impl", so a single generic
+; pattern maps ALL `function_item` -> `function` (no distinct `method` subtype in
+; v1). Trait method *signatures* (`function_signature_item`, no body) are a distinct
+; node type and are intentionally NOT captured in v1.
+;
+; const + static both map to `constant`; associated const/type inside impl/trait
+; reuse the const_item/type_item patterns (captured as constant/type — acceptable).
+
+(function_item
+  name: (identifier) @definition.function.name) @definition.function.node
+
+(struct_item
+  name: (type_identifier) @definition.class.name) @definition.class.node
+
+(enum_item
+  name: (type_identifier) @definition.enum.name) @definition.enum.node
+
+(trait_item
+  name: (type_identifier) @definition.rust.trait.name) @definition.rust.trait.node
+
+(mod_item
+  name: (identifier) @definition.namespace.name) @definition.namespace.node
+
+(const_item
+  name: (identifier) @definition.constant.name) @definition.constant.node
+
+(static_item
+  name: (identifier) @definition.constant.name) @definition.constant.node
+
+(type_item
+  name: (type_identifier) @definition.type.name) @definition.type.node
+
+(macro_definition
+  name: (identifier) @definition.macro.name) @definition.macro.node