assistant-ui 0.0.105 → 0.0.107

package/src/commands/mcp.ts

@@ -135,6 +135,18 @@ function deepMerge(target: any, source: any): any {
   return result;
 }
 
+class McpConfigParseError extends Error {
+  constructor(targetName: string, configPath: string, flag: string) {
+    super(
+      `Invalid ${targetName} MCP config JSON at ${configPath}. Fix the JSON syntax, then run: assistant-ui mcp ${flag}`,
+    );
+    this.name = "McpConfigParseError";
+  }
+}
+
+const getTargetFlag = (target: Exclude<MCPTarget, "claude-code">) =>
+  `--${target}`;
+
 async function installForTarget(target: MCPTarget): Promise<void> {
   if (target === "claude-code") {
     logger.info("Installing MCP server for Claude Code...");
@@ -204,12 +216,15 @@ async function installForTarget(target: MCPTarget): Promise<void> {
     const content = fs.readFileSync(configPath, "utf-8");
     try {
       existingConfig = JSON.parse(content);
-    } catch (e) {
-      logger.error(`Could not parse existing config at ${configPath}`);
-      logger.error(
-        "Please fix the JSON syntax error before running this command.",
+    } catch {
+      const flag = getTargetFlag(target);
+      logger.error(`Could not parse ${targetConfig.name} MCP config.`);
+      logger.info(`Config path: ${configPath}`);
+      logger.info(
+        `Fix the JSON syntax in that file, then run: assistant-ui mcp ${flag}`,
       );
-      throw e;
+      logger.info("No changes were written.");
+      throw new McpConfigParseError(targetConfig.name, configPath, flag);
     }
   }
 

package/src/commands/update.ts

@@ -5,6 +5,15 @@ import { sync as spawnSync } from "cross-spawn";
 import { logger } from "../lib/utils/logger";
 import { getInstallCommand } from "../lib/utils/package-manager";
 
+const logPackageJsonParseError = (packageJsonPath: string) => {
+  logger.error("Could not parse package.json.");
+  console.error(`Package path: ${packageJsonPath}`);
+  console.error(
+    "Fix the JSON syntax in that file, then run: assistant-ui update",
+  );
+  console.error("No changes were written.");
+};
+
 export const update = new Command()
   .name("update")
   .description(
@@ -23,7 +32,14 @@ export const update = new Command()
       process.exit(1);
     }
 
-    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const packageJsonContent = fs.readFileSync(packageJsonPath, "utf-8");
+    let pkg: Record<string, Record<string, string> | undefined>;
+    try {
+      pkg = JSON.parse(packageJsonContent);
+    } catch {
+      logPackageJsonParseError(packageJsonPath);
+      process.exit(1);
+    }
     const sections = ["dependencies", "devDependencies"];
     const targets: string[] = [];
 

package/src/lib/create-project.ts

@@ -3,6 +3,11 @@ import * as path from "node:path";
 import { downloadTemplate } from "giget";
 import { sync as globSync } from "glob";
 import { detect } from "detect-package-manager";
+import {
+  parse as parseJsonc,
+  printParseErrorCode,
+  type ParseError,
+} from "jsonc-parser";
 import { logger } from "./utils/logger";
 import { runSpawn, SpawnExitError } from "./run-spawn";
 
@@ -205,22 +210,25 @@ export async function resolvePackageManagerForCwd(
   }
 }
 
+export interface TransformResult {
+  registryInstallFailure?: { retryCommand: string };
+}
+
 export async function transformProject(
   projectDir: string,
   opts: TransformOptions,
-): Promise<void> {
+): Promise<TransformResult> {
   logger.step("Transforming package.json...");
   transformPackageJson(projectDir);
 
+  logger.step("Transforming project files...");
+  transformTsConfig(projectDir);
+  transformCssFiles(projectDir);
+
   let assistantUI: string[] | undefined;
   let shadcnUI: string[] | undefined;
 
   if (!opts.hasLocalComponents) {
-    logger.step("Transforming project files...");
-
-    transformTsConfig(projectDir);
-    transformCssFiles(projectDir);
-
     const components = scanRequiredComponents(projectDir);
     assistantUI = components.assistantUI;
     shadcnUI = components.shadcnUI;
@@ -244,8 +252,15 @@ export async function transformProject(
     const auiComponents = assistantUI.map((c) => `@assistant-ui/${c}`);
     const components = [...allShadcn, ...auiComponents];
     logger.step(`Installing components: ${components.join(", ")}...`);
-    await installShadcnRegistry(projectDir, components, "components", pm);
+    const failure = await installShadcnRegistry(
+      projectDir,
+      components,
+      "components",
+      pm,
+    );
+    if (failure) return { registryInstallFailure: failure };
   }
+  return {};
 }
 
 function transformPackageJson(projectDir: string): void {
@@ -281,6 +296,18 @@ function transformPackageJson(projectDir: string): void {
   fs.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
 }
 
+function parseTsConfig(content: string): any {
+  const errors: ParseError[] = [];
+  const tsconfig = parseJsonc(content, errors, { allowTrailingComma: true });
+  const error = errors[0];
+  if (error) {
+    throw new SyntaxError(
+      `Invalid tsconfig.json: ${printParseErrorCode(error.error)} at offset ${error.offset}`,
+    );
+  }
+  return tsconfig;
+}
+
 function transformTsConfig(projectDir: string): void {
   const tsconfigPath = path.join(projectDir, "tsconfig.json");
 
@@ -289,16 +316,33 @@ function transformTsConfig(projectDir: string): void {
   }
 
   const content = fs.readFileSync(tsconfigPath, "utf-8");
-  const tsconfig = JSON.parse(content);
+  const tsconfig = parseTsConfig(content);
 
   // Remove workspace paths
   if (tsconfig.compilerOptions?.paths) {
-    delete tsconfig.compilerOptions.paths["@/components/assistant-ui/*"];
-    delete tsconfig.compilerOptions.paths["@/components/icons/*"];
-    delete tsconfig.compilerOptions.paths["@/components/ui/*"];
-    delete tsconfig.compilerOptions.paths["@/hooks/*"];
-    delete tsconfig.compilerOptions.paths["@/lib/utils"];
-    delete tsconfig.compilerOptions.paths["@assistant-ui/ui/*"];
+    const workspaceKeys = new Set([
+      "@/components/assistant-ui/*",
+      "@/components/icons/*",
+      "@/components/ui/*",
+      "@/components/ui/radix/*",
+      "@/hooks/*",
+      "@/lib/utils",
+      "@assistant-ui/ui/*",
+    ]);
+    for (const [key, targets] of Object.entries(
+      tsconfig.compilerOptions.paths as Record<string, unknown>,
+    )) {
+      const targetsWorkspace =
+        Array.isArray(targets) &&
+        targets.some(
+          (target) =>
+            typeof target === "string" &&
+            (target.includes("packages/ui/") || target.startsWith("../")),
+        );
+      if (workspaceKeys.has(key) || targetsWorkspace) {
+        delete tsconfig.compilerOptions.paths[key];
+      }
+    }
 
     if (Object.keys(tsconfig.compilerOptions.paths).length === 0) {
       delete tsconfig.compilerOptions.paths;
@@ -428,20 +472,20 @@ async function installShadcnRegistry(
   components: string[],
   label: string,
   pm: PackageManagerName,
-): Promise<void> {
+): Promise<{ retryCommand: string } | undefined> {
   const [cmd, dlxArgs] = dlxCommand(pm);
   // For npm, dlxArgs may already include `--yes` for npx auto-install.
   // The trailing `--yes` is for shadcn's own confirmation prompt.
-  const addArgs = [...dlxArgs, "shadcn@latest", "add", ...components, "--yes"];
+  const retryArgs = [...dlxArgs, "shadcn@latest", "add", ...components];
+  const addArgs = [...retryArgs, "--yes"];
 
   try {
     await runSpawn(cmd, addArgs, projectDir);
+    return undefined;
   } catch (error) {
     if (error instanceof SpawnExitError) {
-      logger.warn(
-        `shadcn exited with code ${error.code}. Run the following to retry:\n  ${cmd} ${addArgs.slice(0, -1).join(" ")}`,
-      );
-      return;
+      logger.warn(`shadcn exited with code ${error.code}.`);
+      return { retryCommand: `${cmd} ${retryArgs.join(" ")}` };
     }
 
     const message = error instanceof Error ? error.message : String(error);

package/src/lib/utils/registry.test.ts

@@ -0,0 +1,114 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  getComponentsJsonStyle,
+  resolveQuickStartRegistryUrl,
+  resolveRegistryItemUrl,
+} from "./registry";
+
+describe("getComponentsJsonStyle", () => {
+  let cwd: string;
+
+  beforeEach(() => {
+    cwd = fs.mkdtempSync(path.join(os.tmpdir(), "assistant-ui-cli-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  });
+
+  it("reads the style from components.json", () => {
+    fs.writeFileSync(
+      path.join(cwd, "components.json"),
+      JSON.stringify({ style: "base-nova" }),
+    );
+
+    expect(getComponentsJsonStyle(cwd)).toBe("base-nova");
+  });
+
+  it("ignores a stale assistant-ui.json", () => {
+    fs.writeFileSync(
+      path.join(cwd, "assistant-ui.json"),
+      JSON.stringify({ style: "new-york" }),
+    );
+    fs.writeFileSync(
+      path.join(cwd, "components.json"),
+      JSON.stringify({ style: "base-nova" }),
+    );
+
+    expect(getComponentsJsonStyle(cwd)).toBe("base-nova");
+  });
+
+  it("falls back when components.json is missing", () => {
+    expect(getComponentsJsonStyle(cwd)).toBeUndefined();
+  });
+
+  it("falls back when components.json cannot be parsed", () => {
+    fs.writeFileSync(path.join(cwd, "components.json"), "{");
+
+    expect(getComponentsJsonStyle(cwd)).toBeUndefined();
+  });
+
+  it("falls back when the style is not a string", () => {
+    fs.writeFileSync(
+      path.join(cwd, "components.json"),
+      JSON.stringify({ style: 7 }),
+    );
+
+    expect(getComponentsJsonStyle(cwd)).toBeUndefined();
+  });
+});
+
+describe("resolveQuickStartRegistryUrl", () => {
+  it("uses the base quick start for base styles", () => {
+    expect(resolveQuickStartRegistryUrl("base-nova")).toBe(
+      "https://r.assistant-ui.com/base/chat/b/ai-sdk-quick-start/json",
+    );
+  });
+
+  it("uses the radix quick start for radix styles", () => {
+    expect(resolveQuickStartRegistryUrl("radix-nova")).toBe(
+      "https://r.assistant-ui.com/chat/b/ai-sdk-quick-start/json",
+    );
+  });
+
+  it("uses the base quick start without a style", () => {
+    expect(resolveQuickStartRegistryUrl()).toBe(
+      "https://r.assistant-ui.com/base/chat/b/ai-sdk-quick-start/json",
+    );
+  });
+});
+
+describe("resolveRegistryItemUrl", () => {
+  it("uses the style scoped URL for base styles", () => {
+    expect(resolveRegistryItemUrl("thread", "base-nova")).toBe(
+      "https://r.assistant-ui.com/styles/base-nova/thread.json",
+    );
+  });
+
+  it("uses the plain URL for non-base styles", () => {
+    expect(resolveRegistryItemUrl("thread", "nova")).toBe(
+      "https://r.assistant-ui.com/thread.json",
+    );
+  });
+
+  it("uses the base URL without a style", () => {
+    expect(resolveRegistryItemUrl("thread")).toBe(
+      "https://r.assistant-ui.com/base/thread.json",
+    );
+  });
+
+  it("uses the base URL for an explicit undefined style", () => {
+    expect(resolveRegistryItemUrl("thread", undefined)).toBe(
+      "https://r.assistant-ui.com/base/thread.json",
+    );
+  });
+
+  it("keeps the style inside a single path segment", () => {
+    expect(resolveRegistryItemUrl("thread", "base-nova?preview=1")).toBe(
+      "https://r.assistant-ui.com/styles/base-nova%3Fpreview%3D1/thread.json",
+    );
+  });
+});

package/src/lib/utils/registry.ts

@@ -0,0 +1,43 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const REGISTRY_BASE_URL = "https://r.assistant-ui.com";
+
+export function getComponentsJsonStyle(cwd: string): string | undefined {
+  try {
+    const configPath = path.join(cwd, "components.json");
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8")) as {
+      style?: unknown;
+    };
+
+    return typeof config.style === "string" ? config.style : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function resolveQuickStartRegistryUrl(style?: string): string {
+  // The shadcn CLI appends a literal /json segment to fetched URLs containing
+  // /chat/b/ unless they already end with it, so this item must use the direct
+  // tree URLs rather than the /styles/ template.
+  if (style === undefined || style.startsWith("base-")) {
+    return `${REGISTRY_BASE_URL}/base/chat/b/ai-sdk-quick-start/json`;
+  }
+
+  return `${REGISTRY_BASE_URL}/chat/b/ai-sdk-quick-start/json`;
+}
+
+export function resolveRegistryItemUrl(
+  component: string,
+  style?: string,
+): string {
+  if (style === undefined) {
+    return `${REGISTRY_BASE_URL}/base/${encodeURIComponent(component)}.json`;
+  }
+
+  const registryUrl = style.startsWith("base-")
+    ? `${REGISTRY_BASE_URL}/styles/${encodeURIComponent(style)}`
+    : REGISTRY_BASE_URL;
+
+  return `${registryUrl}/${encodeURIComponent(component)}.json`;
+}

package/src/lib/utils/workspace.ts

@@ -0,0 +1,34 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export function resolveRealPath(inputPath: string): string {
+  const resolved = path.resolve(inputPath);
+
+  try {
+    return fs.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+export function findWorkspaceRoot(cwd: string): string | null {
+  let dir = path.resolve(cwd);
+  const root = path.parse(dir).root;
+
+  while (true) {
+    if (fs.existsSync(path.join(dir, "pnpm-workspace.yaml"))) return dir;
+
+    const pkgPath = path.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (pkg.workspaces) return dir;
+      } catch {
+        // Malformed package manifests are not workspace markers.
+      }
+    }
+
+    if (dir === root) return null;
+    dir = path.dirname(dir);
+  }
+}