@mmapp/react-compiler 0.1.0-alpha.1

package/dist/codemod/cli.js

@@ -0,0 +1,1104 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/codemod/cli.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_glob = require("glob");
+
+// src/codemod/index.ts
+var import_core = require("@babel/core");
+var import_helper_plugin_utils = require("@babel/helper-plugin-utils");
+
+// src/codemod/forward.ts
+var t2 = __toESM(require("@babel/types"));
+
+// src/codemod/rules.ts
+var FORWARD_RULES = [
+  // div with flex-col → Stack
+  {
+    htmlTag: "div",
+    atom: "Stack",
+    classSignal: ["flex-col"],
+    implicitClasses: ["flex", "flex-col"],
+    priority: 20
+  },
+  // div with grid → Grid
+  {
+    htmlTag: "div",
+    atom: "Grid",
+    classSignal: ["grid"],
+    implicitClasses: ["grid"],
+    priority: 20
+  },
+  // div with flex (no flex-col) → Row
+  {
+    htmlTag: "div",
+    atom: "Row",
+    classSignal: ["flex"],
+    implicitClasses: ["flex"],
+    priority: 10
+  },
+  // div with no layout signal → Stack (default container)
+  {
+    htmlTag: "div",
+    atom: "Stack",
+    classSignal: [],
+    implicitClasses: [],
+    priority: 0
+  },
+  // Semantic HTML
+  { htmlTag: "main", atom: "Stack", implicitClasses: [] },
+  { htmlTag: "aside", atom: "Stack", implicitClasses: [] },
+  { htmlTag: "nav", atom: "Stack", implicitClasses: [] },
+  { htmlTag: "section", atom: "Section", implicitClasses: [] },
+  { htmlTag: "header", atom: "Row", implicitClasses: [] },
+  { htmlTag: "footer", atom: "Row", implicitClasses: [] },
+  // Text elements
+  { htmlTag: "span", atom: "Text", implicitClasses: [] },
+  { htmlTag: "p", atom: "Text", implicitClasses: [] },
+  { htmlTag: "label", atom: "Text", implicitClasses: [] },
+  { htmlTag: "h1", atom: "Text", implicitClasses: [], props: { variant: "h1" } },
+  { htmlTag: "h2", atom: "Text", implicitClasses: [], props: { variant: "h2" } },
+  { htmlTag: "h3", atom: "Text", implicitClasses: [], props: { variant: "h3" } },
+  { htmlTag: "h4", atom: "Text", implicitClasses: [], props: { variant: "h4" } },
+  { htmlTag: "h5", atom: "Text", implicitClasses: [], props: { variant: "h5" } },
+  { htmlTag: "h6", atom: "Text", implicitClasses: [], props: { variant: "h6" } },
+  // Interactive elements
+  { htmlTag: "button", atom: "Button", implicitClasses: [] },
+  { htmlTag: "a", atom: "Link", implicitClasses: [] },
+  // Form elements
+  { htmlTag: "input", atom: "TextInput", implicitClasses: [] },
+  {
+    htmlTag: "textarea",
+    atom: "TextInput",
+    implicitClasses: [],
+    props: { multiline: true }
+  },
+  // Media
+  { htmlTag: "img", atom: "Image", implicitClasses: [] }
+];
+var REVERSE_RULES = [
+  { atom: "Stack", htmlTag: "div", injectClasses: ["flex", "flex-col"] },
+  { atom: "Row", htmlTag: "div", injectClasses: ["flex"] },
+  { atom: "Grid", htmlTag: "div", injectClasses: ["grid"] },
+  { atom: "Text", htmlTag: "span" },
+  { atom: "Button", htmlTag: "button" },
+  { atom: "Link", htmlTag: "a" },
+  { atom: "TextInput", htmlTag: "input" },
+  { atom: "Image", htmlTag: "img" },
+  { atom: "Section", htmlTag: "section" }
+];
+var CONTROL_FLOW_ATOMS = /* @__PURE__ */ new Set([
+  "Show",
+  "Each",
+  "Modal",
+  "Slot",
+  "Divider"
+]);
+var ATOM_IMPORT_SOURCE = "@mindmatrix/react/atoms";
+var TEXT_VARIANT_TO_TAG = {
+  h1: "h1",
+  h2: "h2",
+  h3: "h3",
+  h4: "h4",
+  h5: "h5",
+  h6: "h6"
+};
+
+// src/codemod/classify.ts
+function extractStaticClasses(attrValue) {
+  if (!attrValue) return [];
+  if (attrValue.type === "StringLiteral") {
+    return attrValue.value.split(/\s+/).filter(Boolean);
+  }
+  if (attrValue.type === "JSXExpressionContainer") {
+    return extractStaticClasses(attrValue.expression);
+  }
+  if (attrValue.type === "TemplateLiteral") {
+    const staticParts = attrValue.quasis.map((q) => q.value.raw).join(" ");
+    return staticParts.split(/\s+/).filter(Boolean);
+  }
+  if (attrValue.type === "CallExpression" && attrValue.callee.type === "Identifier" && attrValue.callee.name === "cn" && attrValue.arguments.length > 0) {
+    const firstArg = attrValue.arguments[0];
+    if (firstArg.type === "StringLiteral") {
+      return firstArg.value.split(/\s+/).filter(Boolean);
+    }
+  }
+  return [];
+}
+function classifyElement(tagName, classNames) {
+  if (tagName[0] === tagName[0].toUpperCase() && tagName[0] !== tagName[0].toLowerCase()) {
+    return null;
+  }
+  if (tagName.startsWith("motion.")) {
+    return null;
+  }
+  const candidates = FORWARD_RULES.filter((r) => r.htmlTag === tagName).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  if (candidates.length === 0) return null;
+  if (tagName === "div") {
+    for (const rule2 of candidates) {
+      if (!rule2.classSignal || rule2.classSignal.length === 0) {
+        continue;
+      }
+      const hasAllSignals = rule2.classSignal.every((s) => classNames.includes(s));
+      if (hasAllSignals) {
+        return makeResult(rule2, tagName);
+      }
+    }
+    const defaultRule = candidates.find((r) => (r.priority ?? 0) === 0);
+    if (defaultRule) {
+      return makeResult(defaultRule, tagName);
+    }
+  }
+  const rule = candidates[0];
+  return makeResult(rule, tagName);
+}
+function makeResult(rule, tagName) {
+  return {
+    atom: rule.atom,
+    removeClasses: rule.implicitClasses ?? [],
+    addProps: rule.props ?? {},
+    originalTag: tagName
+  };
+}
+function reverseClassifyAtom(atomName, props) {
+  if (CONTROL_FLOW_ATOMS.has(atomName)) return null;
+  if (atomName === "Text") {
+    const variantNode = props.get("variant");
+    if (variantNode && variantNode.type === "StringLiteral") {
+      const tag = TEXT_VARIANT_TO_TAG[variantNode.value];
+      if (tag) {
+        return {
+          htmlTag: tag,
+          injectClasses: [],
+          removeProps: ["variant"]
+        };
+      }
+    }
+    return { htmlTag: "span", injectClasses: [], removeProps: [] };
+  }
+  if (atomName === "TextInput") {
+    const multilineNode = props.get("multiline");
+    if (multilineNode) {
+      const isMultiline = multilineNode.type === "BooleanLiteral" && multilineNode.value || multilineNode.type === "JSXExpressionContainer" && multilineNode.expression?.type === "BooleanLiteral" && multilineNode.expression?.value;
+      if (isMultiline) {
+        return { htmlTag: "textarea", injectClasses: [], removeProps: ["multiline"] };
+      }
+    }
+    return { htmlTag: "input", injectClasses: [], removeProps: [] };
+  }
+  const rule = REVERSE_RULES.find((r) => r.atom === atomName);
+  if (!rule) return null;
+  return {
+    htmlTag: rule.htmlTag,
+    injectClasses: rule.injectClasses ?? [],
+    removeProps: rule.removeProps ?? []
+  };
+}
+function removeClassesFromString(className, toRemove) {
+  if (toRemove.length === 0) return className;
+  const removeSet = new Set(toRemove);
+  return className.split(/\s+/).filter((c) => c && !removeSet.has(c)).join(" ");
+}
+function addClassesToString(className, toAdd) {
+  if (toAdd.length === 0) return className;
+  const existing = new Set(className.split(/\s+/).filter(Boolean));
+  const newClasses = toAdd.filter((c) => !existing.has(c));
+  if (newClasses.length === 0) return className;
+  return [...newClasses, ...className.split(/\s+/).filter(Boolean)].join(" ");
+}
+
+// src/codemod/control-flow.ts
+var t = __toESM(require("@babel/types"));
+function matchConditionalRender(expr) {
+  if (expr.type !== "LogicalExpression" || expr.operator !== "&&") return null;
+  if (!isJSXLike(expr.right)) return null;
+  return { condition: expr.left, consequent: expr.right };
+}
+function matchTernaryRender(expr) {
+  if (expr.type !== "ConditionalExpression") return null;
+  if (!isJSXLike(expr.consequent) && !isJSXLike(expr.alternate)) return null;
+  return {
+    condition: expr.test,
+    consequent: expr.consequent,
+    alternate: expr.alternate
+  };
+}
+function matchMapRender(expr) {
+  if (expr.type !== "CallExpression") return null;
+  if (expr.callee.type !== "MemberExpression") return null;
+  const prop = expr.callee.property;
+  if (!(prop.type === "Identifier" && prop.name === "map")) return null;
+  const array = expr.callee.object;
+  const callback = expr.arguments[0];
+  if (!callback) return null;
+  if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression")
+    return null;
+  const param = callback.params[0] || t.identifier("item");
+  const indexParam = callback.params[1] && callback.params[1].type === "Identifier" ? callback.params[1] : null;
+  let keyExpression = null;
+  const returnedJSX = getReturnedJSX(callback.body);
+  if (returnedJSX && returnedJSX.type === "JSXElement") {
+    const keyAttr = returnedJSX.openingElement.attributes.find(
+      (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "key"
+    );
+    if (keyAttr && keyAttr.value) {
+      if (keyAttr.value.type === "JSXExpressionContainer") {
+        keyExpression = keyAttr.value.expression;
+      } else if (keyAttr.value.type === "StringLiteral") {
+        keyExpression = keyAttr.value;
+      }
+    }
+  }
+  return {
+    array,
+    param,
+    indexParam,
+    body: callback.body,
+    keyExpression
+  };
+}
+function createShowElement(condition, children) {
+  const whenAttr = t.jsxAttribute(
+    t.jsxIdentifier("when"),
+    t.jsxExpressionContainer(condition)
+  );
+  const childNodes = [];
+  if (t.isJSXElement(children) || t.isJSXFragment(children)) {
+    childNodes.push(children);
+  } else {
+    childNodes.push(t.jsxExpressionContainer(children));
+  }
+  return t.jsxElement(
+    t.jsxOpeningElement(t.jsxIdentifier("Show"), [whenAttr]),
+    t.jsxClosingElement(t.jsxIdentifier("Show")),
+    childNodes,
+    false
+  );
+}
+function createEachElement(items, paramName, body, keyExpression, indexParam) {
+  const attrs = [
+    t.jsxAttribute(
+      t.jsxIdentifier("items"),
+      t.jsxExpressionContainer(items)
+    ),
+    t.jsxAttribute(t.jsxIdentifier("as"), t.stringLiteral(paramName))
+  ];
+  if (keyExpression) {
+    attrs.push(
+      t.jsxAttribute(
+        t.jsxIdentifier("keyField"),
+        t.jsxExpressionContainer(keyExpression)
+      )
+    );
+  }
+  const params = [t.identifier(paramName)];
+  if (indexParam) params.push(indexParam);
+  const arrow = t.arrowFunctionExpression(params, body);
+  const child = t.jsxExpressionContainer(arrow);
+  removeKeyFromBody(body);
+  return t.jsxElement(
+    t.jsxOpeningElement(t.jsxIdentifier("Each"), attrs),
+    t.jsxClosingElement(t.jsxIdentifier("Each")),
+    [child],
+    false
+  );
+}
+function matchShowElement(node) {
+  const tag = node.openingElement.name;
+  if (tag.type !== "JSXIdentifier" || tag.name !== "Show") return null;
+  const whenAttr = node.openingElement.attributes.find(
+    (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "when"
+  );
+  if (!whenAttr || !whenAttr.value) return null;
+  let condition;
+  if (whenAttr.value.type === "JSXExpressionContainer") {
+    condition = whenAttr.value.expression;
+  } else if (whenAttr.value.type === "StringLiteral") {
+    condition = whenAttr.value;
+  } else {
+    return null;
+  }
+  return { condition, children: node.children };
+}
+function matchEachElement(node) {
+  const tag = node.openingElement.name;
+  if (tag.type !== "JSXIdentifier" || tag.name !== "Each") return null;
+  const itemsAttr = node.openingElement.attributes.find(
+    (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "items"
+  );
+  if (!itemsAttr?.value) return null;
+  const asAttr = node.openingElement.attributes.find(
+    (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "as"
+  );
+  const keyAttr = node.openingElement.attributes.find(
+    (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "keyField"
+  );
+  let items;
+  if (itemsAttr.value.type === "JSXExpressionContainer") {
+    items = itemsAttr.value.expression;
+  } else {
+    return null;
+  }
+  const paramName = asAttr?.value?.type === "StringLiteral" ? asAttr.value.value : "item";
+  let keyExpression = null;
+  if (keyAttr?.value?.type === "JSXExpressionContainer") {
+    keyExpression = keyAttr.value.expression;
+  }
+  return { items, paramName, keyExpression, children: node.children };
+}
+function showToConditional(condition, children) {
+  const content = unwrapChildren(children);
+  const logical = t.logicalExpression("&&", condition, content);
+  return t.jsxExpressionContainer(logical);
+}
+function eachToMap(items, paramName, keyExpression, children) {
+  let callback = null;
+  for (const child of children) {
+    if (child.type === "JSXExpressionContainer" && child.expression.type !== "JSXEmptyExpression") {
+      const expr = child.expression;
+      if (expr.type === "ArrowFunctionExpression" || expr.type === "FunctionExpression") {
+        callback = expr;
+        break;
+      }
+    }
+  }
+  if (!callback) {
+    const content = unwrapChildren(children);
+    callback = t.arrowFunctionExpression([t.identifier(paramName)], content);
+  }
+  if (keyExpression) {
+    addKeyToCallback(callback, keyExpression);
+  }
+  const mapCall = t.callExpression(
+    t.memberExpression(items, t.identifier("map")),
+    [callback]
+  );
+  return t.jsxExpressionContainer(mapCall);
+}
+function isJSXLike(node) {
+  return node.type === "JSXElement" || node.type === "JSXFragment" || node.type === "ParenthesizedExpression" && isJSXLike(node.expression);
+}
+function getReturnedJSX(body) {
+  if (body.type === "JSXElement" || body.type === "JSXFragment") return body;
+  if (body.type === "ParenthesizedExpression") {
+    return getReturnedJSX(body.expression);
+  }
+  if (body.type === "BlockStatement") {
+    for (const stmt of body.body) {
+      if (stmt.type === "ReturnStatement" && stmt.argument) {
+        if (stmt.argument.type === "JSXElement" || stmt.argument.type === "JSXFragment") {
+          return stmt.argument;
+        }
+        if (stmt.argument.type === "ParenthesizedExpression") {
+          return getReturnedJSX(stmt.argument.expression);
+        }
+      }
+    }
+  }
+  return null;
+}
+function removeKeyFromBody(body) {
+  const jsx = getReturnedJSX(body);
+  if (jsx && jsx.type === "JSXElement") {
+    jsx.openingElement.attributes = jsx.openingElement.attributes.filter(
+      (a) => !(a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "key")
+    );
+  }
+}
+function addKeyToCallback(callback, keyExpr) {
+  const jsx = getReturnedJSX(callback.body);
+  if (jsx && jsx.type === "JSXElement") {
+    const hasKey = jsx.openingElement.attributes.some(
+      (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "key"
+    );
+    if (!hasKey) {
+      jsx.openingElement.attributes.unshift(
+        t.jsxAttribute(
+          t.jsxIdentifier("key"),
+          t.jsxExpressionContainer(keyExpr)
+        )
+      );
+    }
+  }
+}
+function unwrapChildren(children) {
+  const meaningful = children.filter((c) => {
+    if (c.type === "JSXText") return c.value.trim().length > 0;
+    return true;
+  });
+  if (meaningful.length === 1) {
+    const child = meaningful[0];
+    if (child.type === "JSXElement" || child.type === "JSXFragment") return child;
+    if (child.type === "JSXExpressionContainer") {
+      return child.expression;
+    }
+  }
+  return t.jsxFragment(t.jsxOpeningFragment(), t.jsxClosingFragment(), meaningful);
+}
+
+// src/codemod/annotation.ts
+var ANNOTATION_PREFIX = "@mm-original";
+function createAnnotation(originalTag, classNames) {
+  const parts = [originalTag, ...classNames.slice(0, 10)];
+  return `${ANNOTATION_PREFIX} ${parts.join(".")}`;
+}
+function parseAnnotation(comment) {
+  const trimmed = comment.trim();
+  if (!trimmed.startsWith(ANNOTATION_PREFIX)) return null;
+  const rest = trimmed.slice(ANNOTATION_PREFIX.length).trim();
+  if (!rest) return null;
+  const parts = rest.split(".");
+  const tag = parts[0];
+  const classes = parts.slice(1);
+  return { tag, classes };
+}
+function addAnnotationComment(node, originalTag, classNames) {
+  const text = ` ${createAnnotation(originalTag, classNames)} `;
+  if (!node.leadingComments) {
+    node.leadingComments = [];
+  }
+  node.leadingComments.push({
+    type: "CommentBlock",
+    value: text
+  });
+}
+function readAnnotationComment(node) {
+  if (!node.leadingComments) return null;
+  for (let i = node.leadingComments.length - 1; i >= 0; i--) {
+    const comment = node.leadingComments[i];
+    const parsed = parseAnnotation(comment.value);
+    if (parsed) {
+      node.leadingComments.splice(i, 1);
+      return parsed;
+    }
+  }
+  return null;
+}
+
+// src/codemod/forward.ts
+function createForwardVisitor(imports, options = {}) {
+  const { annotate = true } = options;
+  return {
+    JSXElement(path) {
+      const opening = path.node.openingElement;
+      const tag = opening.name;
+      if (tag.type !== "JSXIdentifier") return;
+      const tagName = tag.name;
+      const classAttr = opening.attributes.find(
+        (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "className"
+      );
+      const staticClasses = extractStaticClasses(classAttr?.value ?? null);
+      const result = classifyElement(tagName, staticClasses);
+      if (!result) return;
+      if (annotate) {
+        addAnnotationComment(path.node, result.originalTag, staticClasses);
+      }
+      tag.name = result.atom;
+      if (path.node.closingElement) {
+        path.node.closingElement.name.name = result.atom;
+      }
+      imports.addAtom(result.atom);
+      if (classAttr && result.removeClasses.length > 0) {
+        updateClassName(classAttr, result.removeClasses, "remove");
+      }
+      for (const [key, value] of Object.entries(result.addProps)) {
+        const existing = opening.attributes.find(
+          (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === key
+        );
+        if (!existing) {
+          if (typeof value === "boolean") {
+            opening.attributes.push(
+              t2.jsxAttribute(
+                t2.jsxIdentifier(key),
+                value ? null : t2.jsxExpressionContainer(t2.booleanLiteral(false))
+              )
+            );
+          } else {
+            opening.attributes.push(
+              t2.jsxAttribute(t2.jsxIdentifier(key), t2.stringLiteral(value))
+            );
+          }
+        }
+      }
+      renameEventHandlers(opening, "forward");
+    },
+    JSXExpressionContainer(path) {
+      if (!path.parentPath.isJSXElement() && !path.parentPath.isJSXFragment()) return;
+      const expr = path.node.expression;
+      if (expr.type === "JSXEmptyExpression") return;
+      const conditional = matchConditionalRender(expr);
+      if (conditional) {
+        const showEl = createShowElement(conditional.condition, conditional.consequent);
+        imports.addAtom("Show");
+        path.replaceWith(showEl);
+        return;
+      }
+      const ternary = matchTernaryRender(expr);
+      if (ternary) {
+        const show1 = createShowElement(ternary.condition, ternary.consequent);
+        const negated = t2.unaryExpression("!", ternary.condition);
+        const show2 = createShowElement(negated, ternary.alternate);
+        imports.addAtom("Show");
+        path.replaceWithMultiple([show1, show2]);
+        return;
+      }
+      const mapRender = matchMapRender(expr);
+      if (mapRender) {
+        const paramName = mapRender.param.type === "Identifier" ? mapRender.param.name : "item";
+        const eachEl = createEachElement(
+          mapRender.array,
+          paramName,
+          mapRender.body,
+          mapRender.keyExpression,
+          mapRender.indexParam
+        );
+        imports.addAtom("Each");
+        path.replaceWith(eachEl);
+        return;
+      }
+    }
+  };
+}
+function updateClassName(attr, classes, operation) {
+  if (!attr.value) return;
+  if (attr.value.type === "StringLiteral") {
+    const result = operation === "remove" ? removeClassesFromString(attr.value.value, classes) : attr.value.value;
+    if (result.trim()) {
+      attr.value = t2.stringLiteral(result);
+    } else {
+      attr.value = t2.stringLiteral("");
+    }
+    return;
+  }
+  if (attr.value.type === "JSXExpressionContainer") {
+    const expr = attr.value.expression;
+    if (expr.type === "TemplateLiteral") {
+      for (const quasi of expr.quasis) {
+        if (operation === "remove") {
+          quasi.value.raw = removeClassesFromString(quasi.value.raw, classes);
+          quasi.value.cooked = removeClassesFromString(quasi.value.cooked ?? quasi.value.raw, classes);
+        }
+      }
+      return;
+    }
+    if (expr.type === "CallExpression" && expr.callee.type === "Identifier" && expr.callee.name === "cn" && expr.arguments.length > 0) {
+      const firstArg = expr.arguments[0];
+      if (firstArg.type === "StringLiteral" && operation === "remove") {
+        firstArg.value = removeClassesFromString(firstArg.value, classes);
+      }
+      return;
+    }
+  }
+}
+function renameEventHandlers(opening, direction) {
+  const map = direction === "forward" ? { onClick: "onPress", onChange: "onChange", onSubmit: "onSubmit" } : { onPress: "onClick" };
+  for (const attr of opening.attributes) {
+    if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name in map) {
+      attr.name.name = map[attr.name.name];
+    }
+  }
+}
+
+// src/codemod/reverse.ts
+var t3 = __toESM(require("@babel/types"));
+function createReverseVisitor(imports, _options = {}) {
+  return {
+    JSXElement: {
+      // Use exit so children are processed first (bottom-up)
+      exit(path) {
+        const opening = path.node.openingElement;
+        const tag = opening.name;
+        if (tag.type !== "JSXIdentifier") return;
+        const atomName = tag.name;
+        const showMatch = matchShowElement(path.node);
+        if (showMatch) {
+          const replacement = showToConditional(showMatch.condition, showMatch.children);
+          imports.removeAtom("Show");
+          path.replaceWith(replacement);
+          return;
+        }
+        const eachMatch = matchEachElement(path.node);
+        if (eachMatch) {
+          const replacement = eachToMap(
+            eachMatch.items,
+            eachMatch.paramName,
+            eachMatch.keyExpression,
+            eachMatch.children
+          );
+          imports.removeAtom("Each");
+          path.replaceWith(replacement);
+          return;
+        }
+        const annotation = readAnnotationComment(path.node);
+        const propsMap = /* @__PURE__ */ new Map();
+        for (const attr of opening.attributes) {
+          if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier") {
+            propsMap.set(attr.name.name, attr.value ?? t3.booleanLiteral(true));
+          }
+        }
+        const result = reverseClassifyAtom(atomName, propsMap);
+        if (!result) return;
+        const targetTag = annotation?.tag ?? result.htmlTag;
+        tag.name = targetTag;
+        if (path.node.closingElement) {
+          path.node.closingElement.name.name = targetTag;
+        }
+        imports.removeAtom(atomName);
+        if (result.removeProps.length > 0) {
+          opening.attributes = opening.attributes.filter(
+            (attr) => !(attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && result.removeProps.includes(attr.name.name))
+          );
+        }
+        if (result.injectClasses.length > 0) {
+          injectClasses(opening, result.injectClasses, annotation?.classes);
+        }
+        renameEventHandlers2(opening);
+      }
+    }
+  };
+}
+function injectClasses(opening, injectClasses2, _annotationClasses) {
+  const classAttr = opening.attributes.find(
+    (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "className"
+  );
+  if (classAttr && classAttr.value) {
+    if (classAttr.value.type === "StringLiteral") {
+      classAttr.value = t3.stringLiteral(
+        addClassesToString(classAttr.value.value, injectClasses2)
+      );
+      return;
+    }
+    if (classAttr.value.type === "JSXExpressionContainer") {
+      const expr = classAttr.value.expression;
+      if (expr.type === "TemplateLiteral" && expr.quasis.length > 0) {
+        const first = expr.quasis[0];
+        first.value.raw = addClassesToString(first.value.raw, injectClasses2);
+        first.value.cooked = addClassesToString(first.value.cooked ?? first.value.raw, injectClasses2);
+        return;
+      }
+      if (expr.type === "CallExpression" && expr.callee.type === "Identifier" && expr.callee.name === "cn" && expr.arguments.length > 0 && expr.arguments[0].type === "StringLiteral") {
+        expr.arguments[0] = t3.stringLiteral(
+          addClassesToString(expr.arguments[0].value, injectClasses2)
+        );
+        return;
+      }
+    }
+  } else {
+    const classValue = injectClasses2.join(" ");
+    if (classValue) {
+      opening.attributes.push(
+        t3.jsxAttribute(
+          t3.jsxIdentifier("className"),
+          t3.stringLiteral(classValue)
+        )
+      );
+    }
+  }
+}
+function renameEventHandlers2(opening) {
+  const map = { onPress: "onClick" };
+  for (const attr of opening.attributes) {
+    if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name in map) {
+      attr.name.name = map[attr.name.name];
+    }
+  }
+}
+
+// src/codemod/state-transform.ts
+var t4 = __toESM(require("@babel/types"));
+function createStateVisitor(mode) {
+  if (mode === "preserve") return {};
+  if (mode === "annotate") {
+    return {
+      VariableDeclaration(path) {
+        for (const decl of path.node.declarations) {
+          if (!isUseStateCall(decl.init)) continue;
+          if (hasFieldAnnotation(path.node)) continue;
+          const fieldType = inferFieldType(decl.init);
+          const comment = ` @mm-field type=${fieldType} `;
+          if (!path.node.trailingComments) {
+            path.node.trailingComments = [];
+          }
+          path.node.trailingComments.push({
+            type: "CommentLine",
+            value: comment
+          });
+        }
+      }
+    };
+  }
+  return {
+    VariableDeclaration(path) {
+      for (const decl of path.node.declarations) {
+        if (!isUseStateCall(decl.init)) continue;
+        const migrateAnnotation = getMigrateAnnotation(path.node);
+        if (!migrateAnnotation) continue;
+        if (migrateAnnotation.type === "query") {
+          if (decl.id.type !== "ArrayPattern" || decl.id.elements.length < 1)
+            continue;
+          const nameNode = decl.id.elements[0];
+          if (!nameNode || nameNode.type !== "Identifier") continue;
+          decl.id = nameNode;
+          decl.init = t4.callExpression(t4.identifier("useQuery"), [
+            t4.stringLiteral(migrateAnnotation.model || nameNode.name),
+            t4.objectExpression([
+              t4.objectProperty(
+                t4.identifier("where"),
+                t4.objectExpression([])
+              )
+            ])
+          ]);
+        }
+      }
+    }
+  };
+}
+function isUseStateCall(node) {
+  return !!node && node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "useState";
+}
+function hasFieldAnnotation(node) {
+  return !!node.trailingComments && node.trailingComments.some((c) => c.value.includes("@mm-field"));
+}
+function inferFieldType(call) {
+  if (call.arguments.length === 0) return "any";
+  const arg = call.arguments[0];
+  if (arg.type === "StringLiteral") return "text";
+  if (arg.type === "NumericLiteral") return "number";
+  if (arg.type === "BooleanLiteral") return "boolean";
+  if (arg.type === "ArrayExpression") return "list";
+  if (arg.type === "ObjectExpression") return "object";
+  if (arg.type === "NullLiteral") return "any";
+  return "any";
+}
+function getMigrateAnnotation(node) {
+  const comments = [
+    ...node.leadingComments || [],
+    ...node.trailingComments || []
+  ];
+  for (const c of comments) {
+    const match = c.value.match(/@mm-migrate:\s*(query|mutation)(?:\s+(\w+))?/);
+    if (match) {
+      return {
+        type: match[1],
+        model: match[2]
+      };
+    }
+  }
+  return null;
+}
+
+// src/codemod/import-manager.ts
+var t5 = __toESM(require("@babel/types"));
+function createImportTracker() {
+  const used = /* @__PURE__ */ new Set();
+  const removed = /* @__PURE__ */ new Set();
+  return {
+    addAtom(name) {
+      used.add(name);
+      removed.delete(name);
+    },
+    removeAtom(name) {
+      removed.add(name);
+    },
+    getUsedAtoms() {
+      return used;
+    },
+    getRemovedAtoms() {
+      return removed;
+    }
+  };
+}
+function rewriteImportsForward(programPath, tracker) {
+  const usedAtoms = tracker.getUsedAtoms();
+  if (usedAtoms.size === 0) return;
+  let existingImport = null;
+  programPath.traverse({
+    ImportDeclaration(path) {
+      if (path.node.source.value === ATOM_IMPORT_SOURCE) {
+        existingImport = path;
+      }
+    }
+  });
+  if (existingImport) {
+    const existing = new Set(
+      existingImport.node.specifiers.filter((s) => s.type === "ImportSpecifier").map((s) => s.imported.name)
+    );
+    for (const atom of usedAtoms) {
+      if (!existing.has(atom)) {
+        existingImport.node.specifiers.push(
+          t5.importSpecifier(t5.identifier(atom), t5.identifier(atom))
+        );
+      }
+    }
+  } else {
+    const specifiers = Array.from(usedAtoms).sort().map((name) => t5.importSpecifier(t5.identifier(name), t5.identifier(name)));
+    const importDecl = t5.importDeclaration(
+      specifiers,
+      t5.stringLiteral(ATOM_IMPORT_SOURCE)
+    );
+    const lastImport = programPath.get("body").filter((p) => p.isImportDeclaration()).pop();
+    if (lastImport) {
+      lastImport.insertAfter(importDecl);
+    } else {
+      programPath.get("body")[0].insertBefore(importDecl);
+    }
+  }
+}
+function rewriteImportsReverse(programPath, tracker) {
+  const removed = tracker.getRemovedAtoms();
+  if (removed.size === 0) return;
+  programPath.traverse({
+    ImportDeclaration(path) {
+      if (path.node.source.value !== ATOM_IMPORT_SOURCE) return;
+      path.node.specifiers = path.node.specifiers.filter((spec) => {
+        if (spec.type !== "ImportSpecifier") return true;
+        const name = spec.imported.name;
+        return !removed.has(name);
+      });
+      if (path.node.specifiers.length === 0) {
+        path.remove();
+      }
+    }
+  });
+  let hasReactImport = false;
+  programPath.traverse({
+    ImportDeclaration(path) {
+      if (path.node.source.value === "react") {
+        hasReactImport = true;
+      }
+    }
+  });
+  if (!hasReactImport) {
+    const reactImport = t5.importDeclaration(
+      [t5.importDefaultSpecifier(t5.identifier("React"))],
+      t5.stringLiteral("react")
+    );
+    programPath.get("body")[0].insertBefore(reactImport);
+  }
+}
+
+// src/codemod/index.ts
+var codemodPlugin = (0, import_helper_plugin_utils.declare)(
+  (api, options) => {
+    api.assertVersion(7);
+    const direction = options.direction || "forward";
+    const stateMode = options.stateMode || "preserve";
+    return {
+      name: "mm-codemod",
+      visitor: {
+        Program: {
+          enter(programPath) {
+            const imports = createImportTracker();
+            const stateVisitor = createStateVisitor(stateMode);
+            if (direction === "forward") {
+              const forwardVisitor = createForwardVisitor(imports, {
+                annotate: options.annotate ?? true,
+                stateMode
+              });
+              programPath.traverse(stateVisitor);
+              programPath.traverse(forwardVisitor);
+              rewriteImportsForward(programPath, imports);
+            } else {
+              const reverseVisitor = createReverseVisitor(imports, {
+                stripAnnotations: !options.annotate
+              });
+              programPath.traverse(reverseVisitor);
+              rewriteImportsReverse(programPath, imports);
+            }
+          }
+        }
+      }
+    };
+  }
+);
+function transform(source, options) {
+  const babelOptions = {
+    filename: "file.tsx",
+    plugins: [
+      ["@babel/plugin-syntax-typescript", { isTSX: true }],
+      [codemodPlugin, options]
+    ],
+    // Preserve formatting as much as possible
+    retainLines: true,
+    compact: false,
+    sourceMaps: true
+  };
+  const result = (0, import_core.transformSync)(source, babelOptions);
+  if (!result || !result.code) {
+    throw new Error("Codemod transform produced no output");
+  }
+  return { code: result.code, map: result.map };
+}
+
+// src/codemod/cli.ts
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const direction = args[0];
+  if (!direction || !["forward", "reverse", "verify"].includes(direction)) {
+    console.error("Usage: mm-codemod <forward|reverse|verify> <paths...> [options]");
+    console.error("");
+    console.error("Options:");
+    console.error("  --dry-run           Print diff without writing");
+    console.error("  --strip-annotations Remove @mm-original comments");
+    console.error("  --mode <mode>       State mode: preserve|migrate|annotate");
+    console.error("  --out <dir>         Output directory (default: in-place)");
+    console.error("  --verbose           Log every transformation");
+    process.exit(1);
+  }
+  const paths = [];
+  let dryRun = false;
+  let stripAnnotations = false;
+  let stateMode = "preserve";
+  let verbose = false;
+  let outDir;
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--strip-annotations") {
+      stripAnnotations = true;
+    } else if (arg === "--mode") {
+      stateMode = args[++i];
+    } else if (arg === "--out") {
+      outDir = args[++i];
+    } else if (arg === "--verbose") {
+      verbose = true;
+    } else if (!arg.startsWith("-")) {
+      paths.push(arg);
+    }
+  }
+  if (paths.length === 0) {
+    console.error("Error: No paths specified");
+    process.exit(1);
+  }
+  return { direction, paths, dryRun, stripAnnotations, stateMode, verbose, outDir };
+}
+async function findFiles(paths) {
+  const files = [];
+  for (const p of paths) {
+    const resolved = (0, import_path.resolve)(p);
+    const matches = await (0, import_glob.glob)("**/*.{tsx,jsx}", {
+      cwd: resolved,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/__tests__/**", "**/dist/**"]
+    });
+    files.push(...matches);
+  }
+  return files.sort();
+}
+function transformFile(filePath, options, verbose) {
+  const source = (0, import_fs.readFileSync)(filePath, "utf-8");
+  try {
+    const result = transform(source, options);
+    const changed = result.code !== source;
+    if (verbose && changed) {
+      console.log(`  [${options.direction}] ${(0, import_path.relative)(process.cwd(), filePath)}`);
+    }
+    return { code: result.code, changed };
+  } catch (err) {
+    console.error(`  [ERROR] ${(0, import_path.relative)(process.cwd(), filePath)}: ${err.message}`);
+    return { code: source, changed: false };
+  }
+}
+async function main() {
+  const opts = parseArgs(process.argv);
+  const files = await findFiles(opts.paths);
+  console.log(`mm-codemod: ${opts.direction} \u2014 ${files.length} file(s)`);
+  if (opts.direction === "verify") {
+    let pass = 0;
+    let fail = 0;
+    for (const file of files) {
+      const source = (0, import_fs.readFileSync)(file, "utf-8");
+      const forward = transform(source, {
+        direction: "forward",
+        annotate: true,
+        stateMode: opts.stateMode
+      });
+      const roundTripped = transform(forward.code, {
+        direction: "reverse",
+        annotate: false,
+        stateMode: opts.stateMode
+      });
+      const normalize = (s) => s.replace(/\s+/g, " ").trim();
+      if (normalize(roundTripped.code) === normalize(source)) {
+        pass++;
+        if (opts.verbose) console.log(`  [PASS] ${(0, import_path.relative)(process.cwd(), file)}`);
+      } else {
+        fail++;
+        console.log(`  [FAIL] ${(0, import_path.relative)(process.cwd(), file)}`);
+        if (opts.verbose) {
+          console.log("    Expected (normalized):");
+          console.log(`      ${normalize(source).slice(0, 200)}...`);
+          console.log("    Got (normalized):");
+          console.log(`      ${normalize(roundTripped.code).slice(0, 200)}...`);
+        }
+      }
+    }
+    console.log(`
+Results: ${pass} pass, ${fail} fail out of ${files.length} files`);
+    process.exit(fail > 0 ? 1 : 0);
+  }
+  const codemodOptions = {
+    direction: opts.direction,
+    annotate: !opts.stripAnnotations,
+    stateMode: opts.stateMode
+  };
+  let changed = 0;
+  let unchanged = 0;
+  let errors = 0;
+  for (const file of files) {
+    try {
+      const result = transformFile(file, codemodOptions, opts.verbose);
+      if (!result.changed) {
+        unchanged++;
+        continue;
+      }
+      changed++;
+      if (opts.dryRun) {
+        console.log(`  [WOULD CHANGE] ${(0, import_path.relative)(process.cwd(), file)}`);
+        continue;
+      }
+      let outPath = file;
+      if (opts.outDir) {
+        const rel = (0, import_path.relative)((0, import_path.resolve)(opts.paths[0]), file);
+        outPath = (0, import_path.resolve)(opts.outDir, rel);
+        const dir = (0, import_path.dirname)(outPath);
+        if (!(0, import_fs.existsSync)(dir)) (0, import_fs.mkdirSync)(dir, { recursive: true });
+      }
+      (0, import_fs.writeFileSync)(outPath, result.code, "utf-8");
+    } catch (err) {
+      errors++;
+      console.error(`  [ERROR] ${(0, import_path.relative)(process.cwd(), file)}: ${err.message}`);
+    }
+  }
+  console.log(`
+Done: ${changed} changed, ${unchanged} unchanged, ${errors} errors`);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});