supipowers 2.1.0 → 2.2.1

package/src/git/commit.ts

@@ -103,6 +103,8 @@ const COMMIT_STEPS = [
   { key: "ai-analysis", label: "AI analysis" },
   { key: "review-plan", label: "Review plan" },
   { key: "execute-commits", label: "Execute commits" },
+  { key: "push-commits", label: "Push commits" },
+  { key: "open-pr", label: "Open pull request" },
 ] as const;
 
 function createProgress(ctx: any) {
@@ -127,6 +129,9 @@ function createProgress(ctx: any) {
     skip(stepIndex: number, detail?: string) {
       progress.skip(COMMIT_STEPS[stepIndex]!.key, detail);
     },
+    fail(stepIndex: number, detail?: string) {
+      progress.fail(COMMIT_STEPS[stepIndex]!.key, detail);
+    },
     dispose() {
       progress.dispose();
     },
@@ -340,14 +345,11 @@ export async function analyzeAndCommit(
     }
 
     if (!plan) {
-      // Skip remaining tracked steps for the manual path
       progress.skip(5, "manual");
-      progress.skip(6, "manual");
-      progress.dispose();
       const reason = !platform.capabilities.agentSessions
         ? "no agent sessions"
         : agentReason;
-      return manualFallback(platform, ctx, cwd, fileList, platform.paths, agentAttempts, reason);
+      return manualFallback(platform, ctx, cwd, fileList, platform.paths, agentAttempts, progress, reason);
     }
 
     // 6. Present plan for approval
@@ -444,6 +446,7 @@ async function manualFallback(
   fileList: string[],
   paths: PlatformPaths,
   attempts: number,
+  progress: ReturnType<typeof createProgress>,
   reason?: string,
 ): Promise<CommitResult | null> {
   const exec = platform.exec.bind(platform);
@@ -467,27 +470,186 @@ async function manualFallback(
       ? `${reason} \u2014 enter a commit message manually`
       : "Enter a commit message manually",
   );
+  progress.activate(6, "manual");
 
   const message = await ctx.ui.input("Commit message (empty to abort)", {
     helpText: `${fileList.length} file(s) staged`,
   });
-
   if (!message?.trim()) {
     notifyInfo(ctx, "Commit cancelled", "No message provided");
+    progress.skip(6, "aborted");
     return null;
   }
 
   const commitResult = await commitStaged(exec, cwd, message);
   if (!commitResult.success) {
     notifyError(ctx, "Commit failed", commitResult.error);
+    progress.fail(6, "failed");
     return null;
   }
 
   notifySuccess(ctx, "Committed", message.split("\n")[0]);
+  progress.complete(6, "1 done");
+  await offerPostCommitActions(platform, ctx, cwd, progress);
   return { committed: 1, messages: [message] };
 }
 
 
+const PUSH_NO_OPTION = "No — keep commits local";
+const PR_NO_OPTION = "No — leave branch without a PR";
+const PR_YES_OPTION = "Yes — open a Pull Request";
+
+function pushYesOption(branch: string): string {
+  return `Yes — push to origin/${branch}`;
+}
+
+function isDefaultBranchName(branch: string): boolean {
+  return branch === "main" || branch === "master";
+}
+
+function formatCommandFailure(result: { stdout: string; stderr: string; code: number }): string {
+  return result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
+}
+
+async function readCurrentBranch(
+  exec: ExecFn,
+  ctx: any,
+  cwd: string,
+): Promise<string | null> {
+  const result = await exec("git", ["branch", "--show-current"], { cwd });
+  if (result.code !== 0) {
+    notifyError(ctx, "Could not determine current branch", formatCommandFailure(result));
+    return null;
+  }
+
+  return result.stdout.trim() || null;
+}
+
+async function pushCurrentBranch(
+  exec: ExecFn,
+  ctx: any,
+  cwd: string,
+  branch: string,
+): Promise<boolean> {
+  const result = await exec("git", ["push", "-u", "origin", branch], { cwd });
+  if (result.code !== 0) {
+    notifyError(ctx, "Push failed", formatCommandFailure(result));
+    return false;
+  }
+
+  notifySuccess(ctx, "Pushed", `origin/${branch}`);
+  return true;
+}
+
+async function createPullRequest(
+  exec: ExecFn,
+  ctx: any,
+  cwd: string,
+  branch: string,
+): Promise<boolean> {
+  const result = await exec("gh", ["pr", "create", "--fill", "--head", branch], { cwd });
+  if (result.code !== 0) {
+    notifyError(ctx, "Pull request failed", formatCommandFailure(result));
+    return false;
+  }
+
+  const detail = result.stdout.trim() || result.stderr.trim() || `Branch: ${branch}`;
+  notifySuccess(ctx, "Pull request opened", detail);
+  return true;
+}
+
+async function offerPostCommitActions(
+  platform: Platform,
+  ctx: any,
+  cwd: string,
+  progress: ReturnType<typeof createProgress>,
+): Promise<void> {
+  try {
+    const exec = platform.exec.bind(platform);
+    progress.activate(7, "detect branch");
+    const branch = await readCurrentBranch(exec, ctx, cwd);
+    if (!branch) {
+      progress.skip(7, "no branch");
+      progress.skip(8, "no branch");
+      return;
+    }
+
+    const yesPush = pushYesOption(branch);
+    progress.activate(7, "prompt");
+    const pushSelection = await ctx.ui.select("Push commits?", [
+      PUSH_NO_OPTION,
+      yesPush,
+    ], {
+      helpText: `Current branch: ${branch}`,
+    });
+
+    if (!pushSelection) {
+      progress.skip(7, "cancelled");
+      progress.skip(8, "cancelled");
+      return;
+    }
+
+    let pushed = false;
+    if (pushSelection === yesPush) {
+      progress.activate(7, `origin/${branch}`);
+      pushed = await pushCurrentBranch(exec, ctx, cwd, branch);
+      if (!pushed) {
+        progress.fail(7, "failed");
+        progress.skip(8, "push failed");
+        return;
+      }
+      progress.complete(7, `origin/${branch}`);
+    } else {
+      progress.skip(7, "kept local");
+    }
+
+    if (isDefaultBranchName(branch)) {
+      progress.skip(8, "default branch");
+      return;
+    }
+
+    progress.activate(8, "prompt");
+    const prSelection = await ctx.ui.select("Open a Pull Request?", [
+      PR_NO_OPTION,
+      PR_YES_OPTION,
+    ], {
+      helpText: pushed
+        ? `Branch: ${branch}`
+        : `Opening a PR will first push origin/${branch}.`,
+    });
+    if (!prSelection) {
+      progress.skip(8, "cancelled");
+      return;
+    }
+    if (prSelection !== PR_YES_OPTION) {
+      progress.skip(8, "not requested");
+      return;
+    }
+
+    if (!pushed) {
+      progress.activate(7, `origin/${branch}`);
+      pushed = await pushCurrentBranch(exec, ctx, cwd, branch);
+      if (!pushed) {
+        progress.fail(7, "failed");
+        progress.skip(8, "push failed");
+        return;
+      }
+      progress.complete(7, `origin/${branch}`);
+    }
+
+    progress.activate(8, "gh pr create");
+    if (!await createPullRequest(exec, ctx, cwd, branch)) {
+      progress.fail(8, "failed");
+      return;
+    }
+    progress.complete(8, "created");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    progress.fail(8, "error");
+    notifyError(ctx, "Post-commit action failed", message);
+  }
+}
+
 
 // ── Commit execution ───────────────────────────────────────
 
@@ -548,12 +710,12 @@ async function executeCommitPlan(
   await exec("git", ["read-tree", savedTree], { cwd });
 
   progress.complete(6, `${committedMessages.length} done`);
-  progress.dispose();
   notifySuccess(
     ctx,
     `${committedMessages.length} commit(s) created`,
     committedMessages.map((m) => m.split("\n")[0]).join(" | "),
   );
+  await offerPostCommitActions(platform, ctx, cwd, progress);
 
   return { committed: committedMessages.length, messages: committedMessages };
 }

package/src/harness/command.ts

@@ -39,6 +39,7 @@ import {
   loadHarnessSession,
   loadHarnessValidateReport,
   readSlopQueue,
+  saveHarnessDesignSpecJson,
   saveHarnessSession,
 } from "./storage.js";
 import { computeScore } from "./anti_slop/score.js";
@@ -55,6 +56,8 @@ import { buildBackendAdapter } from "./anti_slop/backend-factory.js";
 import { getWorkingTreeStatus } from "../git/status.js";
 import { DEFAULT_HARNESS_CONFIG } from "./hooks/register.js";
 import { handlePrComment } from "./pr-comment/handler.js";
+import { runGitVerificationQa } from "./git-verify-qa.js";
+import { getHarnessSessionDir } from "./project-paths.js";
 import type { HarnessDesignSpec, HarnessGateMode, HarnessSession, HarnessStage } from "../types.js";
 
 modelRegistry.register({
@@ -223,12 +226,13 @@ async function runPipelineWithProgress(
   gates: HarnessGateMode,
   stageInputs: BuildRunnerInput,
   startStage?: HarnessStage,
+  forceStages?: ReadonlySet<HarnessStage>,
 ): Promise<PipelineRunOutcome> {
   const harnessProgress = createHarnessProgress(ctx);
   const modelConfig = loadModelConfig(platform.paths, ctx.cwd);
   const outcome = await pipelineDriver({
     platform, paths: platform.paths, cwd: ctx.cwd, sessionId,
-    modelConfig, gates, stageInputs, startStage,
+    modelConfig, gates, stageInputs, startStage, forceStages,
     onProgress: harnessProgress.onProgress,
   });
   // Single consolidated notification.
@@ -558,12 +562,12 @@ async function runDesignQa(
 
     if (choice === "Accept all suggestions") {
       applyDesignAnalysis(base, analysis);
-      await askCiAndTooling(ctx, base);
+      await askCiAndTooling(platform, ctx, base);
       return base;
     }
 
     if (choice === "Skip — use bare defaults") {
-      await askCiAndTooling(ctx, base);
+      await askCiAndTooling(platform, ctx, base);
       return base;
     }
   }
@@ -627,7 +631,7 @@ async function runDesignQa(
     }
   }
 
-  await askCiAndTooling(ctx, base);
+  await askCiAndTooling(platform, ctx, base);
   return base;
 }
 
@@ -707,7 +711,7 @@ function localCommandOptions(base: HarnessDesignSpec): string[] {
   ]));
 }
 
-async function askCiAndTooling(ctx: HarnessCommandContext, base: HarnessDesignSpec): Promise<void> {
+async function askCiAndTooling(platform: Platform, ctx: HarnessCommandContext, base: HarnessDesignSpec): Promise<void> {
   if (!ctx.ui.select) return;
 
   const triggerChoice = await ctx.ui.select(
@@ -741,6 +745,84 @@ async function askCiAndTooling(ctx: HarnessCommandContext, base: HarnessDesignSp
   } else if (toolChoice) {
     base.ci.localCommand = toolChoice.replace(/\s+\(.+\)$/, "");
   }
+
+  // After the user picks their CI trigger and local command, offer the optional Git
+  // verification flow. This populates `base.ci.git` so the implement stage renders the
+  // PR-source guardrail and validate confirms the wiring. Skippable; declining leaves
+  // `git` unset and the rest of the pipeline behaves identically to before this feature.
+  await runGitVerificationStep(platform, ctx, base);
+}
+
+/**
+ * Adapter around `runGitVerificationQa` that fits the harness command UI. The QA helper
+ * expects an `ExecFn`-shaped function plus a `select / input / notify` UI trio; we wrap
+ * `platform.exec` and `ctx.ui` so the helper stays independent of the OMP plumbing.
+ *
+ * Persists any returned `HarnessCiGitConfig` onto the in-memory `base` spec; the design
+ * stage runner persists the spec to disk so no extra storage call is needed here. We
+ * also widen `base.ci.trigger.branches` to include both `mainBranch` and `devBranch`
+ * so the rendered workflow runs CI on both PR targets — matching the rule "CI runs on
+ * both the dev branch PR and the main branch".
+ */
+async function runGitVerificationStep(
+  platform: Platform,
+  ctx: HarnessCommandContext,
+  base: HarnessDesignSpec,
+): Promise<void> {
+  if (!ctx.ui.select || !ctx.ui.input) return; // No interactive UI — skip silently.
+
+  const sessionDir = getHarnessSessionDir(platform.paths, ctx.cwd, base.sessionId);
+
+  const result = await runGitVerificationQa({
+    exec: (cmd, args, opts) => platform.exec(cmd, args, opts),
+    cwd: ctx.cwd,
+    sessionDir,
+    ui: {
+      select: (title, options) => ctx.ui.select!(title, options as unknown as string[]),
+      input: (label) => ctx.ui.input!(label),
+      notify: (message) => notifyInfo(ctx, "Git verification", message),
+    },
+  });
+
+  if (!result) return;
+  base.ci.git = result;
+
+  // Ensure the CI trigger includes both branches so the workflow runs on PRs targeting
+  // either. Preserve any user-customized branches the prior step already picked.
+  if (base.ci.trigger.mode === "branches") {
+    const next = new Set(base.ci.trigger.branches);
+    next.add(result.mainBranch);
+    if (result.devBranch) next.add(result.devBranch);
+    base.ci.trigger = { mode: "branches", branches: Array.from(next) };
+  }
+}
+
+/**
+ * Harden-mode entry point for Git verification. Mutates the persisted design spec in
+ * place so the downstream implement stage re-renders the workflow with the new `git`
+ * block. Returns true when a new `ci.git` block was captured and persisted so the
+ * caller can force-re-run the affected stages; false when the user declined or no UI
+ * is available.
+ */
+async function runGitVerificationOnHarden(
+  platform: Platform,
+  ctx: HarnessCommandContext,
+  sessionId: string,
+  spec: HarnessDesignSpec,
+): Promise<boolean> {
+  await runGitVerificationStep(platform, ctx, spec);
+  if (!spec.ci.git) return false; // user declined
+  const persisted = saveHarnessDesignSpecJson(platform.paths, ctx.cwd, sessionId, spec);
+  if (!persisted.ok) {
+    notifyInfo(
+      ctx,
+      "Git verification persisted partially",
+      `In-memory spec updated, but persistence failed: ${persisted.error.message}. ` +
+        `Re-run /supi:harness to retry.`,
+    );
+    return false;
+  }
+  return true;
 }
 
 
@@ -902,7 +984,17 @@ async function handleBareEntry(platform: Platform, ctx: HarnessCommandContext):
     if (layerCount >= 2) {
       await promptDocsTierIfNeeded(platform, ctx, sessionId, layerCount);
     }
-    await runPipelineWithProgress(platform, ctx, sessionId, "auto", {});
+    // Offer the optional Git verification flow on harden when the existing spec has no
+    // `ci.git` block. Keeps the harden path lightweight by skipping silently when the
+    // user previously declined or completed the verification. When the user captures a
+    // new `ci.git` block, force implement + validate to re-run so the workflow file is
+    // re-rendered with the `verify-pr-source` job and the validate cross-check fires.
+    let forceStages: ReadonlySet<HarnessStage> | undefined;
+    if (designSpec.ok && !designSpec.value.ci.git) {
+      const captured = await runGitVerificationOnHarden(platform, ctx, sessionId, designSpec.value);
+      if (captured) forceStages = new Set<HarnessStage>(["implement", "validate"]);
+    }
+    await runPipelineWithProgress(platform, ctx, sessionId, "auto", {}, undefined, forceStages);
   } else {
     // Rebuild: full regeneration with user gates at each stage.
     await runRebuildWithGates(platform, ctx, sessionId);