supipowers 1.1.0 → 1.2.2

package/src/platform/omp.ts

@@ -1,34 +1,35 @@
 import type { Platform, AgentSession, AgentSessionOptions } from "./types.js";
 import { createPaths } from "./types.js";
 
-export function createOmpAdapter(pi: any): Platform {
+export function createOmpAdapter(api: any): Platform {
   return {
     name: "omp",
-    registerCommand: (name, opts) => pi.registerCommand(name, opts),
-    getCommands: () => pi.getCommands(),
-    getActiveTools: () => pi.getActiveTools(),
-    exec: (cmd, args, opts) => pi.exec(cmd, args, opts),
+    registerCommand: (name, opts) => api.registerCommand(name, opts),
+    getCommands: () => api.getCommands(),
+    getActiveTools: () => api.getActiveTools(),
+    exec: (cmd, args, opts) => api.exec(cmd, args, opts),
     sendMessage: (content, opts) => {
-      pi.sendMessage(content, {
+      api.sendMessage(content, {
         deliverAs: opts?.deliverAs ?? "steer",
         triggerTurn: opts?.triggerTurn ?? false,
       });
     },
-    registerMessageRenderer: (type, fn) => pi.registerMessageRenderer(type, fn),
+    sendUserMessage: (text: string) => api.sendUserMessage(text),
+    registerMessageRenderer: (type, fn) => api.registerMessageRenderer(type, fn),
 
     setModel(model: string): void {
-      pi.setModel(model);
+      api.setModel(model);
     },
     getCurrentModel(): string {
-      return pi.getCurrentModel?.() ?? "unknown";
+      return api.getCurrentModel?.() ?? "unknown";
     },
     getModelForRole(role: string): string | null {
-      return pi.getModelForRole?.(role) ?? null;
+      return api.getModelForRole?.(role) ?? null;
     },
 
     on: (event: string, handler: any) => {
       if (event === "input") {
-        pi.on("input", (evt: any, ctx: any) => {
+        api.on("input", (evt: any, ctx: any) => {
           const result = handler(evt, ctx);
           if (result?.action === "handled") return { handled: true };
           if (result?.action === "transform") return { handled: true, text: result.text };
@@ -37,18 +38,18 @@ export function createOmpAdapter(pi: any): Platform {
         return;
       }
       if (event === "session_before_compact") {
-        pi.on("session.before_compacting", handler);
+        api.on("session.before_compacting", handler);
         return;
       }
       if (event === "session_compact") {
-        pi.on("session.compacting", handler);
+        api.on("session.compacting", handler);
         return;
       }
-      pi.on(event, handler);
+      api.on(event, handler);
     },
 
     createAgentSession: async (opts: AgentSessionOptions): Promise<AgentSession> => {
-      const { createAgentSession } = pi.pi;
+      const { createAgentSession } = api.pi;
       // OMP's createAgentSession expects model?: Model (full object), not a string.
       // Our AgentSessionOptions uses model?: string (model ID). If we spread a string
       // into the `model` field, OMP thinks an explicit model was provided, skips all

package/src/platform/test-utils.ts

@@ -1,25 +1,26 @@
 // src/platform/test-utils.ts
-import { vi } from "vitest";
+import { mock } from "bun:test";
 import type { Platform, PlatformContext } from "./types.js";
 import { createPaths } from "./types.js";
 
 export function createMockPlatform(overrides?: Partial<Platform>): Platform {
   return {
-    name: "pi",
-    registerCommand: vi.fn(),
-    getCommands: vi.fn(() => []),
-    getActiveTools: vi.fn(() => []),
-    exec: vi.fn(async () => ({ stdout: "", stderr: "", code: 0 })),
-    sendMessage: vi.fn(),
-    registerMessageRenderer: vi.fn(),
-    on: vi.fn(),
-    createAgentSession: vi.fn(async () => ({
-      subscribe: vi.fn(() => () => {}),
-      prompt: vi.fn(async () => {}),
+    name: "omp",
+    registerCommand: mock(),
+    getCommands: mock(() => []),
+    getActiveTools: mock(() => []),
+    exec: mock(async () => ({ stdout: "", stderr: "", code: 0 })),
+    sendMessage: mock(),
+    sendUserMessage: mock(),
+    registerMessageRenderer: mock(),
+    on: mock(),
+    createAgentSession: mock(async () => ({
+      subscribe: mock(() => () => {}),
+      prompt: mock(async () => {}),
       state: { messages: [] },
-      dispose: vi.fn(async () => {}),
+      dispose: mock(async () => {}),
     })),
-    paths: createPaths(".pi"),
+    paths: createPaths(".omp"),
     capabilities: {
       agentSessions: true,
       compactionHooks: true,
@@ -35,9 +36,9 @@ export function createMockContext(overrides?: Partial<PlatformContext>): Platfor
     cwd: "/tmp/test",
     hasUI: true,
     ui: {
-      select: vi.fn(async () => null),
-      notify: vi.fn(),
-      input: vi.fn(async () => null),
+      select: mock(async () => null),
+      notify: mock(),
+      input: mock(async () => null),
     },
     ...overrides,
   };

package/src/platform/types.ts

@@ -5,15 +5,15 @@ import { homedir } from "node:os";
 // ── Path Resolution ────────────────────────────────────────
 
 export interface PlatformPaths {
-  /** The dot-directory name: ".pi" or ".omp" */
+  /** The dot-directory name: ".omp" */
   dotDir: string;
   /** For user-visible messages and LLM prompts */
   dotDirDisplay: string;
-  /** Resolve project-local: paths.project(cwd, "plans") → "<cwd>/.pi/supipowers/plans" */
+  /** Resolve project-local: paths.project(cwd, "plans") → "<cwd>/.omp/supipowers/plans" */
   project(cwd: string, ...segments: string[]): string;
-  /** Resolve global: paths.global("config.json") → "~/.pi/supipowers/config.json" */
+  /** Resolve global: paths.global("config.json") → "~/.omp/supipowers/config.json" */
   global(...segments: string[]): string;
-  /** Resolve agent-level: paths.agent("extensions") → "~/.pi/agent/extensions" */
+  /** Resolve agent-level: paths.agent("extensions") → "~/.omp/agent/extensions" */
   agent(...segments: string[]): string;
 }
 
@@ -113,7 +113,7 @@ export interface PlatformUI {
 // ── Platform ───────────────────────────────────────────────
 
 export interface Platform {
-  name: "pi" | "omp";
+  name: "omp";
 
   // Commands
   registerCommand(name: string, opts: any): void;
@@ -125,11 +125,12 @@ export interface Platform {
   // Execution
   exec(cmd: string, args: string[], opts?: ExecOptions): Promise<ExecResult>;
   sendMessage(content: any, opts?: SendMessageOptions): void;
+  sendUserMessage(text: string): void;
 
   // Introspection
   getActiveTools(): string[];
 
-  // Tool registration (Pi-only)
+  // Tool registration
   registerTool?(definition: any): void;
   setActiveTools?(names: string[]): void;
 

package/src/release/changelog.ts

@@ -1,6 +1,7 @@
 // src/release/changelog.ts — Conventional commit parsing and changelog generation
 
 import type { CategorizedCommits, CommitEntry } from "../types.js";
+import { IMPROVEMENT_TYPES, MAINTENANCE_TYPES, type ConventionalCommitType } from "./commit-types.js";
 
 // Matches: feat(scope)!: message  or  feat!: message  or  feat(scope): message  or  feat: message
 // Capture groups: (1) type, (2) scope|undefined, (3) breaking bang|undefined, (4) message
@@ -36,11 +37,14 @@ function parseLine(line: string): { hash: string; raw: string } | null {
  * AND `features` — the breaking array is the source of truth for what changed
  * the contract; the features array ensures it still shows up in release notes.
  */
+
 export function parseConventionalCommits(gitLog: string): CategorizedCommits {
   const result: CategorizedCommits = {
     features: [],
     fixes: [],
     breaking: [],
+    improvements: [],
+    maintenance: [],
     other: [],
   };
 
@@ -63,27 +67,25 @@ export function parseConventionalCommits(gitLog: string): CategorizedCommits {
     }
 
     const [, type, scope, bang, message] = match;
-    const entry: CommitEntry = { hash, message, ...(scope ? { scope } : {}) };
+    const entry: CommitEntry = { hash, message, type, ...(scope ? { scope } : {}) };
     const isBreaking = bang === "!";
 
+    // Route to the correct bucket based on conventional commit type
+    let bucket: CommitEntry[];
     if (type === "feat") {
-      if (isBreaking) {
-        result.breaking.push({ ...entry });
-        result.features.push(entry);
-      } else {
-        result.features.push(entry);
-      }
+      bucket = result.features;
     } else if (type === "fix") {
-      if (isBreaking) {
-        result.breaking.push({ ...entry });
-        result.fixes.push(entry);
-      } else {
-        result.fixes.push(entry);
-      }
+      bucket = result.fixes;
+    } else if (IMPROVEMENT_TYPES.has(type as ConventionalCommitType)) {
+      bucket = result.improvements;
+    } else if (MAINTENANCE_TYPES.has(type as ConventionalCommitType)) {
+      bucket = result.maintenance;
     } else {
-      // Any other conventional type (chore, docs, refactor, etc.) → other
-      result.other.push(entry);
+      bucket = result.other;
     }
+
+    if (isBreaking) result.breaking.push({ ...entry });
+    bucket.push(entry);
   }
 
   return result;
@@ -113,10 +115,12 @@ export function buildChangelogMarkdown(
   lines.push("");
 
   const sections: [string, CommitEntry[]][] = [
-    ["### 🚨 Breaking Changes", commits.breaking],
-    ["### ✨ Features", commits.features],
-    ["### 🐛 Fixes", commits.fixes],
-    ["### 📦 Other", commits.other],
+    ["### \u{1F6A8} Breaking Changes", commits.breaking],
+    ["### \u{2728} Features", commits.features],
+    ["### \u{1F41B} Fixes", commits.fixes],
+    ["### \u{1F527} Improvements", commits.improvements],
+    ["### \u{1F3D7}\uFE0F Maintenance", commits.maintenance],
+    ["### \u{1F4E6} Other", commits.other],
   ];
 
   let firstSection = true;
@@ -142,7 +146,7 @@ export function buildChangelogMarkdown(
 export function summarizeChanges(commits: CategorizedCommits): string {
   const parts: string[] = [];
 
-  const { features, fixes, breaking } = commits;
+  const { features, fixes, breaking, improvements, maintenance } = commits;
 
   if (features.length > 0) {
     parts.push(`${features.length} feature${features.length === 1 ? "" : "s"}`);
@@ -150,6 +154,12 @@ export function summarizeChanges(commits: CategorizedCommits): string {
   if (fixes.length > 0) {
     parts.push(`${fixes.length} fix${fixes.length === 1 ? "" : "es"}`);
   }
+  if (improvements.length > 0) {
+    parts.push(`${improvements.length} improvement${improvements.length === 1 ? "" : "s"}`);
+  }
+  if (maintenance.length > 0) {
+    parts.push(`${maintenance.length} maintenance`);
+  }
   if (breaking.length > 0) {
     parts.push(
       `${breaking.length} breaking change${breaking.length === 1 ? "" : "s"}`

package/src/release/commit-types.ts

@@ -0,0 +1,35 @@
+// src/release/commit-types.ts — Single source of truth for conventional commit types
+
+/** All valid conventional commit type prefixes. */
+export const VALID_COMMIT_TYPES = [
+  "feat",
+  "fix",
+  "refactor",
+  "perf",
+  "revert",
+  "chore",
+  "ci",
+  "build",
+  "test",
+  "docs",
+  "style",
+] as const;
+
+export type ConventionalCommitType = (typeof VALID_COMMIT_TYPES)[number];
+
+/** Types that land in the "improvements" changelog bucket. */
+export const IMPROVEMENT_TYPES = new Set<ConventionalCommitType>([
+  "refactor",
+  "perf",
+  "revert",
+]);
+
+/** Types that land in the "maintenance" changelog bucket. */
+export const MAINTENANCE_TYPES = new Set<ConventionalCommitType>([
+  "chore",
+  "ci",
+  "build",
+  "test",
+  "docs",
+  "style",
+]);

package/src/release/executor.ts

@@ -2,6 +2,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ReleaseChannel, ReleaseResult } from "../types.js";
+import { commitStaged } from "../git/commit.js";
 
 type ExecFn = (
   cmd: string,
@@ -9,6 +10,9 @@ type ExecFn = (
   opts?: { cwd?: string },
 ) => Promise<{ stdout: string; stderr: string; code: number }>;
 
+/** Callback to report step progress during release execution. */
+export type ReleaseProgressFn = (step: string, status: "active" | "done" | "error", detail?: string) => void;
+
 export interface ExecuteReleaseOptions {
   exec: ExecFn;
   cwd: string;
@@ -16,6 +20,10 @@ export interface ExecuteReleaseOptions {
   changelog: string;
   channels: ReleaseChannel[];
   dryRun: boolean;
+  /** Skip the package.json version write (version was already set locally). */
+  skipBump?: boolean;
+  /** Optional callback for step-by-step progress reporting. */
+  onProgress?: ReleaseProgressFn;
 }
 
 /**
@@ -29,13 +37,14 @@ 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 } = opts;
+  const { exec, cwd, version, changelog, channels, dryRun, skipBump, onProgress } = opts;
+  const progress = onProgress ?? (() => {});
 
   if (dryRun) {
     console.log(`[dry-run] Would build (if scripts.build exists)`);
     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 "release: v${version}"`);
+    console.log(`[dry-run] Would git commit -m "chore(release): v${version}"`);
     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) {
@@ -56,46 +65,79 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
 
   const scripts = pkg["scripts"] as Record<string, string> | undefined;
   if (scripts?.["build"]) {
+    progress("build", "active", "Running build script");
     const buildResult = await exec("bun", ["run", "build"], { cwd });
     if (buildResult.code !== 0) {
-      throw new Error("Build failed");
+      progress("build", "error", buildResult.stderr || "Non-zero exit");
+      throw new Error(`Build failed: ${buildResult.stderr || "non-zero exit"}`);
     }
+    progress("build", "done");
   }
 
   // ── 2. Bump version in package.json ──────────────────────────────────────
-  pkg["version"] = version;
-  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+  if (skipBump) {
+    progress("version-bump", "done", "Already set");
+  } else {
+    progress("version-bump", "active", `Bumping to ${version}`);
+    pkg["version"] = version;
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+    progress("version-bump", "done");
+  }
 
   // ── 3–6. Git operations ──────────────────────────────────────────────────
 
-  const gitAdd = await exec("git", ["add", "-A"], { cwd });
-  if (gitAdd.code !== 0) {
-    return { version, tagCreated: false, pushed: false, channels: [] };
-  }
-
-  const gitCommit = await exec("git", ["commit", "-m", `release: v${version}`], { cwd });
-  if (gitCommit.code !== 0) {
-    return { version, tagCreated: false, pushed: false, channels: [] };
+  // When skipBump is true the version was already committed locally —
+  // there's nothing to stage or commit, so skip straight to tag+push.
+  if (skipBump) {
+    progress("git-add", "done", "Skipped (no changes)");
+    progress("git-commit", "done", "Skipped (already committed)");
+  } else {
+    progress("git-add", "active", "git add -A");
+    const gitAdd = await exec("git", ["add", "-A"], { cwd });
+    if (gitAdd.code !== 0) {
+      const detail = gitAdd.stderr || gitAdd.stdout || `exit code ${gitAdd.code}`;
+      progress("git-add", "error", detail);
+      return { version, tagCreated: false, pushed: false, channels: [], error: `git add: ${detail}` };
+    }
+    progress("git-add", "done");
+
+    const commitMessage = `chore(release): v${version}`;
+    progress("git-commit", "active", commitMessage);
+    const commitResult = await commitStaged(exec, cwd, commitMessage);
+    if (!commitResult.success) {
+      progress("git-commit", "error", commitResult.error);
+      return { version, tagCreated: false, pushed: false, channels: [], error: commitResult.error! };
+    }
+    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) {
-    return { version, tagCreated: false, pushed: false, channels: [] };
+    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-push", "active", "Pushing to origin");
   const gitPush = await exec("git", ["push", "origin", "HEAD", "--follow-tags"], { cwd });
   if (gitPush.code !== 0) {
+    const detail = gitPush.stderr || gitPush.stdout || `exit code ${gitPush.code}`;
+    progress("git-push", "error", detail);
     // Tag was created locally but push failed
-    return { version, tagCreated: true, pushed: false, channels: [] };
+    return { version, tagCreated: true, pushed: false, channels: [], error: `git push: ${detail}` };
   }
+  progress("git-push", "done");
 
   // ── 7. Channel publishing ─────────────────────────────────────────────────
   const channelResults: ReleaseResult["channels"] = [];
 
   for (const channel of channels) {
+    progress(`publish-${channel}`, "active", `Publishing to ${channel}`);
     try {
-      let result: { code: number; stderr: string };
+      let result: { code: number; stdout: string; stderr: string };
       if (channel === "github") {
         result = await exec(
           "gh",
@@ -108,20 +150,17 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
       }
 
       if (result.code !== 0) {
-        channelResults.push({
-          channel,
-          success: false,
-          error: result.stderr || `${channel} publish exited with code ${result.code}`,
-        });
+        const err = result.stderr || result.stdout || `${channel} publish exited with code ${result.code}`;
+        progress(`publish-${channel}`, "error", err);
+        channelResults.push({ channel, success: false, error: err });
       } else {
+        progress(`publish-${channel}`, "done");
         channelResults.push({ channel, success: true });
       }
     } catch (err) {
-      channelResults.push({
-        channel,
-        success: false,
-        error: err instanceof Error ? err.message : String(err),
-      });
+      const msg = err instanceof Error ? err.message : String(err);
+      progress(`publish-${channel}`, "error", msg);
+      channelResults.push({ channel, success: false, error: msg });
     }
   }
 

package/src/release/prompt.ts

@@ -46,7 +46,7 @@ export function buildPolishPrompt(opts: BuildPolishPromptOpts): string {
     "   - Group closely related changes together under the same bullet.",
     "   - Remove noise (chores, reformats, typo fixes) unless they fix a user-visible bug.",
     "   - Do **not** change version numbers.",
-    "   - Do **not** skip or reorder the section headings (Features, Fixes, Breaking Changes).",
+    "   - Do **not** skip or reorder the section headings (Breaking Changes, Features, Fixes, Improvements, Maintenance, Other).",
     "   - Do **not** invent changes that are not in the raw changelog.",
     "",
     "2. **Present** the polished changelog to the user in a readable format.",

package/src/release/version.ts

@@ -2,6 +2,12 @@ import fs from "fs";
 import path from "path";
 import type { BumpType, CategorizedCommits } from "../types.js";
 
+type ExecFn = (
+  cmd: string,
+  args: string[],
+  opts?: { cwd?: string },
+) => Promise<{ stdout: string; stderr: string; code: number }>;
+
 /**
  * Suggest a semver bump type based on categorized commits.
  * Breaking changes win over features; features win over everything else.
@@ -52,3 +58,24 @@ export function getCurrentVersion(cwd: string): string {
     return "0.0.0";
   }
 }
+
+
+/**
+ * Check whether a tag for the given version already exists locally.
+ * Returns `true` when `v{version}` is a known git tag — meaning this
+ * version has already been released and a bump is needed.
+ */
+export async function isVersionReleased(
+  exec: ExecFn,
+  cwd: string,
+  version: string,
+): Promise<boolean> {
+  try {
+    const tag = version.startsWith("v") ? version : `v${version}`;
+    const result = await exec("git", ["tag", "-l", tag], { cwd });
+    // git tag -l prints matching tags, one per line. Non-empty = exists.
+    return result.code === 0 && result.stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}

package/src/storage/plans.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { Plan, PlanTask, TaskComplexity, TaskParallelism } from "../types.js";
+import type { Plan, PlanTask, TaskComplexity } from "../types.js";
 import type { PlatformPaths } from "../platform/types.js";
 
 function getPlansDir(paths: PlatformPaths, cwd: string): string {
@@ -97,26 +97,16 @@ function parseTasksFromMarkdown(content: string): PlanTask[] {
     const body = stripped.slice(startIdx, endIdx);
 
     const name = headerLine.replace(/\[.*?\]/g, "").trim();
-    const parallelism = parseParallelism(headerLine);
     const model = parseModel(headerLine);
     const files = parseFiles(body);
     const criteria = parseCriteria(body);
     const complexity = parseComplexity(body);
 
-    tasks.push({ id, name, description: name, files, criteria, complexity, parallelism, ...(model ? { model } : {}) });
+    tasks.push({ id, name, description: name, files, criteria, complexity, ...(model ? { model } : {}) });
   }
   return tasks;
 }
 
-function parseParallelism(header: string): TaskParallelism {
-  if (header.includes("[parallel-safe]")) return { type: "parallel-safe" };
-  const seqMatch = header.match(/\[sequential: depends on (\d[\d, ]*)\]/);
-  if (seqMatch) {
-    const deps = seqMatch[1].split(",").map((s) => parseInt(s.trim(), 10));
-    return { type: "sequential", dependsOn: deps };
-  }
-  return { type: "sequential", dependsOn: [] };
-}
 
 function parseModel(header: string): string | undefined {
   const match = header.match(/\[model:\s*([^\]]+)\]/);