alchemy 0.1.10 → 0.1.12

package/src/markdown/requirements.ts

@@ -1,135 +0,0 @@
-import { mkdir, writeFile } from "fs/promises";
-import { dirname } from "path";
-import { z } from "zod";
-import {
-  FileContext,
-  ModelId,
-  dependenciesAsMessages,
-  generateText,
-  resolveModel,
-} from "../agent";
-import { rm } from "../fs";
-import { type Context, Resource } from "../resource";
-
-export const ReasoningEffort = z.enum(["low", "medium", "high"]);
-
-export const RequirementsInput = z.object({
-  /**
-   * The ID of the model to use for generating requirements documentation
-   * @default "gpt-4o"
-   */
-  modelId: ModelId.optional(),
-
-  /**
-   * The effort to put into reasoning about the requirements
-   */
-  reasoningEffort: ReasoningEffort.optional(),
-
-  /**
-   * List of requirements to document and analyze
-   */
-  requirements: z.array(z.string()),
-
-  /**
-   * List of dependencies for the requirements document
-   */
-  dependencies: z.array(FileContext).optional(),
-
-  /**
-   * 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
-   */
-  file: z.string().optional(),
-});
-
-export const RequirementsOutput = z.object({
-  /**
-   * Generated markdown document containing organized and analyzed requirements
-   */
-  content: z.string(),
-});
-
-export interface RequirementsInput extends z.infer<typeof RequirementsInput> {}
-export type RequirementsOutput = z.infer<typeof RequirementsOutput>;
-
-export class Requirements extends Resource(
-  "code::Requirements",
-  async (ctx: Context<RequirementsOutput>, props: RequirementsInput) => {
-    if (ctx.event === "delete") {
-      if (props.file) {
-        await rm(props.file);
-      }
-      return;
-    }
-
-    if (props.file) {
-      console.log(
-        ctx.event === "create" ? "Designing" : "Revising",
-        "requirements",
-        props.file,
-      );
-    }
-
-    // Get the appropriate model based on the ID
-    const model = await resolveModel(props.modelId ?? "gpt-4o");
-
-    // Generate the requirements document
-    const { text } = await generateText({
-      model,
-      temperature: props.temperature ?? 0.7,
-      maxSteps: 3, // Allow multiple steps for potential tool usage
-      providerOptions: props.reasoningEffort
-        ? {
-            openai: {
-              reasoningEffort: props.reasoningEffort,
-            },
-          }
-        : undefined,
-      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.",
-        },
-        ...dependenciesAsMessages(props.dependencies ?? []),
-        {
-          role: "user",
-          content: `Please analyze the following system requirements and create a comprehensive, unambiguous markdown document that covers all aspects:
-
-Requirements:
-${props.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.`,
-        },
-      ],
-    });
-
-    if (props.file) {
-      // Ensure the directory exists
-      await mkdir(dirname(props.file), { recursive: true });
-
-      // Write the requirements to the file
-      await writeFile(props.file, text);
-    }
-
-    return {
-      content: text,
-    };
-  },
-) {}

package/src/typescript/check-omission.ts

@@ -1,47 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

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

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

package/src/typescript/install-dependencies.ts

@@ -1,61 +0,0 @@
-import { tool } from "ai";
-import { exec } from "child_process";
-import { promisify } from "util";
-import { z } from "zod";
-
-const execAsync = promisify(exec);
-
-export const installDependencies = tool({
-  description:
-    "Installs dependencies using bun with support for different dependency types (runtime, dev, or peer)",
-  parameters: z.object({
-    packages: z.array(z.string()).describe("Array of package names to install"),
-    type: z
-      .enum(["runtime", "dev", "peer"])
-      .optional()
-      .describe(
-        "Type of dependency to install: runtime, dev, or peer. Default 'runtime'.",
-      ),
-  }),
-  execute: async ({ packages, type }) => {
-    if (packages.length === 0) {
-      throw new Error("No packages specified for installation");
-    }
-
-    let command = "bun add";
-
-    // Add appropriate flags based on dependency type
-    switch (type) {
-      case "dev":
-        command += " -D";
-        break;
-      case "peer":
-        command += " --peer";
-        break;
-      // runtime dependencies don't need a special flag
-    }
-
-    // Add packages to the command
-    command += " " + packages.join(" ");
-
-    try {
-      console.log(`Executing: ${command}`);
-      const { stdout, stderr } = await execAsync(command);
-
-      if (stderr) {
-        console.warn("Installation warnings:", stderr);
-      }
-
-      return {
-        success: true,
-        command,
-        output: stdout,
-        packages,
-        type,
-      };
-    } catch (error: any) {
-      console.error("Installation failed:", error);
-      throw new Error(`Failed to install packages: ${error.message}`);
-    }
-  },
-});

package/src/typescript/package.ts

@@ -1,143 +0,0 @@
-import { generateObject } from "ai";
-import { mkdir, writeFile } from "fs/promises";
-import { dirname } from "path";
-import { z } from "zod";
-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(),
-  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 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
-   */
-  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 PackageJsonInput = z.infer<typeof PackageJsonInput>;
-
-export interface PackageJsonOutput {
-  path: string;
-  content: string;
-  packageJson: z.infer<typeof PackageJsonSchema>;
-}
-
-export class PackageJson extends Resource(
-  "code::Package",
-  async (
-    ctx: Context<PackageJsonOutput>,
-    props: PackageJsonInput,
-  ): Promise<PackageJsonOutput | void> => {
-    if (ctx.event === "delete") {
-      await rm(props.path);
-      return;
-    }
-
-    console.log(ctx.event === "create" ? "Creating" : "Updating", props.path);
-
-    // Get the appropriate model
-    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: 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: ${props.name}
-
-Requirements:
-${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")
-
-Output only the package.json code (do not emit any other files).`,
-        },
-      ],
-    });
-
-    // Ensure the directory exists
-    await mkdir(dirname(props.path), { recursive: true });
-
-    const content = JSON.stringify(result.object, null, 2);
-
-    // Write the package.json file
-    await writeFile(props.path, content);
-
-    return {
-      path: props.path,
-      content,
-      packageJson: result.object,
-    };
-  },
-) {}

package/src/typescript/repair-omissions.ts

@@ -1,31 +0,0 @@
-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

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

@@ -1,170 +0,0 @@
-import { generateObject } from "ai";
-import { mkdir, writeFile } from "fs/promises";
-import { dirname } from "path";
-import { z } from "zod";
-import { FileContext, dependenciesAsMessages, resolveModel } from "../agent";
-import { rm } from "../fs";
-import { type Context, Resource } from "../resource";
-
-export type TypeScriptConfigInput = z.infer<typeof TypeScriptConfigInput>;
-
-export const TypeScriptConfigInput = 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()),
-
-  /**
-   * List of dependencies for the TypeScript configuration
-   */
-  dependencies: z.array(FileContext).optional(),
-
-  /**
-   * 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 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",
-  async (
-    ctx: Context<TypeScriptConfigOutput>,
-    props: TypeScriptConfigInput,
-  ) => {
-    if (ctx.event === "delete") {
-      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");
-
-    // 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.",
-        },
-        ...dependenciesAsMessages(props.dependencies),
-        {
-          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 });
-
-    const content = JSON.stringify(result.object, null, 2);
-
-    // Write the tsconfig.json file
-    await writeFile(props.path, content);
-
-    return {
-      path: props.path,
-      content,
-      tsconfig: result.object,
-    };
-  },
-) {}