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

package/spec/mock-project/dist/src/utils.js

@@ -0,0 +1,290 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlersPath = handlersPath;
+exports.schemasPath = schemasPath;
+exports.isRouteMatch = isRouteMatch;
+exports.isError = isError;
+exports.getHandlerFiles = getHandlerFiles;
+exports.getSchemaFiles = getSchemaFiles;
+exports.getCollectionNameForRepo = getCollectionNameForRepo;
+exports.getRepoInstanceName = getRepoInstanceName;
+exports.toKebabCase = toKebabCase;
+exports.toSnakeCase = toSnakeCase;
+exports.getHttpMethodFromHandlerName = getHttpMethodFromHandlerName;
+exports.getJsDocComment = getJsDocComment;
+exports.getPathParams = getPathParams;
+exports.getDataAtPath = getDataAtPath;
+exports.formatValidationErrors = formatValidationErrors;
+exports.generateShortId = generateShortId;
+var path_1 = require("path");
+var tiny_glob_1 = __importDefault(require("tiny-glob"));
+var FlinkHttpHandler_1 = require("./FlinkHttpHandler");
+var FlinkLog_1 = require("./FlinkLog");
+function handlersPath(appRoot) {
+    return (0, path_1.join)(appRoot, "src", "handlers");
+}
+function schemasPath(appRoot) {
+    return (0, path_1.join)(appRoot, "src", "schemas");
+}
+function isRouteMatch(req, routes) {
+    var match = routes.find(function (_a) {
+        var method = _a.method, path = _a.path;
+        var sameMethod = req.method.toLowerCase() === method;
+        var samePath = req.route.path === path;
+        return sameMethod && samePath;
+    });
+    return !!match;
+}
+function isError(message) {
+    return message.status && message.status > 399;
+}
+function getHandlerFiles(appRoot) {
+    return __awaiter(this, void 0, void 0, function () {
+        var err_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, (0, tiny_glob_1.default)("**/*.ts", {
+                            cwd: handlersPath(appRoot),
+                            absolute: true,
+                        })];
+                case 1: return [2 /*return*/, _a.sent()];
+                case 2:
+                    err_1 = _a.sent();
+                    FlinkLog_1.log.debug("Failed getting handler files: ".concat(err_1));
+                    return [2 /*return*/, []];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function getSchemaFiles(appRoot) {
+    return __awaiter(this, void 0, void 0, function () {
+        var err_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, (0, tiny_glob_1.default)("**/*.ts", {
+                            cwd: schemasPath(appRoot),
+                            absolute: true,
+                        })];
+                case 1: return [2 /*return*/, _a.sent()];
+                case 2:
+                    err_2 = _a.sent();
+                    return [2 /*return*/, []];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function getCollectionNameForRepo(repoFilename) {
+    return repoFilename.replace("Repo.ts", "").toLowerCase();
+}
+function getRepoInstanceName(fn) {
+    var name = fn.split(".ts")[0];
+    return name.charAt(0).toLowerCase() + name.substr(1);
+}
+/**
+ * Convert PascalCase or camelCase to kebab-case
+ *
+ * Examples:
+ * - FooBarBaz → foo-bar-baz
+ * - CarAgent → car-agent
+ * - APIAgent → api-agent
+ * - HTMLParser → html-parser
+ * - IOManager → io-manager
+ *
+ * Handles:
+ * - Single uppercase followed by lowercase: CarAgent → car-agent
+ * - Multiple consecutive uppercase: APIAgent → api-agent
+ * - All caps: HTML → html
+ */
+function toKebabCase(str) {
+    return str
+        // Insert hyphen before uppercase letters that follow lowercase letters
+        // CarAgent → Car-Agent
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        // Insert hyphen before uppercase letter that follows uppercase and precedes lowercase
+        // APIAgent → API-Agent
+        .replace(/([A-Z])([A-Z][a-z])/g, "$1-$2")
+        // Convert to lowercase
+        .toLowerCase();
+}
+/**
+ * Convert kebab-case to snake_case
+ *
+ * Examples:
+ * - car-agent → car_agent
+ * - api-agent → api_agent
+ * - html-parser → html_parser
+ */
+function toSnakeCase(str) {
+    return str.replace(/-/g, "_");
+}
+/**
+ * Get http method from props or convention based on file name
+ * if it starts with i.e "GetFoo"
+ */
+function getHttpMethodFromHandlerName(handlerFilename) {
+    if (handlerFilename.includes(path_1.sep)) {
+        var split = handlerFilename.split(path_1.sep);
+        handlerFilename = split[split.length - 1];
+    }
+    handlerFilename = handlerFilename.toLocaleLowerCase();
+    if (handlerFilename.startsWith(FlinkHttpHandler_1.HttpMethod.get))
+        return FlinkHttpHandler_1.HttpMethod.get;
+    if (handlerFilename.startsWith(FlinkHttpHandler_1.HttpMethod.post))
+        return FlinkHttpHandler_1.HttpMethod.post;
+    if (handlerFilename.startsWith(FlinkHttpHandler_1.HttpMethod.put))
+        return FlinkHttpHandler_1.HttpMethod.put;
+    if (handlerFilename.startsWith(FlinkHttpHandler_1.HttpMethod.delete))
+        return FlinkHttpHandler_1.HttpMethod.delete;
+    if (handlerFilename.startsWith(FlinkHttpHandler_1.HttpMethod.patch))
+        return FlinkHttpHandler_1.HttpMethod.patch;
+}
+function getJsDocComment(comment) {
+    var rows = comment.split("\n").map(function (line) {
+        line = line.trim();
+        if (line.startsWith("//")) {
+            return line.replace("//", line).trim();
+        }
+        return line.replace(/\/\*\*|\*\/|\*/, "").trim();
+    });
+    return rows.join("\n").trim();
+}
+var pathParamsRegex = /:([a-zA-Z0-9]+)/g;
+/**
+ * Returns array of path params from path string.
+ * For example `/user/:id` will return `["id"]`
+ * @param path
+ * @returns
+ */
+function getPathParams(path) {
+    var _a;
+    return ((_a = path.match(pathParamsRegex)) === null || _a === void 0 ? void 0 : _a.map(function (match) { return match.slice(1); })) || [];
+}
+/**
+ * Extracts data at a given JSON path (e.g., "/jobs/5/result")
+ * Returns the value at that path, or undefined if not found
+ */
+function getDataAtPath(data, instancePath) {
+    if (!instancePath || instancePath === "/") {
+        return data;
+    }
+    var parts = instancePath.split("/").filter(function (p) { return p.length > 0; });
+    var current = data;
+    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+        var part = parts_1[_i];
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Formats validation errors with context about the problematic data
+ * @param errors AJV validation errors
+ * @param data The full data object that failed validation
+ * @param maxDataLength Maximum length of data to show (default 500)
+ */
+function formatValidationErrors(errors, data, maxDataLength) {
+    if (maxDataLength === void 0) { maxDataLength = 500; }
+    if (!errors || errors.length === 0) {
+        return "Unknown validation error";
+    }
+    var formatted = [];
+    // Group errors by instance path to avoid repetition
+    var errorsByPath = new Map();
+    for (var _i = 0, errors_1 = errors; _i < errors_1.length; _i++) {
+        var error = errors_1[_i];
+        var path = error.instancePath || "/";
+        if (!errorsByPath.has(path)) {
+            errorsByPath.set(path, []);
+        }
+        errorsByPath.get(path).push(error);
+    }
+    errorsByPath.forEach(function (pathErrors, path) {
+        var dataAtPath = getDataAtPath(data, path);
+        var dataStr = JSON.stringify(dataAtPath);
+        // Truncate if too long
+        if (dataStr.length > maxDataLength) {
+            dataStr = dataStr.substring(0, maxDataLength) + "... (truncated)";
+        }
+        formatted.push("\nPath: ".concat(path));
+        formatted.push("Data: ".concat(dataStr));
+        formatted.push("Errors:");
+        for (var _i = 0, pathErrors_1 = pathErrors; _i < pathErrors_1.length; _i++) {
+            var error = pathErrors_1[_i];
+            if (error.keyword === "required") {
+                formatted.push("  - Missing required property: ".concat(error.params.missingProperty));
+            }
+            else if (error.keyword === "type") {
+                formatted.push("  - Invalid type at ".concat(error.schemaPath, ": expected ").concat(error.params.type, ", got ").concat(typeof dataAtPath));
+            }
+            else if (error.keyword === "additionalProperties") {
+                formatted.push("  - Additional property not allowed: ".concat(error.params.additionalProperty));
+            }
+            else if (error.keyword === "anyOf" || error.keyword === "oneOf") {
+                formatted.push("  - ".concat(error.message));
+            }
+            else {
+                formatted.push("  - ".concat(error.message, " (").concat(error.keyword, ")"));
+            }
+        }
+    });
+    return formatted.join("\n");
+}
+/**
+ * Generate a short random ID for nested conversations
+ * Format: 8 character alphanumeric string (e.g., "a3b7c9d2")
+ */
+function generateShortId() {
+    var chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+    var result = "";
+    for (var i = 0; i < 8; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}

package/spec/mock-project/tsconfig.json

@@ -15,7 +15,12 @@
     "noEmit": true,
     "experimentalDecorators": true,
     "checkJs": false,
-    "typeRoots": ["node_modules/@types", "node_modules/@flink-app"]
+    "typeRoots": ["node_modules/@types", "node_modules/@flink-app"],
+    "baseUrl": ".",
+    "paths": {
+      "@flink-app/flink": ["../../src/index.ts"],
+      "@flink-app/flink/*": ["../../src/*"]
+    }
   },
   "include": ["./src/**/*.ts", "./.flink/**/*.ts"],
   "exclude": ["./node_modules/*"]

package/spec/testHelpers.ts

@@ -0,0 +1,49 @@
+import { LLMAdapter, LLMStreamChunk } from "../src/ai/LLMAdapter";
+
+/**
+ * Mock response data for tests
+ */
+export interface MockLLMResponse {
+    textContent?: string;
+    toolCalls: Array<{ id: string; name: string; input: any }>;
+    usage: { inputTokens: number; outputTokens: number };
+    stopReason: "end_turn" | "tool_use" | "max_tokens";
+}
+
+/**
+ * Helper to create a streaming mock LLM adapter from responses.
+ * LLM adapters are streaming-only, so this creates a mock stream() implementation.
+ *
+ * @param responses Array of responses to return on subsequent calls
+ * @returns LLMAdapter with stream method implemented
+ */
+export function createStreamingMock(responses: MockLLMResponse[]): LLMAdapter {
+    let callIndex = 0;
+
+    const streamGenerator = async function* () {
+        const response = responses[callIndex] || responses[responses.length - 1];
+        callIndex++;
+
+        // Yield text content if present
+        if (response.textContent) {
+            yield { type: "text", delta: response.textContent } as LLMStreamChunk;
+        }
+
+        // Yield tool calls if present
+        if (response.toolCalls && response.toolCalls.length > 0) {
+            for (const toolCall of response.toolCalls) {
+                yield { type: "tool_call", toolCall } as LLMStreamChunk;
+            }
+        }
+
+        // Yield usage information
+        yield { type: "usage", usage: response.usage } as LLMStreamChunk;
+
+        // Yield done event
+        yield { type: "done", stopReason: response.stopReason } as LLMStreamChunk;
+    };
+
+    return {
+        stream: jasmine.createSpy("stream").and.callFake(streamGenerator),
+    };
+}

package/spec/utils.caseConversion.spec.ts

@@ -0,0 +1,80 @@
+import { toKebabCase, toSnakeCase } from "../src/utils";
+
+describe("Case Conversion Utilities", () => {
+    describe("toKebabCase", () => {
+        it("should handle standard PascalCase", () => {
+            expect(toKebabCase("CarAgent")).toBe("car-agent");
+            expect(toKebabCase("FooBarBaz")).toBe("foo-bar-baz");
+            expect(toKebabCase("CarPricingAgent")).toBe("car-pricing-agent");
+        });
+
+        it("should handle consecutive capitals (acronyms)", () => {
+            expect(toKebabCase("APIAgent")).toBe("api-agent");
+            expect(toKebabCase("HTMLParser")).toBe("html-parser");
+            expect(toKebabCase("XMLHttpRequest")).toBe("xml-http-request");
+            expect(toKebabCase("IOManager")).toBe("io-manager");
+        });
+
+        it("should handle camelCase with acronyms", () => {
+            expect(toKebabCase("getHTMLContent")).toBe("get-html-content");
+            expect(toKebabCase("parseJSONData")).toBe("parse-json-data");
+        });
+
+        it("should handle single and double letter strings", () => {
+            expect(toKebabCase("A")).toBe("a");
+            expect(toKebabCase("AB")).toBe("ab");
+            expect(toKebabCase("ABC")).toBe("abc");
+        });
+
+        it("should handle already lowercase strings", () => {
+            expect(toKebabCase("a")).toBe("a");
+            expect(toKebabCase("abc")).toBe("abc");
+        });
+
+        it("should handle camelCase starting with lowercase", () => {
+            expect(toKebabCase("aB")).toBe("a-b");
+            expect(toKebabCase("carAgent")).toBe("car-agent");
+        });
+
+        it("should handle real-world agent class names", () => {
+            expect(toKebabCase("OrchestratorAgent")).toBe("orchestrator-agent");
+            expect(toKebabCase("CarRecommendationAgent")).toBe("car-recommendation-agent");
+            expect(toKebabCase("UserAuthenticationAgent")).toBe("user-authentication-agent");
+        });
+    });
+
+    describe("toSnakeCase", () => {
+        it("should convert kebab-case to snake_case", () => {
+            expect(toSnakeCase("car-agent")).toBe("car_agent");
+            expect(toSnakeCase("foo-bar-baz")).toBe("foo_bar_baz");
+            expect(toSnakeCase("api-agent")).toBe("api_agent");
+        });
+
+        it("should handle single words", () => {
+            expect(toSnakeCase("car")).toBe("car");
+            expect(toSnakeCase("a")).toBe("a");
+        });
+
+        it("should handle multiple hyphens", () => {
+            expect(toSnakeCase("xml-http-request")).toBe("xml_http_request");
+            expect(toSnakeCase("car-pricing-agent")).toBe("car_pricing_agent");
+        });
+
+        it("should convert agent IDs to tool names correctly", () => {
+            // Simulating the full conversion pipeline
+            const agentClass = "CarAgent";
+            const kebab = toKebabCase(agentClass);
+            const toolName = `ask_${toSnakeCase(kebab)}`;
+
+            expect(toolName).toBe("ask_car_agent");
+        });
+
+        it("should handle acronym-based agent names", () => {
+            const agentClass = "APIAgent";
+            const kebab = toKebabCase(agentClass);
+            const toolName = `ask_${toSnakeCase(kebab)}`;
+
+            expect(toolName).toBe("ask_api_agent");
+        });
+    });
+});

package/spec/utils.spec.ts

@@ -48,9 +48,9 @@ describe("Utils", () => {
 
             const formatted = formatValidationErrors(errors, data);
 
-            expect(formatted).toContain('Path: /name');
-            expect(formatted).toContain('Data: 123');
-            expect(formatted).toContain('expected string');
+            expect(formatted).toContain("Path: /name");
+            expect(formatted).toContain("Data: 123");
+            expect(formatted).toContain("expected string");
         });
 
         it("should format missing required property errors", () => {
@@ -67,9 +67,9 @@ describe("Utils", () => {
 
             const formatted = formatValidationErrors(errors, data);
 
-            expect(formatted).toContain('Path: /user');
+            expect(formatted).toContain("Path: /user");
             expect(formatted).toContain('Data: {"name":"John"}');
-            expect(formatted).toContain('Missing required property: email');
+            expect(formatted).toContain("Missing required property: email");
         });
 
         it("should format errors for array items", () => {
@@ -95,9 +95,9 @@ describe("Utils", () => {
 
             const formatted = formatValidationErrors(errors, data);
 
-            expect(formatted).toContain('Path: /jobs/5/result');
+            expect(formatted).toContain("Path: /jobs/5/result");
             expect(formatted).toContain('Data: {"seed":"wrong-type"}');
-            expect(formatted).toContain('must match a schema in anyOf');
+            expect(formatted).toContain("must match a schema in anyOf");
         });
 
         it("should truncate very long data", () => {
@@ -115,7 +115,7 @@ describe("Utils", () => {
 
             const formatted = formatValidationErrors(errors, data, 100);
 
-            expect(formatted).toContain('(truncated)');
+            expect(formatted).toContain("(truncated)");
             expect(formatted.length).toBeLessThan(500);
         });
 
@@ -145,8 +145,8 @@ describe("Utils", () => {
             expect(pathCount).toBe(1);
 
             // But should list both missing properties
-            expect(formatted).toContain('Missing required property: email');
-            expect(formatted).toContain('Missing required property: age');
+            expect(formatted).toContain("Missing required property: email");
+            expect(formatted).toContain("Missing required property: age");
         });
 
         it("should show specific additional property names", () => {
@@ -171,9 +171,9 @@ describe("Utils", () => {
             const formatted = formatValidationErrors(errors, data);
 
             // This formatted output is used in HTTP error responses (400/500) in the error.detail field
-            expect(formatted).toContain('Path: /');
-            expect(formatted).toContain('Additional property not allowed: extraField1');
-            expect(formatted).toContain('Additional property not allowed: extraField2');
+            expect(formatted).toContain("Path: /");
+            expect(formatted).toContain("Additional property not allowed: extraField1");
+            expect(formatted).toContain("Additional property not allowed: extraField2");
         });
     });
 });