assistant-ui 0.0.49 → 0.0.50

package/src/codemods/v0-9/edge-package-split.ts

@@ -0,0 +1,226 @@
+import { createTransformer } from "../utils/createTransformer";
+
+const reactEdgeExports: string[] = [
+  // Edge Runtime
+  "useEdgeRuntime",
+  "EdgeRuntimeOptions",
+  "EdgeModelAdapter",
+  "EdgeChatAdapter",
+  "EdgeRuntimeRequestOptions",
+  "createEdgeRuntimeAPI",
+  "getEdgeRuntimeResponse",
+
+  // Core Types
+  "CoreMessage",
+  "CoreUserMessage",
+  "CoreAssistantMessage",
+  "CoreSystemMessage",
+  "CoreUserContentPart",
+  "CoreAssistantContentPart",
+  "CoreToolCallContentPart",
+
+  // Core message converters
+  "fromCoreMessages",
+  "fromCoreMessage",
+  "toCoreMessages",
+  "toCoreMessage",
+];
+
+// Language model converters to be moved to react-ai-sdk
+const reactAiSdkExports: string[] = [
+  "toLanguageModelMessages",
+  "toLanguageModelTools",
+  "fromLanguageModelMessages",
+  "fromLanguageModelTools",
+  "useDangerousInBrowserRuntime",
+];
+
+const migrateToEdgePackage = createTransformer(({ j, root, markAsChanged }) => {
+  const sourcesToMigrate: string[] = ["@assistant-ui/react"];
+  const movedEdgeSpecifiers: any[] = [];
+  const movedAiSdkSpecifiers: any[] = [];
+  let lastMigratedImportPath: any = null;
+
+  root
+    .find(j.ImportDeclaration)
+    .filter((path: any) => sourcesToMigrate.includes(path.value.source.value))
+    .forEach((path: any) => {
+      let hadMigratedSpecifiers = false;
+      const remainingSpecifiers: any[] = [];
+      path.value.specifiers.forEach((specifier: any) => {
+        if (
+          j.ImportSpecifier.check(specifier) &&
+          reactEdgeExports.includes(specifier.imported.name as string)
+        ) {
+          movedEdgeSpecifiers.push(specifier);
+          hadMigratedSpecifiers = true;
+        } else if (
+          j.ImportSpecifier.check(specifier) &&
+          reactAiSdkExports.includes(specifier.imported.name as string)
+        ) {
+          movedAiSdkSpecifiers.push(specifier);
+          hadMigratedSpecifiers = true;
+        } else {
+          remainingSpecifiers.push(specifier);
+        }
+      });
+      if (hadMigratedSpecifiers) {
+        lastMigratedImportPath = path;
+      }
+      if (remainingSpecifiers.length === 0) {
+        j(path).remove();
+        markAsChanged();
+      } else if (remainingSpecifiers.length !== path.value.specifiers.length) {
+        path.value.specifiers = remainingSpecifiers;
+        markAsChanged();
+      }
+    });
+
+  // Add imports for react-edge
+  if (movedEdgeSpecifiers.length > 0) {
+    const existingEdgeImport = root.find(j.ImportDeclaration, {
+      source: { value: "@assistant-ui/react-edge" },
+    });
+    if (existingEdgeImport.size() > 0) {
+      existingEdgeImport.forEach((path: any) => {
+        movedEdgeSpecifiers.forEach((specifier: any) => {
+          if (
+            !path.value.specifiers.some(
+              (s: any) => s.imported.name === specifier.imported.name,
+            )
+          ) {
+            path.value.specifiers.push(specifier);
+          }
+        });
+      });
+    } else {
+      const newImport = j.importDeclaration(
+        movedEdgeSpecifiers,
+        j.literal("@assistant-ui/react-edge"),
+      );
+      if (lastMigratedImportPath) {
+        j(lastMigratedImportPath).insertAfter(newImport);
+      } else {
+        const firstImport = root.find(j.ImportDeclaration).at(0);
+        if (firstImport.size() > 0) {
+          firstImport.insertBefore(newImport);
+        } else {
+          root.get().node.program.body.unshift(newImport);
+        }
+      }
+    }
+    markAsChanged();
+  }
+
+  // Add imports for react-ai-sdk
+  if (movedAiSdkSpecifiers.length > 0) {
+    const existingAiSdkImport = root.find(j.ImportDeclaration, {
+      source: { value: "@assistant-ui/react-ai-sdk" },
+    });
+    if (existingAiSdkImport.size() > 0) {
+      existingAiSdkImport.forEach((path: any) => {
+        movedAiSdkSpecifiers.forEach((specifier: any) => {
+          if (
+            !path.value.specifiers.some(
+              (s: any) => s.imported.name === specifier.imported.name,
+            )
+          ) {
+            path.value.specifiers.push(specifier);
+          }
+        });
+      });
+    } else {
+      const newImport = j.importDeclaration(
+        movedAiSdkSpecifiers,
+        j.literal("@assistant-ui/react-ai-sdk"),
+      );
+      if (lastMigratedImportPath) {
+        j(lastMigratedImportPath).insertAfter(newImport);
+      } else {
+        const firstImport = root.find(j.ImportDeclaration).at(0);
+        if (firstImport.size() > 0) {
+          firstImport.insertBefore(newImport);
+        } else {
+          root.get().node.program.body.unshift(newImport);
+        }
+      }
+    }
+    markAsChanged();
+  }
+
+  // Migrate imports from edge/converters
+  root.find(j.ImportDeclaration).forEach((path: any) => {
+    const sourceValue: string = path.value.source.value;
+    if (
+      sourceValue.startsWith("@assistant-ui/react/") &&
+      (sourceValue.includes("edge/") ||
+        sourceValue.includes("dangerous-in-browser/"))
+    ) {
+      path.value.source = j.literal(
+        sourceValue.replace(
+          "@assistant-ui/react/",
+          "@assistant-ui/react-edge/",
+        ),
+      );
+      markAsChanged();
+    }
+  });
+
+  // Migrate language model converter imports from react-edge to react-ai-sdk
+  root.find(j.ImportDeclaration).forEach((path: any) => {
+    const sourceValue: string = path.value.source.value;
+    if (sourceValue === "@assistant-ui/react-edge") {
+      let hasLanguageModelConverters = false;
+      const remainingSpecifiers: any[] = [];
+      const aiSdkSpecifiers: any[] = [];
+
+      path.value.specifiers.forEach((specifier: any) => {
+        if (
+          j.ImportSpecifier.check(specifier) &&
+          reactAiSdkExports.includes(specifier.imported.name as string)
+        ) {
+          aiSdkSpecifiers.push(specifier);
+          hasLanguageModelConverters = true;
+        } else {
+          remainingSpecifiers.push(specifier);
+        }
+      });
+
+      if (hasLanguageModelConverters) {
+        if (remainingSpecifiers.length === 0) {
+          j(path).remove();
+        } else {
+          path.value.specifiers = remainingSpecifiers;
+        }
+
+        const existingAiSdkImport = root.find(j.ImportDeclaration, {
+          source: { value: "@assistant-ui/react-ai-sdk" },
+        });
+
+        if (existingAiSdkImport.size() > 0) {
+          existingAiSdkImport.forEach((importPath: any) => {
+            aiSdkSpecifiers.forEach((specifier: any) => {
+              if (
+                !importPath.value.specifiers.some(
+                  (s: any) => s.imported.name === specifier.imported.name,
+                )
+              ) {
+                importPath.value.specifiers.push(specifier);
+              }
+            });
+          });
+        } else {
+          const newImport = j.importDeclaration(
+            aiSdkSpecifiers,
+            j.literal("@assistant-ui/react-ai-sdk"),
+          );
+          j(path).insertAfter(newImport);
+        }
+
+        markAsChanged();
+      }
+    }
+  });
+});
+
+export default migrateToEdgePackage;

package/src/commands/add.ts

@@ -0,0 +1,47 @@
+import { Command } from "commander";
+import { spawn } from "cross-spawn";
+
+const REGISTRY_BASE_URL = "https://r.assistant-ui.com";
+
+export const add = new Command()
+  .name("add")
+  .description("add a component to your project")
+  .argument("<components...>", "the components to add")
+  .option("-y, --yes", "skip confirmation prompt.", true)
+  .option("-o, --overwrite", "overwrite existing files.", false)
+  .option(
+    "-c, --cwd <cwd>",
+    "the working directory. defaults to the current directory.",
+    process.cwd(),
+  )
+  .option("-p, --path <path>", "the path to add the component to.")
+  .action((components: string[], opts) => {
+    const componentsToAdd = components.map((c) => {
+      if (!/^[a-zA-Z0-9-\/]+$/.test(c)) {
+        throw new Error(`Invalid component name: ${c}`);
+      }
+      return `${REGISTRY_BASE_URL}/${encodeURIComponent(c)}`;
+    });
+
+    const args = [`shadcn@latest`, "add", ...componentsToAdd];
+
+    if (opts.yes) args.push("--yes");
+    if (opts.overwrite) args.push("--overwrite");
+    if (opts.cwd) args.push("--cwd", opts.cwd);
+    if (opts.path) args.push("--path", opts.path);
+
+    const child = spawn("npx", args, {
+      stdio: "inherit",
+      shell: true,
+    });
+
+    child.on("error", (error) => {
+      console.error(`Error: ${error.message}`);
+    });
+
+    child.on("close", (code) => {
+      if (code !== 0) {
+        console.log(`other-package-script process exited with code ${code}`);
+      }
+    });
+  });

package/src/commands/create.ts

@@ -0,0 +1,92 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { spawn } from "cross-spawn";
+
+export const create = new Command()
+  .name("create")
+  .description("create a new project")
+  .argument("[project-directory]")
+  .usage(`${chalk.green("[project-directory]")} [options]`)
+  .option(
+    "-t, --template <template>",
+    `
+
+  The template to use for the project, e.g. default, langgraph
+`,
+  )
+  .option(
+    "--use-npm",
+    `
+
+  Explicitly tell the CLI to bootstrap the application using npm
+`,
+  )
+  .option(
+    "--use-pnpm",
+    `
+
+  Explicitly tell the CLI to bootstrap the application using pnpm
+`,
+  )
+  .option(
+    "--use-yarn",
+    `
+
+  Explicitly tell the CLI to bootstrap the application using Yarn
+`,
+  )
+  .option(
+    "--use-bun",
+    `
+
+  Explicitly tell the CLI to bootstrap the application using Bun
+`,
+  )
+  .option(
+    "--skip-install",
+    `
+
+  Explicitly tell the CLI to skip installing packages
+`,
+  )
+  .action((_, opts) => {
+    const templates = {
+      default: "https://github.com/assistant-ui/assistant-ui-starter",
+      langgraph:
+        "https://github.com/assistant-ui/assistant-ui-starter-langgraph",
+    };
+
+    const templateUrl =
+      templates[(opts.template as keyof typeof templates) ?? "default"];
+    if (!templateUrl) {
+      console.error(`Unknown template: ${opts.template}`);
+      process.exit(1);
+    }
+
+    const filteredArgs = process.argv.slice(3).filter((arg, index, arr) => {
+      return !(
+        arg === "-t" ||
+        arg === "--template" ||
+        arr[index - 1] === "-t" ||
+        arr[index - 1] === "--template"
+      );
+    });
+
+    const child = spawn(
+      "npx",
+      [`create-next-app@latest`, ...filteredArgs, "-e", templateUrl],
+      {
+        stdio: "inherit",
+      },
+    );
+
+    child.on("error", (error) => {
+      console.error(`Error: ${error.message}`);
+    });
+
+    child.on("close", (code) => {
+      if (code !== 0) {
+        console.log(`other-package-script process exited with code ${code}`);
+      }
+    });
+  });

package/src/commands/init.ts

@@ -0,0 +1,50 @@
+import { Command } from "commander";
+import { spawn } from "cross-spawn";
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import { create } from "./create";
+
+export const init = new Command()
+  .name("init")
+  .description("initialize assistant-ui in a new or existing project")
+  .action(async () => {
+    // Check if package.json exists in the current directory
+    const packageJsonPath = path.join(process.cwd(), "package.json");
+    const packageJsonExists = fs.existsSync(packageJsonPath);
+
+    if (packageJsonExists) {
+      // If package.json exists, run shadcn add command
+      console.log(
+        chalk.blue("Initializing assistant-ui in existing project..."),
+      );
+
+      const child = spawn(
+        "npx",
+        [
+          `shadcn@latest`,
+          "add",
+          "https://r.assistant-ui.com/chat/b/ai-sdk-quick-start/json",
+        ],
+        {
+          stdio: "inherit",
+        },
+      );
+
+      child.on("error", (error) => {
+        console.error(`Error: ${error.message}`);
+      });
+
+      child.on("close", (code) => {
+        if (code !== 0) {
+          console.log(`shadcn process exited with code ${code}`);
+        }
+      });
+    } else {
+      // If package.json doesn't exist, use the create command
+      console.log(chalk.blue("Creating a new assistant-ui project..."));
+
+      // Execute the create command with default template
+      await create.parseAsync([]);
+    }
+  });

package/src/commands/update.ts

@@ -0,0 +1,60 @@
+import { Command } from "commander";
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import { detect } from "detect-package-manager";
+import { sync as spawnSync } from "cross-spawn";
+
+export const update = new Command()
+  .name("update")
+  .description(
+    "Update all '@assistant-ui/*' and 'assistant-stream' packages in package.json to latest versions using your package manager.",
+  )
+  .option("--dry", "Print the package manager command instead of running it.")
+  .action(async (opts) => {
+    const packageJsonPath = path.join(process.cwd(), "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+      console.error(
+        chalk.red("No package.json found in the current directory."),
+      );
+      process.exit(1);
+    }
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const sections = ["dependencies", "devDependencies"];
+    const targets: string[] = [];
+    for (const section of sections) {
+      if (!pkg[section]) continue;
+      for (const dep in pkg[section]) {
+        if (dep.startsWith("@assistant-ui/") || dep === "assistant-stream") {
+          targets.push(dep);
+        }
+      }
+    }
+    if (!targets.length) {
+      console.log(chalk.yellow("No matching packages found to update."));
+      return;
+    }
+    const pm = await detect({ cwd: process.cwd() });
+    let cmd: string;
+    if (pm === "yarn") {
+      cmd = `yarn add ${targets.map((d) => `${d}@latest`).join(" ")}`;
+    } else if (pm === "pnpm") {
+      cmd = `pnpm add ${targets.map((d) => `${d}@latest`).join(" ")}`;
+    } else if (pm === "bun") {
+      cmd = `bun add ${targets.map((d) => `${d}@latest`).join(" ")}`;
+    } else {
+      cmd = `npm install ${targets.map((d) => `${d}@latest`).join(" ")}`;
+    }
+    if (opts.dry) {
+      console.log(chalk.blue("\nDry run: would run the following command:"));
+      console.log(cmd);
+      return;
+    }
+    console.log(chalk.blue(`\nRunning: ${cmd}`));
+    const result = spawnSync(cmd, { shell: true, stdio: "inherit" });
+    if (result.status !== 0) {
+      console.error(chalk.red("Package manager update failed."));
+      process.exit(result.status || 1);
+    }
+    console.log(chalk.green("\nAll packages updated to latest version!"));
+  });

package/src/commands/upgrade.ts

@@ -0,0 +1,55 @@
+import { Command } from "commander";
+import { transform } from "../lib/transform";
+import { upgrade } from "../lib/upgrade";
+import debug from "debug";
+
+export interface TransformOptions {
+  dry?: boolean;
+  print?: boolean;
+  verbose?: boolean;
+  jscodeshift?: string;
+}
+
+const error = debug("codemod:error");
+debug.enable("codemod:*");
+
+const addTransformOptions = (command: Command): Command => {
+  return command
+    .option("-d, --dry", "Dry run (no changes are made to files)")
+    .option("-p, --print", "Print transformed files to stdout")
+    .option("--verbose", "Show more information about the transform process")
+    .option(
+      "-j, --jscodeshift <options>",
+      "Pass options directly to jscodeshift",
+    );
+};
+
+export const codemodCommand = addTransformOptions(
+  new Command()
+    .name("codemod")
+    .description("CLI tool for running codemods")
+    .argument("<codemod>", "Codemod to run (e.g., rewrite-framework-imports)")
+    .argument("<source>", "Path to source files or directory to transform"),
+).action((codemod, source, options: TransformOptions) => {
+  try {
+    transform(codemod, source, options);
+  } catch (err: any) {
+    error(`Error transforming: ${err}`);
+    error(err.stack);
+    process.exit(1);
+  }
+});
+
+export const upgradeCommand = addTransformOptions(
+  new Command()
+    .command("upgrade")
+    .description("Upgrade ai package dependencies and apply codemods"),
+).action((options: TransformOptions) => {
+  try {
+    upgrade(options);
+  } catch (err: any) {
+    error(`Error upgrading: ${err}`);
+    error(err.stack);
+    process.exit(1);
+  }
+});

package/src/index.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { create } from "./commands/create";
+import { add } from "./commands/add";
+import { codemodCommand, upgradeCommand } from "./commands/upgrade";
+import { init } from "./commands/init";
+import { update } from "./commands/update";
+
+process.on("SIGINT", () => process.exit(0));
+process.on("SIGTERM", () => process.exit(0));
+
+function main() {
+  const program = new Command()
+    .name("assistant-ui")
+    .description("add components and dependencies to your project");
+
+  program.addCommand(add);
+  program.addCommand(create);
+  program.addCommand(init);
+  program.addCommand(codemodCommand);
+  program.addCommand(upgradeCommand);
+  program.addCommand(update);
+
+  program.parse();
+}
+
+main();

package/src/lib/install-ai-sdk-lib.ts

@@ -0,0 +1,92 @@
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import { sync as globSync } from "glob";
+import * as readline from "readline";
+import { detect } from "detect-package-manager";
+
+function askQuestion(query: string): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(query, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+function isPackageInstalled(pkg: string): boolean {
+  const cwd = process.cwd();
+  try {
+    const pkgJsonPath = path.join(cwd, "package.json");
+    if (fs.existsSync(pkgJsonPath)) {
+      const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+      const deps = pkgJson.dependencies || {};
+      const devDeps = pkgJson.devDependencies || {};
+      if (deps[pkg] || devDeps[pkg]) {
+        return true;
+      }
+    }
+  } catch (e) {
+    // Fall back to node_modules check below.
+  }
+  const modulePath = path.join(cwd, "node_modules", ...pkg.split("/"));
+  return fs.existsSync(modulePath);
+}
+
+export default async function installAiSdkLib(): Promise<void> {
+  const cwd = process.cwd();
+  const pattern = "**/*.{js,jsx,ts,tsx}";
+  const files = globSync(pattern, {
+    cwd,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
+  });
+
+  let found = false;
+  for (const file of files) {
+    const fullPath = path.join(cwd, file);
+    const content = fs.readFileSync(fullPath, "utf8");
+    if (content.includes("@assistant-ui/react-ai-sdk")) {
+      found = true;
+      break;
+    }
+  }
+
+  if (found) {
+    if (isPackageInstalled("@assistant-ui/react-ai-sdk")) {
+      console.log(
+        "@assistant-ui/react-ai-sdk is already installed. Skipping installation.",
+      );
+      return;
+    }
+
+    const answer = await askQuestion(
+      "AI SDK imports were added but @assistant-ui/react-ai-sdk is not installed. Do you want to install it? (Y/n) ",
+    );
+    if (answer === "" || answer.toLowerCase().startsWith("y")) {
+      const pm = await detect();
+      let cmd = "";
+      if (pm === "yarn") {
+        cmd = "yarn add @assistant-ui/react-ai-sdk";
+      } else if (pm === "pnpm") {
+        cmd = "pnpm add @assistant-ui/react-ai-sdk";
+      } else if (pm === "bun") {
+        cmd = "bun add @assistant-ui/react-ai-sdk";
+      } else {
+        cmd = "npm install @assistant-ui/react-ai-sdk";
+      }
+      try {
+        execSync(cmd, { stdio: "inherit" });
+      } catch (e) {
+        console.error("Installation failed:", e);
+      }
+    } else {
+      console.log("Skipping installation.");
+    }
+  } else {
+    console.log("No AI SDK imports found; skipping installation.");
+  }
+}