feat: add --allowed-tools CLI flag and show automation command in outro

Add --allowed-tools CLI option to allow pre-approving tools for commands
in non-interactive mode. Also display a helpful automation command in
the outro after interactive mode completes, showing users how to
reproduce their choices programmatically.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: wbern

README.md

@@ -82,6 +82,7 @@ This ensures commands are regenerated whenever anyone runs `npm install`, `pnpm
 | `--overwrite` | Overwrite conflicting files without prompting |
 | `--skip-on-conflict` | Skip conflicting files without prompting |
 | `--flags=beads,github` | Enable feature flags (beads, github, gitlab, etc.) |
+| `--allowed-tools=Bash(git diff:*),Bash(git status:*)` | Pre-approve tools for commands (non-interactive mode) |
 | `--help, -h` | Show help message |
 | `--version, -v` | Show version number |
 

scripts/bin.test.ts

@@ -64,6 +64,16 @@ describe("parseArgs", () => {
       flags: ["beads", "github"],
     });
   });
+
+  it("should parse --allowed-tools as comma-separated list", () => {
+    const args = parseArgs([
+      "--allowed-tools=Bash(git diff:*),Bash(git status:*)",
+    ]);
+
+    expect(args).toEqual({
+      allowedTools: ["Bash(git diff:*)", "Bash(git status:*)"],
+    });
+  });
 });
 
 describe("run", () => {
@@ -153,6 +163,7 @@ describe("CLI_OPTIONS consistency", () => {
       overwrite: undefined,
       skipOnConflict: undefined,
       flags: undefined,
+      allowedTools: undefined,
       includeContribCommands: undefined,
     } satisfies Record<keyof Required<CliArgs>, undefined>;
 

scripts/cli-options.ts

@@ -62,6 +62,13 @@ export const CLI_OPTIONS: CliOption[] = [
     description: "Enable feature flags (beads, github, gitlab, etc.)",
     example: "--flags=beads,github",
   },
+  {
+    flag: "--allowed-tools",
+    key: "allowedTools",
+    type: "array",
+    description: "Pre-approve tools for commands (non-interactive mode)",
+    example: "--allowed-tools=Bash(git diff:*),Bash(git status:*)",
+  },
   {
     flag: "--include-contrib-commands",
     key: "includeContribCommands",

scripts/cli.test.ts

@@ -254,6 +254,96 @@ describe("CLI", () => {
     );
   });
 
+  it("should show automation command in outro for interactive mode", async () => {
+    const { outro } = await import("@clack/prompts");
+    const { main } = await import("./cli.js");
+
+    await setupInteractiveMocks({
+      scope: "project",
+      prefix: "my-",
+      flags: ["beads"],
+      commands: ["red.md", "green.md"],
+    });
+
+    await main();
+
+    expect(outro).toHaveBeenCalledWith(
+      expect.stringContaining("npx @wbern/claude-instructions"),
+    );
+    expect(outro).toHaveBeenCalledWith(
+      expect.stringContaining("--scope=project"),
+    );
+    expect(outro).toHaveBeenCalledWith(expect.stringContaining("--prefix=my-"));
+    expect(outro).toHaveBeenCalledWith(
+      expect.stringContaining("--flags=beads"),
+    );
+  });
+
+  it("should include --commands in automation note when specific commands selected", async () => {
+    const { outro } = await import("@clack/prompts");
+    const { main } = await import("./cli.js");
+
+    await setupInteractiveMocks({
+      scope: "project",
+      commands: ["red.md", "green.md"],
+    });
+
+    await main();
+
+    expect(outro).toHaveBeenCalledWith(
+      expect.stringContaining("--commands=red.md,green.md"),
+    );
+  });
+
+  it("should NOT include --commands in automation note when no commands selected", async () => {
+    const { outro } = await import("@clack/prompts");
+    const { main } = await import("./cli.js");
+
+    await setupInteractiveMocks({
+      scope: "project",
+      commands: [],
+    });
+
+    await main();
+
+    expect(outro).toHaveBeenCalledWith(
+      expect.not.stringContaining("--commands="),
+    );
+  });
+
+  it("should include --allowed-tools in automation note when tools selected", async () => {
+    const { outro } = await import("@clack/prompts");
+    const { main } = await import("./cli.js");
+
+    await setupInteractiveMocks({
+      scope: "project",
+      allowedTools: ["Bash(git diff:*)", "Bash(git status:*)"],
+    });
+
+    await main();
+
+    expect(outro).toHaveBeenCalledWith(
+      expect.stringContaining(
+        "--allowed-tools=Bash(git diff:*),Bash(git status:*)",
+      ),
+    );
+  });
+
+  it("should NOT show automation note in non-interactive mode", async () => {
+    const { outro } = await import("@clack/prompts");
+    const { main } = await import("./cli.js");
+
+    await main({
+      scope: "project",
+      prefix: "my-",
+      flags: ["beads"],
+    });
+
+    expect(outro).toHaveBeenCalledWith(
+      expect.not.stringContaining("To automate this setup"),
+    );
+  });
+
   it("should prompt for command prefix and pass it to generator", async () => {
     const { text } = await import("@clack/prompts");
     const { generateToDirectory } = await import("./cli-generator.js");
@@ -1784,4 +1874,23 @@ describe("non-TTY mode", () => {
       }),
     );
   });
+
+  it("should pass allowedTools from CLI args to generator in non-interactive mode", async () => {
+    const { generateToDirectory } = await import("./cli-generator.js");
+    const { main } = await import("./cli.js");
+
+    await main({
+      scope: "project",
+      prefix: "",
+      allowedTools: ["Bash(git diff:*)", "Bash(git status:*)"],
+    });
+
+    expect(generateToDirectory).toHaveBeenCalledWith(
+      undefined,
+      "project",
+      expect.objectContaining({
+        allowedTools: ["Bash(git diff:*)", "Bash(git status:*)"],
+      }),
+    );
+  });
 });

scripts/cli.ts

@@ -200,6 +200,7 @@ export interface CliArgs {
   overwrite?: boolean;
   skipOnConflict?: boolean;
   flags?: string[];
+  allowedTools?: string[];
   includeContribCommands?: boolean;
 }
 
@@ -219,6 +220,7 @@ export async function main(args?: CliArgs): Promise<void> {
     commandPrefix = args.prefix ?? "";
     selectedCommands = args.commands;
     selectedFlags = args.flags ? v.parse(FlagsSchema, args.flags) : undefined;
+    selectedAllowedTools = args.allowedTools;
 
     if (args.updateExisting) {
       cachedExistingFiles = await checkExistingFiles(undefined, scope, {
@@ -454,6 +456,32 @@ export async function main(args?: CliArgs): Promise<void> {
       ? `${process.cwd()}/.claude/commands`
       : `${os.homedir()}/.claude/commands`;
 
+  // Build automation command for interactive mode
+  const isInteractiveMode = !args?.scope;
+  let automationNote = "";
+  if (isInteractiveMode) {
+    const parts = ["npx @wbern/claude-instructions"];
+    parts.push(`--scope=${scope as string}`);
+    if (commandPrefix) {
+      parts.push(`--prefix=${commandPrefix as string}`);
+    }
+    if (selectedFlags && (selectedFlags as string[]).length > 0) {
+      parts.push(`--flags=${(selectedFlags as string[]).join(",")}`);
+    }
+    if (selectedCommands && (selectedCommands as string[]).length > 0) {
+      parts.push(`--commands=${(selectedCommands as string[]).join(",")}`);
+    }
+    if (selectedAllowedTools && (selectedAllowedTools as string[]).length > 0) {
+      parts.push(
+        `--allowed-tools=${(selectedAllowedTools as string[]).join(",")}`,
+      );
+    }
+    automationNote = `
+
+To automate this setup:
+  ${parts.join(" ")}`;
+  }
+
   outro(
     `Installed ${result.filesGenerated} commands to ${fullPath}
 
@@ -465,7 +493,7 @@ Try it out:
   /red 1 returns "1"     → Write first failing test for your kata
   /green                 → Make it pass
 
-See a full example: https://github.com/wbern/claude-instructions#example-conversations
+See a full example: https://github.com/wbern/claude-instructions#example-conversations${automationNote}
 
 Happy coding!`,
   );