@pellux/goodvibes-sdk 0.28.21 → 0.30.0

package/dist/platform/intelligence/tree-sitter/queries.js

@@ -1 +1,403 @@
-export * from '../../../_internal/platform/intelligence/tree-sitter/queries.js';
+import { logger } from '../../utils/logger.js';
+import { summarizeError } from '../../utils/error-display.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Extract the first line of a node's text (up to `{` or newline). */
+function nodeSignature(node) {
+    const text = node.text ?? '';
+    const brace = text.indexOf('{');
+    const newline = text.indexOf('\n');
+    let end = text.length;
+    if (brace !== -1)
+        end = Math.min(end, brace);
+    if (newline !== -1)
+        end = Math.min(end, newline);
+    return text.slice(0, end).trim();
+}
+/** Check if a node has an `export` keyword as a direct ancestor or sibling. */
+function isExported(node) {
+    const parent = node.parent;
+    if (!parent)
+        return false;
+    // export_statement wraps the declaration
+    if (parent.type === 'export_statement')
+        return true;
+    // Some parsers put export as a child of export_statement
+    for (let i = 0; i < parent.childCount; i++) {
+        const child = parent.child(i);
+        if (child && child.type === 'export')
+            return true;
+    }
+    return false;
+}
+/** Get the identifier name child from a declaration node. */
+function getNameFromNode(node) {
+    // Try 'name' field first
+    const nameChild = node.childForFieldName('name');
+    if (nameChild)
+        return nameChild.text;
+    // Fall back: find first identifier child
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && (child.type === 'identifier' || child.type === 'type_identifier')) {
+            return child.text;
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// TypeScript / JavaScript extraction
+// ---------------------------------------------------------------------------
+const TS_SYMBOL_TYPES = new Set([
+    'function_declaration',
+    'class_declaration',
+    'interface_declaration',
+    'type_alias_declaration',
+    'enum_declaration',
+    'method_definition',
+    'lexical_declaration', // const/let
+    'variable_declaration', // var
+]);
+const TS_SCOPE_TYPES = new Set([
+    'function_declaration',
+    'arrow_function',
+    'function_expression',
+    'class_declaration',
+    'class_expression',
+    'method_definition',
+]);
+function extractTSSymbols(root, container) {
+    const symbols = [];
+    function visitNode(node, currentContainer) {
+        if (!TS_SYMBOL_TYPES.has(node.type)) {
+            for (let i = 0; i < node.childCount; i++) {
+                const child = node.child(i);
+                if (child)
+                    visitNode(child, currentContainer);
+            }
+            return;
+        }
+        const type = node.type;
+        const exported = isExported(node);
+        if (type === 'function_declaration') {
+            const name = getNameFromNode(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'function',
+                    line: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                    column: node.startPosition.column,
+                    exported,
+                    signature: nodeSignature(node),
+                    container: currentContainer,
+                });
+            }
+            // Recurse into function body for nested declarations
+            for (let i = 0; i < node.childCount; i++) {
+                const child = node.child(i);
+                if (child && child.type === 'statement_block') {
+                    visitNode(child, name ?? currentContainer);
+                }
+            }
+            return;
+        }
+        if (type === 'class_declaration') {
+            const name = getNameFromNode(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'class',
+                    line: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                    column: node.startPosition.column,
+                    exported,
+                    signature: nodeSignature(node),
+                    container: currentContainer,
+                });
+                // Recurse into class body for methods
+                for (let i = 0; i < node.childCount; i++) {
+                    const child = node.child(i);
+                    if (child && child.type === 'class_body') {
+                        visitNode(child, name);
+                    }
+                }
+            }
+            return;
+        }
+        if (type === 'interface_declaration') {
+            const name = getNameFromNode(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'interface',
+                    line: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                    column: node.startPosition.column,
+                    exported,
+                    signature: nodeSignature(node),
+                    container: currentContainer,
+                });
+            }
+            return;
+        }
+        if (type === 'type_alias_declaration') {
+            const name = getNameFromNode(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'type',
+                    line: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                    column: node.startPosition.column,
+                    exported,
+                    signature: nodeSignature(node),
+                    container: currentContainer,
+                });
+            }
+            return;
+        }
+        if (type === 'enum_declaration') {
+            const name = getNameFromNode(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'enum',
+                    line: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                    column: node.startPosition.column,
+                    exported,
+                    signature: nodeSignature(node),
+                    container: currentContainer,
+                });
+            }
+            return;
+        }
+        if (type === 'method_definition') {
+            const name = getNameFromNode(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'method',
+                    line: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                    column: node.startPosition.column,
+                    exported: false, // methods aren't individually exported
+                    signature: nodeSignature(node),
+                    container: currentContainer,
+                });
+            }
+            return;
+        }
+        // const/let/var declarations — look for declarators at top level only
+        if (type === 'lexical_declaration' || type === 'variable_declaration') {
+            const isConst = node.child(0)?.text === 'const';
+            for (let i = 0; i < node.childCount; i++) {
+                const child = node.child(i);
+                if (child && child.type === 'variable_declarator') {
+                    const name = getNameFromNode(child);
+                    if (name) {
+                        symbols.push({
+                            name,
+                            kind: isConst ? 'constant' : 'variable',
+                            line: node.startPosition.row + 1,
+                            endLine: node.endPosition.row + 1,
+                            column: node.startPosition.column,
+                            exported,
+                            signature: nodeSignature(node),
+                            container: currentContainer,
+                        });
+                    }
+                }
+            }
+            return;
+        }
+        // Recurse for everything else
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                visitNode(child, currentContainer);
+        }
+    }
+    visitNode(root, container);
+    return symbols;
+}
+// ---------------------------------------------------------------------------
+// Python extraction
+// ---------------------------------------------------------------------------
+function extractPythonSymbols(root) {
+    const symbols = [];
+    function visitNode(node, container) {
+        if (node.type === 'function_definition') {
+            const name = getNameFromNode(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'function',
+                    line: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                    column: node.startPosition.column,
+                    exported: !name.startsWith('_'),
+                    signature: nodeSignature(node),
+                    container,
+                });
+                for (let i = 0; i < node.childCount; i++) {
+                    const child = node.child(i);
+                    if (child && child.type === 'block')
+                        visitNode(child, name);
+                }
+            }
+            return;
+        }
+        if (node.type === 'class_definition') {
+            const name = getNameFromNode(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'class',
+                    line: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                    column: node.startPosition.column,
+                    exported: !name.startsWith('_'),
+                    signature: nodeSignature(node),
+                    container,
+                });
+                for (let i = 0; i < node.childCount; i++) {
+                    const child = node.child(i);
+                    if (child && child.type === 'block')
+                        visitNode(child, name);
+                }
+            }
+            return;
+        }
+        // Module-level assignment
+        if (node.type === 'assignment' && node.parent?.type === 'module') {
+            const leftChild = node.child(0);
+            if (leftChild && leftChild.type === 'identifier') {
+                symbols.push({
+                    name: leftChild.text,
+                    kind: 'variable',
+                    line: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                    column: node.startPosition.column,
+                    exported: !leftChild.text.startsWith('_'),
+                    signature: nodeSignature(node),
+                    container,
+                });
+            }
+            return;
+        }
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                visitNode(child, container);
+        }
+    }
+    visitNode(root);
+    return symbols;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Extract all symbols from a parsed tree.
+ * Supports TypeScript, TSX, JavaScript, and Python.
+ * Returns empty array with a warning for unsupported languages.
+ */
+export function extractSymbols(tree, _language, langId) {
+    try {
+        const root = tree.rootNode;
+        if (langId === 'typescript' || langId === 'tsx' || langId === 'javascript') {
+            return extractTSSymbols(root);
+        }
+        if (langId === 'python') {
+            return extractPythonSymbols(root);
+        }
+        logger.debug('extractSymbols: unsupported language', { langId });
+        return [];
+    }
+    catch (err) {
+        logger.error('extractSymbols: failed', { langId, error: summarizeError(err) });
+        return [];
+    }
+}
+/**
+ * Extract outline (structure without bodies) from a parsed tree.
+ * Returns top-level entries with children for nested declarations.
+ */
+export function extractOutline(tree, language, langId) {
+    try {
+        const symbols = extractSymbols(tree, language, langId);
+        // Build a flat list first, then nest by container
+        const toplevel = [];
+        const byName = new Map();
+        for (const sym of symbols) {
+            const entry = {
+                name: sym.name,
+                kind: sym.kind,
+                line: sym.line,
+                endLine: sym.endLine,
+                signature: sym.signature ?? sym.name,
+                children: [],
+            };
+            const qualifiedName = sym.container ? `${sym.container}.${sym.name}` : sym.name;
+            if (sym.container && byName.has(sym.container)) {
+                byName.get(sym.container)?.children.push(entry);
+            }
+            else {
+                toplevel.push(entry);
+            }
+            byName.set(qualifiedName, entry);
+        }
+        return toplevel;
+    }
+    catch (err) {
+        logger.error('extractOutline: failed', { langId, error: summarizeError(err) });
+        return [];
+    }
+}
+/**
+ * Find the innermost function/class/block enclosing the given (1-based) line.
+ * Returns null if no enclosing scope is found or if the language is unsupported.
+ */
+export function findEnclosingScope(tree, _language, langId, line) {
+    const scopeTypes = langId === 'typescript' || langId === 'tsx' || langId === 'javascript'
+        ? TS_SCOPE_TYPES
+        : langId === 'python'
+            ? new Set(['function_definition', 'class_definition'])
+            : null;
+    if (!scopeTypes) {
+        logger.debug('findEnclosingScope: unsupported language', { langId });
+        return null;
+    }
+    const targetRow = line - 1; // tree-sitter rows are 0-based
+    let best = null;
+    let bestSize = Infinity;
+    function visitNode(node) {
+        const start = node.startPosition.row;
+        const end = node.endPosition.row;
+        if (targetRow < start || targetRow > end)
+            return;
+        if (scopeTypes && scopeTypes.has(node.type)) {
+            const size = end - start;
+            if (size < bestSize) {
+                bestSize = size;
+                const name = getNameFromNode(node) ?? '(anonymous)';
+                best = {
+                    kind: node.type,
+                    name,
+                    startLine: start + 1,
+                    endLine: end + 1,
+                };
+            }
+        }
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                visitNode(child);
+        }
+    }
+    visitNode(tree.rootNode);
+    return best;
+}

package/dist/platform/intelligence/tree-sitter/service.d.ts

@@ -1,2 +1,48 @@
-export * from '../../../_internal/platform/intelligence/tree-sitter/service.js';
+/**
+ * TreeSitterService — Grammar loading, parsing, and tree caching.
+ *
+ * Grammar WASM files are embedded in the compiled binary via Bun's
+ * `with { type: 'file' }` import assertion (see embedded-wasm.ts).
+ * Missing grammars are handled gracefully (returns null, logs warning).
+ * Never throws — callers receive null on failure.
+ */
+import { Language, Tree } from 'web-tree-sitter';
+import type { QueryMatch } from 'web-tree-sitter';
+export declare class TreeSitterService {
+    private parser;
+    private initialized;
+    private initPromise;
+    private languages;
+    private treeCache;
+    /**
+     * Initialize the WASM module. Safe to call multiple times — only runs once.
+     * Must be called before parse() will work.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Load a language grammar by ID. Grammars are loaded lazily and cached.
+     * Returns null if the grammar WASM file is not available.
+     */
+    loadLanguage(langId: string): Promise<Language | null>;
+    /**
+     * Parse a file and cache the result.
+     * Returns null if WASM is not initialized or grammar is unavailable.
+     */
+    parse(filePath: string, content: string, langId?: string): Promise<Tree | null>;
+    /** Invalidate the cached tree for a file (call after edits). */
+    invalidate(filePath: string): void;
+    /**
+     * Run a tree-sitter Query on a parsed tree.
+     * Returns an empty array if the query fails.
+     */
+    query(tree: Tree, language: Language, queryString: string): QueryMatch[];
+    /** Current number of cached trees. */
+    get cacheSize(): number;
+    /** Loaded language IDs. */
+    get loadedLanguages(): string[];
+    /**
+     * Free all resources held by this service instance.
+     */
+    dispose(): void;
+}
 //# sourceMappingURL=service.d.ts.map

package/dist/platform/intelligence/tree-sitter/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/platform/intelligence/tree-sitter/service.ts"],"names":[],"mappings":"AAAA,cAAc,iEAAiE,CAAC"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/platform/intelligence/tree-sitter/service.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAU,QAAQ,EAAS,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAalD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,SAAS,CAAoC;IACrD,OAAO,CAAC,SAAS,CAAsC;IACvD;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAwBjC;;;OAGG;IACG,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAuB5D;;;OAGG;IACG,KAAK,CACT,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IA+CvB,gEAAgE;IAChE,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQlC;;;OAGG;IACH,KAAK,CACH,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,MAAM,GAClB,UAAU,EAAE;IAYf,sCAAsC;IACtC,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,2BAA2B;IAC3B,IAAI,eAAe,IAAI,MAAM,EAAE,CAE9B;IAED;;OAEG;IACH,OAAO,IAAI,IAAI;CAahB"}

package/dist/platform/intelligence/tree-sitter/service.js

@@ -1 +1,171 @@
-export * from '../../../_internal/platform/intelligence/tree-sitter/service.js';
+/**
+ * TreeSitterService — Grammar loading, parsing, and tree caching.
+ *
+ * Grammar WASM files are embedded in the compiled binary via Bun's
+ * `with { type: 'file' }` import assertion (see embedded-wasm.ts).
+ * Missing grammars are handled gracefully (returns null, logs warning).
+ * Never throws — callers receive null on failure.
+ */
+import { Parser, Language, Query, Tree } from 'web-tree-sitter';
+import { logger } from '../../utils/logger.js';
+import { detectLanguage } from './languages.js';
+import { TREE_SITTER_WASM, GRAMMAR_WASM } from './embedded-wasm.js';
+import { summarizeError } from '../../utils/error-display.js';
+const MAX_CACHE_SIZE = 100;
+export class TreeSitterService {
+    parser = null;
+    initialized = false;
+    initPromise = null;
+    languages = new Map();
+    treeCache = new Map();
+    /**
+     * Initialize the WASM module. Safe to call multiple times — only runs once.
+     * Must be called before parse() will work.
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = (async () => {
+            try {
+                // TREE_SITTER_WASM is the embedded WASM path from embedded-wasm.ts.
+                // In compiled binaries it resolves to the embedded file; in dev mode
+                // it resolves to the absolute filesystem path. Both work.
+                await Parser.init({
+                    locateFile: (_path) => TREE_SITTER_WASM,
+                });
+                this.parser = new Parser();
+                this.initialized = true;
+                logger.info('TreeSitterService: WASM initialized');
+            }
+            catch (err) {
+                logger.error('TreeSitterService: WASM init failed', { error: summarizeError(err) });
+                this.initPromise = null; // allow retry on next call
+            }
+        })();
+        return this.initPromise;
+    }
+    /**
+     * Load a language grammar by ID. Grammars are loaded lazily and cached.
+     * Returns null if the grammar WASM file is not available.
+     */
+    async loadLanguage(langId) {
+        const cached = this.languages.get(langId);
+        if (cached)
+            return cached;
+        // Look up the embedded WASM path. If not present, the grammar package is
+        // not installed — return null rather than throwing.
+        const wasmPath = GRAMMAR_WASM[langId];
+        if (!wasmPath) {
+            logger.debug('TreeSitterService: grammar WASM not embedded', { langId });
+            return null;
+        }
+        try {
+            const language = await Language.load(wasmPath);
+            this.languages.set(langId, language);
+            logger.info('TreeSitterService: loaded grammar', { langId });
+            return language;
+        }
+        catch (err) {
+            logger.error('TreeSitterService: failed to load grammar', { langId, error: summarizeError(err) });
+            return null;
+        }
+    }
+    /**
+     * Parse a file and cache the result.
+     * Returns null if WASM is not initialized or grammar is unavailable.
+     */
+    async parse(filePath, content, langId) {
+        if (!this.initialized || !this.parser) {
+            logger.debug('TreeSitterService: not initialized, skipping parse', { filePath });
+            return null;
+        }
+        const resolvedLangId = langId ?? detectLanguage(filePath);
+        if (!resolvedLangId) {
+            logger.debug('TreeSitterService: unknown language for file', { filePath });
+            return null;
+        }
+        const language = await this.loadLanguage(resolvedLangId);
+        if (!language)
+            return null;
+        try {
+            this.parser.setLanguage(language);
+            const tree = this.parser.parse(content);
+            if (!tree)
+                return null;
+            const existing = this.treeCache.get(filePath);
+            const nextVersion = existing ? existing.version + 1 : 1;
+            // FIFO eviction when at capacity (sufficient since parse() re-inserts on update)
+            if (!existing && this.treeCache.size >= MAX_CACHE_SIZE) {
+                const firstKey = this.treeCache.keys().next().value;
+                if (firstKey !== undefined) {
+                    const evicted = this.treeCache.get(firstKey);
+                    if (evicted)
+                        evicted.tree.delete();
+                    this.treeCache.delete(firstKey);
+                }
+            }
+            if (existing)
+                existing.tree.delete();
+            this.treeCache.set(filePath, { tree, version: nextVersion });
+            return tree;
+        }
+        catch (err) {
+            logger.error('TreeSitterService: parse failed', {
+                filePath,
+                langId: resolvedLangId,
+                error: summarizeError(err),
+            });
+            return null;
+        }
+    }
+    /** Invalidate the cached tree for a file (call after edits). */
+    invalidate(filePath) {
+        const entry = this.treeCache.get(filePath);
+        if (entry) {
+            entry.tree.delete();
+            this.treeCache.delete(filePath);
+        }
+    }
+    /**
+     * Run a tree-sitter Query on a parsed tree.
+     * Returns an empty array if the query fails.
+     */
+    query(tree, language, queryString) {
+        try {
+            const q = new Query(language, queryString);
+            const matches = q.matches(tree.rootNode);
+            q.delete();
+            return matches;
+        }
+        catch (err) {
+            logger.error('TreeSitterService: query failed', { error: summarizeError(err) });
+            return [];
+        }
+    }
+    /** Current number of cached trees. */
+    get cacheSize() {
+        return this.treeCache.size;
+    }
+    /** Loaded language IDs. */
+    get loadedLanguages() {
+        return Array.from(this.languages.keys());
+    }
+    /**
+     * Free all resources held by this service instance.
+     */
+    dispose() {
+        for (const entry of this.treeCache.values()) {
+            entry.tree.delete();
+        }
+        this.treeCache.clear();
+        this.languages.clear();
+        if (this.parser) {
+            this.parser.delete();
+            this.parser = null;
+        }
+        this.initialized = false;
+        this.initPromise = null;
+    }
+}

package/dist/platform/knowledge/bookmarks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bookmarks.d.ts","sourceRoot":"","sources":["../../../src/platform/knowledge/bookmarks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAkJxD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,EAAE,CAkB3E"}