supipowers 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pedro Mendes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,194 @@
+<img width="1584" height="672" alt="image" src="https://github.com/user-attachments/assets/ec0f3658-54d7-4471-91ba-39297191f055" />
+
+# Supipowers
+
+Agentic workflows for [OMP](https://github.com/can1357/oh-my-pi). Plan features, orchestrate sub-agents, run quality gates, and ship releases — all from slash commands.
+
+## Install
+
+```bash
+bunx supipowers@latest
+```
+
+The installer checks for OMP, helps you install it if needed, sets up supipowers, and optionally configures LSP servers for your project.
+
+### Manual install
+
+```bash
+# Global (all projects)
+omp install npm:supipowers
+
+# Project-local
+omp install npm:supipowers -l
+```
+
+## Commands
+
+| Command         | What it does                                     |
+| --------------- | ------------------------------------------------ |
+| `/supi`         | Overview — available commands and project status |
+| `/supi:plan`    | Collaborative planning with task breakdown       |
+| `/supi:run`     | Execute a plan with parallel sub-agents          |
+| `/supi:review`  | Quality gates at chosen depth                    |
+| `/supi:qa`      | Run test suite and E2E pipeline                  |
+| `/supi:release` | Version bump, release notes, publish             |
+| `/supi:config`  | View and edit configuration                      |
+| `/supi:status`  | Check running sub-agents and progress            |
+
+### Planning
+
+```
+/supi:plan add authentication to the API
+```
+
+Starts an interactive planning session: clarifying questions, approach proposals, then a structured task breakdown saved to `.omp/supipowers/plans/`.
+
+For simple tasks, skip the brainstorming:
+
+```
+/supi:plan --quick add rate limiting middleware
+```
+
+### Running plans
+
+```
+/supi:run
+```
+
+Loads the latest plan and executes it with sub-agent orchestration. Tasks marked `[parallel-safe]` run concurrently (up to the configured limit). Sequential tasks respect their dependency chains.
+
+The orchestration loop: dispatch batch → collect results → detect conflicts → retry failures → next batch. If interrupted, re-running picks up where it left off.
+
+### Quality review
+
+```
+/supi:review           # uses default profile
+/supi:review --quick   # fast: LSP diagnostics + AI scan
+/supi:review --thorough  # deep: full AI review + code quality
+/supi:review --full    # everything: tests + E2E + all gates
+```
+
+### QA
+
+```
+/supi:qa              # full test suite
+/supi:qa --changed    # tests for changed files only
+/supi:qa --e2e        # Playwright / E2E only
+```
+
+Detects your test framework on first run (vitest, jest, pytest, cargo test, go test) and caches it.
+
+### Release
+
+```
+/supi:release
+```
+
+Analyzes commits since last tag, suggests a version bump, generates release notes, and publishes (npm, GitHub release, or manual — configured on first run).
+
+## Configuration
+
+Layered config: project (`.omp/supipowers/config.json`) overrides global (`~/.omp/supipowers/config.json`).
+
+```
+/supi:config                                    # view current config
+/supi:config set orchestration.maxParallelAgents 5
+/supi:config set defaultProfile thorough
+```
+
+### Profiles
+
+Three built-in profiles control quality gate depth:
+
+| Profile           | LSP | AI Review   | Code Quality | Tests | E2E |
+| ----------------- | --- | ----------- | ------------ | ----- | --- |
+| `quick`           | yes | quick scan  | no           | no    | no  |
+| `thorough`        | yes | deep review | yes          | no    | no  |
+| `full-regression` | yes | deep review | yes          | yes   | yes |
+
+Create custom profiles in `.omp/supipowers/profiles/`.
+
+### Key settings
+
+```jsonc
+{
+  "defaultProfile": "thorough",
+  "orchestration": {
+    "maxParallelAgents": 3, // concurrent sub-agents per batch
+    "maxFixRetries": 2, // retry failed tasks
+    "maxNestingDepth": 2, // sub-agent nesting limit
+    "modelPreference": "auto", // "auto" | "fast" | "capable" | "<model-id>"
+  },
+  "lsp": {
+    "autoDetect": true,
+    "setupGuide": true,
+  },
+  "qa": {
+    "framework": null, // auto-detected and cached
+    "command": null,
+  },
+}
+```
+
+## How it works
+
+Supipowers is built on OMP's extension API. Every command is an immediate action — no state machine, no workflow phases.
+
+**Sub-agent orchestration**: Plans are broken into batches of parallel-safe tasks. Each batch dispatches sub-agents with full OMP tool access (file editing, bash, LSP). After a batch completes, the orchestrator checks for file conflicts, retries failures, and moves to the next batch.
+
+**Quality gates**: Composable checks selected by profile. LSP diagnostics feed real type errors. AI review catches logic issues. Test gates run your actual test suite. Gates report issues with severity levels (error/warning/info).
+
+**LSP integration**: Sub-agents query LSP before making changes (find references, check diagnostics). If no LSP is active, everything still works — just better with it. Run `/supi:config` for setup guidance.
+
+## Project structure
+
+```
+src/
+  index.ts                     # extension entry point
+  commands/                    # slash command handlers
+    supi.ts, plan.ts, run.ts, review.ts, qa.ts, release.ts, config.ts, status.ts
+  orchestrator/                # sub-agent dispatch & coordination
+    batch-scheduler.ts, dispatcher.ts, result-collector.ts, conflict-resolver.ts, prompts.ts
+  quality/                     # composable quality gates
+    gate-runner.ts, lsp-gate.ts, ai-review-gate.ts, test-gate.ts
+  qa/                          # QA pipeline
+    detector.ts, runner.ts, report.ts
+  lsp/                         # LSP integration
+    detector.ts, bridge.ts, setup-guide.ts
+  notifications/               # rich inline notifications
+    renderer.ts, types.ts
+  config/                      # configuration & profiles
+    loader.ts, profiles.ts, defaults.ts, schema.ts
+  storage/                     # persistence
+    plans.ts, runs.ts, reports.ts
+  release/                     # release automation
+    analyzer.ts, notes.ts, publisher.ts
+  types.ts                     # shared type definitions
+skills/
+  planning/SKILL.md
+  code-review/SKILL.md
+  debugging/SKILL.md
+  qa-strategy/SKILL.md
+bin/
+  install.mjs                  # bunx installer
+```
+
+## Development
+
+```bash
+git clone https://github.com/pedromendes/supipowers.git
+cd supipowers
+bun install
+bun run test        # run tests
+bun run typecheck   # type checking
+bun run test:watch  # watch mode
+```
+
+## Requirements
+
+- [OMP](https://github.com/can1357/oh-my-pi) (oh-my-pi)
+- [Bun](https://bun.sh) runtime
+
+## License
+
+MIT

package/bin/install.mjs

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+
+import {
+  intro,
+  outro,
+  confirm,
+  select,
+  multiselect,
+  spinner,
+  isCancel,
+  cancel,
+  note,
+} from "@clack/prompts";
+import { spawnSync } from "node:child_process";
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { resolve, extname, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+
+// ── Helpers ──────────────────────────────────────────────────
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(
+  readFileSync(resolve(__dirname, "..", "package.json"), "utf8")
+);
+const VERSION = pkg.version;
+
+function run(cmd, args, opts = {}) {
+  return spawnSync(cmd, args, {
+    stdio: "pipe",
+    encoding: "utf8",
+    timeout: 120_000,
+    ...opts,
+  });
+}
+
+function bail(msg) {
+  cancel(msg);
+  process.exit(1);
+}
+
+function findOmpBinary() {
+  // Check PATH first
+  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;
+  }
+
+  return null;
+}
+
+// ── LSP Server Data ──────────────────────────────────────────
+
+const LSP_SERVERS = [
+  {
+    language: "TypeScript / JavaScript",
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+    server: "typescript-language-server",
+    installCmd: "bun add -g typescript-language-server typescript",
+  },
+  {
+    language: "Python",
+    extensions: [".py"],
+    server: "pyright",
+    installCmd: "pip install pyright",
+  },
+  {
+    language: "Rust",
+    extensions: [".rs"],
+    server: "rust-analyzer",
+    installCmd: "rustup component add rust-analyzer",
+  },
+  {
+    language: "Go",
+    extensions: [".go"],
+    server: "gopls",
+    installCmd: "go install golang.org/x/tools/gopls@latest",
+  },
+];
+
+function detectLanguages(dir) {
+  const detected = new Set();
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        detected.add(extname(entry.name));
+      } else if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        // One level deep
+        try {
+          const subEntries = readdirSync(join(dir, entry.name), { withFileTypes: true });
+          for (const sub of subEntries) {
+            if (sub.isFile()) detected.add(extname(sub.name));
+          }
+        } catch {
+          // skip unreadable dirs
+        }
+      }
+    }
+  } catch {
+    // skip
+  }
+  return detected;
+}
+
+// ── Main ─────────────────────────────────────────────────────
+
+async function main() {
+  intro(`supipowers v${VERSION}`);
+
+  // ── Step 1: OMP check ──────────────────────────────────────
+
+  let omp = findOmpBinary();
+
+  if (!omp) {
+    note(
+      "OMP (oh-my-pi) is an AI coding agent that supipowers extends.\n" +
+        "It adds sub-agents, LSP integration, and plugin support to pi.\n" +
+        "Learn more: https://github.com/can1357/oh-my-pi",
+      "OMP not found"
+    );
+
+    const shouldInstall = await confirm({
+      message: "Install OMP now?",
+    });
+    if (isCancel(shouldInstall) || !shouldInstall) {
+      bail("Cannot continue without OMP.");
+    }
+
+    const s = spinner();
+    s.start("Installing OMP via bun...");
+    const result = run("bun", ["add", "-g", "@oh-my-pi/pi-coding-agent"]);
+    if (result.status !== 0) {
+      s.stop("OMP installation failed");
+      bail(result.stderr?.trim() || "Unknown error during OMP install.");
+    }
+    s.stop("OMP installed successfully");
+
+    // Re-detect after install
+    omp = findOmpBinary();
+    if (!omp) {
+      bail("OMP was installed but the binary was not found in PATH. Try restarting your shell.");
+    }
+  } else {
+    const version = run(omp, ["--version"]);
+    const ver = version.stdout?.trim() || "unknown";
+    note(`OMP ${ver}`, "OMP detected");
+  }
+
+  // ── Step 2: Install supipowers ─────────────────────────────
+
+  const scope = await select({
+    message: "Where should supipowers be installed?",
+    options: [
+      { value: "global", label: "Global", hint: "available in all projects" },
+      { value: "local", label: "Project-local", hint: "only this directory" },
+    ],
+  });
+  if (isCancel(scope)) bail("Cancelled.");
+
+  const packageSpec = `npm:supipowers@${VERSION}`;
+  const installArgs = ["install", packageSpec];
+  if (scope === "local") installArgs.push("-l");
+
+  const s = spinner();
+  s.start(`Installing supipowers (${scope})...`);
+  const result = run(omp, installArgs);
+  if (result.status !== 0) {
+    s.stop("Installation failed");
+    bail(result.stderr?.trim() || "omp install failed.");
+  }
+  s.stop("supipowers installed");
+
+  // ── Step 3: LSP setup (optional) ──────────────────────────
+
+  const detectedExts = detectLanguages(process.cwd());
+  const matchingServers = LSP_SERVERS.filter((srv) =>
+    srv.extensions.some((ext) => detectedExts.has(ext))
+  );
+
+  if (matchingServers.length > 0) {
+    const selected = await multiselect({
+      message: "Detected project languages. Install LSP servers for better code intelligence?",
+      options: matchingServers.map((srv) => ({
+        value: srv,
+        label: srv.language,
+        hint: srv.server,
+      })),
+      required: false,
+    });
+
+    if (!isCancel(selected) && selected.length > 0) {
+      for (const srv of selected) {
+        const ls = spinner();
+        ls.start(`Installing ${srv.server}...`);
+        const [cmd, ...args] = srv.installCmd.split(" ");
+        const r = run(cmd, args);
+        if (r.status !== 0) {
+          ls.stop(`Failed to install ${srv.server} — you can install manually: ${srv.installCmd}`);
+        } else {
+          ls.stop(`${srv.server} installed`);
+        }
+      }
+    }
+  }
+
+  // ── Done ───────────────────────────────────────────────────
+
+  outro("supipowers is ready! Run `omp` to start using it.");
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "supipowers",
+  "version": "0.1.0",
+  "description": "OMP-native workflow extension inspired by Superpowers.",
+  "type": "module",
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "test:watch": "vitest",
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "keywords": ["omp-extension", "workflow", "agent", "superpowers"],
+  "license": "MIT",
+  "bin": {
+    "supipowers": "./bin/install.mjs"
+  },
+  "files": ["src", "skills", "bin", "README.md", "LICENSE"],
+  "dependencies": {
+    "@clack/prompts": "^0.10.0"
+  },
+  "peerDependencies": {
+    "@oh-my-pi/pi-coding-agent": "*",
+    "@oh-my-pi/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  },
+  "devDependencies": {
+    "@oh-my-pi/pi-coding-agent": "latest",
+    "@oh-my-pi/pi-tui": "latest",
+    "@sinclair/typebox": "^0.34.48",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.0"
+  },
+  "omp": {
+    "extensions": ["./src/index.ts"],
+    "skills": ["./skills"]
+  }
+}

package/skills/code-review/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: code-review
+description: Deep code review methodology for thorough quality assessment
+---
+
+# Code Review Skill
+
+Systematic approach to reviewing code changes.
+
+## Review Checklist
+
+### Correctness
+- Does the code do what it claims?
+- Are edge cases handled?
+- Are error conditions handled?
+
+### Security
+- Input validation at system boundaries?
+- SQL injection, XSS, command injection risks?
+- Secrets in code or logs?
+- Authentication/authorization checks?
+
+### Performance
+- Unnecessary loops or allocations?
+- N+1 query patterns?
+- Missing indexes for frequent queries?
+- Large payloads or unbounded lists?
+
+### Maintainability
+- Clear naming (functions, variables, files)?
+- Single responsibility per unit?
+- Unnecessary abstractions or premature optimization?
+- Comments where logic isn't self-evident?
+
+### Testing
+- Tests cover the happy path?
+- Tests cover error/edge cases?
+- Tests are deterministic (no flaky tests)?
+- Test names describe the behavior?
+
+## Severity Levels
+
+- **error**: Must fix before merge. Bugs, security issues, data loss risks.
+- **warning**: Should fix. Code quality, maintainability, minor issues.
+- **info**: Nice to have. Style, naming suggestions, minor improvements.

package/skills/debugging/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: debugging
+description: Systematic debugging approach — investigate before fixing
+---
+
+# Debugging Skill
+
+## Process
+
+1. **Reproduce**: Can you reliably trigger the bug?
+2. **Isolate**: What's the smallest input that triggers it?
+3. **Investigate**: Read the relevant code. Trace the execution path.
+4. **Hypothesize**: Form a theory about the root cause.
+5. **Verify**: Add logging or a test that confirms the theory.
+6. **Fix**: Make the minimal change that fixes the root cause.
+7. **Validate**: Run the reproducer and existing tests.
+
+## Rules
+
+- Never guess-and-fix. Investigate first.
+- After 3 failed fix attempts, step back and question your assumptions.
+- Fix the root cause, not the symptom.
+- Add a test that would have caught this bug.

package/skills/planning/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: planning
+description: Guides collaborative planning and task breakdown for implementation
+---
+
+# Planning Skill
+
+Guide the user through planning an implementation. This skill is loaded by `/supi:plan`.
+
+## Process
+
+1. **Understand**: Ask one clarifying question at a time. Prefer multiple choice.
+2. **Propose**: Offer 2-3 approaches with trade-offs and your recommendation.
+3. **Break down**: Generate bite-sized tasks with clear boundaries.
+
+## Task Format
+
+Each task must have:
+- Name with parallelism: `[parallel-safe]` or `[sequential: depends on N]`
+- **files**: Exact paths the agent will touch
+- **criteria**: Acceptance criteria (testable)
+- **complexity**: `small` | `medium` | `large`
+
+## Plan Structure
+
+Use this template:
+
+```
+---
+name: <feature-name>
+created: <YYYY-MM-DD>
+tags: [<relevant>, <tags>]
+---
+
+# <Feature Name>
+
+## Context
+<What this plan accomplishes and why>
+
+## Tasks
+
+### 1. <Task name> [parallel-safe]
+- **files**: src/path/to/file.ts
+- **criteria**: <what success looks like>
+- **complexity**: small
+```
+
+## Principles
+
+- Each task should be completable in 2-10 minutes
+- Tasks that touch different files are parallel-safe
+- Tasks that depend on others' output are sequential
+- Include test files in the files list
+- Prefer small, focused tasks over large ones

package/skills/qa-strategy/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: qa-strategy
+description: QA test planning for comprehensive coverage
+---
+
+# QA Strategy Skill
+
+## Test Pyramid
+
+1. **Unit tests**: Fast, isolated, cover individual functions
+2. **Integration tests**: Test component interactions
+3. **E2E tests**: Test user-facing flows end-to-end
+
+## When to Write What
+
+- New function → unit test
+- New API endpoint → integration test
+- New user flow → E2E test
+- Bug fix → regression test at the appropriate level
+
+## Coverage Priorities
+
+Focus testing effort on:
+1. Business logic (highest value)
+2. Error handling paths
+3. Edge cases in input validation
+4. Integration points (API boundaries, DB queries)
+
+Don't test:
+- Framework boilerplate
+- Simple getters/setters
+- Third-party library behavior