supipowers 1.2.6 → 1.5.0

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

@@ -0,0 +1,102 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface AppDetection {
+  type: string;
+  devCommand: string;
+  port: number;
+  baseUrl: string;
+}
+
+function fileExists(cwd: string, ...segments: string[]): boolean {
+  return fs.existsSync(path.join(cwd, ...segments));
+}
+
+function dirExists(cwd: string, ...segments: string[]): boolean {
+  try {
+    return fs.statSync(path.join(cwd, ...segments)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function readJson(filePath: string): Record<string, unknown> | null {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export function detectAppType(cwd: string): AppDetection {
+  let type = "generic";
+  let devCommand = "npm run dev";
+  let port = 3000;
+
+  const hasNextConfig =
+    fileExists(cwd, "next.config.js") ||
+    fileExists(cwd, "next.config.mjs") ||
+    fileExists(cwd, "next.config.ts");
+  const hasNextAppDir = dirExists(cwd, "app") || dirExists(cwd, "src", "app");
+  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) {
+      type = "nextjs-pages";
+    } else {
+      type = "nextjs-app";
+    }
+    port = 3000;
+  } else if (
+    fileExists(cwd, "vite.config.ts") ||
+    fileExists(cwd, "vite.config.js") ||
+    fileExists(cwd, "vite.config.mjs")
+  ) {
+    type = "vite";
+    port = 5173;
+  } else if (fileExists(cwd, "angular.json")) {
+    type = "generic";
+    devCommand = "npm start";
+    port = 4200;
+  } 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;
+      }
+    } 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";
+    } else if (scripts?.start) {
+      devCommand = "npm start";
+    } else if (scripts?.serve) {
+      devCommand = "npm run serve";
+    }
+
+    // Extract port from dev script text
+    const scriptText = scripts?.dev ?? scripts?.start ?? "";
+    if (scriptText) {
+      const portMatch = scriptText.match(/(?:--port|PORT=)\s*(\d+)/);
+      if (portMatch) {
+        port = parseInt(portMatch[1], 10);
+      }
+    }
+  }
+
+  const baseUrl = `http://localhost:${port}`;
+
+  return { type, devCommand, port, baseUrl };
+}

package/src/qa/discover-routes.ts

@@ -0,0 +1,353 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface DiscoveredRoute {
+  path: string;
+  file: string;
+  type: "page" | "api" | "auth";
+  hasForm: boolean;
+  methods?: string[];
+}
+
+const CODE_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js"];
+
+const FORM_PATTERNS =
+  /<form|onSubmit|handleSubmit|useForm|formik|react-hook-form/;
+
+const HTTP_METHODS_RE = /\b(GET|POST|PUT|PATCH|DELETE)\b/g;
+
+/**
+ * Recursively walk `dir`, returning relative file paths whose extension
+ * is in `extensions`. All returned paths use forward slashes.
+ */
+function walkDir(dir: string, extensions: string[]): string[] {
+  if (!fs.existsSync(dir)) return [];
+
+  const results: string[] = [];
+  const extSet = new Set(extensions);
+
+  function recurse(current: string): void {
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        recurse(full);
+      } else if (entry.isFile() && extSet.has(path.extname(entry.name))) {
+        results.push(path.relative(dir, full).replace(/\\/g, "/"));
+      }
+    }
+  }
+
+  recurse(dir);
+  return results;
+}
+
+/** Try to read file content; return empty string on failure. */
+function safeRead(filePath: string): string {
+  try {
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+function hasForm(content: string): boolean {
+  return FORM_PATTERNS.test(content);
+}
+
+function extractHttpMethods(content: string): string[] {
+  const matches = content.match(HTTP_METHODS_RE);
+  if (!matches || matches.length === 0) return ["GET"];
+  return [...new Set(matches)];
+}
+
+// ────────────────────────────────────────────────
+// Framework scanners
+// ────────────────────────────────────────────────
+
+function scanNextjsApp(cwd: string): DiscoveredRoute[] {
+  const routes: DiscoveredRoute[] = [];
+
+  for (const prefix of ["app", "src/app"]) {
+    const dir = path.join(cwd, prefix);
+    if (!fs.existsSync(dir)) continue;
+
+    const files = walkDir(dir, CODE_EXTENSIONS);
+
+    for (const rel of files) {
+      const basename = path.basename(rel);
+      const fullPath = path.join(dir, rel).replace(/\\/g, "/");
+
+      // page files → page routes
+      if (/^page\.(tsx|jsx|ts|js)$/.test(basename)) {
+        const routePath = rel.replace(/(^|\/)page\.\w+$/, "");
+        let route = routePath ? "/" + routePath : "/";
+        // strip route groups: /(groupname)
+        route = route.replace(/\/\([^)]*\)/g, "");
+        if (route === "" || route === "/") {
+          route = "/";
+        }
+        // normalize double slashes
+        route = route.replace(/\/+/g, "/");
+
+        const content = safeRead(path.join(dir, rel));
+        routes.push({
+          path: route,
+          file: (prefix + "/" + rel).replace(/\\/g, "/"),
+          type: "page",
+          hasForm: hasForm(content),
+        });
+      }
+
+      // route files → API routes
+      if (/^route\.(tsx|ts|js)$/.test(basename)) {
+        const route = "/" + rel.replace(/\/route\.\w+$/, "");
+        const content = safeRead(path.join(dir, rel));
+        const methods = extractHttpMethods(content);
+
+        routes.push({
+          path: route.replace(/\/+/g, "/"),
+          file: (prefix + "/" + rel).replace(/\\/g, "/"),
+          type: "api",
+          hasForm: false,
+          methods,
+        });
+      }
+    }
+  }
+
+  return routes;
+}
+
+function scanNextjsPages(cwd: string): DiscoveredRoute[] {
+  const routes: DiscoveredRoute[] = [];
+  const SKIP_BASENAMES = /^_(app|document|error)\./;
+
+  for (const prefix of ["pages", "src/pages"]) {
+    const dir = path.join(cwd, prefix);
+    if (!fs.existsSync(dir)) continue;
+
+    const files = walkDir(dir, CODE_EXTENSIONS);
+
+    for (const rel of files) {
+      const basename = path.basename(rel);
+      if (SKIP_BASENAMES.test(basename)) continue;
+
+      const filePath = (prefix + "/" + rel).replace(/\\/g, "/");
+      const fullDisk = path.join(dir, rel);
+
+      // Strip extension, then replace /index with /
+      const routePath = rel
+        .replace(/\.(tsx|jsx|ts|js)$/, "")
+        .replace(/(^|\/)index$/, "");
+      let route = routePath ? "/" + routePath : "/";
+      if (route === "/" || route === "") route = "/";
+      route = route.replace(/\/+/g, "/");
+
+      if (rel.includes("api/")) {
+        const content = safeRead(fullDisk);
+        const methods = extractHttpMethods(content);
+        routes.push({
+          path: route,
+          file: filePath,
+          type: "api",
+          hasForm: false,
+          methods,
+        });
+      } else {
+        const content = safeRead(fullDisk);
+        routes.push({
+          path: route,
+          file: filePath,
+          type: "page",
+          hasForm: hasForm(content),
+        });
+      }
+    }
+  }
+
+  return routes;
+}
+
+function scanReactRouter(cwd: string): DiscoveredRoute[] {
+  const routes: DiscoveredRoute[] = [];
+  const srcDir = path.join(cwd, "src");
+  if (!fs.existsSync(srcDir)) return routes;
+
+  const files = walkDir(srcDir, CODE_EXTENSIONS);
+
+  for (const rel of files) {
+    const fullDisk = path.join(srcDir, rel);
+    const content = safeRead(fullDisk);
+    if (!content) continue;
+
+    if (!/<Route|createBrowserRouter|useRoutes/.test(content)) continue;
+
+    const filePath = ("src/" + rel).replace(/\\/g, "/");
+
+    // Extract path="..." and path: '...' patterns
+    const pathMatches = content.matchAll(/path[=:]\s*["']([^"']+)["']/g);
+    for (const m of pathMatches) {
+      const routePath = m[1];
+      if (!routePath) continue;
+      routes.push({
+        path: routePath,
+        file: filePath,
+        type: "page",
+        hasForm: hasForm(content),
+      });
+    }
+  }
+
+  return routes;
+}
+
+function scanExpress(cwd: string): DiscoveredRoute[] {
+  const routes: DiscoveredRoute[] = [];
+  const EXPRESS_RE =
+    /\.(get|post|put|patch|delete)\s*\(\s*["'](\/?[^"']*)["']/gi;
+
+  for (const dirName of ["src", "routes", "server"]) {
+    const dir = path.join(cwd, dirName);
+    if (!fs.existsSync(dir)) continue;
+
+    const files = walkDir(dir, [".ts", ".js"]);
+
+    for (const rel of files) {
+      const fullDisk = path.join(dir, rel);
+      const content = safeRead(fullDisk);
+      if (!content) continue;
+
+      const matches = content.matchAll(EXPRESS_RE);
+      for (const m of matches) {
+        let method = m[1].toUpperCase();
+        const routePath = m[2];
+        if (!routePath || !routePath.startsWith("/")) continue;
+
+        routes.push({
+          path: routePath,
+          file: (dirName + "/" + rel).replace(/\\/g, "/"),
+          type: "api",
+          hasForm: false,
+          methods: [method],
+        });
+      }
+    }
+  }
+
+  return routes;
+}
+
+function scanGeneric(cwd: string): DiscoveredRoute[] {
+  const routes: DiscoveredRoute[] = [];
+  const srcDir = path.join(cwd, "src");
+  if (!fs.existsSync(srcDir)) return routes;
+
+  const files = walkDir(srcDir, CODE_EXTENSIONS);
+
+  for (const rel of files) {
+    const fullDisk = path.join(srcDir, rel);
+    const content = safeRead(fullDisk);
+    if (!content) continue;
+
+    if (!/<Route|createBrowserRouter|useRoutes/.test(content)) continue;
+
+    const filePath = ("src/" + rel).replace(/\\/g, "/");
+
+    const pathMatches = content.matchAll(/path[=:]\s*["']([^"']+)["']/g);
+    for (const m of pathMatches) {
+      const routePath = m[1];
+      if (!routePath) continue;
+      routes.push({
+        path: routePath,
+        file: filePath,
+        type: "page",
+        hasForm: hasForm(content),
+      });
+    }
+  }
+
+  return routes;
+}
+
+// ────────────────────────────────────────────────
+// Auth scan (runs for all framework types)
+// ────────────────────────────────────────────────
+
+const AUTH_FILENAME_RE = /(auth|login|signup|register)/i;
+const AUTH_EXCLUDE_RE = /(node_modules|\.next|\.test\.|\.spec\.)/;
+
+function scanAuth(cwd: string): DiscoveredRoute[] {
+  const routes: DiscoveredRoute[] = [];
+  const srcDir = path.join(cwd, "src");
+  if (!fs.existsSync(srcDir)) return routes;
+
+  const files = walkDir(srcDir, CODE_EXTENSIONS);
+
+  for (const rel of files) {
+    const fullRel = "src/" + rel;
+
+    // Exclude node_modules, .next, test/spec files
+    if (AUTH_EXCLUDE_RE.test(fullRel)) continue;
+
+    const basename = path.basename(rel);
+    if (!AUTH_FILENAME_RE.test(basename)) continue;
+
+    const fullDisk = path.join(srcDir, rel);
+    const content = safeRead(fullDisk);
+
+    // Route hint from filename without extension
+    const nameWithoutExt = basename.replace(/\.(tsx|jsx|ts|js)$/, "");
+
+    routes.push({
+      path: "/" + nameWithoutExt,
+      file: fullRel.replace(/\\/g, "/"),
+      type: "auth",
+      hasForm: hasForm(content),
+    });
+  }
+
+  return routes;
+}
+
+// ────────────────────────────────────────────────
+// Main entry point
+// ────────────────────────────────────────────────
+
+export function discoverRoutes(
+  cwd: string,
+  appType: string,
+): DiscoveredRoute[] {
+  let routes: DiscoveredRoute[];
+
+  switch (appType) {
+    case "nextjs-app":
+      routes = scanNextjsApp(cwd);
+      break;
+    case "nextjs-pages":
+      routes = scanNextjsPages(cwd);
+      break;
+    case "react-router":
+      routes = scanReactRouter(cwd);
+      break;
+    case "express":
+      routes = scanExpress(cwd);
+      break;
+    case "vite":
+    case "generic":
+    default:
+      routes = scanGeneric(cwd);
+      break;
+  }
+
+  // Auth scan always runs
+  routes.push(...scanAuth(cwd));
+
+  return routes;
+}

package/src/quality/ai-session.ts

@@ -0,0 +1,96 @@
+import type { GateExecutionContext } from "../types.js";
+
+export interface StructuredAgentRunOptions {
+  cwd: string;
+  prompt: string;
+  model?: string;
+  thinkingLevel?: string | null;
+  timeoutMs?: number;
+}
+
+export type StructuredAgentRunResult =
+  | { status: "ok"; finalText: string }
+  | { status: "error"; finalText: null; error: string };
+
+function extractTextFromContent(content: unknown): string {
+  if (typeof content === "string") {
+    return content.trim();
+  }
+
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") {
+          return part;
+        }
+        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+          return part.text;
+        }
+        return "";
+      })
+      .join("")
+      .trim();
+  }
+
+  if (content && typeof content === "object" && "text" in content && typeof content.text === "string") {
+    return content.text.trim();
+  }
+
+  return "";
+}
+
+export function extractFinalAssistantText(messages: unknown[]): string | null {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!message || typeof message !== "object") {
+      continue;
+    }
+
+    const role = "role" in message ? message.role : undefined;
+    if (role !== undefined && role !== "assistant") {
+      continue;
+    }
+
+    const content = "content" in message ? message.content : message;
+    const text = extractTextFromContent(content);
+    if (text.length > 0) {
+      return text;
+    }
+  }
+
+  return null;
+}
+
+export async function runStructuredAgentSession(
+  createAgentSession: GateExecutionContext["createAgentSession"],
+  options: StructuredAgentRunOptions,
+): Promise<StructuredAgentRunResult> {
+  const session = await createAgentSession({
+    cwd: options.cwd,
+    model: options.model,
+    thinkingLevel: options.thinkingLevel ?? null,
+  });
+
+  try {
+    await session.prompt(options.prompt, { expandPromptTemplates: false });
+    const finalText = extractFinalAssistantText(session.state.messages);
+
+    if (!finalText) {
+      return {
+        status: "error",
+        finalText: null,
+        error: "No final assistant message was returned.",
+      };
+    }
+
+    return { status: "ok", finalText };
+  } catch (error) {
+    return {
+      status: "error",
+      finalText: null,
+      error: error instanceof Error ? error.message : "Agent session failed.",
+    };
+  } finally {
+    await session.dispose();
+  }
+}

package/src/quality/ai-setup.ts

@@ -0,0 +1,86 @@
+import { loadModelConfig } from "../config/model-config.js";
+import { modelRegistry } from "../config/model-registry-instance.js";
+import { createModelBridge, resolveModelForAction } from "../config/model-resolver.js";
+import { validateQualityGates } from "../config/schema.js";
+import { stripMarkdownCodeFence } from "../text.js";
+import type { Platform } from "../platform/types.js";
+import type { ProjectFacts, QualityGatesConfig, SetupProposal } from "../types.js";
+import { runStructuredAgentSession } from "./ai-session.js";
+
+modelRegistry.register({
+  id: "quality-gate-setup",
+  category: "command",
+  label: "Quality gate setup",
+  harnessRoleHint: "slow",
+});
+
+function buildAiSetupPrompt(projectFacts: ProjectFacts, proposal: SetupProposal): string {
+  return [
+    "You are configuring Supipowers review quality gates for a repository.",
+    "Return JSON only as a QualityGatesConfig object.",
+    "",
+    "Available gates and shapes:",
+    '- "lsp-diagnostics": {"enabled": true|false}',
+    '- "lint": {"enabled": true, "command": "..."} or {"enabled": false}',
+    '- "typecheck": {"enabled": true, "command": "..."} or {"enabled": false}',
+    '- "format": {"enabled": true, "command": "..."} or {"enabled": false}',
+    '- "test-suite": {"enabled": true, "command": "..."} or {"enabled": false}',
+    '- "build": {"enabled": true, "command": "..."} or {"enabled": false}',
+    "",
+    "Rules:",
+    "- Prefer commands that already exist in package.json scripts.",
+    "- Never invent a mutating format command such as --write or lint --fix.",
+    "- Prefer checks that verify correctness during review: lsp, lint, typecheck, format check, tests, and build.",
+    "- Keep deterministic suggestions unless you have repository evidence to improve them.",
+    "- Omit gates you do not recommend instead of disabling them unless the baseline already contains them.",
+    "- Do not include explanations outside the JSON.",
+    "",
+    "Project facts:",
+    JSON.stringify(projectFacts, null, 2),
+    "",
+    "Deterministic baseline proposal:",
+    JSON.stringify(proposal.gates, null, 2),
+  ].join("\n");
+}
+
+function parseAiSetupSuggestion(raw: string): QualityGatesConfig {
+  const parsed = JSON.parse(stripMarkdownCodeFence(raw)) as QualityGatesConfig;
+  const validation = validateQualityGates(parsed);
+  if (!validation.valid) {
+    throw new Error(validation.errors.join("\n"));
+  }
+
+  return parsed;
+}
+
+export async function suggestQualityGatesWithAi(input: {
+  platform: Platform;
+  cwd: string;
+  projectFacts: ProjectFacts;
+  proposal: SetupProposal;
+}): Promise<QualityGatesConfig> {
+  const modelConfig = loadModelConfig(input.platform.paths, input.cwd);
+  const resolvedModel = resolveModelForAction(
+    "quality-gate-setup",
+    modelRegistry,
+    modelConfig,
+    createModelBridge(input.platform),
+  );
+
+  const result = await runStructuredAgentSession(
+    input.platform.createAgentSession.bind(input.platform),
+    {
+      cwd: input.cwd,
+      prompt: buildAiSetupPrompt(input.projectFacts, input.proposal),
+      model: resolvedModel.model,
+      thinkingLevel: resolvedModel.thinkingLevel,
+      timeoutMs: 120_000,
+    },
+  );
+
+  if (result.status !== "ok") {
+    throw new Error(result.error);
+  }
+
+  return parseAiSetupSuggestion(result.finalText);
+}