alchemy 0.1.2 → 0.1.3

package/src/typescript/check-omission.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { generateObject } from "../agent/ai";
+import { resolveModel } from "../agent/model";
+
+const CodeOmissionCheck = z.object({
+  hasOmittedCode: z.boolean(),
+  explanation: z.string(),
+});
+
+const haiku = await resolveModel("claude-3-5-haiku-latest");
+
+export async function checkForCodeOmission(code: string): Promise<boolean> {
+  const result = await generateObject({
+    model: haiku,
+    schema: CodeOmissionCheck,
+    temperature: 0.1,
+    messages: [
+      {
+        role: "system",
+        content:
+          "You are checking for signs of code omission in TypeScript code. Look for comments that indicate abbreviated or omitted content.",
+      },
+      {
+        role: "user",
+        content: `Check this code for any signs of content being lazily omitted:
+
+\`\`\`typescript
+${code}
+\`\`\`
+
+Look for patterns like:
+- "// rest of the ..."
+- "// remaining code ..."
+- "// ... existing code ..."
+- "// other methods ..."
+- "// etc ..."
+- "// Implementation would go here"
+- "// For now just ..."
+- Any similar comments that indicate code was abbreviated
+
+Only answer true if you find such comments indicating omitted content. Otherwise answer false.`,
+      },
+    ],
+  });
+
+  return result.object.hasOmittedCode;
+}

package/src/typescript/debug-type-errors.ts

@@ -0,0 +1,42 @@
+import type { CoreMessage } from "ai";
+import { generateText } from "../agent/ai";
+import { resolveModel } from "../agent/model";
+
+export async function debugTypeErrors(
+  messages: CoreMessage[],
+  typeErrors: string,
+): Promise<string> {
+  const o3Model = await resolveModel("o3-mini");
+
+  // Get diagnostic analysis from o3-mini
+  const consultationMessages: CoreMessage[] = [
+    ...messages,
+    {
+      role: "user",
+      content: `Analyze these TypeScript errors and the code to identify the root causes:
+
+TypeScript errors:
+${typeErrors}
+
+Please help by:
+1. Diagnosing the root cause of any type errors
+2. Identifying specific sections of code that need to change
+3. Providing step-by-step guidance on how to fix them
+
+Focus only on type-related issues and necessary fixes.`,
+    },
+  ];
+
+  const { text: analysis } = await generateText({
+    model: o3Model,
+    temperature: 0.1,
+    providerOptions: {
+      openai: {
+        reasoningEffort: "high",
+      },
+    },
+    messages: consultationMessages,
+  });
+
+  return analysis;
+}

package/src/typescript/extract.ts

@@ -0,0 +1,9 @@
+/**
+ * Extracts TypeScript code from a markdown code block
+ * @param text Response text that may contain markdown
+ * @returns The TypeScript code if found, undefined otherwise
+ */
+export function extractTypeScriptCode(text: string): string | undefined {
+  const matches = text.match(/```(?:ts|typescript)\n([\s\S]*?)```/);
+  return matches?.[1]?.trim();
+}

package/src/{components/agent → typescript}/index.ts

@@ -1,4 +1,6 @@
+export * from "./extract";
 export * from "./package";
-export * from "./requirements";
+export * from "./repair";
 export * from "./tsconfig";
 export * from "./typescript";
+export * from "./validate";

package/src/typescript/install-packages.ts

@@ -0,0 +1,50 @@
+import { tool } from "ai";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { z } from "zod";
+
+const execAsync = promisify(exec);
+
+export const installPackages = tool({
+  description: "Installs one or more packages using bun add",
+  parameters: z.object({
+    packages: z.array(z.string()).describe("Array of package names to install"),
+    isDev: z
+      .boolean()
+      .optional()
+      .describe("Whether to install as dev dependencies"),
+    cwd: z
+      .string()
+      .optional()
+      .describe("Working directory where to run the install command"),
+  }),
+  execute: async ({ packages, isDev = false, cwd = process.cwd() }) => {
+    if (packages.length === 0) {
+      throw new Error("No packages specified for installation");
+    }
+
+    const command = `bun add ${isDev ? "-D " : ""}${packages.join(" ")}`;
+
+    try {
+      console.log(`Running command: ${command}`);
+      const { stdout, stderr } = await execAsync(command, { cwd });
+
+      if (stderr) {
+        console.error("Installation stderr:", stderr);
+      }
+
+      return {
+        success: true,
+        command,
+        output: stdout,
+        packages,
+        type: isDev ? "dev" : "regular",
+      };
+    } catch (error: any) {
+      console.error("Installation error:", error);
+      throw new Error(
+        `Failed to install packages: ${error?.message || String(error)}`,
+      );
+    }
+  },
+});

package/src/{components/agent → typescript}/package.ts

@@ -1,13 +1,12 @@
 import { generateObject } from "ai";
-import { mkdir, unlink, writeFile } from "fs/promises";
+import { mkdir, 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;
+import { dependenciesAsMessages } from "../agent/dependencies";
+import { FileContext } from "../agent/file-context";
+import { resolveModel } from "../agent/model";
+import { rm } from "../fs";
+import { type Context, Resource } from "../resource";
 
 export const PackageJsonSchema = z.object({
   name: z.string(),
@@ -35,13 +34,18 @@ export const PackageJsonSchema = z.object({
   files: z.array(z.string()).optional(),
 });
 
-export const PackageInput = z.object({
+export const PackageJsonInput = z.object({
   /**
    * List of requirements for the package
    * Can include dependencies, dev dependencies, scripts, etc.
    */
   requirements: z.array(z.string()),
 
+  /**
+   * List of dependencies for the package
+   */
+  dependencies: z.array(FileContext).optional(),
+
   /**
    * Name of the package
    */
@@ -65,62 +69,75 @@ export const PackageInput = z.object({
   path: z.string(),
 });
 
-export type PackageInput = z.infer<typeof PackageInput>;
-export type PackageOutput = z.infer<typeof PackageJsonSchema>;
+export type PackageJsonInput = z.infer<typeof PackageJsonInput>;
+
+export interface PackageJsonOutput {
+  path: string;
+  content: string;
+  packageJson: z.infer<typeof PackageJsonSchema>;
+}
 
-export class PackageJson extends Agent(
+export class PackageJson extends Resource(
   "code::Package",
-  {
-    description:
-      "This Agent is responsible for generating package.json configuration based on requirements.",
-    input: PackageInput,
-    output: PackageJsonSchema,
-  },
-  async (ctx, input) => {
+  async (
+    ctx: Context<PackageJsonOutput>,
+    props: PackageJsonInput,
+  ): Promise<PackageJsonOutput | void> => {
     if (ctx.event === "delete") {
-      await unlink(input.path);
+      await rm(props.path);
       return;
     }
 
+    console.log(ctx.event === "create" ? "Creating" : "Updating", props.path);
+
     // Get the appropriate model
-    const { model } = await resolveModel(input.model ?? "gpt-4o");
+    const model = await resolveModel(props.model ?? "gpt-4o");
 
     // Generate the package configuration using generateObject for type safety
     const result = await generateObject({
       model,
       schema: PackageJsonSchema,
-      temperature: input.temperature ?? 0.3,
+      temperature: props.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.",
         },
+        ...dependenciesAsMessages(props.dependencies ?? []),
         {
           role: "user",
           content: `Please generate a package.json configuration based on these requirements:
 
-Package name: ${input.name}
+Package name: ${props.name}
 
 Requirements:
-${input.requirements.map((req) => `- ${req}`).join("\n")}
+${props.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")`,
+5. Must use ESM modules (type: "module")
+
+Output only the package.json code (do not emit any other files).`,
         },
       ],
     });
 
     // Ensure the directory exists
-    await mkdir(dirname(input.path), { recursive: true });
+    await mkdir(dirname(props.path), { recursive: true });
+
+    const content = JSON.stringify(result.object, null, 2);
 
     // Write the package.json file
-    await writeFile(input.path, JSON.stringify(result.object, null, 2));
+    await writeFile(props.path, content);
 
-    return result.object;
+    return {
+      path: props.path,
+      content,
+      packageJson: result.object,
+    };
   },
 ) {}

package/src/typescript/repair-omissions.ts

@@ -0,0 +1,31 @@
+import type { CoreMessage, LanguageModelV1 } from "ai";
+import { generateText } from "../agent/ai";
+import { extractTypeScriptCode } from "./extract";
+
+export async function repairCodeOmissions(
+  model: LanguageModelV1,
+  messages: CoreMessage[] = [],
+): Promise<string> {
+  console.log("[TypeScript] Repairing code omissions...");
+
+  const repairMessages: CoreMessage[] = [
+    ...messages,
+    {
+      role: "user" as const,
+      content: `Do not omit implementation or leave placeholders. Complete the implementation fully.`,
+    },
+  ];
+
+  const { text } = await generateText({
+    model,
+    temperature: 0.1,
+    messages: repairMessages,
+  });
+
+  const repairedCode = extractTypeScriptCode(text);
+  if (!repairedCode) {
+    throw new Error("Failed to repair code omissions");
+  }
+
+  return repairedCode;
+}

package/src/typescript/repair.ts

@@ -0,0 +1,45 @@
+import type { CoreMessage } from "ai";
+import { generateText } from "../agent";
+import { extractTypeScriptCode } from "./extract";
+
+export async function repairTypeScriptCode(
+  model: any,
+  typeErrors: string,
+  messages: CoreMessage[],
+): Promise<string> {
+  // If we have type check options, validate and potentially repair type errors
+  console.log("[TypeScript] Fixing type errors...");
+
+  messages.push({
+    role: "user" as const,
+    content: `Fix the type errors in this code:
+
+Type errors found:
+${typeErrors}
+
+Provide a complete implementation that fixes these issues while preserving all functionality.`,
+  });
+
+  // Add the repair attempt to the message history
+  const repairMessages: CoreMessage[] = [
+    {
+      role: "system" as const,
+      content:
+        "You are an expert TypeScript developer fixing type errors. Provide a complete implementation that resolves the identified issues.",
+    },
+    ...messages,
+  ];
+
+  const { text: repairAttempt } = await generateText({
+    model,
+    temperature: 0.1,
+    messages: repairMessages,
+  });
+
+  const repairedCode = extractTypeScriptCode(repairAttempt);
+  if (!repairedCode) {
+    throw new Error("Failed to repair type errors");
+  }
+
+  return repairedCode;
+}

package/src/{components/agent → typescript}/tsconfig.ts

@@ -1,13 +1,14 @@
 import { generateObject } from "ai";
-import { mkdir, unlink, writeFile } from "fs/promises";
+import { mkdir, writeFile } from "fs/promises";
 import { dirname } from "path";
 import { z } from "zod";
-import { Agent } from "./agent";
-import { resolveModel } from "./model";
+import { FileContext, dependenciesAsMessages, resolveModel } from "../agent";
+import { rm } from "../fs";
+import { type Context, Resource } from "../resource";
 
-export type TsConfigProps = z.infer<typeof TsConfigProps>;
+export type TypeScriptConfigInput = z.infer<typeof TypeScriptConfigInput>;
 
-export const TsConfigProps = z.object({
+export const TypeScriptConfigInput = z.object({
   /**
    * The ID of the model to use for generating tsconfig configuration
    * @default "gpt-4o"
@@ -20,6 +21,11 @@ export const TsConfigProps = z.object({
    */
   requirements: z.array(z.string()),
 
+  /**
+   * List of dependencies for the TypeScript configuration
+   */
+  dependencies: z.array(FileContext).optional(),
+
   /**
    * Temperature setting for model generation
    * @default 0.3
@@ -93,22 +99,29 @@ export const TsConfigSchema = z.object({
     .optional(),
 });
 
-export class TypeScriptConfig extends Agent(
+export interface TypeScriptConfigOutput
+  extends z.infer<typeof TypeScriptConfigOutput> {}
+export const TypeScriptConfigOutput = z.object({
+  path: z.string(),
+  content: z.string(),
+  tsconfig: TsConfigSchema,
+});
+
+export class TypeScriptConfig extends Resource(
   "code::tsconfig",
-  {
-    description:
-      "This Agent is responsible for generating tsconfig.json configuration based on requirements.",
-    input: TsConfigProps,
-    output: TsConfigSchema,
-  },
-  async (ctx, props) => {
+  async (
+    ctx: Context<TypeScriptConfigOutput>,
+    props: TypeScriptConfigInput,
+  ) => {
     if (ctx.event === "delete") {
-      await unlink(props.path);
+      await rm(props.path);
       return;
     }
 
+    console.log(ctx.event === "create" ? "Creating" : "Updating", props.path);
+
     // Get the appropriate model
-    const { model } = await resolveModel(props.modelId ?? "gpt-4o");
+    const model = await resolveModel(props.modelId ?? "gpt-4o");
 
     // Generate the tsconfig configuration using generateObject for type safety
     const result = await generateObject({
@@ -121,6 +134,7 @@ export class TypeScriptConfig extends Agent(
           content:
             "You are an expert at creating TypeScript configurations. You will generate a tsconfig.json configuration based on requirements.",
         },
+        ...dependenciesAsMessages(props.dependencies),
         {
           role: "user",
           content: `Please generate a tsconfig.json configuration based on these requirements:
@@ -142,9 +156,15 @@ Rules:
     // Ensure the directory exists
     await mkdir(dirname(props.path), { recursive: true });
 
+    const content = JSON.stringify(result.object, null, 2);
+
     // Write the tsconfig.json file
-    await writeFile(props.path, JSON.stringify(result.object, null, 2));
+    await writeFile(props.path, content);
 
-    return result.object;
+    return {
+      path: props.path,
+      content,
+      tsconfig: result.object,
+    };
   },
 ) {}

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");
+  },
+) {}