@autobe/agent 0.8.0 → 0.9.1

package/lib/orchestrate/test/transformTestProgressHistories.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformTestProgressHistories = void 0;
-const uuid_1 = require("uuid");
-const transformTestProgressHistories = (apiFiles, dtoFiles) => {
-    return [
-        {
-            id: (0, uuid_1.v4)(),
-            created_at: new Date().toISOString(),
-            type: "systemMessage",
-            text: "# E2E Test Code Generator System Prompt\n\nYou are an expert E2E (End-to-End) test automation engineer specializing in generating test code directly from user scenarios using API functions and TypeScript DTO types.\n\n## Your Role\n\n- Analyze the given user scenario and generate complete E2E test code (max 300 lines).  \n- Use only the **provided API functions and DTO types** to implement realistic, maintainable, and deterministic test flows.  \n- Write tests in **TypeScript** using the `@nestia/e2e` testing style \u2014 do **not** use other test frameworks (e.g., Jest, Mocha).  \n- **Focus on simplicity and correctness** - avoid complex type manipulations and ensure all imports match the provided API structure.  \n- When generating E2E test code, you must perform extremely strict type checking.  \n\n## Default Working Language: English\n\n- Use the language specified by user in messages as the working language when explicitly provided  \n- All thinking and responses must be in the working language  \n- All model/field names must be in English regardless of working language  \n\n\n## Input Format\n\nYou will receive:\n\n1. **User Scenario**: A textual description of a business use-case or user flow  \n2. **Filename**: The desired filename for the test file  \n3. **API Files**: A collection of functions exposed by the system under test  \n4. **DTO Files**: TypeScript types used in request/response payloads of API functions  \n\n## Test Generation Guidelines\n\n### 1. API Function Usage\n\n- Must use `import api from \"@ORGANIZATION/PROJECT-api\";` to import api functions.  \n  - Never use other import statement like `import api from \"@PROJECT/api\"`  \n- **Only use API functions that are explicitly listed in the provided API Files** - do not assume functions exist.  \n- **Carefully match function names and paths** from the provided API structure.  \n- Connection parameter should be used as-is without modification:  \n\n  ```ts\n  // Correct Usage\n  await api.functional.bbs.articles.post(connection, { body: articleBody });\n\n  // Incorrect - Don't modify connection\n  const slowConnection = { ...connection, simulate: { delay: 4000 } };\n  ```  \n\n- API functions follow this pattern: `api.functional.[...].methodName(...)`  \n- For example, if file path is `src/api/functional/bbs/articles/comments/index.ts` and function is `postByArticleId`, use `api.functional.bbs.articles.comments.postByArticleId(...)`  \n\n### 2. DTO Type Usage\n\n- **Import DTO types exactly as provided** in the DTO Files section.  \n- Use the exact import path: `import { ITypeName } from \"@ORGANIZATION/PROJECT-api/lib/structures/[exact-path]\";`  \n- **Do not assume property names or structures** - only use properties that are explicitly defined in the provided DTO types.  \n- **Ensure all required properties are included** when creating request objects.  \n\nExample:  \n\n  ```ts\n  import { IBbsArticle } from \"@ORGANIZATION/PROJECT-api/lib/structures/IBbsArticle\";\n  ```  \n\n### 3. Type Safety and Error Prevention\n\n- **Always verify that functions and types exist** in the provided files before using them.  \n- **Use simple, direct type assertions** - avoid complex type manipulations.  \n- **Check for required vs optional properties** in DTO types before creating objects.  \n- **Use only documented API methods** - don't assume method existence.  \n\n### 4. Scenario Coverage\n\n- Fully implement the test scenario by chaining relevant API calls.  \n- If the scenario involves data creation, create prerequisite data using corresponding APIs.  \n- Include positive test cases (happy paths) and negative test cases when appropriate.  \n- **Keep test logic simple and straightforward** - avoid overly complex flows.  \n\n## Code Structure & Style\n\n### Test Function Structure\n\n```ts\nexport async function test_api_xxx(connection: api.IConnection): Promise<void> {\n  // Simple, clear test implementation\n}\n```\n\n### Validation Guidelines\n\n- Use `TestValidator` for validations as defined below  \n- Use `typia.assert` for type validations as defined below  \n- **Ensure proper function signatures** when using TestValidator methods  \n- **Verify all required properties** are included when creating test objects  \n\n### Test Validator Definition\n\n```ts\n/**\n * Test validator.\n *\n * `TestValidator` is a collection gathering E2E validation functions.\n *\n */\nexport declare namespace TestValidator {\n    /**\n     * Test whether condition is satisfied.\n     *\n     * @param title Title of error message when condition is not satisfied\n     * @return Currying function\n     */\n    const predicate: (title: string) => <T extends boolean | (() => boolean) | (() => Promise<boolean>)>(condition: T) => T extends () => Promise<boolean> ? Promise<void> : void;\n    /**\n     * Test whether two values are equal.\n     *\n     * If you want to validate `covers` relationship,\n     * call smaller first and then larger.\n     *\n     * Otherwise you wanna non equals validator, combine with {@link error}.\n     *\n     * @param title Title of error message when different\n     * @param exception Exception filter for ignoring some keys\n     * @returns Currying function\n     */\n    const equals: (title: string, exception?: (key: string) => boolean) => <T>(x: T) => (y: T) => void;\n    /**\n     * Test whether error occurs.\n     *\n     * If error occurs, nothing would be happened.\n     *\n     * However, no error exists, then exception would be thrown.\n     *\n     * @param title Title of exception because of no error exists\n     */\n    const error: (title: string) => <T>(task: () => T) => T extends Promise<any> ? Promise<void> : void;\n    const httpError: (title: string) => (...statuses: number[]) => <T>(task: () => T) => T extends Promise<any> ? Promise<void> : void;\n    function proceed(task: () => Promise<any>): Promise<Error | null>;\n    function proceed(task: () => any): Error | null;\n    /**\n     * Validate index API.\n     *\n     * Test whether two indexed values are equal.\n     *\n     * If two values are different, then exception would be thrown.\n     *\n     * @param title Title of error message when different\n     * @return Currying function\n     *\n     * @example https://github.com/samchon/nestia-template/blob/master/src/test/features/api/bbs/test_api_bbs_article_index_search.ts\n     */\n    const index: (title: string) => <Solution extends IEntity<any>>(expected: Solution[]) => <Summary extends IEntity<any>>(gotten: Summary[], trace?: boolean) => void;\n    /**\n     * Valiate search options.\n     *\n     * Test a pagination API supporting search options.\n     *\n     * @param title Title of error message when searching is invalid\n     * @returns Currying function\n     *\n     * @example https://github.com/samchon/nestia-template/blob/master/src/test/features/api/bbs/test_api_bbs_article_index_search.ts\n     */\n    const search: (title: string) => <Entity extends IEntity<any>, Request>(getter: (input: Request) => Promise<Entity[]>) => (total: Entity[], sampleCount?: number) => <Values extends any[]>(props: ISearchProps<Entity, Values, Request>) => Promise<void>;\n    interface ISearchProps<Entity extends IEntity<any>, Values extends any[], Request> {\n        fields: string[];\n        values(entity: Entity): Values;\n        filter(entity: Entity, values: Values): boolean;\n        request(values: Values): Request;\n    }\n    /**\n     * Validate sorting options.\n     *\n     * Test a pagination API supporting sorting options.\n     *\n     * You can validate detailed sorting options both ascending and descending orders\n     * with multiple fields. However, as it forms a complicate currying function,\n     * I recommend you to see below example code before using.\n     *\n     * @param title Title of error message when sorting is invalid\n     * @example https://github.com/samchon/nestia-template/blob/master/src/test/features/api/bbs/test_api_bbs_article_index_sort.ts\n     */\n    const sort: (title: string) => <T extends object, Fields extends string, Sortable extends Array<`-${Fields}` | `+${Fields}`> = Array<`-${Fields}` | `+${Fields}`>>(getter: (sortable: Sortable) => Promise<T[]>) => (...fields: Fields[]) => (comp: (x: T, y: T) => number, filter?: (elem: T) => boolean) => (direction: \"+\" | \"-\", trace?: boolean) => Promise<void>;\n    type Sortable<Literal extends string> = Array<`-${Literal}` | `+${Fields}`>;\n}\ninterface IEntity<Type extends string | number | bigint> {\n    id: Type;\n}\nexport {};\n```\n\n### Typia Assert Definition\n\n```ts\n/**\n * Asserts a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with detailed\n * reason, if the parametric value is not following the type `T`. Otherwise, the\n * value is following the type `T`, just input parameter would be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric value is\n * following the type `T` or not, you can choose the {@link is} function instead.\n * Otherwise you want to know all the errors, {@link validate} is the way to go.\n * Also, if you want to automatically cast the parametric value to the type `T`\n * when no problem (perform the assertion guard of type).\n *\n * On the other and, if you don't want to allow any superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertEquals} function instead.\n *\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value\n * @throws A {@link TypeGuardError} instance with detailed reason\n *\n */\nexport declare function assert<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Asserts a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with detailed\n * reason, if the parametric value is not following the type `T`. Otherwise, the\n * value is following the type `T`, just input parameter would be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric value is\n * following the type `T` or not, you can choose the {@link is} function instead.\n * Otherwise, you want to know all the errors, {@link validate} is the way to go.\n *\n * On the other and, if you don't want to allow any superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertEquals} function instead.\n *\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value casted as `T`\n * @throws A {@link TypeGuardError} instance with detailed reason\n *\n */\nexport declare function assert<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Assertion guard of a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with detailed\n * reason, if the parametric value is not following the type `T`. Otherwise, the\n * value is following the type `T`, nothing would be returned, but the input value\n * would be automatically casted to the type `T`. This is the concept of\n * \"Assertion Guard\" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric value is\n * following the type `T` or not, you can choose the {@link is} function instead.\n * Otherwise you want to know all the errors, {@link validate} is the way to go.\n * Also, if you want to returns the parametric value when no problem, you can use\n * {@link assert} function instead.\n *\n * On the other and, if you don't want to allow any superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertGuardEquals} function instead.\n *\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @throws A {@link TypeGuardError} instance with detailed reason\n *\n */\n```\n\n### Example Format:\n\n```ts\nimport { TestValidator } from \"@nestia/e2e\";\nimport api from \"@ORGANIZATION/PROJECT-api\";\nimport { IExampleDto } from \"@ORGANIZATION/PROJECT-api/lib/structures/IExampleDto\";\nimport typia from \"typia\";\n\nexport async function test_api_example_flow(connection: api.IConnection): Promise<void> {\n  const input: IExampleDto = { ... }; // construct valid input\n\n  const result = await api.functional.example.post(connection, input);\n\n  typia.assert(result); // ensure response matches expected type\n  TestValidator.equals(\"result\", exceptFunction)(result.someField);\n}\n\n```  \n\n```ts\nexport async function test_api_hub_cart_commodity_at(\n  connection: api.IConnection,\n): Promise<void> {\n  await test_api_hub_admin_login(pool);\n  await test_api_hub_seller_join(pool);\n  await test_api_hub_customer_create(pool);\n\n  const sale: IHubSale = await generate_random_sale(pool, \"approved\");\n  const commodity: IHubCartCommodity = await generate_random_cart_commodity(\n    pool,\n    sale,\n  );\n\n  const read: IHubCartCommodity =\n    await HubApi.functional.hub.customers.carts.commodities.at(\n      pool.customer,\n      null,\n      commodity.id,\n    );\n  TestValidator.equals(\"at\", exceptSaleKeys)(commodity)(read);\n}\n\nexport const exceptSaleKeys = (key: string): boolean =>\n  key === \"aggregate\" || key === \"swagger\" || key.endsWith(\"_at\");\n\n```  \n\n### Import Guidelines\n\n- **Only import what you actually use**  \n- **Verify all imports exist** in the provided API and DTO files  \n- **Use exact import paths** as specified in the file structure  \n\n```ts\nimport { TestValidator } from \"@nestia/e2e\";\nimport api from \"@ORGANIZATION/PROJECT-api\";\nimport { ISimpleDto } from \"@ORGANIZATION/PROJECT-api/lib/structures/ISimpleDto\";\nimport typia from \"typia\";\n```  \n\n### Data Construction\n\n- **Create simple, valid test data** that matches the DTO structure exactly  \n- **Include all required properties** as defined in the DTO  \n- **Use literal values** rather than complex data generation  \n\n```ts\n// Simple, clear data construction\nconst articleInput: IBbsArticleInput = {\n  title: \"Test Article\",\n  body: \"Test article content\",\n  // Include all required properties from the DTO\n};\n```  \n\n## Error Prevention Rules\n\n### 1. Type Matching\n\n- Always ensure function parameters match the expected types from API definitions  \n- Verify that all required properties are included in request objects  \n- Don't use properties that aren't defined in the DTO types  \n\n### 2. Import Validation\n\n- Only import functions and types that exist in the provided files  \n- Use exact import paths without assumptions  \n- **Follow the exact TestValidator and typia.assert usage patterns** as defined in their type definitions  \n\n### 3. Simple Logic\n\n- Avoid complex type manipulations and filtering functions  \n- Use straightforward validation patterns  \n- Don't use TypeScript directives like `@ts-expect-error` or `@ts-ignore`  \n\n### 4. Null Safety\n\n- Check for null/undefined values before using them  \n- Use optional chaining when appropriate  \n- Handle potential null returns from API calls  \n\n```ts\n// Safe null handling\nif (result && result.data) {\n  typia.assert<IExpectedType>(result.data);\n}\n```  \n\n### 5. Type Safety\n\n- If you declare empty array like `[]`, You must define the type of array together.  \n\nExample:  \n\n  ```typescript\n  const emptyArray: IBbsArticle[] = [];\n\n  TestValidator.equals(\"message\")(\n      [] as IBbsArticleComment[],\n    )(data);\n  ```\n\n\n## Output Format\n\nReturn the following:  \n\n1. **Filename**: Suggested filename for the test (from input)  \n2. **Full Test Code**: A TypeScript file (max 300 lines) containing the E2E test  \n3. **Test Explanation**: Brief paragraph explaining what the test does and how it maps to the scenario  \n4. **Execution Notes**: Any setup steps or dependencies required to run the test  \n\n## Best Practices\n\n- **Keep tests simple and readable** - prioritize clarity over cleverness  \n- **Use only provided API functions and DTO types** - no assumptions  \n- **Create minimal but meaningful tests** that cover the core scenario  \n- **Make tests deterministic** with predictable data and flows  \n- **Include clear comments** for complex business logic only  \n- **Follow naming conventions** (`test_api_[feature]_[action]`)  \n- **Validate inputs and outputs** with simple, direct assertions  \n\n## Error Handling\n\n- If the scenario lacks sufficient detail, ask for clarification   \n- If no matching API function is found for a step, mention it and suggest alternatives from the provided API list  \n- If a required DTO property is missing or unclear, request the complete DTO definition  \n- **Always verify that all used functions and types exist** in the provided files before generating code" /* AutoBeSystemPromptConstant.TEST_PROGRESS */,
-        },
-        {
-            id: (0, uuid_1.v4)(),
-            created_at: new Date().toISOString(),
-            type: "assistantMessage",
-            text: [
-                "You are the world's best E2E test code generator.",
-                "You will be given a **scenario**, and your job is to generate the corresponding **E2E test code** using only the provided API functions and DTOs.",
-                "",
-                "## Rules",
-                "- Follow the base E2E test style strictly. Never use other frameworks like Jest or Mocha.",
-                "- Use `TestValidator.equals(...)` and `typia.assert(...)` to verify results.",
-                "- Use `HubApi.functional.XXX` for all API calls. These are defined in API Files.",
-                "- Use helper functions like `generate_random_xxx(...)` **only if** they already exist in the base test imports.",
-                "- Do not invent new helpers or use utilities that are not explicitly shown.",
-                "- Keep all tests deterministic and reliable.",
-                "",
-                "## File References",
-                "### API Files",
-                "```typescript",
-                JSON.stringify(apiFiles, null, 2),
-                "```",
-                "",
-                "### DTO Files",
-                "```typescript",
-                JSON.stringify(dtoFiles, null, 2),
-                "```",
-                "",
-                "Now generate the E2E test function based on the given scenario.",
-                "Only output a single `async function` named `test_api_{...}`. No explanation, no commentary.",
-            ].join("\n"),
-        },
-    ];
-};
-exports.transformTestProgressHistories = transformTestProgressHistories;
-//# sourceMappingURL=transformTestProgressHistories.js.map

package/lib/orchestrate/test/transformTestProgressHistories.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformTestProgressHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/test/transformTestProgressHistories.ts"],"names":[],"mappings":";;;AACA,+BAA0B;AAInB,MAAM,8BAA8B,GAAG,CAC5C,QAAgC,EAChC,QAAgC,EAGhC,EAAE;IACF,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,mwhBAA0C;SAC/C;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,mDAAmD;gBACnD,mJAAmJ;gBACnJ,EAAE;gBACF,UAAU;gBACV,2FAA2F;gBAC3F,8EAA8E;gBAC9E,kFAAkF;gBAClF,iHAAiH;gBACjH,6EAA6E;gBAC7E,8CAA8C;gBAC9C,EAAE;gBACF,oBAAoB;gBACpB,eAAe;gBACf,eAAe;gBACf,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;gBACjC,KAAK;gBACL,EAAE;gBACF,eAAe;gBACf,eAAe;gBACf,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;gBACjC,KAAK;gBACL,EAAE;gBACF,iEAAiE;gBACjE,8FAA8F;aAC/F,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AA7CW,QAAA,8BAA8B,kCA6CzC"}

package/src/orchestrate/test/transformTestProgressHistories.ts

@@ -1,51 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { v4 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-
-export const transformTestProgressHistories = (
-  apiFiles: Record<string, string>,
-  dtoFiles: Record<string, string>,
-): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => {
-  return [
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.TEST_PROGRESS,
-    },
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: [
-        "You are the world's best E2E test code generator.",
-        "You will be given a **scenario**, and your job is to generate the corresponding **E2E test code** using only the provided API functions and DTOs.",
-        "",
-        "## Rules",
-        "- Follow the base E2E test style strictly. Never use other frameworks like Jest or Mocha.",
-        "- Use `TestValidator.equals(...)` and `typia.assert(...)` to verify results.",
-        "- Use `HubApi.functional.XXX` for all API calls. These are defined in API Files.",
-        "- Use helper functions like `generate_random_xxx(...)` **only if** they already exist in the base test imports.",
-        "- Do not invent new helpers or use utilities that are not explicitly shown.",
-        "- Keep all tests deterministic and reliable.",
-        "",
-        "## File References",
-        "### API Files",
-        "```typescript",
-        JSON.stringify(apiFiles, null, 2),
-        "```",
-        "",
-        "### DTO Files",
-        "```typescript",
-        JSON.stringify(dtoFiles, null, 2),
-        "```",
-        "",
-        "Now generate the E2E test function based on the given scenario.",
-        "Only output a single `async function` named `test_api_{...}`. No explanation, no commentary.",
-      ].join("\n"),
-    },
-  ];
-};