codeup-action

name	codeup-action
description	Create a new codeup action with filter and apply steps
argument-hint	[action-name]

Codeup Action Skill

Create a new codeup action based on user-provided filter and steps.

Instructions

When user provides:

• filter: Condition for when the action should run
• steps: What the action should do

Generate a new action file in actions/ directory.

Action Structure

import { defineAction } from "codeup";

export default defineAction({
  meta: {
    name: "action-name", // kebab-case name
    description: "Description", // Short description of what it does
    date: "YYYY-MM-DD", // Today's date
  },
  async filter({ utils }) {
    // Return true if action should run, false otherwise
    return await utils.exists("some-file");
  },
  async apply({ utils }) {
    // Perform the action steps
  },
});

Available Utilities (utils)

File System

Method	Description
resolve(path)	Resolve path relative to cwd
exists(path)	Check if file/directory exists
existsWithAnyExt(path)	Check if file exists with any extension (e.g., .eslintrc matches .eslintrc.json)
read(path)	Read file contents as string
readLines(path)	Read file as array of lines
write(path, contents, opts?)	Write file. Options: { skipIfExists?: boolean, log?: boolean }
remove(path)	Remove file or directory
findUp(name)	Find file in cwd or parent directories
update(path, fn)	Read file, transform with fn, write back
append(path, contents)	Append to file

JSON

Method	Description
readJSON(path)	Read and parse JSON file
writeJSON(path, obj, opts?)	Write object as JSON
updateJSON<T>(path, fn)	Read JSON, transform with fn, write back

Package.json

Method	Description
readPackageJSON()	Read closest package.json
updatePackageJSON(fn)	Update package.json with transformer function
addDependency(name)	Add dependency (string or array)
addDevDependency(name)	Add dev dependency (string or array)
removeDependency(name)	Remove dependency
detectPackageManager()	Detect npm/yarn/pnpm/bun
runPackageManagerCommand(cmd)	Run command with detected package manager
runScript(script)	Run package.json script

Common Filter Patterns

// File exists
await utils.exists("tsconfig.json");

// File with any extension exists
await utils.existsWithAnyExt(".eslintrc");

// File exists AND another doesn't
(await utils.exists("old.config")) && !(await utils.exists("new.config"));

// Check package.json for dependency
const pkg = await utils.readPackageJSON();
return !!pkg?.devDependencies?.["some-package"];

// Check package.json scripts
const pkg = await utils.readPackageJSON();
const scripts = Object.values(pkg?.scripts || {}) as string[];
return scripts.some((s) => s.includes("some-command"));

Common Apply Patterns

// Remove files
await utils.remove(".oldconfig");
await utils.remove(".oldignore");

// Write new config (skip if exists)
await utils.write("new.config.json", JSON.stringify({ key: "value" }, null, 2), {
  skipIfExists: true,
});

// Update package.json scripts
await utils.updatePackageJSON((pkg) => {
  for (const name in pkg.scripts) {
    if (pkg.scripts[name]?.includes("old-cmd")) {
      pkg.scripts[name] = pkg.scripts[name].replace("old-cmd", "new-cmd");
    }
  }
});

// Add/remove dependencies
await utils.addDevDependency("new-package@^1.0.0");
await utils.removeDependency("old-package");

// Update JSON config
await utils.updateJSON<SomeType>("config.json", (config) => {
  delete config.oldOption;
  config.newOption = true;
});

// Run script after changes
await utils.runScript("lint:fix");

Example Actions

Migration Action (eslint-flat style)

import { defineAction } from "codeup";

export default defineAction({
  meta: {
    name: "migrate-config",
    description: "Migrate from old config to new config",
    date: "2026-01-29",
  },
  async filter({ utils }) {
    return (
      (await utils.existsWithAnyExt(".oldrc")) && !(await utils.existsWithAnyExt("new.config"))
    );
  },
  async apply({ utils }) {
    // Read old config
    const oldConfig = await utils.readJSON(".oldrc");

    // Write new config
    await utils.write("new.config.mjs", getTemplate(oldConfig));

    // Remove old files
    await utils.remove(".oldrc");
    await utils.remove(".oldignore");

    // Update dependencies
    await utils.addDevDependency("new-tool@^2.0.0");
    await utils.removeDependency("old-tool");
  },
});

Tool Switch Action (tsgo style)

import { defineAction } from "codeup";

export default defineAction({
  meta: {
    name: "switch-tool",
    description: "Switch from tool-a to tool-b",
    date: "2026-01-29",
  },
  async filter({ utils }) {
    const pkg = await utils.readPackageJSON();
    return !!pkg?.devDependencies?.["tool-a"];
  },
  async apply({ utils }) {
    // Update scripts
    await utils.updatePackageJSON((pkg) => {
      for (const name in pkg.scripts) {
        if (pkg.scripts[name]?.includes("tool-a")) {
          pkg.scripts[name] = pkg.scripts[name].replace("tool-a", "tool-b");
        }
      }
    });

    // Swap dependencies
    await utils.removeDependency("tool-a");
    await utils.addDevDependency("tool-b@latest");
  },
});

Task

1. Ask for action name if not provided
2. Ask for filter condition (when should this action run?)
3. Ask for steps (what should the action do?)
4. Determine appropriate directory under actions/ (use actions/unjs/ for unjs-related actions)
5. Generate the action file with proper structure
6. Use today's date for the meta.date field