supipowers 1.5.3 → 2.0.1

package/src/fix-pr/scripts/wait-and-check.ts

@@ -0,0 +1,108 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { fetchPrComments, parsePrCommentsJsonl } from "../fetch-comments.js";
+import type { PrComment } from "../types.js";
+import { createCliPlatformExec } from "./exec.js";
+
+export interface WaitAndCheckSummary {
+  hasNewComments: boolean;
+  count: number;
+  iteration: number;
+  error?: string;
+}
+
+function fingerprint(comment: PrComment): string {
+  return `${comment.id}\t${comment.updatedAt ?? ""}`;
+}
+
+function diffComments(previous: readonly PrComment[], current: readonly PrComment[]): PrComment[] {
+  if (previous.length === 0) {
+    return [...current];
+  }
+
+  const previousFingerprints = new Set(previous.map(fingerprint));
+  return current.filter((comment) => !previousFingerprints.has(fingerprint(comment)));
+}
+
+async function sleep(ms: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function waitAndCheck(
+  sessionDir: string,
+  delaySeconds: number,
+  iteration: number,
+  repo: string,
+  prNumber: number,
+): Promise<{ exitCode: number; output: string }> {
+  const snapshotsDir = path.join(sessionDir, "snapshots");
+  const previousSnapshotPath = path.join(snapshotsDir, `comments-${iteration - 1}.jsonl`);
+  const newSnapshotPath = path.join(snapshotsDir, `comments-${iteration}.jsonl`);
+
+  await sleep(delaySeconds * 1_000);
+
+  const fetchError = await fetchPrComments(
+    createCliPlatformExec() as any,
+    repo,
+    prNumber,
+    newSnapshotPath,
+    process.cwd(),
+  );
+
+  if (fetchError) {
+    const summary: WaitAndCheckSummary = {
+      hasNewComments: false,
+      count: 0,
+      iteration,
+      error: fetchError,
+    };
+    return { exitCode: 1, output: JSON.stringify(summary) };
+  }
+
+  const previousComments = fs.existsSync(previousSnapshotPath)
+    ? parsePrCommentsJsonl(fs.readFileSync(previousSnapshotPath, "utf8"))
+    : [];
+  const currentComments = fs.existsSync(newSnapshotPath)
+    ? parsePrCommentsJsonl(fs.readFileSync(newSnapshotPath, "utf8"))
+    : [];
+  const changedComments = diffComments(previousComments, currentComments);
+  const summary: WaitAndCheckSummary = {
+    hasNewComments: changedComments.length > 0,
+    count: changedComments.length,
+    iteration,
+  };
+
+  const lines = changedComments.map((comment) => JSON.stringify(comment));
+  lines.push(JSON.stringify(summary));
+  return {
+    exitCode: 0,
+    output: lines.join("\n"),
+  };
+}
+
+async function main(): Promise<void> {
+  const [sessionDir, delayArg, iterationArg, repo, prNumberArg] = process.argv.slice(2);
+  const delaySeconds = Number.parseInt(delayArg ?? "", 10);
+  const iteration = Number.parseInt(iterationArg ?? "", 10);
+  const prNumber = Number.parseInt(prNumberArg ?? "", 10);
+
+  if (!sessionDir || !Number.isInteger(delaySeconds) || !Number.isInteger(iteration) || !repo || !Number.isInteger(prNumber)) {
+    console.log(JSON.stringify({
+      hasNewComments: false,
+      count: 0,
+      iteration: Number.isInteger(iteration) ? iteration : 0,
+      error: "Usage: wait-and-check.ts <session_dir> <delay_seconds> <iteration> <owner/repo> <pr_number>",
+    }));
+    process.exit(1);
+  }
+
+  const result = await waitAndCheck(sessionDir, delaySeconds, iteration, repo, prNumber);
+  console.log(result.output);
+  process.exit(result.exitCode);
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  void main();
+}

package/src/fix-pr/types.ts

@@ -1,3 +1,5 @@
+import type { FixPrAssessmentBatch } from "./contracts.js";
+
 /** Supported automated PR reviewers */
 export type ReviewerType = "coderabbit" | "copilot" | "gemini" | "none";
 
@@ -58,4 +60,6 @@ export interface FixPrSessionLedger {
   iteration: number;
   config: FixPrConfig;
   commentsProcessed: number[];
+  /** Validated per-comment assessment artifact. Absent in older sessions. */
+  assessment?: FixPrAssessmentBatch;
 }

package/src/git/branch-finish.ts

@@ -71,6 +71,11 @@ export function buildBranchFinishPrompt(
     "",
     "```bash",
     `git push -u origin ${branchName}`,
+    "```",
+    "",
+    "Then open the PR. **Preferred:** call the `github` tool with `op: \"pr_create\"` — supply `title` and `body` (or `fill: true` to auto-fill from commits); it returns the new PR URL. **Fallback** if the tool is unavailable in your runtime:",
+    "",
+    "```bash",
     `gh pr create --title "<title>" --body "<summary>"`,
     "```",
     "",

package/src/git/commit-contract.ts

@@ -0,0 +1,83 @@
+// src/git/commit-contract.ts
+//
+// Schema-backed contract for AI-generated commit plans. The AI must return a
+// CommitPlan matching this schema; parseStructuredOutput enforces the structure
+// and runWithOutputValidation retries with schema feedback on drift. Coverage
+// (every staged file appears in exactly one commit) is a runtime rule that
+// can't live in the schema — see validateCommitPlanCoverage.
+
+import { type Static, Type } from "@sinclair/typebox";
+import { VALID_COMMIT_TYPES } from "../release/commit-types.js";
+import type { ValidationError } from "../types.js";
+
+export const CommitGroupSchema = Type.Object(
+  {
+    type: Type.Union(VALID_COMMIT_TYPES.map((value) => Type.Literal(value))),
+    scope: Type.Union([Type.String(), Type.Null()]),
+    summary: Type.String({ minLength: 1 }),
+    details: Type.Array(Type.String()),
+    files: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+  },
+  { additionalProperties: false },
+);
+
+export const CommitPlanSchema = Type.Object(
+  {
+    commits: Type.Array(CommitGroupSchema, { minItems: 1 }),
+  },
+  { additionalProperties: false },
+);
+
+export type CommitGroup = Static<typeof CommitGroupSchema>;
+export type CommitPlan = Static<typeof CommitPlanSchema>;
+
+/**
+ * Verify every staged file appears in exactly one commit and that no commit
+ * references a file outside the staged set. Returns an empty array on success;
+ * a non-empty array indicates the plan is unusable and the caller must block.
+ */
+export function validateCommitPlanCoverage(
+  plan: CommitPlan,
+  stagedFiles: string[],
+): ValidationError[] {
+  const errors: ValidationError[] = [];
+  const stagedSet = new Set(stagedFiles);
+  const occurrences = new Map<string, number[]>();
+
+  plan.commits.forEach((commit, commitIdx) => {
+    commit.files.forEach((file, fileIdx) => {
+      if (!stagedSet.has(file)) {
+        errors.push({
+          path: `commits[${commitIdx}].files[${fileIdx}]`,
+          message: `File is not in the staged set: ${file}`,
+        });
+      }
+      const existing = occurrences.get(file);
+      if (existing) {
+        existing.push(commitIdx);
+      } else {
+        occurrences.set(file, [commitIdx]);
+      }
+    });
+  });
+
+  for (const [file, commitIdxs] of occurrences) {
+    if (commitIdxs.length > 1) {
+      errors.push({
+        path: "commits",
+        message: `File appears in multiple commits (indices ${commitIdxs.join(", ")}): ${file}`,
+      });
+    }
+  }
+
+  for (const file of stagedFiles) {
+    if (!occurrences.has(file)) {
+      errors.push({
+        path: "commits",
+        message: `Staged file not covered by any commit: ${file}`,
+      });
+    }
+  }
+
+  return errors;
+}

package/src/git/commit.ts

@@ -4,9 +4,11 @@
 // a conventional-commit plan (optionally split by file), presents
 // the plan for user approval, then executes file-level staging + commit.
 
-import type { Platform } from "../platform/types.js";
+import type { Platform, PlatformPaths } from "../platform/types.js";
+import { appendReliabilityRecord } from "../storage/reliability-metrics.js";
 import { createWorkflowProgress } from "../platform/progress.js";
 import { VALID_COMMIT_TYPES } from "../release/commit-types.js";
+import { resolveRepoRoot } from "../workspace/repo-root.js";
 import { validateCommitMessage } from "./commit-msg.js";
 import { getWorkingTreeStatus } from "./status.js";
 import { discoverCommitConventions } from "./conventions.js";
@@ -18,17 +20,13 @@ import { loadModelConfig } from "../config/model-config.js";
 
 // ── Public types ───────────────────────────────────────────
 
-export interface CommitGroup {
-  type: string;
-  scope: string | null;
-  summary: string;
-  details: string[];
-  files: string[];
-}
+import { CommitPlanSchema, validateCommitPlanCoverage, type CommitGroup, type CommitPlan } from "./commit-contract.js";
+import { parseStructuredOutput, runWithOutputValidation, formatValidationErrors } from "../ai/structured-output.js";
+import { renderSchemaText } from "../ai/schema-text.js";
 
-export interface CommitPlan {
-  commits: CommitGroup[];
-}
+export type { CommitGroup, CommitPlan };
+
+const COMMIT_PLAN_SCHEMA_TEXT = renderSchemaText(CommitPlanSchema);
 
 export interface CommitResult {
   committed: number;
@@ -135,6 +133,49 @@ function createProgress(ctx: any) {
   };
 }
 
+// ── Staging context ───────────────────────────────────────────
+
+interface CommitStagingContext {
+  stagedFiles: string[];
+}
+
+async function ensureStagedChanges(
+  platform: Platform,
+  ctx: any,
+  cwd: string,
+  status: Awaited<ReturnType<typeof getWorkingTreeStatus>>,
+  progress: ReturnType<typeof createProgress>,
+): Promise<CommitStagingContext | null> {
+  const exec = platform.exec.bind(platform);
+
+  if (status.stagedFiles.length === 0) {
+    progress.activate(1, `${status.files.length} file(s)`);
+    const addResult = await exec("git", ["add", "-A"], { cwd });
+    if (addResult.code !== 0) {
+      notifyError(ctx, "git add failed", addResult.stderr || "Non-zero exit");
+      return null;
+    }
+    progress.complete(1, `${status.files.length} file(s)`);
+  } else {
+    progress.activate(1, `${status.stagedFiles.length} staged`);
+    progress.complete(1, `${status.stagedFiles.length} staged`);
+  }
+
+  const stagedFilesResult = await exec("git", ["diff", "--cached", "--name-only"], { cwd });
+  if (stagedFilesResult.code !== 0) {
+    notifyError(ctx, "git diff failed", stagedFilesResult.stderr || "Could not read staged files");
+    return null;
+  }
+
+  const stagedFiles = normalizeLineEndings(stagedFilesResult.stdout).trim().split("\n").filter(Boolean);
+  if (stagedFiles.length === 0) {
+    notifyInfo(ctx, "Nothing to commit", "No changes after staging");
+    return null;
+  }
+
+  return { stagedFiles };
+}
+
 // ── Main entry point ───────────────────────────────────────
 
 /**
@@ -148,7 +189,7 @@ export async function analyzeAndCommit(
   options: CommitOptions = {},
 ): Promise<CommitResult | null> {
   const exec = platform.exec.bind(platform);
-  const cwd: string = ctx.cwd;
+  const cwd = await resolveRepoRoot(platform, ctx.cwd);
   const progress = createProgress(ctx);
 
   try {
@@ -163,32 +204,24 @@ export async function analyzeAndCommit(
     }
     progress.complete(0, `${status.files.length} file(s)`);
 
-    // 2. Stage everything (match OMP behavior: include untracked)
-    progress.activate(1, `${status.files.length} file(s)`);
-    const addResult = await exec("git", ["add", "-A"], { cwd });
-    if (addResult.code !== 0) {
-      progress.dispose();
-      notifyError(ctx, "git add failed", addResult.stderr || "Non-zero exit");
+    const stagingContext = await ensureStagedChanges(
+      platform,
+      ctx,
+      cwd,
+      status,
+      progress,
+    );
+    if (!stagingContext) {
       return null;
     }
-    progress.complete(1, `${status.files.length} file(s)`);
 
     // 3. Gather diff information
-    progress.activate(2);
-    const [diffResult, statResult, filesResult] = await Promise.all([
+    const fileList = stagingContext.stagedFiles;
+    progress.activate(2, `${fileList.length} file(s)`);
+    const [diffResult, statResult] = await Promise.all([
       exec("git", ["diff", "--cached"], { cwd }),
       exec("git", ["diff", "--cached", "--stat"], { cwd }),
-      exec("git", ["diff", "--cached", "--name-only"], { cwd }),
     ]);
-
-    const fileList = normalizeLineEndings(filesResult.stdout).trim().split("\n").filter(Boolean);
-    if (fileList.length === 0) {
-      progress.complete(2, "empty");
-      progress.dispose();
-      notifyInfo(ctx, "Nothing to commit", "No changes after staging");
-      await exec("git", ["reset", "HEAD"], { cwd });
-      return null;
-    }
     progress.complete(2, `${fileList.length} file(s)`);
 
     // 4. Discover conventions
@@ -207,6 +240,7 @@ export async function analyzeAndCommit(
 
     let plan: CommitPlan | null = null;
     let agentReason: string | undefined;
+    let agentAttempts = 0;
 
     if (platform.capabilities.agentSessions) {
       progress.activate(4, `${fileList.length} file(s)`);
@@ -223,20 +257,21 @@ export async function analyzeAndCommit(
             "harness role";
           let detail = sourceLabel;
           if (candidate.thinkingLevel) {
-            detail += ` \u00b7 ${candidate.thinkingLevel} thinking`;
+            detail += ` · ${candidate.thinkingLevel} thinking`;
           }
           ctx.ui?.setStatus?.("supi-model", `Model: ${candidate.model} (${detail})`);
         }
 
-        const agentResult = await tryAgentPlan(platform, cwd, prompt, candidate.model);
+        const agentResult = await tryAgentPlan(platform, cwd, prompt, fileList, candidate.model);
         if (agentResult.plan) {
-          plan = validatePlanFiles(agentResult.plan, fileList);
+          plan = agentResult.plan;
           progress.complete(4, `${plan.commits.length} commit(s)`);
           break;
         }
 
         // Store last failure reason; try next candidate
         agentReason = agentResult.reason;
+        agentAttempts = agentResult.attempts;
       }
 
       if (!plan) {
@@ -254,7 +289,7 @@ export async function analyzeAndCommit(
       const reason = !platform.capabilities.agentSessions
         ? "no agent sessions"
         : agentReason;
-      return manualFallback(platform, ctx, cwd, fileList, reason);
+      return manualFallback(platform, ctx, cwd, fileList, platform.paths, agentAttempts, reason);
     }
 
     // 6. Present plan for approval
@@ -262,11 +297,11 @@ export async function analyzeAndCommit(
     const planDisplay = formatPlanForDisplay(plan);
     notifyInfo(ctx, "Commit plan ready", "\n" + planDisplay);
     const commitLabel = plan.commits.length === 1
-      ? `commit \u2014 ${formatCommitHeader(plan.commits[0])}`
-      : `commit \u2014 apply ${plan.commits.length} commits`;
+      ? `commit — ${formatCommitHeader(plan.commits[0])}`
+      : `commit — apply ${plan.commits.length} commits`;
     const action = await ctx.ui.select("Proceed?", [
       commitLabel,
-      "abort \u2014 cancel",
+      "abort — cancel",
     ]);
 
     if (!action || action.startsWith("abort")) {
@@ -292,62 +327,53 @@ interface AgentPlanResult {
   plan: CommitPlan | null;
   /** Human-readable reason when plan is null */
   reason?: string;
+  /** Number of attempts made by runWithOutputValidation (0 if never reached). */
+  attempts: number;
 }
 
 async function tryAgentPlan(
   platform: Platform,
   cwd: string,
   prompt: string,
+  stagedFiles: string[],
   model?: string,
 ): Promise<AgentPlanResult> {
-  let session: Awaited<ReturnType<Platform["createAgentSession"]>> | null = null;
   try {
-    session = await platform.createAgentSession({ cwd, hasUI: false, ...(model ? { model } : {}) });
-
-    const agentDone = new Promise<void>((resolve) => {
-      session!.subscribe((event: any) => {
-        if (event.type === "agent_end") resolve();
-      });
-    });
-
-    await session.prompt(prompt);
-    await agentDone;
-
-    // Extract JSON from the last assistant message
-    const messages = session.state.messages;
-    const lastAssistant = [...messages]
-      .reverse()
-      .find((m: any) => m.role === "assistant");
-
-    if (!lastAssistant) return { plan: null, reason: "no assistant response" };
-
-    const text =
-      typeof lastAssistant.content === "string"
-        ? lastAssistant.content
-        : Array.isArray(lastAssistant.content)
-          ? lastAssistant.content
-              .filter((b: any) => b.type === "text")
-              .map((b: any) => b.text)
-              .join("\n")
-          : "";
+    const result = await runWithOutputValidation<CommitPlan>(
+      platform.createAgentSession.bind(platform),
+      {
+        cwd,
+        prompt,
+        schema: COMMIT_PLAN_SCHEMA_TEXT,
+        parse: (raw) => parseStructuredOutput<CommitPlan>(raw, CommitPlanSchema),
+        model,
+        maxAttempts: 3,
+        reliability: {
+          paths: platform.paths,
+          cwd,
+          command: "commit",
+          operation: "commit-plan",
+        },
+      },
+    );
 
-    if (!text) return { plan: null, reason: "empty agent response" };
+    if (result.status === "blocked") {
+      return { plan: null, reason: result.error, attempts: result.attempts };
+    }
 
-    const plan = parseCommitPlan(text);
-    if (!plan) return { plan: null, reason: diagnoseParseFailure(text) };
+    const coverageErrors = validateCommitPlanCoverage(result.output, stagedFiles);
+    if (coverageErrors.length > 0) {
+      return {
+        plan: null,
+        reason: `Commit plan coverage check failed: ${formatValidationErrors(coverageErrors).join("; ")}`,
+        attempts: result.attempts,
+      };
+    }
 
-    return { plan };
+    return { plan: result.output, attempts: result.attempts };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    return { plan: null, reason: message };
-  } finally {
-    if (session) {
-      try {
-        await session.dispose();
-      } catch {
-        // Swallow disposal errors
-      }
-    }
+    return { plan: null, reason: message, attempts: 0 };
   }
 }
 
@@ -358,10 +384,24 @@ async function manualFallback(
   ctx: any,
   cwd: string,
   fileList: string[],
+  paths: PlatformPaths,
+  attempts: number,
   reason?: string,
 ): Promise<CommitResult | null> {
   const exec = platform.exec.bind(platform);
 
+  try {
+    appendReliabilityRecord(paths, cwd, {
+      ts: new Date().toISOString(),
+      command: "commit",
+      operation: "commit-plan",
+      outcome: "fallback",
+      attempts,
+      reason,
+      cwd,
+    });
+  } catch {}
+
   notifyInfo(
     ctx,
     "AI commit unavailable",
@@ -389,24 +429,6 @@ async function manualFallback(
   return { committed: 1, messages: [message] };
 }
 
-// ── Plan validation ────────────────────────────────────────
-
-/**
- * Filter an AI-generated commit plan against the actual staged file list.
- * Removes hallucinated paths that aren't staged, and drops empty groups.
- * Falls back to the original plan if filtering would leave nothing.
- */
-export function validatePlanFiles(plan: CommitPlan, stagedFiles: string[]): CommitPlan {
-  const stagedSet = new Set(stagedFiles);
-  const validCommits = plan.commits
-    .map((group) => ({
-      ...group,
-      files: group.files.filter((f) => stagedSet.has(f)),
-    }))
-    .filter((group) => group.files.length > 0);
-
-  return validCommits.length > 0 ? { commits: validCommits } : plan;
-}
 
 
 // ── Commit execution ───────────────────────────────────────
@@ -542,6 +564,7 @@ export function buildAnalysisPrompt(input: PromptInput): string {
     parts.push(`**Developer context:** ${userContext}`, "");
   }
 
+
   // Diff content — truncate for large diffs
   const diffBytes = Buffer.byteLength(normalizedDiff, "utf8");
 
@@ -589,93 +612,7 @@ export function buildAnalysisPrompt(input: PromptInput): string {
   return parts.join("\n");
 }
 
-// ── 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
-  const fenceRe = /```json\s*\n([\s\S]*?)```/;
-  const match = fenceRe.exec(text);
-  if (!match) return null;
-
-  try {
-    const parsed = JSON.parse(match[1]);
-    if (!parsed.commits || !Array.isArray(parsed.commits)) return null;
-
-    const commits: CommitGroup[] = [];
-    for (const c of parsed.commits) {
-      if (!c.type || !c.summary || !Array.isArray(c.files) || c.files.length === 0) {
-        return null;
-      }
-      if (!(VALID_COMMIT_TYPES as readonly string[]).includes(c.type)) {
-        return null;
-      }
-      commits.push({
-        type: c.type,
-        scope: c.scope ?? null,
-        summary: String(c.summary),
-        details: Array.isArray(c.details) ? c.details.map(String) : [],
-        files: c.files.map(String),
-      });
-    }
-
-    if (commits.length === 0) return null;
-
-    // Validate: no duplicate files across groups
-    const seen = new Set<string>();
-    for (const group of commits) {
-      for (const file of group.files) {
-        if (seen.has(file)) return null;
-        seen.add(file);
-      }
-    }
-
-    return { commits };
-  } catch {
-    return null;
-  }
-}
 
 // ── Formatting ─────────────────────────────────────────────