supipowers 0.1.0

package/src/orchestrator/dispatcher.ts

@@ -0,0 +1,106 @@
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import type { PlanTask, AgentResult, AgentStatus, SupipowersConfig } from "../types.js";
+import { buildTaskPrompt, buildFixPrompt } from "./prompts.js";
+import { isLspAvailable } from "../lsp/detector.js";
+import { notifySuccess, notifyWarning, notifyError } from "../notifications/renderer.js";
+
+export interface DispatchOptions {
+  pi: ExtensionAPI;
+  ctx: { cwd: string; ui: { notify(msg: string, type?: "info" | "warning" | "error"): void } };
+  task: PlanTask;
+  planContext: string;
+  config: SupipowersConfig;
+  lspAvailable: boolean;
+}
+
+export async function dispatchAgent(options: DispatchOptions): Promise<AgentResult> {
+  const { pi, ctx, task, planContext, config, lspAvailable } = options;
+  const startTime = Date.now();
+
+  const prompt = buildTaskPrompt(task, planContext, config, lspAvailable);
+
+  try {
+    const result = await executeSubAgent(pi, prompt, task, config);
+
+    const agentResult: AgentResult = {
+      taskId: task.id,
+      status: result.status,
+      output: result.output,
+      concerns: result.concerns,
+      filesChanged: result.filesChanged,
+      duration: Date.now() - startTime,
+    };
+
+    switch (agentResult.status) {
+      case "done":
+        notifySuccess(ctx, `Task ${task.id} completed`, task.name);
+        break;
+      case "done_with_concerns":
+        notifyWarning(ctx, `Task ${task.id} done with concerns`, agentResult.concerns);
+        break;
+      case "blocked":
+        notifyError(ctx, `Task ${task.id} blocked`, agentResult.output);
+        break;
+    }
+
+    return agentResult;
+  } catch (error) {
+    const agentResult: AgentResult = {
+      taskId: task.id,
+      status: "blocked",
+      output: `Agent error: ${error instanceof Error ? error.message : String(error)}`,
+      filesChanged: [],
+      duration: Date.now() - startTime,
+    };
+    notifyError(ctx, `Task ${task.id} failed`, agentResult.output);
+    return agentResult;
+  }
+}
+
+interface SubAgentResult {
+  status: AgentStatus;
+  output: string;
+  concerns?: string;
+  filesChanged: string[];
+}
+
+async function executeSubAgent(
+  pi: ExtensionAPI,
+  prompt: string,
+  task: PlanTask,
+  config: SupipowersConfig
+): Promise<SubAgentResult> {
+  throw new Error(
+    "Sub-agent dispatch requires OMP runtime. " +
+    "This will be connected to createAgentSession during integration."
+  );
+}
+
+export async function dispatchFixAgent(
+  options: DispatchOptions & { previousOutput: string; failureReason: string }
+): Promise<AgentResult> {
+  const { pi, ctx, task, config, lspAvailable, previousOutput, failureReason } = options;
+  const startTime = Date.now();
+
+  const prompt = buildFixPrompt(task, previousOutput, failureReason, lspAvailable);
+
+  try {
+    const result = await executeSubAgent(pi, prompt, task, config);
+    return {
+      taskId: task.id,
+      status: result.status,
+      output: result.output,
+      concerns: result.concerns,
+      filesChanged: result.filesChanged,
+      duration: Date.now() - startTime,
+    };
+  } catch (error) {
+    return {
+      taskId: task.id,
+      status: "blocked",
+      output: `Fix agent error: ${error instanceof Error ? error.message : String(error)}`,
+      filesChanged: [],
+      duration: Date.now() - startTime,
+    };
+  }
+}

package/src/orchestrator/prompts.ts

@@ -0,0 +1,123 @@
+// src/orchestrator/prompts.ts
+import type { PlanTask, SupipowersConfig } from "../types.js";
+import { buildLspValidationPrompt } from "../lsp/bridge.js";
+
+/** Build the system prompt for a sub-agent executing a task */
+export function buildTaskPrompt(
+  task: PlanTask,
+  planContext: string,
+  config: SupipowersConfig,
+  lspAvailable: boolean
+): string {
+  const sections: string[] = [
+    "# Task Assignment",
+    "",
+    `## Task: ${task.name}`,
+    "",
+    task.description,
+    "",
+    "## Target Files",
+    ...task.files.map((f) => `- ${f}`),
+    "",
+    "## Acceptance Criteria",
+    task.criteria,
+    "",
+    "## Context",
+    planContext,
+    "",
+    "## Instructions",
+    "1. Read the target files to understand current state",
+    "2. Implement the changes described above",
+    "3. Ensure acceptance criteria are met",
+    "4. Report your status when done",
+    "",
+    "Report one of these statuses:",
+    "- DONE: Task completed successfully, all criteria met",
+    "- DONE_WITH_CONCERNS: Completed but with caveats (explain what)",
+    "- BLOCKED: Cannot complete (explain why and what's needed)",
+  ];
+
+  if (lspAvailable) {
+    sections.push(
+      "",
+      "## LSP Available",
+      "You have access to the LSP tool. Use it to:",
+      "- Check diagnostics after making changes",
+      "- Find references before renaming symbols",
+      "- Validate your work has no type errors",
+      "",
+      buildLspValidationPrompt(task.files)
+    );
+  }
+
+  return sections.join("\n");
+}
+
+/** Build prompt for a fix agent */
+export function buildFixPrompt(
+  task: PlanTask,
+  previousOutput: string,
+  failureReason: string,
+  lspAvailable: boolean
+): string {
+  const sections: string[] = [
+    "# Fix Assignment",
+    "",
+    `## Original Task: ${task.name}`,
+    "",
+    "## What Went Wrong",
+    failureReason,
+    "",
+    "## Previous Agent Output",
+    previousOutput,
+    "",
+    "## Target Files",
+    ...task.files.map((f) => `- ${f}`),
+    "",
+    "## Acceptance Criteria",
+    task.criteria,
+    "",
+    "## Instructions",
+    "1. Understand what the previous agent attempted",
+    "2. Identify and fix the issue",
+    "3. Verify the acceptance criteria are now met",
+    "4. Report your status",
+  ];
+
+  if (lspAvailable) {
+    sections.push("", buildLspValidationPrompt(task.files));
+  }
+
+  return sections.join("\n");
+}
+
+/** Build prompt for a merge/conflict resolution agent */
+export function buildMergePrompt(
+  conflictingFiles: string[],
+  agentOutputs: { taskName: string; output: string }[]
+): string {
+  const sections: string[] = [
+    "# Merge Assignment",
+    "",
+    "Multiple agents edited the same files. Resolve the conflicts.",
+    "",
+    "## Conflicting Files",
+    ...conflictingFiles.map((f) => `- ${f}`),
+    "",
+    "## Agent Outputs",
+  ];
+
+  for (const { taskName, output } of agentOutputs) {
+    sections.push(`### ${taskName}`, output, "");
+  }
+
+  sections.push(
+    "## Instructions",
+    "1. Read each conflicting file",
+    "2. Understand what each agent intended",
+    "3. Merge the changes so both intents are preserved",
+    "4. If changes are incompatible, report BLOCKED with explanation"
+  );
+
+  return sections.join("\n");
+}

package/src/orchestrator/result-collector.ts

@@ -0,0 +1,72 @@
+import type { AgentResult, RunBatch } from "../types.js";
+
+export interface BatchSummary {
+  batchIndex: number;
+  total: number;
+  done: number;
+  doneWithConcerns: number;
+  blocked: number;
+  allPassed: boolean;
+  concerns: string[];
+  blockers: string[];
+  filesChanged: string[];
+}
+
+export function summarizeBatch(
+  batch: RunBatch,
+  results: AgentResult[]
+): BatchSummary {
+  const batchResults = results.filter((r) => batch.taskIds.includes(r.taskId));
+
+  const done = batchResults.filter((r) => r.status === "done").length;
+  const doneWithConcerns = batchResults.filter(
+    (r) => r.status === "done_with_concerns"
+  ).length;
+  const blocked = batchResults.filter((r) => r.status === "blocked").length;
+
+  return {
+    batchIndex: batch.index,
+    total: batch.taskIds.length,
+    done,
+    doneWithConcerns,
+    blocked,
+    allPassed: blocked === 0,
+    concerns: batchResults
+      .filter((r) => r.concerns)
+      .map((r) => r.concerns!),
+    blockers: batchResults
+      .filter((r) => r.status === "blocked")
+      .map((r) => r.output),
+    filesChanged: batchResults.flatMap((r) => r.filesChanged),
+  };
+}
+
+export function detectConflicts(results: AgentResult[]): string[] {
+  const fileCounts = new Map<string, number>();
+  for (const result of results) {
+    for (const file of result.filesChanged) {
+      fileCounts.set(file, (fileCounts.get(file) ?? 0) + 1);
+    }
+  }
+  return [...fileCounts.entries()]
+    .filter(([, count]) => count > 1)
+    .map(([file]) => file);
+}
+
+export function buildRunSummary(allResults: AgentResult[]): {
+  totalTasks: number;
+  done: number;
+  doneWithConcerns: number;
+  blocked: number;
+  totalFilesChanged: number;
+  totalDuration: number;
+} {
+  return {
+    totalTasks: allResults.length,
+    done: allResults.filter((r) => r.status === "done").length,
+    doneWithConcerns: allResults.filter((r) => r.status === "done_with_concerns").length,
+    blocked: allResults.filter((r) => r.status === "blocked").length,
+    totalFilesChanged: new Set(allResults.flatMap((r) => r.filesChanged)).size,
+    totalDuration: allResults.reduce((sum, r) => sum + r.duration, 0),
+  };
+}

package/src/qa/detector.ts

@@ -0,0 +1,61 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { updateConfig, loadConfig } from "../config/loader.js";
+
+export interface DetectedFramework {
+  name: string;
+  command: string;
+}
+
+const FRAMEWORK_SIGNATURES: { name: string; files: string[]; command: string }[] = [
+  { name: "vitest", files: ["vitest.config.ts", "vitest.config.js", "vitest.config.mts"], command: "npx vitest run" },
+  { name: "jest", files: ["jest.config.ts", "jest.config.js", "jest.config.mjs"], command: "npx jest" },
+  { name: "mocha", files: [".mocharc.yml", ".mocharc.json", ".mocharc.js"], command: "npx mocha" },
+  { name: "pytest", files: ["pytest.ini", "pyproject.toml", "conftest.py"], command: "pytest" },
+  { name: "cargo-test", files: ["Cargo.toml"], command: "cargo test" },
+  { name: "go-test", files: ["go.mod"], command: "go test ./..." },
+];
+
+export function detectFramework(cwd: string): DetectedFramework | null {
+  const pkgPath = path.join(cwd, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      if (pkg.scripts?.test && pkg.scripts.test !== 'echo "Error: no test specified" && exit 1') {
+        const testScript = pkg.scripts.test;
+        for (const sig of FRAMEWORK_SIGNATURES) {
+          if (testScript.includes(sig.name)) {
+            return { name: sig.name, command: "npm test" };
+          }
+        }
+        return { name: "npm-test", command: "npm test" };
+      }
+    } catch {
+      // continue to file-based detection
+    }
+  }
+
+  for (const sig of FRAMEWORK_SIGNATURES) {
+    for (const file of sig.files) {
+      if (fs.existsSync(path.join(cwd, file))) {
+        return { name: sig.name, command: sig.command };
+      }
+    }
+  }
+
+  return null;
+}
+
+export function detectAndCache(cwd: string): DetectedFramework | null {
+  const config = loadConfig(cwd);
+
+  if (config.qa.framework && config.qa.command) {
+    return { name: config.qa.framework, command: config.qa.command };
+  }
+
+  const detected = detectFramework(cwd);
+  if (detected) {
+    updateConfig(cwd, { qa: { framework: detected.name, command: detected.command } });
+  }
+  return detected;
+}

package/src/qa/report.ts

@@ -0,0 +1,22 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface QaReport {
+  timestamp: string;
+  framework: string;
+  scope: string;
+  totalTests: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  failures: { name: string; file: string; error: string }[];
+}
+
+export function saveQaReport(cwd: string, report: QaReport): string {
+  const dir = path.join(cwd, ".omp", "supipowers", "reports");
+  fs.mkdirSync(dir, { recursive: true });
+  const filename = `qa-${report.timestamp.slice(0, 10)}.json`;
+  const filePath = path.join(dir, filename);
+  fs.writeFileSync(filePath, JSON.stringify(report, null, 2) + "\n");
+  return filePath;
+}

package/src/qa/runner.ts

@@ -0,0 +1,46 @@
+export function buildQaRunPrompt(
+  command: string,
+  scope: "all" | "changed" | "e2e",
+  changedFiles?: string[]
+): string {
+  const sections: string[] = ["# QA Pipeline", ""];
+
+  switch (scope) {
+    case "all":
+      sections.push(`Run the full test suite: \`${command}\``);
+      break;
+    case "changed":
+      sections.push(
+        "Run tests related to changed files only:",
+        ...(changedFiles ?? []).map((f) => `- ${f}`),
+        "",
+        `Base command: \`${command}\``,
+        "Filter to only tests relevant to the files above."
+      );
+      break;
+    case "e2e":
+      sections.push(
+        "Run end-to-end tests only.",
+        "Use Playwright or the configured E2E framework.",
+        "Command: `npx playwright test`"
+      );
+      break;
+  }
+
+  sections.push(
+    "",
+    "Report results in this format:",
+    "- Total tests: N",
+    "- Passed: N",
+    "- Failed: N",
+    "- Skipped: N",
+    "",
+    "For each failure, include:",
+    "- Test name",
+    "- File path",
+    "- Error message",
+    "- Stack trace (first 5 lines)"
+  );
+
+  return sections.join("\n");
+}

package/src/quality/ai-review-gate.ts

@@ -0,0 +1,43 @@
+import type { GateResult } from "../types.js";
+
+export function buildAiReviewPrompt(
+  changedFiles: string[],
+  depth: "quick" | "deep"
+): string {
+  const depthInstructions =
+    depth === "quick"
+      ? "Do a quick scan: check for obvious bugs, security issues, and naming problems."
+      : [
+          "Do a thorough review covering:",
+          "- Correctness and edge cases",
+          "- Security vulnerabilities (OWASP top 10)",
+          "- Performance concerns",
+          "- Code clarity and maintainability",
+          "- Error handling completeness",
+          "- Test coverage gaps",
+        ].join("\n");
+
+  return [
+    "Review the following changed files:",
+    ...changedFiles.map((f) => `- ${f}`),
+    "",
+    depthInstructions,
+    "",
+    "For each issue found, report:",
+    "- Severity: error | warning | info",
+    "- File and line number",
+    "- Description of the issue",
+    "- Suggested fix",
+  ].join("\n");
+}
+
+export function createAiReviewResult(
+  issues: { severity: "error" | "warning" | "info"; message: string; file?: string; line?: number }[]
+): GateResult {
+  const hasErrors = issues.some((i) => i.severity === "error");
+  return {
+    gate: "ai-review",
+    passed: !hasErrors,
+    issues,
+  };
+}

package/src/quality/gate-runner.ts

@@ -0,0 +1,67 @@
+import type { Profile, GateResult, ReviewReport } from "../types.js";
+import { buildLspGatePrompt } from "./lsp-gate.js";
+import { buildAiReviewPrompt } from "./ai-review-gate.js";
+import { buildTestGatePrompt } from "./test-gate.js";
+
+export interface GateRunnerOptions {
+  profile: Profile;
+  changedFiles: string[];
+  testCommand: string | null;
+  lspAvailable: boolean;
+}
+
+export function getActiveGates(profile: Profile, lspAvailable: boolean): string[] {
+  const gates: string[] = [];
+  if (profile.gates.lspDiagnostics && lspAvailable) gates.push("lsp-diagnostics");
+  if (profile.gates.aiReview.enabled) gates.push("ai-review");
+  if (profile.gates.codeQuality) gates.push("code-quality");
+  if (profile.gates.testSuite) gates.push("test-suite");
+  if (profile.gates.e2e) gates.push("e2e");
+  return gates;
+}
+
+export function buildReviewPrompt(options: GateRunnerOptions): string {
+  const { profile, changedFiles, testCommand, lspAvailable } = options;
+  const sections: string[] = [
+    "# Code Review",
+    "",
+    `Profile: ${profile.name}`,
+    "",
+    "Run the following quality checks and report results for each:",
+    "",
+  ];
+
+  if (profile.gates.lspDiagnostics && lspAvailable) {
+    sections.push("## 1. LSP Diagnostics", buildLspGatePrompt(changedFiles), "");
+  }
+
+  if (profile.gates.aiReview.enabled) {
+    sections.push(
+      "## 2. Code Review",
+      buildAiReviewPrompt(changedFiles, profile.gates.aiReview.depth),
+      ""
+    );
+  }
+
+  if (profile.gates.testSuite) {
+    sections.push(
+      "## 3. Test Suite",
+      buildTestGatePrompt(testCommand, false),
+      ""
+    );
+  }
+
+  return sections.join("\n");
+}
+
+export function createReviewReport(
+  profile: string,
+  gates: GateResult[]
+): ReviewReport {
+  return {
+    profile,
+    timestamp: new Date().toISOString(),
+    gates,
+    passed: gates.every((g) => g.passed),
+  };
+}

package/src/quality/lsp-gate.ts

@@ -0,0 +1,24 @@
+import type { GateResult } from "../types.js";
+
+export function buildLspGatePrompt(changedFiles: string[]): string {
+  return [
+    "Run LSP diagnostics on these files and report results:",
+    ...changedFiles.map((f) => `- ${f}`),
+    "",
+    'Use the lsp tool with action "diagnostics" for each file.',
+    "Summarize: total errors, total warnings, and list each issue.",
+  ].join("\n");
+}
+
+export function createLspGateResult(
+  hasErrors: boolean,
+  errorCount: number,
+  warningCount: number,
+  issues: { severity: "error" | "warning" | "info"; message: string; file?: string; line?: number }[]
+): GateResult {
+  return {
+    gate: "lsp-diagnostics",
+    passed: !hasErrors,
+    issues,
+  };
+}

package/src/quality/test-gate.ts

@@ -0,0 +1,39 @@
+import type { GateResult } from "../types.js";
+
+export function buildTestGatePrompt(
+  testCommand: string | null,
+  changedOnly: boolean,
+  changedFiles?: string[]
+): string {
+  const cmd = testCommand ?? "npm test";
+  const scope = changedOnly && changedFiles
+    ? `Only run tests related to: ${changedFiles.join(", ")}`
+    : "Run the full test suite.";
+
+  return [
+    scope,
+    "",
+    `Command: ${cmd}`,
+    "",
+    "Report the results:",
+    "- Total tests, passed, failed, skipped",
+    "- For each failure: test name, file, error message",
+  ].join("\n");
+}
+
+export function createTestGateResult(
+  passed: boolean,
+  totalTests: number,
+  failedTests: number,
+  failures: { message: string; file?: string }[]
+): GateResult {
+  return {
+    gate: "test-suite",
+    passed,
+    issues: failures.map((f) => ({
+      severity: "error" as const,
+      message: `Test failed: ${f.message}`,
+      file: f.file,
+    })),
+  };
+}

package/src/release/analyzer.ts

@@ -0,0 +1,22 @@
+/** Build prompt to analyze commits and suggest version bump */
+export function buildAnalyzerPrompt(lastTag: string | null): string {
+  const sinceArg = lastTag ? `${lastTag}..HEAD` : "HEAD~20..HEAD";
+  return [
+    "# Release Analysis",
+    "",
+    `Analyze commits since ${lastTag ?? "beginning"}.`,
+    "",
+    `Run: git log ${sinceArg} --oneline --no-decorate`,
+    "",
+    "Then determine:",
+    "1. Version bump type: major (breaking changes), minor (new features), patch (fixes)",
+    "2. Categorize commits: features, fixes, breaking changes, other",
+    "3. Suggest the next version number",
+    "",
+    "Report in this format:",
+    "- Current version: <from package.json or last tag>",
+    "- Suggested bump: major|minor|patch",
+    "- Next version: X.Y.Z",
+    "- Changes summary: categorized list",
+  ].join("\n");
+}

package/src/release/notes.ts

@@ -0,0 +1,26 @@
+/** Build prompt to generate release notes */
+export function buildNotesPrompt(version: string, lastTag: string | null): string {
+  const sinceArg = lastTag ? `${lastTag}..HEAD` : "HEAD~20..HEAD";
+  return [
+    "# Generate Release Notes",
+    "",
+    `Version: ${version}`,
+    "",
+    `Run: git log ${sinceArg} --format="%h %s"`,
+    "",
+    "Generate release notes in this format:",
+    "",
+    `## ${version}`,
+    "",
+    "### Features",
+    "- Description (commit hash)",
+    "",
+    "### Fixes",
+    "- Description (commit hash)",
+    "",
+    "### Breaking Changes",
+    "- Description (commit hash)",
+    "",
+    "Keep descriptions user-facing (not commit-message-level detail).",
+  ].join("\n");
+}

package/src/release/publisher.ts

@@ -0,0 +1,33 @@
+/** Build prompt to execute release */
+export function buildPublishPrompt(
+  version: string,
+  pipeline: string | null
+): string {
+  const steps: string[] = [
+    "# Publish Release",
+    "",
+    `Version: ${version}`,
+    "",
+    "Execute these steps (ask for confirmation before each):",
+    "",
+    "1. Update version in package.json",
+    `2. git add package.json && git commit -m "release: v${version}"`,
+    `3. git tag v${version}`,
+  ];
+
+  if (pipeline === "npm") {
+    steps.push("4. npm publish");
+  } else if (pipeline === "github") {
+    steps.push(`4. gh release create v${version} --generate-notes`);
+  } else {
+    steps.push("4. Ask the user what publish step to run");
+  }
+
+  steps.push(
+    "",
+    "IMPORTANT: Ask for user confirmation before tagging and publishing.",
+    "Show them the version, changelog, and what will be published."
+  );
+
+  return steps.join("\n");
+}