@andre-barbosa/opencode-commit 0.1.1 → 0.1.3

package/src/git.ts

@@ -1,64 +1,116 @@
-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,
-  };
-}
+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,136 +1,149 @@
-import type { Plugin } from "@opencode-ai/plugin";
-import type { Part } from "@opencode-ai/sdk";
-import { gatherGitContext, isGitRepo } from "./git.js";
-import { fetchAgent, generateCommitMessage } from "./generate.js";
-import { resolveConfig, type PluginOptions } from "./types.js";
-
-const COMMAND_NAME = "commit";
-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 {
-    "command.execute.before": async (input, output) => {
-      if (input.command !== COMMAND_NAME) return;
-
-      try {
-        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.hasStagedChanges) {
-          output.parts = [
-            textPart(
-              "No staged changes found. Stage files with `git add` and run `/commit` again.",
-            ),
-          ];
-          return skipCommand();
-        }
-
-        const resolvedAgent = await fetchAgent(client, config.agent);
-        if (!resolvedAgent) {
-          output.parts = [
-            textPart(
-              [
-                `Sub-agent \`${config.agent}\` is not configured.`,
-                "",
-                "Copy `agents/commit-writer.md` from this plugin into `.opencode/agents/commit-writer.md`,",
-                "or add the agent to your `opencode.json`.",
-              ].join("\n"),
-            ),
-          ];
-          return skipCommand();
-        }
-
-        await log("info", "Generating commit message", {
-          agent: config.agent,
-          branch: context.branch,
-          sessionID: input.sessionID,
-        });
-
-        const userHint = input.arguments?.trim() || undefined;
-        const result = await generateCommitMessage({
-          client,
-          parentSessionID: input.sessionID,
-          agentName: config.agent,
-          agent: resolvedAgent,
-          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;
+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,51 +1,72 @@
-import type { GitContext } from "./types.js";
-
-export function buildCommitPrompt(context: GitContext, userHint?: string): string {
-  const recentCommitsBlock =
-    context.recentCommits.length > 0
-      ? context.recentCommits.map((subject) => `- ${subject}`).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 staged 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"
-- 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 changes (stat):
-${context.stat || "(empty)"}
-
-Staged diff:
-${context.diff || "(empty)"}
-`;
-}
-
-export function stripCodeFences(text: string): string {
-  const trimmed = text.trim();
-  const fenced = trimmed.match(/^```(?:\w*\n)?([\s\S]*?)```$/);
-  return (fenced?.[1] ?? trimmed).trim();
-}
+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();
+}