vibe-code-explainer 0.2.1 → 0.3.1

package/dist/chunk-Y55I7ZS5.js

@@ -0,0 +1,604 @@
+#!/usr/bin/env node
+import {
+  __require
+} from "./chunk-7OCVIDC7.js";
+
+// src/session/tracker.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, appendFileSync as appendFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2, readdirSync, statSync } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join2 } from "path";
+
+// src/cache/explanation-cache.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync, appendFileSync, unlinkSync, mkdirSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+function getUserTmpDir() {
+  const dir = join(tmpdir(), `code-explainer-${process.getuid?.() ?? "user"}`);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  return dir;
+}
+function getCacheFilePath(sessionId) {
+  return join(getUserTmpDir(), `cache-${sessionId}.jsonl`);
+}
+function hashDiff(diff) {
+  return createHash("sha256").update(diff, "utf-8").digest("hex");
+}
+function getCached(sessionId, diff) {
+  const path = getCacheFilePath(sessionId);
+  if (!existsSync(path)) return void 0;
+  const hash = hashDiff(diff);
+  try {
+    const content = readFileSync(path, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const entry = JSON.parse(lines[i]);
+        if (entry.hash === hash) {
+          return entry.result;
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function setCached(sessionId, diff, result) {
+  const path = getCacheFilePath(sessionId);
+  const entry = { hash: hashDiff(diff), result };
+  try {
+    appendFileSync(path, JSON.stringify(entry) + "\n", { mode: 384 });
+  } catch {
+  }
+}
+function clearCache(sessionId) {
+  const path = getCacheFilePath(sessionId);
+  if (existsSync(path)) {
+    try {
+      unlinkSync(path);
+    } catch {
+    }
+  }
+}
+
+// src/format/box.ts
+import pc from "picocolors";
+var LABELS = {
+  en: {
+    impact: "Impact",
+    howItWorks: "How it works",
+    why: "Why",
+    deepDive: "Deeper dive",
+    risk: "Risk",
+    riskNone: "None",
+    riskLow: "Low",
+    riskMedium: "Medium",
+    riskHigh: "High",
+    samePatternFallback: "Same pattern as before applied to this file."
+  },
+  pt: {
+    impact: "Impacto",
+    howItWorks: "Como funciona",
+    why: "Por que",
+    deepDive: "Pra aprofundar",
+    risk: "Risco",
+    riskNone: "Nenhum",
+    riskLow: "Baixo",
+    riskMedium: "M\xE9dio",
+    riskHigh: "Alto",
+    samePatternFallback: "Mesmo padr\xE3o anterior aplicado a este arquivo."
+  },
+  es: {
+    impact: "Impacto",
+    howItWorks: "C\xF3mo funciona",
+    why: "Por qu\xE9",
+    deepDive: "Para profundizar",
+    risk: "Riesgo",
+    riskNone: "Ninguno",
+    riskLow: "Bajo",
+    riskMedium: "Medio",
+    riskHigh: "Alto",
+    samePatternFallback: "Mismo patr\xF3n anterior aplicado a este archivo."
+  },
+  fr: {
+    impact: "Impact",
+    howItWorks: "Comment \xE7a marche",
+    why: "Pourquoi",
+    deepDive: "Pour approfondir",
+    risk: "Risque",
+    riskNone: "Aucun",
+    riskLow: "Faible",
+    riskMedium: "Moyen",
+    riskHigh: "\xC9lev\xE9",
+    samePatternFallback: "M\xEAme motif que pr\xE9c\xE9demment, appliqu\xE9 \xE0 ce fichier."
+  },
+  de: {
+    impact: "Auswirkung",
+    howItWorks: "Wie es funktioniert",
+    why: "Warum",
+    deepDive: "Mehr lernen",
+    risk: "Risiko",
+    riskNone: "Keines",
+    riskLow: "Gering",
+    riskMedium: "Mittel",
+    riskHigh: "Hoch",
+    samePatternFallback: "Gleiches Muster wie zuvor auf diese Datei angewendet."
+  },
+  it: {
+    impact: "Impatto",
+    howItWorks: "Come funziona",
+    why: "Perch\xE9",
+    deepDive: "Per approfondire",
+    risk: "Rischio",
+    riskNone: "Nessuno",
+    riskLow: "Basso",
+    riskMedium: "Medio",
+    riskHigh: "Alto",
+    samePatternFallback: "Stesso schema applicato a questo file."
+  },
+  zh: {
+    impact: "\u5F71\u54CD",
+    howItWorks: "\u5982\u4F55\u5DE5\u4F5C",
+    why: "\u4E3A\u4EC0\u4E48",
+    deepDive: "\u6DF1\u5165\u5B66\u4E60",
+    risk: "\u98CE\u9669",
+    riskNone: "\u65E0",
+    riskLow: "\u4F4E",
+    riskMedium: "\u4E2D",
+    riskHigh: "\u9AD8",
+    samePatternFallback: "\u540C\u6837\u7684\u6A21\u5F0F\u5E94\u7528\u5230\u6B64\u6587\u4EF6\u3002"
+  },
+  ja: {
+    impact: "\u5F71\u97FF",
+    howItWorks: "\u4ED5\u7D44\u307F",
+    why: "\u306A\u305C",
+    deepDive: "\u3055\u3089\u306B\u5B66\u3076",
+    risk: "\u30EA\u30B9\u30AF",
+    riskNone: "\u306A\u3057",
+    riskLow: "\u4F4E",
+    riskMedium: "\u4E2D",
+    riskHigh: "\u9AD8",
+    samePatternFallback: "\u4EE5\u524D\u3068\u540C\u3058\u30D1\u30BF\u30FC\u30F3\u3092\u3053\u306E\u30D5\u30A1\u30A4\u30EB\u306B\u9069\u7528\u3002"
+  },
+  ko: {
+    impact: "\uC601\uD5A5",
+    howItWorks: "\uC791\uB3D9 \uBC29\uC2DD",
+    why: "\uC774\uC720",
+    deepDive: "\uB354 \uC54C\uC544\uBCF4\uAE30",
+    risk: "\uC704\uD5D8",
+    riskNone: "\uC5C6\uC74C",
+    riskLow: "\uB0AE\uC74C",
+    riskMedium: "\uBCF4\uD1B5",
+    riskHigh: "\uB192\uC74C",
+    samePatternFallback: "\uC774\uC804\uACFC \uB3D9\uC77C\uD55C \uD328\uD134\uC774 \uC774 \uD30C\uC77C\uC5D0 \uC801\uC6A9\uB418\uC5C8\uC2B5\uB2C8\uB2E4."
+  }
+};
+function getLabels(language) {
+  return LABELS[language] ?? LABELS.en;
+}
+function isNoColor() {
+  return "NO_COLOR" in process.env || process.env.TERM === "dumb";
+}
+function color(fn, text) {
+  return isNoColor() ? text : fn(text);
+}
+function getTerminalWidth() {
+  return process.stderr.columns || 80;
+}
+function riskBorderColor(risk) {
+  switch (risk) {
+    case "none":
+      return pc.green;
+    case "low":
+      return pc.yellow;
+    case "medium":
+      return pc.yellow;
+    case "high":
+      return pc.red;
+  }
+}
+function riskIcon(risk) {
+  if (isNoColor()) {
+    switch (risk) {
+      case "none":
+        return "[OK]";
+      case "low":
+        return "[!]";
+      case "medium":
+        return "[!!]";
+      case "high":
+        return "[!!!]";
+    }
+  }
+  switch (risk) {
+    case "none":
+      return color(pc.green, "\u2713");
+    case "low":
+      return color(pc.yellow, "\u26A0");
+    case "medium":
+      return color(pc.yellow, "\u26A0");
+    case "high":
+      return color(pc.red, "\u{1F6A8}");
+  }
+}
+function riskLabelText(risk, labels) {
+  switch (risk) {
+    case "none":
+      return labels.riskNone;
+    case "low":
+      return labels.riskLow;
+    case "medium":
+      return labels.riskMedium;
+    case "high":
+      return labels.riskHigh;
+  }
+}
+function riskLabelColor(risk) {
+  switch (risk) {
+    case "none":
+      return pc.green;
+    case "low":
+      return pc.yellow;
+    case "medium":
+      return pc.yellow;
+    case "high":
+      return pc.red;
+  }
+}
+function highlightInlineCode(text) {
+  if (isNoColor()) return text;
+  return text.replace(/`([^`]+)`/g, (_, code) => color(pc.cyan, code));
+}
+function wrapText(text, maxWidth) {
+  const out = [];
+  for (const raw of text.split("\n")) {
+    if (raw.length <= maxWidth) {
+      out.push(raw);
+      continue;
+    }
+    let remaining = raw;
+    while (remaining.length > maxWidth) {
+      let breakAt = remaining.lastIndexOf(" ", maxWidth);
+      if (breakAt <= 0) breakAt = maxWidth;
+      out.push(remaining.slice(0, breakAt));
+      remaining = remaining.slice(breakAt).trimStart();
+    }
+    if (remaining) out.push(remaining);
+  }
+  return out;
+}
+var BOX_TITLE = "vibe-code-explainer";
+var PAD_LEFT = 2;
+var PAD_RIGHT = 2;
+function line(raw, styled) {
+  return { text: styled ?? raw, raw };
+}
+function blankLine() {
+  return line("");
+}
+function buildBoxOutput(contentLines, borderColor) {
+  const width = Math.min(getTerminalWidth() - 2, 70);
+  const innerWidth = width - 2;
+  const top = `\u256D\u2500 ${color(pc.dim, BOX_TITLE)} ${"\u2500".repeat(Math.max(0, innerWidth - BOX_TITLE.length - 4))}\u2500\u256E`;
+  const bottom = `\u2570${"\u2500".repeat(innerWidth)}\u256F`;
+  const sideChar = color(borderColor, "\u2502");
+  const middle = contentLines.map((bl) => {
+    const padding = " ".repeat(Math.max(0, innerWidth - bl.raw.length - PAD_LEFT - PAD_RIGHT));
+    return `${sideChar}${" ".repeat(PAD_LEFT)}${bl.text}${padding}${" ".repeat(PAD_RIGHT)}${sideChar}`;
+  });
+  return [color(borderColor, top), ...middle, color(borderColor, bottom)].join("\n");
+}
+function renderSection(def) {
+  const out = [];
+  const headerRaw = `\u25B8 ${def.header}`;
+  const headerStyled = color(pc.bold, color(def.headerColor, headerRaw));
+  out.push(line(headerRaw, headerStyled));
+  const bodyMax = def.innerWidth - PAD_LEFT - PAD_RIGHT - 2;
+  const wrapped = wrapText(def.body, bodyMax);
+  for (const w of wrapped) {
+    const indented = `  ${w}`;
+    const styled = `  ${highlightInlineCode(w)}`;
+    out.push(line(indented, styled));
+  }
+  return out;
+}
+function formatExplanationBox(inputs) {
+  const labels = getLabels(inputs.language);
+  const result = inputs.result;
+  const borderFn = riskBorderColor(result.risk);
+  const lines = [];
+  const innerWidth = Math.min(getTerminalWidth() - 2, 70) - 2;
+  lines.push(blankLine());
+  const filePathRaw = `\u{1F4C4}  ${inputs.filePath}`;
+  const filePathStyled = color(pc.bold, color(pc.cyan, filePathRaw));
+  lines.push(line(filePathRaw, filePathStyled));
+  if (result.isSamePattern) {
+    lines.push(blankLine());
+    const noteRaw = result.samePatternNote || labels.samePatternFallback;
+    const noteWrapped = wrapText(noteRaw, innerWidth - PAD_LEFT - PAD_RIGHT);
+    for (const w of noteWrapped) {
+      lines.push(line(w, color(pc.dim, w)));
+    }
+  } else {
+    if (result.impact) {
+      lines.push(blankLine());
+      if (inputs.detailLevel === "minimal") {
+        const wrapped = wrapText(result.impact, innerWidth - PAD_LEFT - PAD_RIGHT);
+        for (const w of wrapped) {
+          lines.push(line(w, highlightInlineCode(w)));
+        }
+      } else {
+        const sec = renderSection({
+          header: labels.impact,
+          headerColor: pc.cyan,
+          body: result.impact,
+          innerWidth
+        });
+        lines.push(...sec);
+      }
+    }
+    if (inputs.detailLevel !== "minimal" && result.howItWorks) {
+      lines.push(blankLine());
+      const sec = renderSection({
+        header: labels.howItWorks,
+        headerColor: pc.green,
+        body: result.howItWorks,
+        innerWidth
+      });
+      lines.push(...sec);
+    }
+    if (inputs.detailLevel !== "minimal" && result.why) {
+      lines.push(blankLine());
+      const sec = renderSection({
+        header: labels.why,
+        headerColor: pc.magenta,
+        body: result.why,
+        innerWidth
+      });
+      lines.push(...sec);
+    }
+    if (inputs.detailLevel === "verbose" && result.deepDive && result.deepDive.length > 0) {
+      lines.push(blankLine());
+      const headerRaw = `\u25B8 ${labels.deepDive}`;
+      const headerStyled = color(pc.bold, color(pc.dim, headerRaw));
+      lines.push(line(headerRaw, headerStyled));
+      const itemMax = innerWidth - PAD_LEFT - PAD_RIGHT - 4;
+      for (const item of result.deepDive) {
+        const text = `${item.term}: ${item.explanation}`;
+        const wrapped = wrapText(text, itemMax);
+        for (let i = 0; i < wrapped.length; i++) {
+          const prefix = i === 0 ? "  \u2014 " : "    ";
+          const raw = `${prefix}${wrapped[i]}`;
+          const styled = `${prefix}${highlightInlineCode(wrapped[i])}`;
+          lines.push(line(raw, styled));
+        }
+      }
+    }
+  }
+  lines.push(blankLine());
+  const dividerWidth = innerWidth - PAD_LEFT - PAD_RIGHT;
+  const dividerRaw = "\u2504".repeat(dividerWidth);
+  lines.push(line(dividerRaw, color(pc.dim, dividerRaw)));
+  lines.push(blankLine());
+  const riskHeaderRaw = `${stripAnsi(riskIcon(result.risk))}  ${labels.risk}: ${riskLabelText(result.risk, labels)}`;
+  const riskHeaderStyled = `${riskIcon(result.risk)}  ${color(pc.bold, color(riskLabelColor(result.risk), `${labels.risk}: ${riskLabelText(result.risk, labels)}`))}`;
+  lines.push(line(riskHeaderRaw, riskHeaderStyled));
+  if (result.risk !== "none" && result.riskReason) {
+    const reasonMax = innerWidth - PAD_LEFT - PAD_RIGHT - 3;
+    const wrapped = wrapText(result.riskReason, reasonMax);
+    for (const w of wrapped) {
+      const raw = `   ${w}`;
+      const styled = `   ${color(pc.dim, color(riskLabelColor(result.risk), w))}`;
+      lines.push(line(raw, styled));
+    }
+  }
+  lines.push(blankLine());
+  return buildBoxOutput(lines, borderFn);
+}
+function formatSkipNotice(reason) {
+  return color(pc.dim, `[code-explainer] skipped: ${reason}`);
+}
+function formatErrorNotice(problem, cause, fix) {
+  return color(pc.yellow, `[code-explainer] ${problem}. ${cause}. Fix: ${fix}.`);
+}
+function formatDriftAlert(totalFiles, unrelatedFiles, userRequest, language = "en") {
+  const labels = getLabels(language);
+  const lines = [];
+  const innerWidth = Math.min(getTerminalWidth() - 2, 70) - 2;
+  lines.push(blankLine());
+  const headerRaw = `\u26A1 SESSION DRIFT`;
+  const headerStyled = color(pc.bold, color(pc.yellow, headerRaw));
+  lines.push(line(headerRaw, headerStyled));
+  lines.push(blankLine());
+  const summaryRaw = `Claude has modified ${totalFiles} files this session.`;
+  lines.push(line(summaryRaw));
+  const unrelatedRaw = `${unrelatedFiles.length} may be unrelated:`;
+  lines.push(line(unrelatedRaw));
+  for (const file of unrelatedFiles) {
+    const truncated = file.length > innerWidth - 8 ? file.slice(0, innerWidth - 11) + "..." : file;
+    const raw = `  \u2022 ${truncated}`;
+    const styled = `  ${color(pc.yellow, "\u2022")} ${truncated}`;
+    lines.push(line(raw, styled));
+  }
+  if (userRequest) {
+    lines.push(blankLine());
+    const requestLines = wrapText(`Your request: "${userRequest}"`, innerWidth - PAD_LEFT - PAD_RIGHT);
+    for (const w of requestLines) {
+      lines.push(line(w, color(pc.dim, w)));
+    }
+  }
+  lines.push(blankLine());
+  const noticeRaw = `\u26A0  Consider reviewing these changes.`;
+  lines.push(line(noticeRaw, color(pc.bold, color(pc.yellow, noticeRaw))));
+  lines.push(blankLine());
+  return buildBoxOutput(lines, pc.yellow);
+}
+function printToStderr(text) {
+  try {
+    const fs = __require("fs");
+    const ttyPath = process.platform === "win32" ? "\\\\.\\CONOUT$" : "/dev/tty";
+    const fd = fs.openSync(ttyPath, "w");
+    fs.writeSync(fd, text + "\n");
+    fs.closeSync(fd);
+  } catch {
+    process.stderr.write(text + "\n");
+  }
+}
+function stripAnsi(s) {
+  return s.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
+// src/session/tracker.ts
+var TWO_HOURS_MS = 2 * 60 * 60 * 1e3;
+function getUserTmpDir2() {
+  const dir = join2(tmpdir2(), `code-explainer-${process.getuid?.() ?? "user"}`);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true, mode: 448 });
+  }
+  return dir;
+}
+function getSessionFilePath(sessionId) {
+  return join2(getUserTmpDir2(), `session-${sessionId}.jsonl`);
+}
+function recordEntry(sessionId, entry) {
+  const path = getSessionFilePath(sessionId);
+  try {
+    appendFileSync2(path, JSON.stringify(entry) + "\n", { mode: 384 });
+  } catch {
+  }
+}
+function readSession(sessionId) {
+  const path = getSessionFilePath(sessionId);
+  if (!existsSync2(path)) return [];
+  try {
+    const content = readFileSync2(path, "utf-8");
+    return content.split("\n").filter((l) => l.trim()).map((line2) => {
+      try {
+        return JSON.parse(line2);
+      } catch {
+        return null;
+      }
+    }).filter((e) => e !== null);
+  } catch {
+    return [];
+  }
+}
+function getRecentSummaries(sessionId, n) {
+  const entries = readSession(sessionId);
+  if (entries.length === 0) return [];
+  return entries.slice(-n).map((e) => `${e.file}: ${e.summary}`);
+}
+function cleanStaleSessionFiles() {
+  try {
+    const dir = getUserTmpDir2();
+    const now = Date.now();
+    const entries = readdirSync(dir);
+    for (const name of entries) {
+      if (!name.startsWith("session-") && !name.startsWith("cache-")) continue;
+      const filePath = join2(dir, name);
+      try {
+        const stat = statSync(filePath);
+        if (now - stat.mtimeMs > TWO_HOURS_MS) {
+          unlinkSync2(filePath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function getSessionIdFromEnv() {
+  return process.env.CODE_EXPLAINER_SESSION_ID;
+}
+function findLatestSession() {
+  try {
+    const dir = getUserTmpDir2();
+    const entries = readdirSync(dir).filter((n) => n.startsWith("session-") && n.endsWith(".jsonl")).map((n) => ({
+      name: n,
+      id: n.slice("session-".length, -".jsonl".length),
+      mtime: statSync(join2(dir, n)).mtimeMs
+    })).sort((a, b) => b.mtime - a.mtime);
+    return entries[0]?.id;
+  } catch {
+    return void 0;
+  }
+}
+async function printSummary() {
+  const sessionId = getSessionIdFromEnv() ?? findLatestSession();
+  if (!sessionId) {
+    process.stderr.write("[code-explainer] No active session found. Session data is created when Claude Code makes changes.\n");
+    return;
+  }
+  const entries = readSession(sessionId);
+  if (entries.length === 0) {
+    process.stderr.write(`[code-explainer] Session '${sessionId}' has no recorded changes yet.
+`);
+    return;
+  }
+  const related = entries.filter((e) => !e.unrelated);
+  const unrelated = entries.filter((e) => e.unrelated);
+  const uniqueFiles = Array.from(new Set(entries.map((e) => e.file)));
+  const unrelatedFiles = Array.from(new Set(unrelated.map((e) => e.file)));
+  const alert = formatDriftAlert(uniqueFiles.length, unrelatedFiles);
+  printToStderr(alert);
+  process.stderr.write(`
+Total changes: ${entries.length}
+`);
+  process.stderr.write(`Files touched: ${uniqueFiles.length}
+`);
+  process.stderr.write(`Related changes: ${related.length}
+`);
+  process.stderr.write(`Unrelated/risky: ${unrelated.length}
+`);
+  const risks = { none: 0, low: 0, medium: 0, high: 0 };
+  for (const e of entries) risks[e.risk]++;
+  process.stderr.write(`
+Risk breakdown:
+`);
+  process.stderr.write(`  None:   ${risks.none}
+`);
+  process.stderr.write(`  Low:    ${risks.low}
+`);
+  process.stderr.write(`  Medium: ${risks.medium}
+`);
+  process.stderr.write(`  High:   ${risks.high}
+`);
+}
+async function endSession() {
+  const sessionId = getSessionIdFromEnv() ?? findLatestSession();
+  if (!sessionId) {
+    process.stderr.write("[code-explainer] No active session to end.\n");
+    return;
+  }
+  const sessionPath = getSessionFilePath(sessionId);
+  if (existsSync2(sessionPath)) {
+    try {
+      unlinkSync2(sessionPath);
+    } catch {
+    }
+  }
+  clearCache(sessionId);
+  process.stderr.write(`[code-explainer] Session '${sessionId}' ended. State cleared.
+`);
+}
+
+export {
+  getCached,
+  setCached,
+  formatExplanationBox,
+  formatSkipNotice,
+  formatErrorNotice,
+  formatDriftAlert,
+  getSessionFilePath,
+  recordEntry,
+  readSession,
+  getRecentSummaries,
+  cleanStaleSessionFiles,
+  printSummary,
+  endSession
+};
+//# sourceMappingURL=chunk-Y55I7ZS5.js.map