@poetic-ai/poetic 1.42.0

package/dist/chunk-2VSQMRCB.js

@@ -0,0 +1,18 @@
+// src/core/providers/generated/provider-ids.ts
+var ENABLED_PROVIDER_IDS = [
+  "claude",
+  "codex",
+  "cursor",
+  "grok",
+  "opencode",
+  "antigravity",
+  "copilot",
+  "kiro",
+  "gemini",
+  "pi"
+];
+
+export {
+  ENABLED_PROVIDER_IDS
+};
+//# sourceMappingURL=chunk-2VSQMRCB.js.map

package/dist/chunk-2XQXYBM2.js

@@ -0,0 +1,130 @@
+// src/orchestrator/cli-build-lock.ts
+import { createHash } from "crypto";
+import fs from "fs";
+import * as fsPromises from "fs/promises";
+import os from "os";
+import path from "path";
+import { setTimeout as sleep } from "timers/promises";
+import { fileURLToPath } from "url";
+function resolveCliPackageRoot(fallbackRoot) {
+  let current = path.dirname(fileURLToPath(import.meta.url));
+  let distOnlyPackageRoot;
+  while (true) {
+    if (path.basename(current) === "dist" && fs.existsSync(path.join(current, "entry.js"))) {
+      distOnlyPackageRoot ??= path.dirname(current);
+    }
+    const packageJsonPath = path.join(current, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+        if (packageJson.name === "@poetic-ai/poetic") {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return distOnlyPackageRoot ?? path.resolve(fallbackRoot);
+    }
+    current = parent;
+  }
+}
+function resolveHashedTempCliBuildLockDir(packageRoot) {
+  const hash = createHash("sha256").update(packageRoot).digest("hex").slice(0, 16);
+  return path.join(os.tmpdir(), "poetic-cli-build-locks", hash);
+}
+function resolveCliBuildLockDir(repoRoot) {
+  const packageRoot = resolveCliPackageRoot(repoRoot);
+  return resolveHashedTempCliBuildLockDir(packageRoot);
+}
+async function acquireCliBuildLock(repoRoot) {
+  const lockDir = resolveCliBuildLockDir(repoRoot);
+  const lockPath = path.join(lockDir, "cli-build.lock");
+  const token = `${process.pid}:${Date.now()}:${Math.random().toString(36).slice(2)}`;
+  const deadline = Date.now() + 6e4;
+  await fsPromises.mkdir(lockDir, { recursive: true });
+  const lockOwnerIsAlive = (contents) => {
+    const pid = Number(contents.split(":", 1)[0]);
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return error.code === "EPERM";
+    }
+  };
+  const uniqueSidecarPath = (kind) => `${lockPath}.${kind}.${process.pid}.${Date.now().toString(36)}.${Math.random().toString(36).slice(2)}`;
+  const restoreLockFromSidecar = async (sidecarPath) => {
+    try {
+      await fsPromises.link(sidecarPath, lockPath);
+    } catch {
+    }
+  };
+  const reclaimStaleLock = async (expectedContents) => {
+    const reclaimPath = uniqueSidecarPath("reclaim");
+    try {
+      await fsPromises.rename(lockPath, reclaimPath);
+    } catch {
+      return;
+    }
+    let reclaimedContents = null;
+    try {
+      reclaimedContents = await fsPromises.readFile(reclaimPath, "utf8");
+    } catch {
+      reclaimedContents = null;
+    }
+    if (reclaimedContents !== null && reclaimedContents !== expectedContents) {
+      await restoreLockFromSidecar(reclaimPath);
+    }
+    await fsPromises.unlink(reclaimPath).catch(() => {
+    });
+  };
+  const releaseLock = async () => {
+    const releasePath = uniqueSidecarPath("release");
+    try {
+      await fsPromises.rename(lockPath, releasePath);
+    } catch {
+      return;
+    }
+    try {
+      const contents = await fsPromises.readFile(releasePath, "utf8");
+      if (contents.trim() !== token) {
+        await restoreLockFromSidecar(releasePath);
+      }
+    } catch {
+    }
+    await fsPromises.unlink(releasePath).catch(() => {
+    });
+  };
+  while (true) {
+    try {
+      await fsPromises.writeFile(lockPath, `${token}
+`, { flag: "wx" });
+      return releaseLock;
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") throw error;
+      try {
+        await fsPromises.stat(lockPath);
+        const contents = await fsPromises.readFile(lockPath, "utf8");
+        if (!lockOwnerIsAlive(contents)) {
+          await reclaimStaleLock(contents);
+          continue;
+        }
+      } catch {
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(
+          "Timed out waiting for another poetic process to finish rebuilding the CLI."
+        );
+      }
+      await sleep(250);
+    }
+  }
+}
+
+export {
+  acquireCliBuildLock
+};
+//# sourceMappingURL=chunk-2XQXYBM2.js.map

package/dist/chunk-2YFUIER7.js

@@ -0,0 +1,426 @@
+// src/core/providers/shared/error-parser-core.ts
+var DEFAULT_ERROR_PATTERNS = {
+  rateLimit: [
+    "rate limit",
+    "too many requests",
+    "quota exceeded",
+    "resource_exhausted",
+    // HTTP 429 must carry status-code context. A bare '429' substring matches
+    // unrelated text (counts, ids, offsets, token totals) and false-positives
+    // into a retryable classification. The worded patterns above still catch
+    // the common phrasings; these gate the numeric form to genuine HTTP status.
+    "http 429",
+    "status 429",
+    "status code 429",
+    "code: 429",
+    "429 too many requests",
+    // Colon/equals/JSON variants of the same status-code context (literal substrings).
+    "status: 429",
+    "status=429",
+    '"code":429',
+    '"code": 429'
+  ],
+  auth: [
+    "unauthorized",
+    "not authorized",
+    "access to model",
+    "invalid api key",
+    "authentication failed",
+    "api key",
+    "invalid_api_key",
+    "not authenticated",
+    "login required",
+    "authentication required",
+    "session expired",
+    "credentials invalid",
+    "could not load credentials",
+    "load credentials",
+    "credentials from any providers",
+    "unauthenticated",
+    "forbidden"
+  ],
+  network: [
+    "econnrefused",
+    "enotfound",
+    "enetunreach",
+    "network error",
+    "connection",
+    "fetch failed",
+    "etimedout",
+    "connection timeout",
+    "econnreset",
+    "eai_again",
+    "socket hang up",
+    "getaddrinfo"
+  ],
+  timeout: [
+    "timed out",
+    "execution timed out",
+    "hard_timeout",
+    "process-limiter",
+    "process timeout"
+  ],
+  validation: [
+    "invalid",
+    "unknown option",
+    "unrecognized",
+    "usage:",
+    "bad request",
+    "invalid arguments"
+  ],
+  capacity: [
+    "service unavailable",
+    "upstream connect error",
+    "upstream connection reset",
+    "disconnect/reset before headers",
+    "temporarily unavailable",
+    "server is overloaded",
+    "overloaded",
+    // Transient HTTP statuses must carry status-code context. A bare numeric
+    // substring (e.g. '503' inside "Processed 503 items") false-positives into
+    // a retryable capacity classification. The worded patterns above still
+    // catch the common phrasings; these gate the numeric forms to genuine HTTP
+    // status. Retryable transient set: 408 (request timeout), 425 (too early),
+    // 500 (internal server error), 502 (bad gateway), 503 (service
+    // unavailable), 504 (gateway timeout). 429 lives in rateLimit above.
+    // Deterministic client errors (400/401/403/404/422) and conflicts (409)
+    // are intentionally absent: retrying them only burns the retry budget.
+    // For each code: 'http <n>' / 'status <n>' / 'status code <n>' / 'code: <n>'
+    // plus the colon/equals/JSON variants 'status: <n>' / 'status=<n>' /
+    // '"code":<n>' / '"code": <n>' (all literal lowercased substrings). The bare
+    // number is deliberately excluded so it never matches counts/ids in prose.
+    "http 408",
+    "status 408",
+    "status code 408",
+    "code: 408",
+    "status: 408",
+    "status=408",
+    '"code":408',
+    '"code": 408',
+    "408 request timeout",
+    "http 425",
+    "status 425",
+    "status code 425",
+    "code: 425",
+    "status: 425",
+    "status=425",
+    '"code":425',
+    '"code": 425',
+    "http 500",
+    "status 500",
+    "status code 500",
+    "code: 500",
+    "status: 500",
+    "status=500",
+    '"code":500',
+    '"code": 500',
+    "500 internal server error",
+    "http 502",
+    "status 502",
+    "status code 502",
+    "code: 502",
+    "status: 502",
+    "status=502",
+    '"code":502',
+    '"code": 502',
+    "502 bad gateway",
+    "http 503",
+    "status 503",
+    "status code 503",
+    "code: 503",
+    "status: 503",
+    "status=503",
+    '"code":503',
+    '"code": 503',
+    "503 service unavailable",
+    "http 504",
+    "status 504",
+    "status code 504",
+    "code: 504",
+    "status: 504",
+    "status=504",
+    '"code":504',
+    '"code": 504',
+    "504 gateway timeout"
+  ],
+  contextOverflow: [
+    "maximum context length",
+    "maximum context window",
+    "max context length",
+    "max context window",
+    "context window exceeded",
+    "context length exceeded",
+    "context length exceeds",
+    "context window is full",
+    "prompt is too long",
+    "prompt too long",
+    "input is too long",
+    "request is too long",
+    "too many tokens",
+    "token limit exceeded",
+    "exceeds the token limit",
+    "maximum number of tokens"
+    // Deliberately no bare 'context window' / 'token limit' / 'request exceeds'
+    // patterns: stderr that merely mentions these phrases is not an overflow,
+    // and misclassification here makes the run non-retryable.
+  ]
+};
+var ERROR_EXIT_CODES = {
+  rateLimit: [],
+  auth: [],
+  network: [7],
+  // curl-style network error
+  timeout: [124, 137, 143, 252],
+  // timeout command, SIGKILL, SIGTERM, bash timeout
+  validation: [2]
+  // Standard "usage error"
+};
+function matchesErrorPattern(lowerCombined, pattern) {
+  const normalizedPattern = pattern.toLowerCase();
+  if (/^\d+$/.test(normalizedPattern)) {
+    return new RegExp(`(^|\\D)${normalizedPattern}(\\D|$)`).test(lowerCombined);
+  }
+  return lowerCombined.includes(normalizedPattern);
+}
+function isRateLimitError(combined, exitCode, patterns = DEFAULT_ERROR_PATTERNS.rateLimit) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern)) || exitCode !== void 0 && ERROR_EXIT_CODES.rateLimit.includes(exitCode);
+}
+function isAuthError(combined, exitCode, patterns = DEFAULT_ERROR_PATTERNS.auth) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern)) || exitCode !== void 0 && ERROR_EXIT_CODES.auth.includes(exitCode);
+}
+function isNetworkError(combined, exitCode, patterns = DEFAULT_ERROR_PATTERNS.network) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern)) || exitCode !== void 0 && ERROR_EXIT_CODES.network.includes(exitCode);
+}
+function isTimeoutError(combined, exitCode, patterns = DEFAULT_ERROR_PATTERNS.timeout) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern)) || exitCode !== void 0 && ERROR_EXIT_CODES.timeout.includes(exitCode);
+}
+function isValidationError(combined, exitCode, patterns = DEFAULT_ERROR_PATTERNS.validation) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern)) || exitCode !== void 0 && ERROR_EXIT_CODES.validation.includes(exitCode);
+}
+function isContextOverflowError(combined, patterns = DEFAULT_ERROR_PATTERNS.contextOverflow) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern));
+}
+function isCapacityError(combined, _exitCode, patterns = DEFAULT_ERROR_PATTERNS.capacity) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern));
+}
+function extractRetryAfter(combined, defaultSeconds = 60) {
+  const headerMatch = combined.match(/retry[- _]after["']?[:\s]+(\d+)/i);
+  if (headerMatch?.[1]) {
+    return parseInt(headerMatch[1], 10);
+  }
+  const naturalMatch = combined.match(/rate\s+limit[\s\S]{0,100}?(\d+)\s*seconds?/i);
+  if (naturalMatch?.[1]) {
+    return parseInt(naturalMatch[1], 10);
+  }
+  const waitMatch = combined.match(/(?:wait|try again in)\s+(\d+)\s*seconds?/i);
+  if (waitMatch?.[1]) {
+    return parseInt(waitMatch[1], 10);
+  }
+  return defaultSeconds;
+}
+function createRateLimitError(errorOutput, exitCode, providerName, defaultRetryAfter = 60) {
+  const retryAfterSeconds = extractRetryAfter(errorOutput, defaultRetryAfter);
+  return {
+    type: "rate_limit",
+    retryable: true,
+    retryAfter: retryAfterSeconds,
+    userMessage: `${providerName} API rate limit exceeded. Will retry after ${retryAfterSeconds}s cooldown.`,
+    debugInfo: {
+      exitCode,
+      retryAfterSeconds
+    },
+    originalError: errorOutput
+  };
+}
+function createAuthError(stderr, exitCode, authMessage, context, telemetryCallback) {
+  if (telemetryCallback && context) {
+    let errorType = "unknown";
+    const lowerStderr = stderr.toLowerCase();
+    const lowerMessage = authMessage.toLowerCase();
+    if (lowerStderr.includes("command not found") || lowerMessage.includes("not found")) {
+      errorType = "cli_not_found";
+    } else if (lowerStderr.includes("invalid") || lowerStderr.includes("expired") || lowerMessage.includes("invalid")) {
+      errorType = "token_invalid";
+    } else if (lowerStderr.includes("authentication") || lowerStderr.includes("login") || lowerMessage.includes("authentication") || lowerMessage.includes("login")) {
+      errorType = "auth_required";
+    }
+    telemetryCallback({
+      provider: context.provider,
+      stage: context.stage,
+      errorType,
+      errorMessage: authMessage,
+      suggestion: context.suggestion,
+      taskId: context.taskId,
+      exitCode
+    });
+  }
+  return {
+    type: "auth",
+    retryable: false,
+    userMessage: authMessage,
+    debugInfo: { exitCode },
+    originalError: stderr
+  };
+}
+function createNetworkError(stderr, exitCode, providerName, retryAfter = 5) {
+  return {
+    type: "network",
+    retryable: true,
+    retryAfter,
+    userMessage: `Network error connecting to ${providerName} API. Will retry with exponential backoff.`,
+    debugInfo: { exitCode },
+    originalError: stderr
+  };
+}
+function createTimeoutError(stderr, exitCode, timeoutMessage = "Execution timed out after configured timeout. Consider simplifying the task or splitting into smaller chunks.") {
+  return {
+    type: "timeout",
+    retryable: false,
+    userMessage: timeoutMessage,
+    debugInfo: { exitCode },
+    originalError: stderr
+  };
+}
+function createValidationError(stderr, stdout, exitCode, validationMessage) {
+  return {
+    type: "validation",
+    retryable: false,
+    userMessage: validationMessage,
+    debugInfo: { exitCode, stderr, stdout },
+    originalError: stderr
+  };
+}
+var CAPACITY_HTTP_STATUSES = [408, 425, 500, 502, 503, 504];
+function extractCapacityHttpStatus(errorText) {
+  const statusAlternation = CAPACITY_HTTP_STATUSES.join("|");
+  const trimmed = errorText.trim();
+  const bareLine = trimmed.match(new RegExp(`^(${statusAlternation})$`));
+  if (bareLine?.[1]) {
+    return parseInt(bareLine[1], 10);
+  }
+  const contextual = errorText.match(
+    new RegExp(
+      String.raw`(?:` + // HTTP 502 / http 502 / HTTP/502
+      String.raw`\bhttp\s*[/\s]\s*|` + // status 503 / status: 503 / status=503 / status code 503
+      String.raw`\bstatus(?:\s*code)?\s*[:=\s]\s*|` + // code: 504 / "code":504 / "code": 504
+      String.raw`(?:"code"|\bcode)\s*[:=]\s*|` + // code 504 (space-separated, no colon)
+      String.raw`\bcode\s+|` + // API Error: 503
+      String.raw`\bapi\s+error\s*[:=]\s*` + String.raw`)(${statusAlternation})\b`,
+      "i"
+    )
+  );
+  if (contextual?.[1]) {
+    return parseInt(contextual[1], 10);
+  }
+  const reasonPhrase = errorText.match(
+    new RegExp(
+      String.raw`\b(${statusAlternation})\s+(?:` + String.raw`service\s+unavailable|` + String.raw`internal\s+server\s+error|` + String.raw`bad\s+gateway|` + String.raw`gateway\s+timeout|` + String.raw`request\s+timeout|` + String.raw`too\s+early` + String.raw`)\b`,
+      "i"
+    )
+  );
+  if (reasonPhrase?.[1]) {
+    return parseInt(reasonPhrase[1], 10);
+  }
+  return void 0;
+}
+function createCapacityError(stderr, exitCode, providerName, retryAfter = 30) {
+  const httpStatus = extractCapacityHttpStatus(stderr);
+  const statusSuffix = httpStatus !== void 0 ? ` (${httpStatus})` : "";
+  return {
+    type: "capacity",
+    retryable: true,
+    retryAfter,
+    userMessage: `${providerName} service is temporarily unavailable${statusSuffix}. Will retry after ${retryAfter}s.`,
+    debugInfo: {
+      exitCode,
+      ...httpStatus !== void 0 ? { httpStatus } : {}
+    },
+    originalError: stderr
+  };
+}
+function createUnknownError(stderr, stdout, exitCode, providerName, retryAfter = 2) {
+  return {
+    type: "unknown",
+    retryable: true,
+    retryAfter,
+    userMessage: `${providerName} execution failed with exit code ${exitCode || "unknown"}. Error: ${stderr.slice(0, 200)}`,
+    debugInfo: {
+      exitCode,
+      stderrLength: stderr.length,
+      stdoutLength: stdout.length
+    },
+    originalError: stderr
+  };
+}
+function formatParsedError(parsed, providerName) {
+  const lines = [];
+  lines.push(`[${providerName} Error] Type: ${parsed.type}`);
+  lines.push(`[${providerName} Error] Retryable: ${parsed.retryable ? "yes" : "no"}`);
+  if (parsed.retryAfter) {
+    lines.push(`[${providerName} Error] Retry after: ${parsed.retryAfter}s`);
+  }
+  lines.push(`[${providerName} Error] Message: ${parsed.userMessage}`);
+  if (Object.keys(parsed.debugInfo).length > 0) {
+    lines.push(`[${providerName} Error] Debug: ${JSON.stringify(parsed.debugInfo)}`);
+  }
+  return lines.join("\n");
+}
+function isPermanentFailure(parsed) {
+  return !parsed.retryable;
+}
+var DEFAULT_RETRY_DELAYS = {
+  rate_limit: 6e4,
+  // 1 minute
+  network: 2e3,
+  // 2 seconds
+  unknown: 1e3,
+  // 1 second
+  auth: 0,
+  // No delay for non-retryable
+  timeout: 0,
+  // No delay for non-retryable
+  validation: 0,
+  // No delay for non-retryable
+  capacity: 3e4
+  // 30 seconds - service needs time to recover
+};
+function getRetryDelay(parsed, attemptNumber, delayMap = DEFAULT_RETRY_DELAYS, maxDelay = 3e4) {
+  if ((parsed.type === "rate_limit" || parsed.type === "network" || parsed.type === "capacity") && parsed.retryAfter) {
+    return parsed.retryAfter * 1e3;
+  }
+  const baseDelay = delayMap[parsed.type] ?? delayMap.unknown;
+  return Math.min(baseDelay * 2 ** (attemptNumber - 1), maxDelay);
+}
+
+export {
+  DEFAULT_ERROR_PATTERNS,
+  ERROR_EXIT_CODES,
+  matchesErrorPattern,
+  isRateLimitError,
+  isAuthError,
+  isNetworkError,
+  isTimeoutError,
+  isValidationError,
+  isContextOverflowError,
+  isCapacityError,
+  extractRetryAfter,
+  createRateLimitError,
+  createAuthError,
+  createNetworkError,
+  createTimeoutError,
+  createValidationError,
+  createCapacityError,
+  createUnknownError,
+  formatParsedError,
+  isPermanentFailure,
+  DEFAULT_RETRY_DELAYS,
+  getRetryDelay
+};
+//# sourceMappingURL=chunk-2YFUIER7.js.map