@poetic-ai/poetic 1.42.0

package/dist/chunk-VTLNJQ44.js

@@ -0,0 +1,133 @@
+import {
+  pathMatchesSandboxBlockedPrefix
+} from "./chunk-RI4EX2QE.js";
+import {
+  isIgnoredPlanningArtifactPath
+} from "./chunk-72XCRQED.js";
+import {
+  parseDiffGitHeaderPaths
+} from "./chunk-C3L6YQ7P.js";
+
+// src/core/synthesis/variant-work-evidence.ts
+function splitGitDiffStanzas(diff) {
+  return diff.split(/(?=^diff --git )/m).filter((stanza) => stanza.trim().length > 0);
+}
+function parseDiffGitHeader(stanza) {
+  const headerLine = stanza.split(/\r?\n/, 1)[0] ?? "";
+  return parseDiffGitHeaderPaths(headerLine);
+}
+function isSandboxProvisioningDeletionStanza(stanza) {
+  const header = parseDiffGitHeader(stanza);
+  if (!header) return false;
+  if (header.aPath !== header.bPath) return false;
+  if (!pathMatchesSandboxBlockedPrefix(header.aPath)) return false;
+  if (!/^deleted file mode \d+$/m.test(stanza)) return false;
+  if (!/^\+\+\+ \/dev\/null$/m.test(stanza)) return false;
+  const hasContentAdditions = stanza.split(/\r?\n/).some(
+    (line) => line.startsWith("+") && !line.startsWith("+++") && line.slice(1).trim().length > 0
+  );
+  return !hasContentAdditions;
+}
+function stripSandboxProvisioningDeletionsFromDiff(diff) {
+  if (!diff || !diff.trim()) {
+    return { diff: "", removedStanzas: 0, totalStanzas: 0 };
+  }
+  const stanzas = splitGitDiffStanzas(diff);
+  if (stanzas.length === 0) {
+    return { diff, removedStanzas: 0, totalStanzas: 0 };
+  }
+  const retained = [];
+  let removedStanzas = 0;
+  for (const stanza of stanzas) {
+    if (isSandboxProvisioningDeletionStanza(stanza)) {
+      removedStanzas++;
+    } else {
+      retained.push(stanza);
+    }
+  }
+  return {
+    diff: retained.join(""),
+    removedStanzas,
+    totalStanzas: stanzas.length
+  };
+}
+function summarizeUnifiedDiff(diff) {
+  const retainedDiff = stripSandboxProvisioningDeletionsFromDiff(diff).diff;
+  if (!retainedDiff.trim()) {
+    return { filesChanged: 0, linesAdded: 0, linesDeleted: 0 };
+  }
+  const changedPaths = /* @__PURE__ */ new Set();
+  for (const stanza of splitGitDiffStanzas(retainedDiff)) {
+    const header = parseDiffGitHeader(stanza);
+    if (header) changedPaths.add(header.bPath);
+  }
+  let linesAdded = 0;
+  let linesDeleted = 0;
+  let inHunk = false;
+  for (const line of retainedDiff.split(/\r?\n/)) {
+    if (line.startsWith("diff --git ")) {
+      inHunk = false;
+    } else if (line.startsWith("@@")) {
+      inHunk = true;
+    } else if (inHunk && line.startsWith("+")) {
+      linesAdded++;
+    } else if (inHunk && line.startsWith("-")) {
+      linesDeleted++;
+    }
+  }
+  return { filesChanged: changedPaths.size, linesAdded, linesDeleted };
+}
+function hasDiffEvidence(diff) {
+  if (!diff.trim()) return false;
+  if (/^Binary files .+ differ$/m.test(diff)) return true;
+  if (!/^diff --git /m.test(diff) && !/^@@ /m.test(diff)) return false;
+  return diff.split(/\r?\n/).some((line) => {
+    if (!line || line.startsWith("+++") || line.startsWith("---")) return false;
+    return (line.startsWith("+") || line.startsWith("-")) && line.slice(1).trim().length > 0;
+  });
+}
+function hasIgnoredPlanningArtifactEvidence(variant) {
+  const paths = variant.ignoredPathEvidence?.paths;
+  if (!Array.isArray(paths) || paths.length === 0) return false;
+  return paths.some(isIgnoredPlanningArtifactPath);
+}
+function isTimedOutVariantResult(variant) {
+  return variant.timedOut === true || variant.terminationReason === "timeout";
+}
+function hasMasterObservedTimeoutWorkEvidence(variant) {
+  const recon = variant.timeoutReconciliation;
+  if (!recon) return false;
+  return (recon.worktreeFilesChanged ?? 0) > 0 || (recon.worktreeLinesAdded ?? 0) > 0;
+}
+function hasVariantRealWorkEvidence(variant) {
+  if (variant.timeoutReconciliation != null) {
+    return hasMasterObservedTimeoutWorkEvidence(variant);
+  }
+  const diff = typeof variant.worktreeDiff === "string" ? variant.worktreeDiff : "";
+  if (diff.trim()) {
+    const stripped = stripSandboxProvisioningDeletionsFromDiff(diff);
+    if (stripped.removedStanzas > 0 && !hasDiffEvidence(stripped.diff)) {
+      return false;
+    }
+    if (hasDiffEvidence(stripped.diff)) {
+      return true;
+    }
+  }
+  if (isTimedOutVariantResult(variant)) {
+    return false;
+  }
+  const filesChanged = variant.gitMetrics?.filesChanged ?? variant.worktreeSummary?.filesChanged ?? variant.filesChanged ?? 0;
+  const linesAdded = variant.gitMetrics?.linesAdded ?? variant.worktreeSummary?.insertions ?? variant.linesAdded ?? 0;
+  const linesRemoved = variant.gitMetrics?.linesDeleted ?? variant.worktreeSummary?.deletions ?? variant.linesRemoved ?? 0;
+  return filesChanged > 0 || linesAdded > 0 || linesRemoved > 0;
+}
+
+export {
+  stripSandboxProvisioningDeletionsFromDiff,
+  summarizeUnifiedDiff,
+  hasDiffEvidence,
+  hasIgnoredPlanningArtifactEvidence,
+  hasMasterObservedTimeoutWorkEvidence,
+  hasVariantRealWorkEvidence
+};
+//# sourceMappingURL=chunk-VTLNJQ44.js.map

package/dist/chunk-VTW7HP3R.js

@@ -0,0 +1,100 @@
+import {
+  parseGitStatusPaths
+} from "./chunk-MN6PL4AN.js";
+import {
+  shouldExcludeFile
+} from "./chunk-NS33V3IM.js";
+import {
+  ANSI_ESCAPE_SEQUENCE
+} from "./chunk-PFTQBXS6.js";
+import {
+  isDebugMode
+} from "./chunk-EJGCZGUF.js";
+
+// src/core/providers/shared/pure-cli-runner.ts
+async function getGitHead(workingDir) {
+  try {
+    const { execa } = await import("execa");
+    const result = await execa("git", ["rev-parse", "HEAD"], { cwd: workingDir });
+    const head = result.stdout.trim();
+    return head.length > 0 ? head : void 0;
+  } catch (err) {
+    if (isDebugMode()) {
+      console.warn(`[PureCliRunner] Unable to resolve HEAD in ${workingDir}:`, err);
+    }
+    return void 0;
+  }
+}
+async function getGitBranch(workingDir) {
+  try {
+    const { execa } = await import("execa");
+    const result = await execa("git", ["branch", "--show-current"], { cwd: workingDir });
+    const branch = result.stdout.trim();
+    return branch.length > 0 ? branch : void 0;
+  } catch (err) {
+    if (isDebugMode()) {
+      console.warn(`[PureCliRunner] Unable to resolve branch in ${workingDir}:`, err);
+    }
+    return void 0;
+  }
+}
+function parseNameOnlyLines(output) {
+  return output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function isTrackedChangedFile(file) {
+  return file.length > 0 && !file.startsWith("node_modules") && file !== ".claudeignore" && !shouldExcludeFile(file);
+}
+async function getGitStatusPaths(workingDir) {
+  try {
+    const { execa } = await import("execa");
+    const status = await execa("git", ["status", "--porcelain", "--untracked-files=all"], {
+      cwd: workingDir,
+      reject: false
+    });
+    const statusPaths = status.stdout.trim().length > 0 ? parseGitStatusPaths(status.stdout) : [];
+    return new Set(statusPaths.filter(isTrackedChangedFile));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Unable to read git status in ${workingDir}: ${message}`);
+  }
+}
+async function detectGitChangedFiles(workingDir, baseline) {
+  const { execa } = await import("execa");
+  const files = /* @__PURE__ */ new Set();
+  const baselineHead = typeof baseline === "string" ? baseline : baseline?.baselineHead;
+  const baselineStatusPaths = typeof baseline === "string" ? /* @__PURE__ */ new Set() : new Set(baseline?.baselineStatusPaths ?? []);
+  const currentHead = await getGitHead(workingDir);
+  if (baselineHead && currentHead && baselineHead !== currentHead) {
+    try {
+      const diff = await execa("git", ["diff", "--name-only", baselineHead, currentHead], {
+        cwd: workingDir,
+        reject: false
+      });
+      for (const file of parseNameOnlyLines(diff.stdout)) {
+        if (isTrackedChangedFile(file)) {
+          files.add(file);
+        }
+      }
+    } catch {
+    }
+  }
+  const statusPaths = await getGitStatusPaths(workingDir);
+  statusPaths.forEach((file) => {
+    if (!baselineStatusPaths.has(file)) {
+      files.add(file);
+    }
+  });
+  return Array.from(files);
+}
+function stripAnsiSequences(str) {
+  return str.replace(ANSI_ESCAPE_SEQUENCE, "").replace(/\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)/g, "").replace(/\x1BP(?:[^\x1B]|\x1B(?!\\))*\x1B\\/g, "");
+}
+
+export {
+  getGitHead,
+  getGitBranch,
+  getGitStatusPaths,
+  detectGitChangedFiles,
+  stripAnsiSequences
+};
+//# sourceMappingURL=chunk-VTW7HP3R.js.map

package/dist/chunk-VVGEPBPS.js

@@ -0,0 +1,218 @@
+// src/core/judge/json-output-parser.ts
+function extractBalancedJson(text) {
+  return extractBalancedJsonObjects(text)[0] ?? null;
+}
+function extractBalancedJsonObjects(text) {
+  const objects = [];
+  let start = -1;
+  let depth = 0;
+  let inString = false;
+  let escaping = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === void 0) continue;
+    if (inString) {
+      if (escaping) {
+        escaping = false;
+      } else if (ch === "\\") {
+        escaping = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") {
+      if (depth === 0) {
+        start = i;
+      }
+      depth++;
+      continue;
+    }
+    if (ch === "}") {
+      if (depth === 0) continue;
+      depth--;
+      if (depth === 0 && start >= 0) {
+        objects.push(text.slice(start, i + 1));
+        start = -1;
+      }
+    }
+  }
+  return objects;
+}
+function stripMarkdownCodeFences(text) {
+  return text.replace(/^\s*```[^\n]*$/gm, "");
+}
+function collectJsonCandidates(text) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (candidate) => {
+    const trimmed = candidate?.trim();
+    if (!trimmed || seen.has(trimmed)) {
+      return;
+    }
+    seen.add(trimmed);
+    candidates.push(trimmed);
+  };
+  push(text);
+  for (const match of text.matchAll(/```(?:json)?\s*\n?([\s\S]*?)\n?```/gi)) {
+    push(match[1]);
+  }
+  const stripped = stripMarkdownCodeFences(text).trim();
+  push(stripped);
+  for (const balanced of extractBalancedJsonObjects(stripped)) {
+    push(balanced);
+  }
+  for (const balanced of extractBalancedJsonObjects(text)) {
+    push(balanced);
+  }
+  for (const line of stripped.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      push(trimmed);
+    }
+  }
+  push(extractBalancedJson(stripped));
+  push(extractBalancedJson(text));
+  return candidates;
+}
+function isStandaloneMalformedJsonCandidate(response) {
+  const trimmed = response.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return false;
+  try {
+    JSON.parse(trimmed);
+    return false;
+  } catch {
+    return /[{[]/.test(trimmed);
+  }
+}
+function parseJsonCandidate(candidate) {
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    const repairCandidates = /* @__PURE__ */ new Set();
+    const balanced = extractBalancedJson(candidate);
+    if (balanced) {
+      repairCandidates.add(balanced);
+    }
+    repairCandidates.add(candidate);
+    for (const repairCandidate of repairCandidates) {
+      const repaired = repairMalformedJsonCandidate(repairCandidate);
+      if (!repaired) continue;
+      try {
+        return JSON.parse(repaired);
+      } catch {
+      }
+    }
+    return null;
+  }
+}
+var MALFORMED_SIBLING_WRAPPER_PATTERN = /\{\s*"(correctness|quality|dimensions|limitation|os)"\s*:/y;
+function repairMalformedJsonCandidate(candidate) {
+  if (!candidate) return null;
+  const output = [];
+  const stack = [];
+  let inString = false;
+  let escaping = false;
+  let changed = false;
+  let lastSignificantOutputChar = "";
+  const append = (value) => {
+    output.push(value);
+    if (!/\s/.test(value)) {
+      lastSignificantOutputChar = value;
+    }
+  };
+  const nextNonWhitespaceChar = (start) => {
+    for (let i = start; i < candidate.length; i++) {
+      const ch = candidate[i];
+      if (ch && !/\s/.test(ch)) {
+        return ch;
+      }
+    }
+    return "";
+  };
+  const startsMalformedSiblingWrapper = (start) => {
+    if (stack[stack.length - 1] !== "{" || lastSignificantOutputChar !== ",") return false;
+    MALFORMED_SIBLING_WRAPPER_PATTERN.lastIndex = start;
+    return MALFORMED_SIBLING_WRAPPER_PATTERN.test(candidate);
+  };
+  for (let i = 0; i < candidate.length; i++) {
+    const ch = candidate[i];
+    if (ch === void 0) continue;
+    if (inString) {
+      append(ch);
+      if (escaping) {
+        escaping = false;
+      } else if (ch === "\\") {
+        escaping = true;
+      } else if (ch === '"') {
+        inString = false;
+      } else if (ch === "\n") {
+        output[output.length - 1] = "\\n";
+        changed = true;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      append(ch);
+      continue;
+    }
+    if (ch === "{" || ch === "[") {
+      if (ch === "{" && startsMalformedSiblingWrapper(i)) {
+        changed = true;
+        continue;
+      }
+      if ((lastSignificantOutputChar === "}" || lastSignificantOutputChar === "]") && ch === "{") {
+        append(",");
+        changed = true;
+      }
+      stack.push(ch);
+      append(ch);
+      continue;
+    }
+    if (ch === "}" || ch === "]") {
+      const expectedOpen = ch === "}" ? "{" : "[";
+      const actualOpen = stack[stack.length - 1];
+      if (actualOpen === expectedOpen) {
+        stack.pop();
+        if (lastSignificantOutputChar === ",") {
+          output.pop();
+          changed = true;
+        }
+        append(ch);
+      } else {
+        changed = true;
+      }
+      continue;
+    }
+    if (ch === ",") {
+      const next = nextNonWhitespaceChar(i + 1);
+      if (next === "}" || next === "]" || next === "") {
+        changed = true;
+        continue;
+      }
+    }
+    append(ch);
+  }
+  while (stack.length > 0) {
+    const open = stack.pop();
+    append(open === "{" ? "}" : "]");
+    changed = true;
+  }
+  const repaired = output.join("").trim();
+  return changed && repaired ? repaired : null;
+}
+
+export {
+  extractBalancedJson,
+  extractBalancedJsonObjects,
+  stripMarkdownCodeFences,
+  collectJsonCandidates,
+  isStandaloneMalformedJsonCandidate,
+  parseJsonCandidate
+};
+//# sourceMappingURL=chunk-VVGEPBPS.js.map

package/dist/chunk-VVLLL7I4.js

@@ -0,0 +1,166 @@
+import {
+  classifyTask
+} from "./chunk-FQ7FSZRW.js";
+import {
+  calculateGuidanceTier,
+  generatePromptInjection,
+  validateTaskSpec
+} from "./chunk-P6VQROCO.js";
+import {
+  analyzeTask
+} from "./chunk-OA4GPILI.js";
+import {
+  parsePromptSpec
+} from "./chunk-7T7RUJI7.js";
+import {
+  isQuietOutputRequested
+} from "./chunk-FKAUPHMR.js";
+
+// src/utils/cli-breadcrumbs.ts
+import chalk from "chalk";
+var DEFAULT_IDLE_AFTER_MS = 3e4;
+function formatBreadcrumbLine(prefix, label, detail) {
+  const message = detail && detail.trim().length > 0 ? `${prefix}: ${label}: ${detail}` : `${prefix}: ${label}`;
+  return `${chalk.gray(message)}
+`;
+}
+function createCliBreadcrumb(options) {
+  if (isQuietOutputRequested()) {
+    const handle2 = {
+      markActivity() {
+      },
+      complete() {
+      },
+      fail() {
+      },
+      dispose() {
+      },
+      [Symbol.dispose]() {
+        handle2.dispose();
+      }
+    };
+    return handle2;
+  }
+  const label = options.label.trim();
+  const stream = options.stream ?? process.stderr;
+  const idleAfterMs = typeof options.idleAfterMs === "number" && Number.isFinite(options.idleAfterMs) ? Math.max(0, Math.floor(options.idleAfterMs)) : DEFAULT_IDLE_AFTER_MS;
+  let idleTimer;
+  let disposed = false;
+  const clearIdleTimer = () => {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = void 0;
+    }
+  };
+  const emit = (symbol, detail) => {
+    if (disposed) return;
+    stream.write(formatBreadcrumbLine(symbol, label, detail));
+  };
+  const armIdleHeartbeat = () => {
+    clearIdleTimer();
+    if (disposed || idleAfterMs <= 0) return;
+    idleTimer = setTimeout(() => {
+      idleTimer = void 0;
+      emit("Info", "still working...");
+      armIdleHeartbeat();
+    }, idleAfterMs);
+  };
+  emit("Info", options.detail);
+  armIdleHeartbeat();
+  const handle = {
+    markActivity(detail) {
+      if (disposed) return;
+      if (detail) emit("Info", detail);
+      armIdleHeartbeat();
+    },
+    complete(detail) {
+      if (disposed) return;
+      clearIdleTimer();
+      if (detail) emit("OK", detail);
+      disposed = true;
+    },
+    fail(detail) {
+      if (disposed) return;
+      clearIdleTimer();
+      if (detail) emit("Error", detail);
+      disposed = true;
+    },
+    dispose() {
+      if (disposed) return;
+      clearIdleTimer();
+      disposed = true;
+    },
+    [Symbol.dispose]() {
+      handle.dispose();
+    }
+  };
+  return handle;
+}
+
+// src/planning/execution-spec-signals.ts
+function evaluateExecutionSpec(taskDescription) {
+  const hasFillPlaceholders = /<<<FILL/i.test(taskDescription);
+  if (!hasFillPlaceholders) {
+    return null;
+  }
+  const hasAdr = /^##\s*Context/im.test(taskDescription) && /^##\s*Decision/im.test(taskDescription);
+  const hasResearch = /^##\s*Research\s+Questions?/im.test(taskDescription);
+  const hasBug = /^##\s*Reproduction\s+Steps/im.test(taskDescription);
+  const mockBoosts = hasAdr ? [{ kind: "adr" }] : hasResearch ? [{ kind: "research" }] : hasBug ? [{ kind: "reproducibility" }] : [{ kind: "scope" }, { kind: "acceptance" }, { kind: "testing" }];
+  const completeness = validateTaskSpec(taskDescription, mockBoosts);
+  const guidanceTier = calculateGuidanceTier(completeness);
+  return {
+    completenessScore: completeness.score,
+    guidanceTier,
+    missingFields: completeness.missing,
+    hasFillPlaceholders,
+    promptInjection: generatePromptInjection(completeness, guidanceTier)
+  };
+}
+
+// src/core/judge/prompt-spec-summary.ts
+function toPromptSpecSummary(spec) {
+  return {
+    intent: spec.intent,
+    editsRequired: spec.editsRequired,
+    prefersMinimalChange: spec.prefersMinimalChange,
+    testsRequested: spec.testsRequested,
+    testExecutionRequested: spec.testExecutionRequested,
+    isTestIntent: spec.isTestIntent,
+    isAnalysisIntent: spec.isAnalysisIntent,
+    fileTargets: spec.fileConstraint.targets,
+    deliverableSpecified: spec.deliverableConstraint.specified,
+    deliverableTargets: spec.deliverableConstraint.targets,
+    requirementCount: spec.requirements.length
+  };
+}
+
+// src/core/classification/task-profile.ts
+function buildTaskProfile(classification, promptSpec, analysis) {
+  return {
+    classification,
+    promptSpec,
+    analysis,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: "1.0"
+  };
+}
+function buildTaskProfileFromPrompt(prompt, options) {
+  const classification = classifyTask(prompt, {
+    stripInjections: options?.stripInjections,
+    variants: options?.variants
+  });
+  const fullSpec = parsePromptSpec(prompt, {
+    analysisMode: options?.analysisMode
+  });
+  const promptSpec = toPromptSpecSummary(fullSpec);
+  const analysis = analyzeTask(prompt);
+  return buildTaskProfile(classification, promptSpec, analysis);
+}
+
+export {
+  buildTaskProfileFromPrompt,
+  createCliBreadcrumb,
+  evaluateExecutionSpec
+};
+//# sourceMappingURL=chunk-VVLLL7I4.js.map