feat: auto-run .md files with ma in inline commands

When a command inline (!`...`) contains a path ending in .md,
automatically prefix it with `ma` to execute it as an agent.
This enables composing markdown agents together without explicitly
typing `ma`.

Examples:
- !`helper.claude.md` → ma helper.claude.md
- !`./task.md arg1` → ma ./task.md arg1
- !`~/agents/tool.md` → ma ~/agents/tool.md

Author: johnlindquist

src/imports.test.ts

@@ -1,5 +1,5 @@
-import { test, expect, beforeAll, afterAll } from "bun:test";
-import { expandImports, hasImports, toCanonicalPath } from "./imports";
+import { test, expect, beforeAll, afterAll, describe } from "bun:test";
+import { expandImports, hasImports, toCanonicalPath, isMarkdownFileCommand } from "./imports";
 import { mkdtemp, rm, symlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -422,3 +422,63 @@ test("expandImports runs bun commands in invocationCwd", async () => {
   expect(result).toContain("bun-invocation-dir");
   expect(result).not.toContain("bun-agent-dir");
 });
+
+// Auto-run .md files with ma tests
+describe("isMarkdownFileCommand", () => {
+  test("detects simple .md file", () => {
+    expect(isMarkdownFileCommand("foo.md")).toBe(true);
+  });
+
+  test("detects relative path .md file", () => {
+    expect(isMarkdownFileCommand("./foo.md")).toBe(true);
+    expect(isMarkdownFileCommand("../foo.md")).toBe(true);
+  });
+
+  test("detects home path .md file", () => {
+    expect(isMarkdownFileCommand("~/foo.md")).toBe(true);
+    expect(isMarkdownFileCommand("~/.ma/foo.md")).toBe(true);
+  });
+
+  test("detects absolute path .md file", () => {
+    expect(isMarkdownFileCommand("/path/to/foo.md")).toBe(true);
+  });
+
+  test("detects compound .md file names", () => {
+    expect(isMarkdownFileCommand("foo.claude.md")).toBe(true);
+    expect(isMarkdownFileCommand("task.i.claude.md")).toBe(true);
+  });
+
+  test("detects .md file with arguments", () => {
+    expect(isMarkdownFileCommand("foo.md arg1 arg2")).toBe(true);
+    expect(isMarkdownFileCommand("./task.claude.md --verbose")).toBe(true);
+  });
+
+  test("does NOT match non-.md files", () => {
+    expect(isMarkdownFileCommand("foo.txt")).toBe(false);
+    expect(isMarkdownFileCommand("foo.js")).toBe(false);
+    expect(isMarkdownFileCommand("echo hello")).toBe(false);
+    expect(isMarkdownFileCommand("ls -la")).toBe(false);
+  });
+
+  test("does NOT match commands containing .md elsewhere", () => {
+    expect(isMarkdownFileCommand("echo foo.md")).toBe(false);
+    expect(isMarkdownFileCommand("cat foo.md")).toBe(false);
+    expect(isMarkdownFileCommand("grep pattern foo.md")).toBe(false);
+  });
+
+  test("does NOT match .md in the middle of command", () => {
+    expect(isMarkdownFileCommand("cp foo.md bar.md")).toBe(false);
+  });
+});
+
+test("expandImports does not affect non-.md commands", async () => {
+  const content = "!`echo 'not an md file'`";
+  const result = await expandImports(content, testDir);
+  expect(result).toContain("not an md file");
+});
+
+test("expandImports preserves normal shell commands", async () => {
+  const content = "!`echo hello.txt`";
+  const result = await expandImports(content, testDir);
+  expect(result).toContain("hello.txt");
+});

src/imports.ts

@@ -740,6 +740,20 @@ async function processFileImport(
   return expandImports(content, dirname(resolvedPath), newStack, verbose, importCtx);
 }
 
+/**
+ * Pattern to detect markdown file paths that should be auto-run with `ma`
+ * Matches: foo.md, ./foo.md, ~/foo.md, /path/to/foo.md, foo.claude.md, etc.
+ * The command must start with a path-like pattern and end with .md
+ */
+const MD_FILE_COMMAND_PATTERN = /^(~?\.?\.?\/)?[^\s]+\.md(\s|$)/;
+
+/**
+ * Check if a command looks like a markdown file that should be run with `ma`
+ */
+export function isMarkdownFileCommand(command: string): boolean {
+  return MD_FILE_COMMAND_PATTERN.test(command.trim());
+}
+
 /**
  * Process a single command inline
  */
@@ -749,8 +763,15 @@ async function processCommandInline(
   verbose: boolean,
   importCtx?: ImportContext
 ): Promise<string> {
-  // Always log command execution to stderr for visibility
-  console.error(`[imports] Executing: ${command}`);
+  // Auto-prefix markdown files with `ma` to run them as agents
+  let actualCommand = command;
+  if (isMarkdownFileCommand(command)) {
+    actualCommand = `ma ${command}`;
+    console.error(`[imports] Auto-running .md file with ma: ${actualCommand}`);
+  } else {
+    // Always log command execution to stderr for visibility
+    console.error(`[imports] Executing: ${command}`);
+  }
 
   // Use importCtx.env if provided, otherwise fall back to process.env
   const env = importCtx?.env ?? process.env;
@@ -760,7 +781,7 @@ async function processCommandInline(
   const commandCwd = importCtx?.invocationCwd ?? currentFileDir;
 
   try {
-    const result = Bun.spawnSync(["sh", "-c", command], {
+    const result = Bun.spawnSync(["sh", "-c", actualCommand], {
       cwd: commandCwd,
       stdout: "pipe",
       stderr: "pipe",
@@ -785,7 +806,7 @@ async function processCommandInline(
     }
     return output;
   } catch (err) {
-    throw new Error(`Command failed: ${command} - ${(err as Error).message}`);
+    throw new Error(`Command failed: ${actualCommand} - ${(err as Error).message}`);
   }
 }