@mgiles/perk 3.2.0 → 3.3.0

package/extension/doors/commitCompact.ts

@@ -1,251 +0,0 @@
-// The warm `/commit-and-compact` door: commit the work so far, then compact the session.
-//
-// Human-only slash command (no model-facing tool twin, no cold door, no workflow-state field —
-// warm-plane only). The commit half needs the model (real staging judgment + a real commit
-// message), so the dirty arm DRIVES the session (`pi.sendUserMessage`, warm-door discipline);
-// the compaction half is deterministic extension work keyed on `agent_settled` (the one-shot
-// "the driven run fully settled" hook — `turn_end` would compact mid-run). Fail-safe posture:
-// never compact when uncommitted work might exist — the undeterminable-git-state and no-commit
-// arms skip compaction with a loud warning naming pi's builtin `/compact` escape hatch. Clean
-// and read-only trees compact immediately (the commit half is vacuous there).
-//
-// The pending record is in-memory by design (lost on `/reload` — the user re-runs the command);
-// re-invoking while a drive is in flight simply overwrites it.
-
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { bindingSuffix } from "../substrate/bindingDelivery.ts";
-import type { PlanRef } from "../substrate/cache.ts";
-import { registerPerkCommand } from "../substrate/command.ts";
-import { commitsSince, headSha, worktreeDirty } from "../substrate/git.ts";
-import { render } from "../substrate/prompts.ts";
-import type { ToolGating } from "../substrate/toolGating.ts";
-import { branchOf, rebuildWorkflowState } from "../substrate/workflowState.ts";
-import { report, type Severity } from "../surfaces/report.ts";
-import { planReadInstruction } from "./lifecycleGates.ts";
-
-/** The driven-commit guidance (pure + exported for offline tests and the drive-coverage guard). */
-export function commitAndCompactGuidance(): string {
-  return render("commit-and-compact.md", {});
-}
-
-/**
- * Compaction instructions for the arms with nothing to commit (read-only / clean tree). Inline,
- * not a `prompts/` template — compaction `customInstructions` stay inline (the objective
- * threshold-compaction precedent); only injected user-message prose goes to `prompts/`.
- */
-export const DIRECT_COMPACT_INSTRUCTIONS =
-  "Preserve the current task's intent, progress so far, and the concrete next steps.";
-
-/**
- * Compaction instructions for the committed arm: embed the `git log --oneline` listing of the
- * new commit(s) so the summary references them. Pure + exported for offline tests.
- */
-export function compactInstructions(commits: string | null): string {
-  return [
-    "The work completed so far was just committed:",
-    "",
-    commits ?? "(commit list unavailable)",
-    "",
-    "Preserve in the summary: the task being implemented and its current progress, what the new " +
-      "commit(s) contain, and the concrete next steps for the remaining work. The committed diff " +
-      "is recoverable via git, so prefer intent and next steps over restating the diff.",
-  ].join("\n");
-}
-
-/** The one-shot record the dirty/drive arm leaves for the `agent_settled` handler. */
-export interface PendingCompact {
-  cwd: string;
-  /** HEAD at invocation (null on an unborn HEAD) — the advance gate compares against this. */
-  headBefore: string | null;
-}
-
-export type CommitCompactCompletion =
-  | { outcome: "committed"; commits: string | null }
-  | { outcome: "clean" }
-  | { outcome: "read-only" };
-
-/** The door's side-effect surface — `ExtensionContext`-backed in wiring, recorder fakes in tests. */
-export interface CommitCompactIo {
-  report(severity: Severity, message: string): void;
-  send(guidance: string): void;
-  compact(customInstructions: string, completion: CommitCompactCompletion): void;
-}
-
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.trim() !== "";
-}
-
-/**
- * The command-specific active-plan resolver. Session-tier `active_plan_ref` is the only authority:
- * a checkout cache ref can select a future plan and is unrelated to this live session.
- */
-export function activeSessionPlanRef(ctx: ExtensionContext): PlanRef | null {
-  try {
-    const ref: unknown = rebuildWorkflowState(branchOf(ctx)).active_plan_ref;
-    if (typeof ref !== "object" || ref === null) return null;
-    const candidate = ref as Record<string, unknown>;
-    if (
-      !isNonEmptyString(candidate.provider) ||
-      !isNonEmptyString(candidate.pr_id) ||
-      !isNonEmptyString(candidate.url)
-    ) {
-      return null;
-    }
-    if (
-      !Array.isArray(candidate.labels) ||
-      !candidate.labels.every((label) => typeof label === "string")
-    ) {
-      return null;
-    }
-    if (candidate.objective_id !== null && typeof candidate.objective_id !== "string") return null;
-    if (
-      candidate.base !== undefined &&
-      candidate.base !== null &&
-      typeof candidate.base !== "string"
-    ) {
-      return null;
-    }
-    return {
-      provider: candidate.provider,
-      pr_id: candidate.pr_id,
-      url: candidate.url,
-      labels: candidate.labels,
-      objective_id: candidate.objective_id,
-      ...(candidate.base !== undefined ? { base: candidate.base } : {}),
-    };
-  } catch {
-    return null;
-  }
-}
-
-/** Render the completion-gated turn that reorients the resumed agent from repository evidence. */
-export function commitAndCompactContinuation(
-  planRef: PlanRef | null,
-  completion: CommitCompactCompletion,
-): string {
-  const provider = planRef?.provider ?? "";
-  const planId = planRef?.pr_id ?? "";
-  const planUrl = planRef?.url ?? "";
-  const readCmd =
-    planRef === null ? "" : planReadInstruction(planRef.provider, planRef.pr_id, planRef.url);
-  return render("commit-and-compact-continuation.md", {
-    provider,
-    plan_id: planId,
-    plan_url: planUrl,
-    read_cmd: readCmd,
-    is_github: provider === "github" ? "x" : "",
-    committed: completion.outcome === "committed" ? "x" : "",
-    clean: completion.outcome === "clean" ? "x" : "",
-    read_only: completion.outcome === "read-only" ? "x" : "",
-    commits: completion.outcome === "committed" ? (completion.commits ?? "") : "",
-  });
-}
-
-/**
- * The invocation arms (gate → undeterminable → clean → dirty, in that order). Returns the
- * pending record only on the dirty/drive arm — every other arm resolves immediately.
- */
-export function startCommitAndCompact(
-  cwd: string,
-  gateActive: boolean,
-  io: CommitCompactIo,
-): PendingCompact | null {
-  if (gateActive) {
-    io.report("info", "read-only session — nothing to commit; compacting…");
-    io.compact(DIRECT_COMPACT_INSTRUCTIONS, { outcome: "read-only" });
-    return null;
-  }
-  const dirty = worktreeDirty(cwd);
-  if (dirty === null) {
-    // Fail-safe: never compact when uncommitted work might exist.
-    io.report(
-      "warning",
-      "cannot determine the git worktree state — compaction skipped; run /compact to compact anyway.",
-    );
-    return null;
-  }
-  if (!dirty) {
-    io.report("info", "worktree clean — nothing to commit; compacting…");
-    io.compact(DIRECT_COMPACT_INSTRUCTIONS, { outcome: "clean" });
-    return null;
-  }
-  io.report("info", "driving a commit of the work completed so far…");
-  const headBefore = headSha(cwd);
-  io.send(commitAndCompactGuidance());
-  return { cwd, headBefore };
-}
-
-/**
- * The settle arms: compact only when HEAD actually advanced past the invocation-time sha;
- * otherwise (model declined / commit failed / HEAD unreadable) warn and skip — same fail-safe.
- */
-export function settleCommitAndCompact(pending: PendingCompact, io: CommitCompactIo): void {
-  const headNow = headSha(pending.cwd);
-  if (headNow === null || headNow === pending.headBefore) {
-    io.report(
-      "warning",
-      "no commit was made — compaction skipped; run /compact to compact anyway.",
-    );
-    return;
-  }
-  io.report("info", "committed — compacting the session…");
-  const commits = commitsSince(pending.cwd, pending.headBefore);
-  io.compact(compactInstructions(commits), { outcome: "committed", commits });
-}
-
-/** Register the `/commit-and-compact` command + its one-shot `agent_settled` consumer. */
-export function registerCommitAndCompact(pi: ExtensionAPI, gating: ToolGating): void {
-  let pending: PendingCompact | null = null;
-
-  const ioFor = (ctx: ExtensionContext): CommitCompactIo => ({
-    report: (severity, message) => {
-      report(ctx, "commit-and-compact", severity, message);
-    },
-    send: (guidance) => {
-      // The trigger lets repos bind a skill via `[[bindings]]`; drive unconditionally — report()
-      // already carries the headless stderr fallback.
-      pi.sendUserMessage(guidance + bindingSuffix(ctx.cwd, "command:commit-and-compact"));
-    },
-    compact: (customInstructions, completion) => {
-      // Render while the command/event context is current. Manual compaction stays in the same
-      // AgentSession + extension runner, so onComplete may use captured `pi`; it must not read
-      // `ctx` or recompute session/filesystem state after compaction.
-      const continuation = commitAndCompactContinuation(activeSessionPlanRef(ctx), completion);
-      ctx.compact({
-        customInstructions,
-        onComplete: () => {
-          try {
-            // Optionless on purpose: resume immediately under the active stage's own bindings.
-            pi.sendUserMessage(continuation);
-          } catch (error) {
-            console.error(`perk: commit-and-compact — continuation dispatch failed — ${error}`);
-          }
-        },
-        onError: (error) => {
-          console.error(`perk: commit-and-compact — compaction failed — ${error}`);
-        },
-      });
-    },
-  });
-
-  pi.on("agent_settled", async (_event, ctx) => {
-    if (pending === null) return;
-    const record = pending;
-    pending = null; // consume-then-clear: the record is strictly one-shot
-    try {
-      settleCommitAndCompact(record, ioFor(ctx));
-    } catch (error) {
-      console.error(`perk: commit-and-compact — settle handling failed — ${error}`);
-    }
-  });
-
-  registerPerkCommand(pi, "commit-and-compact", {
-    description:
-      "Commit the work completed so far (a driven model turn stages and writes the message), " +
-      "compact, then continue automatically after compaction succeeds. Clean or read-only " +
-      "sessions compact immediately; a skipped or failed compaction never continues.",
-    handler: async (_args, ctx) => {
-      pending = startCommitAndCompact(ctx.cwd, gating.isActive(), ioFor(ctx));
-    },
-  });
-}