supipowers 1.5.2 → 2.0.0

package/src/platform/omp.ts

@@ -6,6 +6,7 @@ import type {
   ExecResult,
 } from "./types.js";
 import { createPaths } from "./types.js";
+import { normalizeSystemPromptBlocks } from "./system-prompt.js";
 
 async function execWithEnv(cmd: string, args: string[], opts: ExecOptions): Promise<ExecResult> {
   const subprocess = Bun.spawn([cmd, ...args], {
@@ -50,6 +51,8 @@ export function createOmpAdapter(api: any): Platform {
     registerCommand: (name, opts) => api.registerCommand(name, opts),
     getCommands: () => api.getCommands(),
     getActiveTools: () => api.getActiveTools(),
+    getAllTools:
+      typeof api.getAllTools === "function" ? () => api.getAllTools() : undefined,
     exec: (cmd, args, opts) =>
       opts?.env ? execWithEnv(cmd, args, opts) : api.exec(cmd, args, opts),
     sendMessage: (content, opts) => {
@@ -105,14 +108,18 @@ export function createOmpAdapter(api: any): Platform {
       // Fix: extract `model` from opts and pass it as `modelPattern` (string field
       // that OMP resolves after extension models are registered).
       const { model, ...restOpts } = opts;
+      const sessionOpts = { ...restOpts };
+      if ("systemPrompt" in sessionOpts) {
+        sessionOpts.systemPrompt = normalizeSystemPromptBlocks(sessionOpts.systemPrompt);
+      }
       const { session } = await createAgentSession({
-        cwd: restOpts.cwd ?? process.cwd(),
+        cwd: sessionOpts.cwd ?? process.cwd(),
         hasUI: false,
         disableExtensionDiscovery: true,
         skills: [],
         promptTemplates: [],
         slashCommands: [],
-        ...restOpts,
+        ...sessionOpts,
         // Only pass modelPattern when we have an explicit model override.
         // When undefined, OMP uses its own default (user's configured model).
         ...(model ? { modelPattern: model } : {}),
@@ -126,6 +133,10 @@ export function createOmpAdapter(api: any): Platform {
     },
 
     registerTool: api.registerTool ? (definition: any) => api.registerTool(definition) : undefined,
+    setActiveTools:
+      typeof api.setActiveTools === "function"
+        ? (names: string[]) => api.setActiveTools(names)
+        : undefined,
 
     paths: createPaths(".omp"),
     capabilities: {
@@ -133,6 +144,8 @@ export function createOmpAdapter(api: any): Platform {
       compactionHooks: true,
       customWidgets: true,
       registerTool: typeof api.registerTool === "function",
+      activeToolFiltering:
+        typeof api.getAllTools === "function" && typeof api.setActiveTools === "function",
     },
   };
 }

package/src/platform/system-prompt.ts

@@ -0,0 +1,37 @@
+export type SystemPromptBlocks = string[];
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+export function normalizeSystemPromptBlocks(value: unknown): SystemPromptBlocks {
+  if (Array.isArray(value)) {
+    return value.filter((block): block is string => typeof block === "string" && block.length > 0);
+  }
+  if (typeof value === "string") {
+    return value.length > 0 ? [value] : [];
+  }
+
+  const record = asRecord(value);
+  if (record && "systemPrompt" in record) {
+    return normalizeSystemPromptBlocks(record.systemPrompt);
+  }
+
+  return [];
+}
+
+export function systemPromptText(value: unknown): string {
+  return normalizeSystemPromptBlocks(value).join("\n\n");
+}
+
+export function appendSystemPromptBlock(value: unknown, block: string): SystemPromptBlocks {
+  const blocks = normalizeSystemPromptBlocks(value);
+  return block.length > 0 ? [...blocks, block] : blocks;
+}
+
+export function prependSystemPromptBlock(value: unknown, block: string): SystemPromptBlocks {
+  const blocks = normalizeSystemPromptBlocks(value);
+  return block.length > 0 ? [block, ...blocks] : blocks;
+}

package/src/platform/test-utils.ts

@@ -12,11 +12,13 @@ export function createMockPlatform(overrides?: Partial<Platform>): Platform {
     registerCommand: mock(),
     getCommands: mock(() => []),
     getActiveTools: mock(() => []),
+    getAllTools: mock(() => []),
     exec: mock(async () => ({ stdout: "", stderr: "", code: 0 })),
     sendMessage: mock(),
     sendUserMessage: mock(),
     registerMessageRenderer: mock(),
     on: mock(),
+    setActiveTools: mock(async () => {}),
     createAgentSession: mock(async () => ({
       subscribe: mock(() => () => {}),
       prompt: mock(async () => {}),
@@ -29,6 +31,7 @@ export function createMockPlatform(overrides?: Partial<Platform>): Platform {
       compactionHooks: true,
       customWidgets: true,
       registerTool: true,
+      activeToolFiltering: true,
     },
     ...overrides,
   };

package/src/platform/types.ts

@@ -37,6 +37,7 @@ export interface PlatformCapabilities {
   compactionHooks: boolean;
   customWidgets: boolean;
   registerTool: boolean;
+  activeToolFiltering: boolean;
 }
 
 // ── Agent Sessions ─────────────────────────────────────────
@@ -47,6 +48,9 @@ export interface AgentSessionOptions {
   parentTaskPrefix?: string;
   model?: string;
   thinkingLevel?: string | null;
+  systemPrompt?: string[];
+  agentId?: string;
+  agentDisplayName?: string;
   [key: string]: unknown;
 }
 
@@ -130,10 +134,11 @@ export interface Platform {
 
   // Introspection
   getActiveTools(): string[];
+  getAllTools?(): string[];
 
   // Tool registration
   registerTool?(definition: any): void;
-  setActiveTools?(names: string[]): void;
+  setActiveTools?(names: string[]): Promise<void>;
 
   // Rendering
   registerMessageRenderer<T>(type: string, renderer: any): void;

package/src/qa/config.ts

@@ -1,11 +1,17 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { E2eQaConfig } from "./types.js";
 import type { PlatformPaths } from "../platform/types.js";
+import type { WorkspaceTarget } from "../types.js";
+import { getLocalTargetStatePath } from "../workspace/state-paths.js"
+import type { E2eQaConfig } from "./types.js";
 
 const CONFIG_FILENAME = "e2e-qa.json";
 
-function getConfigPath(paths: PlatformPaths, cwd: string): string {
+function getConfigPath(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget): string {
+  if (target) {
+    return getLocalTargetStatePath(paths, target, CONFIG_FILENAME);
+  }
+
   return paths.project(cwd, CONFIG_FILENAME);
 }
 
@@ -26,8 +32,8 @@ export const DEFAULT_E2E_QA_CONFIG: E2eQaConfig = {
   },
 };
 
-export function loadE2eQaConfig(paths: PlatformPaths, cwd: string): E2eQaConfig | null {
-  const configPath = getConfigPath(paths, cwd);
+export function loadE2eQaConfig(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget): E2eQaConfig | null {
+  const configPath = getConfigPath(paths, cwd, target);
   if (!fs.existsSync(configPath)) return null;
   try {
     return JSON.parse(fs.readFileSync(configPath, "utf-8")) as E2eQaConfig;
@@ -36,8 +42,8 @@ export function loadE2eQaConfig(paths: PlatformPaths, cwd: string): E2eQaConfig
   }
 }
 
-export function saveE2eQaConfig(paths: PlatformPaths, cwd: string, config: E2eQaConfig): void {
-  const configPath = getConfigPath(paths, cwd);
+export function saveE2eQaConfig(paths: PlatformPaths, cwd: string, config: E2eQaConfig, target?: WorkspaceTarget): void {
+  const configPath = getConfigPath(paths, cwd, target);
   fs.mkdirSync(path.dirname(configPath), { recursive: true });
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
 }

package/src/qa/detect-app-type.ts

@@ -1,11 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import type { AppType } from "./types.js";
 
 export interface AppDetection {
-  type: string;
+  type: AppType;
   devCommand: string;
   port: number;
   baseUrl: string;
+  isLikelyApp: boolean;
 }
 
 function fileExists(cwd: string, ...segments: string[]): boolean {
@@ -29,9 +31,10 @@ function readJson(filePath: string): Record<string, unknown> | null {
 }
 
 export function detectAppType(cwd: string): AppDetection {
-  let type = "generic";
+  let type: AppType = "generic";
   let devCommand = "npm run dev";
   let port = 3000;
+  let isLikelyApp = false;
 
   const hasNextConfig =
     fileExists(cwd, "next.config.js") ||
@@ -41,7 +44,6 @@ export function detectAppType(cwd: string): AppDetection {
   const hasNextPagesDir = dirExists(cwd, "pages") || dirExists(cwd, "src", "pages");
 
   if (hasNextConfig || hasNextAppDir || hasNextPagesDir) {
-    // Default nextjs-app; only switch to pages if pages dir exists and app dir does not
     if (hasNextAppDir) {
       type = "nextjs-app";
     } else if (hasNextPagesDir) {
@@ -50,6 +52,7 @@ export function detectAppType(cwd: string): AppDetection {
       type = "nextjs-app";
     }
     port = 3000;
+    isLikelyApp = true;
   } else if (
     fileExists(cwd, "vite.config.ts") ||
     fileExists(cwd, "vite.config.js") ||
@@ -57,36 +60,40 @@ export function detectAppType(cwd: string): AppDetection {
   ) {
     type = "vite";
     port = 5173;
+    isLikelyApp = true;
   } else if (fileExists(cwd, "angular.json")) {
     type = "generic";
     devCommand = "npm start";
     port = 4200;
+    isLikelyApp = true;
   } else if (fileExists(cwd, "package.json")) {
     try {
       const raw = fs.readFileSync(path.join(cwd, "package.json"), "utf8");
       if (raw.includes('"express"')) {
         type = "express";
         port = 3000;
+        isLikelyApp = true;
       }
     } catch {
       // proceed with defaults
     }
   }
 
-  // Override devCommand from package.json scripts
   const pkgPath = path.join(cwd, "package.json");
   const pkg = readJson(pkgPath);
   if (pkg) {
     const scripts = pkg.scripts as Record<string, string> | undefined;
     if (scripts?.dev) {
       devCommand = "npm run dev";
+      isLikelyApp = true;
     } else if (scripts?.start) {
       devCommand = "npm start";
+      isLikelyApp = true;
     } else if (scripts?.serve) {
       devCommand = "npm run serve";
+      isLikelyApp = true;
     }
 
-    // Extract port from dev script text
     const scriptText = scripts?.dev ?? scripts?.start ?? "";
     if (scriptText) {
       const portMatch = scriptText.match(/(?:--port|PORT=)\s*(\d+)/);
@@ -98,5 +105,5 @@ export function detectAppType(cwd: string): AppDetection {
 
   const baseUrl = `http://localhost:${port}`;
 
-  return { type, devCommand, port, baseUrl };
+  return { type, devCommand, port, baseUrl, isLikelyApp };
 }

package/src/qa/matrix.ts

@@ -1,11 +1,17 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { E2eMatrix, E2eFlowRecord, E2eTestResult, E2eRegression } from "./types.js";
 import type { PlatformPaths } from "../platform/types.js";
+import type { WorkspaceTarget } from "../types.js";
+import { getLocalTargetStatePath } from "../workspace/state-paths.js"
+import type { E2eFlowRecord, E2eMatrix, E2eRegression, E2eTestResult } from "./types.js";
 
 const MATRIX_FILENAME = "e2e-matrix.json";
 
-function getMatrixPath(paths: PlatformPaths, cwd: string): string {
+function getMatrixPath(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget): string {
+  if (target) {
+    return getLocalTargetStatePath(paths, target, MATRIX_FILENAME);
+  }
+
   return paths.project(cwd, MATRIX_FILENAME);
 }
 
@@ -18,8 +24,8 @@ export function createEmptyMatrix(appType: string): E2eMatrix {
   };
 }
 
-export function loadE2eMatrix(paths: PlatformPaths, cwd: string): E2eMatrix | null {
-  const matrixPath = getMatrixPath(paths, cwd);
+export function loadE2eMatrix(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget): E2eMatrix | null {
+  const matrixPath = getMatrixPath(paths, cwd, target);
   if (!fs.existsSync(matrixPath)) return null;
   try {
     return JSON.parse(fs.readFileSync(matrixPath, "utf-8")) as E2eMatrix;
@@ -28,8 +34,8 @@ export function loadE2eMatrix(paths: PlatformPaths, cwd: string): E2eMatrix | nu
   }
 }
 
-export function saveE2eMatrix(paths: PlatformPaths, cwd: string, matrix: E2eMatrix): void {
-  const matrixPath = getMatrixPath(paths, cwd);
+export function saveE2eMatrix(paths: PlatformPaths, cwd: string, matrix: E2eMatrix, target?: WorkspaceTarget): void {
+  const matrixPath = getMatrixPath(paths, cwd, target);
   fs.mkdirSync(path.dirname(matrixPath), { recursive: true });
   fs.writeFileSync(matrixPath, JSON.stringify(matrix, null, 2));
 }

package/src/qa/prompt-builder.ts

@@ -13,7 +13,17 @@ export interface E2ePromptOptions {
 }
 
 export function buildE2eOrchestratorPrompt(options: E2ePromptOptions): string {
-  const { appType, sessionDir, scriptsDir, config, discoveredRoutes, previousMatrix, skillContent, dotDirDisplay } = options;
+  const {
+    cwd,
+    appType,
+    sessionDir,
+    scriptsDir,
+    config,
+    discoveredRoutes,
+    previousMatrix,
+    skillContent,
+    dotDirDisplay,
+  } = options;
   const { playwright, execution } = config;
 
   const headedFlag = playwright.headless ? "" : " --headed";
@@ -22,7 +32,7 @@ export function buildE2eOrchestratorPrompt(options: E2ePromptOptions): string {
     "# E2E QA Pipeline — Autonomous Execution",
     "",
     `You are an autonomous E2E QA pipeline for a **${appType.type}** application.`,
-    "Run all phases sequentially without stopping. Use `playwright-cli` for browser interactions and the provided scripts for test execution.",
+    "Run all phases sequentially without stopping. Use `playwright-cli` for browser interactions and the provided Bun runners for execution.",
     "",
     "## Session Context",
     "",
@@ -37,7 +47,6 @@ export function buildE2eOrchestratorPrompt(options: E2ePromptOptions): string {
     "",
   ];
 
-  // Previous matrix
   if (previousMatrix) {
     sections.push(
       "## Previous Matrix",
@@ -53,7 +62,6 @@ export function buildE2eOrchestratorPrompt(options: E2ePromptOptions): string {
     );
   }
 
-  // Route hints (not authoritative — playwright-cli exploration is the source of truth)
   sections.push(
     "## Route Hints",
     "",
@@ -65,7 +73,6 @@ export function buildE2eOrchestratorPrompt(options: E2ePromptOptions): string {
     "",
   );
 
-  // Skill content
   if (skillContent) {
     sections.push(
       "## E2E Testing Methodology",
@@ -75,7 +82,6 @@ export function buildE2eOrchestratorPrompt(options: E2ePromptOptions): string {
     );
   }
 
-  // Step 1: Flow Discovery — interactive exploration via playwright-cli
   sections.push(
     "## Step 1: Flow Discovery",
     "",
@@ -105,7 +111,6 @@ export function buildE2eOrchestratorPrompt(options: E2ePromptOptions): string {
     "",
   );
 
-  // Step 2: Test Generation
   sections.push(
     "## Step 2: Test Generation",
     "",
@@ -118,7 +123,7 @@ export function buildE2eOrchestratorPrompt(options: E2ePromptOptions): string {
     "   - Use `expect(page).toHaveURL()`, `expect(locator).toBeVisible()` for assertions",
     "   - Use `page.waitForSelector()` or `expect(locator).toBeVisible()` before assertions — never use `networkidle` (unreliable for SPAs)",
     "   - Set meaningful test descriptions that describe the user journey",
-    `4. Import from \`playwright/test\``,
+    "4. Import from `playwright/test`",
     `5. Each test should start with \`await page.goto('${appType.baseUrl}/...')\``,
     "",
     "Example test structure:",
@@ -138,23 +143,22 @@ export function buildE2eOrchestratorPrompt(options: E2ePromptOptions): string {
     "",
   );
 
-  // Step 3: Execution
   sections.push(
     "## Step 3: Execution",
     "",
     "Run the generated tests:",
     "",
-    `1. Start the dev server:`,
-    "```bash",
-    `bash ${scriptsDir}/start-dev-server.sh "${options.cwd}" "${appType.devCommand}" ${appType.port} 60 "${sessionDir}"`,
+    "1. Start the dev server:",
+    "```text",
+    `bun \"${scriptsDir}/start-dev-server.ts\" \"${cwd}\" \"${appType.devCommand}\" ${appType.port} 60 \"${sessionDir}\"`,
     "```",
     "   Read the JSON output. If `ready: false`, stop and report the error.",
     "",
-    "2. Run the tests — **IMPORTANT: never run playwright directly. Always use the script:**",
-    "```bash",
-    `bash ${scriptsDir}/run-e2e-tests.sh "${sessionDir}/tests" "${appType.baseUrl}"`,
+    "2. Run the tests — **IMPORTANT: never run playwright directly. Always use the runner:**",
+    "```text",
+    `bun \"${scriptsDir}/run-e2e-tests.ts\" \"${sessionDir}/tests\" \"${appType.baseUrl}\"`,
     "```",
-    "   Exit codes: 0 = all passed, 2 = some tests failed, 1 = script/playwright error.",
+    "   Exit codes: 0 = all passed, 2 = some tests failed, 1 = runner/playwright error.",
     "   Read the JSON output. It contains `total`, `passed`, `failed`, `failures[]`.",
     "",
     `3. If there are failures and retries remain (max ${execution.maxRetries}):`,
@@ -164,13 +168,12 @@ export function buildE2eOrchestratorPrompt(options: E2ePromptOptions): string {
     "   - If real app bug: note it for the report",
     "",
     "4. Stop the dev server:",
-    "```bash",
-    `bash ${scriptsDir}/stop-dev-server.sh "${sessionDir}"`,
+    "```text",
+    `bun \"${scriptsDir}/stop-dev-server.ts\" \"${sessionDir}\"`,
     "```",
     "",
   );
 
-  // Step 4: Regression Analysis & Reporting
   sections.push(
     "## Step 4: Regression Analysis & Reporting",
     "",
@@ -195,33 +198,28 @@ export function buildE2eOrchestratorPrompt(options: E2ePromptOptions): string {
     "",
   );
 
-  // Script paths
   sections.push(
-    "## Script Paths",
+    "## Runner Paths",
     "",
-    `- detect-app-type.sh: \`${scriptsDir}/detect-app-type.sh\``,
-    `- discover-routes.sh: \`${scriptsDir}/discover-routes.sh\``,
-    `- start-dev-server.sh: \`${scriptsDir}/start-dev-server.sh\``,
-    `- run-e2e-tests.sh: \`${scriptsDir}/run-e2e-tests.sh\``,
-    `- stop-dev-server.sh: \`${scriptsDir}/stop-dev-server.sh\``,
+    `- start-dev-server.ts: \`${scriptsDir}/start-dev-server.ts\``,
+    `- run-e2e-tests.ts: \`${scriptsDir}/run-e2e-tests.ts\``,
+    `- stop-dev-server.ts: \`${scriptsDir}/stop-dev-server.ts\``,
     "",
   );
 
-  // Token guidance
   sections.push(
     "## Token Guidance",
     "",
     "To minimize token usage:",
-    "- Always use `run-e2e-tests.sh` — never run playwright directly for test execution",
+    "- Always use `run-e2e-tests.ts` — never run playwright directly for test execution",
     "- Use `playwright-cli snapshot` instead of `playwright-cli screenshot` when you only need element structure",
     "- Only read the `failures` array from test results, skip passed tests",
     "- Don't cat full test files when analyzing failures — read only the failing line range",
     "- Write tests incrementally by flow group, run after each group to catch issues early",
-    "- Don't dump raw playwright output — the script produces a compact JSON summary",
+    "- Don't dump raw playwright output — the runner produces a compact JSON summary",
     "",
   );
 
-  // Troubleshooting
   sections.push(
     "## Troubleshooting",
     "",

package/src/qa/scripts/dev-server-utils.ts

@@ -0,0 +1,72 @@
+import { spawnSync } from "node:child_process";
+import { getShellInvocation } from "../../utils/shell.js";
+
+export const DEV_SERVER_PID_FILENAME = "dev-server.pid";
+
+const HEALTHCHECK_TIMEOUT_MS = 1_000;
+const FORCE_KILL_WAIT_MS = 250;
+
+export async function isServerReachable(port: number): Promise<boolean> {
+  try {
+    await fetch(`http://localhost:${port}`, {
+      signal: AbortSignal.timeout(HEALTHCHECK_TIMEOUT_MS),
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function processExists(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function sleep(ms: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function killProcessTree(pid: number): Promise<void> {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return;
+  }
+
+  if (process.platform === "win32") {
+    spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], {
+      stdio: "ignore",
+    });
+    await sleep(FORCE_KILL_WAIT_MS);
+    return;
+  }
+
+  try {
+    process.kill(-pid, "SIGTERM");
+  } catch {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      return;
+    }
+  }
+
+  await sleep(1_000);
+  if (!processExists(pid)) {
+    return;
+  }
+
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+      return;
+    }
+  }
+}
+
+export { getShellInvocation };