agentv 0.21.0 → 0.21.2

package/dist/{chunk-MA3MJNJH.js → chunk-WOCXZEH4.js}

@@ -142,11 +142,20 @@ var require_dist = __commonJS({
 
 // src/index.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import { Command } from "commander";
+import { binary, run, subcommands as subcommands2 } from "cmd-ts";
 
 // src/commands/eval/index.ts
 import { stat as stat4 } from "node:fs/promises";
 import path19 from "node:path";
+import {
+  command,
+  flag,
+  number as number4,
+  option,
+  optional as optional2,
+  restPositionals,
+  string as string4
+} from "cmd-ts";
 import fg from "fast-glob";
 
 // src/commands/eval/run-eval.ts
@@ -155,7 +164,7 @@ import { access as access6, mkdir as mkdir7 } from "node:fs/promises";
 import path18 from "node:path";
 import { pathToFileURL } from "node:url";
 
-// ../../packages/core/dist/chunk-BO7KG7JX.js
+// ../../packages/core/dist/chunk-B2J23S7D.js
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
@@ -1039,8 +1048,8 @@ var ZodType = class {
   promise() {
     return ZodPromise.create(this, this._def);
   }
-  or(option) {
-    return ZodUnion.create([this, option], this._def);
+  or(option4) {
+    return ZodUnion.create([this, option4], this._def);
   }
   and(incoming) {
     return ZodIntersection.create(this, incoming, this._def);
@@ -2890,7 +2899,7 @@ var ZodUnion = class extends ZodType {
       return INVALID;
     }
     if (ctx.common.async) {
-      return Promise.all(options.map(async (option) => {
+      return Promise.all(options.map(async (option4) => {
         const childCtx = {
           ...ctx,
           common: {
@@ -2900,7 +2909,7 @@ var ZodUnion = class extends ZodType {
           parent: null
         };
         return {
-          result: await option._parseAsync({
+          result: await option4._parseAsync({
             data: ctx.data,
             path: ctx.path,
             parent: childCtx
@@ -2911,7 +2920,7 @@ var ZodUnion = class extends ZodType {
     } else {
       let dirty = void 0;
       const issues = [];
-      for (const option of options) {
+      for (const option4 of options) {
         const childCtx = {
           ...ctx,
           common: {
@@ -2920,7 +2929,7 @@ var ZodUnion = class extends ZodType {
           },
           parent: null
         };
-        const result = option._parseSync({
+        const result = option4._parseSync({
           data: ctx.data,
           path: ctx.path,
           parent: childCtx
@@ -3001,8 +3010,8 @@ var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
     }
     const discriminator = this.discriminator;
     const discriminatorValue = ctx.data[discriminator];
-    const option = this.optionsMap.get(discriminatorValue);
-    if (!option) {
+    const option4 = this.optionsMap.get(discriminatorValue);
+    if (!option4) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union_discriminator,
         options: Array.from(this.optionsMap.keys()),
@@ -3011,13 +3020,13 @@ var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
       return INVALID;
     }
     if (ctx.common.async) {
-      return option._parseAsync({
+      return option4._parseAsync({
         data: ctx.data,
         path: ctx.path,
         parent: ctx
       });
     } else {
-      return option._parseSync({
+      return option4._parseSync({
         data: ctx.data,
         path: ctx.path,
         parent: ctx
@@ -4201,7 +4210,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../../packages/core/dist/chunk-BO7KG7JX.js
+// ../../packages/core/dist/chunk-B2J23S7D.js
 async function fileExists(filePath) {
   try {
     await access(filePath, constants.F_OK);
@@ -4577,9 +4586,9 @@ function resolveVSCodeConfig(target, env, insiders) {
   const dryRunSource = target.dry_run ?? target.dryRun;
   const subagentRootSource = target.subagent_root ?? target.subagentRoot;
   const defaultCommand = insiders ? "code-insiders" : "code";
-  const command = resolveOptionalLiteralString(commandSource) ?? defaultCommand;
+  const command5 = resolveOptionalLiteralString(commandSource) ?? defaultCommand;
   return {
-    command,
+    command: command5,
     waitForResponse: resolveOptionalBoolean(waitSource) ?? true,
     dryRun: resolveOptionalBoolean(dryRunSource) ?? false,
     subagentRoot: resolveOptionalString(subagentRootSource, env, `${target.name} subagent root`, {
@@ -8081,7 +8090,7 @@ var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
   defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
   defineLazy(inst._zod, "values", () => {
     if (def.options.every((o) => o._zod.values)) {
-      return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
+      return new Set(def.options.flatMap((option4) => Array.from(option4._zod.values)));
     }
     return void 0;
   });
@@ -8095,8 +8104,8 @@ var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
   inst._zod.parse = (payload, ctx) => {
     let async = false;
     const results = [];
-    for (const option of def.options) {
-      const result = option._zod.run({
+    for (const option4 of def.options) {
+      const result = option4._zod.run({
         value: payload.value,
         issues: []
       }, ctx);
@@ -8121,10 +8130,10 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
   const _super = inst._zod.parse;
   defineLazy(inst._zod, "propValues", () => {
     const propValues = {};
-    for (const option of def.options) {
-      const pv = option._zod.propValues;
+    for (const option4 of def.options) {
+      const pv = option4._zod.propValues;
       if (!pv || Object.keys(pv).length === 0)
-        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
+        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option4)}"`);
       for (const [k, v] of Object.entries(pv)) {
         if (!propValues[k])
           propValues[k] = /* @__PURE__ */ new Set();
@@ -15328,8 +15337,8 @@ function isTransforming(_schema, _ctx) {
       return false;
     }
     case "union": {
-      for (const option of def.options) {
-        if (isTransforming(option, ctx))
+      for (const option4 of def.options) {
+        if (isTransforming(option4, ctx))
           return true;
       }
       return false;
@@ -35887,7 +35896,7 @@ async function withRetry(fn, retryConfig, signal) {
 }
 var execAsync2 = promisify2(execWithCallback);
 var DEFAULT_MAX_BUFFER = 10 * 1024 * 1024;
-async function defaultCommandRunner(command, options) {
+async function defaultCommandRunner(command5, options) {
   const execOptions = {
     cwd: options.cwd,
     env: options.env,
@@ -35897,7 +35906,7 @@ async function defaultCommandRunner(command, options) {
     shell: process.platform === "win32" ? "powershell.exe" : void 0
   };
   try {
-    const { stdout, stderr } = await execAsync2(command, execOptions);
+    const { stdout, stderr } = await execAsync2(command5, execOptions);
     return {
       stdout,
       stderr,
@@ -37821,7 +37830,7 @@ function pLimit(concurrency) {
     activeCount--;
     resumeNext();
   };
-  const run = async (function_, resolve2, arguments_) => {
+  const run2 = async (function_, resolve2, arguments_) => {
     const result = (async () => function_(...arguments_))();
     resolve2(result);
     try {
@@ -37834,7 +37843,7 @@ function pLimit(concurrency) {
     new Promise((internalResolve) => {
       queue.enqueue(internalResolve);
     }).then(
-      run.bind(void 0, function_, resolve2, arguments_)
+      run2.bind(void 0, function_, resolve2, arguments_)
     );
     (async () => {
       await Promise.resolve();
@@ -38778,9 +38787,6 @@ function buildPrompt(expectedOutcome, question, referenceAnswer) {
   }
   return parts.join("\n");
 }
-function createAgentKernel() {
-  return { status: "stub" };
-}
 
 // src/commands/eval/env.ts
 import { constants as constants4 } from "node:fs";
@@ -39513,17 +39519,18 @@ function formatEvaluationSummary(summary) {
 
 // ../../packages/core/dist/evaluation/validation/index.js
 import { readFile as readFile7 } from "node:fs/promises";
+import path16 from "node:path";
 import { parse as parse6 } from "yaml";
 import { readFile as readFile23 } from "node:fs/promises";
-import path16 from "node:path";
+import path23 from "node:path";
 import { parse as parse23 } from "yaml";
 import { readFile as readFile33 } from "node:fs/promises";
-import path23 from "node:path";
+import path33 from "node:path";
 import { parse as parse33 } from "yaml";
 import { readFile as readFile43 } from "node:fs/promises";
 import { parse as parse42 } from "yaml";
 import { readFile as readFile52 } from "node:fs/promises";
-import path33 from "node:path";
+import path43 from "node:path";
 import { parse as parse52 } from "yaml";
 var SCHEMA_EVAL_V2 = "agentv-eval-v2";
 var SCHEMA_TARGETS_V2 = "agentv-targets-v2.2";
@@ -39533,12 +39540,12 @@ async function detectFileType(filePath) {
     const content = await readFile7(filePath, "utf8");
     const parsed = parse6(content);
     if (typeof parsed !== "object" || parsed === null) {
-      return "unknown";
+      return inferFileTypeFromPath(filePath);
     }
     const record2 = parsed;
     const schema = record2.$schema;
     if (typeof schema !== "string") {
-      return "unknown";
+      return inferFileTypeFromPath(filePath);
     }
     switch (schema) {
       case SCHEMA_EVAL_V2:
@@ -39548,18 +39555,31 @@ async function detectFileType(filePath) {
       case SCHEMA_CONFIG_V22:
         return "config";
       default:
-        return "unknown";
+        return inferFileTypeFromPath(filePath);
     }
   } catch {
-    return "unknown";
+    return inferFileTypeFromPath(filePath);
+  }
+}
+function inferFileTypeFromPath(filePath) {
+  const normalized = path16.normalize(filePath).replace(/\\/g, "/");
+  const basename = path16.basename(filePath);
+  if (normalized.includes("/.agentv/")) {
+    if (basename === "config.yaml" || basename === "config.yml") {
+      return "config";
+    }
+    if (basename === "targets.yaml" || basename === "targets.yml") {
+      return "targets";
+    }
   }
+  return "eval";
 }
 function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function validateEvalFile(filePath) {
   const errors = [];
-  const absolutePath = path16.resolve(filePath);
+  const absolutePath = path23.resolve(filePath);
   let parsed;
   try {
     const content = await readFile23(absolutePath, "utf8");
@@ -39908,7 +39928,7 @@ function validateUnknownSettings(target, provider, absolutePath, location, error
 }
 async function validateTargetsFile(filePath) {
   const errors = [];
-  const absolutePath = path23.resolve(filePath);
+  const absolutePath = path33.resolve(filePath);
   let parsed;
   try {
     const content = await readFile33(absolutePath, "utf8");
@@ -40187,8 +40207,8 @@ async function validateConfigFile(filePath) {
     }
     const config2 = parsed;
     const schema = config2.$schema;
-    if (schema !== SCHEMA_CONFIG_V222) {
-      const message = typeof schema === "string" ? `Invalid $schema value '${schema}'. Expected '${SCHEMA_CONFIG_V222}'` : `Missing required field '$schema'. Please add '$schema: ${SCHEMA_CONFIG_V222}' at the top of the file.`;
+    if (schema !== void 0 && schema !== SCHEMA_CONFIG_V222) {
+      const message = `Invalid $schema value '${schema}'. Expected '${SCHEMA_CONFIG_V222}' or omit the field.`;
       errors.push({
         severity: "error",
         filePath,
@@ -40250,7 +40270,7 @@ function isObject3(value) {
 }
 async function validateFileReferences(evalFilePath) {
   const errors = [];
-  const absolutePath = path33.resolve(evalFilePath);
+  const absolutePath = path43.resolve(evalFilePath);
   const gitRoot = await findGitRoot(absolutePath);
   if (!gitRoot) {
     errors.push({
@@ -40607,12 +40627,12 @@ function buildDefaultOutputPath(cwd, format) {
   const extension = getDefaultExtension(format);
   return path18.join(cwd, ".agentv", "results", `${baseName}_${timestamp}${extension}`);
 }
-function resolvePromptDirectory(option, cwd) {
-  if (option === void 0) {
+function resolvePromptDirectory(option4, cwd) {
+  if (option4 === void 0) {
     return void 0;
   }
-  if (typeof option === "string" && option.trim().length > 0) {
-    return path18.resolve(cwd, option);
+  if (typeof option4 === "string" && option4.trim().length > 0) {
+    return path18.resolve(cwd, option4);
   }
   return path18.join(cwd, ".agentv", "prompts");
 }
@@ -40916,56 +40936,119 @@ async function resolveEvaluationRunner() {
 }
 
 // src/commands/eval/index.ts
-function parseInteger(value, fallback) {
-  const parsed = Number.parseInt(value, 10);
-  if (Number.isNaN(parsed)) {
-    return fallback;
-  }
-  return parsed;
-}
-function registerEvalCommand(program) {
-  program.command("eval").description("Run eval suites and report results").argument("<eval-paths...>", "Path(s) or glob(s) to evaluation .yaml file(s)").option("--target <name>", "Override target name from targets.yaml", "default").option("--targets <path>", "Path to targets.yaml (overrides discovery)").option("--eval-id <id>", "Run only the eval case with this identifier").option(
-    "--workers <count>",
-    "Number of parallel workers (default: 1, max: 50). Can also be set per-target in targets.yaml",
-    (value) => parseInteger(value, 1)
-  ).option("--out <path>", "Write results to the specified path").option(
-    "--output-format <format>",
-    "Output format: 'jsonl' or 'yaml' (default: jsonl)",
-    "jsonl"
-  ).option("--dry-run", "Use mock provider responses instead of real LLM calls", false).option(
-    "--dry-run-delay <ms>",
-    "Fixed delay in milliseconds for dry-run mode (overridden by delay range if specified)",
-    (value) => parseInteger(value, 0),
-    0
-  ).option(
-    "--dry-run-delay-min <ms>",
-    "Minimum delay in milliseconds for dry-run mode (requires --dry-run-delay-max)",
-    (value) => parseInteger(value, 0),
-    0
-  ).option(
-    "--dry-run-delay-max <ms>",
-    "Maximum delay in milliseconds for dry-run mode (requires --dry-run-delay-min)",
-    (value) => parseInteger(value, 0),
-    0
-  ).option(
-    "--agent-timeout <seconds>",
-    "Timeout in seconds for provider responses (default: 120)",
-    (value) => parseInteger(value, 120),
-    120
-  ).option(
-    "--max-retries <count>",
-    "Retry count for timeout recoveries (default: 2)",
-    (value) => parseInteger(value, 2),
-    2
-  ).option("--cache", "Enable in-memory provider response cache", false).option("--verbose", "Enable verbose logging", false).option(
-    "--dump-prompts [dir]",
-    "Persist prompt payloads for debugging (optional custom directory)"
-  ).action(async (evalPaths, rawOptions) => {
-    const resolvedPaths = await resolveEvalPaths(evalPaths, process.cwd());
+var evalCommand = command({
+  name: "eval",
+  description: "Run eval suites and report results",
+  args: {
+    evalPaths: restPositionals({
+      type: string4,
+      displayName: "eval-paths",
+      description: "Path(s) or glob(s) to evaluation .yaml file(s)"
+    }),
+    target: option({
+      type: string4,
+      long: "target",
+      description: "Override target name from targets.yaml",
+      defaultValue: () => "default"
+    }),
+    targets: option({
+      type: optional2(string4),
+      long: "targets",
+      description: "Path to targets.yaml (overrides discovery)"
+    }),
+    evalId: option({
+      type: optional2(string4),
+      long: "eval-id",
+      description: "Run only the eval case with this identifier"
+    }),
+    workers: option({
+      type: number4,
+      long: "workers",
+      description: "Number of parallel workers (default: 1, max: 50). Can also be set per-target in targets.yaml",
+      defaultValue: () => 1
+    }),
+    out: option({
+      type: optional2(string4),
+      long: "out",
+      description: "Write results to the specified path"
+    }),
+    outputFormat: option({
+      type: string4,
+      long: "output-format",
+      description: "Output format: 'jsonl' or 'yaml' (default: jsonl)",
+      defaultValue: () => "jsonl"
+    }),
+    dryRun: flag({
+      long: "dry-run",
+      description: "Use mock provider responses instead of real LLM calls"
+    }),
+    dryRunDelay: option({
+      type: number4,
+      long: "dry-run-delay",
+      description: "Fixed delay in milliseconds for dry-run mode (overridden by delay range if specified)",
+      defaultValue: () => 0
+    }),
+    dryRunDelayMin: option({
+      type: number4,
+      long: "dry-run-delay-min",
+      description: "Minimum delay in milliseconds for dry-run mode (requires --dry-run-delay-max)",
+      defaultValue: () => 0
+    }),
+    dryRunDelayMax: option({
+      type: number4,
+      long: "dry-run-delay-max",
+      description: "Maximum delay in milliseconds for dry-run mode (requires --dry-run-delay-min)",
+      defaultValue: () => 0
+    }),
+    agentTimeout: option({
+      type: number4,
+      long: "agent-timeout",
+      description: "Timeout in seconds for provider responses (default: 120)",
+      defaultValue: () => 120
+    }),
+    maxRetries: option({
+      type: number4,
+      long: "max-retries",
+      description: "Retry count for timeout recoveries (default: 2)",
+      defaultValue: () => 2
+    }),
+    cache: flag({
+      long: "cache",
+      description: "Enable in-memory provider response cache"
+    }),
+    verbose: flag({
+      long: "verbose",
+      description: "Enable verbose logging"
+    }),
+    dumpPrompts: option({
+      type: optional2(string4),
+      long: "dump-prompts",
+      description: "Directory path for persisting prompt payloads for debugging"
+    })
+  },
+  handler: async (args) => {
+    const resolvedPaths = await resolveEvalPaths(args.evalPaths, process.cwd());
+    const dumpPrompts = args.dumpPrompts !== void 0 ? args.dumpPrompts === "." ? true : args.dumpPrompts : void 0;
+    const rawOptions = {
+      target: args.target,
+      targets: args.targets,
+      evalId: args.evalId,
+      workers: args.workers,
+      out: args.out,
+      outputFormat: args.outputFormat,
+      dryRun: args.dryRun,
+      dryRunDelay: args.dryRunDelay,
+      dryRunDelayMin: args.dryRunDelayMin,
+      dryRunDelayMax: args.dryRunDelayMax,
+      agentTimeout: args.agentTimeout,
+      maxRetries: args.maxRetries,
+      cache: args.cache,
+      verbose: args.verbose,
+      dumpPrompts
+    };
     await runEvalCommand({ testFiles: resolvedPaths, rawOptions });
-  });
-  return program;
-}
+  }
+});
 async function resolveEvalPaths(evalPaths, cwd) {
   const normalizedInputs = evalPaths.map((value) => value?.trim()).filter((value) => value);
   if (normalizedInputs.length === 0) {
@@ -41013,6 +41096,9 @@ async function resolveEvalPaths(evalPaths, cwd) {
   return sorted;
 }
 
+// src/commands/generate/index.ts
+import { command as command2, flag as flag2, option as option2, optional as optional3, positional as positional2, string as string5, subcommands } from "cmd-ts";
+
 // src/commands/generate/rubrics.ts
 import { readFile as readFile8, writeFile as writeFile6 } from "node:fs/promises";
 import path20 from "node:path";
@@ -41154,29 +41240,53 @@ function extractQuestion(evalCase) {
 }
 
 // src/commands/generate/index.ts
-function registerGenerateCommand(program) {
-  const generate = program.command("generate").description("Generate evaluation artifacts");
-  generate.command("rubrics <file>").description("Generate rubrics from expected_outcome in YAML eval file").option(
-    "-t, --target <target>",
-    "Override target for rubric generation (default: file target or openai:gpt-4o)"
-  ).option("-v, --verbose", "Show detailed progress").action(async (file2, options) => {
+var rubricsCommand = command2({
+  name: "rubrics",
+  description: "Generate rubrics from expected_outcome in YAML eval file",
+  args: {
+    file: positional2({
+      type: string5,
+      displayName: "file",
+      description: "Path to YAML eval file"
+    }),
+    target: option2({
+      type: optional3(string5),
+      long: "target",
+      short: "t",
+      description: "Override target for rubric generation (default: file target or openai:gpt-4o)"
+    }),
+    verbose: flag2({
+      long: "verbose",
+      short: "v",
+      description: "Show detailed progress"
+    })
+  },
+  handler: async ({ file: file2, target, verbose }) => {
     try {
       await generateRubricsCommand({
         file: file2,
-        target: options.target,
-        verbose: options.verbose
+        target,
+        verbose
       });
     } catch (error40) {
       console.error(`Error: ${error40.message}`);
       process.exit(1);
     }
-  });
-}
+  }
+});
+var generateCommand = subcommands({
+  name: "generate",
+  description: "Generate evaluation artifacts",
+  cmds: {
+    rubrics: rubricsCommand
+  }
+});
 
 // src/commands/init/index.ts
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import path24 from "node:path";
 import * as readline from "node:readline/promises";
+import { command as command3, option as option3, optional as optional4, string as string6 } from "cmd-ts";
 
 // src/templates/index.ts
 import { readFileSync, readdirSync, statSync } from "node:fs";
@@ -41355,15 +41465,28 @@ Files installed to ${path24.relative(targetPath, claudeDir)}:`);
   console.log("  2. Configure targets in .agentv/targets.yaml");
   console.log("  3. Create eval files using the schema and prompt templates");
 }
+var initCmdTsCommand = command3({
+  name: "init",
+  description: "Initialize AgentV in your project (installs prompt templates and schema to .github)",
+  args: {
+    path: option3({
+      type: optional4(string6),
+      long: "path",
+      description: "Target directory for initialization (default: current directory)"
+    })
+  },
+  handler: async ({ path: targetPath }) => {
+    try {
+      await initCommand({ targetPath });
+    } catch (error40) {
+      console.error(`Error: ${error40.message}`);
+      process.exit(1);
+    }
+  }
+});
 
-// src/commands/status.ts
-function registerStatusCommand(program) {
-  program.command("status").description("Show the latest AgentV kernel status").action(() => {
-    const kernel = createAgentKernel();
-    console.log(`Kernel status: ${kernel.status}`);
-  });
-  return program;
-}
+// src/commands/validate/index.ts
+import { command as command4, restPositionals as restPositionals2, string as string7 } from "cmd-ts";
 
 // src/commands/validate/format-output.ts
 var ANSI_RED3 = "\x1B[31m";
@@ -41468,20 +41591,6 @@ async function validateFiles(paths) {
 async function validateSingleFile(filePath) {
   const absolutePath = path25.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
-  if (fileType === "unknown") {
-    return {
-      valid: false,
-      filePath: absolutePath,
-      fileType: "unknown",
-      errors: [
-        {
-          severity: "error",
-          filePath: absolutePath,
-          message: "Missing or invalid $schema field. File must declare schema: 'agentv-eval-v2', 'agentv-targets-v2', or 'agentv-config-v2'"
-        }
-      ]
-    };
-  }
   let result;
   if (fileType === "eval") {
     result = await validateEvalFile(absolutePath);
@@ -41551,7 +41660,7 @@ function isYamlFile(filePath) {
 }
 
 // src/commands/validate/index.ts
-async function runValidateCommand(paths, _options) {
+async function runValidateCommand(paths) {
   if (paths.length === 0) {
     console.error("Error: No paths specified. Usage: agentv validate <paths...>");
     process.exit(1);
@@ -41563,47 +41672,45 @@ async function runValidateCommand(paths, _options) {
     process.exit(1);
   }
 }
-function registerValidateCommand(program) {
-  program.command("validate").description("Validate AgentV eval and targets YAML files").argument("<paths...>", "Files or directories to validate").action(async (paths, _options) => {
+var validateCommand = command4({
+  name: "validate",
+  description: "Validate AgentV eval and targets YAML files",
+  args: {
+    paths: restPositionals2({
+      type: string7,
+      displayName: "paths",
+      description: "Files or directories to validate"
+    })
+  },
+  handler: async ({ paths }) => {
     try {
-      await runValidateCommand(paths, _options);
+      await runValidateCommand(paths);
     } catch (error40) {
       console.error(`Error: ${error40.message}`);
       process.exit(1);
     }
-  });
-  return program;
-}
+  }
+});
 
 // src/index.ts
 var packageJson = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8"));
-function createProgram() {
-  const program = new Command();
-  program.name("agentv").description("AgentV CLI scaffolding").version(packageJson.version);
-  registerStatusCommand(program);
-  registerEvalCommand(program);
-  registerValidateCommand(program);
-  registerGenerateCommand(program);
-  program.command("init [path]").description(
-    "Initialize AgentV in your project (installs prompt templates and schema to .github)"
-  ).action(async (targetPath) => {
-    try {
-      await initCommand({ targetPath });
-    } catch (error40) {
-      console.error(`Error: ${error40.message}`);
-      process.exit(1);
-    }
-  });
-  return program;
-}
+var app = subcommands2({
+  name: "agentv",
+  description: "AgentV CLI",
+  version: packageJson.version,
+  cmds: {
+    eval: evalCommand,
+    validate: validateCommand,
+    generate: generateCommand,
+    init: initCmdTsCommand
+  }
+});
 async function runCli(argv = process.argv) {
-  const program = createProgram();
-  await program.parseAsync(argv);
-  return program;
+  await run(binary(app), argv);
 }
 
 export {
-  createProgram,
+  app,
   runCli
 };
-//# sourceMappingURL=chunk-MA3MJNJH.js.map
+//# sourceMappingURL=chunk-WOCXZEH4.js.map