alchemy 0.2.2 → 0.2.4

package/lib/vitepress/vitepress.d.ts

@@ -0,0 +1,71 @@
+import type { DefaultTheme, ThemeOptions } from "vitepress";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import type { HomePage } from "./home-page";
+export interface VitePressProjectProps {
+    /**
+     * The name/path of the project
+     */
+    name: string;
+    /**
+     * The title of the documentation site
+     */
+    title?: string;
+    /**
+     * The description of the documentation site
+     */
+    description?: string;
+    /**
+     * Whether to use TypeScript for config and theme files
+     * @default true
+     */
+    typescript?: boolean;
+    tsconfig?: {
+        extends?: string;
+        references?: string[];
+        compilerOptions?: Record<string, any>;
+    };
+    /**
+     * Force overwrite the project config files during the update phase
+     * @default false
+     */
+    overwrite?: boolean;
+    /**
+     * The dependencies to install
+     */
+    dependencies?: Record<string, string>;
+    /**
+     * The dev dependencies to install
+     */
+    devDependencies?: Record<string, string>;
+    /**
+     * The theme options to use
+     */
+    theme?: ThemeOptions;
+    /**
+     * The theme config to use
+     */
+    themeConfig: DefaultTheme.Config;
+    /**
+     * The home page configuration
+     */
+    home: HomePage;
+    /**
+     * Whether to delete the project folder during the delete phase
+     * @default true
+     */
+    delete?: boolean;
+    /**
+     * The directory to generate the docs in
+     *
+     * @default {@link name}
+     */
+    dir?: string;
+}
+export interface VitePressProject extends VitePressProjectProps, Resource {
+    /**
+     * The name/path of the project
+     */
+    name: string;
+}
+export declare const VitePressProject: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<VitePressProject>, id: string, props: VitePressProjectProps) => Promise<VitePressProject>);

package/lib/vitepress/vitepress.js

@@ -0,0 +1,266 @@
+import { exec } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+import yaml from "yaml";
+import { Folder, JsonFile, TextFile, TypeScriptFile } from "../fs";
+import { Resource } from "../resource";
+import { InstallDependencies, fixedDependencies } from "./dependencies";
+const execAsync = promisify(exec);
+export const VitePressProject = Resource("project::VitePressProject", {
+    alwaysUpdate: true,
+}, async function (id, props) {
+    const dir = props.dir ?? props.name;
+    if (this.phase === "delete") {
+        try {
+            if (props.delete !== false) {
+                if (await fs.exists(dir)) {
+                    // Delete the entire project directory
+                    await execAsync(`rm -rf ${dir}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error deleting VitePress project ${id}:`, error);
+        }
+        return this.destroy();
+    }
+    const cwd = (await Folder("dir", {
+        path: dir,
+        delete: props.delete,
+    })).path;
+    // Initialize package.json
+    await JsonFile(path.join(cwd, "package.json"), {
+        name: props.name,
+        scripts: {
+            "docs:gen": "bun alchemy.run.ts",
+            "docs:dev": "vitepress dev",
+            "docs:build": "vitepress build",
+            "docs:preview": "vitepress preview",
+        },
+        dependencies: fixedDependencies(props.dependencies || {}),
+        devDependencies: fixedDependencies(props.devDependencies || {}),
+    });
+    await InstallDependencies("dependencies", {
+        cwd,
+        dependencies: props.dependencies,
+        devDependencies: {
+            vue: "latest",
+            vitepress: "latest",
+            "@shikijs/vitepress-twoslash": "latest",
+            "markdown-it-footnote": "latest",
+            ...props.devDependencies,
+        },
+    });
+    // Create .vitepress directory and config
+    await Folder(path.join(cwd, ".vitepress"));
+    await Folder(path.join(cwd, ".vitepress", "theme"));
+    await Promise.all([
+        TextFile(path.join(cwd, ".gitignore"), `.vitepress/cache\n`),
+        JsonFile(path.join(cwd, "tsconfig.json"), {
+            extends: props.tsconfig?.extends,
+            references: props.tsconfig?.references?.map((path) => ({ path })),
+            compilerOptions: props.tsconfig?.compilerOptions,
+        }),
+        TextFile(path.join(cwd, "index.md"), `---\n${yaml.stringify(props.home)}---\n`),
+        //       TypeScriptFile(
+        //         path.join(cwd, "alchemy.run.ts"),
+        //         `import alchemy from "alchemy";
+        // import { Folder } from "alchemy/fs";
+        // import { Document } from "alchemy/docs";
+        // import path from "path";
+        // await using _ = alchemy("alchemy.run", {
+        //   stage: "prod",
+        //   phase: process.argv.includes("--destroy") ? "destroy" : "up",
+        //   password: process.env.SECRET_PASSPHRASE,
+        //   quiet: !process.argv.includes("--verbose"),
+        // });
+        // const docs = await Folder(path.join("alchemy.run", "docs"));
+        // await Document("home.md", {
+        //   path: path.join(docs.path, "home.md"),
+        //   prompt: await alchemy\`Generate a landing page.\`,
+        // });
+        // `,
+        //       ),
+        TypeScriptFile(path.join(cwd, ".vitepress", "theme", "index.ts"), `import TwoslashFloatingVue from "@shikijs/vitepress-twoslash/client";
+import "@shikijs/vitepress-twoslash/style.css";
+import type { Theme as ThemeConfig } from "vitepress";
+import Theme from "vitepress/theme-without-fonts";
+import "./style.css";
+
+export default {
+  extends: Theme,
+  enhanceApp(ctx) {
+    ctx.app.use(TwoslashFloatingVue);
+  },
+} satisfies ThemeConfig;
+  `),
+        TextFile(path.join(cwd, ".vitepress", "theme", "style.css"), `/**
+* Customize default theme styling by overriding CSS variables:
+* https://github.com/vuejs/vitepress/blob/main/src/client/theme-default/styles/vars.css
+*/
+
+/**
+* Colors
+*
+* Each colors have exact same color scale system with 3 levels of solid
+* colors with different brightness, and 1 soft color.
+*
+* - \`XXX-1\`: The most solid color used mainly for colored text. It must
+*   satisfy the contrast ratio against when used on top of \`XXX-soft\`.
+*
+* - \`XXX-2\`: The color used mainly for hover state of the button.
+*
+* - \`XXX-3\`: The color for solid background, such as bg color of the button.
+*   It must satisfy the contrast ratio with pure white (#ffffff) text on
+*   top of it.
+*
+* - \`XXX-soft\`: The color used for subtle background such as custom container
+*   or badges. It must satisfy the contrast ratio when putting \`XXX-1\` colors
+*   on top of it.
+*
+*   The soft color must be semi transparent alpha channel. This is crucial
+*   because it allows adding multiple "soft" colors on top of each other
+*   to create a accent, such as when having inline code block inside
+*   custom containers.
+*
+* - \`default\`: The color used purely for subtle indication without any
+*   special meanings attached to it such as bg color for menu hover state.
+*
+* - \`brand\`: Used for primary brand colors, such as link text, button with
+*   brand theme, etc.
+*
+* - \`tip\`: Used to indicate useful information. The default theme uses the
+*   brand color for this by default.
+*
+* - \`warning\`: Used to indicate warning to the users. Used in custom
+*   container, badges, etc.
+*
+* - \`danger\`: Used to show error, or dangerous message to the users. Used
+*   in custom container, badges, etc.
+* -------------------------------------------------------------------------- */
+
+:root {
+  --vp-c-default-1: var(--vp-c-gray-1);
+  --vp-c-default-2: var(--vp-c-gray-2);
+  --vp-c-default-3: var(--vp-c-gray-3);
+  --vp-c-default-soft: var(--vp-c-gray-soft);
+
+  --vp-c-brand-1: var(--vp-c-indigo-1);
+  --vp-c-brand-2: var(--vp-c-indigo-2);
+  --vp-c-brand-3: var(--vp-c-indigo-3);
+  --vp-c-brand-soft: var(--vp-c-indigo-soft);
+
+  --vp-c-tip-1: var(--vp-c-brand-1);
+  --vp-c-tip-2: var(--vp-c-brand-2);
+  --vp-c-tip-3: var(--vp-c-brand-3);
+  --vp-c-tip-soft: var(--vp-c-brand-soft);
+
+  --vp-c-warning-1: var(--vp-c-yellow-1);
+  --vp-c-warning-2: var(--vp-c-yellow-2);
+  --vp-c-warning-3: var(--vp-c-yellow-3);
+  --vp-c-warning-soft: var(--vp-c-yellow-soft);
+
+  --vp-c-danger-1: var(--vp-c-red-1);
+  --vp-c-danger-2: var(--vp-c-red-2);
+  --vp-c-danger-3: var(--vp-c-red-3);
+  --vp-c-danger-soft: var(--vp-c-red-soft);
+}
+
+/**
+* Component: Button
+* -------------------------------------------------------------------------- */
+
+:root {
+  --vp-button-brand-border: transparent;
+  --vp-button-brand-text: var(--vp-c-white);
+  --vp-button-brand-bg: var(--vp-c-brand-3);
+  --vp-button-brand-hover-border: transparent;
+  --vp-button-brand-hover-text: var(--vp-c-white);
+  --vp-button-brand-hover-bg: var(--vp-c-brand-2);
+  --vp-button-brand-active-border: transparent;
+  --vp-button-brand-active-text: var(--vp-c-white);
+  --vp-button-brand-active-bg: var(--vp-c-brand-1);
+}
+
+/**
+* Component: Home
+* -------------------------------------------------------------------------- */
+
+:root {
+  --vp-home-hero-name-color: transparent;
+  --vp-home-hero-name-background: -webkit-linear-gradient(
+    120deg,
+    #bd34fe 30%,
+    #41d1ff
+  );
+
+  --vp-home-hero-image-background-image: linear-gradient(
+    -45deg,
+    #bd34fe 50%,
+    #47caff 50%
+  );
+  --vp-home-hero-image-filter: blur(44px);
+}
+
+@media (min-width: 640px) {
+  :root {
+    --vp-home-hero-image-filter: blur(56px);
+  }
+}
+
+@media (min-width: 960px) {
+  :root {
+    --vp-home-hero-image-filter: blur(68px);
+  }
+}
+
+/**
+* Component: Custom Block
+* -------------------------------------------------------------------------- */
+
+:root {
+  --vp-custom-block-tip-border: transparent;
+  --vp-custom-block-tip-text: var(--vp-c-text-1);
+  --vp-custom-block-tip-bg: var(--vp-c-brand-soft);
+  --vp-custom-block-tip-code-bg: var(--vp-c-brand-soft);
+}
+
+/**
+* Component: Algolia
+* -------------------------------------------------------------------------- */
+
+.DocSearch {
+  --docsearch-primary-color: var(--vp-c-brand-1) !important;
+}
+`),
+        TypeScriptFile(path.join(cwd, ".vitepress", "config.mts"), `import { transformerTwoslash } from "@shikijs/vitepress-twoslash";
+import footnotePlugin from "markdown-it-footnote";
+import { defineConfig } from "vitepress";
+
+// https://vitepress.dev/reference/site-config
+export default defineConfig({
+  title: ${JSON.stringify(props.title || "Alchemy")},
+  description: ${JSON.stringify(props.description || "Alchemy Docs")},
+  markdown: {
+    // @ts-ignore
+    codeTransformers: [transformerTwoslash()],
+    theme: ${JSON.stringify(props.theme ?? {
+            light: "light-plus",
+            dark: "dark-plus",
+        })},
+    config: (md) => md.use(footnotePlugin),
+  },
+  // https://vitepress.dev/reference/default-theme-config
+  themeConfig: ${JSON.stringify({
+            ...props.themeConfig,
+            search: props.themeConfig.search ?? { provider: "local" },
+            nav: props.themeConfig.nav ?? [{ text: "Home", link: "/" }],
+            sidebar: props.themeConfig.sidebar ?? [],
+            socialLinks: props.themeConfig.socialLinks ?? [],
+        })}
+});
+`),
+    ]);
+    return this(props);
+});

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "alchemy",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "module": "./lib/index.js",
   "scripts": {
-    "publish:npm": "cp ../README.md . && rm -rf ./*.tsbuildinfo && rm -rf ./lib && tsc -b && npm publish && rm README.md"
+    "publish:npm": "cp ../README.md . && rm -rf ./*.tsbuildinfo && rm -rf ./lib && tsc -b && npm publish && rm README.md",
+    "docs:gen": "rm -rf ./docs && typedoc"
   },
   "files": ["lib", "src"],
   "exports": {
     ".": "./lib/index.js",
+    "./ai": "./lib/ai/index.js",
     "./aws": "./lib/aws/index.js",
     "./aws/oidc": "./lib/aws/oidc/index.js",
     "./cloudflare": "./lib/cloudflare/index.js",
@@ -22,6 +24,7 @@
   },
   "peerDependencies": {
     "@ai-sdk/openai": "^1.1.9",
+    "@ai-sdk/openai-compatible": "^0.2.2",
     "@aws-sdk/client-dynamodb": "^3.0.0",
     "@aws-sdk/client-iam": "^3.0.0",
     "@aws-sdk/client-lambda": "^3.0.0",
@@ -31,17 +34,20 @@
     "@aws-sdk/client-sesv2": "^3.0.0",
     "@aws-sdk/client-sqs": "^3.0.0",
     "@aws-sdk/client-sts": "^3.0.0",
+    "arktype": "^2.0.0",
+    "prettier": "^3.0.0",
     "@octokit/rest": "^21.1.1",
-    "ai": "^4.1.16",
+    "ai": "^4.0.0",
     "diff": "^7.0.0",
-    "esbuild": "^0.24.2",
-    "glob": "^10.3.10",
-    "hono": "^4.7.4",
+    "esbuild": "^0.25.1",
+    "glob": "^10.0.0",
+    "hono": "^4.0.0",
     "libsodium-wrappers": "^0.7.15",
     "jszip": "^3.0.0",
-    "stripe": "^17.7.0",
-    "turndown": "^7.2.0",
-    "zod": "^3.24.1"
+    "stripe": "^17.0.0",
+    "turndown": "^7.0.0",
+    "yaml": "^2.0.0",
+    "zod": "^3.0.0"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^1.1.6",
@@ -55,12 +61,18 @@
     "@types/node": "latest",
     "@types/turndown": "^5.0.5",
     "ai": "^4.1.16",
+    "arktype": "^2.1.16",
     "change-case": "^5.4.4",
     "libsodium-wrappers": "^0.7.15",
     "openpgp": "^6.1.0",
+    "prettier": "^3.5.3",
     "turndown": "^7.2.0",
+    "typedoc": "^0.28.1",
+    "typedoc-plugin-markdown": "^4.6.0",
     "typescript": "latest",
     "vite": "^6.0.7",
-    "wrangler": "^3.114.0"
+    "vitepress": "^1.6.3",
+    "wrangler": "^3.114.0",
+    "yaml": "^2.7.1"
   }
 }

package/src/ai/ark.ts

@@ -0,0 +1,118 @@
+import {
+  type Tool as AITool,
+  type Schema,
+  type ToolExecutionOptions,
+  tool as aitool,
+  jsonSchema,
+} from "ai";
+import { ArkErrors, type JsonSchema, type type } from "arktype";
+
+export namespace ark {
+  export function schema<T>(type: JsonSchema): Schema<T>;
+  export function schema<T extends type>(type: T): Schema<type.infer<T>> {
+    const jsonSchemaObj = type.toJsonSchema() as any;
+    const processedSchema = processSchema(jsonSchemaObj);
+
+    return jsonSchema(processedSchema, {
+      validate: (value) => {
+        const out = type(value) as type.infer<T> | type.errors;
+        if (out instanceof ArkErrors) {
+          return {
+            success: false,
+            error: new Error(out.summary),
+          };
+        }
+        return {
+          success: true,
+          value: out,
+        };
+      },
+    });
+  }
+
+  /**
+   * Recursively processes a JSON schema and sets additionalProperties: false
+   * for any object types.
+   *
+   * Structured Outputs requires additionalProperties: false
+   */
+  function processSchema(schema: any): any {
+    if (!schema || typeof schema !== "object") return schema;
+
+    // Create a copy to avoid mutating the original
+    const result = { ...schema };
+
+    // Convert anyOf with all const values to enum
+    if (result.anyOf && Array.isArray(result.anyOf)) {
+      const allConst = result.anyOf.every(
+        (item: any) => item && typeof item === "object" && "const" in item,
+      );
+
+      if (allConst) {
+        // Extract all const values
+        const enumValues = result.anyOf.map((item: any) => item.const);
+
+        // Determine the type based on the first const value
+        // Assuming all const values are of the same type
+        const firstType = typeof enumValues[0];
+
+        // Replace anyOf with enum
+        delete result.anyOf;
+        result.type = firstType;
+        result.enum = enumValues;
+      } else {
+        // Process each item in anyOf
+        result.anyOf = result.anyOf.map(processSchema);
+      }
+    }
+
+    // If this is an object type, set additionalProperties: false
+    if (result.type === "object") {
+      result.additionalProperties = false;
+      result.properties ??= {};
+    }
+
+    // Process properties of objects
+    if (result.properties && typeof result.properties === "object") {
+      result.properties = Object.fromEntries(
+        Object.entries(result.properties).map(([key, value]) => [
+          key,
+          processSchema(value),
+        ]),
+      );
+    }
+
+    // Process items in arrays
+    if (result.items) {
+      result.items = processSchema(result.items);
+    }
+
+    // Process allOf, oneOf
+    for (const key of ["allOf", "oneOf"]) {
+      if (Array.isArray(result[key])) {
+        result[key] = result[key].map(processSchema);
+      }
+    }
+
+    return result;
+  }
+
+  export interface Tool<Input extends type, Output>
+    extends Omit<AITool<Schema<type.infer<Input>>>, "parameters" | "execute"> {
+    description?: string;
+    parameters: Input;
+    execute: (
+      input: type.infer<Input>,
+      options: ToolExecutionOptions,
+    ) => Promise<Output>;
+  }
+
+  export function tool<Input extends type, Output>(
+    tool: Tool<Input, Output>,
+  ): AITool<Schema<type.infer<Input>>, Output> {
+    return aitool({
+      ...tool,
+      parameters: ark.schema<Input>(tool.parameters),
+    } as any);
+  }
+}

package/src/ai/client.ts

@@ -0,0 +1,78 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import type { Secret } from "../secret";
+
+/**
+ * Model configuration for AI operations
+ */
+export interface ModelConfig {
+  /**
+   * Model ID to use
+   * @default 'gpt-4o'
+   */
+  id?: string;
+
+  /**
+   * Model provider name
+   * @default 'openai'
+   */
+  provider?: string;
+
+  /**
+   * Model-specific options
+   */
+  options?: Record<string, unknown>;
+}
+
+/**
+ * Configuration for creating an OpenAI client
+ */
+export interface ClientConfig {
+  /**
+   * Base URL for the OpenAI API
+   * @default 'https://api.openai.com/v1'
+   */
+  baseURL?: string;
+
+  /**
+   * OpenAI API key to use for generating content
+   * If not provided, will use OPENAI_API_KEY environment variable
+   */
+  apiKey?: Secret;
+
+  /**
+   * Model configuration
+   */
+  model?: ModelConfig;
+}
+
+/**
+ * Creates an OpenAI-compatible client with the given configuration
+ */
+export function createClient(config: ClientConfig) {
+  // Get API key from props or environment
+  const apiKey = config.apiKey?.unencrypted || process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OpenAI API key is required");
+  }
+
+  // Initialize OpenAI compatible provider
+  return createOpenAICompatible({
+    name: config.model?.provider || "openai",
+    apiKey,
+    baseURL: config.baseURL || "https://api.openai.com/v1",
+  });
+}
+
+/**
+ * Gets the model ID from the configuration or returns the default
+ */
+export function getModelId(config: ClientConfig): string {
+  return config.model?.id || "gpt-4o";
+}
+
+/**
+ * Gets the model options from the configuration
+ */
+export function getModelOptions(config: ClientConfig): Record<string, unknown> {
+  return config.model?.options || {};
+}