@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-QGJDMEOV.js

@@ -0,0 +1,34 @@
+import {
+  POETIC_TELEMETRY_SQLITE_BUSY_TIMEOUT_MS,
+  POETIC_TELEMETRY_SQLITE_CACHE_SIZE,
+  POETIC_TELEMETRY_SQLITE_MMAP_SIZE,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/telemetry/sqlite-timeout-config.ts
+function getSqliteBusyTimeoutMs() {
+  return readEnv(POETIC_TELEMETRY_SQLITE_BUSY_TIMEOUT_MS).value ?? 3e4;
+}
+function getSqliteCacheSize() {
+  return readEnv(POETIC_TELEMETRY_SQLITE_CACHE_SIZE).value ?? -2e4;
+}
+function getSqliteMmapSize() {
+  return readEnv(POETIC_TELEMETRY_SQLITE_MMAP_SIZE).value ?? 268435456;
+}
+function applySqlitePragmas(db, options) {
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma(`busy_timeout = ${getSqliteBusyTimeoutMs()}`);
+  db.pragma(`cache_size = ${getSqliteCacheSize()}`);
+  db.pragma("temp_store = MEMORY");
+  db.pragma(`mmap_size = ${getSqliteMmapSize()}`);
+  if (options?.foreignKeys === true) {
+    db.pragma("foreign_keys = ON");
+  }
+}
+
+export {
+  getSqliteBusyTimeoutMs,
+  applySqlitePragmas
+};
+//# sourceMappingURL=chunk-QGJDMEOV.js.map

package/dist/chunk-QJYIHVXT.js

@@ -0,0 +1,100 @@
+import {
+  parseGitStatusPaths
+} from "./chunk-MN6PL4AN.js";
+import {
+  shouldExcludeFile
+} from "./chunk-NS33V3IM.js";
+import {
+  ANSI_ESCAPE_SEQUENCE
+} from "./chunk-SQZRPY23.js";
+import {
+  isDebugMode
+} from "./chunk-EJGCZGUF.js";
+
+// src/core/providers/shared/pure-cli-runner.ts
+async function getGitHead(workingDir) {
+  try {
+    const { execa } = await import("execa");
+    const result = await execa("git", ["rev-parse", "HEAD"], { cwd: workingDir });
+    const head = result.stdout.trim();
+    return head.length > 0 ? head : void 0;
+  } catch (err) {
+    if (isDebugMode()) {
+      console.warn(`[PureCliRunner] Unable to resolve HEAD in ${workingDir}:`, err);
+    }
+    return void 0;
+  }
+}
+async function getGitBranch(workingDir) {
+  try {
+    const { execa } = await import("execa");
+    const result = await execa("git", ["branch", "--show-current"], { cwd: workingDir });
+    const branch = result.stdout.trim();
+    return branch.length > 0 ? branch : void 0;
+  } catch (err) {
+    if (isDebugMode()) {
+      console.warn(`[PureCliRunner] Unable to resolve branch in ${workingDir}:`, err);
+    }
+    return void 0;
+  }
+}
+function parseNameOnlyLines(output) {
+  return output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function isTrackedChangedFile(file) {
+  return file.length > 0 && !file.startsWith("node_modules") && file !== ".claudeignore" && !shouldExcludeFile(file);
+}
+async function getGitStatusPaths(workingDir) {
+  try {
+    const { execa } = await import("execa");
+    const status = await execa("git", ["status", "--porcelain", "--untracked-files=all"], {
+      cwd: workingDir,
+      reject: false
+    });
+    const statusPaths = status.stdout.trim().length > 0 ? parseGitStatusPaths(status.stdout) : [];
+    return new Set(statusPaths.filter(isTrackedChangedFile));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Unable to read git status in ${workingDir}: ${message}`);
+  }
+}
+async function detectGitChangedFiles(workingDir, baseline) {
+  const { execa } = await import("execa");
+  const files = /* @__PURE__ */ new Set();
+  const baselineHead = typeof baseline === "string" ? baseline : baseline?.baselineHead;
+  const baselineStatusPaths = typeof baseline === "string" ? /* @__PURE__ */ new Set() : new Set(baseline?.baselineStatusPaths ?? []);
+  const currentHead = await getGitHead(workingDir);
+  if (baselineHead && currentHead && baselineHead !== currentHead) {
+    try {
+      const diff = await execa("git", ["diff", "--name-only", baselineHead, currentHead], {
+        cwd: workingDir,
+        reject: false
+      });
+      for (const file of parseNameOnlyLines(diff.stdout)) {
+        if (isTrackedChangedFile(file)) {
+          files.add(file);
+        }
+      }
+    } catch {
+    }
+  }
+  const statusPaths = await getGitStatusPaths(workingDir);
+  statusPaths.forEach((file) => {
+    if (!baselineStatusPaths.has(file)) {
+      files.add(file);
+    }
+  });
+  return Array.from(files);
+}
+function stripAnsiSequences(str) {
+  return str.replace(ANSI_ESCAPE_SEQUENCE, "").replace(/\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)/g, "").replace(/\x1BP(?:[^\x1B]|\x1B(?!\\))*\x1B\\/g, "");
+}
+
+export {
+  getGitHead,
+  getGitBranch,
+  getGitStatusPaths,
+  detectGitChangedFiles,
+  stripAnsiSequences
+};
+//# sourceMappingURL=chunk-QJYIHVXT.js.map

package/dist/chunk-QNOB37UH.js

@@ -0,0 +1,58 @@
+// src/core/verification/verdict-label.ts
+var EXPLICIT_FAILURE_STATUSES = /* @__PURE__ */ new Set([
+  "failed",
+  "error",
+  "timeout",
+  // Synthesis/gate vocabularies that mean a real failure.
+  "rejected"
+]);
+var EXPLICIT_UNAVAILABLE_STATUSES = /* @__PURE__ */ new Set([
+  "not_run",
+  "skipped",
+  "unavailable",
+  "unsupported",
+  "no_data",
+  "no-data"
+]);
+function gateStatusToDisplayVerdict(status) {
+  const normalized = typeof status === "string" ? status.trim().toLowerCase() : "";
+  if (normalized === "passed") return "passed";
+  if (EXPLICIT_FAILURE_STATUSES.has(normalized)) return "failed";
+  if (EXPLICIT_UNAVAILABLE_STATUSES.has(normalized)) return "unavailable";
+  return "unavailable";
+}
+function deriveTestVerificationDisplay(input) {
+  const rawVerdict = gateStatusToDisplayVerdict(input.rawTestStatus);
+  if (rawVerdict === "failed") return "failed";
+  if (typeof input.exitCode === "number" && input.exitCode !== 0) return "failed";
+  if (typeof input.failedTests === "number" && input.failedTests > 0) return "failed";
+  const derivedVerdict = gateStatusToDisplayVerdict(input.testStatus);
+  if (derivedVerdict === "failed") return "failed";
+  if (derivedVerdict === "passed" && rawVerdict !== "unavailable") {
+    return "passed";
+  }
+  if (derivedVerdict === "passed" && input.rawTestStatus == null) {
+    return "passed";
+  }
+  if (derivedVerdict === "passed" && rawVerdict === "passed") {
+    return "passed";
+  }
+  return derivedVerdict === "passed" ? "unavailable" : derivedVerdict;
+}
+function formatVerificationDisplayVerdict(verdict) {
+  switch (verdict) {
+    case "passed":
+      return "passed";
+    case "failed":
+      return "failed";
+    case "unavailable":
+      return "unavailable";
+  }
+}
+
+export {
+  gateStatusToDisplayVerdict,
+  deriveTestVerificationDisplay,
+  formatVerificationDisplayVerdict
+};
+//# sourceMappingURL=chunk-QNOB37UH.js.map

package/dist/chunk-QOCOVLUH.js

@@ -0,0 +1,462 @@
+import {
+  ENABLED_PROVIDER_IDS
+} from "./chunk-2VSQMRCB.js";
+import {
+  isValidCommandName,
+  isValidPath
+} from "./chunk-3G6FZCRF.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+import {
+  sanitizeString
+} from "./chunk-LPITVM7M.js";
+
+// src/utils/cli-validation.ts
+import fs from "fs";
+import * as path from "path";
+import { z } from "zod";
+
+// src/core/git/ref-safety.ts
+var SAFE_GIT_REMOTE_PATTERN = /^[A-Za-z0-9._-]+$/u;
+var SAFE_GIT_REF_PATTERN = /^[A-Za-z0-9_.~^/@{}-]+$/u;
+function isSafeGitRemote(remote) {
+  const trimmed = remote.trim();
+  return trimmed.length > 0 && !trimmed.startsWith("-") && SAFE_GIT_REMOTE_PATTERN.test(trimmed);
+}
+function isSafeGitRef(ref) {
+  const trimmed = ref.trim();
+  return trimmed.length > 0 && !trimmed.startsWith("-") && SAFE_GIT_REF_PATTERN.test(trimmed);
+}
+function isSafeGitRemoteAndRef(remote, ref) {
+  return isSafeGitRemote(remote) && isSafeGitRef(ref);
+}
+
+// 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"
+);
+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 = path.posix.normalize(filePath.replaceAll("\\", "/"));
+  if (normalizedPosix === ".." || normalizedPosix.startsWith("../") || normalizedPosix.includes("/../")) {
+    return false;
+  }
+  const cwd = getSafeCwd();
+  if (!path.isAbsolute(filePath) && !cwd) {
+    return false;
+  }
+  if (cwd && !path.isAbsolute(filePath)) {
+    let resolved;
+    try {
+      resolved = path.resolve(filePath);
+    } catch {
+      return false;
+    }
+    const relativeToCwd = path.relative(cwd, resolved);
+    if (relativeToCwd === ".." || relativeToCwd.startsWith(`..${path.sep}`)) {
+      return false;
+    }
+  }
+  return true;
+}, "Path traversal detected - file path attempts to access parent directories");
+var ExistingFilePathSchema = FilePathSchema.refine(
+  (filePath) => {
+    try {
+      const resolvedPath = path.resolve(filePath);
+      return fs.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 = path.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: provider:model:strategy:mode, provider:strategy:mode, or provider:strategy (optionally prefixed with handle=)"
+);
+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 errors = formatValidationErrors(result.error);
+    throw new Error(`Invalid command options:
+${errors}`);
+  }
+  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 path2 = issue.path.length > 0 ? issue.path.join(".") : "input";
+    const message = issue.message;
+    const flagName = path2 === "input" ? "input" : path2.includes(".") ? path2.split(".").map((p) => camelToFlag(p)).join(" ") : camelToFlag(path2);
+    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 };
+}
+function createSafeErrorMessage(error, field) {
+  const safeField = sanitizeString(field);
+  const isZodErrorLike = typeof error === "object" && error !== null && "issues" in error && Array.isArray(error.issues);
+  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}: Managed auto-sync refuses branch ${branch}; switch to ${defaultBranch} or use a dedicated backlog sync branch`;
+    }
+    const sanitized = sanitizeString(
+      error.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]")
+    );
+    return `Error in ${safeField}: ${sanitized}`;
+  }
+  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(),
+  earlyExit: BooleanFlagSchema.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(),
+  circuitBreaker: BooleanFlagSchema.optional(),
+  circuitBreakerThreshold: OptionalStringSchema,
+  circuitBreakerTimeout: OptionalStringSchema,
+  aiJudge: BooleanFlagSchema.optional(),
+  costMetrics: BooleanFlagSchema.optional(),
+  plan: BooleanFlagSchema.optional(),
+  planOutput: z.enum(["text", "json"]).optional(),
+  planResumeContext: z.unknown().optional(),
+  geminiAutoTools: BooleanFlagSchema.optional(),
+  geminiAllowTools: StringArraySchema.optional(),
+  geminiBlockTools: StringArraySchema.optional(),
+  geminiToolPolicy: OptionalStringSchema
+}).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(),
+  aiJudgeCriteriaWeights: OptionalStringSchema,
+  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,
+  explainRouting: BooleanFlagSchema.optional(),
+  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 {
+  isSafeGitRemoteAndRef,
+  VALID_PROVIDER_NAMES,
+  formatValidProviderNames,
+  ProviderNameSchema,
+  ModelNameSchema,
+  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-QOCOVLUH.js.map