opencode-github-release 0.1.0 → 0.3.1

package/README.md

@@ -20,7 +20,7 @@ Restart OpenCode. The plugin loads automatically.
 
 ## Usage
 
-Ask OpenCode to create a release. The plugin provides a `create_release` tool with these modes:
+Ask OpenCode to create a release. The plugin provides `create_release` and `suggest_bump` tools. When you give a specific version or bump, `create_release` is called directly. When you don't, `suggest_bump` analyzes your commits first and asks for confirmation. Modes:
 
 **Auto-bump from latest tag:**
 ```
@@ -39,6 +39,36 @@ Release version 2.0.0
 Create a patch release with notes "Fixed login bug"
 ```
 
+**Auto-suggest from git history:**
+```
+Create a release
+```
+
+## How it works
+
+When you request a release, the plugin fetches the latest git tag from the repository and computes the next version from it. If you specify a bump (`patch`/`minor`/`major`) or an explicit version, it creates the tag and release immediately. If you don't specify either (e.g., just "create a release"), the plugin instead runs `suggest_bump` — it analyzes commits since the latest tag using conventional commit conventions: `fix` → patch, `feat` → minor, `BREAKING CHANGE` → major — and presents the suggestion for your confirmation before proceeding.
+
+If you don't provide release notes, the plugin automatically generates them from the commit history via `gh release create --generate-notes`.
+
+`create_release` expects conventional commit messages (`feat:`, `fix:`, `BREAKING CHANGE:`) for accurate auto-suggestion. Commits that follow this convention are classified as:
+
+- `fix:` → patch bump
+- `feat:` → minor bump
+- `BREAKING CHANGE:` or `feat!:` / `fix!:` → major bump
+
+Example output when running `suggest_bump`:
+
+```
+Latest tag: v0.1.0
+Commits: 3
+
+  [fix] a1b2c3d Fix login timeout
+  [feat] e4f5g6h Add user dashboard
+  [BREAKING] i7j8k9l Redesign auth API
+
+Suggested bump: major -> v1.0.0
+```
+
 ## Prerequisites
 
 - [Git](https://git-scm.com/)

package/dist/index.js

@@ -21,34 +21,111 @@ function bumpVersion(current, bump) {
   }
   return `v${major}.${minor}.${patch}`;
 }
+function classifyCommit(subject) {
+  const breaking = /^BREAKING CHANGE:/im.test(subject) || /^\w+(\([^)]*\))?!:/m.test(subject);
+  const match = subject.match(/^(\w+)(\([^)]*\))?(!)?\s*:/);
+  const type = match?.[1]?.toLowerCase();
+  if (type === "feat") return { type: "feat", breaking };
+  if (type === "fix") return { type: "fix", breaking };
+  return { type: "other", breaking };
+}
 var plugin = async ({ $ }) => {
   return {
     tool: {
+      suggest_bump: tool({
+        description: "Analyze git history since the latest tag and suggest a semantic version bump. Call this tool when the user asks to create a release but does NOT specify patch/minor/major or an explicit version string. After receiving the suggestion, present it to the user and ask for confirmation before calling create_release.",
+        args: {},
+        async execute(_args, _context) {
+          await $`git fetch --tags --force 2>/dev/null || true`.quiet();
+          const tagResult = await $`git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0"`.text();
+          const latestTag = tagResult.trim();
+          const logText = await $`git log ${latestTag}..HEAD --oneline 2>/dev/null || true`.text();
+          if (!logText) {
+            return `No new commits since ${latestTag}. No release needed.`;
+          }
+          const lines = logText.split("\n");
+          const entries = lines.map((line) => {
+            const hash = line.split(/\s+/)[0];
+            const subject = line.slice(hash.length).trim();
+            const { type, breaking } = classifyCommit(subject);
+            return { hash, subject, type, breaking };
+          });
+          let suggestedBump = "patch";
+          for (const entry of entries) {
+            if (entry.breaking) {
+              suggestedBump = "major";
+              break;
+            }
+            if (entry.type === "feat") {
+              suggestedBump = "minor";
+            }
+          }
+          const output = entries.map((e) => {
+            const tag = e.breaking ? "[BREAKING]" : e.type === "feat" ? "[feat]" : e.type === "fix" ? "[fix]" : "     ";
+            return `  ${tag} ${e.hash} ${e.subject}`;
+          }).join("\n");
+          return [
+            `Latest tag: ${latestTag}`,
+            `Commits: ${entries.length}`,
+            "",
+            output,
+            "",
+            `Suggested bump: ${suggestedBump} -> ${bumpVersion(latestTag, suggestedBump)}`
+          ].join("\n");
+        }
+      }),
       create_release: tool({
-        description: 'Create a git tag and publish a GitHub release with semantic versioning. Provide either `bump` to auto-compute the next version from the latest tag, or an explicit `version` string (e.g. "2.0.0" or "v2.0.0").',
+        description: 'Create a git tag and publish a GitHub release with semantic versioning. Provide either `bump` to auto-compute the next version from the latest tag, or an explicit `version` string (e.g. "2.0.0" or "v2.0.0"). If the user only asks to "create a release" without specifying a bump or version, call suggest_bump first instead of this tool.',
         args: {
           bump: tool.schema.enum(["patch", "minor", "major"]).optional(),
           version: tool.schema.string().optional(),
-          notes: tool.schema.string().optional()
+          notes: tool.schema.string().optional(),
+          force: tool.schema.boolean().optional()
         },
         async execute(args, _context) {
-          const { bump, version, notes } = args;
+          const { bump, version, notes, force } = args;
           if (!bump && !version) {
             throw new Error("Provide either `bump` (patch/minor/major) or an explicit `version` string");
           }
-          await $`git fetch --tags --force 2>/dev/null || true`;
-          const result = await $`git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0"`;
-          const latestTag = result.stdout.toString().trim();
+          const status = (await $`git status --porcelain`.text()).trim();
+          if (status && !force) {
+            const count = status.split("\n").length;
+            return `${count} uncommitted file(s) detected. Call create_release with force: true to proceed anyway, or commit/stash first.`;
+          }
+          await $`git fetch --tags --force 2>/dev/null || true`.quiet();
+          const tagResult = await $`git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0"`.text();
+          const latestTag = tagResult.trim();
           const newTag = version ? version.startsWith("v") ? version : `v${version}` : bumpVersion(latestTag, bump);
+          const branch = (await $`git rev-parse --abbrev-ref HEAD`.text()).trim();
+          let unpushedInfo = "";
+          if (branch !== "HEAD") {
+            const unpushed = (await $`git log origin/${branch}..HEAD --oneline 2>/dev/null || true`.text()).trim();
+            if (unpushed) {
+              unpushedInfo = `${unpushed.split("\n").length} unpushed commit(s) will be included in this release.`;
+            }
+          }
+          const hasPkg = (await $`test -f package.json && echo "yes" || echo "no"`.text()).trim() === "yes";
+          if (hasPkg) {
+            const bareVersion = newTag.replace(/^v/, "");
+            await $`npm version ${bareVersion} --no-git-tag-version`.quiet();
+            await $`git add package.json package-lock.json 2>/dev/null || true`.quiet();
+            await $`git commit -m ${`chore(release): bump version to ${newTag}`}`.quiet();
+            if (branch !== "HEAD") {
+              await $`git push origin ${branch}`.quiet();
+            }
+          }
           const message = notes || `Release ${newTag}`;
-          await $`git tag -a ${newTag} -m ${message}`;
-          await $`git push origin ${newTag}`;
+          await $`git tag -a ${newTag} -m ${message}`.quiet();
+          await $`git push origin ${newTag}`.quiet();
           if (notes) {
-            await $`gh release create ${newTag} --title ${newTag} --notes ${notes}`;
+            await $`gh release create ${newTag} --title ${newTag} --notes ${notes}`.quiet();
           } else {
-            await $`gh release create ${newTag} --title ${newTag} --generate-notes`;
+            await $`gh release create ${newTag} --title ${newTag} --generate-notes`.quiet();
           }
-          return `\u2713 Created and published ${newTag} (bumped from ${latestTag})`;
+          let result = `Created and published ${newTag} (bumped from ${latestTag})`;
+          if (unpushedInfo) result += `
+${unpushedInfo}`;
+          return result;
         }
       })
     }

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "opencode-github-release",
-  "version": "0.1.0",
+  "version": "0.3.1",
   "description": "OpenCode plugin to create git tags and publish GitHub releases with semantic versioning.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amestsantim/opencode-github-release"
+  },
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",