@poetic-ai/poetic 1.42.0

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

package/dist/chunk-QTCJ5CC5.js

@@ -0,0 +1,172 @@
+import {
+  resolveReasoningEffort
+} from "./chunk-ON3G73BU.js";
+import {
+  getProviderConfig
+} from "./chunk-AT4TNPWW.js";
+import {
+  debugLog,
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/core/providers/shared/output-drift.ts
+var reported = /* @__PURE__ */ new Set();
+function reportOutputDrift(event) {
+  const key = `${event.provider}:${event.field}`;
+  if (reported.has(key)) return;
+  reported.add(key);
+  const warningSeverity = event.severity === "parse_fallback" ? "WARN" /* WARN */ : "INFO" /* INFO */;
+  emitWarning(
+    "PR-006",
+    {
+      provider: event.provider,
+      subsystem: "provider-output-drift",
+      executionPhase: "execution"
+    },
+    {
+      severity: warningSeverity,
+      metadata: {
+        provider: event.provider,
+        severity: event.severity,
+        field: event.field,
+        detail: event.detail,
+        ...event.outputShapeTag !== void 0 ? { outputShapeTag: event.outputShapeTag } : {}
+      }
+    }
+  );
+}
+
+// src/core/providers/settings-resolver.ts
+var TEMPERATURE_PRECISION = 0.1;
+var TEMPERATURE_DETERMINISTIC = 0;
+var TEMPERATURE_CREATIVE = 0.5;
+var TEMPERATURE_BALANCED = 0.3;
+var TEMPERATURE_ANALYSIS = 0.2;
+var TOP_P_FOCUSED = 0.85;
+var TOP_P_MODERATE = 0.9;
+var TOP_P_BALANCED = 0.92;
+var TOP_P_DIVERSE = 0.95;
+var FALLBACK_SETTINGS_BY_TASK_TYPE = {
+  // Precision tasks: Low temperature, focused sampling
+  bug_fix: { temperature: TEMPERATURE_PRECISION, topP: TOP_P_FOCUSED },
+  security: { temperature: TEMPERATURE_DETERMINISTIC, topP: TOP_P_FOCUSED },
+  test: { temperature: TEMPERATURE_PRECISION, topP: TOP_P_FOCUSED },
+  // Documentation: High temperature, diverse sampling (creative writing)
+  documentation: { temperature: TEMPERATURE_CREATIVE, topP: TOP_P_DIVERSE },
+  // Balanced tasks: Medium temperature, balanced sampling
+  feature: { temperature: TEMPERATURE_BALANCED, topP: TOP_P_BALANCED },
+  refactor: { temperature: TEMPERATURE_BALANCED, topP: TOP_P_BALANCED },
+  migration: { temperature: TEMPERATURE_BALANCED, topP: TOP_P_BALANCED },
+  maintenance: { temperature: TEMPERATURE_BALANCED, topP: TOP_P_BALANCED },
+  // Analysis tasks: Low-medium temperature, thorough sampling
+  analysis: { temperature: TEMPERATURE_ANALYSIS, topP: TOP_P_MODERATE },
+  review: { temperature: TEMPERATURE_ANALYSIS, topP: TOP_P_MODERATE },
+  // Performance optimization: Medium temperature (exploration needed)
+  performance: { temperature: TEMPERATURE_BALANCED, topP: TOP_P_BALANCED },
+  // Default/general: Conservative balanced settings
+  general: { temperature: TEMPERATURE_BALANCED, topP: TOP_P_DIVERSE }
+};
+var DEFAULT_SETTINGS = {
+  temperature: TEMPERATURE_BALANCED,
+  topP: TOP_P_DIVERSE
+};
+var FALLBACK_REASONING_BY_TASK_TYPE = {
+  bug_fix: "high",
+  security: "xhigh",
+  test: "medium",
+  documentation: "low",
+  feature: "medium",
+  refactor: "medium",
+  migration: "medium",
+  maintenance: "low",
+  analysis: "high",
+  review: "xhigh",
+  performance: "high",
+  general: "medium"
+};
+var SAMPLING_SETTINGS_PROVIDERS = /* @__PURE__ */ new Set(["gemini"]);
+var REASONING_SETTINGS_PROVIDERS = /* @__PURE__ */ new Set(["codex", "opencode", "claude"]);
+function normalizeReasoningEffort(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase().replace(/[_\s]/g, "-");
+  if (normalized === "low" || normalized === "medium" || normalized === "high") {
+    return normalized;
+  }
+  if (normalized === "xhigh" || normalized === "x-high" || normalized === "extra-high") {
+    return "xhigh";
+  }
+  if (normalized === "max") return "max";
+  return void 0;
+}
+function parseTaskSetting(settings) {
+  const result = {};
+  if (typeof settings.temperature === "number") {
+    result.temperature = settings.temperature;
+  }
+  if (typeof settings.top_p === "number") {
+    result.topP = settings.top_p;
+  }
+  if (typeof settings.top_k === "number") {
+    result.topK = settings.top_k;
+  }
+  const reasoningEffort = normalizeReasoningEffort(settings.reasoning_effort);
+  if (reasoningEffort) {
+    result.reasoningEffort = reasoningEffort;
+  }
+  if (typeof settings.thinking_budget === "number") {
+    result.thinkingBudget = settings.thinking_budget;
+  }
+  return result;
+}
+function resolveSettings(taskType, provider) {
+  if (!SAMPLING_SETTINGS_PROVIDERS.has(provider) && !REASONING_SETTINGS_PROVIDERS.has(provider)) {
+    return {};
+  }
+  try {
+    const providerConfig = getProviderConfig(provider);
+    const taskSettings = providerConfig.task_settings;
+    if (taskSettings && taskType && taskSettings[taskType]) {
+      const settings = taskSettings[taskType];
+      if (!settings) {
+        debugLog(`[SettingsResolver] Empty settings object for ${taskType}`);
+      } else {
+        const result = parseTaskSetting(settings);
+        debugLog(`[SettingsResolver] Loaded settings for ${taskType} from YAML config`);
+        return result;
+      }
+    }
+    if (taskSettings?.default) {
+      const settings = taskSettings.default;
+      if (!settings) {
+        debugLog("[SettingsResolver] Empty default settings object");
+      } else {
+        const result = parseTaskSetting(settings);
+        debugLog("[SettingsResolver] Using default settings from YAML config");
+        return result;
+      }
+    }
+  } catch (error) {
+    debugLog(`[SettingsResolver] Failed to load config for ${provider}: ${error}`);
+  }
+  if (REASONING_SETTINGS_PROVIDERS.has(provider)) {
+    const taskEffort = (taskType && FALLBACK_REASONING_BY_TASK_TYPE[taskType]) ?? "medium";
+    const resolution = resolveReasoningEffort(provider, taskEffort, false);
+    const effectiveEffort = resolution.nativeParam ?? resolution.resolvedLevel;
+    debugLog(
+      `[SettingsResolver] Reasoning effort for ${provider}: requested="${taskEffort}", effective="${effectiveEffort}", outcome="${resolution.outcome}" (taskType=${taskType ?? "unknown"})`
+    );
+    return { reasoningEffort: effectiveEffort };
+  }
+  if (taskType && FALLBACK_SETTINGS_BY_TASK_TYPE[taskType]) {
+    debugLog(`[SettingsResolver] Using fallback settings for task type: ${taskType}`);
+    return FALLBACK_SETTINGS_BY_TASK_TYPE[taskType];
+  }
+  debugLog(`[SettingsResolver] Using default settings (task type: ${taskType ?? "unknown"})`);
+  return DEFAULT_SETTINGS;
+}
+
+export {
+  reportOutputDrift,
+  resolveSettings
+};
+//# sourceMappingURL=chunk-QTCJ5CC5.js.map