@andre-barbosa/opencode-commit 0.1.1 → 0.1.4

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 André Barbosa
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 André Barbosa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,127 +1,137 @@
-# @andre-barbosa/opencode-commit
-
-OpenCode plugin that generates **Conventional Commits** messages from staged git changes using a dedicated sub-agent on a model you choose.
-
-Run `/commit` in the OpenCode TUI to get a suggested message like `feat(auth): add oauth login flow` — copy it and commit manually.
-
-## Features
-
-- `/commit` slash command (display only, no auto-commit)
-- Dedicated hidden `commit-writer` sub-agent with its own model
-- Conventional Commits format enforced (`feat(scope): ...`, `fix(scope): ...`, etc.)
-- Optional hint: `/commit emphasize breaking API change`
-- Uses staged diff, branch name, and recent commit subjects for context
-
-## Requirements
-
-- [OpenCode](https://opencode.ai/) with plugin support
-- A git repository with staged changes
-
-## Installation
-
-### 1. Copy agent and command templates
-
-```bash
-mkdir -p .opencode/agents .opencode/commands
-cp agents/commit-writer.md .opencode/agents/commit-writer.md
-cp commands/commit.md .opencode/commands/commit.md
-```
-
-### 2. Configure the plugin
-
-**Local development** (this repo):
-
-```json
-{
-  "$schema": "https://opencode.ai/config.json",
-  "plugin": [
-    [
-      "file:///C:/absolute/path/to/opencode-commit/src/index.ts",
-      {
-        "agent": "commit-writer",
-        "maxDiffChars": 12000
-      }
-    ]
-  ],
-  "agent": {
-    "commit-writer": {
-      "model": "opencode-go/deepseek-v4-flash"
-    }
-  }
-}
-```
-
-**From npm:**
-
-```json
-{
-  "plugin": [
-    ["@andre-barbosa/opencode-commit", { "agent": "commit-writer" }]
-  ],
-  "agent": {
-    "commit-writer": {
-      "model": "opencode-go/deepseek-v4-flash"
-    }
-  }
-}
-```
-
-See [opencode.example.json](opencode.example.json) for a full example.
-
-### 3. Set your model
-
-Edit the model on the `commit-writer` agent in `opencode.json` or in `.opencode/agents/commit-writer.md`:
-
-```yaml
-model: opencode-go/deepseek-v4-flash
-```
-
-Run `opencode models` to list available models.
-
-## Usage
-
-1. Stage your changes: `git add ...`
-2. Open OpenCode in the project
-3. Run `/commit`
-4. Copy the suggested message and commit: `git commit -m "feat(scope): ..."`
-
-Optional extra instruction:
-
-```text
-/commit focus on test coverage improvements
-```
-
-## Plugin options
-
-When loading the plugin as a tuple `[name, options]`:
-
-| Option | Default | Description |
-| --- | --- | --- |
-| `agent` | `commit-writer` | Sub-agent name to invoke |
-| `maxDiffChars` | `12000` | Max staged diff characters sent to the sub-agent |
-
-## Commit message format
-
-Generated messages follow [Conventional Commits](https://www.conventionalcommits.org/):
-
-```
-type(scope): short imperative description
-
-- optional bullet body
-```
-
-Allowed types: `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `build`, `ci`, `chore`.
-
-## Project layout
-
-```
-opencode-commit/
-├── src/                  # plugin source
-├── agents/               # commit-writer sub-agent template
-├── commands/             # /commit command stub
-└── opencode.example.json
-```
-
-## License
-
-MIT
+# @andre-barbosa/opencode-commit
+
+OpenCode plugin that generates **Conventional Commits** messages or split commit plans from uncommitted git changes using a model you choose.
+
+Run `/commit` in the OpenCode TUI to get a suggested message like `feat(auth): add oauth login flow` — copy it and commit manually.
+
+## Features
+
+- `/commit` slash command (display only, no auto-commit)
+- Split commit planning with `/commit split` and `/commit split <folder...>`
+- Dedicated model for commit message generation
+- Conventional Commits format enforced (`feat(scope): ...`, `fix(scope): ...`, etc.)
+- Optional hint: `/commit emphasize breaking API change`
+- Uses staged diffs, unstaged diffs, non-ignored untracked filenames, branch name, and recent commit subjects for context
+
+## Requirements
+
+- [OpenCode](https://opencode.ai/) with plugin support
+- A git repository with uncommitted changes
+
+## Installation
+
+### Configure the plugin
+
+**Local development** (this repo):
+
+Build the plugin first:
+
+```bash
+npm run build
+```
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    [
+      "file:///C:/absolute/path/to/opencode-commit/dist/index.js",
+      {
+        "model": "opencode-go/deepseek-v4-flash",
+        "maxDiffChars": 12000
+      }
+    ]
+  ]
+}
+```
+
+**From npm:**
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    ["@andre-barbosa/opencode-commit", { "model": "opencode-go/deepseek-v4-flash" }]
+  ]
+}
+```
+
+See [opencode.example.json](opencode.example.json) for a full example.
+
+Run `opencode models` to list available models.
+Restart OpenCode after editing config.
+When testing local changes, run `npm run build` again before restarting OpenCode.
+
+## Usage
+
+1. Make changes in a git repository. Staging is optional.
+2. Open OpenCode in the project.
+3. Run `/commit`.
+4. Copy the suggested message and commit: `git commit -m "feat(scope): ..."`.
+
+Optional extra instruction:
+
+```text
+/commit focus on test coverage improvements
+```
+
+Split commit planning:
+
+```text
+/commit split
+```
+
+This suggests one commit message per changed top-level folder. Files in the repo root are grouped under `root`.
+
+```text
+/commit split apps/web packages/api
+```
+
+This suggests one commit message for each requested folder with changes under that path.
+
+Split mode only suggests a plan. It does not stage files and does not create commits.
+
+## Plugin options
+
+When loading the plugin as a tuple `[name, options]`:
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `model` | required | Model to use in `provider/model-id` format |
+| `maxDiffChars` | `12000` | Max tracked diff characters sent across staged and unstaged diffs |
+
+## Change scope
+
+`/commit` analyzes:
+
+- Staged tracked changes from `git diff --staged`
+- Unstaged tracked changes from `git diff`
+- Changed-file metadata from `git diff --name-status`
+- Non-ignored untracked filenames from `git ls-files --others --exclude-standard`
+
+It does not read untracked file contents and does not ask Git for ignored files.
+
+## Commit message format
+
+Generated messages follow [Conventional Commits](https://www.conventionalcommits.org/):
+
+```
+type(scope): short imperative description
+
+- optional bullet body
+```
+
+Allowed types: `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `build`, `ci`, `chore`.
+
+## Project layout
+
+```
+opencode-commit/
+├── src/                  # plugin source
+├── commands/             # optional /commit command stub
+└── opencode.example.json
+```
+
+## License
+
+MIT

package/dist/generate.d.ts

@@ -0,0 +1,18 @@
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+import type { CommitGroup, CommitRequest, ModelRef } from "./types.js";
+import type { GitContext } from "./types.js";
+type Client = ReturnType<typeof createOpencodeClient>;
+export declare function formatModelRef(model?: ModelRef): string;
+export declare function generateCommitMessage(input: {
+    client: Client;
+    parentSessionID: string;
+    model: ModelRef;
+    context: GitContext;
+    request: CommitRequest;
+    groups?: CommitGroup[];
+}): Promise<{
+    content: string;
+    childSessionID: string;
+    modelLabel: string;
+}>;
+export {};

package/dist/generate.js

@@ -0,0 +1,58 @@
+import { buildCommitPrompt, COMMIT_SYSTEM_PROMPT, stripCodeFences, } from "./prompt.js";
+const COMMIT_AGENT = "plan";
+function extractText(parts) {
+    return parts
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("")
+        .trim();
+}
+export function formatModelRef(model) {
+    if (!model)
+        return "default";
+    return `${model.providerID}/${model.modelID}`;
+}
+async function createChildSession(client, parentSessionID) {
+    const { data: session, error } = await client.session.create({
+        body: {
+            title: "Commit message",
+            parentID: parentSessionID,
+        },
+    });
+    if (error || !session?.id) {
+        throw new Error(`Failed to create child session: ${String(error)}`);
+    }
+    return session.id;
+}
+export async function generateCommitMessage(input) {
+    const childSessionID = await createChildSession(input.client, input.parentSessionID);
+    const prompt = buildCommitPrompt({
+        context: input.context,
+        request: input.request,
+        groups: input.groups,
+    });
+    const body = {
+        agent: COMMIT_AGENT,
+        model: input.model,
+        system: COMMIT_SYSTEM_PROMPT,
+        parts: [{ type: "text", text: prompt }],
+    };
+    const { data: result, error } = await input.client.session.prompt({
+        path: { id: childSessionID },
+        body,
+    });
+    if (error) {
+        throw new Error(`Commit prompt failed: ${String(error)}`);
+    }
+    const parts = result
+        ?.parts ?? [];
+    const rawText = extractText(parts);
+    if (!rawText) {
+        throw new Error(`Commit model returned no text. Child session: ${childSessionID}`);
+    }
+    return {
+        content: stripCodeFences(rawText),
+        childSessionID,
+        modelLabel: formatModelRef(input.model),
+    };
+}

package/dist/git.d.ts

@@ -0,0 +1,6 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { GitContext } from "./types.js";
+type Shell = PluginInput["$"];
+export declare function isGitRepo($: Shell, worktree: string): Promise<boolean>;
+export declare function gatherGitContext($: Shell, worktree: string, maxDiffChars: number): Promise<GitContext>;
+export {};

package/dist/git.js

@@ -0,0 +1,98 @@
+async function readGitOutput($, worktree, run) {
+    const result = await run($);
+    if (result.exitCode !== 0) {
+        return "";
+    }
+    return result.stdout?.toString().trim() ?? "";
+}
+export async function isGitRepo($, worktree) {
+    const result = await $ `git rev-parse --git-dir`.cwd(worktree).quiet().nothrow();
+    return result.exitCode === 0;
+}
+function truncateDiff(diff, maxChars, label) {
+    if (diff.length <= maxChars)
+        return diff;
+    return `${diff.slice(0, maxChars)}\n\n[${label} diff truncated at ${maxChars} characters]`;
+}
+function splitDiffs(input) {
+    if (!input.staged || !input.unstaged) {
+        return {
+            staged: truncateDiff(input.staged, input.maxDiffChars, "staged"),
+            unstaged: truncateDiff(input.unstaged, input.maxDiffChars, "unstaged"),
+        };
+    }
+    const half = Math.floor(input.maxDiffChars / 2);
+    let stagedLimit = Math.min(input.staged.length, half);
+    let unstagedLimit = Math.min(input.unstaged.length, input.maxDiffChars - stagedLimit);
+    stagedLimit = Math.min(input.staged.length, input.maxDiffChars - unstagedLimit);
+    return {
+        staged: truncateDiff(input.staged, stagedLimit, "staged"),
+        unstaged: truncateDiff(input.unstaged, unstagedLimit, "unstaged"),
+    };
+}
+function parseNameStatus(output, source) {
+    if (!output)
+        return [];
+    return output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const [status, ...paths] = line.split("\t");
+        return {
+            path: paths[paths.length - 1] ?? "",
+            status: status ?? "?",
+            source,
+        };
+    })
+        .filter((file) => file.path.length > 0);
+}
+export async function gatherGitContext($, worktree, maxDiffChars) {
+    const branch = (await readGitOutput($, worktree, ($) => $ `git symbolic-ref --quiet --short HEAD`.cwd(worktree).quiet().nothrow())) ||
+        (await readGitOutput($, worktree, ($) => $ `git rev-parse --short HEAD`.cwd(worktree).quiet().nothrow())) ||
+        "unknown";
+    const stagedStat = await readGitOutput($, worktree, ($) => $ `git diff --staged --stat`.cwd(worktree).quiet().nothrow());
+    const rawStagedDiff = await readGitOutput($, worktree, ($) => $ `git diff --staged`.cwd(worktree).quiet().nothrow());
+    const stagedNameStatus = await readGitOutput($, worktree, ($) => $ `git diff --staged --name-status`.cwd(worktree).quiet().nothrow());
+    const unstagedStat = await readGitOutput($, worktree, ($) => $ `git diff --stat`.cwd(worktree).quiet().nothrow());
+    const rawUnstagedDiff = await readGitOutput($, worktree, ($) => $ `git diff`.cwd(worktree).quiet().nothrow());
+    const unstagedNameStatus = await readGitOutput($, worktree, ($) => $ `git diff --name-status`.cwd(worktree).quiet().nothrow());
+    const untrackedOutput = await readGitOutput($, worktree, ($) => $ `git ls-files --others --exclude-standard`.cwd(worktree).quiet().nothrow());
+    const untrackedFiles = untrackedOutput
+        ? untrackedOutput.split("\n").map((line) => line.trim()).filter(Boolean)
+        : [];
+    const diffs = splitDiffs({
+        staged: rawStagedDiff,
+        unstaged: rawUnstagedDiff,
+        maxDiffChars,
+    });
+    const changedFiles = [
+        ...parseNameStatus(stagedNameStatus, "staged"),
+        ...parseNameStatus(unstagedNameStatus, "unstaged"),
+        ...untrackedFiles.map((path) => ({
+            path,
+            status: "A",
+            source: "untracked",
+        })),
+    ];
+    const logOutput = await readGitOutput($, worktree, ($) => $ `git log -5 --pretty=format:%s`.cwd(worktree).quiet().nothrow());
+    const recentCommits = logOutput
+        ? logOutput.split("\n").map((line) => line.trim()).filter(Boolean)
+        : [];
+    const hasUncommittedChanges = stagedStat.length > 0 ||
+        rawStagedDiff.length > 0 ||
+        unstagedStat.length > 0 ||
+        rawUnstagedDiff.length > 0 ||
+        untrackedFiles.length > 0;
+    return {
+        branch,
+        stagedStat,
+        stagedDiff: diffs.staged,
+        unstagedStat,
+        unstagedDiff: diffs.unstaged,
+        changedFiles,
+        untrackedFiles,
+        recentCommits,
+        hasUncommittedChanges,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const OpenCodeCommitPlugin: Plugin;
+export default OpenCodeCommitPlugin;

package/dist/index.js

@@ -0,0 +1,155 @@
+import { gatherGitContext, isGitRepo } from "./git.js";
+import { generateCommitMessage } from "./generate.js";
+import { buildCommitGroups, parseCommitRequest, parseModelRef, resolveConfig, } from "./types.js";
+const COMMAND_NAME = "commit";
+const COMMAND_DESCRIPTION = "Generate a commit message or split commit plan from uncommitted changes";
+const COMMAND_TEMPLATE = "Handled by the opencode-commit plugin.";
+const SKIP_ERROR = "skip";
+function textPart(text) {
+    return { type: "text", text };
+}
+function formatOutput(input) {
+    if (input.request.mode === "split") {
+        const missingFolders = input.missingFolders ?? [];
+        const missingBlock = missingFolders.length > 0
+            ? [
+                `No changes found for requested folder(s): ${formatFolderList(missingFolders)}.`,
+                "",
+            ]
+            : [];
+        return [
+            "## Suggested commit plan",
+            "",
+            ...missingBlock,
+            input.content,
+            "",
+            `Model: \`${input.modelLabel}\` · Child session: \`${input.childSessionID}\``,
+            "",
+            "Stage the listed files for each commit, then run `git commit` with the suggested message.",
+        ].join("\n");
+    }
+    return [
+        "## Suggested commit message",
+        "",
+        "```",
+        input.content,
+        "```",
+        "",
+        `Model: \`${input.modelLabel}\` · Child session: \`${input.childSessionID}\``,
+        "",
+        "Copy the message above and run `git commit` when ready.",
+    ].join("\n");
+}
+function formatFolderList(folders) {
+    return folders.map((folder) => `\`${folder}\``).join(", ");
+}
+const skipCommand = () => {
+    throw new Error(SKIP_ERROR);
+};
+export const OpenCodeCommitPlugin = async ({ client, $, worktree }, options) => {
+    const config = resolveConfig(options);
+    const log = async (level, message, extra) => {
+        await client.app
+            .log({
+            body: {
+                service: "opencode-commit",
+                level,
+                message,
+                extra,
+            },
+        })
+            .catch(() => { });
+    };
+    return {
+        config: async (cfg) => {
+            cfg.command ??= {};
+            cfg.command[COMMAND_NAME] = {
+                description: COMMAND_DESCRIPTION,
+                template: COMMAND_TEMPLATE,
+                subtask: true,
+            };
+            if (config.model) {
+                cfg.command[COMMAND_NAME].model = config.model;
+            }
+        },
+        "command.execute.before": async (input, output) => {
+            if (input.command !== COMMAND_NAME)
+                return;
+            try {
+                if (!config.model) {
+                    output.parts = [
+                        textPart([
+                            "No commit model configured.",
+                            "",
+                            "Add a `model` option to the opencode-commit plugin config, for example:",
+                            "`[\"@andre-barbosa/opencode-commit\", { \"model\": \"opencode-go/deepseek-v4-flash\" }]`",
+                        ].join("\n")),
+                    ];
+                    return skipCommand();
+                }
+                const model = parseModelRef(config.model);
+                const request = parseCommitRequest(input.arguments);
+                if (!(await isGitRepo($, worktree))) {
+                    output.parts = [
+                        textPart("Not a git repository. Run `/commit` from inside a git worktree."),
+                    ];
+                    return skipCommand();
+                }
+                const context = await gatherGitContext($, worktree, config.maxDiffChars);
+                if (!context.hasUncommittedChanges) {
+                    output.parts = [
+                        textPart("No uncommitted changes found. Make changes and run `/commit` again."),
+                    ];
+                    return skipCommand();
+                }
+                let groups;
+                let missingFolders = [];
+                if (request.mode === "split") {
+                    const grouped = buildCommitGroups(context.changedFiles, request.folders);
+                    groups = grouped.groups;
+                    missingFolders = grouped.missingFolders;
+                    if (groups.length === 0) {
+                        const target = request.folders.length > 0
+                            ? `requested folder(s): ${formatFolderList(request.folders)}`
+                            : "changed folders";
+                        output.parts = [textPart(`No changes found for ${target}.`)];
+                        return skipCommand();
+                    }
+                }
+                await log("info", "Generating commit message", {
+                    model: config.model,
+                    mode: request.mode,
+                    folders: request.mode === "split" ? request.folders : undefined,
+                    branch: context.branch,
+                    sessionID: input.sessionID,
+                });
+                const result = await generateCommitMessage({
+                    client,
+                    parentSessionID: input.sessionID,
+                    model,
+                    context,
+                    request,
+                    groups,
+                });
+                output.parts = [
+                    textPart(formatOutput({ ...result, request, missingFolders })),
+                ];
+                return skipCommand();
+            }
+            catch (error) {
+                if (error instanceof Error && error.message === SKIP_ERROR) {
+                    throw error;
+                }
+                await log("error", "Commit message generation failed", {
+                    error: String(error),
+                    sessionID: input.sessionID,
+                });
+                output.parts = [
+                    textPart(`Failed to generate commit message: ${String(error)}`),
+                ];
+                return skipCommand();
+            }
+        },
+    };
+};
+export default OpenCodeCommitPlugin;

package/dist/prompt.d.ts

@@ -0,0 +1,8 @@
+import type { CommitGroup, CommitRequest, GitContext } from "./types.js";
+export declare const COMMIT_SYSTEM_PROMPT: string;
+export declare function buildCommitPrompt(input: {
+    context: GitContext;
+    request: CommitRequest;
+    groups?: CommitGroup[];
+}): string;
+export declare function stripCodeFences(text: string): string;