padrone 1.4.0 → 1.6.0

package/src/cli/doctor.ts

@@ -1,10 +1,15 @@
 import { resolve } from 'node:path';
-import { commandSymbol } from '../command-utils.ts';
-import type { AnyPadroneCommand, PadroneActionContext } from '../types.ts';
+import * as z from 'zod/v4';
+import { getJsonSchema } from '../core/args.ts';
+import { getCommand, isPadroneProgram } from '../core/commands.ts';
+import type { AnyPadroneCommand, PadroneActionContext } from '../types/index.ts';
+import { detectEntry } from './link.ts';
 
-interface DoctorArgs {
-  entry: string;
-}
+export const doctorSchema = z.object({
+  entry: z.string().optional().describe('Entry file that exports a Padrone program (auto-detected from package.json if omitted)'),
+});
+
+type DoctorArgs = z.infer<typeof doctorSchema>;
 
 type Severity = 'error' | 'warning';
 
@@ -15,7 +20,18 @@ interface Diagnostic {
 }
 
 export async function runDoctor(args: DoctorArgs, _ctx: PadroneActionContext) {
-  const entryPath = resolve(args.entry);
+  let entryPath: string;
+
+  if (args.entry) {
+    entryPath = resolve(args.entry);
+  } else {
+    const detected = detectEntry(process.cwd());
+    if (!detected) {
+      console.error('Could not detect entry point. Provide an entry file or add a "bin" field to package.json.');
+      process.exit(1);
+    }
+    entryPath = detected.entry;
+  }
 
   let mod: Record<string, unknown>;
   try {
@@ -33,7 +49,7 @@ export async function runDoctor(args: DoctorArgs, _ctx: PadroneActionContext) {
     process.exit(1);
   }
 
-  const cmd = (program as any)[commandSymbol] as AnyPadroneCommand;
+  const cmd = getCommand(program as object);
   const diagnostics: Diagnostic[] = [];
 
   collectDiagnostics(cmd, diagnostics);
@@ -63,6 +79,8 @@ export async function runDoctor(args: DoctorArgs, _ctx: PadroneActionContext) {
 }
 
 function collectDiagnostics(cmd: AnyPadroneCommand, diagnostics: Diagnostic[]) {
+  checkCircularParentRefs(cmd, diagnostics);
+
   const allCommands = flattenCommands(cmd);
 
   checkDuplicateAliases(allCommands, diagnostics);
@@ -70,7 +88,12 @@ function collectDiagnostics(cmd: AnyPadroneCommand, diagnostics: Diagnostic[]) {
   checkCommandsWithoutActions(allCommands, diagnostics);
   checkSchemasWithoutDescriptions(allCommands, diagnostics);
   checkConflictingPositionals(allCommands, diagnostics);
-  checkUnusedPlugins(allCommands, diagnostics);
+  checkUnusedInterceptors(allCommands, diagnostics);
+  checkDuplicateOptionFlagsAndAliases(allCommands, diagnostics);
+  checkUnreachableCommands(allCommands, diagnostics);
+  checkMissingCommandDescriptions(allCommands, diagnostics);
+  checkEmptyCommandGroups(allCommands, diagnostics);
+  checkDeprecatedWithoutHint(allCommands, diagnostics);
 }
 
 function flattenCommands(cmd: AnyPadroneCommand): AnyPadroneCommand[] {
@@ -87,10 +110,10 @@ function commandDisplayName(cmd: AnyPadroneCommand): string {
   return cmd.path || cmd.name || '<root>';
 }
 
-function getJsonSchema(cmd: AnyPadroneCommand): Record<string, any> | null {
+function getCommandJsonSchema(cmd: AnyPadroneCommand): Record<string, any> | null {
   try {
     if (!cmd.argsSchema) return null;
-    return cmd.argsSchema['~standard'].jsonSchema.input({ target: 'draft-2020-12' }) as Record<string, any>;
+    return getJsonSchema(cmd.argsSchema) as Record<string, any>;
   } catch {
     return null;
   }
@@ -147,7 +170,7 @@ function checkShadowedOptionNames(commands: AnyPadroneCommand[], diagnostics: Di
     }
 
     // Check option names in schema
-    const jsonSchema = getJsonSchema(cmd);
+    const jsonSchema = getCommandJsonSchema(cmd);
     if (!jsonSchema?.properties) continue;
 
     for (const propName of Object.keys(jsonSchema.properties)) {
@@ -220,7 +243,7 @@ function checkCommandsWithoutActions(commands: AnyPadroneCommand[], diagnostics:
  */
 function checkSchemasWithoutDescriptions(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
   for (const cmd of commands) {
-    const jsonSchema = getJsonSchema(cmd);
+    const jsonSchema = getCommandJsonSchema(cmd);
     if (!jsonSchema?.properties) continue;
 
     for (const [propName, propSchema] of Object.entries(jsonSchema.properties as Record<string, any>)) {
@@ -275,7 +298,7 @@ function checkConflictingPositionals(commands: AnyPadroneCommand[], diagnostics:
     }
 
     // Check for positional names that don't exist in schema
-    const jsonSchema = getJsonSchema(cmd);
+    const jsonSchema = getCommandJsonSchema(cmd);
     if (jsonSchema?.properties) {
       for (const p of positional) {
         const name = (p as string).replace(/^\.\.\./, '');
@@ -292,27 +315,198 @@ function checkConflictingPositionals(commands: AnyPadroneCommand[], diagnostics:
 }
 
 /**
- * Check for plugins that don't define any phase handlers.
+ * Check for interceptors that don't define any phase handlers.
  */
-function checkUnusedPlugins(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
+function checkUnusedInterceptors(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
   const phases = ['start', 'parse', 'validate', 'execute', 'error', 'shutdown'] as const;
 
   for (const cmd of commands) {
-    if (!cmd.plugins) continue;
+    if (!cmd.interceptors) continue;
 
-    for (const plugin of cmd.plugins) {
-      const hasHandler = phases.some((phase) => typeof (plugin as any)[phase] === 'function');
+    for (const interceptor of cmd.interceptors) {
+      const phases_obj = interceptor.factory();
+      const hasHandler = phases.some((phase) => typeof (phases_obj as any)[phase] === 'function');
       if (!hasHandler) {
         diagnostics.push({
           severity: 'warning',
           command: commandDisplayName(cmd),
-          message: `Plugin "${plugin.name}" has no phase handlers.`,
+          message: `Interceptor "${interceptor.meta.name}" has no phase handlers.`,
         });
       }
     }
   }
 }
 
+/**
+ * Check for circular parent references in the command tree.
+ * Uses a visited set to detect cycles before flattening.
+ */
+function checkCircularParentRefs(cmd: AnyPadroneCommand, diagnostics: Diagnostic[]) {
+  const visited = new Set<AnyPadroneCommand>();
+
+  function walk(node: AnyPadroneCommand) {
+    if (visited.has(node)) {
+      diagnostics.push({
+        severity: 'error',
+        command: commandDisplayName(node),
+        message: 'Circular reference detected in command tree.',
+      });
+      return;
+    }
+    visited.add(node);
+    if (node.commands) {
+      for (const sub of node.commands) {
+        walk(sub);
+      }
+    }
+  }
+
+  walk(cmd);
+}
+
+/**
+ * Check for duplicate flags or aliases within a single command's meta fields.
+ * e.g., two different options both using `-v` or both aliased to `--output`.
+ */
+function checkDuplicateOptionFlagsAndAliases(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
+  for (const cmd of commands) {
+    if (!cmd.meta?.fields) continue;
+
+    const seenFlags = new Map<string, string>();
+    const seenAliases = new Map<string, string>();
+
+    for (const [fieldName, fieldMeta] of Object.entries(cmd.meta.fields)) {
+      if (!fieldMeta) continue;
+
+      if (fieldMeta.flags) {
+        const flagList = typeof fieldMeta.flags === 'string' ? [fieldMeta.flags] : fieldMeta.flags;
+        for (const flag of flagList) {
+          const existing = seenFlags.get(flag);
+          if (existing) {
+            diagnostics.push({
+              severity: 'error',
+              command: commandDisplayName(cmd),
+              message: `Flag "-${flag}" is used by both "${existing}" and "${fieldName}".`,
+            });
+          } else {
+            seenFlags.set(flag, fieldName);
+          }
+        }
+      }
+
+      if (fieldMeta.alias) {
+        const aliasList = typeof fieldMeta.alias === 'string' ? [fieldMeta.alias] : fieldMeta.alias;
+        for (const alias of aliasList) {
+          const existing = seenAliases.get(alias);
+          if (existing) {
+            diagnostics.push({
+              severity: 'error',
+              command: commandDisplayName(cmd),
+              message: `Alias "--${alias}" is used by both "${existing}" and "${fieldName}".`,
+            });
+          } else {
+            seenAliases.set(alias, fieldName);
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Check for commands that are unreachable because a parent is hidden.
+ * A hidden parent makes all its children effectively invisible to users.
+ */
+function checkUnreachableCommands(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
+  for (const cmd of commands) {
+    if (!cmd.parent || cmd.hidden) continue;
+
+    let ancestor: AnyPadroneCommand | undefined = cmd.parent;
+    while (ancestor) {
+      if (ancestor.hidden && ancestor.parent) {
+        diagnostics.push({
+          severity: 'warning',
+          command: commandDisplayName(cmd),
+          message: `Command is unreachable because parent "${commandDisplayName(ancestor)}" is hidden.`,
+        });
+        break;
+      }
+      ancestor = ancestor.parent;
+    }
+  }
+}
+
+/**
+ * Check for non-root commands without a title or description.
+ */
+function checkMissingCommandDescriptions(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
+  for (const cmd of commands) {
+    if (!cmd.parent) continue;
+    if (cmd.hidden) continue;
+
+    if (!cmd.title && !cmd.description) {
+      diagnostics.push({
+        severity: 'warning',
+        command: commandDisplayName(cmd),
+        message: 'Command has no title or description.',
+      });
+    }
+  }
+}
+
+/**
+ * Check for branch commands (have subcommands) that have no leaf descendants.
+ * This catches empty command groups where all subcommands are also empty branches.
+ */
+function checkEmptyCommandGroups(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
+  function hasLeafDescendant(cmd: AnyPadroneCommand): boolean {
+    if (!cmd.commands || cmd.commands.length === 0) return true;
+    return cmd.commands.some(hasLeafDescendant);
+  }
+
+  for (const cmd of commands) {
+    if (!cmd.commands || cmd.commands.length === 0) continue;
+
+    const allSubsEmpty = cmd.commands.every((sub) => sub.commands && sub.commands.length > 0 && !hasLeafDescendant(sub));
+
+    if (allSubsEmpty) {
+      diagnostics.push({
+        severity: 'warning',
+        command: commandDisplayName(cmd),
+        message: 'Command group has no reachable leaf commands.',
+      });
+    }
+  }
+}
+
+/**
+ * Check for deprecated commands that use `deprecated: true` without a hint message.
+ */
+function checkDeprecatedWithoutHint(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
+  for (const cmd of commands) {
+    if (cmd.deprecated === true) {
+      diagnostics.push({
+        severity: 'warning',
+        command: commandDisplayName(cmd),
+        message: 'Command is deprecated without a replacement hint. Use a string to provide guidance (e.g., "Use \'new-cmd\' instead").',
+      });
+    }
+
+    // Also check deprecated option fields
+    if (cmd.meta?.fields) {
+      for (const [fieldName, fieldMeta] of Object.entries(cmd.meta.fields)) {
+        if (fieldMeta?.deprecated === true) {
+          diagnostics.push({
+            severity: 'warning',
+            command: commandDisplayName(cmd),
+            message: `Option "${fieldName}" is deprecated without a replacement hint.`,
+          });
+        }
+      }
+    }
+  }
+}
+
 function findProgram(mod: Record<string, unknown>): unknown | null {
   const defaultExport = mod.default;
   if (isPadroneProgram(defaultExport)) return defaultExport;
@@ -323,8 +517,3 @@ function findProgram(mod: Record<string, unknown>): unknown | null {
 
   return null;
 }
-
-function isPadroneProgram(value: unknown): boolean {
-  if (!value || typeof value !== 'object') return false;
-  return commandSymbol in value;
-}

package/src/cli/index.ts

@@ -1,12 +1,11 @@
 import { createPadrone } from 'padrone';
 import pkg from 'padrone/package.json' with { type: 'json' };
-import * as z from 'zod/v4';
-import { runCompletions } from './completions.ts';
-import { runDocs } from './docs.ts';
-import { runDoctor } from './doctor.ts';
-import { runInit } from './init.ts';
-import { runLink, runUnlink } from './link.ts';
-import { runWrap } from './wrap.ts';
+import { completionsSchema, runCompletions } from './completions.ts';
+import { docsSchema, runDocs } from './docs.ts';
+import { doctorSchema, runDoctor } from './doctor.ts';
+import { initSchema, runInit } from './init.ts';
+import { linkSchema, runLink, runUnlink, unlinkSchema } from './link.ts';
+import { runWrap, wrapSchema } from './wrap.ts';
 
 const PadroneCLI = createPadrone('padrone')
   .configure({
@@ -19,17 +18,9 @@ const PadroneCLI = createPadrone('padrone')
       .configure({
         description: 'Scaffold a new Padrone CLI project',
       })
-      .arguments(
-        z.object({
-          name: z.string().optional().describe('Project name (defaults to directory name)'),
-          description: z.string().optional().describe('Project description'),
-          version: z.string().optional().default('0.1.0').describe('Initial version'),
-          dir: z.string().optional().describe('Target directory (defaults to current directory)'),
-        }),
-        {
-          positional: ['dir'],
-        },
-      )
+      .arguments(initSchema, {
+        positional: ['dir'],
+      })
       .async()
       .action(runInit),
   )
@@ -38,18 +29,9 @@ const PadroneCLI = createPadrone('padrone')
       .configure({
         description: 'Generate documentation for a Padrone CLI program',
       })
-      .arguments(
-        z.object({
-          entry: z.string().describe('Entry file that exports a Padrone program'),
-          output: z.string().optional().default('./docs/cli').describe('Output directory'),
-          format: z.enum(['markdown', 'html', 'man', 'json']).optional().default('markdown').describe('Output format'),
-          includeHidden: z.boolean().optional().default(false).describe('Include hidden commands and options'),
-          dryRun: z.boolean().optional().default(false).describe('Print what would be generated without writing'),
-        }),
-        {
-          positional: ['entry'],
-        },
-      )
+      .arguments(docsSchema, {
+        positional: ['entry'],
+      })
       .async()
       .action(runDocs),
   )
@@ -58,14 +40,9 @@ const PadroneCLI = createPadrone('padrone')
       .configure({
         description: 'Lint and validate a Padrone CLI program definition',
       })
-      .arguments(
-        z.object({
-          entry: z.string().describe('Entry file that exports a Padrone program'),
-        }),
-        {
-          positional: ['entry'],
-        },
-      )
+      .arguments(doctorSchema, {
+        positional: ['entry'],
+      })
       .async()
       .action(runDoctor),
   )
@@ -74,16 +51,9 @@ const PadroneCLI = createPadrone('padrone')
       .configure({
         description: 'Show shell completion install instructions for a Padrone CLI program',
       })
-      .arguments(
-        z.object({
-          appPath: z.string().optional().describe('Path or name of the CLI program (defaults to padrone)'),
-          for: z.enum(['bash', 'zsh', 'fish', 'powershell']).optional().describe('Target shell (auto-detected if omitted)'),
-          setup: z.boolean().optional().default(false).describe('Write completions to shell config file'),
-        }),
-        {
-          positional: ['appPath'],
-        },
-      )
+      .arguments(completionsSchema, {
+        positional: ['appPath'],
+      })
       .action(runCompletions),
   )
   .command('link', (cmd) =>
@@ -91,17 +61,9 @@ const PadroneCLI = createPadrone('padrone')
       .configure({
         description: 'Link a Padrone CLI program for global use during development',
       })
-      .arguments(
-        z.object({
-          entry: z.string().optional().describe('Entry file (auto-detected from package.json bin field)'),
-          name: z.string().optional().describe('Command name (auto-detected from package.json)'),
-          list: z.boolean().optional().default(false).describe('List all linked programs'),
-          setup: z.boolean().optional().default(false).describe('Add ~/.padrone/bin to PATH in shell config'),
-        }),
-        {
-          positional: ['entry'],
-        },
-      )
+      .arguments(linkSchema, {
+        positional: ['entry'],
+      })
       .async()
       .action(runLink),
   )
@@ -110,14 +72,9 @@ const PadroneCLI = createPadrone('padrone')
       .configure({
         description: 'Remove a previously linked Padrone CLI program',
       })
-      .arguments(
-        z.object({
-          name: z.string().optional().describe('Program name to unlink (auto-detected from current directory)'),
-        }),
-        {
-          positional: ['name'],
-        },
-      )
+      .arguments(unlinkSchema, {
+        positional: ['name'],
+      })
       .async()
       .action(runUnlink),
   )
@@ -126,21 +83,10 @@ const PadroneCLI = createPadrone('padrone')
       .configure({
         description: 'Generate a Padrone wrapper for an existing CLI tool',
       })
-      .arguments(
-        z.object({
-          command: z.string().describe('CLI command to wrap (e.g. gh, docker, kubectl)'),
-          source: z.enum(['help', 'fish', 'zsh']).optional().default('help').describe('Parsing source (default: help)'),
-          output: z.string().optional().describe('Output directory (default: ./src/<command>)'),
-          depth: z.number().default(4).optional().describe('Max subcommand depth'),
-          dryRun: z.boolean().optional().default(false).describe('Print what would be generated without writing'),
-          overwrite: z.boolean().optional().default(false).describe('Overwrite existing files'),
-          yes: z.boolean().optional().default(false).describe('Skip confirmation prompt'),
-        }),
-        {
-          positional: ['command'],
-          fields: { yes: { alias: 'y' } },
-        },
-      )
+      .arguments(wrapSchema, {
+        positional: ['command'],
+        fields: { yes: { alias: 'y' } },
+      })
       .async()
       .action(runWrap),
   );

package/src/cli/init.ts

@@ -1,14 +1,17 @@
 import { existsSync } from 'node:fs';
 import { basename, resolve } from 'node:path';
 import { createFileEmitter, template } from 'padrone/codegen';
-import type { PadroneActionContext } from '../types.ts';
+import * as z from 'zod/v4';
+import type { PadroneActionContext } from '../types/index.ts';
 
-interface InitArgs {
-  name?: string;
-  description?: string;
-  version?: string;
-  dir?: string;
-}
+export const initSchema = z.object({
+  name: z.string().optional().describe('Project name (defaults to directory name)'),
+  description: z.string().optional().describe('Project description'),
+  version: z.string().optional().default('0.1.0').describe('Initial version'),
+  dir: z.string().optional().describe('Target directory (defaults to current directory)'),
+});
+
+type InitArgs = z.infer<typeof initSchema>;
 
 const packageJsonTemplate = template(`{
   "name": "{{name}}",
@@ -16,9 +19,7 @@ const packageJsonTemplate = template(`{
   "private": true,
   "type": "module",
   "module": "src/index.ts",
-  "bin": {
-    "{{name}}": "src/index.ts"
-  },
+  "bin": "src/index.ts",
   "scripts": {
     "start": "bun src/index.ts",
     "dev": "bun --watch src/index.ts",
@@ -131,5 +132,6 @@ export async function runInit(args: InitArgs, ctx: PadroneActionContext) {
     output(`  cd ${dir}`);
   }
   output('  bun install');
+  output('  bun update');
   output('  bun run dev');
 }

package/src/cli/link.ts

@@ -1,19 +1,23 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, dirname, resolve } from 'node:path';
-import { detectShell, getRcFile, type ShellType, writeToRcFile } from '../shell-utils.ts';
-import type { PadroneActionContext } from '../types.ts';
-
-interface LinkArgs {
-  entry?: string;
-  name?: string;
-  list?: boolean;
-  setup?: boolean;
-}
+import * as z from 'zod/v4';
+import type { PadroneActionContext } from '../types/index.ts';
+import { detectShell, getRcFile, type ShellType, writeToRcFile } from '../util/shell-utils.ts';
 
-interface UnlinkArgs {
-  name?: string;
-}
+export const linkSchema = z.object({
+  entry: z.string().optional().describe('Entry file (auto-detected from package.json bin field)'),
+  name: z.string().optional().describe('Command name (auto-detected from package.json)'),
+  list: z.boolean().optional().default(false).describe('List all linked programs'),
+  setup: z.boolean().optional().default(false).describe('Add ~/.padrone/bin to PATH in shell config'),
+});
+
+export const unlinkSchema = z.object({
+  name: z.string().optional().describe('Program name to unlink (auto-detected from current directory)'),
+});
+
+type LinkArgs = z.infer<typeof linkSchema>;
+type UnlinkArgs = z.infer<typeof unlinkSchema>;
 
 interface LinkEntry {
   name: string;
@@ -49,7 +53,7 @@ function writeLinks(links: LinksData) {
   writeFileSync(LINKS_FILE, `${JSON.stringify(links, null, 2)}\n`);
 }
 
-interface DetectedEntry {
+export interface DetectedEntry {
   entry: string;
   name: string;
   /** Full run command prefix parsed from scripts (e.g. "bun --conditions=padrone@dev") */
@@ -70,7 +74,7 @@ function parseRunPrefix(script: string, entryRelative: string, dir: string): str
   return undefined;
 }
 
-function detectEntry(dir: string): DetectedEntry | undefined {
+export function detectEntry(dir: string): DetectedEntry | undefined {
   const pkgPath = resolve(dir, 'package.json');
   if (!existsSync(pkgPath)) return undefined;
 
@@ -143,8 +147,8 @@ function buildPathSnippet(shell: ShellType, binDir: string): string {
   }
 }
 
-function setupPath(shell: ShellType): { file: string; updated: boolean } {
-  const rcFile = getRcFile(shell);
+async function setupPath(shell: ShellType): Promise<{ file: string; updated: boolean }> {
+  const rcFile = await getRcFile(shell);
   if (!rcFile) {
     throw new Error(`Could not determine config file for ${shell}.`);
   }
@@ -268,13 +272,13 @@ export async function runLink(args: LinkArgs, ctx: PadroneActionContext) {
 
   if (!isInPath(BIN_DIR)) {
     if (args.setup) {
-      const shell = detectShell();
+      const shell = await detectShell();
       if (!shell) {
         error('Could not detect shell. Add the PATH manually:');
         error(`  export PATH="${BIN_DIR}:$PATH"`);
         return;
       }
-      const result = setupPath(shell);
+      const result = await setupPath(shell);
       const verb = result.updated ? 'Updated' : 'Added';
       output(`${verb} PATH in ${result.file}`);
       output('Restart your shell or run:');

package/src/cli/wrap.ts

@@ -1,20 +1,23 @@
 import { resolve } from 'node:path';
 import { createCodeBuilder, createFileEmitter, generateCommandTree } from 'padrone/codegen';
+import * as z from 'zod/v4';
 import type { DiscoverySource } from '../codegen/discovery.ts';
 import { discoverCli } from '../codegen/discovery.ts';
 import { template } from '../codegen/template.ts';
 import type { GeneratorContext } from '../codegen/types.ts';
-import type { PadroneActionContext } from '../types.ts';
-
-interface WrapArgs {
-  command: string;
-  source?: DiscoverySource;
-  output?: string;
-  depth?: number;
-  dryRun?: boolean;
-  overwrite?: boolean;
-  yes?: boolean;
-}
+import type { PadroneActionContext } from '../types/index.ts';
+
+export const wrapSchema = z.object({
+  command: z.string().describe('CLI command to wrap (e.g. gh, docker, kubectl)'),
+  source: z.enum(['help', 'fish', 'zsh']).optional().default('help').describe('Parsing source (default: help)'),
+  output: z.string().optional().describe('Output directory (default: ./src/<command>)'),
+  depth: z.number().default(4).optional().describe('Max subcommand depth'),
+  dryRun: z.boolean().optional().default(false).describe('Print what would be generated without writing'),
+  overwrite: z.boolean().optional().default(false).describe('Overwrite existing files'),
+  yes: z.boolean().optional().default(false).describe('Skip confirmation prompt'),
+});
+
+type WrapArgs = z.infer<typeof wrapSchema>;
 
 export async function runWrap(args: WrapArgs, ctx: PadroneActionContext) {
   const { output, error } = ctx.runtime;