@andre-barbosa/opencode-commit 0.1.1 → 0.1.4

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/opencode.example.json

@@ -1,17 +1,12 @@
-{
-  "$schema": "https://opencode.ai/config.json",
-  "plugin": [
-    [
-      "@andre-barbosa/opencode-commit",
-      {
-        "agent": "commit-writer",
-        "maxDiffChars": 12000
-      }
-    ]
-  ],
-  "agent": {
-    "commit-writer": {
-      "model": "opencode-go/deepseek-v4-flash"
-    }
-  }
-}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    [
+      "@andre-barbosa/opencode-commit",
+      {
+        "model": "your-provider/your-model",
+        "maxDiffChars": 12000
+      }
+    ]
+  ]
+}

package/package.json

@@ -1,51 +1,55 @@
-{
-  "name": "@andre-barbosa/opencode-commit",
-  "version": "0.1.1",
-  "description": "OpenCode plugin that generates Conventional Commit messages via a dedicated sub-agent",
-  "type": "module",
-  "main": "src/index.ts",
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "files": [
-    "src",
-    "agents",
-    "commands",
-    "opencode.example.json",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run typecheck"
-  },
-  "keywords": [
-    "opencode",
-    "opencode-plugin",
-    "git",
-    "commit",
-    "conventional-commits"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/AndreB10/opencode-commit.git"
-  },
-  "bugs": {
-    "url": "https://github.com/AndreB10/opencode-commit/issues"
-  },
-  "homepage": "https://github.com/AndreB10/opencode-commit#readme",
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "@opencode-ai/plugin": "^1.3.3"
-  },
-  "devDependencies": {
-    "@opencode-ai/sdk": "^1.3.3",
-    "typescript": "^5.8.3"
-  },
-  "engines": {
-    "node": ">=18"
-  }
-}
+{
+  "name": "@andre-barbosa/opencode-commit",
+  "version": "0.1.4",
+  "description": "OpenCode plugin that generates Conventional Commit messages and split commit plans via /commit using a configured model",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "opencode.example.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm run build"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "git",
+    "commit",
+    "conventional-commits"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AndreB10/opencode-commit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AndreB10/opencode-commit/issues"
+  },
+  "homepage": "https://github.com/AndreB10/opencode-commit#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.3.3"
+  },
+  "devDependencies": {
+    "@opencode-ai/sdk": "^1.3.3",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/agents/commit-writer.md

@@ -1,27 +0,0 @@
----
-description: Generates conventional commit messages from git diffs
-mode: subagent
-hidden: true
-model: opencode-go/deepseek-v4-flash
-temperature: 0.1
-permission:
-  edit: deny
-  bash: deny
-  webfetch: deny
----
-
-You are a commit message writer. Given a git diff and context, produce a single commit message.
-
-You MUST follow Conventional Commits:
-
-- Subject: `type(scope): description` or `type: description`
-- Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore
-- Scope: optional but preferred for localized changes (e.g. auth, api, ui)
-- Description: imperative, lowercase, no trailing period, max 72 chars for the subject line
-- Body: optional blank line then bullet points for non-obvious context
-- Breaking changes: `feat!:` / `fix!:` or a `BREAKING CHANGE:` footer
-
-Never output free-form subjects like "Update files", "WIP", or "Misc changes".
-Never wrap the message in code fences.
-Never add commentary before or after the commit message.
-Output only the commit message text.

package/commands/commit.md

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

package/src/generate.ts

@@ -1,112 +0,0 @@
-import type { createOpencodeClient } from "@opencode-ai/sdk";
-import type { AgentInfo, ModelRef } from "./types.js";
-import { buildCommitPrompt, stripCodeFences } from "./prompt.js";
-import type { GitContext } from "./types.js";
-
-type Client = ReturnType<typeof createOpencodeClient>;
-
-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}`;
-}
-
-export async function fetchAgent(
-  client: Client,
-  agentName: string,
-): Promise<AgentInfo | undefined> {
-  const { data, error } = await client.app.agents();
-  if (error || !Array.isArray(data)) return undefined;
-
-  const agent = data.find((entry) => entry.name === agentName);
-  if (!agent) return undefined;
-
-  return {
-    name: agent.name,
-    model: agent.model
-      ? {
-          providerID: agent.model.providerID,
-          modelID: agent.model.modelID,
-        }
-      : undefined,
-  };
-}
-
-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;
-  agentName: string;
-  agent: AgentInfo;
-  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: string;
-    parts: Array<{ type: "text"; text: string }>;
-    model?: ModelRef;
-  } = {
-    agent: input.agentName,
-    parts: [{ type: "text", text: prompt }],
-  };
-
-  if (input.agent.model) {
-    body.model = input.agent.model;
-  }
-
-  const { data: result, error } = await input.client.session.prompt({
-    path: { id: childSessionID },
-    body,
-  });
-
-  if (error) {
-    throw new Error(`Sub-agent 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(
-      `Sub-agent returned no text. Child session: ${childSessionID}`,
-    );
-  }
-
-  return {
-    message: stripCodeFences(rawText),
-    childSessionID,
-    modelLabel: formatModelRef(input.agent.model),
-  };
-}

package/src/git.ts

@@ -1,64 +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;
-}
-
-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 stat = await readGitOutput($, worktree, ($) =>
-    $`git diff --staged --stat`.cwd(worktree).quiet().nothrow(),
-  );
-  const rawDiff = await readGitOutput($, worktree, ($) =>
-    $`git diff --staged`.cwd(worktree).quiet().nothrow(),
-  );
-  const diff =
-    rawDiff.length > maxDiffChars
-      ? `${rawDiff.slice(0, maxDiffChars)}\n\n[diff truncated at ${maxDiffChars} characters]`
-      : rawDiff;
-
-  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 hasStagedChanges = stat.length > 0 || rawDiff.length > 0;
-
-  return {
-    branch,
-    stat,
-    diff,
-    recentCommits,
-    hasStagedChanges,
-  };
-}