@andre-barbosa/opencode-commit 0.1.3 → 0.1.5

package/README.md

@@ -1,12 +1,13 @@
 # @andre-barbosa/opencode-commit
 
-OpenCode plugin that generates **Conventional Commits** messages from uncommitted git changes using a model you choose.
+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`
@@ -23,12 +24,18 @@ Run `/commit` in the OpenCode TUI to get a suggested message like `feat(auth): a
 
 **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/src/index.ts",
+      "file:///C:/absolute/path/to/opencode-commit/dist/index.js",
       {
         "model": "opencode-go/deepseek-v4-flash",
         "maxDiffChars": 12000
@@ -53,6 +60,7 @@ 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
 
@@ -67,6 +75,22 @@ Optional extra instruction:
 /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]`:
@@ -82,6 +106,7 @@ When loading the plugin as a tuple `[name, options]`:
 
 - 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.

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,147 @@
+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.";
+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(", ");
+}
+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,
+            };
+            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;
+                }
+                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;
+                }
+                const context = await gatherGitContext($, worktree, config.maxDiffChars);
+                if (!context.hasUncommittedChanges) {
+                    output.parts = [
+                        textPart("No uncommitted changes found. Make changes and run `/commit` again."),
+                    ];
+                    return;
+                }
+                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;
+                    }
+                }
+                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;
+            }
+            catch (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;
+            }
+        },
+    };
+};
+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;

package/dist/prompt.js

@@ -0,0 +1,118 @@
+export const COMMIT_SYSTEM_PROMPT = [
+    "You are a commit message writer.",
+    "Given git changes and context, produce the requested commit output.",
+    "Output only the requested commit message or commit plan.",
+].join("\n");
+function formatChangedFiles(files) {
+    if (files.length === 0)
+        return "(none)";
+    const filesByPath = new Map();
+    for (const file of files) {
+        filesByPath.set(file.path, [
+            ...(filesByPath.get(file.path) ?? []),
+            `${file.source}:${file.status}`,
+        ]);
+    }
+    return Array.from(filesByPath, ([path, details]) => `- ${path} (${details.join(", ")})`).join("\n");
+}
+function formatCommitGroups(groups) {
+    if (groups.length === 0)
+        return "(none)";
+    return groups
+        .map((group) => `### ${group.name}\n${formatChangedFiles(group.files)}`)
+        .join("\n\n");
+}
+export function buildCommitPrompt(input) {
+    const { context, request } = input;
+    const recentCommitsBlock = context.recentCommits.length > 0
+        ? context.recentCommits.map((subject) => `- ${subject}`).join("\n")
+        : "(none)";
+    const untrackedFilesBlock = context.untrackedFiles.length > 0
+        ? context.untrackedFiles.map((file) => `- ${file}`).join("\n")
+        : "(none)";
+    const changedFilesBlock = formatChangedFiles(context.changedFiles);
+    const hintBlock = request.mode === "single" && request.userHint
+        ? `\nAdditional instruction from the user:\n${request.userHint}\n`
+        : "";
+    const contextBlock = `Branch: ${context.branch}
+
+Recent commit subjects (align scope naming when sensible):
+${recentCommitsBlock}
+
+Changed files:
+${changedFilesBlock}
+
+Staged tracked changes (stat):
+${context.stagedStat || "(empty)"}
+
+Staged tracked diff:
+${context.stagedDiff || "(empty)"}
+
+Unstaged tracked changes (stat):
+${context.unstagedStat || "(empty)"}
+
+Unstaged tracked diff:
+${context.unstagedDiff || "(empty)"}
+
+Untracked files (filenames only, contents not read):
+${untrackedFilesBlock}`;
+    if (request.mode === "split") {
+        return `Write a split commit plan for the uncommitted changes below.
+
+Format rules (Conventional Commits - required):
+- Produce one commit plan item for each split group listed below
+- Do NOT include groups that are not listed below
+- Each message subject MUST use type(scope): description or type: description
+- Allowed types: feat, fix, docs, style, refactor, perf, test, build, ci, chore
+- Scope is optional but preferred when changes are localized (e.g. feat(auth):, fix(api):)
+- Description: imperative mood, lowercase, no trailing period, max 72 chars for the full subject
+- Optional body: blank line after subject, then bullet points; keep lines <= 72 chars
+- Breaking changes: use feat!: or fix!: prefix, or add a BREAKING CHANGE: footer
+- Use staged and unstaged tracked diffs as the source of truth
+- Untracked files are filenames only; do not infer contents that are not shown
+- Output ONLY the commit plan markdown - no top-level title, no commentary, no tool calls
+
+Output format for each group:
+### group-name
+Files:
+- path/to/file
+
+Message:
+fenced text block containing only that group's commit message
+
+Split groups:
+${formatCommitGroups(input.groups ?? [])}
+
+${contextBlock}
+`;
+    }
+    return `Write a git commit message for the uncommitted changes below.
+
+Format rules (Conventional Commits - required):
+- Subject line MUST use type(scope): description or type: description
+- Allowed types: feat, fix, docs, style, refactor, perf, test, build, ci, chore
+- Scope is optional but preferred when changes are localized (e.g. feat(auth):, fix(api):)
+- Description: imperative mood, lowercase, no trailing period, max 72 chars for the full subject
+- Optional body: blank line after subject, then bullet points; keep lines <= 72 chars
+- Breaking changes: use feat!: or fix!: prefix, or add a BREAKING CHANGE: footer
+- Do NOT use free-form subjects like "Update files", "WIP", or "Misc changes"
+- Use staged and unstaged tracked diffs as the source of truth
+- Untracked files are filenames only; do not infer contents that are not shown
+- Output ONLY the commit message text - no code fences, no commentary, no tool calls
+
+Examples:
+feat(auth): add oauth login flow
+
+- add google and github providers
+- store refresh tokens in secure storage
+
+fix(api): handle null response from user endpoint
+${hintBlock}
+${contextBlock}
+`;
+}
+export function stripCodeFences(text) {
+    const trimmed = text.trim();
+    const fenced = trimmed.match(/^```(?:\w*\n)?([\s\S]*?)```$/);
+    return (fenced?.[1] ?? trimmed).trim();
+}

package/dist/types.d.ts

@@ -0,0 +1,48 @@
+export type ModelRef = {
+    providerID: string;
+    modelID: string;
+};
+export type CommitRequest = {
+    mode: "single";
+    userHint?: string;
+} | {
+    mode: "split";
+    folders: string[];
+};
+export type ChangedFileSource = "staged" | "unstaged" | "untracked";
+export type ChangedFile = {
+    path: string;
+    status: string;
+    source: ChangedFileSource;
+};
+export type CommitGroup = {
+    name: string;
+    files: ChangedFile[];
+};
+export type PluginOptions = {
+    model?: string;
+    maxDiffChars?: number;
+};
+export type ResolvedPluginConfig = {
+    model?: string;
+    maxDiffChars: number;
+};
+export declare const DEFAULT_MAX_DIFF_CHARS = 12000;
+export declare function resolveConfig(options?: PluginOptions): ResolvedPluginConfig;
+export declare function parseModelRef(model: string): ModelRef;
+export declare function parseCommitRequest(args?: string): CommitRequest;
+export declare function buildCommitGroups(files: ChangedFile[], folders: string[]): {
+    groups: CommitGroup[];
+    missingFolders: string[];
+};
+export type GitContext = {
+    branch: string;
+    stagedStat: string;
+    stagedDiff: string;
+    unstagedStat: string;
+    unstagedDiff: string;
+    changedFiles: ChangedFile[];
+    untrackedFiles: string[];
+    recentCommits: string[];
+    hasUncommittedChanges: boolean;
+};

package/dist/types.js

@@ -0,0 +1,67 @@
+export const DEFAULT_MAX_DIFF_CHARS = 12_000;
+export function resolveConfig(options) {
+    const model = typeof options?.model === "string" ? options.model.trim() : "";
+    return {
+        model: model || undefined,
+        maxDiffChars: typeof options?.maxDiffChars === "number" && options.maxDiffChars > 0
+            ? Math.floor(options.maxDiffChars)
+            : DEFAULT_MAX_DIFF_CHARS,
+    };
+}
+export function parseModelRef(model) {
+    const separator = model.indexOf("/");
+    if (separator <= 0 || separator === model.length - 1) {
+        throw new Error(`Invalid commit model \`${model}\`. Use the format \`provider/model-id\`.`);
+    }
+    return {
+        providerID: model.slice(0, separator),
+        modelID: model.slice(separator + 1),
+    };
+}
+function normalizeFolder(folder) {
+    return folder
+        .trim()
+        .replace(/^\.\/+/, "")
+        .replace(/^\/+/, "")
+        .replace(/\/+$/, "");
+}
+export function parseCommitRequest(args) {
+    const trimmed = args?.trim() ?? "";
+    if (!trimmed)
+        return { mode: "single" };
+    const tokens = trimmed.split(/\s+/);
+    if (tokens[0]?.toLowerCase() !== "split") {
+        return { mode: "single", userHint: trimmed };
+    }
+    const folders = Array.from(new Set(tokens.slice(1).map(normalizeFolder).filter(Boolean)));
+    return { mode: "split", folders };
+}
+function groupNameForPath(path) {
+    const slashIndex = path.indexOf("/");
+    return slashIndex === -1 ? "root" : path.slice(0, slashIndex);
+}
+function isInsideFolder(path, folder) {
+    return path === folder || path.startsWith(`${folder}/`);
+}
+export function buildCommitGroups(files, folders) {
+    if (folders.length > 0) {
+        const groups = folders
+            .map((folder) => ({
+            name: folder,
+            files: files.filter((file) => isInsideFolder(file.path, folder)),
+        }))
+            .filter((group) => group.files.length > 0);
+        const missingFolders = folders.filter((folder) => !groups.some((group) => group.name === folder));
+        return { groups, missingFolders };
+    }
+    const groupsByName = new Map();
+    for (const file of files) {
+        const name = groupNameForPath(file.path);
+        groupsByName.set(name, [...(groupsByName.get(name) ?? []), file]);
+    }
+    const groups = Array.from(groupsByName, ([name, groupFiles]) => ({
+        name,
+        files: groupFiles,
+    })).sort((a, b) => a.name.localeCompare(b.name));
+    return { groups, missingFolders: [] };
+}

package/package.json

@@ -1,22 +1,27 @@
 {
   "name": "@andre-barbosa/opencode-commit",
-  "version": "0.1.3",
-  "description": "OpenCode plugin that generates Conventional Commit messages via /commit using a configured model",
+  "version": "0.1.5",
+  "description": "OpenCode plugin that generates Conventional Commit messages and split commit plans via /commit using a configured model",
   "type": "module",
-  "main": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "files": [
-    "src",
-    "commands",
+    "dist",
     "opencode.example.json",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
+    "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run typecheck"
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm run build"
   },
   "keywords": [
     "opencode",

package/commands/commit.md

@@ -1,5 +0,0 @@
----
-description: Generate a commit message from uncommitted changes
----
-
-Handled by the opencode-commit plugin.

package/src/generate.ts

@@ -1,89 +0,0 @@
-import type { createOpencodeClient } from "@opencode-ai/sdk";
-import type { ModelRef } from "./types.js";
-import {
-  buildCommitPrompt,
-  COMMIT_SYSTEM_PROMPT,
-  stripCodeFences,
-} from "./prompt.js";
-import type { GitContext } from "./types.js";
-
-type Client = ReturnType<typeof createOpencodeClient>;
-const COMMIT_AGENT = "plan";
-
-function extractText(parts: Array<{ type?: string; text?: string }>): string {
-  return parts
-    .filter((part) => part.type === "text" && typeof part.text === "string")
-    .map((part) => part.text as string)
-    .join("")
-    .trim();
-}
-
-export function formatModelRef(model?: ModelRef): string {
-  if (!model) return "default";
-  return `${model.providerID}/${model.modelID}`;
-}
-
-async function createChildSession(
-  client: Client,
-  parentSessionID: string,
-): Promise<string> {
-  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: {
-  client: Client;
-  parentSessionID: string;
-  model: ModelRef;
-  context: GitContext;
-  userHint?: string;
-}): Promise<{ message: string; childSessionID: string; modelLabel: string }> {
-  const childSessionID = await createChildSession(
-    input.client,
-    input.parentSessionID,
-  );
-
-  const prompt = buildCommitPrompt(input.context, input.userHint);
-  const body = {
-    agent: COMMIT_AGENT,
-    model: input.model,
-    system: COMMIT_SYSTEM_PROMPT,
-    parts: [{ type: "text" as const, 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 as { parts?: Array<{ type?: string; text?: string }> } | undefined)
-      ?.parts ?? [];
-  const rawText = extractText(parts);
-
-  if (!rawText) {
-    throw new Error(
-      `Commit model returned no text. Child session: ${childSessionID}`,
-    );
-  }
-
-  return {
-    message: stripCodeFences(rawText),
-    childSessionID,
-    modelLabel: formatModelRef(input.model),
-  };
-}

package/src/git.ts

@@ -1,116 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import type { GitContext } from "./types.js";
-
-type Shell = PluginInput["$"];
-
-async function readGitOutput(
-  $: Shell,
-  worktree: string,
-  run: ($: Shell) => Promise<{ exitCode: number; stdout?: { toString(): string } }>,
-): Promise<string> {
-  const result = await run($);
-  if (result.exitCode !== 0) {
-    return "";
-  }
-  return result.stdout?.toString().trim() ?? "";
-}
-
-export async function isGitRepo($: Shell, worktree: string): Promise<boolean> {
-  const result = await $`git rev-parse --git-dir`.cwd(worktree).quiet().nothrow();
-  return result.exitCode === 0;
-}
-
-function truncateDiff(diff: string, maxChars: number, label: string): string {
-  if (diff.length <= maxChars) return diff;
-  return `${diff.slice(0, maxChars)}\n\n[${label} diff truncated at ${maxChars} characters]`;
-}
-
-function splitDiffs(input: {
-  staged: string;
-  unstaged: string;
-  maxDiffChars: number;
-}): { staged: string; unstaged: string } {
-  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"),
-  };
-}
-
-export async function gatherGitContext(
-  $: Shell,
-  worktree: string,
-  maxDiffChars: number,
-): Promise<GitContext> {
-  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 unstagedStat = await readGitOutput($, worktree, ($) =>
-    $`git diff --stat`.cwd(worktree).quiet().nothrow(),
-  );
-  const rawUnstagedDiff = await readGitOutput($, worktree, ($) =>
-    $`git diff`.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 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,
-    untrackedFiles,
-    recentCommits,
-    hasUncommittedChanges,
-  };
-}

package/src/index.ts

@@ -1,149 +0,0 @@
-import type { Plugin } from "@opencode-ai/plugin";
-import type { Part } from "@opencode-ai/sdk";
-import { gatherGitContext, isGitRepo } from "./git.js";
-import { generateCommitMessage } from "./generate.js";
-import { parseModelRef, resolveConfig, type PluginOptions } from "./types.js";
-
-const COMMAND_NAME = "commit";
-const COMMAND_DESCRIPTION = "Generate a commit message from uncommitted changes";
-const COMMAND_TEMPLATE = "Handled by the opencode-commit plugin.";
-const SKIP_ERROR = "skip";
-
-function textPart(text: string): Part {
-  return { type: "text", text } as Part;
-}
-
-function formatOutput(input: {
-  message: string;
-  modelLabel: string;
-  childSessionID: string;
-}): string {
-  return [
-    "## Suggested commit message",
-    "",
-    "```",
-    input.message,
-    "```",
-    "",
-    `Model: \`${input.modelLabel}\` · Child session: \`${input.childSessionID}\``,
-    "",
-    "Copy the message above and run `git commit` when ready.",
-  ].join("\n");
-}
-
-const skipCommand = (): never => {
-  throw new Error(SKIP_ERROR);
-};
-
-export const OpenCodeCommitPlugin: Plugin = async (
-  { client, $, worktree },
-  options?: PluginOptions,
-) => {
-  const config = resolveConfig(options);
-
-  const log = async (
-    level: "info" | "warn" | "error",
-    message: string,
-    extra?: Record<string, unknown>,
-  ) => {
-    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,
-      };
-
-      if (config.model && !cfg.command[COMMAND_NAME].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);
-
-        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();
-        }
-
-        await log("info", "Generating commit message", {
-          model: config.model,
-          branch: context.branch,
-          sessionID: input.sessionID,
-        });
-
-        const userHint = input.arguments?.trim() || undefined;
-        const result = await generateCommitMessage({
-          client,
-          parentSessionID: input.sessionID,
-          model,
-          context,
-          userHint,
-        });
-
-        output.parts = [textPart(formatOutput(result))];
-        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/src/prompt.ts

@@ -1,72 +0,0 @@
-import type { GitContext } from "./types.js";
-
-export const COMMIT_SYSTEM_PROMPT = [
-  "You are a commit message writer.",
-  "Given git changes and context, produce a single commit message.",
-  "Output only the commit message text.",
-].join("\n");
-
-export function buildCommitPrompt(context: GitContext, userHint?: string): string {
-  const recentCommitsBlock =
-    context.recentCommits.length > 0
-      ? context.recentCommits.map((subject) => `- ${subject}`).join("\n")
-      : "(none)";
-  const untrackedFilesBlock =
-    context.untrackedFiles.length > 0
-      ? context.untrackedFiles.map((file) => `- ${file}`).join("\n")
-      : "(none)";
-
-  const hintBlock =
-    userHint && userHint.trim().length > 0
-      ? `\nAdditional instruction from the user:\n${userHint.trim()}\n`
-      : "";
-
-  return `Write a git commit message for the uncommitted changes below.
-
-Format rules (Conventional Commits - required):
-- Subject line MUST use type(scope): description or type: description
-- Allowed types: feat, fix, docs, style, refactor, perf, test, build, ci, chore
-- Scope is optional but preferred when changes are localized (e.g. feat(auth):, fix(api):)
-- Description: imperative mood, lowercase, no trailing period, max 72 chars for the full subject
-- Optional body: blank line after subject, then bullet points; keep lines <= 72 chars
-- Breaking changes: use feat!: or fix!: prefix, or add a BREAKING CHANGE: footer
-- Do NOT use free-form subjects like "Update files", "WIP", or "Misc changes"
-- Use staged and unstaged tracked diffs as the source of truth
-- Untracked files are filenames only; do not infer contents that are not shown
-- Output ONLY the commit message text - no code fences, no commentary, no tool calls
-
-Examples:
-feat(auth): add oauth login flow
-
-- add google and github providers
-- store refresh tokens in secure storage
-
-fix(api): handle null response from user endpoint
-${hintBlock}
-Branch: ${context.branch}
-
-Recent commit subjects (align scope naming when sensible):
-${recentCommitsBlock}
-
-Staged tracked changes (stat):
-${context.stagedStat || "(empty)"}
-
-Staged tracked diff:
-${context.stagedDiff || "(empty)"}
-
-Unstaged tracked changes (stat):
-${context.unstagedStat || "(empty)"}
-
-Unstaged tracked diff:
-${context.unstagedDiff || "(empty)"}
-
-Untracked files (filenames only, contents not read):
-${untrackedFilesBlock}
-`;
-}
-
-export function stripCodeFences(text: string): string {
-  const trimmed = text.trim();
-  const fenced = trimmed.match(/^```(?:\w*\n)?([\s\S]*?)```$/);
-  return (fenced?.[1] ?? trimmed).trim();
-}

package/src/types.ts

@@ -1,53 +0,0 @@
-export type ModelRef = {
-  providerID: string;
-  modelID: string;
-};
-
-export type PluginOptions = {
-  model?: string;
-  maxDiffChars?: number;
-};
-
-export type ResolvedPluginConfig = {
-  model?: string;
-  maxDiffChars: number;
-};
-
-export const DEFAULT_MAX_DIFF_CHARS = 12_000;
-
-export function resolveConfig(options?: PluginOptions): ResolvedPluginConfig {
-  const model = typeof options?.model === "string" ? options.model.trim() : "";
-
-  return {
-    model: model || undefined,
-    maxDiffChars:
-      typeof options?.maxDiffChars === "number" && options.maxDiffChars > 0
-        ? Math.floor(options.maxDiffChars)
-        : DEFAULT_MAX_DIFF_CHARS,
-  };
-}
-
-export function parseModelRef(model: string): ModelRef {
-  const separator = model.indexOf("/");
-  if (separator <= 0 || separator === model.length - 1) {
-    throw new Error(
-      `Invalid commit model \`${model}\`. Use the format \`provider/model-id\`.`,
-    );
-  }
-
-  return {
-    providerID: model.slice(0, separator),
-    modelID: model.slice(separator + 1),
-  };
-}
-
-export type GitContext = {
-  branch: string;
-  stagedStat: string;
-  stagedDiff: string;
-  unstagedStat: string;
-  unstagedDiff: string;
-  untrackedFiles: string[];
-  recentCommits: string[];
-  hasUncommittedChanges: boolean;
-};