@wasabeef/agentnote 0.1.0

package/dist/cli.js

@@ -0,0 +1,1138 @@
+#!/usr/bin/env node
+
+// src/commands/init.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// src/paths.ts
+import { join } from "node:path";
+
+// src/git.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function git(args2, options) {
+  const { stdout } = await execFileAsync("git", args2, {
+    cwd: options?.cwd,
+    encoding: "utf-8"
+  });
+  return stdout.trim();
+}
+async function gitSafe(args2, options) {
+  try {
+    const stdout = await git(args2, options);
+    return { stdout, exitCode: 0 };
+  } catch (err) {
+    return { stdout: err.stdout?.trim() ?? "", exitCode: err.code ?? 1 };
+  }
+}
+async function repoRoot() {
+  return git(["rev-parse", "--show-toplevel"]);
+}
+
+// src/paths.ts
+var _root = null;
+async function root() {
+  if (!_root) {
+    try {
+      _root = await repoRoot();
+    } catch {
+      console.error("error: git repository not found");
+      process.exit(1);
+    }
+  }
+  return _root;
+}
+async function agentnoteDir() {
+  return join(await root(), ".git", "agentnote");
+}
+async function sessionFile() {
+  return join(await agentnoteDir(), "session");
+}
+
+// src/agents/claude-code.ts
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync, globSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir } from "node:os";
+var HOOK_COMMAND = "$(npm bin 2>/dev/null)/agentnote hook 2>/dev/null || agentnote hook 2>/dev/null || npx --yes @wasabeef/agentnote hook";
+var HOOKS_CONFIG = {
+  SessionStart: [
+    { hooks: [{ type: "command", command: HOOK_COMMAND, async: true }] }
+  ],
+  Stop: [
+    { hooks: [{ type: "command", command: HOOK_COMMAND, async: true }] }
+  ],
+  UserPromptSubmit: [
+    { hooks: [{ type: "command", command: HOOK_COMMAND, async: true }] }
+  ],
+  PreToolUse: [
+    {
+      matcher: "Bash",
+      hooks: [{ type: "command", if: "Bash(git commit *)", command: HOOK_COMMAND }]
+    }
+  ],
+  PostToolUse: [
+    {
+      matcher: "Edit|Write|NotebookEdit|Bash",
+      hooks: [{ type: "command", command: HOOK_COMMAND, async: true }]
+    }
+  ]
+};
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isValidSessionId(id) {
+  return UUID_PATTERN.test(id);
+}
+function isValidTranscriptPath(p) {
+  const claudeBase = join2(homedir(), ".claude");
+  return p.startsWith(claudeBase);
+}
+function isGitCommit(cmd) {
+  const trimmed = cmd.trim();
+  return (trimmed.startsWith("git commit") || trimmed.startsWith("git -c ")) && trimmed.includes("commit") && !trimmed.includes("--amend");
+}
+var claudeCode = {
+  name: "claude-code",
+  settingsRelPath: ".claude/settings.json",
+  async installHooks(repoRoot2) {
+    const settingsPath = join2(repoRoot2, this.settingsRelPath);
+    const { dirname } = await import("node:path");
+    await mkdir(dirname(settingsPath), { recursive: true });
+    let settings = {};
+    if (existsSync(settingsPath)) {
+      try {
+        settings = JSON.parse(await readFile(settingsPath, "utf-8"));
+      } catch {
+        settings = {};
+      }
+    }
+    const hooks = settings.hooks ?? {};
+    const raw = JSON.stringify(hooks);
+    if (raw.includes("@wasabeef/agentnote")) return;
+    for (const [event, entries] of Object.entries(HOOKS_CONFIG)) {
+      hooks[event] = [...hooks[event] ?? [], ...entries];
+    }
+    settings.hooks = hooks;
+    await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  },
+  async removeHooks(repoRoot2) {
+    const settingsPath = join2(repoRoot2, this.settingsRelPath);
+    if (!existsSync(settingsPath)) return;
+    try {
+      const settings = JSON.parse(await readFile(settingsPath, "utf-8"));
+      if (!settings.hooks) return;
+      for (const [event, entries] of Object.entries(settings.hooks)) {
+        settings.hooks[event] = entries.filter((e) => {
+          const text = JSON.stringify(e);
+          return !text.includes("@wasabeef/agentnote");
+        });
+        if (settings.hooks[event].length === 0) delete settings.hooks[event];
+      }
+      if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+      await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    } catch {
+    }
+  },
+  async isEnabled(repoRoot2) {
+    const settingsPath = join2(repoRoot2, this.settingsRelPath);
+    if (!existsSync(settingsPath)) return false;
+    try {
+      const content = await readFile(settingsPath, "utf-8");
+      return content.includes("@wasabeef/agentnote");
+    } catch {
+      return false;
+    }
+  },
+  parseEvent(input) {
+    let e;
+    try {
+      e = JSON.parse(input.raw);
+    } catch {
+      return null;
+    }
+    const sid = e.session_id;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    if (!sid || !isValidSessionId(sid)) return null;
+    const tp = e.transcript_path && isValidTranscriptPath(e.transcript_path) ? e.transcript_path : void 0;
+    switch (e.hook_event_name) {
+      case "SessionStart":
+        return { kind: "session_start", sessionId: sid, timestamp: ts, model: e.model, transcriptPath: tp };
+      case "Stop":
+        return { kind: "stop", sessionId: sid, timestamp: ts, transcriptPath: tp };
+      case "UserPromptSubmit":
+        return e.prompt ? { kind: "prompt", sessionId: sid, timestamp: ts, prompt: e.prompt } : null;
+      case "PreToolUse": {
+        const cmd = e.tool_input?.command ?? "";
+        if (e.tool_name === "Bash" && isGitCommit(cmd)) {
+          return { kind: "pre_commit", sessionId: sid, timestamp: ts, commitCommand: cmd };
+        }
+        return null;
+      }
+      case "PostToolUse": {
+        const tool = e.tool_name;
+        if ((tool === "Edit" || tool === "Write" || tool === "NotebookEdit") && e.tool_input?.file_path) {
+          return { kind: "file_change", sessionId: sid, timestamp: ts, tool, file: e.tool_input.file_path };
+        }
+        if (tool === "Bash" && isGitCommit(e.tool_input?.command ?? "")) {
+          return { kind: "post_commit", sessionId: sid, timestamp: ts, transcriptPath: tp };
+        }
+        return null;
+      }
+      default:
+        return null;
+    }
+  },
+  findTranscript(sessionId) {
+    if (!isValidSessionId(sessionId)) return null;
+    const claudeDir = join2(homedir(), ".claude", "projects");
+    const pattern = join2(claudeDir, "**", "sessions", `${sessionId}.jsonl`);
+    const matches = globSync(pattern);
+    if (matches.length === 0) return null;
+    const match = matches[0];
+    return isValidTranscriptPath(match) ? match : null;
+  },
+  async extractInteractions(transcriptPath) {
+    if (!isValidTranscriptPath(transcriptPath) || !existsSync(transcriptPath)) return [];
+    try {
+      const content = await readFile(transcriptPath, "utf-8");
+      const lines = content.trim().split("\n");
+      const interactions = [];
+      let pendingPrompt = null;
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if (entry.type === "user" && entry.message?.content) {
+            for (const block of entry.message.content) {
+              if (block.type === "text" && block.text) {
+                if (pendingPrompt !== null) {
+                  interactions.push({ prompt: pendingPrompt, response: null });
+                }
+                pendingPrompt = block.text;
+              }
+            }
+          }
+          if (entry.type === "assistant" && entry.message?.content && pendingPrompt !== null) {
+            const texts = [];
+            for (const block of entry.message.content) {
+              if (block.type === "text" && block.text) texts.push(block.text);
+            }
+            if (texts.length > 0) {
+              interactions.push({ prompt: pendingPrompt, response: texts.join("\n") });
+              pendingPrompt = null;
+            }
+          }
+        } catch {
+        }
+      }
+      if (pendingPrompt !== null) {
+        interactions.push({ prompt: pendingPrompt, response: null });
+      }
+      return interactions;
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/commands/init.ts
+var WORKFLOW_TEMPLATE = `name: Agentnote
+on:
+  pull_request:
+    types: [opened, synchronize]
+permissions:
+  contents: read
+  pull-requests: write
+jobs:
+  report:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: wasabeef/agentnote@v1
+`;
+async function init(args2) {
+  const skipHooks = args2.includes("--no-hooks");
+  const skipAction = args2.includes("--no-action");
+  const skipNotes = args2.includes("--no-notes");
+  const hooksOnly = args2.includes("--hooks");
+  const actionOnly = args2.includes("--action");
+  const repoRoot2 = await root();
+  const results = [];
+  await mkdir2(await agentnoteDir(), { recursive: true });
+  if (!skipHooks && !actionOnly) {
+    const adapter = claudeCode;
+    if (await adapter.isEnabled(repoRoot2)) {
+      results.push("  \xB7 hooks already configured");
+    } else {
+      await adapter.installHooks(repoRoot2);
+      results.push("  \u2713 hooks added to .claude/settings.json");
+    }
+  }
+  if (!skipAction && !hooksOnly) {
+    const workflowDir = join3(repoRoot2, ".github", "workflows");
+    const workflowPath = join3(workflowDir, "agentnote.yml");
+    if (existsSync2(workflowPath)) {
+      results.push("  \xB7 workflow already exists at .github/workflows/agentnote.yml");
+    } else {
+      await mkdir2(workflowDir, { recursive: true });
+      await writeFile2(workflowPath, WORKFLOW_TEMPLATE);
+      results.push("  \u2713 workflow created at .github/workflows/agentnote.yml");
+    }
+  }
+  if (!skipNotes && !hooksOnly && !actionOnly) {
+    const { stdout } = await gitSafe([
+      "config",
+      "--get-all",
+      "remote.origin.fetch"
+    ]);
+    if (stdout.includes("refs/notes/agentnote")) {
+      results.push("  \xB7 git already configured to fetch notes");
+    } else {
+      await gitSafe([
+        "config",
+        "--add",
+        "remote.origin.fetch",
+        "+refs/notes/agentnote:refs/notes/agentnote"
+      ]);
+      results.push("  \u2713 git configured to auto-fetch notes on pull");
+    }
+  }
+  console.log("");
+  console.log("agentnote init");
+  console.log("");
+  for (const line of results) {
+    console.log(line);
+  }
+  const toCommit = [];
+  if (!skipHooks && !actionOnly) toCommit.push(".claude/settings.json");
+  if (!skipAction && !hooksOnly) {
+    const workflowPath = join3(repoRoot2, ".github", "workflows", "agentnote.yml");
+    if (existsSync2(workflowPath)) toCommit.push(".github/workflows/agentnote.yml");
+  }
+  if (toCommit.length > 0) {
+    console.log("");
+    console.log("  Next: commit and push these files");
+    console.log(`    git add ${toCommit.join(" ")}`);
+    console.log('    git commit -m "chore: enable agentnote session tracking"');
+    console.log("    git push");
+  }
+  console.log("");
+}
+
+// src/commands/commit.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { existsSync as existsSync5 } from "node:fs";
+import { spawn } from "node:child_process";
+import { join as join5 } from "node:path";
+
+// src/core/jsonl.ts
+import { readFile as readFile2, appendFile } from "node:fs/promises";
+import { existsSync as existsSync3 } from "node:fs";
+async function readJsonlField(filePath, field) {
+  if (!existsSync3(filePath)) return [];
+  const content = await readFile2(filePath, "utf-8");
+  const seen = /* @__PURE__ */ new Set();
+  const values = [];
+  for (const line of content.trim().split("\n")) {
+    if (!line) continue;
+    try {
+      const entry = JSON.parse(line);
+      const val = entry[field];
+      if (val && !seen.has(val)) {
+        seen.add(val);
+        values.push(val);
+      }
+    } catch {
+    }
+  }
+  return values;
+}
+async function appendJsonl(filePath, data) {
+  await appendFile(filePath, JSON.stringify(data) + "\n");
+}
+
+// src/core/storage.ts
+var NOTES_REF = "agentnote";
+async function writeNote(commitSha, data) {
+  const body = JSON.stringify(data, null, 2);
+  await gitSafe(["notes", `--ref=${NOTES_REF}`, "add", "-f", "-m", body, commitSha]);
+}
+async function readNote(commitSha) {
+  const { stdout, exitCode } = await gitSafe([
+    "notes",
+    `--ref=${NOTES_REF}`,
+    "show",
+    commitSha
+  ]);
+  if (exitCode !== 0 || !stdout.trim()) return null;
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+}
+
+// src/core/entry.ts
+var SCHEMA_VERSION = 1;
+var RESPONSE_MAX_LENGTH = 2e3;
+function calcAiRatio(commitFiles, aiFiles) {
+  if (commitFiles.length === 0) return 0;
+  const aiSet = new Set(aiFiles);
+  const matched = commitFiles.filter((f) => aiSet.has(f));
+  return Math.round(matched.length / commitFiles.length * 100);
+}
+function truncate(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "\u2026";
+}
+function buildEntry(opts) {
+  return {
+    v: SCHEMA_VERSION,
+    session_id: opts.sessionId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    interactions: opts.interactions.map((i) => ({
+      prompt: i.prompt,
+      response: i.response ? truncate(i.response, RESPONSE_MAX_LENGTH) : null
+    })),
+    files_in_commit: opts.commitFiles,
+    files_by_ai: opts.aiFiles,
+    ai_ratio: calcAiRatio(opts.commitFiles, opts.aiFiles)
+  };
+}
+
+// src/core/rotate.ts
+import { rename } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+async function rotateLogs(sessionDir, commitSha, fileNames = ["prompts.jsonl", "changes.jsonl"]) {
+  for (const name of fileNames) {
+    const src = join4(sessionDir, name);
+    if (existsSync4(src)) {
+      const base = name.replace(".jsonl", "");
+      await rename(
+        src,
+        join4(sessionDir, `${base}-${commitSha.slice(0, 8)}.jsonl`)
+      );
+    }
+  }
+}
+
+// src/commands/commit.ts
+async function commit(args2) {
+  const sf = await sessionFile();
+  let sessionId = "";
+  if (existsSync5(sf)) {
+    sessionId = (await readFile3(sf, "utf-8")).trim();
+  }
+  const gitArgs = ["commit"];
+  if (sessionId) {
+    gitArgs.push("--trailer", `Agentnote-Session: ${sessionId}`);
+  }
+  gitArgs.push(...args2);
+  const child = spawn("git", gitArgs, {
+    stdio: "inherit",
+    cwd: process.cwd()
+  });
+  const exitCode = await new Promise((resolve) => {
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+  if (sessionId) {
+    try {
+      const agentnoteDirPath = await agentnoteDir();
+      const sessionDir = join5(agentnoteDirPath, "sessions", sessionId);
+      const commitSha = await git(["rev-parse", "HEAD"]);
+      let commitFiles = [];
+      try {
+        const raw = await git([
+          "diff-tree",
+          "--no-commit-id",
+          "--name-only",
+          "-r",
+          "HEAD"
+        ]);
+        commitFiles = raw.split("\n").filter(Boolean);
+      } catch {
+      }
+      const aiFiles = await readJsonlField(
+        join5(sessionDir, "changes.jsonl"),
+        "file"
+      );
+      const prompts = await readJsonlField(
+        join5(sessionDir, "prompts.jsonl"),
+        "prompt"
+      );
+      let interactions;
+      const transcriptPathFile = join5(sessionDir, "transcript_path");
+      if (existsSync5(transcriptPathFile)) {
+        const transcriptPath = (await readFile3(transcriptPathFile, "utf-8")).trim();
+        if (transcriptPath) {
+          const allInteractions = await claudeCode.extractInteractions(transcriptPath);
+          interactions = prompts.length > 0 && allInteractions.length > 0 ? allInteractions.slice(-prompts.length) : prompts.map((p) => ({ prompt: p, response: null }));
+        } else {
+          interactions = prompts.map((p) => ({ prompt: p, response: null }));
+        }
+      } else {
+        interactions = prompts.map((p) => ({ prompt: p, response: null }));
+      }
+      const entry = buildEntry({
+        sessionId,
+        interactions,
+        commitFiles,
+        aiFiles
+      });
+      await writeNote(commitSha, entry);
+      await rotateLogs(sessionDir, commitSha);
+      console.log(
+        `agentnote: ${interactions.length} prompts, AI ratio ${entry.ai_ratio}%`
+      );
+    } catch (err) {
+      console.error(`agentnote: warning: ${err.message}`);
+    }
+  }
+}
+
+// src/commands/show.ts
+import { stat } from "node:fs/promises";
+async function show(commitRef) {
+  const ref = commitRef ?? "HEAD";
+  const commitInfo = await git(["log", "-1", "--format=%h %s", ref]);
+  const commitSha = await git(["log", "-1", "--format=%H", ref]);
+  const sessionId = (await git([
+    "log",
+    "-1",
+    "--format=%(trailers:key=Agentnote-Session,valueonly)",
+    ref
+  ])).trim();
+  console.log(`commit:  ${commitInfo}`);
+  if (!sessionId) {
+    console.log("session: none (no agentnote data)");
+    return;
+  }
+  console.log(`session: ${sessionId}`);
+  const raw = await readNote(commitSha);
+  const entry = raw;
+  if (entry) {
+    console.log();
+    const ratioBar = renderRatioBar(entry.ai_ratio);
+    console.log(`ai:      ${entry.ai_ratio}% ${ratioBar}`);
+    console.log(
+      `files:   ${entry.files_in_commit.length} changed, ${entry.files_by_ai.length} by AI`
+    );
+    if (entry.files_in_commit.length > 0) {
+      console.log();
+      for (const file of entry.files_in_commit) {
+        const isAi = entry.files_by_ai.includes(file);
+        const marker = isAi ? "  \u{1F916}" : "  \u{1F464}";
+        console.log(`  ${file}${marker}`);
+      }
+    }
+    const interactions = entry.interactions ?? (entry.prompts ?? []).map((p) => ({
+      prompt: p,
+      response: null
+    }));
+    if (interactions.length > 0) {
+      console.log();
+      console.log(`prompts: ${interactions.length}`);
+      for (let i = 0; i < interactions.length; i++) {
+        const { prompt, response } = interactions[i];
+        console.log();
+        console.log(`  ${i + 1}. ${truncateLines(prompt, 120)}`);
+        if (response) {
+          console.log(`     \u2192 ${truncateLines(response, 200)}`);
+        }
+      }
+    }
+  } else {
+    console.log("entry:   no agentnote note found for this commit");
+  }
+  console.log();
+  const adapter = claudeCode;
+  const transcriptPath = adapter.findTranscript(sessionId);
+  if (transcriptPath) {
+    const stats = await stat(transcriptPath);
+    const sizeKb = (stats.size / 1024).toFixed(1);
+    console.log(`transcript: ${transcriptPath} (${sizeKb} KB)`);
+  } else {
+    console.log("transcript: not found locally");
+  }
+}
+function renderRatioBar(ratio) {
+  const width = 20;
+  const filled = Math.round(ratio / 100 * width);
+  const empty = width - filled;
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}]`;
+}
+function truncateLines(text, maxLen) {
+  const firstLine = text.split("\n")[0];
+  if (firstLine.length <= maxLen) return firstLine;
+  return firstLine.slice(0, maxLen) + "\u2026";
+}
+
+// src/commands/log.ts
+async function log(count = 10) {
+  const raw = await git([
+    "log",
+    `-${count}`,
+    "--format=%H	%h %s	%(trailers:key=Agentnote-Session,valueonly)"
+  ]);
+  if (!raw) {
+    console.log("no commits found");
+    return;
+  }
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("	");
+    const fullSha = parts[0];
+    const commitPart = parts[1];
+    const sid = parts[2]?.trim();
+    if (!fullSha || !commitPart) continue;
+    if (!sid) {
+      console.log(commitPart);
+      continue;
+    }
+    let ratioStr = "";
+    let promptCount = "";
+    const note = await readNote(fullSha);
+    if (note) {
+      const entry = note;
+      ratioStr = `${entry.ai_ratio}%`;
+      promptCount = `${entry.interactions?.length ?? entry.prompts?.length ?? 0}p`;
+    }
+    if (ratioStr) {
+      console.log(
+        `${commitPart}  [${sid.slice(0, 8)}\u2026 | \u{1F916}${ratioStr} | ${promptCount}]`
+      );
+    } else {
+      console.log(`${commitPart}  [${sid.slice(0, 8)}\u2026]`);
+    }
+  }
+}
+
+// src/commands/status.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { existsSync as existsSync6 } from "node:fs";
+var VERSION = "0.1.0";
+async function status() {
+  console.log(`agentnote v${VERSION}`);
+  console.log();
+  const repoRoot2 = await root();
+  const adapter = claudeCode;
+  const hooksActive = await adapter.isEnabled(repoRoot2);
+  if (hooksActive) {
+    console.log("hooks:   active");
+  } else {
+    console.log("hooks:   not configured (run 'agentnote init')");
+  }
+  const sessionPath = await sessionFile();
+  if (existsSync6(sessionPath)) {
+    const sid = (await readFile4(sessionPath, "utf-8")).trim();
+    console.log(`session: ${sid.slice(0, 8)}\u2026`);
+  } else {
+    console.log("session: none");
+  }
+  const { stdout } = await gitSafe([
+    "log",
+    "-20",
+    "--format=%(trailers:key=Agentnote-Session,valueonly)"
+  ]);
+  const linked = stdout.split("\n").filter((line) => line.trim().length > 0).length;
+  console.log(`linked:  ${linked}/20 recent commits`);
+}
+
+// src/commands/hook.ts
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3, realpath } from "node:fs/promises";
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join6, relative, isAbsolute } from "node:path";
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function hook() {
+  const raw = await readStdin();
+  let sync = false;
+  try {
+    const peek = JSON.parse(raw);
+    sync = peek.hook_event_name === "PreToolUse";
+  } catch {
+    return;
+  }
+  const adapter = claudeCode;
+  const input = { raw, sync };
+  const event = adapter.parseEvent(input);
+  if (!event) return;
+  const agentnoteDirPath = await agentnoteDir();
+  const sessionDir = join6(agentnoteDirPath, "sessions", event.sessionId);
+  await mkdir3(sessionDir, { recursive: true });
+  switch (event.kind) {
+    case "session_start": {
+      await writeFile3(join6(agentnoteDirPath, "session"), event.sessionId);
+      if (event.transcriptPath) {
+        await writeFile3(join6(sessionDir, "transcript_path"), event.transcriptPath);
+      }
+      await appendJsonl(join6(sessionDir, "events.jsonl"), {
+        event: "session_start",
+        session_id: event.sessionId,
+        timestamp: event.timestamp,
+        model: event.model ?? null
+      });
+      break;
+    }
+    case "stop": {
+      await writeFile3(join6(agentnoteDirPath, "session"), event.sessionId);
+      if (event.transcriptPath) {
+        await writeFile3(join6(sessionDir, "transcript_path"), event.transcriptPath);
+      }
+      await appendJsonl(join6(sessionDir, "events.jsonl"), {
+        event: "stop",
+        session_id: event.sessionId,
+        timestamp: event.timestamp
+      });
+      break;
+    }
+    case "prompt": {
+      await appendJsonl(join6(sessionDir, "prompts.jsonl"), {
+        event: "prompt",
+        timestamp: event.timestamp,
+        prompt: event.prompt
+      });
+      break;
+    }
+    case "file_change": {
+      let filePath = event.file ?? "";
+      if (isAbsolute(filePath)) {
+        try {
+          const rawRoot = (await git(["rev-parse", "--show-toplevel"])).trim();
+          const repoRoot2 = await realpath(rawRoot);
+          let normalizedFile = filePath;
+          if (repoRoot2.startsWith("/private") && !normalizedFile.startsWith("/private")) {
+            normalizedFile = "/private" + normalizedFile;
+          } else if (!repoRoot2.startsWith("/private") && normalizedFile.startsWith("/private")) {
+            normalizedFile = normalizedFile.replace(/^\/private/, "");
+          }
+          filePath = relative(repoRoot2, normalizedFile);
+        } catch {
+        }
+      }
+      await appendJsonl(join6(sessionDir, "changes.jsonl"), {
+        event: "file_change",
+        timestamp: event.timestamp,
+        tool: event.tool,
+        file: filePath,
+        session_id: event.sessionId
+      });
+      break;
+    }
+    case "pre_commit": {
+      const cmd = event.commitCommand ?? "";
+      if (!cmd.includes("Agentnote-Session") && event.sessionId) {
+        process.stdout.write(
+          JSON.stringify({
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              updatedInput: {
+                command: `${cmd} --trailer 'Agentnote-Session: ${event.sessionId}'`
+              }
+            }
+          })
+        );
+      }
+      break;
+    }
+    case "post_commit": {
+      try {
+        await recordEntry(agentnoteDirPath, event.sessionId, event.transcriptPath);
+      } catch {
+      }
+      break;
+    }
+  }
+}
+async function recordEntry(agentnoteDirPath, sessionId, eventTranscriptPath) {
+  const sessionDir = join6(agentnoteDirPath, "sessions", sessionId);
+  const commitSha = await git(["rev-parse", "HEAD"]);
+  let commitFiles = [];
+  try {
+    const raw = await git(["diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD"]);
+    commitFiles = raw.split("\n").filter(Boolean);
+  } catch {
+  }
+  const aiFiles = await readJsonlField(join6(sessionDir, "changes.jsonl"), "file");
+  const prompts = await readJsonlField(join6(sessionDir, "prompts.jsonl"), "prompt");
+  const transcriptPath = eventTranscriptPath ?? await readSavedTranscriptPath(sessionDir);
+  const adapter = claudeCode;
+  let interactions;
+  if (transcriptPath) {
+    const allInteractions = await adapter.extractInteractions(transcriptPath);
+    interactions = prompts.length > 0 && allInteractions.length > 0 ? allInteractions.slice(-prompts.length) : prompts.map((p) => ({ prompt: p, response: null }));
+  } else {
+    interactions = prompts.map((p) => ({ prompt: p, response: null }));
+  }
+  const entry = buildEntry({
+    sessionId,
+    interactions,
+    commitFiles,
+    aiFiles
+  });
+  await writeNote(commitSha, entry);
+  await rotateLogs(sessionDir, commitSha);
+}
+async function readSavedTranscriptPath(sessionDir) {
+  const saved = join6(sessionDir, "transcript_path");
+  if (!existsSync7(saved)) return null;
+  const p = (await readFile5(saved, "utf-8")).trim();
+  return p || null;
+}
+
+// src/commands/pr.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
+var MARKER_BEGIN = "<!-- agentnote-begin -->";
+var MARKER_END = "<!-- agentnote-end -->";
+async function collectReport(base) {
+  const head = await git(["rev-parse", "--short", "HEAD"]);
+  const raw = await git([
+    "log",
+    "--reverse",
+    "--format=%H	%h	%s",
+    `${base}..HEAD`
+  ]);
+  if (!raw.trim()) return null;
+  const commits = [];
+  for (const line of raw.trim().split("\n")) {
+    const [sha, short, ...msgParts] = line.split("	");
+    const message = msgParts.join("	");
+    const note = await readNote(sha);
+    if (!note) {
+      commits.push({
+        sha,
+        short,
+        message,
+        session_id: null,
+        ai_ratio: null,
+        prompts_count: 0,
+        files_total: 0,
+        files_ai: 0,
+        files: [],
+        interactions: []
+      });
+      continue;
+    }
+    const entry = note;
+    const interactions = entry.interactions ?? (entry.prompts ?? []).map((p) => ({ prompt: p, response: null }));
+    const filesInCommit = entry.files_in_commit ?? [];
+    const filesByAi = entry.files_by_ai ?? [];
+    commits.push({
+      sha,
+      short,
+      message,
+      session_id: entry.session_id ?? null,
+      ai_ratio: entry.ai_ratio ?? 0,
+      prompts_count: interactions.length,
+      files_total: filesInCommit.length,
+      files_ai: filesByAi.length,
+      files: filesInCommit.map((f) => ({
+        path: f,
+        by_ai: filesByAi.includes(f)
+      })),
+      interactions
+    });
+  }
+  const tracked = commits.filter((c) => c.session_id !== null);
+  const totalFiles = tracked.reduce((s, c) => s + c.files_total, 0);
+  const totalFilesAi = tracked.reduce((s, c) => s + c.files_ai, 0);
+  return {
+    base,
+    head,
+    total_commits: commits.length,
+    tracked_commits: tracked.length,
+    total_prompts: tracked.reduce((s, c) => s + c.prompts_count, 0),
+    total_files: totalFiles,
+    total_files_ai: totalFilesAi,
+    overall_ai_ratio: totalFiles > 0 ? Math.round(totalFilesAi / totalFiles * 100) : 0,
+    commits
+  };
+}
+function renderMarkdown(report) {
+  const lines = [];
+  lines.push("## \u{1F916} Agentnote \u2014 AI Session Report");
+  lines.push("");
+  lines.push(
+    `**Overall AI ratio: ${report.overall_ai_ratio}%** (${report.tracked_commits}/${report.total_commits} commits tracked, ${report.total_prompts} prompts)`
+  );
+  lines.push("");
+  lines.push("| Commit | AI | Prompts | Files |");
+  lines.push("|---|---|---|---|");
+  for (const c of report.commits) {
+    if (c.ai_ratio === null) {
+      lines.push(`| \`${c.short}\` ${c.message} | \u2014 | \u2014 | \u2014 |`);
+      continue;
+    }
+    const bar = renderBar(c.ai_ratio);
+    const fileList = c.files.map((f) => `${basename(f.path)} ${f.by_ai ? "\u{1F916}" : "\u{1F464}"}`).join(", ");
+    lines.push(
+      `| \`${c.short}\` ${c.message} | ${c.ai_ratio}% ${bar} | ${c.prompts_count} | ${fileList} |`
+    );
+  }
+  lines.push("");
+  const withPrompts = report.commits.filter((c) => c.interactions.length > 0);
+  if (withPrompts.length > 0) {
+    lines.push("<details>");
+    lines.push(`<summary>Prompts & Responses (${report.total_prompts} total)</summary>`);
+    lines.push("");
+    for (const c of withPrompts) {
+      lines.push(`**\`${c.short}\`** ${c.message}`);
+      lines.push("");
+      for (const { prompt, response } of c.interactions) {
+        lines.push(`> **Prompt:** ${prompt}`);
+        if (response) {
+          const truncated = response.length > 500 ? response.slice(0, 500) + "\u2026" : response;
+          lines.push(">");
+          lines.push(`> **Response:** ${truncated.split("\n").join("\n> ")}`);
+        }
+        lines.push("");
+      }
+    }
+    lines.push("</details>");
+  }
+  return lines.join("\n");
+}
+function renderChat(report) {
+  const lines = [];
+  lines.push("## \u{1F916} Agentnote \u2014 Session Transcript");
+  lines.push("");
+  lines.push(
+    `**Overall AI ratio: ${report.overall_ai_ratio}%** (${report.tracked_commits}/${report.total_commits} commits tracked, ${report.total_prompts} prompts)`
+  );
+  for (const c of report.commits) {
+    lines.push("");
+    const ratioLabel = c.ai_ratio === null ? "" : c.ai_ratio === 0 ? "\u{1F464} Human 100% \u2591\u2591\u2591\u2591\u2591" : `AI ${c.ai_ratio}% ${renderBar(c.ai_ratio)}`;
+    const aiCount = c.files.filter((f) => f.by_ai).length;
+    const humanCount = c.files.length - aiCount;
+    const fileSummary = c.files.length > 0 ? ` \xB7 ${c.files.length} files (${aiCount} \u{1F916} ${humanCount} \u{1F464})` : "";
+    const summaryExtra = ratioLabel ? ` \u2014 ${ratioLabel}` : "";
+    const summaryFiles = fileSummary;
+    if (c.interactions.length === 0 && c.ai_ratio === null) {
+      lines.push(`<details>`);
+      lines.push(`<summary><code>${c.short}</code> ${c.message}</summary>`);
+      lines.push("");
+      lines.push("*No agentnote data for this commit.*");
+      lines.push("");
+      lines.push(`</details>`);
+      continue;
+    }
+    lines.push(`<details>`);
+    lines.push(`<summary><code>${c.short}</code> ${c.message}${summaryExtra}${summaryFiles}</summary>`);
+    lines.push("");
+    for (const { prompt, response } of c.interactions) {
+      lines.push(`> **\u{1F9D1} Prompt**`);
+      lines.push(`> ${prompt.split("\n").join("\n> ")}`);
+      lines.push("");
+      if (response) {
+        lines.push(`**\u{1F916} Response**`);
+        lines.push("");
+        const truncated = response.length > 800 ? response.slice(0, 800) + "\u2026" : response;
+        lines.push(truncated);
+        lines.push("");
+      }
+    }
+    if (c.interactions.length > 0 && c.ai_ratio === 0) {
+      lines.push("*AI provided guidance, but the code was written by a human.*");
+      lines.push("");
+    }
+    if (c.files.length > 0) {
+      lines.push("**Files:**");
+      for (const f of c.files) {
+        lines.push(`- \`${f.path}\` ${f.by_ai ? "\u{1F916}" : "\u{1F464}"}`);
+      }
+      lines.push("");
+    }
+    lines.push(`</details>`);
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("<details>");
+  lines.push(`<summary>\u{1F4CA} Summary</summary>`);
+  lines.push("");
+  lines.push(
+    `**Overall AI ratio: ${report.overall_ai_ratio}%** (${report.tracked_commits}/${report.total_commits} commits, ${report.total_prompts} prompts)`
+  );
+  lines.push("");
+  lines.push("| Commit | AI | Prompts | Files |");
+  lines.push("|---|---|---|---|");
+  for (const c of report.commits) {
+    if (c.ai_ratio === null) {
+      lines.push(`| \`${c.short}\` ${c.message} | \u2014 | \u2014 | \u2014 |`);
+      continue;
+    }
+    const fileList = c.files.map((f) => `${basename(f.path)} ${f.by_ai ? "\u{1F916}" : "\u{1F464}"}`).join(", ");
+    lines.push(
+      `| \`${c.short}\` ${c.message} | ${c.ai_ratio}% ${renderBar(c.ai_ratio)} | ${c.prompts_count} | ${fileList} |`
+    );
+  }
+  lines.push("");
+  lines.push("</details>");
+  return lines.join("\n");
+}
+function wrapWithMarkers(content) {
+  return `${MARKER_BEGIN}
+${content}
+${MARKER_END}`;
+}
+function upsertInDescription(existingBody, section) {
+  const marked = wrapWithMarkers(section);
+  if (existingBody.includes(MARKER_BEGIN)) {
+    const before = existingBody.slice(0, existingBody.indexOf(MARKER_BEGIN));
+    const after = existingBody.includes(MARKER_END) ? existingBody.slice(existingBody.indexOf(MARKER_END) + MARKER_END.length) : "";
+    return before.trimEnd() + "\n\n" + marked + after;
+  }
+  return existingBody.trimEnd() + "\n\n" + marked;
+}
+async function updatePrDescription(prNumber, section) {
+  const { stdout: bodyJson } = await execFileAsync2("gh", [
+    "pr",
+    "view",
+    prNumber,
+    "--json",
+    "body"
+  ], { encoding: "utf-8" });
+  const currentBody = JSON.parse(bodyJson).body ?? "";
+  const newBody = upsertInDescription(currentBody, section);
+  await execFileAsync2("gh", [
+    "pr",
+    "edit",
+    prNumber,
+    "--body",
+    newBody
+  ], { encoding: "utf-8" });
+}
+async function pr(args2) {
+  const isJson = args2.includes("--json");
+  const formatIdx = args2.indexOf("--format");
+  const format = formatIdx !== -1 ? args2[formatIdx + 1] : "table";
+  const updateIdx = args2.indexOf("--update");
+  const prNumber = updateIdx !== -1 ? args2[updateIdx + 1] : null;
+  const positional = args2.filter(
+    (a, i) => !a.startsWith("--") && (formatIdx === -1 || i !== formatIdx + 1) && (updateIdx === -1 || i !== updateIdx + 1)
+  );
+  const base = positional[0] ?? await detectBaseBranch();
+  if (!base) {
+    console.error(
+      "error: could not detect base branch. pass it as argument: agentnote pr <base>"
+    );
+    process.exit(1);
+  }
+  const report = await collectReport(base);
+  if (!report) {
+    if (isJson) {
+      console.log(JSON.stringify({ error: "no commits found" }));
+    } else {
+      console.log("no commits found between HEAD and " + base);
+    }
+    return;
+  }
+  let output;
+  if (isJson) {
+    output = JSON.stringify(report, null, 2);
+  } else if (format === "chat") {
+    output = renderChat(report);
+  } else {
+    output = renderMarkdown(report);
+  }
+  if (prNumber) {
+    await updatePrDescription(prNumber, output);
+    console.log(`agentnote: PR #${prNumber} description updated`);
+  } else {
+    console.log(output);
+  }
+}
+function renderBar(ratio) {
+  const width = 5;
+  const filled = Math.round(ratio / 100 * width);
+  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
+function basename(path) {
+  return path.split("/").pop() ?? path;
+}
+async function detectBaseBranch() {
+  for (const name of ["main", "master", "develop"]) {
+    const { exitCode } = await gitSafe([
+      "rev-parse",
+      "--verify",
+      `origin/${name}`
+    ]);
+    if (exitCode === 0) return `origin/${name}`;
+  }
+  return null;
+}
+
+// src/cli.ts
+var VERSION2 = "0.1.0";
+var HELP = `
+agentnote \u2014 remember why your code changed
+
+usage:
+  agentnote init [options]       set up hooks, workflow, and notes auto-fetch
+                                   --hooks         hooks only
+                                   --action        workflow only
+                                   --no-action     skip workflow
+  agentnote show [commit]        show session details for a commit
+  agentnote log [n]              list recent commits with session info
+  agentnote pr [base] [options]  generate report for a PR
+                                   --json          structured JSON
+                                   --format chat   chat-style transcript
+                                   --update <pr#>  insert into PR description
+  agentnote status               show current tracking state
+  agentnote commit [args]        git commit with session context (optional)
+  agentnote version              print version
+  agentnote help                 show this help
+`.trim();
+var command = process.argv[2];
+var args = process.argv.slice(3);
+switch (command) {
+  case "init":
+    await init(args);
+    break;
+  case "commit":
+    await commit(args);
+    break;
+  case "show":
+    await show(args[0]);
+    break;
+  case "log":
+    await log(args[0] ? parseInt(args[0], 10) : 10);
+    break;
+  case "pr":
+    await pr(args);
+    break;
+  case "status":
+    await status();
+    break;
+  case "hook":
+    await hook();
+    break;
+  case "version":
+  case "--version":
+  case "-v":
+    console.log(`agentnote v${VERSION2}`);
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+  case void 0:
+    console.log(HELP);
+    break;
+  default:
+    console.error(`unknown command: ${command}`);
+    console.log(HELP);
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@wasabeef/agentnote",
+  "version": "0.1.0",
+  "description": "Remember why your code changed. Link AI agent sessions to git commits.",
+  "type": "module",
+  "bin": {
+    "agentnote": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "esbuild src/cli.ts --bundle --platform=node --format=esm --outfile=dist/cli.js --banner:js='#!/usr/bin/env node'",
+    "dev": "tsx src/cli.ts",
+    "lint": "tsc --noEmit",
+    "test": "node --import tsx/esm --test 'src/**/*.test.ts'",
+    "test:coverage": "node --import tsx/esm --test --experimental-test-coverage 'src/**/*.test.ts'",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "claude-code",
+    "git",
+    "session",
+    "agentnote",
+    "ai",
+    "traceability"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "esbuild": "^0.27.5",
+    "tsx": "^4.20.0",
+    "typescript": "^6.0.2"
+  }
+}