alchemy 0.1.1 → 0.1.3

package/src/typescript/typescript.ts

@@ -0,0 +1,217 @@
+import type { CoreMessage } from "ai";
+import { mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { z } from "zod";
+import { ModelId, generateText, resolveModel } from "../agent";
+import { dependenciesAsMessages } from "../agent/dependencies";
+import { FileContext } from "../agent/file-context";
+import { rm } from "../fs";
+import { type Context, Resource } from "../resource";
+import { checkForCodeOmission } from "./check-omission";
+import { debugTypeErrors } from "./debug-type-errors";
+import { extractTypeScriptCode } from "./extract";
+import { repairTypeScriptCode } from "./repair";
+import { repairCodeOmissions } from "./repair-omissions";
+import { validateTypeScript } from "./validate";
+
+export type TypeScriptFileInput = z.infer<typeof TypeScriptFileInput>;
+
+const TypeScriptFileInput = z.object({
+  /**
+   * The ID of the model to use for generating TypeScript code
+   * @default "gpt-4o"
+   */
+  modelId: ModelId.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(FileContext).optional(),
+
+  /**
+   * Temperature setting for model generation (higher = more creative, lower = more focused)
+   * @default 0.7
+   */
+  temperature: z.number().optional(),
+
+  /**
+   * Whether to perform TypeScript type checking on the generated code
+   * @default false
+   */
+  typeCheck: z.boolean().optional(),
+
+  /**
+   * Path to the tsconfig.json file to use for validation
+   * If not provided, will look for tsconfig.json in the project root
+   * Only used if typeCheck is true
+   */
+  tsconfigPath: z.string().optional(),
+
+  /**
+   * Project root directory. Used to resolve tsconfig.json and module imports
+   * If not provided, will use the directory of the target file
+   * Only used if typeCheck is true
+   */
+  projectRoot: z.string().optional(),
+});
+
+export type TypeScriptFileOutput = z.infer<typeof TypeScriptFileOutput>;
+export const TypeScriptFileOutput = FileContext;
+
+export class TypeScriptFile extends Resource(
+  "code::TypeScriptFile",
+  async (ctx: Context<TypeScriptFileOutput>, props: TypeScriptFileInput) => {
+    if (ctx.event === "delete") {
+      await rm(props.path);
+      return;
+    }
+
+    console.log("Implementing", props.path);
+
+    // Get the appropriate model based on the ID
+    const model = await resolveModel(props.modelId ?? "gpt-4o");
+
+    const messages: CoreMessage[] = [
+      {
+        role: "system" as const,
+        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 containing the COMPLETE implementation\n" +
+          "IMPORTANT: You must ALWAYS provide the ENTIRE file contents, including ALL imports, types, and implementations.\n" +
+          "NEVER output partial code or omit any functionality from the original file when making changes.\n" +
+          "Do not include any other explanations or multiple code blocks.",
+      },
+      ...dependenciesAsMessages(props.dependencies),
+      {
+        role: "user" as const,
+        content: `Please generate TypeScript code based on the following specifications:
+
+Requirements:
+${props.requirements}
+
+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
+5. Include ALL necessary imports and dependencies
+6. Contain the COMPLETE implementation with no omissions`,
+      },
+    ];
+
+    const maxAttempts = 3;
+    let code: string | undefined;
+    let typeErrors: string | undefined;
+
+    // Try generating and validating code up to maxAttempts times
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        // After 2 failed attempts, consult o3-mini for analysis
+        if (attempt === maxAttempts) {
+          if (!ctx.quiet) {
+            console.log("[TypeScript] Consulting expert for code analysis...");
+          }
+          const diagnosis = await debugTypeErrors(messages, typeErrors!);
+
+          messages.push({
+            role: "user",
+            content: diagnosis,
+          });
+        }
+
+        // Generate the TypeScript code
+        if (!ctx.quiet) {
+          console.log(`[TypeScript] Generating code attempt ${attempt}...`);
+        }
+        const { text } = await generateText({
+          model,
+          temperature: Math.max(
+            0.1,
+            (props.temperature ?? 0.7) * (1 - attempt * 0.2),
+          ),
+          messages,
+        });
+
+        code = extractTypeScriptCode(text);
+        if (!code) {
+          console.log("Format mismatch");
+          messages.push(
+            {
+              role: "assistant" as const,
+              content: text,
+            },
+            {
+              role: "user" as const,
+              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 containing the COMPLETE implementation. No other text or explanations.",
+            },
+          );
+          continue;
+        }
+
+        // First check for omissions
+        if (!ctx.quiet) {
+          console.log("[TypeScript] Checking for code omissions...");
+        }
+        const hasOmissions = await checkForCodeOmission(code);
+        if (hasOmissions) {
+          code = await repairCodeOmissions(model, messages);
+        }
+
+        // Ensure the directory exists
+        await mkdir(dirname(props.path), { recursive: true });
+
+        // Write the TypeScript file
+        await writeFile(props.path, code);
+
+        if (props.typeCheck) {
+          typeErrors = await validateTypeScript(props.path, {
+            tsconfigPath: props.tsconfigPath,
+            projectRoot: props.projectRoot,
+          });
+          if (typeErrors) {
+            if (attempt === maxAttempts) {
+              throw new Error(
+                `Failed to generate type-safe code after maximum attempts. Errors:\n${typeErrors}`,
+              );
+            } else {
+              code = await repairTypeScriptCode(model, typeErrors, messages);
+              continue;
+            }
+          }
+        }
+
+        // If we get here, the code is valid
+        return {
+          path: props.path,
+          content: code,
+        };
+      } catch (error) {
+        // On the last attempt, rethrow the error
+        if (attempt === maxAttempts) {
+          throw error;
+        }
+        // Otherwise continue to the next attempt
+        if (!ctx.quiet) {
+          console.log(`Attempt ${attempt} failed:`, error);
+        }
+      }
+    }
+
+    // This should never be reached due to the throws above
+    throw new Error("Unexpected code generation failure");
+  },
+) {}

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();
-}