@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-JKBHJQMT.js

@@ -0,0 +1,434 @@
+import {
+  EXCLUDED_PATH_PREFIXES,
+  shouldExcludeFile
+} from "./chunk-NS33V3IM.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/core/git/change-summary.ts
+import { readFile, stat } from "fs/promises";
+import { join } from "path";
+import { execa } from "execa";
+var DIFF_EXCLUDE_PATTERNS = [...EXCLUDED_PATH_PREFIXES, "planning/.tmp.*", "*.log"];
+var GIT_SNAPSHOT_TIMEOUT_MS = 1e4;
+var EMPTY_NUMSTAT = { linesAdded: 0, linesRemoved: 0, files: [] };
+var EMPTY_SNAPSHOT = {
+  headSha: "",
+  hasCommittedChanges: false,
+  committedDiffText: "",
+  committedNumstat: EMPTY_NUMSTAT,
+  committedStatusLines: [],
+  unstagedDiffText: "",
+  unstagedNumstat: EMPTY_NUMSTAT,
+  stagedDiffText: "",
+  stagedNumstat: EMPTY_NUMSTAT,
+  untrackedFiles: [],
+  statusLines: [],
+  isGitRepo: false
+};
+function splitTextLines(content) {
+  if (content.length === 0) {
+    return [];
+  }
+  return content.endsWith("\n") ? content.slice(0, -1).split("\n") : content.split("\n");
+}
+async function collectWorktreeSnapshot(worktreePath, baselineRef) {
+  if (!worktreePath) return EMPTY_SNAPSHOT;
+  try {
+    const opts = {
+      cwd: worktreePath,
+      reject: false,
+      stdio: "pipe",
+      timeout: GIT_SNAPSHOT_TIMEOUT_MS
+    };
+    const gitCheck = await execa("git", ["rev-parse", "--is-inside-work-tree"], opts);
+    if (gitCheck.exitCode !== 0) return EMPTY_SNAPSHOT;
+    const headResult = await execa("git", ["rev-parse", "HEAD"], opts);
+    const headSha = headResult.stdout.trim();
+    const hasCommittedChanges = !!(baselineRef && headSha && headSha !== baselineRef);
+    const excludeArgs = buildExcludeArgs();
+    const [
+      committedDiff,
+      committedNumstatRaw,
+      committedStatusRaw,
+      unstagedDiff,
+      unstagedNumstatRaw,
+      stagedDiff,
+      stagedNumstatRaw,
+      untrackedResult,
+      statusResult
+    ] = await Promise.all([
+      // Committed diff (full text + numstat)
+      hasCommittedChanges ? execa("git", ["diff", `${baselineRef}..HEAD`, ...excludeArgs], opts) : null,
+      hasCommittedChanges ? execa("git", ["diff", "--numstat", `${baselineRef}..HEAD`, ...excludeArgs], opts) : null,
+      hasCommittedChanges ? execa("git", ["diff", "--name-status", `${baselineRef}..HEAD`, ...excludeArgs], opts) : null,
+      // Unstaged (full text + numstat)
+      execa("git", ["diff", ...excludeArgs], opts),
+      execa("git", ["diff", "--numstat", ...excludeArgs], opts),
+      // Staged (full text + numstat)
+      execa("git", ["diff", "--cached", ...excludeArgs], opts),
+      execa("git", ["diff", "--cached", "--numstat", ...excludeArgs], opts),
+      // Untracked files
+      execa("git", ["ls-files", "--others", "--exclude-standard", ...excludeArgs], opts),
+      // Porcelain status
+      execa("git", ["status", "--porcelain", ...excludeArgs], opts)
+    ]);
+    const untrackedFiles = (untrackedResult.stdout ?? "").trim().split("\n").filter(Boolean).filter((f) => !shouldExcludePath(f));
+    const statusLines = (statusResult.stdout ?? "").split("\n").filter((line) => line.trim().length > 0).filter((line) => {
+      const body = line.slice(3).trim();
+      const targetPath = body.includes(" -> ") ? body.split(" -> ").at(-1) ?? body : body;
+      return !shouldExcludePath(targetPath);
+    });
+    return {
+      headSha,
+      hasCommittedChanges,
+      committedDiffText: committedDiff?.stdout ?? "",
+      committedNumstat: parseNumstat(committedNumstatRaw?.stdout),
+      committedStatusLines: parseCommittedStatusLines(committedStatusRaw?.stdout),
+      unstagedDiffText: unstagedDiff.stdout ?? "",
+      unstagedNumstat: parseNumstat(unstagedNumstatRaw.stdout),
+      stagedDiffText: stagedDiff.stdout ?? "",
+      stagedNumstat: parseNumstat(stagedNumstatRaw.stdout),
+      untrackedFiles,
+      statusLines,
+      isGitRepo: true
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    emitWarning(
+      "VAL-001E",
+      {
+        subsystem: "git",
+        executionPhase: "validation"
+      },
+      {
+        severity: "ERROR" /* ERROR */,
+        metadata: {
+          operation: "collectWorktreeSnapshot",
+          worktreeProvided: true,
+          error: message
+        }
+      }
+    );
+    return { ...EMPTY_SNAPSHOT, error: message };
+  }
+}
+function deriveChangeSummaryFromSnapshot(snapshot, includeUntracked = true) {
+  if (!snapshot.isGitRepo) {
+    return {
+      filesChanged: 0,
+      linesAdded: 0,
+      linesRemoved: 0,
+      changedPaths: [],
+      source: "fallback"
+    };
+  }
+  const allFiles = /* @__PURE__ */ new Set();
+  let totalAdded = 0;
+  let totalRemoved = 0;
+  let source = "dirty-worktree";
+  if (snapshot.hasCommittedChanges && snapshot.committedNumstat.files.length > 0) {
+    totalAdded += snapshot.committedNumstat.linesAdded;
+    totalRemoved += snapshot.committedNumstat.linesRemoved;
+    for (const f of snapshot.committedNumstat.files) allFiles.add(f);
+    source = "committed";
+  } else {
+    totalAdded += snapshot.unstagedNumstat.linesAdded + snapshot.stagedNumstat.linesAdded;
+    totalRemoved += snapshot.unstagedNumstat.linesRemoved + snapshot.stagedNumstat.linesRemoved;
+    for (const f of snapshot.unstagedNumstat.files) allFiles.add(f);
+    for (const f of snapshot.stagedNumstat.files) allFiles.add(f);
+  }
+  if (includeUntracked) {
+    for (const f of snapshot.untrackedFiles) allFiles.add(f);
+  }
+  return {
+    filesChanged: allFiles.size,
+    linesAdded: totalAdded,
+    linesRemoved: totalRemoved,
+    changedPaths: Array.from(allFiles),
+    source
+  };
+}
+function deriveEffectiveDiffMetrics(snapshot) {
+  if (!snapshot.isGitRepo) {
+    return {
+      filesChanged: 0,
+      linesAdded: 0,
+      linesRemoved: 0,
+      changedPaths: []
+    };
+  }
+  const allFiles = /* @__PURE__ */ new Set([...snapshot.unstagedNumstat.files, ...snapshot.stagedNumstat.files]);
+  return {
+    filesChanged: allFiles.size,
+    linesAdded: snapshot.unstagedNumstat.linesAdded + snapshot.stagedNumstat.linesAdded,
+    linesRemoved: snapshot.unstagedNumstat.linesRemoved + snapshot.stagedNumstat.linesRemoved,
+    changedPaths: Array.from(allFiles)
+  };
+}
+function deriveDiffTextFromSnapshot(snapshot) {
+  if (!snapshot.isGitRepo) return "";
+  const parts = [];
+  if (snapshot.committedDiffText) parts.push(snapshot.committedDiffText);
+  if (snapshot.unstagedDiffText) parts.push(snapshot.unstagedDiffText);
+  if (snapshot.stagedDiffText) parts.push(snapshot.stagedDiffText);
+  return parts.join("\n");
+}
+async function synthesizeUntrackedDiffs(worktreePath, untrackedFiles) {
+  if (untrackedFiles.length === 0) return "";
+  const diffs = [];
+  const maxFiles = 50;
+  const maxFileSize = 100 * 1024;
+  let processedCount = 0;
+  for (const file of untrackedFiles) {
+    if (shouldExcludePath(file)) continue;
+    if (processedCount >= maxFiles) {
+      diffs.push(`
+# Warning: Truncated at ${maxFiles} untracked files`);
+      break;
+    }
+    try {
+      const filePath = join(worktreePath, file);
+      const fileStat = await stat(filePath);
+      if (!fileStat.isFile() || fileStat.size > maxFileSize) continue;
+      const content = await readFile(filePath, "utf-8");
+      if (content.includes("\0")) continue;
+      const lines = splitTextLines(content);
+      const diffLines = lines.map((line) => `+${line}`);
+      diffs.push(
+        `diff --git a/${file} b/${file}`,
+        "new file mode 100644",
+        "--- /dev/null",
+        `+++ b/${file}`,
+        `@@ -0,0 +1,${lines.length} @@`,
+        ...diffLines
+      );
+      processedCount++;
+    } catch {
+    }
+  }
+  return diffs.join("\n");
+}
+function buildExcludeArgs() {
+  if (DIFF_EXCLUDE_PATTERNS.length === 0) return [];
+  return ["--", ...DIFF_EXCLUDE_PATTERNS.map((p) => `:(exclude)${p}`)];
+}
+function shouldExcludePath(filePath) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  if (shouldExcludeFile(normalizedPath)) {
+    return true;
+  }
+  for (const pattern of DIFF_EXCLUDE_PATTERNS) {
+    const directoryPattern = pattern.endsWith("/") ? pattern : `${pattern}/`;
+    if (normalizedPath === pattern || normalizedPath.startsWith(directoryPattern)) {
+      return true;
+    }
+    if (pattern.startsWith("*") && normalizedPath.endsWith(pattern.slice(1))) {
+      return true;
+    }
+  }
+  return false;
+}
+function parseNumstat(numstatOutput) {
+  if (!numstatOutput || !numstatOutput.trim()) {
+    return { linesAdded: 0, linesRemoved: 0, files: [] };
+  }
+  let totalAdded = 0;
+  let totalRemoved = 0;
+  const files = [];
+  for (const line of numstatOutput.trim().split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("	");
+    if (parts.length < 3) continue;
+    const added = parts[0]?.trim();
+    const removed = parts[1]?.trim();
+    const filePath = parts[2]?.trim();
+    if (!filePath) continue;
+    if (shouldExcludePath(filePath)) continue;
+    files.push(filePath);
+    if (added !== "-") {
+      totalAdded += Number.parseInt(added ?? "0", 10) || 0;
+    }
+    if (removed !== "-") {
+      totalRemoved += Number.parseInt(removed ?? "0", 10) || 0;
+    }
+  }
+  return {
+    linesAdded: totalAdded,
+    linesRemoved: totalRemoved,
+    files
+  };
+}
+function parseCommittedStatusLines(nameStatusOutput) {
+  if (!nameStatusOutput || !nameStatusOutput.trim()) {
+    return [];
+  }
+  return nameStatusOutput.trim().split("\n").map((line) => {
+    const parts = line.split("	").filter(Boolean);
+    const status = parts[0] ?? "";
+    const path = parts.at(-1)?.trim() ?? "";
+    if (!path || shouldExcludePath(path)) {
+      return null;
+    }
+    const oldPath = status.startsWith("R") ? parts[1]?.trim() : void 0;
+    const normalizedStatus = status.startsWith("A") ? " A" : status.startsWith("M") ? " M" : status.startsWith("D") ? " D" : status.startsWith("R") ? " R" : "  ";
+    return oldPath ? `${normalizedStatus} ${oldPath} -> ${path}` : `${normalizedStatus} ${path}`;
+  }).filter((line) => Boolean(line));
+}
+async function getGitChangeSummary(worktreePath, baselineRef, includeUntracked = true) {
+  if (!worktreePath) {
+    return {
+      filesChanged: 0,
+      linesAdded: 0,
+      linesRemoved: 0,
+      changedPaths: [],
+      source: "fallback"
+    };
+  }
+  try {
+    const gitCheck = await execa("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: worktreePath,
+      reject: false
+    });
+    if (gitCheck.exitCode !== 0) {
+      return {
+        filesChanged: 0,
+        linesAdded: 0,
+        linesRemoved: 0,
+        changedPaths: [],
+        source: "fallback"
+      };
+    }
+    const excludeArgs = buildExcludeArgs();
+    const allFiles = /* @__PURE__ */ new Set();
+    let totalAdded = 0;
+    let totalRemoved = 0;
+    let source = "dirty-worktree";
+    let committedDiffAvailable = false;
+    if (baselineRef) {
+      const head = await execa("git", ["rev-parse", "HEAD"], {
+        cwd: worktreePath,
+        reject: false
+      });
+      const currentHead = head.stdout.trim();
+      if (currentHead && currentHead !== baselineRef) {
+        const committedNumstat = await execa(
+          "git",
+          ["diff", "--numstat", `${baselineRef}..HEAD`, ...excludeArgs],
+          { cwd: worktreePath, reject: false }
+        );
+        const committedStats = parseNumstat(committedNumstat.stdout);
+        if (committedStats.files.length > 0) {
+          totalAdded += committedStats.linesAdded;
+          totalRemoved += committedStats.linesRemoved;
+          for (const file of committedStats.files) {
+            allFiles.add(file);
+          }
+          source = "committed";
+          committedDiffAvailable = true;
+        }
+      }
+    }
+    if (!committedDiffAvailable) {
+      const unstagedNumstat = await execa("git", ["diff", "--numstat", ...excludeArgs], {
+        cwd: worktreePath,
+        reject: false
+      });
+      const stagedNumstat = await execa("git", ["diff", "--cached", "--numstat", ...excludeArgs], {
+        cwd: worktreePath,
+        reject: false
+      });
+      const unstagedStats = parseNumstat(unstagedNumstat.stdout);
+      const stagedStats = parseNumstat(stagedNumstat.stdout);
+      totalAdded += unstagedStats.linesAdded + stagedStats.linesAdded;
+      totalRemoved += unstagedStats.linesRemoved + stagedStats.linesRemoved;
+      for (const file of unstagedStats.files) {
+        allFiles.add(file);
+      }
+      for (const file of stagedStats.files) {
+        allFiles.add(file);
+      }
+    }
+    if (includeUntracked) {
+      const untrackedResult = await execa("git", ["ls-files", "--others", "--exclude-standard"], {
+        cwd: worktreePath,
+        reject: false
+      });
+      if (untrackedResult.stdout && untrackedResult.exitCode === 0) {
+        const untrackedFiles = untrackedResult.stdout.trim().split("\n").filter(Boolean).filter((f) => !shouldExcludePath(f));
+        for (const file of untrackedFiles) {
+          allFiles.add(file);
+        }
+        const maxFiles = 50;
+        const maxFileSize = 100 * 1024;
+        let processedCount = 0;
+        for (const file of untrackedFiles) {
+          if (processedCount >= maxFiles) break;
+          try {
+            const filePath = join(worktreePath, file);
+            const fileStat = await stat(filePath);
+            if (!fileStat.isFile() || fileStat.size > maxFileSize) {
+              continue;
+            }
+            const content = await readFile(filePath, "utf-8");
+            if (content.includes("\0")) {
+              continue;
+            }
+            const lines = splitTextLines(content).length;
+            totalAdded += lines;
+            processedCount++;
+          } catch {
+          }
+        }
+      }
+    }
+    return {
+      filesChanged: allFiles.size,
+      linesAdded: totalAdded,
+      linesRemoved: totalRemoved,
+      changedPaths: Array.from(allFiles),
+      source
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    emitWarning(
+      "VAL-001E",
+      {
+        subsystem: "git",
+        executionPhase: "validation"
+      },
+      {
+        severity: "ERROR" /* ERROR */,
+        metadata: {
+          operation: "getGitChangeSummary",
+          worktreePath,
+          error: message
+        }
+      }
+    );
+    return {
+      filesChanged: 0,
+      linesAdded: 0,
+      linesRemoved: 0,
+      changedPaths: [],
+      source: "fallback",
+      error: message
+    };
+  }
+}
+
+export {
+  DIFF_EXCLUDE_PATTERNS,
+  splitTextLines,
+  collectWorktreeSnapshot,
+  deriveChangeSummaryFromSnapshot,
+  deriveEffectiveDiffMetrics,
+  deriveDiffTextFromSnapshot,
+  synthesizeUntrackedDiffs,
+  buildExcludeArgs,
+  shouldExcludePath,
+  parseNumstat,
+  getGitChangeSummary
+};
+//# sourceMappingURL=chunk-JKBHJQMT.js.map

package/dist/chunk-JLS65NUQ.js

@@ -0,0 +1,14 @@
+// src/utils/format-helpers.ts
+function formatBytes(bytes) {
+  const n = typeof bytes === "bigint" ? Number(bytes) : bytes;
+  if (n === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.min(Math.floor(Math.log(n) / Math.log(k)), sizes.length - 1);
+  return `${Math.round(n / k ** i * 100) / 100} ${sizes[i]}`;
+}
+
+export {
+  formatBytes
+};
+//# sourceMappingURL=chunk-JLS65NUQ.js.map

package/dist/chunk-JOSYEJKY.js

@@ -0,0 +1,141 @@
+// src/core/judge/no-edit-directive.ts
+var CODE_CHANGE_INTENT_PATTERN = /\b(add|build|create|edit|fix|implement|refactor|remove|replace|update)\b/i;
+var IMPERATIVE_EDIT_VERBS = String.raw`(?:modify|change|edit|write|create|add|touch)(?:\s*,\s*(?:modify|change|edit|write|create|add|touch))*(?:\s*,?\s*(?:and|or)\s+(?:modify|change|edit|write|create|add|touch))?`;
+var GERUND_EDIT_VERBS = String.raw`(?:modifying|changing|editing|writing|creating|adding|touching)(?:\s*,\s*(?:modifying|changing|editing|writing|creating|adding|touching))*(?:\s*,?\s*(?:and|or)\s+(?:modifying|changing|editing|writing|creating|adding|touching))?`;
+var SHORT_IMPERATIVE_EDIT_VERBS = String.raw`(?:modify|edit|change)(?:\s*,\s*(?:modify|edit|change))*(?:\s*,?\s*(?:and|or)\s+(?:modify|edit|change))?`;
+var SCOPED_CIRCUMSTANCE_TAIL = String.raw`(?:any|no|all)\s+(?:circumstances|condition|conditions)\b`;
+var SCOPED_LOCATION_PREPOSITIONS = String.raw`outside|in|except|(?:under|inside)(?!\s+${SCOPED_CIRCUMSTANCE_TAIL})`;
+var SCOPED_OBJECT_RESTRICTIONS = "other|unrelated|additional|existing";
+var SCOPED_NO_EDIT_PATTERNS = [
+  new RegExp(
+    String.raw`\bdo\s+not\s+${IMPERATIVE_EDIT_VERBS}\s+(?:any\s+)?(?:${SCOPED_OBJECT_RESTRICTIONS})\b`,
+    "i"
+  ),
+  new RegExp(
+    String.raw`\bdon't\s+${IMPERATIVE_EDIT_VERBS}\s+(?:any\s+)?(?:${SCOPED_OBJECT_RESTRICTIONS})\b`,
+    "i"
+  ),
+  new RegExp(
+    String.raw`\bdo\s+not\s+${IMPERATIVE_EDIT_VERBS}\s+files?\s+(?:${SCOPED_LOCATION_PREPOSITIONS})\b`,
+    "i"
+  ),
+  new RegExp(
+    String.raw`\bdon't\s+${IMPERATIVE_EDIT_VERBS}\s+files?\s+(?:${SCOPED_LOCATION_PREPOSITIONS})\b`,
+    "i"
+  ),
+  new RegExp(
+    String.raw`\bwithout\s+${GERUND_EDIT_VERBS}\s+(?:any\s+)?(?:${SCOPED_OBJECT_RESTRICTIONS})\b`,
+    "i"
+  ),
+  new RegExp(
+    String.raw`\bwithout\s+${GERUND_EDIT_VERBS}\s+files?\s+(?:${SCOPED_LOCATION_PREPOSITIONS})\b`,
+    "i"
+  ),
+  // Short "no edits outside/under/inside X" is path-scoped, not a global ban
+  new RegExp(String.raw`\bno\s+edits?\s+(?:${SCOPED_LOCATION_PREPOSITIONS})\b`, "i"),
+  /\bno\s+(?:file|workspace|repo|repository)\s+(?:changes|edits|modifications)\s+needed\s+for\b/i
+];
+var BLANKET_NO_EDIT_PATTERNS = [
+  // do not / don't + verb(s) + files/workspace/code (not scoped location/other/existing)
+  new RegExp(
+    String.raw`\bdo\s+not\s+${IMPERATIVE_EDIT_VERBS}\s+(?:any\s+)?(?:files?|the\s+workspace|the\s+repo|the\s+repository|code|source)\b(?!\s+(?:${SCOPED_LOCATION_PREPOSITIONS}|${SCOPED_OBJECT_RESTRICTIONS})\b)`,
+    "i"
+  ),
+  new RegExp(
+    String.raw`\bdon't\s+${IMPERATIVE_EDIT_VERBS}\s+(?:any\s+)?(?:files?|the\s+workspace|the\s+repo|the\s+repository|code|source)\b(?!\s+(?:${SCOPED_LOCATION_PREPOSITIONS}|${SCOPED_OBJECT_RESTRICTIONS})\b)`,
+    "i"
+  ),
+  // short form: bare verb only at clause end, with explicit file-like object, or
+  // blanket "anything" — not scoped object restrictions such as "the public API"
+  new RegExp(
+    String.raw`\bdo\s+not\s+${SHORT_IMPERATIVE_EDIT_VERBS}(?!\s+(?:any\s+)?(?:${SCOPED_OBJECT_RESTRICTIONS})\b)(?:\s+(?:any\s+)?(?:code|files?|source|workspace|anything)\b(?!\s+(?:${SCOPED_LOCATION_PREPOSITIONS})\b)|(?=\s*[.!?;,]|$))`,
+    "i"
+  ),
+  new RegExp(
+    String.raw`\bdon't\s+${SHORT_IMPERATIVE_EDIT_VERBS}(?!\s+(?:any\s+)?(?:${SCOPED_OBJECT_RESTRICTIONS})\b)(?:\s+(?:any\s+)?(?:code|files?|source|workspace|anything)\b(?!\s+(?:${SCOPED_LOCATION_PREPOSITIONS})\b)|(?=\s*[.!?;,]|$))`,
+    "i"
+  ),
+  // without + gerund(s) + files/workspace/code (requires file-like object; not "dependencies")
+  new RegExp(
+    String.raw`\bwithout\s+${GERUND_EDIT_VERBS}\s+(?:any\s+)?(?:files?|the\s+workspace|the\s+repo|the\s+repository|code|source)\b(?!\s+(?:${SCOPED_LOCATION_PREPOSITIONS})\b)`,
+    "i"
+  ),
+  /\bwithout\s+code\s+changes?\b/i,
+  /\bno\s+(?:file|workspace|repo|repository)\s+(?:changes|edits|modifications)\b(?!\s+needed\s+for\b)/i,
+  /\bno\s+code\s+changes?\b/i,
+  // "no edits" is blanket; "no edits outside/under/inside X" is scoped
+  new RegExp(String.raw`\bno\s+edits?\b(?!\s+(?:${SCOPED_LOCATION_PREPOSITIONS})\b)`, "i"),
+  /\bdo\s+not\s+write\s+code\b/i,
+  /\bdon't\s+write\s+code\b/i,
+  /\b(?:return|record|provide)\s+(?:findings|analysis|assessment|report)\s+only\b/i,
+  /\b(?:only|just)\s+analy(?:s|z)e\b/i,
+  /\b--analysis-only\b/i,
+  /\banalysis[- ]only\b/i,
+  // Operating-mode read-only only — bare "read-only" is not sufficient
+  // (e.g. "implement a read-only endpoint" is an edit task).
+  /\bread[- ]only\s+(?:audit|review|analysis|inspection)\b/i,
+  /\b(?:operate|operating|work|working)\s+in\s+read[- ]only(?:\s+mode)?\b/i
+];
+function maskScopedNoEditPhrases(text) {
+  let remaining = text;
+  for (const pattern of SCOPED_NO_EDIT_PATTERNS) {
+    remaining = remaining.replace(pattern, " ");
+  }
+  return remaining;
+}
+function hasCodeChangeIntent(text) {
+  const clauses = text.split(/(?<=[.!?])\s+|\n+/).map((clause) => clause.trim()).filter(Boolean);
+  return clauses.some((clause) => {
+    const remaining = maskScopedNoEditPhrases(clause);
+    return !matchesBlanketPattern(remaining) && CODE_CHANGE_INTENT_PATTERN.test(remaining);
+  });
+}
+function hasScopedNoEditConstraint(text) {
+  return SCOPED_NO_EDIT_PATTERNS.some((pattern) => pattern.test(text));
+}
+function hasTrueBlanketNoEditConstraint(text) {
+  return matchesBlanketPattern(maskScopedNoEditPhrases(text));
+}
+function matchesBlanketPattern(text) {
+  return BLANKET_NO_EDIT_PATTERNS.some((pattern) => pattern.test(text));
+}
+function classifyExplicitNoEdit(text) {
+  if (!text) {
+    return false;
+  }
+  const codeChangeIntent = hasCodeChangeIntent(text);
+  const scopedConstraint = hasScopedNoEditConstraint(text);
+  const blanketConstraint = hasTrueBlanketNoEditConstraint(text);
+  if (blanketConstraint) {
+    return true;
+  }
+  if (scopedConstraint) {
+    return !codeChangeIntent;
+  }
+  return false;
+}
+function detectExplicitNoEditDirective(text) {
+  return classifyExplicitNoEdit(text);
+}
+function detectProseResponseOnlyDirective(text) {
+  const proseOnlyPatterns = [
+    /\bin\s+(?:one|a|single)\s+sentence\b[\s\S]{0,160}\b(?:state|say|answer|respond|return|provide|summari[sz]e|explain)\b/i,
+    /\b(?:state|say|answer|respond|return|provide|summari[sz]e|explain)\b[\s\S]{0,160}\bin\s+(?:one|a|single)\s+sentence\b/i,
+    /\b(?:one|single)-sentence\s+(?:answer|response|summary|statement|output)\b/i,
+    /\b(?:return|provide|record)\s+(?:a\s+)?(?:concise\s+)?(?:answer|response|summary|statement)\s+only\b/i
+  ];
+  if (!proseOnlyPatterns.some((pattern) => pattern.test(text))) {
+    return false;
+  }
+  const explicitEditTarget = /\b(?:files?|workspace|repo|repository|source|code|implementation|tests?|unit tests?|integration tests?)\b/i.test(
+    text
+  ) || /\b[A-Za-z0-9_./@+-]+\.(?:[cm]?[jt]sx?|json|css|scss|md|ya?ml|toml)\b/.test(text);
+  return !explicitEditTarget;
+}
+
+export {
+  classifyExplicitNoEdit,
+  detectExplicitNoEditDirective,
+  detectProseResponseOnlyDirective
+};
+//# sourceMappingURL=chunk-JOSYEJKY.js.map

package/dist/chunk-JPKSXKNB.js

@@ -0,0 +1,94 @@
+import {
+  NATIVE_TELEMETRY_UNAVAILABLE_MARKER,
+  NODE_VERSION_MISMATCH_MARKER
+} from "./chunk-TAJPCXSB.js";
+import {
+  POETIC_SQLITE_REQUIRE_NATIVE,
+  coerceEnvValue
+} from "./chunk-5DLKYTQX.js";
+
+// src/core/runtime/node-runtime.ts
+import { createRequire } from "module";
+var REQUIRED_NODE_MAJOR = 24;
+function parseNodeMajor(version) {
+  const major = version.replace(/^v/, "").split(".")[0];
+  return Number.parseInt(major ?? "", 10);
+}
+function isEnabled(value) {
+  return /^(1|true|yes|on)$/i.test(value?.trim() ?? "");
+}
+function isTestRuntime(env = process.env) {
+  return env.NODE_ENV === "test" || isEnabled(env.VITEST);
+}
+function shouldRequireNativeSqlite(env = process.env) {
+  const configured = env[POETIC_SQLITE_REQUIRE_NATIVE.name];
+  if (configured !== void 0 && configured !== "") {
+    return coerceEnvValue(POETIC_SQLITE_REQUIRE_NATIVE, configured);
+  }
+  return isTestRuntime(env) ? false : POETIC_SQLITE_REQUIRE_NATIVE.default === true;
+}
+function prepareDiagnosticRuntime(version = process.version, env = process.env) {
+  if (parseNodeMajor(version) !== REQUIRED_NODE_MAJOR) {
+    env.POETIC_SQLITE_REQUIRE_NATIVE = "0";
+  }
+}
+function isDiagnosticInvocation({ command, args, bareMode }) {
+  if (command === void 0) {
+    return bareMode !== "tui";
+  }
+  if (command === "--help" || command === "-h" || command === "help" || command === "--version" || command === "-V") {
+    return true;
+  }
+  if (args.includes("--help") || args.includes("-h")) {
+    return true;
+  }
+  return (command === "doctor" || command === "d") && !args.includes("--fix");
+}
+function loadBetterSqlite3() {
+  const nodeRequire = createRequire(import.meta.url);
+  return nodeRequire("better-sqlite3");
+}
+function assertPoeticRuntimeReady(options = {}) {
+  const version = options.version ?? process.version;
+  const env = options.env ?? process.env;
+  const currentMajor = parseNodeMajor(version);
+  const allowUnsupportedNode = isEnabled(env.POETIC_ALLOW_UNSUPPORTED_NODE);
+  if (currentMajor !== REQUIRED_NODE_MAJOR && !allowUnsupportedNode) {
+    const command = options.command ? ` for \`poetic ${options.command}\`` : "";
+    throw new Error(
+      [
+        `Error: ${NODE_VERSION_MISMATCH_MARKER}${command}.`,
+        `Required: v${REQUIRED_NODE_MAJOR}.x`,
+        `Current: ${version}`,
+        `Select Node ${REQUIRED_NODE_MAJOR} and rebuild native dependencies before retrying.`,
+        "See docs/TROUBLESHOOTING.md#node-version-mismatch."
+      ].join("\n")
+    );
+  }
+  if (options.requiresNativeTelemetry === false || !shouldRequireNativeSqlite(env)) {
+    return;
+  }
+  try {
+    const Database = (options.loadNativeDatabase ?? loadBetterSqlite3)();
+    const database = new Database(":memory:");
+    database.close();
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      [
+        `Error: ${NATIVE_TELEMETRY_UNAVAILABLE_MARKER} under Node ${version}.`,
+        `better-sqlite3 readiness check failed: ${detail}`,
+        `Rebuild it under Node ${REQUIRED_NODE_MAJOR}: npm rebuild better-sqlite3`,
+        "Set POETIC_SQLITE_REQUIRE_NATIVE=0 only for an explicit lossy fallback."
+      ].join("\n")
+    );
+  }
+}
+
+export {
+  shouldRequireNativeSqlite,
+  prepareDiagnosticRuntime,
+  isDiagnosticInvocation,
+  assertPoeticRuntimeReady
+};
+//# sourceMappingURL=chunk-JPKSXKNB.js.map