supipowers 0.5.0 → 0.6.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "supipowers",
-  "version": "0.5.0",
-  "description": "OMP-native workflow extension inspired by Superpowers.",
+  "version": "0.6.1",
+  "description": "OMP-native workflow extension inspired by supipowers.",
   "type": "module",
   "scripts": {
     "test": "vitest run",
@@ -13,7 +13,7 @@
     "omp-extension",
     "workflow",
     "agent",
-    "superpowers"
+    "supipowers"
   ],
   "license": "MIT",
   "bin": {

package/skills/context-mode/SKILL.md

@@ -0,0 +1,38 @@
+# Context Mode — Tool Routing Instructions
+
+When context-mode sandbox tools are available, prefer them over raw tool calls to keep your context window lean.
+
+## Tool Selection Hierarchy
+
+Use context-mode tools in this priority order:
+
+1. **ctx_batch_execute** — for multi-step operations. Runs multiple commands and searches in a single call.
+   - Use when: you need to run 2+ commands, or combine a command with a search
+   - Example: checking a build AND searching for a symbol
+
+2. **ctx_search** — for querying previously indexed knowledge. No re-execution needed.
+   - Use when: you've already indexed data and need to find something in it
+   - Example: finding a function definition you indexed earlier
+
+3. **ctx_execute / ctx_execute_file** — for single commands or file processing.
+   - Use when: running one command whose output would be large
+   - Example: listing a directory, reading a large log file
+
+4. **Raw Bash/Read/Grep** — only when necessary.
+   - Use when: editing files (Read before Edit), running build/test commands where real-time output matters, or when the output is known to be small
+
+## Forbidden Patterns
+
+- Do NOT use Bash for `curl`/`wget`/HTTP requests — use `ctx_fetch_and_index` instead
+- Do NOT use Read for analyzing large files (>100 lines) — use `ctx_execute_file` to process and summarize
+- Do NOT use Bash for directory listings with >20 expected files — use `ctx_execute`
+
+## Output Constraints
+
+- Keep tool output responses under 500 words when possible
+- Write large artifacts (generated code, data dumps) to files rather than returning them inline
+- Prefer structured summaries over raw output
+
+## Sub-Agent Awareness
+
+These routing instructions apply within sub-agent sessions. When you are a sub-agent dispatched by supipowers, follow the same tool preference hierarchy.

package/src/commands/config.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
 import { loadConfig, updateConfig } from "../config/loader.js";
 import { listProfiles } from "../config/profiles.js";
+import { checkInstallation } from "../context-mode/installer.js";
 import type { SupipowersConfig } from "../types.js";
 
 const FRAMEWORK_OPTIONS = [
@@ -126,7 +127,7 @@ function buildSettings(cwd: string): SettingDef[] {
   ];
 }
 
-export function handleConfig(ctx: ExtensionContext): void {
+export function handleConfig(pi: ExtensionAPI, ctx: ExtensionContext): void {
   if (!ctx.hasUI) {
     ctx.ui.notify("Config UI requires interactive mode", "warning");
     return;
@@ -179,13 +180,33 @@ export function handleConfig(ctx: ExtensionContext): void {
       }
     }
   })();
+
+  // Context-mode status (async, fire-and-forget)
+  checkInstallation(
+    (cmd: string, args: string[]) => pi.exec(cmd, args),
+    pi.getActiveTools(),
+  ).then((status) => {
+    const lines = [
+      "",
+      "Context Mode:",
+      `  CLI installed: ${status.cliInstalled ? "\u2713" + (status.version ? ` v${status.version}` : "") : "\u2717"}`,
+      `  MCP configured: ${status.mcpConfigured ? "\u2713" : "\u2717"}`,
+      `  Tools available: ${status.toolsAvailable ? "\u2713" : "\u2717"}`,
+    ];
+    if (!status.mcpConfigured && status.cliInstalled) {
+      lines.push("  \u2192 Run `omp mcp add context-mode` to enable");
+    }
+    ctx.ui.notify(lines.join("\n"), "info");
+  }).catch(() => {
+    // Silently ignore — context-mode status is optional
+  });
 }
 
 export function registerConfigCommand(pi: ExtensionAPI): void {
   pi.registerCommand("supi:config", {
     description: "View and manage Supipowers configuration",
     async handler(_args, ctx) {
-      handleConfig(ctx);
+      handleConfig(pi, ctx);
     },
   });
 }

package/src/commands/fix-pr.ts

@@ -172,7 +172,7 @@ export function registerFixPrCommand(pi: ExtensionAPI): void {
           content: [{ type: "text", text: prompt }],
           display: "none",
         },
-        { deliverAs: "steer" },
+        { deliverAs: "steer", triggerTurn: true },
       );
 
       notifyInfo(ctx, `Fix-PR started: PR #${prNumber}`, `${commentCount} comments to assess | session ${ledger.id}`);

package/src/commands/plan.ts

@@ -130,7 +130,7 @@ export function registerPlanCommand(pi: ExtensionAPI): void {
           content: [{ type: "text", text: prompt }],
           display: "none",
         },
-        { deliverAs: "steer" }
+        { deliverAs: "steer", triggerTurn: true }
       );
 
       notifyInfo(ctx, "Planning started", args ? `Topic: ${args}` : "Describe what you want to build");

package/src/commands/qa.ts

@@ -256,7 +256,7 @@ export function registerQaCommand(pi: ExtensionAPI): void {
           content: [{ type: "text", text: prompt }],
           display: "none",
         },
-        { deliverAs: "steer" },
+        { deliverAs: "steer", triggerTurn: true },
       );
 
       notifyInfo(

package/src/commands/release.ts

@@ -40,7 +40,7 @@ export function registerReleaseCommand(pi: ExtensionAPI): void {
           content: [{ type: "text", text: prompt }],
           display: "none",
         },
-        { deliverAs: "steer" }
+        { deliverAs: "steer", triggerTurn: true }
       );
     },
   });

package/src/commands/review.ts

@@ -92,7 +92,7 @@ export function registerReviewCommand(pi: ExtensionAPI): void {
           content: [{ type: "text", text: reviewPrompt }],
           display: "none",
         },
-        { deliverAs: "steer" }
+        { deliverAs: "steer", triggerTurn: true }
       );
     },
   });

package/src/commands/run.ts

@@ -15,6 +15,7 @@ import { dispatchAgent, dispatchAgentWithReview, dispatchFixAgent } from "../orc
 import { summarizeBatch, buildRunSummary } from "../orchestrator/result-collector.js";
 import { analyzeConflicts } from "../orchestrator/conflict-resolver.js";
 import { isLspAvailable } from "../lsp/detector.js";
+import { detectContextMode } from "../context-mode/detector.js";
 import {
   notifyInfo,
   notifySuccess,
@@ -24,6 +25,7 @@ import {
 } from "../notifications/renderer.js";
 import { buildWorktreePrompt } from "../git/worktree.js";
 import { buildBranchFinishPrompt } from "../git/branch-finish.js";
+import { detectBaseBranch } from "../git/base-branch.js";
 import type { RunManifest, AgentResult } from "../types.js";
 
 export function registerRunCommand(pi: ExtensionAPI): void {
@@ -88,7 +90,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
                 content: [{ type: "text", text: worktreeInstructions }],
                 display: "none",
               },
-              { deliverAs: "steer" },
+              { deliverAs: "steer", triggerTurn: true },
             );
             notifyInfo(ctx, "Setting up worktree", `Branch: ${branchName}`);
           }
@@ -104,6 +106,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
       }
       const plan = parsePlan(planContent, manifest.planRef);
       const lsp = isLspAvailable(pi.getActiveTools());
+      const ctxMode = detectContextMode(pi.getActiveTools()).available;
 
       for (const batch of manifest.batches) {
         if (batch.status === "completed") continue;
@@ -129,6 +132,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
             planContext: plan.context,
             config,
             lspAvailable: lsp,
+            contextModeAvailable: ctxMode,
           });
         });
 
@@ -140,7 +144,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
           }
         }
 
-        const conflicts = analyzeConflicts(batchResults, plan.tasks);
+        const conflicts = analyzeConflicts(batchResults, plan.tasks, ctxMode);
         if (conflicts.hasConflicts) {
           notifyWarning(
             ctx,
@@ -164,6 +168,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
                 planContext: plan.context,
                 config,
                 lspAvailable: lsp,
+                contextModeAvailable: ctxMode,
                 previousOutput: failed.output,
                 failureReason: failed.output,
               });
@@ -208,7 +213,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
       if (branchName && manifest.status === "completed") {
         const finishInstructions = buildBranchFinishPrompt({
           branchName,
-          baseBranch: "main",
+          baseBranch: await detectBaseBranch((cmd, args) => pi.exec(cmd, args)),
         });
         pi.sendMessage(
           {
@@ -216,7 +221,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
             content: [{ type: "text", text: finishInstructions }],
             display: "none",
           },
-          { deliverAs: "steer" },
+          { deliverAs: "steer", triggerTurn: true },
         );
         notifyInfo(ctx, "Run succeeded", "Follow branch finish instructions to integrate your work");
       }

package/src/config/defaults.ts

@@ -24,6 +24,16 @@ export const DEFAULT_CONFIG: SupipowersConfig = {
   release: {
     pipeline: null,
   },
+  contextMode: {
+    enabled: true,
+    compressionThreshold: 4096,
+    blockHttpCommands: true,
+    routingInstructions: true,
+    eventTracking: true,
+    compaction: true,
+    llmSummarization: false,
+    llmThreshold: 16384,
+  },
 };
 
 export const BUILTIN_PROFILES: Record<string, Profile> = {

package/src/config/schema.ts

@@ -30,6 +30,16 @@ const ConfigSchema = Type.Object({
   release: Type.Object({
     pipeline: Type.Union([Type.String(), Type.Null()]),
   }),
+  contextMode: Type.Object({
+    enabled: Type.Boolean(),
+    compressionThreshold: Type.Number({ minimum: 1024 }),
+    blockHttpCommands: Type.Boolean(),
+    routingInstructions: Type.Boolean(),
+    eventTracking: Type.Boolean(),
+    compaction: Type.Boolean(),
+    llmSummarization: Type.Boolean(),
+    llmThreshold: Type.Number({ minimum: 4096 }),
+  }),
 });
 
 export function validateConfig(data: unknown): { valid: boolean; errors: string[] } {

package/src/context-mode/compressor.ts

@@ -0,0 +1,200 @@
+// src/context-mode/compressor.ts
+
+interface ToolResultEventLike {
+  toolName: string;
+  input: Record<string, unknown>;
+  content: Array<{ type: string; text?: string }>;
+  isError: boolean;
+  details: unknown;
+}
+
+interface ToolResultEventResult {
+  content?: Array<{ type: string; text: string }>;
+}
+
+const BASH_HEAD_LINES = 5;
+const BASH_TAIL_LINES = 10;
+const READ_PREVIEW_LINES = 10;
+const GREP_MAX_MATCHES = 10;
+const FIND_MAX_PATHS = 20;
+
+/** Measure total byte length of text content entries */
+function measureTextBytes(content: Array<{ type: string; text?: string }>): number {
+  let total = 0;
+  for (const entry of content) {
+    if (entry.type === "text" && entry.text) {
+      total += new TextEncoder().encode(entry.text).byteLength;
+    }
+  }
+  return total;
+}
+
+/** Check if content contains any non-text entries */
+function hasNonTextContent(content: Array<{ type: string }>): boolean {
+  return content.some((entry) => entry.type !== "text");
+}
+
+/** Get combined text from all text content entries */
+function getCombinedText(content: Array<{ type: string; text?: string }>): string {
+  return content
+    .filter((entry) => entry.type === "text" && entry.text)
+    .map((entry) => entry.text!)
+    .join("\n");
+}
+
+/** Compress bash tool output */
+function compressBash(text: string, details: unknown): string | undefined {
+  const exitCode =
+    details && typeof details === "object" && "exitCode" in details
+      ? (details as { exitCode: number }).exitCode
+      : 0;
+
+  // Non-zero exit: keep full output for debugging
+  if (exitCode !== 0) return undefined;
+
+  const lines = text.split("\n");
+  const totalLines = lines.length;
+
+  if (totalLines <= BASH_HEAD_LINES + BASH_TAIL_LINES) return undefined;
+
+  const head = lines.slice(0, BASH_HEAD_LINES);
+  const tail = lines.slice(-BASH_TAIL_LINES);
+  const omitted = totalLines - BASH_HEAD_LINES - BASH_TAIL_LINES;
+
+  return [
+    ...head,
+    `[...compressed: ${omitted} lines omitted (${totalLines} lines total)...]`,
+    ...tail,
+  ].join("\n");
+}
+
+/** Compress read tool output */
+function compressRead(text: string, input: Record<string, unknown>): string | undefined {
+  // Scoped reads (offset/limit) are already targeted — pass through
+  if (input.offset !== undefined || input.limit !== undefined) return undefined;
+
+  const lines = text.split("\n");
+  const totalLines = lines.length;
+  const path = typeof input.path === "string" ? input.path : "unknown";
+
+  if (totalLines <= READ_PREVIEW_LINES) return undefined;
+
+  const preview = lines.slice(0, READ_PREVIEW_LINES);
+  return [
+    `File: ${path} (${totalLines} lines total)`,
+    "",
+    ...preview,
+    `[...compressed: remaining ${totalLines - READ_PREVIEW_LINES} lines omitted...]`,
+  ].join("\n");
+}
+
+/** Compress grep tool output */
+function compressGrep(text: string): string | undefined {
+  const lines = text.split("\n").filter((l) => l.length > 0);
+  const totalMatches = lines.length;
+
+  if (totalMatches <= GREP_MAX_MATCHES) return undefined;
+
+  const kept = lines.slice(0, GREP_MAX_MATCHES);
+  return [
+    `${totalMatches} matches total, showing first ${GREP_MAX_MATCHES}:`,
+    "",
+    ...kept,
+    `[...compressed: ${totalMatches - GREP_MAX_MATCHES} more matches omitted...]`,
+  ].join("\n");
+}
+
+/** Compress find tool output */
+function compressFind(text: string): string | undefined {
+  const lines = text.split("\n").filter((l) => l.length > 0);
+  const totalFiles = lines.length;
+
+  if (totalFiles <= FIND_MAX_PATHS) return undefined;
+
+  const kept = lines.slice(0, FIND_MAX_PATHS);
+  return [
+    `${totalFiles} files found, showing first ${FIND_MAX_PATHS}:`,
+    "",
+    ...kept,
+    `[...compressed: ${totalFiles - FIND_MAX_PATHS} more files omitted...]`,
+  ].join("\n");
+}
+
+/** Compress a tool result if it exceeds the threshold */
+export function compressToolResult(
+  event: ToolResultEventLike,
+  threshold: number,
+): ToolResultEventResult | undefined {
+  // General rules: pass through errors, non-text content, and small outputs
+  if (event.isError) return undefined;
+  if (hasNonTextContent(event.content)) return undefined;
+  if (measureTextBytes(event.content) <= threshold) return undefined;
+
+  const text = getCombinedText(event.content);
+  let compressed: string | undefined;
+
+  switch (event.toolName) {
+    case "bash":
+      compressed = compressBash(text, event.details);
+      break;
+    case "read":
+      compressed = compressRead(text, event.input);
+      break;
+    case "grep":
+      compressed = compressGrep(text);
+      break;
+    case "find":
+      compressed = compressFind(text);
+      break;
+    default:
+      return undefined;
+  }
+
+  if (!compressed) return undefined;
+  return { content: [{ type: "text", text: compressed }] };
+}
+
+/** Summarization prompt templates by tool type */
+const SUMMARIZE_PROMPTS: Record<string, string> = {
+  bash: "Summarize this command output. Preserve: exit code, key findings, error messages, file paths mentioned. Be concise (under 200 words).",
+  read: "Summarize this file content. Preserve: file structure, key exports/functions, notable patterns. Be concise (under 200 words).",
+  grep: "Summarize these search results. Preserve: match count, most relevant matches, file distribution. Be concise (under 200 words).",
+  find: "Summarize these file paths. Preserve: directory structure, file count, key patterns. Be concise (under 200 words).",
+};
+
+/** Compress with optional LLM summarization for very large outputs */
+export async function compressToolResultWithLLM(
+  event: ToolResultEventLike,
+  threshold: number,
+  llmThreshold: number,
+  summarize: (text: string, toolName: string) => Promise<string>,
+): Promise<ToolResultEventResult | undefined> {
+  // General rules
+  if (event.isError) return undefined;
+  if (hasNonTextContent(event.content)) return undefined;
+  const byteSize = measureTextBytes(event.content);
+  if (byteSize <= threshold) return undefined;
+
+  const text = getCombinedText(event.content);
+
+  // Below LLM threshold: use structural compression
+  if (byteSize < llmThreshold) {
+    return compressToolResult(event, threshold);
+  }
+
+  // Above LLM threshold: try LLM summarization
+  try {
+    const prompt = SUMMARIZE_PROMPTS[event.toolName] ?? "Summarize this output concisely (under 200 words).";
+    const summary = await summarize(`${prompt}\n\n${text}`, event.toolName);
+
+    // Validate: non-empty and reasonably sized
+    if (summary && summary.length >= 50) {
+      return { content: [{ type: "text", text: summary }] };
+    }
+  } catch {
+    // Fall through to structural compression
+  }
+
+  // Fallback
+  return compressToolResult(event, threshold);
+}

package/src/context-mode/detector.ts

@@ -0,0 +1,59 @@
+// src/context-mode/detector.ts
+
+/** Which context-mode MCP tools are available in the current session */
+export interface ContextModeStatus {
+  available: boolean;
+  tools: {
+    ctxExecute: boolean;
+    ctxBatchExecute: boolean;
+    ctxExecuteFile: boolean;
+    ctxIndex: boolean;
+    ctxSearch: boolean;
+    ctxFetchAndIndex: boolean;
+  };
+}
+
+/** Suffixes to match against full MCP-namespaced tool names */
+const TOOL_SUFFIXES: Array<[string, keyof ContextModeStatus["tools"]]> = [
+  ["ctx_execute", "ctxExecute"],
+  ["ctx_batch_execute", "ctxBatchExecute"],
+  ["ctx_execute_file", "ctxExecuteFile"],
+  ["ctx_index", "ctxIndex"],
+  ["ctx_search", "ctxSearch"],
+  ["ctx_fetch_and_index", "ctxFetchAndIndex"],
+];
+
+/**
+ * Extract the short tool name from a potentially MCP-namespaced tool name.
+ * MCP tools use the format: mcp__<server>__<tool_name>
+ * Native tools use bare names like: lsp, bash, etc.
+ */
+function getShortName(tool: string): string {
+  const lastSep = tool.lastIndexOf("__");
+  return lastSep >= 0 ? tool.slice(lastSep + 2) : tool;
+}
+
+/** Detect context-mode MCP tool availability from the active tools list */
+export function detectContextMode(activeTools: string[]): ContextModeStatus {
+  const tools: ContextModeStatus["tools"] = {
+    ctxExecute: false,
+    ctxBatchExecute: false,
+    ctxExecuteFile: false,
+    ctxIndex: false,
+    ctxSearch: false,
+    ctxFetchAndIndex: false,
+  };
+
+  for (const tool of activeTools) {
+    const shortName = getShortName(tool);
+    for (const [suffix, key] of TOOL_SUFFIXES) {
+      if (shortName === suffix) {
+        tools[key] = true;
+        break;
+      }
+    }
+  }
+
+  const available = Object.values(tools).some(Boolean);
+  return { available, tools };
+}