mistagent 0.1.0

package/dist/src/tools/code-analyzer/core/ingestion/tree-sitter-queries.js

@@ -0,0 +1,355 @@
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/*
+ * Tree-sitter queries for extracting code definitions.
+ *
+ * Note: Different grammars (typescript vs tsx vs javascript) may have
+ * slightly different node types. These queries are designed to be
+ * compatible with the standard tree-sitter grammars.
+ */
+// TypeScript queries - works with tree-sitter-typescript
+export const TYPESCRIPT_QUERIES = `
+(class_declaration
+  name: (type_identifier) @name) @definition.class
+
+(interface_declaration
+  name: (type_identifier) @name) @definition.interface
+
+(function_declaration
+  name: (identifier) @name) @definition.function
+
+(method_definition
+  name: (property_identifier) @name) @definition.method
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (arrow_function))) @definition.function
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (function_expression))) @definition.function
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (arrow_function)))) @definition.function
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (function_expression)))) @definition.function
+
+(import_statement
+  source: (string) @import.source) @import
+
+(call_expression
+  function: (identifier) @call.name) @call
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @call.name)) @call
+
+; Heritage queries - class extends
+(class_declaration
+  name: (type_identifier) @heritage.class
+  (class_heritage
+    (extends_clause
+      value: (identifier) @heritage.extends))) @heritage
+
+; Heritage queries - class implements interface
+(class_declaration
+  name: (type_identifier) @heritage.class
+  (class_heritage
+    (implements_clause
+      (type_identifier) @heritage.implements))) @heritage.impl
+`;
+// JavaScript queries - works with tree-sitter-javascript  
+export const JAVASCRIPT_QUERIES = `
+(class_declaration
+  name: (identifier) @name) @definition.class
+
+(function_declaration
+  name: (identifier) @name) @definition.function
+
+(method_definition
+  name: (property_identifier) @name) @definition.method
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (arrow_function))) @definition.function
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (function_expression))) @definition.function
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (arrow_function)))) @definition.function
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (function_expression)))) @definition.function
+
+(import_statement
+  source: (string) @import.source) @import
+
+(call_expression
+  function: (identifier) @call.name) @call
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @call.name)) @call
+
+; Heritage queries - class extends (JavaScript uses different AST than TypeScript)
+; In tree-sitter-javascript, class_heritage directly contains the parent identifier
+(class_declaration
+  name: (identifier) @heritage.class
+  (class_heritage
+    (identifier) @heritage.extends)) @heritage
+`;
+// Python queries - works with tree-sitter-python
+export const PYTHON_QUERIES = `
+(class_definition
+  name: (identifier) @name) @definition.class
+
+(function_definition
+  name: (identifier) @name) @definition.function
+
+(import_statement
+  name: (dotted_name) @import.source) @import
+
+(import_from_statement
+  module_name: (dotted_name) @import.source) @import
+
+(call
+  function: (identifier) @call.name) @call
+
+(call
+  function: (attribute
+    attribute: (identifier) @call.name)) @call
+
+; Heritage queries - Python class inheritance
+(class_definition
+  name: (identifier) @heritage.class
+  superclasses: (argument_list
+    (identifier) @heritage.extends)) @heritage
+`;
+// Java queries - works with tree-sitter-java
+export const JAVA_QUERIES = `
+; Classes, Interfaces, Enums, Annotations
+(class_declaration name: (identifier) @name) @definition.class
+(interface_declaration name: (identifier) @name) @definition.interface
+(enum_declaration name: (identifier) @name) @definition.enum
+(annotation_type_declaration name: (identifier) @name) @definition.annotation
+
+; Methods & Constructors
+(method_declaration name: (identifier) @name) @definition.method
+(constructor_declaration name: (identifier) @name) @definition.constructor
+
+; Imports - capture any import declaration child as source
+(import_declaration (_) @import.source) @import
+
+; Calls
+(method_invocation name: (identifier) @call.name) @call
+(method_invocation object: (_) name: (identifier) @call.name) @call
+
+; Heritage - extends class
+(class_declaration name: (identifier) @heritage.class
+  (superclass (type_identifier) @heritage.extends)) @heritage
+
+; Heritage - implements interfaces
+(class_declaration name: (identifier) @heritage.class
+  (super_interfaces (type_list (type_identifier) @heritage.implements))) @heritage.impl
+`;
+// C queries - works with tree-sitter-c
+export const C_QUERIES = `
+; Functions
+(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function
+(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function
+
+; Structs, Unions, Enums, Typedefs
+(struct_specifier name: (type_identifier) @name) @definition.struct
+(union_specifier name: (type_identifier) @name) @definition.union
+(enum_specifier name: (type_identifier) @name) @definition.enum
+(type_definition declarator: (type_identifier) @name) @definition.typedef
+
+; Macros
+(preproc_function_def name: (identifier) @name) @definition.macro
+(preproc_def name: (identifier) @name) @definition.macro
+
+; Includes
+(preproc_include path: (_) @import.source) @import
+
+; Calls
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (field_expression field: (field_identifier) @call.name)) @call
+`;
+// Go queries - works with tree-sitter-go
+export const GO_QUERIES = `
+; Functions & Methods
+(function_declaration name: (identifier) @name) @definition.function
+(method_declaration name: (field_identifier) @name) @definition.method
+
+; Types
+(type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @definition.struct
+(type_declaration (type_spec name: (type_identifier) @name type: (interface_type))) @definition.interface
+(type_declaration (type_spec name: (type_identifier) @name)) @definition.type
+
+; Imports
+(import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import
+(import_declaration (import_spec_list (import_spec path: (interpreted_string_literal) @import.source))) @import
+
+; Calls
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (selector_expression field: (field_identifier) @call.name)) @call
+`;
+// C++ queries - works with tree-sitter-cpp
+export const CPP_QUERIES = `
+; Classes, Structs, Namespaces
+(class_specifier name: (type_identifier) @name) @definition.class
+(struct_specifier name: (type_identifier) @name) @definition.struct
+(namespace_definition name: (namespace_identifier) @name) @definition.namespace
+(enum_specifier name: (type_identifier) @name) @definition.enum
+
+; Functions & Methods
+(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function
+(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))) @definition.method
+
+; Templates
+(template_declaration (class_specifier name: (type_identifier) @name)) @definition.template
+(template_declaration (function_definition declarator: (function_declarator declarator: (identifier) @name))) @definition.template
+
+; Includes
+(preproc_include path: (_) @import.source) @import
+
+; Calls
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (field_expression field: (field_identifier) @call.name)) @call
+(call_expression function: (qualified_identifier name: (identifier) @call.name)) @call
+(call_expression function: (template_function name: (identifier) @call.name)) @call
+
+; Heritage
+(class_specifier name: (type_identifier) @heritage.class
+  (base_class_clause (type_identifier) @heritage.extends)) @heritage
+(class_specifier name: (type_identifier) @heritage.class
+  (base_class_clause (access_specifier) (type_identifier) @heritage.extends)) @heritage
+`;
+// C# queries - works with tree-sitter-c-sharp
+export const CSHARP_QUERIES = `
+; Types
+(class_declaration name: (identifier) @name) @definition.class
+(interface_declaration name: (identifier) @name) @definition.interface
+(struct_declaration name: (identifier) @name) @definition.struct
+(enum_declaration name: (identifier) @name) @definition.enum
+(record_declaration name: (identifier) @name) @definition.record
+(delegate_declaration name: (identifier) @name) @definition.delegate
+
+; Namespaces
+(namespace_declaration name: (identifier) @name) @definition.namespace
+(namespace_declaration name: (qualified_name) @name) @definition.namespace
+
+; Methods & Properties
+(method_declaration name: (identifier) @name) @definition.method
+(local_function_statement name: (identifier) @name) @definition.function
+(constructor_declaration name: (identifier) @name) @definition.constructor
+(property_declaration name: (identifier) @name) @definition.property
+
+; Using
+(using_directive (qualified_name) @import.source) @import
+(using_directive (identifier) @import.source) @import
+
+; Calls
+(invocation_expression function: (identifier) @call.name) @call
+(invocation_expression function: (member_access_expression name: (identifier) @call.name)) @call
+
+; Heritage
+(class_declaration name: (identifier) @heritage.class
+  (base_list (simple_base_type (identifier) @heritage.extends))) @heritage
+(class_declaration name: (identifier) @heritage.class
+  (base_list (simple_base_type (generic_name (identifier) @heritage.extends)))) @heritage
+`;
+// Rust queries - works with tree-sitter-rust
+export const RUST_QUERIES = `
+; Functions & Items
+(function_item name: (identifier) @name) @definition.function
+(struct_item name: (type_identifier) @name) @definition.struct
+(enum_item name: (type_identifier) @name) @definition.enum
+(trait_item name: (type_identifier) @name) @definition.trait
+(impl_item type: (type_identifier) @name) @definition.impl
+(mod_item name: (identifier) @name) @definition.module
+
+; Type aliases, const, static, macros
+(type_item name: (type_identifier) @name) @definition.type
+(const_item name: (identifier) @name) @definition.const
+(static_item name: (identifier) @name) @definition.static
+(macro_definition name: (identifier) @name) @definition.macro
+
+; Use statements
+(use_declaration argument: (_) @import.source) @import
+
+; Calls
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (field_expression field: (field_identifier) @call.name)) @call
+(call_expression function: (scoped_identifier name: (identifier) @call.name)) @call
+(call_expression function: (generic_function function: (identifier) @call.name)) @call
+
+; Heritage (trait implementation)
+(impl_item trait: (type_identifier) @heritage.trait type: (type_identifier) @heritage.class) @heritage
+(impl_item trait: (generic_type type: (type_identifier) @heritage.trait) type: (type_identifier) @heritage.class) @heritage
+`;
+// Solidity queries - works with tree-sitter-solidity
+export const SOLIDITY_QUERIES = `
+; Contracts, Libraries, Interfaces
+(contract_declaration name: (identifier) @name) @definition.class
+(library_declaration name: (identifier) @name) @definition.class
+(interface_declaration name: (identifier) @name) @definition.interface
+
+; Functions, Constructors, Modifiers
+(function_definition name: (identifier) @name) @definition.function
+(modifier_definition name: (identifier) @name) @definition.function
+
+; Events, Errors
+(event_definition name: (identifier) @name) @definition.function
+(error_declaration name: (identifier) @name) @definition.function
+
+; Structs, Enums
+(struct_declaration name: (identifier) @name) @definition.struct
+(enum_declaration name: (identifier) @name) @definition.enum
+
+; Imports
+(import_directive source: (string) @import.source) @import
+
+; Calls (Solidity call_expression uses 'expression' child, not 'function' field)
+(call_expression (expression (identifier) @call.name)) @call
+(call_expression (expression (member_expression property: (identifier) @call.name))) @call
+
+; Heritage - contract inheritance (contract X is Y, Z)
+(contract_declaration
+  name: (identifier) @heritage.class
+  (inheritance_specifier ancestor: (user_defined_type (identifier) @heritage.extends))) @heritage
+(interface_declaration
+  name: (identifier) @heritage.class
+  (inheritance_specifier ancestor: (user_defined_type (identifier) @heritage.extends))) @heritage
+`;
+export const LANGUAGE_QUERIES = {
+    [SupportedLanguages.TypeScript]: TYPESCRIPT_QUERIES,
+    [SupportedLanguages.JavaScript]: JAVASCRIPT_QUERIES,
+    [SupportedLanguages.Python]: PYTHON_QUERIES,
+    [SupportedLanguages.Java]: JAVA_QUERIES,
+    [SupportedLanguages.C]: C_QUERIES,
+    [SupportedLanguages.Go]: GO_QUERIES,
+    [SupportedLanguages.CPlusPlus]: CPP_QUERIES,
+    [SupportedLanguages.CSharp]: CSHARP_QUERIES,
+    [SupportedLanguages.Rust]: RUST_QUERIES,
+    [SupportedLanguages.Solidity]: SOLIDITY_QUERIES,
+};
+//# sourceMappingURL=tree-sitter-queries.js.map

package/dist/src/tools/code-analyzer/core/ingestion/tree-sitter-queries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-sitter-queries.js","sourceRoot":"","sources":["../../../../../../src/tools/code-analyzer/core/ingestion/tree-sitter-queries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAEzE;;;;;;GAMG;AAEH,yDAAyD;AACzD,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DjC,CAAC;AAEF,2DAA2D;AAC3D,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDjC,CAAC;AAEF,iDAAiD;AACjD,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CAyB7B,CAAC;AAEF,6CAA6C;AAC7C,MAAM,CAAC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CAyB3B,CAAC;AAEF,uCAAuC;AACvC,MAAM,CAAC,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;CAqBxB,CAAC;AAEF,yCAAyC;AACzC,MAAM,CAAC,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;CAiBzB,CAAC;AAEF,2CAA2C;AAC3C,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B1B,CAAC;AAEF,8CAA8C;AAC9C,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgC7B,CAAC;AAEF,6CAA6C;AAC7C,MAAM,CAAC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B3B,CAAC;AAEF,qDAAqD;AACrD,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgC/B,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAuC;IAClE,CAAC,kBAAkB,CAAC,UAAU,CAAC,EAAE,kBAAkB;IACnD,CAAC,kBAAkB,CAAC,UAAU,CAAC,EAAE,kBAAkB;IACnD,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,cAAc;IAC3C,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,YAAY;IACvC,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,SAAS;IACjC,CAAC,kBAAkB,CAAC,EAAE,CAAC,EAAE,UAAU;IACnC,CAAC,kBAAkB,CAAC,SAAS,CAAC,EAAE,WAAW;IAC3C,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,cAAc;IAC3C,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,YAAY;IACvC,CAAC,kBAAkB,CAAC,QAAQ,CAAC,EAAE,gBAAgB;CAChD,CAAC"}

package/dist/src/tools/code-analyzer/core/ingestion/utils.d.ts

@@ -0,0 +1,11 @@
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/**
+ * Yield control to the event loop so spinners/progress can render.
+ * Call periodically in hot loops to prevent UI freezes.
+ */
+export declare const yieldToEventLoop: () => Promise<void>;
+/**
+ * Map file extension to SupportedLanguage enum
+ */
+export declare const getLanguageFromFilename: (filename: string) => SupportedLanguages | null;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/tools/code-analyzer/core/ingestion/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../src/tools/code-analyzer/core/ingestion/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAEzE;;;GAGG;AACH,eAAO,MAAM,gBAAgB,QAAO,OAAO,CAAC,IAAI,CAAkD,CAAC;AAEnG;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAAI,UAAU,MAAM,KAAG,kBAAkB,GAAG,IAyB/E,CAAC"}

package/dist/src/tools/code-analyzer/core/ingestion/utils.js

@@ -0,0 +1,48 @@
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/**
+ * Yield control to the event loop so spinners/progress can render.
+ * Call periodically in hot loops to prevent UI freezes.
+ */
+export const yieldToEventLoop = () => new Promise(resolve => setImmediate(resolve));
+/**
+ * Map file extension to SupportedLanguage enum
+ */
+export const getLanguageFromFilename = (filename) => {
+    // TypeScript (including TSX)
+    if (filename.endsWith('.tsx'))
+        return SupportedLanguages.TypeScript;
+    if (filename.endsWith('.ts'))
+        return SupportedLanguages.TypeScript;
+    // JavaScript (including JSX)
+    if (filename.endsWith('.jsx'))
+        return SupportedLanguages.JavaScript;
+    if (filename.endsWith('.js'))
+        return SupportedLanguages.JavaScript;
+    // Python
+    if (filename.endsWith('.py'))
+        return SupportedLanguages.Python;
+    // Java
+    if (filename.endsWith('.java'))
+        return SupportedLanguages.Java;
+    // C (source and headers)
+    if (filename.endsWith('.c') || filename.endsWith('.h'))
+        return SupportedLanguages.C;
+    // C++ (all common extensions)
+    if (filename.endsWith('.cpp') || filename.endsWith('.cc') || filename.endsWith('.cxx') ||
+        filename.endsWith('.hpp') || filename.endsWith('.hxx') || filename.endsWith('.hh'))
+        return SupportedLanguages.CPlusPlus;
+    // C#
+    if (filename.endsWith('.cs'))
+        return SupportedLanguages.CSharp;
+    // Go
+    if (filename.endsWith('.go'))
+        return SupportedLanguages.Go;
+    // Rust
+    if (filename.endsWith('.rs'))
+        return SupportedLanguages.Rust;
+    // Solidity
+    if (filename.endsWith('.sol'))
+        return SupportedLanguages.Solidity;
+    return null;
+};
+//# sourceMappingURL=utils.js.map

package/dist/src/tools/code-analyzer/core/ingestion/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../src/tools/code-analyzer/core/ingestion/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAEzE;;;GAGG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAkB,EAAE,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;AAEnG;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,QAAgB,EAA6B,EAAE;IACrF,6BAA6B;IAC7B,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,kBAAkB,CAAC,UAAU,CAAC;IACpE,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,kBAAkB,CAAC,UAAU,CAAC;IACnE,6BAA6B;IAC7B,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,kBAAkB,CAAC,UAAU,CAAC;IACpE,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,kBAAkB,CAAC,UAAU,CAAC;IACnE,SAAS;IACT,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,kBAAkB,CAAC,MAAM,CAAC;IAC/D,OAAO;IACP,IAAI,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,kBAAkB,CAAC,IAAI,CAAC;IAC/D,yBAAyB;IACzB,IAAI,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO,kBAAkB,CAAC,CAAC,CAAC;IACpF,8BAA8B;IAC9B,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC;QAClF,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,kBAAkB,CAAC,SAAS,CAAC;IAC5H,KAAK;IACL,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,kBAAkB,CAAC,MAAM,CAAC;IAC/D,KAAK;IACL,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,kBAAkB,CAAC,EAAE,CAAC;IAC3D,OAAO;IACP,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,kBAAkB,CAAC,IAAI,CAAC;IAC7D,WAAW;IACX,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,kBAAkB,CAAC,QAAQ,CAAC;IAClE,OAAO,IAAI,CAAC;AACd,CAAC,CAAC"}

package/dist/src/tools/code-analyzer/core/ingestion/workers/parse-worker.d.ts

@@ -0,0 +1,59 @@
+interface ParsedNode {
+    id: string;
+    label: string;
+    properties: {
+        name: string;
+        filePath: string;
+        startLine: number;
+        endLine: number;
+        language: string;
+        isExported: boolean;
+    };
+}
+interface ParsedRelationship {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    type: 'DEFINES';
+    confidence: number;
+    reason: string;
+}
+interface ParsedSymbol {
+    filePath: string;
+    name: string;
+    nodeId: string;
+    type: string;
+}
+export interface ExtractedImport {
+    filePath: string;
+    rawImportPath: string;
+    language: string;
+}
+export interface ExtractedCall {
+    filePath: string;
+    calledName: string;
+    /** generateId of enclosing function, or generateId('File', filePath) for top-level */
+    sourceId: string;
+}
+export interface ExtractedHeritage {
+    filePath: string;
+    className: string;
+    parentName: string;
+    /** 'extends' | 'implements' | 'trait-impl' */
+    kind: string;
+}
+export interface ParseWorkerResult {
+    nodes: ParsedNode[];
+    relationships: ParsedRelationship[];
+    symbols: ParsedSymbol[];
+    imports: ExtractedImport[];
+    calls: ExtractedCall[];
+    heritage: ExtractedHeritage[];
+    fileCount: number;
+}
+export interface ParseWorkerInput {
+    path: string;
+    content: string;
+}
+export {};
+//# sourceMappingURL=parse-worker.d.ts.map

package/dist/src/tools/code-analyzer/core/ingestion/workers/parse-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-worker.d.ts","sourceRoot":"","sources":["../../../../../../../src/tools/code-analyzer/core/ingestion/workers/parse-worker.ts"],"names":[],"mappings":"AAqBA,UAAU,UAAU;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE;QACV,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,OAAO,CAAC;KACrB,CAAC;CACH;AAED,UAAU,kBAAkB;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,SAAS,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,YAAY;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,sFAAsF;IACtF,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,aAAa,EAAE,kBAAkB,EAAE,CAAC;IACpC,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB"}