assistant-ui 0.0.123 → 0.0.125

package/src/codemods/v0-11/content-part-to-message-part.ts

@@ -1,4 +1,5 @@
 import { createTransformer } from "../utils/createTransformer";
+import { resolveBinding } from "../utils/resolveBinding";
 
 // Map of old ContentPart names to new MessagePart names
 const typeRenamingMap: Record<string, string> = {
@@ -71,100 +72,230 @@ const typeRenamingMap: Record<string, string> = {
 
 const migrateContentPartToMessagePart = createTransformer(
   ({ j, root, markAsChanged }) => {
-    // 1. Update imports
-    root.find(j.ImportDeclaration).forEach((path: any) => {
-      const source = path.value.source.value;
+    const renameExport = (path: any, newName: string) => {
+      const specifier = path.value;
+      const replacement: any = j.exportSpecifier.from({
+        local: j.identifier(newName),
+        exported: j.Identifier.check(specifier.exported)
+          ? j.identifier(specifier.exported.name)
+          : specifier.exported,
+      });
+      replacement.exportKind = specifier.exportKind;
+      replacement.comments = specifier.comments;
+      path.replace(replacement);
+    };
 
-      // Only process imports from @assistant-ui packages
-      if (typeof source === "string" && source.startsWith("@assistant-ui/")) {
-        path.value.specifiers?.forEach((specifier: any) => {
-          if (j.ImportSpecifier.check(specifier)) {
-            const oldName = specifier.imported.name as string;
-            if (typeRenamingMap[oldName]) {
-              specifier.imported.name = typeRenamingMap[oldName];
-              if (specifier.local && specifier.local.name === oldName) {
-                specifier.local.name = typeRenamingMap[oldName];
-              }
-              markAsChanged();
-            }
-          }
-        });
-      }
+    const declaredNames = new Set<string>();
+    root.find(j.TSTypeParameter).forEach((path: any) => {
+      declaredNames.add(path.value.name.name ?? path.value.name);
     });
+    const identifiers = root.find(j.Identifier).paths();
+    for (const path of identifiers) {
+      if (path.parent.value.id === path.value)
+        declaredNames.add(path.value.name);
+    }
+    const usedNames = new Set(identifiers.map((path: any) => path.value.name));
+    const messageBindings = new Set<any>();
+    const namespaceBindings = new Set<any>();
+    const namespaceNames = new Set<string>();
 
-    // 2. Update MessagePrimitive.Content to MessagePrimitive.Parts
-    root.find(j.MemberExpression).forEach((path: any) => {
-      if (
-        path.value.object &&
-        path.value.object.name === "MessagePrimitive" &&
-        path.value.property &&
-        path.value.property.name === "Content"
-      ) {
-        path.value.property.name = "Parts";
-        markAsChanged();
-      }
-    });
-
-    // 3. Update JSX member expressions (e.g., MessagePrimitive.Content in JSX)
-    root.find(j.JSXMemberExpression).forEach((path: any) => {
-      if (
-        path.value.object &&
-        path.value.object.name === "MessagePrimitive" &&
-        path.value.property &&
-        path.value.property.name === "Content"
-      ) {
-        path.value.property.name = "Parts";
-        markAsChanged();
-      }
-    });
+    root.find(j.ImportDeclaration).forEach((path: any) => {
+      const source = path.value.source.value;
+      if (typeof source !== "string" || !source.startsWith("@assistant-ui/"))
+        return;
 
-    // 4. Update all identifiers for types, hooks, and primitives
-    Object.entries(typeRenamingMap).forEach(([oldName, newName]) => {
-      // Update type references
-      root.find(j.TSTypeReference).forEach((path: any) => {
-        if (path.value.typeName && path.value.typeName.name === oldName) {
-          path.value.typeName.name = newName;
-          markAsChanged();
+      path.value.specifiers?.forEach((specifier: any, index: number) => {
+        if (j.ImportNamespaceSpecifier.check(specifier)) {
+          namespaceBindings.add(specifier.local);
+          if (j.Identifier.check(specifier.local))
+            namespaceNames.add(specifier.local.name);
+          return;
         }
-      });
-
-      // Update identifier references
-      root.find(j.Identifier).forEach((path: any) => {
-        if (path.value.name === oldName) {
-          // Skip if this is part of an import declaration (already handled above)
-          if (j.ImportSpecifier.check(path.parent.value)) {
-            return;
-          }
+        if (
+          !j.ImportSpecifier.check(specifier) ||
+          !j.Identifier.check(specifier.imported) ||
+          !j.Identifier.check(specifier.local)
+        )
+          return;
+        const oldName = specifier.imported.name;
+        const importKind = (specifier as { importKind?: string }).importKind;
+        const typeOnly =
+          path.value.importKind === "type" || importKind === "type";
+        if (oldName === "MessagePrimitive" && !typeOnly) {
+          messageBindings.add(specifier.local);
+        }
+        const newName = typeRenamingMap[oldName];
+        if (!newName) return;
 
-          // Skip if this is a property key in an object
+        const references = identifiers.filter((reference: any) => {
+          const node = reference.value;
+          if (node.name !== oldName) return false;
+          const parent = reference.parent.value;
           if (
-            j.Property.check(path.parent.value) &&
-            path.parent.value.key === path.value
-          ) {
-            return;
-          }
-
-          // Skip if this is a property in a member expression
+            parent.type.startsWith("Import") ||
+            parent.id === node ||
+            parent.label === node
+          )
+            return false;
+          if (parent.key === node && !parent.computed && parent.value !== node)
+            return false;
+          if (parent.property === node && !parent.computed) return false;
+          if (j.TSQualifiedName.check(parent) && parent.right === node)
+            return false;
+          if (j.JSXAttribute.check(parent) || j.JSXNamespacedName.check(parent))
+            return false;
           if (
-            j.MemberExpression.check(path.parent.value) &&
-            path.parent.value.property === path.value
-          ) {
-            return;
+            (j.JSXOpeningElement.check(parent) ||
+              j.JSXClosingElement.check(parent)) &&
+            /^[a-z]/.test(oldName)
+          )
+            return false;
+          if (
+            j.ExportSpecifier.check(parent) &&
+            (reference.parent.parent.value.source || parent.local !== node)
+          )
+            return false;
+          return true;
+        });
+        // Retain the local alias when a declaration in either TypeScript namespace
+        // could capture a renamed reference. The resolver covers value bindings.
+        const canRename =
+          specifier.local.name === oldName &&
+          !usedNames.has(newName) &&
+          !declaredNames.has(newName) &&
+          !declaredNames.has(oldName) &&
+          references.every((reference: any) => {
+            const binding = resolveBinding(j, reference, oldName);
+            return binding === specifier.local || (typeOnly && !binding);
+          });
+        if (canRename) {
+          for (const reference of references) {
+            const parent = reference.parent.value;
+            if (
+              (j.Property.check(parent) || j.ObjectProperty.check(parent)) &&
+              parent.shorthand
+            ) {
+              parent.shorthand = false;
+              parent.key = j.identifier(oldName);
+              parent.value = j.identifier(newName);
+            } else if (j.ExportSpecifier.check(parent)) {
+              renameExport(reference.parent, newName);
+            } else {
+              reference.value.name = newName;
+            }
           }
-
-          path.value.name = newName;
-          markAsChanged();
         }
+        const replacement: any = j.importSpecifier(
+          j.identifier(newName),
+          j.identifier(canRename ? newName : specifier.local.name),
+        );
+        replacement.importKind = importKind;
+        replacement.comments = specifier.comments;
+        path.get("specifiers", index).replace(replacement);
+        markAsChanged();
       });
+    });
 
-      // Update JSX element names
-      root.find(j.JSXIdentifier).forEach((path: any) => {
-        if (path.value.name === oldName) {
-          path.value.name = newName;
-          markAsChanged();
-        }
+    root.find(j.ExportNamedDeclaration).forEach((path: any) => {
+      const source = path.value.source?.value;
+      if (typeof source !== "string" || !source.startsWith("@assistant-ui/"))
+        return;
+      path.value.specifiers?.forEach((specifier: any, index: number) => {
+        if (
+          !j.ExportSpecifier.check(specifier) ||
+          !j.Identifier.check(specifier.local)
+        )
+          return;
+        const newName = typeRenamingMap[specifier.local.name];
+        if (!newName) return;
+        renameExport(path.get("specifiers", index), newName);
+        markAsChanged();
       });
     });
+
+    const isTypeShadowed = (path: any, name: string) => {
+      if (!declaredNames.has(name)) return false;
+      for (let current = path.parent; current; current = current.parent) {
+        const node = current.value;
+        if (
+          node.type === "TSTypeParameterDeclaration" &&
+          node.params.some((param: any) => param.name === name)
+        )
+          return true;
+        if (node.type === "ClassExpression" && node.id?.name === name)
+          return true;
+        if (!["Program", "BlockStatement", "TSModuleBlock"].includes(node.type))
+          continue;
+        if (
+          node.body.some((statement: any) => {
+            const declaration = statement.declaration ?? statement;
+            return (
+              [
+                "TSInterfaceDeclaration",
+                "TSTypeAliasDeclaration",
+                "TSEnumDeclaration",
+                "ClassDeclaration",
+                "TSModuleDeclaration",
+              ].includes(declaration.type) && declaration.id?.name === name
+            );
+          })
+        )
+          return true;
+      }
+      return false;
+    };
+
+    const isInTypeQuery = (path: any) => {
+      for (let current = path.parent; current; current = current.parent) {
+        if (j.TSTypeQuery.check(current.value)) return true;
+      }
+      return false;
+    };
+
+    const renameNamespaceMember = (path: any) => {
+      const node = path.value;
+      const qualified = j.TSQualifiedName.check(node);
+      const object = qualified ? node.left : node.object;
+      const property = qualified ? node.right : node.property;
+      if (
+        node.computed ||
+        !j.Identifier.check(object) ||
+        !j.Identifier.check(property)
+      )
+        return;
+      const newName = typeRenamingMap[property.name];
+      if (!newName) return;
+      if (qualified && !isInTypeQuery(path)) {
+        if (
+          !namespaceNames.has(object.name) ||
+          isTypeShadowed(path, object.name)
+        )
+          return;
+      } else if (!namespaceBindings.has(resolveBinding(j, path, object.name))) {
+        return;
+      }
+      property.name = newName;
+      markAsChanged();
+    };
+    root.find(j.TSQualifiedName).forEach(renameNamespaceMember);
+    root.find(j.JSXMemberExpression).forEach(renameNamespaceMember);
+    root.find(j.MemberExpression).forEach(renameNamespaceMember);
+
+    const renameContent = (path: any) => {
+      const { object, property, computed } = path.value;
+      if (
+        computed ||
+        !j.Identifier.check(object) ||
+        !j.Identifier.check(property) ||
+        property.name !== "Content" ||
+        !messageBindings.has(resolveBinding(j, path, object.name))
+      )
+        return;
+      property.name = "Parts";
+      markAsChanged();
+    };
+    root.find(j.MemberExpression).forEach(renameContent);
+    root.find(j.JSXMemberExpression).forEach(renameContent);
   },
 );
 

package/src/codemods/v0-12/__tests__/event-names-to-camelcase.test.ts

@@ -125,3 +125,26 @@ function MyComponent() {
     );
   });
 });
+
+describe("event-name migration preserves unrelated strings", () => {
+  const cases = [
+    "constructor",
+    "toString",
+    "__proto__",
+    "hasOwnProperty",
+  ].flatMap((name) => [JSON.stringify(name), `\`${name}\``]);
+
+  it.each(cases)("leaves %s unchanged without event renames", (literal) => {
+    expectNoChange(`const key = ${literal};`);
+  });
+
+  it.each(cases)("preserves %s beside an event rename", (literal) => {
+    const source = `import { useAuiEvent } from "@assistant-ui/react";
+const key = ${literal};
+useAuiEvent("thread.run-start", () => {});`;
+    const output = applyTransform(source);
+    expect(output).toBe(source.replace("thread.run-start", "thread.runStart"));
+    expect(() => j(output!)).not.toThrow();
+    expectNoChange(output!);
+  });
+});

package/src/codemods/v0-12/__tests__/primitive-if-to-aui-if.test.ts

@@ -969,7 +969,7 @@ function MyComponent() {
   });
 });
 
-describe("condition precedence", () => {
+describe("condition semantics", () => {
   const compileCondition = (jsx: string) => {
     const output = applyTransform(`
 import { MessagePrimitive, ComposerPrimitive } from "@assistant-ui/react";
@@ -982,6 +982,40 @@ const view = ${jsx};
     ) => boolean;
   };
 
+  it.each(["hasBranches", "lastOrHover"])(
+    "keeps %s={false} unconditional",
+    (filter) => {
+      const condition = compileCondition(
+        `<MessagePrimitive.If ${filter}={false} />`,
+      );
+
+      for (const branchCount of [1, 2]) {
+        for (const isLast of [false, true]) {
+          for (const isHovering of [false, true]) {
+            expect(
+              condition({ message: { branchCount, isLast, isHovering } }),
+            ).toBe(true);
+          }
+        }
+      }
+    },
+  );
+
+  it.each(["hasBranches", "lastOrHover"])(
+    "keeps the role filter when %s={false}",
+    (filter) => {
+      const condition = compileCondition(
+        `<MessagePrimitive.If ${filter}={false} assistant />`,
+      );
+      const message = { branchCount: 1, isLast: false, isHovering: false };
+
+      expect(condition({ message: { ...message, role: "assistant" } })).toBe(
+        true,
+      );
+      expect(condition({ message: { ...message, role: "user" } })).toBe(false);
+    },
+  );
+
   it.each([
     {
       jsx: "<MessagePrimitive.If speaking={false} />",
@@ -1015,3 +1049,118 @@ const view = ${jsx};
     expect(condition(visible)).toBe(true);
   });
 });
+
+describe("conditional import bindings", () => {
+  it("adds AuiIf to the primitive's module when another package is imported later", () => {
+    const output =
+      applyTransform(`import { ThreadPrimitive } from "@assistant-ui/react";
+import { MarkdownTextPrimitive } from "@assistant-ui/react-markdown";
+export const Empty = () => <ThreadPrimitive.If empty><MarkdownTextPrimitive /></ThreadPrimitive.If>;`)!;
+    expect(output).toContain(
+      'import { ThreadPrimitive, AuiIf } from "@assistant-ui/react"',
+    );
+    expect(output).toContain(
+      'import { MarkdownTextPrimitive } from "@assistant-ui/react-markdown"',
+    );
+  });
+
+  it("uses an existing value import's local alias for both tags", () => {
+    const output =
+      applyTransform(`import { ThreadPrimitive, AuiIf as If } from "@assistant-ui/react";
+export const Empty = () => <ThreadPrimitive.If empty>Empty</ThreadPrimitive.If>;`)!;
+    expect(output).toContain("<If condition=");
+    expect(output).toContain("</If>");
+    expect(
+      j(output)
+        .find(j.ImportSpecifier, { imported: { name: "AuiIf" } })
+        .size(),
+    ).toBe(1);
+  });
+
+  it.each([
+    'import type { AuiIf } from "@assistant-ui/react";',
+    'import { type AuiIf } from "@assistant-ui/react";',
+    'import { AuiIf } from "./custom-if";',
+    'import { Other as AuiIf } from "@assistant-ui/react";',
+  ])(
+    "keeps a separate value binding when the name is occupied: %s",
+    (declaration) => {
+      const output =
+        applyTransform(`import { ThreadPrimitive } from "@assistant-ui/react";
+${declaration}
+export const Empty = () => <ThreadPrimitive.Empty>Empty</ThreadPrimitive.Empty>;`)!;
+      expect(output).toContain("AuiIf as AuiIf1");
+      expect(output).toContain("<AuiIf1 condition=");
+      expect(output).toContain("</AuiIf1>");
+      expect(output).toContain(declaration);
+    },
+  );
+
+  it("does not append a value component to a later type-only import", () => {
+    const output =
+      applyTransform(`import { ThreadPrimitive } from "@assistant-ui/react";
+import type { ThreadMessage } from "@assistant-ui/react";
+export const Empty = () => <ThreadPrimitive.If empty />;`)!;
+    expect(output).toContain(
+      'import { ThreadPrimitive, AuiIf } from "@assistant-ui/react"',
+    );
+    expect(output).toContain(
+      'import type { ThreadMessage } from "@assistant-ui/react"',
+    );
+  });
+
+  it("avoids shadowed aliases and reuses the fresh binding for multiple elements", () => {
+    const output =
+      applyTransform(`import { ThreadPrimitive, AuiIf as If } from "@assistant-ui/react";
+export function Empty(If, AuiIf) {
+  return <ThreadPrimitive.If empty><ThreadPrimitive.Empty /></ThreadPrimitive.If>;
+}`)!;
+    expect(output).toContain("AuiIf as AuiIf1");
+    expect(output.match(/<AuiIf1 condition=/g)).toHaveLength(2);
+    expect(output).toContain("</AuiIf1>");
+    expect(
+      j(output)
+        .find(j.ImportSpecifier, { imported: { name: "AuiIf" } })
+        .size(),
+    ).toBe(2);
+    expect(applyTransform(output)).toBeNull();
+  });
+
+  it("keeps namespace imports intact", () => {
+    const output =
+      applyTransform(`import { ThreadPrimitive } from "@assistant-ui/react";
+import * as primitives from "@assistant-ui/react";
+export const Empty = () => <ThreadPrimitive.If empty />;`)!;
+    expect(output).toContain(
+      'import { ThreadPrimitive, AuiIf } from "@assistant-ui/react"',
+    );
+    expect(output).toContain(
+      'import * as primitives from "@assistant-ui/react"',
+    );
+    expect(() => j(output)).not.toThrow();
+  });
+
+  it("uses a component name when an existing alias starts with lowercase", () => {
+    const output =
+      applyTransform(`import { ThreadPrimitive, AuiIf as conditional } from "@assistant-ui/react";
+export const Empty = () => <ThreadPrimitive.If empty />;`)!;
+    expect(output).toContain("<AuiIf1 condition=");
+    expect(output).toContain("AuiIf as conditional");
+    expect(
+      j(output)
+        .find(j.ImportSpecifier, { local: { name: "AuiIf1" } })
+        .size(),
+    ).toBe(1);
+  });
+
+  it("resolves aliased primitives without migrating their shadowed names", () => {
+    const output =
+      applyTransform(`import { ThreadPrimitive as Thread } from "@assistant-ui/react";
+export const Empty = () => <Thread.If empty />;
+export const Custom = (Thread) => <Thread.If empty />;`)!;
+    expect(output).toContain("export const Empty = () => <AuiIf condition=");
+    expect(output).toContain(
+      "export const Custom = (Thread) => <Thread.If empty />;",
+    );
+  });
+});

package/src/codemods/v0-12/event-names-to-camelcase.ts

@@ -1,6 +1,5 @@
 import { createTransformer } from "../utils/createTransformer";
 
-// Map of old kebab-case event names to new camelCase event names
 const eventNameMap: Record<string, string> = {
   "thread.run-start": "thread.runStart",
   "thread.run-end": "thread.runEnd",
@@ -12,16 +11,13 @@ const eventNameMap: Record<string, string> = {
 
 const migrateEventNamesToCamelCase = createTransformer(
   ({ j, root, markAsChanged }) => {
-    // Find all string literals in the code
     root.find(j.Literal).forEach((path: any) => {
       const node = path.value;
 
-      // Check if this is a string literal
       if (typeof node.value === "string") {
         const oldEventName = node.value;
 
-        // Check if this event name needs to be migrated
-        if (eventNameMap[oldEventName]) {
+        if (Object.hasOwn(eventNameMap, oldEventName)) {
           const newEventName = eventNameMap[oldEventName];
           node.value = newEventName;
           markAsChanged();
@@ -29,16 +25,14 @@ const migrateEventNamesToCamelCase = createTransformer(
       }
     });
 
-    // Also handle template literals (in case event names are in template strings)
     root.find(j.TemplateLiteral).forEach((path: any) => {
       const node = path.value;
 
-      // Check quasi (string parts) in template literals
       node.quasis.forEach((quasi: any) => {
         if (quasi.value && typeof quasi.value.raw === "string") {
           const oldEventName = quasi.value.raw;
 
-          if (eventNameMap[oldEventName]) {
+          if (Object.hasOwn(eventNameMap, oldEventName)) {
             const newEventName = eventNameMap[oldEventName];
             quasi.value.raw = newEventName;
             quasi.value.cooked = newEventName;