feat: add ma create command for interactive agent creation

Adds a new `ma create` subcommand that provides an interactive wizard
for creating new markdown agent files. Supports both interactive and
non-interactive modes with options for location (-p project, -g global,
-l cwd) and frontmatter passthrough (--model, etc.).

Author: johnlindquist

src/cli.ts

@@ -78,13 +78,20 @@ export function parseCliArgs(argv: string[]): CliArgs {
 function printHelp() {
   console.log(`
 Usage: ma <file.md> [any flags for the command]
+       ma create [name] [flags]
        ma <file.md> --command <cmd>
        ma <file.md> --dry-run
        ma <url> [--trust]
        ma --setup
        ma --logs
        ma --help
 
+Create Mode:
+  ma create                     Interactive agent creator
+  ma create --name my-task      Create with name
+  ma create -n task -p          Create in project .ma/ folder
+  ma create -g --model gpt-4    Create in global ~/.ma/ folder with frontmatter
+
 Command resolution:
   1. --command flag (e.g., ma task.md --command claude)
   2. Filename pattern (e.g., task.claude.md → claude)

src/create.ts

@@ -0,0 +1,254 @@
+/**
+ * Interactive command to create new agent files
+ * Usage: ma create [options]
+ */
+
+import { input, select, confirm } from "@inquirer/prompts";
+import { existsSync, mkdirSync } from "fs";
+import { join, resolve } from "path";
+import yaml from "js-yaml";
+import { getProjectAgentsDir, getUserAgentsDir } from "./cli";
+
+interface CreateOptions {
+  name?: string;
+  command?: string;
+  location?: "cwd" | "project" | "user" | "custom";
+  customDir?: string;
+  content?: string;
+  frontmatter: Record<string, unknown>;
+}
+
+/**
+ * Parse CLI args into create options and frontmatter
+ */
+function parseCreateArgs(args: string[]): CreateOptions {
+  const options: CreateOptions = {
+    frontmatter: {},
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    // Handle positional arg as name if it's the first arg and not a flag
+    if (i === 0 && !arg.startsWith("-")) {
+      options.name = arg;
+      continue;
+    }
+
+    if (!arg.startsWith("-")) continue;
+
+    // Handle known flags
+    if (arg === "--name" || arg === "-n") {
+      options.name = args[++i];
+    } else if (arg === "--command" || arg === "-c") {
+      options.command = args[++i];
+    } else if (arg === "--location" || arg === "-l") {
+      const loc = args[++i];
+      if (["cwd", "project", "user"].includes(loc)) {
+        options.location = loc as "cwd" | "project" | "user";
+      }
+    } else if (arg === "--dir" || arg === "-d") {
+      options.location = "custom";
+      options.customDir = args[++i];
+    } else if (arg === "--content" || arg === "--body") {
+      options.content = args[++i];
+    } else if (arg === "--global" || arg === "-g") {
+      options.location = "user";
+    } else if (arg === "--project" || arg === "-p") {
+      options.location = "project";
+    } else {
+      // Treat as frontmatter
+      const key = arg.replace(/^-+/, "");
+      // If next arg is a value (not a flag), use it. Otherwise true.
+      const nextArg = args[i + 1];
+
+      if (nextArg && !nextArg.startsWith("-")) {
+        // Simple type inference for cleaner YAML
+        if (nextArg === "true") options.frontmatter[key] = true;
+        else if (nextArg === "false") options.frontmatter[key] = false;
+        else if (!isNaN(Number(nextArg)) && nextArg.trim() !== "")
+          options.frontmatter[key] = Number(nextArg);
+        else options.frontmatter[key] = nextArg;
+        i++;
+      } else {
+        options.frontmatter[key] = true;
+      }
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Run the create wizard
+ */
+export async function runCreate(args: string[]): Promise<void> {
+  // Handle help flag specially
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Usage: ma create [name] [flags]
+
+Create a new markdown agent. Any unknown flags are added to frontmatter.
+
+Options:
+  --name, -n       Agent name (e.g. 'task')
+  --command, -c    Tool to run (claude, gpt, python, etc)
+  --project, -p    Save to project agents (.ma/)
+  --global, -g     Save to global agents (~/.ma/)
+  --content        Initial prompt content
+
+Examples:
+  ma create task --command claude
+  ma create search -g --model perplexity
+`);
+    return;
+  }
+
+  const options = parseCreateArgs(args);
+
+  // 1. Name
+  if (!options.name) {
+    options.name = await input({
+      message: "Agent name:",
+      default: "task.claude.md",
+      validate: (value) => value.length > 0 || "Name is required",
+    });
+  }
+
+  // Ensure extension
+  if (!options.name.endsWith(".md")) {
+    options.name += ".md";
+  }
+
+  // 2. Command (if not specified and not obvious from name)
+  const nameParts = options.name.split(".");
+  // Matches name.command.md pattern
+  const inferredCommand =
+    nameParts.length >= 3 ? nameParts[nameParts.length - 2] : undefined;
+
+  if (!options.command && !inferredCommand) {
+    // Check if frontmatter has a model, often implies a specific tool
+    const defaultCmd = options.frontmatter.model ? "claude" : "claude";
+
+    options.command = await input({
+      message: "Command to wrap (e.g. claude, python, bash):",
+      default: defaultCmd,
+    });
+  }
+
+  // 3. Location
+  if (!options.location) {
+    options.location = await select({
+      message: "Where should we create this agent?",
+      choices: [
+        { name: `Current Directory (${process.cwd()})`, value: "cwd" },
+        {
+          name: "Project (.ma/)",
+          value: "project",
+          description: "Shared with team",
+        },
+        {
+          name: "User (~/.ma/)",
+          value: "user",
+          description: "Personal global agents",
+        },
+      ],
+    });
+  }
+
+  // Determine target directory
+  let targetDir = process.cwd();
+  if (options.location === "project") {
+    targetDir = getProjectAgentsDir();
+  } else if (options.location === "user") {
+    targetDir = getUserAgentsDir();
+  } else if (options.location === "custom" && options.customDir) {
+    targetDir = resolve(options.customDir);
+  }
+
+  // 4. Content
+  if (options.content === undefined) {
+    // Default template
+    options.content = `
+# ${options.name.replace(".md", "")}
+
+Describe your agent's task here.
+You can use variables like {{ prompt }} which map to CLI arguments.
+
+Example:
+Can you help me with {{ prompt }}?
+`.trim();
+  }
+
+  // Prepare frontmatter
+  const finalFrontmatter = { ...options.frontmatter };
+
+  // If no args defined and using default template, add safe defaults
+  if (!finalFrontmatter.args && !Object.keys(options.frontmatter).length) {
+    finalFrontmatter.args = ["prompt"];
+  }
+
+  // Construct YAML
+  let fileContent = "";
+  if (Object.keys(finalFrontmatter).length > 0) {
+    fileContent += "---\n";
+    fileContent += yaml.dump(finalFrontmatter);
+    fileContent += "---\n\n";
+  }
+
+  fileContent += options.content;
+
+  // Append newline
+  if (!fileContent.endsWith("\n")) {
+    fileContent += "\n";
+  }
+
+  // Ensure directory exists
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  const targetPath = join(targetDir, options.name);
+
+  if (existsSync(targetPath)) {
+    const overwrite = await confirm({
+      message: `File ${options.name} already exists in ${targetDir}. Overwrite?`,
+      default: false,
+    });
+    if (!overwrite) {
+      console.log("Cancelled.");
+      return;
+    }
+  }
+
+  await Bun.write(targetPath, fileContent);
+
+  console.log(`\n✅ Created agent: ${targetPath}`);
+
+  // Suggest renaming if command isn't embedded and wasn't explicit
+  if (
+    options.command &&
+    !inferredCommand &&
+    !options.name.includes(`.${options.command}.`)
+  ) {
+    console.log(
+      `\nTip: Consider naming your file "${options.name.replace(".md", "")}.${options.command}.md" to auto-detect the command.`
+    );
+  }
+
+  // Show run command
+  const relativePath =
+    options.location === "cwd" ? `./${options.name}` : options.name;
+  let runCmd = `ma ${relativePath}`;
+
+  // If we had to supply a command explicitly and it's not in the filename
+  if (
+    options.command &&
+    !inferredCommand &&
+    !options.name.includes(`.${options.command}.`)
+  ) {
+    runCmd += ` --command ${options.command}`;
+  }
+
+  console.log(`\nRun it with:\n  ${runCmd}\n`);
+}

src/index.ts

@@ -79,6 +79,15 @@ async function main() {
   try {
     const cliArgs = parseCliArgs(process.argv);
 
+    // Handle 'create' subcommand
+    // Intercept "create" as a keyword rather than a file path
+    if (cliArgs.filePath === "create") {
+      // Dynamic import to avoid loading inquirer prompts when not needed (startup speed)
+      const { runCreate } = await import("./create");
+      await runCreate(cliArgs.passthroughArgs);
+      process.exit(0);
+    }
+
     // Handle ma's own commands when no file provided
     let filePath = cliArgs.filePath;
     if (!filePath) {
@@ -89,6 +98,7 @@ async function main() {
       } else if (!result.handled) {
         // No file selected and no command handled - show usage
         console.error("Usage: ma <file.md> [flags for command]");
+        console.error("       ma create [options]");
         console.error("Run 'ma --help' for more info");
         throw new ConfigurationError("No agent file specified", 1);
       }