@poetic-ai/poetic 1.42.0

package/dist/chunk-2A5CILN3.js

@@ -0,0 +1,310 @@
+import {
+  runProviderNative
+} from "./chunk-W3JMT2YY.js";
+import {
+  resolveJudgeConfig,
+  resolvePreferred
+} from "./chunk-XPU2XADL.js";
+import {
+  resolveProviderStreamingEnabled
+} from "./chunk-HIO33P3G.js";
+import {
+  getProviderRuntimeQuirks
+} from "./chunk-FC23CTXV.js";
+import {
+  withRetry
+} from "./chunk-CKNX3TTP.js";
+import {
+  createCleanChildEnv
+} from "./chunk-6TZJRKNW.js";
+import {
+  isQuietOutputRequested
+} from "./chunk-FKAUPHMR.js";
+import {
+  ProviderExecutionError
+} from "./chunk-LUVKFFWR.js";
+import {
+  modelSupportsAdaptiveThinking,
+  modelSupportsManualThinkingBudget
+} from "./chunk-ON3G73BU.js";
+import {
+  isDebugMode
+} from "./chunk-EJGCZGUF.js";
+import {
+  POETIC_PROVIDER_STREAMING,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/core/judge/llm-judge-executor.ts
+import { performance } from "perf_hooks";
+
+// src/core/providers/shared/provider-live-progress.ts
+var DEFAULT_PROGRESS_INTERVAL_MS = 15e3;
+function shouldShowProviderLiveProgress(env = process.env, enabled = true) {
+  if (!enabled) return false;
+  if (isQuietOutputRequested()) return false;
+  if (isTestRuntime(env)) return false;
+  return resolveProviderStreamingEnabled(env);
+}
+function createProviderLiveProgressReporter(options) {
+  const now = options.now ?? Date.now;
+  const startMs = now();
+  const minIntervalMs = options.minIntervalMs ?? DEFAULT_PROGRESS_INTERVAL_MS;
+  const enabled = shouldShowProviderLiveProgress(options.env, options.enabled ?? true);
+  const write = options.write;
+  let lastWriteMs = 0;
+  let observedOutput = false;
+  let observedText = false;
+  const startedTools = /* @__PURE__ */ new Set();
+  const emit = (message, force = false) => {
+    if (!enabled || !write) return;
+    const current = now();
+    if (!force && lastWriteMs > 0 && current - lastWriteMs < minIntervalMs) {
+      return;
+    }
+    lastWriteMs = current;
+    write(`[progress] ${options.label}: ${message}
+`);
+  };
+  const formatProvider = () => options.provider ? ` (${options.provider})` : "";
+  return {
+    enabled,
+    onActivity(_activity) {
+      if (!observedOutput) {
+        observedOutput = true;
+        emit(`provider output started${formatProvider()}`, true);
+        return;
+      }
+      const elapsedSeconds = Math.max(1, Math.round((now() - startMs) / 1e3));
+      emit(`provider still active (${elapsedSeconds}s)`);
+    },
+    onStreamEvent(event) {
+      switch (event.type) {
+        case "model_resolved":
+          break;
+        case "tool_event": {
+          const toolKey = event.id ?? `${event.name}:${event.phase ?? "unknown"}`;
+          if (event.phase === "started" && !startedTools.has(toolKey)) {
+            startedTools.add(toolKey);
+            emit(`tool ${event.name} started`, true);
+          } else if (event.phase === "completed") {
+            emit(`tool ${event.name} completed`);
+          }
+          break;
+        }
+        case "text_delta":
+        case "text_snapshot":
+          if (!observedText) {
+            observedText = true;
+            emit(`provider text received${formatProvider()}`, true);
+          } else {
+            emit(`provider still writing${formatProvider()}`);
+          }
+          break;
+        case "usage_delta":
+          break;
+      }
+    }
+  };
+}
+function isTestRuntime(env) {
+  if (env.POETIC_TEST_ALLOW_PROGRESS === "1") return false;
+  return env.NODE_ENV === "test" || env.VITEST === "true" || env.VITEST === "1";
+}
+
+// src/core/judge/llm-judge-executor.ts
+function computeDefaultThinkingBudget(options) {
+  const variantCount = options.variantCount ?? 2;
+  const basePerVariant = 8192;
+  const floor = 32768;
+  const ceiling = 131072;
+  return Math.min(ceiling, Math.max(floor, variantCount * basePerVariant));
+}
+var CLAUDE_JUDGE_DISALLOWED_TOOLS = [
+  "Agent",
+  "Task",
+  "Read",
+  "Glob",
+  "Grep",
+  "Bash",
+  "Write",
+  "Edit",
+  "NotebookEdit",
+  "WebFetch",
+  "WebSearch"
+].join(",");
+var LlmJudgeExecutor = class {
+  async evaluate(prompt, options = {}) {
+    if (!prompt || prompt.trim().length === 0) {
+      throw new Error("Judge prompt must be provided.");
+    }
+    const resolved = resolveJudgeConfig(
+      {
+        judgeProvider: options.provider,
+        judgeModel: options.model
+      },
+      options.workingDir ?? process.cwd(),
+      options.judgeType
+    );
+    const provider = resolved.provider.value;
+    const model = resolved.model.value;
+    const judgeTransport = getProviderRuntimeQuirks(provider)?.judgeTransport;
+    const workingDir = options.workingDir ?? process.cwd();
+    const _unifiedCandidate = resolvePreferred("judge", {
+      cli: { judgeProvider: options.provider, judgeModel: options.model },
+      cwd: workingDir
+    });
+    if (isDebugMode()) {
+      console.debug(
+        `[LlmJudgeExecutor] unified resolver: provider=${_unifiedCandidate.provider} model=${_unifiedCandidate.model} source=${_unifiedCandidate.source}`
+      );
+    }
+    const baseTimeoutMs = (options.timeoutSeconds ?? 300) * 1e3;
+    const maxAttempts = typeof options.maxAttempts === "number" && Number.isFinite(options.maxAttempts) ? Math.max(1, Math.floor(options.maxAttempts)) : 3;
+    const DEADLINE_SAFETY_BUFFER_MS = 5e3;
+    const MIN_RETRY_ATTEMPT_WINDOW_MS = 1e3;
+    const env = createCleanChildEnv(options.env);
+    env.POETIC_AGENT_ROLE = env.POETIC_AGENT_ROLE ?? "judge";
+    env.POETIC_FEATURE_ENABLE_CLAUDE_ENHANCED = "1";
+    env.POETIC_CLAUDE_ENHANCED_USE_SUBAGENTS = "0";
+    env.POETIC_CLAUDE_SKIP_BUILTIN_AGENTS = "1";
+    env.POETIC_CLAUDE_ENHANCED_RESTRICT_TOOLS = "1";
+    env.POETIC_CLAUDE_ENHANCED_TOOLS_PROFILE = "decomposition-search-only";
+    env.POETIC_CLAUDE_ENHANCED_DISALLOWED_TOOLS = CLAUDE_JUDGE_DISALLOWED_TOOLS;
+    env.POETIC_CLAUDE_ENHANCED_PERMISSION_MODE = "dontAsk";
+    env.POETIC_CLAUDE_STRICT_MCP_CONFIG = "1";
+    env.POETIC_CLAUDE_MAX_TURNS = env.POETIC_CLAUDE_MAX_TURNS ?? "2";
+    env.POETIC_CLAUDE_SAFE_MODE = "1";
+    if (provider === "claude") {
+      env.POETIC_CLAUDE_STREAM_OUTPUT = "1";
+      const isAdaptiveThinkingModel = modelSupportsAdaptiveThinking(provider, model);
+      const supportsManualThinkingBudget = modelSupportsManualThinkingBudget(provider, model);
+      if (isAdaptiveThinkingModel && !supportsManualThinkingBudget) {
+        env.CLAUDE_CODE_EFFORT_LEVEL = "high";
+      } else {
+        const budget = typeof options.thinkingBudgetTokens === "number" && Number.isFinite(options.thinkingBudgetTokens) ? Math.max(0, Math.floor(options.thinkingBudgetTokens)) : computeDefaultThinkingBudget(options);
+        env.ANTHROPIC_MAX_THINKING_TOKENS = String(budget);
+        env.MAX_THINKING_TOKENS = String(budget);
+      }
+      const requireThinking = isAdaptiveThinkingModel && !supportsManualThinkingBudget ? false : options.requireThinking ?? true;
+      if (requireThinking) {
+        env.POETIC_JUDGE_REQUIRE_THINKING = "1";
+      }
+      if (typeof options.temperature === "number") {
+        env.CLAUDE_TEMPERATURE = String(options.temperature);
+      }
+    }
+    if (!options.progressWriter && env[POETIC_PROVIDER_STREAMING.name] === void 0 && readEnv(POETIC_PROVIDER_STREAMING).source !== "env") {
+      env[POETIC_PROVIDER_STREAMING.name] = "0";
+    }
+    const progressEnv = { ...process.env, ...env };
+    const progressReporter = createProviderLiveProgressReporter({
+      label: options.progressLabel ?? "AI judge",
+      provider,
+      enabled: options.showProgress !== false,
+      env: progressEnv,
+      write: options.progressWriter
+    });
+    const started = performance.now();
+    const retryResult = await withRetry(
+      async () => {
+        let attemptTimeoutMs = baseTimeoutMs;
+        if (options.deadlineMs != null) {
+          const remainingBudgetMs = options.deadlineMs - Date.now() - DEADLINE_SAFETY_BUFFER_MS;
+          if (remainingBudgetMs <= 0) {
+            throw new ProviderExecutionError("Judge deadline exceeded before attempt start.", {
+              retryable: false,
+              reason: "deadline_exhausted"
+            });
+          }
+          attemptTimeoutMs = Math.max(1, Math.min(baseTimeoutMs, remainingBudgetMs));
+        }
+        const result = await runProviderNative({
+          provider,
+          prompt,
+          workingDir,
+          abortSignal: options.abortSignal,
+          model,
+          env,
+          timeoutMs: attemptTimeoutMs,
+          deadlineMs: options.deadlineMs,
+          executionIntent: "analysis",
+          // Honor a provider-declared judge boundary while preserving the
+          // configured transport contract for providers without an override.
+          ...judgeTransport ? { transport: judgeTransport } : {},
+          presentationProfile: "structured-stream",
+          onData: void 0,
+          onErrorData: void 0,
+          onActivity: (activity) => {
+            progressReporter.onActivity(activity);
+          },
+          onStreamEvent: (event) => {
+            progressReporter.onStreamEvent(event);
+          }
+        });
+        if (result.exitCode !== 0) {
+          const TRANSIENT_EXIT_CODES = /* @__PURE__ */ new Set([124, 137, 143]);
+          const exitCode = result.exitCode ?? -1;
+          const isTransient = result.exitCode !== void 0 && TRANSIENT_EXIT_CODES.has(result.exitCode);
+          throw new ProviderExecutionError(
+            `Judge provider '${provider}' exited with code ${exitCode}`,
+            {
+              // Only transient process failures are retryable; deterministic failures are terminal.
+              retryable: isTransient,
+              reason: isTransient ? "transient_failure" : "nonzero_exit",
+              exitCode,
+              stderr: result.stderr
+            }
+          );
+        }
+        const output = (result.stdout ?? "").trim();
+        if (output.length === 0) {
+          const details = (result.stderr ?? "").trim();
+          throw new ProviderExecutionError(`Judge provider '${provider}' returned empty output.`, {
+            // Empty stdout is often transient provider behavior and can recover on retry.
+            retryable: true,
+            reason: "empty_output",
+            stderr: details
+          });
+        }
+        return {
+          output,
+          tokenUsage: result.tokenUsage,
+          totalCostUsd: result.totalCostUsd,
+          thinkingBlocksObserved: result.thinkingBlocksObserved,
+          sandboxProvenance: result.sandboxProvenance,
+          sandboxEvidence: result.sandboxEvidence
+        };
+      },
+      {
+        maxAttempts,
+        initialDelayMs: 2e3,
+        maxDelayMs: 3e4,
+        backoffMultiplier: 2,
+        providerName: provider,
+        operation: "judge_evaluate",
+        deadlineMs: options.deadlineMs,
+        minimumAttemptTimeMs: MIN_RETRY_ATTEMPT_WINDOW_MS,
+        abortSignal: options.abortSignal
+      }
+    );
+    const durationMs = Math.round(performance.now() - started);
+    return {
+      output: retryResult.result.output,
+      provider,
+      model,
+      durationMs,
+      tokenUsage: retryResult.result.tokenUsage,
+      totalCostUsd: retryResult.result.totalCostUsd,
+      thinkingBlocksObserved: retryResult.result.thinkingBlocksObserved,
+      sandboxProvenance: retryResult.result.sandboxProvenance,
+      sandboxEvidence: retryResult.result.sandboxEvidence
+    };
+  }
+};
+
+export {
+  createProviderLiveProgressReporter,
+  LlmJudgeExecutor
+};
+//# sourceMappingURL=chunk-2A5CILN3.js.map

package/dist/chunk-2AQUWJPW.js

@@ -0,0 +1,225 @@
+import {
+  isActiveRunStatus,
+  isCompletedRunStatus,
+  isFailedRunStatus,
+  normalizeRunStatus
+} from "./chunk-44N5WZZH.js";
+
+// src/core/progress/activity-identity.ts
+function identitySegment(value) {
+  return encodeURIComponent(value.trim());
+}
+function canonicalPoeticObjectKey(ref) {
+  const ownIdentity = `${ref.kind}:${identitySegment(ref.id)}`;
+  return ref.parent ? `${canonicalPoeticObjectKey({ ...ref.parent })}/${ownIdentity}` : ownIdentity;
+}
+function canonicalRunInstanceKey(run) {
+  const displayIdentity = identitySegment(run.id);
+  return run.sourcePath ? `${displayIdentity}@${identitySegment(run.sourcePath)}` : displayIdentity;
+}
+function canonicalBlockerInstanceKey(blocker) {
+  return `${identitySegment(blocker.runId)}:${identitySegment(blocker.blockerId)}`;
+}
+function canonicalBlockerRef(blocker) {
+  return {
+    kind: "blocker",
+    id: blocker.blockerId,
+    parent: { kind: "run", id: blocker.runId }
+  };
+}
+
+// src/core/progress/activity-transition-projection.ts
+var ACTIVITY_PROJECTION_LIMIT = 40;
+var QUEUED_RUN_STATUSES = /* @__PURE__ */ new Set(["pending", "queued", "starting", "submitted", "submitting"]);
+function parseTimestamp(value) {
+  if (!value) return void 0;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : void 0;
+}
+function snapshotTimestamp(snapshot, observedAt) {
+  return parseTimestamp(snapshot.generatedAt) ?? observedAt;
+}
+function runTimestamp(run, snapshot, observedAt) {
+  return parseTimestamp(run.updatedAt) ?? (Number.isFinite(run.startedAtMs) ? run.startedAtMs : void 0) ?? snapshotTimestamp(snapshot, observedAt);
+}
+function compactLabel(value, fallback) {
+  const normalized = value?.trim().replace(/\s+/g, " ") || fallback;
+  const limit = 96;
+  return normalized.length <= limit ? normalized : `${normalized.slice(0, limit - 3)}...`;
+}
+function runProjection(run) {
+  const status = normalizeRunStatus(run.status);
+  if (QUEUED_RUN_STATUSES.has(status)) {
+    return { stateKey: "queued", kind: "phase", phase: "queued" };
+  }
+  if (isActiveRunStatus(status)) {
+    return { stateKey: "started", kind: "phase", phase: "started" };
+  }
+  if (isCompletedRunStatus(status)) {
+    return { stateKey: "completed", kind: "phase", phase: "completed" };
+  }
+  if (isFailedRunStatus(status)) {
+    const cancelled = status === "cancelled" || status === "canceled";
+    return {
+      stateKey: cancelled ? "cancelled" : "failed",
+      kind: "outcome",
+      outcome: cancelled ? "cancelled" : "failed"
+    };
+  }
+  return void 0;
+}
+function projectRun(run, projection, occurredAt) {
+  const runRef = { kind: "run", id: run.id };
+  const title = compactLabel(run.title, run.id);
+  const id = `activity:run:${canonicalRunInstanceKey(run)}:${projection.stateKey}`;
+  if (projection.kind === "outcome") {
+    const outcomeLabel = projection.outcome === "cancelled" ? "cancelled" : "failed";
+    return {
+      activity: {
+        kind: "outcome",
+        id,
+        occurredAt,
+        message: `Run ${outcomeLabel}: ${title}`,
+        subject: runRef,
+        outcome: projection.outcome
+      },
+      objectRefs: [runRef]
+    };
+  }
+  const phaseLabel = {
+    queued: "queued",
+    started: "started",
+    completed: "completed"
+  };
+  return {
+    activity: {
+      kind: "run",
+      id,
+      occurredAt,
+      message: `Run ${phaseLabel[projection.phase]}: ${title}`,
+      run: runRef,
+      phase: projection.phase
+    },
+    objectRefs: [runRef]
+  };
+}
+function projectBlocker(blocker, occurredAt) {
+  const runRef = { kind: "run", id: blocker.runId };
+  const blockerRef = canonicalBlockerRef(blocker);
+  return {
+    activity: {
+      kind: "blocker",
+      id: `activity:blocker:${canonicalBlockerInstanceKey(blocker)}:raised`,
+      occurredAt,
+      message: `Needs attention: ${compactLabel(blocker.question, blocker.blockerId)}`,
+      blocker: blockerRef,
+      subject: runRef,
+      state: "raised"
+    },
+    objectRefs: [blockerRef, runRef]
+  };
+}
+function projectDecision(decision, occurredAt) {
+  const decisionRef = {
+    kind: "decision",
+    id: decision.id
+  };
+  return {
+    activity: {
+      kind: "decision",
+      id: `activity:decision:${decision.id}:proposed`,
+      occurredAt,
+      message: `Decision pending: ${compactLabel(decision.title, decision.id)}`,
+      decision: decisionRef,
+      state: "proposed"
+    },
+    objectRefs: [decisionRef]
+  };
+}
+function asConversationEvent(projected) {
+  return {
+    kind: "activity",
+    id: `conversation:${projected.activity.id}`,
+    createdAt: projected.activity.occurredAt,
+    objectRefs: projected.objectRefs,
+    activity: projected.activity
+  };
+}
+function boundedLimit(value) {
+  if (value === void 0) return ACTIVITY_PROJECTION_LIMIT;
+  if (!Number.isFinite(value)) return ACTIVITY_PROJECTION_LIMIT;
+  return Math.min(ACTIVITY_PROJECTION_LIMIT, Math.max(0, Math.floor(value)));
+}
+function projectActivityTransitions(options) {
+  const fallbackTimestamp = options.observedAt !== void 0 && Number.isFinite(options.observedAt) ? options.observedAt : 0;
+  const previousRuns = new Map(
+    options.previous?.runs.map((run) => [canonicalRunInstanceKey(run), run])
+  );
+  const previousBlockers = new Set(
+    options.previous?.pendingBlockers.map(canonicalBlockerInstanceKey)
+  );
+  const previousDecisions = new Set(
+    options.previous?.promotedDecisions.map((decision) => decision.id)
+  );
+  const projected = [];
+  for (const run of new Map(
+    options.current.runs.map((item) => [canonicalRunInstanceKey(item), item])
+  ).values()) {
+    const currentProjection = runProjection(run);
+    if (!currentProjection) continue;
+    const previousRun = previousRuns.get(canonicalRunInstanceKey(run));
+    const previousProjection = previousRun ? runProjection(previousRun) : void 0;
+    if (previousProjection?.stateKey === currentProjection.stateKey) continue;
+    if (previousRun && options.previous) {
+      const currentOccurredAt = runTimestamp(run, options.current, fallbackTimestamp);
+      const previousOccurredAt = runTimestamp(previousRun, options.previous, fallbackTimestamp);
+      const previousObservedAt = snapshotTimestamp(options.previous, fallbackTimestamp);
+      const regressed = currentOccurredAt < previousOccurredAt;
+      const recoveredInsideObservedWindow = previousOccurredAt < previousObservedAt && currentOccurredAt <= previousObservedAt;
+      if (regressed || recoveredInsideObservedWindow) continue;
+    }
+    projected.push(
+      projectRun(run, currentProjection, runTimestamp(run, options.current, fallbackTimestamp))
+    );
+  }
+  const occurredAt = snapshotTimestamp(options.current, fallbackTimestamp);
+  for (const blocker of new Map(
+    options.current.pendingBlockers.map((item) => [canonicalBlockerInstanceKey(item), item])
+  ).values()) {
+    if (!previousBlockers.has(canonicalBlockerInstanceKey(blocker))) {
+      projected.push(projectBlocker(blocker, occurredAt));
+    }
+  }
+  for (const decision of new Map(
+    options.current.promotedDecisions.map((item) => [item.id, item])
+  ).values()) {
+    if (!previousDecisions.has(decision.id)) {
+      projected.push(projectDecision(decision, occurredAt));
+    }
+  }
+  const limit = boundedLimit(options.limit);
+  if (limit === 0) return [];
+  return projected.map(asConversationEvent).sort((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id)).slice(-limit);
+}
+function formatActivityObjectRefs(refs) {
+  const uniqueRefs = new Map(refs.map((ref) => [canonicalPoeticObjectKey(ref), ref]));
+  const visibleRefs = [...uniqueRefs.values()].slice(0, 2);
+  const labels = visibleRefs.map((ref) => `${ref.kind} ${ref.id}`);
+  const hiddenCount = uniqueRefs.size - visibleRefs.length;
+  if (hiddenCount > 0) labels.push(`${hiddenCount} more`);
+  return labels.join(", ");
+}
+function formatConversationActivityText(event) {
+  const objectIdentity = formatActivityObjectRefs(event.objectRefs);
+  const suffix = objectIdentity.length > 0 ? ` | ${objectIdentity}` : "";
+  return `Activity: ${event.activity.message}${suffix}`;
+}
+
+export {
+  identitySegment,
+  canonicalRunInstanceKey,
+  canonicalBlockerInstanceKey,
+  projectActivityTransitions,
+  formatConversationActivityText
+};
+//# sourceMappingURL=chunk-2AQUWJPW.js.map