supipowers 0.1.0

package/src/config/defaults.ts

@@ -0,0 +1,72 @@
+// src/config/defaults.ts
+import type { SupipowersConfig, Profile } from "../types.js";
+
+export const DEFAULT_CONFIG: SupipowersConfig = {
+  version: "1.0.0",
+  defaultProfile: "thorough",
+  orchestration: {
+    maxParallelAgents: 3,
+    maxFixRetries: 2,
+    maxNestingDepth: 2,
+    modelPreference: "auto",
+  },
+  lsp: {
+    autoDetect: true,
+    setupGuide: true,
+  },
+  notifications: {
+    verbosity: "normal",
+  },
+  qa: {
+    framework: null,
+    command: null,
+  },
+  release: {
+    pipeline: null,
+  },
+};
+
+export const BUILTIN_PROFILES: Record<string, Profile> = {
+  quick: {
+    name: "quick",
+    gates: {
+      lspDiagnostics: true,
+      aiReview: { enabled: true, depth: "quick" },
+      codeQuality: false,
+      testSuite: false,
+      e2e: false,
+    },
+    orchestration: {
+      reviewAfterEachBatch: false,
+      finalReview: false,
+    },
+  },
+  thorough: {
+    name: "thorough",
+    gates: {
+      lspDiagnostics: true,
+      aiReview: { enabled: true, depth: "deep" },
+      codeQuality: true,
+      testSuite: false,
+      e2e: false,
+    },
+    orchestration: {
+      reviewAfterEachBatch: true,
+      finalReview: true,
+    },
+  },
+  "full-regression": {
+    name: "full-regression",
+    gates: {
+      lspDiagnostics: true,
+      aiReview: { enabled: true, depth: "deep" },
+      codeQuality: true,
+      testSuite: true,
+      e2e: true,
+    },
+    orchestration: {
+      reviewAfterEachBatch: true,
+      finalReview: true,
+    },
+  },
+};

package/src/config/loader.ts

@@ -0,0 +1,101 @@
+// src/config/loader.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { SupipowersConfig } from "../types.js";
+import { DEFAULT_CONFIG } from "./defaults.js";
+
+const PROJECT_CONFIG_PATH = [".omp", "supipowers", "config.json"];
+const GLOBAL_CONFIG_DIR = ".omp";
+const GLOBAL_CONFIG_PATH = ["supipowers", "config.json"];
+
+function getProjectConfigPath(cwd: string): string {
+  return path.join(cwd, ...PROJECT_CONFIG_PATH);
+}
+
+function getGlobalConfigPath(): string {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return path.join(home, GLOBAL_CONFIG_DIR, ...GLOBAL_CONFIG_PATH);
+}
+
+function readJsonSafe(filePath: string): Record<string, unknown> | null {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/** Deep merge source into target. Source values override target. */
+export function deepMerge<T extends Record<string, unknown>>(
+  target: T,
+  source: Record<string, unknown>
+): T {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = (result as Record<string, unknown>)[key];
+    if (
+      sourceVal !== null &&
+      typeof sourceVal === "object" &&
+      !Array.isArray(sourceVal) &&
+      targetVal !== null &&
+      typeof targetVal === "object" &&
+      !Array.isArray(targetVal)
+    ) {
+      (result as Record<string, unknown>)[key] = deepMerge(
+        targetVal as Record<string, unknown>,
+        sourceVal as Record<string, unknown>
+      );
+    } else {
+      (result as Record<string, unknown>)[key] = sourceVal;
+    }
+  }
+  return result;
+}
+
+/** Load config with global -> project layering over defaults.
+ *  Validates and migrates if version is outdated. */
+export function loadConfig(cwd: string): SupipowersConfig {
+  const globalData = readJsonSafe(getGlobalConfigPath());
+  const projectData = readJsonSafe(getProjectConfigPath(cwd));
+
+  let config = { ...DEFAULT_CONFIG };
+  if (globalData) config = deepMerge(config, globalData);
+  if (projectData) config = deepMerge(config, projectData);
+
+  // Migrate if version is older than current default
+  if (config.version !== DEFAULT_CONFIG.version) {
+    config = migrateConfig(config);
+    // Persist migrated config if project-level exists
+    if (projectData) saveConfig(cwd, config);
+  }
+
+  return config;
+}
+
+/** Migrate config from older versions to current */
+function migrateConfig(config: SupipowersConfig): SupipowersConfig {
+  // Currently v1.0.0 is the only version — future migrations go here
+  // Each migration handles one version bump:
+  // if (config.version === "0.x.x") { ... config.version = "1.0.0"; }
+  return { ...config, version: DEFAULT_CONFIG.version };
+}
+
+/** Save project-level config */
+export function saveConfig(cwd: string, config: SupipowersConfig): void {
+  const configPath = getProjectConfigPath(cwd);
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+
+/** Update specific config fields (deep merge into current) */
+export function updateConfig(
+  cwd: string,
+  updates: Record<string, unknown>
+): SupipowersConfig {
+  const current = loadConfig(cwd);
+  const updated = deepMerge(current, updates);
+  saveConfig(cwd, updated);
+  return updated;
+}

package/src/config/profiles.ts

@@ -0,0 +1,64 @@
+// src/config/profiles.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { Profile, SupipowersConfig } from "../types.js";
+import { BUILTIN_PROFILES } from "./defaults.js";
+
+const PROFILES_DIR = [".omp", "supipowers", "profiles"];
+
+function getProfilesDir(cwd: string): string {
+  return path.join(cwd, ...PROFILES_DIR);
+}
+
+/** Load a profile by name. Checks project dir first, then built-ins. */
+export function loadProfile(cwd: string, name: string): Profile | null {
+  // Check project-level custom profiles
+  const customPath = path.join(getProfilesDir(cwd), `${name}.json`);
+  if (fs.existsSync(customPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(customPath, "utf-8")) as Profile;
+    } catch {
+      // fall through to built-in
+    }
+  }
+  return BUILTIN_PROFILES[name] ?? null;
+}
+
+/** Resolve the active profile from config, with optional override */
+export function resolveProfile(
+  cwd: string,
+  config: SupipowersConfig,
+  override?: string
+): Profile {
+  const name = override ?? config.defaultProfile;
+  const profile = loadProfile(cwd, name);
+  if (!profile) {
+    // Fallback to thorough if configured profile doesn't exist
+    return BUILTIN_PROFILES["thorough"];
+  }
+  return profile;
+}
+
+/** List all available profiles (built-in + custom) */
+export function listProfiles(cwd: string): string[] {
+  const names = new Set(Object.keys(BUILTIN_PROFILES));
+  const dir = getProfilesDir(cwd);
+  if (fs.existsSync(dir)) {
+    for (const file of fs.readdirSync(dir)) {
+      if (file.endsWith(".json")) {
+        names.add(file.replace(".json", ""));
+      }
+    }
+  }
+  return [...names].sort();
+}
+
+/** Save a custom profile */
+export function saveProfile(cwd: string, profile: Profile): void {
+  const dir = getProfilesDir(cwd);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, `${profile.name}.json`),
+    JSON.stringify(profile, null, 2) + "\n"
+  );
+}

package/src/config/schema.ts

@@ -0,0 +1,42 @@
+// src/config/schema.ts
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import type { SupipowersConfig, Profile } from "../types.js";
+
+const ConfigSchema = Type.Object({
+  version: Type.String(),
+  defaultProfile: Type.String(),
+  orchestration: Type.Object({
+    maxParallelAgents: Type.Number({ minimum: 1, maximum: 10 }),
+    maxFixRetries: Type.Number({ minimum: 0, maximum: 5 }),
+    maxNestingDepth: Type.Number({ minimum: 0, maximum: 5 }),
+    modelPreference: Type.String(),
+  }),
+  lsp: Type.Object({
+    autoDetect: Type.Boolean(),
+    setupGuide: Type.Boolean(),
+  }),
+  notifications: Type.Object({
+    verbosity: Type.Union([
+      Type.Literal("quiet"),
+      Type.Literal("normal"),
+      Type.Literal("verbose"),
+    ]),
+  }),
+  qa: Type.Object({
+    framework: Type.Union([Type.String(), Type.Null()]),
+    command: Type.Union([Type.String(), Type.Null()]),
+  }),
+  release: Type.Object({
+    pipeline: Type.Union([Type.String(), Type.Null()]),
+  }),
+});
+
+export function validateConfig(data: unknown): { valid: boolean; errors: string[] } {
+  const valid = Value.Check(ConfigSchema, data);
+  if (valid) return { valid: true, errors: [] };
+  const errors = [...Value.Errors(ConfigSchema, data)].map(
+    (e) => `${e.path}: ${e.message}`
+  );
+  return { valid: false, errors };
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { registerSupiCommand } from "./commands/supi.js";
+import { registerConfigCommand } from "./commands/config.js";
+import { registerStatusCommand } from "./commands/status.js";
+import { registerPlanCommand } from "./commands/plan.js";
+import { registerRunCommand } from "./commands/run.js";
+import { registerReviewCommand } from "./commands/review.js";
+import { registerQaCommand } from "./commands/qa.js";
+import { registerReleaseCommand } from "./commands/release.js";
+
+export default function supipowers(pi: ExtensionAPI): void {
+  // Register all commands
+  registerSupiCommand(pi);
+  registerConfigCommand(pi);
+  registerStatusCommand(pi);
+  registerPlanCommand(pi);
+  registerRunCommand(pi);
+  registerReviewCommand(pi);
+  registerQaCommand(pi);
+  registerReleaseCommand(pi);
+
+  // Session start
+  pi.on("session_start", async (_event, ctx) => {
+    if (ctx.hasUI) {
+      ctx.ui.setStatus("supipowers", "supi ready");
+    }
+  });
+}

package/src/lsp/bridge.ts

@@ -0,0 +1,59 @@
+// src/lsp/bridge.ts
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+
+export interface DiagnosticsResult {
+  file: string;
+  diagnostics: Diagnostic[];
+}
+
+export interface Diagnostic {
+  severity: "error" | "warning" | "info" | "hint";
+  message: string;
+  line: number;
+  column: number;
+}
+
+/**
+ * Request LSP diagnostics for a file by sending a message that
+ * triggers the LLM to use the lsp tool. For direct use,
+ * we provide a prompt snippet the orchestrator can include
+ * in sub-agent assignments.
+ */
+export function buildLspDiagnosticsPrompt(files: string[]): string {
+  const fileList = files.map((f) => `- ${f}`).join("\n");
+  return [
+    "Run LSP diagnostics on these files and report any errors or warnings:",
+    fileList,
+    "",
+    'Use the lsp tool with action "diagnostics" for each file.',
+    "Report the results in this format:",
+    "FILE: <path>",
+    "  LINE:COL SEVERITY: message",
+  ].join("\n");
+}
+
+/**
+ * Build a prompt snippet for sub-agents to check references before renaming.
+ */
+export function buildLspReferencesPrompt(symbol: string, file: string): string {
+  return [
+    `Before modifying "${symbol}" in ${file}, use the lsp tool:`,
+    `1. action: "references", file: "${file}", symbol: "${symbol}"`,
+    "2. Review all references to understand impact",
+    "3. Update all references as part of your changes",
+  ].join("\n");
+}
+
+/**
+ * Build a prompt for post-edit validation via LSP.
+ */
+export function buildLspValidationPrompt(files: string[]): string {
+  const fileList = files.map((f) => `- ${f}`).join("\n");
+  return [
+    "After making your changes, validate with LSP:",
+    fileList,
+    "",
+    'Use the lsp tool with action "diagnostics" on each changed file.',
+    "If there are errors, fix them before reporting completion.",
+  ].join("\n");
+}

package/src/lsp/detector.ts

@@ -0,0 +1,38 @@
+// src/lsp/detector.ts
+import type { SupipowersConfig } from "../types.js";
+
+export interface LspStatus {
+  available: boolean;
+  servers: LspServerInfo[];
+}
+
+export interface LspServerInfo {
+  name: string;
+  status: "running" | "stopped" | "error";
+  fileTypes: string[];
+  error?: string;
+}
+
+/**
+ * Check LSP availability by invoking the lsp tool's "status" action.
+ * Uses pi.exec to call the lsp tool programmatically.
+ */
+export async function detectLsp(
+  exec: (cmd: string, args: string[]) => Promise<{ stdout: string; exitCode: number }>
+): Promise<LspStatus> {
+  try {
+    // We check by looking for LSP config files or running servers
+    // In OMP, LSP is a built-in tool — we check if it's in active tools
+    return { available: false, servers: [] };
+  } catch {
+    return { available: false, servers: [] };
+  }
+}
+
+/**
+ * Check if LSP is available from the extension context.
+ * Reads the active tools list to see if "lsp" is registered.
+ */
+export function isLspAvailable(activeTools: string[]): boolean {
+  return activeTools.includes("lsp");
+}

package/src/lsp/setup-guide.ts

@@ -0,0 +1,81 @@
+// src/lsp/setup-guide.ts
+
+export interface SetupInstruction {
+  language: string;
+  server: string;
+  installCommand: string;
+  notes: string;
+}
+
+const COMMON_LSP_SERVERS: SetupInstruction[] = [
+  {
+    language: "TypeScript/JavaScript",
+    server: "typescript-language-server",
+    installCommand: "bun add -g typescript-language-server typescript",
+    notes: "Requires a tsconfig.json in your project root.",
+  },
+  {
+    language: "Python",
+    server: "pyright",
+    installCommand: "pip install pyright",
+    notes: "Works best with a pyrightconfig.json or pyproject.toml.",
+  },
+  {
+    language: "Rust",
+    server: "rust-analyzer",
+    installCommand: "rustup component add rust-analyzer",
+    notes: "Requires a Cargo.toml project.",
+  },
+  {
+    language: "Go",
+    server: "gopls",
+    installCommand: "go install golang.org/x/tools/gopls@latest",
+    notes: "Requires a go.mod project.",
+  },
+];
+
+/** Get setup instructions for detected project languages */
+export function getSetupInstructions(detectedLanguages: string[]): SetupInstruction[] {
+  return COMMON_LSP_SERVERS.filter((s) =>
+    detectedLanguages.some((lang) =>
+      s.language.toLowerCase().includes(lang.toLowerCase())
+    )
+  );
+}
+
+/** Detect project languages from file extensions */
+export function detectProjectLanguages(files: string[]): string[] {
+  const extMap: Record<string, string> = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".py": "python",
+    ".rs": "rust",
+    ".go": "go",
+    ".java": "java",
+    ".rb": "ruby",
+    ".php": "php",
+  };
+  const languages = new Set<string>();
+  for (const file of files) {
+    const ext = file.slice(file.lastIndexOf("."));
+    if (extMap[ext]) languages.add(extMap[ext]);
+  }
+  return [...languages];
+}
+
+/** Format setup instructions as readable text */
+export function formatSetupGuide(instructions: SetupInstruction[]): string {
+  if (instructions.length === 0) {
+    return "No LSP setup instructions available for your project languages.";
+  }
+  const lines = ["LSP Setup Guide:", ""];
+  for (const inst of instructions) {
+    lines.push(`## ${inst.language} — ${inst.server}`);
+    lines.push(`Install: ${inst.installCommand}`);
+    lines.push(`Note: ${inst.notes}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}

package/src/notifications/renderer.ts

@@ -0,0 +1,67 @@
+import type { Notification } from "../types.js";
+import { LEVEL_ICONS, NOTIFY_TYPE_MAP } from "./types.js";
+
+/** Format a notification into a styled text string */
+export function formatNotification(notification: Notification): string {
+  const icon = LEVEL_ICONS[notification.level] ?? "";
+  const parts = [`${icon} ${notification.title}`];
+  if (notification.detail) {
+    parts.push(` \u2014 ${notification.detail}`);
+  }
+  return parts.join("");
+}
+
+/** Send a notification through OMP's UI */
+export function sendNotification(
+  ctx: { ui: { notify(message: string, type?: "info" | "warning" | "error"): void } },
+  notification: Notification
+): void {
+  const message = formatNotification(notification);
+  const type = NOTIFY_TYPE_MAP[notification.level] ?? "info";
+  ctx.ui.notify(message, type);
+}
+
+/** Convenience: send a success notification */
+export function notifySuccess(
+  ctx: { ui: { notify(message: string, type?: "info" | "warning" | "error"): void } },
+  title: string,
+  detail?: string
+): void {
+  sendNotification(ctx, { level: "success", title, detail });
+}
+
+/** Convenience: send a warning notification */
+export function notifyWarning(
+  ctx: { ui: { notify(message: string, type?: "info" | "warning" | "error"): void } },
+  title: string,
+  detail?: string
+): void {
+  sendNotification(ctx, { level: "warning", title, detail });
+}
+
+/** Convenience: send an error notification */
+export function notifyError(
+  ctx: { ui: { notify(message: string, type?: "info" | "warning" | "error"): void } },
+  title: string,
+  detail?: string
+): void {
+  sendNotification(ctx, { level: "error", title, detail });
+}
+
+/** Convenience: send an info notification */
+export function notifyInfo(
+  ctx: { ui: { notify(message: string, type?: "info" | "warning" | "error"): void } },
+  title: string,
+  detail?: string
+): void {
+  sendNotification(ctx, { level: "info", title, detail });
+}
+
+/** Convenience: send a summary notification */
+export function notifySummary(
+  ctx: { ui: { notify(message: string, type?: "info" | "warning" | "error"): void } },
+  title: string,
+  detail?: string
+): void {
+  sendNotification(ctx, { level: "summary", title, detail });
+}

package/src/notifications/types.ts

@@ -0,0 +1,19 @@
+export type { Notification, NotificationLevel } from "../types.js";
+
+/** Icons mapped to notification levels */
+export const LEVEL_ICONS: Record<string, string> = {
+  success: "\u2713",  // ✓
+  warning: "\u26A0",  // ⚠
+  error: "\u2717",    // ✗
+  info: "\u25C9",     // ◉
+  summary: "\u25B8",  // ▸
+};
+
+/** Map notification levels to ctx.ui.notify types */
+export const NOTIFY_TYPE_MAP: Record<string, "info" | "warning" | "error"> = {
+  success: "info",
+  warning: "warning",
+  error: "error",
+  info: "info",
+  summary: "info",
+};

package/src/orchestrator/batch-scheduler.ts

@@ -0,0 +1,59 @@
+// src/orchestrator/batch-scheduler.ts
+import type { PlanTask, RunBatch } from "../types.js";
+
+/**
+ * Group plan tasks into execution batches.
+ * Parallel-safe tasks with no pending dependencies run together.
+ * Sequential tasks wait for their dependencies.
+ */
+export function scheduleBatches(
+  tasks: PlanTask[],
+  maxParallel: number
+): RunBatch[] {
+  const batches: RunBatch[] = [];
+  const completed = new Set<number>();
+  const remaining = new Set(tasks.map((t) => t.id));
+
+  let batchIndex = 0;
+
+  while (remaining.size > 0) {
+    const ready: number[] = [];
+
+    for (const task of tasks) {
+      if (!remaining.has(task.id)) continue;
+
+      if (task.parallelism.type === "parallel-safe") {
+        ready.push(task.id);
+      } else if (task.parallelism.type === "sequential") {
+        const depsReady = task.parallelism.dependsOn.every((dep) =>
+          completed.has(dep)
+        );
+        if (depsReady) ready.push(task.id);
+      }
+
+      if (ready.length >= maxParallel) break;
+    }
+
+    if (ready.length === 0) {
+      // Deadlock: remaining tasks have unresolvable dependencies
+      // Force the first remaining task into a batch
+      const first = [...remaining][0];
+      ready.push(first);
+    }
+
+    const batch: RunBatch = {
+      index: batchIndex++,
+      taskIds: ready.slice(0, maxParallel),
+      status: "pending",
+    };
+
+    for (const id of batch.taskIds) {
+      remaining.delete(id);
+      completed.add(id);
+    }
+
+    batches.push(batch);
+  }
+
+  return batches;
+}

package/src/orchestrator/conflict-resolver.ts

@@ -0,0 +1,38 @@
+import type { AgentResult, PlanTask } from "../types.js";
+import { detectConflicts } from "./result-collector.js";
+import { buildMergePrompt } from "./prompts.js";
+
+export interface ConflictResolution {
+  hasConflicts: boolean;
+  conflictingFiles: string[];
+  mergePrompt?: string;
+}
+
+export function analyzeConflicts(
+  results: AgentResult[],
+  tasks: PlanTask[]
+): ConflictResolution {
+  const conflictingFiles = detectConflicts(results);
+
+  if (conflictingFiles.length === 0) {
+    return { hasConflicts: false, conflictingFiles: [] };
+  }
+
+  const conflictingResults = results.filter((r) =>
+    r.filesChanged.some((f) => conflictingFiles.includes(f))
+  );
+
+  const agentOutputs = conflictingResults.map((r) => {
+    const task = tasks.find((t) => t.id === r.taskId);
+    return {
+      taskName: task?.name ?? `Task ${r.taskId}`,
+      output: r.output,
+    };
+  });
+
+  return {
+    hasConflicts: true,
+    conflictingFiles,
+    mergePrompt: buildMergePrompt(conflictingFiles, agentOutputs),
+  };
+}