alchemy 0.2.5 → 0.3.1

package/src/ai/approve.ts

@@ -0,0 +1,163 @@
+import type { CoreMessage } from "ai";
+import { type } from "arktype";
+import { Data } from "./data";
+
+/**
+ * Properties for approving or denying content
+ */
+export interface ApproveProps {
+  /**
+   * Content to be reviewed
+   * Use alchemy template literals to include file context:
+   * @example
+   * content: await alchemy`
+   *   Review this code:
+   *   ${alchemy.file("src/api.ts")}
+   * `
+   *
+   * Required unless messages are provided
+   */
+  content?: string;
+
+  /**
+   * Prompt for the approval decision
+   * This should include specific criteria for approval or denial
+   * @example
+   * prompt: "Approve this code if it follows security best practices and has proper error handling."
+   *
+   * Required unless messages are provided
+   */
+  prompt?: string;
+
+  /**
+   * System prompt for the model
+   * This is used to provide instructions to the model about how to make the decision
+   */
+  system?: string;
+
+  /**
+   * Message history for the conversation
+   * If provided, this will be used instead of the prompt and content
+   */
+  messages?: CoreMessage[];
+
+  /**
+   * Temperature for controlling randomness in generation.
+   * Higher values (e.g., 0.8) make output more random,
+   * lower values (e.g., 0.2) make it more deterministic.
+   * @default 0.2 (lower for more consistent decisions)
+   */
+  temperature?: number;
+}
+
+/**
+ * Result of the approval process
+ */
+export interface ApprovalResult {
+  /**
+   * Whether the content was approved
+   */
+  approved: boolean;
+
+  /**
+   * Explanation for the decision
+   */
+  explanation: string;
+
+  /**
+   * Suggestions for improvement if denied
+   */
+  suggestions?: string[];
+
+  /**
+   * Updated message history with the approval response appended
+   */
+  messages: CoreMessage[];
+}
+
+export type Approve = ApprovalResult;
+
+/**
+ * Default system prompt for approval decisions
+ */
+const DEFAULT_APPROVE_SYSTEM_PROMPT = `You are an expert content reviewer tasked with approving or denying content based on specific criteria.
+
+Your role is to:
+1. Carefully evaluate the content against the provided criteria
+2. Make a clear decision to approve or deny the content
+3. Provide a detailed explanation for your decision
+4. If denying, offer specific suggestions for improvement
+
+Be objective, thorough, and fair in your assessment.`;
+
+/**
+ * Approves or denies content based on a prompt or message history
+ *
+ * @example
+ * // Approve or deny a code file
+ * const result = await Approve("code-approval", {
+ *   content: await alchemy`
+ *     Review this API implementation:
+ *     ${alchemy.file("src/api.ts")}
+ *   `,
+ *   prompt: "Approve this code if it follows security best practices and has proper error handling."
+ * });
+ *
+ * if (result.approved) {
+ *   console.log("Content approved:", result.explanation);
+ * } else {
+ *   console.log("Content denied:", result.explanation);
+ *   console.log("Suggestions:", result.suggestions);
+ * }
+ *
+ * @example
+ * // Approve or deny using message history
+ * const result = await Approve("doc-approval-with-history", {
+ *   content: "This is the content to review",
+ *   prompt: "Approve this documentation if it is clear and accurate",
+ *   messages: [
+ *     { role: "user", content: "Can you review this documentation?" },
+ *     { role: "assistant", content: "Yes, I'd be happy to review it." },
+ *     { role: "user", content: "Please check for clarity and accuracy." }
+ *   ]
+ * });
+ */
+export async function Approve(
+  id: string,
+  props: ApproveProps
+): Promise<ApprovalResult> {
+  // Create messages array if not provided
+  const messages =
+    props.messages ||
+    (props.content && props.prompt
+      ? [
+          {
+            role: "user" as const,
+            content: `${props.content}\n\n${props.prompt}`,
+          },
+        ]
+      : []);
+
+  if (messages.length === 0) {
+    throw new Error(
+      "Either messages or both content and prompt must be provided"
+    );
+  }
+
+  const data = await Data(id, {
+    schema: type({
+      approved: "boolean",
+      explanation: "string",
+      suggestions: "string[]?",
+    }),
+    messages,
+    system: props.system || DEFAULT_APPROVE_SYSTEM_PROMPT,
+    temperature: props.temperature ?? 0.2,
+  });
+
+  // Return the result with updated messages from Data
+  return {
+    ...data.object,
+    messages: data.messages,
+  };
+}

package/src/ai/astro-file.ts

@@ -0,0 +1,269 @@
+import { generateText } from "ai";
+import prettier from "prettier";
+import type { Context } from "../context";
+import { StaticAstroFile } from "../fs/static-astro-file";
+import { Resource } from "../resource";
+import type { Secret } from "../secret";
+import { type ModelConfig, createModel } from "./client";
+
+/**
+ * Properties for creating or updating an AstroFile
+ */
+export interface AstroFileProps {
+  /**
+   * Path to the Astro file
+   */
+  path: string;
+
+  /**
+   * Base URL for the OpenAI API
+   * @default 'https://api.openai.com/v1'
+   */
+  baseURL?: string;
+
+  /**
+   * Prompt for generating content
+   * Use alchemy template literals to include file context:
+   * @example
+   * prompt: await alchemy`
+   *   Generate an Astro component using:
+   *   ${alchemy.file("src/types.ts")}
+   * `
+   */
+  prompt: string;
+
+  /**
+   * System prompt for the model
+   * This is used to provide instructions to the model about how to format the response
+   * The default system prompt instructs the model to return Astro code inside ```astro fences
+   * @default "You are an Astro component generator. Create Astro components based on the user's requirements. Your response MUST include only Astro code inside ```astro fences. Do not include any other text, explanations, or multiple code blocks."
+   */
+  system?: string;
+
+  /**
+   * OpenAI API key to use for generating content
+   * If not provided, will use OPENAI_API_KEY environment variable
+   */
+  apiKey?: Secret;
+
+  /**
+   * Model configuration
+   */
+  model?: ModelConfig;
+
+  /**
+   * Temperature for controlling randomness in generation.
+   * Higher values (e.g., 0.8) make output more random,
+   * lower values (e.g., 0.2) make it more deterministic.
+   * @default 0.7
+   */
+  temperature?: number;
+
+  /**
+   * Prettier configuration to use for formatting the Astro code
+   * If not provided, will use the default Prettier configuration
+   */
+  prettierConfig?: prettier.Options;
+}
+
+/**
+ * An Astro file that can be created, updated, and deleted
+ */
+export interface AstroFile extends AstroFileProps, Resource<"ai::AstroFile"> {
+  /**
+   * Content of the Astro file
+   */
+  content: string;
+
+  /**
+   * Time at which the file was created
+   */
+  createdAt: number;
+
+  /**
+   * Time at which the file was last updated
+   */
+  updatedAt: number;
+}
+
+/**
+ * Default system prompt for Astro file generation
+ */
+const DEFAULT_ASTRO_SYSTEM_PROMPT =
+  "You are an Astro component generator. Create Astro components based on the user's requirements. Your response MUST include only Astro code inside ```astro fences. Do not include any other text, explanations, or multiple code blocks.";
+
+/**
+ * Resource for generating Astro files using AI models.
+ * Extracts Astro code from between ```astro fences, validates the response,
+ * and formats the code with Prettier.
+ *
+ * @example
+ * // Create a simple Astro component
+ * const header = await AstroFile("header", {
+ *   path: "./src/components/Header.astro",
+ *   prompt: await alchemy`
+ *     Generate an Astro header component with:
+ *     - Site logo
+ *     - Navigation menu with Home, About, Services, Contact links
+ *     - Mobile responsive design
+ *     - Dark/light mode toggle
+ *   `,
+ *   model: {
+ *     id: "gpt-4o",
+ *     provider: "openai"
+ *   }
+ * });
+ *
+ * @example
+ * // Generate an Astro page with data fetching
+ * const blogPost = await AstroFile("blog-post", {
+ *   path: "./src/pages/blog/[slug].astro",
+ *   prompt: await alchemy`
+ *     Create an Astro blog post page that:
+ *     - Uses getStaticPaths to generate pages from a CMS
+ *     - Renders markdown content
+ *     - Includes author info, publication date, and related posts
+ *     - Has social sharing buttons
+ *
+ *     Use the following types:
+ *     ${alchemy.file("src/types/Blog.ts")}
+ *   `,
+ *   temperature: 0.2,
+ *   prettierConfig: {
+ *     semi: false,
+ *     singleQuote: true,
+ *     printWidth: 120
+ *   }
+ * });
+ *
+ * @example
+ * // Generate a layout with custom system prompt
+ * const mainLayout = await AstroFile("main-layout", {
+ *   path: "./src/layouts/MainLayout.astro",
+ *   prompt: await alchemy`
+ *     Create the main layout for an Astro site that:
+ *     - Includes common head metadata and SEO optimization
+ *     - Has slots for page content, header, and footer
+ *     - Imports and uses the Header and Footer components
+ *     - Sets up viewport and responsive configurations
+ *   `,
+ *   system: "You are an expert Astro developer. Create a single Astro layout file inside ```astro fences with no additional text. Follow Astro best practices and include proper typing in the frontmatter section.",
+ *   model: {
+ *     id: "claude-3-opus-20240229",
+ *     provider: "anthropic"
+ *   }
+ * });
+ */
+export const AstroFile = Resource(
+  "ai::AstroFile",
+  async function (
+    this: Context<AstroFile>,
+    id: string,
+    props: AstroFileProps
+  ): Promise<AstroFile> {
+    // Handle deletion phase
+    if (this.phase === "delete") {
+      return this.destroy();
+    }
+
+    // Use provided system prompt or default
+    const system = props.system || DEFAULT_ASTRO_SYSTEM_PROMPT;
+
+    // Generate initial content
+    const { text } = await generateText({
+      model: createModel(props),
+      prompt: props.prompt,
+      system,
+      providerOptions: props.model?.options,
+      ...(props.temperature === undefined
+        ? {}
+        : { temperature: props.temperature }),
+    });
+
+    // Extract and validate Astro code
+    let { code, error } = await extractAstroCode(text);
+
+    // Re-prompt if there are validation errors
+    if (error) {
+      const errorSystem = `${system}\n\nERROR: ${error}\n\nPlease try again and ensure your response contains exactly one Astro code block inside \`\`\`astro fences.`;
+
+      const { text: retryText } = await generateText({
+        model: createModel(props),
+        prompt: props.prompt,
+        system: errorSystem,
+        providerOptions: props.model?.options,
+        ...(props.temperature === undefined
+          ? {}
+          : { temperature: props.temperature }),
+      });
+
+      const retryResult = await extractAstroCode(retryText);
+
+      if (retryResult.error) {
+        throw new Error(
+          `Failed to generate valid Astro code: ${retryResult.error}`
+        );
+      }
+
+      code = retryResult.code;
+    }
+
+    // Format the code with Prettier
+    try {
+      // Set default parser to astro
+      const prettierOptions: prettier.Options = {
+        parser: "astro",
+        ...props.prettierConfig,
+      };
+
+      // Format the code
+      code = await prettier.format(code, prettierOptions);
+    } catch (error) {
+      // If Prettier formatting fails, just use the unformatted code
+      console.warn("Failed to format Astro code with Prettier:", error);
+    }
+
+    // Use StaticAstroFile to create/update the file
+    const file = await StaticAstroFile("file", props.path, code);
+
+    // Return the resource
+    return this({
+      ...props,
+      content: file.content,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+  }
+);
+
+/**
+ * Extracts Astro code from between ```astro fences
+ * Validates that exactly one Astro code block exists
+ *
+ * @param text The text to extract Astro code from
+ * @returns The extracted Astro code or error message
+ */
+async function extractAstroCode(
+  text: string
+): Promise<{ code: string; error?: string }> {
+  const astroCodeRegex = /```astro\s*([\s\S]*?)```/g;
+  const matches = Array.from(text.matchAll(astroCodeRegex));
+
+  if (matches.length === 0) {
+    return {
+      code: "",
+      error:
+        "No Astro code block found in the response. Please include your code within ```astro fences.",
+    };
+  }
+
+  if (matches.length > 1) {
+    return {
+      code: "",
+      error:
+        "Multiple Astro code blocks found in the response. Please provide exactly one code block within ```astro fences.",
+    };
+  }
+
+  return { code: matches[0][1].trim() };
+}

package/src/ai/client.ts

@@ -1,4 +1,5 @@
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { anthropic } from "@ai-sdk/anthropic";
+import { openai } from "@ai-sdk/openai";
 import type { Secret } from "../secret";
 
 /**
@@ -20,7 +21,7 @@ export interface ModelConfig {
   /**
    * Model-specific options
    */
-  options?: Record<string, unknown>;
+  options?: Record<string, any>;
 }
 
 /**
@@ -48,31 +49,69 @@ export interface ClientConfig {
 /**
  * Creates an OpenAI-compatible client with the given configuration
  */
-export function createClient(config: ClientConfig) {
-  // Get API key from props or environment
-  const apiKey = config.apiKey?.unencrypted || process.env.OPENAI_API_KEY;
-  if (!apiKey) {
-    throw new Error("OpenAI API key is required");
+export function createModel(config: ClientConfig) {
+  if (config.model?.provider === "anthropic") {
+    return anthropic(config.model?.id ?? "claude-3-7-sonnet-latest");
+  } else {
+    return openai(config.model?.id ?? "gpt-4o");
   }
-
-  // Initialize OpenAI compatible provider
-  return createOpenAICompatible({
-    name: config.model?.provider || "openai",
-    apiKey,
-    baseURL: config.baseURL || "https://api.openai.com/v1",
-  });
 }
 
 /**
- * Gets the model ID from the configuration or returns the default
+ * Maximum time to retry in milliseconds (5 minutes)
  */
-export function getModelId(config: ClientConfig): string {
-  return config.model?.id || "gpt-4o";
-}
+const MAX_RETRY_TIME = 5 * 60 * 1000;
+
+/**
+ * Initial delay between retries in milliseconds
+ */
+const INITIAL_RETRY_DELAY = 1000;
+
+/**
+ * Maximum number of retries
+ */
+const MAX_RETRIES = 10;
 
 /**
- * Gets the model options from the configuration
+ * Handles rate limiting with exponential backoff
+ * @param fn Function to retry
+ * @returns Result of the function
+ * @throws Error if max retries or time is exceeded
  */
-export function getModelOptions(config: ClientConfig): Record<string, unknown> {
-  return config.model?.options || {};
+export async function withRateLimitRetry<T>(fn: () => Promise<T>): Promise<T> {
+  let retryCount = 0;
+  let lastError: Error | null = null;
+  let startTime = Date.now();
+
+  while (true) {
+    try {
+      return await fn();
+    } catch (error: any) {
+      lastError = error;
+
+      console.log("retry error", error);
+
+      // Check if we should retry
+      const isRateLimit = error.statusCode === 429;
+      const timeElapsed = Date.now() - startTime;
+      const shouldRetry =
+        isRateLimit && retryCount < MAX_RETRIES && timeElapsed < MAX_RETRY_TIME;
+
+      if (!shouldRetry) {
+        throw error;
+      }
+
+      // Calculate delay with exponential backoff
+      const delay = Math.min(
+        INITIAL_RETRY_DELAY * Math.pow(2, retryCount),
+        MAX_RETRY_TIME - timeElapsed
+      );
+
+      console.log(`Retrying in ${delay}ms`);
+
+      // Wait before retrying
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      retryCount++;
+    }
+  }
 }