@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-PAAWLLZX.js

@@ -0,0 +1,74 @@
+import {
+  DefaultSecretScrubber
+} from "./chunk-3E244UDA.js";
+
+// src/security/error-sanitize.ts
+import { homedir } from "node:os";
+var scrubber = new DefaultSecretScrubber();
+var ERROR_DETAIL_MAX = 500;
+function messageOf(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  try {
+    return String(err);
+  } catch {
+    return "unknown error";
+  }
+}
+function sanitizeApiError(err) {
+  const lower = messageOf(err).toLowerCase();
+  if (lower.includes("enoent") || lower.includes("no such file")) {
+    return "resource not found";
+  }
+  if (lower.includes("eacces") || lower.includes("permission")) {
+    return "permission denied";
+  }
+  if (lower.includes("json") && (lower.includes("parse") || lower.includes("unexpected"))) {
+    return "malformed data";
+  }
+  return "internal error";
+}
+function scrubErrorDetail(err) {
+  const out = scrubErrorText(messageOf(err));
+  return out.length > ERROR_DETAIL_MAX ? `${out.slice(0, ERROR_DETAIL_MAX - 1)}\u2026` : out;
+}
+function scrubErrorText(text) {
+  if (!text) return text;
+  let out = scrubber.scrub(text);
+  const home = safeHomedir();
+  if (home && home.length > 2) {
+    out = replaceAllCaseInsensitive(out, home, "~");
+    const alt = home.includes("\\") ? home.replace(/\\/g, "/") : home.replace(/\//g, "\\");
+    if (alt !== home) out = replaceAllCaseInsensitive(out, alt, "~");
+  }
+  return out;
+}
+function safeHomedir() {
+  try {
+    return homedir();
+  } catch {
+    return "";
+  }
+}
+function replaceAllCaseInsensitive(haystack, needle, replacement) {
+  const lowerHay = haystack.toLowerCase();
+  const lowerNeedle = needle.toLowerCase();
+  let idx = lowerHay.indexOf(lowerNeedle);
+  if (idx === -1) return haystack;
+  let out = "";
+  let from = 0;
+  while (idx !== -1) {
+    out += haystack.slice(from, idx) + replacement;
+    from = idx + needle.length;
+    idx = lowerHay.indexOf(lowerNeedle, from);
+  }
+  return out + haystack.slice(from);
+}
+
+export {
+  ERROR_DETAIL_MAX,
+  sanitizeApiError,
+  scrubErrorDetail,
+  scrubErrorText
+};
+//# sourceMappingURL=chunk-PAAWLLZX.js.map

package/dist/chunk-PFXFQQRT.js

@@ -0,0 +1,339 @@
+import {
+  SECRET_FILE_MODE
+} from "./chunk-H5E77KUJ.js";
+import {
+  atomicWrite,
+  withFileLock
+} from "./chunk-7ZHZE5EO.js";
+
+// src/plugins/review-report-store.ts
+import { randomUUID } from "node:crypto";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+
+// src/plugins/review-report-types.ts
+var InvalidReportTransitionError = class extends Error {
+  from;
+  to;
+  constructor(from, to, reason) {
+    const msg = reason ?? `Invalid report transition from "${from}" to "${to}"`;
+    super(msg);
+    this.name = "InvalidReportTransitionError";
+    this.from = from;
+    this.to = to;
+  }
+};
+var REPORT_TRANSITION_MATRIX = {
+  open: /* @__PURE__ */ new Set(["actioned", "completed", "skipped"]),
+  actioned: /* @__PURE__ */ new Set(["completed", "skipped"]),
+  completed: /* @__PURE__ */ new Set(["open"]),
+  skipped: /* @__PURE__ */ new Set(["open"])
+};
+function validateReportTransition(from, to) {
+  if (from === to) return;
+  const allowed = REPORT_TRANSITION_MATRIX[from];
+  if (!allowed?.has(to)) {
+    throw new InvalidReportTransitionError(from, to);
+  }
+}
+function reportEventTypeFor(to) {
+  switch (to) {
+    case "actioned":
+      return "actioned";
+    case "completed":
+      return "completed";
+    case "skipped":
+      return "skipped";
+    default:
+      return "reopened";
+  }
+}
+
+// src/plugins/review-report-store.ts
+var REPORT_RETENTION_MS = 90 * 24 * 60 * 60 * 1e3;
+var REPORT_DEFAULT_PAGE_SIZE = 25;
+var NL = "\n";
+var REPORT_STORE_FILE = "review-reports.jsonl";
+function resolveReportStorePath(projectDir) {
+  return path.join(projectDir, REPORT_STORE_FILE);
+}
+var JsonlReportStore = class {
+  filePath;
+  constructor(projectDir) {
+    this.filePath = resolveReportStorePath(projectDir);
+  }
+  get storePath() {
+    return this.filePath;
+  }
+  // ── Persist (create or reopen) ───────────────────────────────────
+  async persist(input) {
+    return withFileLock(this.filePath, async () => {
+      const existing = await this._findRecord(input.id);
+      if (existing) {
+        const updated = {
+          ...existing,
+          counts: input.counts,
+          totalFindings: input.totalFindings,
+          unparseableCount: input.unparseableCount,
+          durationSeconds: input.durationSeconds ?? existing.durationSeconds,
+          rawText: input.rawText || existing.rawText,
+          files: input.files.length > 0 ? input.files : existing.files,
+          ...input.evidenceStatus !== void 0 ? { evidenceStatus: input.evidenceStatus } : {},
+          ...input.evidenceChecks !== void 0 ? { evidenceChecks: input.evidenceChecks } : {}
+        };
+        await fsp.appendFile(this.filePath, JSON.stringify({ __report: 1, data: updated }) + NL, {
+          encoding: "utf8",
+          mode: SECRET_FILE_MODE
+        });
+        return updated;
+      }
+      const report = {
+        id: input.id,
+        reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: input.sessionId,
+        agentId: input.agentId,
+        reviewerModel: input.reviewerModel,
+        source: input.source,
+        reviewStatus: input.reviewStatus,
+        lifecycle: "open",
+        files: input.files,
+        counts: input.counts,
+        totalFindings: input.totalFindings,
+        unparseableCount: input.unparseableCount,
+        durationSeconds: input.durationSeconds,
+        rawText: input.rawText,
+        ...input.cascadeDepth !== void 0 ? { cascadeDepth: input.cascadeDepth } : {},
+        ...input.evidenceStatus !== void 0 ? { evidenceStatus: input.evidenceStatus } : {},
+        ...input.evidenceChecks !== void 0 ? { evidenceChecks: input.evidenceChecks } : {}
+      };
+      const createdEvent = {
+        id: randomUUID(),
+        reportId: report.id,
+        eventType: "created",
+        fromLifecycle: null,
+        toLifecycle: "open",
+        actorId: "system",
+        actorKind: "system",
+        timestamp: report.reviewedAt
+      };
+      const lines = JSON.stringify({ __report: 1, data: report }) + NL + JSON.stringify({ __reportEvent: 1, data: createdEvent }) + NL;
+      await fsp.appendFile(this.filePath, lines, { encoding: "utf8", mode: SECRET_FILE_MODE });
+      return report;
+    });
+  }
+  // ── Lifecycle transitions ────────────────────────────────────────
+  async transition(reportId, to, actor, opts) {
+    return withFileLock(this.filePath, async () => {
+      const all = await this._readAll();
+      const entry = all.find((e) => e.report.id === reportId);
+      if (!entry) throw new Error(`Review report not found: ${reportId}`);
+      const from = this._materialize(entry).lifecycle;
+      validateReportTransition(from, to);
+      const event = {
+        id: randomUUID(),
+        reportId,
+        eventType: reportEventTypeFor(to),
+        fromLifecycle: from,
+        toLifecycle: to,
+        actorId: actor.id,
+        actorKind: actor.kind,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: opts?.reason
+      };
+      entry.report.lifecycle = to;
+      await fsp.appendFile(this.filePath, JSON.stringify({ __reportEvent: 1, data: event }) + NL, {
+        encoding: "utf8",
+        mode: SECRET_FILE_MODE
+      });
+      return { ...entry.report };
+    });
+  }
+  async updateEvidence(reportId, status, checks) {
+    return withFileLock(this.filePath, async () => {
+      const all = await this._readAll();
+      const entry = all.find((candidate) => candidate.report.id === reportId);
+      if (!entry) throw new Error(`Review report not found: ${reportId}`);
+      const updated = {
+        ...this._materialize(entry),
+        evidenceStatus: status,
+        evidenceChecks: checks
+      };
+      await fsp.appendFile(
+        this.filePath,
+        `${JSON.stringify({ __report: 1, data: updated })}${NL}`,
+        { encoding: "utf8", mode: SECRET_FILE_MODE }
+      );
+      return updated;
+    });
+  }
+  async addNote(reportId, actor, note) {
+    return withFileLock(this.filePath, async () => {
+      const all = await this._readAll();
+      const entry = all.find((e) => e.report.id === reportId);
+      if (!entry) throw new Error(`Review report not found: ${reportId}`);
+      const materialized = this._materialize(entry);
+      const event = {
+        id: randomUUID(),
+        reportId,
+        eventType: "note_added",
+        fromLifecycle: materialized.lifecycle,
+        toLifecycle: materialized.lifecycle,
+        actorId: actor.id,
+        actorKind: actor.kind,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: note
+      };
+      await fsp.appendFile(this.filePath, JSON.stringify({ __reportEvent: 1, data: event }) + NL, {
+        encoding: "utf8",
+        mode: SECRET_FILE_MODE
+      });
+      return materialized;
+    });
+  }
+  // ── Query ────────────────────────────────────────────────────────
+  async list(opts) {
+    const all = await this._readAll();
+    let reports = all.map((e) => this._materialize(e));
+    if (opts?.statuses && opts.statuses.length > 0) {
+      const set = new Set(opts.statuses);
+      reports = reports.filter((r) => set.has(r.lifecycle));
+    }
+    if (opts?.sources && opts.sources.length > 0) {
+      const set = new Set(opts.sources);
+      reports = reports.filter((r) => set.has(r.source));
+    }
+    reports.sort((a, b) => b.reviewedAt.localeCompare(a.reviewedAt));
+    const limit = opts?.limit ?? REPORT_DEFAULT_PAGE_SIZE;
+    return reports.slice(0, limit);
+  }
+  async get(id) {
+    const all = await this._readAll();
+    const entry = all.find((e) => e.report.id === id);
+    return entry ? this._materialize(entry) : null;
+  }
+  async getEvents(reportId) {
+    const all = await this._readAllLines();
+    const events = [];
+    for (const line of all) {
+      try {
+        const parsed = JSON.parse(line);
+        if (this._isEventRecord(parsed) && parsed.data.reportId === reportId) {
+          events.push(parsed.data);
+        }
+      } catch {
+      }
+    }
+    return events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  }
+  // ── Compaction ───────────────────────────────────────────────────
+  async compact(opts) {
+    return withFileLock(this.filePath, async () => {
+      const maxAge = opts?.maxAgeMs ?? REPORT_RETENTION_MS;
+      const now = Date.now();
+      const all = await this._readAll();
+      const kept = [];
+      let removed = 0;
+      let eventsFolded = 0;
+      for (const entry of all) {
+        const age = now - new Date(entry.report.reviewedAt).getTime();
+        const materialized = this._materialize(entry);
+        const isTerminal = materialized.lifecycle === "completed" || materialized.lifecycle === "skipped";
+        if (isTerminal && age > maxAge) {
+          removed++;
+          eventsFolded += entry.events.length;
+          continue;
+        }
+        const oldEvents = entry.events.filter(
+          (ev) => now - new Date(ev.timestamp).getTime() > maxAge
+        );
+        if (oldEvents.length > 1) {
+          eventsFolded += oldEvents.length - 1;
+          const newestOld = oldEvents.sort((a, b) => b.timestamp.localeCompare(a.timestamp))[0];
+          entry.events = [
+            newestOld,
+            ...entry.events.filter((ev) => now - new Date(ev.timestamp).getTime() <= maxAge)
+          ];
+        }
+        kept.push({ record: { __report: 1, data: entry.report }, events: entry.events });
+      }
+      const lines = [];
+      for (const { record, events } of kept) {
+        if (record) lines.push(JSON.stringify(record));
+        for (const ev of events) {
+          lines.push(JSON.stringify({ __reportEvent: 1, data: ev }));
+        }
+      }
+      lines.push(
+        JSON.stringify({
+          __reportCompact: 1,
+          compactedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          removedReports: removed,
+          foldedEvents: eventsFolded
+        })
+      );
+      await atomicWrite(this.filePath, lines.join(NL) + NL, { mode: 384 });
+      return { removed, eventsFolded };
+    });
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  async _readAllLines() {
+    try {
+      const raw = await fsp.readFile(this.filePath, "utf8");
+      return raw.split(NL).filter((l) => l.trim().length > 0);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+  _isReportRecord(v) {
+    return typeof v === "object" && v !== null && v["__report"] === 1;
+  }
+  _isEventRecord(v) {
+    return typeof v === "object" && v !== null && v["__reportEvent"] === 1;
+  }
+  async _readAll() {
+    const lines = await this._readAllLines();
+    const reports = /* @__PURE__ */ new Map();
+    const eventsMap = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (this._isReportRecord(parsed)) {
+          reports.set(parsed.data.id, parsed.data);
+          if (!eventsMap.has(parsed.data.id)) eventsMap.set(parsed.data.id, []);
+        } else if (this._isEventRecord(parsed)) {
+          const list = eventsMap.get(parsed.data.reportId);
+          if (list) list.push(parsed.data);
+        }
+      } catch {
+      }
+    }
+    return Array.from(reports.entries()).map(([id, report]) => ({
+      report,
+      events: eventsMap.get(id) ?? []
+    }));
+  }
+  async _findRecord(id) {
+    const all = await this._readAll();
+    const entry = all.find((e) => e.report.id === id);
+    return entry ? this._materialize(entry) : null;
+  }
+  _materialize(entry) {
+    if (entry.events.length === 0) return { ...entry.report };
+    const sorted = [...entry.events].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    const latest = sorted[sorted.length - 1];
+    if (latest.eventType !== "note_added") {
+      return { ...entry.report, lifecycle: latest.toLifecycle };
+    }
+    return { ...entry.report };
+  }
+};
+
+export {
+  REPORT_RETENTION_MS,
+  REPORT_DEFAULT_PAGE_SIZE,
+  REPORT_STORE_FILE,
+  resolveReportStorePath,
+  JsonlReportStore
+};
+//# sourceMappingURL=chunk-PFXFQQRT.js.map

package/dist/chunk-PFZO3C6H.js

@@ -0,0 +1,14 @@
+// src/utils/expect-defined.ts
+function expectDefined(value, label) {
+  if (value === null || value === void 0) {
+    const err = new Error(label ? `Expected ${label} to be defined` : "Expected value to be defined");
+    err.name = "ExpectDefinedError";
+    throw err;
+  }
+  return value;
+}
+
+export {
+  expectDefined
+};
+//# sourceMappingURL=chunk-PFZO3C6H.js.map

package/dist/chunk-PHH7LD45.js

@@ -0,0 +1,113 @@
+// src/notifications/notifier-impl.ts
+function emptyCounters() {
+  return { attempted: 0, delivered: 0, failed: 0, suppressed: 0 };
+}
+var NotifierImpl = class _NotifierImpl {
+  #channels = /* @__PURE__ */ new Map();
+  #counters = /* @__PURE__ */ new Map();
+  /** Soft cap for #counters — prevents unbounded growth if channels are
+   *  repeatedly registered with distinct names. */
+  static #MAX_COUNTERS = 100;
+  // -----------------------------------------------------------------------
+  // Lifecycle
+  // -----------------------------------------------------------------------
+  notify(channels, message) {
+    const names = typeof channels === "string" ? [channels] : channels;
+    if (names.length === 0) return Promise.resolve([]);
+    const results = [];
+    for (const name of names) {
+      const channel = this.#channels.get(name);
+      if (!channel) continue;
+      const counters = this.#counters.get(name) ?? emptyCounters();
+      counters.attempted += 1;
+      this.#counters.set(name, counters);
+      results.push(
+        channel.deliver(message).then(
+          (result) => {
+            if (result.ok) {
+              counters.delivered += 1;
+            } else {
+              counters.failed += 1;
+            }
+            return result;
+          },
+          (err) => {
+            counters.failed += 1;
+            const error = err instanceof Error ? err.message : "unknown rejection";
+            return {
+              ok: false,
+              channel: name,
+              error: `threw: ${error}`,
+              deliveredAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+          }
+        )
+      );
+    }
+    return Promise.all(results);
+  }
+  registerChannel(channel) {
+    this.#channels.set(channel.name, channel);
+    if (!this.#counters.has(channel.name)) {
+      if (this.#counters.size >= _NotifierImpl.#MAX_COUNTERS) {
+        const oldest = this.#counters.keys().next();
+        if (!oldest.done && oldest.value !== void 0) {
+          this.#counters.delete(oldest.value);
+        }
+      }
+      this.#counters.set(channel.name, emptyCounters());
+    }
+  }
+  unregisterChannel(name) {
+    this.#channels.delete(name);
+  }
+  async channels() {
+    const entries = Array.from(this.#channels.entries());
+    const results = await Promise.allSettled(
+      entries.map(async ([name, channel]) => {
+        try {
+          const ping = await channel.ping();
+          return { name, type: channel.type, ok: ping.ok, error: ping.error };
+        } catch {
+          return { name, type: channel.type, ok: false, error: "ping threw" };
+        }
+      })
+    );
+    return results.map(
+      (r) => r.status === "fulfilled" ? r.value : { name: "unknown", type: "unknown", ok: false, error: "unhandled ping rejection" }
+    );
+  }
+  counters() {
+    let attempted = 0;
+    let delivered = 0;
+    let failed = 0;
+    let suppressed = 0;
+    for (const c of this.#counters.values()) {
+      attempted += c.attempted;
+      delivered += c.delivered;
+      failed += c.failed;
+      suppressed += c.suppressed;
+    }
+    return { attempted, delivered, failed, suppressed };
+  }
+  /**
+   * Return per-channel counters for detailed diagnostics.
+   * Not part of the `Notifier` interface — available on the concrete class.
+   */
+  perChannelCounters() {
+    const result = {};
+    for (const [name, c] of this.#counters) {
+      result[name] = {
+        attempted: c.attempted,
+        delivered: c.delivered,
+        failed: c.failed
+      };
+    }
+    return result;
+  }
+};
+
+export {
+  NotifierImpl
+};
+//# sourceMappingURL=chunk-PHH7LD45.js.map