opencode-github-release 0.5.0 → 0.6.0

package/README.md

@@ -8,7 +8,15 @@ An [OpenCode](https://opencode.ai) plugin that creates git tags and publishes Gi
 
 ## Installation
 
-Add to your `opencode.json`:
+For OpenCode V2, add to your `opencode.json`:
+
+```json
+{
+  "plugins": ["opencode-github-release"]
+}
+```
+
+For OpenCode V1 (1.18.29 or newer), use its V1 configuration key instead:
 
 ```json
 {
@@ -93,12 +101,14 @@ There are commit skills such as (https://github.com/PedroHBO/opencode-config-ski
 - [GitHub CLI](https://cli.github.com/) (`gh`) authenticated to your account
 - The current directory must be a git repository with a remote named `origin`
 
+Git commands run in the session's working directory. Release creation pushes commits and tags to `origin` and publishes through `gh`; verify the proposed version before proceeding.
+
 ## Development
 
 ```bash
 npm install
 npm run typecheck
-npm run build
+npm test
 npm pack --dry-run
 ```
 

package/dist/chunk-G33QYB47.js

@@ -0,0 +1,195 @@
+// src/release.ts
+import { execFile } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+import { promisify } from "util";
+var exec = promisify(execFile);
+function runner(directory, signal) {
+  return async (command, args) => {
+    const { stdout } = await exec(command, args, {
+      cwd: directory,
+      signal,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return stdout.trim();
+  };
+}
+async function optional(run, command, args, fallback = "") {
+  try {
+    return await run(command, args);
+  } catch {
+    return fallback;
+  }
+}
+function bumpVersion(current, bump) {
+  const prefix = current.startsWith("v") ? "v" : "";
+  const cleaned = current.replace(/^v/, "");
+  const match = cleaned.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) throw new Error(`Cannot parse semver from "${current}"`);
+  let major = parseInt(match[1], 10);
+  let minor = parseInt(match[2], 10);
+  let patch = parseInt(match[3], 10);
+  if (bump === "major") {
+    major++;
+    minor = 0;
+    patch = 0;
+  }
+  if (bump === "minor") {
+    minor++;
+    patch = 0;
+  }
+  if (bump === "patch") {
+    patch++;
+  }
+  return `${prefix}${major}.${minor}.${patch}`;
+}
+function classifyCommit(subject, body) {
+  const breaking = /^\w+(\([^)]*\))?!:/.test(subject) || /^BREAKING(?: CHANGE|-CHANGE):[ \t]+\S/m.test(body);
+  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 };
+}
+async function latestTag(run) {
+  await optional(run, "git", ["fetch", "--tags", "--force"]);
+  return optional(run, "git", ["describe", "--tags", "--abbrev=0"], "v0.0.0");
+}
+async function suggestBump(run, progress) {
+  await progress("Fetching tags\u2026");
+  const tag = await latestTag(run);
+  const logText = await optional(run, "git", ["log", `${tag}..HEAD`, "-z", "--format=%h%x00%s%x00%b"]);
+  if (!logText) {
+    return { title: "No new commits", output: `No new commits since ${tag}. No release needed.` };
+  }
+  const fields = logText.split("\0");
+  fields.pop();
+  const entries = [];
+  for (let i = 0; i < fields.length; i += 3) {
+    const [hash, subject, body] = fields.slice(i, i + 3);
+    entries.push({ hash, subject, ...classifyCommit(subject, body) });
+  }
+  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 tag2 = e.breaking ? "[BREAKING]" : e.type === "feat" ? "[feat]" : e.type === "fix" ? "[fix]" : "     ";
+    return `  ${tag2} ${e.hash} ${e.subject}`;
+  }).join("\n");
+  return {
+    title: "Bump suggestion",
+    output: [
+      `Latest tag: ${tag}`,
+      `Commits: ${entries.length}`,
+      "",
+      output,
+      "",
+      `Suggested bump: ${suggestedBump} -> ${bumpVersion(tag, suggestedBump)}`
+    ].join("\n")
+  };
+}
+async function createRelease(args, directory, run, progress) {
+  const { bump, version, notes, force } = args;
+  if (!bump && !version) {
+    throw new Error("Provide either `bump` (patch/minor/major) or an explicit `version` string");
+  }
+  await progress("Checking working tree\u2026");
+  const status = await run("git", ["status", "--porcelain"]);
+  if (status && !force) {
+    const count = status.split("\n").length;
+    return {
+      title: "Uncommitted files",
+      output: `${count} uncommitted file(s) detected. Call create_release with force: true to proceed anyway, or commit/stash first.`
+    };
+  }
+  await progress("Fetching tags\u2026");
+  const tag = await latestTag(run);
+  const repoUsesV = tag.startsWith("v");
+  const hasExistingTags = await run("git", ["tag", "-l"]) !== "";
+  let newTag;
+  if (version) {
+    const versionHasV = version.startsWith("v");
+    if (hasExistingTags && versionHasV !== repoUsesV) {
+      const suggestion = versionHasV ? version.replace(/^v/, "") : `v${version}`;
+      return {
+        title: "Version prefix mismatch",
+        output: [
+          `Existing releases use ${repoUsesV ? 'the "v" prefix' : 'no "v" prefix'} (e.g. "${tag}"),`,
+          `but you provided "${version}" which ${versionHasV ? "has" : "does not have"} a "v" prefix.`,
+          "",
+          `Would you like to use "${suggestion}" instead?`,
+          "If so, call create_release again with the corrected version."
+        ].join("\n")
+      };
+    }
+    newTag = version;
+  } else {
+    newTag = bumpVersion(tag, bump);
+  }
+  await progress(`Bumping to ${newTag}\u2026`);
+  const branch = await run("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
+  let unpushedBefore = [];
+  if (branch !== "HEAD") {
+    const before = await optional(run, "git", ["log", `origin/${branch}..HEAD`, "--oneline"]);
+    if (before) {
+      unpushedBefore = before.split("\n").map((line) => {
+        const hash = line.split(/\s+/)[0];
+        return { hash, subject: line.slice(hash.length).trim() };
+      });
+    }
+  }
+  if (existsSync(join(directory, "package.json"))) {
+    const bareVersion = newTag.replace(/^v/, "");
+    await run("npm", ["version", bareVersion, "--no-git-tag-version"]);
+    await optional(run, "git", ["add", "package.json", "package-lock.json"]);
+    await run("git", ["commit", "-m", `chore(release): bump version to ${newTag}`]);
+  }
+  if (branch !== "HEAD") {
+    await progress("Pushing commits\u2026");
+    await run("git", ["push", "origin", branch]);
+  }
+  await progress("Tagging release\u2026");
+  await run("git", ["tag", "-a", newTag, "-m", notes || `Release ${newTag}`]);
+  await run("git", ["push", "origin", newTag]);
+  await progress("Creating GitHub release\u2026");
+  if (notes) {
+    await run("gh", ["release", "create", newTag, "--title", newTag, "--notes", notes]);
+  } else {
+    await run("gh", ["release", "create", newTag, "--title", newTag, "--generate-notes"]);
+  }
+  let result = `Created and published ${newTag} (bumped from ${tag})`;
+  if (branch !== "HEAD" && unpushedBefore.length > 0) {
+    const remaining = await optional(run, "git", ["log", `origin/${branch}..HEAD`, "--oneline"]);
+    const remainingCount = remaining ? remaining.split("\n").length : 0;
+    const pushedCount = unpushedBefore.length - remainingCount;
+    if (pushedCount > 0) {
+      const plural = pushedCount === 1 ? "" : "s";
+      result += `
+Pushed ${pushedCount} commit${plural} to ${branch}:`;
+      for (let i = 0; i < pushedCount; i++) {
+        result += `
+  ${unpushedBefore[i].hash} ${unpushedBefore[i].subject}`;
+      }
+    }
+    if (remainingCount > 0) {
+      const plural = remainingCount === 1 ? "" : "s";
+      const verb = remainingCount === 1 ? "is" : "are";
+      result += `
+Note: ${remainingCount} commit${plural} in this release ${verb} not yet pushed to origin/${branch}.`;
+    }
+  }
+  return { title: newTag, output: result };
+}
+
+export {
+  runner,
+  suggestBump,
+  createRelease
+};

package/dist/index.d.ts

@@ -1,5 +1,10 @@
+import { Plugin as Plugin$1 } from '@opencode/plugin';
 import { Plugin } from '@opencode-ai/plugin';
 
-declare const plugin: Plugin;
+declare const _default: {
+    server: Plugin;
+    id: string;
+    setup: (context: Plugin$1.Context) => Promise<Plugin$1.Cleanup | void> | Plugin$1.Cleanup | void;
+};
 
-export { plugin as default };
+export { _default as default };

package/dist/index.js

@@ -1,196 +1,84 @@
+import {
+  createRelease,
+  runner,
+  suggestBump
+} from "./chunk-G33QYB47.js";
+
 // src/index.ts
+import { Plugin } from "@opencode/plugin";
 import { tool } from "@opencode-ai/plugin";
-function bumpVersion(current, bump) {
-  const prefix = current.startsWith("v") ? "v" : "";
-  const cleaned = current.replace(/^v/, "");
-  const match = cleaned.match(/^(\d+)\.(\d+)\.(\d+)/);
-  if (!match) throw new Error(`Cannot parse semver from "${current}"`);
-  let major = parseInt(match[1], 10);
-  let minor = parseInt(match[2], 10);
-  let patch = parseInt(match[3], 10);
-  if (bump === "major") {
-    major++;
-    minor = 0;
-    patch = 0;
+var suggestDescription = "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.";
+var releaseDescription = '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.';
+var v1 = async () => ({
+  tool: {
+    suggest_bump: tool({
+      description: suggestDescription,
+      args: {},
+      async execute(_args, context) {
+        return suggestBump(runner(context.directory, context.abort), (title) => context.metadata({ title }));
+      }
+    }),
+    create_release: tool({
+      description: releaseDescription,
+      args: {
+        bump: tool.schema.enum(["patch", "minor", "major"]).optional(),
+        version: tool.schema.string().optional(),
+        notes: tool.schema.string().optional(),
+        force: tool.schema.boolean().optional()
+      },
+      async execute(args, context) {
+        return createRelease(args, context.directory, runner(context.directory, context.abort), (title) => context.metadata({ title }));
+      }
+    })
   }
-  if (bump === "minor") {
-    minor++;
-    patch = 0;
-  }
-  if (bump === "patch") {
-    patch++;
-  }
-  return `${prefix}${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) {
-          context.metadata({ title: "Fetching tags\u2026" });
-          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 {
-              title: "No new commits",
-              output: `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 {
-            title: "Bump suggestion",
-            output: [
-              `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"). 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(),
-          force: tool.schema.boolean().optional()
-        },
-        async execute(args, context) {
-          const { bump, version, notes, force } = args;
-          if (!bump && !version) {
-            throw new Error("Provide either `bump` (patch/minor/major) or an explicit `version` string");
-          }
-          context.metadata({ title: "Checking working tree\u2026" });
-          const status = (await $`git status --porcelain`.text()).trim();
-          if (status && !force) {
-            const count = status.split("\n").length;
-            return {
-              title: "Uncommitted files",
-              output: `${count} uncommitted file(s) detected. Call create_release with force: true to proceed anyway, or commit/stash first.`
-            };
-          }
-          context.metadata({ title: "Fetching tags\u2026" });
-          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 repoUsesV = latestTag.startsWith("v");
-          const hasExistingTags = parseInt((await $`git tag -l 2>/dev/null | wc -l`.text()).trim(), 10) > 0;
-          let newTag;
-          if (version) {
-            const versionHasV = version.startsWith("v");
-            if (hasExistingTags && versionHasV !== repoUsesV) {
-              const suggestion = versionHasV ? version.replace(/^v/, "") : `v${version}`;
-              return {
-                title: "Version prefix mismatch",
-                output: [
-                  `Existing releases use ${repoUsesV ? 'the "v" prefix' : 'no "v" prefix'} (e.g. "${latestTag}"),`,
-                  `but you provided "${version}" which ${versionHasV ? "has" : "does not have"} a "v" prefix.`,
-                  "",
-                  `Would you like to use "${suggestion}" instead?`,
-                  "If so, call create_release again with the corrected version."
-                ].join("\n")
-              };
-            }
-            newTag = version;
-          } else {
-            newTag = bumpVersion(latestTag, bump);
-          }
-          context.metadata({ title: `Bumping to ${newTag}\u2026` });
-          const branch = (await $`git rev-parse --abbrev-ref HEAD`.text()).trim();
-          let unpushedBefore = [];
-          if (branch !== "HEAD") {
-            const before = (await $`git log origin/${branch}..HEAD --oneline 2>/dev/null || true`.text()).trim();
-            if (before) {
-              unpushedBefore = before.split("\n").map((line) => {
-                const hash = line.split(/\s+/)[0];
-                return { hash, subject: line.slice(hash.length).trim() };
-              });
-            }
-          }
-          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") {
-            context.metadata({ title: "Pushing commits\u2026" });
-            await $`git push origin ${branch}`.quiet();
-          }
-          context.metadata({ title: "Tagging release\u2026" });
-          const message = notes || `Release ${newTag}`;
-          await $`git tag -a ${newTag} -m ${message}`.quiet();
-          await $`git push origin ${newTag}`.quiet();
-          context.metadata({ title: "Creating GitHub release\u2026" });
-          if (notes) {
-            await $`gh release create ${newTag} --title ${newTag} --notes ${notes}`.quiet();
-          } else {
-            await $`gh release create ${newTag} --title ${newTag} --generate-notes`.quiet();
+});
+var index_default = {
+  ...Plugin.define({
+    id: "opencode-github-release",
+    async setup(ctx) {
+      await ctx.tool.transform((editor) => {
+        editor.add({
+          name: "suggest_bump",
+          description: suggestDescription,
+          input: { type: "object", properties: {}, additionalProperties: false },
+          async execute(_input, context) {
+            const session = await ctx.session.get({ sessionID: context.sessionID });
+            const result = await suggestBump(
+              runner(session.location.directory, context.signal),
+              (title) => context.progress({ status: title })
+            );
+            return { content: result.output, metadata: { title: result.title } };
           }
-          let result = `Created and published ${newTag} (bumped from ${latestTag})`;
-          if (branch !== "HEAD" && unpushedBefore.length > 0) {
-            const remaining = (await $`git log origin/${branch}..HEAD --oneline 2>/dev/null || true`.text()).trim();
-            const remainingCount = remaining ? remaining.split("\n").length : 0;
-            const pushedCount = unpushedBefore.length - remainingCount;
-            if (pushedCount > 0) {
-              const plural = pushedCount === 1 ? "" : "s";
-              result += `
-Pushed ${pushedCount} commit${plural} to ${branch}:`;
-              for (let i = 0; i < pushedCount; i++) {
-                result += `
-  ${unpushedBefore[i].hash} ${unpushedBefore[i].subject}`;
-              }
-            }
-            if (remainingCount > 0) {
-              const plural = remainingCount === 1 ? "" : "s";
-              const verb = remainingCount === 1 ? "is" : "are";
-              result += `
-Note: ${remainingCount} commit${plural} in this release ${verb} not yet pushed to origin/${branch}.`;
-            }
+        });
+        editor.add({
+          name: "create_release",
+          description: releaseDescription,
+          input: {
+            type: "object",
+            properties: {
+              bump: { type: "string", enum: ["patch", "minor", "major"] },
+              version: { type: "string" },
+              notes: { type: "string" },
+              force: { type: "boolean" }
+            },
+            additionalProperties: false
+          },
+          async execute(input, context) {
+            const session = await ctx.session.get({ sessionID: context.sessionID });
+            const result = await createRelease(
+              input,
+              session.location.directory,
+              runner(session.location.directory, context.signal),
+              (title) => context.progress({ status: title })
+            );
+            return { content: result.output, metadata: { title: result.title } };
           }
-          return { title: newTag, output: result };
-        }
-      })
+        });
+      });
     }
-  };
+  }),
+  server: v1
 };
-var index_default = plugin;
 export {
   index_default as default
 };

package/dist/release.d.ts

@@ -0,0 +1,18 @@
+type Bump = "patch" | "minor" | "major";
+type Result = {
+    title: string;
+    output: string;
+};
+type Runner = (command: string, args: string[]) => Promise<string>;
+type Progress = (title: string) => Promise<void> | void;
+declare function runner(directory: string, signal?: AbortSignal): Runner;
+declare function suggestBump(run: Runner, progress: Progress): Promise<Result>;
+type ReleaseArgs = {
+    bump?: Bump;
+    version?: string;
+    notes?: string;
+    force?: boolean;
+};
+declare function createRelease(args: ReleaseArgs, directory: string, run: Runner, progress: Progress): Promise<Result>;
+
+export { type Bump, type Progress, type ReleaseArgs, type Result, type Runner, createRelease, runner, suggestBump };

package/dist/release.js

@@ -0,0 +1,10 @@
+import {
+  createRelease,
+  runner,
+  suggestBump
+} from "./chunk-G33QYB47.js";
+export {
+  createRelease,
+  runner,
+  suggestBump
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-github-release",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "OpenCode plugin to create git tags and publish GitHub releases with semantic versioning.",
   "repository": {
     "type": "git",
@@ -21,10 +21,11 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "build": "tsup src/index.ts src/release.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/release.ts --format esm --dts --watch",
     "typecheck": "tsc --noEmit",
-    "check": "npm run typecheck && npm run build && npm pack --dry-run",
+    "test": "npm run build && node --test test/*.test.js",
+    "check": "npm run typecheck && npm run test && npm pack --dry-run",
     "prepublishOnly": "npm run check"
   },
   "keywords": [
@@ -38,7 +39,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "^1.14.41"
+    "@opencode-ai/plugin": "^1.18.29",
+    "@opencode/plugin": "^2.0.24"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",