alchemy 0.0.8 → 0.1.2

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

package/src/components/agent/requirements.ts

@@ -0,0 +1,111 @@
+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";
+import { scrapeWebPage } from "./scrape";
+
+export const RequirementsInput = z.object({
+  /**
+   * The ID of the model to use for generating requirements documentation
+   * @default "gpt-4o"
+   */
+  modelId: z.string().optional(),
+
+  /**
+   * List of requirements to document and analyze
+   */
+  requirements: z.array(z.string()),
+
+  /**
+   * One-line summary of the requirements document
+   */
+  title: z.string(),
+
+  /**
+   * Temperature setting for model generation (higher = more creative, lower = more focused)
+   * @default 0.7
+   */
+  temperature: z.number().optional(),
+
+  /**
+   * File path where the requirements document should be written
+   */
+  path: z.string(),
+});
+
+export const RequirementsOutput = z.object({
+  /**
+   * Generated markdown document containing organized and analyzed requirements
+   */
+  content: z.string(),
+});
+
+export type RequirementsInput = z.infer<typeof RequirementsInput>;
+export type RequirementsOutput = z.infer<typeof RequirementsOutput>;
+
+export class Requirements extends Agent(
+  "code::Requirements",
+  {
+    description:
+      "This Agent is responsible for writing and refining a detailed requirements document from a list of requirements.",
+    input: RequirementsInput,
+    output: RequirementsOutput,
+  },
+  async (ctx, input) => {
+    if (ctx.event === "delete") {
+      await unlink(input.path);
+      return;
+    }
+
+    // Get the appropriate model based on the ID
+    const { model } = await resolveModel(input.modelId ?? "gpt-4o");
+
+    // Generate the requirements document
+    const { text } = await generateText({
+      model,
+      temperature: input.temperature ?? 0.7,
+      maxSteps: 3, // Allow multiple steps for potential tool usage
+      tools: {
+        scrapeWebPage,
+      },
+      messages: [
+        {
+          role: "system",
+          content:
+            "You are a helpful assistant that creates markdown documents from requirements. You can use the scrapeWebPage tool to get additional requirements from relevant URLs if needed.",
+        },
+        {
+          role: "user",
+          content: `Please analyze the following system requirements and create a comprehensive, unambiguous markdown document that covers all aspects:
+
+Title: ${input.title}
+
+Requirements:
+${input.requirements.map((req) => `- ${req}`).join("\n")}
+
+Guidelines:
+1. Make explicit decisions for any ambiguous requirements - do not leave open questions
+2. Document the reasoning behind key decisions
+3. Be specific about technical choices and implementation details
+4. Avoid phrases like "could be", "might need", or "possibly requires" - be definitive
+5. Organize requirements into logical sections with clear dependencies and relationships
+
+Format the output in markdown with appropriate headers, lists, and sections, starting with the title as an H1 header.
+Include technical considerations and implementation details, ensuring every requirement has a clear, actionable specification.`,
+        },
+      ],
+    });
+
+    // Ensure the directory exists
+    await mkdir(dirname(input.path), { recursive: true });
+
+    // Write the requirements to the file
+    await writeFile(input.path, text);
+
+    return {
+      content: text,
+    };
+  },
+) {}

package/src/components/agent/scrape.ts

@@ -0,0 +1,47 @@
+import { tool } from "ai";
+import TurndownService from "turndown";
+import { z } from "zod";
+
+export const scrapeWebPage = tool({
+  description: "Scrapes a web page and converts HTML content to Markdown",
+  parameters: z.object({
+    url: z.string().url().describe("The URL to scrape content from"),
+    turndownOptions: z
+      .object({
+        headingStyle: z.enum(["setext", "atx"]).optional(),
+        hr: z.string().optional(),
+        bulletListMarker: z.enum(["-", "*", "+"]).optional(),
+        codeBlockStyle: z.enum(["indented", "fenced"]).optional(),
+        emDelimiter: z.enum(["_", "*"]).optional(),
+        strongDelimiter: z.enum(["__", "**"]).optional(),
+        linkStyle: z.enum(["inlined", "referenced"]).optional(),
+        linkReferenceStyle: z
+          .enum(["full", "collapsed", "shortcut"])
+          .optional(),
+      })
+      .optional()
+      .describe("Custom options for Turndown HTML to Markdown conversion"),
+  }),
+  execute: async ({ url, turndownOptions }) => {
+    console.log("Scraping web page:", url);
+    try {
+      // Fetch the page content
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+      }
+
+      // Get the HTML content
+      const html = await response.text();
+
+      // Initialize Turndown with options
+      const turndownService = new TurndownService(turndownOptions);
+
+      // Convert HTML to Markdown and return
+      return turndownService.turndown(html);
+    } catch (error) {
+      console.error("Error scraping web page:", error);
+      throw error;
+    }
+  },
+});

package/src/components/agent/tsconfig.ts

@@ -0,0 +1,150 @@
+import { generateObject } 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 TsConfigProps = z.infer<typeof TsConfigProps>;
+
+export const TsConfigProps = z.object({
+  /**
+   * The ID of the model to use for generating tsconfig configuration
+   * @default "gpt-4o"
+   */
+  modelId: z.string().optional(),
+
+  /**
+   * List of requirements for the TypeScript configuration
+   * Can include module settings, compilation options, etc.
+   */
+  requirements: z.array(z.string()),
+
+  /**
+   * Temperature setting for model generation
+   * @default 0.3
+   */
+  temperature: z.number().optional(),
+
+  /**
+   * Path to the tsconfig.json file to generate
+   */
+  path: z.string(),
+});
+
+export type TsConfigJson = z.infer<typeof TsConfigSchema>;
+export const TsConfigSchema = z.object({
+  $schema: z.string().optional(),
+  compilerOptions: z.object({
+    target: z.enum([
+      "es2015",
+      "es2016",
+      "es2017",
+      "es2018",
+      "es2019",
+      "es2020",
+      "es2021",
+      "es2022",
+      "esnext",
+    ]),
+    module: z.enum([
+      "commonjs",
+      "es2015",
+      "es2020",
+      "es2022",
+      "esnext",
+      "node16",
+      "nodenext",
+    ]),
+    lib: z.array(z.string()).optional(),
+    declaration: z.boolean().optional(),
+    declarationMap: z.boolean().optional(),
+    sourceMap: z.boolean().optional(),
+    outDir: z.string().optional(),
+    rootDir: z.string().optional(),
+    strict: z.boolean(),
+    esModuleInterop: z.boolean().optional(),
+    skipLibCheck: z.boolean().optional(),
+    forceConsistentCasingInFileNames: z.boolean().optional(),
+    moduleResolution: z
+      .enum(["node", "node16", "nodenext", "bundler"])
+      .optional(),
+    resolveJsonModule: z.boolean().optional(),
+    isolatedModules: z.boolean().optional(),
+    allowJs: z.boolean().optional(),
+    checkJs: z.boolean().optional(),
+    noEmit: z.boolean().optional(),
+    incremental: z.boolean().optional(),
+    composite: z.boolean().optional(),
+    tsBuildInfoFile: z.string().optional(),
+    paths: z.record(z.array(z.string())).optional(),
+    baseUrl: z.string().optional(),
+    types: z.array(z.string()).optional(),
+    typeRoots: z.array(z.string()).optional(),
+  }),
+  include: z.array(z.string()).optional(),
+  exclude: z.array(z.string()).optional(),
+  references: z
+    .array(
+      z.object({
+        path: z.string(),
+      }),
+    )
+    .optional(),
+});
+
+export class TypeScriptConfig extends Agent(
+  "code::tsconfig",
+  {
+    description:
+      "This Agent is responsible for generating tsconfig.json configuration based on requirements.",
+    input: TsConfigProps,
+    output: TsConfigSchema,
+  },
+  async (ctx, props) => {
+    if (ctx.event === "delete") {
+      await unlink(props.path);
+      return;
+    }
+
+    // Get the appropriate model
+    const { model } = await resolveModel(props.modelId ?? "gpt-4o");
+
+    // Generate the tsconfig configuration using generateObject for type safety
+    const result = await generateObject({
+      model,
+      schema: TsConfigSchema,
+      temperature: props.temperature ?? 0.3,
+      messages: [
+        {
+          role: "system",
+          content:
+            "You are an expert at creating TypeScript configurations. You will generate a tsconfig.json configuration based on requirements.",
+        },
+        {
+          role: "user",
+          content: `Please generate a tsconfig.json configuration based on these requirements:
+
+Requirements:
+${props.requirements.map((req) => `- ${req}`).join("\n")}
+
+Rules:
+1. Use modern TypeScript features
+2. Enable strict type checking
+3. Use ESM modules by default
+4. Include source maps for better debugging
+5. Infer appropriate settings for declarations, module resolution, and other options based on the requirements
+6. Use appropriate paths for source and output directories`,
+        },
+      ],
+    });
+
+    // Ensure the directory exists
+    await mkdir(dirname(props.path), { recursive: true });
+
+    // Write the tsconfig.json file
+    await writeFile(props.path, JSON.stringify(result.object, null, 2));
+
+    return result.object;
+  },
+) {}