supipowers 0.1.0

package/src/storage/plans.ts

@@ -0,0 +1,129 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { Plan, PlanTask, TaskComplexity, TaskParallelism } from "../types.js";
+
+const PLANS_DIR = [".omp", "supipowers", "plans"];
+
+function getPlansDir(cwd: string): string {
+  return path.join(cwd, ...PLANS_DIR);
+}
+
+/** List all saved plans */
+export function listPlans(cwd: string): string[] {
+  const dir = getPlansDir(cwd);
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir)
+    .filter((f) => f.endsWith(".md"))
+    .sort()
+    .reverse();
+}
+
+/** Read a plan file by name */
+export function readPlanFile(cwd: string, name: string): string | null {
+  const filePath = path.join(getPlansDir(cwd), name);
+  if (!fs.existsSync(filePath)) return null;
+  return fs.readFileSync(filePath, "utf-8");
+}
+
+/** Save a plan markdown file */
+export function savePlan(cwd: string, filename: string, content: string): string {
+  const dir = getPlansDir(cwd);
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, filename);
+  fs.writeFileSync(filePath, content);
+  return filePath;
+}
+
+/** Parse a plan markdown file into a Plan object */
+export function parsePlan(content: string, filePath: string): Plan {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  const meta: Record<string, string | string[]> = {};
+
+  if (frontmatterMatch) {
+    for (const line of frontmatterMatch[1].split("\n")) {
+      const colonIdx = line.indexOf(":");
+      if (colonIdx === -1) continue;
+      const key = line.slice(0, colonIdx).trim();
+      const val = line.slice(colonIdx + 1).trim();
+      if (val.startsWith("[") && val.endsWith("]")) {
+        meta[key] = val
+          .slice(1, -1)
+          .split(",")
+          .map((s) => s.trim());
+      } else {
+        meta[key] = val;
+      }
+    }
+  }
+
+  const tasks = parseTasksFromMarkdown(content);
+
+  return {
+    name: (meta.name as string) ?? path.basename(filePath, ".md"),
+    created: (meta.created as string) ?? "",
+    tags: (meta.tags as string[]) ?? [],
+    context: extractContext(content),
+    tasks,
+    filePath,
+  };
+}
+
+function extractContext(content: string): string {
+  const contextMatch = content.match(/## Context\n\n?([\s\S]*?)(?=\n## |$)/);
+  return contextMatch?.[1]?.trim() ?? "";
+}
+
+function parseTasksFromMarkdown(content: string): PlanTask[] {
+  const tasks: PlanTask[] = [];
+  const taskRegex = /### (\d+)\. (.+)/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = taskRegex.exec(content)) !== null) {
+    const id = parseInt(match[1], 10);
+    const headerLine = match[2];
+    const startIdx = match.index + match[0].length;
+    const nextTaskMatch = /\n### \d+\. /.exec(content.slice(startIdx));
+    const endIdx = nextTaskMatch
+      ? startIdx + nextTaskMatch.index
+      : content.length;
+    const body = content.slice(startIdx, endIdx);
+
+    const name = headerLine.replace(/\[.*?\]/g, "").trim();
+    const parallelism = parseParallelism(headerLine);
+    const files = parseFiles(body);
+    const criteria = parseCriteria(body);
+    const complexity = parseComplexity(body);
+
+    tasks.push({ id, name, description: name, files, criteria, complexity, parallelism });
+  }
+  return tasks;
+}
+
+function parseParallelism(header: string): TaskParallelism {
+  if (header.includes("[parallel-safe]")) return { type: "parallel-safe" };
+  const seqMatch = header.match(/\[sequential: depends on (\d[\d, ]*)\]/);
+  if (seqMatch) {
+    const deps = seqMatch[1].split(",").map((s) => parseInt(s.trim(), 10));
+    return { type: "sequential", dependsOn: deps };
+  }
+  return { type: "sequential", dependsOn: [] };
+}
+
+function parseFiles(body: string): string[] {
+  const filesMatch = body.match(/\*\*files?\*\*:\s*(.+)/i);
+  if (!filesMatch) return [];
+  return filesMatch[1].split(",").map((s) => s.trim());
+}
+
+function parseCriteria(body: string): string {
+  const match = body.match(/\*\*criteria\*\*:\s*(.+)/i);
+  return match?.[1]?.trim() ?? "";
+}
+
+function parseComplexity(body: string): TaskComplexity {
+  const match = body.match(/\*\*complexity\*\*:\s*(\w+)/i);
+  const val = match?.[1]?.toLowerCase();
+  if (val === "small" || val === "medium" || val === "large") return val;
+  return "medium";
+}

package/src/storage/reports.ts

@@ -0,0 +1,36 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ReviewReport } from "../types.js";
+
+const REPORTS_DIR = [".omp", "supipowers", "reports"];
+
+function getReportsDir(cwd: string): string {
+  return path.join(cwd, ...REPORTS_DIR);
+}
+
+/** Save a review report */
+export function saveReviewReport(cwd: string, report: ReviewReport): string {
+  const dir = getReportsDir(cwd);
+  fs.mkdirSync(dir, { recursive: true });
+  const filename = `review-${report.timestamp.slice(0, 10)}.json`;
+  const filePath = path.join(dir, filename);
+  fs.writeFileSync(filePath, JSON.stringify(report, null, 2) + "\n");
+  return filePath;
+}
+
+/** Load the latest review report */
+export function loadLatestReport(cwd: string): ReviewReport | null {
+  const dir = getReportsDir(cwd);
+  if (!fs.existsSync(dir)) return null;
+  const files = fs
+    .readdirSync(dir)
+    .filter((f) => f.startsWith("review-") && f.endsWith(".json"))
+    .sort()
+    .reverse();
+  if (files.length === 0) return null;
+  try {
+    return JSON.parse(fs.readFileSync(path.join(dir, files[0]), "utf-8"));
+  } catch {
+    return null;
+  }
+}

package/src/storage/runs.ts

@@ -0,0 +1,124 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { RunManifest, AgentResult } from "../types.js";
+
+const RUNS_DIR = [".omp", "supipowers", "runs"];
+
+function getRunsDir(cwd: string): string {
+  return path.join(cwd, ...RUNS_DIR);
+}
+
+function getRunDir(cwd: string, runId: string): string {
+  return path.join(getRunsDir(cwd), runId);
+}
+
+/** Generate a unique run ID */
+export function generateRunId(): string {
+  const now = new Date();
+  const date = now.toISOString().slice(0, 10).replace(/-/g, "");
+  const time = now.toISOString().slice(11, 19).replace(/:/g, "");
+  const suffix = Math.random().toString(36).slice(2, 6);
+  return `run-${date}-${time}-${suffix}`;
+}
+
+/** Create a new run */
+export function createRun(cwd: string, manifest: RunManifest): void {
+  const runDir = getRunDir(cwd, manifest.id);
+  fs.mkdirSync(path.join(runDir, "agents"), { recursive: true });
+  fs.writeFileSync(
+    path.join(runDir, "manifest.json"),
+    JSON.stringify(manifest, null, 2) + "\n"
+  );
+}
+
+/** Load a run manifest */
+export function loadRun(cwd: string, runId: string): RunManifest | null {
+  const filePath = path.join(getRunDir(cwd, runId), "manifest.json");
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/** Update a run manifest */
+export function updateRun(cwd: string, manifest: RunManifest): void {
+  const filePath = path.join(getRunDir(cwd, manifest.id), "manifest.json");
+  fs.writeFileSync(filePath, JSON.stringify(manifest, null, 2) + "\n");
+}
+
+/** Save an agent result */
+export function saveAgentResult(
+  cwd: string,
+  runId: string,
+  result: AgentResult
+): void {
+  const filePath = path.join(
+    getRunDir(cwd, runId),
+    "agents",
+    `task-${result.taskId}.json`
+  );
+  fs.writeFileSync(filePath, JSON.stringify(result, null, 2) + "\n");
+}
+
+/** Load an agent result */
+export function loadAgentResult(
+  cwd: string,
+  runId: string,
+  taskId: number
+): AgentResult | null {
+  const filePath = path.join(
+    getRunDir(cwd, runId),
+    "agents",
+    `task-${taskId}.json`
+  );
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/** Load all agent results for a run */
+export function loadAllAgentResults(
+  cwd: string,
+  runId: string
+): AgentResult[] {
+  const agentsDir = path.join(getRunDir(cwd, runId), "agents");
+  if (!fs.existsSync(agentsDir)) return [];
+  return fs
+    .readdirSync(agentsDir)
+    .filter((f) => f.endsWith(".json"))
+    .map((f) => {
+      try {
+        return JSON.parse(fs.readFileSync(path.join(agentsDir, f), "utf-8"));
+      } catch {
+        return null;
+      }
+    })
+    .filter((r): r is AgentResult => r !== null);
+}
+
+/** List all runs, newest first */
+export function listRuns(cwd: string): string[] {
+  const dir = getRunsDir(cwd);
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir)
+    .filter((f) => f.startsWith("run-"))
+    .sort()
+    .reverse();
+}
+
+/** Find the latest active run (running or paused) */
+export function findActiveRun(cwd: string): RunManifest | null {
+  for (const runId of listRuns(cwd)) {
+    const manifest = loadRun(cwd, runId);
+    if (manifest && (manifest.status === "running" || manifest.status === "paused")) {
+      return manifest;
+    }
+  }
+  return null;
+}

package/src/types.ts

@@ -0,0 +1,142 @@
+// src/types.ts — Shared type definitions for supipowers
+
+/** Sub-agent execution status */
+export type AgentStatus = "done" | "done_with_concerns" | "blocked";
+
+/** Task complexity level */
+export type TaskComplexity = "small" | "medium" | "large";
+
+/** Task parallelism annotation */
+export type TaskParallelism =
+  | { type: "parallel-safe" }
+  | { type: "sequential"; dependsOn: number[] };
+
+/** A single task in a plan */
+export interface PlanTask {
+  id: number;
+  name: string;
+  description: string;
+  files: string[];
+  criteria: string;
+  complexity: TaskComplexity;
+  parallelism: TaskParallelism;
+}
+
+/** A plan document (parsed from markdown) */
+export interface Plan {
+  name: string;
+  created: string;
+  tags: string[];
+  context: string;
+  tasks: PlanTask[];
+  filePath: string;
+}
+
+/** Per-agent result stored after execution */
+export interface AgentResult {
+  taskId: number;
+  status: AgentStatus;
+  output: string;
+  concerns?: string;
+  filesChanged: string[];
+  duration: number;
+}
+
+/** Batch status in a run */
+export type BatchStatus = "pending" | "running" | "completed" | "failed";
+
+/** A batch of tasks in a run */
+export interface RunBatch {
+  index: number;
+  taskIds: number[];
+  status: BatchStatus;
+}
+
+/** Overall run status */
+export type RunStatus = "running" | "completed" | "paused" | "failed";
+
+/** Run manifest stored on disk */
+export interface RunManifest {
+  id: string;
+  planRef: string;
+  profile: string;
+  status: RunStatus;
+  startedAt: string;
+  completedAt?: string;
+  batches: RunBatch[];
+}
+
+/** Notification severity level */
+export type NotificationLevel = "success" | "warning" | "error" | "info" | "summary";
+
+/** Notification payload */
+export interface Notification {
+  level: NotificationLevel;
+  title: string;
+  detail?: string;
+}
+
+/** Quality gate result */
+export interface GateResult {
+  gate: string;
+  passed: boolean;
+  issues: GateIssue[];
+}
+
+/** A single issue from a quality gate */
+export interface GateIssue {
+  severity: "error" | "warning" | "info";
+  message: string;
+  file?: string;
+  line?: number;
+}
+
+/** Review report */
+export interface ReviewReport {
+  profile: string;
+  timestamp: string;
+  gates: GateResult[];
+  passed: boolean;
+}
+
+/** Config shape */
+export interface SupipowersConfig {
+  version: string;
+  defaultProfile: string;
+  orchestration: {
+    maxParallelAgents: number;
+    maxFixRetries: number;
+    maxNestingDepth: number;
+    modelPreference: string;
+  };
+  lsp: {
+    autoDetect: boolean;
+    setupGuide: boolean;
+  };
+  notifications: {
+    verbosity: "quiet" | "normal" | "verbose";
+  };
+  qa: {
+    framework: string | null;
+    command: string | null;
+  };
+  release: {
+    pipeline: string | null;
+  };
+}
+
+/** Profile shape */
+export interface Profile {
+  name: string;
+  gates: {
+    lspDiagnostics: boolean;
+    aiReview: { enabled: boolean; depth: "quick" | "deep" };
+    codeQuality: boolean;
+    testSuite: boolean;
+    e2e: boolean;
+  };
+  orchestration: {
+    reviewAfterEachBatch: boolean;
+    finalReview: boolean;
+  };
+}