alchemy 0.3.0 → 0.3.1

package/src/ai/review.ts

@@ -0,0 +1,213 @@
+import { generateText, type CoreMessage } from "ai";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import type { Secret } from "../secret";
+import { createModel, withRateLimitRetry, type ModelConfig } from "./client";
+
+/**
+ * Properties for creating or updating a Review
+ */
+export interface ReviewProps {
+  /**
+   * 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 review
+   * This should include specific instructions for the review
+   * @example
+   * prompt: "Review this code for security vulnerabilities, performance issues, and best practices."
+   *
+   * Required unless messages are provided
+   */
+  prompt?: string;
+
+  /**
+   * Message history for the conversation
+   * If provided, this will be used instead of the prompt and content
+   */
+  messages?: CoreMessage[];
+
+  /**
+   * 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 act as a reviewer
+   */
+  system?: string;
+
+  /**
+   * AI 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;
+
+  /**
+   * Maximum number of tokens to generate.
+   * Higher values allow for longer documents but may increase cost and generation time.
+   * @default 10000
+   */
+  maxTokens?: number;
+}
+
+/**
+ * Output returned after Review creation/update
+ */
+export interface Review extends ReviewProps, Resource<"ai::Review"> {
+  /**
+   * Content of the review
+   */
+  content: string;
+
+  /**
+   * Updated message history with the review response appended
+   */
+  messages: CoreMessage[];
+
+  /**
+   * Time at which the review was created
+   */
+  createdAt: number;
+
+  /**
+   * Time at which the review was last updated
+   */
+  updatedAt: number;
+}
+
+/**
+ * Default system prompt for review generation
+ */
+const DEFAULT_REVIEW_SYSTEM_PROMPT = `You are an expert code reviewer and technical writer. Your task is to provide a thorough review of the provided content. Your review should include:
+
+1. A high-level summary of the content
+2. Detailed feedback on the content's quality, accuracy, and completeness
+3. Specific suggestions for improvement
+4. Alternative approaches or solutions where applicable
+5. Best practices that should be followed
+6. Potential issues or concerns that should be addressed
+
+Provide your review in a clear, well-structured format.`;
+
+/**
+ * Creates or updates a Review resource
+ *
+ * @example
+ * // Create a review of a code file
+ * const codeReview = await Review("api-review", {
+ *   content: await alchemy`
+ *     Review this API implementation:
+ *     ${alchemy.file("src/api.ts")}
+ *   `,
+ *   prompt: "Review this API implementation for security vulnerabilities, performance issues, and best practices. Suggest improvements and alternative approaches."
+ * });
+ *
+ * @example
+ * // Create a review of a document
+ * const docReview = await Review("tutorial-review", {
+ *   content: await alchemy`
+ *     Review this tutorial:
+ *     ${alchemy.file("docs/tutorials/getting-started.md")}
+ *   `,
+ *   prompt: "Review this tutorial for clarity, accuracy, and completeness. Suggest improvements to make it more user-friendly."
+ * });
+ *
+ * @example
+ * // Create a review with message history
+ * const reviewWithHistory = await Review("code-review-iteration-2", {
+ *   content: "Updated code implementation",
+ *   prompt: "Review this updated implementation",
+ *   messages: [
+ *     { role: "user", content: "Can you review my code?" },
+ *     { role: "assistant", content: "I'll review your code. Please share it." },
+ *     { role: "user", content: "Here's my implementation: [code]" },
+ *     { role: "assistant", content: "Here's my review of your code: [previous review]" }
+ *   ]
+ * });
+ */
+export const Review = Resource(
+  "ai::Review",
+  async function (
+    this: Context<Review>,
+    id: string,
+    props: ReviewProps
+  ): Promise<Review> {
+    if (this.phase === "delete") {
+      return this.destroy();
+    }
+
+    // Use provided system prompt or default
+    const system = props.system || DEFAULT_REVIEW_SYSTEM_PROMPT;
+
+    // Create messages array if not provided
+    const messages =
+      props.messages ||
+      (props.content && props.prompt
+        ? [
+            {
+              role: "user",
+              content: `${props.content}\n\n${props.prompt}`,
+            },
+          ]
+        : []);
+
+    if (messages.length === 0) {
+      throw new Error(
+        "Either messages or both content and prompt must be provided"
+      );
+    }
+
+    // Generate review content with rate limit retry
+    const { text } = await withRateLimitRetry(async () => {
+      return generateText({
+        model: createModel(props),
+        messages,
+        system,
+        maxTokens: props.maxTokens || 8192,
+        providerOptions: props.model?.options,
+        ...(props.temperature === undefined
+          ? {}
+          : { temperature: props.temperature }),
+      });
+    });
+
+    // Create updated message history with the AI's response
+    const updatedMessages = [
+      ...messages,
+      {
+        role: "assistant" as const,
+        content: text,
+      },
+    ];
+
+    // Return the review with the direct text from the LLM and updated messages
+    return this({
+      ...props,
+      content: text,
+      messages: updatedMessages,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+  }
+);

package/src/ai/typescript-file.ts

@@ -1,12 +1,9 @@
 import { generateText } from "ai";
-import fs from "node:fs/promises";
-import path from "node:path";
-import prettier from "prettier";
 import type { Context } from "../context";
+import { StaticTypeScriptFile } from "../fs/static-typescript-file";
 import { Resource } from "../resource";
 import type { Secret } from "../secret";
-import { ignore } from "../util/ignore";
-import { type ModelConfig, createModel } from "./client";
+import { createModel, type ModelConfig } from "./client";
 
 /**
  * Properties for creating or updating a TypeScriptFile
@@ -65,7 +62,7 @@ export interface TypeScriptFileProps {
    * Prettier configuration to use for formatting the TypeScript code
    * If not provided, will use the default Prettier configuration
    */
-  prettierConfig?: prettier.Options;
+  prettierConfig?: object;
 }
 
 /**
@@ -166,20 +163,11 @@ export const TypeScriptFile = Resource(
   async function (
     this: Context<TypeScriptFile>,
     id: string,
-    props: TypeScriptFileProps,
+    props: TypeScriptFileProps
   ): Promise<TypeScriptFile> {
-    // Ensure directory exists
-    await fs.mkdir(path.dirname(props.path), { recursive: true });
-
+    // Handle delete phase
     if (this.phase === "delete") {
-      try {
-        await fs.unlink(props.path);
-      } catch (error: any) {
-        // Ignore if file doesn't exist
-        if (error.code !== "ENOENT") {
-          throw error;
-        }
-      }
+      // StaticTypeScriptFile will handle the deletion
       return this.destroy();
     }
 
@@ -218,46 +206,24 @@ export const TypeScriptFile = Resource(
 
       if (retryResult.error) {
         throw new Error(
-          `Failed to generate valid TypeScript code: ${retryResult.error}`,
+          `Failed to generate valid TypeScript code: ${retryResult.error}`
         );
       }
 
       code = retryResult.code;
     }
 
-    // Format the code with Prettier
-    try {
-      // Set default parser to typescript
-      const prettierOptions: prettier.Options = {
-        parser: "typescript",
-        ...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 TypeScript code with Prettier:", error);
-    }
-
-    if (this.phase === "update" && props.path !== this.props.path) {
-      await ignore("ENOENT", () => fs.unlink(this.props.path));
-    }
-
-    // Write content to file
-    await fs.writeFile(props.path, code);
-
-    // Get file stats for timestamps
-    const stats = await fs.stat(props.path);
+    // Use StaticTypeScriptFile to create/update the file
+    const file = await StaticTypeScriptFile("file", props.path, code);
 
     // Return the resource
     return this({
       ...props,
-      content: code,
-      createdAt: stats.birthtimeMs,
-      updatedAt: stats.mtimeMs,
+      content: file.content,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
     });
-  },
+  }
 );
 
 /**
@@ -268,7 +234,7 @@ export const TypeScriptFile = Resource(
  * @returns The extracted TypeScript code or error message
  */
 async function extractTypeScriptCode(
-  text: string,
+  text: string
 ): Promise<{ code: string; error?: string }> {
   const tsCodeRegex = /```ts\s*([\s\S]*?)```/g;
   const matches = Array.from(text.matchAll(tsCodeRegex));

package/src/ai/vue-file.ts

@@ -1,10 +1,8 @@
 import { generateText } from "ai";
-import fs from "node:fs/promises";
-import path from "node:path";
 import type { Context } from "../context";
+import { StaticVueFile } from "../fs/static-vue-file";
 import { Resource } from "../resource";
 import type { Secret } from "../secret";
-import { ignore } from "../util/ignore";
 import { type ModelConfig, createModel } from "./client";
 
 /**
@@ -149,20 +147,10 @@ export const VueFile = Resource(
   async function (
     this: Context<VueFile>,
     id: string,
-    props: VueFileProps,
+    props: VueFileProps
   ): Promise<VueFile> {
-    // Ensure directory exists
-    await fs.mkdir(path.dirname(props.path), { recursive: true });
-
+    // Handle deletion phase
     if (this.phase === "delete") {
-      try {
-        await fs.unlink(props.path);
-      } catch (error: any) {
-        // Ignore if file doesn't exist
-        if (error.code !== "ENOENT") {
-          throw error;
-        }
-      }
       return this.destroy();
     }
 
@@ -201,31 +189,24 @@ export const VueFile = Resource(
 
       if (retryResult.error) {
         throw new Error(
-          `Failed to generate valid Vue code: ${retryResult.error}`,
+          `Failed to generate valid Vue code: ${retryResult.error}`
         );
       }
 
       code = retryResult.code;
     }
 
-    if (this.phase === "update" && props.path !== this.props.path) {
-      await ignore("ENOENT", () => fs.unlink(this.props.path));
-    }
-
-    // Write content to file
-    await fs.writeFile(props.path, code);
-
-    // Get file stats for timestamps
-    const stats = await fs.stat(props.path);
+    // Use StaticVueFile to create/update the file
+    const file = await StaticVueFile("file", props.path, code);
 
     // Return the resource
     return this({
       ...props,
-      content: code,
-      createdAt: stats.birthtimeMs,
-      updatedAt: stats.mtimeMs,
+      content: file.content,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
     });
-  },
+  }
 );
 
 /**
@@ -236,7 +217,7 @@ export const VueFile = Resource(
  * @returns The extracted Vue code or error message
  */
 async function extractVueCode(
-  text: string,
+  text: string
 ): Promise<{ code: string; error?: string }> {
   const vueCodeRegex = /```vue\s*([\s\S]*?)```/g;
   const matches = Array.from(text.matchAll(vueCodeRegex));

package/src/ai/yaml-file.ts

@@ -1,11 +1,9 @@
 import { generateObject, generateText } from "ai";
 import type { JsonSchema, Type, type } from "arktype";
-import fs from "node:fs/promises";
-import path from "node:path";
 import type { Context } from "../context";
+import { StaticYamlFile } from "../fs/static-yaml-file";
 import { Resource } from "../resource";
 import type { Secret } from "../secret";
-import { ignore } from "../util/ignore";
 import { ark } from "./ark";
 import { type ModelConfig, createModel } from "./client";
 
@@ -200,32 +198,11 @@ export const YAMLFile = Resource("ai::YAMLFile", async function <
 >(this: Context<YAMLFile<T extends Type<any, any> ? type.infer<T> : any>>, id: string, props: YAMLFileProps<T>): Promise<
   YAMLFile<T extends Type<any, any> ? type.infer<T> : any>
 > {
-  // Ensure directory exists
-  await fs.mkdir(path.dirname(props.path), { recursive: true });
-
+  // Handle deletion phase
   if (this.phase === "delete") {
-    try {
-      await fs.unlink(props.path);
-    } catch (error: any) {
-      // Ignore if file doesn't exist
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
     return this.destroy();
   }
 
-  // Dynamic import js-yaml to avoid dependency issues
-  // This allows the code to work even if js-yaml is not installed
-  let yaml: typeof import("yaml");
-  try {
-    yaml = await import("yaml");
-  } catch (err) {
-    throw new Error(
-      "The 'yaml' package is required for the YAMLFile resource. Please install it with: bun add yaml",
-    );
-  }
-
   let yamlContent: string;
   let yamlObject: any;
 
@@ -247,16 +224,9 @@ export const YAMLFile = Resource("ai::YAMLFile", async function <
 
     yamlObject = object;
 
-    // Convert object to YAML
-    try {
-      yamlContent = yaml.stringify(yamlObject, {
-        indent: 2,
-      });
-    } catch (error) {
-      throw new Error(
-        `Failed to convert object to YAML: ${(error as Error).message}`,
-      );
-    }
+    // Let StaticYamlFile handle the YAML conversion
+    const file = await StaticYamlFile("file", props.path, yamlObject);
+    yamlContent = file.content;
   } else {
     // Use fence-based extraction
     // Use provided system prompt or default
@@ -301,32 +271,22 @@ export const YAMLFile = Resource("ai::YAMLFile", async function <
 
     yamlContent = content;
 
-    // Parse YAML to validate and get object representation
-    try {
-      yamlObject = yaml.parse(yamlContent);
-    } catch (error) {
-      throw new Error(`Failed to parse YAML: ${(error as Error).message}`);
-    }
-  }
+    // Create the file with the string content
+    const file = await StaticYamlFile("file", props.path, yamlContent);
 
-  if (this.phase === "update" && props.path !== this.props.path) {
-    await ignore("ENOENT", () => fs.unlink(this.props.path));
+    // We need to parse the YAML to get the object representation
+    const yaml = await import("yaml");
+    yamlObject = yaml.parse(yamlContent);
   }
 
-  // Write content to file
-  await fs.writeFile(props.path, yamlContent);
-
-  // Get file stats for timestamps
-  const stats = await fs.stat(props.path);
-
   // Return the resource
   return this({
     ...props,
     schema: props.schema,
     content: yamlContent,
     yaml: yamlObject,
-    createdAt: stats.birthtimeMs,
-    updatedAt: stats.mtimeMs,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
   });
 });
 
@@ -338,7 +298,7 @@ export const YAMLFile = Resource("ai::YAMLFile", async function <
  * @returns The extracted YAML or error message
  */
 async function extractYAMLContent(
-  text: string,
+  text: string
 ): Promise<{ content: string; error?: string }> {
   // Check for yaml or yml fence blocks
   const yamlCodeRegex = /```(yaml|yml)\s*([\s\S]*?)```/g;

package/src/alchemy.ts

@@ -111,6 +111,16 @@ function _alchemy(
         values.map(async function resolve(value): Promise<string> {
           if (typeof value === "string") {
             return indent + value;
+          } else if (value === null) {
+            return "null";
+          } else if (value === undefined) {
+            return "undefined";
+          } else if (
+            typeof value === "number" ||
+            typeof value === "boolean" ||
+            typeof value === "bigint"
+          ) {
+            return value.toString();
           } else if (value instanceof Promise) {
             return resolve(await value);
           } else if (isFileRef(value)) {
@@ -128,14 +138,15 @@ function _alchemy(
           } else if (Array.isArray(value)) {
             return (
               await Promise.all(
-                value.map(async (value, i) => `${i}. ${await resolve(value)}`),
+                value.map(async (value, i) => `${i}. ${await resolve(value)}`)
               )
             ).join("\n");
           } else {
             // TODO: support other types
-            throw new Error(`Unsupported value type: ${JSON.stringify(value)}`);
+            console.log(value);
+            throw new Error(`Unsupported value type: ${value}`);
           }
-        }),
+        })
       );
 
       // Construct the string template by joining template parts with interpolated values
@@ -144,12 +155,12 @@ function _alchemy(
           part
             .split("\n")
             .map((line) =>
-              line.startsWith(indent) ? line.slice(indent.length) : line,
+              line.startsWith(indent) ? line.slice(indent.length) : line
             )
-            .join("\n"),
+            .join("\n")
         )
         .flatMap((part, i) =>
-          i < stringValues.length ? [part, stringValues[i] ?? ""] : [part],
+          i < stringValues.length ? [part, stringValues[i] ?? ""] : [part]
         )
         .join("")
         .split("\n");
@@ -240,7 +251,7 @@ export interface AlchemyOptions {
  */
 function scope(
   id: string | undefined,
-  options?: AlchemyOptions,
+  options?: AlchemyOptions
   // TODO: maybe we want to allow using _ = await alchemy.scope(import.meta)
   // | [meta: ImportMeta]
 ): Scope {

package/src/apply.ts

@@ -19,7 +19,7 @@ export interface ApplyOptions {
 export async function apply<Out extends Resource>(
   resource: PendingResource<Out>,
   props: ResourceProps | undefined,
-  options?: ApplyOptions,
+  options?: ApplyOptions
 ): Promise<Awaited<Out>> {
   const scope = resource.Scope;
   try {
@@ -64,18 +64,18 @@ export async function apply<Out extends Resource>(
                 "@secret": value.unencrypted,
               }
             : value,
-        2,
+        2
       );
       const newProps = JSON.stringify(
         await serialize(scope, props, {
           encrypt: false,
         }),
         null,
-        2,
+        2
       );
       if (oldProps === newProps && alwaysUpdate !== true) {
         if (!quiet) {
-          console.log(`Skip:    "${resource.FQN}" (no changes)`);
+          // console.log(`Skip:    "${resource.FQN}" (no changes)`);
         }
         return state.output as Awaited<Out>;
       }
@@ -88,7 +88,7 @@ export async function apply<Out extends Resource>(
 
     if (!quiet) {
       console.log(
-        `${phase === "create" ? "Create" : "Update"}:  "${resource.FQN}"`,
+        `${phase === "create" ? "Create" : "Update"}:  "${resource.FQN}"`
       );
     }
 
@@ -108,7 +108,7 @@ export async function apply<Out extends Resource>(
       replace: () => {
         if (isReplaced) {
           console.warn(
-            `Resource ${resource.Kind} ${resource.FQN} is already marked as REPLACE`,
+            `Resource ${resource.Kind} ${resource.FQN} is already marked as REPLACE`
           );
           return;
         }
@@ -117,11 +117,11 @@ export async function apply<Out extends Resource>(
     });
 
     const output = await alchemy.run(resource.ID, async () =>
-      provider.handler.bind(ctx)(resource.ID, props),
+      provider.handler.bind(ctx)(resource.ID, props)
     );
     if (!quiet) {
       console.log(
-        `${phase === "create" ? "Created" : "Updated"}: "${resource.FQN}"`,
+        `${phase === "create" ? "Created" : "Updated"}: "${resource.FQN}"`
       );
     }
 

package/src/cloudflare/generate-asset-manifest.ts

@@ -17,10 +17,10 @@ export async function generateAssetManifest(
       cacheControl: "max-age=0,no-cache,no-store,must-revalidate",
     },
     {
-      files: ["**/*.js", "**/*.css"],
+      files: ["**/*.js", "**/*.css", "**/*.png", "**/*.webp"],
       cacheControl: "max-age=31536000,public,immutable",
     },
-  ],
+  ]
 ): Promise<AssetManifest> {
   // First, collect all file info based on fileOptions (reversed to prioritize later rules)
   const fileInfos: Array<{
@@ -55,7 +55,7 @@ export async function generateAssetManifest(
                 : (fileOption.ignore ?? [])),
             ],
           });
-        }),
+        })
       )
     )
       .flat()
@@ -86,7 +86,7 @@ export async function generateAssetManifest(
         cacheControl,
         contentType: contentType ?? getContentType(file),
       } satisfies AssetManifestEntry;
-    }),
+    })
   );
 
   return manifestEntries;