distill-mcp 0.6.0-beta

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

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../src/ast/python/queries.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,cAAc,oEAG1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,8DAGvB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,8EAKxB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,mJAO3B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,uGAK1B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,+EAI5B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,wJAMxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,owBAgCjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;CASV,CAAC"}

package/dist/ast/python/queries.js

@@ -0,0 +1,137 @@
+/**
+ * Python Tree-sitter Queries
+ *
+ * S-expression queries for extracting Python code elements.
+ * Tree-sitter uses a query language similar to Lisp S-expressions.
+ */
+/**
+ * Query to find all function definitions (including async)
+ * Captures:
+ * - @function: the function_definition node
+ * - @name: the function name
+ */
+export const FUNCTION_QUERY = `
+(function_definition
+  name: (identifier) @name) @function
+`;
+/**
+ * Query to find all class definitions
+ * Captures:
+ * - @class: the class_definition node
+ * - @name: the class name
+ */
+export const CLASS_QUERY = `
+(class_definition
+  name: (identifier) @name) @class
+`;
+/**
+ * Query to find all import statements
+ * Captures:
+ * - @import: the import statement node
+ */
+export const IMPORT_QUERY = `
+[
+  (import_statement) @import
+  (import_from_statement) @import
+]
+`;
+/**
+ * Query to find all decorated definitions
+ * Captures:
+ * - @decorator: the decorator node
+ * - @definition: the decorated definition (function or class)
+ */
+export const DECORATED_QUERY = `
+(decorated_definition
+  (decorator) @decorator
+  definition: [
+    (function_definition) @function
+    (class_definition) @class
+  ])
+`;
+/**
+ * Query to find all assignments at module level (variables)
+ * Captures:
+ * - @variable: the assignment node
+ * - @name: the variable name
+ */
+export const VARIABLE_QUERY = `
+(module
+  (expression_statement
+    (assignment
+      left: (identifier) @name) @variable))
+`;
+/**
+ * Query to find all type aliases (using TypeAlias or simple assignment with type annotation)
+ * Captures:
+ * - @type_alias: the type alias definition
+ */
+export const TYPE_ALIAS_QUERY = `
+(module
+  (type_alias_statement
+    name: (type) @name) @type_alias)
+`;
+/**
+ * Query to find class methods
+ * Captures:
+ * - @method: the function_definition node inside a class
+ * - @name: the method name
+ * - @class_name: the parent class name
+ */
+export const METHOD_QUERY = `
+(class_definition
+  name: (identifier) @class_name
+  body: (block
+    (function_definition
+      name: (identifier) @method_name) @method))
+`;
+/**
+ * Combined query for all top-level definitions
+ * This is more efficient than running multiple queries
+ */
+export const ALL_DEFINITIONS_QUERY = `
+; Functions at module level
+(module
+  (function_definition
+    name: (identifier) @func_name) @function)
+
+; Decorated functions at module level
+(module
+  (decorated_definition
+    (function_definition
+      name: (identifier) @decorated_func_name) @decorated_function))
+
+; Classes at module level
+(module
+  (class_definition
+    name: (identifier) @class_name) @class)
+
+; Decorated classes at module level
+(module
+  (decorated_definition
+    (class_definition
+      name: (identifier) @decorated_class_name) @decorated_class))
+
+; Import statements
+(import_statement) @import
+(import_from_statement) @import_from
+
+; Module-level variables
+(module
+  (expression_statement
+    (assignment
+      left: (identifier) @var_name) @variable))
+`;
+/**
+ * Query patterns as a single object for easy access
+ */
+export const QUERIES = {
+    function: FUNCTION_QUERY,
+    class: CLASS_QUERY,
+    import: IMPORT_QUERY,
+    decorated: DECORATED_QUERY,
+    variable: VARIABLE_QUERY,
+    typeAlias: TYPE_ALIAS_QUERY,
+    method: METHOD_QUERY,
+    all: ALL_DEFINITIONS_QUERY,
+};

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

@@ -0,0 +1,63 @@
+/**
+ * Python Parser Utilities
+ *
+ * Helper functions for converting Tree-sitter nodes to CodeElements
+ * and extracting Python-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 docstring from a function or class body
+ * Returns the docstring content without the quotes
+ */
+export declare function extractDocstring(bodyNode: Node | null): string | undefined;
+/**
+ * Get function signature from a function_definition node
+ */
+export declare function getFunctionSignature(node: Node, isAsync: boolean): string;
+/**
+ * Get class signature from a class_definition node
+ */
+export declare function getClassSignature(node: Node): string;
+/**
+ * Check if a function is async
+ */
+export declare function isAsyncFunction(node: Node): boolean;
+/**
+ * Check if a definition has decorators that indicate it's exported
+ * (e.g., @property, @staticmethod, @classmethod)
+ */
+export declare function getDecorators(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;
+/**
+ * Get the body node of a function or class
+ */
+export declare function getBodyNode(node: Node): Node | null;
+/**
+ * Extract import name from an import statement
+ */
+export declare function getImportName(node: Node): string;
+/**
+ * Get the full import statement text
+ */
+export declare function getImportSignature(node: Node): string;
+export {};
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/ast/python/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,gBAAgB,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,GAAG,SAAS,CAwB1E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAWzE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAQpD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAWnD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,CAalD;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,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAEnD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CA+BhD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAErD"}

package/dist/ast/python/utils.js

@@ -0,0 +1,159 @@
+/**
+ * Python Parser Utilities
+ *
+ * Helper functions for converting Tree-sitter nodes to CodeElements
+ * and extracting Python-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 docstring from a function or class body
+ * Returns the docstring content without the quotes
+ */
+export function extractDocstring(bodyNode) {
+    if (!bodyNode)
+        return undefined;
+    // Look for the first expression_statement containing a string
+    for (const child of bodyNode.children) {
+        if (child.type === "expression_statement") {
+            const stringNode = child.firstChild;
+            if (stringNode && (stringNode.type === "string" || stringNode.type === "concatenated_string")) {
+                const text = stringNode.text;
+                // Remove triple quotes and clean up
+                if (text.startsWith('"""') || text.startsWith("'''")) {
+                    return text.slice(3, -3).trim();
+                }
+                // Single quoted strings (less common for docstrings)
+                if (text.startsWith('"') || text.startsWith("'")) {
+                    return text.slice(1, -1).trim();
+                }
+            }
+        }
+        // Only check the first statement
+        break;
+    }
+    return undefined;
+}
+/**
+ * Get function signature from a function_definition node
+ */
+export function getFunctionSignature(node, isAsync) {
+    const nameNode = node.childForFieldName("name");
+    const paramsNode = node.childForFieldName("parameters");
+    const returnType = node.childForFieldName("return_type");
+    const name = nameNode?.text ?? "unknown";
+    const params = paramsNode?.text ?? "()";
+    const asyncPrefix = isAsync ? "async " : "";
+    const returnAnnotation = returnType ? ` -> ${returnType.text}` : "";
+    return `${asyncPrefix}def ${name}${params}${returnAnnotation}`;
+}
+/**
+ * Get class signature from a class_definition node
+ */
+export function getClassSignature(node) {
+    const nameNode = node.childForFieldName("name");
+    const superclassNode = node.childForFieldName("superclasses");
+    const name = nameNode?.text ?? "unknown";
+    const superclasses = superclassNode ? `(${superclassNode.text})` : "";
+    return `class ${name}${superclasses}`;
+}
+/**
+ * Check if a function is async
+ */
+export function isAsyncFunction(node) {
+    // In tree-sitter-python, async functions have type "function_definition"
+    // with an "async" modifier in their parent or the first child is "async" keyword
+    const firstChild = node.firstChild;
+    if (firstChild && firstChild.type === "async") {
+        return true;
+    }
+    // Check if there's an "async" keyword before "def"
+    const prevSibling = node.previousSibling;
+    return prevSibling?.type === "async" || false;
+}
+/**
+ * Check if a definition has decorators that indicate it's exported
+ * (e.g., @property, @staticmethod, @classmethod)
+ */
+export function getDecorators(node) {
+    const decorators = [];
+    let current = node.previousSibling;
+    while (current && current.type === "decorator") {
+        const nameNode = current.firstNamedChild;
+        if (nameNode) {
+            decorators.unshift(nameNode.text);
+        }
+        current = current.previousSibling;
+    }
+    return decorators;
+}
+/**
+ * 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,
+    };
+}
+/**
+ * Get the body node of a function or class
+ */
+export function getBodyNode(node) {
+    return node.childForFieldName("body");
+}
+/**
+ * Extract import name from an import statement
+ */
+export function getImportName(node) {
+    // For "import x" -> return "x"
+    // For "from x import y" -> return "y"
+    // For "import x as y" -> return "y"
+    if (node.type === "import_statement") {
+        const nameNode = node.firstNamedChild;
+        if (nameNode?.type === "dotted_name") {
+            return nameNode.text.split(".").pop() ?? nameNode.text;
+        }
+        if (nameNode?.type === "aliased_import") {
+            const alias = nameNode.childForFieldName("alias");
+            return alias?.text ?? nameNode.firstNamedChild?.text ?? "";
+        }
+        return nameNode?.text ?? "";
+    }
+    if (node.type === "import_from_statement") {
+        // Get the imported names
+        for (const child of node.namedChildren) {
+            if (child.type === "dotted_name" && child.previousSibling?.type !== "from") {
+                return child.text.split(".").pop() ?? child.text;
+            }
+            if (child.type === "aliased_import") {
+                const alias = child.childForFieldName("alias");
+                return alias?.text ?? child.firstNamedChild?.text ?? "";
+            }
+        }
+    }
+    return node.text.split(/\s+/).pop() ?? "";
+}
+/**
+ * Get the full import statement text
+ */
+export function getImportSignature(node) {
+    return node.text.split("\n")[0] ?? node.text;
+}

package/dist/ast/quick-scan.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Quick Scan - Regex-based fast scanning for top-level declarations
+ *
+ * Provides 90% faster parsing for skeleton mode by using regex
+ * instead of full AST parsing. Trade-off: no endLine, no signatures.
+ */
+import type { SupportedLanguage, FileStructure } from "./types.js";
+interface QuickElement {
+    name: string;
+    line: number;
+    exported: boolean;
+    isAsync?: boolean;
+}
+interface QuickScanResult {
+    functions: QuickElement[];
+    classes: QuickElement[];
+    interfaces: QuickElement[];
+    types: QuickElement[];
+    variables: QuickElement[];
+    imports: string[];
+}
+/**
+ * Quick scan TypeScript/JavaScript content
+ */
+export declare function quickScanTypeScript(content: string): QuickScanResult;
+/**
+ * Quick scan Python content
+ */
+export declare function quickScanPython(content: string): QuickScanResult;
+/**
+ * Quick scan Go content
+ */
+export declare function quickScanGo(content: string): QuickScanResult;
+export declare function convertToFileStructure(scan: QuickScanResult, language: SupportedLanguage, totalLines: number): FileStructure;
+/**
+ * Quick scan content based on language
+ */
+export declare function quickScan(content: string, language: SupportedLanguage): FileStructure;
+export {};
+//# sourceMappingURL=quick-scan.d.ts.map

package/dist/ast/quick-scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quick-scan.d.ts","sourceRoot":"","sources":["../../src/ast/quick-scan.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAe,MAAM,YAAY,CAAC;AAEhF,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,UAAU,eAAe;IACvB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,UAAU,EAAE,YAAY,EAAE,CAAC;IAC3B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAwCD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAgFpE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CA2DhE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAkD5D;AAgBD,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,iBAAiB,EAC3B,UAAU,EAAE,MAAM,GACjB,aAAa,CAiBf;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,iBAAiB,GAC1B,aAAa,CA6Bf"}

package/dist/ast/quick-scan.js

@@ -0,0 +1,287 @@
+/**
+ * Quick Scan - Regex-based fast scanning for top-level declarations
+ *
+ * Provides 90% faster parsing for skeleton mode by using regex
+ * instead of full AST parsing. Trade-off: no endLine, no signatures.
+ */
+// TypeScript/JavaScript patterns
+const TS_PATTERNS = {
+    // export async function foo(
+    function: /^\s*(export\s+)?(async\s+)?function\s+(\w+)/,
+    // export class Foo
+    class: /^\s*(export\s+)?class\s+(\w+)/,
+    // export interface Foo
+    interface: /^\s*(export\s+)?interface\s+(\w+)/,
+    // export type Foo
+    type: /^\s*(export\s+)?type\s+(\w+)/,
+    // export const foo = or export const foo:
+    constExport: /^\s*export\s+const\s+(\w+)\s*[=:]/,
+    // import ... from or import "
+    import: /^\s*import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?["']([^"']+)["']/,
+};
+// Python patterns
+const PY_PATTERNS = {
+    // def foo(
+    function: /^def\s+(\w+)\s*\(/,
+    // async def foo(
+    asyncFunction: /^async\s+def\s+(\w+)\s*\(/,
+    // class Foo:
+    class: /^class\s+(\w+)/,
+    // from x import y or import x
+    import: /^(?:from\s+(\S+)\s+import|import\s+(\S+))/,
+};
+// Go patterns
+const GO_PATTERNS = {
+    // func Foo( or func (r *Receiver) Foo(
+    function: /^func\s+(?:\([^)]*\)\s+)?(\w+)\s*\(/,
+    // type Foo struct/interface
+    type: /^type\s+(\w+)\s+(?:struct|interface)/,
+    // import "x" or import ( multiline )
+    import: /^import\s+(?:\(\s*)?["']?([^"'\s)]+)/,
+};
+/**
+ * Quick scan TypeScript/JavaScript content
+ */
+export function quickScanTypeScript(content) {
+    const lines = content.split("\n");
+    const result = {
+        functions: [],
+        classes: [],
+        interfaces: [],
+        types: [],
+        variables: [],
+        imports: [],
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        const lineNum = i + 1; // 1-indexed
+        // Functions
+        const fnMatch = line.match(TS_PATTERNS.function);
+        if (fnMatch?.[3]) {
+            result.functions.push({
+                name: fnMatch[3],
+                line: lineNum,
+                exported: !!fnMatch[1],
+                isAsync: !!fnMatch[2],
+            });
+            continue;
+        }
+        // Classes
+        const classMatch = line.match(TS_PATTERNS.class);
+        if (classMatch?.[2]) {
+            result.classes.push({
+                name: classMatch[2],
+                line: lineNum,
+                exported: !!classMatch[1],
+            });
+            continue;
+        }
+        // Interfaces
+        const ifaceMatch = line.match(TS_PATTERNS.interface);
+        if (ifaceMatch?.[2]) {
+            result.interfaces.push({
+                name: ifaceMatch[2],
+                line: lineNum,
+                exported: !!ifaceMatch[1],
+            });
+            continue;
+        }
+        // Types
+        const typeMatch = line.match(TS_PATTERNS.type);
+        if (typeMatch?.[2]) {
+            result.types.push({
+                name: typeMatch[2],
+                line: lineNum,
+                exported: !!typeMatch[1],
+            });
+            continue;
+        }
+        // Exported const
+        const constMatch = line.match(TS_PATTERNS.constExport);
+        if (constMatch?.[1]) {
+            result.variables.push({
+                name: constMatch[1],
+                line: lineNum,
+                exported: true,
+            });
+            continue;
+        }
+        // Imports
+        const importMatch = line.match(TS_PATTERNS.import);
+        if (importMatch?.[1]) {
+            result.imports.push(importMatch[1]);
+        }
+    }
+    return result;
+}
+/**
+ * Quick scan Python content
+ */
+export function quickScanPython(content) {
+    const lines = content.split("\n");
+    const result = {
+        functions: [],
+        classes: [],
+        interfaces: [],
+        types: [],
+        variables: [],
+        imports: [],
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        const lineNum = i + 1;
+        // Async functions
+        const asyncMatch = line.match(PY_PATTERNS.asyncFunction);
+        if (asyncMatch?.[1]) {
+            result.functions.push({
+                name: asyncMatch[1],
+                line: lineNum,
+                exported: true, // Python doesn't have export keyword
+                isAsync: true,
+            });
+            continue;
+        }
+        // Functions
+        const fnMatch = line.match(PY_PATTERNS.function);
+        if (fnMatch?.[1]) {
+            result.functions.push({
+                name: fnMatch[1],
+                line: lineNum,
+                exported: true,
+            });
+            continue;
+        }
+        // Classes
+        const classMatch = line.match(PY_PATTERNS.class);
+        if (classMatch?.[1]) {
+            result.classes.push({
+                name: classMatch[1],
+                line: lineNum,
+                exported: true,
+            });
+            continue;
+        }
+        // Imports
+        const importMatch = line.match(PY_PATTERNS.import);
+        const importName = importMatch?.[1] || importMatch?.[2];
+        if (importName) {
+            result.imports.push(importName);
+        }
+    }
+    return result;
+}
+/**
+ * Quick scan Go content
+ */
+export function quickScanGo(content) {
+    const lines = content.split("\n");
+    const result = {
+        functions: [],
+        classes: [],
+        interfaces: [],
+        types: [],
+        variables: [],
+        imports: [],
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        const lineNum = i + 1;
+        // Functions
+        const fnMatch = line.match(GO_PATTERNS.function);
+        const fnName = fnMatch?.[1];
+        if (fnName && fnName.length > 0) {
+            const firstChar = fnName[0];
+            result.functions.push({
+                name: fnName,
+                line: lineNum,
+                exported: firstChar === firstChar.toUpperCase(), // Go: uppercase = exported
+            });
+            continue;
+        }
+        // Types (struct/interface)
+        const typeMatch = line.match(GO_PATTERNS.type);
+        const typeName = typeMatch?.[1];
+        if (typeName && typeName.length > 0) {
+            const firstChar = typeName[0];
+            result.types.push({
+                name: typeName,
+                line: lineNum,
+                exported: firstChar === firstChar.toUpperCase(),
+            });
+            continue;
+        }
+        // Imports
+        const importMatch = line.match(GO_PATTERNS.import);
+        if (importMatch?.[1]) {
+            result.imports.push(importMatch[1]);
+        }
+    }
+    return result;
+}
+/**
+ * Convert QuickScanResult to FileStructure
+ */
+function toCodeElement(el, type) {
+    return {
+        type: type,
+        name: el.name,
+        startLine: el.line,
+        endLine: el.line, // Quick mode: no endLine
+        isExported: el.exported,
+        isAsync: el.isAsync,
+    };
+}
+export function convertToFileStructure(scan, language, totalLines) {
+    return {
+        language,
+        totalLines,
+        functions: scan.functions.map((f) => toCodeElement(f, "function")),
+        classes: scan.classes.map((c) => toCodeElement(c, "class")),
+        interfaces: scan.interfaces.map((i) => toCodeElement(i, "interface")),
+        types: scan.types.map((t) => toCodeElement(t, "type")),
+        variables: scan.variables.map((v) => toCodeElement(v, "variable")),
+        imports: scan.imports.map((name) => ({
+            type: "import",
+            name,
+            startLine: 0,
+            endLine: 0,
+        })),
+        exports: [], // Not tracked in quick mode
+    };
+}
+/**
+ * Quick scan content based on language
+ */
+export function quickScan(content, language) {
+    const totalLines = content.split("\n").length;
+    let scanResult;
+    switch (language) {
+        case "typescript":
+        case "javascript":
+            scanResult = quickScanTypeScript(content);
+            break;
+        case "python":
+            scanResult = quickScanPython(content);
+            break;
+        case "go":
+            scanResult = quickScanGo(content);
+            break;
+        default:
+            // Fallback: empty structure for unsupported languages
+            scanResult = {
+                functions: [],
+                classes: [],
+                interfaces: [],
+                types: [],
+                variables: [],
+                imports: [],
+            };
+    }
+    return convertToFileStructure(scanResult, language, totalLines);
+}