assistant-ui 0.0.49 → 0.0.50

package/src/lib/install-edge-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 installEdgeLib(): 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-edge")) {
+      found = true;
+      break;
+    }
+  }
+
+  if (found) {
+    if (isPackageInstalled("@assistant-ui/react-edge")) {
+      console.log(
+        "@assistant-ui/react-edge is already installed. Skipping installation.",
+      );
+      return;
+    }
+
+    const answer = await askQuestion(
+      "Edge Runtime imports were added but @assistant-ui/react-edge 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-edge";
+      } else if (pm === "pnpm") {
+        cmd = "pnpm add @assistant-ui/react-edge";
+      } else if (pm === "bun") {
+        cmd = "bun add @assistant-ui/react-edge";
+      } else {
+        cmd = "npm install @assistant-ui/react-edge";
+      }
+      try {
+        execSync(cmd, { stdio: "inherit" });
+      } catch (e) {
+        console.error("Installation failed:", e);
+      }
+    } else {
+      console.log("Skipping installation.");
+    }
+  } else {
+    console.log("No Edge Runtime imports found; skipping installation.");
+  }
+}

package/src/lib/install-ui-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 installReactUILib(): 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-ui")) {
+      found = true;
+      break;
+    }
+  }
+
+  if (found) {
+    if (isPackageInstalled("@assistant-ui/react-ui")) {
+      console.log(
+        "@assistant-ui/react-ui is already installed. Skipping installation.",
+      );
+      return;
+    }
+
+    const answer = await askQuestion(
+      "React UI imports were added but @assistant-ui/react-ui 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-ui";
+      } else if (pm === "pnpm") {
+        cmd = "pnpm add @assistant-ui/react-ui";
+      } else if (pm === "bun") {
+        cmd = "bun add @assistant-ui/react-ui";
+      } else {
+        cmd = "npm install @assistant-ui/react-ui";
+      }
+      try {
+        execSync(cmd, { stdio: "inherit" });
+      } catch (e) {
+        console.error("Installation failed:", e);
+      }
+    } else {
+      console.log("Skipping installation.");
+    }
+  } else {
+    console.log("No React UI imports found; skipping installation.");
+  }
+}

package/src/lib/transform-options.ts

@@ -0,0 +1,6 @@
+export interface TransformOptions {
+  dry?: boolean;
+  print?: boolean;
+  verbose?: boolean;
+  jscodeshift?: string;
+}

package/src/lib/transform.ts

@@ -0,0 +1,177 @@
+import { execFileSync, spawnSync } from "child_process";
+import debug from "debug";
+import path from "path";
+import { TransformOptions } from "./transform-options";
+import { fileURLToPath } from "url";
+import * as fs from "fs";
+import { sync as globSync } from "glob";
+
+const log = debug("codemod:transform");
+const error = debug("codemod:transform:error");
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Gets the list of files that need to be processed in the codebase
+ * Only includes files that contain "assistant-ui" to optimize performance
+ */
+export function getRelevantFiles(cwd: string): string[] {
+  const pattern = "**/*.{js,jsx,ts,tsx}";
+  const files = globSync(pattern, {
+    cwd,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/*.min.js",
+      "**/*.bundle.js",
+    ],
+  });
+
+  // Filter files to only include those containing "assistant-ui"
+  const relevantFiles = files.filter((file) => {
+    try {
+      const content = fs.readFileSync(path.join(cwd, file), "utf8");
+      return content.includes("assistant-ui");
+    } catch (err) {
+      return false;
+    }
+  });
+
+  return relevantFiles.map((file) => path.join(cwd, file));
+}
+
+/**
+ * Counts the number of files that need to be processed
+ */
+export function countFilesToProcess(cwd: string): number {
+  return getRelevantFiles(cwd).length;
+}
+
+function buildCommand(
+  codemodPath: string,
+  targetFiles: string[],
+  options: TransformOptions,
+): string[] {
+  const command = [
+    "npx",
+    "jscodeshift",
+    "-t",
+    codemodPath,
+    ...targetFiles,
+    "--parser",
+    "tsx",
+  ];
+
+  if (options.dry) {
+    command.push("--dry");
+  }
+
+  if (options.print) {
+    command.push("--print");
+  }
+
+  if (options.verbose) {
+    command.push("--verbose");
+  }
+
+  if (options.jscodeshift) {
+    command.push(options.jscodeshift);
+  }
+
+  return command;
+}
+
+export type TransformErrors = {
+  transform: string;
+  filename: string;
+  summary: string;
+}[];
+
+function parseErrors(transform: string, output: string): TransformErrors {
+  const errors: TransformErrors = [];
+  const errorRegex = /ERR (.+) Transformation error/g;
+  const syntaxErrorRegex = /SyntaxError: .+/g;
+
+  let match;
+  while ((match = errorRegex.exec(output)) !== null) {
+    const filename = match[1]!;
+    const syntaxErrorMatch = syntaxErrorRegex.exec(output);
+    if (syntaxErrorMatch) {
+      const summary = syntaxErrorMatch[0];
+      errors.push({ transform, filename, summary });
+    }
+  }
+
+  return errors;
+}
+
+export function transform(
+  codemod: string,
+  source: string,
+  transformOptions: TransformOptions,
+  options: {
+    logStatus: boolean;
+    onProgress?: (processedFiles: number) => void;
+    relevantFiles?: string[];
+  } = { logStatus: true },
+): TransformErrors {
+  if (options.logStatus) {
+    log(`Applying codemod '${codemod}': ${source}`);
+  }
+  const codemodPath = path.resolve(__dirname, `../codemods/${codemod}.js`);
+
+  // Use pre-computed relevant files if provided, otherwise get them
+  const targetFiles = options.relevantFiles || getRelevantFiles(source);
+
+  if (targetFiles.length === 0) {
+    log(`No relevant files found for codemod '${codemod}'`);
+    return [];
+  }
+
+  log(`Found ${targetFiles.length} relevant files for codemod '${codemod}'`);
+
+  const command = buildCommand(codemodPath, targetFiles, transformOptions);
+
+  // Use spawn instead of execFileSync to capture output in real-time
+  if (options.onProgress) {
+    const result = spawnSync(command[0]!, command.slice(1), {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    const stdout = result.stdout || "";
+
+    // Count the number of processed files from the output
+    const processedFiles = (stdout.match(/Processing file/g) || []).length;
+    if (options.onProgress) {
+      options.onProgress(processedFiles);
+    }
+
+    const errors = parseErrors(codemod, stdout);
+    if (options.logStatus && errors.length > 0) {
+      errors.forEach(({ transform, filename, summary }) => {
+        error(
+          `Error applying codemod [codemod=${transform}, path=${filename}, summary=${summary}]`,
+        );
+      });
+    }
+    return errors;
+  } else {
+    // Use the original synchronous approach if no progress callback
+    const stdout = execFileSync(command[0]!, command.slice(1), {
+      encoding: "utf8",
+      stdio: "pipe",
+    });
+    const errors = parseErrors(codemod, stdout);
+    if (options.logStatus && errors.length > 0) {
+      errors.forEach(({ transform, filename, summary }) => {
+        error(
+          `Error applying codemod [codemod=${transform}, path=${filename}, summary=${summary}]`,
+        );
+      });
+    }
+    return errors;
+  }
+}

package/src/lib/upgrade.ts

@@ -0,0 +1,83 @@
+import debug from "debug";
+import { transform, TransformErrors, getRelevantFiles } from "./transform";
+import { TransformOptions } from "./transform-options";
+import { SingleBar, Presets } from "cli-progress";
+import installReactUILib from "./install-ui-lib";
+import installEdgeLib from "./install-edge-lib";
+import installAiSdkLib from "./install-ai-sdk-lib";
+
+const bundle = ["v0-8/ui-package-split", "v0-9/edge-package-split"];
+
+const log = debug("codemod:upgrade");
+const error = debug("codemod:upgrade:error");
+
+/**
+ * Runs the upgrade cycle:
+ *   - Runs each codemod in the bundle.
+ *   - Displays progress using cli-progress.
+ *   - After codemods run, checks if any file now imports from the new packages and prompts for install.
+ */
+export async function upgrade(options: TransformOptions) {
+  const cwd = process.cwd();
+  log("Starting upgrade...");
+
+  // Find relevant files once to avoid duplicate work
+  console.log("Analyzing codebase...");
+  const relevantFiles = getRelevantFiles(cwd);
+  const fileCount = relevantFiles.length;
+  console.log(`Found ${fileCount} files to process.`);
+
+  // Calculate total work units (files × codemods)
+  const totalWork = fileCount * bundle.length;
+  let completedWork = 0;
+
+  const bar = new SingleBar(
+    {
+      format: "Progress |{bar}| {percentage}% | ETA: {eta}s || {status}",
+      hideCursor: true,
+    },
+    Presets.shades_classic,
+  );
+
+  bar.start(totalWork, 0, { status: "Starting..." });
+  const allErrors: TransformErrors = [];
+
+  for (const codemod of bundle) {
+    bar.update(completedWork, { status: `Running ${codemod}...` });
+
+    // Use a custom progress callback to update the progress bar
+    const errors = transform(codemod, cwd, options, {
+      logStatus: false,
+      onProgress: (processedFiles: number) => {
+        completedWork = bundle.indexOf(codemod) * fileCount + processedFiles;
+        bar.update(Math.min(completedWork, totalWork), {
+          status: `Running ${codemod} (${processedFiles}/${fileCount} files)`,
+        });
+      },
+      relevantFiles, // Pass the pre-computed relevant files
+    });
+
+    allErrors.push(...errors);
+    completedWork = (bundle.indexOf(codemod) + 1) * fileCount;
+    bar.update(completedWork, { status: `Completed ${codemod}` });
+  }
+
+  bar.update(totalWork, { status: "Checking dependencies..." });
+  bar.stop();
+
+  if (allErrors.length > 0) {
+    log("Some codemods did not apply successfully to all files. Details:");
+    allErrors.forEach(({ transform, filename, summary }) => {
+      error(`codemod=${transform}, path=${filename}, summary=${summary}`);
+    });
+  }
+
+  // After codemods run, check if files import from the new packages and prompt for install.
+  console.log("Checking for package dependencies...");
+  await installReactUILib();
+  await installEdgeLib();
+  await installAiSdkLib();
+
+  log("Upgrade complete.");
+  console.log("✅ Upgrade complete!");
+}