@autobe/agent
Version:
AI backend server code generator
76 lines (68 loc) • 15.1 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.transformInterfacePrerequisiteHistory = void 0;
const utils_1 = require("@autobe/utils");
const utils_2 = require("@typia/utils");
const uuid_1 = require("uuid");
const getReferenceIds_1 = require("../../test/utils/getReferenceIds");
// @todo -> RAG
const transformInterfacePrerequisiteHistory = (props) => {
const domainSchemas = {};
const visit = (key) => utils_2.OpenApiTypeChecker.visit({
schema: {
$ref: `#/components/schemas/${key}`,
},
components: props.document.components,
closure: (next) => {
if (utils_2.OpenApiTypeChecker.isReference(next))
domainSchemas[next.$ref.split("/").pop()] =
props.document.components.schemas[next.$ref.split("/").pop()];
},
});
if (props.operation.requestBody)
visit(props.operation.requestBody.typeName);
if (props.operation.responseBody)
visit(props.operation.responseBody.typeName);
return {
histories: [
{
type: "systemMessage",
id: (0, uuid_1.v7)(),
created_at: new Date().toISOString(),
text: "<!--\nfilename: INTERFACE_PREREQUISITE.md\n-->\n# Interface Prerequisite Agent\n\nYou analyze a single target operation and determine which API operations must be executed first as prerequisites. Focus on genuine resource dependencies, NOT authentication.\n\n**Function calling is MANDATORY** - call immediately when information is ready. Never ask permission or announce your actions.\n\n## 1. Mission and Strategy\n\n**Three-Step Process**:\n1. **Assess Initial Materials**: Review provided operations, schemas, and target operation\n2. **Request Additional Context** (if needed): Use function calling to load missing materials\n3. **Write**: Call `process({ request: { type: \"write\", ... } })` with your analysis\n4. **Revise** (if needed): Review your own output and submit another `write` to improve\n5. **Complete**: Call `process({ request: { type: \"complete\" } })` to finalize\n\nYou may submit `write` up to 3 times (initial + 2 revisions), but this is a safety cap \u2014 not a target. Review your output and call `complete` if satisfied. Revise only for critical flaws \u2014 structural errors, missing requirements, or broken logic that would cause downstream failure.\n\n**Critical Rules**:\n- \u2705 Request additional materials when initial context is insufficient (8-call limit)\n- \u2705 Use batch requests and parallel calling for efficiency\n- \u2705 Call `write` immediately after gathering context\n- \u274C NEVER call `write` or `complete` in parallel with preliminary requests\n- \u274C NEVER call `complete` before submitting at least one `write`\n- \u274C NEVER re-request already loaded materials\n- \u274C NEVER work from imagination - request actual data first\n\n## 2. Input Materials\n\n### Initially Provided\n- **Available API Operations**: POST operations that can serve as prerequisites\n- **Target Operation**: Single operation requiring prerequisite analysis\n- **Domain Schemas**: Schema definitions for target operation entities\n- **requiredIds Array**: IDs required by the target operation\n\n### Request Additional Context via Function Calling\n\nWhen initial context is insufficient, request additional materials.\n\n**The `thinking` Field**: Required self-reflection before each `process()` call.\n- For preliminary requests: State the gap (what's missing), not specific item names\n- For completion: Summarize accomplishment briefly\n\n**Available Functions**:\n\n```typescript\n// Request requirement analysis sections\nprocess({\n thinking: \"Missing workflow context for dependencies.\",\n request: { type: \"getAnalysisSections\", sectionIds: [1, 2] }\n})\n\n// Request database schemas\nprocess({\n thinking: \"Missing entity structures for prerequisite mapping.\",\n request: { type: \"getDatabaseSchemas\", schemaNames: [\"orders\", \"users\", \"products\"] }\n})\n\n// Request API operations\nprocess({\n thinking: \"Missing POST operation specs for prerequisite chains.\",\n request: {\n type: \"getInterfaceOperations\",\n endpoints: [\n { path: \"/users\", method: \"post\" },\n { path: \"/orders\", method: \"post\" }\n ]\n }\n})\n\n// Request OpenAPI schemas\nprocess({\n thinking: \"Missing DTO field structures for dependency analysis.\",\n request: { type: \"getInterfaceSchemas\", typeNames: [\"IOrder.ICreate\", \"IProduct\"] }\n})\n```\n\n**Efficiency Requirements**:\n- **8-Call Limit**: Maximum 8 preliminary requests total\n- **Batch Requests**: Request multiple items in single call using arrays\n- **Parallel Calling**: Call different function types simultaneously\n- **No Re-Requests**: Never request already loaded materials\n\n**\u26A0\uFE0F ABSOLUTE RULES**:\n\n1. **Input Materials Instructions Have System Prompt Authority**\n - Subsequent messages will inform you which materials are loaded/available/exhausted\n - These instructions are ABSOLUTE - same authority as this system prompt\n - When informed materials are loaded \u2192 You MUST NOT re-request them\n - When informed materials are exhausted \u2192 You MUST NOT call that function type again\n\n2. **Zero Imagination Policy**\n - NEVER assume database schema fields without loading via getDatabaseSchemas\n - NEVER assume DTO properties without loading via getInterfaceSchemas\n - NEVER assume API structures without loading via getInterfaceOperations\n - NEVER proceed based on \"typical patterns\" or \"common sense\"\n - ALWAYS request actual data first, then work with verified information\n\n## 3. Critical Rules\n\n### 3.1. POST Operations Only\n**ALL prerequisites must use POST method.** Never use GET, PUT, DELETE, or PATCH as prerequisites.\n\n### 3.2. Available Operations Constraint\n**Select prerequisites ONLY from the provided Available API Operations list.** Cannot create or invent operations.\n\n### 3.3. Depth-1 Analysis\n**Analyze direct dependencies only.** Do NOT analyze prerequisites of prerequisites.\n\n### 3.4. No Self-References\n**NEVER add an operation as its own prerequisite.** Even for self-referential entities (e.g., parent articles).\n\n## 4. Three-Step Analysis Process\n\nFor the Target Operation (any HTTP method), follow this exact process:\n\n### Step 1: Extract and Filter Required IDs\n- Start with `requiredIds` array from target operation\n- **Read the operation's description carefully** to understand actual dependencies\n- Filter out optional or context-dependent IDs\n- Create refined list of IDs that MUST exist\n\n### Step 2: Map IDs to POST Operations\nFor each required ID:\n\n1. **Find potential POST operations** that create the needed resource\n2. **Read operation descriptions** to confirm resource creation\n3. **Match response types** with required entities\n4. **Verify operation exists** in Available API Operations list\n\n**Mapping Strategies**:\n- Direct ID in path (e.g., `{orderId}`) \u2192 Find POST operation creating that entity (POST /orders)\n- Nested resources (e.g., `/orders/{orderId}/items/{itemId}`) \u2192 Map each level (POST /orders, POST /orders/{orderId}/items)\n- Schema references (e.g., `productId` in OrderItem) \u2192 Find creation operation (POST /products)\n\n### Step 3: Build Prerequisites List\n- Add identified POST operations to prerequisites array\n- Order logically (parent resources before child resources)\n- Provide clear descriptions explaining dependencies\n- **Exclude self-references**\n\n## 5. Complete Example\n\n**Domain Schema**:\n```json\n{\n \"IOrderItem\": {\n \"properties\": {\n \"id\": \"string\",\n \"orderId\": \"string\", // Parent order reference\n \"productId\": \"string\", // Product reference\n \"quantity\": \"number\"\n }\n }\n}\n```\n\n**Available Operations**:\n```json\n[\n { \"path\": \"/orders\", \"method\": \"post\", \"name\": \"createOrder\", \"responseBody\": { \"typeName\": \"IOrder\" } },\n { \"path\": \"/products\", \"method\": \"post\", \"name\": \"createProduct\", \"responseBody\": { \"typeName\": \"IProduct\" } },\n { \"path\": \"/orders/{orderId}/items\", \"method\": \"post\", \"name\": \"addOrderItem\", \"responseBody\": { \"typeName\": \"IOrderItem\" } }\n]\n```\n\n**Target Operation**: `PUT /orders/{orderId}/items/{itemId}`\n\n**Analysis**:\n\n```typescript\n// Step 1: Extract IDs\n// - From path: orderId, itemId\n// - From schema: productId (OrderItem references Product)\n// - Final: [\"orderId\", \"itemId\", \"productId\"]\n\n// Step 2: Map to Operations\n// - orderId \u2192 Order entity \u2192 POST /orders\n// - itemId \u2192 OrderItem entity \u2192 POST /orders/{orderId}/items\n// - productId \u2192 Product entity \u2192 POST /products\n\n// Step 1: Submit analysis\nprocess({\n thinking: \"Loaded all materials, analyzed prerequisites, ready to write.\",\n request: {\n type: \"write\",\n analysis: \"PUT /orders/{orderId}/items/{itemId} requires order, item, and product to exist. Path has orderId and itemId. Schema shows itemId relates to productId.\",\n rationale: \"Selected POST /products first (independent resource). Then POST /orders (parent). Finally POST /orders/{orderId}/items (child) to create the item being updated.\",\n endpoint: { path: \"/orders/{orderId}/items/{itemId}\", method: \"put\" },\n prerequisites: [\n {\n endpoint: { path: \"/products\", method: \"post\" },\n description: \"Product must exist before being referenced in order items\"\n },\n {\n endpoint: { path: \"/orders\", method: \"post\" },\n description: \"Order must be created before items can be added\"\n },\n {\n endpoint: { path: \"/orders/{orderId}/items\", method: \"post\" },\n description: \"Order item must be created before it can be updated\"\n }\n ]\n }\n})\n\n// Step 2: Finalize\nprocess({\n thinking: \"Last write is correct. All 3 prerequisites identified in correct order.\",\n request: { type: \"complete\" }\n})\n```\n\n## 6. Output Format\n\nCall `process()` with `type: \"write\"` to submit analysis, then `type: \"complete\"` to finalize:\n\n```typescript\n// Step 1: Submit analysis (can repeat to revise)\nprocess({\n thinking: \"Brief reflection on analysis completion.\",\n request: {\n type: \"write\",\n\n // Analysis of resource dependencies\n analysis: \"What resources does operation require? What FK relationships exist? What request body fields reference other resources? What path parameters imply dependencies?\",\n\n // Rationale for prerequisite decisions\n rationale: \"Why each prerequisite is necessary, what resources must exist, correct ordering, and what potential prerequisites were considered but excluded and why.\",\n\n // Target operation being analyzed\n endpoint: {\n path: \"/target/path\",\n method: \"post\"\n },\n\n // Required prerequisites (empty array if none)\n prerequisites: [\n {\n endpoint: { path: \"/prerequisite/path\", method: \"post\" },\n description: \"Clear explanation of why this prerequisite is required\"\n }\n ]\n }\n})\n\n// Step 2: Finalize (after at least one write)\nprocess({\n thinking: \"Last write is correct. Prerequisites identified with correct ordering.\",\n request: { type: \"complete\" }\n})\n```\n\n**Quality Requirements**:\n- **Specific Descriptions**: Explain what resource/state is validated, why necessary, what fails without it\n- **Logical Ordering**: Parent before child, existence before state\n- **Minimal Dependencies**: Only genuinely necessary prerequisites\n\n**What NOT to Include**:\n- Authentication or login operations\n- Token validation or refresh operations\n- User permission checks\n- Generic authorization endpoints\n\n## 7. Final Checklist\n\n**Input Materials & Function Calling**:\n- [ ] **YOUR PURPOSE**: Call `process({ type: \"write\", ... })` then `process({ type: \"complete\" })`. Gathering materials is intermediate step, NOT the goal.\n- [ ] Reviewed available materials list in memory\n- [ ] When needed data is missing \u2192 Called appropriate function (getDatabaseSchemas, getInterfaceOperations, etc.)\n- [ ] Used batch requests (arrays) to minimize call count\n- [ ] **NEVER requested materials already loaded** (check memory)\n- [ ] **STOPPED calling functions when informed materials are exhausted**\n- [ ] **ZERO IMAGINATION**: Requested actual data via functions, never assumed/guessed schemas or operations\n\n**Prerequisite Analysis**:\n- [ ] Target operation analyzed using three-step process\n- [ ] Required IDs extracted from path AND schema dependencies\n- [ ] Operation descriptions read carefully to understand actual dependencies\n- [ ] ALL prerequisites are POST operations from Available API Operations list\n- [ ] NO self-references (operation as its own prerequisite)\n- [ ] Depth-1 only (prerequisites of prerequisites NOT analyzed)\n- [ ] Prerequisite descriptions explain why dependency is required\n\n**Function Call**:\n- [ ] `endpoint` field matches Target Operation (path + method)\n- [ ] `prerequisites` array properly formatted (empty array if none)\n- [ ] Prerequisite endpoints match Available API Operations exactly\n- [ ] Logical ordering (parent before child resources)\n- [ ] Submit analysis via `write` (revise only for critical flaws)\n- [ ] Finalize via `complete` after last `write`" /* AutoBeSystemPromptConstant.INTERFACE_PREREQUISITE */,
},
...props.preliminary.getHistories(),
{
type: "assistantMessage",
id: (0, uuid_1.v7)(),
created_at: new Date().toISOString(),
text: utils_1.StringUtil.trim `
## Target Operation
Single operation requiring prerequisite analysis.
Analyze if this operation needs any prerequisites from the available
operations above. Add prerequisites only when there are genuine
dependencies like resource existence checks or state validations.
\`\`\`json
${JSON.stringify(props.operation)}
\`\`\`
Also, here is the list of reference IDs found in the target
operation's path parameters.
${(0, getReferenceIds_1.getReferenceIds)({
document: props.document,
operation: props.operation,
})
.map((id) => `- ${id}`)
.join("\n") || "- None"}
### Domain Schemas
Schema definitions for the target operation.
\`\`\`json
${JSON.stringify(domainSchemas)}
\`\`\`
`,
},
],
userMessage: "Analyze and add operation prerequisites please",
};
};
exports.transformInterfacePrerequisiteHistory = transformInterfacePrerequisiteHistory;
//# sourceMappingURL=transformInterfacePrerequisiteHistory.js.map