alchemy 0.0.8 → 0.1.2

package/src/components/agent/typescript.ts

@@ -0,0 +1,177 @@
+import type { CoreMessage } from "ai";
+import { generateText } from "ai";
+import { mkdir, unlink, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { z } from "zod";
+import { Agent } from "./agent";
+import { resolveModel } from "./model";
+
+export type CodeProps = z.infer<typeof CodeProps>;
+
+export type File = z.infer<typeof File>;
+export const File = z.object({
+  path: z.string(),
+  content: z.string(),
+});
+
+const CodeProps = z.object({
+  /**
+   * The ID of the model to use for generating TypeScript code
+   * @default "gpt-4o"
+   */
+  modelId: z.string().optional(),
+
+  /**
+   * The name of the file to write the code to
+   */
+  path: z.string(),
+
+  /**
+   * The requirements for the TypeScript file
+   */
+  requirements: z.string(),
+
+  /**
+   * List of other code files that it depends on
+   */
+  dependencies: z.array(File).optional(),
+
+  /**
+   * Temperature setting for model generation (higher = more creative, lower = more focused)
+   * @default 0.7
+   */
+  temperature: z.number().optional(),
+});
+
+export type CodeOutput = z.infer<typeof CodeOutput>;
+export const CodeOutput = File;
+
+export class TypeScriptFile extends Agent(
+  "code::TypeScriptFile",
+  {
+    description:
+      "This Agent is responsible for generating TypeScript code based on requirements and context from other code files.",
+    input: CodeProps,
+    output: CodeOutput,
+  },
+  async (ctx, props) => {
+    if (ctx.event === "delete") {
+      await unlink(props.path);
+      return;
+    }
+
+    // Get the appropriate model based on the ID
+    const { model } = await resolveModel(props.modelId ?? "gpt-4o");
+
+    // Generate the TypeScript code with retries
+    const content = await generateCodeWithRetries(model, props);
+
+    // Ensure the directory exists
+    await mkdir(dirname(props.path), { recursive: true });
+
+    // Write the TypeScript file
+    await writeFile(props.path, content);
+
+    return {
+      path: props.path,
+      content: content,
+    };
+  },
+) {}
+
+/**
+ * Attempts to generate valid TypeScript code with retries
+ */
+async function generateCodeWithRetries(
+  model: any,
+  props: CodeProps,
+  maxAttempts = 3,
+): Promise<string> {
+  const baseMessages: CoreMessage[] = [
+    {
+      role: "system",
+      content:
+        "You are an expert TypeScript developer that generates clean, well-documented code following best practices. " +
+        "Your response must follow this exact format:\n" +
+        "1. A single sentence describing what the code will do\n" +
+        "2. A single TypeScript code block surrounded by ```ts and ``` tags\n" +
+        "Do not include any other explanations or multiple code blocks.",
+    },
+    {
+      role: "user",
+      content: `Please generate TypeScript code based on the following specifications:
+
+Requirements:
+${props.requirements}
+
+${
+  props.dependencies?.length
+    ? `Context (other code files):
+${props.dependencies.map((dep) => dep.content).join("\n\n")}`
+    : ""
+}
+
+The code should:
+1. Be well-documented with JSDoc comments
+2. Follow TypeScript best practices
+3. Include proper type definitions
+4. Be ready to use with the provided context files
+
+Your response MUST follow this format:
+- One sentence summary of what the code will do
+- Single TypeScript code block surrounded by \`\`\`ts and \`\`\` tags
+- No other explanations or multiple code blocks`,
+    },
+  ];
+
+  const messages = [...baseMessages];
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const { text } = await generateText({
+      model,
+      temperature: Math.max(
+        0.1,
+        (props.temperature ?? 0.7) * (1 - attempt * 0.2),
+      ), // Reduce temperature with each attempt
+      messages,
+    });
+
+    const code = extractTypeScriptCode(text);
+    if (code) {
+      return code;
+    }
+
+    if (attempt === maxAttempts) {
+      throw new Error(
+        "Failed to generate valid TypeScript code after maximum attempts",
+      );
+    }
+
+    // Add the failed attempt and correction request to the message chain
+    messages.push(
+      {
+        role: "assistant",
+        content: text,
+      },
+      {
+        role: "user",
+        content:
+          "Your response did not match the required format. Please provide your response with exactly one sentence summary" +
+          " followed by a single TypeScript code block surrounded by ```ts and ``` tags. No other text or explanations.",
+      },
+    );
+  }
+
+  // This should never be reached due to the throw above
+  throw new Error("Unexpected code generation failure");
+}
+
+/**
+ * Extracts TypeScript code from a markdown code block
+ * @param text Response text that may contain markdown
+ * @returns The TypeScript code if found, undefined otherwise
+ */
+function extractTypeScriptCode(text: string): string | undefined {
+  const matches = text.match(/```(?:ts|typescript)\n([\s\S]*?)```/);
+  return matches?.[1]?.trim();
+}

package/src/components/aws/bucket.ts

@@ -0,0 +1,168 @@
+import {
+  CreateBucketCommand,
+  DeleteBucketCommand,
+  GetBucketAclCommand,
+  GetBucketLocationCommand,
+  GetBucketTaggingCommand,
+  GetBucketVersioningCommand,
+  HeadBucketCommand,
+  NoSuchBucket,
+  PutBucketTaggingCommand,
+  S3Client,
+} from "@aws-sdk/client-s3";
+import { ignore } from "../../error";
+import { Resource } from "../../resource";
+
+export interface BucketProps {
+  bucketName: string;
+  tags?: Record<string, string>;
+}
+
+export interface BucketOutput extends BucketProps {
+  id: string; // Same as bucketName for AWS
+  arn: string;
+  bucketDomainName: string; // Format: bucket-name.s3.amazonaws.com
+  bucketRegionalDomainName?: string; // Format: bucket-name.s3.region.amazonaws.com
+  hostedZoneId?: string; // S3 hosted zone ID for the region
+  region?: string; // AWS Region where bucket resides
+  websiteEndpoint?: string; // Only if website hosting is enabled
+  websiteDomain?: string; // Only if website hosting is enabled
+  versioningEnabled?: boolean;
+  acl?: string;
+}
+
+export class Bucket extends Resource(
+  "s3::Bucket",
+  async (ctx, props: BucketProps) => {
+    const client = new S3Client({});
+
+    if (ctx.event === "delete") {
+      await ignore(NoSuchBucket.name, () =>
+        client.send(
+          new DeleteBucketCommand({
+            Bucket: props.bucketName,
+          }),
+        ),
+      );
+      return props;
+    } else {
+      try {
+        // Check if bucket exists
+        await client.send(
+          new HeadBucketCommand({
+            Bucket: props.bucketName,
+          }),
+        );
+
+        // Update tags if they changed and bucket exists
+        if (ctx.event === "update" && props.tags) {
+          await client.send(
+            new PutBucketTaggingCommand({
+              Bucket: props.bucketName,
+              Tagging: {
+                TagSet: Object.entries(props.tags).map(([Key, Value]) => ({
+                  Key,
+                  Value,
+                })),
+              },
+            }),
+          );
+        }
+      } catch (error: any) {
+        if (error.name === "NotFound") {
+          // Create bucket if it doesn't exist
+          await client.send(
+            new CreateBucketCommand({
+              Bucket: props.bucketName,
+              // Add tags during creation if specified
+              ...(props.tags && {
+                Tagging: {
+                  TagSet: Object.entries(props.tags).map(([Key, Value]) => ({
+                    Key,
+                    Value,
+                  })),
+                },
+              }),
+            }),
+          );
+        } else {
+          throw error;
+        }
+      }
+
+      // Get bucket details
+      const [locationResponse, versioningResponse, aclResponse] =
+        await Promise.all([
+          client.send(
+            new GetBucketLocationCommand({ Bucket: props.bucketName }),
+          ),
+          client.send(
+            new GetBucketVersioningCommand({ Bucket: props.bucketName }),
+          ),
+          client.send(new GetBucketAclCommand({ Bucket: props.bucketName })),
+        ]);
+
+      const region = locationResponse.LocationConstraint || "us-east-1";
+
+      // Get tags if they exist
+      let tags = props.tags;
+      if (!tags) {
+        try {
+          const taggingResponse = await client.send(
+            new GetBucketTaggingCommand({ Bucket: props.bucketName }),
+          );
+          tags = Object.fromEntries(
+            taggingResponse.TagSet?.map(({ Key, Value }) => [Key, Value]) || [],
+          );
+        } catch (error: any) {
+          if (error.name !== "NoSuchTagSet") {
+            throw error;
+          }
+        }
+      }
+
+      const output: BucketOutput = {
+        bucketName: props.bucketName,
+        id: props.bucketName,
+        arn: `arn:aws:s3:::${props.bucketName}`,
+        bucketDomainName: `${props.bucketName}.s3.amazonaws.com`,
+        bucketRegionalDomainName: `${props.bucketName}.s3.${region}.amazonaws.com`,
+        region,
+        hostedZoneId: getHostedZoneId(region),
+        versioningEnabled: versioningResponse.Status === "Enabled",
+        acl: aclResponse.Grants?.[0]?.Permission?.toLowerCase(),
+        ...(tags && { tags }),
+      };
+
+      return output;
+    }
+  },
+) {}
+
+// Helper function to get S3 hosted zone IDs by region
+function getHostedZoneId(region: string): string {
+  const hostedZoneIds: Record<string, string> = {
+    "us-east-1": "Z3AQBSTGFYJSTF",
+    "us-east-2": "Z2O1EMRO9K5GLX",
+    "us-west-1": "Z2F56UZL2M1ACD",
+    "us-west-2": "Z3BJ6K6RIION7M",
+    "af-south-1": "Z11KHD8FBVPUYU",
+    "ap-east-1": "ZNB98KWMFR0R6",
+    "ap-south-1": "Z11RGJOFQNVJUP",
+    "ap-northeast-1": "Z2M4EHUR26P7ZW",
+    "ap-northeast-2": "Z3W03O7B5YMIYP",
+    "ap-northeast-3": "Z2YQB5RD63NC85",
+    "ap-southeast-1": "Z3O0J2DXBE1FTB",
+    "ap-southeast-2": "Z1WCIGYICN2BYD",
+    "ca-central-1": "Z1QDHH18159H29",
+    "eu-central-1": "Z21DNDUVLTQW6Q",
+    "eu-west-1": "Z1BKCTXD74EZPE",
+    "eu-west-2": "Z3GKZC51ZF0DB4",
+    "eu-west-3": "Z3R1K369G5AVDG",
+    "eu-north-1": "Z3BAZG2TWCNX0D",
+    "eu-south-1": "Z30OZKI7KPW7MI",
+    "me-south-1": "Z1MPMWCPA7YB62",
+    "sa-east-1": "Z7KQH4QJS55SO",
+  };
+  return hostedZoneIds[region] || "Z3AQBSTGFYJSTF"; // Default to us-east-1 if region not found
+}

package/src/components/aws/function.ts

@@ -0,0 +1,302 @@
+import {
+  Architecture,
+  CreateFunctionCommand,
+  DeleteFunctionCommand,
+  GetFunctionCommand,
+  GetFunctionConfigurationCommand,
+  LambdaClient,
+  ResourceNotFoundException,
+  Runtime,
+  UpdateFunctionCodeCommand,
+  UpdateFunctionConfigurationCommand,
+} from "@aws-sdk/client-lambda";
+import fs from "node:fs";
+import path from "node:path";
+import { ignore } from "../../error";
+import { Resource, type Context } from "../../resource";
+
+async function resolveRegion(client: LambdaClient): Promise<string> {
+  const region = client.config.region;
+  if (typeof region === "string") return region;
+  if (typeof region === "function") return region();
+  throw new Error("Could not resolve AWS region");
+}
+
+export interface FunctionProps {
+  functionName: string;
+  zipPath: string;
+  roleArn: string;
+  handler?: string;
+  runtime?: Runtime;
+  architecture?: Architecture;
+  description?: string;
+  timeout?: number;
+  memorySize?: number;
+  environment?: Record<string, string>;
+  tags?: Record<string, string>;
+  url?: {
+    authType?: "AWS_IAM" | "NONE";
+    cors?: {
+      allowCredentials?: boolean;
+      allowHeaders?: string[];
+      allowMethods?: string[];
+      allowOrigins?: string[];
+      exposeHeaders?: string[];
+      maxAge?: number;
+    };
+  };
+}
+
+export interface FunctionOutput extends FunctionProps {
+  id: string; // Same as functionName
+  arn: string;
+  lastModified: string;
+  version: string;
+  qualifiedArn: string; // ARN with version
+  invokeArn: string; // ARN for API Gateway
+  sourceCodeHash: string;
+  sourceCodeSize: number;
+  ephemeralStorageSize?: number;
+  architectures: string[];
+  masterArn?: string; // Only for Lambda@Edge
+  revisionId: string;
+  state?: string;
+  stateReason?: string;
+  stateReasonCode?: string;
+  lastUpdateStatus?: string;
+  lastUpdateStatusReason?: string;
+  lastUpdateStatusReasonCode?: string;
+  packageType: string;
+  signingProfileVersionArn?: string;
+  signingJobArn?: string;
+}
+
+export class Function extends Resource(
+  "lambda::Function",
+  async (ctx: Context<FunctionOutput>, props: FunctionProps) => {
+    const client = new LambdaClient({});
+    const region = await resolveRegion(client);
+
+    const code = await zipCode(props.zipPath);
+
+    if (ctx.event === "delete") {
+      await ignore(ResourceNotFoundException.name, () =>
+        client.send(
+          new DeleteFunctionCommand({
+            FunctionName: props.functionName,
+          }),
+        ),
+      );
+
+      // Return a minimal FunctionOutput for deleted state
+      return {
+        ...props,
+        id: props.functionName,
+        arn: `arn:aws:lambda:${region}:${process.env.AWS_ACCOUNT_ID}:function:${props.functionName}`,
+        lastModified: new Date().toISOString(),
+        version: "$LATEST",
+        qualifiedArn: `arn:aws:lambda:${region}:${process.env.AWS_ACCOUNT_ID}:function:${props.functionName}:$LATEST`,
+        invokeArn: `arn:aws:apigateway:${region}:lambda:path/2015-03-31/functions/arn:aws:lambda:${region}:${process.env.AWS_ACCOUNT_ID}:function:${props.functionName}/invocations`,
+        sourceCodeHash: "",
+        sourceCodeSize: 0,
+        architectures: props.architecture
+          ? [props.architecture]
+          : [Architecture.x86_64],
+        revisionId: "",
+        state: "Inactive",
+        packageType: "Zip",
+      };
+    } else {
+      try {
+        // Check if function exists
+        const func = await client.send(
+          new GetFunctionCommand({
+            FunctionName: props.functionName,
+          }),
+        );
+
+        if (ctx.event === "update") {
+          // Wait for function to stabilize
+          await waitForFunctionStabilization(client, props.functionName);
+
+          // Update function code
+          await client.send(
+            new UpdateFunctionCodeCommand({
+              FunctionName: props.functionName,
+              ZipFile: code,
+            }),
+          );
+
+          // Wait for code update to stabilize
+          await waitForFunctionStabilization(client, props.functionName);
+
+          // Update function configuration
+          await client.send(
+            new UpdateFunctionConfigurationCommand({
+              FunctionName: props.functionName,
+              Handler: props.handler,
+              Runtime: props.runtime,
+              Role: props.roleArn,
+              Description: props.description,
+              Timeout: props.timeout,
+              MemorySize: props.memorySize,
+              Environment: props.environment
+                ? { Variables: props.environment }
+                : undefined,
+            }),
+          );
+
+          // Wait for configuration update to stabilize
+          await waitForFunctionStabilization(client, props.functionName);
+        }
+      } catch (error: any) {
+        if (error.name === "ResourceNotFoundException") {
+          // Create function if it doesn't exist
+          const startTime = Date.now();
+          let delay = 100; // Start with 100ms delay
+
+          while (true) {
+            try {
+              await client.send(
+                new CreateFunctionCommand({
+                  FunctionName: props.functionName,
+                  Code: { ZipFile: code },
+                  Handler: props.handler || "index.handler",
+                  Runtime: props.runtime || Runtime.nodejs20x,
+                  Role: props.roleArn,
+                  Description: props.description,
+                  Timeout: props.timeout || 3,
+                  MemorySize: props.memorySize || 128,
+                  Environment: props.environment
+                    ? { Variables: props.environment }
+                    : undefined,
+                  Architectures: props.architecture
+                    ? [props.architecture]
+                    : [Architecture.x86_64],
+                  Tags: props.tags,
+                }),
+              );
+              break; // Success - exit retry loop
+            } catch (createError: any) {
+              if (
+                createError.name !== "InvalidParameterValueException" ||
+                !createError.message?.includes("cannot be assumed by Lambda")
+              ) {
+                throw createError; // Different error - rethrow
+              }
+
+              if (Date.now() - startTime > 10000) {
+                throw new Error(
+                  "Timeout waiting for IAM role to be assumable by Lambda after 10s",
+                );
+              }
+
+              await new Promise((resolve) => setTimeout(resolve, delay));
+              delay = Math.min(delay * 2, 1000); // Exponential backoff capped at 1s
+            }
+          }
+
+          // Wait for function to be active
+          let isCreating = true;
+          while (isCreating) {
+            const config = await client.send(
+              new GetFunctionConfigurationCommand({
+                FunctionName: props.functionName,
+              }),
+            );
+            isCreating = config.State === "Pending";
+            if (isCreating) {
+              await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+          }
+        } else {
+          throw error;
+        }
+      }
+
+      // Get complete function details
+      const [func, config] = await Promise.all([
+        client.send(
+          new GetFunctionCommand({
+            FunctionName: props.functionName,
+          }),
+        ),
+        client.send(
+          new GetFunctionConfigurationCommand({
+            FunctionName: props.functionName,
+          }),
+        ),
+      ]);
+
+      const output: FunctionOutput = {
+        ...props,
+        id: props.functionName,
+        arn: config.FunctionArn!,
+        lastModified: config.LastModified!,
+        version: config.Version!,
+        qualifiedArn: `${config.FunctionArn}:${config.Version}`,
+        invokeArn: `arn:aws:apigateway:${region}:lambda:path/2015-03-31/functions/${config.FunctionArn}/invocations`,
+        sourceCodeHash: config.CodeSha256!,
+        sourceCodeSize: config.CodeSize!,
+        ephemeralStorageSize: config.EphemeralStorage?.Size,
+        architectures: config.Architectures || [],
+        masterArn: config.MasterArn,
+        revisionId: config.RevisionId!,
+        state: config.State,
+        stateReason: config.StateReason,
+        stateReasonCode: config.StateReasonCode,
+        lastUpdateStatus: config.LastUpdateStatus,
+        lastUpdateStatusReason: config.LastUpdateStatusReason,
+        lastUpdateStatusReasonCode: config.LastUpdateStatusReasonCode,
+        packageType: config.PackageType!,
+        signingProfileVersionArn: config.SigningProfileVersionArn,
+        signingJobArn: config.SigningJobArn,
+      };
+
+      return output;
+    }
+  },
+) {}
+
+// Helper to wait for function to stabilize
+async function waitForFunctionStabilization(
+  client: LambdaClient,
+  functionName: string,
+) {
+  while (true) {
+    const config = await client.send(
+      new GetFunctionConfigurationCommand({
+        FunctionName: functionName,
+      }),
+    );
+
+    // Check if function is in a stable state
+    if (config.State === "Active" && config.LastUpdateStatus === "Successful") {
+      break;
+    }
+
+    // If there's a failure, throw an error
+    if (config.State === "Failed" || config.LastUpdateStatus === "Failed") {
+      throw new Error(
+        `Function failed to stabilize: ${config.StateReason || config.LastUpdateStatusReason}`,
+      );
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+}
+
+// Helper to zip the code
+async function zipCode(filePath: string): Promise<Buffer> {
+  const fileContent = await fs.promises.readFile(filePath);
+  const fileName = path.basename(filePath);
+
+  // Create a zip buffer in memory
+  const zip = new (await import("jszip")).default();
+  zip.file(fileName, fileContent);
+  return zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    platform: "UNIX",
+  });
+}

package/src/components/aws/index.ts

@@ -0,0 +1,6 @@
+export * from "./bucket";
+export * from "./function";
+export * from "./policy";
+export * from "./queue";
+export * from "./role";
+export * from "./table";