@cogit/cli 0.30.0 → 0.31.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cogit",
   "displayName": "cogit",
-  "version": "0.30.0",
+  "version": "0.31.1",
   "description": "Git remembers what changed. cogit remembers why.",
   "author": {
     "name": "Eren Sertkaya"

package/README.md

@@ -8,8 +8,47 @@ Git remembers what changed. cogit remembers why.
 
 cogit records every message you send to an AI coding agent as a *thought commit*: what you
 asked, what came of it, and the message it answered. Your code commits point back to the
-thought behind them, so `git log` tells you what changed and cogit tells you why. It works with
-Claude Code today.
+thought behind them, so `cogit why` takes any line of code back to the reason it exists. It works
+with Claude Code today.
+
+Agent memory helps your agent remember. cogit helps you understand.
+
+It runs as a Claude Code plugin and works through Claude Code hooks, so the record is written
+while you work, not reconstructed from the diff afterwards.
+
+**[Click through a saved map](https://erensrtky.github.io/cogit/demo/)**: no install, no server.
+It's the page `cogit open` writes, built from sample data and read-only.
+
+## Why
+
+I started by copying code out of ChatGPT, then moved to browser tools, editor extensions and now
+terminal agents. Each step moved the code further from me, and I kept feeling something was
+slipping away. When you write code yourself, it sinks in bit by bit: you know why that table
+exists and why you wrote that class. When an agent writes it, that feeling goes away.
+
+The information isn't really gone. It sits in your messages, the agent's replies and your commits,
+just in separate places. cogit ties them together, so you can always walk back and see why
+something was done. It helps most when you juggle projects: I run 5-10 agents at once across 2-3
+of them, and a few minutes later I can lose track of what I did where.
+
+<img src="docs/images/why-abstraction.png" alt="A conceptual chart from machine code to software factories: abstraction keeps rising, while how much of the why you can still trace falls sharply once AI starts writing code. cogit keeps what falls away.">
+
+It's bigger than one person's memory: a reviewer sees what changed, not why.
+[More, with research and sources](docs/guide/why.md).
+
+cogit isn't:
+
+- **Agent memory** (OpenViking, Mem0): that helps your agent recall what you talked about.
+- **A token saver** (RTK, Headroom): that sends the model less.
+- **A code map** (graphify): that shows how a codebase fits together.
+- **An orchestrator** (Herdr, Conductor): that runs many agents at once.
+- **A planning framework** (BMAD, Spec Kit): that decides what to build next.
+- **An AI review bot** (CodeRabbit, Greptile): that comments on whether a diff looks right.
+
+It answers the one question they leave open: why is this code the way it is? I use several of
+them alongside it.
+
+## See it
 
 <img src="docs/images/map.png" alt="The map: sessions as a git graph, each with its messages, branches, commit chips and a left off here marker">
 
@@ -23,8 +62,8 @@ what the change does, and the diff.*
 
 <img src="docs/images/tasks.png" alt="The Tasks panel: suggested items with Accept and Dismiss, open items with Done, and a Done section">
 
-*Tasks — what your sessions left undone, drafted when a session closes. You accept, dismiss or
-close each one.*
+*Tasks — work that came up in a session and didn't get finished, caught when the session closes.
+You accept, dismiss or close each one.*
 
 <img src="docs/images/files.png" alt="The Files view: a changed file opened, listing the messages that touched it with each message's reason and the option it rejected">
 
@@ -43,25 +82,21 @@ including the option that was rejected.*
 - **Intent, Shape, Code**: a message that landed commits shows why it happened, a small
   picture of what the change does (a diagram, a before/after or interface table, an example
   or plain steps), and the diff, in one place.
-- **Tasks**: when a session ends, a small model drafts a few user-level items from what it
-  left undone; you accept, dismiss or close them (`cogit captures`, and on the map).
+- **Tasks**: when a session ends, a small model catches the work that came up and didn't get
+  finished as a few user-level items; you accept, dismiss or close them (`cogit captures`, and
+  on the map).
 - **Pull request descriptions with the decisions**: `cogit pr` writes the goal, the
   decisions and the rejected options, never the raw chat.
 - **Teams share the record through git**: after a pull, your teammates' sessions are on the
   map too, with who ran them and what changed most.
-- **The agent remembers**: a new session starts where the last one left off, and before
-  editing a file the agent hears what was already tried and rejected there.
 - **Cheap by default**: a small side model records in the background; in our sessions it
   cost about 1–2% of a session's tokens.
-- **Private by default**: no server, no account. The raw conversation stays on your machine
-  and keys are redacted.
-
-## Why
-
-AI coding agents made writing code faster and moved the bottleneck to review: in a study of
-718 firms, they opened 23% more pull requests while review time rose 49% and finished work did
-not measurably grow. A reviewer sees what changed, not why; the why stays in a chat nobody else
-reads. cogit keeps it next to the code. [More, with sources](docs/guide/why.md).
+- **No server, no account**: it runs on your machine. Your chats are not committed. The record
+  (titles, decisions and reasons) is, so it travels with your branch; `cogit init` lets you keep
+  it local instead. Key and token patterns are redacted.
+- **The agent gets the context too**: a new session starts where the last one left off, and
+  before editing a file the agent hears what was already tried and rejected there. It works
+  alongside memory tools; it doesn't replace them.
 
 ## Install
 

package/dist/{chunk-ECWQ77TQ.js → chunk-DJFQNOZT.js}

@@ -21206,7 +21206,7 @@ async function migrateProject(root) {
     const next = renameGitignoreLines(text);
     if (next !== text) await atomicWrite(gitignore, next).catch(() => void 0);
   }
-  const { installGitHooks: installGitHooks2 } = await import("./git-hooks-6ROMVVPI.js");
+  const { installGitHooks: installGitHooks2 } = await import("./git-hooks-KQ3BN2VC.js");
   await installGitHooks2(dir).catch(() => void 0);
   return true;
 }
@@ -23793,6 +23793,9 @@ function isStoredTurn(value) {
   const turn = value;
   return typeof turn.uuid === "string" && turn.uuid !== "" && typeof turn.at === "string" && typeof turn.text === "string" && Array.isArray(turn.replies) && turn.replies.every((reply) => typeof reply === "string") && turn.tools !== null && typeof turn.tools === "object";
 }
+function answerSize(turn) {
+  return turn.replies.reduce((sum, reply) => sum + reply.length, 0) + JSON.stringify(turn.tools).length;
+}
 async function readConversationStore(root, sessionId) {
   let text;
   try {
@@ -23819,16 +23822,28 @@ async function readConversationStore(root, sessionId) {
       order.push(value.uuid);
       continue;
     }
-    if (prev.hash === void 0 && value.hash !== void 0) byUuid.set(value.uuid, value);
+    const fuller = answerSize(value) > answerSize(prev) ? value : prev;
+    const hash2 = prev.hash ?? value.hash;
+    byUuid.set(value.uuid, {
+      ...prev,
+      ...hash2 === void 0 ? {} : { hash: hash2 },
+      replies: fuller.replies,
+      tools: fuller.tools
+    });
   }
   return order.map((uuid3) => byUuid.get(uuid3));
 }
 async function appendConversationTurns(root, sessionId, turns) {
-  const known = new Set((await readConversationStore(root, sessionId)).map((turn) => turn.uuid));
+  const stored = new Map(
+    (await readConversationStore(root, sessionId)).map((turn) => [turn.uuid, turn])
+  );
+  const seen = /* @__PURE__ */ new Set();
   const fresh = [];
   for (const turn of turns) {
-    if (turn.uuid === void 0 || known.has(turn.uuid)) continue;
-    known.add(turn.uuid);
+    if (turn.uuid === void 0 || seen.has(turn.uuid)) continue;
+    seen.add(turn.uuid);
+    const held = stored.get(turn.uuid);
+    if (held && answerSize(turn) <= answerSize(held)) continue;
     fresh.push({
       uuid: turn.uuid,
       ...turn.hash === void 0 ? {} : { hash: turn.hash },
@@ -23839,13 +23854,17 @@ async function appendConversationTurns(root, sessionId, turns) {
     });
   }
   if (fresh.length === 0) return 0;
-  const { value } = redactDeep(fresh);
+  const value = redactDeep(fresh).value.filter((turn) => {
+    const held = stored.get(turn.uuid);
+    return !held || answerSize(turn) > answerSize(held);
+  });
+  if (value.length === 0) return 0;
   const chunk = `${value.map((turn) => JSON.stringify(turn)).join("\n")}
 `;
   const file2 = projectPaths(root).conversation(sessionId);
   await mkdir4(dirname6(file2), { recursive: true });
   await appendFile(file2, gzipSync(Buffer.from(chunk, "utf8")));
-  return fresh.length;
+  return value.length;
 }
 async function appendConversationHashes(root, sessionId, hashes) {
   if (hashes.size === 0) return 0;
@@ -24044,6 +24063,9 @@ var exec4 = promisify3(execFile3);
 var THOUGHT_TRAILER = "Thought";
 var THOUGHT_VALUE = /^h[0-9a-f]{12}$/;
 var FULL_HASH = /^[0-9a-f]{40}$/;
+var THOUGHT_LINE = new RegExp(`^[ \\t]*${THOUGHT_TRAILER}:[ \\t]*(h[0-9a-f]{12})[ \\t]*$`, "gim");
+var COMMIT_MARK = "
";
+var LOG_MAX_BUFFER = 256 * 1024 * 1024;
 async function readable(path2) {
   return access2(path2).then(
     () => true,
@@ -24070,10 +24092,23 @@ async function writeTrailer(messageFile, value) {
     messagePath(messageFile)
   ]);
 }
+async function replayingCommits(dir, env) {
+  let gitDir;
+  try {
+    const { stdout } = await exec4("git", ["-C", dir, "rev-parse", "--absolute-git-dir"], { env });
+    gitDir = String(stdout).trim();
+  } catch {
+    return false;
+  }
+  const states = ["rebase-merge", "rebase-apply", "CHERRY_PICK_HEAD"];
+  const found = await Promise.all(states.map((state) => readable(resolve3(gitDir, state))));
+  return found.includes(true);
+}
 async function addThoughtTrailer(opts) {
   const env = opts.env ?? process.env;
   if (captureDisabled(env)) return false;
   if (opts.source === "merge" || opts.source === "squash") return false;
+  if (await replayingCommits(opts.dir, env)) return false;
   const agent = defaultAgent();
   const named = (env[agent.commitSessionEnv] ?? "").trim();
   if (named !== "") {
@@ -24101,17 +24136,14 @@ async function addThoughtTrailer(opts) {
 }
 function parseThoughtTrailers(stdout) {
   const out = /* @__PURE__ */ new Map();
-  for (const line of stdout.split("\n")) {
-    const separator = line.indexOf("\0");
+  for (const record2 of stdout.split(COMMIT_MARK)) {
+    const separator = record2.indexOf("\0");
     if (separator === -1) continue;
-    const commit = line.slice(0, separator);
+    const commit = record2.slice(0, separator);
     if (!FULL_HASH.test(commit)) continue;
-    for (const value of line.slice(separator + 1).split(/[,\s]+/)) {
-      if (THOUGHT_VALUE.test(value)) {
-        out.set(commit, value);
-        break;
-      }
-    }
+    const body = record2.slice(separator + 1);
+    const thoughts = [...body.matchAll(THOUGHT_LINE)].map((match) => match[1]);
+    if (thoughts.length > 0) out.set(commit, [...new Set(thoughts)]);
   }
   return out;
 }
@@ -24122,15 +24154,17 @@ async function readThoughtTrailers(root, opts = {}) {
     "-C",
     gitRoot,
     "log",
-    "--format=%H%x00%(trailers:key=Thought,valueonly)",
+    "--format=%x01%H%x00%B",
+    "--extended-regexp",
+    "--regexp-ignore-case",
+    `--grep=^[[:space:]]*${THOUGHT_TRAILER}:`,
     ...opts.since === void 0 ? [] : [`--since=${opts.since}`]
   ];
   try {
-    const { stdout } = await exec4(
-      "git",
-      args,
-      opts.env === void 0 ? void 0 : { env: opts.env }
-    );
+    const { stdout } = await exec4("git", args, {
+      maxBuffer: LOG_MAX_BUFFER,
+      ...opts.env === void 0 ? {} : { env: opts.env }
+    });
     return parseThoughtTrailers(String(stdout));
   } catch {
     return /* @__PURE__ */ new Map();
@@ -24158,19 +24192,21 @@ function earliestSessionStart(sessions) {
 function sameCommit(recorded, commit) {
   return commit.startsWith(recorded) || recorded.startsWith(commit);
 }
-function thoughtOf(recorded, trailers) {
-  for (const [commit, thought] of trailers) {
-    if (sameCommit(recorded, commit)) return thought;
+function thoughtsOf(recorded, trailers) {
+  for (const [commit, thoughts] of trailers) {
+    if (sameCommit(recorded, commit)) return thoughts;
   }
   return void 0;
 }
 function attachThoughtTrailers(sessions, trailers) {
   if (trailers.size === 0) return [...sessions];
   const byThought = /* @__PURE__ */ new Map();
-  for (const [commit, thought] of trailers) {
-    const list = byThought.get(thought);
-    if (list === void 0) byThought.set(thought, [commit]);
-    else if (!list.some((hash2) => sameCommit(hash2, commit))) list.push(commit);
+  for (const [commit, thoughts] of trailers) {
+    for (const thought of thoughts) {
+      const list = byThought.get(thought);
+      if (list === void 0) byThought.set(thought, [commit]);
+      else if (!list.some((hash2) => sameCommit(hash2, commit))) list.push(commit);
+    }
   }
   return sessions.map((session) => {
     let changed = false;
@@ -24178,8 +24214,8 @@ function attachThoughtTrailers(sessions, trailers) {
       if (node2.kind !== "message") return node2;
       const current = node2.commits ?? [];
       const kept = current.filter((hash2) => {
-        const thought = thoughtOf(hash2, trailers);
-        return thought === void 0 || thought === node2.id;
+        const thoughts = thoughtsOf(hash2, trailers);
+        return thoughts === void 0 || thoughts.includes(node2.id);
       });
       const claimed = (byThought.get(node2.id) ?? []).filter(
         (commit) => !kept.some((hash2) => sameCommit(hash2, commit))
@@ -24500,9 +24536,8 @@ function embedViewModel(template, model) {
   if (!template.includes(EMPTY_DATA_ELEMENT)) {
     throw new Error(`the template has no empty <script id="${DATA_ELEMENT_ID}"> element`);
   }
-  const data = `<script id="${DATA_ELEMENT_ID}" type="application/json">${escapeForScript(
-    JSON.stringify(model)
-  )}</script>`;
+  const json2 = JSON.stringify(model, null, 1).replace(/\n +/g, "\n");
+  const data = `<script id="${DATA_ELEMENT_ID}" type="application/json">${escapeForScript(json2)}</script>`;
   return template.replace(EMPTY_DATA_ELEMENT, () => data);
 }
 
@@ -25090,7 +25125,9 @@ async function show(opts) {
         `  ${candidate.sessionId} \xB7 ${candidate.label}${candidate.id === candidate.label ? "" : ` (${candidate.id})`}  ${candidate.title}`
       );
     }
-    throw new CliError(`"${opts.ref}" is ambiguous; use a longer prefix`);
+    throw new CliError(
+      COMMIT_REF.test(opts.ref) ? `commit ${opts.ref} comes from several thoughts; open one by its message hash` : `"${opts.ref}" is ambiguous; use a longer prefix`
+    );
   }
   const { session, messages, message } = result.hit;
   const sessionId = session.sessionId;
@@ -25559,7 +25596,7 @@ async function onSessionEnd(ctx) {
 // package.json
 var package_default = {
   name: "@cogit/cli",
-  version: "0.30.0",
+  version: "0.31.1",
   description: "Git remembers what changed. cogit remembers why.",
   license: "MIT",
   keywords: [