distill-mcp 0.6.0-beta

package/dist/ast/rust/utils.js

@@ -0,0 +1,254 @@
+/**
+ * Rust Parser Utilities
+ *
+ * Helper functions for converting Tree-sitter nodes to CodeElements
+ * and extracting Rust-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 Rust doc comment from above a declaration
+ * Rust uses /// and //! for doc comments, or block doc comments
+ */
+export function extractRustDoc(node, lines) {
+    const startLine = node.startPosition.row;
+    const comments = [];
+    // Look for doc comments above the node
+    // Skip attributes like #[derive(...)] and continue looking
+    for (let i = startLine - 1; i >= 0; i--) {
+        const line = lines[i]?.trim();
+        if (!line) {
+            // Empty line - continue looking
+            continue;
+        }
+        else if (line.startsWith("///")) {
+            // Outer doc comment
+            comments.unshift(line.slice(3).trim());
+        }
+        else if (line.startsWith("//!")) {
+            // Inner doc comment (module-level)
+            comments.unshift(line.slice(3).trim());
+        }
+        else if (line.startsWith("#[") || line.startsWith("#![")) {
+            // Attribute - skip and continue looking for doc comments
+            continue;
+        }
+        else if (line.startsWith("//")) {
+            // Regular comment - skip and continue
+            continue;
+        }
+        else {
+            // Something else (code) - stop
+            break;
+        }
+    }
+    return comments.length > 0 ? comments.join("\n") : undefined;
+}
+/**
+ * Check if a node has a visibility modifier (pub, pub(crate), etc.)
+ */
+export function hasVisibility(node) {
+    const visibilityNode = node.childForFieldName("visibility_modifier");
+    if (visibilityNode)
+        return true;
+    // Also check first child for visibility_modifier
+    for (const child of node.children) {
+        if (child.type === "visibility_modifier") {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Get visibility string from a node
+ */
+export function getVisibility(node) {
+    for (const child of node.children) {
+        if (child.type === "visibility_modifier") {
+            return child.text;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if a function is async
+ */
+export function isAsyncFn(node) {
+    // Check for async keyword in function modifiers
+    for (const child of node.children) {
+        if (child.type === "async") {
+            return true;
+        }
+    }
+    // Also check the text for async keyword (may have pub async, etc.)
+    const text = node.text.trimStart();
+    // Match patterns like "async fn", "pub async fn", "pub(crate) async fn"
+    return /^(?:pub(?:\([^)]*\))?\s+)?async\s+fn\s/.test(text);
+}
+/**
+ * Get function signature from a function_item node
+ */
+export function getFunctionSignature(node) {
+    const nameNode = node.childForFieldName("name");
+    const paramsNode = node.childForFieldName("parameters");
+    const returnTypeNode = node.childForFieldName("return_type");
+    const visibility = getVisibility(node);
+    const isAsync = isAsyncFn(node);
+    const name = nameNode?.text ?? "unknown";
+    const params = paramsNode?.text ?? "()";
+    const returnType = returnTypeNode ? ` -> ${returnTypeNode.text}` : "";
+    const prefix = [visibility, isAsync ? "async" : null, "fn"]
+        .filter(Boolean)
+        .join(" ");
+    return `${prefix} ${name}${params}${returnType}`;
+}
+/**
+ * Get struct signature
+ */
+export function getStructSignature(node) {
+    const nameNode = node.childForFieldName("name");
+    const visibility = getVisibility(node);
+    const name = nameNode?.text ?? "unknown";
+    const prefix = [visibility, "struct"].filter(Boolean).join(" ");
+    return `${prefix} ${name}`;
+}
+/**
+ * Get enum signature
+ */
+export function getEnumSignature(node) {
+    const nameNode = node.childForFieldName("name");
+    const visibility = getVisibility(node);
+    const name = nameNode?.text ?? "unknown";
+    const prefix = [visibility, "enum"].filter(Boolean).join(" ");
+    return `${prefix} ${name}`;
+}
+/**
+ * Get trait signature
+ */
+export function getTraitSignature(node) {
+    const nameNode = node.childForFieldName("name");
+    const visibility = getVisibility(node);
+    const name = nameNode?.text ?? "unknown";
+    const prefix = [visibility, "trait"].filter(Boolean).join(" ");
+    return `${prefix} ${name}`;
+}
+/**
+ * Get impl block signature
+ */
+export function getImplSignature(node) {
+    const typeNode = node.childForFieldName("type");
+    const traitNode = node.childForFieldName("trait");
+    const typeName = typeNode?.text ?? "unknown";
+    if (traitNode) {
+        return `impl ${traitNode.text} for ${typeName}`;
+    }
+    return `impl ${typeName}`;
+}
+/**
+ * Get the type name from an impl block
+ */
+export function getImplTypeName(node) {
+    const typeNode = node.childForFieldName("type");
+    return typeNode?.text ?? "unknown";
+}
+/**
+ * Get the trait name from an impl block (if implementing a trait)
+ */
+export function getImplTraitName(node) {
+    const traitNode = node.childForFieldName("trait");
+    return traitNode?.text;
+}
+/**
+ * Extract the use path from a use_declaration
+ */
+export function getUsePath(node) {
+    // The use path is typically the text minus "use " and ";"
+    const text = node.text.trim();
+    // Remove "use " prefix and trailing ";"
+    let path = text;
+    if (path.startsWith("use ")) {
+        path = path.slice(4);
+    }
+    if (path.endsWith(";")) {
+        path = path.slice(0, -1);
+    }
+    return path.trim();
+}
+/**
+ * Get the short name from a use path
+ * e.g., "std::collections::HashMap" -> "HashMap"
+ */
+export function getUseShortName(usePath) {
+    // Handle "as Alias" syntax
+    const asMatch = usePath.match(/\s+as\s+(\w+)\s*$/);
+    if (asMatch) {
+        return asMatch[1];
+    }
+    // Handle brace syntax: use std::{A, B} or use std::io::{self, Read}
+    const braceMatch = usePath.match(/::?\{(.+)\}\s*$/);
+    if (braceMatch) {
+        const items = braceMatch[1].split(",").map((s) => s.trim());
+        // Return first non-self item or the full set
+        const nonSelf = items.filter((i) => i !== "self");
+        if (nonSelf.length === 1) {
+            return nonSelf[0];
+        }
+        return `{${items.join(", ")}}`;
+    }
+    // Handle glob: use std::*
+    if (usePath.endsWith("::*")) {
+        const parts = usePath.slice(0, -3).split("::");
+        return `${parts[parts.length - 1]}::*`;
+    }
+    // Simple path: use std::collections::HashMap
+    const parts = usePath.split("::");
+    return parts[parts.length - 1] ?? usePath;
+}
+/**
+ * Get const/static signature
+ */
+export function getConstSignature(node, kind) {
+    const nameNode = node.childForFieldName("name");
+    const typeNode = node.childForFieldName("type");
+    const visibility = getVisibility(node);
+    const name = nameNode?.text ?? "unknown";
+    const typePart = typeNode ? `: ${typeNode.text}` : "";
+    const prefix = [visibility, kind].filter(Boolean).join(" ");
+    return `${prefix} ${name}${typePart}`;
+}
+/**
+ * Get type alias signature
+ */
+export function getTypeAliasSignature(node) {
+    const nameNode = node.childForFieldName("name");
+    const visibility = getVisibility(node);
+    const name = nameNode?.text ?? "unknown";
+    const prefix = [visibility, "type"].filter(Boolean).join(" ");
+    return `${prefix} ${name}`;
+}
+/**
+ * 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/swift/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Swift AST Parser Module
+ *
+ * Exports all Swift parsing functionality.
+ */
+export { swiftTreeSitterParser, parseSwift, parseSwiftAsync, extractSwiftElement, searchSwiftElements, initSwiftParser, } from "./parser.js";
+export { QUERIES } from "./queries.js";
+export { getLineNumber, getEndLineNumber, extractSwiftDoc, getAccessLevel, isPublic, isAsync, isStatic, getFunctionSignature, getMethodSignature, getClassSignature, getStructSignature, getProtocolSignature, getEnumSignature, getExtensionSignature, getTypealiasSignature, getImportPath, getVariableSignature, createCodeElement, } from "./utils.js";
+export type { SwiftAccessLevel } from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/ast/swift/index.js

@@ -0,0 +1,8 @@
+/**
+ * Swift AST Parser Module
+ *
+ * Exports all Swift parsing functionality.
+ */
+export { swiftTreeSitterParser, parseSwift, parseSwiftAsync, extractSwiftElement, searchSwiftElements, initSwiftParser, } from "./parser.js";
+export { QUERIES } from "./queries.js";
+export { getLineNumber, getEndLineNumber, extractSwiftDoc, getAccessLevel, isPublic, isAsync, isStatic, getFunctionSignature, getMethodSignature, getClassSignature, getStructSignature, getProtocolSignature, getEnumSignature, getExtensionSignature, getTypealiasSignature, getImportPath, getVariableSignature, createCodeElement, } from "./utils.js";

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

@@ -0,0 +1,31 @@
+/**
+ * Swift Tree-sitter Parser
+ *
+ * AST parser for Swift using Tree-sitter for accurate code analysis.
+ */
+import type { CodeElement, FileStructure, ExtractedContent, ExtractionTarget, ExtractionOptions, LanguageParser } from "../types.js";
+/**
+ * Parse Swift content and extract structure
+ */
+export declare function parseSwift(content: string): FileStructure;
+/**
+ * Async version of parseSwift
+ */
+export declare function parseSwiftAsync(content: string): Promise<FileStructure>;
+/**
+ * Extract a specific element from Swift code
+ */
+export declare function extractSwiftElement(content: string, target: ExtractionTarget, options: ExtractionOptions): Promise<ExtractedContent | null>;
+/**
+ * Search for elements matching a query
+ */
+export declare function searchSwiftElements(content: string, query: string): Promise<CodeElement[]>;
+/**
+ * LanguageParser implementation for Swift
+ */
+export declare const swiftTreeSitterParser: LanguageParser;
+/**
+ * Initialize the Swift parser
+ */
+export declare function initSwiftParser(): Promise<void>;
+//# sourceMappingURL=parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/ast/swift/parser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAWH,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAEjB,cAAc,EACf,MAAM,aAAa,CAAC;AA8DrB;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAWzD;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAW7E;AAmVD;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAoElC;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAwBhG;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAmHnC,CAAC;AAEF;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAErD"}