@poetic-ai/poetic 1.42.0

package/dist/chunk-UR2IBGIM.js

@@ -0,0 +1,521 @@
+import {
+  appendWorkspaceEditInstructions,
+  extractFileTargets,
+  generateMinimalAdaptation,
+  generateWorkspaceAgentHeader,
+  injectBacklogReviewContract
+} from "./chunk-VX3UMWB7.js";
+import {
+  sanitizeString
+} from "./chunk-LPITVM7M.js";
+
+// src/core/providers/shared/prompt-strengthening.ts
+function strengthenAmbiguousLanguage(prompt, level = "moderate") {
+  const operations = [];
+  const patterns = getAmbiguousLanguagePatterns(level);
+  const matchedDescriptions = [];
+  for (const { pattern, description } of patterns) {
+    if (clonePattern(pattern).test(prompt)) {
+      matchedDescriptions.push(description);
+    }
+  }
+  if (matchedDescriptions.length === 0) {
+    return { strengthened: prompt, operations };
+  }
+  if (/\b(write|generate|emit|produce)\b[^.\n]{0,40}\bcode\b/i.test(prompt)) {
+    return { strengthened: prompt, operations };
+  }
+  operations.push(...matchedDescriptions);
+  return {
+    strengthened: `${prompt}${buildExecutionFocusNote(level)}`,
+    operations
+  };
+}
+function buildExecutionFocusNote(level) {
+  const firmness = {
+    conservative: "This task expects working code, not only a plan or description.",
+    moderate: "This task expects working code applied as workspace edits, not only a plan or description.",
+    aggressive: "REQUIRED: Apply working code as workspace edits. A plan or description alone does not complete this task."
+  };
+  return [
+    "",
+    "",
+    "---",
+    "EXECUTION EXPECTATION",
+    firmness[level] ?? firmness.moderate,
+    "Follow the task text above exactly as written; this note adds no new requirements.",
+    "---"
+  ].join("\n");
+}
+function clonePattern(regex) {
+  return new RegExp(regex.source, regex.flags);
+}
+function getAmbiguousLanguagePatterns(_level) {
+  return [
+    {
+      pattern: /\b(implement|add|create)[ \t]+/gi,
+      description: "Detected ambiguous implementation verb; appended execution expectation"
+    },
+    {
+      pattern: /\b(refactor|update|modify)[ \t]+/gi,
+      description: "Detected ambiguous refactoring verb; appended execution expectation"
+    },
+    {
+      pattern: /\b(fix|resolve)[ \t]+/gi,
+      description: "Detected ambiguous bug-fix verb; appended execution expectation"
+    }
+  ];
+}
+function generateFileModificationChecklist(targetFiles, level = "moderate") {
+  if (targetFiles.length < 2) {
+    return "";
+  }
+  const checklistItems = targetFiles.map((file, idx) => `${idx + 1}. [ ] ${file}`);
+  const footer = level === "aggressive" ? "Address every file the task requires. If a file needs no change, say so and why." : "Address each file the task requires; if a file needs no change, briefly explain why.";
+  return [
+    "",
+    "---",
+    "RELEVANT FILES (edit those the task requires):",
+    ...checklistItems,
+    "",
+    footer,
+    "---",
+    ""
+  ].join("\n");
+}
+function generateImplementationDirective(level = "moderate", executionIntent = "code") {
+  if (executionIntent === "analysis") {
+    return "";
+  }
+  const directives = {
+    conservative: [
+      "---",
+      "EXECUTION MODE: IMPLEMENTATION",
+      "- Generate working code",
+      "- Emit workspace edits",
+      "---"
+    ],
+    moderate: [
+      "---",
+      "EXECUTION MODE: IMPLEMENTATION",
+      "- Generate working, executable code",
+      "- Emit workspace edits via JSONL protocol",
+      "- Do NOT produce standalone planning files in place of implementation",
+      "---"
+    ],
+    aggressive: [
+      "---",
+      "EXECUTION MODE: IMPLEMENTATION (MANDATORY)",
+      "- Generate working, executable code",
+      "- Emit workspace edits via JSONL protocol IMMEDIATELY",
+      "- Planning-only output (without implementation) will be treated as FAILURE",
+      "- Analysis without code implementation will be REJECTED",
+      "---"
+    ]
+  };
+  const lines = directives[level] || directives.moderate;
+  return `
+
+${lines.join("\n")}`;
+}
+function generatePreviousErrorDirective(previousError, level = "moderate") {
+  const categoryLabel = {
+    timeout: "Timeout/Deadline",
+    auth: "Authentication/Authorization",
+    syntax: "Syntax/Parse Error",
+    resource: "Resource Exhaustion",
+    unknown: "Unknown Error"
+  }[previousError.category];
+  const lines = [];
+  lines.push("---");
+  if (level === "aggressive") {
+    lines.push(" RETRY CONTEXT: Previous iteration FAILED - you MUST adjust your approach");
+  } else {
+    lines.push("RETRY CONTEXT: Previous iteration failed");
+  }
+  lines.push(
+    `Iteration ${previousError.iteration} failed with error: ${sanitizeString(previousError.message)}`
+  );
+  lines.push(`Error category: ${categoryLabel}`);
+  if (previousError.hint) {
+    const hint = sanitizeString(previousError.hint);
+    if (level === "aggressive") {
+      lines.push(`CRITICAL recovery hint: ${hint}`);
+    } else {
+      lines.push(`Recovery hint: ${hint}`);
+    }
+  }
+  lines.push("");
+  if (level === "aggressive") {
+    lines.push(
+      "You MUST adjust your approach to address this failure. Do NOT repeat the same steps."
+    );
+  } else {
+    lines.push("Adjust your approach to address this failure.");
+  }
+  lines.push("---");
+  return `
+
+${lines.join("\n")}`;
+}
+function strengthenPrompt(prompt, options = {}) {
+  const {
+    executionIntent = "code",
+    level = "moderate",
+    targetFiles: explicitTargets = [],
+    previousError
+  } = options;
+  const allOperations = [];
+  let strengthened = prompt;
+  if (previousError) {
+    const errorDirective = generatePreviousErrorDirective(previousError, level);
+    if (errorDirective) {
+      strengthened += errorDirective;
+      allOperations.push(
+        `Added retry context for iteration ${previousError.iteration} (${previousError.category} error)`
+      );
+    }
+  }
+  if (executionIntent !== "analysis") {
+    const langResult = strengthenAmbiguousLanguage(strengthened, level);
+    strengthened = langResult.strengthened;
+    allOperations.push(...langResult.operations);
+  }
+  const extractedTargets = extractFileTargets(strengthened);
+  const targetFiles = Array.from(/* @__PURE__ */ new Set([...extractedTargets, ...explicitTargets]));
+  if (executionIntent !== "analysis" && targetFiles.length > 1) {
+    const checklist = generateFileModificationChecklist(targetFiles, level);
+    if (checklist) {
+      strengthened += checklist;
+      allOperations.push(`Added file checklist for ${targetFiles.length} targets`);
+    }
+  }
+  if (executionIntent !== "analysis") {
+    const directive = generateImplementationDirective(level, executionIntent);
+    if (directive) {
+      strengthened += directive;
+      allOperations.push("Added execution mode directive");
+    }
+  }
+  return {
+    strengthened,
+    operations: allOperations,
+    targetFiles
+  };
+}
+function mapStrategyToStrengtheningLevel(strategy) {
+  switch (strategy?.toLowerCase()) {
+    case "conservative":
+      return "conservative";
+    case "innovative":
+      return "aggressive";
+    case "hybrid":
+      return "moderate";
+    default:
+      return "moderate";
+  }
+}
+
+// src/core/providers/shared/prompt-mode.ts
+import { createHash } from "crypto";
+var MODE_DEFAULTS = {
+  passthrough: {
+    injection: {
+      header: false,
+      fileSection: false,
+      protocol: false,
+      protocolExamples: false,
+      strengthen: false,
+      minimalGuidance: false
+    },
+    edit: {
+      injectJsonlInstructions: false,
+      parseJsonl: "best-effort",
+      // Still parse if provider happens to emit JSONL
+      enforceFileTargets: false
+    }
+  },
+  enhanced: {
+    injection: {
+      header: true,
+      fileSection: true,
+      protocol: true,
+      protocolExamples: true,
+      strengthen: false,
+      minimalGuidance: false
+    },
+    edit: {
+      injectJsonlInstructions: true,
+      parseJsonl: "best-effort",
+      enforceFileTargets: true
+    }
+  },
+  strengthened: {
+    injection: {
+      header: true,
+      fileSection: true,
+      protocol: true,
+      protocolExamples: true,
+      strengthen: true,
+      minimalGuidance: false
+    },
+    edit: {
+      injectJsonlInstructions: true,
+      parseJsonl: "best-effort",
+      enforceFileTargets: true
+    }
+  },
+  minimal: {
+    injection: {
+      header: true,
+      fileSection: false,
+      protocol: true,
+      protocolExamples: false,
+      strengthen: false,
+      minimalGuidance: true
+    },
+    edit: {
+      injectJsonlInstructions: true,
+      parseJsonl: "best-effort",
+      enforceFileTargets: false
+      // Minimal mode is more permissive
+    }
+  }
+};
+function applyWorkspaceMode(prompt, options) {
+  const {
+    mode,
+    provider,
+    executionIntent = "code",
+    strategy = "conservative",
+    targetFiles: explicitTargets = [],
+    strengtheningLevel,
+    injectionOverrides = {},
+    editOverrides = {},
+    projectRoot
+  } = options;
+  const defaults = MODE_DEFAULTS[mode];
+  const injection = { ...defaults.injection, ...injectionOverrides };
+  const editContract = { ...defaults.edit, ...editOverrides };
+  const operations = [];
+  let adapted = prompt;
+  let completionSignalVariant;
+  const extractedTargets = extractFileTargets(prompt);
+  const targetFiles = Array.from(/* @__PURE__ */ new Set([...extractedTargets, ...explicitTargets]));
+  if (mode === "passthrough") {
+    operations.push("Passthrough mode - no modifications");
+    return buildResult(prompt, adapted, mode, targetFiles, operations, editContract);
+  }
+  const beforeContract = adapted;
+  adapted = injectBacklogReviewContract(adapted, targetFiles);
+  if (adapted !== beforeContract) {
+    operations.push("Injected backlog review contract (P2: deterministic review behavior)");
+  }
+  if (injection.minimalGuidance) {
+    if (injection.header) {
+      const header = generateWorkspaceAgentHeader(provider, executionIntent);
+      adapted = `${header}
+
+${adapted}`;
+      operations.push(`Added ${provider} workspace agent header`);
+    }
+    const minimalGuidance = generateMinimalAdaptation({
+      executionIntent,
+      targetFiles,
+      strategy
+    });
+    adapted = `${minimalGuidance}
+
+${adapted}`;
+    operations.push("Applied minimal adaptation guidance");
+    if (injection.protocol) {
+      const protocolResult = appendWorkspaceEditInstructions(adapted, {
+        targetFiles,
+        executionIntent,
+        includeExamples: false,
+        level: "conservative",
+        projectRoot
+      });
+      adapted = protocolResult.text;
+      completionSignalVariant = protocolResult.completionSignalVariant;
+      operations.push("Added workspace edit protocol (minimal, no examples)");
+    }
+    return buildResult(
+      prompt,
+      adapted,
+      mode,
+      targetFiles,
+      operations,
+      editContract,
+      completionSignalVariant
+    );
+  }
+  if (injection.strengthen) {
+    const level = strengtheningLevel ?? mapStrategyToStrengtheningLevel(strategy);
+    const strengthResult = strengthenPrompt(adapted, {
+      executionIntent,
+      level,
+      targetFiles,
+      providerName: provider
+    });
+    adapted = strengthResult.strengthened;
+    operations.push(...strengthResult.operations);
+  }
+  if (injection.header) {
+    const header = generateWorkspaceAgentHeader(provider, executionIntent);
+    adapted = `${header}
+
+${adapted}`;
+    operations.push(`Added ${provider} workspace agent header`);
+  }
+  if (injection.fileSection && targetFiles.length > 0) {
+    const separator = "=".repeat(60);
+    const fileSection = [
+      "",
+      separator,
+      targetFiles.length === 1 ? "TARGET FILE:" : "TARGET FILES:",
+      ...targetFiles.map((f) => `  - ${f}`),
+      separator,
+      ""
+    ].join("\n");
+    adapted += fileSection;
+    operations.push(`Added file target section (${targetFiles.length} files)`);
+  }
+  if (injection.protocol) {
+    const level = strengtheningLevel ?? mapStrategyToStrengtheningLevel(strategy);
+    const protocolResult = appendWorkspaceEditInstructions(adapted, {
+      targetFiles,
+      executionIntent,
+      includeExamples: injection.protocolExamples,
+      level,
+      projectRoot
+    });
+    adapted = protocolResult.text;
+    completionSignalVariant = protocolResult.completionSignalVariant;
+    operations.push(
+      `Added workspace edit protocol${injection.protocolExamples ? " with examples" : ""}`
+    );
+  }
+  return buildResult(
+    prompt,
+    adapted,
+    mode,
+    targetFiles,
+    operations,
+    editContract,
+    completionSignalVariant
+  );
+}
+function buildResult(original, adapted, mode, targetFiles, operations, editContract, completionSignalVariant) {
+  const hash = createHash("sha256").update(adapted).digest("hex").slice(0, 16);
+  return {
+    original,
+    adapted,
+    mode,
+    targetFiles,
+    operations,
+    editContract,
+    completionSignalVariant,
+    adaptedHash: hash,
+    lengths: {
+      original: original.length,
+      adapted: adapted.length,
+      delta: adapted.length - original.length
+    }
+  };
+}
+function isValidWorkspaceMode(value) {
+  return ["passthrough", "enhanced", "strengthened", "minimal"].includes(value);
+}
+function getProviderDefaultMode(provider) {
+  const normalized = provider.toLowerCase();
+  if (["claude", "copilot", "codex", "opencode", "grok"].includes(normalized)) {
+    return "passthrough";
+  }
+  if (["gemini"].includes(normalized)) {
+    return "enhanced";
+  }
+  if (["cursor"].includes(normalized)) {
+    return "enhanced";
+  }
+  return "passthrough";
+}
+var MODE_ORDER = {
+  passthrough: 0,
+  minimal: 1,
+  enhanced: 2,
+  strengthened: 3
+};
+var PROVIDER_MODE_CONSTRAINTS = {
+  claude: {
+    supportedModes: ["passthrough"],
+    defaultMode: "passthrough",
+    maxSafeMode: "passthrough"
+  },
+  cursor: {
+    supportedModes: ["passthrough", "enhanced", "minimal"],
+    defaultMode: "enhanced",
+    maxSafeMode: "enhanced"
+  },
+  codex: {
+    supportedModes: ["passthrough"],
+    defaultMode: "passthrough",
+    maxSafeMode: "passthrough"
+  },
+  gemini: {
+    supportedModes: ["passthrough", "enhanced", "minimal"],
+    defaultMode: "enhanced",
+    maxSafeMode: "enhanced"
+  },
+  copilot: {
+    supportedModes: ["passthrough", "enhanced", "minimal"],
+    defaultMode: "passthrough",
+    maxSafeMode: "enhanced"
+  },
+  opencode: {
+    supportedModes: ["passthrough", "enhanced", "minimal"],
+    defaultMode: "passthrough",
+    maxSafeMode: "enhanced"
+  },
+  grok: {
+    supportedModes: ["passthrough", "enhanced", "minimal"],
+    defaultMode: "passthrough",
+    maxSafeMode: "enhanced"
+  }
+};
+function getProviderModeConstraints(provider) {
+  const normalized = provider.toLowerCase();
+  return PROVIDER_MODE_CONSTRAINTS[normalized] ?? {
+    supportedModes: ["passthrough", "enhanced", "minimal"],
+    defaultMode: "passthrough",
+    maxSafeMode: "enhanced"
+  };
+}
+function clampToMaxSafeMode(mode, constraints) {
+  const modeOrder = MODE_ORDER[mode] ?? 0;
+  const maxOrder = MODE_ORDER[constraints.maxSafeMode] ?? 0;
+  if (modeOrder > maxOrder) {
+    return { mode: constraints.maxSafeMode, clamped: true };
+  }
+  return { mode, clamped: false };
+}
+function resolveEffectiveMode(variantOverride, globalMode, provider) {
+  if (variantOverride) {
+    return variantOverride;
+  }
+  if (globalMode) {
+    return globalMode;
+  }
+  return getProviderDefaultMode(provider);
+}
+
+export {
+  strengthenPrompt,
+  mapStrategyToStrengtheningLevel,
+  applyWorkspaceMode,
+  isValidWorkspaceMode,
+  getProviderModeConstraints,
+  clampToMaxSafeMode,
+  resolveEffectiveMode
+};
+//# sourceMappingURL=chunk-UR2IBGIM.js.map