@poetic-ai/poetic 1.42.0

package/dist/chunk-CE5OZBYY.js

@@ -0,0 +1,21 @@
+// src/core/estimation/runtime-estimate.ts
+var RUNTIME_ESTIMATOR_VERSION = 1;
+function provenanceForTier(tier) {
+  switch (tier) {
+    case "exact":
+    case "provider-model-strategy":
+    case "provider-model":
+      return "telemetry";
+    case "provider":
+    case "global":
+      return "blended";
+    case "cold-start":
+      return "heuristic";
+  }
+}
+
+export {
+  RUNTIME_ESTIMATOR_VERSION,
+  provenanceForTier
+};
+//# sourceMappingURL=chunk-CE5OZBYY.js.map

package/dist/chunk-CFBIG37O.js

@@ -0,0 +1,154 @@
+import {
+  isProjectConfigPath,
+  isProjectDocsPath,
+  isProjectSourcePath,
+  isProjectTestPath
+} from "./chunk-UDMS5AD3.js";
+
+// src/core/judge/diff-token-extractor.ts
+function categorizeFile(filePath) {
+  const path = filePath.toLowerCase();
+  if (isProjectTestPath(filePath) || /\.(test|spec)\.(ts|tsx|js|jsx|py|go|rs)$/.test(path) || /(^|\/)test_.*\.py$/.test(path) || /(^|\/).+_test\.py$/.test(path) || /_test\.(go|rs|ts|tsx|js|jsx)$/.test(path) || path.includes("/__test__/") || path.includes("/test/") || path.includes("/tests/") || path.startsWith("test/") || path.startsWith("tests/")) {
+    return "test";
+  }
+  if (/-lock\.(json|yaml|yml)$/.test(path) || /\.lock$/.test(path)) {
+    return "lockfile";
+  }
+  if (path.startsWith("dist/") || path.startsWith("build/") || path.startsWith("node_modules/") || path.startsWith(".poetic/") || path.startsWith("vendor/") || /\.min\.(js|css)$/.test(path) || /\.d\.ts$/.test(path)) {
+    return "generated";
+  }
+  if (/\.(md|txt|rst)$/.test(path) || path.startsWith("docs/") || isProjectDocsPath(filePath)) {
+    return "docs";
+  }
+  if (/\.(json|yaml|yml|toml)$/.test(path) || /tsconfig.*\.json$/.test(path) || /\.\w*rc(\.json)?$/.test(path) || isProjectConfigPath(filePath)) {
+    return "config";
+  }
+  if (isProjectSourcePath(filePath)) {
+    return "source";
+  }
+  return "other";
+}
+function extractDiffTokens(diffText) {
+  const identifiers = /* @__PURE__ */ new Set();
+  const stringLiterals = /* @__PURE__ */ new Set();
+  const exportedSymbols = /* @__PURE__ */ new Set();
+  const addedLines = diffText.split("\n").filter((line) => line.startsWith("+") && !line.startsWith("+++")).map((line) => line.slice(1));
+  for (const line of addedLines) {
+    const identifierMatches = line.match(/[A-Za-z_][A-Za-z0-9_]{2,}/g);
+    if (identifierMatches) {
+      for (const id of identifierMatches) {
+        identifiers.add(id);
+      }
+    }
+    const singleQuotedMatches = line.match(/'([^'\\]*(\\.[^'\\]*)*)'/g);
+    if (singleQuotedMatches) {
+      for (const match of singleQuotedMatches) {
+        const content = match.slice(1, -1).trim();
+        extractWordsFromString(content, stringLiterals);
+      }
+    }
+    const doubleQuotedMatches = line.match(/"([^"\\]*(\\.[^"\\]*)*)"/g);
+    if (doubleQuotedMatches) {
+      for (const match of doubleQuotedMatches) {
+        const content = match.slice(1, -1).trim();
+        extractWordsFromString(content, stringLiterals);
+      }
+    }
+    const templateLiteralMatches = line.match(/`([^`\\]*(\\.[^`\\]*)*)`/g);
+    if (templateLiteralMatches) {
+      for (const match of templateLiteralMatches) {
+        const content = match.slice(1, -1).trim();
+        const cleaned = content.replace(/\$\{[^}]*\}/g, "");
+        extractWordsFromString(cleaned, stringLiterals);
+      }
+    }
+    const exportMatch = line.match(/export\s*\{([^}]+)\}/);
+    if (exportMatch?.[1]) {
+      const symbols = exportMatch[1].split(",").map((s) => {
+        const parts = s.trim().split(/\s+as\s+/);
+        return parts[0]?.trim() ?? "";
+      }).filter(Boolean);
+      for (const sym of symbols) {
+        exportedSymbols.add(sym);
+      }
+    }
+    const exportFnMatch = line.match(
+      /export\s+(function|const|let|var|class|interface|type)\s+([A-Za-z_][A-Za-z0-9_]*)/
+    );
+    if (exportFnMatch?.[2]) {
+      exportedSymbols.add(exportFnMatch[2]);
+    }
+    const importMatch = line.match(/import\s*\{([^}]+)\}/);
+    if (importMatch?.[1]) {
+      const symbols = importMatch[1].split(",").map((s) => {
+        const parts = s.trim().split(/\s+as\s+/);
+        return parts[0]?.trim() ?? "";
+      }).filter(Boolean);
+      for (const sym of symbols) {
+        exportedSymbols.add(sym);
+      }
+    }
+  }
+  const allTokens = /* @__PURE__ */ new Set();
+  for (const id of identifiers) {
+    allTokens.add(id.toLowerCase());
+  }
+  for (const literal of stringLiterals) {
+    allTokens.add(literal.toLowerCase());
+  }
+  for (const symbol of exportedSymbols) {
+    allTokens.add(symbol.toLowerCase());
+  }
+  return {
+    identifiers,
+    stringLiterals,
+    exportedSymbols,
+    allTokens
+  };
+}
+function extractWordsFromString(str, target) {
+  const words = str.split(/[\s.,;:!?()[\]{}<>/\\|@#$%^&*+=~`"'-]+/).filter(Boolean);
+  for (const word of words) {
+    if (word.length > 0) {
+      target.add(word);
+    }
+  }
+}
+function extractChangedFilesMeta(diffText, filesChanged) {
+  const paths = /* @__PURE__ */ new Set();
+  const fileHeaderPattern = /^\+{3}\s+b\/(.+)$/gm;
+  let match = fileHeaderPattern.exec(diffText);
+  while (match !== null) {
+    if (match[1]) paths.add(match[1]);
+    match = fileHeaderPattern.exec(diffText);
+  }
+  const gitDiffPattern = /^diff --git a\/(.+) b\/(.+)$/gm;
+  let gitMatch = gitDiffPattern.exec(diffText);
+  while (gitMatch !== null) {
+    const oldPath = gitMatch[1];
+    const newPath = gitMatch[2];
+    if (oldPath && newPath && oldPath !== newPath) {
+      paths.add(newPath);
+    } else {
+      if (oldPath) paths.add(oldPath);
+      if (newPath) paths.add(newPath);
+    }
+    gitMatch = gitDiffPattern.exec(diffText);
+  }
+  if (filesChanged) {
+    for (const file of filesChanged) {
+      paths.add(file);
+    }
+  }
+  return Array.from(paths).map((path) => ({
+    path,
+    category: categorizeFile(path)
+  }));
+}
+
+export {
+  categorizeFile,
+  extractDiffTokens,
+  extractChangedFilesMeta
+};
+//# sourceMappingURL=chunk-CFBIG37O.js.map

package/dist/chunk-CJC6GZ46.js

@@ -0,0 +1,457 @@
+import {
+  ProcessRegistry
+} from "./chunk-XPHKYHO4.js";
+import {
+  reapOrphanedTmuxSessions
+} from "./chunk-4CUY7AFY.js";
+import {
+  assertSafePathComponent
+} from "./chunk-S2VQCZO4.js";
+import {
+  isPathWithin
+} from "./chunk-XZE4XARH.js";
+
+// src/core/orphan-detector.ts
+import fs from "fs/promises";
+import { platform } from "os";
+import path from "path";
+import { execa } from "execa";
+var DEFAULT_NODE_PROCESS_PATTERNS = [
+  "poetic",
+  "dist/worker.js",
+  // Catch development mode processes that should have exited
+  "tsx watch src/cli/entry.ts",
+  "npm run dev",
+  // Provider-spawned Node helper processes that can survive parent CLI termination.
+  /[/\\]@google[/\\]gemini-cli[/\\]/i,
+  /(?:^|\s|[/\\])gemini(?:\.js)?(?:\s|$).*--yolo/i,
+  /opencode.*tsserver/i,
+  /opencode.*typingsinstaller/i
+  // NOTE: vitest patterns intentionally excluded from defaults
+  // to prevent killing legitimate test runs during development.
+  // Cleaned up explicitly by the teardown returned from tests/global-setup.ts.
+];
+var DEFAULT_PROVIDER_CLI_EXECUTABLES = /* @__PURE__ */ new Set([
+  "claude",
+  "codex",
+  "cursor-agent",
+  "grok",
+  "copilot",
+  "opencode",
+  "kiro-cli",
+  "agy",
+  "gemini",
+  "pi"
+]);
+var DEFAULT_PROVIDER_CLI_PACKAGE_PATHS = [
+  /[/\\]@anthropic-ai[/\\]claude-code[/\\]/i,
+  /[/\\]@openai[/\\]codex[/\\]/i,
+  /[/\\]@github[/\\]copilot[/\\]/i
+];
+var OrphanDetector = class {
+  options;
+  matchDefaultProviderCliProcesses;
+  constructor(options = {}) {
+    this.matchDefaultProviderCliProcesses = options.processPatterns === void 0;
+    this.options = {
+      kill: options.kill ?? false,
+      verbose: options.verbose ?? true,
+      processPatterns: options.processPatterns ?? DEFAULT_NODE_PROCESS_PATTERNS,
+      protectedPids: options.protectedPids ?? [],
+      ownedPids: options.ownedPids ?? []
+    };
+  }
+  /**
+   * Detect orphaned Poetic processes
+   *
+   * @returns List of detected orphaned processes
+   */
+  async detect() {
+    const currentPlatform = platform();
+    switch (currentPlatform) {
+      case "darwin":
+      case "linux":
+        return this.detectUnix();
+      case "win32":
+        return this.detectWindows();
+      default:
+        if (this.options.verbose) {
+          console.log(`Orphan detection not supported on platform: ${currentPlatform}`);
+        }
+        return [];
+    }
+  }
+  extractBackgroundWorkerStatePath(command) {
+    if (!command.includes("dist/worker.js") || !command.includes("--task-id")) {
+      return null;
+    }
+    const taskId = command.match(/--task-id\s+(\S+)/)?.[1];
+    const configFile = command.match(/--config-file\s+(\S+)/)?.[1];
+    if (!taskId || !configFile) {
+      return null;
+    }
+    const marker = `${path.sep}.poetic${path.sep}`;
+    const markerIndex = configFile.indexOf(marker);
+    if (markerIndex < 0) {
+      return null;
+    }
+    let safeTaskId;
+    try {
+      safeTaskId = assertSafePathComponent(taskId, "taskId");
+    } catch {
+      return null;
+    }
+    const repoRoot = configFile.slice(0, markerIndex);
+    const backgroundDir = path.join(repoRoot, ".poetic", "telemetry", "state", "background");
+    const statePath = path.join(backgroundDir, `${safeTaskId}.json`);
+    return isPathWithin(statePath, backgroundDir) ? statePath : null;
+  }
+  async isActiveBackgroundWorker(pid, command) {
+    const statePath = this.extractBackgroundWorkerStatePath(command);
+    if (!statePath) {
+      return false;
+    }
+    try {
+      const raw = await fs.readFile(statePath, "utf8");
+      const state = JSON.parse(raw);
+      return state.pid === pid && state.status === "running";
+    } catch {
+      return false;
+    }
+  }
+  async isProtectedProcess(pid, command) {
+    if (this.options.protectedPids.includes(pid)) {
+      return true;
+    }
+    return this.isActiveBackgroundWorker(pid, command);
+  }
+  /**
+   * Detect and optionally kill orphaned processes
+   *
+   * @returns Number of processes killed (or would be killed in dry-run)
+   */
+  async detectAndClean() {
+    const orphans = await this.detect();
+    if (orphans.length === 0) {
+      if (this.options.verbose) {
+        console.log("No orphaned Poetic processes detected");
+      }
+      return 0;
+    }
+    if (this.options.verbose) {
+      console.log(`
+Found ${orphans.length} orphaned Poetic process(es):`);
+      for (const orphan of orphans) {
+        console.log(
+          `  \u2022 PID ${orphan.pid} (parent ${orphan.ppid}): ${orphan.command.substring(0, 80)}`
+        );
+        console.log(`    Reason: ${orphan.reason}`);
+      }
+    }
+    if (!this.options.kill) {
+      if (this.options.verbose) {
+        console.log("\nRun with kill=true to terminate these processes");
+      }
+      return orphans.length;
+    }
+    let killedCount = 0;
+    for (const orphan of orphans) {
+      if (await this.killProcess(orphan)) {
+        killedCount++;
+      }
+    }
+    if (this.options.verbose) {
+      console.log(`
+Killed ${killedCount} of ${orphans.length} orphaned process(es)`);
+    }
+    return killedCount;
+  }
+  /**
+   * Detect orphaned processes on Unix-like systems (macOS, Linux)
+   */
+  async detectUnix() {
+    try {
+      const { stdout } = await execa("ps", ["aux"], { reject: false });
+      const lines = stdout.split("\n");
+      const orphans = [];
+      const currentPid = process.pid;
+      for (const line of lines) {
+        if (!line || line.startsWith("USER")) {
+          continue;
+        }
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 11) {
+          continue;
+        }
+        const pidStr = parts[1] || "";
+        if (!pidStr) continue;
+        const pid = Number.parseInt(pidStr, 10);
+        const command = parts.slice(10).join(" ");
+        if (pid === currentPid) {
+          continue;
+        }
+        if (await this.isProtectedProcess(pid, command)) {
+          continue;
+        }
+        if (!this.isReapablePoeticProcess(pid, command)) {
+          continue;
+        }
+        const ppid = await this.getParentPid(pid);
+        if (ppid === null) {
+          continue;
+        }
+        const orphanReason = await this.checkIfOrphaned(pid, ppid);
+        if (orphanReason) {
+          orphans.push({
+            pid,
+            ppid,
+            command,
+            reason: orphanReason
+          });
+        }
+      }
+      return orphans;
+    } catch (error) {
+      if (this.options.verbose) {
+        console.error("Failed to detect orphaned processes:", error);
+      }
+      return [];
+    }
+  }
+  /**
+   * Detect orphaned processes on Windows
+   */
+  async detectWindows() {
+    try {
+      const { stdout } = await execa(
+        "wmic",
+        ["process", "get", "ProcessId,ParentProcessId,CommandLine", "/format:csv"],
+        { reject: false }
+      );
+      const lines = stdout.split("\n");
+      const orphans = [];
+      const currentPid = process.pid;
+      const header = lines.find((line) => line.trim().length > 0 && line.toLowerCase().includes("processid"))?.split(",").map((part) => part.trim().toLowerCase());
+      const hasNodeColumn = header?.[0] === "node";
+      for (const line of lines) {
+        if (!line.trim() || line.toLowerCase().includes("processid")) {
+          continue;
+        }
+        const parts = line.split(",");
+        const minColumns = hasNodeColumn ? 4 : 3;
+        if (parts.length < minColumns) {
+          continue;
+        }
+        const pid = Number.parseInt(parts.at(-1)?.trim() ?? "", 10);
+        const ppid = Number.parseInt(parts.at(-2)?.trim() ?? "", 10);
+        const commandStartIndex = hasNodeColumn ? 1 : 0;
+        const command = parts.slice(commandStartIndex, -2).join(",").trim();
+        if (Number.isNaN(pid) || Number.isNaN(ppid)) {
+          continue;
+        }
+        if (pid === currentPid) {
+          continue;
+        }
+        if (await this.isProtectedProcess(pid, command)) {
+          continue;
+        }
+        if (!this.isReapablePoeticProcess(pid, command)) {
+          continue;
+        }
+        const orphanReason = await this.checkIfOrphaned(pid, ppid);
+        if (orphanReason) {
+          orphans.push({
+            pid,
+            ppid,
+            command,
+            reason: orphanReason
+          });
+        }
+      }
+      return orphans;
+    } catch (error) {
+      if (this.options.verbose) {
+        console.error("Failed to detect orphaned processes on Windows:", error);
+      }
+      return [];
+    }
+  }
+  /**
+   * Reap only processes with Poetic ownership evidence, or known Poetic
+   * node/CLI patterns that are not provider-exe-name matches.
+   */
+  isReapablePoeticProcess(pid, command) {
+    if (this.options.ownedPids.includes(pid)) {
+      return true;
+    }
+    if (!this.isPoeticProcess(command)) {
+      return false;
+    }
+    return !this.requiresOwnershipEvidence(command) || this.hasCmdlineOwnershipEvidence(command);
+  }
+  requiresOwnershipEvidence(command) {
+    if (!this.matchDefaultProviderCliProcesses) {
+      return false;
+    }
+    return this.isDefaultProviderCliProcess(command) || this.isProviderHelperDefaultPattern(command);
+  }
+  isProviderHelperDefaultPattern(command) {
+    return /[/\\]@google[/\\]gemini-cli[/\\]/i.test(command) || /(?:^|\s|[/\\])gemini(?:\.js)?(?:\s|$).*--yolo/i.test(command) || /opencode.*tsserver/i.test(command) || /opencode.*typingsinstaller/i.test(command);
+  }
+  hasCmdlineOwnershipEvidence(command) {
+    const unixMarker = "/.poetic/";
+    const windowsMarker = "\\.poetic\\";
+    return command.includes(unixMarker) || command.includes(windowsMarker);
+  }
+  /**
+   * Check if a command line indicates a Poetic process
+   */
+  isPoeticProcess(command) {
+    if (this.matchDefaultProviderCliProcesses && this.isDefaultProviderCliProcess(command)) {
+      return true;
+    }
+    if (!command.includes("node")) {
+      return false;
+    }
+    return this.options.processPatterns.some(
+      (pattern) => typeof pattern === "string" ? command.includes(pattern) : pattern.test(command)
+    );
+  }
+  isDefaultProviderCliProcess(command) {
+    const tokens = command.trim().split(/\s+/).filter((token) => token.length > 0);
+    if (tokens.length === 0) {
+      return false;
+    }
+    const first = tokens[0];
+    if (!first) {
+      return false;
+    }
+    if (this.isProviderCliToken(first)) {
+      return true;
+    }
+    const firstName = this.normalizeExecutableName(first);
+    const second = tokens[1];
+    return (firstName === "node" || firstName === "nodejs") && !!second && this.isProviderCliToken(second);
+  }
+  isProviderCliToken(token) {
+    const normalized = this.normalizeExecutableName(token);
+    if (DEFAULT_PROVIDER_CLI_EXECUTABLES.has(normalized)) {
+      return true;
+    }
+    const cleaned = this.stripTokenQuotes(token);
+    return DEFAULT_PROVIDER_CLI_PACKAGE_PATHS.some((pattern) => pattern.test(cleaned));
+  }
+  normalizeExecutableName(token) {
+    const cleaned = this.stripTokenQuotes(token);
+    const basename = cleaned.split(/[/\\]/).pop() ?? cleaned;
+    return basename.replace(/\.(?:js|cmd|exe)$/i, "").toLowerCase();
+  }
+  stripTokenQuotes(token) {
+    return token.replace(/^['"]|['"]$/g, "");
+  }
+  /**
+   * Get parent PID for a given process
+   */
+  async getParentPid(pid) {
+    try {
+      const currentPlatform = platform();
+      if (currentPlatform === "darwin" || currentPlatform === "linux") {
+        const { stdout } = await execa("ps", ["-o", "ppid=", "-p", String(pid)], {
+          reject: false
+        });
+        const ppid = Number.parseInt(stdout.trim(), 10);
+        return Number.isNaN(ppid) ? null : ppid;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if a process is orphaned
+   *
+   * Orphan criteria:
+   * 1. Parent PID is 1 (init/systemd) - process was reparented
+   * 2. Parent PID doesn't exist - parent died without cleanup
+   *
+   * @returns Reason string if orphaned, null if not orphaned
+   */
+  async checkIfOrphaned(_pid, ppid) {
+    if (ppid === 1) {
+      return "Parent died (reparented to init/systemd)";
+    }
+    try {
+      const currentPlatform = platform();
+      if (currentPlatform === "darwin" || currentPlatform === "linux") {
+        process.kill(ppid, 0);
+        return null;
+      }
+      if (currentPlatform === "win32") {
+        const { exitCode } = await execa("tasklist", ["/FI", `PID eq ${ppid}`], {
+          reject: false
+        });
+        if (exitCode === 0) {
+          return null;
+        }
+        return "Parent process does not exist";
+      }
+    } catch (_error) {
+      return "Parent process does not exist or is not accessible";
+    }
+    return null;
+  }
+  /**
+   * Kill a process (with SIGTERM, then SIGKILL after delay)
+   *
+   * @returns true if killed successfully, false otherwise
+   */
+  async killProcess(orphan) {
+    try {
+      if (this.options.verbose) {
+        console.log(`Killing PID ${orphan.pid} (${orphan.reason})...`);
+      }
+      process.kill(orphan.pid, "SIGTERM");
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      try {
+        process.kill(orphan.pid, 0);
+        if (this.options.verbose) {
+          console.log(`  PID ${orphan.pid} did not exit gracefully, force killing...`);
+        }
+        process.kill(orphan.pid, "SIGKILL");
+      } catch {
+      }
+      return true;
+    } catch (error) {
+      if (this.options.verbose) {
+        console.error(`  Failed to kill PID ${orphan.pid}:`, error);
+      }
+      return false;
+    }
+  }
+};
+async function cleanOrphanedProcesses(options = {}) {
+  let ownedPids = options.ownedPids;
+  if (ownedPids === void 0) {
+    try {
+      const registry = new ProcessRegistry({ verbose: false });
+      await registry.init();
+      ownedPids = (await registry.getAll()).map((entry) => entry.pid);
+    } catch {
+      ownedPids = [];
+    }
+  }
+  const detector = new OrphanDetector({ ...options, ownedPids });
+  const killed = await detector.detectAndClean();
+  try {
+    const reaped = await reapOrphanedTmuxSessions({ dryRun: options.kill !== true });
+    return killed + reaped.length;
+  } catch {
+    return killed;
+  }
+}
+
+export {
+  OrphanDetector,
+  cleanOrphanedProcesses
+};
+//# sourceMappingURL=chunk-CJC6GZ46.js.map