@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-JQD5VYKR.js

@@ -0,0 +1,483 @@
+import {
+  detectProjectCapabilities
+} from "./chunk-GNH3QGTL.js";
+import {
+  isProjectConfigPath,
+  isProjectDocsPath
+} from "./chunk-UDMS5AD3.js";
+
+// src/core/project/spec-harness-convergence.ts
+function pushFirstAvailable(out, commands) {
+  const command = commands.find((entry) => entry.trim().length > 0);
+  if (command && !out.includes(command)) {
+    out.push(command);
+  }
+}
+function resolveSpecHarnessConvergenceCommands(root) {
+  const capabilities = detectProjectCapabilities(root);
+  const commands = [];
+  pushFirstAvailable(commands, capabilities.verification.test);
+  pushFirstAvailable(commands, capabilities.verification.typecheck);
+  return commands;
+}
+
+// src/core/providers/shared/prompt-adapter-core.ts
+var POETIC_CONTEXT_MARKER_NAMES = [
+  "POETIC_ANALYSIS_CONTEXT",
+  "POETIC_STAGE_CONTEXT",
+  "POETIC_CONTEXT_INJECTION"
+];
+var POETIC_CONTEXT_MARKER_PATTERN = POETIC_CONTEXT_MARKER_NAMES.join("|");
+var POETIC_CONTEXT_BLOCK_RE = new RegExp(
+  `<!--\\s*(?:${POETIC_CONTEXT_MARKER_PATTERN})\\s*-->\\r?\\n?[\\s\\S]*?\\r?\\n?<!--\\s*\\/(?:${POETIC_CONTEXT_MARKER_PATTERN})\\s*-->`,
+  "g"
+);
+var POETIC_CONTEXT_MARKER_RE = new RegExp(
+  `<!--\\s*(\\/)?\\s*(${POETIC_CONTEXT_MARKER_PATTERN})\\s*-->`,
+  "g"
+);
+function neutralizePoeticContextMarkers(text) {
+  return text.replace(
+    POETIC_CONTEXT_MARKER_RE,
+    (_match, closing, marker) => `[${closing ? "/" : ""}${marker}]`
+  );
+}
+function neutralizeUnpairedPoeticContextMarkers(text) {
+  const sections = [];
+  let cursor = 0;
+  for (const match of text.matchAll(POETIC_CONTEXT_BLOCK_RE)) {
+    const index = match.index ?? 0;
+    sections.push(neutralizePoeticContextMarkers(text.slice(cursor, index)));
+    sections.push(match[0]);
+    cursor = index + match[0].length;
+  }
+  sections.push(neutralizePoeticContextMarkers(text.slice(cursor)));
+  return sections.join("");
+}
+function stripPoeticContextBlocks(text) {
+  return text.replace(POETIC_CONTEXT_BLOCK_RE, "");
+}
+function normalizePath(pathStr) {
+  return pathStr.replace(/\\/g, "/").replace(/^\.\//, "").trim();
+}
+function stripTrailingPunctuation(value) {
+  return value.replace(/[.,;:]+$/g, "").trim();
+}
+function stripTrailingKnownAnnotation(value) {
+  return value.replace(
+    /\s*\((?:create|new|modify|out\s+of\s+scope|out-of-scope|read[\s-]?only|optional|reference|related|info\s+only)\)\s*$/i,
+    ""
+  ).trim();
+}
+var NEUTRAL_ROOT_MANIFEST_BASENAMES = /* @__PURE__ */ new Set([
+  "go.mod",
+  "go.sum",
+  "go.work",
+  "go.work.sum",
+  "cargo.toml",
+  "cargo.lock",
+  "pom.xml",
+  "setup.py",
+  "pipfile",
+  "pipfile.lock",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock"
+]);
+function isLikelyFilePathToken(value) {
+  const file = value.trim();
+  if (!file) return false;
+  if (file.match(/^[A-Z]:?$/)) return false;
+  if (file.includes("/")) return true;
+  if (file.startsWith(".")) return true;
+  if (file === "Makefile" || file === "Dockerfile" || file === "LICENSE") return true;
+  if (isProjectConfigPath(file) || isProjectDocsPath(file)) {
+    return true;
+  }
+  if (NEUTRAL_ROOT_MANIFEST_BASENAMES.has(file.toLowerCase())) return true;
+  return false;
+}
+function normalizeFileTargetToken(raw) {
+  const stripPathWrappers = (value) => value.replace(/^[`'"]+|[`'"]+$/g, "").trim();
+  const stripTrailingLineReference = (value) => value.replace(/(?:#L?\d+(?::\d+)?(?:-L?\d+(?::\d+)?)?|:\d+(?::\d+)?)$/i, "").trim();
+  let trimmed = raw.trim().replace(/^[`'"]+|[`'"]+$/g, "").trim();
+  trimmed = stripTrailingPunctuation(trimmed);
+  trimmed = stripTrailingKnownAnnotation(trimmed);
+  trimmed = stripTrailingPunctuation(trimmed);
+  const extMatch = /^(.+?\.(?:ts|tsx|js|jsx|json|md|yaml|yml|toml|go|rs|py|c|cc|cpp|h|hpp))(?:(?::\d+)+|[`'"()[\]*_]|\s|$)/i.exec(
+    trimmed
+  );
+  let candidate = (extMatch?.[1] ?? trimmed).replace(/[;,]$/, "").trim();
+  candidate = candidate.replace(/(\.[A-Za-z0-9]+)\*+$/u, "$1");
+  if (!extMatch && candidate.includes("/") && /\s/.test(candidate)) {
+    candidate = candidate.split(/\s+/)[0]?.trim() ?? candidate;
+  }
+  candidate = stripPathWrappers(candidate);
+  candidate = stripTrailingLineReference(candidate);
+  candidate = stripTrailingPunctuation(candidate);
+  return normalizePath(candidate);
+}
+var SCOPED_EDIT_ONLY_CLAUSE_RE = /\b(?:edit|update|modify|change)\s+only\s+([\s\S]+?)(?=\.\s*(?:Do\s+not|Don't)\b|\.\s*$|$)/i;
+var FILE_PATH_IN_SEGMENT_RE = /(?:`([^`\n]+)`|([A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)+\.[A-Za-z0-9]{1,12}))/g;
+function stripNegatedFileClauses(prompt) {
+  let result = prompt;
+  const patterns = [
+    /\bdo\s+not\s+(?:inspect\s+or\s+)?(?:modify|edit)\s+[^.\n]+/gi,
+    /\bdon't\s+(?:modify|edit)\s+[^.\n]+/gi,
+    /\bdo\s+not\s+modify\s+files\s+outside\s+[^.\n]+/gi
+  ];
+  for (const pattern of patterns) {
+    result = result.replace(pattern, " ");
+  }
+  return result;
+}
+function extractPathsFromTextSegment(segment) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const match of segment.matchAll(FILE_PATH_IN_SEGMENT_RE)) {
+    const raw = match[1] ?? match[2] ?? "";
+    const normalized = normalizeFileTargetToken(raw);
+    if (normalized.length > 0 && isLikelyFilePathToken(normalized)) {
+      paths.add(normalized);
+    }
+  }
+  return Array.from(paths);
+}
+function extractScopedEditOnlyPaths(prompt) {
+  const match = SCOPED_EDIT_ONLY_CLAUSE_RE.exec(prompt);
+  if (!match?.[1]) {
+    return [];
+  }
+  return extractPathsFromTextSegment(match[1]);
+}
+function renderFileTargets(targets, options = {}) {
+  const uniqueTargets = Array.from(new Set(targets.filter((target) => target.trim().length > 0)));
+  if (uniqueTargets.length === 0) return "";
+  if (options.style === "single") {
+    return uniqueTargets.map((target) => `FILE: ${target}`).join("\n");
+  }
+  if (uniqueTargets.length === 1) {
+    return `FILE: ${uniqueTargets[0]}`;
+  }
+  if (options.style === "list" || uniqueTargets.length > 2) {
+    return `FILES:
+${uniqueTargets.map((target) => `- ${target}`).join("\n")}`;
+  }
+  return uniqueTargets.map((target) => `FILE: ${target}`).join("\n");
+}
+function hasExplicitFileTargets(text, options = {}) {
+  return extractExplicitFileTargets(text, options).length > 0;
+}
+function extractExplicitFileTargets(prompt, options = {}) {
+  const { includeProseMarkers = false, includeScopedSections = false } = options;
+  const targets = /* @__PURE__ */ new Set();
+  const addCandidate = (raw) => {
+    const candidate = normalizeFileTargetToken(raw);
+    if (isLikelyFilePathToken(candidate)) {
+      targets.add(candidate);
+    }
+  };
+  let cleanPrompt = stripPoeticContextBlocks(prompt);
+  const toolPolicySplit = cleanPrompt.split(/\n---\n\n/);
+  if (toolPolicySplit.length > 1 && /##\s*Tool Usage Policy/i.test(toolPolicySplit[0] ?? "")) {
+    cleanPrompt = toolPolicySplit.slice(1).join("\n---\n\n");
+  }
+  cleanPrompt = cleanPrompt.replace(/##\s+Recent Git History[\s\S]*?(?=\n##\s+|\n$)/gi, "");
+  cleanPrompt = cleanPrompt.replace(/##\s+Relevant Files[\s\S]*?(?=\n##\s+|\n$)/gi, "");
+  cleanPrompt = cleanPrompt.replace(/##\s+Architecture Context[\s\S]*?(?=\n##\s+|\n$)/gi, "");
+  const singleFileRegex = /\bfile:\s*([^\n,;]+?)(?=(?:\s+\band\b|\s*\bfile:|$)|\n|[,;]|$)/gi;
+  const multiLineRegex = /\bfiles:\s*\n((?:\s*[-*]\s*[^\n]+\n?)+)/i;
+  const fileTargetsBlockRegex = /file targets:\s*\n((?:\s*[-•]\s*[^\n]+\n?)+)/i;
+  const scopedSectionRegex = /(?:^|\n)\s*#{1,6}\s*(?:scope(?:\s*\/\s*surfaces?\s+affected)?(?:\s*\(optional\))?|files?\s+to\s+modify)\s*\n((?:\s*[-*]\s*[^\n]+\n?)+)/i;
+  for (const match of cleanPrompt.matchAll(singleFileRegex)) {
+    if (match[1]) {
+      addCandidate(
+        match[1].trim().replace(/^FILE:?\s*/i, "").replace(/^[A-Z]:?\s*/, "").trim()
+      );
+    }
+  }
+  const processListBlock = (block, linePattern, trimPattern) => {
+    if (!block) return;
+    const lines = block.match(linePattern);
+    if (!lines) return;
+    for (const line of lines) {
+      addCandidate(
+        line.replace(trimPattern, "").replace(/^FILE:?\s*/i, "").trim()
+      );
+    }
+  };
+  processListBlock(multiLineRegex.exec(cleanPrompt)?.[1], /^\s*[-*]\s*[^\n]+/gm, /^\s*[-*]\s*/);
+  processListBlock(
+    fileTargetsBlockRegex.exec(cleanPrompt)?.[1],
+    /^\s*[-•]\s*[^\n]+/gm,
+    /^\s*[-•]\s*/
+  );
+  if (includeProseMarkers) {
+    const proseRegex = /files?\s+to\s+(?:modify|change|update|touch)[:\s]*\n((?:\s*[-*]\s*[^\n]+\n?)+)/gim;
+    for (const match of cleanPrompt.matchAll(proseRegex)) {
+      processListBlock(match[1], /^\s*[-*]\s*[^\n]+/gm, /^\s*[-*]\s*/);
+    }
+  }
+  if (includeScopedSections) {
+    processListBlock(
+      scopedSectionRegex.exec(cleanPrompt)?.[1],
+      /^\s*[-*]\s*[^\n]+/gm,
+      /^\s*[-*]\s*/
+    );
+  }
+  return Array.from(targets);
+}
+function generateWorkspaceAgentHeader(provider, executionIntent) {
+  switch (executionIntent) {
+    case "code":
+      return `# ${provider} Workspace Agent: Code Generation Mode
+You are editing an isolated workspace
+Output must be executable code`;
+    case "analysis":
+      return `# ${provider} Workspace Agent: Analysis Mode
+You are analyzing an isolated git worktree
+Provide detailed analysis`;
+    case "mixed":
+      return `# ${provider} Workspace Agent: Mixed Mode
+analysis + implementation
+Both investigation and executable code`;
+    default:
+      return "# Workspace Agent: Default Mode";
+  }
+}
+function generateAnalysisModeInstructions(executionIntent) {
+  switch (executionIntent) {
+    case "code":
+      return "";
+    case "analysis":
+      return "PRIMARY FOCUS: Analysis, insights, and recommendations\nCODE CHANGES: Optional";
+    case "mixed":
+      return "BALANCED APPROACH: Both planning and implementation are expected";
+    default:
+      return "";
+  }
+}
+function extractFileTargets(prompt) {
+  return extractExplicitFileTargets(prompt);
+}
+function generateMinimalAdaptation(options) {
+  const intent = options.executionIntent || "code";
+  const strategy = options.strategy || "conservative";
+  const files = options.targetFiles?.length ? options.targetFiles.join(", ") : "";
+  const intentGuide = {
+    code: "Simplified code generation guidance: Focus on direct implementation.",
+    analysis: "Simplified analysis guidance: Provide concise, targeted insights.",
+    mixed: "Simplified mixed-mode guidance: Balance analysis and implementation."
+  };
+  const strategyGuide = {
+    conservative: "Thorough inline documentation. Prioritize existing patterns, safety, and comprehensive error handling.",
+    hybrid: "Balanced approach. Adapt carefully to context.",
+    innovative: "Creative solutions. Explore alternative implementations."
+  };
+  const fileContext = files ? `Target: ${files}` : "";
+  return ["Simplified Guidance:", intentGuide[intent], strategyGuide[strategy], fileContext].filter(Boolean).join("\n");
+}
+function injectBacklogReviewContract(prompt, targetFiles) {
+  const normalizedPrompt = prompt.toLowerCase();
+  const touchesBacklog = targetFiles.some((file) => file.toLowerCase().includes("backlog/"));
+  const looksLikeReview = normalizedPrompt.includes("you are reviewing") || normalizedPrompt.includes("review this backlog") || normalizedPrompt.includes("review") && normalizedPrompt.includes("backlog");
+  const isBacklogReview = touchesBacklog && looksLikeReview;
+  if (!isBacklogReview) {
+    return prompt;
+  }
+  const contractLines = [
+    "## BACKLOG REVIEW CONTRACT",
+    "**Do not delete or rewrite existing sections.** Only append a 'Review' section at the top of the file.",
+    "",
+    "Keep all existing content intact (implementation plan, references, timestamps, etc.).",
+    "",
+    "**Output expectations:**",
+    "- Target length: ~25\u201360 lines total (for the Review section)",
+    "- Cover all required sections; 3\u20135 bullets per section",
+    "- End with a short 'Recommended next action' (1\u20132 bullets)",
+    ""
+  ];
+  const fileSpecPattern = /^FILE:/im;
+  if (fileSpecPattern.test(prompt)) {
+    const lines = prompt.split("\n");
+    let insertIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line && /^FILE:/i.test(line)) {
+        insertIndex = i + 1;
+        while (insertIndex < lines.length) {
+          const nextLine = lines[insertIndex];
+          if (nextLine && /^FILE:/i.test(nextLine)) {
+            insertIndex++;
+          } else {
+            break;
+          }
+        }
+        break;
+      }
+    }
+    lines.splice(insertIndex, 0, ...contractLines);
+    return lines.join("\n");
+  }
+  return `${contractLines.join("\n")}
+${prompt}`;
+}
+function generateSpecHarness(root) {
+  return `## Spec Harness v1: Deterministic Output Expectations
+
+**Purpose:** Ensure consistent, testable outputs across all providers
+
+### Required Semantics
+- All file paths MUST be repo-relative (not absolute)
+- All edits MUST target files within the repository
+- Do NOT edit generated, dependency, or build output directories (e.g. vendor/, node_modules/, .git/, dist/, target/, __pycache__/, build/)
+- Do NOT edit \`.poetic/\` except for required control files (e.g. \`.poetic/edits.jsonl\`) or when explicitly requested
+- Configuration files require explicit justification in completion signal
+
+### Must-Fail Inputs (Your output should handle these gracefully)
+- Empty/null file paths
+- Paths outside repository boundaries
+- Circular dependencies in imports
+- Syntax errors in generated code
+
+### Output Stability Rules
+1. **Deterministic ordering**: Always process files in lexicographic order
+2. **Consistent formatting**: Use project's existing style (respect .editorconfig, biome.json, etc.)
+3. **Stable identifiers**: Generated names should be predictable (avoid random suffixes unless required)
+4. **Idempotency**: Running the same task twice should produce equivalent results
+
+${renderSmokeCommandsSection(root)}`;
+}
+function renderSmokeCommandsSection(root) {
+  const header = "### Smoke Commands for Self-Validation";
+  const trailer = "**Note:** These are validation expectations. Run the targeted checks when feasible, especially for touched code or tests. If you cannot run them, say that explicitly in your completion signal and still emit the completion signal.";
+  if (root) {
+    const commands = resolveSpecHarnessConvergenceCommands(root);
+    if (commands.length > 0) {
+      const bullets = commands.map((command) => `- \`${command}\``).join("\n");
+      return `${header}
+Before completing, mentally verify (or actually run if you have shell access) the project's verification commands:
+${bullets}
+Also run the project's documented lint/build commands when you touched relevant code.
+
+${trailer}`;
+    }
+    return `${header}
+Before completing, mentally verify (or actually run if you have shell access) the project's own test, lint, and build commands as documented for this project. If this project's language is not recognized or has no verification commands, report verification as unavailable in your completion signal rather than claiming the output is clean.
+
+${trailer}`;
+  }
+  return `${header}
+Before completing, mentally verify (or actually run if you have shell access) the project's own test, lint, and build commands as documented for this project. If this project's language is not recognized or has no verification commands, report verification as unavailable in your completion signal rather than claiming the output is clean.
+
+${trailer}`;
+}
+var COMPLETION_DIRECTIVE_VARIANT_A = `## REQUIRED: Completion Signal
+
+Before finishing, emit exactly ONE completion signal (as a JSON line, not in code fences):
+
+{"type":"poetic_completion","filesEdited":["path/to/file.ts"],"editIntent":"edited","reason":"<what you did>"}
+
+**editIntent values:**
+- "edited": You made changes to files
+- "no-op": No changes needed (MUST explain why in reason)
+- "partial": Some changes made but incomplete (explain what's missing)
+
+**Examples:**
+{"type":"poetic_completion","filesEdited":["src/auth.ts"],"editIntent":"edited","reason":"Added null check for user object"}
+{"type":"poetic_completion","filesEdited":[],"editIntent":"no-op","reason":"File already contains all specified functions"}
+{"type":"poetic_completion","filesEdited":["src/api.ts"],"editIntent":"partial","reason":"Added 2/3 endpoints; third needs schema change"}
+
+If you cannot complete the task, still emit with "partial" and explain why.`;
+var COMPLETION_DIRECTIVE_VARIANT_B = `## MANDATORY: Task Completion Signal
+
+When done, output exactly ONE completion record (raw JSON line \u2014 no markdown fences):
+
+{"type":"poetic_completion","filesEdited":["path/to/file.ts"],"editIntent":"edited","reason":"<summary of what you did>"}
+
+**editIntent options:**
+- "edited": files were modified
+- "no-op": nothing to change (reason field must explain why)
+- "partial": work is incomplete (reason field must describe what remains)
+
+**Examples:**
+{"type":"poetic_completion","filesEdited":["src/auth.ts"],"editIntent":"edited","reason":"Added null check for user object"}
+{"type":"poetic_completion","filesEdited":[],"editIntent":"no-op","reason":"File already contains all specified functions"}
+{"type":"poetic_completion","filesEdited":["src/api.ts"],"editIntent":"partial","reason":"Added 2/3 endpoints; third needs schema change"}
+
+Always emit this record \u2014 even if the task could not be completed. Use "partial" and describe why.`;
+function generateCompletionDirectiveWithVariant(forceVariant) {
+  const variant = forceVariant ?? (Math.random() < 0.5 ? "A" : "B");
+  const text = variant === "A" ? COMPLETION_DIRECTIVE_VARIANT_A : COMPLETION_DIRECTIVE_VARIANT_B;
+  return { text, completion_signal_variant: variant };
+}
+function appendWorkspaceEditInstructions(prompt, options) {
+  const {
+    targetFiles: _targetFiles = [],
+    // FILE: enforcement disabled per A/B test results (2026-02-02)
+    includeExamples = true,
+    level = "conservative",
+    executionIntent: _executionIntent,
+    // Accepted but not currently used
+    projectRoot
+  } = options;
+  const fileContext = "";
+  const editInstructions = [
+    "Workspace Edit Protocol:",
+    "1. For every file change, write ONE JSON line to `.poetic/edits.jsonl` in this worktree.",
+    '   Format: {"type":"poetic_edit","op":"writeFile","path":"relative/path.ts","contents":"FULL FILE CONTENT"}',
+    "2. Supported ops:",
+    "   - writeFile: complete file replacement",
+    "   - appendFile: add content to end of file",
+    "   - renameFile, deleteFile as needed",
+    "3. Paths must be repo-relative and must not target generated, dependency, or build output directories (e.g. vendor/, node_modules/, .git/, dist/, target/, __pycache__/, build/).",
+    "   Note: `.poetic/edits.jsonl` is required for edit events; avoid other `.poetic/` writes unless explicitly requested."
+  ];
+  const exampleSection = includeExamples ? [
+    "\nEdit Event Examples:",
+    '{"type":"poetic_edit","op":"writeFile","path":"src/utils/logger.ts","contents":"...full file content..."}',
+    '{"type":"poetic_edit","op":"appendFile","path":"src/config.ts","contents":"// New configuration added"}'
+  ] : [];
+  const aggressionLevelNotes = {
+    conservative: "Thorough documentation, preserve existing code structure.",
+    moderate: "Balanced approach, refactor with careful consideration.",
+    aggressive: "Open to significant restructuring if beneficial."
+  }[level];
+  const completionDirective = generateCompletionDirectiveWithVariant();
+  return {
+    text: [
+      prompt,
+      "\n",
+      generateSpecHarness(projectRoot),
+      "\n",
+      fileContext,
+      editInstructions.join("\n"),
+      `Execution Strategy: ${aggressionLevelNotes}`,
+      ...exampleSection,
+      "\n",
+      completionDirective.text
+    ].join("\n"),
+    completionSignalVariant: completionDirective.completion_signal_variant
+  };
+}
+
+export {
+  resolveSpecHarnessConvergenceCommands,
+  neutralizePoeticContextMarkers,
+  neutralizeUnpairedPoeticContextMarkers,
+  stripPoeticContextBlocks,
+  normalizePath,
+  normalizeFileTargetToken,
+  stripNegatedFileClauses,
+  extractScopedEditOnlyPaths,
+  renderFileTargets,
+  hasExplicitFileTargets,
+  extractExplicitFileTargets,
+  generateWorkspaceAgentHeader,
+  generateAnalysisModeInstructions,
+  extractFileTargets,
+  generateMinimalAdaptation,
+  injectBacklogReviewContract,
+  generateCompletionDirectiveWithVariant,
+  appendWorkspaceEditInstructions
+};
+//# sourceMappingURL=chunk-JQD5VYKR.js.map