@poetic-ai/poetic 1.42.0

package/dist/chunk-CUSRN6RJ.js

@@ -0,0 +1,632 @@
+import {
+  findProviderCollisions
+} from "./chunk-4GSN5O5J.js";
+import {
+  validateRolesConfig
+} from "./chunk-YB3JD4E6.js";
+import {
+  checkDefaultProviderEnablement,
+  loadProviderRegistryForCwd
+} from "./chunk-XPU2XADL.js";
+import {
+  mutateUserState
+} from "./chunk-SZ7DL357.js";
+import {
+  KNOWN_POETIC_CONFIG_ROOTS,
+  PoeticConfigSchema,
+  SystemConfigSchema,
+  UserPreferencesSchema
+} from "./chunk-G36W2T2S.js";
+import {
+  isInvalidExplicitConfigError
+} from "./chunk-AT4TNPWW.js";
+
+// src/core/config/first-time-setup-state.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readRawSetup(preferences) {
+  if (!preferences || !isRecord(preferences)) return {};
+  return isRecord(preferences.firstTimeSetup) ? preferences.firstTimeSetup : {};
+}
+function legacyDefaultsInitialized(preferences) {
+  if (!preferences || !isRecord(preferences)) return false;
+  const topLevel = readRawSetup(preferences);
+  if (topLevel.version !== 2 && topLevel.completed === true) return true;
+  const preferencesRoot = isRecord(preferences.preferences) ? preferences.preferences : void 0;
+  const cursor = preferencesRoot && isRecord(preferencesRoot.cursor) ? preferencesRoot.cursor : null;
+  const cursorSetup = cursor && isRecord(cursor.firstTimeSetup) ? cursor.firstTimeSetup : null;
+  return cursorSetup?.completed === true;
+}
+function readFirstTimeSetupState(preferences) {
+  const raw = readRawSetup(preferences);
+  if (raw.version === 2) {
+    const readyProviderIds = Array.isArray(raw.readyProviderIds) ? [
+      ...new Set(
+        raw.readyProviderIds.filter(
+          (id) => typeof id === "string" && id.length > 0
+        )
+      )
+    ] : [];
+    const defaultsInitialized = raw.defaultsInitialized === true;
+    const completed = defaultsInitialized && raw.completed === true && readyProviderIds.length > 0;
+    return {
+      version: 2,
+      defaultsInitialized,
+      ...typeof raw.defaultsInitializedAt === "string" ? { defaultsInitializedAt: raw.defaultsInitializedAt } : {},
+      completed,
+      ...completed && typeof raw.completedAt === "string" ? { completedAt: raw.completedAt } : {},
+      readyProviderIds
+    };
+  }
+  return {
+    version: 2,
+    defaultsInitialized: legacyDefaultsInitialized(preferences),
+    ...typeof raw.timestamp === "string" ? { defaultsInitializedAt: raw.timestamp } : {},
+    completed: false,
+    readyProviderIds: []
+  };
+}
+function isFirstTimeDefaultsInitialized(preferences) {
+  return readFirstTimeSetupState(preferences).defaultsInitialized;
+}
+function isFirstTimeSetupCompleted(preferences) {
+  return readFirstTimeSetupState(preferences).completed;
+}
+function markFirstTimeDefaultsInitialized(options = {}) {
+  return mutateUserState(
+    (state) => {
+      const existing = readFirstTimeSetupState(state);
+      const timestamp = options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+      const next = {
+        ...existing,
+        version: 2,
+        defaultsInitialized: true,
+        defaultsInitializedAt: existing.defaultsInitializedAt ?? timestamp
+      };
+      state.firstTimeSetup = next;
+      return next;
+    },
+    options.filePath ? { filePath: options.filePath } : {}
+  );
+}
+function markFirstTimeSetupCompleted(providerIds, options = {}) {
+  const normalized = [...new Set(providerIds.map((id) => id.trim()).filter(Boolean))];
+  if (normalized.length === 0) {
+    throw new Error("First-run completion requires at least one ready provider");
+  }
+  return mutateUserState(
+    (state) => {
+      const existing = readFirstTimeSetupState(state);
+      if (!existing.defaultsInitialized) {
+        throw new Error(
+          "First-run completion cannot be recorded before required user defaults are initialized"
+        );
+      }
+      const timestamp = options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+      const next = {
+        version: 2,
+        defaultsInitialized: existing.defaultsInitialized,
+        ...existing.defaultsInitializedAt ? { defaultsInitializedAt: existing.defaultsInitializedAt } : {},
+        completed: true,
+        completedAt: existing.completedAt ?? timestamp,
+        readyProviderIds: normalized
+      };
+      state.firstTimeSetup = next;
+      return next;
+    },
+    options.filePath ? { filePath: options.filePath } : {}
+  );
+}
+
+// src/core/config/config-validator.ts
+function validatePoeticConfig(config, options = {}) {
+  const {
+    strict: _strict = false,
+    includeWarnings = true,
+    includeSuggestions: _includeSuggestions = true,
+    cwd = process.cwd()
+  } = options;
+  const errors = [];
+  const warnings = [];
+  const suggestions = [];
+  errors.push(...detectUnknownRootKeys(config));
+  const schemaResult = PoeticConfigSchema.safeParse(config);
+  if (!schemaResult.success) {
+    for (const zodError of schemaResult.error.issues) {
+      errors.push(parseZodError(zodError));
+    }
+  }
+  if (schemaResult.success) {
+    const validConfig = schemaResult.data;
+    validateCustomRules(validConfig, errors, warnings, suggestions, cwd);
+  }
+  if (schemaResult.success && includeWarnings) {
+    validateBusinessLogic(schemaResult.data, warnings, suggestions);
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings,
+    suggestions,
+    autoFixed: false
+  };
+}
+function detectUnknownRootKeys(config) {
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    return [];
+  }
+  const knownRoots = new Set(KNOWN_POETIC_CONFIG_ROOTS);
+  const unknownKeys = Object.keys(config).filter((key) => !knownRoots.has(key));
+  if (unknownKeys.length === 0) {
+    return [];
+  }
+  return [
+    {
+      code: "unrecognized_keys",
+      message: `Unrecognized configuration root key(s): ${unknownKeys.join(", ")}`,
+      path: [],
+      fixable: true,
+      fixSuggestion: `Remove unrecognized properties: ${unknownKeys.join(", ")}`
+    }
+  ];
+}
+function validateUserPreferences(preferences) {
+  const errors = [];
+  const warnings = [];
+  const suggestions = [];
+  const schemaResult = UserPreferencesSchema.safeParse(preferences);
+  if (!schemaResult.success) {
+    const zodErrors = schemaResult.error.issues;
+    for (const zodError of zodErrors) {
+      errors.push(parseZodError(zodError));
+    }
+  }
+  if (schemaResult.success) {
+    const validPrefs = schemaResult.data;
+    validateUserPreferencesLogic(validPrefs, errors, warnings, suggestions);
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings,
+    suggestions,
+    autoFixed: false
+  };
+}
+function validateSystemConfig(config) {
+  const errors = [];
+  const warnings = [];
+  const suggestions = [];
+  const schemaResult = SystemConfigSchema.safeParse(config);
+  if (!schemaResult.success) {
+    const zodErrors = schemaResult.error.issues;
+    for (const zodError of zodErrors) {
+      errors.push(parseZodError(zodError));
+    }
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings,
+    suggestions,
+    autoFixed: false
+  };
+}
+function parseZodError(zodError) {
+  const path = zodError.path.map(String);
+  const message = zodError.message;
+  let fixable = false;
+  let fixSuggestion;
+  let expected;
+  let received;
+  switch (zodError.code) {
+    case "invalid_type":
+      fixable = true;
+      if ("expected" in zodError) {
+        expected = String(zodError.expected);
+      }
+      if ("received" in zodError) {
+        received = String(zodError.received);
+      }
+      if (expected === "string" && received === "undefined") {
+        fixSuggestion = `Add a string value for '${path.join(".")}' or remove the property`;
+      } else if (expected === "boolean") {
+        fixSuggestion = `Use true or false for '${path.join(".")}'`;
+      }
+      break;
+    case "invalid_format": {
+      fixable = true;
+      const zodErrorWithOptions = zodError;
+      const options = zodErrorWithOptions.options?.join(", ") || "unknown options";
+      fixSuggestion = `Use one of: ${options}`;
+      break;
+    }
+    case "invalid_value": {
+      fixable = true;
+      const zodErrorWithExpected = zodError;
+      fixSuggestion = `Use the exact value: ${zodErrorWithExpected.expected}`;
+      break;
+    }
+    case "unrecognized_keys": {
+      fixable = true;
+      const zodErrorWithKeys = zodError;
+      fixSuggestion = `Remove unrecognized properties: ${zodErrorWithKeys.keys?.join(", ")}`;
+      break;
+    }
+  }
+  return {
+    code: zodError.code,
+    message,
+    path,
+    expected,
+    received,
+    fixable,
+    fixSuggestion
+  };
+}
+function hasEnabledProperty(value) {
+  return typeof value === "object" && value !== null && "enabled" in value;
+}
+var PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+function normalizeProviderId(value) {
+  const provider = value?.toLowerCase().trim();
+  return provider && PROVIDER_ID_PATTERN.test(provider) ? provider : null;
+}
+function enabledProvidersFromConfig(config) {
+  if (!config.providers) {
+    return null;
+  }
+  return Object.entries(config.providers).filter(([_, provider]) => hasEnabledProperty(provider) && provider.enabled).map(([name]) => name);
+}
+function providerEnabledFromConfig(config, provider) {
+  const providers = config.providers;
+  const providerConfig = providers?.[provider];
+  return hasEnabledProperty(providerConfig) ? providerConfig.enabled : void 0;
+}
+function addDisabledProviderError(provider, path, errors, enabledProviders) {
+  errors.push({
+    code: "invalid_default_provider",
+    message: `Default provider '${provider}' is not enabled`,
+    path,
+    fixable: true,
+    fixSuggestion: `Either enable ${provider} provider or change the default provider to one of: ${enabledProviders.join(", ") || "(none)"}`
+  });
+}
+function validateProviderEnabled(providerValue, path, config, errors, cwd) {
+  const provider = normalizeProviderId(providerValue);
+  if (!provider) {
+    if (providerValue !== void 0 && providerValue.trim() !== "") {
+      errors.push({
+        code: "invalid_provider_format",
+        message: `Provider '${providerValue}' has an invalid format`,
+        path,
+        fixable: false,
+        fixSuggestion: "Use lowercase letters, digits, underscores, or hyphens"
+      });
+    }
+    return;
+  }
+  if (providerEnabledFromConfig(config, provider) === false) {
+    addDisabledProviderError(provider, path, errors, enabledProvidersFromConfig(config) ?? []);
+    return;
+  }
+  try {
+    const check = checkDefaultProviderEnablement(provider, cwd);
+    if (!check.providerKnown) {
+      errors.push({
+        code: "unknown_defaults_provider",
+        message: `Default provider '${provider}' is not a known provider`,
+        path,
+        fixable: false,
+        fixSuggestion: `Use one of: ${check.knownProviders.join(", ")}`
+      });
+      return;
+    }
+    if (!check.providerEnabled) {
+      addDisabledProviderError(provider, path, errors, check.enabledProviders);
+    }
+  } catch (error) {
+    if (isInvalidExplicitConfigError(error)) {
+      throw error;
+    }
+    errors.push({
+      code: "provider_registry_unavailable",
+      message: `Could not validate default provider '${provider}' against providers.yaml: ${error instanceof Error ? error.message : String(error)}`,
+      path,
+      fixable: false
+    });
+  }
+}
+function validateCustomRules(config, errors, warnings, _suggestions, cwd) {
+  if (config.providers) {
+    const enabledProviders = enabledProvidersFromConfig(config) ?? [];
+    if (enabledProviders.length === 0) {
+      errors.push({
+        code: "no_enabled_providers",
+        message: "At least one provider must be enabled",
+        path: ["providers"],
+        fixable: true,
+        fixSuggestion: "Set at least one provider.enabled to true"
+      });
+    }
+    if (!config.defaults?.provider) {
+      const legacyProvider = normalizeProviderId(config.defaultProvider);
+      if (legacyProvider && providerEnabledFromConfig(config, legacyProvider) === false) {
+        addDisabledProviderError(legacyProvider, ["defaultProvider"], errors, enabledProviders);
+      }
+    }
+  }
+  validateProviderEnabled(config.defaults?.provider, ["defaults", "provider"], config, errors, cwd);
+  if (!config.defaults?.provider) {
+    validateProviderEnabled(config.defaultProvider, ["defaultProvider"], config, errors, cwd);
+  }
+  if (config.defaultProvider && config.defaults?.provider) {
+    const legacyProvider = normalizeProviderId(config.defaultProvider);
+    const canonicalProvider = normalizeProviderId(config.defaults.provider);
+    if (legacyProvider && canonicalProvider && legacyProvider !== canonicalProvider) {
+      warnings.push({
+        code: "default_provider_source_drift",
+        message: `defaultProvider '${legacyProvider}' differs from defaults.provider '${canonicalProvider}'; defaults.provider is the canonical runtime default`,
+        path: ["defaultProvider"],
+        recommendation: "Remove defaultProvider or set it to match defaults.provider"
+      });
+    }
+  }
+  let knownProviderIds = [];
+  try {
+    knownProviderIds = Object.keys(loadProviderRegistryForCwd(cwd).providers);
+  } catch {
+    knownProviderIds = [];
+  }
+  if (knownProviderIds.length > 0) {
+    const defaultsProvider = config.defaults?.provider;
+    if (defaultsProvider && !knownProviderIds.includes(defaultsProvider)) {
+      errors.push({
+        code: "unknown_defaults_provider",
+        message: `defaults.provider '${defaultsProvider}' is not a known provider`,
+        path: ["defaults", "provider"],
+        fixable: false,
+        fixSuggestion: `Use one of: ${knownProviderIds.join(", ")}`
+      });
+    }
+    const askPresets = config.ask?.presets;
+    if (askPresets) {
+      for (const presetName of findProviderCollisions(Object.keys(askPresets), knownProviderIds)) {
+        errors.push({
+          code: "ask_preset_provider_collision",
+          message: `ask.presets name '${presetName}' collides with a registered provider id`,
+          path: ["ask", "presets", presetName],
+          fixable: false,
+          fixSuggestion: "Rename the preset; positional preset names must not shadow providers"
+        });
+      }
+    }
+    const judgeProvider = config.defaults?.judge?.provider;
+    if (judgeProvider && !knownProviderIds.includes(judgeProvider)) {
+      errors.push({
+        code: "unknown_judge_provider",
+        message: `defaults.judge.provider '${judgeProvider}' is not a known provider`,
+        path: ["defaults", "judge", "provider"],
+        fixable: false,
+        fixSuggestion: `Use one of: ${knownProviderIds.join(", ")}`
+      });
+    }
+    const synthesisProvider = config.defaults?.synthesis?.provider;
+    if (synthesisProvider && !knownProviderIds.includes(synthesisProvider)) {
+      errors.push({
+        code: "unknown_synthesis_provider",
+        message: `defaults.synthesis.provider '${synthesisProvider}' is not a known provider`,
+        path: ["defaults", "synthesis", "provider"],
+        fixable: false,
+        fixSuggestion: `Use one of: ${knownProviderIds.join(", ")}`
+      });
+    }
+    for (const rolesError of validateRolesConfig(
+      config.roles,
+      knownProviderIds
+    )) {
+      errors.push({
+        code: rolesError.code,
+        message: rolesError.message,
+        path: rolesError.path,
+        fixable: false,
+        fixSuggestion: rolesError.code.startsWith("unknown_") ? `Use one of: ${knownProviderIds.join(", ")}` : void 0
+      });
+    }
+  }
+  if (config.quality?.coverage?.threshold) {
+    const threshold = config.quality.coverage.threshold;
+    if (threshold < 0 || threshold > 100) {
+      errors.push({
+        code: "invalid_coverage_threshold",
+        message: "Coverage threshold must be between 0 and 100",
+        path: ["quality", "coverage", "threshold"],
+        fixable: true,
+        fixSuggestion: "Set threshold to a value between 0 and 100"
+      });
+    }
+  }
+  if (config.execution?.defaultTimeout) {
+    const timeout = config.execution.defaultTimeout;
+    if (timeout < 1 || timeout > 180) {
+      warnings.push({
+        code: "extreme_timeout",
+        message: `Timeout of ${timeout} minutes is unusual`,
+        path: ["execution", "defaultTimeout"],
+        recommendation: "Consider using a timeout between 5 and 60 minutes"
+      });
+    }
+  }
+}
+function validateBusinessLogic(config, warnings, suggestions) {
+  if (!config.telemetry?.enabled) {
+    suggestions.push({
+      type: "improvement",
+      message: "Enable telemetry to track variant performance and improve recommendations",
+      path: ["telemetry", "enabled"],
+      action: "Set telemetry.enabled to true"
+    });
+  }
+  if (config.quality?.coverage?.threshold && config.quality.coverage.threshold < 70) {
+    suggestions.push({
+      type: "best-practice",
+      message: "Consider increasing coverage threshold for better code quality",
+      path: ["quality", "coverage", "threshold"],
+      action: "Set coverage.threshold to 80 or higher"
+    });
+  }
+  if (config.variants?.strategies) {
+    const totalWeight = Object.values(config.variants.strategies).reduce(
+      (sum, strategy) => {
+        if (typeof strategy === "object" && strategy !== null && "weight" in strategy && typeof strategy.weight === "number") {
+          return sum + strategy.weight;
+        }
+        return sum;
+      },
+      0
+    );
+    if (Math.abs(totalWeight - 1) > 0.01) {
+      warnings.push({
+        code: "invalid_strategy_weights",
+        message: `Strategy weights sum to ${totalWeight}, should sum to 1.0`,
+        path: ["variants", "strategies"],
+        recommendation: "Adjust strategy weights so they sum to 1.0"
+      });
+    }
+  }
+}
+function validateUserPreferencesLogic(preferences, _errors, warnings, suggestions) {
+  const cursorPrefs = preferences?.preferences?.cursor;
+  if (!cursorPrefs) {
+    return;
+  }
+  const cursorModel = cursorPrefs.defaultModel;
+  const validModels = [
+    "auto",
+    "cheetah",
+    "sonnet-4.5",
+    "sonnet-4.5-thinking",
+    "gpt-5",
+    "gpt-5-codex",
+    "opus-4.1",
+    "grok"
+  ];
+  if (cursorModel && !validModels.includes(cursorModel)) {
+    warnings.push({
+      code: "unknown_cursor_model",
+      message: `Unknown cursor model: ${cursorModel}`,
+      path: ["preferences", "cursor", "defaultModel"],
+      recommendation: `Use one of: ${validModels.join(", ")}`
+    });
+  }
+  if (!isFirstTimeDefaultsInitialized(preferences)) {
+    suggestions.push({
+      type: "improvement",
+      message: "Initialize user defaults for optimal experience",
+      path: ["firstTimeSetup"],
+      action: "Run poetic provider setup --first-run"
+    });
+  }
+  const usageHistory = cursorPrefs.usageHistory;
+  if (usageHistory?.lastUsed && usageHistory.usageCount === 0) {
+    warnings.push({
+      code: "inconsistent_usage_history",
+      message: "Last used model specified but usage count is 0",
+      path: ["preferences", "cursor", "usageHistory"],
+      recommendation: "Update usage count to match actual usage"
+    });
+  }
+}
+function generateValidationReport(result) {
+  const lines = [];
+  if (result.isValid) {
+    lines.push("Configuration is valid");
+  } else {
+    lines.push("Configuration has errors");
+  }
+  if (result.errors.length > 0) {
+    lines.push("\nErrors:");
+    for (const error of result.errors) {
+      lines.push(`  ${error.path.join(".")}: ${error.message}`);
+      if (error.fixSuggestion) {
+        lines.push(`    Fix: ${error.fixSuggestion}`);
+      }
+    }
+  }
+  if (result.warnings.length > 0) {
+    lines.push("\nWarnings:");
+    for (const warning of result.warnings) {
+      lines.push(`  ${warning.path.join(".")}: ${warning.message}`);
+      if (warning.recommendation) {
+        lines.push(`    Recommendation: ${warning.recommendation}`);
+      }
+    }
+  }
+  if (result.suggestions.length > 0) {
+    lines.push("\nSuggestions:");
+    for (const suggestion of result.suggestions) {
+      lines.push(`  - ${suggestion.message}`);
+      if (suggestion.action) {
+        lines.push(`    Action: ${suggestion.action}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function quickValidate(config) {
+  return validatePoeticConfig(config, {
+    includeWarnings: false,
+    includeSuggestions: false
+  }).isValid;
+}
+function autoFixConfig(config) {
+  const changes = [];
+  const fixedConfig = typeof config === "object" && config !== null ? structuredClone(config) : {};
+  if (!fixedConfig.defaultProvider && typeof fixedConfig.providers === "object" && fixedConfig.providers !== null) {
+    const providers = fixedConfig.providers;
+    const enabledProviders = Object.entries(providers).filter(([_, provider]) => hasEnabledProperty(provider) && provider.enabled).map(([name]) => name);
+    if (enabledProviders.length > 0) {
+      fixedConfig.defaultProvider = enabledProviders[0];
+      changes.push(`Set defaultProvider to '${fixedConfig.defaultProvider}'`);
+    }
+  }
+  if (typeof fixedConfig.providers === "object" && fixedConfig.providers !== null) {
+    const providers = fixedConfig.providers;
+    const enabledCount = Object.values(providers).filter(
+      (p) => hasEnabledProperty(p) && p.enabled
+    ).length;
+    if (enabledCount === 0) {
+      const firstRepairable = Object.entries(providers).find(
+        ([, provider]) => hasEnabledProperty(provider)
+      );
+      if (firstRepairable !== void 0) {
+        const [name, provider] = firstRepairable;
+        provider.enabled = true;
+        changes.push(`Enabled '${name}' provider (no providers were enabled)`);
+      }
+    }
+  }
+  const validationResult = validatePoeticConfig(fixedConfig);
+  const remainingErrors = validationResult.errors.filter((error) => !error.fixable);
+  return {
+    fixedConfig,
+    changes,
+    remainingErrors
+  };
+}
+
+export {
+  readFirstTimeSetupState,
+  isFirstTimeDefaultsInitialized,
+  isFirstTimeSetupCompleted,
+  markFirstTimeDefaultsInitialized,
+  markFirstTimeSetupCompleted,
+  validatePoeticConfig,
+  validateUserPreferences,
+  validateSystemConfig,
+  generateValidationReport,
+  quickValidate,
+  autoFixConfig
+};
+//# sourceMappingURL=chunk-CUSRN6RJ.js.map

package/dist/chunk-D5EP5D2W.js

@@ -0,0 +1,26 @@
+// src/planning/task-status-policy.ts
+function resolveTaskStatusForStageOutcome(outcome) {
+  if (outcome.kind === "stage-result") {
+    if (outcome.validationPassed) {
+      return outcome.apply ? "done" : "review";
+    }
+    return "in_progress";
+  }
+  const { event } = outcome;
+  switch (event.eventType) {
+    case "started":
+      return event.attempt === 1 ? "in_progress" : void 0;
+    case "succeeded":
+      if (!event.terminal) return void 0;
+      return outcome.apply ? "done" : "review";
+    case "failed":
+      return event.terminal ? "blocked" : void 0;
+    case "skipped":
+      return event.terminal ? "blocked" : void 0;
+  }
+}
+
+export {
+  resolveTaskStatusForStageOutcome
+};
+//# sourceMappingURL=chunk-D5EP5D2W.js.map