@elizaos/plugin-gitpathologist 2.0.3-beta.2 → 2.0.3-beta.4

package/dist/node/index.js

@@ -0,0 +1,1023 @@
+// src/index.ts
+import { logger as logger3 } from "@elizaos/core";
+
+// src/actions/git-pathology.ts
+import path3 from "node:path";
+
+// src/render.ts
+function short(sha) {
+  return sha.slice(0, 7);
+}
+function inflectionLine(point) {
+  const direction = point.delta >= 0 ? "+" : "";
+  return `- \`${short(point.sha)}\` (${point.date.slice(0, 10)}, ${point.author}): score ${point.score.toFixed(2)} ${direction}${point.delta.toFixed(2)} — ${point.reasonShort}`;
+}
+function rotCauseBlock(cause) {
+  const [from, to] = cause.shaRange;
+  const evidence = cause.evidence.length > 0 ? `
+  - Evidence: ${cause.evidence.map(short).join(", ")}` : "";
+  return `### ${cause.category} — \`${short(from)}\`..\`${short(to)}\`
+
+${cause.narrative}${evidence}`;
+}
+function renderReport(report) {
+  const window = `${report.window.since.slice(0, 10)} → ${report.window.until.slice(0, 10)}`;
+  const peaks = report.peaks.length === 0 ? "_None detected in window._" : report.peaks.map(inflectionLine).join(`
+`);
+  const drifts = report.drifts.length === 0 ? "_None detected in window._" : report.drifts.map(inflectionLine).join(`
+`);
+  const causes = report.rotCauses.length === 0 ? "_No drift narration generated. Either no drifts detected, or budget = 0._" : report.rotCauses.map(rotCauseBlock).join(`
+
+`);
+  const authors = report.authors.length > 0 ? report.authors.join(", ") : "_none_";
+  return `# Git Pathology — \`${report.surface}\`
+
+**Repo:** \`${report.repoRoot}\`
+**Window:** ${window}
+**HEAD:** \`${short(report.headSha)}\`
+**Commits analyzed:** ${report.commitCount} (${authors})
+**LLM calls:** ${report.llmCalls}
+
+## Peaks (local maxima of health)
+
+${peaks}
+
+## Drift inflections (sustained downturns)
+
+${drifts}
+
+## Rot post-mortem
+
+${causes}
+`;
+}
+
+// src/services/git-pathology-service.ts
+import { logger as logger2, Service } from "@elizaos/core";
+
+// src/cache/report-cache.ts
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import path from "node:path";
+function makeCacheKey(input) {
+  return createHash("sha256").update(`${input.surface}\x00${input.since}`).digest("hex");
+}
+function defaultCacheDir(repoRoot) {
+  const override = process.env.GITPATHOLOGIST_CACHE_DIR?.trim();
+  if (override) {
+    return path.isAbsolute(override) ? override : path.join(repoRoot, override);
+  }
+  return path.join(repoRoot, ".eliza", "gitpathology");
+}
+function ensureCacheDir(cacheDir) {
+  if (!existsSync(cacheDir))
+    mkdirSync(cacheDir, { recursive: true });
+}
+function createReportCache(cacheDir) {
+  ensureCacheDir(cacheDir);
+  const pathFor = (key) => path.join(cacheDir, `${key}.json`);
+  return {
+    dir: cacheDir,
+    read(key) {
+      const file = pathFor(key);
+      if (!existsSync(file))
+        return null;
+      try {
+        const raw = readFileSync(file, "utf8");
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    },
+    write(report) {
+      const file = pathFor(report.cacheKey);
+      const tmp = path.join(cacheDir, `.${report.cacheKey}.${process.pid}.${Date.now()}.tmp`);
+      writeFileSync(tmp, JSON.stringify(report, null, 2), "utf8");
+      renameSync(tmp, file);
+    },
+    list() {
+      if (!existsSync(cacheDir))
+        return [];
+      const files = readdirSync(cacheDir).filter((f) => f.endsWith(".json"));
+      const out = [];
+      for (const file of files) {
+        try {
+          const full = path.join(cacheDir, file);
+          const stat = statSync(full);
+          const raw = readFileSync(full, "utf8");
+          const report = JSON.parse(raw);
+          out.push({
+            cacheKey: report.cacheKey,
+            surface: report.surface,
+            generatedAt: report.generatedAt,
+            headSha: report.headSha,
+            commitCount: report.commitCount,
+            sizeBytes: stat.size
+          });
+        } catch {}
+      }
+      return out.sort((a, b) => b.generatedAt.localeCompare(a.generatedAt));
+    },
+    isFreshFor(key, currentHeadSha) {
+      const cached = this.read(key);
+      return cached?.headSha === currentHeadSha;
+    }
+  };
+}
+
+// src/pipeline/classify.ts
+var PREFIX_MAP = {
+  feat: "feature",
+  feature: "feature",
+  fix: "fix",
+  bug: "fix",
+  hotfix: "fix",
+  refactor: "refactor",
+  perf: "refactor",
+  revert: "revert",
+  chore: "chore",
+  docs: "chore",
+  doc: "chore",
+  style: "chore",
+  test: "chore",
+  ci: "chore",
+  build: "chore"
+};
+var CONVENTIONAL_RE = /^([a-z]+)(?:\(([^)]+)\))?!?:\s*(.+)$/i;
+var WIP_RE = /^(?:wip|fixup!|squash!|amend!)\b/i;
+var REVERT_SUBJECT_RE = /^Revert\b/;
+var MERGE_SUBJECT_RE = /^Merge\b/;
+function classifyOne(commit) {
+  const subject = commit.subject.trim();
+  const riskFlags = [];
+  let type = "other";
+  let scope;
+  if (commit.parents.length > 1) {
+    type = "merge";
+  } else if (MERGE_SUBJECT_RE.test(subject)) {
+    type = "merge";
+  } else if (REVERT_SUBJECT_RE.test(subject)) {
+    type = "revert";
+    riskFlags.push("revert-subject");
+  } else if (WIP_RE.test(subject)) {
+    type = "wip";
+    riskFlags.push("wip-message");
+  } else {
+    const match = subject.match(CONVENTIONAL_RE);
+    if (match) {
+      const prefix = (match[1] ?? "").toLowerCase();
+      const mapped = PREFIX_MAP[prefix];
+      if (mapped) {
+        type = mapped;
+        scope = match[2];
+      }
+    }
+  }
+  const churn = commit.files.reduce((acc, f) => acc + f.added + f.deleted, 0);
+  if (churn >= 500)
+    riskFlags.push("large-churn");
+  if (commit.files.length >= 20)
+    riskFlags.push("wide-blast");
+  if (subject.length < 12 && type === "other")
+    riskFlags.push("terse-message");
+  if (subject.includes("!:"))
+    riskFlags.push("breaking");
+  return {
+    ...commit,
+    type,
+    scope,
+    riskFlags,
+    classifiedBy: "rule"
+  };
+}
+function classify(commits) {
+  return commits.map(classifyOne);
+}
+
+// src/pipeline/inflect.ts
+var PEAK_WINDOW = 2;
+var PEAK_MIN_SCORE = 0.05;
+var PEAK_LIMIT = 5;
+var DRIFT_WINDOW = 5;
+var DRIFT_DROP = 0.25;
+var DRIFT_LIMIT = 5;
+function toInflection(point, reason) {
+  return {
+    sha: point.sha,
+    date: point.date,
+    author: point.author,
+    score: point.score,
+    delta: point.delta,
+    reasonShort: reason
+  };
+}
+function reasonForPeak(point) {
+  const parts = [];
+  if (point.type === "feature")
+    parts.push("feature landed");
+  else if (point.type === "refactor")
+    parts.push("clean refactor");
+  else if (point.type === "fix")
+    parts.push("targeted fix");
+  else
+    parts.push(`${point.type} commit`);
+  if (point.riskFlags.includes("large-churn") === false && point.churn < 200) {
+    parts.push("low churn");
+  }
+  if (point.delta > 0.4)
+    parts.push("strong delta");
+  return parts.join(", ") || "local maximum";
+}
+function reasonForDrift(point, avgAfter) {
+  const drop = (point.score - avgAfter).toFixed(2);
+  const flags = point.riskFlags.length > 0 ? ` flags=${point.riskFlags.join("|")}` : "";
+  return `score drops ${drop} over next ${DRIFT_WINDOW} commits${flags}`;
+}
+function avg(points, from, count) {
+  let sum = 0;
+  let taken = 0;
+  for (let i = from;i < points.length && taken < count; i++) {
+    const p = points[i];
+    if (!p)
+      continue;
+    sum += p.score;
+    taken += 1;
+  }
+  return taken === 0 ? 0 : sum / taken;
+}
+function findInflections(points) {
+  const peaks = [];
+  const drifts = [];
+  for (let i = 0;i < points.length; i++) {
+    const point = points[i];
+    if (!point)
+      continue;
+    if (point.score < PEAK_MIN_SCORE)
+      continue;
+    const window = points.slice(Math.max(0, i - PEAK_WINDOW), i + PEAK_WINDOW + 1);
+    const isMaxInWindow = window.every((p) => p.score <= point.score);
+    const hasStrictlyLessNeighbour = window.some((p) => p.score < point.score);
+    if (!isMaxInWindow || !hasStrictlyLessNeighbour)
+      continue;
+    const tiedEarlier = peaks.some((existing) => {
+      const prevIdx = points.findIndex((p) => p.sha === existing.sha);
+      return prevIdx >= 0 && prevIdx >= i - PEAK_WINDOW && existing.score === point.score;
+    });
+    if (tiedEarlier)
+      continue;
+    peaks.push(toInflection(point, reasonForPeak(point)));
+  }
+  for (let i = 0;i < points.length; i++) {
+    const point = points[i];
+    if (!point)
+      continue;
+    if (i + DRIFT_WINDOW >= points.length)
+      break;
+    const after = avg(points, i + 1, DRIFT_WINDOW);
+    const drop = point.score - after;
+    if (drop >= DRIFT_DROP) {
+      drifts.push(toInflection(point, reasonForDrift(point, after)));
+    }
+  }
+  peaks.sort((a, b) => b.score - a.score);
+  drifts.sort((a, b) => b.score - b.delta - (a.score - a.delta));
+  return {
+    peaks: peaks.slice(0, PEAK_LIMIT),
+    drifts: drifts.slice(0, DRIFT_LIMIT)
+  };
+}
+
+// src/pipeline/narrate.ts
+import { logger, ModelType } from "@elizaos/core";
+
+// src/secret-scrubber.ts
+var SECRET_PATTERNS = [
+  { label: "ANTHROPIC", pattern: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g },
+  { label: "OPENAI", pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/g },
+  { label: "GITHUB", pattern: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g },
+  { label: "AWS", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
+  { label: "SLACK", pattern: /\bxox[bpoa]-[A-Za-z0-9-]{10,}\b/g },
+  { label: "BEARER", pattern: /\bBearer\s+[A-Za-z0-9._~+/=-]{20,}/g }
+];
+var SECRET_ENV_NAME = /\b([A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASS|API|AUTH|CREDENTIAL)[A-Z0-9_]*)\s*[:=]\s*['"]?([A-Za-z0-9_\-.+/=]{12,})['"]?/g;
+function scrubSecrets(input) {
+  if (!input)
+    return input;
+  let out = input;
+  for (const { label, pattern } of SECRET_PATTERNS) {
+    out = out.replace(pattern, `<REDACTED:${label}>`);
+  }
+  out = out.replace(SECRET_ENV_NAME, (_match, name) => `${name}=<REDACTED:ENV>`);
+  return out;
+}
+function scrubSecretsDeep(value) {
+  if (typeof value === "string")
+    return scrubSecrets(value);
+  if (Array.isArray(value))
+    return value.map(scrubSecretsDeep);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = scrubSecretsDeep(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/pipeline/scan.ts
+import { spawnSync } from "node:child_process";
+import path2 from "node:path";
+var RECORD_SEP = "\x1E";
+var UNIT_SEP = "\x1F";
+var LOG_FORMAT = `${[`${RECORD_SEP}COMMIT`, "%H", "%P", "%an", "%ae", "%aI", "%s"].join(UNIT_SEP)}${UNIT_SEP}%b`;
+function resolveSurfacePath(surface) {
+  if (path2.isAbsolute(surface.path)) {
+    return path2.relative(surface.repoRoot, surface.path) || ".";
+  }
+  return surface.path;
+}
+function runGit(repoRoot, args) {
+  const result = spawnSync("git", args, {
+    cwd: repoRoot,
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024
+  });
+  if (result.error || result.status !== 0) {
+    const detail = result.error?.message ?? result.stderr?.toString() ?? "";
+    throw new Error(`git ${args.join(" ")} failed: ${detail}`);
+  }
+  return result.stdout.toString();
+}
+function headSha(repoRoot) {
+  return runGit(repoRoot, ["rev-parse", "HEAD"]).trim();
+}
+function inferStatus(added, deleted) {
+  if (added > 0 && deleted === 0)
+    return "A";
+  if (added === 0 && deleted > 0)
+    return "D";
+  return "M";
+}
+function parseFileBlock(lines) {
+  const touches = [];
+  for (const line of lines) {
+    if (!line)
+      continue;
+    const parts = line.split("\t");
+    if (parts.length < 3)
+      continue;
+    const [addedRaw, deletedRaw, ...pathParts] = parts;
+    const addedStr = addedRaw ?? "0";
+    const deletedStr = deletedRaw ?? "0";
+    const added = addedStr === "-" ? 0 : Number.parseInt(addedStr, 10);
+    const deleted = deletedStr === "-" ? 0 : Number.parseInt(deletedStr, 10);
+    if (!Number.isFinite(added) || !Number.isFinite(deleted))
+      continue;
+    const filePath = pathParts.join("\t");
+    if (!filePath)
+      continue;
+    touches.push({ path: filePath, added, deleted, status: inferStatus(added, deleted) });
+  }
+  return touches;
+}
+function scan(surface, options) {
+  const surfacePath = resolveSurfacePath(surface);
+  const args = [
+    "log",
+    "--no-color",
+    `--since=${normalizeSince(options.since)}`,
+    `--pretty=format:${LOG_FORMAT}`,
+    "--numstat",
+    "--no-renames",
+    "--",
+    surfacePath
+  ];
+  const raw = runGit(surface.repoRoot, args);
+  if (!raw.trim())
+    return [];
+  const records = raw.split(RECORD_SEP).filter((r) => r.trim());
+  const commits = [];
+  for (const record of records) {
+    if (!record.startsWith("COMMIT"))
+      continue;
+    const rest = record.slice("COMMIT".length);
+    const fields = rest.split(UNIT_SEP);
+    if (fields.length < 8)
+      continue;
+    const [, sha, parentsStr, author, authorEmail, date, subject, bodyAndFiles] = fields;
+    if (!sha || !date)
+      continue;
+    const lines = (bodyAndFiles ?? "").split(`
+`);
+    const splitIdx = findFileBlockStart(lines);
+    const body = lines.slice(0, splitIdx).join(`
+`).trim();
+    const fileLines = lines.slice(splitIdx).filter((l) => l.length > 0);
+    const files = parseFileBlock(fileLines);
+    commits.push({
+      sha,
+      parents: parentsStr ? parentsStr.split(" ").filter(Boolean) : [],
+      author: author ?? "",
+      authorEmail: authorEmail ?? "",
+      date,
+      subject: subject ?? "",
+      body,
+      files,
+      diffSnippet: ""
+    });
+  }
+  return commits;
+}
+function findFileBlockStart(lines) {
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (!line)
+      continue;
+    const first = line.split("\t")[0] ?? "";
+    if (/^\d+$/.test(first) || first === "-")
+      return i;
+  }
+  return lines.length;
+}
+var RELATIVE_SINCE = /^(\d+)\s*(d|w|m|y)$/;
+function normalizeSince(since) {
+  const match = since.trim().match(RELATIVE_SINCE);
+  if (!match)
+    return since;
+  const n = match[1] ?? "0";
+  const unit = match[2] ?? "d";
+  const map = {
+    d: "days",
+    w: "weeks",
+    m: "months",
+    y: "years"
+  };
+  return `${n} ${map[unit] ?? "days"} ago`;
+}
+function fetchDiffSnippet(repoRoot, sha, surfacePath, maxBytes = 16 * 1024) {
+  const args = ["show", "--no-color", "-U2", "--format=", sha, "--", surfacePath];
+  const result = spawnSync("git", args, {
+    cwd: repoRoot,
+    encoding: "utf8",
+    maxBuffer: 8 * 1024 * 1024
+  });
+  if (result.status !== 0)
+    return "";
+  const out = result.stdout.toString();
+  return out.length > maxBytes ? `${out.slice(0, maxBytes)}
+... [truncated]` : out;
+}
+
+// src/pipeline/narrate.ts
+var LOG_PREFIX = "[GitPathology/narrate]";
+var VALID_CATEGORIES = new Set([
+  "rushed-fix",
+  "scope-creep",
+  "bad-merge",
+  "revert-cycle",
+  "churn-spiral",
+  "other"
+]);
+async function narrate(runtime, ctx) {
+  const rotCauses = [];
+  let llmCalls = 0;
+  const indexBySha = new Map(ctx.timeline.map((point, idx) => [point.sha, idx]));
+  const useModelFn = runtime?.useModel;
+  const budget = Math.max(0, Math.floor(ctx.budget));
+  for (const drift of ctx.drifts) {
+    const idx = indexBySha.get(drift.sha);
+    if (idx === undefined)
+      continue;
+    const point = ctx.timeline[idx];
+    if (!point)
+      continue;
+    const before = ctx.timeline.slice(Math.max(0, idx - 3), idx);
+    const after = ctx.timeline.slice(idx + 1, idx + 4);
+    const fallback = deterministicRotCause(point, before, after, drift);
+    if (typeof useModelFn === "function" && llmCalls < budget) {
+      const diff = scrubSecrets(fetchDiffSnippet(ctx.repoRoot, point.sha, ctx.surfacePath, 8 * 1024));
+      try {
+        const result = await callModel(useModelFn, buildPrompt(ctx.surfacePath, point, before, after, diff));
+        llmCalls += 1;
+        const parsed = parseRotCause(result);
+        if (parsed) {
+          rotCauses.push({
+            ...fallback,
+            category: parsed.category,
+            narrative: parsed.narrative
+          });
+          continue;
+        }
+        logger.warn(`${LOG_PREFIX} model returned unparseable rot cause for ${point.sha}`);
+      } catch (err) {
+        logger.warn(`${LOG_PREFIX} model call failed for ${point.sha}: ${err.message}`);
+      }
+    } else if (typeof useModelFn !== "function" && llmCalls === 0 && rotCauses.length === 0) {
+      logger.warn(`${LOG_PREFIX} runtime has no useModel; using deterministic rot-cause fallback`);
+    }
+    rotCauses.push(fallback);
+  }
+  return { rotCauses, llmCalls };
+}
+function deterministicRotCause(point, before, after, drift) {
+  const category = categorizeDeterministically(point, before, after);
+  const flags = point.riskFlags.length > 0 ? point.riskFlags.join(", ") : "no explicit flags";
+  const previousScore = before.at(-1)?.score;
+  const nextScore = after.at(-1)?.score;
+  const narrative = [
+    `${point.sha.slice(0, 7)} marks a ${Math.abs(drift.delta).toFixed(2)}-point quality drop on this surface, with ${point.churn} churn across ${point.files.length} file(s) and ${flags}.`,
+    `The surrounding window moves from ${typeof previousScore === "number" ? previousScore.toFixed(2) : "no prior score"} to ${point.score.toFixed(2)}${typeof nextScore === "number" ? ` and then ${nextScore.toFixed(2)}` : ""}, so this commit is a deterministic inflection even without LLM narration.`
+  ].join(" ");
+  return {
+    shaRange: rangeFor(point, after),
+    category,
+    evidence: evidenceShas(point, before, after),
+    narrative
+  };
+}
+function categorizeDeterministically(point, before, after) {
+  const subject = point.subject.toLowerCase();
+  const flags = new Set(point.riskFlags.map((flag) => flag.toLowerCase()));
+  if (point.type === "revert" || subject.includes("revert"))
+    return "revert-cycle";
+  if (point.type === "merge" || flags.has("merge"))
+    return "bad-merge";
+  if (flags.has("hotfix") || subject.includes("hotfix") || subject.includes("quick fix")) {
+    return "rushed-fix";
+  }
+  const neighboringChurn = [...before, ...after].reduce((sum, commit) => sum + commit.churn, 0);
+  if (point.churn > 500 || neighboringChurn > 1000)
+    return "churn-spiral";
+  if (point.files.length > 8 || flags.has("large-change"))
+    return "scope-creep";
+  return "other";
+}
+function rangeFor(point, after) {
+  const last = after.length > 0 ? after[after.length - 1] : null;
+  return [point.sha, last ? last.sha : point.sha];
+}
+function evidenceShas(point, before, after) {
+  return [...before.map((p) => p.sha), point.sha, ...after.map((p) => p.sha)];
+}
+function buildPrompt(surface, point, before, after, diff) {
+  const fmt = (p) => `  ${p.sha.slice(0, 7)} [${p.type}] (${p.churn} churn, score ${p.score.toFixed(2)}) ${scrubSecrets(p.subject)}`;
+  return [
+    "You are diagnosing the start of a code-quality decline in a git repository surface.",
+    "",
+    `Surface: ${surface}`,
+    `Drift commit: ${point.sha.slice(0, 7)} by ${point.author} on ${point.date.slice(0, 10)}`,
+    `  Subject: ${scrubSecrets(point.subject)}`,
+    `  Type: ${point.type}  Risk flags: ${point.riskFlags.join(", ") || "(none)"}  Churn: ${point.churn}  Files: ${point.files.length}`,
+    `  Score: ${point.score.toFixed(2)}  Delta: ${point.delta.toFixed(2)}`,
+    "",
+    "Commits immediately before (oldest first):",
+    before.length === 0 ? "  (none in window)" : before.map(fmt).join(`
+`),
+    "",
+    "Commits immediately after (oldest first):",
+    after.length === 0 ? "  (none in window)" : after.map(fmt).join(`
+`),
+    "",
+    "Diff snippet of the drift commit (secrets redacted):",
+    diff || "  (no diff available)",
+    "",
+    "Classify the most likely cause from this set:",
+    '  "rushed-fix", "scope-creep", "bad-merge", "revert-cycle", "churn-spiral", "other"',
+    "",
+    "Then write a 2-3 sentence narrative explaining WHY this commit looks like the start of decline. Reference specific evidence from the commits or diff above.",
+    "",
+    'Respond with exactly one JSON object: {"category": "<one of the above>", "narrative": "<2-3 sentences>"}'
+  ].join(`
+`);
+}
+async function callModel(useModelFn, prompt) {
+  const result = await useModelFn(ModelType.TEXT_SMALL, {
+    prompt,
+    temperature: 0.2,
+    stream: false
+  });
+  if (typeof result !== "string")
+    return "";
+  return result;
+}
+function parseRotCause(raw) {
+  if (!raw)
+    return null;
+  const jsonStart = raw.indexOf("{");
+  const jsonEnd = raw.lastIndexOf("}");
+  if (jsonStart < 0 || jsonEnd <= jsonStart)
+    return null;
+  const slice = raw.slice(jsonStart, jsonEnd + 1);
+  try {
+    const obj = JSON.parse(slice);
+    const category = typeof obj.category === "string" ? obj.category : "other";
+    const narrative = typeof obj.narrative === "string" ? obj.narrative.trim() : "";
+    if (!narrative)
+      return null;
+    const safeCategory = VALID_CATEGORIES.has(category) ? category : "other";
+    return { category: safeCategory, narrative };
+  } catch {
+    return null;
+  }
+}
+
+// src/pipeline/score.ts
+var ALPHA = 0.3;
+var REVERT_LOOKBACK = 7;
+var BASE = {
+  feature: 0.5,
+  refactor: 0.4,
+  fix: 0.2,
+  chore: 0.1,
+  merge: 0,
+  other: 0,
+  wip: -0.3,
+  revert: -0.5
+};
+var TEST_PATH_RE = /(?:^|\/)(__tests__|tests?)\/|\.(?:test|spec)\.[jt]sx?$/i;
+var REVERT_SHA_RE = /\b([0-9a-f]{7,40})\b/i;
+function churnPenalty(churn) {
+  if (churn <= 100)
+    return 0;
+  const value = Math.log10(churn / 100) * 0.4;
+  return Math.min(value, 1.2);
+}
+function filesPenalty(count) {
+  return Math.min(count * 0.05, 0.5);
+}
+function testBonus(commit) {
+  return commit.files.some((f) => TEST_PATH_RE.test(f.path)) ? 0.2 : 0;
+}
+function wipPenalty(commit) {
+  return commit.riskFlags.includes("wip-message") ? 0.3 : 0;
+}
+function findRevertTarget(commit, byShortSha) {
+  if (commit.type !== "revert")
+    return null;
+  const match = commit.body.match(REVERT_SHA_RE) ?? commit.subject.match(REVERT_SHA_RE);
+  if (!match)
+    return null;
+  const sha = (match[1] ?? "").toLowerCase();
+  const short2 = sha.slice(0, 7);
+  const idx = byShortSha.get(short2);
+  return typeof idx === "number" ? idx : null;
+}
+function score(commits) {
+  const points = [];
+  const byShortSha = new Map;
+  let running = 0;
+  for (let i = 0;i < commits.length; i++) {
+    const commit = commits[i];
+    if (!commit)
+      continue;
+    const churn = commit.files.reduce((acc, f) => acc + f.added + f.deleted, 0);
+    const base = BASE[commit.type];
+    const delta = base - churnPenalty(churn) - filesPenalty(commit.files.length) - wipPenalty(commit) + testBonus(commit);
+    running = ALPHA * delta + (1 - ALPHA) * running;
+    points.push({ ...commit, delta, score: running, churn });
+    byShortSha.set(commit.sha.slice(0, 7), i);
+  }
+  let needsRecompute = false;
+  for (let i = 0;i < points.length; i++) {
+    const point = points[i];
+    if (!point)
+      continue;
+    const targetIdx = findRevertTarget(point, byShortSha);
+    if (targetIdx === null)
+      continue;
+    const distance = i - targetIdx;
+    if (distance <= 0 || distance > REVERT_LOOKBACK)
+      continue;
+    const target = points[targetIdx];
+    if (!target)
+      continue;
+    target.delta -= 0.5;
+    target.riskFlags = [...target.riskFlags, "later-reverted"];
+    needsRecompute = true;
+  }
+  if (needsRecompute) {
+    running = 0;
+    for (const point of points) {
+      running = ALPHA * point.delta + (1 - ALPHA) * running;
+      point.score = running;
+    }
+  }
+  return points;
+}
+
+// src/services/git-pathology-service.ts
+var GIT_PATHOLOGY_SERVICE_NAME = "git_pathology";
+var LOG_PREFIX2 = "[GitPathologyService]";
+var DEFAULT_OPTIONS = {
+  since: "14d",
+  budget: 20,
+  cache: "auto"
+};
+function defaultBudget() {
+  const raw = process.env.GITPATHOLOGIST_BUDGET?.trim();
+  if (!raw)
+    return DEFAULT_OPTIONS.budget;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_OPTIONS.budget;
+}
+
+class GitPathologyService extends Service {
+  static serviceType = GIT_PATHOLOGY_SERVICE_NAME;
+  capabilityDescription = "Forensic git-history analysis: per-surface health timeline, drift inflection detection, rot post-mortem.";
+  static async start(runtime) {
+    logger2.info(`${LOG_PREFIX2} starting`);
+    return new GitPathologyService(runtime);
+  }
+  async stop() {}
+  async runReport(surface, overrides = {}) {
+    const options = { ...DEFAULT_OPTIONS, budget: defaultBudget(), ...overrides };
+    const cacheDir = defaultCacheDir(surface.repoRoot);
+    const cache = createReportCache(cacheDir);
+    const cacheKey = makeCacheKey({ surface: surface.path, since: options.since });
+    const currentHead = headSha(surface.repoRoot);
+    if (options.cache !== "force") {
+      const cached = cache.read(cacheKey);
+      if (cached && cached.headSha === currentHead) {
+        logger2.info(`${LOG_PREFIX2} cache hit ${cacheKey.slice(0, 12)} surface=${surface.path}`);
+        return scrubSecretsDeep(cached);
+      }
+      if (options.cache === "read-only") {
+        throw new Error(`gitpathology cache miss for ${surface.path} (HEAD changed or no prior report)`);
+      }
+    }
+    const raw = scan(surface, { since: options.since });
+    if (raw.length === 0) {
+      const empty = scrubSecretsDeep(emptyReport(surface, options, currentHead, cacheKey));
+      cache.write(empty);
+      return empty;
+    }
+    const chronological = [...raw].reverse();
+    const classified = classify(chronological);
+    const points = score(classified);
+    const { peaks, drifts } = findInflections(points);
+    const { rotCauses, llmCalls } = await narrate(this.runtime ?? null, {
+      surfacePath: resolveSurfacePath(surface),
+      repoRoot: surface.repoRoot,
+      timeline: points,
+      drifts,
+      budget: options.budget
+    });
+    const oldest = points[0]?.date ?? new Date().toISOString();
+    const newest = points[points.length - 1]?.date ?? new Date().toISOString();
+    const authors = Array.from(new Set(points.map((p) => p.author))).sort();
+    const report = {
+      surface: surface.path,
+      repoRoot: surface.repoRoot,
+      window: { since: oldest, until: newest },
+      commitCount: points.length,
+      authors,
+      timeline: points,
+      peaks,
+      drifts,
+      rotCauses,
+      llmCalls,
+      headSha: currentHead,
+      generatedAt: new Date().toISOString(),
+      cacheKey
+    };
+    const safeReport = scrubSecretsDeep(report);
+    cache.write(safeReport);
+    logger2.info(`${LOG_PREFIX2} report written ${cacheKey.slice(0, 12)} surface=${surface.path} commits=${points.length} llm=${llmCalls}`);
+    return safeReport;
+  }
+  listReports(repoRoot) {
+    return createReportCache(defaultCacheDir(repoRoot)).list();
+  }
+}
+function emptyReport(surface, options, headSha2, cacheKey) {
+  const now = new Date().toISOString();
+  return {
+    surface: surface.path,
+    repoRoot: surface.repoRoot,
+    window: { since: options.since, until: now },
+    commitCount: 0,
+    authors: [],
+    timeline: [],
+    peaks: [],
+    drifts: [],
+    rotCauses: [],
+    llmCalls: 0,
+    headSha: headSha2,
+    generatedAt: now,
+    cacheKey
+  };
+}
+
+// src/actions/git-pathology.ts
+var VALID_ACTIONS = new Set(["report", "list"]);
+var SURFACE_HINT_RE = /\b(pathology|git\s+history|code\s+health|drift|rot|inflection|when\s+did\s+(?:this\s+)?(?:code|file|module|package|plugin|service|component|path|repo|repository|branch|commit))\b/i;
+function getService(runtime) {
+  return runtime.getService(GIT_PATHOLOGY_SERVICE_NAME) ?? null;
+}
+function paramsRecord(options) {
+  if (!options || typeof options !== "object")
+    return {};
+  const parameters = options.parameters;
+  if (parameters && typeof parameters === "object") {
+    return parameters;
+  }
+  const params = options.params;
+  if (params && typeof params === "object")
+    return params;
+  return options;
+}
+function readAction(params) {
+  const rawValue = params.action;
+  const raw = typeof rawValue === "string" ? rawValue.toLowerCase() : "report";
+  return VALID_ACTIONS.has(raw) ? raw : "report";
+}
+function readString(params, key) {
+  const v = params[key];
+  return typeof v === "string" && v.trim() ? v.trim() : undefined;
+}
+function readNumber(params, key) {
+  const v = params[key];
+  if (typeof v === "number" && Number.isFinite(v))
+    return v;
+  if (typeof v === "string" && v.trim()) {
+    const parsed = Number.parseInt(v, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return;
+}
+function buildOptions(params) {
+  const out = {};
+  const since = readString(params, "since");
+  if (since)
+    out.since = since;
+  const budget = readNumber(params, "budget");
+  if (typeof budget === "number")
+    out.budget = budget;
+  const cache = readString(params, "cache");
+  if (cache === "auto" || cache === "force" || cache === "read-only")
+    out.cache = cache;
+  return out;
+}
+function resolveRepoRoot() {
+  const fromEnv = process.env.ELIZA_WORKSPACE_DIR;
+  const cwd = fromEnv?.trim() ? fromEnv.trim() : process.cwd();
+  return path3.resolve(cwd);
+}
+function listResult(service, repoRoot) {
+  const summaries = service.listReports(repoRoot);
+  if (summaries.length === 0) {
+    return {
+      success: true,
+      text: "No cached pathology reports for this repo yet.",
+      data: { reports: [] }
+    };
+  }
+  const lines = summaries.map((s) => `- ${s.surface} (${s.commitCount} commits) — HEAD ${s.headSha.slice(0, 7)}, generated ${s.generatedAt}`);
+  return {
+    success: true,
+    text: `Cached pathology reports:
+${lines.join(`
+`)}`,
+    data: { reports: summaries }
+  };
+}
+function reportResult(report) {
+  return {
+    success: true,
+    text: renderReport(report),
+    data: { report }
+  };
+}
+var gitPathologyAction = {
+  name: "GIT_PATHOLOGY",
+  similes: [
+    "ANALYZE_GIT_PATHOLOGY",
+    "GIT_HEALTH",
+    "GIT_FORENSICS",
+    "PATHOLOGY_REPORT",
+    "CODE_HISTORY_HEALTH",
+    "WHERE_DID_ROT_START"
+  ],
+  description: "Forensic git-history analysis for a path/glob surface. Returns peaks (peak quality moments), drift inflections (where rot started), and a post-mortem narrative. Use when the user asks 'when did this code get bad', 'where did rot start in X', or 'analyze git pathology for Y'. Actions: report (default), list (show cached reports).",
+  contexts: ["code", "git", "general"],
+  suppressPostActionContinuation: true,
+  parameters: [
+    {
+      name: "action",
+      description: "Which gitpathologist action: report or list. Default: report.",
+      required: false,
+      schema: { type: "string", enum: ["report", "list"] }
+    },
+    {
+      name: "surface",
+      description: "Path or glob to analyze (relative to repo root). Required for action=report.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "since",
+      description: "Lookback window. ISO date or relative (e.g. '14d', '4w'). Default '14d'.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "budget",
+      description: "Max LLM narration calls per analysis. Default 20.",
+      required: false,
+      schema: { type: "integer", minimum: 0 }
+    },
+    {
+      name: "cache",
+      description: "Cache policy: auto (default), force (recompute), read-only (fail on miss).",
+      required: false,
+      schema: { type: "string", enum: ["auto", "force", "read-only"] }
+    }
+  ],
+  validate: async (runtime, message) => {
+    if (!getService(runtime))
+      return false;
+    const content = message.content;
+    const params = content.params && typeof content.params === "object" ? content.params : null;
+    if (params && typeof params.action === "string") {
+      return true;
+    }
+    if (params && typeof params.surface === "string")
+      return true;
+    const text = typeof content.text === "string" ? content.text : "";
+    return SURFACE_HINT_RE.test(text);
+  },
+  handler: async (runtime, _message, _state, options, callback) => {
+    const service = getService(runtime);
+    if (!service) {
+      const text = "GitPathologyService not registered on runtime.";
+      return { success: false, text, error: "SERVICE_UNAVAILABLE" };
+    }
+    const params = paramsRecord(options);
+    const action = readAction(params);
+    const repoRoot = resolveRepoRoot();
+    if (action === "list") {
+      const result2 = listResult(service, repoRoot);
+      if (callback && typeof result2.text === "string") {
+        await callback({ text: result2.text });
+      }
+      return result2;
+    }
+    const surfacePath = readString(params, "surface");
+    if (!surfacePath) {
+      const text = "action=report requires a `surface` param (path or glob relative to repo root).";
+      if (callback)
+        await callback({ text });
+      return { success: false, text, error: "MISSING_SURFACE" };
+    }
+    const surface = { path: surfacePath, repoRoot };
+    const overrides = buildOptions(params);
+    let report;
+    try {
+      report = await service.runReport(surface, overrides);
+    } catch (err) {
+      const text = `Git pathology analysis failed: ${err.message}`;
+      if (callback)
+        await callback({ text });
+      return { success: false, text, error: "ANALYSIS_FAILED" };
+    }
+    const result = reportResult(report);
+    if (callback && typeof result.text === "string") {
+      await callback({ text: result.text });
+    }
+    return result;
+  }
+};
+
+// src/index.ts
+var gitpathologistPlugin = {
+  name: "@elizaos/plugin-gitpathologist",
+  description: "Forensic git-history analysis for elizaOS agents: per-surface health timeline, drift inflection detection, rot post-mortem.",
+  init: async (_config, _runtime) => {
+    logger3.info("[GitPathology] plugin initialized");
+  },
+  async dispose(runtime) {
+    const svc = runtime.getService(GIT_PATHOLOGY_SERVICE_NAME);
+    await svc?.stop();
+  },
+  services: [GitPathologyService],
+  actions: [gitPathologyAction],
+  providers: []
+};
+var src_default = gitpathologistPlugin;
+export {
+  gitPathologyAction,
+  src_default as default,
+  GitPathologyService,
+  GIT_PATHOLOGY_SERVICE_NAME
+};
+
+//# debugId=1234025F431646EF64756E2164756E21