supipowers 1.2.2 → 1.2.3

package/bin/install.mjs

@@ -3,9 +3,11 @@ import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 
+const isWindows = process.platform === "win32";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const result = spawnSync("bun", [join(__dirname, "install.ts"), ...process.argv.slice(2)], {
   stdio: "inherit",
   env: process.env,
+  shell: isWindows,
 });
 process.exit(result.status ?? 1);

package/bin/install.ts

@@ -26,6 +26,8 @@ import { homedir } from "node:os";
 import { scanAll, installDep, formatReport } from "../src/deps/registry.js";
 import type { ExecResult } from "../src/platform/types.js";
 
+const isWindows = process.platform === "win32";
+
 // ── Helpers ──────────────────────────────────────────────────
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -46,6 +48,7 @@ function run(cmd: string, args: string[], opts: Record<string, unknown> = {}): R
     stdio: "pipe",
     encoding: "utf8",
     timeout: 120_000,
+    shell: isWindows,
     ...opts,
   }) as unknown as RunResult;
 }
@@ -56,32 +59,54 @@ function bail(msg: string): never {
 }
 
 function findOmpBinary(): string | null {
-  // Check PATH first
+  // Check PATH first (shell: true in run() resolves .cmd shims on Windows)
   const check = run("omp", ["--version"]);
   if (!check.error && check.status === 0) return "omp";
 
-  // Fallback: check common bun global location
-  const bunPath = join(homedir(), ".bun", "bin", "omp");
-  if (existsSync(bunPath)) {
-    const fallback = run(bunPath, ["--version"]);
-    if (!fallback.error && fallback.status === 0) return bunPath;
+  // Fallback: check common global locations
+  const candidates = [
+    join(homedir(), ".bun", "bin", "omp"),
+  ];
+  if (isWindows) {
+    // Bun on Windows installs .exe binaries
+    candidates.push(join(homedir(), ".bun", "bin", "omp.exe"));
+    // npm globals on Windows
+    const appData = process.env.APPDATA;
+    if (appData) candidates.push(join(appData, "npm", "omp.cmd"));
+  }
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      const fallback = run(candidate, ["--version"]);
+      if (!fallback.error && fallback.status === 0) return candidate;
+    }
   }
 
   return null;
 }
 
 function findPiBinary(): string | null {
-  // Check PATH first
+  // Check PATH first (shell: true in run() resolves .cmd shims on Windows)
   const check = run("pi", ["--version"]);
   if (!check.error && check.status === 0) return "pi";
 
-  // Fallback: check common npm/bun global locations
-  for (const candidate of [
-    join(homedir(), ".bun", "bin", "pi"),
-    join(homedir(), ".npm-global", "bin", "pi"),
-    "/usr/local/bin/pi",
-    "/opt/homebrew/bin/pi",
-  ]) {
+  // Fallback: check common global locations
+  const candidates: string[] = [];
+  if (isWindows) {
+    candidates.push(join(homedir(), ".bun", "bin", "pi.exe"));
+    const appData = process.env.APPDATA;
+    if (appData) {
+      candidates.push(join(appData, "npm", "pi.cmd"));
+      candidates.push(join(appData, "npm", "pi"));
+    }
+  } else {
+    candidates.push(
+      join(homedir(), ".bun", "bin", "pi"),
+      join(homedir(), ".npm-global", "bin", "pi"),
+      "/usr/local/bin/pi",
+      "/opt/homebrew/bin/pi",
+    );
+  }
+  for (const candidate of candidates) {
     if (existsSync(candidate)) {
       const fallback = run(candidate, ["--version"]);
       if (!fallback.error && fallback.status === 0) return candidate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Workflow extension for OMP coding agents.",
   "type": "module",
   "scripts": {

package/src/commands/release.ts

@@ -3,7 +3,7 @@ import type { ReleaseChannel, BumpType } from "../types.js";
 import { loadConfig, updateConfig } from "../config/loader.js";
 import { detectChannels } from "../release/detector.js";
 import { parseConventionalCommits, buildChangelogMarkdown, summarizeChanges } from "../release/changelog.js";
-import { getCurrentVersion, suggestBump, bumpVersion, isVersionReleased } from "../release/version.js";
+import { getCurrentVersion, suggestBump, bumpVersion, isVersionReleased, isTagOnRemote } from "../release/version.js";
 import { executeRelease, type ReleaseProgressFn } from "../release/executor.js";
 import { buildPolishPrompt } from "../release/prompt.js";
 import { notifyInfo, notifySuccess, notifyError } from "../notifications/renderer.js";
@@ -278,11 +278,16 @@ export function handleRelease(platform: Platform, ctx: any, args?: string): void
       progress.activate(2, "Parsing git history");
       const lastTag = await getLastTag(platform, ctx.cwd);
       const currentVersion = getCurrentVersion(ctx.cwd);
-      const alreadyReleased = await isVersionReleased(
+      const localTagExists = await isVersionReleased(
         platform.exec.bind(platform),
         ctx.cwd,
         currentVersion,
       );
+      // Only check remote when local tag exists — avoids a network call when
+      // the version was never tagged at all.
+      const remoteTagExists = localTagExists
+        ? await isTagOnRemote(platform.exec.bind(platform), ctx.cwd, currentVersion)
+        : false;
 
       // 3. Parse commits since last tag
       const sinceArg = lastTag ? `${lastTag}..HEAD` : "HEAD~50..HEAD";
@@ -303,18 +308,30 @@ export function handleRelease(platform: Platform, ctx: any, args?: string): void
       const commitCount = commits.features.length + commits.fixes.length + commits.breaking.length + commits.improvements.length + commits.maintenance.length + commits.other.length;
       progress.complete(2, `${commitCount} commits since ${lastTag ?? "start"}`);
 
-      // 4. Version resolution — skip bump when local version is unreleased
+      // 4. Version resolution
+      //    Three states:
+      //    a) No local tag              → version is unreleased, skip bump
+      //    b) Local tag, not on remote  → incomplete release, skip bump + skip tag
+      //    c) Local + remote tag        → fully released, ask for bump
       let nextVersion: string;
       let skipBump: boolean;
+      let skipTag = false;
 
-      if (!alreadyReleased && currentVersion !== "0.0.0") {
-        // Local version hasn't been tagged yet — use it as-is
+      if (!localTagExists && currentVersion !== "0.0.0") {
+        // (a) No tag at all — version in package.json is unreleased
         nextVersion = currentVersion;
         skipBump = true;
         progress.skip(3, `v${currentVersion} (already set, not yet released)`);
-        notifyInfo(ctx, `Using v${currentVersion}`, "Version not yet released — skipping bump");
+        notifyInfo(ctx, `Using v${currentVersion}`, "Version not yet released \u2014 skipping bump");
+      } else if (localTagExists && !remoteTagExists) {
+        // (b) Tag exists locally but never made it to origin — resume
+        nextVersion = currentVersion;
+        skipBump = true;
+        skipTag = true;
+        progress.skip(3, `v${currentVersion} (tag exists locally, not pushed)`);
+        notifyInfo(ctx, `Resuming v${currentVersion}`, "Tag exists locally but not on remote \u2014 will push");
       } else {
-        // Version already released — ask for bump
+        // (c) Fully released — ask for bump
         progress.activate(3, "Awaiting version selection");
         const suggested = suggestBump(commits);
         const bumpChoice = await ctx.ui.select(
@@ -330,7 +347,7 @@ export function handleRelease(platform: Platform, ctx: any, args?: string): void
         const bump = bumpChoice.split(" \u2014 ")[0] as BumpType;
         nextVersion = bumpVersion(currentVersion, bump);
         skipBump = false;
-        progress.complete(3, `${currentVersion} → ${nextVersion} (${bump})`);
+        progress.complete(3, `${currentVersion} \u2192 ${nextVersion} (${bump})`);
       }
 
       // 5. Build changelog
@@ -416,6 +433,7 @@ export function handleRelease(platform: Platform, ctx: any, args?: string): void
           channels,
           dryRun: isDryRun,
           skipBump,
+          skipTag,
           onProgress: progress.executorProgress(),
         });
 

package/src/deps/registry.ts

@@ -34,7 +34,9 @@ export async function checkBinary(
   exec: ExecFn,
   binary: string,
 ): Promise<{ installed: boolean; version?: string }> {
-  const which = await exec("which", [binary]);
+  // `which` is Unix-only; Windows uses `where` to locate executables
+  const whichCmd = process.platform === "win32" ? "where" : "which";
+  const which = await exec(whichCmd, [binary]);
   if (which.code !== 0) return { installed: false };
 
   const ver = await exec(binary, ["--version"]);

package/src/release/commit-types.ts

@@ -13,6 +13,7 @@ export const VALID_COMMIT_TYPES = [
   "test",
   "docs",
   "style",
+  "release",
 ] as const;
 
 export type ConventionalCommitType = (typeof VALID_COMMIT_TYPES)[number];
@@ -32,4 +33,5 @@ export const MAINTENANCE_TYPES = new Set<ConventionalCommitType>([
   "test",
   "docs",
   "style",
+  "release",
 ]);

package/src/release/executor.ts

@@ -22,6 +22,8 @@ export interface ExecuteReleaseOptions {
   dryRun: boolean;
   /** Skip the package.json version write (version was already set locally). */
   skipBump?: boolean;
+  /** Skip creating the git tag (it already exists locally). */
+  skipTag?: boolean;
   /** Optional callback for step-by-step progress reporting. */
   onProgress?: ReleaseProgressFn;
 }
@@ -37,7 +39,7 @@ export interface ExecuteReleaseOptions {
  *   happen (all flags true) so callers can preview without side-effects.
  */
 export async function executeRelease(opts: ExecuteReleaseOptions): Promise<ReleaseResult> {
-  const { exec, cwd, version, changelog, channels, dryRun, skipBump, onProgress } = opts;
+  const { exec, cwd, version, changelog, channels, dryRun, skipBump, skipTag, onProgress } = opts;
   const progress = onProgress ?? (() => {});
 
   if (dryRun) {
@@ -45,7 +47,11 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
     console.log(`[dry-run] Would bump version to ${version}`);
     console.log(`[dry-run] Would git add -A`);
     console.log(`[dry-run] Would git commit -m "chore(release): v${version}"`);
-    console.log(`[dry-run] Would git tag -a v${version}`);
+    if (skipTag) {
+      console.log(`[dry-run] Would skip git tag (already exists locally)`);
+    } else {
+      console.log(`[dry-run] Would git tag -a v${version}`);
+    }
     console.log(`[dry-run] Would git push origin HEAD --follow-tags`);
     for (const ch of channels) {
       console.log(`[dry-run] Would publish to channel: ${ch}`);
@@ -111,15 +117,19 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
     progress("git-commit", "done");
   }
 
-  progress("git-tag", "active", `v${version}`);
-  const tagMessage = `Release v${version}\n\n${changelog}`;
-  const gitTag = await exec("git", ["tag", "-a", `v${version}`, "-m", tagMessage], { cwd });
-  if (gitTag.code !== 0) {
-    const detail = gitTag.stderr || gitTag.stdout || `exit code ${gitTag.code}`;
-    progress("git-tag", "error", detail);
-    return { version, tagCreated: false, pushed: false, channels: [], error: `git tag: ${detail}` };
+  if (skipTag) {
+    progress("git-tag", "done", "Already exists");
+  } else {
+    progress("git-tag", "active", `v${version}`);
+    const tagMessage = `Release v${version}\n\n${changelog}`;
+    const gitTag = await exec("git", ["tag", "-a", `v${version}`, "-m", tagMessage], { cwd });
+    if (gitTag.code !== 0) {
+      const detail = gitTag.stderr || gitTag.stdout || `exit code ${gitTag.code}`;
+      progress("git-tag", "error", detail);
+      return { version, tagCreated: false, pushed: false, channels: [], error: `git tag: ${detail}` };
+    }
+    progress("git-tag", "done");
   }
-  progress("git-tag", "done");
 
   progress("git-push", "active", "Pushing to origin");
   const gitPush = await exec("git", ["push", "origin", "HEAD", "--follow-tags"], { cwd });

package/src/release/version.ts

@@ -78,4 +78,22 @@ export async function isVersionReleased(
   } catch {
     return false;
   }
-}
+}
+
+/**
+ * Check whether a tag for the given version exists on the remote (origin).
+ * Returns true when `v{version}` is found via `git ls-remote --tags origin`.
+ */
+export async function isTagOnRemote(
+  exec: ExecFn,
+  cwd: string,
+  version: string,
+): Promise<boolean> {
+  try {
+    const tag = version.startsWith("v") ? version : `v${version}`;
+    const result = await exec("git", ["ls-remote", "--tags", "origin", tag], { cwd });
+    return result.code === 0 && result.stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}