archetype-engine 2.0.0

package/dist/src/ai/index.d.ts

@@ -0,0 +1,492 @@
+/**
+ * AI Module
+ *
+ * Ready-to-use tool definitions for AI frameworks (OpenAI, Anthropic, Vercel AI SDK).
+ *
+ * @module ai
+ *
+ * @example
+ * ```typescript
+ * // With Vercel AI SDK
+ * import { createManifestBuilder, aiTools } from 'archetype-engine/ai'
+ * import { generateText } from 'ai'
+ * import { openai } from '@ai-sdk/openai'
+ *
+ * const builder = createManifestBuilder()
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   tools: aiTools.vercel(builder),
+ *   system: 'You are an app builder. Use the tools to build the app.',
+ *   prompt: 'Create a blog with users and posts',
+ *   maxSteps: 10
+ * })
+ *
+ * // After AI finishes calling tools, generate the app
+ * const { files, success } = await builder.generate()
+ * ```
+ */
+export type { ToolDefinition, ToolParameter, ToolResult, ManifestBuilder, AddEntityParams, UpdateEntityParams, RemoveEntityParams, SetDatabaseParams, SetAuthParams, OpenAITool, AnthropicTool, VercelAITool, } from './types';
+export { createManifestBuilder } from './state';
+export { toolDefinitions } from './tools';
+export { getOpenAITools, executeOpenAITool, createOpenAIHandler } from './adapters/openai';
+export { getAnthropicTools, executeAnthropicTool, createAnthropicHandler } from './adapters/anthropic';
+export { getVercelAITools } from './adapters/vercel';
+export type { VercelAITools } from './adapters/vercel';
+import type { ManifestBuilder } from './types';
+/**
+ * Convenience object for getting tools in different formats
+ */
+export declare const aiTools: {
+    /**
+     * Get tools for OpenAI function calling
+     */
+    openai: () => import("./types").OpenAITool[];
+    /**
+     * Get tools for Anthropic tool use
+     */
+    anthropic: () => import("./types").AnthropicTool[];
+    /**
+     * Get tools for Vercel AI SDK (requires builder instance)
+     */
+    vercel: (builder: ManifestBuilder) => {
+        add_entity: {
+            description: string;
+            parameters: import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                fields: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["text", "number", "boolean", "date"]>;
+                    required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    unique: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    email: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    url: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    min: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    max: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    oneOf: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                    integer: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    positive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    default: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                    label: import("zod").ZodOptional<import("zod").ZodString>;
+                }, "strip", import("zod").ZodTypeAny, {
+                    type: "number" | "boolean" | "text" | "date";
+                    email?: boolean | undefined;
+                    url?: boolean | undefined;
+                    oneOf?: string[] | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    integer?: boolean | undefined;
+                    positive?: boolean | undefined;
+                    required?: boolean | undefined;
+                    unique?: boolean | undefined;
+                    default?: unknown;
+                    label?: string | undefined;
+                }, {
+                    type: "number" | "boolean" | "text" | "date";
+                    email?: boolean | undefined;
+                    url?: boolean | undefined;
+                    oneOf?: string[] | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    integer?: boolean | undefined;
+                    positive?: boolean | undefined;
+                    required?: boolean | undefined;
+                    unique?: boolean | undefined;
+                    default?: unknown;
+                    label?: string | undefined;
+                }>>;
+                relations: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["hasOne", "hasMany", "belongsToMany"]>;
+                    entity: import("zod").ZodString;
+                }, "strip", import("zod").ZodTypeAny, {
+                    type: "hasOne" | "hasMany" | "belongsToMany";
+                    entity: string;
+                }, {
+                    type: "hasOne" | "hasMany" | "belongsToMany";
+                    entity: string;
+                }>>>;
+                behaviors: import("zod").ZodOptional<import("zod").ZodObject<{
+                    timestamps: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    softDelete: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    audit: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, "strip", import("zod").ZodTypeAny, {
+                    timestamps?: boolean | undefined;
+                    softDelete?: boolean | undefined;
+                    audit?: boolean | undefined;
+                }, {
+                    timestamps?: boolean | undefined;
+                    softDelete?: boolean | undefined;
+                    audit?: boolean | undefined;
+                }>>;
+                protected: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodBoolean, import("zod").ZodEnum<["write", "all"]>]>>;
+            }, "strip", import("zod").ZodTypeAny, {
+                fields: Record<string, {
+                    type: "number" | "boolean" | "text" | "date";
+                    email?: boolean | undefined;
+                    url?: boolean | undefined;
+                    oneOf?: string[] | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    integer?: boolean | undefined;
+                    positive?: boolean | undefined;
+                    required?: boolean | undefined;
+                    unique?: boolean | undefined;
+                    default?: unknown;
+                    label?: string | undefined;
+                }>;
+                name: string;
+                protected?: boolean | "write" | "all" | undefined;
+                relations?: Record<string, {
+                    type: "hasOne" | "hasMany" | "belongsToMany";
+                    entity: string;
+                }> | undefined;
+                behaviors?: {
+                    timestamps?: boolean | undefined;
+                    softDelete?: boolean | undefined;
+                    audit?: boolean | undefined;
+                } | undefined;
+            }, {
+                fields: Record<string, {
+                    type: "number" | "boolean" | "text" | "date";
+                    email?: boolean | undefined;
+                    url?: boolean | undefined;
+                    oneOf?: string[] | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    integer?: boolean | undefined;
+                    positive?: boolean | undefined;
+                    required?: boolean | undefined;
+                    unique?: boolean | undefined;
+                    default?: unknown;
+                    label?: string | undefined;
+                }>;
+                name: string;
+                protected?: boolean | "write" | "all" | undefined;
+                relations?: Record<string, {
+                    type: "hasOne" | "hasMany" | "belongsToMany";
+                    entity: string;
+                }> | undefined;
+                behaviors?: {
+                    timestamps?: boolean | undefined;
+                    softDelete?: boolean | undefined;
+                    audit?: boolean | undefined;
+                } | undefined;
+            }>;
+            execute: (params: {
+                name: string;
+                fields: Record<string, import("zod").TypeOf<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["text", "number", "boolean", "date"]>;
+                    required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    unique: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    email: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    url: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    min: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    max: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    oneOf: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                    integer: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    positive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    default: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                    label: import("zod").ZodOptional<import("zod").ZodString>;
+                }, "strip", import("zod").ZodTypeAny, {
+                    type: "number" | "boolean" | "text" | "date";
+                    email?: boolean | undefined;
+                    url?: boolean | undefined;
+                    oneOf?: string[] | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    integer?: boolean | undefined;
+                    positive?: boolean | undefined;
+                    required?: boolean | undefined;
+                    unique?: boolean | undefined;
+                    default?: unknown;
+                    label?: string | undefined;
+                }, {
+                    type: "number" | "boolean" | "text" | "date";
+                    email?: boolean | undefined;
+                    url?: boolean | undefined;
+                    oneOf?: string[] | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    integer?: boolean | undefined;
+                    positive?: boolean | undefined;
+                    required?: boolean | undefined;
+                    unique?: boolean | undefined;
+                    default?: unknown;
+                    label?: string | undefined;
+                }>>>;
+                relations?: Record<string, import("zod").TypeOf<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["hasOne", "hasMany", "belongsToMany"]>;
+                    entity: import("zod").ZodString;
+                }, "strip", import("zod").ZodTypeAny, {
+                    type: "hasOne" | "hasMany" | "belongsToMany";
+                    entity: string;
+                }, {
+                    type: "hasOne" | "hasMany" | "belongsToMany";
+                    entity: string;
+                }>>>;
+                behaviors?: {
+                    timestamps?: boolean;
+                    softDelete?: boolean;
+                    audit?: boolean;
+                };
+                protected?: boolean | "write" | "all";
+            }) => Promise<import("./types").ToolResult>;
+        };
+        update_entity: {
+            description: string;
+            parameters: import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                fields: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+                    type: import("zod").ZodOptional<import("zod").ZodEnum<["text", "number", "boolean", "date"]>>;
+                    required: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+                    unique: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+                    email: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+                    url: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+                    min: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                    max: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                    oneOf: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>>;
+                    integer: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+                    positive: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+                    default: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodUnknown>>;
+                    label: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodString>>;
+                }, "strip", import("zod").ZodTypeAny, {
+                    email?: boolean | undefined;
+                    url?: boolean | undefined;
+                    oneOf?: string[] | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    integer?: boolean | undefined;
+                    positive?: boolean | undefined;
+                    type?: "number" | "boolean" | "text" | "date" | undefined;
+                    required?: boolean | undefined;
+                    unique?: boolean | undefined;
+                    default?: unknown;
+                    label?: string | undefined;
+                }, {
+                    email?: boolean | undefined;
+                    url?: boolean | undefined;
+                    oneOf?: string[] | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    integer?: boolean | undefined;
+                    positive?: boolean | undefined;
+                    type?: "number" | "boolean" | "text" | "date" | undefined;
+                    required?: boolean | undefined;
+                    unique?: boolean | undefined;
+                    default?: unknown;
+                    label?: string | undefined;
+                }>>>;
+                relations: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["hasOne", "hasMany", "belongsToMany"]>;
+                    entity: import("zod").ZodString;
+                }, "strip", import("zod").ZodTypeAny, {
+                    type: "hasOne" | "hasMany" | "belongsToMany";
+                    entity: string;
+                }, {
+                    type: "hasOne" | "hasMany" | "belongsToMany";
+                    entity: string;
+                }>>>;
+                behaviors: import("zod").ZodOptional<import("zod").ZodObject<{
+                    timestamps: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    softDelete: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    audit: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, "strip", import("zod").ZodTypeAny, {
+                    timestamps?: boolean | undefined;
+                    softDelete?: boolean | undefined;
+                    audit?: boolean | undefined;
+                }, {
+                    timestamps?: boolean | undefined;
+                    softDelete?: boolean | undefined;
+                    audit?: boolean | undefined;
+                }>>;
+                protected: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodBoolean, import("zod").ZodEnum<["write", "all"]>]>>;
+            }, "strip", import("zod").ZodTypeAny, {
+                name: string;
+                fields?: Record<string, {
+                    email?: boolean | undefined;
+                    url?: boolean | undefined;
+                    oneOf?: string[] | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    integer?: boolean | undefined;
+                    positive?: boolean | undefined;
+                    type?: "number" | "boolean" | "text" | "date" | undefined;
+                    required?: boolean | undefined;
+                    unique?: boolean | undefined;
+                    default?: unknown;
+                    label?: string | undefined;
+                }> | undefined;
+                protected?: boolean | "write" | "all" | undefined;
+                relations?: Record<string, {
+                    type: "hasOne" | "hasMany" | "belongsToMany";
+                    entity: string;
+                }> | undefined;
+                behaviors?: {
+                    timestamps?: boolean | undefined;
+                    softDelete?: boolean | undefined;
+                    audit?: boolean | undefined;
+                } | undefined;
+            }, {
+                name: string;
+                fields?: Record<string, {
+                    email?: boolean | undefined;
+                    url?: boolean | undefined;
+                    oneOf?: string[] | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    integer?: boolean | undefined;
+                    positive?: boolean | undefined;
+                    type?: "number" | "boolean" | "text" | "date" | undefined;
+                    required?: boolean | undefined;
+                    unique?: boolean | undefined;
+                    default?: unknown;
+                    label?: string | undefined;
+                }> | undefined;
+                protected?: boolean | "write" | "all" | undefined;
+                relations?: Record<string, {
+                    type: "hasOne" | "hasMany" | "belongsToMany";
+                    entity: string;
+                }> | undefined;
+                behaviors?: {
+                    timestamps?: boolean | undefined;
+                    softDelete?: boolean | undefined;
+                    audit?: boolean | undefined;
+                } | undefined;
+            }>;
+            execute: (params: {
+                name: string;
+                fields?: Record<string, Partial<import("zod").TypeOf<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["text", "number", "boolean", "date"]>;
+                    required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    unique: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    email: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    url: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    min: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    max: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    oneOf: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                    integer: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    positive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    default: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                    label: import("zod").ZodOptional<import("zod").ZodString>;
+                }, "strip", import("zod").ZodTypeAny, {
+                    type: "number" | "boolean" | "text" | "date";
+                    email?: boolean | undefined;
+                    url?: boolean | undefined;
+                    oneOf?: string[] | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    integer?: boolean | undefined;
+                    positive?: boolean | undefined;
+                    required?: boolean | undefined;
+                    unique?: boolean | undefined;
+                    default?: unknown;
+                    label?: string | undefined;
+                }, {
+                    type: "number" | "boolean" | "text" | "date";
+                    email?: boolean | undefined;
+                    url?: boolean | undefined;
+                    oneOf?: string[] | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    integer?: boolean | undefined;
+                    positive?: boolean | undefined;
+                    required?: boolean | undefined;
+                    unique?: boolean | undefined;
+                    default?: unknown;
+                    label?: string | undefined;
+                }>>>>;
+                relations?: Record<string, import("zod").TypeOf<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["hasOne", "hasMany", "belongsToMany"]>;
+                    entity: import("zod").ZodString;
+                }, "strip", import("zod").ZodTypeAny, {
+                    type: "hasOne" | "hasMany" | "belongsToMany";
+                    entity: string;
+                }, {
+                    type: "hasOne" | "hasMany" | "belongsToMany";
+                    entity: string;
+                }>>>;
+                behaviors?: {
+                    timestamps?: boolean;
+                    softDelete?: boolean;
+                    audit?: boolean;
+                };
+                protected?: boolean | "write" | "all";
+            }) => Promise<import("./types").ToolResult>;
+        };
+        remove_entity: {
+            description: string;
+            parameters: import("zod").ZodObject<{
+                name: import("zod").ZodString;
+            }, "strip", import("zod").ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+            execute: (params: {
+                name: string;
+            }) => Promise<import("./types").ToolResult>;
+        };
+        set_database: {
+            description: string;
+            parameters: import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["sqlite", "postgres", "mysql"]>;
+                file: import("zod").ZodOptional<import("zod").ZodString>;
+                url: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "strip", import("zod").ZodTypeAny, {
+                type: "sqlite" | "postgres" | "mysql";
+                url?: string | undefined;
+                file?: string | undefined;
+            }, {
+                type: "sqlite" | "postgres" | "mysql";
+                url?: string | undefined;
+                file?: string | undefined;
+            }>;
+            execute: (params: {
+                type: "sqlite" | "postgres" | "mysql";
+                file?: string;
+                url?: string;
+            }) => Promise<import("./types").ToolResult>;
+        };
+        set_auth: {
+            description: string;
+            parameters: import("zod").ZodObject<{
+                enabled: import("zod").ZodBoolean;
+                providers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<["credentials", "google", "github", "discord"]>, "many">>;
+                sessionStrategy: import("zod").ZodOptional<import("zod").ZodEnum<["jwt", "database"]>>;
+            }, "strip", import("zod").ZodTypeAny, {
+                enabled: boolean;
+                providers?: ("credentials" | "google" | "github" | "discord")[] | undefined;
+                sessionStrategy?: "database" | "jwt" | undefined;
+            }, {
+                enabled: boolean;
+                providers?: ("credentials" | "google" | "github" | "discord")[] | undefined;
+                sessionStrategy?: "database" | "jwt" | undefined;
+            }>;
+            execute: (params: {
+                enabled: boolean;
+                providers?: ("credentials" | "google" | "github" | "discord")[];
+                sessionStrategy?: "jwt" | "database";
+            }) => Promise<import("./types").ToolResult>;
+        };
+        validate: {
+            description: string;
+            parameters: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+            execute: () => Promise<{
+                success: boolean;
+                message: string;
+                errors: import("..").ValidationError[];
+                warnings: import("..").ValidationError[];
+            }>;
+        };
+        generate: {
+            description: string;
+            parameters: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+            execute: () => Promise<{
+                success: boolean;
+                message: string;
+                files: string[];
+                errors: string[] | undefined;
+            }>;
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/ai/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ai/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,YAAY,EACV,cAAc,EACd,aAAa,EACb,UAAU,EACV,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EACb,UAAU,EACV,aAAa,EACb,YAAY,GACb,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAG/C,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAGzC,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAG1F,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAGtG,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACpD,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAMtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C;;GAEG;AACH,eAAO,MAAM,OAAO;IAClB;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;sBACe,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAEoG,CAAC;;;;;;;;;;yBAAqE,CAAC;8BAAc,CAAC;8BAAqB,CAAC;yBAAgB,CAAC;;yBAA6B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA6xB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAA2E,CAAC;;;;;;;;;;yBAAqE,CAAC;8BAAc,CAAC;8BAAqB,CAAC;yBAAgB,CAAC;;yBAA6B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAu4B,CAAC;mBAAa,CAAC;;;;;;;;;;;;;;;;;;;;yBAAme,CAAC;+BAA6E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAD7uF,CAAA"}

package/dist/src/ai/index.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * AI Module
+ *
+ * Ready-to-use tool definitions for AI frameworks (OpenAI, Anthropic, Vercel AI SDK).
+ *
+ * @module ai
+ *
+ * @example
+ * ```typescript
+ * // With Vercel AI SDK
+ * import { createManifestBuilder, aiTools } from 'archetype-engine/ai'
+ * import { generateText } from 'ai'
+ * import { openai } from '@ai-sdk/openai'
+ *
+ * const builder = createManifestBuilder()
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   tools: aiTools.vercel(builder),
+ *   system: 'You are an app builder. Use the tools to build the app.',
+ *   prompt: 'Create a blog with users and posts',
+ *   maxSteps: 10
+ * })
+ *
+ * // After AI finishes calling tools, generate the app
+ * const { files, success } = await builder.generate()
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiTools = exports.getVercelAITools = exports.createAnthropicHandler = exports.executeAnthropicTool = exports.getAnthropicTools = exports.createOpenAIHandler = exports.executeOpenAITool = exports.getOpenAITools = exports.toolDefinitions = exports.createManifestBuilder = void 0;
+// State
+var state_1 = require("./state");
+Object.defineProperty(exports, "createManifestBuilder", { enumerable: true, get: function () { return state_1.createManifestBuilder; } });
+// Tool definitions
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "toolDefinitions", { enumerable: true, get: function () { return tools_1.toolDefinitions; } });
+// OpenAI adapter
+var openai_1 = require("./adapters/openai");
+Object.defineProperty(exports, "getOpenAITools", { enumerable: true, get: function () { return openai_1.getOpenAITools; } });
+Object.defineProperty(exports, "executeOpenAITool", { enumerable: true, get: function () { return openai_1.executeOpenAITool; } });
+Object.defineProperty(exports, "createOpenAIHandler", { enumerable: true, get: function () { return openai_1.createOpenAIHandler; } });
+// Anthropic adapter
+var anthropic_1 = require("./adapters/anthropic");
+Object.defineProperty(exports, "getAnthropicTools", { enumerable: true, get: function () { return anthropic_1.getAnthropicTools; } });
+Object.defineProperty(exports, "executeAnthropicTool", { enumerable: true, get: function () { return anthropic_1.executeAnthropicTool; } });
+Object.defineProperty(exports, "createAnthropicHandler", { enumerable: true, get: function () { return anthropic_1.createAnthropicHandler; } });
+// Vercel AI SDK adapter
+var vercel_1 = require("./adapters/vercel");
+Object.defineProperty(exports, "getVercelAITools", { enumerable: true, get: function () { return vercel_1.getVercelAITools; } });
+// Import for aiTools convenience object
+const openai_2 = require("./adapters/openai");
+const anthropic_2 = require("./adapters/anthropic");
+const vercel_2 = require("./adapters/vercel");
+/**
+ * Convenience object for getting tools in different formats
+ */
+exports.aiTools = {
+    /**
+     * Get tools for OpenAI function calling
+     */
+    openai: () => (0, openai_2.getOpenAITools)(),
+    /**
+     * Get tools for Anthropic tool use
+     */
+    anthropic: () => (0, anthropic_2.getAnthropicTools)(),
+    /**
+     * Get tools for Vercel AI SDK (requires builder instance)
+     */
+    vercel: (builder) => (0, vercel_2.getVercelAITools)(builder),
+};

package/dist/src/ai/state.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ManifestBuilder - State manager for AI tool calls
+ *
+ * Tracks the manifest being built across multiple AI tool calls.
+ *
+ * @module ai/state
+ */
+import type { ManifestBuilder as IManifestBuilder } from './types';
+/**
+ * Create a new ManifestBuilder instance
+ */
+export declare function createManifestBuilder(): IManifestBuilder;
+//# sourceMappingURL=state.d.ts.map

package/dist/src/ai/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/ai/state.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EACV,eAAe,IAAI,gBAAgB,EAOpC,MAAM,SAAS,CAAA;AAKhB;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,gBAAgB,CAyOxD"}