@flink-app/flink 0.14.3 → 2.0.0-alpha.100

package/dist/src/schema-extraction/TypeScriptSourceParser.js

@@ -0,0 +1,925 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptSourceParser = void 0;
+var TypeScriptTokenizer_1 = require("./TypeScriptTokenizer");
+/**
+ * Pure utility class for parsing TypeScript source code as text.
+ * All methods are static and side-effect free for easy testing.
+ *
+ * This class provides fast, regex-based parsing without using ts-morph
+ * or the TypeScript compiler, making it suitable for performance-critical
+ * schema extraction.
+ */
+var TypeScriptSourceParser = /** @class */ (function () {
+    function TypeScriptSourceParser() {
+    }
+    /**
+     * Remove comments from source code to avoid false positives in schema detection.
+     * Handles both single-line (//) and multi-line (/* *\/) comments.
+     */
+    TypeScriptSourceParser.removeComments = function (sourceText) {
+        // Remove multi-line comments: /* ... */
+        var text = sourceText.replace(/\/\*[\s\S]*?\*\//g, '');
+        // Remove single-line comments: // ...
+        text = text.replace(/\/\/.*$/gm, '');
+        return text;
+    };
+    /**
+     * Detect if a tool source file uses Zod or JSON schemas.
+     * If true, TypeScript schema extraction should be skipped.
+     *
+     * Note: Strips comments first to avoid false positives from commented-out schemas.
+     */
+    TypeScriptSourceParser.detectSchemaType = function (sourceText) {
+        // Strip comments to avoid matching commented-out schema definitions
+        var textWithoutComments = this.removeComments(sourceText);
+        var hasZodSchemas = textWithoutComments.includes('inputSchema:') || textWithoutComments.includes('outputSchema:');
+        var hasJsonSchemas = textWithoutComments.includes('inputJsonSchema:') || textWithoutComments.includes('outputJsonSchema:');
+        return {
+            hasZodSchemas: hasZodSchemas,
+            hasJsonSchemas: hasJsonSchemas,
+            shouldSkipTypeScriptExtraction: hasZodSchemas || hasJsonSchemas,
+        };
+    };
+    /**
+     * Extract type arguments from Handler<Ctx, Req, Res, Params, Query> declaration.
+     *
+     * @example
+     * ```typescript
+     * parseHandlerTypeArgs('const handler: Handler<AppCtx, LoginReq, LoginRes>')
+     * // Returns: { contextType: 'AppCtx', reqType: 'LoginReq', resType: 'LoginRes' }
+     * ```
+     */
+    TypeScriptSourceParser.parseHandlerTypeArgs = function (sourceText) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        // Try to find Handler< or GetHandler< or PostHandler< etc.
+        var handlerMatch = sourceText.match(/\b(Get|Post|Put|Patch|Delete)?Handler\s*</);
+        if (!handlerMatch) {
+            return null;
+        }
+        var handlerType = handlerMatch[0].replace(/\s*<$/, '');
+        var startIdx = sourceText.indexOf(handlerMatch[0]);
+        if (startIdx === -1) {
+            return null;
+        }
+        // Find the matching closing > by counting bracket depth
+        var depth = 0;
+        var endIdx = -1;
+        for (var i = startIdx + handlerMatch[0].length; i < sourceText.length; i++) {
+            if (sourceText[i] === '<') {
+                depth++;
+            }
+            else if (sourceText[i] === '>') {
+                if (depth === 0) {
+                    endIdx = i;
+                    break;
+                }
+                depth--;
+            }
+        }
+        if (endIdx === -1) {
+            return null;
+        }
+        var typeArgsText = sourceText.slice(startIdx + handlerMatch[0].length, endIdx);
+        var typeArgs = this.splitTopLevelCommas(typeArgsText);
+        if (typeArgs.length === 0) {
+            return null;
+        }
+        // Handler<Ctx, Req, Res, Params, Query>
+        // GetHandler<Ctx, Res, Params, Query> (no Req)
+        // PostHandler<Ctx, Req, Res, Params, Query>
+        // etc.
+        var isGetHandler = handlerType === 'GetHandler';
+        if (isGetHandler) {
+            // GetHandler<Ctx, Res, Params, Query>
+            return {
+                contextType: (_a = typeArgs[0]) === null || _a === void 0 ? void 0 : _a.trim(),
+                resType: (_b = typeArgs[1]) === null || _b === void 0 ? void 0 : _b.trim(),
+                paramsType: (_c = typeArgs[2]) === null || _c === void 0 ? void 0 : _c.trim(),
+                queryType: (_d = typeArgs[3]) === null || _d === void 0 ? void 0 : _d.trim(),
+            };
+        }
+        else {
+            // Handler<Ctx, Req, Res, Params, Query>
+            return {
+                contextType: (_e = typeArgs[0]) === null || _e === void 0 ? void 0 : _e.trim(),
+                reqType: (_f = typeArgs[1]) === null || _f === void 0 ? void 0 : _f.trim(),
+                resType: (_g = typeArgs[2]) === null || _g === void 0 ? void 0 : _g.trim(),
+                paramsType: (_h = typeArgs[3]) === null || _h === void 0 ? void 0 : _h.trim(),
+                queryType: (_j = typeArgs[4]) === null || _j === void 0 ? void 0 : _j.trim(),
+            };
+        }
+    };
+    /**
+     * Extract type arguments from FlinkTool<Ctx, Input, Output> declaration.
+     *
+     * @example
+     * ```typescript
+     * parseFlinkToolTypeArgs('const handler: FlinkTool<Ctx, CreateDocInput, ToolResult<DocOutput>>')
+     * // Returns: { contextType: 'Ctx', inputType: 'CreateDocInput', outputType: 'ToolResult<DocOutput>' }
+     * ```
+     */
+    TypeScriptSourceParser.parseFlinkToolTypeArgs = function (sourceText) {
+        // Find FlinkTool< and then manually parse to find the matching closing >
+        var startIdx = sourceText.indexOf('FlinkTool<');
+        if (startIdx === -1) {
+            return null;
+        }
+        // Find the matching closing > by counting bracket depth
+        var depth = 0;
+        var endIdx = -1;
+        for (var i = startIdx + 'FlinkTool<'.length; i < sourceText.length; i++) {
+            if (sourceText[i] === '<') {
+                depth++;
+            }
+            else if (sourceText[i] === '>') {
+                if (depth === 0) {
+                    endIdx = i;
+                    break;
+                }
+                depth--;
+            }
+        }
+        if (endIdx === -1) {
+            return null;
+        }
+        // Extract the content between the brackets
+        var typeArgsStr = sourceText.substring(startIdx + 'FlinkTool<'.length, endIdx);
+        // Parse the type arguments by splitting on commas at the top level (not inside angle brackets)
+        var typeArgs = this.splitTopLevelCommas(typeArgsStr);
+        if (typeArgs.length < 3) {
+            return null;
+        }
+        return {
+            contextType: typeArgs[0].trim(),
+            inputType: typeArgs[1].trim(),
+            outputType: typeArgs[2].trim(),
+        };
+    };
+    /**
+     * Split a string by commas, but only at the top level (not inside angle brackets).
+     * Helper for parsing generic type arguments like "Ctx, Input, ToolResult<Output>"
+     */
+    TypeScriptSourceParser.splitTopLevelCommas = function (str) {
+        var result = [];
+        var current = '';
+        var depth = 0;
+        for (var _i = 0, str_1 = str; _i < str_1.length; _i++) {
+            var char = str_1[_i];
+            if (char === '<') {
+                depth++;
+                current += char;
+            }
+            else if (char === '>') {
+                depth--;
+                current += char;
+            }
+            else if (char === ',' && depth === 0) {
+                result.push(current);
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current) {
+            result.push(current);
+        }
+        return result;
+    };
+    /**
+     * Check if a type should generate a schema.
+     * Returns false for primitives and special types, true for named types and inline objects.
+     */
+    TypeScriptSourceParser.shouldGenerateSchema = function (typeName) {
+        // Skip 'any' and 'unknown'
+        if (typeName === 'any' || typeName === 'unknown') {
+            return false;
+        }
+        // Generate schemas for inline object types like {} or { foo: string }
+        if (typeName.startsWith('{')) {
+            return true;
+        }
+        // Skip primitive types
+        var primitives = ['string', 'number', 'boolean', 'void', 'undefined', 'null'];
+        if (primitives.includes(typeName.toLowerCase())) {
+            return false;
+        }
+        // Skip binary/non-serializable built-in types that can never have JSON schemas
+        var nonSerializableTypes = ['Buffer', 'ArrayBuffer', 'SharedArrayBuffer', 'Blob', 'ReadableStream', 'WritableStream', 'DataView', 'Uint8Array'];
+        if (nonSerializableTypes.includes(typeName)) {
+            return false;
+        }
+        // Must be a named type (starts with uppercase letter)
+        return /^[A-Z]/.test(typeName);
+    };
+    /**
+     * Check if a type is a built-in TypeScript type.
+     */
+    TypeScriptSourceParser.isBuiltInType = function (typeName) {
+        var builtIns = [
+            'String', 'Number', 'Boolean', 'Date', 'Array', 'Object', 'Record',
+            'Promise', 'Set', 'Map', 'Partial', 'Required', 'Pick', 'Omit',
+            'Readonly', 'ReadonlyArray'
+        ];
+        return builtIns.includes(typeName);
+    };
+    /**
+     * Extract T from ToolResult<T> type name.
+     *
+     * @example
+     * ```typescript
+     * unwrapToolResultType('ToolResult<DocOutput>')  // Returns: 'DocOutput'
+     * unwrapToolResultType('DocOutput')              // Returns: 'DocOutput'
+     * ```
+     */
+    TypeScriptSourceParser.unwrapToolResultType = function (typeName) {
+        var match = typeName.match(/ToolResult<(.+)>/);
+        if (match) {
+            return match[1].trim();
+        }
+        return typeName;
+    };
+    /**
+     * Convert inline object type to interface definition.
+     *
+     * @example
+     * ```typescript
+     * convertInlineObjectToInterface('{}', 'MyInput')
+     * // Returns: 'export interface MyInput {}'
+     *
+     * convertInlineObjectToInterface('{ foo: string }', 'MyInput')
+     * // Returns: 'export interface MyInput {\n  foo: string;\n}'
+     * ```
+     */
+    TypeScriptSourceParser.convertInlineObjectToInterface = function (inlineType, interfaceName) {
+        // For empty object, create empty interface
+        if (inlineType.trim() === '{}') {
+            return "export interface ".concat(interfaceName, " {}");
+        }
+        // For non-empty inline object, convert to interface
+        // Remove outer braces and clean up
+        var body = inlineType.trim().slice(1, -1).trim();
+        // Ensure properties end with semicolons (convert commas to semicolons if needed)
+        body = body.replace(/,\s*$/g, ';').replace(/([^;])\s*$/g, '$1;');
+        return "export interface ".concat(interfaceName, " {\n  ").concat(body, "\n}");
+    };
+    /**
+     * Find an interface or type definition in source text.
+     *
+     * @example
+     * ```typescript
+     * const source = `
+     *   interface User {
+     *     name: string;
+     *   }
+     * `;
+     * findTypeDefinition(source, 'User')
+     * // Returns: { name: 'User', definition: 'interface User { ... }', kind: 'interface' }
+     * ```
+     */
+    TypeScriptSourceParser.findTypeDefinition = function (sourceText, typeName) {
+        // Skip if it's an inline type
+        if (typeName.startsWith('{')) {
+            return null;
+        }
+        // Try to find interface definition first
+        // Pattern: (optional JSDoc) interface Name (optional generics) (optional extends) { ... }
+        var interfacePattern = new RegExp("((?:\\/\\*\\*[\\s\\S]*?\\*\\/\\s*)?)interface\\s+".concat(typeName, "\\s*"), 'gm');
+        var interfaceMatch = interfacePattern.exec(sourceText);
+        if (interfaceMatch) {
+            var startIndex = interfaceMatch.index;
+            var jsDocAndInterface = interfaceMatch[0];
+            // Find the opening brace
+            var afterInterface = sourceText.slice(interfaceMatch.index + interfaceMatch[0].length);
+            var braceMatch = afterInterface.match(/^[^{]*\{/);
+            if (braceMatch) {
+                var braceStart = interfaceMatch.index + interfaceMatch[0].length + braceMatch[0].length - 1;
+                // Use tokenizer for robust bracket matching (handles strings and comments)
+                var tokenizer = new TypeScriptTokenizer_1.TypeScriptTokenizer(sourceText);
+                var braceEnd = tokenizer.findMatchingBracketAt(braceStart, '{');
+                if (braceEnd !== -1) {
+                    var definition = sourceText.slice(startIndex, braceEnd + 1).trim();
+                    return {
+                        name: typeName,
+                        definition: definition,
+                        kind: 'interface',
+                    };
+                }
+            }
+        }
+        // Match type alias: type Name = ...;
+        var typePattern = new RegExp("((?:\\/\\*\\*[\\s\\S]*?\\*\\/\\s*)?)type\\s+".concat(typeName, "\\s*=\\s*"), 'gm');
+        var typeMatch = typePattern.exec(sourceText);
+        if (typeMatch) {
+            var startIndex = typeMatch.index;
+            var afterEquals = typeMatch.index + typeMatch[0].length;
+            // Use tokenizer to find semicolon, properly handling strings and comments
+            var tokenizer = new TypeScriptTokenizer_1.TypeScriptTokenizer(sourceText);
+            var depth = 0;
+            var i = afterEquals;
+            while (i < sourceText.length) {
+                var token = tokenizer.getNextToken(i);
+                // Only process non-string, non-comment tokens
+                if (token.type !== 'string' && token.type !== 'comment') {
+                    var char = token.value;
+                    // Track depth
+                    if (char === '{' || char === '[' || char === '(' || char === '<') {
+                        depth++;
+                    }
+                    else if (char === '}' || char === ']' || char === ')' || char === '>') {
+                        depth--;
+                        // Closing a bracket back to top level may terminate a
+                        // semicolon-free type alias (e.g. `type Params = { ... }`
+                        // with no trailing `;`). Only stop if the type does not
+                        // continue with an operator such as `|` or `&`.
+                        if (depth === 0 && !this.typeContinuesAfter(sourceText, token.endPos)) {
+                            var definition = sourceText.slice(startIndex, token.endPos).trim();
+                            return {
+                                name: typeName,
+                                definition: definition,
+                                kind: 'type',
+                            };
+                        }
+                    }
+                    // End of type at semicolon (at depth 0)
+                    if (char === ';' && depth === 0) {
+                        var definition = sourceText.slice(startIndex, i + 1).trim();
+                        return {
+                            name: typeName,
+                            definition: definition,
+                            kind: 'type',
+                        };
+                    }
+                }
+                i = token.endPos;
+            }
+        }
+        return null;
+    };
+    /**
+     * Peek at the next non-whitespace, non-comment character starting at `fromPos`.
+     * Returns the character, or undefined if only whitespace/comments remain.
+     */
+    TypeScriptSourceParser.peekNextSignificantChar = function (sourceText, fromPos) {
+        var tokenizer = new TypeScriptTokenizer_1.TypeScriptTokenizer(sourceText);
+        var i = fromPos;
+        while (i < sourceText.length) {
+            var token = tokenizer.getNextToken(i);
+            if (token.type === 'comment') {
+                i = token.endPos;
+                continue;
+            }
+            if (token.type === 'string') {
+                return token.value[0];
+            }
+            if (!/\s/.test(token.value)) {
+                return token.value;
+            }
+            i = token.endPos;
+        }
+        return undefined;
+    };
+    /**
+     * Determine whether a type expression continues after `fromPos`, i.e. whether
+     * the character that follows is a type-combinator/continuation operator
+     * (`|`, `&`, `[`, `.`, etc.) rather than the start of an unrelated statement.
+     *
+     * Used to decide if a top-level closing bracket terminates a semicolon-free
+     * type alias or whether the alias keeps going (e.g. a union of object types).
+     */
+    TypeScriptSourceParser.typeContinuesAfter = function (sourceText, fromPos) {
+        var next = this.peekNextSignificantChar(sourceText, fromPos);
+        if (next === undefined) {
+            return false;
+        }
+        // Operators that mean the type expression continues across the boundary.
+        return '|&[.<'.includes(next);
+    };
+    /**
+     * Rename an interface or type definition.
+     *
+     * @example
+     * ```typescript
+     * renameTypeDefinition('interface User { name: string }', 'User', 'Person')
+     * // Returns: 'export interface Person { name: string }'
+     * ```
+     */
+    TypeScriptSourceParser.renameTypeDefinition = function (definition, oldName, newName, exportIt) {
+        if (exportIt === void 0) { exportIt = true; }
+        var exportPrefix = exportIt ? 'export ' : '';
+        // Try interface rename
+        if (definition.includes('interface')) {
+            return definition.replace(new RegExp("interface\\s+".concat(oldName, "\\b")), "".concat(exportPrefix, "interface ").concat(newName));
+        }
+        // Try type alias rename
+        if (definition.includes('type')) {
+            return definition.replace(new RegExp("type\\s+".concat(oldName, "\\b")), "".concat(exportPrefix, "type ").concat(newName));
+        }
+        return definition;
+    };
+    /**
+     * Extract all type names referenced in a type definition.
+     * Excludes JSDoc comments and string literals.
+     *
+     * @example
+     * ```typescript
+     * extractReferencedTypes('interface Doc { author: User; tags: Tag[] }')
+     * // Returns: ['User', 'Tag']
+     * extractReferencedTypes('PaginatedResponse<Car>')
+     * // Returns: ['PaginatedResponse', 'Car']
+     * ```
+     */
+    TypeScriptSourceParser.extractReferencedTypes = function (typeDefinition) {
+        var types = [];
+        // Remove JSDoc comments to avoid extracting type names from documentation
+        var withoutJsDoc = typeDefinition.replace(/\/\*\*[\s\S]*?\*\//g, '');
+        // Match type references in actual code
+        // Types appear after: : < Array< extends implements | &
+        // Also match standalone types (e.g., PaginatedResponse in "PaginatedResponse<Car>")
+        // But exclude types after "interface" or "type" keywords (those are definitions, not references)
+        var typeContextRegex = /(?<!interface\s)(?<!type\s)(?::\s*|<|Array<|extends\s+|implements\s+|\|\s*|&\s*)?([A-Z][a-zA-Z0-9_]*)/g;
+        var match;
+        while ((match = typeContextRegex.exec(withoutJsDoc)) !== null) {
+            var typeName = match[1];
+            // Skip if this looks like it's part of "interface Name" or "type Name"
+            var beforeMatch = withoutJsDoc.substring(Math.max(0, match.index - 15), match.index);
+            if (/\b(interface|type)\s*$/.test(beforeMatch)) {
+                continue;
+            }
+            // Filter out built-in types and duplicates
+            if (!this.isBuiltInType(typeName) && !types.includes(typeName)) {
+                types.push(typeName);
+            }
+        }
+        return types;
+    };
+    /**
+     * Check if a type name is an inline object type.
+     */
+    TypeScriptSourceParser.isInlineObjectType = function (typeName) {
+        return typeName.trim().startsWith('{');
+    };
+    /**
+     * Parse JSDoc comment text to extract description.
+     * Strips JSDoc comment markers and leading asterisks.
+     *
+     * @example
+     * ```typescript
+     * parseJsDocDescription('/** Max cars to retrieve *\/')
+     * // Returns: "Max cars to retrieve"
+     *
+     * parseJsDocDescription('/**\n * Max cars to retrieve\n * from the database\n *\/')
+     * // Returns: "Max cars to retrieve from the database"
+     *
+     * parseJsDocDescription('')
+     * // Returns: ""
+     * ```
+     */
+    TypeScriptSourceParser.parseJsDocDescription = function (jsDocText) {
+        if (!jsDocText) {
+            return '';
+        }
+        // Remove /** and */ markers
+        var cleaned = jsDocText.replace(/^\/\*\*/, '').replace(/\*\/$/, '');
+        // Remove leading * from each line
+        cleaned = cleaned
+            .split('\n')
+            .map(function (line) { return line.trim().replace(/^\*\s?/, ''); })
+            .filter(function (line) { return line.length > 0; })
+            .join(' ');
+        // Collapse multiple spaces into single space
+        cleaned = cleaned.replace(/\s+/g, ' ');
+        return cleaned.trim();
+    };
+    /**
+     * Extract property metadata from an object type body.
+     * Parses properties with optional JSDoc comments.
+     * Only extracts top-level properties (not nested object properties).
+     *
+     * @param objectBody The content between { and } in an object type
+     * @returns Array of property metadata (name + description)
+     *
+     * @example
+     * ```typescript
+     * const body = `
+     *   /** Max cars to retrieve *\/
+     *   limit: string;
+     *   page?: number;
+     * `;
+     * extractPropertiesFromObjectType(body)
+     * // Returns: [
+     * //   { name: "limit", description: "Max cars to retrieve" },
+     * //   { name: "page", description: "" }
+     * // ]
+     * ```
+     */
+    TypeScriptSourceParser.extractPropertiesFromObjectType = function (objectBody) {
+        var properties = [];
+        var i = 0;
+        while (i < objectBody.length) {
+            // Skip whitespace
+            while (i < objectBody.length && /\s/.test(objectBody[i])) {
+                i++;
+            }
+            if (i >= objectBody.length)
+                break;
+            // Check for JSDoc comment
+            var jsDoc = '';
+            if (objectBody[i] === '/' && i + 1 < objectBody.length && objectBody[i + 1] === '*' && i + 2 < objectBody.length && objectBody[i + 2] === '*') {
+                var endIndex = objectBody.indexOf('*/', i + 3);
+                if (endIndex !== -1) {
+                    jsDoc = objectBody.slice(i, endIndex + 2);
+                    i = endIndex + 2;
+                }
+                else {
+                    break;
+                }
+            }
+            // Skip whitespace after JSDoc
+            while (i < objectBody.length && /\s/.test(objectBody[i])) {
+                i++;
+            }
+            if (i >= objectBody.length)
+                break;
+            // Extract property name
+            var propertyNameMatch = objectBody.slice(i).match(/^(\w+)\??:/);
+            if (!propertyNameMatch) {
+                i++;
+                continue;
+            }
+            var propertyName = propertyNameMatch[1];
+            i += propertyNameMatch[0].length;
+            // Skip the type until we hit a delimiter at top level (;, ,, or closing })
+            // Use tokenizer to properly handle strings and comments
+            var tokenizer = new TypeScriptTokenizer_1.TypeScriptTokenizer(objectBody);
+            var depth = 0;
+            while (i < objectBody.length) {
+                var token = tokenizer.getNextToken(i);
+                // Only process non-string, non-comment tokens
+                if (token.type !== 'string' && token.type !== 'comment') {
+                    var char = token.value;
+                    // Track depth for nested objects/arrays
+                    if (char === '{' || char === '[' || char === '(') {
+                        depth++;
+                    }
+                    else if (char === '}' || char === ']' || char === ')') {
+                        depth--;
+                    }
+                    // End of property at top level
+                    if (depth === 0 && (char === ';' || char === ',')) {
+                        i = token.endPos; // Move past delimiter
+                        break;
+                    }
+                    // End of property at a top-level newline when no `;`/`,`
+                    // delimiter is used (semicolon-free style, issue #77). Only
+                    // terminate when the next line starts a new member (an
+                    // identifier, quoted key, or JSDoc) - not a continuation of
+                    // the current type such as a leading `|` union arm.
+                    if (depth === 0 && (char === '\n' || char === '\r')) {
+                        var next = this.peekNextSignificantChar(objectBody, token.endPos);
+                        if (next === undefined || /[A-Za-z_$"'/]/.test(next)) {
+                            break; // Leave i at the newline; outer loop skips whitespace
+                        }
+                    }
+                }
+                i = token.endPos;
+            }
+            // Add property
+            var description = this.parseJsDocDescription(jsDoc);
+            properties.push({
+                name: propertyName,
+                description: description,
+            });
+        }
+        return properties;
+    };
+    /**
+     * Copy a type definition and recursively find all its dependencies.
+     * Returns structured data without side effects.
+     *
+     * @param sourceText Full source file text to search for types
+     * @param typeName Name of the type to copy
+     * @param newName New name for the type (use same name for dependencies)
+     * @param copiedTypes Set of already-copied type names to avoid duplication
+     * @returns Object containing the main definition, dependency definitions, and import statements
+     *
+     * @example
+     * ```typescript
+     * const source = `
+     *   import { Address } from './Address';
+     *   interface User {
+     *     profile: Profile;
+     *     address: Address;
+     *   }
+     *   interface Profile {
+     *     name: string;
+     *   }
+     * `;
+     * const result = copyTypeWithDependencies(source, 'User', 'UserSchema', new Set());
+     * // Returns: {
+     * //   mainDefinition: 'export interface UserSchema { profile: Profile; address: Address; }',
+     * //   dependencies: ['export interface Profile { name: string; }'],
+     * //   imports: ['import { Address } from "./Address"'],
+     * //   copiedTypes: Set(['User', 'Profile'])
+     * // }
+     * ```
+     */
+    TypeScriptSourceParser.copyTypeWithDependencies = function (sourceText, typeName, newName, copiedTypes) {
+        var dependencies = [];
+        var imports = [];
+        // Handle inline object types specially
+        var mainDefinition = null;
+        if (this.isInlineObjectType(typeName)) {
+            mainDefinition = this.convertInlineObjectToInterface(typeName, newName);
+        }
+        else {
+            // Find and copy the main type from file
+            var found = this.findTypeDefinition(sourceText, typeName);
+            if (found) {
+                mainDefinition = this.renameTypeDefinition(found.definition, typeName, newName);
+            }
+        }
+        if (!mainDefinition) {
+            return { mainDefinition: null, dependencies: [], imports: [], copiedTypes: copiedTypes };
+        }
+        // Mark this type as copied
+        copiedTypes.add(typeName);
+        // Find all referenced types in the definition
+        var referencedTypes = this.extractReferencedTypes(mainDefinition);
+        // Recursively copy each referenced type (if not already copied)
+        for (var _i = 0, referencedTypes_1 = referencedTypes; _i < referencedTypes_1.length; _i++) {
+            var refType = referencedTypes_1[_i];
+            if (!copiedTypes.has(refType) && !this.isBuiltInType(refType)) {
+                // Check if this type is defined in the current file
+                var typeDef = this.findTypeDefinition(sourceText, refType);
+                if (typeDef) {
+                    // Type is defined in same file - recursively copy it
+                    var result = this.copyTypeWithDependencies(sourceText, refType, refType, copiedTypes);
+                    if (result.mainDefinition) {
+                        dependencies.push(result.mainDefinition);
+                    }
+                    dependencies.push.apply(dependencies, result.dependencies);
+                    imports.push.apply(imports, result.imports);
+                }
+                else {
+                    // Type is not in current file - must be imported
+                    // Extract the import statement for it
+                    var importStmt = this.extractImportForType(sourceText, refType);
+                    if (importStmt && !imports.includes(importStmt)) {
+                        imports.push(importStmt);
+                    }
+                    // Mark as copied to avoid trying to find it again
+                    copiedTypes.add(refType);
+                }
+            }
+        }
+        return { mainDefinition: mainDefinition, dependencies: dependencies, imports: imports, copiedTypes: copiedTypes };
+    };
+    /**
+     * Extract import statement for a specific type from source text.
+     *
+     * @param sourceText Full source file text
+     * @param typeName Name of the type to find import for
+     * @returns Import statement or null if not found
+     *
+     * @example
+     * ```typescript
+     * const source = `
+     *   import { User } from '../schemas/User';
+     *   import type { Profile } from '../schemas/Profile';
+     *   import Foo from '../schemas/Foo';
+     * `;
+     * extractImportForType(source, 'User')
+     * // Returns: "import { User } from '../schemas/User'"
+     *
+     * extractImportForType(source, 'Profile')
+     * // Returns: "import type { Profile } from '../schemas/Profile'"
+     *
+     * extractImportForType(source, 'Foo')
+     * // Returns: "import Foo from '../schemas/Foo'"
+     * ```
+     */
+    TypeScriptSourceParser.extractImportForType = function (sourceText, typeName) {
+        // Supports: import Foo from '...'  OR  import { Foo } from '...'
+        // Also supports: import type Foo from '...'  OR  import type { Foo } from '...'
+        var importRegex = new RegExp("import\\s+(?:type\\s+)?(?:{[^}]*\\b".concat(typeName, "\\b[^}]*}|").concat(typeName, ")\\s+from\\s+(['\"][^'\"]+['\"])"), 'gm');
+        var match = importRegex.exec(sourceText);
+        if (match) {
+            return match[0];
+        }
+        return null;
+    };
+    /**
+     * Extract all imports from a source file.
+     * Used to get transitive dependencies when importing a type.
+     *
+     * @param sourceText Source code to extract imports from
+     * @returns Array of import statements
+     */
+    TypeScriptSourceParser.extractAllImports = function (sourceText) {
+        var imports = [];
+        // Match all import statements (including type imports, named imports, default imports, namespace imports)
+        var importRegex = /import\s+(?:type\s+)?(?:{[^}]+}|\w+|(?:\*\s+as\s+\w+))\s+from\s+['"][^'"]+['"]/gm;
+        var match;
+        while ((match = importRegex.exec(sourceText)) !== null) {
+            imports.push(match[0]);
+        }
+        return imports;
+    };
+    /**
+     * Adjust import path to be relative to .flink/schemas/ directory.
+     *
+     * @param importStatement Original import statement
+     * @returns Adjusted import statement with corrected path
+     *
+     * @example
+     * ```typescript
+     * adjustImportPathForSchemas('import { User } from "../schemas/User"')
+     * // Returns: 'import { User } from "../../src/schemas/User"'
+     *
+     * adjustImportPathForSchemas('import Profile from "../../schemas/Profile"')
+     * // Returns: 'import Profile from "../../src/schemas/Profile"'
+     *
+     * adjustImportPathForSchemas('import { Req } from "../clients/SupermetricsClient"')
+     * // Returns: 'import { Req } from "../../src/clients/SupermetricsClient"'
+     *
+     * adjustImportPathForSchemas('import { Foo } from "@company/shared"')
+     * // Returns: 'import { Foo } from "@company/shared"' (unchanged - not relative)
+     * ```
+     */
+    TypeScriptSourceParser.adjustImportPathForSchemas = function (importStatement) {
+        // schemas.ts is at: .flink/schemas/schemas.ts
+        // Handler imports can be from anywhere in src/ (handlers, schemas, clients, etc.)
+        // We need to adjust ALL relative imports to work from .flink/schemas/
+        // Extract the path from import statement
+        var pathMatch = importStatement.match(/from\s+(['"])([^'"]+)['"]/);
+        if (!pathMatch) {
+            return importStatement;
+        }
+        var quote = pathMatch[1];
+        var importPath = pathMatch[2];
+        // Skip non-relative imports (package imports like "@company/shared", "lodash")
+        if (!importPath.startsWith('./') && !importPath.startsWith('../')) {
+            return importStatement;
+        }
+        // For relative imports, we need to adjust the path to work from .flink/schemas/
+        // Original: from handler at src/handlers/foo/Bar.ts importing "../clients/Client"
+        // Resolves to: src/clients/Client
+        // From schemas.ts at .flink/schemas/schemas.ts, we need: "../../src/clients/Client"
+        // Extract the path after src/ directory
+        // Patterns we handle:
+        // - "../schemas/User" → "../../src/schemas/User"
+        // - "../../schemas/User" → "../../src/schemas/User"
+        // - "../clients/Client" → "../../src/clients/Client"
+        // - "../../types/Foo" → "../../src/types/Foo"
+        // Find the src directory marker in the path
+        var adjustedPath;
+        if (importPath.includes('/schemas/')) {
+            // Special case for schemas - extract everything after '/schemas/'
+            var schemasIndex = importPath.indexOf('/schemas/');
+            var pathAfterSchemas = importPath.substring(schemasIndex + '/schemas/'.length);
+            adjustedPath = "../../src/schemas/".concat(pathAfterSchemas);
+        }
+        else {
+            // General case: assume the import resolves to src/<something>
+            // Count the number of "../" to understand directory depth, then reconstruct
+            // For simplicity, we'll assume all imports from handlers resolve to src/*
+            // Pattern: any number of "../" optionally followed by "./" followed by a directory path
+            // Strip both "../" and "./" prefixes
+            var pathWithoutLeadingDots = importPath.replace(/^(\.\.\/)*/, '').replace(/^\.\//, '');
+            adjustedPath = "../../src/".concat(pathWithoutLeadingDots);
+        }
+        return importStatement.replace("from ".concat(quote).concat(importPath).concat(quote), "from ".concat(quote).concat(adjustedPath).concat(quote));
+    };
+    /**
+     * Extract property metadata from a named type definition.
+     * Searches for the type definition and parses its properties.
+     *
+     * @param sourceText Full source file text
+     * @param typeName Name of the type to extract properties from
+     * @returns Array of property metadata, or null if type not found
+     *
+     * @example
+     * ```typescript
+     * const source = `
+     *   interface Query {
+     *     /** Max items *\/
+     *     limit: string;
+     *     page?: number;
+     *   }
+     * `;
+     * extractPropertyMetadata(source, 'Query')
+     * // Returns: [
+     * //   { name: "limit", description: "Max items" },
+     * //   { name: "page", description: "" }
+     * // ]
+     * ```
+     */
+    TypeScriptSourceParser.extractPropertyMetadata = function (sourceText, typeName) {
+        // Find the type definition
+        var typeDef = this.findTypeDefinition(sourceText, typeName);
+        if (!typeDef) {
+            return null;
+        }
+        // Extract the object body (content between { and })
+        var definition = typeDef.definition;
+        // Find the opening brace
+        var openBraceIndex = definition.indexOf('{');
+        if (openBraceIndex === -1) {
+            return null;
+        }
+        // Use tokenizer to find the matching closing brace (handles strings and comments)
+        var tokenizer = new TypeScriptTokenizer_1.TypeScriptTokenizer(definition);
+        var closeBraceIndex = tokenizer.findMatchingBracketAt(openBraceIndex, '{');
+        if (closeBraceIndex === -1) {
+            return null;
+        }
+        // Extract the object body (excluding the outer braces)
+        var objectBody = definition.slice(openBraceIndex + 1, closeBraceIndex);
+        return this.extractPropertiesFromObjectType(objectBody);
+    };
+    /**
+     * Consolidates duplicate imports from the same module.
+     * Merges named imports and preserves default imports.
+     *
+     * @param imports Array of import statements
+     * @returns Consolidated import statements with duplicates merged
+     *
+     * @example
+     * ```typescript
+     * const imports = [
+     *   'import { Ad } from "../../src/schemas/Ad"',
+     *   'import { AdStatus } from "../../src/schemas/Ad"',
+     *   'import { User } from "../../src/schemas/User"'
+     * ];
+     * consolidateImports(imports)
+     * // Returns: [
+     * //   'import { Ad, AdStatus } from "../../src/schemas/Ad"',
+     * //   'import { User } from "../../src/schemas/User"'
+     * // ]
+     * ```
+     */
+    TypeScriptSourceParser.consolidateImports = function (imports) {
+        // Map: module path -> { namedImports: Set<string>, defaultImport?: string }
+        var importMap = new Map();
+        var _loop_1 = function (importStmt) {
+            // Parse import statement to extract module path and imports
+            // Patterns:
+            //   - import { Foo, Bar } from "path"
+            //   - import type { Foo, Bar } from "path"
+            //   - import Foo from "path"
+            //   - import type Foo from "path"
+            var namedMatch = importStmt.match(/import\s+(?:type\s+)?\{([^}]+)\}\s+from\s+(['"])([^'"]+)['"]/);
+            var defaultMatch = importStmt.match(/import\s+(?:type\s+)?(\w+)\s+from\s+(['"])([^'"]+)['"]/);
+            if (namedMatch) {
+                var namedImports = namedMatch[1]
+                    .split(',')
+                    .map(function (s) { return s.trim(); })
+                    .filter(function (s) { return s.length > 0; });
+                var modulePath = namedMatch[3];
+                if (!importMap.has(modulePath)) {
+                    importMap.set(modulePath, { namedImports: new Set() });
+                }
+                var entry_1 = importMap.get(modulePath);
+                namedImports.forEach(function (name) { return entry_1.namedImports.add(name); });
+            }
+            else if (defaultMatch) {
+                var defaultImport = defaultMatch[1];
+                var modulePath = defaultMatch[3];
+                if (!importMap.has(modulePath)) {
+                    importMap.set(modulePath, { namedImports: new Set() });
+                }
+                var entry = importMap.get(modulePath);
+                entry.defaultImport = defaultImport;
+            }
+        };
+        for (var _i = 0, imports_1 = imports; _i < imports_1.length; _i++) {
+            var importStmt = imports_1[_i];
+            _loop_1(importStmt);
+        }
+        // Generate consolidated import statements
+        var consolidated = [];
+        var entries = Array.from(importMap.entries());
+        for (var _a = 0, entries_1 = entries; _a < entries_1.length; _a++) {
+            var _b = entries_1[_a], modulePath = _b[0], _c = _b[1], namedImports = _c.namedImports, defaultImport = _c.defaultImport;
+            if (defaultImport && namedImports.size > 0) {
+                // Both default and named imports
+                var named = Array.from(namedImports).sort().join(', ');
+                consolidated.push("import ".concat(defaultImport, ", { ").concat(named, " } from \"").concat(modulePath, "\""));
+            }
+            else if (defaultImport) {
+                // Default import only
+                consolidated.push("import ".concat(defaultImport, " from \"").concat(modulePath, "\""));
+            }
+            else if (namedImports.size > 0) {
+                // Named imports only
+                var named = Array.from(namedImports).sort().join(', ');
+                consolidated.push("import { ".concat(named, " } from \"").concat(modulePath, "\""));
+            }
+        }
+        return consolidated;
+    };
+    return TypeScriptSourceParser;
+}());
+exports.TypeScriptSourceParser = TypeScriptSourceParser;