@poetic-ai/poetic 1.42.0

package/dist/chunk-7GDRQBQC.js

@@ -0,0 +1,419 @@
+import {
+  isLabModeFromEnv
+} from "./chunk-PGSPX4SU.js";
+import {
+  resolveProjectRuntimeDir
+} from "./chunk-RGWHUI5E.js";
+import {
+  resolvePoeticRoot
+} from "./chunk-LEIIWPWQ.js";
+import {
+  POETIC_LAB_BASELINE,
+  POETIC_LAB_ID,
+  POETIC_LAB_RUN_ID,
+  POETIC_WORKTREE_BASE,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/orchestrator/lab-mode.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createHash } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var labContextStorage = new AsyncLocalStorage();
+var LabPathResolver = class _LabPathResolver {
+  static instance = null;
+  /** Process-wide fallback for single-run CLI / tests outside ALS. */
+  legacySlot = { context: null, source: null };
+  incompleteEnvWarningEmitted = false;
+  constructor() {
+  }
+  resolveSlot() {
+    return labContextStorage.getStore() ?? this.legacySlot;
+  }
+  isEnvLabModeEnabled() {
+    return isLabModeFromEnv();
+  }
+  hydrateContextFromEnv() {
+    const slot = this.resolveSlot();
+    if (slot.source === "cleared") {
+      return;
+    }
+    if (!this.isEnvLabModeEnabled()) {
+      if (slot.source === "env") {
+        slot.context = null;
+        slot.source = null;
+      }
+      return;
+    }
+    if (slot.source === "explicit") {
+      return;
+    }
+    const labId = readEnv(POETIC_LAB_ID).value;
+    const runId = readEnv(POETIC_LAB_RUN_ID).value;
+    if (!labId || !runId) {
+      if (!this.incompleteEnvWarningEmitted) {
+        this.incompleteEnvWarningEmitted = true;
+        console.warn(
+          "[LabPathResolver] POETIC_LAB_MODE is enabled but lab context is incomplete. Ignoring lab mode until both POETIC_LAB_ID and POETIC_LAB_RUN_ID are set."
+        );
+      }
+      return;
+    }
+    slot.context = {
+      labId,
+      runId,
+      baseline: readEnv(POETIC_LAB_BASELINE).value ?? "HEAD",
+      task: "env"
+    };
+    slot.source = "env";
+    this.incompleteEnvWarningEmitted = false;
+  }
+  /**
+   * Gets the singleton instance of the resolver.
+   */
+  static getInstance() {
+    if (!_LabPathResolver.instance) {
+      _LabPathResolver.instance = new _LabPathResolver();
+    }
+    return _LabPathResolver.instance;
+  }
+  /**
+   * True when the current async tree has an ALS lab slot (not merely legacy fallback).
+   */
+  hasScopedContext() {
+    return labContextStorage.getStore() !== void 0;
+  }
+  /**
+   * Run asynchronous work with an isolated lab slot pre-loaded with context.
+   */
+  runWithContextAsync(context, fn) {
+    return labContextStorage.run({ context: { ...context }, source: "explicit" }, fn);
+  }
+  /**
+   * Enter an empty isolated slot for asynchronous setup and execution.
+   */
+  runIsolatedAsync(fn) {
+    return labContextStorage.run({ context: null, source: null }, fn);
+  }
+  /**
+   * Bind delayed lifecycle work (signals, beforeExit, deferred cleanup) to the
+   * current slot. EventEmitter callbacks otherwise inherit the emitter's async
+   * context, which can be the production/legacy slot rather than the lab run
+   * that registered the cleanup.
+   */
+  bindCurrentContext(fn) {
+    const current = this.resolveSlot();
+    const captured = {
+      context: current.context ? { ...current.context } : null,
+      source: current.source
+    };
+    return (...args) => labContextStorage.run(
+      {
+        context: captured.context ? { ...captured.context } : null,
+        source: captured.source
+      },
+      () => fn(...args)
+    );
+  }
+  /**
+   * Sets the lab context for the current execution (scoped slot if active, else legacy).
+   * Must be called explicitly before path resolution when lab mode is active.
+   */
+  setContext(context) {
+    const slot = this.resolveSlot();
+    slot.context = context;
+    slot.source = "explicit";
+    this.incompleteEnvWarningEmitted = false;
+  }
+  /**
+   * Clears the lab context for the active slot only, returning that slot to
+   * standard path behavior. Concurrent ALS trees are unaffected.
+   * Must be called after lab execution to prevent state leakage.
+   */
+  clearContext() {
+    const slot = this.resolveSlot();
+    slot.context = null;
+    slot.source = "cleared";
+  }
+  /**
+   * Returns true if lab mode is currently active for the active slot.
+   */
+  isLabMode() {
+    this.hydrateContextFromEnv();
+    return this.resolveSlot().context !== null;
+  }
+  /**
+   * Returns the current lab context for the active slot, or null if not active.
+   */
+  getContext() {
+    this.hydrateContextFromEnv();
+    return this.resolveSlot().context;
+  }
+  /**
+   * Helper method to construct lab-specific or standard paths.
+   * Reduces duplication and prevents copy-paste errors in path resolution.
+   */
+  getBasePath(poeticDir, subpath) {
+    if (!this.isLabMode()) {
+      return path.join(poeticDir, subpath);
+    }
+    const context = this.resolveSlot().context;
+    if (!context) {
+      return path.join(poeticDir, subpath);
+    }
+    const labsDir = path.basename(path.resolve(poeticDir)) === ".poetic" ? resolveProjectRuntimeDir(poeticDir, "labs") : path.join(poeticDir, "labs");
+    return path.join(labsDir, context.labId, "runs", context.runId, subpath);
+  }
+  /**
+   * Resolves the telemetry directory path.
+   * Lab mode: `.poetic/labs/{labId}/runs/{runId}/telemetry/`
+   * Standard: `{poeticDir}/telemetry/`
+   */
+  getTelemetryDir(poeticDir) {
+    return this.getBasePath(poeticDir, "telemetry");
+  }
+  /**
+   * Resolves the state directory path.
+   * Lab mode: `.poetic/labs/{labId}/runs/{runId}/state/`
+   * Standard: `{poeticDir}/telemetry/state/`
+   */
+  getStateDir(poeticDir) {
+    if (!this.isLabMode()) {
+      return path.join(poeticDir, "telemetry", "state");
+    }
+    return this.getBasePath(poeticDir, "state");
+  }
+  /**
+   * Resolves the worktree base directory path.
+   * Lab mode: `.poetic/labs/{labId}/runs/{runId}/worktrees/`
+   * Standard: POETIC_WORKTREE_BASE env or `/tmp/poetic-worktrees`
+   */
+  getWorktreeBaseDir(poeticDir) {
+    if (!this.isLabMode()) {
+      return readEnv(POETIC_WORKTREE_BASE).value ?? "/tmp/poetic-worktrees";
+    }
+    return this.getBasePath(poeticDir, "worktrees");
+  }
+  /**
+   * Resolves the artifact storage directory path.
+   * Lab mode: `.poetic/labs/{labId}/runs/{runId}/artifacts/`
+   * Standard: `{poeticDir}/artifacts/`
+   */
+  getArtifactDir(poeticDir) {
+    if (!this.isLabMode()) {
+      return path.join(poeticDir, "artifacts");
+    }
+    return this.getBasePath(poeticDir, "artifacts");
+  }
+  /**
+   * Resolves the logs directory path.
+   * Lab mode: `.poetic/labs/{labId}/runs/{runId}/logs/`
+   * Standard: `{poeticDir}/telemetry/logs/`
+   */
+  getLogsDir(poeticDir) {
+    if (!this.isLabMode()) {
+      return path.join(poeticDir, "telemetry", "logs");
+    }
+    return this.getBasePath(poeticDir, "logs");
+  }
+};
+function runWithLabContextAsync(context, fn) {
+  return LabPathResolver.getInstance().runWithContextAsync(context, fn);
+}
+function generateLabId(task, baseline) {
+  const normalizedTask = task.trim().toLowerCase();
+  const normalizedBaseline = baseline.trim();
+  const input = `${normalizedTask}:${normalizedBaseline}`;
+  const hash = createHash("sha256").update(input).digest("hex");
+  return `lab-${hash.substring(0, 8)}`;
+}
+function generateRunId() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  const suffix = String(Math.floor(Math.random() * 1e3)).padStart(3, "0");
+  return `${year}${month}${day}-${hours}${minutes}${seconds}-${suffix}`;
+}
+function createLabContext(task, baseline = "HEAD") {
+  const labId = generateLabId(task, baseline);
+  const runId = generateRunId();
+  return {
+    labId,
+    runId,
+    baseline,
+    task
+  };
+}
+function resolveDefaultPoeticDir() {
+  return path.join(resolvePoeticRoot(process.cwd()), ".poetic");
+}
+function validateLabConfig() {
+  const errors = [];
+  const labId = readEnv(POETIC_LAB_ID).value;
+  if (labId !== void 0) {
+    if (!/^[a-zA-Z0-9-_]+$/.test(labId)) {
+      errors.push(
+        "POETIC_LAB_ID must contain only alphanumeric characters, hyphens, and underscores"
+      );
+    }
+  }
+  const runId = readEnv(POETIC_LAB_RUN_ID).value;
+  if (runId !== void 0) {
+    if (!/^\d{8}-\d{6}-\d{3}$/.test(runId)) {
+      errors.push(
+        "POETIC_LAB_RUN_ID must match format YYYYMMDD-HHMMSS-NNN (e.g., 20251220-195415-748)"
+      );
+    }
+  }
+  const labBaselineResult = readEnv(POETIC_LAB_BASELINE);
+  const baseline = labBaselineResult.source === "env" ? labBaselineResult.value : void 0;
+  if (baseline !== void 0) {
+    if (baseline.trim().length === 0) {
+      errors.push("POETIC_LAB_BASELINE must not be empty");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function verifyLabMode() {
+  const resolver = LabPathResolver.getInstance();
+  const context = resolver.getContext();
+  if (!context) {
+    return { active: false, context: null, paths: null };
+  }
+  const poeticDir = resolveDefaultPoeticDir();
+  return {
+    active: true,
+    context,
+    paths: {
+      telemetry: resolver.getTelemetryDir(poeticDir),
+      state: resolver.getStateDir(poeticDir),
+      worktrees: resolver.getWorktreeBaseDir(poeticDir),
+      logs: resolver.getLogsDir(poeticDir)
+    }
+  };
+}
+function initializeLabModeFromEnv(task) {
+  const isLabModeEnabled = isLabModeFromEnv();
+  if (!isLabModeEnabled) {
+    return false;
+  }
+  const baseline = readEnv(POETIC_LAB_BASELINE).value ?? "HEAD";
+  const customLabId = readEnv(POETIC_LAB_ID).value;
+  const customRunId = readEnv(POETIC_LAB_RUN_ID).value;
+  const resolver = LabPathResolver.getInstance();
+  if (customLabId && customRunId) {
+    resolver.setContext({
+      labId: customLabId,
+      runId: customRunId,
+      baseline,
+      task
+    });
+  } else if (customLabId) {
+    resolver.setContext({
+      labId: customLabId,
+      runId: generateRunId(),
+      baseline,
+      task
+    });
+  } else {
+    const context = createLabContext(task, baseline);
+    resolver.setContext(context);
+  }
+  return true;
+}
+function getMostRecentLabRun() {
+  const poeticDir = resolveDefaultPoeticDir();
+  const labsDir = resolveProjectRuntimeDir(poeticDir, "labs");
+  if (!fs.existsSync(labsDir)) {
+    return null;
+  }
+  let mostRecentRun = null;
+  let mostRecentTimestamp = 0;
+  try {
+    const labIds = fs.readdirSync(labsDir);
+    for (const labId of labIds) {
+      const runsDir = path.join(labsDir, labId, "runs");
+      if (!fs.existsSync(runsDir)) {
+        continue;
+      }
+      const runIds = fs.readdirSync(runsDir);
+      for (const runId of runIds) {
+        const match = /^(\d{8})-(\d{6})-(\d{3})$/.exec(runId);
+        if (!match) {
+          continue;
+        }
+        const dateStr = match[1] ?? "";
+        const timeStr = match[2] ?? "";
+        const year = Number.parseInt(dateStr.substring(0, 4), 10);
+        const month = Number.parseInt(dateStr.substring(4, 6), 10) - 1;
+        const day = Number.parseInt(dateStr.substring(6, 8), 10);
+        const hours = Number.parseInt(timeStr.substring(0, 2), 10);
+        const minutes = Number.parseInt(timeStr.substring(2, 4), 10);
+        const seconds = Number.parseInt(timeStr.substring(4, 6), 10);
+        const timestamp = new Date(year, month, day, hours, minutes, seconds).getTime();
+        if (timestamp > mostRecentTimestamp) {
+          mostRecentTimestamp = timestamp;
+          mostRecentRun = {
+            labId,
+            runId,
+            baseline: "HEAD",
+            // We don't store this, default to HEAD
+            task: "unknown"
+            // We don't store this
+          };
+        }
+      }
+    }
+  } catch (_error) {
+    return null;
+  }
+  return mostRecentRun;
+}
+function getLabWarningStateFile() {
+  return path.join(resolveDefaultPoeticDir(), ".last-lab-warning");
+}
+function checkAndWarnLabContext() {
+  const resolver = LabPathResolver.getInstance();
+  if (resolver.isLabMode()) {
+    return;
+  }
+  const warningStateFile = getLabWarningStateFile();
+  if (fs.existsSync(warningStateFile)) {
+    return;
+  }
+  const recentLabRun = getMostRecentLabRun();
+  if (!recentLabRun) {
+    return;
+  }
+  const poeticDir = resolveDefaultPoeticDir();
+  const labPath = path.join(poeticDir, "labs", recentLabRun.labId, "runs", recentLabRun.runId);
+  console.log(
+    `Note: Most recent run was lab (${recentLabRun.labId}). Use --lab to continue in lab mode, or view results at: ${labPath}`
+  );
+  try {
+    fs.writeFileSync(warningStateFile, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+
+export {
+  LabPathResolver,
+  runWithLabContextAsync,
+  generateLabId,
+  generateRunId,
+  createLabContext,
+  validateLabConfig,
+  verifyLabMode,
+  initializeLabModeFromEnv,
+  getMostRecentLabRun,
+  checkAndWarnLabContext
+};
+//# sourceMappingURL=chunk-7GDRQBQC.js.map

package/dist/chunk-7GPCEFUV.js

@@ -0,0 +1,270 @@
+import {
+  readProviderDryRunFreshness
+} from "./chunk-IKFP2KUR.js";
+import {
+  getProviderHealth
+} from "./chunk-UHRBTZYY.js";
+import {
+  classifyProviderReadiness,
+  getProviderReadiness,
+  probeProviderAuthReadiness,
+  probeProviderCli,
+  resolveNamedReadiness
+} from "./chunk-AURFMVCD.js";
+import {
+  resolveProviderReleaseStatus
+} from "./chunk-VBNCKCCI.js";
+import {
+  normalizeEngineId,
+  resolveProviderCliCommand
+} from "./chunk-SURZ2WFE.js";
+import {
+  getProviderConfig
+} from "./chunk-AT4TNPWW.js";
+
+// src/core/providers/provider-matrix.ts
+import { createHash } from "crypto";
+var MATRIX_CACHE_TTL_MS = 6e4;
+var matrixCache = /* @__PURE__ */ new Map();
+function buildAuthProbeEnvCacheKey(env) {
+  if (!env) return "";
+  const serialized = Object.entries(env).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}=${value ?? ""}`).join("\0");
+  return createHash("sha256").update(serialized).digest("hex");
+}
+function buildCacheKey(options) {
+  return `${options.providerFilter ?? ""}:${String(options.probeAuth ?? false)}:${buildAuthProbeEnvCacheKey(options.authProbeEnv)}`;
+}
+var MATRIX_PROVIDER_SPECS = [
+  { id: "claude", versionArgs: ["--version"] },
+  { id: "codex", versionArgs: ["--version"] },
+  { id: "grok", versionArgs: ["--version"] },
+  { id: "cursor", versionArgs: ["--version"] },
+  { id: "opencode", versionArgs: ["--version"] },
+  { id: "gemini", versionArgs: ["--version"] },
+  { id: "copilot", versionArgs: ["--version"] },
+  { id: "kiro", versionArgs: ["--version"] },
+  { id: "pi", versionArgs: ["--version"] },
+  { id: "antigravity", versionArgs: ["--version"] }
+];
+var MATRIX_PROVIDER_IDS = MATRIX_PROVIDER_SPECS.map((spec) => spec.id);
+var MATRIX_PROVIDER_SPEC_IDS = MATRIX_PROVIDER_IDS;
+function getOrderedMatrixProviderSpecs() {
+  return [...MATRIX_PROVIDER_SPECS].sort((a, b) => {
+    const orderA = getProviderConfig(a.id).order;
+    const orderB = getProviderConfig(b.id).order;
+    return orderA - orderB;
+  });
+}
+function mapAuthReadinessState(state) {
+  if (state === "yes") return true;
+  if (state === "no") return false;
+  return "unknown";
+}
+function classifyMatrixProbeRow(input) {
+  const authClassification = (() => {
+    if (!input.probeAuth || input.authReady === "skipped") {
+      return {
+        authEvidence: "not-collected",
+        authDetail: "Authentication status was not collected for this matrix row."
+      };
+    }
+    if (input.authReady === true) {
+      return {
+        authEvidence: "provider-reported",
+        authDetail: "Passive provider readiness reported authentication available."
+      };
+    }
+    if (input.authReady === false) {
+      return {
+        authEvidence: "reported-missing",
+        authDetail: "Passive provider readiness reported authentication missing."
+      };
+    }
+    return {
+      authEvidence: "passive-unknown",
+      authDetail: "Passive provider readiness could not verify provider-owned auth state."
+    };
+  })();
+  if (!input.cliPresent) {
+    return {
+      readinessStatus: "unavailable",
+      readinessStatusDetail: "CLI is not installed.",
+      ...authClassification
+    };
+  }
+  if (input.cliDegraded || input.runtimeDegraded) {
+    return {
+      readinessStatus: "broken",
+      readinessStatusDetail: "CLI or runtime health is degraded.",
+      ...authClassification
+    };
+  }
+  if (input.probeAuth && input.authReady === true) {
+    return {
+      readinessStatus: "normal-auth-ready",
+      readinessStatusDetail: "CLI is installed and passive auth readiness evidence is present.",
+      ...authClassification
+    };
+  }
+  if (input.probeAuth && input.authReady === false) {
+    return {
+      readinessStatus: "normal-auth-needed",
+      readinessStatusDetail: "CLI is installed, but authentication is missing.",
+      ...authClassification
+    };
+  }
+  return {
+    readinessStatus: "installed-but-unverified",
+    readinessStatusDetail: "CLI is installed, but auth or execution readiness is not verified by this matrix probe.",
+    ...authClassification
+  };
+}
+async function collectProviderMatrix(options) {
+  const probeAuth = options?.probeAuth ?? false;
+  const forceRefresh = options?.forceRefresh ?? false;
+  const providerFilter = options?.providerFilter ? normalizeEngineId(options.providerFilter.trim()) : void 0;
+  if (!forceRefresh) {
+    const cacheKey2 = buildCacheKey({
+      probeAuth,
+      providerFilter,
+      authProbeEnv: options?.authProbeEnv
+    });
+    const cached = matrixCache.get(cacheKey2);
+    if (cached && Date.now() - cached.timestamp < MATRIX_CACHE_TTL_MS) {
+      return cached.result;
+    }
+  }
+  const orderedSpecs = getOrderedMatrixProviderSpecs();
+  const specs = providerFilter ? orderedSpecs.filter((s) => s.id === providerFilter) : orderedSpecs;
+  if (providerFilter && specs.length === 0) {
+    throw new Error(
+      `Unknown provider "${options?.providerFilter}". Known providers: ${MATRIX_PROVIDER_IDS.join(", ")}`
+    );
+  }
+  const rows = [];
+  for (const spec of specs) {
+    let displayName = spec.id;
+    let tier = "supported";
+    let releaseStatus = "experimental";
+    try {
+      const config = getProviderConfig(spec.id);
+      displayName = config.display_name || config.name || spec.id;
+      tier = config.experimental ? "experimental" : "supported";
+      releaseStatus = resolveProviderReleaseStatus(config);
+    } catch {
+      tier = "experimental";
+      releaseStatus = "experimental";
+    }
+    let command;
+    let prefixArgs;
+    try {
+      const resolved = resolveProviderCliCommand(spec.id);
+      command = resolved.command;
+      prefixArgs = resolved.prefixArgs;
+    } catch {
+      command = void 0;
+    }
+    let cliPresent = false;
+    let cliDegraded = false;
+    if (command) {
+      const probe = await probeProviderCli(command, spec.versionArgs, prefixArgs);
+      cliPresent = probe.present;
+      if (probe.present && !probe.healthy) {
+        cliDegraded = true;
+      }
+    }
+    let authReady = "skipped";
+    if (probeAuth && cliPresent) {
+      authReady = mapAuthReadinessState(
+        await probeProviderAuthReadiness(spec.id, void 0, {
+          mode: "passive",
+          ...options?.authProbeEnv ? { env: options.authProbeEnv } : {}
+        })
+      );
+    }
+    let healthScore = null;
+    let degraded = false;
+    let lastFailurePhase;
+    if (cliPresent) {
+      const snapshot = getProviderHealth(spec.id);
+      healthScore = snapshot.score;
+      degraded = snapshot.degraded || cliDegraded;
+      lastFailurePhase = snapshot.lastFailurePhase;
+      if (cliDegraded) {
+        degraded = true;
+      }
+    }
+    const runtimeDegraded = degraded;
+    let status;
+    if (!cliPresent) {
+      status = "missing";
+    } else if (degraded || authReady === false) {
+      degraded = true;
+      status = "degraded";
+    } else {
+      status = "available";
+    }
+    const classification = classifyMatrixProbeRow({
+      cliPresent,
+      cliDegraded,
+      runtimeDegraded,
+      probeAuth,
+      authReady
+    });
+    rows.push({
+      id: spec.id,
+      displayName,
+      tier,
+      releaseStatus,
+      cliPresent,
+      authReady,
+      healthScore,
+      degraded,
+      lastFailurePhase,
+      status,
+      ...classification
+    });
+  }
+  const cacheKey = buildCacheKey({
+    probeAuth,
+    providerFilter,
+    authProbeEnv: options?.authProbeEnv
+  });
+  matrixCache.set(cacheKey, { result: rows, timestamp: Date.now() });
+  return rows;
+}
+function resolveProviderMatrixRowReadiness(row, readiness, repoRoot) {
+  const resolved = resolveNamedReadiness(readiness, readProviderDryRunFreshness(row.id, repoRoot));
+  return {
+    ...row,
+    ...classifyProviderReadiness(readiness, resolved),
+    resolved
+  };
+}
+async function enrichProviderMatrixRowsWithResolvedReadiness(rows, repoRoot, options = {}) {
+  return Promise.all(
+    rows.map(async (row) => {
+      try {
+        const readiness = await getProviderReadiness(row.id, {
+          mode: "setup",
+          sandboxProbeMode: "none",
+          ...options.authProbeEnv ? { authProbeEnv: options.authProbeEnv } : {}
+        });
+        return resolveProviderMatrixRowReadiness(row, readiness, repoRoot);
+      } catch {
+        return { ...row };
+      }
+    })
+  );
+}
+function clearProviderMatrixCacheForTest() {
+  matrixCache.clear();
+}
+
+export {
+  MATRIX_PROVIDER_SPEC_IDS,
+  collectProviderMatrix,
+  enrichProviderMatrixRowsWithResolvedReadiness,
+  clearProviderMatrixCacheForTest
+};
+//# sourceMappingURL=chunk-7GPCEFUV.js.map