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

package/dist/src/schema-extraction/TypeScriptSourceParser.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var TypeScriptSourceParser_1 = require("./TypeScriptSourceParser");
+describe("TypeScriptSourceParser", function () {
+    describe("detectSchemaType", function () {
+        it("should detect Zod schemas", function () {
+            var source = "\n                export const Tool: FlinkToolProps = {\n                    inputSchema: z.object({ name: z.string() })\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.detectSchemaType(source);
+            expect(result.hasZodSchemas).toBe(true);
+            expect(result.shouldSkipTypeScriptExtraction).toBe(true);
+        });
+        it("should detect JSON schemas", function () {
+            var source = "\n                export const Tool: FlinkToolProps = {\n                    inputJsonSchema: { type: \"object\" }\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.detectSchemaType(source);
+            expect(result.hasJsonSchemas).toBe(true);
+            expect(result.shouldSkipTypeScriptExtraction).toBe(true);
+        });
+        it("should detect neither for TypeScript-only tools", function () {
+            var source = "\n                const handler: FlinkTool<Ctx, Input, Output> = async () => {};\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.detectSchemaType(source);
+            expect(result.hasZodSchemas).toBe(false);
+            expect(result.hasJsonSchemas).toBe(false);
+            expect(result.shouldSkipTypeScriptExtraction).toBe(false);
+        });
+    });
+    describe("parseFlinkToolTypeArgs", function () {
+        it("should extract type arguments from FlinkTool declaration", function () {
+            var source = "const handler: FlinkTool<Ctx, CreateDocInput, ToolResult<DocOutput>> = async () => {};";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.parseFlinkToolTypeArgs(source);
+            expect(result).toEqual({
+                contextType: "Ctx",
+                inputType: "CreateDocInput",
+                outputType: "ToolResult<DocOutput>",
+            });
+        });
+        it("should handle inline object types", function () {
+            var source = "const handler: FlinkTool<Ctx, { foo: string }, ToolResult<Output>> = async () => {};";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.parseFlinkToolTypeArgs(source);
+            expect(result === null || result === void 0 ? void 0 : result.inputType).toBe("{ foo: string }");
+        });
+        it("should handle empty object input", function () {
+            var source = "const handler: FlinkTool<Ctx, {}, ToolResult<Output>> = async () => {};";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.parseFlinkToolTypeArgs(source);
+            expect(result === null || result === void 0 ? void 0 : result.inputType).toBe("{}");
+        });
+        it("should return null if no FlinkTool found", function () {
+            var source = "const handler = async () => {};";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.parseFlinkToolTypeArgs(source);
+            expect(result).toBeNull();
+        });
+        it("should handle whitespace variations", function () {
+            var source = "const handler: FlinkTool<Ctx,Input,Output> = async () => {};";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.parseFlinkToolTypeArgs(source);
+            expect(result).toEqual({
+                contextType: "Ctx",
+                inputType: "Input",
+                outputType: "Output",
+            });
+        });
+    });
+    describe("shouldGenerateSchema", function () {
+        it("should return false for 'any'", function () {
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.shouldGenerateSchema("any")).toBe(false);
+        });
+        it("should return false for primitives", function () {
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.shouldGenerateSchema("string")).toBe(false);
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.shouldGenerateSchema("number")).toBe(false);
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.shouldGenerateSchema("boolean")).toBe(false);
+        });
+        it("should return true for inline objects", function () {
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.shouldGenerateSchema("{}")).toBe(true);
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.shouldGenerateSchema("{ foo: string }")).toBe(true);
+        });
+        it("should return true for named types", function () {
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.shouldGenerateSchema("User")).toBe(true);
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.shouldGenerateSchema("CreateDocInput")).toBe(true);
+        });
+    });
+    describe("unwrapToolResultType", function () {
+        it("should extract type from ToolResult<T>", function () {
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.unwrapToolResultType("ToolResult<DocOutput>")).toBe("DocOutput");
+        });
+        it("should handle complex generic types", function () {
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.unwrapToolResultType("ToolResult<Array<Doc>>")).toBe("Array<Doc>");
+        });
+        it("should return as-is if not ToolResult", function () {
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.unwrapToolResultType("DocOutput")).toBe("DocOutput");
+        });
+    });
+    describe("convertInlineObjectToInterface", function () {
+        it("should convert empty object", function () {
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.convertInlineObjectToInterface("{}", "MyInput");
+            expect(result).toBe("export interface MyInput {}");
+        });
+        it("should convert single property", function () {
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.convertInlineObjectToInterface("{ foo: string }", "MyInput");
+            expect(result).toContain("export interface MyInput");
+            expect(result).toContain("foo: string;");
+        });
+        it("should convert multiple properties", function () {
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.convertInlineObjectToInterface("{ foo: string; bar: number }", "MyInput");
+            expect(result).toContain("export interface MyInput");
+            expect(result).toContain("foo: string;");
+            expect(result).toContain("bar: number;");
+        });
+        it("should handle properties with commas", function () {
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.convertInlineObjectToInterface("{ foo: string, bar: number }", "MyInput");
+            expect(result).toContain("foo: string");
+            expect(result).toContain("bar: number");
+        });
+    });
+    describe("findTypeDefinition", function () {
+        it("should find interface definitions", function () {
+            var source = "\n                interface User {\n                    name: string;\n                    age: number;\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.findTypeDefinition(source, "User");
+            expect(result).not.toBeNull();
+            expect(result === null || result === void 0 ? void 0 : result.kind).toBe("interface");
+            expect(result === null || result === void 0 ? void 0 : result.name).toBe("User");
+            expect(result === null || result === void 0 ? void 0 : result.definition).toContain("interface User");
+        });
+        it("should find type alias definitions", function () {
+            var source = "\n                type UserId = string;\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.findTypeDefinition(source, "UserId");
+            expect(result).not.toBeNull();
+            expect(result === null || result === void 0 ? void 0 : result.kind).toBe("type");
+            expect(result === null || result === void 0 ? void 0 : result.name).toBe("UserId");
+        });
+        it("should find interfaces with JSDoc", function () {
+            var source = "\n                /**\n                 * User model\n                 */\n                interface User {\n                    name: string;\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.findTypeDefinition(source, "User");
+            expect(result).not.toBeNull();
+            expect(result === null || result === void 0 ? void 0 : result.definition).toContain("/**");
+        });
+        it("should return null for non-existent types", function () {
+            var source = "interface User { name: string; }";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.findTypeDefinition(source, "NonExistent");
+            expect(result).toBeNull();
+        });
+        it("should handle interfaces with generics", function () {
+            var source = "\n                interface List<T> {\n                    items: T[];\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.findTypeDefinition(source, "List");
+            expect(result).not.toBeNull();
+            expect(result === null || result === void 0 ? void 0 : result.definition).toContain("interface List<T>");
+        });
+        it("should handle interfaces with extends", function () {
+            var source = "\n                interface Admin extends User {\n                    role: string;\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.findTypeDefinition(source, "Admin");
+            expect(result).not.toBeNull();
+            expect(result === null || result === void 0 ? void 0 : result.definition).toContain("extends User");
+        });
+    });
+    describe("renameTypeDefinition", function () {
+        it("should rename interface", function () {
+            var def = "interface User { name: string; }";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.renameTypeDefinition(def, "User", "Person");
+            expect(result).toBe("export interface Person { name: string; }");
+        });
+        it("should rename type alias", function () {
+            var def = "type UserId = string;";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.renameTypeDefinition(def, "UserId", "PersonId");
+            expect(result).toBe("export type PersonId = string;");
+        });
+        it("should not export if exportIt is false", function () {
+            var def = "interface User { name: string; }";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.renameTypeDefinition(def, "User", "Person", false);
+            expect(result).toBe("interface Person { name: string; }");
+        });
+    });
+    describe("extractReferencedTypes", function () {
+        it("should extract type references from interface", function () {
+            var def = "\n                interface Document {\n                    author: User;\n                    tags: Tag[];\n                    metadata: Metadata;\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.extractReferencedTypes(def);
+            expect(result).toContain("User");
+            expect(result).toContain("Tag");
+            expect(result).toContain("Metadata");
+        });
+        it("should not extract built-in types", function () {
+            var def = "\n                interface Doc {\n                    title: string;\n                    count: number;\n                    date: Date;\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.extractReferencedTypes(def);
+            expect(result).not.toContain("Date");
+            expect(result.length).toBe(0);
+        });
+        it("should not extract types from JSDoc comments", function () {
+            var def = "\n                /**\n                 * Title for the document\n                 * Optional user info\n                 */\n                interface Doc {\n                    title: string;\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.extractReferencedTypes(def);
+            expect(result).not.toContain("Title");
+            expect(result).not.toContain("Optional");
+        });
+        it("should handle union types", function () {
+            var def = "\n                interface Result {\n                    data: Success | Error;\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.extractReferencedTypes(def);
+            expect(result).toContain("Success");
+            expect(result).toContain("Error");
+        });
+        it("should handle intersection types", function () {
+            var def = "\n                interface Combined {\n                    data: Base & Extra;\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.extractReferencedTypes(def);
+            expect(result).toContain("Base");
+            expect(result).toContain("Extra");
+        });
+        it("should handle Array generics", function () {
+            var def = "\n                interface List {\n                    items: Array<Item>;\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.extractReferencedTypes(def);
+            expect(result).toContain("Item");
+        });
+        it("should not include duplicates", function () {
+            var def = "\n                interface Doc {\n                    author: User;\n                    editor: User;\n                }\n            ";
+            var result = TypeScriptSourceParser_1.TypeScriptSourceParser.extractReferencedTypes(def);
+            expect(result.filter(function (t) { return t === "User"; }).length).toBe(1);
+        });
+    });
+    describe("isInlineObjectType", function () {
+        it("should return true for inline objects", function () {
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.isInlineObjectType("{}")).toBe(true);
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.isInlineObjectType("{ foo: string }")).toBe(true);
+        });
+        it("should return false for named types", function () {
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.isInlineObjectType("User")).toBe(false);
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.isInlineObjectType("CreateDocInput")).toBe(false);
+        });
+    });
+    describe("isBuiltInType", function () {
+        it("should return true for built-in types", function () {
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.isBuiltInType("String")).toBe(true);
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.isBuiltInType("Array")).toBe(true);
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.isBuiltInType("Promise")).toBe(true);
+        });
+        it("should return false for custom types", function () {
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.isBuiltInType("User")).toBe(false);
+            expect(TypeScriptSourceParser_1.TypeScriptSourceParser.isBuiltInType("CustomType")).toBe(false);
+        });
+    });
+});

package/dist/src/schema-extraction/TypeScriptTokenizer.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Simple TypeScript tokenizer for robust bracket matching.
+ *
+ * Properly handles:
+ * - String literals with all quote types
+ * - Escape sequences in strings
+ * - Line comments
+ * - Block comments
+ * - Nested brackets
+ *
+ * This prevents bracket counting errors when special characters
+ * appear inside strings or comments.
+ */
+export interface Token {
+    type: 'string' | 'comment' | 'bracket' | 'char';
+    value: string;
+    startPos: number;
+    endPos: number;
+}
+export declare class TypeScriptTokenizer {
+    private text;
+    private pos;
+    constructor(text: string);
+    /**
+     * Find matching closing bracket from current position.
+     * Properly handles strings and comments.
+     *
+     * @param openChar Opening bracket character
+     * @returns Position of matching closing bracket, or -1 if not found
+     */
+    findMatchingBracket(openChar: '{' | '<' | '(' | '['): number;
+    /**
+     * Find matching closing bracket from a specific start position.
+     */
+    findMatchingBracketAt(startPos: number, openChar: '{' | '<' | '(' | '['): number;
+    /**
+     * Get next meaningful token, properly handling strings and comments.
+     * Public for use in other parsing utilities.
+     */
+    getNextToken(startPos: number): Token;
+    /**
+     * Parse string literal, handling escape sequences.
+     */
+    private parseStringLiteral;
+    /**
+     * Parse line comment (// ... \n).
+     */
+    private parseLineComment;
+    /**
+     * Parse block comment (/* ... *\/).
+     */
+    private parseBlockComment;
+    /**
+     * Get closing bracket character for an opening bracket.
+     */
+    private getClosingBracket;
+}

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

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * Simple TypeScript tokenizer for robust bracket matching.
+ *
+ * Properly handles:
+ * - String literals with all quote types
+ * - Escape sequences in strings
+ * - Line comments
+ * - Block comments
+ * - Nested brackets
+ *
+ * This prevents bracket counting errors when special characters
+ * appear inside strings or comments.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptTokenizer = void 0;
+var TypeScriptTokenizer = /** @class */ (function () {
+    function TypeScriptTokenizer(text) {
+        this.pos = 0;
+        this.text = text;
+    }
+    /**
+     * Find matching closing bracket from current position.
+     * Properly handles strings and comments.
+     *
+     * @param openChar Opening bracket character
+     * @returns Position of matching closing bracket, or -1 if not found
+     */
+    TypeScriptTokenizer.prototype.findMatchingBracket = function (openChar) {
+        var closeChar = this.getClosingBracket(openChar);
+        var depth = 1;
+        var i = this.pos + 1;
+        while (i < this.text.length && depth > 0) {
+            var token = this.getNextToken(i);
+            // Only count brackets outside strings and comments
+            if (token.type === 'bracket') {
+                if (token.value === openChar) {
+                    depth++;
+                }
+                else if (token.value === closeChar) {
+                    depth--;
+                }
+            }
+            i = token.endPos;
+        }
+        return depth === 0 ? i - 1 : -1;
+    };
+    /**
+     * Find matching closing bracket from a specific start position.
+     */
+    TypeScriptTokenizer.prototype.findMatchingBracketAt = function (startPos, openChar) {
+        this.pos = startPos;
+        return this.findMatchingBracket(openChar);
+    };
+    /**
+     * Get next meaningful token, properly handling strings and comments.
+     * Public for use in other parsing utilities.
+     */
+    TypeScriptTokenizer.prototype.getNextToken = function (startPos) {
+        var char = this.text[startPos];
+        // String literal (single, double, or backtick quotes)
+        if (char === '"' || char === "'" || char === '`') {
+            return this.parseStringLiteral(startPos, char);
+        }
+        // Line comment
+        if (char === '/' && this.text[startPos + 1] === '/') {
+            return this.parseLineComment(startPos);
+        }
+        // Block comment
+        if (char === '/' && this.text[startPos + 1] === '*') {
+            return this.parseBlockComment(startPos);
+        }
+        // Bracket characters
+        if ('{}<>()[]'.includes(char)) {
+            return {
+                type: 'bracket',
+                value: char,
+                startPos: startPos,
+                endPos: startPos + 1,
+            };
+        }
+        // Other character (not important for bracket matching)
+        return {
+            type: 'char',
+            value: char,
+            startPos: startPos,
+            endPos: startPos + 1,
+        };
+    };
+    /**
+     * Parse string literal, handling escape sequences.
+     */
+    TypeScriptTokenizer.prototype.parseStringLiteral = function (startPos, quoteChar) {
+        var i = startPos + 1;
+        var escaped = false;
+        while (i < this.text.length) {
+            if (escaped) {
+                // Skip escaped character
+                escaped = false;
+                i++;
+                continue;
+            }
+            if (this.text[i] === '\\') {
+                // Found escape sequence
+                escaped = true;
+                i++;
+                continue;
+            }
+            if (this.text[i] === quoteChar) {
+                // Found closing quote
+                return {
+                    type: 'string',
+                    value: this.text.slice(startPos, i + 1),
+                    startPos: startPos,
+                    endPos: i + 1,
+                };
+            }
+            i++;
+        }
+        // Unclosed string - return what we have
+        // (Let TypeScript compiler handle the error)
+        return {
+            type: 'string',
+            value: this.text.slice(startPos),
+            startPos: startPos,
+            endPos: this.text.length,
+        };
+    };
+    /**
+     * Parse line comment (// ... \n).
+     */
+    TypeScriptTokenizer.prototype.parseLineComment = function (startPos) {
+        var newlinePos = this.text.indexOf('\n', startPos);
+        var endPos = newlinePos === -1 ? this.text.length : newlinePos + 1;
+        return {
+            type: 'comment',
+            value: this.text.slice(startPos, endPos),
+            startPos: startPos,
+            endPos: endPos,
+        };
+    };
+    /**
+     * Parse block comment (/* ... *\/).
+     */
+    TypeScriptTokenizer.prototype.parseBlockComment = function (startPos) {
+        var endPos = this.text.indexOf('*/', startPos + 2);
+        if (endPos === -1) {
+            // Unclosed block comment - return what we have
+            return {
+                type: 'comment',
+                value: this.text.slice(startPos),
+                startPos: startPos,
+                endPos: this.text.length,
+            };
+        }
+        return {
+            type: 'comment',
+            value: this.text.slice(startPos, endPos + 2),
+            startPos: startPos,
+            endPos: endPos + 2,
+        };
+    };
+    /**
+     * Get closing bracket character for an opening bracket.
+     */
+    TypeScriptTokenizer.prototype.getClosingBracket = function (open) {
+        var pairs = {
+            '{': '}',
+            '<': '>',
+            '(': ')',
+            '[': ']',
+        };
+        return pairs[open];
+    };
+    return TypeScriptTokenizer;
+}());
+exports.TypeScriptTokenizer = TypeScriptTokenizer;

package/dist/src/schema-extraction/index.d.ts

@@ -0,0 +1,2 @@
+export { TypeScriptSourceParser } from "./TypeScriptSourceParser";
+export * from "./types";

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

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptSourceParser = void 0;
+var TypeScriptSourceParser_1 = require("./TypeScriptSourceParser");
+Object.defineProperty(exports, "TypeScriptSourceParser", { enumerable: true, get: function () { return TypeScriptSourceParser_1.TypeScriptSourceParser; } });
+__exportStar(require("./types"), exports);

package/dist/src/schema-extraction/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Schema type detection result
+ */
+export interface SchemaTypeDetection {
+    hasZodSchemas: boolean;
+    hasJsonSchemas: boolean;
+    shouldSkipTypeScriptExtraction: boolean;
+}
+/**
+ * FlinkTool type arguments extracted from source
+ */
+export interface FlinkToolTypeArgs {
+    contextType: string;
+    inputType: string;
+    outputType: string;
+}
+/**
+ * Result of type definition search
+ */
+export interface TypeDefinition {
+    name: string;
+    definition: string;
+    kind: 'interface' | 'type';
+}
+/**
+ * Metadata for a single property (parameter or query field)
+ */
+export interface PropertyMetadata {
+    name: string;
+    description: string;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils/loadFlinkConfig.d.ts

@@ -0,0 +1,53 @@
+import { LoggingConfig } from "../FlinkLogFactory";
+/**
+ * Compiler plugin descriptor — declared in flink.config.js, consumed by the TypeScript compiler.
+ * Plugin packages export a compilerPlugin() factory that returns this shape.
+ */
+export interface FlinkCompilerPlugin {
+    /** npm package name, e.g. "@flink-app/inbound-email-plugin" */
+    package: string;
+    /** Directory to scan for handler files, e.g. "src/email-handlers" */
+    scanDir: string;
+    /** Base name for the generated .flink/generatedXxx.ts file, e.g. "generatedEmailHandlers" */
+    generatedFile: string;
+    /** Name of the singleton array exported by the plugin package, e.g. "autoRegisteredEmailHandlers" */
+    registrationVar: string;
+    /**
+     * Optional callback to confirm a file should be registered.
+     * Receives the raw file content and the absolute file path.
+     * Return true to include the file, false to skip it.
+     */
+    detectBy?: (fileContent: string, filePath: string) => boolean;
+}
+/**
+ * Flink configuration file structure
+ */
+export interface FlinkConfig {
+    logging?: LoggingConfig;
+    /** Compiler plugins that extend auto-discovery to custom directories */
+    compilerPlugins?: FlinkCompilerPlugin[];
+    /** Disable auto-discovery of services from src/services/. Default: false */
+    disableServices?: boolean;
+}
+/**
+ * Load Flink configuration from flink.config.js in current working directory
+ *
+ * @returns FlinkConfig object or undefined if not found/invalid
+ *
+ * @example
+ * ```javascript
+ * // flink.config.js
+ * module.exports = {
+ *   logging: {
+ *     global: "info",
+ *     showTimestamps: true,
+ *     components: {
+ *       "flink.ai.openai": "trace",
+ *       "flink.ai.*": "debug",
+ *       "flink.database.**": "warn"
+ *     }
+ *   }
+ * };
+ * ```
+ */
+export declare function loadFlinkConfig(cwd?: string): FlinkConfig | undefined;

package/dist/src/utils/loadFlinkConfig.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFlinkConfig = loadFlinkConfig;
+var path = __importStar(require("path"));
+var fs = __importStar(require("fs"));
+/**
+ * Load Flink configuration from flink.config.js in current working directory
+ *
+ * @returns FlinkConfig object or undefined if not found/invalid
+ *
+ * @example
+ * ```javascript
+ * // flink.config.js
+ * module.exports = {
+ *   logging: {
+ *     global: "info",
+ *     showTimestamps: true,
+ *     components: {
+ *       "flink.ai.openai": "trace",
+ *       "flink.ai.*": "debug",
+ *       "flink.database.**": "warn"
+ *     }
+ *   }
+ * };
+ * ```
+ */
+function loadFlinkConfig(cwd) {
+    try {
+        // Look for flink.config.js in current working directory (or provided cwd)
+        var configPath = path.join(cwd !== null && cwd !== void 0 ? cwd : process.cwd(), "flink.config.js");
+        // Check if file exists
+        if (!fs.existsSync(configPath)) {
+            return undefined;
+        }
+        // Load config using require (CommonJS)
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        var config = require(configPath);
+        // Validate structure
+        if (!config || typeof config !== "object") {
+            console.warn("[flink] Warning: flink.config.js exists but does not export an object");
+            return undefined;
+        }
+        // Validate logging config if present
+        if (config.logging && typeof config.logging !== "object") {
+            console.warn("[flink] Warning: flink.config.js has invalid logging config (must be object)");
+            return undefined;
+        }
+        return config;
+    }
+    catch (error) {
+        console.warn("[flink] Warning: Failed to load flink.config.js:", error);
+        return undefined;
+    }
+}