@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-K54Y7MLK.js

@@ -0,0 +1,160 @@
+// src/core/providers/cursor/preflight.ts
+import { existsSync } from "fs";
+import { access, mkdir, readFile, rm, writeFile } from "fs/promises";
+import path from "path";
+function isSafeTargetFilePath(target) {
+  if (!target || path.isAbsolute(target) || path.win32.isAbsolute(target)) {
+    return false;
+  }
+  return !target.split(/[\\/]+/).some((segment) => segment === "..");
+}
+async function canWriteProbe(dir) {
+  const probeDir = path.join(dir, ".poetic-cursor-preflight");
+  const probeFile = path.join(probeDir, "write-probe.tmp");
+  try {
+    await mkdir(probeDir, { recursive: true });
+    await writeFile(probeFile, "ok", "utf8");
+    await rm(probeFile, { force: true });
+    await rm(probeDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    try {
+      await rm(probeDir, { recursive: true, force: true });
+    } catch {
+    }
+    return false;
+  }
+}
+function parseJsonObject(content) {
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function evaluateCursorConfigWriteRestrictions(config, scope) {
+  if (config.approvalMode === "manual" || config.approvalMode === "strict") {
+    return `approvalMode is '${String(config.approvalMode)}'`;
+  }
+  const sandbox = config.sandbox;
+  if (sandbox && typeof sandbox === "object") {
+    const mode = sandbox.mode;
+    if (mode === "enabled" || mode === "strict") {
+      return `sandbox.mode is '${String(mode)}'`;
+    }
+  }
+  const permissions = config.permissions;
+  if (!permissions || typeof permissions !== "object") {
+    return scope === "project" ? void 0 : "permissions.allow is missing";
+  }
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const deny = Array.isArray(permissions.deny) ? permissions.deny : [];
+  const hasWriteAllow = allow.some((entry) => typeof entry === "string" && /^Write\(/.test(entry));
+  const hasWriteDeny = deny.some((entry) => typeof entry === "string" && /^Write\(/.test(entry));
+  if (hasWriteDeny) {
+    return "permissions.deny contains Write(...) rules";
+  }
+  if (!hasWriteAllow) {
+    return allow.length > 0 ? "permissions.allow has no Write(...) rules" : "permissions.allow is empty or missing";
+  }
+  return void 0;
+}
+async function inspectCursorConfigFile(configPath, scope) {
+  if (!existsSync(configPath)) {
+    return void 0;
+  }
+  const content = await readFile(configPath, "utf8");
+  const config = parseJsonObject(content);
+  if (!config) {
+    return "config file is not valid JSON";
+  }
+  return evaluateCursorConfigWriteRestrictions(config, scope);
+}
+async function runCursorExecutionPreflight(input) {
+  const issues = [];
+  try {
+    await access(input.workingDir);
+  } catch {
+    issues.push({
+      code: "worktree_not_writable",
+      message: `Worktree path is not accessible: ${input.workingDir}`
+    });
+    return { ok: false, issues };
+  }
+  if (!await canWriteProbe(input.workingDir)) {
+    issues.push({
+      code: "worktree_not_writable",
+      message: `Worktree is not writable: ${input.workingDir}`
+    });
+  }
+  for (const target of input.targetFiles ?? []) {
+    if (!isSafeTargetFilePath(target)) {
+      issues.push({
+        code: "target_parent_not_creatable",
+        message: `Target path escapes worktree and cannot be probed: "${target}"`
+      });
+      continue;
+    }
+    const parentDir = path.join(input.workingDir, path.dirname(target));
+    if (parentDir === input.workingDir) {
+      continue;
+    }
+    const parentExisted = existsSync(parentDir);
+    if (!parentExisted) {
+      try {
+        await mkdir(parentDir, { recursive: true });
+      } catch {
+        issues.push({
+          code: "target_parent_not_creatable",
+          message: `Cannot create parent directory for target "${target}": ${parentDir}`
+        });
+        continue;
+      }
+    }
+    if (!await canWriteProbe(parentDir)) {
+      issues.push({
+        code: "target_parent_not_creatable",
+        message: `Parent directory is not writable for target "${target}": ${parentDir}`
+      });
+    }
+    if (!parentExisted) {
+      try {
+        await rm(parentDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+  const runtimeRestriction = await inspectCursorConfigFile(
+    path.join(input.cursorConfigDir, "cli-config.json"),
+    "runtime"
+  );
+  if (runtimeRestriction) {
+    issues.push({
+      code: "runtime_write_rules",
+      message: `Cursor runtime cli-config.json may block edits (${runtimeRestriction}).`
+    });
+  }
+  const projectCliPath = path.join(input.workingDir, ".cursor", "cli.json");
+  const projectRestriction = await inspectCursorConfigFile(projectCliPath, "project");
+  if (projectRestriction) {
+    issues.push({
+      code: "project_cli_restrictive",
+      message: `Project .cursor/cli.json may block edits (${projectRestriction}).`
+    });
+  }
+  return { ok: issues.length === 0, issues };
+}
+function formatCursorExecutionPreflightFailure(result) {
+  const headline = "Cursor preflight failed: likely target/permission/sandbox mismatch before provider launch.";
+  const details = result.issues.map((issue) => `- ${issue.message}`).join("\n");
+  return `${headline}
+${details}`;
+}
+
+export {
+  evaluateCursorConfigWriteRestrictions,
+  runCursorExecutionPreflight,
+  formatCursorExecutionPreflightFailure
+};
+//# sourceMappingURL=chunk-K54Y7MLK.js.map

package/dist/chunk-KAT4RXUT.js

@@ -0,0 +1,521 @@
+import {
+  appendWorkspaceEditInstructions,
+  extractFileTargets,
+  generateMinimalAdaptation,
+  generateWorkspaceAgentHeader,
+  injectBacklogReviewContract
+} from "./chunk-JQD5VYKR.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-KAT4RXUT.js.map