distill-mcp 0.6.0-beta

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

@@ -0,0 +1,94 @@
+/**
+ * Swift Parser Utilities
+ *
+ * Helper functions for converting Tree-sitter nodes to CodeElements
+ * and extracting Swift-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 Swift documentation comment from above a declaration
+ * Swift uses /// for single-line doc comments and block comments
+ */
+export declare function extractSwiftDoc(node: Node, lines: string[]): string | undefined;
+/**
+ * Swift access levels
+ */
+export type SwiftAccessLevel = "private" | "fileprivate" | "internal" | "public" | "open";
+/**
+ * Get access level from a node
+ */
+export declare function getAccessLevel(node: Node): SwiftAccessLevel | undefined;
+/**
+ * Check if a node has public or open visibility (external API)
+ */
+export declare function isPublic(node: Node): boolean;
+/**
+ * Check if a function/method is async
+ */
+export declare function isAsync(node: Node): boolean;
+/**
+ * Check if a node has static modifier
+ */
+export declare function isStatic(node: Node): boolean;
+/**
+ * Get function signature from a function_declaration node
+ */
+export declare function getFunctionSignature(node: Node): string;
+/**
+ * Get method signature (same as function but with receiver context)
+ */
+export declare function getMethodSignature(node: Node): string;
+/**
+ * Get class signature
+ */
+export declare function getClassSignature(node: Node): string;
+/**
+ * Get struct signature
+ */
+export declare function getStructSignature(node: Node): string;
+/**
+ * Get protocol signature
+ */
+export declare function getProtocolSignature(node: Node): string;
+/**
+ * Get enum signature
+ */
+export declare function getEnumSignature(node: Node): string;
+/**
+ * Get extension signature
+ */
+export declare function getExtensionSignature(node: Node): string;
+/**
+ * Get typealias signature
+ */
+export declare function getTypealiasSignature(node: Node): string;
+/**
+ * Get import path from import declaration
+ */
+export declare function getImportPath(node: Node): string;
+/**
+ * Get variable/constant signature
+ */
+export declare function getVariableSignature(node: Node): string;
+/**
+ * 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;
+export {};
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/ast/swift/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,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAgD/E;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,aAAa,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE1F;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,gBAAgB,GAAG,SAAS,CAmBvE;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAG5C;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAc3C;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAW5C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAsDvD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAErD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAyCpD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CA6BrD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CA6BvD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CA6BnD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CA2BxD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CA4BxD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAOhD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAMvD;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"}

package/dist/ast/swift/utils.js

@@ -0,0 +1,411 @@
+/**
+ * Swift Parser Utilities
+ *
+ * Helper functions for converting Tree-sitter nodes to CodeElements
+ * and extracting Swift-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 Swift documentation comment from above a declaration
+ * Swift uses /// for single-line doc comments and block comments
+ */
+export function extractSwiftDoc(node, lines) {
+    const startLine = node.startPosition.row;
+    const comments = [];
+    // Look for doc comments above the node
+    for (let i = startLine - 1; i >= 0; i--) {
+        const line = lines[i]?.trim();
+        if (!line) {
+            // Empty line - continue looking
+            continue;
+        }
+        else if (line.startsWith("///")) {
+            // Single-line doc comment
+            const content = line.slice(3).trim();
+            if (content)
+                comments.unshift(content);
+        }
+        else if (line.endsWith("*/")) {
+            // End of block comment - look for the start
+            for (let j = i; j >= 0; j--) {
+                const commentLine = lines[j]?.trim();
+                if (commentLine?.startsWith("/**")) {
+                    // Found start of doc block
+                    for (let k = j; k <= i; k++) {
+                        let cl = lines[k]?.trim() ?? "";
+                        // Clean up comment markers
+                        if (cl.startsWith("/**"))
+                            cl = cl.slice(3).trim();
+                        if (cl.endsWith("*/"))
+                            cl = cl.slice(0, -2).trim();
+                        if (cl.startsWith("*"))
+                            cl = cl.slice(1).trim();
+                        if (cl)
+                            comments.push(cl);
+                    }
+                    break;
+                }
+            }
+            break;
+        }
+        else if (line.startsWith("*")) {
+            // Middle of block comment
+            continue;
+        }
+        else if (line.startsWith("//") && !line.startsWith("///")) {
+            // Regular comment - skip
+            continue;
+        }
+        else if (line.startsWith("@")) {
+            // Attribute like @available, @discardableResult - continue
+            continue;
+        }
+        else {
+            // Something else (code) - stop
+            break;
+        }
+    }
+    return comments.length > 0 ? comments.join("\n") : undefined;
+}
+/**
+ * Get access level from a node
+ */
+export function getAccessLevel(node) {
+    for (const child of node.children) {
+        if (child.type === "modifiers") {
+            for (const modifier of child.children) {
+                const text = modifier.text;
+                if (text === "private" || text === "fileprivate" || text === "internal" || text === "public" || text === "open") {
+                    return text;
+                }
+            }
+        }
+        // Also check for direct visibility_modifier nodes
+        if (child.type === "visibility_modifier") {
+            const text = child.text;
+            if (text === "private" || text === "fileprivate" || text === "internal" || text === "public" || text === "open") {
+                return text;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if a node has public or open visibility (external API)
+ */
+export function isPublic(node) {
+    const accessLevel = getAccessLevel(node);
+    return accessLevel === "public" || accessLevel === "open" || accessLevel === undefined;
+}
+/**
+ * Check if a function/method is async
+ */
+export function isAsync(node) {
+    for (const child of node.children) {
+        if (child.type === "modifiers") {
+            for (const modifier of child.children) {
+                if (modifier.text === "async") {
+                    return true;
+                }
+            }
+        }
+        if (child.text === "async") {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if a node has static modifier
+ */
+export function isStatic(node) {
+    for (const child of node.children) {
+        if (child.type === "modifiers") {
+            for (const modifier of child.children) {
+                if (modifier.text === "static" || modifier.text === "class") {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Get function signature from a function_declaration node
+ */
+export function getFunctionSignature(node) {
+    const parts = [];
+    // Access level
+    const accessLevel = getAccessLevel(node);
+    if (accessLevel && accessLevel !== "internal") {
+        parts.push(accessLevel);
+    }
+    // Static/class modifier
+    if (isStatic(node)) {
+        parts.push("static");
+    }
+    // Async modifier
+    if (isAsync(node)) {
+        parts.push("async");
+    }
+    parts.push("func");
+    // Function name
+    const nameNode = node.childForFieldName("name");
+    const name = nameNode?.text ?? "unknown";
+    // Parameters
+    let params = "()";
+    for (const child of node.children) {
+        if (child.type === "parameter_clause" || child.type === "function_signature") {
+            const paramClause = child.type === "function_signature"
+                ? child.children.find(c => c.type === "parameter_clause")
+                : child;
+            if (paramClause) {
+                params = paramClause.text;
+            }
+            break;
+        }
+    }
+    // Return type
+    let returnType = "";
+    for (const child of node.children) {
+        if (child.type === "function_signature") {
+            const returnClause = child.children.find(c => c.type === "function_result");
+            if (returnClause) {
+                returnType = ` ${returnClause.text}`;
+            }
+            break;
+        }
+    }
+    parts.push(`${name}${params}${returnType}`);
+    return parts.join(" ");
+}
+/**
+ * Get method signature (same as function but with receiver context)
+ */
+export function getMethodSignature(node) {
+    return getFunctionSignature(node);
+}
+/**
+ * Get class signature
+ */
+export function getClassSignature(node) {
+    const parts = [];
+    const accessLevel = getAccessLevel(node);
+    if (accessLevel && accessLevel !== "internal") {
+        parts.push(accessLevel);
+    }
+    // Check for final modifier
+    for (const child of node.children) {
+        if (child.type === "modifiers") {
+            for (const modifier of child.children) {
+                if (modifier.text === "final") {
+                    parts.push("final");
+                    break;
+                }
+            }
+        }
+    }
+    parts.push("class");
+    // Class name - look for type_identifier
+    let name = "unknown";
+    for (const child of node.children) {
+        if (child.type === "type_identifier") {
+            name = child.text;
+            break;
+        }
+    }
+    parts.push(name);
+    // Inheritance clause
+    for (const child of node.children) {
+        if (child.type === "type_inheritance_clause" || child.type === "inheritance_specifier") {
+            parts.push(child.text);
+            break;
+        }
+    }
+    return parts.join(" ");
+}
+/**
+ * Get struct signature
+ */
+export function getStructSignature(node) {
+    const parts = [];
+    const accessLevel = getAccessLevel(node);
+    if (accessLevel && accessLevel !== "internal") {
+        parts.push(accessLevel);
+    }
+    parts.push("struct");
+    // Struct name - look for type_identifier
+    let name = "unknown";
+    for (const child of node.children) {
+        if (child.type === "type_identifier") {
+            name = child.text;
+            break;
+        }
+    }
+    parts.push(name);
+    // Inheritance clause (protocols)
+    for (const child of node.children) {
+        if (child.type === "type_inheritance_clause" || child.type === "inheritance_specifier") {
+            parts.push(child.text);
+            break;
+        }
+    }
+    return parts.join(" ");
+}
+/**
+ * Get protocol signature
+ */
+export function getProtocolSignature(node) {
+    const parts = [];
+    const accessLevel = getAccessLevel(node);
+    if (accessLevel && accessLevel !== "internal") {
+        parts.push(accessLevel);
+    }
+    parts.push("protocol");
+    // Protocol name - look for type_identifier
+    let name = "unknown";
+    for (const child of node.children) {
+        if (child.type === "type_identifier") {
+            name = child.text;
+            break;
+        }
+    }
+    parts.push(name);
+    // Inheritance clause
+    for (const child of node.children) {
+        if (child.type === "type_inheritance_clause" || child.type === "inheritance_specifier") {
+            parts.push(child.text);
+            break;
+        }
+    }
+    return parts.join(" ");
+}
+/**
+ * Get enum signature
+ */
+export function getEnumSignature(node) {
+    const parts = [];
+    const accessLevel = getAccessLevel(node);
+    if (accessLevel && accessLevel !== "internal") {
+        parts.push(accessLevel);
+    }
+    parts.push("enum");
+    // Enum name - look for type_identifier
+    let name = "unknown";
+    for (const child of node.children) {
+        if (child.type === "type_identifier") {
+            name = child.text;
+            break;
+        }
+    }
+    parts.push(name);
+    // Raw type or protocol conformance
+    for (const child of node.children) {
+        if (child.type === "type_inheritance_clause" || child.type === "inheritance_specifier") {
+            parts.push(child.text);
+            break;
+        }
+    }
+    return parts.join(" ");
+}
+/**
+ * Get extension signature
+ */
+export function getExtensionSignature(node) {
+    const parts = [];
+    const accessLevel = getAccessLevel(node);
+    if (accessLevel && accessLevel !== "internal") {
+        parts.push(accessLevel);
+    }
+    parts.push("extension");
+    // Extended type
+    for (const child of node.children) {
+        if (child.type === "type_identifier" || child.type === "user_type") {
+            parts.push(child.text);
+            break;
+        }
+    }
+    // Protocol conformance
+    for (const child of node.children) {
+        if (child.type === "type_inheritance_clause") {
+            parts.push(child.text);
+            break;
+        }
+    }
+    return parts.join(" ");
+}
+/**
+ * Get typealias signature
+ */
+export function getTypealiasSignature(node) {
+    const parts = [];
+    const accessLevel = getAccessLevel(node);
+    if (accessLevel && accessLevel !== "internal") {
+        parts.push(accessLevel);
+    }
+    parts.push("typealias");
+    // Typealias name
+    const nameNode = node.childForFieldName("name");
+    const name = nameNode?.text ?? "unknown";
+    parts.push(name);
+    // Type assignment
+    for (const child of node.children) {
+        if (child.type === "type_annotation" || child.text.startsWith("=")) {
+            // Get the type after =
+            const typeText = child.text.replace(/^=\s*/, "");
+            if (typeText) {
+                parts.push("=", typeText);
+            }
+            break;
+        }
+    }
+    return parts.join(" ");
+}
+/**
+ * Get import path from import declaration
+ */
+export function getImportPath(node) {
+    // Remove "import " prefix
+    const text = node.text.trim();
+    if (text.startsWith("import ")) {
+        return text.slice(7).trim();
+    }
+    return text;
+}
+/**
+ * Get variable/constant signature
+ */
+export function getVariableSignature(node) {
+    const text = node.text.trim();
+    // Get just the declaration part (first line)
+    const firstLine = text.split("\n")[0] ?? text;
+    // Clean up and return
+    return firstLine.replace(/\s*[={].*$/, "").trim();
+}
+/**
+ * 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,
+    };
+}

package/dist/ast/types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * AST Types
+ *
+ * Shared type definitions for code parsing and extraction.
+ */
+export type SupportedLanguage = "typescript" | "javascript" | "python" | "go" | "rust" | "php" | "swift" | "json" | "yaml" | "unknown";
+export type ElementType = "function" | "class" | "interface" | "type" | "variable" | "import" | "export" | "method";
+export interface CodeElement {
+    /** Type of code element */
+    type: ElementType;
+    /** Name of the element */
+    name: string;
+    /** Starting line number (1-indexed) */
+    startLine: number;
+    /** Ending line number (1-indexed) */
+    endLine: number;
+    /** Function/method signature if applicable */
+    signature?: string;
+    /** JSDoc/docstring content if present */
+    documentation?: string;
+    /** Whether this element is exported */
+    isExported?: boolean;
+    /** Whether this is async (for functions) */
+    isAsync?: boolean;
+    /** Parent element name (for methods in classes) */
+    parent?: string;
+}
+export interface FileStructure {
+    /** Detected language */
+    language: SupportedLanguage;
+    /** Total lines in file */
+    totalLines: number;
+    /** Import statements */
+    imports: CodeElement[];
+    /** Export statements */
+    exports: CodeElement[];
+    /** Function declarations */
+    functions: CodeElement[];
+    /** Class declarations */
+    classes: CodeElement[];
+    /** Interface declarations (TS) */
+    interfaces: CodeElement[];
+    /** Type alias declarations (TS) */
+    types: CodeElement[];
+    /** Variable/constant declarations */
+    variables: CodeElement[];
+}
+export interface ExtractedContent {
+    /** Extracted code content */
+    content: string;
+    /** Elements that were extracted */
+    elements: CodeElement[];
+    /** Related import statements */
+    relatedImports: string[];
+    /** Start line of extraction */
+    startLine: number;
+    /** End line of extraction */
+    endLine: number;
+}
+export interface ExtractionTarget {
+    /** Type of element to find */
+    type: ElementType;
+    /** Name of element to find */
+    name: string;
+}
+export interface ExtractionOptions {
+    /** Include related imports */
+    includeImports: boolean;
+    /** Include JSDoc/docstring comments */
+    includeComments: boolean;
+}
+/**
+ * Options for parsing control
+ */
+export interface ParseOptions {
+    /** Extract signature and documentation (default: false for performance) */
+    detailed?: boolean;
+}
+/**
+ * Parser interface that all language parsers must implement
+ */
+export interface LanguageParser {
+    /** Supported languages */
+    languages: SupportedLanguage[];
+    /** Parse file content and return structure */
+    parse(content: string, options?: ParseOptions): FileStructure;
+    /** Extract a specific element by target */
+    extractElement(content: string, target: ExtractionTarget, options: ExtractionOptions): ExtractedContent | null;
+    /** Search for elements matching a query */
+    searchElements(content: string, query: string): CodeElement[];
+}
+/**
+ * Create an empty file structure
+ */
+export declare function createEmptyStructure(language: SupportedLanguage, totalLines: number): FileStructure;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/ast/types.ts"],"names":[],"mappings":"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"}

package/dist/ast/types.js

@@ -0,0 +1,21 @@
+/**
+ * AST Types
+ *
+ * Shared type definitions for code parsing and extraction.
+ */
+/**
+ * Create an empty file structure
+ */
+export function createEmptyStructure(language, totalLines) {
+    return {
+        language,
+        totalLines,
+        imports: [],
+        exports: [],
+        functions: [],
+        classes: [],
+        interfaces: [],
+        types: [],
+        variables: [],
+    };
+}

package/dist/ast/typescript.d.ts

@@ -0,0 +1,24 @@
+/**
+ * TypeScript/JavaScript Parser
+ *
+ * Uses TypeScript Compiler API for accurate AST parsing.
+ */
+import type { CodeElement, FileStructure, ExtractedContent, ExtractionTarget, ExtractionOptions, ParseOptions, LanguageParser } from "./types.js";
+/**
+ * Parse TypeScript/JavaScript content into FileStructure
+ * @param options ParseOptions - set detailed: true to extract signature/documentation
+ */
+export declare function parseTypeScript(content: string, isTypeScript?: boolean, options?: ParseOptions): FileStructure;
+/**
+ * Extract a specific element from TypeScript content
+ */
+export declare function extractTypeScriptElement(content: string, target: ExtractionTarget, options: ExtractionOptions, isTypeScript?: boolean): ExtractedContent | null;
+/**
+ * Search for elements matching a query
+ */
+export declare function searchTypeScriptElements(content: string, query: string): CodeElement[];
+/**
+ * TypeScript parser implementation
+ */
+export declare const typescriptParser: LanguageParser;
+//# sourceMappingURL=typescript.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../src/ast/typescript.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,cAAc,EAEf,MAAM,YAAY,CAAC;AAyDpB;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,YAAY,GAAE,OAAc,EAC5B,OAAO,GAAE,YAAiB,GACzB,aAAa,CAkMf;AAuCD;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,iBAAiB,EAC1B,YAAY,GAAE,OAAc,GAC3B,gBAAgB,GAAG,IAAI,CA+DzB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE,CAyBtF;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAkB9B,CAAC"}