supipowers 1.1.0 → 1.2.2

package/src/git/conventions.ts

@@ -0,0 +1,215 @@
+// src/git/conventions.ts — Discover commit message conventions from repo docs and config
+
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+type ExecFn = (
+  cmd: string,
+  args: string[],
+  opts?: { cwd?: string },
+) => Promise<{ stdout: string; code: number }>;
+
+export interface CommitConventions {
+  /** Concatenated relevant sections from repo docs */
+  guidelines: string;
+  /** Source files that were found */
+  sources: string[];
+}
+
+/** Max total output size — prevents blowing up the agent prompt */
+const MAX_GUIDELINES_BYTES = 4096;
+
+/**
+ * Discover commit conventions by scanning well-known files and config.
+ * Pure I/O — reads filesystem and one git config query, no side effects.
+ */
+export async function discoverCommitConventions(
+  exec: ExecFn,
+  cwd: string,
+): Promise<CommitConventions> {
+  const sections: { source: string; content: string }[] = [];
+
+  // ── Markdown docs (extract commit-related sections) ──────
+  for (const file of ["CONTRIBUTING.md", "AGENTS.md"]) {
+    const content = readFileSafe(join(cwd, file));
+    if (content) {
+      const extracted = extractCommitSections(content);
+      if (extracted) {
+        sections.push({ source: file, content: extracted });
+      }
+    }
+  }
+
+  // ── Dedicated commit convention files (read in full) ─────
+  for (const file of ["COMMIT.md", "COMMIT_CONVENTIONS.md"]) {
+    const content = readFileSafe(join(cwd, file));
+    if (content) {
+      sections.push({ source: file, content });
+    }
+  }
+
+  // ── Commitlint config ────────────────────────────────────
+  for (const file of [
+    ".commitlintrc.json",
+    ".commitlintrc.yml",
+    ".commitlintrc.js",
+  ]) {
+    const content = readFileSafe(join(cwd, file));
+    if (content) {
+      sections.push({ source: file, content });
+    }
+  }
+
+  // ── Commitizen config ────────────────────────────────────
+  for (const file of [".czrc", ".cz.json"]) {
+    const content = readFileSafe(join(cwd, file));
+    if (content) {
+      sections.push({ source: file, content });
+    }
+  }
+
+  // ── package.json — commitlint / commitizen fields ────────
+  const pkgContent = readFileSafe(join(cwd, "package.json"));
+  if (pkgContent) {
+    try {
+      const pkg = JSON.parse(pkgContent);
+      const relevant: Record<string, unknown> = {};
+      if (pkg.commitlint) relevant.commitlint = pkg.commitlint;
+      if (pkg.config?.commitizen) relevant["config.commitizen"] = pkg.config.commitizen;
+      if (Object.keys(relevant).length > 0) {
+        sections.push({
+          source: "package.json",
+          content: JSON.stringify(relevant, null, 2),
+        });
+      }
+    } catch {
+      // Malformed package.json — skip
+    }
+  }
+
+  // ── Commit hooks ─────────────────────────────────────────
+  for (const hookPath of [
+    join(cwd, ".husky", "commit-msg"),
+    join(cwd, ".git", "hooks", "commit-msg"),
+  ]) {
+    const content = readFileSafe(hookPath);
+    if (content) {
+      const relative = hookPath.startsWith(cwd)
+        ? hookPath.slice(cwd.length + 1)
+        : hookPath;
+      sections.push({ source: relative, content });
+    }
+  }
+
+  // ── Git commit template ──────────────────────────────────
+  try {
+    const result = await exec(
+      "git",
+      ["config", "commit.template"],
+      { cwd },
+    );
+    if (result.code === 0 && result.stdout.trim()) {
+      const templatePath = result.stdout.trim();
+      const absPath = templatePath.startsWith("/")
+        ? templatePath
+        : join(cwd, templatePath);
+      const content = readFileSafe(absPath);
+      if (content) {
+        sections.push({ source: `commit.template (${templatePath})`, content });
+      }
+    }
+  } catch {
+    // git config query failed — skip
+  }
+
+  // ── Assemble and truncate ────────────────────────────────
+  if (sections.length === 0) {
+    return { guidelines: "", sources: [] };
+  }
+
+  let guidelines = sections
+    .map((s) => `### ${s.source}\n${s.content}`)
+    .join("\n\n");
+
+  if (Buffer.byteLength(guidelines, "utf8") > MAX_GUIDELINES_BYTES) {
+    // Truncate by sections from the end until under limit
+    while (
+      sections.length > 1 &&
+      Buffer.byteLength(guidelines, "utf8") > MAX_GUIDELINES_BYTES
+    ) {
+      sections.pop();
+      guidelines = sections
+        .map((s) => `### ${s.source}\n${s.content}`)
+        .join("\n\n");
+    }
+    // If a single section is still too large, hard-truncate
+    if (Buffer.byteLength(guidelines, "utf8") > MAX_GUIDELINES_BYTES) {
+      guidelines = guidelines.slice(0, MAX_GUIDELINES_BYTES) + "\n[truncated]";
+    }
+  }
+
+  return {
+    guidelines,
+    sources: sections.map((s) => s.source),
+  };
+}
+
+// ── Helpers ──────────────────────────────────────────────────
+
+function readFileSafe(path: string): string | null {
+  try {
+    if (!existsSync(path)) return null;
+    const content = readFileSync(path, "utf8");
+    return content.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract markdown sections whose headings mention commit conventions.
+ * Returns null if no relevant sections found.
+ */
+function extractCommitSections(markdown: string): string | null {
+  const lines = markdown.split("\n");
+  const HEADING_RE = /^(#{1,4})\s+(.+)$/;
+  const KEYWORDS_RE = /commit|conventional|message format/i;
+
+  const sections: string[] = [];
+  let capturing = false;
+  let captureLevel = 0;
+  let buffer: string[] = [];
+
+  for (const line of lines) {
+    const headingMatch = HEADING_RE.exec(line);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      const title = headingMatch[2];
+
+      // If we were capturing, a same-or-higher-level heading ends the section
+      if (capturing && level <= captureLevel) {
+        sections.push(buffer.join("\n"));
+        buffer = [];
+        capturing = false;
+      }
+
+      if (KEYWORDS_RE.test(title)) {
+        capturing = true;
+        captureLevel = level;
+        buffer.push(line);
+        continue;
+      }
+    }
+
+    if (capturing) {
+      buffer.push(line);
+    }
+  }
+
+  // Flush last section
+  if (capturing && buffer.length > 0) {
+    sections.push(buffer.join("\n"));
+  }
+
+  return sections.length > 0 ? sections.join("\n\n") : null;
+}

package/src/git/status.ts

@@ -0,0 +1,27 @@
+type ExecFn = (cmd: string, args: string[], opts?: { cwd?: string }) => Promise<{ stdout: string; code: number }>;
+
+export interface WorkingTreeStatus {
+  dirty: boolean;
+  /** Files with uncommitted changes (staged + unstaged + untracked) */
+  files: string[];
+}
+
+/**
+ * Check whether the working tree has uncommitted changes.
+ * Returns dirty: false on non-git dirs or exec errors — don't block the caller.
+ */
+export async function getWorkingTreeStatus(exec: ExecFn, cwd: string): Promise<WorkingTreeStatus> {
+  try {
+    const result = await exec("git", ["status", "--porcelain"], { cwd });
+    if (result.code !== 0) {
+      return { dirty: false, files: [] };
+    }
+    const files = result.stdout
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => line.slice(3)); // strip 2-char status + space
+    return { dirty: files.length > 0, files };
+  } catch {
+    return { dirty: false, files: [] };
+  }
+}

package/src/global.d.ts

@@ -0,0 +1,5 @@
+// Allow importing .md files (required by @oh-my-pi/pi-ai transitive imports)
+declare module "*.md" {
+  const content: string;
+  export default content;
+}

package/src/index.ts

@@ -1,13 +1,7 @@
-import { detectPlatform } from "./platform/detect.js";
 import { createOmpAdapter } from "./platform/omp.js";
-import { createPiAdapter } from "./platform/pi.js";
 import { bootstrap } from "./bootstrap.js";
 
 export default function supipowers(rawApi: any): void {
-  const platformType = detectPlatform(rawApi);
-  const platform = platformType === "omp"
-    ? createOmpAdapter(rawApi)
-    : createPiAdapter(rawApi);
-
+  const platform = createOmpAdapter(rawApi);
   bootstrap(platform);
 }

package/src/mcp/config.ts

@@ -1,8 +1,9 @@
 // src/mcp/config.ts
 import * as fs from "node:fs";
+import { homedir } from "node:os";
 import * as path from "node:path";
 import type { PlatformPaths } from "../platform/types.js";
-import type { McpRegistry, ServerConfig } from "./types.js";
+import type { McpRegistry, ServerConfig, HostMcpServer } from "./types.js";
 import { createEmptyRegistry, isValidServerName } from "./types.js";
 
 function getMcpConfigPath(paths: PlatformPaths, cwd: string): string {
@@ -142,3 +143,81 @@ export function acquireLock(paths: PlatformPaths, cwd: string): { acquired: bool
     },
   };
 }
+
+
+// ── Host Config Discovery ─────────────────────────────────────
+
+interface HostMcpRaw {
+  mcpServers?: Record<string, {
+    type?: "stdio" | "http" | "sse";
+    command?: string;
+    args?: string[];
+    url?: string;
+    headers?: Record<string, string>;
+    env?: Record<string, string>;
+    enabled?: boolean;
+    auth?: unknown;
+    oauth?: unknown;
+  }>;
+}
+
+/**
+ * Discover MCP servers from host config files:
+ *   - User-level OMP: paths.agent("mcp.json") → ~/.omp/agent/mcp.json
+ *   - Project-level OMP: <cwd>/<dotDir>/mcp.json → <cwd>/.omp/mcp.json
+ *   - Claude Code:          ~/.claude.json
+ *
+ * All use the same { mcpServers: Record<string, ...> } shape.
+ */
+export function discoverHostMcpServers(
+  paths: PlatformPaths,
+  cwd: string,
+  homeDir: string = homedir(),
+): HostMcpServer[] {
+  const dot = paths.dotDir;
+
+  // OMP agent-level (user) config: ~/.omp/agent/mcp.json
+  const userPath = paths.agent("mcp.json");
+  // OMP project-level config: <cwd>/.omp/mcp.json
+  const projectPath = path.join(cwd, dot, "mcp.json");
+  // Claude Code user config: ~/.claude.json
+  const claudeCodePath = path.join(homeDir, ".claude.json");
+
+  const sources: Array<{ scope: HostMcpServer["scope"]; filePath: string }> = [
+    { scope: "user", filePath: userPath },
+    { scope: "project", filePath: projectPath },
+    { scope: "claude-code", filePath: claudeCodePath },
+  ];
+
+  const discovered: HostMcpServer[] = [];
+
+  for (const { scope, filePath } of sources) {
+    const data = readJsonSafe(filePath) as HostMcpRaw | null;
+    if (!data?.mcpServers) continue;
+
+    for (const [name, raw] of Object.entries(data.mcpServers)) {
+      // Skip explicitly disabled servers
+      if (raw.enabled === false) continue;
+
+      const effectiveType = raw.type ?? "stdio";
+      let transport: HostMcpServer["transport"] = "stdio";
+      if (effectiveType === "http") transport = "http";
+      else if (effectiveType === "sse") transport = "sse";
+
+      discovered.push({
+        name,
+        scope,
+        transport,
+        url: raw.url,
+        command: raw.command,
+        args: raw.args,
+        env: raw.env,
+        headers: raw.headers,
+        enabled: raw.enabled,
+        hasAuth: raw.auth !== undefined || raw.oauth !== undefined,
+      });
+    }
+  }
+
+  return discovered;
+}

package/src/mcp/docs.ts

@@ -119,7 +119,7 @@ function buildManagedSection(servers: Record<string, { description: string }>):
   lines.push("The following MCP servers are available via `$tag` or the `mcpc_<name>` tool:");
   lines.push("");
   for (const [name, { description }] of entries) {
-    lines.push(`- **$${name}** — ${description}. Details: .pi/supipowers/mcpc/${name}/README.md`);
+    lines.push(`- **$${name}** — ${description}. Details: .omp/supipowers/mcpc/${name}/README.md`);
   }
   lines.push("");
   lines.push("Use `/supi:mcp` to manage servers. Invoke the `supi:mcpc` skill for usage patterns.");

package/src/mcp/types.ts

@@ -47,6 +47,20 @@ export interface ServerState {
   catalog?: ToolCatalog;
 }
 
+/** A server discovered from the OMP host MCP config (not yet in supipowers registry) */
+export interface HostMcpServer {
+  name: string;
+  scope: "user" | "project" | "claude-code";
+  transport: "http" | "stdio" | "sse";
+  url?: string;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  headers?: Record<string, string>;
+  enabled?: boolean;
+  hasAuth?: boolean;
+}
+
 /** mcpc exit codes per documentation */
 export const MCPC_EXIT = {
   SUCCESS: 0,

package/src/planning/approval-flow.ts

@@ -0,0 +1,174 @@
+import type { Platform } from "../platform/types.js";
+import { listPlans, readPlanFile } from "../storage/plans.js";
+
+/**
+ * Plan approval flow state.
+ *
+ * After `/supi:plan` sends the planning steer, this module tracks the
+ * planning session. When the agent finishes a turn, we detect newly
+ * written plan files and show an approval UI — mirroring OMP's native
+ * `/plan` approval experience.
+ */
+let planningActive = false;
+let plansBefore: string[] = [];
+let planCwd: string = "";
+/** newSession function captured from the command context at plan start. */
+let capturedNewSession: ((options?: any) => Promise<{ cancelled: boolean }>) | null = null;
+
+/** Mark planning as started (called by plan command after sending steer). */
+export function startPlanTracking(
+  cwd: string,
+  paths: any,
+  newSession?: (options?: any) => Promise<{ cancelled: boolean }>,
+): void {
+  planningActive = true;
+  planCwd = cwd;
+  plansBefore = listPlans(paths, cwd);
+  capturedNewSession = newSession ?? null;
+}
+
+/** Cancel plan tracking (e.g., session change). */
+export function cancelPlanTracking(): void {
+  planningActive = false;
+  plansBefore = [];
+  planCwd = "";
+  capturedNewSession = null;
+}
+
+/** Whether a planning session is currently active. */
+export function isPlanningActive(): boolean {
+  return planningActive;
+}
+
+/**
+ * Build the execution handoff prompt from an approved plan.
+ *
+ * Mirrors OMP's `plan-mode-approved.md` template: critical directive
+ * to execute, the full plan content, and step-by-step instructions.
+ */
+function buildExecutionPrompt(planContent: string, planPath: string): string {
+  return [
+    "<critical>",
+    "Plan approved. You **MUST** execute it now.",
+    "</critical>",
+    "",
+    `Finalized plan: \`${planPath}\``,
+    "",
+    "## Plan",
+    "",
+    planContent,
+    "",
+    "<instruction>",
+    `You **MUST** execute this plan step by step from \`${planPath}\`.`,
+    "You **MUST** verify each step before proceeding to the next.",
+    "Before execution, you **MUST** initialize todo tracking with the task list.",
+    "After each completed step, immediately update progress so it stays visible.",
+    "</instruction>",
+    "",
+    "<critical>",
+    "You **MUST** keep going until complete. This matters.",
+    "</critical>",
+  ].join("\n");
+}
+
+/**
+ * Execute the approve-and-execute flow.
+ *
+ * Clears the current session via ctx.newSession() (gives a clean slate),
+ * then sends the execution prompt as a user message so the agent picks it
+ * up immediately in the new session.
+ *
+ * Falls back to same-session steer when ctx.newSession is unavailable
+ * (headless / SDK environments that don't expose the session API).
+ */
+async function executeApproveFlow(
+  platform: Platform,
+  ctx: any,
+  planContent: string,
+  planPath: string,
+): Promise<void> {
+  const prompt = buildExecutionPrompt(planContent, planPath);
+
+  if (capturedNewSession) {
+    const result = await capturedNewSession();
+    if (result?.cancelled) {
+      // User dismissed the new-session prompt — keep plan state intact.
+      ctx.ui.notify("Session start cancelled. Plan saved; run /supi:plan again to execute.");
+      return;
+    }
+    platform.sendUserMessage(prompt);
+  } else {
+    // Fallback: headless/SDK mode — steer in the current session.
+    platform.sendMessage(
+      {
+        customType: "supi-plan-execute",
+        content: [{ type: "text", text: prompt }],
+        display: "none",
+      },
+      { deliverAs: "steer", triggerTurn: true },
+    );
+    ctx.ui.notify("Plan approved — starting execution");
+  }
+}
+
+/**
+ * Register the agent_end hook that drives the plan approval UI.
+ *
+ * After the planning agent finishes each turn, detect if a new plan
+ * file appeared and show an approval selector:
+ *   - "Approve and execute" → clear session, send execution prompt
+ *   - "Refine plan"        → let user type refinement (empty = approve)
+ *   - "Stay in plan mode"  → cancel tracking, return control
+ */
+export function registerPlanApprovalHook(platform: Platform): void {
+  platform.on("agent_end", async (_event: any, ctx: any) => {
+    if (!planningActive || !ctx?.hasUI) return;
+
+    // Detect newly written plan files
+    const plansNow = listPlans(platform.paths, planCwd);
+    const newPlans = plansNow.filter((p) => !plansBefore.includes(p));
+
+    if (newPlans.length === 0) {
+      // No new plan yet — agent is still exploring/asking questions.
+      // Update snapshot so we detect the plan on a future turn.
+      plansBefore = plansNow;
+      return;
+    }
+
+    // Pick the most recent new plan
+    const planName = newPlans[newPlans.length - 1];
+    const planContent = readPlanFile(platform.paths, planCwd, planName);
+    if (!planContent) return;
+
+    const planPath = `${platform.paths.dotDirDisplay}/supipowers/plans/${planName}`;
+
+    const choice = await ctx.ui.select("Plan complete — what next?", [
+      "Approve and execute",
+      "Refine plan",
+      "Stay in plan mode",
+    ]);
+
+    if (choice === "Approve and execute") {
+      planningActive = false;
+      plansBefore = [];
+      await executeApproveFlow(platform, ctx, planContent, planPath);
+    } else if (choice === "Refine plan") {
+      // Keep planning active, let user type refinement.
+      // Empty input is treated as misclick → fall through to approve.
+      plansBefore = plansNow;
+      const refinement = await ctx.ui.input("What should be refined?");
+      if (!refinement || !refinement.trim()) {
+        // Misclick: treat empty input as approval
+        planningActive = false;
+        plansBefore = [];
+        await executeApproveFlow(platform, ctx, planContent, planPath);
+      } else {
+        ctx.ui.setEditorText?.(refinement);
+      }
+    } else {
+      // Stay in plan mode — user keeps control, tracking cancelled
+      cancelPlanTracking();
+      ctx.ui.notify("Planning complete. Plan saved but not executing.");
+    }
+  });
+}

package/src/planning/plan-writer-prompt.ts

@@ -98,7 +98,7 @@ export function buildPlanWriterPrompt(options: PlanWriterOptions): string {
     "",
     "- [ ] **Step 2: Run test to verify it fails**",
     "",
-    "Run: `npx vitest run tests/path/test.ts`",
+    "Run: `bun test tests/path/test.ts`",
     'Expected: FAIL with "myFunction is not defined"',
     "",
     "- [ ] **Step 3: Write minimal implementation**",
@@ -111,7 +111,7 @@ export function buildPlanWriterPrompt(options: PlanWriterOptions): string {
     "",
     "- [ ] **Step 4: Run test to verify it passes**",
     "",
-    "Run: `npx vitest run tests/path/test.ts`",
+    "Run: `bun test tests/path/test.ts`",
     "Expected: PASS",
     "",
     "- [ ] **Step 5: Commit**",
@@ -159,11 +159,12 @@ export function buildPlanWriterPrompt(options: PlanWriterOptions): string {
     // ── Execution Handoff ────────────────────────────────────────
     "## Step 6: Execution Handoff",
     "",
-    "After saving the plan, ask:",
+    "After saving the plan, tell the user:",
     "",
-    '> "Plan complete and saved to `<path>`. Ready to execute?"',
+    '> "Plan saved to `<path>`. Review it and approve when ready."',
     "",
-    "Wait for user confirmation before proceeding to execution.",
+    "Then **stop and wait**. Do NOT start executing.",
+    "The user will see an approval prompt. Once they approve, a fresh execution session begins automatically.",
     "",
   ];
 

package/src/planning/prompt-builder.ts

@@ -166,10 +166,11 @@ export function buildQuickPlanPrompt(
     "---",
     "```",
     "",
-    "Each task should have: name, [parallel-safe] or [sequential] annotation,",
-    "**files**, **criteria**, and **complexity** (small/medium/large).",
+    "Each task should have: name, **files**, **criteria**, and **complexity** (small/medium/large).",
     "",
-    "After generating the plan, save it and confirm with the user.",
+    "After generating the plan, save it and tell the user:",
+    '> "Plan saved to `<path>`. Review it and approve when ready."',
+    "Then stop and wait. The user will see an approval prompt.",
   ];
 
   if (skillContent) {

package/src/platform/detect.ts

@@ -1,9 +1,7 @@
 // src/platform/detect.ts
-export type PlatformType = "pi" | "omp";
-
-export function detectPlatform(rawApi: any): PlatformType {
-  if (rawApi.pi && typeof rawApi.pi.createAgentSession === "function") {
-    return "omp";
+export function detectPlatform(rawApi: any): "omp" {
+  if (!rawApi.pi || typeof rawApi.pi.createAgentSession !== "function") {
+    throw new Error("Unrecognized API shape — expected OMP ExtensionAPI");
   }
-  return "pi";
+  return "omp";
 }