@reachdevel/opencode-git-commit 2.0.1 → 2.0.3

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm version](https://badge.fury.io/js/@reachdevel%2Fopencode-git-commit.svg)](https://badge.fury.io/js/@reachdevel%2Fopencode-git-commit)
 
-An OpenCode plugin that automatically commits changes when your coding session becomes idle.
+An OpenCode plugin that automatically commits changes when your coding session ends.
 
 Requires OpenCode v2 (uses the `@opencode/plugin` v2 plugin API).
 
@@ -10,19 +10,23 @@ Requires OpenCode v2 (uses the `@opencode/plugin` v2 plugin API).
 
 This plugin monitors your OpenCode session and automatically creates git commits when:
 
-1. The session goes idle (no active operations)
+1. The session finishes a run (succeeded, failed, or interrupted)
 2. There are uncommitted changes in your working directory
 3. A git repository exists (or can be initialized)
 
-The commit message is intelligently extracted from the last assistant message in your conversation, making commits contextual and meaningful.
+Commit messages are derived from the staged diff itself, so they are deterministic and cost nothing to produce.
 
 ## Features
 
-- **Automatic Commits** - Commits changes whenever your session becomes idle
-- **Smart Commit Messages** - Extracts context from your last conversation to create meaningful commit messages
+- **Automatic Commits** - Commits as soon as a session run reaches a terminal state
+- **Diff-Derived Messages** - Build Conventional Commit subjects from the staged diff, with no model call and no guessing from conversation prose
+- **Type Inference** - Picks `feat`, `fix`, `test`, `docs`, or `chore` from the change shape and the paths involved
+- **Representative File** - Leads with the most meaningful path, ranking source over tests over docs over build output
 - **Auto-initialize** - Automatically initializes a git repository if one doesn't exist
 - **Respects .gitignore** - Git handles ignored files automatically
-- **Conventional Commits** - Uses `feat:` or `fix:` prefixes based on message content
+- **Identity Fallback** - Commits with a bot identity only when the machine has no `user.email` configured
+- **Bypasses Hooks** - Uses `--no-verify` so auto-commits never block on hooks
+- **Serializes Per Directory** - Queues commits per working directory so concurrent sessions can't collide
 
 ## Installation
 
@@ -59,11 +63,40 @@ Then add to `opencode.json`:
 
 ## How It Works
 
-1. When a `session.idle` event is triggered, the plugin checks for git changes
-2. If changes exist, it fetches the last assistant message from your session
-3. Extracts the first line, sanitizes it, and uses it as the commit message
-4. Stages all changes with `git add .`
-5. Commits with `--no-verify` to bypass hooks
+1. A terminal session event (`session.execution.succeeded`, `.failed`, or `.interrupted`) arrives
+2. `git status --porcelain` checks for uncommitted changes; if the directory isn't a repository yet, one is initialized
+3. Everything is staged with `git add .`, so new files are included in the description
+4. `git diff --cached --name-status` and `--numstat` describe the staged change set
+5. Paths and line deltas determine the Conventional Commit type and the file list
+6. The commit is created with `--no-verify`
+
+### Message Format
+
+Subjects follow Conventional Commits and are capped at 72 characters:
+
+```
+<type>: <verb> <files>
+```
+
+| Situation | Example |
+| --- | --- |
+| Only files added | `feat: add src/brand-new.ts` |
+| Mixed edits | `fix: update src/a.ts and README.md` |
+| Only tests touched | `test: update src/a.test.ts` |
+| Only docs touched | `docs: update README.md` |
+| Only deletions | `chore: remove src/gone.ts` |
+| Lockfiles / `dist/` / CI config only | `chore: update dist/index.js` |
+| More than two files | `fix: update src/one.ts and 5 more files` |
+
+Type inference is purely structural, which keeps it predictable:
+
+- `test` - every changed path looks like a test (`*.test.*`, `__tests__/`, `spec/`)
+- `docs` - every changed path looks like documentation (`*.md`, `docs/`)
+- `chore` - build output, lockfiles, CI config, or deletions only
+- `feat` - every changed path is newly added
+- `fix` - anything else, meaning existing files were modified
+
+Because messages come from the diff rather than the model's last sentence, they never inherit stray markup, backticks, or file paths mangled by sanitizing. If diff parsing fails for any reason, the plugin falls back to `chore: automated update` and logs the reason at debug level instead of failing the commit.
 
 ## Configuration
 
@@ -77,9 +110,13 @@ To disable it for a project, remove its id from the plugin list:
 }
 ```
 
+## Notes
+
+Messages describe *what changed*, not *why*. They are structural by design: deterministic, free, and unable to fail. If you want prose messages, layer a model call on top of this rather than replacing it.
+
 ## Requirements
 
-- OpenCode with plugin support
+- OpenCode v2 or later with plugin support
 - Node.js (for running the plugin)
 - Git installed on your system
 

package/dist/index.js

@@ -31,21 +31,105 @@ async function isRepository(cwd) {
         return false;
     }
 }
-function commitMessageFrom(messages) {
-    const assistant = [...messages].reverse().find((m) => m.type === "assistant");
-    const text = assistant?.content?.find((part) => part.type === "text")?.text;
-    if (!text)
-        return undefined;
-    const sanitized = text
-        .split("\n")[0]
-        .replace(/[^a-zA-Z0-9 ]/g, "")
-        .substring(0, 50)
-        .trim();
-    return sanitized || undefined;
+const TEST_RE = /(^|\/)(tests?|__tests__|spec)\/|\.(test|spec)\.[cm]?[jt]sx?$/;
+const DOC_RE = /(^|\/)(docs?)\/|\.(md|mdx|rst)$|^readme/i;
+const BUILD_RE = /(^|\/)(dist|build|out|coverage|\.next|target|vendor)\/|(^|\/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|.*\.lock|\.DS_Store|tsconfig.*\.json|.*\.config\.[cm]?[jt]s)$|^\.github\//;
+const SOURCE_RE = /\.(cm?js|[jt]sx?|py|rs|go|rb|java|kt|swift|c|h|cc|cpp|hpp|cs|php|svelte|vue|sh|bash|sql|html|css|scss|astro)$/;
+/** Ranking used to pick the most representative file when several changed. */
+function rank(file) {
+    if (BUILD_RE.test(file))
+        return 3;
+    if (DOC_RE.test(file))
+        return 2;
+    if (TEST_RE.test(file))
+        return 1;
+    return 0;
+}
+function isAll(changes, pattern) {
+    return changes.every((c) => pattern.test(c.file));
+}
+/** Parse `git diff --cached --name-status`, e.g. "M\tsrc/a.ts" or "R100\told\tnew". */
+function parseNameStatus(output) {
+    const entries = [];
+    for (const line of output.split("\n")) {
+        if (!line.trim())
+            continue;
+        const fields = line.split("\t");
+        entries.push({ status: fields[0] ?? "", file: fields[fields.length - 1] ?? "" });
+    }
+    return entries;
+}
+/** Parse `git diff --cached --numstat`, e.g. "6\t1\tsrc/a.ts". */
+function parseNumstat(output) {
+    const stats = new Map();
+    for (const line of output.split("\n")) {
+        if (!line.trim())
+            continue;
+        const [added, deleted, ...rest] = line.split("\t");
+        const file = rest[rest.length - 1];
+        if (!file)
+            continue;
+        stats.set(file, {
+            added: Number.isFinite(+added) ? +added : 0,
+            deleted: Number.isFinite(+deleted) ? +deleted : 0,
+        });
+    }
+    return stats;
+}
+async function stagedChanges(cwd) {
+    const [nameStatus, numstat] = await Promise.all([
+        git(cwd, ["diff", "--cached", "--name-status"]),
+        git(cwd, ["diff", "--cached", "--numstat"]),
+    ]);
+    const stats = parseNumstat(numstat);
+    return parseNameStatus(nameStatus).map(({ status, file }) => ({
+        status,
+        file,
+        added: stats.get(file)?.added ?? 0,
+        deleted: stats.get(file)?.deleted ?? 0,
+    }));
+}
+/** Map the change set onto a Conventional Commits type. */
+function classify(changes) {
+    const allAdded = changes.every((c) => c.status.startsWith("A"));
+    const allDeleted = changes.every((c) => c.status.startsWith("D"));
+    if (isAll(changes, TEST_RE))
+        return "test";
+    if (isAll(changes, DOC_RE))
+        return "docs";
+    if (isAll(changes, BUILD_RE))
+        return "chore";
+    if (allDeleted)
+        return "chore";
+    if (allAdded)
+        return "feat";
+    return "fix";
 }
-function buildCommitMessage(text) {
-    const type = text.toLowerCase().includes("fix") ? "fix" : "feat";
-    return `${type}: ${text}`;
+function describeFiles(files) {
+    const [first, second] = files;
+    if (files.length === 1)
+        return first;
+    if (files.length === 2)
+        return `${first} and ${second}`;
+    // "and N more files" counts everything beyond the first, not beyond what we kept.
+    return `${first} and ${files.length - 1} more files`;
+}
+/** Build a commit subject from the staged diff alone - no model call, no prose guessing. */
+async function commitMessageFromDiff(cwd) {
+    const changes = await stagedChanges(cwd);
+    if (!changes.length)
+        return undefined;
+    const type = classify(changes);
+    const allDeleted = changes.every((c) => c.status.startsWith("D"));
+    // Lead with the most representative path and keep the subject readable.
+    const files = changes
+        .slice()
+        .sort((a, b) => rank(a.file) - rank(b.file) || a.file.length - b.file.length)
+        .map((c) => c.file);
+    const verb = allDeleted ? "remove" : type === "feat" ? "add" : "update";
+    const subject = `${type}: ${verb} ${describeFiles(files)}`;
+    const message = subject.length > 72 ? `${subject.slice(0, 69).trimEnd()}...` : subject;
+    return message.replace(/[\r\n]/g, " ");
 }
 const GitAutocommitPlugin = Plugin.define({
     id: "git-autocommit",
@@ -53,7 +137,7 @@ const GitAutocommitPlugin = Plugin.define({
         log("info", `Plugin initialized for ${ctx.location.directory}`);
         const controller = new AbortController();
         const pending = new Map();
-        const run = (directory, sessionID) => {
+        const run = (directory) => {
             const previous = pending.get(directory) ?? Promise.resolve();
             const next = previous.then(async () => {
                 const cwd = directory;
@@ -67,11 +151,18 @@ const GitAutocommitPlugin = Plugin.define({
                     log("debug", "No changes detected");
                     return;
                 }
-                const messages = await ctx.session.context({ sessionID });
-                const text = commitMessageFrom(messages) ?? "automated update";
-                const message = buildCommitMessage(text);
-                // Stage and commit (git respects .gitignore by default)
+                // Stage first so the diff describes everything, including brand new files
                 await git(cwd, ["add", "."]);
+                // Derive the message from the staged diff itself: deterministic, local, never garbled
+                let message;
+                try {
+                    message = await commitMessageFromDiff(cwd);
+                }
+                catch (err) {
+                    log("debug", `Falling back to generic message: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                if (!message)
+                    message = "chore: automated update";
                 // Fall back to a bot identity only when the machine has no git identity configured
                 const identity = process.env.GIT_AUTHOR_EMAIL || (await git(cwd, ["config", "--get", "user.email"]).catch(() => ""))
                     ? []
@@ -86,6 +177,18 @@ const GitAutocommitPlugin = Plugin.define({
             pending.set(directory, settled);
             return settled;
         };
+        // Only commit on root session endings - skip subagent sessions so their
+        // work isn't committed while the parent task is still in flight.
+        async function isRootSession(sessionID) {
+            try {
+                const info = await ctx.session.get({ sessionID });
+                return !info?.parentID;
+            }
+            catch {
+                // If we can't determine parentage, run to avoid losing commits
+                return true;
+            }
+        }
         void (async () => {
             for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
                 // OpenCode v2 does not publish session.idle to plugins. The terminal
@@ -93,7 +196,12 @@ const GitAutocommitPlugin = Plugin.define({
                 if (!isTerminal(event))
                     continue;
                 log("debug", `Session finished (${event.type})`);
-                await run(ctx.location.directory, event.data.sessionID);
+                // Skip subagent sessions: only root session endings trigger commits
+                if (!(await isRootSession(event.data.sessionID))) {
+                    log("debug", `Skipping subagent session ${event.data.sessionID}`);
+                    continue;
+                }
+                await run(ctx.location.directory);
             }
         })();
         return () => controller.abort();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reachdevel/opencode-git-commit",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Zero-config background git auto-commit plugin for OpenCode CLI",
   "author": "Levent Kurt <reachdevel@gmail.com>",
   "license": "MIT",