assistant-ui 0.0.116 → 0.0.118

package/src/lib/transform.test.ts

@@ -1,4 +1,8 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, onTestFinished, vi } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createRequire } from "node:module";
 
 const mocks = vi.hoisted(() => ({
   runSpawnCapture: vi.fn(),
@@ -13,6 +17,63 @@ import { transform } from "./transform";
 import { SpawnExitError } from "./run-spawn";
 
 describe("transform", () => {
+  it.each(["parse", "transform"])(
+    "rejects real jscodeshift %s failures",
+    async (kind) => {
+      const directory = mkdtempSync(join(tmpdir(), "aui-transform-errors-"));
+      onTestFinished(() => rmSync(directory, { recursive: true, force: true }));
+      const file = join(directory, "app.tsx");
+      const source =
+        kind === "parse"
+          ? 'import "@assistant-ui/react"; const broken = ;'
+          : 'import "@assistant-ui/react"; const value = 1;';
+      writeFileSync(file, source);
+      const codemod = join(directory, "transform.cjs");
+      writeFileSync(
+        codemod,
+        kind === "parse"
+          ? "module.exports = (file, api) => api.jscodeshift(file.source).toSource();"
+          : 'module.exports = () => { throw new Error("fixture transform failure"); };',
+      );
+      const actual =
+        await vi.importActual<typeof import("./run-spawn")>("./run-spawn");
+      const require = createRequire(import.meta.url);
+      mocks.runSpawnCapture.mockImplementationOnce(
+        (_command: string, args: string[]) => {
+          const runnerArgs = args.slice(1);
+          runnerArgs[runnerArgs.indexOf("-t") + 1] = codemod;
+          return actual.runSpawnCapture(process.execPath, [
+            require.resolve("jscodeshift/bin/jscodeshift.js"),
+            ...runnerArgs,
+            "--run-in-band",
+          ]);
+        },
+      );
+
+      const failure = transform(
+        "v0-12/assistant-api-to-aui",
+        directory,
+        {},
+        {
+          logStatus: false,
+          relevantFiles: [file],
+        },
+      );
+      await expect(failure).rejects.toBeInstanceOf(SpawnExitError);
+      await expect(failure).rejects.toThrow(
+        "Codemod 'v0-12/assistant-api-to-aui' failed",
+      );
+      await expect(failure).rejects.toThrow(
+        kind === "parse" ? "Transformation error" : "fixture transform failure",
+      );
+      await expect(failure).rejects.toMatchObject({
+        stdout: expect.stringContaining("Transformation error"),
+      });
+      expect(readFileSync(file, "utf8")).toBe(source);
+    },
+    15_000,
+  );
+
   it("runs codemods asynchronously and reports progress", async () => {
     mocks.runSpawnCapture.mockResolvedValue({
       code: 0,
@@ -62,7 +123,14 @@ describe("transform", () => {
     );
 
     await expect(failure).rejects.toBeInstanceOf(SpawnExitError);
+    await expect(failure).rejects.toThrow(
+      "Codemod 'v0-8/ui-package-split' failed",
+    );
     await expect(failure).rejects.toThrow("SyntaxError: Broken input");
+    await expect(failure).rejects.toMatchObject({
+      stdout: "Processing file app.tsx\n",
+      stderr: "SyntaxError: Broken input\n",
+    });
     expect(onProgress).not.toHaveBeenCalled();
   });
 

package/src/lib/transform.ts

@@ -7,19 +7,23 @@ import { sync as globSync } from "glob";
 import { runSpawnCapture, SpawnExitError, SpawnSignalError } from "./run-spawn";
 
 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
+ * Gets relevant source files from an explicit file or directory target.
+ * Directory scans only include files containing "assistant-ui".
  */
-export function getRelevantFiles(cwd: string): string[] {
+export function getRelevantFiles(source: string): string[] {
+  const target = path.resolve(source);
+  if (fs.statSync(target).isFile()) {
+    return /\.(js|jsx|ts|tsx)$/.test(target) ? [target] : [];
+  }
+
   const pattern = "**/*.{js,jsx,ts,tsx}";
   const files = globSync(pattern, {
-    cwd,
+    cwd: target,
     ignore: [
       "**/node_modules/**",
       "**/dist/**",
@@ -27,26 +31,25 @@ export function getRelevantFiles(cwd: string): string[] {
       "**/*.min.js",
       "**/*.bundle.js",
     ],
-  });
+  }).map((file) => path.join(target, file));
 
-  // Filter files to only include those containing "assistant-ui"
   const relevantFiles = files.filter((file) => {
     try {
-      const content = fs.readFileSync(path.join(cwd, file), "utf8");
+      const content = fs.readFileSync(file, "utf8");
       return content.includes("assistant-ui");
     } catch {
       return false;
     }
   });
 
-  return relevantFiles.map((file) => path.join(cwd, file));
+  return relevantFiles;
 }
 
 /**
  * Counts the number of files that need to be processed
  */
-export function countFilesToProcess(cwd: string): number {
-  return getRelevantFiles(cwd).length;
+export function countFilesToProcess(source: string): number {
+  return getRelevantFiles(source).length;
 }
 
 function buildCommand(
@@ -62,6 +65,7 @@ function buildCommand(
     ...targetFiles,
     "--parser",
     "tsx",
+    "--fail-on-error",
   ];
 
   if (options.dry) {
@@ -89,23 +93,6 @@ export type TransformErrors = {
   summary: string;
 }[];
 
-function parseErrors(transform: string, output: string): TransformErrors {
-  const errors: TransformErrors = [];
-  const errorRegex = /ERR (.+) Transformation error/g;
-  const syntaxErrorRegex = /SyntaxError: .+/g;
-
-  for (const match of output.matchAll(errorRegex)) {
-    const filename = match[1]!;
-    const syntaxErrorMatch = syntaxErrorRegex.exec(output);
-    if (syntaxErrorMatch) {
-      const summary = syntaxErrorMatch[0];
-      errors.push({ transform, filename, summary });
-    }
-  }
-
-  return errors;
-}
-
 export async function transform(
   codemod: string,
   source: string,
@@ -138,7 +125,13 @@ export async function transform(
     throw new SpawnSignalError(result.signal, false);
   }
   if (result.code !== 0) {
-    throw new SpawnExitError(result.code || 1, result.stderr);
+    const failure = new SpawnExitError(
+      result.code || 1,
+      result.stderr,
+      result.stdout,
+    );
+    failure.message = `Codemod '${codemod}' failed\n${failure.message}`;
+    throw failure;
   }
 
   const { stdout } = result;
@@ -148,13 +141,5 @@ export async function transform(
     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;
+  return [];
 }

package/src/lib/upgrade.ts

@@ -1,5 +1,5 @@
 import debug from "debug";
-import { transform, type TransformErrors, getRelevantFiles } from "./transform";
+import { transform, getRelevantFiles } from "./transform";
 import type { TransformOptions } from "./transform-options";
 import { SingleBar, Presets } from "cli-progress";
 import installEdgeLib from "./install-edge-lib";
@@ -16,13 +16,12 @@ const bundle = [
 ];
 
 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.
+ *   - Outside dry mode, checks for new package imports and prompts for install.
  */
 export async function upgrade(options: TransformOptions) {
   const cwd = process.cwd();
@@ -48,14 +47,13 @@ export async function upgrade(options: TransformOptions) {
   );
 
   bar.start(totalWork, 0, { status: "Starting..." });
-  const allErrors: TransformErrors = [];
 
   try {
     for (const codemod of bundle) {
       bar.update(completedWork, { status: `Running ${codemod}...` });
 
       // Use a custom progress callback to update the progress bar
-      const errors = await transform(codemod, cwd, options, {
+      await transform(codemod, cwd, options, {
         logStatus: false,
         onProgress: (processedFiles: number) => {
           completedWork = bundle.indexOf(codemod) * fileCount + processedFiles;
@@ -66,24 +64,22 @@ export async function upgrade(options: TransformOptions) {
         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.update(totalWork, {
+      status: options.dry ? "Preview complete" : "Checking dependencies...",
+    });
   } finally {
     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}`);
-    });
+  if (options.dry) {
+    logger.success("Dry run complete. No files were changed.");
+    return;
   }
 
-  // After codemods run, check if files import from the new packages and prompt for install.
   logger.info("Checking for package dependencies...");
   await installEdgeLib();
   await installAiSdkLib();

package/src/lib/utils/package-manager.ts

@@ -9,13 +9,36 @@ export type PackageManagerName = "npm" | "pnpm" | "yarn" | "bun";
 
 export function askQuestion(query: string): Promise<string> {
   return new Promise((resolve) => {
+    // A stream only reaches EOF once, so a run that already consumed stdin gets
+    // no further `end` and an interface built over it would wait on a `close`
+    // that cannot arrive. An upgrade asks up to three questions.
+    if (process.stdin.readableEnded) {
+      resolve("");
+      return;
+    }
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
     });
-    rl.question(query, (answer) => {
+    // stdin at EOF (a piped or CI run) emits `close` without a `line`, so the
+    // question callback alone would leave this pending forever and the process
+    // would exit 0 with the remaining work silently skipped. An empty answer is
+    // what pressing Enter sends, so EOF lands on the prompt's own default.
+    // A final answer with no trailing newline arrives as `line` instead of
+    // through the callback, and has to win over that default.
+    // Ctrl-C in raw mode is delivered as this event rather than as a signal,
+    // and without a listener readline answers it by closing — which the EOF
+    // default would then read as approval. A cancelled prompt declines.
+    let cancelled = false;
+    rl.on("SIGINT", () => {
+      cancelled = true;
       rl.close();
+    });
+    rl.on("line", resolve);
+    rl.on("close", () => resolve(cancelled ? "n" : ""));
+    rl.question(query, (answer) => {
       resolve(answer);
+      rl.close();
     });
   });
 }

package/plugin/.claude-plugin/plugin.json

@@ -1,8 +0,0 @@
-{
-  "name": "assistant-ui",
-  "description": "Build AI chat interfaces using assistant-ui components",
-  "version": "0.1.0",
-  "author": {
-    "name": "assistant-ui"
-  }
-}

package/plugin/skills/assistant-ui/SKILL.md

@@ -1,199 +0,0 @@
----
-name: assistant-ui
-description: Add, configure, and integrate assistant-ui components in React apps. Use when developers ask to add a chat thread, set up a runtime, integrate with AI SDK, configure tools, or build AI chat interfaces with assistant-ui.
----
-
-# assistant-ui
-
-Use this skill to help users build AI chat interfaces with assistant-ui.
-
-## Step 1: Check Project Setup
-
-Check if the project has `components.json` (shadcn config) and `@assistant-ui/react` installed.
-
-If assistant-ui is not yet set up, run:
-
-```bash
-npx assistant-ui init --yes
-```
-
-This initializes shadcn and installs the default assistant-ui chat components.
-
-## Step 2: Add Components
-
-Install components via the shadcn registry:
-
-```bash
-npx shadcn@latest add "https://r.assistant-ui.com/base/chat/b/ai-sdk-quick-start/json"
-```
-
-For Radix-styled projects (`components.json` style not starting with `base-`), use `https://r.assistant-ui.com/chat/b/ai-sdk-quick-start/json` instead.
-
-Available component presets:
-
-| Preset | Registry URL |
-|--------|-------------|
-| AI SDK Quick Start | `https://r.assistant-ui.com/base/chat/b/ai-sdk-quick-start/json` |
-
-You can also add individual assistant-ui components with the assistant-ui CLI, which picks the right flavor from `components.json`:
-
-```bash
-npx assistant-ui add thread
-npx assistant-ui add markdown-text
-```
-
-To use the shadcn CLI directly instead, add the assistant-ui registry to `components.json`:
-
-```json
-{
-  "registries": {
-    "@assistant-ui": "https://r.assistant-ui.com/styles/{style}/{name}.json"
-  }
-}
-```
-
-Then add components with the namespaced form:
-
-```bash
-npx shadcn@latest add @assistant-ui/thread
-npx shadcn@latest add @assistant-ui/markdown-text
-```
-
-## Step 3: Runtime Setup
-
-assistant-ui requires a runtime. The most common setup uses AI SDK:
-
-### AI SDK Runtime (recommended)
-
-Install the integration package:
-```bash
-npm install @assistant-ui/ai-sdk
-```
-
-Create a chat API route (Next.js App Router):
-
-```ts
-// app/api/chat/route.ts
-import { openai } from "@ai-sdk/openai";
-import { streamText } from "ai";
-
-export const maxDuration = 30;
-
-export async function POST(req: Request) {
-  const { messages, config } = await req.json();
-
-  const result = streamText({
-    model: openai("gpt-5.6-luna"),
-    messages,
-    ...config,
-  });
-
-  return result.toDataStreamResponse();
-}
-```
-
-Create the assistant component:
-
-```tsx
-"use client";
-
-import { AssistantRuntimeProvider } from "@assistant-ui/react";
-import { useChatRuntime } from "@assistant-ui/ai-sdk";
-import { Thread } from "@/components/assistant-ui/elements/thread.aui";
-
-export const Assistant = () => {
-  const runtime = useChatRuntime({
-    api: "/api/chat",
-  });
-
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      <Thread />
-    </AssistantRuntimeProvider>
-  );
-};
-```
-
-## Step 4: Tools (optional)
-
-To add tool calling support, define tools on the backend and render them on the frontend:
-
-### Backend tool (AI SDK):
-
-```ts
-import { streamText, tool } from "ai";
-import { z } from "zod";
-
-const result = streamText({
-  model: openai("gpt-5.6-luna"),
-  messages,
-  tools: {
-    get_weather: tool({
-      description: "Get weather for a location",
-      parameters: z.object({
-        location: z.string(),
-      }),
-      execute: async ({ location }) => {
-        return { temperature: 72, condition: "sunny", location };
-      },
-    }),
-  },
-});
-```
-
-### Frontend tool UI:
-
-Create a toolkit with a renderer for the tool. The tool executes on the backend, so the entry uses `externalTool()` and only attaches UI:
-
-```tsx
-// app/toolkit.tsx
-"use generative";
-
-import { defineToolkit, externalTool } from "@assistant-ui/react";
-
-export default defineToolkit({
-  get_weather: {
-    execute: externalTool(),
-    render: ({ args, result }) => {
-      return (
-        <div>
-          <p>Weather for {args?.location}</p>
-          {result && <p>{result.temperature}F, {result.condition}</p>}
-        </div>
-      );
-    },
-  },
-});
-```
-
-Register the toolkit in your assistant component:
-
-```tsx
-import { AssistantRuntimeProvider, Tools, useAui } from "@assistant-ui/react";
-import toolkit from "@/app/toolkit";
-
-const aui = useAui({
-  tools: Tools({ toolkit }),
-});
-
-<AssistantRuntimeProvider aui={aui} runtime={runtime}>
-  <Thread />
-</AssistantRuntimeProvider>
-```
-
-Do not use `makeAssistantToolUI`, `useAssistantToolUI`, `makeAssistantTool`, or `useAssistantTool`; they are deprecated in favor of toolkits.
-
-## Key Packages
-
-| Package | Purpose |
-|---------|---------|
-| `@assistant-ui/react` | Core React components and primitives |
-| `@assistant-ui/ai-sdk` | Vercel AI SDK integration |
-| `@assistant-ui/react-markdown` | Markdown rendering |
-| `@assistant-ui/react-syntax-highlighter` | Code highlighting |
-| `@assistant-ui/ui` | Pre-built shadcn/ui component set |
-| `@assistant-ui/styles` | Pre-built CSS for non-Tailwind users |
-
-## Environment Variables
-
-For OpenAI-based setups, ensure `OPENAI_API_KEY` is set in `.env.local`.

package/plugin/skills/assistant-ui/shipables.json

@@ -1,22 +0,0 @@
-{
-  "version": "1.0.0",
-  "keywords": [
-    "assistant-ui",
-    "chat",
-    "ai",
-    "chatbot",
-    "react",
-    "ai-sdk",
-    "shadcn",
-    "thread",
-    "copilot",
-    "assistant"
-  ],
-  "categories": ["frameworks", "ai-ml"],
-  "author": {
-    "name": "Yonom",
-    "github": "Yonom"
-  },
-  "repository": "https://github.com/assistant-ui/assistant-ui",
-  "homepage": "https://www.assistant-ui.com"
-}