alchemy 0.0.8 → 0.1.1

package/package.json

@@ -1,28 +1,29 @@
 {
   "name": "alchemy",
-  "version": "0.0.8",
-  "description": "sql alchemy",
-  "main": "alchemy.js",
-  "scripts": {
-    "test": "make test",
-    "test-w": "make test-w",
-    "test-debug": "mocha --debug-brk --require should"
-  },
-  "author": "Radu Brehar",
-  "license": "MIT",
-  "dependencies": {
-    "pg": "~3.4.0",
-    "expect.js": "^0.3.0",
-    "functionally": "^0.2.1",
-    "classy": "^1.4.0",
-    "bluebird": "~2.2.2",
-    "bunyan": "^0.23.1",
-    "jsesc": "~0.4.3",
-    "newify": "~1.0.0",
-    "ustring": "^1.1.1"
+  "version": "0.1.1",
+  "module": "index.ts",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./agent": "./src/components/agent/index.ts",
+    "./fs": "./src/components/fs/index.ts",
+    "./aws": "./src/components/aws/index.ts",
+    "./esbuild": "./src/components/esbuild.ts"
   },
   "devDependencies": {
-    "should": "~4.0.4",
-    "mocha": "~1.20.1"
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "@ai-sdk/openai": "^1.0.0",
+    "@aws-sdk/client-dynamodb": "^3.0.0",
+    "@aws-sdk/client-iam": "^3.0.0",
+    "@aws-sdk/client-lambda": "^3.0.0",
+    "@aws-sdk/client-s3": "^3.0.0",
+    "@aws-sdk/client-sqs": "^3.0.1",
+    "ai": "^4.0.0",
+    "jszip": "^3.0.0",
+    "esbuild": "^0.24.2",
+    "turndown": "^7.2.0",
+    "zod": "^3.24.1"
   }
 }

package/src/alchemize.ts

@@ -0,0 +1,151 @@
+import { evaluate } from "./apply";
+import { destroy } from "./destroy";
+import { defaultStage, nodes, providers, stateStore } from "./global";
+import type { StateStore } from "./state";
+
+let finalized = false;
+
+export interface AlchemizeOptions {
+  /**
+   * Determines whether the resources will be created/updated or deleted.
+   *
+   * @default "up"
+   */
+  mode?: "up" | "destroy";
+  /**
+   * Name to scope the resource state under (e.g. `.alchemy/{stage}/..`).
+   *
+   * @default - your POSIX username
+   */
+  stage?: string;
+  /**
+   * If true, will not prune resources that were dropped from the root stack.
+   *
+   * @default true
+   */
+  destroyOrphans?: boolean;
+  /**
+   * A custom state store to use instead of the default file system store.
+   */
+  stateStore?: StateStore;
+}
+
+/**
+ * Explicitly finalize the program by deleting any resources that were dropped from the root stack.
+ *
+ * By default, this will be called when
+ */
+export async function alchemize(options?: AlchemizeOptions) {
+  if (finalized) {
+    return;
+  }
+  finalized = true;
+
+  const stage = options?.stage ?? defaultStage;
+  const state = options?.stateStore ?? stateStore;
+
+  await state.init?.();
+
+  // Track in-progress deletions to avoid duplicate work
+  const deletionPromises = new Map<string, Promise<void>>();
+
+  const priorStates = await state.all(stage);
+  const priorIDs = Object.keys(priorStates);
+
+  const mode = options?.mode ?? "up";
+
+  if (mode === "up") {
+    await Promise.allSettled(
+      Array.from(nodes.values())
+        .reverse()
+        .map((node) =>
+          evaluate(node.resource, {
+            stage,
+          }),
+        ),
+    );
+
+    if (options?.destroyOrphans === false) {
+      return;
+    }
+  }
+  const aliveIDs = new Set(
+    mode === "up"
+      ? nodes.keys()
+      : // There are no alive resources in destroy mode
+        [],
+  );
+
+  const orphanIDs = Array.from(priorIDs).filter((id) => !aliveIDs.has(id));
+
+  const orphanStates = Object.fromEntries(
+    orphanIDs.map((id) => [id, priorStates[id]] as const),
+  );
+  // compute a map of resourceID -> upstream dependencies (resources that depend on it)
+  const orphanGraph: Record<string, Set<string>> = {};
+  for (const [orphanID, orphanState] of Object.entries(orphanStates)) {
+    orphanGraph[orphanID] ??= new Set();
+    for (const dep of orphanState.deps) {
+      (orphanGraph[dep] ??= new Set()).add(orphanID);
+    }
+  }
+
+  // Start deletion from each orphan that has no dependents (nothing depends on it)
+  await Promise.all(
+    orphanIDs
+      .filter((id) => orphanGraph[id].size === 0)
+      .map((id) => deleteOrphan(id)),
+  );
+
+  // Recursively delete orphans in dependency order
+  async function deleteOrphan(orphanID: string): Promise<void> {
+    // Return existing deletion promise if this orphan is already being deleted
+    const existing = deletionPromises.get(orphanID);
+    if (existing) {
+      return existing;
+    }
+
+    // Create promise immediately to prevent race conditions
+    let resolve: () => void;
+    let reject: (error: any) => void;
+    const promise = new Promise<void>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    deletionPromises.set(orphanID, promise);
+
+    try {
+      const orphanState = orphanStates[orphanID];
+
+      // First delete this resource
+      const providerType = orphanState.provider;
+      const provider = providers.get(providerType);
+      if (!provider) {
+        throw new Error(
+          `No provider found for ${providerType}. Did you forget to import it?`,
+        );
+      }
+      await destroy(stage, orphanID, orphanState, provider);
+
+      // After this resource is deleted, we can delete its dependencies if they're orphans
+      if (orphanState.deps.length > 0) {
+        await Promise.all(
+          orphanState.deps
+            .filter((dep) => orphanIDs.includes(dep)) // Only delete if it's an orphan
+            .map((dep) => deleteOrphan(dep)),
+        );
+      }
+
+      resolve!();
+    } catch (error) {
+      reject!(error);
+    }
+
+    return promise;
+  }
+}
+
+if (process.env.ALCHEMY_NO_DEPLOY !== "true") {
+  // Listen for signals or events
+  process.on("exit", () => alchemize());
+}

package/src/apply.ts

@@ -0,0 +1,117 @@
+import { defaultStage, stateStore } from "./global";
+import { Output } from "./output";
+import {
+  Input,
+  Provider,
+  type Resource,
+  ResourceID,
+  isResource,
+} from "./resource";
+import type { StateStore } from "./state";
+
+interface ApplyOptions {
+  stage?: string;
+  stateStore?: StateStore;
+}
+
+/**
+ * Apply a sub-graph to produce a resource.
+ * @param output A sub-graph that produces a resource.
+ * @returns The resource properties.
+ */
+export async function apply<T>(
+  output: T | Output<T>,
+  options?: ApplyOptions,
+): Promise<T> {
+  return (await evaluate(output, options)).value;
+}
+
+class Evaluated<T> {
+  constructor(
+    public readonly value: T,
+    public readonly deps: string[] = [],
+  ) {}
+}
+
+const cache = new WeakMap<Resource, Promise<Evaluated<any>>>();
+
+export async function evaluate<T>(
+  output: T | Output<T>,
+  options: ApplyOptions = {},
+): Promise<Evaluated<T>> {
+  const state = options.stateStore ?? stateStore;
+  if (isResource(output)) {
+    const resource = output;
+    const resourceID = resource[ResourceID];
+    const evaluated = await Promise.all(
+      resource[Input].map((r) => evaluate<any>(r, options)),
+    );
+
+    if (cache.has(resource)) {
+      return await cache.get(resource)!;
+    }
+    let resolve: (value: Evaluated<any>) => void;
+    let reject: (reason?: any) => void;
+    const promise = new Promise<Evaluated<any>>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    // set this eagerly to avoid double-apply (caused by recursive applies to inputs)
+    cache.set(resource, promise);
+
+    const deps = new Set(evaluated.flatMap((input) => input.deps));
+    const inputs = evaluated.map((input) => input.value);
+    try {
+      const result: T = await resource[Provider].update(
+        options.stage ?? defaultStage,
+        resource,
+        deps,
+        inputs as [],
+        state,
+      );
+      resolve!(new Evaluated(result, [resourceID, ...deps]));
+    } catch (error) {
+      reject!(error);
+    }
+    return promise;
+  } else if (output instanceof Output) {
+    const inside = output as unknown as {
+      parent: Output<any>;
+      fn: (value: any) => T;
+    };
+    const parent = await evaluate(inside.parent, options);
+    const ret = inside.fn(parent.value);
+    // the ret may be an Output (e.g. in the flatMap case), so we need to evaluate it and include its deps
+    const evaluated = await evaluate(ret, options);
+    return new Evaluated<T>(evaluated.value, [
+      ...parent.deps,
+      ...evaluated.deps,
+    ]);
+  } else if (Array.isArray(output)) {
+    const evaluatedItems = await Promise.all(
+      output.map((item) => evaluate(item, options)),
+    );
+    return new Evaluated(
+      evaluatedItems.map((e) => e.value) as unknown as T,
+      evaluatedItems.flatMap((e) => e.deps),
+    );
+  } else if (output && typeof output === "object") {
+    const entries = Object.entries(output);
+    const evaluatedEntries = await Promise.all(
+      entries.map(
+        async ([key, value]) => [key, await evaluate(value, options)] as const,
+      ),
+    );
+
+    const result = Object.fromEntries(
+      evaluatedEntries.map(([key, evaluated]) => [key, evaluated.value]),
+    ) as unknown as T;
+
+    const deps = evaluatedEntries.flatMap(([_, evaluated]) => evaluated.deps);
+
+    return new Evaluated(result, deps);
+  }
+
+  // Base case: primitive value
+  return new Evaluated<T>(output as T);
+}

package/src/components/agent/agent.ts

@@ -0,0 +1,45 @@
+import type { ZodType } from "zod";
+import { type Context, type Provider, Resource } from "../../resource";
+
+export function Agent<Type extends string, TInput, TOutput>(
+  type: Type,
+  {
+    description,
+    input,
+    output,
+  }: {
+    description: string;
+    input: ZodType<TInput>;
+    output: ZodType<TOutput>;
+  },
+  handler: (ctx: Context<TOutput>, props: TInput) => Promise<TOutput | void>,
+): Provider<Type, [TInput], Awaited<TOutput>> & {
+  description: string;
+  input: ZodType<TInput>;
+  output: ZodType<TOutput>;
+} {
+  // @ts-expect-error - we don't care that the props are not statically known, they will be visible outside this scope
+  return class Agent extends Resource(
+    type,
+    async (ctx: Context<TOutput>, props: TInput): Promise<TOutput | void> => {
+      // Validate input
+      const validatedInput = input.parse(props);
+
+      // Call handler with validated input
+      const result = await handler(ctx, validatedInput);
+
+      if (ctx.event === "delete") {
+        return;
+      }
+
+      // Validate output
+      const validatedOutput = output.parse(result);
+
+      return validatedOutput;
+    },
+  ) {
+    static readonly description = description;
+    static readonly input = input;
+    static readonly output = output;
+  };
+}

package/src/components/agent/anthropic.ts

@@ -0,0 +1,27 @@
+/**
+ * @see https://docs.anthropic.com/en/docs/about-claude/models#model-comparison-table
+ */
+export const AnthropicModels = [
+  // Claude 3.5 Sonnet models
+  "claude-3-5-sonnet",
+  "claude-3-5-sonnet-20241022",
+  "claude-3-5-sonnet-20240620",
+
+  // Claude 3.5 Haiku models
+  "claude-3-5-haiku",
+  "claude-3-5-haiku-20241022",
+
+  // Claude 3 models
+  "claude-3-opus",
+  "claude-3-opus-20240229",
+  "claude-3-sonnet",
+  "claude-3-sonnet-20240229",
+  "claude-3-haiku",
+  "claude-3-haiku-20240307",
+] as const;
+
+export type AnthropicModelId = (typeof AnthropicModels)[number] | (string & {});
+
+export function isAnthropicModel(model: string): model is AnthropicModelId {
+  return model.startsWith("claude-");
+}

package/src/components/agent/index.ts

@@ -0,0 +1,4 @@
+export * from "./package";
+export * from "./requirements";
+export * from "./tsconfig";
+export * from "./typescript";

package/src/components/agent/model.ts

@@ -0,0 +1,22 @@
+import { type AnthropicModelId, isAnthropicModel } from "./anthropic";
+import { type OpenAIChatModelId, isOpenAIModel } from "./openai";
+
+export type ModelId = OpenAIChatModelId | AnthropicModelId;
+
+export async function resolveModel(modelId: ModelId) {
+  if (isOpenAIModel(modelId)) {
+    const { openai } = await import("@ai-sdk/openai");
+    return {
+      type: "openai" as const,
+      model: openai(modelId as OpenAIChatModelId),
+    };
+  }
+  if (isAnthropicModel(modelId)) {
+    const { anthropic } = await import("@ai-sdk/anthropic");
+    return {
+      type: "anthropic" as const,
+      model: anthropic(modelId as AnthropicModelId),
+    };
+  }
+  throw new Error(`Unsupported model ID: ${modelId}`);
+}

package/src/components/agent/openai.ts

@@ -0,0 +1,44 @@
+export const OpenAIModels = [
+  // O1 models
+  "o1",
+  "o1-2024-12-17",
+  "o1-mini",
+  "o1-mini-2024-09-12",
+  "o1-preview",
+  "o1-preview-2024-09-12",
+
+  // GPT-4O models
+  "gpt-4o",
+  "gpt-4o-2024-05-13",
+  "gpt-4o-2024-08-06",
+  "gpt-4o-2024-11-20",
+  "gpt-4o-audio-preview",
+  "gpt-4o-audio-preview-2024-10-01",
+  "gpt-4o-audio-preview-2024-12-17",
+  "gpt-4o-mini",
+  "gpt-4o-mini-2024-07-18",
+
+  // GPT-4 models
+  "gpt-4-turbo",
+  "gpt-4-turbo-2024-04-09",
+  "gpt-4-turbo-preview",
+  "gpt-4-0125-preview",
+  "gpt-4-1106-preview",
+  "gpt-4",
+  "gpt-4-0613",
+
+  // GPT-3.5 models
+  "gpt-3.5-turbo-0125",
+  "gpt-3.5-turbo",
+  "gpt-3.5-turbo-1106",
+] as const;
+
+export type OpenAIChatModelId = (typeof OpenAIModels)[number] | (string & {});
+
+export function isOpenAIModel(model: string): model is OpenAIChatModelId {
+  return (
+    model.startsWith("gpt-") ||
+    model.startsWith("o1") ||
+    model.startsWith("gpt-4o")
+  );
+}

package/src/components/agent/package.ts

@@ -0,0 +1,126 @@
+import { generateObject } from "ai";
+import { mkdir, unlink, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { z } from "zod";
+import { Agent } from "./agent";
+import type { AnthropicModelId } from "./anthropic";
+import { resolveModel } from "./model";
+import type { OpenAIChatModelId } from "./openai";
+
+export type ModelId = OpenAIChatModelId | AnthropicModelId;
+
+export const PackageJsonSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  description: z.string().optional(),
+  main: z.string().optional(),
+  types: z.string().optional(),
+  type: z.literal("module"),
+  scripts: z.record(z.string()).optional(),
+  peerDependencies: z.record(z.string()).optional(),
+  peerDependenciesMeta: z
+    .record(z.object({ optional: z.boolean() }))
+    .optional(),
+  devDependencies: z.record(z.string()).optional(),
+  keywords: z.array(z.string()).optional(),
+  author: z.string().optional(),
+  license: z.string().optional(),
+  repository: z
+    .object({
+      type: z.string(),
+      url: z.string(),
+    })
+    .optional(),
+  exports: z.unknown().optional(),
+  files: z.array(z.string()).optional(),
+});
+
+export const PackageInput = z.object({
+  /**
+   * List of requirements for the package
+   * Can include dependencies, dev dependencies, scripts, etc.
+   */
+  requirements: z.array(z.string()),
+
+  /**
+   * Name of the package
+   */
+  name: z.string(),
+
+  /**
+   * The ID of the model to use for generating package configuration
+   * @default "gpt-4o"
+   */
+  model: z.string().optional(),
+
+  /**
+   * Temperature setting for model generation
+   * @default 0.3
+   */
+  temperature: z.number().optional(),
+
+  /**
+   * Path to the package.json file to generate
+   */
+  path: z.string(),
+});
+
+export type PackageInput = z.infer<typeof PackageInput>;
+export type PackageOutput = z.infer<typeof PackageJsonSchema>;
+
+export class PackageJson extends Agent(
+  "code::Package",
+  {
+    description:
+      "This Agent is responsible for generating package.json configuration based on requirements.",
+    input: PackageInput,
+    output: PackageJsonSchema,
+  },
+  async (ctx, input) => {
+    if (ctx.event === "delete") {
+      await unlink(input.path);
+      return;
+    }
+
+    // Get the appropriate model
+    const { model } = await resolveModel(input.model ?? "gpt-4o");
+
+    // Generate the package configuration using generateObject for type safety
+    const result = await generateObject({
+      model,
+      schema: PackageJsonSchema,
+      temperature: input.temperature ?? 0.3,
+      messages: [
+        {
+          role: "system",
+          content:
+            "You are an expert at creating Node.js/TypeScript package configurations. You will generate a package.json configuration based on requirements.",
+        },
+        {
+          role: "user",
+          content: `Please generate a package.json configuration based on these requirements:
+
+Package name: ${input.name}
+
+Requirements:
+${input.requirements.map((req) => `- ${req}`).join("\n")}
+
+Rules:
+1. All dependencies must be peer dependencies
+2. Use latest stable versions for all dependencies
+3. Include standard TypeScript configuration in devDependencies
+4. Use "bun" as the package manager
+5. Must use ESM modules (type: "module")`,
+        },
+      ],
+    });
+
+    // Ensure the directory exists
+    await mkdir(dirname(input.path), { recursive: true });
+
+    // Write the package.json file
+    await writeFile(input.path, JSON.stringify(result.object, null, 2));
+
+    return result.object;
+  },
+) {}