alchemy 0.1.2 → 0.1.3

package/src/typescript/validate.ts

@@ -0,0 +1,73 @@
+import { dirname, resolve } from "path";
+import * as ts from "typescript";
+
+export interface TypeCheckOptions {
+  tsconfigPath?: string;
+  projectRoot?: string;
+}
+
+/**
+ * Validates TypeScript code and returns formatted error messages if there are any type errors
+ * @returns Formatted error message if there are errors, undefined if valid
+ */
+export async function validateTypeScript(
+  filePath: string,
+  options: TypeCheckOptions,
+): Promise<string | undefined> {
+  const projectRoot = options.projectRoot ?? dirname(filePath);
+  const tsconfigPath =
+    options.tsconfigPath ?? resolve(projectRoot, "tsconfig.json");
+
+  // Load tsconfig.json if it exists
+  let compilerOptions: ts.CompilerOptions = {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    strict: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    noEmit: true,
+  };
+
+  if (ts.sys.fileExists(tsconfigPath)) {
+    const { config, error } = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+    if (error) {
+      throw new Error(`Error reading tsconfig.json: ${error.messageText}`);
+    }
+
+    const { options: parsedOptions, errors } = ts.parseJsonConfigFileContent(
+      config,
+      ts.sys,
+      projectRoot,
+    );
+
+    if (errors.length) {
+      throw new Error(
+        `Error parsing tsconfig.json: ${errors.map((e) => e.messageText).join("\n")}`,
+      );
+    }
+
+    compilerOptions = parsedOptions;
+  }
+
+  // Create program
+  const program = ts.createProgram({
+    rootNames: [filePath],
+    options: compilerOptions,
+  });
+
+  // Get diagnostics
+  const diagnostics = [
+    ...program.getSemanticDiagnostics(),
+    ...program.getSyntacticDiagnostics(),
+  ];
+
+  if (diagnostics.length > 0) {
+    return ts.formatDiagnosticsWithColorAndContext(diagnostics, {
+      getCanonicalFileName: (path) => path,
+      getCurrentDirectory: () => projectRoot,
+      getNewLine: () => ts.sys.newLine,
+    });
+  }
+
+  return undefined;
+}

package/test/scope.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "bun:test";
+import { apply } from "../src/apply";
+import type { PolicyDocument } from "../src/components/aws/policy";
+import { Role } from "../src/components/aws/role";
+import { File } from "../src/components/fs";
+import { destroy } from "../src/destroy";
+import { rootScope } from "../src/global";
+import { type Context, Resource } from "../src/resource";
+import { Scope, getScope, withScope } from "../src/scope";
+
+describe("Scope", () => {
+  it("should maintain scope context and track resources", async () => {
+    const testScope = new Scope("test");
+
+    await withScope(testScope, async () => {
+      new File("test-file", "test.txt", "Hello World");
+
+      const currentScope = getScope();
+      expect(currentScope).toEqual(testScope);
+    });
+    expect(testScope.nodes.size).toBe(1);
+    expect(testScope).toBe(testScope);
+    expect(testScope).not.toBe(rootScope);
+  });
+
+  it("should handle nested resources with AWS Role", async () => {
+    class ServiceResources extends Resource(
+      "service-resources",
+      async (
+        ctx: Context<{ roleArn: string }>,
+        props: { roleName: string },
+      ) => {
+        const assumeRolePolicy: PolicyDocument = {
+          Version: "2012-10-17",
+          Statement: [
+            {
+              Effect: "Allow",
+              Principal: {
+                Service: "lambda.amazonaws.com",
+              },
+              Action: "sts:AssumeRole",
+            },
+          ],
+        };
+
+        const role = new Role(`role`, {
+          roleName: props.roleName,
+          assumeRolePolicy,
+        });
+
+        return {
+          roleArn: role.arn,
+        };
+      },
+    ) {}
+
+    const service = new ServiceResources("test-service", {
+      roleName: "alchemy-test-scope-role",
+    });
+
+    // Apply the parent resource which should create the role
+    const output = await apply(service);
+
+    // Clean up
+    await destroy(service);
+  });
+});

package/src/components/agent/agent.ts

@@ -1,45 +0,0 @@
-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/model.ts

@@ -1,22 +0,0 @@
-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/typescript.ts

@@ -1,177 +0,0 @@
-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();
-}