@poetic-ai/poetic 1.42.0

package/dist/chunk-J62KPGII.js

@@ -0,0 +1,464 @@
+import {
+  getIntEnv
+} from "./chunk-XAONGNST.js";
+import {
+  readCanonicalPoeticConfig,
+  selectedPoeticConfigCandidate
+} from "./chunk-G36W2T2S.js";
+import {
+  formatBytes
+} from "./chunk-JLS65NUQ.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/telemetry/db-size-manager.ts
+import { stat } from "fs/promises";
+
+// src/telemetry/retention-config.ts
+import { existsSync } from "fs";
+import * as path from "path";
+var DEFAULTS = {
+  telemetryDays: 90,
+  dbSoftDays: 180,
+  dbWarningDays: 90,
+  backupsDays: 30,
+  backupsMonthlyCount: 3,
+  backupsMaxBytes: 1024 * 1024 * 1024,
+  logsDays: 7,
+  vacuumOnCleanup: true,
+  signalFilesRetentionDays: 90
+};
+function parseClampedEnvInt(envVar, defaultValue, min, max) {
+  const raw = process.env[envVar];
+  if (!raw) return defaultValue;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return defaultValue;
+  if (parsed < min || parsed > max) return defaultValue;
+  return parsed;
+}
+function resolveRetentionConfig(opts) {
+  const config = { ...DEFAULTS };
+  const configFilePath = opts?.configFilePath === null ? null : opts?.configFilePath ?? selectedPoeticConfigCandidate(
+    path.join(process.cwd(), ".poetic", "config", "poetic.config.jsonc")
+  );
+  if (configFilePath !== null && existsSync(configFilePath)) {
+    const read = readCanonicalPoeticConfig(configFilePath);
+    if (read.status === "invalid") throw read.error;
+    if (read.status === "valid") {
+      const telemetry = read.config.telemetry;
+      const retention = telemetry && typeof telemetry === "object" && !Array.isArray(telemetry) ? telemetry.retention : void 0;
+      if (retention && typeof retention === "object") {
+        const r = retention;
+        if (typeof r.backups_days === "number" && r.backups_days > 0) {
+          config.backupsDays = r.backups_days;
+        }
+        if (typeof r.backups_monthly_count === "number" && r.backups_monthly_count >= 0) {
+          config.backupsMonthlyCount = r.backups_monthly_count;
+        }
+        if (typeof r.backups_max_bytes === "number" && r.backups_max_bytes >= 0) {
+          config.backupsMaxBytes = r.backups_max_bytes;
+        }
+        if (typeof r.logs_days === "number" && r.logs_days > 0) {
+          config.logsDays = r.logs_days;
+        }
+        if (typeof r.vacuum_on_cleanup === "boolean") {
+          config.vacuumOnCleanup = r.vacuum_on_cleanup;
+        }
+      }
+    }
+  }
+  config.telemetryDays = getIntEnv("POETIC_TELEMETRY_RETENTION_DAYS", config.telemetryDays);
+  config.signalFilesRetentionDays = getIntEnv(
+    "POETIC_TELEMETRY_SIGNALS_RETENTION_DAYS",
+    config.signalFilesRetentionDays
+  );
+  const softDays = parseClampedEnvInt("POETIC_DB_SOFT_RETENTION_DAYS", config.dbSoftDays, 30, 3650);
+  config.dbSoftDays = softDays;
+  config.dbWarningDays = parseClampedEnvInt(
+    "POETIC_DB_WARNING_RETENTION_DAYS",
+    config.dbWarningDays,
+    7,
+    Math.min(softDays, 3650)
+  );
+  return config;
+}
+
+// src/telemetry/db-size-manager.ts
+function parseEnvInt(envVar, defaultValue, min, max) {
+  const value = process.env[envVar];
+  if (!value) return defaultValue;
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isNaN(parsed)) {
+    emitWarning(
+      "CFG-002",
+      {
+        taskId: "system",
+        subsystem: "telemetry",
+        executionPhase: "setup"
+      },
+      {
+        severity: "INFO" /* INFO */,
+        metadata: {
+          envVar,
+          invalidValue: value,
+          defaultValue,
+          reason: "Invalid environment variable value"
+        }
+      }
+    );
+    return defaultValue;
+  }
+  if (parsed < min || parsed > max) {
+    emitWarning(
+      "CFG-002",
+      {
+        taskId: "system",
+        subsystem: "telemetry",
+        executionPhase: "setup"
+      },
+      {
+        severity: "INFO" /* INFO */,
+        metadata: {
+          envVar,
+          value: parsed,
+          min,
+          max,
+          defaultValue,
+          reason: "Environment variable out of range"
+        }
+      }
+    );
+    return defaultValue;
+  }
+  return parsed;
+}
+var SOFT_LIMIT = parseEnvInt(
+  "POETIC_DB_SOFT_LIMIT",
+  1610612736,
+  // 1.5GB default - Silent cleanup
+  104857600,
+  // 100MB minimum
+  10737418240
+  // 10GB maximum
+);
+var WARNING_LIMIT = parseEnvInt(
+  "POETIC_DB_WARNING_LIMIT",
+  2147483648,
+  // 2GB default - Warn and aggressive cleanup
+  Math.max(SOFT_LIMIT, 104857600),
+  // Must be >= SOFT_LIMIT
+  10737418240
+  // 10GB maximum
+);
+var HARD_LIMIT = parseEnvInt(
+  "POETIC_DB_HARD_LIMIT",
+  5368709120,
+  // 5GB default - Block writes, require manual intervention
+  Math.max(WARNING_LIMIT, 104857600),
+  // Must be >= WARNING_LIMIT
+  53687091200
+  // 50GB maximum
+);
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var _dbRetention = resolveRetentionConfig({ configFilePath: null });
+var SOFT_RETENTION_DAYS = _dbRetention.dbSoftDays;
+var WARNING_RETENTION_DAYS = _dbRetention.dbWarningDays;
+var VARIANT_EXECUTIONS_RETENTION_WHERE = "completed_at IS NOT NULL AND ((typeof(completed_at) IN ('integer', 'real') AND completed_at < ?) OR (typeof(completed_at) = 'text' AND completed_at < ?))";
+var DbSizeManager = class _DbSizeManager {
+  constructor(dbPath, db) {
+    this.dbPath = dbPath;
+    this.db = db;
+  }
+  dbPath;
+  db;
+  /**
+   * Get current database file size in bytes
+   */
+  async getDbSize() {
+    try {
+      const stats = await stat(this.dbPath);
+      return stats.size;
+    } catch (_error) {
+      return 0;
+    }
+  }
+  /**
+   * Format bytes for human-readable output
+   */
+  /**
+   * Check database size and perform automatic cleanup if needed
+   *
+   * This is the main entry point, designed to run on startup (async, non-blocking).
+   *
+   * Cleanup strategy:
+   * - < 1.5GB: No action
+   * - 1.5-2GB: Silent cleanup (delete >180 day old records)
+   * - 2-5GB: Warn and aggressive cleanup (delete >90 day old records)
+   * - > 5GB: Error, require manual intervention
+   */
+  async checkAndCleanup() {
+    const size = await this.getDbSize();
+    if (size >= HARD_LIMIT) {
+      throw new Error(
+        `Telemetry DB at hard limit (${formatBytes(size)}). Manual intervention required: poetic telemetry cleanup --older-than 30d`
+      );
+    }
+    if (size >= WARNING_LIMIT) {
+      console.warn(`Telemetry DB >2GB (${formatBytes(size)}). Cleaning aggressively...`);
+      const report = await this.cleanup({
+        olderThan: WARNING_RETENTION_DAYS,
+        vacuum: true
+      });
+      console.warn(`Freed ${formatBytes(report.freedBytes || 0)} from telemetry DB`);
+      return { ...report, level: "warning" };
+    }
+    if (size >= SOFT_LIMIT) {
+      const report = await this.cleanup({
+        olderThan: SOFT_RETENTION_DAYS,
+        vacuum: true
+      });
+      return { ...report, level: "soft" };
+    }
+    return {
+      cleaned: false,
+      size,
+      level: "ok"
+    };
+  }
+  /**
+   * Perform cleanup of old telemetry data
+   *
+   * @param options Cleanup configuration
+   * @returns Cleanup report with statistics
+   */
+  async cleanup(options) {
+    const oldSize = await this.getDbSize();
+    const cutoff = Date.now() - options.olderThan * DAY_MS;
+    if (options.dryRun) {
+      const isoCutoff2 = new Date(cutoff).toISOString();
+      const countMatch = (sql, ...params) => {
+        try {
+          const row = this.db.prepare(sql).get(...params);
+          return row?.count ?? 0;
+        } catch {
+          return 0;
+        }
+      };
+      const deletedRecords2 = countMatch(
+        `SELECT COUNT(*) AS count FROM variant_executions WHERE ${VARIANT_EXECUTIONS_RETENTION_WHERE}`,
+        cutoff,
+        isoCutoff2
+      ) + countMatch(
+        "SELECT COUNT(*) AS count FROM variant_executions_v2 WHERE created_at < ?",
+        isoCutoff2
+      ) + countMatch(
+        "SELECT COUNT(*) AS count FROM variant_results WHERE completed_at < ? AND completed_at IS NOT NULL",
+        isoCutoff2
+      );
+      return {
+        cleaned: false,
+        deletedRecords: deletedRecords2,
+        oldSize,
+        newSize: oldSize,
+        freedBytes: 0,
+        size: oldSize,
+        level: "ok"
+      };
+    }
+    const isoCutoff = new Date(cutoff).toISOString();
+    let deletedRecords = 0;
+    try {
+      this.runInTransaction(() => {
+        const deleteEvidenceResult = this.tolerantDelete(
+          `DELETE FROM deduction_evidence_v2
+            WHERE judge_deduction_id IN (
+              SELECT jd.judge_deduction_id
+              FROM judge_deductions_v2 jd
+              JOIN judge_variant_scores_v2 jvs
+                ON jvs.judge_variant_score_id = jd.judge_variant_score_id
+              JOIN variant_executions_v2 ve
+                ON ve.variant_execution_id = jvs.variant_execution_id
+              WHERE ve.created_at < ?
+            )`,
+          isoCutoff
+        );
+        const deleteDeductionsResult = this.tolerantDelete(
+          `DELETE FROM judge_deductions_v2
+            WHERE judge_variant_score_id IN (
+              SELECT jvs.judge_variant_score_id
+              FROM judge_variant_scores_v2 jvs
+              JOIN variant_executions_v2 ve
+                ON ve.variant_execution_id = jvs.variant_execution_id
+              WHERE ve.created_at < ?
+            )`,
+          isoCutoff
+        );
+        const deleteScoresResult = this.tolerantDelete(
+          `DELETE FROM judge_variant_scores_v2
+            WHERE variant_execution_id IN (
+              SELECT variant_execution_id
+              FROM variant_executions_v2
+              WHERE created_at < ?
+            )`,
+          isoCutoff
+        );
+        const deleteTouchesResult = this.tolerantDelete(
+          `DELETE FROM file_touches_v2
+            WHERE variant_execution_id IN (
+              SELECT variant_execution_id
+              FROM variant_executions_v2
+              WHERE created_at < ?
+            )`,
+          isoCutoff
+        );
+        const deleteVariantExecutionsV2Result = this.tolerantDelete(
+          "DELETE FROM variant_executions_v2 WHERE created_at < ?",
+          isoCutoff
+        );
+        const variantsResult = this.tolerantDelete(
+          `DELETE FROM variant_executions WHERE ${VARIANT_EXECUTIONS_RETENTION_WHERE}`,
+          cutoff,
+          isoCutoff
+        );
+        const deleteVariantResultsResult = this.tolerantDelete(
+          "DELETE FROM variant_results WHERE completed_at < ? AND completed_at IS NOT NULL",
+          isoCutoff
+        );
+        deletedRecords = (variantsResult.changes || 0) + (deleteVariantExecutionsV2Result.changes || 0) + (deleteTouchesResult.changes || 0) + (deleteScoresResult.changes || 0) + (deleteDeductionsResult.changes || 0) + (deleteEvidenceResult.changes || 0) + (deleteVariantResultsResult.changes || 0);
+      });
+    } catch (error) {
+      console.error("Telemetry cleanup failed:", error);
+      throw error;
+    }
+    if (options.vacuum && !options.dryRun) {
+      const VACUUM_FREELIST_THRESHOLD_PAGES = 256;
+      let shouldVacuum = deletedRecords > 0;
+      if (!shouldVacuum) {
+        shouldVacuum = this.getFreelistPageCount() >= VACUUM_FREELIST_THRESHOLD_PAGES;
+      }
+      if (shouldVacuum) {
+        const vacuumStmt = this.db.prepare("VACUUM");
+        vacuumStmt.run();
+      }
+    }
+    const newSize = await this.getDbSize();
+    const freedBytes = oldSize - newSize;
+    return {
+      cleaned: true,
+      deletedRecords,
+      oldSize,
+      newSize,
+      freedBytes,
+      size: newSize,
+      level: "ok"
+    };
+  }
+  /**
+   * Run a unit of work inside a transaction so the delete batch is atomic
+   * (all-or-nothing). Uses better-sqlite3's transaction() (which nests safely
+   * via savepoints) when available; otherwise falls back to explicit
+   * BEGIN/COMMIT/ROLLBACK via exec() so the all-or-nothing contract still holds
+   * on any DatabaseLike (a mid-batch failure rolls back earlier deletes instead
+   * of committing orphans). Only a driver that throws on BEGIN (e.g. a
+   * non-persistent in-memory shim) degrades to a direct call.
+   */
+  runInTransaction(work) {
+    if (this.db.transaction) {
+      this.db.transaction(work)();
+      return;
+    }
+    try {
+      this.db.exec("BEGIN");
+    } catch {
+      work();
+      return;
+    }
+    try {
+      work();
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+      }
+      throw error;
+    }
+  }
+  /**
+   * Read the SQLite freelist page count. Returns 0 when the pragma is
+   * unavailable (e.g. the in-memory shim) so VACUUM gating fails closed toward
+   * "skip" on a no-delete run.
+   */
+  getFreelistPageCount() {
+    try {
+      const result = this.db.pragma("freelist_count");
+      if (Array.isArray(result)) {
+        const row = result[0];
+        return row?.freelist_count ?? 0;
+      }
+      return typeof result === "number" ? result : 0;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Run a DELETE, tolerating only the expected "no such table" error that
+   * historical DBs missing an optional table will raise. Every other error
+   * propagates so the surrounding transaction rolls the whole cleanup back
+   * (all-or-nothing) instead of committing orphaned rows.
+   */
+  tolerantDelete(sql, ...params) {
+    try {
+      return this.db.prepare(sql).run(...params);
+    } catch (error) {
+      if (_DbSizeManager.isMissingTableError(error)) {
+        return { changes: 0 };
+      }
+      throw error;
+    }
+  }
+  static isMissingTableError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /no such table/i.test(message);
+  }
+  /**
+   * Get database statistics
+   */
+  async getStats() {
+    const size = await this.getDbSize();
+    let level = "ok";
+    let limitForPercent = SOFT_LIMIT;
+    if (size >= HARD_LIMIT) {
+      level = "critical";
+      limitForPercent = HARD_LIMIT;
+    } else if (size >= WARNING_LIMIT) {
+      level = "warning";
+      limitForPercent = WARNING_LIMIT;
+    } else if (size >= SOFT_LIMIT) {
+      level = "soft";
+      limitForPercent = SOFT_LIMIT;
+    }
+    const percentOfLimit = size / limitForPercent * 100;
+    let recordCount;
+    try {
+      const countStmt = this.db.prepare("SELECT COUNT(*) as count FROM variant_executions");
+      const result = countStmt.get();
+      recordCount = result?.count;
+    } catch {
+    }
+    return {
+      size,
+      sizeFormatted: formatBytes(size),
+      level,
+      percentOfLimit,
+      recordCount
+    };
+  }
+};
+
+export {
+  resolveRetentionConfig,
+  DbSizeManager
+};
+//# sourceMappingURL=chunk-J62KPGII.js.map

package/dist/chunk-J6P3FWWW.js

@@ -0,0 +1,130 @@
+import {
+  ensureConfigDir,
+  getBackupPath,
+  getConfigPaths,
+  normalizeConfigPath
+} from "./chunk-L6OM4A22.js";
+import {
+  validatePath
+} from "./chunk-XZE4XARH.js";
+
+// src/core/config/utils/file-operations.ts
+import { randomBytes } from "crypto";
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname, join, parse, sep } from "path";
+function atomicWrite(filePath, content, options = {}) {
+  const startTime = Date.now();
+  const {
+    backup = true,
+    encoding = "utf8",
+    mode = 420,
+    skipValidation = false,
+    baseDir = process.cwd()
+  } = options;
+  const generateTempPath = (dir) => {
+    return join(dir, `.tmp.${process.pid}.${Date.now()}.${randomBytes(8).toString("hex")}`);
+  };
+  let tempPath;
+  let backupPath;
+  try {
+    let normalizedPath = normalizeConfigPath(filePath);
+    if (!skipValidation) {
+      const { userConfigDir } = getConfigPaths(baseDir);
+      const isUserConfigPath = normalizedPath === userConfigDir || normalizedPath.startsWith(userConfigDir + sep);
+      const validation = validatePath(filePath, {
+        baseDir,
+        allowMissingParentDir: true,
+        allowDynamicImport: isUserConfigPath,
+        allowedDirs: [join(baseDir, ".poetic"), userConfigDir]
+        // strictAllowedDirs: false (default) - baseDir (process.cwd()) is implicitly allowed
+        // To restrict writes to ONLY .poetic/ and ~/.config/poetic/, set strictAllowedDirs: true
+      });
+      if (!validation.isValid) {
+        throw new Error(
+          `Security Error: Invalid config path "${filePath}": ${validation.reason}. Risk level: ${validation.riskLevel}`
+        );
+      }
+      normalizedPath = validation.normalizedPath;
+    }
+    const dir = dirname(normalizedPath);
+    if (!ensureConfigDir(dir)) {
+      throw new Error(`Cannot create directory: ${dir}`);
+    }
+    if (backup && existsSync(normalizedPath)) {
+      backupPath = getBackupPath(normalizedPath);
+      const backupContent = readFileSync(normalizedPath);
+      writeFileSync(backupPath, backupContent);
+    }
+    let retryCount = 0;
+    const MAX_RETRIES = 3;
+    while (retryCount < MAX_RETRIES) {
+      tempPath = generateTempPath(dir);
+      if (!existsSync(tempPath)) {
+        break;
+      }
+      retryCount++;
+      if (retryCount >= MAX_RETRIES) {
+        throw new Error(`Failed to generate unique temp file after ${MAX_RETRIES} attempts`);
+      }
+    }
+    if (!tempPath) {
+      throw new Error("Failed to generate temporary file path");
+    }
+    let writeContent;
+    if (typeof content === "string") {
+      writeContent = Buffer.from(content, encoding);
+    } else {
+      writeContent = content;
+    }
+    writeFileSync(tempPath, writeContent, { mode });
+    const verification = readFileSync(tempPath);
+    if (verification.length !== writeContent.length) {
+      throw new Error("File write verification failed");
+    }
+    renameSync(tempPath, normalizedPath);
+    const duration = Date.now() - startTime;
+    return {
+      success: true,
+      path: normalizedPath,
+      backupPath,
+      bytesWritten: writeContent.length,
+      duration
+    };
+  } catch (error) {
+    if (tempPath) {
+      try {
+        unlinkSync(tempPath);
+      } catch {
+      }
+    }
+    return {
+      success: false,
+      path: filePath,
+      error: error instanceof Error ? error : new Error(String(error)),
+      duration: Date.now() - startTime
+    };
+  }
+}
+function atomicWriteJson(filePath, data, options = {}) {
+  const jsonString = `${JSON.stringify(data, null, 2)}
+`;
+  return atomicWrite(filePath, jsonString, {
+    backup: false,
+    ...options,
+    encoding: "utf8"
+  });
+}
+
+export {
+  atomicWrite,
+  atomicWriteJson
+};
+//# sourceMappingURL=chunk-J6P3FWWW.js.map