supipowers 1.2.6 → 1.5.0

package/src/quality/runner.ts

@@ -0,0 +1,268 @@
+// src/quality/runner.ts
+import type { ExecOptions, ExecResult, Platform } from "../platform/types.js";
+import type {
+  GateDefinition,
+  GateExecutionContext,
+  GateFilters,
+  GateId,
+  GateResult,
+  GateSummary,
+  QualityGatesConfig,
+  ResolvedModel,
+  ReviewReport,
+} from "../types.js";
+import { CANONICAL_GATE_ORDER, type GateRegistry } from "./registry.js";
+import { collectLspDiagnostics } from "../lsp/bridge.js";
+
+interface ReviewScope {
+  changedFiles: string[];
+  scopeFiles: string[];
+  fileScope: GateExecutionContext["fileScope"];
+}
+
+export type ReviewRunEvent =
+  | {
+      type: "scope-discovered";
+      changedFiles: number;
+      scopeFiles: number;
+      fileScope: GateExecutionContext["fileScope"];
+    }
+  | { type: "gate-started"; gateId: GateId }
+  | { type: "gate-skipped"; gateId: GateId; reason: string }
+  | {
+      type: "gate-completed";
+      gateId: GateId;
+      status: GateResult["status"];
+      summary: string;
+    };
+
+export interface RunQualityGatesInput {
+  platform: Pick<Platform, "exec" | "getActiveTools" | "createAgentSession">;
+  cwd: string;
+  gates: QualityGatesConfig;
+  filters: GateFilters;
+  reviewModel: ResolvedModel;
+  gateRegistry?: GateRegistry;
+  getLspDiagnostics?: GateExecutionContext["getLspDiagnostics"];
+  now?: () => Date;
+  onEvent?: (event: ReviewRunEvent) => void;
+}
+
+function isGateEnabled(config: QualityGatesConfig[GateId] | undefined): boolean {
+  if (!config) {
+    return false;
+  }
+
+  return config.enabled === true;
+}
+
+function normalizeFileList(...chunks: string[]): string[] {
+  const seen = new Set<string>();
+
+  for (const chunk of chunks) {
+    for (const line of chunk.split("\n")) {
+      const file = line.trim();
+      if (file.length === 0) {
+        continue;
+      }
+      seen.add(file);
+    }
+  }
+
+  return [...seen];
+}
+
+async function safeExec(
+  exec: Platform["exec"],
+  cmd: string,
+  args: string[],
+  opts?: ExecOptions,
+): Promise<ExecResult> {
+  try {
+    return await exec(cmd, args, opts);
+  } catch (error) {
+    return {
+      stdout: "",
+      stderr: (error as Error).message,
+      code: 1,
+    };
+  }
+}
+
+export async function discoverReviewScope(
+  exec: Platform["exec"],
+  cwd: string,
+): Promise<ReviewScope> {
+  const head = await safeExec(exec, "git", ["diff", "--name-only", "HEAD"], { cwd });
+  const cached = await safeExec(exec, "git", ["diff", "--name-only", "--cached"], { cwd });
+  const untracked = await safeExec(exec, "git", ["ls-files", "--others", "--exclude-standard"], { cwd });
+  const changedFiles = normalizeFileList(head.stdout, cached.stdout, untracked.stdout);
+
+  if (changedFiles.length > 0) {
+    return {
+      changedFiles,
+      scopeFiles: changedFiles,
+      fileScope: "changed-files",
+    };
+  }
+
+  const tracked = await safeExec(exec, "git", ["ls-files"], { cwd });
+  const scopeFiles = normalizeFileList(tracked.stdout);
+
+  return {
+    changedFiles: [],
+    scopeFiles,
+    fileScope: "all-files",
+  };
+}
+
+function selectConfiguredGates(gates: QualityGatesConfig, filters: GateFilters): GateId[] {
+  const enabledGates = CANONICAL_GATE_ORDER.filter((gateId) =>
+    isGateEnabled(gates[gateId]),
+  );
+
+  if (filters.only && filters.only.length > 0) {
+    const only = new Set(filters.only);
+    return enabledGates.filter((gateId) => only.has(gateId));
+  }
+
+  return enabledGates;
+}
+
+function createExecShell(exec: Platform["exec"]): GateExecutionContext["execShell"] {
+  return async (command: string, opts?: ExecOptions): Promise<ExecResult> => {
+    if (process.platform === "win32") {
+      return exec("cmd", ["/d", "/s", "/c", command], opts);
+    }
+
+    return exec("sh", ["-lc", command], opts);
+  };
+}
+
+function createGateExecutionContext(
+  input: RunQualityGatesInput,
+  scope: ReviewScope,
+): GateExecutionContext {
+  const exec = input.platform.exec.bind(input.platform);
+  const createAgentSession = input.platform.createAgentSession.bind(input.platform);
+  const activeTools = input.platform.getActiveTools();
+  const reviewModel = {
+    model: input.reviewModel.model,
+    thinkingLevel: input.reviewModel.thinkingLevel,
+  };
+
+  return {
+    cwd: input.cwd,
+    changedFiles: scope.changedFiles,
+    scopeFiles: scope.scopeFiles,
+    fileScope: scope.fileScope,
+    exec,
+    execShell: createExecShell(exec),
+    getLspDiagnostics:
+      input.getLspDiagnostics ??
+      ((scopeFiles, fileScope) =>
+        collectLspDiagnostics({
+          cwd: input.cwd,
+          scopeFiles,
+          fileScope,
+          createAgentSession,
+          reviewModel,
+        })),
+    createAgentSession,
+    activeTools,
+    reviewModel,
+  };
+}
+
+function createSkippedGateResult(gate: GateId, reason = "Skipped by filter"): GateResult {
+  return {
+    gate,
+    status: "skipped",
+    summary: reason,
+    issues: [],
+  };
+}
+
+async function runConfiguredGate(
+  gateId: GateId,
+  registry: GateRegistry,
+  context: GateExecutionContext,
+  gates: QualityGatesConfig,
+): Promise<GateResult> {
+  const definition = registry[gateId] as GateDefinition<NonNullable<QualityGatesConfig[typeof gateId]>> | undefined;
+  if (!definition) {
+    throw new Error(`Gate definition not registered: ${gateId}`);
+  }
+
+  const config = gates[gateId];
+  if (!config || config.enabled !== true) {
+    throw new Error(`Gate ${gateId} is not enabled`);
+  }
+
+  return definition.run(context, config as NonNullable<QualityGatesConfig[typeof gateId]>);
+}
+
+export function summarizeGateStatuses(gates: GateResult[]): GateSummary {
+  return gates.reduce<GateSummary>(
+    (summary, gate) => {
+      summary[gate.status] += 1;
+      return summary;
+    },
+    { passed: 0, failed: 0, skipped: 0, blocked: 0 },
+  );
+}
+
+export function computeOverallStatus(summary: GateSummary): ReviewReport["overallStatus"] {
+  if (summary.blocked > 0) {
+    return "blocked";
+  }
+  if (summary.failed > 0) {
+    return "failed";
+  }
+  return "passed";
+}
+
+export async function runQualityGates(input: RunQualityGatesInput): Promise<ReviewReport> {
+  const selectedGates = selectConfiguredGates(input.gates, input.filters);
+  const scope = await discoverReviewScope(input.platform.exec.bind(input.platform), input.cwd);
+  input.onEvent?.({
+    type: "scope-discovered",
+    changedFiles: scope.changedFiles.length,
+    scopeFiles: scope.scopeFiles.length,
+    fileScope: scope.fileScope,
+  });
+  const context = createGateExecutionContext(input, scope);
+  const skipped = new Set(input.filters.skip ?? []);
+  const registry = input.gateRegistry ?? {};
+  const gates: GateResult[] = [];
+
+  // Run all gates concurrently — each gate is independent (no shared mutable state)
+  const promises = selectedGates.map(async (gateId): Promise<GateResult> => {
+    if (skipped.has(gateId)) {
+      input.onEvent?.({ type: "gate-skipped", gateId, reason: "Skipped by filter" });
+      return createSkippedGateResult(gateId);
+    }
+
+    input.onEvent?.({ type: "gate-started", gateId });
+    const result = await runConfiguredGate(gateId, registry, context, input.gates);
+    input.onEvent?.({
+      type: "gate-completed",
+      gateId,
+      status: result.status,
+      summary: result.summary,
+    });
+    return result;
+  });
+
+  gates.push(...await Promise.all(promises));
+
+  const summary = summarizeGateStatuses(gates);
+
+  return {
+    timestamp: (input.now ?? (() => new Date()))().toISOString(),
+    selectedGates,
+    gates,
+    summary,
+    overallStatus: computeOverallStatus(summary),
+  };
+}

package/src/quality/schemas.ts

@@ -0,0 +1,48 @@
+import { Type } from "@sinclair/typebox";
+import type { TSchema } from "@sinclair/typebox";
+import type { GateId } from "../types.js";
+
+export const LspDiagnosticsGateConfigSchema = Type.Object(
+  {
+    enabled: Type.Boolean(),
+  },
+  { additionalProperties: false },
+);
+
+export const CommandGateConfigSchema = Type.Union([
+  Type.Object(
+    {
+      enabled: Type.Literal(false),
+      command: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      enabled: Type.Literal(true),
+      command: Type.String({ minLength: 1 }),
+    },
+    { additionalProperties: false },
+  ),
+]);
+
+export const QualityGatesSchema = Type.Object(
+  {
+    "lsp-diagnostics": Type.Optional(LspDiagnosticsGateConfigSchema),
+    lint: Type.Optional(CommandGateConfigSchema),
+    typecheck: Type.Optional(CommandGateConfigSchema),
+    format: Type.Optional(CommandGateConfigSchema),
+    "test-suite": Type.Optional(CommandGateConfigSchema),
+    build: Type.Optional(CommandGateConfigSchema),
+  },
+  { additionalProperties: false },
+);
+
+export const GATE_CONFIG_SCHEMAS: Record<GateId, TSchema> = {
+  "lsp-diagnostics": LspDiagnosticsGateConfigSchema,
+  lint: CommandGateConfigSchema,
+  typecheck: CommandGateConfigSchema,
+  format: CommandGateConfigSchema,
+  "test-suite": CommandGateConfigSchema,
+  build: CommandGateConfigSchema,
+};

package/src/quality/setup.ts

@@ -0,0 +1,227 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { Platform, PlatformContext } from "../platform/types.js";
+import type {
+  ConfigScope,
+  ProjectFacts,
+  QualityGatesConfig,
+  SetupGatesResult,
+  SetupProposal,
+} from "../types.js";
+import type { InspectionLoadResult } from "../config/schema.js";
+import { validateQualityGates } from "../config/schema.js";
+import { writeQualityGatesConfig } from "../config/loader.js";
+import { CANONICAL_GATE_ORDER } from "./registry.js";
+import { detectReviewGates } from "./review-gates.js";
+import { suggestQualityGatesWithAi } from "./ai-setup.js";
+
+export type GateSetupMode = "deterministic" | "ai-assisted";
+
+export type SetupGatesProgressEvent =
+  | { type: "collecting-project-facts" }
+  | { type: "baseline-ready" }
+  | { type: "ai-analysis-started" }
+  | { type: "ai-analysis-completed" };
+
+export interface SetupGatesOptions {
+  mode?: GateSetupMode;
+  onProgress?: (event: SetupGatesProgressEvent) => void;
+}
+
+export interface GateSetupDialogOptions {
+  title?: string;
+  intro?: string;
+}
+
+export interface SetupGatesDependencies {
+  suggestWithAi?: (input: {
+    platform: Platform;
+    cwd: string;
+    projectFacts: ProjectFacts;
+    proposal: SetupProposal;
+  }) => Promise<QualityGatesConfig>;
+}
+
+function readPackageScripts(cwd: string): Record<string, string> {
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) as {
+      scripts?: Record<string, string>;
+    };
+    return parsed.scripts ?? {};
+  } catch {
+    return {};
+  }
+}
+
+function detectLockfiles(cwd: string): string[] {
+  return ["bun.lock", "bun.lockb", "package-lock.json", "pnpm-lock.yaml", "yarn.lock"]
+    .filter((file) => fs.existsSync(path.join(cwd, file)));
+}
+
+export function collectProjectFacts(
+  cwd: string,
+  inspection: InspectionLoadResult,
+  activeTools: string[],
+): ProjectFacts {
+  return {
+    cwd,
+    packageScripts: readPackageScripts(cwd),
+    lockfiles: detectLockfiles(cwd),
+    activeTools,
+    existingGates: inspection.effectiveConfig?.quality.gates ?? {},
+  };
+}
+
+export function summarizeEnabledGates(gates: QualityGatesConfig): string {
+  const enabled = CANONICAL_GATE_ORDER.filter((gateId) => gates[gateId]?.enabled === true);
+
+  return enabled.length > 0 ? enabled.join(", ") : "none";
+}
+
+export function formatGateProposal(proposal: SetupProposal): string {
+  const entries = CANONICAL_GATE_ORDER
+    .filter((gateId) => proposal.gates[gateId] !== undefined)
+    .map((gateId) => [gateId, proposal.gates[gateId]] as const);
+  if (entries.length === 0) {
+    return "No gates suggested.";
+  }
+
+  return entries
+    .map(([gateId, config]) => `${gateId}: ${JSON.stringify(config)}`)
+    .join("\n");
+}
+
+export function buildDeterministicSuggestion(projectFacts: ProjectFacts): SetupProposal {
+  return { gates: detectReviewGates(projectFacts) };
+}
+
+export async function setupGates(
+  platform: Platform,
+  cwd: string,
+  inspection: InspectionLoadResult,
+  options: SetupGatesOptions = {},
+  deps: SetupGatesDependencies = {},
+): Promise<SetupGatesResult> {
+  options.onProgress?.({ type: "collecting-project-facts" });
+  const projectFacts = collectProjectFacts(cwd, inspection, platform.getActiveTools());
+  let proposal = buildDeterministicSuggestion(projectFacts);
+  options.onProgress?.({ type: "baseline-ready" });
+
+  if (options.mode === "ai-assisted") {
+    options.onProgress?.({ type: "ai-analysis-started" });
+    const suggestWithAi = deps.suggestWithAi ?? suggestQualityGatesWithAi;
+    proposal = {
+      gates: await suggestWithAi({
+        platform,
+        cwd,
+        projectFacts,
+        proposal,
+      }),
+    };
+    options.onProgress?.({ type: "ai-analysis-completed" });
+  }
+
+  const validation = validateQualityGates(proposal.gates);
+  if (!validation.valid) {
+    return {
+      status: "invalid",
+      proposal,
+      errors: validation.errors,
+    };
+  }
+
+  return {
+    status: "proposed",
+    proposal,
+  };
+}
+
+function parseRevisedProposal(raw: string): SetupProposal {
+  const parsed = JSON.parse(raw) as QualityGatesConfig;
+  const validation = validateQualityGates(parsed);
+  if (!validation.valid) {
+    throw new Error(validation.errors.join("\n"));
+  }
+
+  return { gates: parsed };
+}
+
+function labelForScope(scope: ConfigScope): string {
+  return scope === "project"
+    ? "Project (.omp/supipowers/config.json)"
+    : "Global (~/.omp/supipowers/config.json)";
+}
+
+async function selectSaveScope(ctx: PlatformContext): Promise<ConfigScope | null> {
+  const choice = await ctx.ui.select(
+    "Save quality gates to",
+    [labelForScope("project"), labelForScope("global"), "Cancel"],
+    {
+      initialIndex: 0,
+      helpText: "Choose whether review gates apply only to this project or all projects.",
+    },
+  );
+
+  if (!choice || choice === "Cancel") {
+    return null;
+  }
+
+  return choice === labelForScope("global") ? "global" : "project";
+}
+
+function buildProposalHelpText(proposal: SetupProposal, options?: GateSetupDialogOptions): string {
+  return [options?.intro, formatGateProposal(proposal)].filter(Boolean).join("\n\n");
+}
+
+export async function interactivelySaveGateSetup(
+  ctx: PlatformContext,
+  paths: Platform["paths"],
+  cwd: string,
+  initial: SetupProposal,
+  options: GateSetupDialogOptions = {},
+): Promise<"saved" | "cancelled"> {
+  let proposal = initial;
+
+  while (true) {
+    const choice = await ctx.ui.select(
+      options.title ?? "Quality gate setup",
+      ["Accept", "Revise", "Cancel"],
+      { helpText: buildProposalHelpText(proposal, options) },
+    );
+
+    if (!choice || choice === "Cancel") {
+      return "cancelled";
+    }
+
+    if (choice === "Revise") {
+      const revised = await ctx.ui.input(
+        "Edit quality.gates JSON",
+        { value: JSON.stringify(proposal.gates, null, 2) },
+      );
+
+      if (!revised) {
+        continue;
+      }
+
+      try {
+        proposal = parseRevisedProposal(revised);
+      } catch (error) {
+        ctx.ui.notify((error as Error).message, "error");
+      }
+      continue;
+    }
+
+    const scope = await selectSaveScope(ctx);
+    if (!scope) {
+      return "cancelled";
+    }
+
+    writeQualityGatesConfig(paths, cwd, scope, proposal.gates);
+    return "saved";
+  }
+}

package/src/release/changelog.ts

@@ -1,6 +1,8 @@
 // src/release/changelog.ts — Conventional commit parsing and changelog generation
 
 import type { CategorizedCommits, CommitEntry } from "../types.js";
+import { normalizeLineEndings } from "../text.js";
+import { formatTag } from "./version.js";
 import { IMPROVEMENT_TYPES, MAINTENANCE_TYPES, type ConventionalCommitType } from "./commit-types.js";
 
 // Matches: feat(scope)!: message  or  feat!: message  or  feat(scope): message  or  feat: message
@@ -39,6 +41,7 @@ function parseLine(line: string): { hash: string; raw: string } | null {
  */
 
 export function parseConventionalCommits(gitLog: string): CategorizedCommits {
+  const normalizedGitLog = normalizeLineEndings(gitLog);
   const result: CategorizedCommits = {
     features: [],
     fixes: [],
@@ -48,7 +51,7 @@ export function parseConventionalCommits(gitLog: string): CategorizedCommits {
     other: [],
   };
 
-  for (const line of gitLog.split("\n")) {
+  for (const line of normalizedGitLog.split("\n")) {
     const parsed = parseLine(line);
     if (!parsed) continue;
 
@@ -106,11 +109,12 @@ function formatEntry(entry: CommitEntry): string {
  */
 export function buildChangelogMarkdown(
   commits: CategorizedCommits,
-  version: string
+  version: string,
+  tagFormat: string = "v${version}",
 ): string {
   const lines: string[] = [];
 
-  lines.push(`## v${version}`);
+  lines.push(`## ${formatTag(version, tagFormat)}`);
   lines.push(`_${isoDate(new Date())}_`);
   lines.push("");
 

package/src/release/channels/custom.ts

@@ -0,0 +1,43 @@
+// src/release/channels/custom.ts — Wraps user-defined custom channel config into a ChannelHandler
+import type { CustomChannelConfig } from "../../types.js";
+import type { ChannelHandler, ChannelPublishContext, ChannelStatus, ExecFn } from "./types.js";
+
+
+export function createCustomHandler(id: string, config: CustomChannelConfig): ChannelHandler {
+  return {
+    id,
+    label: config.label,
+
+    async detect(exec: ExecFn, cwd: string): Promise<ChannelStatus> {
+      if (!config.detectCommand) {
+        return { channel: id, available: true, detail: "No detect command configured — assumed available" };
+      }
+      try {
+        const result = await exec("sh", ["-c", config.detectCommand], { cwd });
+        if (result.code === 0) {
+          return { channel: id, available: true, detail: `Detect command succeeded` };
+        }
+        return { channel: id, available: false, detail: `Detect command exited with code ${result.code}` };
+      } catch {
+        return { channel: id, available: false, detail: "Detect command failed to execute" };
+      }
+    },
+
+    async publish(exec: ExecFn, ctx: ChannelPublishContext): Promise<{ success: boolean; error?: string }> {
+      try {
+        // `${tag}`/`${version}`/`${changelog}` stay in the shell template, but
+        // their values cross the shell boundary via environment variables.
+        const result = await exec("sh", ["-c", config.publishCommand], {
+          cwd: ctx.cwd,
+          env: { tag: ctx.tag, version: ctx.version, changelog: ctx.changelog },
+        });
+        if (result.code !== 0) {
+          return { success: false, error: result.stderr || result.stdout || `Custom channel '${id}' exited with code ${result.code}` };
+        }
+        return { success: true };
+      } catch (err) {
+        return { success: false, error: err instanceof Error ? err.message : String(err) };
+      }
+    },
+  };
+}

package/src/release/channels/gitea.ts

@@ -0,0 +1,35 @@
+// src/release/channels/gitea.ts — Built-in Gitea/Forgejo release channel
+import type { ChannelHandler, ChannelPublishContext, ChannelStatus, ExecFn } from "./types.js";
+
+export const gitea: ChannelHandler = {
+  id: "gitea",
+  label: "Gitea Releases",
+
+  async detect(exec: ExecFn, cwd: string): Promise<ChannelStatus> {
+    try {
+      const result = await exec("tea", ["login", "list"], { cwd });
+      if (result.code === 0 && result.stdout.trim().length > 0) {
+        return { channel: "gitea", available: true, detail: "Authenticated with Gitea CLI" };
+      }
+      return { channel: "gitea", available: false, detail: "Gitea CLI not authenticated (run: tea login add)" };
+    } catch {
+      return { channel: "gitea", available: false, detail: "Gitea CLI not installed (install: https://gitea.com/gitea/tea)" };
+    }
+  },
+
+  async publish(exec: ExecFn, ctx: ChannelPublishContext): Promise<{ success: boolean; error?: string }> {
+    try {
+      const result = await exec(
+        "tea",
+        ["release", "create", "--tag", ctx.tag, "--title", ctx.tag, "--note", ctx.changelog],
+        { cwd: ctx.cwd },
+      );
+      if (result.code !== 0) {
+        return { success: false, error: result.stderr || result.stdout || `tea release create exited with code ${result.code}` };
+      }
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  },
+};

package/src/release/channels/github.ts

@@ -0,0 +1,35 @@
+// src/release/channels/github.ts — Built-in GitHub release channel
+import type { ChannelHandler, ChannelPublishContext, ChannelStatus, ExecFn } from "./types.js";
+
+export const github: ChannelHandler = {
+  id: "github",
+  label: "GitHub Releases",
+
+  async detect(exec: ExecFn, cwd: string): Promise<ChannelStatus> {
+    try {
+      const result = await exec("gh", ["auth", "status"], { cwd });
+      if (result.code === 0) {
+        return { channel: "github", available: true, detail: "Authenticated with GitHub CLI" };
+      }
+      return { channel: "github", available: false, detail: "GitHub CLI not authenticated (run: gh auth login)" };
+    } catch {
+      return { channel: "github", available: false, detail: "GitHub CLI not installed (install: https://cli.github.com)" };
+    }
+  },
+
+  async publish(exec: ExecFn, ctx: ChannelPublishContext): Promise<{ success: boolean; error?: string }> {
+    try {
+      const result = await exec(
+        "gh",
+        ["release", "create", ctx.tag, "--title", ctx.tag, "--notes", ctx.changelog],
+        { cwd: ctx.cwd },
+      );
+      if (result.code !== 0) {
+        return { success: false, error: result.stderr || result.stdout || `gh release create exited with code ${result.code}` };
+      }
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  },
+};