distill-mcp 0.6.0-beta

package/dist/ast/go/queries.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Go Tree-sitter Queries
+ *
+ * S-expression queries for extracting Go code elements.
+ */
+/**
+ * Query to find all function declarations
+ */
+export declare const FUNCTION_QUERY = "\n(function_declaration\n  name: (identifier) @name) @function\n";
+/**
+ * Query to find all method declarations
+ */
+export declare const METHOD_QUERY = "\n(method_declaration\n  receiver: (parameter_list) @receiver\n  name: (field_identifier) @name) @method\n";
+/**
+ * Query to find all type declarations (struct, interface)
+ */
+export declare const TYPE_QUERY = "\n(type_declaration\n  (type_spec\n    name: (type_identifier) @name\n    type: [\n      (struct_type) @struct\n      (interface_type) @interface\n    ])) @type\n";
+/**
+ * Query to find all import declarations
+ */
+export declare const IMPORT_QUERY = "\n[\n  (import_declaration\n    (import_spec) @import)\n  (import_declaration\n    (import_spec_list\n      (import_spec) @import))\n]\n";
+/**
+ * Query to find package-level variable declarations
+ */
+export declare const VARIABLE_QUERY = "\n(source_file\n  (var_declaration\n    (var_spec\n      name: (identifier) @name)) @variable)\n";
+/**
+ * Query to find package-level constant declarations
+ */
+export declare const CONST_QUERY = "\n(source_file\n  (const_declaration\n    (const_spec\n      name: (identifier) @name)) @constant)\n";
+/**
+ * Query to find type aliases
+ */
+export declare const TYPE_ALIAS_QUERY = "\n(type_declaration\n  (type_spec\n    name: (type_identifier) @name\n    type: (type_identifier) @alias_type)) @type_alias\n";
+/**
+ * Combined query for common elements
+ */
+export declare const ALL_DEFINITIONS_QUERY = "\n; Package declaration\n(package_clause\n  (package_identifier) @package_name) @package\n\n; Import declarations\n(import_declaration) @import_decl\n\n; Function declarations\n(function_declaration\n  name: (identifier) @func_name) @function\n\n; Method declarations\n(method_declaration\n  name: (field_identifier) @method_name) @method\n\n; Type declarations\n(type_declaration\n  (type_spec\n    name: (type_identifier) @type_name)) @type\n\n; Variable declarations\n(var_declaration) @var_decl\n\n; Constant declarations\n(const_declaration) @const_decl\n";
+/**
+ * Query patterns as a single object for easy access
+ */
+export declare const QUERIES: {
+    readonly function: "\n(function_declaration\n  name: (identifier) @name) @function\n";
+    readonly method: "\n(method_declaration\n  receiver: (parameter_list) @receiver\n  name: (field_identifier) @name) @method\n";
+    readonly type: "\n(type_declaration\n  (type_spec\n    name: (type_identifier) @name\n    type: [\n      (struct_type) @struct\n      (interface_type) @interface\n    ])) @type\n";
+    readonly import: "\n[\n  (import_declaration\n    (import_spec) @import)\n  (import_declaration\n    (import_spec_list\n      (import_spec) @import))\n]\n";
+    readonly variable: "\n(source_file\n  (var_declaration\n    (var_spec\n      name: (identifier) @name)) @variable)\n";
+    readonly constant: "\n(source_file\n  (const_declaration\n    (const_spec\n      name: (identifier) @name)) @constant)\n";
+    readonly typeAlias: "\n(type_declaration\n  (type_spec\n    name: (type_identifier) @name\n    type: (type_identifier) @alias_type)) @type_alias\n";
+    readonly all: "\n; Package declaration\n(package_clause\n  (package_identifier) @package_name) @package\n\n; Import declarations\n(import_declaration) @import_decl\n\n; Function declarations\n(function_declaration\n  name: (identifier) @func_name) @function\n\n; Method declarations\n(method_declaration\n  name: (field_identifier) @method_name) @method\n\n; Type declarations\n(type_declaration\n  (type_spec\n    name: (type_identifier) @type_name)) @type\n\n; Variable declarations\n(var_declaration) @var_decl\n\n; Constant declarations\n(const_declaration) @const_decl\n";
+};
+//# sourceMappingURL=queries.d.ts.map

package/dist/ast/go/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../src/ast/go/queries.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc,qEAG1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,+GAIxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,uKAQtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,6IAQxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,qGAK1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,yGAKvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,kIAK5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,qjBA0BjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;CASV,CAAC"}

package/dist/ast/go/queries.js

@@ -0,0 +1,114 @@
+/**
+ * Go Tree-sitter Queries
+ *
+ * S-expression queries for extracting Go code elements.
+ */
+/**
+ * Query to find all function declarations
+ */
+export const FUNCTION_QUERY = `
+(function_declaration
+  name: (identifier) @name) @function
+`;
+/**
+ * Query to find all method declarations
+ */
+export const METHOD_QUERY = `
+(method_declaration
+  receiver: (parameter_list) @receiver
+  name: (field_identifier) @name) @method
+`;
+/**
+ * Query to find all type declarations (struct, interface)
+ */
+export const TYPE_QUERY = `
+(type_declaration
+  (type_spec
+    name: (type_identifier) @name
+    type: [
+      (struct_type) @struct
+      (interface_type) @interface
+    ])) @type
+`;
+/**
+ * Query to find all import declarations
+ */
+export const IMPORT_QUERY = `
+[
+  (import_declaration
+    (import_spec) @import)
+  (import_declaration
+    (import_spec_list
+      (import_spec) @import))
+]
+`;
+/**
+ * Query to find package-level variable declarations
+ */
+export const VARIABLE_QUERY = `
+(source_file
+  (var_declaration
+    (var_spec
+      name: (identifier) @name)) @variable)
+`;
+/**
+ * Query to find package-level constant declarations
+ */
+export const CONST_QUERY = `
+(source_file
+  (const_declaration
+    (const_spec
+      name: (identifier) @name)) @constant)
+`;
+/**
+ * Query to find type aliases
+ */
+export const TYPE_ALIAS_QUERY = `
+(type_declaration
+  (type_spec
+    name: (type_identifier) @name
+    type: (type_identifier) @alias_type)) @type_alias
+`;
+/**
+ * Combined query for common elements
+ */
+export const ALL_DEFINITIONS_QUERY = `
+; Package declaration
+(package_clause
+  (package_identifier) @package_name) @package
+
+; Import declarations
+(import_declaration) @import_decl
+
+; Function declarations
+(function_declaration
+  name: (identifier) @func_name) @function
+
+; Method declarations
+(method_declaration
+  name: (field_identifier) @method_name) @method
+
+; Type declarations
+(type_declaration
+  (type_spec
+    name: (type_identifier) @type_name)) @type
+
+; Variable declarations
+(var_declaration) @var_decl
+
+; Constant declarations
+(const_declaration) @const_decl
+`;
+/**
+ * Query patterns as a single object for easy access
+ */
+export const QUERIES = {
+    function: FUNCTION_QUERY,
+    method: METHOD_QUERY,
+    type: TYPE_QUERY,
+    import: IMPORT_QUERY,
+    variable: VARIABLE_QUERY,
+    constant: CONST_QUERY,
+    typeAlias: TYPE_ALIAS_QUERY,
+    all: ALL_DEFINITIONS_QUERY,
+};

package/dist/ast/go/utils.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Go Parser Utilities
+ *
+ * Helper functions for converting Tree-sitter nodes to CodeElements
+ * and extracting Go-specific constructs.
+ */
+import type Parser from "web-tree-sitter";
+type Node = Parser.SyntaxNode;
+import type { CodeElement, ElementType } from "../types.js";
+/**
+ * Get line number from a Tree-sitter node (1-indexed)
+ */
+export declare function getLineNumber(node: Node): number;
+/**
+ * Get end line number from a Tree-sitter node (1-indexed)
+ */
+export declare function getEndLineNumber(node: Node): number;
+/**
+ * Extract Go doc comment from above a declaration
+ * Go uses // comments above declarations
+ */
+export declare function extractGoDoc(node: Node, lines: string[]): string | undefined;
+/**
+ * Get function signature from a function_declaration node
+ */
+export declare function getFunctionSignature(node: Node): string;
+/**
+ * Get method signature from a method_declaration node
+ */
+export declare function getMethodSignature(node: Node): string;
+/**
+ * Get type signature (struct, interface)
+ */
+export declare function getTypeSignature(node: Node, kind: string): string;
+/**
+ * Check if a declaration is exported (starts with uppercase)
+ */
+export declare function isExported(name: string): boolean;
+/**
+ * Get receiver type name from a method
+ */
+export declare function getReceiverType(node: Node): string | undefined;
+/**
+ * Create a CodeElement from a Tree-sitter node
+ */
+export declare function createCodeElement(type: ElementType, name: string, node: Node, options?: {
+    signature?: string;
+    documentation?: string;
+    isAsync?: boolean;
+    isExported?: boolean;
+    parent?: string;
+}): CodeElement;
+/**
+ * Extract import path from an import spec
+ */
+export declare function getImportPath(node: Node): string;
+/**
+ * Get the short name from an import path
+ */
+export declare function getImportName(importPath: string): string;
+/**
+ * Get alias if import has one
+ */
+export declare function getImportAlias(node: Node): string | undefined;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/ast/go/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/ast/go/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,MAAM,MAAM,iBAAiB,CAAC;AAC1C,KAAK,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC;AAC9B,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE5D;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAEhD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAEnD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAkB5E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAUvD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAYrD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAIjE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIhD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAO9D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GACA,WAAW,CAYb;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAQhD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAM7D"}

package/dist/ast/go/utils.js

@@ -0,0 +1,140 @@
+/**
+ * Go Parser Utilities
+ *
+ * Helper functions for converting Tree-sitter nodes to CodeElements
+ * and extracting Go-specific constructs.
+ */
+/**
+ * Get line number from a Tree-sitter node (1-indexed)
+ */
+export function getLineNumber(node) {
+    return node.startPosition.row + 1;
+}
+/**
+ * Get end line number from a Tree-sitter node (1-indexed)
+ */
+export function getEndLineNumber(node) {
+    return node.endPosition.row + 1;
+}
+/**
+ * Extract Go doc comment from above a declaration
+ * Go uses // comments above declarations
+ */
+export function extractGoDoc(node, lines) {
+    const startLine = node.startPosition.row;
+    const comments = [];
+    // Look for comments above the node
+    for (let i = startLine - 1; i >= 0; i--) {
+        const line = lines[i]?.trim();
+        if (line?.startsWith("//")) {
+            comments.unshift(line.slice(2).trim());
+        }
+        else if (line === "") {
+            // Allow empty lines between comments
+            continue;
+        }
+        else {
+            break;
+        }
+    }
+    return comments.length > 0 ? comments.join("\n") : undefined;
+}
+/**
+ * Get function signature from a function_declaration node
+ */
+export function getFunctionSignature(node) {
+    const nameNode = node.childForFieldName("name");
+    const paramsNode = node.childForFieldName("parameters");
+    const resultNode = node.childForFieldName("result");
+    const name = nameNode?.text ?? "unknown";
+    const params = paramsNode?.text ?? "()";
+    const result = resultNode ? ` ${resultNode.text}` : "";
+    return `func ${name}${params}${result}`;
+}
+/**
+ * Get method signature from a method_declaration node
+ */
+export function getMethodSignature(node) {
+    const receiverNode = node.childForFieldName("receiver");
+    const nameNode = node.childForFieldName("name");
+    const paramsNode = node.childForFieldName("parameters");
+    const resultNode = node.childForFieldName("result");
+    const receiver = receiverNode?.text ?? "";
+    const name = nameNode?.text ?? "unknown";
+    const params = paramsNode?.text ?? "()";
+    const result = resultNode ? ` ${resultNode.text}` : "";
+    return `func ${receiver} ${name}${params}${result}`;
+}
+/**
+ * Get type signature (struct, interface)
+ */
+export function getTypeSignature(node, kind) {
+    const nameNode = node.childForFieldName("name");
+    const name = nameNode?.text ?? "unknown";
+    return `type ${name} ${kind}`;
+}
+/**
+ * Check if a declaration is exported (starts with uppercase)
+ */
+export function isExported(name) {
+    if (!name || name.length === 0)
+        return false;
+    const firstChar = name.charAt(0);
+    return firstChar === firstChar.toUpperCase() && firstChar !== firstChar.toLowerCase();
+}
+/**
+ * Get receiver type name from a method
+ */
+export function getReceiverType(node) {
+    const receiverNode = node.childForFieldName("receiver");
+    if (!receiverNode)
+        return undefined;
+    // Find the type identifier in the receiver
+    const typeNode = receiverNode.descendantsOfType("type_identifier")[0];
+    return typeNode?.text;
+}
+/**
+ * Create a CodeElement from a Tree-sitter node
+ */
+export function createCodeElement(type, name, node, options) {
+    return {
+        type,
+        name,
+        startLine: getLineNumber(node),
+        endLine: getEndLineNumber(node),
+        signature: options?.signature,
+        documentation: options?.documentation,
+        isAsync: options?.isAsync,
+        isExported: options?.isExported,
+        parent: options?.parent,
+    };
+}
+/**
+ * Extract import path from an import spec
+ */
+export function getImportPath(node) {
+    // Find the interpreted_string_literal child
+    const pathNode = node.descendantsOfType("interpreted_string_literal")[0];
+    if (pathNode) {
+        // Remove quotes
+        return pathNode.text.slice(1, -1);
+    }
+    return node.text;
+}
+/**
+ * Get the short name from an import path
+ */
+export function getImportName(importPath) {
+    const parts = importPath.split("/");
+    return parts[parts.length - 1] ?? importPath;
+}
+/**
+ * Get alias if import has one
+ */
+export function getImportAlias(node) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode && nameNode.type === "package_identifier") {
+        return nameNode.text;
+    }
+    return undefined;
+}

package/dist/ast/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * AST Parser Router
+ *
+ * Routes parsing requests to the appropriate language parser.
+ */
+export type { SupportedLanguage, ElementType, CodeElement, FileStructure, ExtractedContent, ExtractionTarget, ExtractionOptions, ParseOptions, LanguageParser, } from "./types.js";
+export { createEmptyStructure } from "./types.js";
+import type { SupportedLanguage, CodeElement, FileStructure, ExtractedContent, ExtractionTarget, ExtractionOptions, ParseOptions, LanguageParser } from "./types.js";
+/**
+ * Get parser for a language
+ */
+export declare function getParser(language: SupportedLanguage): LanguageParser | undefined;
+/**
+ * Check if a language has parser support
+ */
+export declare function hasParserSupport(language: SupportedLanguage): boolean;
+/**
+ * Parse file content and return structure
+ * @param mode 'full' for AST parsing, 'quick' for regex-based scan (faster, less detail)
+ * @param options ParseOptions to control extraction (detailed: true for signature/documentation)
+ */
+export declare function parseFile(content: string, language: SupportedLanguage, mode?: "full" | "quick", options?: ParseOptions): FileStructure;
+/**
+ * Extract a specific element from content
+ */
+export declare function extractElement(content: string, language: SupportedLanguage, target: ExtractionTarget, options: ExtractionOptions): ExtractedContent | null;
+/**
+ * Search for elements matching a query
+ */
+export declare function searchElements(content: string, language: SupportedLanguage, query: string): CodeElement[];
+/**
+ * Extract lines from content
+ */
+export declare function extractLines(content: string, startLine: number, endLine: number): ExtractedContent;
+/**
+ * Format file structure as summary
+ */
+export declare function formatStructureSummary(structure: FileStructure, filePath: string, format?: "plain" | "markdown"): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/ast/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ast/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACV,iBAAiB,EACjB,WAAW,EACX,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,cAAc,GACf,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAElD,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACf,MAAM,YAAY,CAAC;AAuBpB;;GAEG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,iBAAiB,GAAG,cAAc,GAAG,SAAS,CAEjF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAErE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,GAAE,MAAM,GAAG,OAAgB,EAC/B,OAAO,GAAE,YAAiB,GACzB,aAAa,CAkBf;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,iBAAiB,GACzB,gBAAgB,GAAG,IAAI,CAQzB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,MAAM,GACZ,WAAW,EAAE,CAQf;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,gBAAgB,CAiBlB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,aAAa,EACxB,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,OAAO,GAAG,UAAoB,GACrC,MAAM,CAuIR"}

package/dist/ast/index.js

@@ -0,0 +1,245 @@
+/**
+ * AST Parser Router
+ *
+ * Routes parsing requests to the appropriate language parser.
+ */
+export { createEmptyStructure } from "./types.js";
+import { createEmptyStructure } from "./types.js";
+import { typescriptParser, parseTypeScript } from "./typescript.js";
+import { quickScan } from "./quick-scan.js";
+import { pythonTreeSitterParser } from "./python/index.js";
+import { goTreeSitterParser } from "./go/index.js";
+import { rustTreeSitterParser } from "./rust/index.js";
+import { phpTreeSitterParser } from "./php/index.js";
+import { swiftTreeSitterParser } from "./swift/index.js";
+/**
+ * Registry of language parsers
+ */
+const parserRegistry = new Map([
+    ["typescript", typescriptParser],
+    ["javascript", typescriptParser], // JS uses same parser
+    ["python", pythonTreeSitterParser], // Tree-sitter based parser
+    ["go", goTreeSitterParser], // Tree-sitter based parser
+    ["rust", rustTreeSitterParser], // Tree-sitter based parser
+    ["php", phpTreeSitterParser], // Tree-sitter based parser
+    ["swift", swiftTreeSitterParser], // Tree-sitter based parser
+]);
+/**
+ * Get parser for a language
+ */
+export function getParser(language) {
+    return parserRegistry.get(language);
+}
+/**
+ * Check if a language has parser support
+ */
+export function hasParserSupport(language) {
+    return parserRegistry.has(language);
+}
+/**
+ * Parse file content and return structure
+ * @param mode 'full' for AST parsing, 'quick' for regex-based scan (faster, less detail)
+ * @param options ParseOptions to control extraction (detailed: true for signature/documentation)
+ */
+export function parseFile(content, language, mode = "full", options = {}) {
+    // Quick mode: use regex-based scan (90% faster, no endLine/signatures)
+    if (mode === "quick") {
+        return quickScan(content, language);
+    }
+    const parser = parserRegistry.get(language);
+    if (parser) {
+        // Special case for JavaScript (use TS parser with isTypeScript=false)
+        if (language === "javascript") {
+            return parseTypeScript(content, false, options);
+        }
+        return parser.parse(content, options);
+    }
+    // No parser available - return minimal structure
+    return createEmptyStructure(language, content.split("\n").length);
+}
+/**
+ * Extract a specific element from content
+ */
+export function extractElement(content, language, target, options) {
+    const parser = parserRegistry.get(language);
+    if (!parser) {
+        return null;
+    }
+    return parser.extractElement(content, target, options);
+}
+/**
+ * Search for elements matching a query
+ */
+export function searchElements(content, language, query) {
+    const parser = parserRegistry.get(language);
+    if (!parser) {
+        return [];
+    }
+    return parser.searchElements(content, query);
+}
+/**
+ * Extract lines from content
+ */
+export function extractLines(content, startLine, endLine) {
+    const lines = content.split("\n");
+    const totalLines = lines.length;
+    // Clamp line numbers
+    const start = Math.max(1, Math.min(startLine, totalLines));
+    const end = Math.max(start, Math.min(endLine, totalLines));
+    const extractedLines = lines.slice(start - 1, end);
+    return {
+        content: extractedLines.join("\n"),
+        elements: [],
+        relatedImports: [],
+        startLine: start,
+        endLine: end,
+    };
+}
+/**
+ * Format file structure as summary
+ */
+export function formatStructureSummary(structure, filePath, format = "plain") {
+    const parts = [];
+    const md = format === "markdown";
+    if (md) {
+        parts.push(`## File Structure: ${filePath}`);
+        parts.push("");
+        parts.push(`**Language:** ${formatLanguageName(structure.language)}`);
+        parts.push(`**Lines:** ${structure.totalLines}`);
+        parts.push("");
+    }
+    else {
+        parts.push(`${filePath} (${formatLanguageName(structure.language)}, ${structure.totalLines} lines)`);
+    }
+    // Exports
+    if (structure.exports.length > 0) {
+        if (md) {
+            parts.push("### Exports");
+            for (const exp of structure.exports) {
+                parts.push(`- \`${exp.name}\` (line ${exp.startLine})`);
+            }
+            parts.push("");
+        }
+        else {
+            const expList = structure.exports.map(e => e.name).join(", ");
+            parts.push(`EXPORTS: ${expList}`);
+        }
+    }
+    // Functions
+    if (structure.functions.length > 0) {
+        if (md) {
+            parts.push("### Functions");
+            for (const func of structure.functions) {
+                const prefix = func.type === "method" ? `${func.parent}.` : "";
+                const async = func.isAsync ? "async " : "";
+                const exported = func.isExported ? "exported " : "";
+                parts.push(`- \`${prefix}${func.name}\` (${exported}${async}${func.type}, lines ${func.startLine}-${func.endLine})`);
+            }
+            parts.push("");
+        }
+        else {
+            const fnList = structure.functions.map(f => `${f.name} (${f.startLine}-${f.endLine})`).join(", ");
+            parts.push(`FUNCTIONS: ${fnList}`);
+        }
+    }
+    // Classes
+    if (structure.classes.length > 0) {
+        if (md) {
+            parts.push("### Classes");
+            for (const cls of structure.classes) {
+                const exported = cls.isExported ? "exported " : "";
+                parts.push(`- \`${cls.name}\` (${exported}class, lines ${cls.startLine}-${cls.endLine})`);
+            }
+            parts.push("");
+        }
+        else {
+            const clsList = structure.classes.map(c => `${c.name} (${c.startLine}-${c.endLine})`).join(", ");
+            parts.push(`CLASSES: ${clsList}`);
+        }
+    }
+    // Interfaces (no line numbers in plain - minor elements)
+    if (structure.interfaces.length > 0) {
+        if (md) {
+            parts.push("### Interfaces");
+            for (const iface of structure.interfaces) {
+                const exported = iface.isExported ? "exported " : "";
+                parts.push(`- \`${iface.name}\` (${exported}interface, lines ${iface.startLine}-${iface.endLine})`);
+            }
+            parts.push("");
+        }
+        else {
+            const ifList = structure.interfaces.map(i => i.name).join(", ");
+            parts.push(`INTERFACES: ${ifList}`);
+        }
+    }
+    // Types (no line numbers in plain - minor elements)
+    if (structure.types.length > 0) {
+        if (md) {
+            parts.push("### Types");
+            for (const type of structure.types) {
+                const exported = type.isExported ? "exported " : "";
+                parts.push(`- \`${type.name}\` (${exported}type, lines ${type.startLine}-${type.endLine})`);
+            }
+            parts.push("");
+        }
+        else {
+            const typeList = structure.types.map(t => t.name).join(", ");
+            parts.push(`TYPES: ${typeList}`);
+        }
+    }
+    // Variables (exported only)
+    const exportedVars = structure.variables.filter(v => v.isExported);
+    if (exportedVars.length > 0) {
+        if (md) {
+            parts.push("### Exported Variables");
+            for (const variable of exportedVars) {
+                parts.push(`- \`${variable.name}\` (variable, lines ${variable.startLine}-${variable.endLine})`);
+            }
+            parts.push("");
+        }
+        else {
+            const varList = exportedVars.map(v => v.name).join(", ");
+            parts.push(`EXPORTS: ${varList}`);
+        }
+    }
+    // Imports (collapsed, max 3)
+    if (structure.imports.length > 0) {
+        const uniqueImports = [...new Set(structure.imports.map((i) => i.name))];
+        if (md) {
+            parts.push(`### Imports (${structure.imports.length})`);
+            if (uniqueImports.length <= 3) {
+                for (const name of uniqueImports) {
+                    parts.push(`- \`${name}\``);
+                }
+            }
+            else {
+                for (const name of uniqueImports.slice(0, 3)) {
+                    parts.push(`- \`${name}\``);
+                }
+                parts.push(`- ... and ${uniqueImports.length - 3} more`);
+            }
+            parts.push("");
+        }
+        else {
+            const importList = uniqueImports.slice(0, 3).join(", ");
+            const more = uniqueImports.length > 3 ? ` +${uniqueImports.length - 3}` : "";
+            parts.push(`IMPORTS: ${importList}${more}`);
+        }
+    }
+    return parts.join("\n");
+}
+function formatLanguageName(language) {
+    const names = {
+        typescript: "TypeScript",
+        javascript: "JavaScript",
+        python: "Python",
+        go: "Go",
+        rust: "Rust",
+        php: "PHP",
+        swift: "Swift",
+        json: "JSON",
+        yaml: "YAML",
+        unknown: "Unknown",
+    };
+    return names[language];
+}

package/dist/ast/php/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * PHP AST Parser Module
+ *
+ * Exports the Tree-sitter based PHP parser.
+ */
+export { phpTreeSitterParser, parsePhp, parsePhpAsync, extractPhpElement, searchPhpElements, initPhpParser, } from "./parser.js";
+export { QUERIES } from "./queries.js";
+export { getLineNumber, getEndLineNumber, extractPhpDoc, getVisibility, isPublic, getFunctionSignature, getMethodSignature, getClassSignature, createCodeElement, } from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/ast/php/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ast/php/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,mBAAmB,EACnB,QAAQ,EACR,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,GACd,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,QAAQ,EACR,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,YAAY,CAAC"}