alchemy 0.1.1 → 0.1.3

package/src/state.ts

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { ignore } from "./error";
 
 export interface State {
   status:
@@ -18,41 +19,64 @@ export interface State {
 }
 
 export interface StateStore {
+  /** Initialize the state container if one is required */
   init?(): Promise<void>;
+  /** Delete the state container if one exists */
+  deinit?(): Promise<void>;
   /** List all resources in the given stage. */
-  list(stage: string): Promise<string[]>;
-  get(stage: string, key: string): Promise<State | undefined>;
-  getBatch(stage: string, ids: string[]): Promise<Record<string, State>>;
-  all(stage: string): Promise<Record<string, State>>;
-  set(stage: string, key: string, value: State): Promise<void>;
-  delete(stage: string, key: string): Promise<void>;
+  list(): Promise<string[]>;
+  /** Return the number of items let in this store */
+  count(): Promise<number>;
+  get(key: string): Promise<State | undefined>;
+  getBatch(ids: string[]): Promise<Record<string, State>>;
+  all(): Promise<Record<string, State>>;
+  set(key: string, value: State): Promise<void>;
+  delete(key: string): Promise<void>;
 }
 
 const stateFile = path.join(process.cwd(), ".alchemy");
 
-/**
- * @internal
- */
-export const defaultStore: StateStore = {
-  async init() {
+export type StateStoreType = new (dir: string) => StateStore;
+
+export class FileSystemStateStore implements StateStore {
+  public readonly path: string;
+  constructor(dir: string) {
+    this.path = path.join(stateFile, dir);
+  }
+
+  async init(): Promise<void> {
     await fs.promises.mkdir(stateFile, { recursive: true });
-  },
-  async list(stage) {
+    await fs.promises.mkdir(this.path, { recursive: true });
+  }
+
+  async deinit(): Promise<void> {
+    await ignore("ENOENT", () => fs.promises.rmdir(this.path));
+  }
+
+  async count(): Promise<number> {
+    return Object.keys(await this.list()).length;
+  }
+
+  async list(): Promise<string[]> {
     try {
-      return (await fs.promises.readdir(path.join(stateFile, stage))).map(
-        (file) => file.replace(/\.json$/, ""),
-      );
+      const files = await fs.promises.readdir(this.path, {
+        withFileTypes: true,
+      });
+      return files
+        .filter((dirent) => dirent.isFile() && dirent.name.endsWith(".json"))
+        .map((dirent) => dirent.name.replace(/\.json$/, ""));
     } catch (error: any) {
       if (error.code === "ENOENT") {
         return [];
       }
       throw error;
     }
-  },
-  async get(stage, key) {
+  }
+
+  async get(key: string): Promise<State | undefined> {
     try {
       const content = await fs.promises.readFile(
-        await getPath(stage, key),
+        await this.getPath(key),
         "utf8",
       );
       return JSON.parse(content) as State;
@@ -62,25 +86,29 @@ export const defaultStore: StateStore = {
       }
       throw error;
     }
-  },
-  async set(stage, key, value) {
+  }
+
+  async set(key: string, value: State): Promise<void> {
     return fs.promises.writeFile(
-      await getPath(stage, key),
+      await this.getPath(key),
       JSON.stringify(value, null, 2),
     );
-  },
-  async delete(stage, key) {
-    return fs.promises.unlink(await getPath(stage, key));
-  },
-  async all(stage: string): Promise<Record<string, State>> {
-    return this.getBatch(stage, await this.list(stage));
-  },
-  async getBatch(stage: string, ids: string[]): Promise<Record<string, State>> {
+  }
+
+  async delete(key: string): Promise<void> {
+    return fs.promises.unlink(await this.getPath(key));
+  }
+
+  async all(): Promise<Record<string, State>> {
+    return this.getBatch(await this.list());
+  }
+
+  async getBatch(ids: string[]): Promise<Record<string, State>> {
     return Object.fromEntries(
       (
         await Promise.all(
           Array.from(ids).flatMap(async (id) => {
-            const s = await this.get(stage, id);
+            const s = await this.get(id);
             if (s === undefined) {
               return [] as const;
             }
@@ -89,12 +117,12 @@ export const defaultStore: StateStore = {
         )
       ).flat(),
     );
-  },
-};
+  }
 
-async function getPath(stage: string, key: string) {
-  const file = path.join(stateFile, stage, `${key}.json`);
-  const dir = path.dirname(file);
-  await fs.promises.mkdir(dir, { recursive: true });
-  return file;
+  private async getPath(key: string): Promise<string> {
+    const file = path.join(this.path, `${key}.json`);
+    const dir = path.dirname(file);
+    await fs.promises.mkdir(dir, { recursive: true });
+    return file;
+  }
 }

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