alchemy 0.3.1 → 0.4.0

package/src/{util/serde.ts → serde.ts}

@@ -1,6 +1,6 @@
-import { Scope } from "../scope";
-import { Secret } from "../secret";
-import { decryptWithKey, encryptWithKey } from "./encrypt";
+import { decryptWithKey, encrypt } from "./encrypt";
+import { Scope } from "./scope";
+import { Secret } from "./secret";
 
 import type { Type } from "arktype";
 
@@ -18,7 +18,7 @@ export async function serialize(
   value: any,
   options?: {
     encrypt?: boolean;
-  },
+  }
 ): Promise<any> {
   if (Array.isArray(value)) {
     return Promise.all(value.map((value) => serialize(scope, value, options)));
@@ -29,13 +29,17 @@ export async function serialize(
     return {
       "@secret":
         options?.encrypt !== false
-          ? await encryptWithKey(value.unencrypted, scope.password)
+          ? await encrypt(value.unencrypted, scope.password)
           : value.unencrypted,
     };
   } else if (isType(value)) {
     return {
       "@schema": value.toJSON(),
     };
+  } else if (value instanceof Date) {
+    return {
+      "@date": value.toISOString(),
+    };
   } else if (value instanceof Scope) {
     return undefined;
   } else if (value && typeof value === "object") {
@@ -44,8 +48,8 @@ export async function serialize(
         Object.entries(value).map(async ([key, value]) => [
           key,
           await serialize(scope, value, options),
-        ]),
-      ),
+        ])
+      )
     );
   }
   return value;
@@ -54,7 +58,7 @@ export async function serialize(
 export async function deserialize(scope: Scope, value: any): Promise<any> {
   if (Array.isArray(value)) {
     return await Promise.all(
-      value.map(async (item) => await deserialize(scope, item)),
+      value.map(async (item) => await deserialize(scope, item))
     );
   } else if (value && typeof value === "object") {
     if (typeof value["@secret"] === "string") {
@@ -64,14 +68,16 @@ export async function deserialize(scope: Scope, value: any): Promise<any> {
       return new Secret(await decryptWithKey(value["@secret"], scope.password));
     } else if ("@schema" in value) {
       return value["@schema"];
+    } else if ("@date" in value) {
+      return new Date(value["@date"]);
     } else {
       return Object.fromEntries(
         await Promise.all(
           Object.entries(value).map(async ([key, value]) => [
             key,
             await deserialize(scope, value),
-          ]),
-        ),
+          ])
+        )
       );
     }
   }

package/src/test/bun.ts

@@ -78,7 +78,7 @@ type test = {
     name: string,
     options: TestOptions,
     fn: (scope: Scope) => Promise<any>,
-    timeout?: number,
+    timeout?: number
   ): void;
 
   /**
@@ -121,6 +121,7 @@ type test = {
  * ```
  */
 export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
+  let isFailed = false;
   defaultOptions = defaultOptions ?? {};
   if (
     defaultOptions.stateStore === undefined &&
@@ -129,7 +130,7 @@ export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
   ) {
     defaultOptions.stateStore = (scope) =>
       new R2RestStateStore(scope, {
-        apiKey: process.env.CLOUDFLARE_API_KEY,
+        apiKey: alchemy.secret(process.env.CLOUDFLARE_API_KEY),
         email: process.env.CLOUDFLARE_EMAIL,
         bucketName: process.env.CLOUDFLARE_BUCKET_NAME!,
       });
@@ -150,7 +151,7 @@ export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
     {
       // parent: globalTestScope,
       stateStore: defaultOptions?.stateStore,
-    },
+    }
   );
   test.scope = localTestScope;
 
@@ -170,7 +171,7 @@ export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
 
   // Clean up test scope after all tests complete
   afterAll(async () => {
-    if (defaultOptions?.destroy !== false) {
+    if (defaultOptions?.destroy !== false && !isFailed) {
       await alchemy.destroy(test.scope);
     }
   });
@@ -192,8 +193,8 @@ export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
       obj && typeof obj === "object"
         ? Object.fromEntries(
             Object.entries(obj).flatMap(([k, v]) =>
-              v !== undefined ? [[k, v]] : [],
-            ),
+              v !== undefined ? [[k, v]] : []
+            )
           )
         : {};
 
@@ -229,7 +230,7 @@ export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
             }
           }
         });
-      },
+      }
     );
   }
 }

package/src/util/sha256.ts

@@ -0,0 +1,5 @@
+import { createHash } from "node:crypto";
+
+export function sha256(value: string): string {
+  return createHash("sha256").update(value).digest("hex");
+}

package/src/web/vitepress/config.ts

@@ -1,11 +1,12 @@
 import path from "path";
-import type { DefaultTheme, ThemeOptions } from "vitepress";
+import type { DefaultTheme, HeadConfig, ThemeOptions } from "vitepress";
 import { StaticTypeScriptFile } from "../../fs/static-typescript-file";
 
 export type VitePressConfigProps = {
   cwd: string;
   title?: string;
   description?: string;
+  head?: HeadConfig[];
   theme?: ThemeOptions;
   themeConfig: DefaultTheme.Config;
 };
@@ -23,6 +24,7 @@ import { defineConfig } from "vitepress";
 export default defineConfig({
   title: ${JSON.stringify(props.title || "Alchemy")},
   description: ${JSON.stringify(props.description || "Alchemy Docs")},
+  head: ${JSON.stringify(props.head || [])},
   markdown: {
     // @ts-ignore
     codeTransformers: [transformerTwoslash()],

package/src/web/vitepress/index.ts

@@ -1,4 +1,5 @@
 export * from "./config";
 export * from "./custom-theme";
 export * from "./home-page";
+export * from "./process-front-matter-files";
 export * from "./vitepress";

package/src/web/vitepress/process-front-matter-files.ts

@@ -0,0 +1,98 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+/**
+ * Process markdown files with frontmatter to generate navigation items
+ * @param directoryPath The directory containing markdown files
+ * @param linkPrefix The prefix for navigation links
+ * @returns Sorted array of navigation items with text and link properties
+ */
+export async function processFrontmatterFiles(
+  directoryPath: string,
+  linkPrefix: string
+): Promise<
+  {
+    text: string;
+    link: string;
+    items?: {
+      text: string;
+      link: string;
+      items?: { text: string; link: string }[];
+    }[];
+  }[]
+> {
+  const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+
+  const processedEntries = await Promise.all(
+    entries
+      .filter((entry) => !entry.name.endsWith("index.md"))
+      .map(async (entry) => {
+        const fullPath = path.join(directoryPath, entry.name);
+
+        if (entry.isDirectory()) {
+          // Process subdirectory recursively
+          const items = await processFrontmatterFiles(
+            fullPath,
+            `${linkPrefix}/${entry.name}`
+          );
+
+          // Create section for subdirectory
+          return {
+            text: entry.name.charAt(0).toUpperCase() + entry.name.slice(1),
+            collapsed: false,
+            items,
+            order: 10000, // Default order for directories
+          };
+        }
+
+        // Process markdown file
+        if (!entry.name.endsWith(".md")) {
+          return null;
+        }
+
+        const content = await fs.readFile(fullPath, "utf-8");
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        let order = 10000;
+        let title;
+
+        if (frontmatterMatch) {
+          const frontmatter = frontmatterMatch[1];
+          const orderMatch = frontmatter.match(/order:\s*(\d+)/);
+          if (orderMatch) {
+            order = parseInt(orderMatch[1]);
+          }
+          const titleMatch = frontmatter.match(/title:\s*(.+)/);
+          if (titleMatch) {
+            title = titleMatch[1].trim();
+          }
+        }
+
+        // If no title in frontmatter, try to get first heading
+        if (!title) {
+          const headingMatch = content.match(/^#\s+(.+)$/m);
+          if (headingMatch) {
+            title = headingMatch[1].trim();
+          }
+        }
+
+        // Fall back to filename if no title found
+        if (!title) {
+          const name = entry.name.replace(".md", "");
+          title = name.charAt(0).toUpperCase() + name.slice(1);
+        }
+
+        return {
+          text: title,
+          link: `${linkPrefix}/${entry.name}`,
+          order,
+        };
+      })
+  );
+
+  // Filter out null entries and sort by order
+  return processedEntries
+    .filter((entry) => entry !== null)
+    .sort((a, b) => a.order - b.order)
+    .map(({ text, link, items }) =>
+      items ? { text, items, collapsed: true } : { text, link }
+    ) as any;
+}

package/src/web/vitepress/vitepress.ts

@@ -117,8 +117,9 @@ export const VitepressProject = Resource(
       try {
         if (props.delete !== false) {
           if (await fs.exists(dir)) {
-            // Delete the entire project directory
-            await execAsync(`rm -rf ${dir}`);
+            await fs.rm(dir, { recursive: true, force: true });
+            // // Delete the entire project directory
+            // await execAsync(`rm -rf ${dir}`);
           }
         }
       } catch (error) {

package/lib/ai/approve.d.ts

@@ -1,99 +0,0 @@
-import type { CoreMessage } from "ai";
-/**
- * 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;
-/**
- * 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 declare function Approve(id: string, props: ApproveProps): Promise<ApprovalResult>;

package/lib/ai/approve.js

@@ -1,76 +0,0 @@
-import { type } from "arktype";
-import { Data } from "./data";
-/**
- * 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, props) {
-    // 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");
-    }
-    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/lib/ai/review.d.ts

@@ -1,122 +0,0 @@
-import { type CoreMessage } from "ai";
-import type { Context } from "../context";
-import { Resource } from "../resource";
-import type { Secret } from "../secret";
-import { 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;
-}
-/**
- * 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 declare const Review: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<Review>, id: string, props: ReviewProps) => Promise<Review>);

package/lib/ai/review.js

@@ -1,101 +0,0 @@
-import { generateText } from "ai";
-import { Resource } from "../resource";
-import { createModel, withRateLimitRetry } from "./client";
-/**
- * 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 (id, props) {
-    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",
-            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(),
-    });
-});