acture-codemods 1.1.0

package/dist/index.cjs

@@ -0,0 +1,746 @@
+'use strict';
+
+var tsMorph = require('ts-morph');
+
+// src/codemods/wrap-handler-with-mutation.ts
+var DEFAULT_EVENTS = /* @__PURE__ */ new Set(["onClick", "onChange", "onSubmit"]);
+function resolveOptions(opts) {
+  const raw = opts?.["events"];
+  const events = raw ? new Set(raw.split(",").map((s) => s.trim()).filter(Boolean)) : DEFAULT_EVENTS;
+  return {
+    events,
+    importFrom: opts?.["import-from"] ?? "acture-migration",
+    importName: opts?.["import-name"] ?? "wrapMutation"
+  };
+}
+var wrapHandlerWithMutation = {
+  name: "wrap-handler-with-mutation",
+  description: "Wrap onClick/onChange/onSubmit handler expressions with wrapMutation(). Adds the import if missing.",
+  async run(options) {
+    const resolved = resolveOptions(options.options);
+    const project = new tsMorph.Project({
+      useInMemoryFileSystem: false,
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: {
+        allowJs: false,
+        jsx: 4
+        /* ReactJSX */
+      }
+    });
+    const fileChanges = [];
+    let totalChanged = 0;
+    let totalSkipped = 0;
+    for (const path of options.files) {
+      const sourceFile = project.addSourceFileAtPath(path);
+      const before = sourceFile.getFullText();
+      const notes = [];
+      let attrCount = 0;
+      sourceFile.getDescendantsOfKind(tsMorph.SyntaxKind.JsxAttribute).forEach((attr) => {
+        const nameNode = attr.getNameNode();
+        const name = nameNode.getText();
+        if (!resolved.events.has(name)) return;
+        const initializer = attr.getInitializer();
+        if (!initializer || initializer.getKind() !== tsMorph.SyntaxKind.JsxExpression) {
+          notes.push(`${path}: skipped ${name} \u2014 not a {...} expression`);
+          return;
+        }
+        const expr = initializer.asKindOrThrow(tsMorph.SyntaxKind.JsxExpression).getExpression();
+        if (!expr) {
+          notes.push(`${path}: skipped ${name} \u2014 empty expression`);
+          return;
+        }
+        if (isAlreadyWrapped(expr, resolved.importName)) return;
+        const inner = expr.getText();
+        initializer.replaceWithText(`{${resolved.importName}(${inner})}`);
+        attrCount++;
+      });
+      if (attrCount > 0) {
+        ensureImport(sourceFile, resolved.importName, resolved.importFrom);
+      }
+      const after = sourceFile.getFullText();
+      const changed = before !== after;
+      if (changed) totalChanged++;
+      else totalSkipped++;
+      fileChanges.push({
+        path,
+        before,
+        after,
+        changed,
+        ...notes.length > 0 ? { notes } : {}
+      });
+      if (changed && !options.dryRun) {
+        await sourceFile.save();
+      }
+      project.removeSourceFile(sourceFile);
+    }
+    return {
+      codemod: "wrap-handler-with-mutation",
+      version: "1.0.0",
+      files: fileChanges,
+      summary: {
+        total: options.files.length,
+        changed: totalChanged,
+        skipped: totalSkipped
+      }
+    };
+  }
+};
+function isAlreadyWrapped(expr, importName) {
+  if (expr.getKind() !== tsMorph.SyntaxKind.CallExpression) return false;
+  const callee = expr.asKindOrThrow(tsMorph.SyntaxKind.CallExpression).getExpression();
+  return callee.getText() === importName;
+}
+function ensureImport(sourceFile, importName, importFrom) {
+  const existing = sourceFile.getImportDeclaration(
+    (d) => d.getModuleSpecifierValue() === importFrom
+  );
+  if (existing) {
+    const named = existing.getNamedImports().map((n) => n.getName());
+    if (!named.includes(importName)) {
+      existing.addNamedImport(importName);
+    }
+    return;
+  }
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: importFrom,
+    namedImports: [importName]
+  });
+}
+var SUPPORTED_EVENTS = /* @__PURE__ */ new Set(["onClick", "onSubmit", "onChange"]);
+function resolveOptions2(opts) {
+  return {
+    idPrefix: opts?.["id-prefix"] ?? "app.wrapped",
+    registryImport: opts?.["registry-import"] ?? "./acture/registry",
+    actureImport: opts?.["acture-import"] ?? "acture"
+  };
+}
+var extractOnClickToCommand = {
+  name: "extract-onclick-to-command",
+  description: "Lift inline onClick / onSubmit / onChange arrow handlers into module-level defineCommand calls.",
+  async run(options) {
+    const resolved = resolveOptions2(options.options);
+    const project = new tsMorph.Project({
+      useInMemoryFileSystem: false,
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: {
+        allowJs: false,
+        jsx: 4
+        /* ReactJSX */
+      }
+    });
+    const fileChanges = [];
+    let totalChanged = 0;
+    let totalSkipped = 0;
+    for (const path of options.files) {
+      const sourceFile = project.addSourceFileAtPath(path);
+      const before = sourceFile.getFullText();
+      const notes = [];
+      const liftedCommands = [];
+      sourceFile.getDescendantsOfKind(tsMorph.SyntaxKind.JsxAttribute).forEach((attr) => {
+        const lifted = liftAttribute(attr, resolved, sourceFile, liftedCommands.length, notes);
+        if (lifted) liftedCommands.push(lifted);
+      });
+      if (liftedCommands.length > 0) {
+        ensureImports(sourceFile, resolved);
+        insertCommandDecls(sourceFile, liftedCommands);
+      }
+      const after = sourceFile.getFullText();
+      const changed = before !== after;
+      if (changed) totalChanged++;
+      else totalSkipped++;
+      fileChanges.push({
+        path,
+        before,
+        after,
+        changed,
+        ...notes.length > 0 ? { notes } : {}
+      });
+      if (changed && !options.dryRun) {
+        await sourceFile.save();
+      }
+      project.removeSourceFile(sourceFile);
+    }
+    return {
+      codemod: "extract-onclick-to-command",
+      version: "1.0.0",
+      files: fileChanges,
+      summary: {
+        total: options.files.length,
+        changed: totalChanged,
+        skipped: totalSkipped
+      }
+    };
+  }
+};
+function liftAttribute(attr, options, sourceFile, liftedIndex, notes) {
+  const name = attr.getNameNode().getText();
+  if (!SUPPORTED_EVENTS.has(name)) return null;
+  const initializer = attr.getInitializer();
+  if (!initializer || initializer.getKind() !== tsMorph.SyntaxKind.JsxExpression) return null;
+  const expr = initializer.asKindOrThrow(tsMorph.SyntaxKind.JsxExpression).getExpression();
+  if (!expr || expr.getKind() !== tsMorph.SyntaxKind.ArrowFunction) return null;
+  const arrow = expr.asKindOrThrow(tsMorph.SyntaxKind.ArrowFunction);
+  if (arrow.getParameters().length > 0) {
+    notes.push(`${sourceFile.getFilePath()}: skipped ${name} \u2014 handler takes parameters`);
+    return null;
+  }
+  const verb = deriveVerb(arrow, name);
+  const varName = liftedIndex === 0 ? `__cmd_${verb}` : `__cmd_${verb}_${liftedIndex}`;
+  const commandId = `${options.idPrefix}.${verb}`;
+  const title = prettify(verb);
+  const body = arrowBodyToExecuteBody(arrow);
+  const spec = `const ${varName} = defineCommand({
+  id: ${JSON.stringify(commandId)},
+  title: ${JSON.stringify(title)},
+  execute: () => {
+${body}
+    return ok(undefined);
+  },
+});`;
+  initializer.replaceWithText(`{() => registry.dispatch(${varName}.id)}`);
+  return { varName, spec };
+}
+function deriveVerb(arrow, attrName) {
+  const text = arrow.getBody().getText().trim();
+  const idMatch = /^([a-zA-Z_$][\w$]*)/.exec(text);
+  const base = idMatch?.[1] ?? attrName.replace(/^on/, "").toLowerCase();
+  return camelize(base);
+}
+function camelize(s) {
+  return s.replace(/^./, (c) => c.toLowerCase()).replace(/[^a-zA-Z0-9]/g, "");
+}
+function prettify(verb) {
+  return verb.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (c) => c.toUpperCase());
+}
+function arrowBodyToExecuteBody(arrow) {
+  const body = arrow.getBody();
+  if (body.getKind() === tsMorph.SyntaxKind.Block) {
+    const text = body.getText();
+    const inner = text.slice(1, -1).trim();
+    return inner.split("\n").map((line) => `    ${line}`).join("\n");
+  }
+  return `    ${body.getText()};`;
+}
+function ensureImports(sourceFile, options) {
+  addNamedImport(sourceFile, options.actureImport, "defineCommand");
+  addNamedImport(sourceFile, options.actureImport, "ok");
+  addNamedImport(sourceFile, options.registryImport, "registry");
+}
+function addNamedImport(sourceFile, from, name) {
+  const existing = sourceFile.getImportDeclaration(
+    (d) => d.getModuleSpecifierValue() === from
+  );
+  if (existing) {
+    if (!existing.getNamedImports().some((n) => n.getName() === name)) {
+      existing.addNamedImport(name);
+    }
+    return;
+  }
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: from,
+    namedImports: [name]
+  });
+}
+function insertCommandDecls(sourceFile, commands) {
+  const imports = sourceFile.getImportDeclarations();
+  const insertAfter = imports.length > 0 ? imports[imports.length - 1].getEnd() : 0;
+  const text = "\n\n" + commands.map((c) => c.spec).join("\n\n") + "\n";
+  sourceFile.insertText(insertAfter, text);
+}
+function resolveOptions3(opts) {
+  const raw = opts?.["callees"];
+  const callees = raw ? new Set(raw.split(",").map((s) => s.trim()).filter(Boolean)) : /* @__PURE__ */ new Set(["dispatch"]);
+  const idRewrite = opts?.["id-rewrite"] === "dot" ? "dot" : "keep";
+  return {
+    callees,
+    registryImport: opts?.["registry-import"] ?? "./acture/registry",
+    idRewrite
+  };
+}
+var reduxActionToCommand = {
+  name: "redux-action-to-command",
+  description: "Convert dispatch({type, payload}) call sites to registry.dispatch(id, payload). Adds the registry import.",
+  async run(options) {
+    const resolved = resolveOptions3(options.options);
+    const project = new tsMorph.Project({
+      useInMemoryFileSystem: false,
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: {
+        allowJs: false,
+        jsx: 4
+        /* ReactJSX */
+      }
+    });
+    const fileChanges = [];
+    let totalChanged = 0;
+    let totalSkipped = 0;
+    for (const path of options.files) {
+      const sourceFile = project.addSourceFileAtPath(path);
+      const before = sourceFile.getFullText();
+      const notes = [];
+      let rewriteCount = 0;
+      sourceFile.getDescendantsOfKind(tsMorph.SyntaxKind.CallExpression).forEach((call) => {
+        if (rewriteOne(call, resolved, notes, path)) rewriteCount++;
+      });
+      if (rewriteCount > 0) {
+        ensureRegistryImport(sourceFile, resolved.registryImport);
+      }
+      const after = sourceFile.getFullText();
+      const changed = before !== after;
+      if (changed) totalChanged++;
+      else totalSkipped++;
+      fileChanges.push({
+        path,
+        before,
+        after,
+        changed,
+        ...notes.length > 0 ? { notes } : {}
+      });
+      if (changed && !options.dryRun) {
+        await sourceFile.save();
+      }
+      project.removeSourceFile(sourceFile);
+    }
+    return {
+      codemod: "redux-action-to-command",
+      version: "1.0.0",
+      files: fileChanges,
+      summary: {
+        total: options.files.length,
+        changed: totalChanged,
+        skipped: totalSkipped
+      }
+    };
+  }
+};
+function rewriteOne(call, options, notes, path) {
+  const callee = call.getExpression();
+  if (callee.getKind() !== tsMorph.SyntaxKind.Identifier) return false;
+  const calleeName = callee.getText();
+  if (!options.callees.has(calleeName)) return false;
+  const args = call.getArguments();
+  if (args.length !== 1) return false;
+  const arg = args[0];
+  if (arg.getKind() !== tsMorph.SyntaxKind.ObjectLiteralExpression) return false;
+  const obj = arg.asKindOrThrow(tsMorph.SyntaxKind.ObjectLiteralExpression);
+  const props = obj.getProperties();
+  let typeLiteral = null;
+  let payloadText = null;
+  let foreignKey = false;
+  for (const p of props) {
+    if (p.getKind() !== tsMorph.SyntaxKind.PropertyAssignment) {
+      foreignKey = true;
+      continue;
+    }
+    const pa = p.asKindOrThrow(tsMorph.SyntaxKind.PropertyAssignment);
+    const name = pa.getName();
+    if (name === "type") {
+      const init = pa.getInitializerOrThrow();
+      if (init.getKind() === tsMorph.SyntaxKind.StringLiteral) {
+        typeLiteral = init.asKindOrThrow(tsMorph.SyntaxKind.StringLiteral).getLiteralText();
+      } else {
+        notes.push(`${path}: skipped ${calleeName}({...}) \u2014 non-literal type`);
+        return false;
+      }
+    } else if (name === "payload") {
+      payloadText = pa.getInitializerOrThrow().getText();
+    } else {
+      foreignKey = true;
+    }
+  }
+  if (!typeLiteral) return false;
+  if (foreignKey) {
+    notes.push(`${path}: skipped ${calleeName}({ type: '${typeLiteral}', ...}) \u2014 has extra keys`);
+    return false;
+  }
+  const rewrittenId = options.idRewrite === "dot" ? rewriteIdDot(typeLiteral) : typeLiteral;
+  const replacement = payloadText ? `registry.dispatch(${JSON.stringify(rewrittenId)}, ${payloadText})` : `registry.dispatch(${JSON.stringify(rewrittenId)})`;
+  call.replaceWithText(replacement);
+  return true;
+}
+function rewriteIdDot(slashId) {
+  if (!slashId.includes("/")) return slashId;
+  return "app." + slashId.replace(/\//g, ".");
+}
+function ensureRegistryImport(sourceFile, from) {
+  const existing = sourceFile.getImportDeclaration(
+    (d) => d.getModuleSpecifierValue() === from
+  );
+  if (existing) {
+    if (!existing.getNamedImports().some((n) => n.getName() === "registry")) {
+      existing.addNamedImport("registry");
+    }
+    return;
+  }
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: from,
+    namedImports: ["registry"]
+  });
+}
+var DEFAULT_EVENTS2 = ["onClick", "onChange", "onSubmit"];
+function resolveOptions4(opts) {
+  const rawEvents = opts?.["events"];
+  const events = rawEvents ? new Set(rawEvents.split(",").map((s) => s.trim()).filter(Boolean)) : new Set(DEFAULT_EVENTS2);
+  const setterPattern = opts?.["setter-pattern"] ? new RegExp(opts["setter-pattern"]) : /^set[A-Z]/;
+  return {
+    idPrefix: opts?.["id-prefix"] ?? "app.state",
+    setterPattern,
+    events,
+    importFrom: opts?.["import-from"] ?? "acture-migration"
+  };
+}
+var useStateMutationToCommand = {
+  name: "usestate-mutation-to-command",
+  description: "Wrap inline handlers whose body is composed of useState setter calls with wrapMutation. Derives a command id from the setter name.",
+  async run(options) {
+    const resolved = resolveOptions4(options.options);
+    const project = new tsMorph.Project({
+      useInMemoryFileSystem: false,
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: {
+        allowJs: false,
+        jsx: 4
+        /* ReactJSX */
+      }
+    });
+    const fileChanges = [];
+    let totalChanged = 0;
+    let totalSkipped = 0;
+    for (const path of options.files) {
+      const sourceFile = project.addSourceFileAtPath(path);
+      const before = sourceFile.getFullText();
+      const notes = [];
+      let wrapCount = 0;
+      sourceFile.getDescendantsOfKind(tsMorph.SyntaxKind.JsxAttribute).forEach((attr) => {
+        if (rewriteOne2(attr, resolved, notes, path)) wrapCount++;
+      });
+      if (wrapCount > 0) {
+        ensureImport2(sourceFile, "wrapMutation", resolved.importFrom);
+      }
+      const after = sourceFile.getFullText();
+      const changed = before !== after;
+      if (changed) totalChanged++;
+      else totalSkipped++;
+      fileChanges.push({
+        path,
+        before,
+        after,
+        changed,
+        ...notes.length > 0 ? { notes } : {}
+      });
+      if (changed && !options.dryRun) {
+        await sourceFile.save();
+      }
+      project.removeSourceFile(sourceFile);
+    }
+    return {
+      codemod: "usestate-mutation-to-command",
+      version: "1.0.0",
+      files: fileChanges,
+      summary: {
+        total: options.files.length,
+        changed: totalChanged,
+        skipped: totalSkipped
+      }
+    };
+  }
+};
+function rewriteOne2(attr, options, notes, path) {
+  const name = attr.getNameNode().getText();
+  if (!options.events.has(name)) return false;
+  const initializer = attr.getInitializer();
+  if (!initializer || initializer.getKind() !== tsMorph.SyntaxKind.JsxExpression) return false;
+  const expr = initializer.asKindOrThrow(tsMorph.SyntaxKind.JsxExpression).getExpression();
+  if (!expr || expr.getKind() !== tsMorph.SyntaxKind.ArrowFunction) return false;
+  const arrow = expr.asKindOrThrow(tsMorph.SyntaxKind.ArrowFunction);
+  if (isInsideWrapMutation(arrow)) return false;
+  const setterName = findFirstSetter(arrow, options.setterPattern);
+  if (!setterName) return false;
+  const body = arrow.getBody();
+  if (!isSetterOnlyBody(body, options.setterPattern)) {
+    notes.push(`${path}: skipped ${name} \u2014 body has non-setter statements`);
+    return false;
+  }
+  const id = `${options.idPrefix}.${setterName}`;
+  const inner = arrow.getText();
+  initializer.replaceWithText(`{wrapMutation(${inner}, { id: ${JSON.stringify(id)} })}`);
+  return true;
+}
+function isInsideWrapMutation(arrow) {
+  const parent = arrow.getParent();
+  if (!parent) return false;
+  if (parent.getKind() !== tsMorph.SyntaxKind.CallExpression) return false;
+  const callee = parent.asKindOrThrow(tsMorph.SyntaxKind.CallExpression).getExpression();
+  return callee.getText() === "wrapMutation";
+}
+function findFirstSetter(arrow, pattern) {
+  const body = arrow.getBody();
+  const calls = body.getDescendantsOfKind(tsMorph.SyntaxKind.CallExpression);
+  if (body.getKind() === tsMorph.SyntaxKind.CallExpression) {
+    const call = body.asKindOrThrow(tsMorph.SyntaxKind.CallExpression);
+    const callee = call.getExpression();
+    if (callee.getKind() === tsMorph.SyntaxKind.Identifier && pattern.test(callee.getText())) {
+      return callee.getText();
+    }
+  }
+  for (const call of calls) {
+    const callee = call.getExpression();
+    if (callee.getKind() === tsMorph.SyntaxKind.Identifier && pattern.test(callee.getText())) {
+      return callee.getText();
+    }
+  }
+  return null;
+}
+function isSetterOnlyBody(body, pattern) {
+  if (body.getKind() === tsMorph.SyntaxKind.Block) {
+    const block = body.asKindOrThrow(tsMorph.SyntaxKind.Block);
+    for (const stmt of block.getStatements()) {
+      if (stmt.getKind() !== tsMorph.SyntaxKind.ExpressionStatement) return false;
+      const inner = stmt.asKindOrThrow(tsMorph.SyntaxKind.ExpressionStatement).getExpression();
+      if (!isSetterCall(inner, pattern)) return false;
+    }
+    return true;
+  }
+  return isSetterCall(body, pattern);
+}
+function isSetterCall(node, pattern) {
+  if (node.getKind() !== tsMorph.SyntaxKind.CallExpression) return false;
+  const callee = node.asKindOrThrow(tsMorph.SyntaxKind.CallExpression).getExpression();
+  if (callee.getKind() !== tsMorph.SyntaxKind.Identifier) return false;
+  return pattern.test(callee.getText());
+}
+function ensureImport2(sourceFile, importName, importFrom) {
+  const existing = sourceFile.getImportDeclaration(
+    (d) => d.getModuleSpecifierValue() === importFrom
+  );
+  if (existing) {
+    if (!existing.getNamedImports().some((n) => n.getName() === importName)) {
+      existing.addNamedImport(importName);
+    }
+    return;
+  }
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: importFrom,
+    namedImports: [importName]
+  });
+}
+function resolveOptions5(opts) {
+  return {
+    actureImport: opts?.["acture-import"] ?? "acture",
+    titleFrom: opts?.["title-from"] === "id" ? "id" : "id-last-segment"
+  };
+}
+var rtkThunkToCommand = {
+  name: "rtk-thunk-to-command",
+  description: "Convert createAsyncThunk(id, payloadCreator) into defineCommand({id, title, execute}). Rewrites return X to return ok(X).",
+  async run(options) {
+    const resolved = resolveOptions5(options.options);
+    const project = new tsMorph.Project({
+      useInMemoryFileSystem: false,
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: {
+        allowJs: false,
+        jsx: 4
+        /* ReactJSX */
+      }
+    });
+    const fileChanges = [];
+    let totalChanged = 0;
+    let totalSkipped = 0;
+    for (const path of options.files) {
+      const sourceFile = project.addSourceFileAtPath(path);
+      const before = sourceFile.getFullText();
+      const notes = [];
+      let rewriteCount = 0;
+      const thunkCalls = sourceFile.getDescendantsOfKind(tsMorph.SyntaxKind.CallExpression).filter((call) => {
+        const callee = call.getExpression();
+        return callee.getKind() === tsMorph.SyntaxKind.Identifier && callee.getText() === "createAsyncThunk";
+      });
+      for (const call of thunkCalls) {
+        if (call.wasForgotten()) continue;
+        if (rewriteOne3(call, resolved, notes, path)) rewriteCount++;
+      }
+      if (rewriteCount > 0) {
+        ensureImport3(sourceFile, "defineCommand", resolved.actureImport);
+        ensureImport3(sourceFile, "ok", resolved.actureImport);
+      }
+      const after = sourceFile.getFullText();
+      const changed = before !== after;
+      if (changed) totalChanged++;
+      else totalSkipped++;
+      fileChanges.push({
+        path,
+        before,
+        after,
+        changed,
+        ...notes.length > 0 ? { notes } : {}
+      });
+      if (changed && !options.dryRun) {
+        await sourceFile.save();
+      }
+      project.removeSourceFile(sourceFile);
+    }
+    return {
+      codemod: "rtk-thunk-to-command",
+      version: "1.0.0",
+      files: fileChanges,
+      summary: {
+        total: options.files.length,
+        changed: totalChanged,
+        skipped: totalSkipped
+      }
+    };
+  }
+};
+function rewriteOne3(call, options, notes, path) {
+  const callee = call.getExpression();
+  if (callee.getKind() !== tsMorph.SyntaxKind.Identifier) return false;
+  if (callee.getText() !== "createAsyncThunk") return false;
+  const args = call.getArguments();
+  if (args.length !== 2) {
+    notes.push(`${path}: skipped createAsyncThunk(...) \u2014 expected exactly 2 args`);
+    return false;
+  }
+  const idArg = args[0];
+  if (idArg.getKind() !== tsMorph.SyntaxKind.StringLiteral) {
+    notes.push(`${path}: skipped createAsyncThunk(...) \u2014 non-literal id`);
+    return false;
+  }
+  const id = idArg.asKindOrThrow(tsMorph.SyntaxKind.StringLiteral).getLiteralText();
+  const fnArg = args[1];
+  const fnKind = fnArg.getKind();
+  if (fnKind !== tsMorph.SyntaxKind.ArrowFunction && fnKind !== tsMorph.SyntaxKind.FunctionExpression) {
+    notes.push(`${path}: skipped createAsyncThunk(...) \u2014 payload creator is not a function`);
+    return false;
+  }
+  const fn = fnArg;
+  rewriteReturnsToOk(fn, notes, path, id);
+  const executeText = fnToExecuteText(fn);
+  const title = options.titleFrom === "id" ? id : deriveTitle(id);
+  const replacement = `defineCommand({
+  id: ${JSON.stringify(id)},
+  title: ${JSON.stringify(title)},
+  execute: ${executeText},
+})`;
+  call.replaceWithText(replacement);
+  notes.push(
+    `${path}: createAsyncThunk('${id}') \u2192 defineCommand. Add a params: <zod schema> if you want palette/MCP/AI to see a typed parameter.`
+  );
+  return true;
+}
+function rewriteReturnsToOk(fn, notes, path, id) {
+  const body = fn.getBody();
+  if (body.getKind() !== tsMorph.SyntaxKind.Block) {
+    const text = body.getText();
+    body.replaceWithText(`ok(${text})`);
+    return;
+  }
+  let hadAnyReturn = false;
+  body.getDescendantsOfKind(tsMorph.SyntaxKind.ReturnStatement).forEach((ret) => {
+    hadAnyReturn = true;
+    const expr = ret.getExpression();
+    if (!expr) {
+      ret.replaceWithText("return ok(undefined);");
+    } else {
+      ret.replaceWithText(`return ok(${expr.getText()});`);
+    }
+  });
+  if (!hadAnyReturn) {
+    notes.push(
+      `${path}: createAsyncThunk('${id}') had no return \u2014 appended return ok(undefined);`
+    );
+    body.replaceWithText(body.getText().replace(/\}$/, "\n  return ok(undefined);\n}"));
+  }
+}
+function fnToExecuteText(fn) {
+  return fn.getText();
+}
+function deriveTitle(id) {
+  const last = id.split("/").pop()?.split(".").pop() ?? id;
+  return last.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (c) => c.toUpperCase());
+}
+function ensureImport3(sourceFile, importName, importFrom) {
+  const existing = sourceFile.getImportDeclaration(
+    (d) => d.getModuleSpecifierValue() === importFrom
+  );
+  if (existing) {
+    if (!existing.getNamedImports().some((n) => n.getName() === importName)) {
+      existing.addNamedImport(importName);
+    }
+    return;
+  }
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: importFrom,
+    namedImports: [importName]
+  });
+}
+
+// src/manifest.ts
+var MANIFEST = [
+  {
+    name: wrapHandlerWithMutation.name,
+    description: wrapHandlerWithMutation.description,
+    status: "shipped",
+    since: "1.0.0",
+    codemod: wrapHandlerWithMutation
+  },
+  {
+    name: extractOnClickToCommand.name,
+    description: extractOnClickToCommand.description,
+    status: "shipped",
+    since: "1.0.0",
+    codemod: extractOnClickToCommand
+  },
+  {
+    name: reduxActionToCommand.name,
+    description: reduxActionToCommand.description,
+    status: "shipped",
+    since: "1.1.0",
+    codemod: reduxActionToCommand
+  },
+  {
+    name: useStateMutationToCommand.name,
+    description: useStateMutationToCommand.description,
+    status: "shipped",
+    since: "1.1.0",
+    codemod: useStateMutationToCommand
+  },
+  {
+    name: rtkThunkToCommand.name,
+    description: rtkThunkToCommand.description,
+    status: "shipped",
+    since: "1.1.0",
+    codemod: rtkThunkToCommand
+  }
+];
+function findCodemod(name) {
+  const entry = MANIFEST.find((m) => m.name === name);
+  return entry?.codemod;
+}
+function listShipped() {
+  return MANIFEST.filter((m) => m.status === "shipped");
+}
+
+// src/runner.ts
+async function runCodemod(name, options) {
+  const codemod = findCodemod(name);
+  if (!codemod) {
+    const known = MANIFEST.filter((m) => m.status === "shipped").map((m) => m.name).join(", ");
+    throw new Error(
+      `Unknown codemod "${name}". Available: ${known || "(none shipped yet)"}`
+    );
+  }
+  return await codemod.run(options);
+}
+
+exports.MANIFEST = MANIFEST;
+exports.extractOnClickToCommand = extractOnClickToCommand;
+exports.findCodemod = findCodemod;
+exports.listShipped = listShipped;
+exports.reduxActionToCommand = reduxActionToCommand;
+exports.rtkThunkToCommand = rtkThunkToCommand;
+exports.runCodemod = runCodemod;
+exports.useStateMutationToCommand = useStateMutationToCommand;
+exports.wrapHandlerWithMutation = wrapHandlerWithMutation;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map