agentpostmortem 0.1.0

package/dist/chunk-Q7YDLORD.js

@@ -0,0 +1,547 @@
+// src/storage/paths.ts
+import fs2 from "fs/promises";
+import os from "os";
+import path2 from "path";
+import { z } from "zod";
+
+// src/storage/project.ts
+import crypto from "crypto";
+import fs from "fs/promises";
+import path from "path";
+var PROJECT_HASH_LENGTH = 24;
+async function canonicalWorktree(worktree) {
+  const resolved = path.resolve(worktree);
+  const canonical = await fs.realpath(resolved).catch(() => resolved);
+  return process.platform === "win32" ? canonical.toLowerCase() : canonical;
+}
+async function projectId(worktree) {
+  const canonical = await canonicalWorktree(worktree);
+  return crypto.createHash("sha256").update(canonical).digest("hex").slice(0, PROJECT_HASH_LENGTH);
+}
+
+// src/storage/paths.ts
+var PostmortemConfigSchema = z.object({
+  storage: z.enum(["user", "repo"]).optional(),
+  storeRaw: z.boolean().optional()
+});
+function postmortemConfigPath(worktree) {
+  return path2.join(path2.resolve(worktree), ".opencode", "postmortem.json");
+}
+async function isSymlink(p) {
+  const stat = await fs2.lstat(p).catch(() => void 0);
+  return stat?.isSymbolicLink() ?? false;
+}
+async function symlinkError(p, operation, label) {
+  if (!await isSymlink(p)) return void 0;
+  return `refusing to ${operation} postmortem artifact because ${label} is a symlink: ${p}`;
+}
+async function assertSafeArtifactPath(p, operation, label) {
+  const error = await symlinkError(p, operation, label);
+  if (!error) return;
+  throw new Error(error);
+}
+async function repoStorageSafety(worktree) {
+  const root = path2.resolve(worktree);
+  const opencodeDir = path2.join(root, ".opencode");
+  if (await isSymlink(opencodeDir)) {
+    return {
+      safe: false,
+      error: "repo-local postmortem storage is unsafe because .opencode is a symlink"
+    };
+  }
+  const postmortemsDir = path2.join(opencodeDir, "postmortems");
+  if (await isSymlink(postmortemsDir)) {
+    return {
+      safe: false,
+      error: "repo-local postmortem storage is unsafe because .opencode/postmortems is a symlink"
+    };
+  }
+  const id = await projectId(worktree);
+  const projectDir = path2.join(postmortemsDir, id);
+  if (await isSymlink(projectDir)) {
+    return {
+      safe: false,
+      error: `repo-local postmortem storage is unsafe because .opencode/postmortems/${id} is a symlink`
+    };
+  }
+  const artifacts = [
+    ["last-run.json", "last-run.json"],
+    ["failures.jsonl", "failures.jsonl"],
+    ["rules.json", "rules.json"],
+    ["index.json", "index.json"],
+    ["write.lock", "write.lock"]
+  ];
+  for (const [name, label] of artifacts) {
+    const artifactPath = path2.join(projectDir, name);
+    if (await isSymlink(artifactPath)) {
+      return {
+        safe: false,
+        error: `repo-local postmortem storage is unsafe because ${label} is a symlink at ${artifactPath}`
+      };
+    }
+  }
+  return { safe: true };
+}
+async function loadPostmortemConfig(worktree) {
+  const raw = await fs2.readFile(postmortemConfigPath(worktree), "utf8").catch(() => "");
+  if (!raw.trim()) return {};
+  const parsed = await Promise.resolve().then(() => JSON.parse(raw)).catch(() => ({}));
+  const config = PostmortemConfigSchema.safeParse(parsed);
+  if (!config.success) return {};
+  return config.data;
+}
+async function savePostmortemConfig(worktree, config) {
+  const parsed = PostmortemConfigSchema.parse(config);
+  const configPath = postmortemConfigPath(worktree);
+  await fs2.mkdir(path2.dirname(configPath), { recursive: true });
+  await fs2.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf8");
+  return {
+    path: configPath,
+    config: parsed
+  };
+}
+function baseDataDir() {
+  const home = os.homedir();
+  if (process.platform === "darwin") {
+    return path2.join(home, "Library", "Application Support");
+  }
+  if (process.platform === "win32") {
+    return process.env.LOCALAPPDATA || process.env.APPDATA || path2.join(home, "AppData", "Local");
+  }
+  return process.env.XDG_DATA_HOME || path2.join(home, ".local", "share");
+}
+function globalPostmortemRoot() {
+  return path2.join(baseDataDir(), "opencode", "postmortems");
+}
+async function postmortemPaths(worktree) {
+  const resolvedWorktree = path2.resolve(worktree);
+  const id = await projectId(worktree);
+  return {
+    projectId: id,
+    globalRoot: globalPostmortemRoot(),
+    defaultRoot: path2.join(globalPostmortemRoot(), id),
+    localOverrideRoot: path2.join(resolvedWorktree, ".opencode", "postmortems", id)
+  };
+}
+async function resolvePostmortemRoot(worktree) {
+  const [paths, config] = await Promise.all([postmortemPaths(worktree), loadPostmortemConfig(worktree)]);
+  const repoSafe = config.storage === "repo" ? (await repoStorageSafety(worktree)).safe : false;
+  return {
+    projectId: paths.projectId,
+    defaultRoot: paths.defaultRoot,
+    localOverrideRoot: paths.localOverrideRoot,
+    root: repoSafe ? paths.localOverrideRoot : paths.defaultRoot
+  };
+}
+
+// src/store/failures.ts
+import fs5 from "fs/promises";
+
+// src/model.ts
+import { z as z2 } from "zod";
+var MAX_REDACTED_TEXT = 2e3;
+var MAX_RULE_TEXT = 160;
+var MAX_SIGNATURES = 10;
+var MAX_PATHS = 50;
+var MAX_TOOLS = 20;
+var FAILURE_RECORD_SCHEMA_VERSION = 1;
+var EvidenceType = z2.enum([
+  "tool",
+  "error",
+  "diff_summary",
+  "git_status",
+  "context_gap"
+]);
+var EvidenceItem = z2.object({
+  type: EvidenceType,
+  redactedText: z2.string().max(MAX_REDACTED_TEXT),
+  hash: z2.string(),
+  byteCount: z2.number().int().nonnegative(),
+  tokenEstimate: z2.number().int().nonnegative()
+});
+var Signature = z2.object({
+  messageHash: z2.string(),
+  toolFailureHash: z2.string().optional()
+});
+var GuardrailMatch = z2.object({
+  signatures: z2.array(z2.string()).max(MAX_SIGNATURES).optional(),
+  paths: z2.array(z2.string()).max(MAX_PATHS).optional(),
+  tools: z2.array(z2.string()).max(MAX_TOOLS).optional(),
+  keywords: z2.array(z2.string()).optional()
+});
+var GuardrailRule = z2.object({
+  id: z2.string(),
+  enabled: z2.boolean(),
+  match: GuardrailMatch,
+  rule: z2.object({
+    text: z2.string().max(MAX_RULE_TEXT),
+    severity: z2.enum(["must", "should"])
+  }),
+  userFeedbackRating: z2.enum(["positive", "negative"]).optional(),
+  userFeedbackNote: z2.string().max(500).optional()
+});
+var FailureKind = z2.enum([
+  "missing_env",
+  "missing_file",
+  "test_failure",
+  "wrong_file",
+  "unknown"
+]);
+var WhyFailedCitation = z2.object({
+  type: EvidenceType,
+  hash: z2.string()
+});
+var WhyFailedHypothesis = z2.object({
+  type: FailureKind,
+  confidence: z2.number().min(0).max(1),
+  explanation: z2.string().max(300),
+  citations: z2.array(WhyFailedCitation).min(1).max(5)
+});
+var WhyFailedRuleSuggestion = z2.object({
+  text: z2.string().max(MAX_RULE_TEXT),
+  severity: z2.enum(["must", "should"]),
+  match: GuardrailMatch
+});
+var WhyFailedAnalysis = z2.object({
+  version: z2.literal(1),
+  generatedAt: z2.string(),
+  hierarchy: z2.array(FailureKind).min(1).max(5),
+  hypotheses: z2.array(WhyFailedHypothesis).min(1).max(3),
+  rules: z2.array(WhyFailedRuleSuggestion).min(1).max(3)
+});
+var FailureRecord = z2.object({
+  schemaVersion: z2.literal(FAILURE_RECORD_SCHEMA_VERSION),
+  id: z2.string(),
+  projectId: z2.string(),
+  createdAt: z2.string(),
+  sessionId: z2.string(),
+  parentFailureId: z2.string().optional(),
+  runId: z2.string().optional(),
+  signature: Signature,
+  evidence: z2.array(EvidenceItem).optional(),
+  redactionReport: z2.unknown().optional(),
+  selectionTrace: z2.unknown().optional(),
+  analysis: WhyFailedAnalysis.optional()
+});
+var FailureRecordPartial = FailureRecord.partial();
+
+// src/storage/lock.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+var DEFAULT_LOCK_STALE_TTL_MS = 12e4;
+var LockBusyError = class extends Error {
+  constructor(lockPath) {
+    super(`lock already held: ${lockPath}`);
+    this.lockPath = lockPath;
+    this.name = "LockBusyError";
+  }
+};
+function stale(data, now, ttlMs) {
+  const createdAt = Date.parse(data.createdAt);
+  if (Number.isNaN(createdAt)) return true;
+  return now - createdAt > ttlMs;
+}
+async function read(lockPath) {
+  await assertSafeArtifactPath(lockPath, "read", "write.lock");
+  const text = await fs3.readFile(lockPath, "utf8");
+  return JSON.parse(text);
+}
+async function readOptional(lockPath) {
+  return read(lockPath).catch((error) => {
+    const err = error;
+    if (err.code === "ENOENT") return null;
+    throw error;
+  });
+}
+async function claim(lockPath, now) {
+  await assertSafeArtifactPath(lockPath, "lock", "write.lock");
+  const data = {
+    pid: process.pid,
+    createdAt: new Date(now).toISOString()
+  };
+  await fs3.mkdir(path3.dirname(lockPath), { recursive: true });
+  await fs3.writeFile(lockPath, JSON.stringify(data), { flag: "wx" });
+  return data;
+}
+async function acquireWriteLock(lockPath, options = {}) {
+  const staleTtlMs = options.staleTtlMs ?? DEFAULT_LOCK_STALE_TTL_MS;
+  const now = options.now ?? Date.now;
+  try {
+    const data = await claim(lockPath, now());
+    return {
+      data,
+      path: lockPath,
+      release: async () => {
+        const current2 = await readOptional(lockPath);
+        if (!current2) return;
+        if (current2.pid !== data.pid || current2.createdAt !== data.createdAt) return;
+        await fs3.rm(lockPath, { force: true });
+      }
+    };
+  } catch (error) {
+    const err = error;
+    if (err.code !== "EEXIST") throw err;
+  }
+  const current = await readOptional(lockPath);
+  if (!current || !stale(current, now(), staleTtlMs)) {
+    throw new LockBusyError(lockPath);
+  }
+  await fs3.rm(lockPath, { force: true });
+  try {
+    const data = await claim(lockPath, now());
+    return {
+      data,
+      path: lockPath,
+      release: async () => {
+        const latest = await readOptional(lockPath);
+        if (!latest) return;
+        if (latest.pid !== data.pid || latest.createdAt !== data.createdAt) return;
+        await fs3.rm(lockPath, { force: true });
+      }
+    };
+  } catch (error) {
+    const err = error;
+    if (err.code === "EEXIST") throw new LockBusyError(lockPath);
+    throw err;
+  }
+}
+
+// src/store/paths.ts
+import path4 from "path";
+function storePathsFromRoot(root) {
+  return {
+    root,
+    failures: path4.join(root, "failures.jsonl"),
+    rules: path4.join(root, "rules.json"),
+    index: path4.join(root, "index.json"),
+    summary: path4.join(root, "SUMMARY.md"),
+    lock: path4.join(root, "write.lock")
+  };
+}
+
+// src/store/summary.ts
+import fs4 from "fs/promises";
+function parseDate(value) {
+  const time = Date.parse(value);
+  if (Number.isNaN(time)) return 0;
+  return time;
+}
+function safe(value) {
+  if (!value) return "-";
+  return value.replace(/\r?\n/g, " ").replace(/\|/g, "\\|").trim() || "-";
+}
+function renderSummary(records) {
+  const sorted = [...records].sort((a, b) => {
+    const timeDiff = parseDate(b.createdAt) - parseDate(a.createdAt);
+    if (timeDiff !== 0) return timeDiff;
+    return a.id.localeCompare(b.id);
+  });
+  const lines = [
+    "# Failure Summary",
+    "",
+    `- Total records: ${sorted.length}`,
+    "",
+    "## Records",
+    "",
+    "| id | createdAt | sessionId | messageHash | toolFailureHash | evidenceCount |",
+    "| --- | --- | --- | --- | --- | --- |",
+    ...sorted.map((record) => {
+      const evidenceCount = record.evidence?.length ?? 0;
+      return [
+        `| ${safe(record.id)}`,
+        `${safe(record.createdAt)}`,
+        `${safe(record.sessionId)}`,
+        `${safe(record.signature.messageHash)}`,
+        `${safe(record.signature.toolFailureHash)}`,
+        `${evidenceCount} |`
+      ].join(" | ");
+    })
+  ];
+  return `${lines.join("\n")}
+`;
+}
+async function writeSummary(root, records) {
+  const paths = storePathsFromRoot(root);
+  const content = renderSummary(records);
+  await fs4.mkdir(paths.root, { recursive: true });
+  const lock = await acquireWriteLock(paths.lock);
+  try {
+    await fs4.writeFile(paths.summary, content, "utf8");
+  } finally {
+    await lock.release();
+  }
+  return {
+    path: paths.summary,
+    lockPath: paths.lock,
+    content
+  };
+}
+
+// src/store/failures.ts
+function parseFailureLines(text) {
+  if (!text) {
+    return {
+      records: [],
+      skipped: 0,
+      warnings: []
+    };
+  }
+  const lines = text.split("\n");
+  const records = [];
+  const warnings = [];
+  lines.forEach((line, index) => {
+    if (line.length === 0) return;
+    try {
+      const item = FailureRecord.parse(JSON.parse(line));
+      records.push(item);
+    } catch {
+      warnings.push({
+        line: index + 1,
+        message: "skipped corrupted or invalid failure record"
+      });
+    }
+  });
+  return {
+    records,
+    skipped: warnings.length,
+    warnings
+  };
+}
+async function writeFailureRecords(path5, records) {
+  await assertSafeArtifactPath(path5, "write", "failures.jsonl");
+  const lines = records.map((record) => JSON.stringify(record)).join("\n");
+  await fs5.writeFile(path5, lines.length > 0 ? `${lines}
+` : "", "utf8");
+}
+async function appendFailureRecord(root, record) {
+  const paths = storePathsFromRoot(root);
+  const parsed = FailureRecord.parse(record);
+  await fs5.mkdir(paths.root, { recursive: true });
+  await assertSafeArtifactPath(paths.failures, "append", "failures.jsonl");
+  const lock = await acquireWriteLock(paths.lock);
+  try {
+    await fs5.appendFile(paths.failures, `${JSON.stringify(parsed)}
+`, "utf8");
+  } finally {
+    await lock.release();
+  }
+  return {
+    path: paths.failures,
+    lockPath: paths.lock
+  };
+}
+async function loadFailureRecords(root) {
+  const paths = storePathsFromRoot(root);
+  await assertSafeArtifactPath(paths.failures, "read", "failures.jsonl");
+  const text = await fs5.readFile(paths.failures, "utf8").catch((error) => {
+    const err = error;
+    if (err.code === "ENOENT") return "";
+    throw err;
+  });
+  return parseFailureLines(text);
+}
+async function updateFailureRecord(root, id, update) {
+  const paths = storePathsFromRoot(root);
+  await fs5.mkdir(paths.root, { recursive: true });
+  await assertSafeArtifactPath(paths.failures, "read", "failures.jsonl");
+  const lock = await acquireWriteLock(paths.lock);
+  let result;
+  try {
+    const text = await fs5.readFile(paths.failures, "utf8").catch((error) => {
+      const err = error;
+      if (err.code === "ENOENT") return "";
+      throw err;
+    });
+    const loaded = parseFailureLines(text);
+    const index = loaded.records.findIndex((record) => record.id === id);
+    if (index < 0) {
+      result = {
+        notFound: true,
+        records: loaded.records.length,
+        skipped: loaded.skipped,
+        warnings: loaded.warnings
+      };
+    } else {
+      const next = FailureRecord.parse(
+        update(loaded.records[index])
+      );
+      loaded.records.splice(index, 1, next);
+      await writeFailureRecords(paths.failures, loaded.records);
+      result = {
+        updated: next,
+        notFound: false,
+        records: loaded.records.length,
+        skipped: loaded.skipped,
+        warnings: loaded.warnings
+      };
+    }
+  } finally {
+    await lock.release();
+  }
+  if (!result.notFound)
+    await writeSummary(root, (await loadFailureRecords(root)).records);
+  return result;
+}
+function pruneFailureRecords(records, options = {}) {
+  const nowMs = options.nowMs ?? (options.nowIso ? Date.parse(options.nowIso) : Date.now());
+  const cmp = (a, b) => {
+    const ta = Date.parse(a.createdAt);
+    const tb = Date.parse(b.createdAt);
+    if (ta !== tb) return tb - ta;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  };
+  const sorted = [...records].sort(cmp);
+  const dropped = [];
+  let kept = sorted;
+  if (typeof options.maxAgeDays === "number") {
+    const cutoff = nowMs - options.maxAgeDays * 24 * 60 * 60 * 1e3;
+    const pass = [];
+    for (const r of kept) {
+      const t = Date.parse(r.createdAt);
+      if (t >= cutoff) pass.push(r);
+      else dropped.push(r);
+    }
+    kept = pass;
+  }
+  const keepN = typeof options.keepLastN === "number" ? options.keepLastN : options.maxRecords;
+  if (typeof keepN === "number" && kept.length > keepN) {
+    const toDrop = kept.slice(keepN);
+    dropped.push(...toDrop);
+    kept = kept.slice(0, keepN);
+  }
+  if (typeof options.maxBytes === "number") {
+    const sizes = kept.map(
+      (r) => Buffer.byteLength(`${JSON.stringify(r)}
+`, "utf8")
+    );
+    let total = sizes.reduce((s, n) => s + n, 0);
+    while (total > options.maxBytes && kept.length > 0) {
+      const removed = kept.pop();
+      const sz = sizes.pop();
+      total -= sz;
+      dropped.push(removed);
+    }
+  }
+  dropped.sort(cmp);
+  return { kept, dropped };
+}
+
+export {
+  postmortemConfigPath,
+  assertSafeArtifactPath,
+  repoStorageSafety,
+  loadPostmortemConfig,
+  savePostmortemConfig,
+  resolvePostmortemRoot,
+  MAX_RULE_TEXT,
+  FAILURE_RECORD_SCHEMA_VERSION,
+  GuardrailRule,
+  acquireWriteLock,
+  storePathsFromRoot,
+  writeSummary,
+  appendFailureRecord,
+  loadFailureRecords,
+  updateFailureRecord,
+  pruneFailureRecords
+};

package/dist/eval-EOZA44ZZ.js

@@ -0,0 +1,63 @@
+import {
+  loadFailureRecords,
+  resolvePostmortemRoot
+} from "./chunk-Q7YDLORD.js";
+
+// src/eval.ts
+function signatureKey(record) {
+  return record.signature.toolFailureHash ?? record.signature.messageHash;
+}
+function deterministicSort(records) {
+  return [...records].sort((a, b) => {
+    const ta = Date.parse(a.createdAt);
+    const tb = Date.parse(b.createdAt);
+    if (ta !== tb) return ta - tb;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  });
+}
+async function renderEval(worktree, args = {}) {
+  const paths = await resolvePostmortemRoot(worktree);
+  const loaded = await loadFailureRecords(paths.root);
+  const records = deterministicSort(loaded.records);
+  const totalRecords = records.length;
+  const sigs = records.map(signatureKey);
+  const window = Math.max(1, Number(args.window ?? 10));
+  let repeatWithinWindowCount = 0;
+  const repeatCounts = {};
+  for (let i = 0; i < sigs.length; i++) {
+    const s = sigs[i];
+    let repeated = false;
+    for (let j = i + 1; j <= i + window && j < sigs.length; j++) {
+      if (sigs[j] === s) {
+        repeated = true;
+        repeatCounts[s] = (repeatCounts[s] ?? 0) + 1;
+      }
+    }
+    if (repeated) repeatWithinWindowCount++;
+  }
+  const uniqueSignatures = new Set(sigs).size;
+  const repeatCountsBySignature = Object.entries(repeatCounts).sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
+  }).map(([signature, count]) => ({ signature, count }));
+  const payload = {
+    totalRecords,
+    uniqueSignatures,
+    repeatRateWithinWindow: totalRecords === 0 ? 0 : repeatWithinWindowCount / totalRecords,
+    repeatCountsBySignature
+  };
+  if (args.json) return JSON.stringify(payload, null, 2);
+  const lines = [];
+  lines.push(`postmortem root: ${paths.root}`);
+  lines.push(`total records: ${totalRecords}`);
+  lines.push(`unique signatures: ${uniqueSignatures}`);
+  lines.push(`repeat rate within window=${window}: ${payload.repeatRateWithinWindow}`);
+  lines.push(`repeat counts by signature:`);
+  for (const r of repeatCountsBySignature) lines.push(` - ${r.signature}: ${r.count}`);
+  return lines.join("\n");
+}
+var eval_default = renderEval;
+export {
+  eval_default as default,
+  renderEval
+};