bluera-knowledge 0.14.0 → 0.14.2

package/src/analysis/tree-sitter-parser.test.ts

@@ -1,297 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  createRustParser,
-  createGoParser,
-  parseRustCode,
-  parseGoCode,
-  positionToLineNumber,
-  getNodeText,
-  getChildrenOfType,
-  getFirstChildOfType,
-  getChildByFieldName,
-  hasVisibilityModifier,
-  getVisibilityModifier,
-  isAsyncFunction,
-  isUnsafeFunction,
-  getFunctionSignature,
-  queryNodesByType,
-  extractImportPath,
-  type TreeSitterNode,
-  type TreeSitterTree,
-} from './tree-sitter-parser.js';
-
-describe('tree-sitter-parser', () => {
-  describe('createRustParser', () => {
-    it('creates a functional Rust parser', () => {
-      const parser = createRustParser();
-      expect(parser).toBeDefined();
-      const tree = parser.parse('fn main() {}');
-      expect(tree).toBeDefined();
-    });
-  });
-
-  describe('createGoParser', () => {
-    it('creates a functional Go parser', () => {
-      const parser = createGoParser();
-      expect(parser).toBeDefined();
-      const tree = parser.parse('package main\nfunc main() {}');
-      expect(tree).toBeDefined();
-    });
-  });
-
-  describe('parseRustCode', () => {
-    it('parses valid Rust code', () => {
-      const tree = parseRustCode('fn hello() {}');
-      expect(tree).not.toBeNull();
-      expect(tree?.rootNode).toBeDefined();
-    });
-
-    it('handles malformed Rust code gracefully', () => {
-      // Tree-sitter is very tolerant, but we test the structure
-      const tree = parseRustCode('fn {{{ invalid syntax');
-      // Tree-sitter returns a tree even with errors, so check it's valid
-      expect(tree).not.toBeNull();
-    });
-  });
-
-  describe('parseGoCode', () => {
-    it('parses valid Go code', () => {
-      const tree = parseGoCode('package main\nfunc hello() {}');
-      expect(tree).not.toBeNull();
-      expect(tree?.rootNode).toBeDefined();
-    });
-
-    it('handles malformed Go code gracefully', () => {
-      // Tree-sitter is very tolerant
-      const tree = parseGoCode('package {{{ invalid');
-      expect(tree).not.toBeNull();
-    });
-  });
-
-  describe('positionToLineNumber', () => {
-    it('converts 0-indexed row to 1-indexed line number', () => {
-      expect(positionToLineNumber({ row: 0, column: 0 })).toBe(1);
-      expect(positionToLineNumber({ row: 5, column: 10 })).toBe(6);
-      expect(positionToLineNumber({ row: 99, column: 0 })).toBe(100);
-    });
-  });
-
-  describe('getNodeText', () => {
-    it('returns the text content of a node', () => {
-      const tree = parseRustCode('fn hello() {}');
-      expect(tree).not.toBeNull();
-      const rootText = getNodeText(tree!.rootNode as TreeSitterNode);
-      expect(rootText).toBe('fn hello() {}');
-    });
-  });
-
-  describe('getChildrenOfType', () => {
-    it('returns children matching the specified type', () => {
-      const tree = parseRustCode('fn a() {} fn b() {} fn c() {}');
-      expect(tree).not.toBeNull();
-      const functions = getChildrenOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(functions).toHaveLength(3);
-    });
-
-    it('returns empty array when no children match', () => {
-      const tree = parseRustCode('fn hello() {}');
-      expect(tree).not.toBeNull();
-      const structs = getChildrenOfType(tree!.rootNode as TreeSitterNode, 'struct_item');
-      expect(structs).toEqual([]);
-    });
-  });
-
-  describe('getFirstChildOfType', () => {
-    it('returns first child matching the type', () => {
-      const tree = parseRustCode('fn first() {} fn second() {}');
-      expect(tree).not.toBeNull();
-      const firstFn = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(firstFn).not.toBeNull();
-      expect(firstFn!.text).toContain('first');
-    });
-
-    it('returns null when no child matches', () => {
-      const tree = parseRustCode('fn hello() {}');
-      expect(tree).not.toBeNull();
-      const structNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'struct_item');
-      expect(structNode).toBeNull();
-    });
-  });
-
-  describe('getChildByFieldName', () => {
-    it('returns child by field name', () => {
-      const tree = parseRustCode('fn hello() {}');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      const nameNode = getChildByFieldName(fnNode!, 'name');
-      expect(nameNode).not.toBeNull();
-      expect(nameNode!.text).toBe('hello');
-    });
-
-    it('returns null when field does not exist', () => {
-      const tree = parseRustCode('fn hello() {}');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      const nonexistent = getChildByFieldName(fnNode!, 'nonexistent_field');
-      expect(nonexistent).toBeNull();
-    });
-  });
-
-  describe('hasVisibilityModifier', () => {
-    it('returns true for pub functions', () => {
-      const tree = parseRustCode('pub fn hello() {}');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      expect(hasVisibilityModifier(fnNode!)).toBe(true);
-    });
-
-    it('returns false for private functions', () => {
-      const tree = parseRustCode('fn hello() {}');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      expect(hasVisibilityModifier(fnNode!)).toBe(false);
-    });
-  });
-
-  describe('getVisibilityModifier', () => {
-    it('returns visibility text for pub items', () => {
-      const tree = parseRustCode('pub fn hello() {}');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      expect(getVisibilityModifier(fnNode!)).toBe('pub');
-    });
-
-    it('returns visibility text for pub(crate)', () => {
-      const tree = parseRustCode('pub(crate) fn hello() {}');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      expect(getVisibilityModifier(fnNode!)).toBe('pub(crate)');
-    });
-
-    it('returns null for private items', () => {
-      const tree = parseRustCode('fn hello() {}');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      expect(getVisibilityModifier(fnNode!)).toBeNull();
-    });
-  });
-
-  describe('isAsyncFunction', () => {
-    it('returns true for async functions', () => {
-      const tree = parseRustCode('async fn fetch() {}');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      expect(isAsyncFunction(fnNode!)).toBe(true);
-    });
-
-    it('returns false for sync functions', () => {
-      const tree = parseRustCode('fn sync() {}');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      expect(isAsyncFunction(fnNode!)).toBe(false);
-    });
-  });
-
-  describe('isUnsafeFunction', () => {
-    it('returns true for unsafe functions', () => {
-      const tree = parseRustCode('unsafe fn danger() {}');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      expect(isUnsafeFunction(fnNode!)).toBe(true);
-    });
-
-    it('returns false for safe functions', () => {
-      const tree = parseRustCode('fn safe() {}');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      expect(isUnsafeFunction(fnNode!)).toBe(false);
-    });
-  });
-
-  describe('getFunctionSignature', () => {
-    it('returns basic function signature', () => {
-      const tree = parseRustCode('fn hello() {}');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      const sig = getFunctionSignature(fnNode!);
-      expect(sig).toContain('hello');
-      expect(sig).toContain('()');
-    });
-
-    it('returns signature with return type', () => {
-      const tree = parseRustCode('fn get() -> i32 { 42 }');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      const sig = getFunctionSignature(fnNode!);
-      expect(sig).toContain('get');
-      expect(sig).toContain('i32');
-    });
-
-    it('returns signature with type parameters', () => {
-      const tree = parseRustCode('fn generic<T>(val: T) -> T { val }');
-      expect(tree).not.toBeNull();
-      const fnNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'function_item');
-      expect(fnNode).not.toBeNull();
-      const sig = getFunctionSignature(fnNode!);
-      expect(sig).toContain('<T>');
-    });
-
-    it('returns empty string when name node is missing', () => {
-      // Create a mock node without a name field
-      const mockNode: Partial<TreeSitterNode> = {
-        children: [],
-        childForFieldName: () => null,
-      };
-      const sig = getFunctionSignature(mockNode as TreeSitterNode);
-      expect(sig).toBe('');
-    });
-  });
-
-  describe('queryNodesByType', () => {
-    it('queries single node type', () => {
-      const tree = parseRustCode('fn a() {} struct B {} fn c() {}');
-      expect(tree).not.toBeNull();
-      const functions = queryNodesByType(tree as TreeSitterTree, 'function_item');
-      expect(functions).toHaveLength(2);
-    });
-
-    it('queries multiple node types', () => {
-      const tree = parseRustCode('fn a() {} struct B {} fn c() {}');
-      expect(tree).not.toBeNull();
-      const items = queryNodesByType(tree as TreeSitterTree, ['function_item', 'struct_item']);
-      expect(items).toHaveLength(3);
-    });
-  });
-
-  describe('extractImportPath', () => {
-    it('extracts import path from use statement', () => {
-      const tree = parseRustCode('use std::collections::HashMap;');
-      expect(tree).not.toBeNull();
-      const useNode = getFirstChildOfType(tree!.rootNode as TreeSitterNode, 'use_declaration');
-      expect(useNode).not.toBeNull();
-      const path = extractImportPath(useNode!);
-      expect(path).toContain('std');
-    });
-
-    it('returns empty string when argument node is missing', () => {
-      // Create a mock node without an argument field
-      const mockNode: Partial<TreeSitterNode> = {
-        childForFieldName: () => null,
-      };
-      const path = extractImportPath(mockNode as TreeSitterNode);
-      expect(path).toBe('');
-    });
-  });
-});

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

@@ -1,217 +0,0 @@
-import Parser from 'tree-sitter';
-import Go from 'tree-sitter-go';
-import Rust from 'tree-sitter-rust';
-
-/**
- * Tree-sitter infrastructure for parsing Rust and Go code.
- * Provides utilities for AST traversal, querying, and position conversion.
- */
-
-export interface TreeSitterPosition {
-  row: number;
-  column: number;
-}
-
-export interface TreeSitterNode {
-  type: string;
-  text: string;
-  startPosition: TreeSitterPosition;
-  endPosition: TreeSitterPosition;
-  startIndex: number;
-  endIndex: number;
-  childCount: number;
-  namedChildCount: number;
-  children: TreeSitterNode[];
-  namedChildren: TreeSitterNode[];
-  parent: TreeSitterNode | null;
-  nextSibling: TreeSitterNode | null;
-  previousSibling: TreeSitterNode | null;
-  firstChild: TreeSitterNode | null;
-  lastChild: TreeSitterNode | null;
-  firstNamedChild: TreeSitterNode | null;
-  lastNamedChild: TreeSitterNode | null;
-  child(index: number): TreeSitterNode | null;
-  namedChild(index: number): TreeSitterNode | null;
-  childForFieldName(fieldName: string): TreeSitterNode | null;
-  descendantsOfType(type: string | string[]): TreeSitterNode[];
-}
-
-export interface TreeSitterTree {
-  rootNode: TreeSitterNode;
-  edit(delta: unknown): void;
-  walk(): unknown;
-}
-
-/**
- * Initialize a tree-sitter parser for Rust
- */
-export function createRustParser(): Parser {
-  const parser = new Parser();
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- tree-sitter-rust lacks TypeScript definitions
-  parser.setLanguage(Rust as Parser.Language);
-  return parser;
-}
-
-/**
- * Parse Rust source code into an AST
- */
-export function parseRustCode(code: string): TreeSitterTree | null {
-  try {
-    const parser = createRustParser();
-    return parser.parse(code);
-  } catch {
-    // Return null for malformed code
-    return null;
-  }
-}
-
-/**
- * Initialize a tree-sitter parser for Go
- */
-export function createGoParser(): Parser {
-  const parser = new Parser();
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- tree-sitter-go lacks TypeScript definitions
-  parser.setLanguage(Go as Parser.Language);
-  return parser;
-}
-
-/**
- * Parse Go source code into an AST
- */
-export function parseGoCode(code: string): TreeSitterTree | null {
-  try {
-    const parser = createGoParser();
-    return parser.parse(code);
-  } catch {
-    // Return null for malformed code
-    return null;
-  }
-}
-
-/**
- * Convert tree-sitter position (0-indexed) to line number (1-indexed)
- */
-export function positionToLineNumber(position: TreeSitterPosition): number {
-  return position.row + 1;
-}
-
-/**
- * Get the text content of a node
- */
-export function getNodeText(node: TreeSitterNode): string {
-  return node.text;
-}
-
-/**
- * Get all children of a specific type
- */
-export function getChildrenOfType(node: TreeSitterNode, type: string): TreeSitterNode[] {
-  return node.children.filter((child) => child.type === type);
-}
-
-/**
- * Get the first child of a specific type
- */
-export function getFirstChildOfType(node: TreeSitterNode, type: string): TreeSitterNode | null {
-  return node.children.find((child) => child.type === type) ?? null;
-}
-
-/**
- * Get child by field name (e.g., "name", "body", "parameters")
- */
-export function getChildByFieldName(
-  node: TreeSitterNode,
-  fieldName: string
-): TreeSitterNode | null {
-  return node.childForFieldName(fieldName);
-}
-
-/**
- * Check if node has a visibility modifier (pub)
- */
-export function hasVisibilityModifier(node: TreeSitterNode): boolean {
-  return node.children.some((child) => child.type === 'visibility_modifier');
-}
-
-/**
- * Get visibility modifier text (e.g., "pub", "pub(crate)")
- */
-export function getVisibilityModifier(node: TreeSitterNode): string | null {
-  const visNode = node.children.find((child) => child.type === 'visibility_modifier');
-  return visNode !== undefined ? visNode.text : null;
-}
-
-/**
- * Check if a function is async
- */
-export function isAsyncFunction(node: TreeSitterNode): boolean {
-  // Check for 'async' keyword in function_item or function_signature_item
-  return node.children.some((child) => child.type === 'async' || child.text === 'async');
-}
-
-/**
- * Check if a function is unsafe
- */
-export function isUnsafeFunction(node: TreeSitterNode): boolean {
-  return node.children.some((child) => child.type === 'unsafe' || child.text === 'unsafe');
-}
-
-/**
- * Extract function signature including generics and parameters
- */
-export function getFunctionSignature(node: TreeSitterNode): string {
-  // Extract the full signature by getting text from name to return type
-  const nameNode = getChildByFieldName(node, 'name');
-  const parametersNode = getChildByFieldName(node, 'parameters');
-  const returnTypeNode = getChildByFieldName(node, 'return_type');
-  const typeParametersNode = getChildByFieldName(node, 'type_parameters');
-
-  if (nameNode === null) {
-    return '';
-  }
-
-  let signature = nameNode.text;
-
-  // Add type parameters (generics)
-  if (typeParametersNode !== null) {
-    signature += typeParametersNode.text;
-  }
-
-  // Add parameters
-  if (parametersNode !== null) {
-    signature += parametersNode.text;
-  }
-
-  // Add return type
-  if (returnTypeNode !== null) {
-    signature += ` ${returnTypeNode.text}`;
-  }
-
-  return signature;
-}
-
-/**
- * Query nodes of specific type from the tree
- * @param tree The tree-sitter tree
- * @param nodeType The type of nodes to find (e.g., 'function_item', 'struct_item')
- * @returns Array of matching nodes
- */
-export function queryNodesByType(
-  tree: TreeSitterTree,
-  nodeType: string | string[]
-): TreeSitterNode[] {
-  const types = Array.isArray(nodeType) ? nodeType : [nodeType];
-  return tree.rootNode.descendantsOfType(types);
-}
-
-/**
- * Extract use statement import path
- */
-export function extractImportPath(useNode: TreeSitterNode): string {
-  // Get the use_declaration argument
-  const argumentNode = getChildByFieldName(useNode, 'argument');
-  if (argumentNode === null) {
-    return '';
-  }
-  return argumentNode.text;
-}

package/src/analysis/zil/index.ts

@@ -1,34 +0,0 @@
-/**
- * ZIL (Zork Implementation Language) Support
- *
- * Provides full graph support for ZIL source files:
- * - Lexer: Tokenizes ZIL syntax
- * - Parser: Extracts symbols, imports, and calls
- * - Adapter: Implements LanguageAdapter interface
- *
- * @example
- * ```typescript
- * import { ZilAdapter } from './zil/index.js';
- * import { AdapterRegistry } from './adapter-registry.js';
- *
- * // Register ZIL support
- * const registry = AdapterRegistry.getInstance();
- * registry.register(new ZilAdapter());
- * ```
- */
-
-export { ZilLexer, TokenType, type Token } from './zil-lexer.js';
-export {
-  ZilParser,
-  type ZilForm,
-  type ZilNode,
-  type ZilSymbol,
-  type ZilCall,
-} from './zil-parser.js';
-export { ZilAdapter } from './zil-adapter.js';
-export {
-  ZIL_SPECIAL_FORMS,
-  ZIL_DEFINITION_FORMS,
-  isSpecialForm,
-  isDefinitionForm,
-} from './zil-special-forms.js';