supipowers 1.2.6 → 1.5.0

package/src/git/commit.ts

@@ -5,13 +5,15 @@
 // the plan for user approval, then executes file-level staging + commit.
 
 import type { Platform } from "../platform/types.js";
+import { createWorkflowProgress } from "../platform/progress.js";
 import { VALID_COMMIT_TYPES } from "../release/commit-types.js";
 import { validateCommitMessage } from "./commit-msg.js";
 import { getWorkingTreeStatus } from "./status.js";
 import { discoverCommitConventions } from "./conventions.js";
+import { normalizeLineEndings } from "../text.js";
 import { notifyInfo, notifyError, notifySuccess } from "../notifications/renderer.js";
 import { modelRegistry } from "../config/model-registry-instance.js";
-import { resolveModelForAction, createModelBridge } from "../config/model-resolver.js";
+import { resolveAllCandidates, createModelBridge } from "../config/model-resolver.js";
 import { loadModelConfig } from "../config/model-config.js";
 
 // ── Public types ───────────────────────────────────────────
@@ -95,129 +97,40 @@ const DIFF_TRUNCATED_LINES = 200;
 
 // ── Commit progress tracker ────────────────────────────────
 
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const STATUS_KEY = "supi-commit";
-const WIDGET_KEY = "supi-commit";
+const COMMIT_STEPS = [
+  { key: "check-working-tree", label: "Check working tree" },
+  { key: "stage-changes", label: "Stage changes" },
+  { key: "read-diff", label: "Read diff" },
+  { key: "scan-conventions", label: "Scan conventions" },
+  { key: "ai-analysis", label: "AI analysis" },
+  { key: "review-plan", label: "Review plan" },
+  { key: "execute-commits", label: "Execute commits" },
+] as const;
 
-/** A named step in the commit workflow. */
-interface Step {
-  label: string;
-  status: "pending" | "active" | "done" | "skipped";
-  detail?: string;
-}
-
-/**
- * Rich progress tracker for the commit flow.
- *
- * Uses `setWidget` for a persistent multi-line panel showing all steps,
- * and `setStatus` for the current operation detail in the footer.
- */
 function createProgress(ctx: any) {
-  const steps: Step[] = [
-    { label: "Check working tree", status: "pending" },
-    { label: "Stage changes", status: "pending" },
-    { label: "Read diff", status: "pending" },
-    { label: "Scan conventions", status: "pending" },
-    { label: "AI analysis", status: "pending" },
-    { label: "Review plan", status: "pending" },
-    { label: "Execute commits", status: "pending" },
-  ];
-
-  let frame = 0;
-  let statusDetail = "";
-  let timer: ReturnType<typeof setInterval> | null = null;
-
-  function icon(step: Step): string {
-    switch (step.status) {
-      case "done":    return "✓";
-      case "active":  return SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
-      case "skipped": return "–";
-      default:        return "○";
-    }
-  }
-
-  function renderWidget(): string[] {
-    const lines: string[] = ["┌─ supi:commit ─────────────────────┐"];
-    for (const step of steps) {
-      const mark = icon(step);
-      const detail = step.detail ? ` (${step.detail})` : "";
-      lines.push(`│ ${mark} ${step.label}${detail}`);
-    }
-    lines.push("└───────────────────────────────────┘");
-    return lines;
-  }
-
-  function refresh() {
-    frame++;
-    ctx.ui.setWidget?.(WIDGET_KEY, renderWidget());
-    if (statusDetail) {
-      ctx.ui.setStatus?.(STATUS_KEY, `${SPINNER_FRAMES[frame % SPINNER_FRAMES.length]} ${statusDetail}`);
-    }
-  }
-
-  function startTimer() {
-    if (!timer) {
-      timer = setInterval(refresh, 80);
-    }
-  }
-
-  function stopTimer() {
-    if (timer) {
-      clearInterval(timer);
-      timer = null;
-    }
-  }
+  const progress = createWorkflowProgress(ctx.ui, {
+    title: "supi:commit",
+    statusKey: "supi-commit",
+    widgetKey: "supi-commit",
+    clearStatusKeys: ["supi-model"],
+    steps: [...COMMIT_STEPS],
+  });
 
   return {
-    /**
-     * Mark a step as active (in progress) with an optional status-bar detail.
-     * `stepIndex` is 0-based into the steps array.
-     */
     activate(stepIndex: number, detail?: string) {
-      const step = steps[stepIndex];
-      if (step) {
-        step.status = "active";
-        step.detail = detail;
-      }
-      statusDetail = detail ?? step?.label ?? "";
-      startTimer();
-      refresh();
+      progress.activate(COMMIT_STEPS[stepIndex]!.key, detail);
     },
-
-    /** Update the status-bar detail text without changing the step. */
     detail(text: string) {
-      statusDetail = text;
-      // Also update the current active step's detail
-      const active = steps.find((s) => s.status === "active");
-      if (active) active.detail = text;
+      progress.detail(text);
     },
-
-    /** Mark a step as completed. */
     complete(stepIndex: number, detail?: string) {
-      const step = steps[stepIndex];
-      if (step) {
-        step.status = "done";
-        if (detail !== undefined) step.detail = detail;
-      }
-      refresh();
+      progress.complete(COMMIT_STEPS[stepIndex]!.key, detail);
     },
-
-    /** Mark a step as skipped. */
     skip(stepIndex: number, detail?: string) {
-      const step = steps[stepIndex];
-      if (step) {
-        step.status = "skipped";
-        if (detail !== undefined) step.detail = detail;
-      }
-      refresh();
+      progress.skip(COMMIT_STEPS[stepIndex]!.key, detail);
     },
-
-    /** Tear down: stop animation, clear status bar and widget. */
     dispose() {
-      stopTimer();
-      ctx.ui.setStatus?.(STATUS_KEY, undefined);
-      ctx.ui.setStatus?.("supi-model", undefined);
-      ctx.ui.setWidget?.(WIDGET_KEY, undefined);
+      progress.dispose();
     },
   };
 }
@@ -268,7 +181,7 @@ export async function analyzeAndCommit(
       exec("git", ["diff", "--cached", "--name-only"], { cwd }),
     ]);
 
-    const fileList = filesResult.stdout.trim().split("\n").filter(Boolean);
+    const fileList = normalizeLineEndings(filesResult.stdout).trim().split("\n").filter(Boolean);
     if (fileList.length === 0) {
       progress.complete(2, "empty");
       progress.dispose();
@@ -293,32 +206,41 @@ export async function analyzeAndCommit(
     });
 
     let plan: CommitPlan | null = null;
+    let agentReason: string | undefined;
 
     if (platform.capabilities.agentSessions) {
       progress.activate(4, `${fileList.length} file(s)`);
-      // Resolve the commit sub-agent model from config (falls back to session default)
       const modelCfg = loadModelConfig(platform.paths, cwd);
       const bridge = createModelBridge(platform);
-      const commitModel = resolveModelForAction("commit", modelRegistry, modelCfg, bridge);
-
-      // Show model override in status bar if not using the main session model
-      if (commitModel.source !== "main" && commitModel.model) {
-        const sourceLabel =
-          commitModel.source === "action" ? "configured for commit" :
-          commitModel.source === "default" ? "supipowers default" :
-          "harness role";
-        let detail = sourceLabel;
-        if (commitModel.thinkingLevel) {
-          detail += ` \u00b7 ${commitModel.thinkingLevel} thinking`;
+      const candidates = resolveAllCandidates("commit", modelRegistry, modelCfg, bridge);
+
+      for (const candidate of candidates) {
+        // Show model override in status bar if not using the main session model
+        if (candidate.source !== "main" && candidate.model) {
+          const sourceLabel =
+            candidate.source === "action" ? "configured for commit" :
+            candidate.source === "default" ? "supipowers default" :
+            "harness role";
+          let detail = sourceLabel;
+          if (candidate.thinkingLevel) {
+            detail += ` \u00b7 ${candidate.thinkingLevel} thinking`;
+          }
+          ctx.ui?.setStatus?.("supi-model", `Model: ${candidate.model} (${detail})`);
+        }
+
+        const agentResult = await tryAgentPlan(platform, cwd, prompt, candidate.model);
+        if (agentResult.plan) {
+          plan = validatePlanFiles(agentResult.plan, fileList);
+          progress.complete(4, `${plan.commits.length} commit(s)`);
+          break;
         }
-        ctx.ui?.setStatus?.("supi-model", `Model: ${commitModel.model} (${detail})`);
+
+        // Store last failure reason; try next candidate
+        agentReason = agentResult.reason;
       }
-      plan = await tryAgentPlan(platform, cwd, prompt, commitModel.model);
-      if (plan) {
-        plan = validatePlanFiles(plan, fileList);
-        progress.complete(4, `${plan.commits.length} commit(s)`);
-      } else {
-        progress.skip(4, "unavailable");
+
+      if (!plan) {
+        progress.skip(4, agentReason ?? "unavailable");
       }
     } else {
       progress.skip(4, "no agent sessions");
@@ -329,7 +251,10 @@ export async function analyzeAndCommit(
       progress.skip(5, "manual");
       progress.skip(6, "manual");
       progress.dispose();
-      return manualFallback(platform, ctx, cwd, fileList);
+      const reason = !platform.capabilities.agentSessions
+        ? "no agent sessions"
+        : agentReason;
+      return manualFallback(platform, ctx, cwd, fileList, reason);
     }
 
     // 6. Present plan for approval
@@ -363,12 +288,18 @@ export async function analyzeAndCommit(
 
 // ── Agent interaction ──────────────────────────────────────
 
+interface AgentPlanResult {
+  plan: CommitPlan | null;
+  /** Human-readable reason when plan is null */
+  reason?: string;
+}
+
 async function tryAgentPlan(
   platform: Platform,
   cwd: string,
   prompt: string,
   model?: string,
-): Promise<CommitPlan | null> {
+): Promise<AgentPlanResult> {
   let session: Awaited<ReturnType<Platform["createAgentSession"]>> | null = null;
   try {
     session = await platform.createAgentSession({ cwd, hasUI: false, ...(model ? { model } : {}) });
@@ -388,7 +319,7 @@ async function tryAgentPlan(
       .reverse()
       .find((m: any) => m.role === "assistant");
 
-    if (!lastAssistant) return null;
+    if (!lastAssistant) return { plan: null, reason: "no assistant response" };
 
     const text =
       typeof lastAssistant.content === "string"
@@ -400,9 +331,15 @@ async function tryAgentPlan(
               .join("\n")
           : "";
 
-    return parseCommitPlan(text);
-  } catch {
-    return null;
+    if (!text) return { plan: null, reason: "empty agent response" };
+
+    const plan = parseCommitPlan(text);
+    if (!plan) return { plan: null, reason: diagnoseParseFailure(text) };
+
+    return { plan };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { plan: null, reason: message };
   } finally {
     if (session) {
       try {
@@ -421,13 +358,16 @@ async function manualFallback(
   ctx: any,
   cwd: string,
   fileList: string[],
+  reason?: string,
 ): Promise<CommitResult | null> {
   const exec = platform.exec.bind(platform);
 
   notifyInfo(
     ctx,
     "AI commit unavailable",
-    "Enter a commit message manually",
+    reason
+      ? `${reason} \u2014 enter a commit message manually`
+      : "Enter a commit message manually",
   );
 
   const message = await ctx.ui.input("Commit message (empty to abort)", {
@@ -581,6 +521,7 @@ interface PromptInput {
 /** Exported for testing */
 export function buildAnalysisPrompt(input: PromptInput): string {
   const { diff, stat, fileList, conventions, userContext } = input;
+  const normalizedDiff = normalizeLineEndings(diff);
 
   const parts: string[] = [
     "You are a commit message generator. Analyze the following code changes and produce a commit plan.",
@@ -602,12 +543,12 @@ export function buildAnalysisPrompt(input: PromptInput): string {
   }
 
   // Diff content — truncate for large diffs
-  const diffBytes = Buffer.byteLength(diff, "utf8");
+  const diffBytes = Buffer.byteLength(normalizedDiff, "utf8");
 
   if (diffBytes <= DIFF_FULL_LIMIT) {
-    parts.push("**Full diff:**", "```", diff, "```", "");
+    parts.push("**Full diff:**", "```", normalizedDiff, "```", "");
   } else if (diffBytes <= DIFF_STAT_ONLY_LIMIT) {
-    const truncated = diff.split("\n").slice(0, DIFF_TRUNCATED_LINES).join("\n");
+    const truncated = normalizedDiff.split("\n").slice(0, DIFF_TRUNCATED_LINES).join("\n");
     parts.push(
       "**Diff (truncated — too large for full inclusion):**",
       "```",
@@ -650,6 +591,47 @@ export function buildAnalysisPrompt(input: PromptInput): string {
 
 // ── Plan parsing ───────────────────────────────────────────
 
+/**
+ * Produce a human-readable reason why parseCommitPlan returned null.
+ * Used for diagnostics — never shown raw to the user.
+ */
+function diagnoseParseFailure(text: string): string {
+  const fenceRe = /```json\s*\n([\s\S]*?)```/;
+  const match = fenceRe.exec(text);
+  if (!match) return "no JSON code block in response";
+
+  let parsed: any;
+  try {
+    parsed = JSON.parse(match[1]);
+  } catch {
+    return "JSON parse error in response";
+  }
+
+  if (!parsed.commits || !Array.isArray(parsed.commits)) return "missing commits array";
+  if (parsed.commits.length === 0) return "empty commits array";
+
+  for (const c of parsed.commits) {
+    if (!c.type) return "commit missing type";
+    if (!c.summary) return "commit missing summary";
+    if (!Array.isArray(c.files) || c.files.length === 0) return "commit missing files";
+    if (!(VALID_COMMIT_TYPES as readonly string[]).includes(c.type)) {
+      return `invalid commit type: ${c.type}`;
+    }
+  }
+
+  // Check for duplicate files across groups
+  const seen = new Set<string>();
+  for (const group of parsed.commits) {
+    for (const file of group.files) {
+      if (seen.has(file)) return `duplicate file across commits: ${file}`;
+      seen.add(file);
+    }
+  }
+
+  return "unknown parse failure";
+}
+
+
 /** Exported for testing */
 export function parseCommitPlan(text: string): CommitPlan | null {
   // Look for ```json ... ``` fenced block

package/src/git/conventions.ts

@@ -1,7 +1,7 @@
 // src/git/conventions.ts — Discover commit message conventions from repo docs and config
 
 import { readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 
 type ExecFn = (
   cmd: string,
@@ -110,7 +110,7 @@ export async function discoverCommitConventions(
     );
     if (result.code === 0 && result.stdout.trim()) {
       const templatePath = result.stdout.trim();
-      const absPath = templatePath.startsWith("/")
+      const absPath = isAbsolute(templatePath)
         ? templatePath
         : join(cwd, templatePath);
       const content = readFileSafe(absPath);

package/src/git/status.ts

@@ -1,3 +1,6 @@
+import { normalizeLineEndings } from "../text.js";
+
+
 type ExecFn = (cmd: string, args: string[], opts?: { cwd?: string }) => Promise<{ stdout: string; code: number }>;
 
 export interface WorkingTreeStatus {
@@ -16,7 +19,7 @@ export async function getWorkingTreeStatus(exec: ExecFn, cwd: string): Promise<W
     if (result.code !== 0) {
       return { dirty: false, files: [] };
     }
-    const files = result.stdout
+    const files = normalizeLineEndings(result.stdout)
       .split("\n")
       .filter(Boolean)
       .map((line) => line.slice(3)); // strip 2-char status + space

package/src/lsp/bridge.ts

@@ -1,4 +1,7 @@
 // src/lsp/bridge.ts
+import type { GateExecutionContext, GateIssue } from "../types.js";
+import { runStructuredAgentSession } from "../quality/ai-session.js";
+import { stripMarkdownCodeFence } from "../text.js";
 
 export interface DiagnosticsResult {
   file: string;
@@ -12,25 +15,148 @@ export interface Diagnostic {
   column: number;
 }
 
+function isDiagnostic(value: unknown): value is Diagnostic {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    ["error", "warning", "info", "hint"].includes((value as Diagnostic).severity) &&
+    typeof (value as Diagnostic).message === "string" &&
+    typeof (value as Diagnostic).line === "number" &&
+    typeof (value as Diagnostic).column === "number"
+  );
+}
+
+function isDiagnosticsResult(value: unknown): value is DiagnosticsResult {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as DiagnosticsResult).file === "string" &&
+    Array.isArray((value as DiagnosticsResult).diagnostics) &&
+    (value as DiagnosticsResult).diagnostics.every((diagnostic) => isDiagnostic(diagnostic))
+  );
+}
+
+function normalizeDiagnosticSeverity(severity: Diagnostic["severity"]): GateIssue["severity"] {
+  return severity === "hint" ? "info" : severity;
+}
+
+function formatDiagnosticDetail(diagnostic: Diagnostic): string | undefined {
+  return diagnostic.column > 0 ? `column ${diagnostic.column}` : undefined;
+}
+
+function extractJsonArray(raw: string): unknown | null {
+  const trimmed = raw.trim();
+
+  // 1. Try direct parse (no fence)
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) return parsed;
+  } catch {}
+
+  // 2. Strip markdown code fence and retry
+  const stripped = stripMarkdownCodeFence(trimmed);
+  if (stripped !== trimmed) {
+    try {
+      const parsed = JSON.parse(stripped);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {}
+  }
+
+  // 3. Extract first JSON array from prose via bracket matching
+  const start = trimmed.indexOf("[");
+  if (start === -1) return null;
+
+  let depth = 0;
+  for (let i = start; i < trimmed.length; i++) {
+    if (trimmed[i] === "[") depth++;
+    else if (trimmed[i] === "]") depth--;
+    if (depth === 0) {
+      try {
+        const parsed = JSON.parse(trimmed.slice(start, i + 1));
+        if (Array.isArray(parsed)) return parsed;
+      } catch {}
+      break;
+    }
+  }
+
+  return null;
+}
+
+function parseLspDiagnosticsResults(raw: string): DiagnosticsResult[] | null {
+  const parsed = extractJsonArray(raw);
+  if (!Array.isArray(parsed)) return null;
+  return parsed.every((entry) => isDiagnosticsResult(entry)) ? parsed : null;
+}
+
 /**
- * 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.
+ * Request LSP diagnostics via a headless agent session that can call the lsp tool.
  */
-export function buildLspDiagnosticsPrompt(files: string[]): string {
-  const fileList = files.map((f) => `- ${f}`).join("\n");
+export function buildLspDiagnosticsPrompt(
+  scopeFiles: string[],
+  fileScope: GateExecutionContext["fileScope"],
+): string {
+  const scopeInstruction =
+    fileScope === "all-files"
+      ? [
+          'Run repository-wide diagnostics with the lsp tool using action "diagnostics" and file "*".',
+          "Return diagnostics for files that report issues.",
+        ]
+      : [
+          "Run LSP diagnostics on these files:",
+          ...scopeFiles.map((file) => `- ${file}`),
+          "",
+          'Use the lsp tool with action "diagnostics" for each listed file.',
+        ];
+
   return [
-    "Run LSP diagnostics on these files and report any errors or warnings:",
-    fileList,
+    "You are collecting structured LSP diagnostics for a review quality gate.",
+    ...scopeInstruction,
     "",
-    'Use the lsp tool with action "diagnostics" for each file.',
-    "Report the results in this format:",
-    "FILE: <path>",
-    "  LINE:COL SEVERITY: message",
+    "Return JSON only as an array with this exact shape:",
+    '[{"file":"path/to/file.ts","diagnostics":[{"severity":"error|warning|info|hint","message":"text","line":1,"column":1}]}]',
+    "",
+    "Rules:",
+    "- Do not wrap the JSON in markdown fences.",
+    "- Include line and column numbers exactly as reported by the tool.",
+    "- Use an empty array when there are no diagnostics.",
   ].join("\n");
 }
 
+export async function collectLspDiagnostics(options: {
+  cwd: string;
+  scopeFiles: string[];
+  fileScope: GateExecutionContext["fileScope"];
+  createAgentSession: GateExecutionContext["createAgentSession"];
+  reviewModel?: GateExecutionContext["reviewModel"];
+}): Promise<GateIssue[]> {
+  const sessionResult = await runStructuredAgentSession(options.createAgentSession, {
+    cwd: options.cwd,
+    prompt: buildLspDiagnosticsPrompt(options.scopeFiles, options.fileScope),
+    model: options.reviewModel?.model,
+    thinkingLevel: options.reviewModel?.thinkingLevel ?? null,
+    timeoutMs: 120_000,
+  });
+
+  if (sessionResult.status !== "ok") {
+    throw new Error(sessionResult.error);
+  }
+
+  const parsed = parseLspDiagnosticsResults(sessionResult.finalText);
+  if (!parsed) {
+    throw new Error("LSP diagnostics integration returned invalid JSON.");
+  }
+
+  return parsed.flatMap((result) =>
+    result.diagnostics.map<GateIssue>((diagnostic) => ({
+      severity: normalizeDiagnosticSeverity(diagnostic.severity),
+      message: diagnostic.message,
+      file: result.file,
+      line: diagnostic.line,
+      detail: formatDiagnosticDetail(diagnostic),
+    })),
+  );
+}
+
 /**
  * Build a prompt snippet for sub-agents to check references before renaming.
  */