@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-I7SCBHJN.js

@@ -0,0 +1,655 @@
+import {
+  parseEffortToken
+} from "./chunk-TGXXYDL4.js";
+import {
+  isSafeGitRef
+} from "./chunk-D2M2Y5ID.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+import {
+  isValidCommandName,
+  isValidPath
+} from "./chunk-HGFXODKO.js";
+import {
+  toRepoRelativePath
+} from "./chunk-STW7OFOA.js";
+import {
+  sanitizeString
+} from "./chunk-CPSVQR2I.js";
+
+// src/utils/cli-validation.ts
+import fs2 from "fs";
+import * as path2 from "path";
+import { z } from "zod";
+
+// src/core/providers/generated/provider-ids.ts
+var ENABLED_PROVIDER_IDS = [
+  "claude",
+  "codex",
+  "cursor",
+  "grok",
+  "opencode",
+  "antigravity",
+  "copilot",
+  "kiro",
+  "gemini",
+  "pi"
+];
+
+// src/planning/managed-sync-refusal.ts
+import * as fs from "fs/promises";
+import path from "path";
+
+// scripts/lib/home-path-detector.mjs
+var ABSOLUTE_HOME_PATH_PATTERN = /(^|[^/A-Za-z0-9._-]|file:\/\/(?:localhost)?|:\/\/file)\/(Users|home)\/([A-Za-z0-9._-]+)/g;
+var PLACEHOLDER_HOME_NAMES = /* @__PURE__ */ new Set([
+  "user",
+  "username",
+  "test",
+  "tester",
+  "testuser",
+  "dev",
+  "alice",
+  "bob",
+  "john",
+  "jane",
+  "example",
+  "foo",
+  "bar",
+  "baz",
+  "you",
+  "me",
+  "runner",
+  // CI (e.g. GitHub Actions /home/runner)
+  "build-dogfood-user",
+  // synthetic dogfood account in redaction fixtures
+  "build-test",
+  "evil",
+  // adversarial path-traversal fixtures
+  "projects",
+  "a.b",
+  // synthetic sandbox-home fixture (/Users/a.b/...)
+  "u",
+  "x"
+]);
+function isLikelyRealHomeName(name) {
+  if (!name) return false;
+  if (name.startsWith(".")) return false;
+  if (PLACEHOLDER_HOME_NAMES.has(name.toLowerCase())) return false;
+  return true;
+}
+function findFirstRealHomePath(text) {
+  const pattern = new RegExp(ABSOLUTE_HOME_PATH_PATTERN.source, "g");
+  let match = pattern.exec(text);
+  while (match !== null) {
+    const [, , dir, name] = match;
+    if (isLikelyRealHomeName(name)) {
+      return `/${dir}/${name}`;
+    }
+    if (match[0].length > 0 && pattern.lastIndex > match.index + 1) {
+      pattern.lastIndex = match.index + 1;
+    }
+    match = pattern.exec(text);
+  }
+  return void 0;
+}
+
+// src/planning/managed-sync-refusal.ts
+var ManagedSyncBranchError = class extends Error {
+  branch;
+  defaultBranch;
+  constructor(message, details) {
+    super(message);
+    this.name = "ManagedSyncBranchError";
+    this.branch = details?.branch ?? "";
+    this.defaultBranch = details?.defaultBranch ?? "";
+  }
+};
+function describeManagedSyncBranchRefusal(branch, defaultBranch) {
+  return `Managed auto-sync refuses branch ${branch}; it publishes only from ${defaultBranch} or a chore/backlog-sync-* branch. Switch to ${defaultBranch}, pass --no-sync to keep the change local, or run "build plan storage enable" from ${defaultBranch} to publish from any branch`;
+}
+function formatManagedSyncBranchError(error) {
+  if (error.branch.length > 0 && error.defaultBranch.length > 0) {
+    return describeManagedSyncBranchRefusal(error.branch, error.defaultBranch);
+  }
+  return error.message;
+}
+function isManagedSyncBranchError(error) {
+  return error instanceof ManagedSyncBranchError || error instanceof Error && error.name === "ManagedSyncBranchError";
+}
+function formatHomePathRefusal(findings) {
+  const listed = findings.map((f) => `    ${f.file} (${f.match})`).join("\n");
+  return `Skipped sync: managed file embeds an absolute home path; rewrite it with ~ or a repo-relative path
+${listed}`;
+}
+async function findEmbeddedHomePaths(projectRoot, filePaths) {
+  const relativePaths = [
+    ...new Set(
+      filePaths.map((fp) => path.isAbsolute(fp) ? toRepoRelativePath(projectRoot, fp) : fp)
+    )
+  ].filter((rp) => rp.length > 0 && rp.endsWith(".md"));
+  const findings = [];
+  for (const rp of relativePaths) {
+    let content;
+    try {
+      content = await fs.readFile(path.join(projectRoot, rp), "utf8");
+    } catch {
+      continue;
+    }
+    const match = findFirstRealHomePath(content);
+    if (match) {
+      findings.push({ file: rp, match });
+    }
+  }
+  return findings;
+}
+async function findEmbeddedHomePathRefusal(projectRoot, filePaths) {
+  const findings = await findEmbeddedHomePaths(projectRoot, filePaths);
+  return findings.length > 0 ? formatHomePathRefusal(findings) : void 0;
+}
+
+// src/utils/cli-validation.ts
+var PROVIDER_FAMILY_ALIASES = ["openai", "anthropic"];
+var VALID_PROVIDER_NAMES = [
+  .../* @__PURE__ */ new Set([...ENABLED_PROVIDER_IDS, ...PROVIDER_FAMILY_ALIASES])
+].sort();
+function formatValidProviderNames() {
+  return VALID_PROVIDER_NAMES.join(", ");
+}
+var ProviderNameSchema = z.string().min(1, "Provider name cannot be empty").max(64, "Provider name too long (max 64 characters)").regex(/^[a-z][a-z0-9._-]*$/, "Provider name contains invalid characters").refine((provider) => VALID_PROVIDER_NAMES.includes(provider), {
+  message: `Invalid provider name. Must be one of: ${formatValidProviderNames()}`
+}).describe(`Invalid provider name. Must be one of: ${formatValidProviderNames()}`);
+var ModelNameSchema = z.string().min(1, "Model name cannot be empty").max(100, "Model name too long (max 100 characters)").regex(
+  /^[a-zA-Z0-9][a-zA-Z0-9._:\-/[\]]*$/,
+  "Model name contains invalid characters. Only alphanumeric, dots, colons, hyphens, underscores, forward slashes, and square brackets allowed"
+);
+function parseProviderFirstTarget(input) {
+  const tokens = input.trim().split(":");
+  const provider = (tokens[0] ?? "").trim().toLowerCase();
+  const rest = tokens.slice(1).map((token) => token.trim());
+  let effort;
+  if (rest.length > 0) {
+    const maybeEffort = parseEffortToken(rest[rest.length - 1] ?? "", true);
+    if (maybeEffort) {
+      effort = maybeEffort;
+      rest.pop();
+    }
+  }
+  const model = rest.length > 0 ? rest.join(":") : void 0;
+  const target = { provider };
+  if (model) target.model = model;
+  if (effort) target.effort = effort;
+  return target;
+}
+function parseSynthesisModelTarget(input) {
+  const firstColon = input.indexOf(":");
+  const firstToken = (firstColon === -1 ? input : input.slice(0, firstColon)).trim().toLowerCase();
+  if (VALID_PROVIDER_NAMES.includes(firstToken)) {
+    return parseProviderFirstTarget(input);
+  }
+  return { model: input };
+}
+var SynthesisModelTargetSchema = z.string().min(1, "Synthesis model target cannot be empty").max(200, "Synthesis model target too long (max 200 characters)").superRefine((raw, ctx) => {
+  const firstToken = (raw.split(":")[0] ?? "").trim().toLowerCase();
+  if (VALID_PROVIDER_NAMES.includes(firstToken) && raw.split(":").some((seg) => seg.trim() === "")) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Synthesis model target has an empty segment; use provider:model[:effort]"
+    });
+  }
+  const parsed = parseSynthesisModelTarget(raw);
+  if (parsed.provider !== void 0) {
+    if (!VALID_PROVIDER_NAMES.includes(parsed.provider)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Invalid synthesis provider '${parsed.provider}'. Must be one of: ${formatValidProviderNames()}`
+      });
+    }
+    if (parsed.model !== void 0 && !ModelNameSchema.safeParse(parsed.model).success) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Invalid synthesis model '${parsed.model}'.`
+      });
+    }
+    return;
+  }
+  if (!ModelNameSchema.safeParse(raw).success) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `Invalid synthesis model '${raw}'.`
+    });
+  }
+});
+var FilePathSchema = z.string().min(1, "File path cannot be empty").max(4096, "File path too long (max 4096 characters)").refine((filePath) => {
+  if (filePath.includes("\0")) {
+    return false;
+  }
+  return isValidPath(filePath);
+}, "File path contains dangerous characters").refine((filePath) => {
+  const normalizedPosix = path2.posix.normalize(filePath.replaceAll("\\", "/"));
+  if (normalizedPosix === ".." || normalizedPosix.startsWith("../") || normalizedPosix.includes("/../")) {
+    return false;
+  }
+  const cwd = getSafeCwd();
+  if (!path2.isAbsolute(filePath) && !cwd) {
+    return false;
+  }
+  if (cwd && !path2.isAbsolute(filePath)) {
+    let resolved;
+    try {
+      resolved = path2.resolve(filePath);
+    } catch {
+      return false;
+    }
+    const relativeToCwd = path2.relative(cwd, resolved);
+    if (relativeToCwd === ".." || relativeToCwd.startsWith(`..${path2.sep}`)) {
+      return false;
+    }
+  }
+  return true;
+}, "Path traversal detected - file path attempts to access parent directories");
+var ExistingFilePathSchema = FilePathSchema.refine(
+  (filePath) => {
+    try {
+      const resolvedPath = path2.resolve(filePath);
+      return fs2.existsSync(resolvedPath);
+    } catch {
+      return false;
+    }
+  },
+  { message: "File does not exist" }
+);
+var DirectoryPathSchema = z.string().min(1, "Directory path cannot be empty").max(4096, "Directory path too long (max 4096 characters)").refine((dirPath) => {
+  if (dirPath.includes("\0")) {
+    return false;
+  }
+  const dangerousChars = /[;&|`$<>(){}[\]!*?~\n\r]/;
+  if (dangerousChars.test(dirPath)) {
+    return false;
+  }
+  const normalized = path2.normalize(dirPath);
+  if (normalized.includes("..")) {
+    return false;
+  }
+  return true;
+}, "Directory path contains dangerous characters or attempts traversal");
+var PositiveIntegerSchema = z.number().int("Value must be an integer").positive("Value must be positive").max(Number.MAX_SAFE_INTEGER, "Value exceeds maximum safe integer");
+var PortNumberSchema = z.number().int("Port must be an integer").min(1, "Port must be at least 1").max(65535, "Port must be at most 65535");
+var TimeoutSchema = z.number().int("Timeout must be an integer").min(0, "Timeout cannot be negative").max(6e5, "Timeout cannot exceed 10 minutes (600000ms)");
+var TimeoutMinutesSchema = z.number().int("Timeout must be an integer number of minutes").min(1, "Timeout must be at least 1 minute").max(1440, "Timeout cannot exceed 1440 minutes (24 hours)");
+var ConcurrencySchema = z.number().int("Concurrency must be an integer").min(1, "Concurrency must be at least 1").max(100, "Concurrency cannot exceed 100 parallel operations");
+var MAX_TASK_DESCRIPTION_CHARS = 1e5;
+var TaskDescriptionSchema = z.string().min(1, "Task description cannot be empty").max(
+  MAX_TASK_DESCRIPTION_CHARS,
+  `Task description too long (max ${MAX_TASK_DESCRIPTION_CHARS} characters)`
+).refine((desc) => !desc.includes("\0"), "Task description contains a null byte");
+var CommandNameSchema = z.string().min(1, "Command name cannot be empty").refine((command) => isValidCommandName(command), "Command name contains invalid characters.");
+var EnvVarNameSchema = z.string().regex(
+  /^[A-Z_][A-Z0-9_]*$/,
+  "Environment variable name must start with letter or underscore, contain only uppercase letters, numbers, and underscores"
+).max(255, "Environment variable name too long (max 255 characters)");
+var BooleanFlagSchema = z.union([
+  z.boolean(),
+  z.literal("true").transform(() => true),
+  z.literal("false").transform(() => false),
+  z.literal("1").transform(() => true),
+  z.literal("0").transform(() => false),
+  z.literal("yes").transform(() => true),
+  z.literal("no").transform(() => false)
+]);
+var JsonStringSchema = z.string().min(2, "JSON string too short").max(1e6, "JSON string too long (max 1MB)").refine((str) => {
+  try {
+    JSON.parse(str);
+    return true;
+  } catch {
+    return false;
+  }
+}, "Invalid JSON format").transform((str) => JSON.parse(str));
+var VariantSchema = z.string().regex(
+  /^(?:[A-Za-z0-9_-]+=)?[a-zA-Z0-9-]+(?:(?::[a-zA-Z0-9._/[\]+-]*){0,4}:[a-zA-Z0-9._/[\]+-]+)?$/,
+  'Invalid variant format. Expected a provider id optionally followed by colon-separated segments (model, effort-<level>, mode), optionally prefixed with handle=. Run "build explain variants" for the grammar.'
+);
+var ReasoningEffortSchema = z.preprocess((value) => {
+  if (value === void 0 || value === null) return void 0;
+  const normalized = normalizeReasoningEffortInput(value);
+  return normalized ?? value;
+}, z.enum(["low", "medium", "high", "xhigh", "max"]).optional());
+var StringArraySchema = z.array(z.string().min(1, "Array element cannot be empty")).min(1, "Array must contain at least one element");
+var VariantArraySchema = z.array(VariantSchema).max(20, "Too many variants (max 20)");
+var OptionalStringSchema = z.string().optional().transform((val) => val?.trim() || void 0);
+var OptionalPositiveIntegerSchema = z.number().int().positive().optional();
+function validateCommandOptions(schema, options) {
+  const result = schema.safeParse(options);
+  if (!result.success) {
+    const message = `Invalid command options:
+${formatValidationErrors(result.error)}`;
+    throw Object.defineProperty(new z.ZodError(result.error.issues), "message", { value: message });
+  }
+  return result.data;
+}
+function camelToFlag(camelCase) {
+  return "--" + camelCase.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+}
+function getSafeCwd() {
+  try {
+    return process.cwd();
+  } catch {
+    return void 0;
+  }
+}
+function formatValidationErrors(error) {
+  return error.issues.map((issue) => {
+    const path3 = issue.path.length > 0 ? issue.path.join(".") : "input";
+    const message = issue.message;
+    const flagName = path3 === "input" ? "input" : path3.includes(".") ? path3.split(".").map((p) => camelToFlag(p)).join(" ") : camelToFlag(path3);
+    let friendlyMessage = message;
+    if (issue.code === "invalid_value") {
+      const options = issue.values || [];
+      const normalizedFlag = flagName.replace(/^--/, "");
+      if (normalizedFlag === "provider" || normalizedFlag === "input") {
+        friendlyMessage = `Invalid provider name. Must be one of: ${options.join(", ")}`;
+      } else {
+        friendlyMessage = `Invalid option: expected one of ${options.map((opt) => `"${opt}"`).join("|")}`;
+      }
+    }
+    if (issue.code === "invalid_type") {
+      const issueRecord = issue;
+      const received = typeof issueRecord.received === "string" ? issueRecord.received : typeof issue.input;
+      friendlyMessage = `Expected ${issue.expected}, received ${received}`;
+      return `  ${flagName}: ${friendlyMessage}`;
+    }
+    if (issue.code === "too_small") {
+      friendlyMessage = `${message} (minimum: ${issue.minimum})`;
+      return `  ${flagName}: ${friendlyMessage}`;
+    }
+    if (issue.code === "too_big") {
+      friendlyMessage = `${message} (maximum: ${issue.maximum})`;
+      return `  ${flagName}: ${friendlyMessage}`;
+    }
+    return `  ${flagName}: ${friendlyMessage}`;
+  }).join("\n");
+}
+function safeParseWithErrors(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    errors: formatValidationErrors(result.error)
+  };
+}
+function validatePartial(schema, data) {
+  const partialSchema = schema.partial();
+  return validateCommandOptions(partialSchema, data);
+}
+function readManagedSyncBranchFields(error) {
+  if (error.name !== "ManagedSyncBranchError") {
+    return void 0;
+  }
+  const candidate = error;
+  if (typeof candidate.branch !== "string" || typeof candidate.defaultBranch !== "string") {
+    return void 0;
+  }
+  if (!isSafeGitRef(candidate.branch) || !isSafeGitRef(candidate.defaultBranch)) {
+    return void 0;
+  }
+  return { branch: candidate.branch, defaultBranch: candidate.defaultBranch };
+}
+var PRINTABLE_MANAGED_PATH = /^[\w.][\w./-]*$/;
+function readManagedSyncPathFields(error) {
+  if (error.name !== "ManagedSyncPathError") return void 0;
+  const candidate = error;
+  if (typeof candidate.detail !== "string" || !Array.isArray(candidate.paths)) return void 0;
+  const printable = candidate.paths.every(
+    (value) => typeof value === "string" && PRINTABLE_MANAGED_PATH.test(value) && !value.includes("..")
+  );
+  return printable ? { detail: candidate.detail, paths: candidate.paths } : void 0;
+}
+function sanitizeErrorMessageText(message) {
+  return sanitizeString(
+    message.replace(/\/[^\s:]+/g, "[path]").replace(/\b[A-Za-z]:\\[^\s:]+/g, "[path]").replace(/\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g, "[ip]").replace(/:[0-9]{1,5}\b/g, ":[port]")
+  );
+}
+function createSafeErrorMessage(error, field) {
+  const safeField = sanitizeString(field);
+  const isZodErrorLike = typeof error === "object" && error !== null && "issues" in error && Array.isArray(error.issues);
+  const zodMessage = isZodErrorLike ? error.message : void 0;
+  if (typeof zodMessage === "string" && zodMessage.startsWith("Invalid command options:")) {
+    return `Error in ${safeField}: ${sanitizeErrorMessageText(zodMessage)}`;
+  }
+  if (error instanceof z.ZodError || isZodErrorLike) {
+    return `Validation failed for ${safeField}: Invalid input format`;
+  }
+  if (error instanceof Error) {
+    const typedRefuse = readManagedSyncBranchFields(error);
+    if (typedRefuse) {
+      const branch = sanitizeString(typedRefuse.branch);
+      const defaultBranch = sanitizeString(typedRefuse.defaultBranch);
+      return `Error in ${safeField}: ${describeManagedSyncBranchRefusal(branch, defaultBranch)}`;
+    }
+    const pathRefuse = readManagedSyncPathFields(error);
+    if (pathRefuse) {
+      const paths = pathRefuse.paths.map((managedPath) => sanitizeString(managedPath)).join(", ");
+      const detail = sanitizeString(pathRefuse.detail);
+      return `Error in ${safeField}: ${detail}${paths ? `: ${paths}` : ""}`;
+    }
+    return `Error in ${safeField}: ${sanitizeErrorMessageText(error.message)}`;
+  }
+  return `Unknown error in ${safeField}`;
+}
+var RunCommandOptionsSchema = z.object({
+  engine: OptionalStringSchema,
+  provider: ProviderNameSchema.optional(),
+  variants: PositiveIntegerSchema.optional(),
+  maxConcurrent: ConcurrencySchema.optional(),
+  parallel: ConcurrencySchema.optional(),
+  agent: OptionalStringSchema,
+  explainAgents: BooleanFlagSchema.optional(),
+  model: ModelNameSchema.optional(),
+  compete: BooleanFlagSchema.optional(),
+  variant: VariantArraySchema.optional(),
+  streamResults: BooleanFlagSchema.optional(),
+  auto: BooleanFlagSchema.optional(),
+  noAuto: BooleanFlagSchema.optional(),
+  optimize: OptionalStringSchema,
+  profile: OptionalStringSchema,
+  autoloop: BooleanFlagSchema.optional(),
+  autoloopMaxIterations: PositiveIntegerSchema.optional(),
+  autoloopTimebox: TimeoutMinutesSchema.optional(),
+  autoloopMinProgress: z.number().min(0).max(1).optional(),
+  autoloopJudge: BooleanFlagSchema.optional(),
+  autoloopQualityGates: BooleanFlagSchema.optional(),
+  timeout: TimeoutSchema.optional(),
+  providerRouting: OptionalStringSchema,
+  explainRouting: BooleanFlagSchema.optional(),
+  forceProvider: ProviderNameSchema.optional(),
+  aiJudge: BooleanFlagSchema.optional(),
+  costMetrics: BooleanFlagSchema.optional()
+}).strict();
+var CompeteCommandOptionsSchema = z.object({
+  variant: VariantArraySchema.optional(),
+  localVariants: OptionalStringSchema,
+  timeout: TimeoutSchema.optional(),
+  aiJudge: BooleanFlagSchema.optional(),
+  aiJudgeModel: ModelNameSchema.optional(),
+  aiJudgeVerbose: BooleanFlagSchema.optional(),
+  aiJudgeShowRationale: BooleanFlagSchema.optional(),
+  aiJudgeVerbosity: z.enum(["silent", "minimal", "normal", "detailed", "debug"]).optional(),
+  streamResults: BooleanFlagSchema.optional(),
+  costMetrics: BooleanFlagSchema.optional(),
+  aiJudgeMinScore: z.number().min(0).max(100).optional(),
+  aiJudgeConfidenceThreshold: z.number().min(0).max(1).optional(),
+  aiJudgeStreaming: BooleanFlagSchema.optional(),
+  aiJudgeTelemetry: BooleanFlagSchema.optional(),
+  cleanup: BooleanFlagSchema.optional(),
+  parallel: ConcurrencySchema.optional(),
+  verbose: BooleanFlagSchema.optional(),
+  providerRouting: OptionalStringSchema,
+  saveAs: OptionalStringSchema,
+  prompt: OptionalStringSchema,
+  promptVersion: z.union([
+    PositiveIntegerSchema,
+    z.string().regex(/^[a-z0-9][a-z0-9._-]*$/i, "Invalid prompt version selector")
+  ]).optional()
+}).strict();
+var TaskIdSchema = z.string().min(1, "Task ID cannot be empty").max(100, "Task ID too long (max 100 characters)").regex(
+  /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/,
+  "Task ID contains invalid characters. Only alphanumeric, dots, hyphens, and underscores allowed"
+);
+var PromptIdSchema = z.string().min(1, "Prompt ID cannot be empty").max(100, "Prompt ID too long (max 100 characters)").regex(
+  /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/,
+  "Prompt ID contains invalid characters. Only alphanumeric, dots, hyphens, and underscores allowed"
+);
+var PromptNameSchema = z.string().min(1, "Prompt name cannot be empty").max(200, "Prompt name too long (max 200 characters)").refine((name) => {
+  if (name.includes("\0")) {
+    return false;
+  }
+  const dangerousChars = /[;&|`$<>(){}[\]!*?~\n\r]/;
+  return !dangerousChars.test(name);
+}, "Prompt name contains dangerous characters");
+var PromptCategorySchema = z.string().min(1, "Category cannot be empty").max(50, "Category too long (max 50 characters)").regex(/^[a-zA-Z0-9][a-zA-Z0-9._\-\s]*$/, "Category contains invalid characters");
+var PromptContentSchema = z.string().min(1, "Prompt content cannot be empty").max(5e4, "Prompt content too long (max 50000 characters)").refine((content) => {
+  if (content.includes("\0")) {
+    return false;
+  }
+  return true;
+}, "Prompt content contains null bytes");
+var PromptVersionIdSchema = z.string().regex(/^v\d+(\.\d+)?$/, "Version ID must be in format v1 or v1.0").or(PositiveIntegerSchema.transform((v) => `v${v}`));
+var PromptFormatSchema = z.enum(["table", "json", "yaml", "markdown"]).describe("Invalid format. Must be one of: table, json, yaml, markdown");
+var PromptSortFieldSchema = z.enum([
+  "name",
+  "executions",
+  "quality",
+  "updated",
+  "created",
+  "category",
+  "version",
+  "cost",
+  "duration",
+  "success_rate"
+]).describe("Invalid sort field");
+var PromptOptimizationLevelSchema = z.enum(["light", "moderate", "aggressive"]).describe("Invalid optimization level. Must be one of: light, moderate, aggressive");
+function coerceInt(value) {
+  return Number(value);
+}
+function coerceFloat(value) {
+  return Number(value);
+}
+var CLIValidationError = class extends Error {
+  constructor(message, field, code = "CLI_VALIDATION_ERROR") {
+    super(message);
+    this.field = field;
+    this.code = code;
+    this.name = "CLIValidationError";
+  }
+  field;
+  code;
+};
+var cli_validation_default = {
+  // Schemas
+  ProviderNameSchema,
+  ModelNameSchema,
+  FilePathSchema,
+  ExistingFilePathSchema,
+  DirectoryPathSchema,
+  PositiveIntegerSchema,
+  PortNumberSchema,
+  TimeoutSchema,
+  TimeoutMinutesSchema,
+  ConcurrencySchema,
+  MAX_TASK_DESCRIPTION_CHARS,
+  TaskDescriptionSchema,
+  TaskIdSchema,
+  CommandNameSchema,
+  EnvVarNameSchema,
+  BooleanFlagSchema,
+  JsonStringSchema,
+  VariantSchema,
+  ReasoningEffortSchema,
+  StringArraySchema,
+  VariantArraySchema,
+  OptionalStringSchema,
+  OptionalPositiveIntegerSchema,
+  RunCommandOptionsSchema,
+  CompeteCommandOptionsSchema,
+  // Prompt-specific schemas
+  PromptIdSchema,
+  PromptNameSchema,
+  PromptCategorySchema,
+  PromptContentSchema,
+  PromptVersionIdSchema,
+  PromptFormatSchema,
+  PromptSortFieldSchema,
+  PromptOptimizationLevelSchema,
+  // Helper functions
+  validateCommandOptions,
+  formatValidationErrors,
+  safeParseWithErrors,
+  validatePartial,
+  createSafeErrorMessage,
+  coerceInt,
+  coerceFloat,
+  // Error class
+  CLIValidationError
+};
+
+export {
+  ENABLED_PROVIDER_IDS,
+  ManagedSyncBranchError,
+  describeManagedSyncBranchRefusal,
+  formatManagedSyncBranchError,
+  isManagedSyncBranchError,
+  formatHomePathRefusal,
+  findEmbeddedHomePaths,
+  findEmbeddedHomePathRefusal,
+  VALID_PROVIDER_NAMES,
+  formatValidProviderNames,
+  ProviderNameSchema,
+  ModelNameSchema,
+  parseProviderFirstTarget,
+  parseSynthesisModelTarget,
+  SynthesisModelTargetSchema,
+  FilePathSchema,
+  ExistingFilePathSchema,
+  DirectoryPathSchema,
+  PositiveIntegerSchema,
+  PortNumberSchema,
+  TimeoutSchema,
+  TimeoutMinutesSchema,
+  ConcurrencySchema,
+  MAX_TASK_DESCRIPTION_CHARS,
+  TaskDescriptionSchema,
+  CommandNameSchema,
+  EnvVarNameSchema,
+  BooleanFlagSchema,
+  JsonStringSchema,
+  VariantSchema,
+  ReasoningEffortSchema,
+  StringArraySchema,
+  VariantArraySchema,
+  OptionalStringSchema,
+  OptionalPositiveIntegerSchema,
+  validateCommandOptions,
+  formatValidationErrors,
+  safeParseWithErrors,
+  validatePartial,
+  createSafeErrorMessage,
+  RunCommandOptionsSchema,
+  CompeteCommandOptionsSchema,
+  TaskIdSchema,
+  PromptIdSchema,
+  PromptNameSchema,
+  PromptCategorySchema,
+  PromptContentSchema,
+  PromptVersionIdSchema,
+  PromptFormatSchema,
+  PromptSortFieldSchema,
+  PromptOptimizationLevelSchema,
+  coerceInt,
+  coerceFloat,
+  CLIValidationError,
+  cli_validation_default
+};
+//# sourceMappingURL=chunk-I7SCBHJN.js.map