@poetic-ai/poetic 1.42.0

package/dist/chunk-ZSKKMTQJ.js

@@ -0,0 +1,554 @@
+import {
+  normalizeProviderForEstimator
+} from "./chunk-LWCBNGH6.js";
+import {
+  stripPoeticContextBlocks
+} from "./chunk-VX3UMWB7.js";
+import {
+  ModelMetadataResolver,
+  findOpencodeFallbackContextWindow,
+  getOpencodeCatalogEntry,
+  isExactCompatibilityMatch,
+  resolveOpencodeContextWindow
+} from "./chunk-XT2ZQVTC.js";
+import {
+  splitClaudeModelContextSuffix
+} from "./chunk-MWHLBPNU.js";
+
+// src/orchestrator/token-estimator.ts
+var UTILIZATION_WARN_PERCENT = 80;
+var UTILIZATION_SPLIT_PERCENT = 85;
+var CONTEXT_WINDOWS = {
+  // Provider marker for normalization; Claude context windows return early
+  // through ProviderRegistry so model metadata stays in providers.yaml.
+  claude: {},
+  // Provider marker for normalization; Codex context windows return early
+  // through ProviderRegistry so model metadata stays in providers.yaml.
+  codex: {},
+  // Compatibility-only estimator bucket for OpenAI-family model names.
+  // This is not a runnable Poetic provider; Codex owns OpenAI-backed CLI execution.
+  openai: {},
+  // Provider marker for normalization; Gemini context windows return early
+  // through ProviderRegistry so model metadata stays in providers.yaml.
+  gemini: {},
+  // Provider marker for normalization; Cursor context windows resolve through
+  // ProviderRegistry first and keep conservative fallbacks for legacy aliases.
+  cursor: {},
+  // Provider marker for normalization; OpenCode context windows return early
+  // through the provider catalog so runtime and estimator share one fallback table.
+  opencode: {},
+  // Provider marker for normalization; Copilot context windows return early
+  // through ProviderRegistry, with legacy fallbacks for removed aliases.
+  copilot: {}
+};
+function lookupProviderEntry(table, provider) {
+  return Object.hasOwn(table, provider) ? table[provider] : void 0;
+}
+function isKnownEstimatorProviderInput(provider) {
+  const normalizedProvider = (provider || "").toLowerCase().trim();
+  if (!normalizedProvider) return false;
+  if (normalizedProvider in CONTEXT_WINDOWS) return true;
+  return ESTIMATOR_PROVIDER_ALIASES.has(normalizedProvider);
+}
+var DEFAULT_CONTEXT_WINDOW = 128e3;
+var GPT_FAMILY = "gpt";
+var CLAUDE_FAMILY = "claude";
+var ESTIMATOR_PROVIDER_ALIASES = /* @__PURE__ */ new Set(["anthropic", "google", "github", "opencode"]);
+var OPENAI_TOKENIZER_PROVIDERS = /* @__PURE__ */ new Set([
+  "codex",
+  "openai",
+  "copilot"
+]);
+var CLAUDE_TOKENIZER_PROVIDERS = /* @__PURE__ */ new Set(["claude"]);
+var GPT_4_TIKTOKEN_MODEL = [GPT_FAMILY, "4"].join("-");
+var GPT_4_TURBO_MODEL = [GPT_FAMILY, "4", "turbo"].join("-");
+var GPT_4_TURBO_PREVIEW_TIKTOKEN_MODEL = [GPT_FAMILY, "4", "turbo", "preview"].join("-");
+var GPT_4O_TIKTOKEN_MODEL = `${GPT_FAMILY}-4o`;
+var GPT_4O_MINI_TIKTOKEN_MODEL = `${GPT_FAMILY}-4o-mini`;
+var GPT_3_5_TURBO_TIKTOKEN_MODEL = `${GPT_FAMILY}-3.5-turbo`;
+var GPT_3_5_TIKTOKEN_ALIAS = `${GPT_FAMILY}-3.5`;
+var GPT_5_TIKTOKEN_ALIAS = [GPT_FAMILY, "5"].join("-");
+var GPT_5_CODEX_MINI_TIKTOKEN_ALIAS = [GPT_FAMILY, "5", "codex", "mini"].join("-");
+var CLAUDE_OPUS_4_1_COMPAT_MODEL = [CLAUDE_FAMILY, "opus", "4", "1"].join("-");
+var CLAUDE_3_OPUS_COMPAT_MODEL = [CLAUDE_FAMILY, "3", "opus"].join("-");
+var CLAUDE_3_SONNET_COMPAT_MODEL = [CLAUDE_FAMILY, "3", "sonnet"].join("-");
+var CLAUDE_3_HAIKU_COMPAT_MODEL = [CLAUDE_FAMILY, "3", "haiku"].join("-");
+var CLAUDE_LEGACY_CONTEXT_WINDOWS = {
+  [CLAUDE_OPUS_4_1_COMPAT_MODEL]: 2e5,
+  "sonnet-4": 2e5,
+  "sonnet-3-5": 2e5,
+  "sonnet-3": 2e5,
+  [CLAUDE_3_OPUS_COMPAT_MODEL]: 2e5,
+  [CLAUDE_3_SONNET_COMPAT_MODEL]: 2e5,
+  [CLAUDE_3_HAIKU_COMPAT_MODEL]: 2e5
+};
+var CODEX_LEGACY_CONTEXT_WINDOWS = {
+  codex: 8e3
+};
+var COPILOT_LEGACY_CONTEXT_WINDOWS = {
+  [GPT_4_TIKTOKEN_MODEL]: 128e3,
+  [GPT_3_5_TURBO_TIKTOKEN_MODEL]: 16e3
+};
+function normalizeModelKey(model) {
+  return model.trim().toLowerCase();
+}
+function findFallbackContextWindowMatch(model, windows) {
+  const normalizedModel = normalizeModelKey(model);
+  if (normalizedModel === "") {
+    return void 0;
+  }
+  const exactMatch = windows[normalizedModel];
+  if (exactMatch !== void 0) {
+    return { contextWindow: exactMatch, exact: true };
+  }
+  for (const [knownModel, contextWindow] of Object.entries(windows)) {
+    if (normalizedModel.includes(knownModel) || knownModel.includes(normalizedModel)) {
+      return { contextWindow, exact: false };
+    }
+  }
+  return void 0;
+}
+var DEFAULT_CHARS_PER_TOKEN = 4;
+var HEURISTIC_CHARS_PER_TOKEN = {
+  // Gemini uses similar tokenization to GPT-4 (~4 chars per token)
+  gemini: 4
+};
+var MODEL_CONFIDENCE_RESOLVERS = {
+  openai: (_provider, model) => getOpenAiCompatibilityConfidence(model) ?? 0.3,
+  opencode: (_provider, model) => getOpencodeCatalogConfidence(model) ?? 0.3,
+  cursor: (_provider, model) => normalizeModelKey(model) === "auto" ? 0.8 : void 0,
+  claude: (provider, model) => {
+    const legacyConfidence = getLegacyContextConfidence(model, CLAUDE_LEGACY_CONTEXT_WINDOWS);
+    if (legacyConfidence === 1) {
+      return legacyConfidence;
+    }
+    const registryConfidence = getProviderRegistryModelConfidence(provider, model);
+    if (registryConfidence !== void 0) {
+      return registryConfidence;
+    }
+    return legacyConfidence;
+  },
+  codex: (_provider, model) => CODEX_LEGACY_CONTEXT_WINDOWS[normalizeModelKey(model)] !== void 0 ? 0.9 : void 0,
+  copilot: (provider, model) => {
+    const exactLegacyConfidence = COPILOT_LEGACY_CONTEXT_WINDOWS[normalizeModelKey(model)] !== void 0 ? 0.9 : void 0;
+    if (exactLegacyConfidence !== void 0) {
+      return exactLegacyConfidence;
+    }
+    const registryConfidence = getProviderRegistryModelConfidence(provider, model);
+    if (registryConfidence !== void 0) {
+      return registryConfidence;
+    }
+    return getLegacyContextConfidence(model, COPILOT_LEGACY_CONTEXT_WINDOWS, 0.9) ?? 0.3;
+  }
+};
+var CONTEXT_WINDOW_RESOLVERS = {
+  opencode: (model) => resolveOpencodeContextWindow(model, DEFAULT_CONTEXT_WINDOW),
+  claude: (model) => {
+    const baseModel = splitClaudeModelContextSuffix(model).base;
+    return CLAUDE_LEGACY_CONTEXT_WINDOWS[normalizeModelKey(baseModel)];
+  },
+  codex: (model) => CODEX_LEGACY_CONTEXT_WINDOWS[normalizeModelKey(model)],
+  copilot: (model) => COPILOT_LEGACY_CONTEXT_WINDOWS[normalizeModelKey(model)]
+};
+var PROVIDER_OVERHEAD_PROFILES = {
+  claude: {
+    systemPromptTokens: 1500,
+    outputReservePercent: 0.3
+    // 30% for Claude's verbose outputs
+  },
+  codex: {
+    systemPromptTokens: 800,
+    outputReservePercent: 0.25
+  },
+  openai: {
+    systemPromptTokens: 800,
+    outputReservePercent: 0.25
+  },
+  gemini: {
+    systemPromptTokens: 1e3,
+    outputReservePercent: 0.25
+  },
+  cursor: {
+    systemPromptTokens: 1e3,
+    outputReservePercent: 0.25
+  },
+  opencode: {
+    systemPromptTokens: 1e3,
+    outputReservePercent: 0.25
+  },
+  copilot: {
+    systemPromptTokens: 800,
+    outputReservePercent: 0.25
+  }
+};
+var GUESSED_MODEL_MATCH_CONFIDENCE = 0.4;
+function isGuessedModelMatch(resolved, substringMatched) {
+  if (!resolved) return false;
+  if (resolved.matchType === "fuzzy") return true;
+  return resolved.matchType === "fallback" && substringMatched;
+}
+function getProviderRegistryModelConfidence(provider, model) {
+  const resolved = ModelMetadataResolver.resolveModel(provider, model, { allowFuzzy: true });
+  if (!resolved) return void 0;
+  return resolved.matchType === "fuzzy" ? GUESSED_MODEL_MATCH_CONFIDENCE : 1;
+}
+function getLegacyContextConfidence(model, windows, exactConfidence = 1) {
+  const match = findFallbackContextWindowMatch(model, windows);
+  if (!match) {
+    return void 0;
+  }
+  return match.exact ? exactConfidence : GUESSED_MODEL_MATCH_CONFIDENCE;
+}
+function getOpenAiCompatibilityConfidence(model) {
+  const resolved = ModelMetadataResolver.resolveModel("openai", model, {
+    allowFallback: true,
+    allowFuzzy: true
+  });
+  if (!resolved) return void 0;
+  return isGuessedModelMatch(resolved, isExactCompatibilityMatch("openai", model) === false) ? GUESSED_MODEL_MATCH_CONFIDENCE : 1;
+}
+function getOpencodeCatalogConfidence(model) {
+  const catalogEntry = getOpencodeCatalogEntry(model);
+  if (catalogEntry.source === "registry") {
+    return 1;
+  }
+  const fallbackMatch = findOpencodeFallbackContextWindow(model);
+  if (fallbackMatch) {
+    return fallbackMatch.exact ? 0.9 : GUESSED_MODEL_MATCH_CONFIDENCE;
+  }
+  return void 0;
+}
+var DEFAULT_THRESHOLD_PERCENT = 0.65;
+var TokenEstimator = class {
+  // tiktoken is a declared dependency; assume available at runtime.
+  // estimateOpenAITokens / estimateClaudeTokens each contain their own try/catch
+  // that falls back to chars/4 or chars/3.5 if the dynamic import fails.
+  tiketokenAvailable = true;
+  encodingCache = /* @__PURE__ */ new Map();
+  /**
+   * Analyze task to determine if splitting is needed
+   *
+   * @param prompt - Task description
+   * @param provider - Target provider ID (e.g., 'claude', 'openai', or a config-defined provider)
+   * @param model - Target model (e.g., 'claude-sonnet-4-5', 'gpt-4')
+   * @returns Decomposition decision with token analysis
+   */
+  async analyzeTask(prompt, provider, model) {
+    const normalizedProvider = normalizeProviderForEstimator(provider, model);
+    const inputProviderKnown = isKnownEstimatorProviderInput(provider);
+    const promptForEstimation = stripPoeticInjectedContext(prompt);
+    const estimatedTokens = await this.estimateTokens(
+      promptForEstimation,
+      normalizedProvider,
+      model
+    );
+    const contextWindow = this.getContextWindow(normalizedProvider, model);
+    const thresholdTokens = this.getRecommendedThreshold(normalizedProvider, model);
+    const overhead = this.getContextOverhead(normalizedProvider, model);
+    const utilizationPercent = estimatedTokens / contextWindow * 100;
+    const adjustedUtilizationPercent = (estimatedTokens + overhead.total) / contextWindow * 100;
+    const estimationConfidence = inputProviderKnown ? this.getModelConfidence(normalizedProvider, model) : 0.5;
+    const validationMetadata = this.computeValidationMetadata(
+      promptForEstimation,
+      utilizationPercent
+    );
+    if (utilizationPercent < 60) {
+      return {
+        shouldSplit: false,
+        reason: "within-threshold",
+        estimatedTokens,
+        contextWindow,
+        utilizationPercent,
+        thresholdTokens,
+        adjustedUtilizationPercent,
+        overhead,
+        estimationConfidence,
+        validationMetadata
+      };
+    }
+    const strategy = this.selectSplitStrategy(
+      promptForEstimation,
+      estimatedTokens,
+      thresholdTokens
+    );
+    return {
+      shouldSplit: true,
+      reason: "exceeds-threshold",
+      estimatedTokens,
+      contextWindow,
+      utilizationPercent,
+      thresholdTokens,
+      strategy,
+      adjustedUtilizationPercent,
+      overhead,
+      estimationConfidence,
+      validationMetadata
+    };
+  }
+  /**
+   * Compute validation metadata for autoloop gate selection
+   *
+   * Provides hints about quality gate policy based on task characteristics:
+   * - Simple tasks with low token utilization → deterministic gates only (fast CI)
+   * - Complex tasks or high utilization → all gates (comprehensive verification)
+   *
+   * @param prompt - Task description
+   * @param utilizationPercent - Context window utilization percentage
+   * @returns Validation metadata with policy recommendation
+   */
+  computeValidationMetadata(prompt, utilizationPercent) {
+    const rationale = [];
+    if (utilizationPercent < 40) {
+      rationale.push("Low complexity task (< 40% context usage)");
+      rationale.push("Recommend deterministic gates only for fast CI velocity");
+      return {
+        recommendedGatePolicy: "deterministic",
+        rationale
+      };
+    }
+    const complexitySignals = [
+      "refactor",
+      "architecture",
+      "breaking change",
+      "migration",
+      "security"
+    ];
+    const isComplex = complexitySignals.some(
+      (signal) => prompt.toLowerCase().includes(signal.toLowerCase())
+    );
+    if (isComplex || utilizationPercent >= 40) {
+      rationale.push(
+        isComplex ? "Complex task detected (refactor/architecture/migration)" : "High complexity task (\u2265 40% context usage)"
+      );
+      rationale.push("Recommend all gates for comprehensive verification");
+      return {
+        recommendedGatePolicy: "all",
+        rationale
+      };
+    }
+    rationale.push("Default to deterministic gates for CI velocity");
+    return {
+      recommendedGatePolicy: "deterministic",
+      rationale
+    };
+  }
+  /**
+   * Estimate token count for text
+   *
+   * @param text - Text to analyze
+   * @param provider - Target provider
+   * @param model - Target model
+   * @returns Estimated token count
+   */
+  async estimateTokens(text, provider, model) {
+    if (OPENAI_TOKENIZER_PROVIDERS.has(provider)) {
+      return this.estimateOpenAITokens(text, model);
+    }
+    if (CLAUDE_TOKENIZER_PROVIDERS.has(provider)) {
+      return this.estimateClaudeTokens(text, model);
+    }
+    const charsPerToken = lookupProviderEntry(HEURISTIC_CHARS_PER_TOKEN, provider) ?? DEFAULT_CHARS_PER_TOKEN;
+    return Math.ceil(text.length / charsPerToken);
+  }
+  /**
+   * Estimate tokens using OpenAI's tiktoken
+   * Falls back to character-based approximation if tiktoken unavailable
+   */
+  async estimateOpenAITokens(text, model) {
+    if (!this.tiketokenAvailable) {
+      return Math.ceil(text.length / 4);
+    }
+    try {
+      const { encoding_for_model } = await import("tiktoken");
+      const modelMap = {
+        [GPT_4_TIKTOKEN_MODEL]: GPT_4_TIKTOKEN_MODEL,
+        [GPT_4_TURBO_MODEL]: GPT_4_TURBO_PREVIEW_TIKTOKEN_MODEL,
+        [GPT_4O_TIKTOKEN_MODEL]: GPT_4O_TIKTOKEN_MODEL,
+        [GPT_4O_MINI_TIKTOKEN_MODEL]: GPT_4O_MINI_TIKTOKEN_MODEL,
+        [GPT_3_5_TURBO_TIKTOKEN_MODEL]: GPT_3_5_TURBO_TIKTOKEN_MODEL,
+        [GPT_3_5_TIKTOKEN_ALIAS]: GPT_3_5_TURBO_TIKTOKEN_MODEL,
+        [GPT_5_CODEX_MINI_TIKTOKEN_ALIAS]: GPT_4_TIKTOKEN_MODEL,
+        // Use GPT-4 tokenizer for Codex
+        [GPT_5_TIKTOKEN_ALIAS]: GPT_4_TIKTOKEN_MODEL,
+        codex: GPT_4_TIKTOKEN_MODEL
+      };
+      const tiketokenModel = modelMap[model] || GPT_4_TIKTOKEN_MODEL;
+      const cacheKey = tiketokenModel;
+      let encoding = this.encodingCache.get(cacheKey);
+      if (!encoding) {
+        encoding = encoding_for_model(
+          tiketokenModel
+        );
+        this.encodingCache.set(cacheKey, encoding);
+      }
+      const tokens = encoding.encode(text);
+      return tokens.length;
+    } catch {
+      return Math.ceil(text.length / 4);
+    }
+  }
+  /**
+   * Estimate tokens for Claude models using tiktoken cl100k_base.
+   * Falls back to chars/3.5 if tiktoken is unavailable.
+   */
+  async estimateClaudeTokens(text, _model) {
+    if (!this.tiketokenAvailable) {
+      return Math.ceil(text.length / 3.5);
+    }
+    try {
+      const { get_encoding } = await import("tiktoken");
+      const cacheKey = "cl100k_base";
+      let encoding = this.encodingCache.get(cacheKey);
+      if (!encoding) {
+        encoding = get_encoding("cl100k_base");
+        this.encodingCache.set(cacheKey, encoding);
+      }
+      const tokens = encoding.encode(text);
+      return tokens.length;
+    } catch {
+      return Math.ceil(text.length / 3.5);
+    }
+  }
+  /**
+   * Get confidence score for a provider and model
+   *
+   * @param provider - Provider ID
+   * @param model - Model identifier
+   * @returns Confidence score (0.0-1.0)
+   */
+  getModelConfidence(provider, model) {
+    const resolverConfidence = lookupProviderEntry(MODEL_CONFIDENCE_RESOLVERS, provider)?.(
+      provider,
+      model
+    );
+    if (resolverConfidence !== void 0) {
+      return resolverConfidence;
+    }
+    return getProviderRegistryModelConfidence(provider, model) ?? 0.3;
+  }
+  /**
+   * Get context window size for provider and model
+   *
+   * @param provider - Provider ID
+   * @param model - Model identifier
+   * @returns Context window in tokens
+   */
+  getContextWindow(provider, model) {
+    const resolvedWindow = lookupProviderEntry(CONTEXT_WINDOW_RESOLVERS, provider)?.(model);
+    if (resolvedWindow !== void 0) {
+      return resolvedWindow;
+    }
+    try {
+      return ModelMetadataResolver.getContextWindow(provider, model, {
+        allowFallback: true,
+        allowFuzzy: true
+      }) ?? DEFAULT_CONTEXT_WINDOW;
+    } catch {
+      return DEFAULT_CONTEXT_WINDOW;
+    }
+  }
+  /**
+   * Get recommended threshold in tokens (65% of context window)
+   *
+   * @param provider - Provider ID
+   * @param model - Model identifier
+   * @returns Recommended threshold in tokens
+   */
+  getRecommendedThreshold(provider, model) {
+    const contextWindow = this.getContextWindow(provider, model);
+    return Math.floor(contextWindow * DEFAULT_THRESHOLD_PERCENT);
+  }
+  /**
+   * Calculate context overhead for a provider and model
+   *
+   * Conservative overhead estimates:
+   * - Claude: 1500 tokens system, 30% output reserve
+   * - Codex/OpenAI: 800 tokens system, 25% output reserve
+   * - Gemini: 1000 tokens system, 25% output reserve
+   * - Other providers: 1000 tokens system, 25% output reserve
+   * - Always add 5% safety margin
+   *
+   * @param provider - Provider ID
+   * @param model - Model identifier
+   * @returns Token overhead breakdown
+   */
+  getContextOverhead(provider, model) {
+    const contextWindow = this.getContextWindow(provider, model);
+    const profile = lookupProviderEntry(PROVIDER_OVERHEAD_PROFILES, provider) || {
+      systemPromptTokens: 1e3,
+      outputReservePercent: 0.25
+    };
+    const systemPrompt = profile.systemPromptTokens;
+    const outputReservePercent = profile.outputReservePercent;
+    const outputReserve = Math.floor(contextWindow * outputReservePercent);
+    const safetyMargin = Math.floor(contextWindow * 0.05);
+    const total = systemPrompt + outputReserve + safetyMargin;
+    return {
+      systemPrompt,
+      outputReserve,
+      safetyMargin,
+      total
+    };
+  }
+  /**
+   * Select best split strategy based on task content and token count
+   *
+   * @param prompt - Task description
+   * @param estimatedTokens - Estimated token count
+   * @param threshold - Recommended threshold
+   * @returns Recommended split strategy
+   */
+  selectSplitStrategy(prompt, estimatedTokens, threshold) {
+    const sampleText = prompt.length > 5e3 ? prompt.slice(0, 5e3) : prompt;
+    const fileMatches = sampleText.match(
+      /([a-zA-Z0-9_\-/]+\.(?:ts|js|tsx|jsx|py|java|go|rs|cpp|c|h))\b/g
+    );
+    if (fileMatches && fileMatches.length > 1) {
+      return "file-based";
+    }
+    const firstLine = sampleText.split("\n")[0] || "";
+    const colonPattern = /^(.+?):\s*(.+)$/;
+    const colonMatch = firstLine.match(colonPattern);
+    if (colonMatch) {
+      const featureList = colonMatch[2] || "";
+      const features = featureList.split(/\s*,\s*|\s+and\s+/i);
+      if (features.length > 1) {
+        return "feature-based";
+      }
+    }
+    if (estimatedTokens > threshold * 2) {
+      return "sequential";
+    }
+    return "semantic";
+  }
+  /**
+   * Free cached encodings
+   */
+  cleanup() {
+    for (const encoding of this.encodingCache.values()) {
+      try {
+        encoding.free?.();
+      } catch {
+      }
+    }
+    this.encodingCache.clear();
+  }
+};
+function stripPoeticInjectedContext(prompt) {
+  if (!prompt) return "";
+  let text = stripPoeticContextBlocks(String(prompt));
+  const toolPolicySplit = text.split(/\n---\n\n/);
+  if (toolPolicySplit.length > 1 && /##\s*Tool Usage Policy/i.test(toolPolicySplit[0] ?? "")) {
+    text = toolPolicySplit.slice(1).join("\n---\n\n");
+  }
+  text = text.replace(/(^|\n)\s*FILE TARGETS:\s*\n(?:\s*[-•]\s+[^\n]+\n?)+/gi, "\n");
+  return text;
+}
+
+export {
+  UTILIZATION_WARN_PERCENT,
+  UTILIZATION_SPLIT_PERCENT,
+  DEFAULT_THRESHOLD_PERCENT,
+  TokenEstimator
+};
+//# sourceMappingURL=chunk-ZSKKMTQJ.js.map