@gitkraken/compose-tools 0.1.0 → 0.3.0

package/dist/utils/cancellation.d.ts

@@ -0,0 +1,26 @@
+//#region src/utils/cancellation.d.ts
+/**
+ * True for native `AbortError` thrown by signal-aware adapters
+ * (e.g. shared-tools' AI loop, `child_process.spawn` with a signal,
+ * `fetch` with a signal). Workflow files use this in their try/catch
+ * to translate native abort errors into `ComposeWorkflowError('CANCELLED')`.
+ */
+declare function isAbortError(err: unknown): boolean;
+/**
+ * Translate a caught error into the workflow-domain shape, then throw.
+ *
+ * - `ComposeWorkflowError` is rethrown unchanged (already in the right shape).
+ * - Native `AbortError` (or any error caught while the cancellation token is
+ *   already aborted) becomes `ComposeWorkflowError('CANCELLED')`.
+ * - Anything else is rethrown unchanged.
+ *
+ * Workflows that delegate AI work to a task wrap that single task call in
+ * `try { ... } catch (err) { rethrowAsWorkflowError(err, input.cancellation); }`.
+ * Git operations elsewhere in the workflow do not pass `cancellation` into
+ * underlying ops — they run to completion regardless — and so cannot
+ * surface `AbortError`. Returns `never` so callers don't have to add an
+ * unreachable trailing throw.
+ */
+declare function rethrowAsWorkflowError(err: unknown, cancellation?: AbortSignal): never;
+//#endregion
+export { isAbortError, rethrowAsWorkflowError };

package/dist/utils/cancellation.js

@@ -0,0 +1 @@
+import{ComposeWorkflowError as e}from"../errors/workflow.js";function t(e){return e instanceof Error&&(e.name===`AbortError`||e.name===`DOMException`)}function n(n,r){throw n instanceof e?n:t(n)||r?.aborted?new e(`CANCELLED`,n instanceof Error?n.message:`Operation cancelled`,{cause:n}):n}export{t as isAbortError,n as rethrowAsWorkflowError};

package/dist/workflows/compose.d.ts

@@ -3,13 +3,14 @@ import { ComposeGitPort, SigningConfig } from "../ports/git.js";
 import { BranchPartition, CommitSuggestion, ComposeHunk, ComposeTaskName, PromptOverride } from "../tasks/types.js";
 import { ConventionDescriptor } from "../git/utils/conventions.js";
 import { OnAfterModelCall, OnBeforeModelCall, OnBeforePrompt } from "../tasks/ai-loop.js";
+import { RedactHunkContent } from "../tasks/utils/redact.js";
 import { AnalysisResult } from "../tasks/analyze/types.js";
 import { GroupingResult, GroupingStrategy } from "../tasks/group/types.js";
 import { OrderingResult } from "../tasks/order/types.js";
 import { ComposeSession } from "../tasks/session.js";
 import { PartitionStrategy } from "../tasks/partition/types.js";
 import { ComposeContext, ComposeSource, ComposeTarget } from "./types.js";
-import { SafetySnapshot } from "../git/types.js";
+import { SafetySnapshot, StashConflict } from "../git/types.js";
 import { ComposeBranchPlan } from "../git/apply-target.js";
 import { AiModelPort, UndoId } from "@gitkraken/shared-tools";
 
@@ -31,13 +32,17 @@ interface ComposePlanInput {
   strategy?: ComposeStrategy;
   depth?: ComposeDepth;
   maxRetries?: number;
+  /** See {@link ComposeInput.maxTokens}. */
+  maxTokens?: number;
   onProgress?: (event: ComposeProgressEvent) => void;
-  signal?: AbortSignal;
+  cancellation?: AbortSignal;
   onBeforeModelCall?: OnBeforeModelCall;
   onAfterModelCall?: OnAfterModelCall;
   onBeforePrompt?: OnBeforePrompt;
   /** See {@link ComposeInput.hunkFilter}. */
   hunkFilter?: ComposeInput['hunkFilter'];
+  /** See {@link ComposeInput.redactHunkContent}. */
+  redactHunkContent?: ComposeInput['redactHunkContent'];
   /** See {@link ComposeInput.session}. */
   session?: ComposeSession;
   /** See {@link ComposeInput.promptOverrides}. */
@@ -56,18 +61,33 @@ interface ComposePlanResult {
   /** See {@link ComposeResult.hunksFilteredCount}. */
   hunksFilteredCount?: number;
 }
-/** Pure-apply input — takes a previously computed plan and writes it to the repository. */
+/**
+ * Pure-apply input — takes a previously computed plan and writes it to the repository.
+ *
+ * No `cancellation` — `applyComposePlan` is git-only and runs to completion.
+ */
 interface ApplyComposePlanInput {
   git: ComposeGitPort;
   applyPlan: ComposeApplyPlan;
   source?: ComposeSource;
   target?: ComposeTarget;
   onProgress?: (event: ComposeProgressEvent) => void;
-  signal?: AbortSignal;
   /** GPG signing config for produced commits. See {@link ComposeInput.signing}. */
   signing?: SigningConfig;
   /** How to pick the primary author for each commit. See {@link ComposeInput.authorAttribution}. */
   authorAttribution?: ComposeInput['authorAttribution'];
+  /** See {@link ComposeInput.applyCommitIds}. */
+  applyCommitIds?: string[];
+  /** See {@link ComposeInput.stashLabel}. */
+  stashLabel?: string;
+  /**
+   * Same filter that was passed to {@link composePlan} when the cached plan was created.
+   * The plan's snapshot was rebuilt from the filtered hunks; the apply step re-collects
+   * from source and must re-apply this filter before comparing the diff hash, otherwise
+   * the comparison fails on every consumer that uses a filter (the fresh unfiltered
+   * diff hash never equals the cached filtered one). See {@link ComposeInput.hunkFilter}.
+   */
+  hunkFilter?: ComposeInput['hunkFilter'];
 }
 /** Result of {@link applyComposePlan}. */
 interface ApplyComposePlanResult {
@@ -76,6 +96,12 @@ interface ApplyComposePlanResult {
   partitionGroups?: BranchPartition[][];
   phases: PhaseDetail[];
   undoId?: UndoId;
+  /** Plan commit IDs actually written. A prefix of `plan.allOrderedCommits.map(c => c.id)` for partial apply. */
+  appliedCommitIds?: string[];
+  /** Hunk indices not covered by the applied commits. Empty for full apply. */
+  unappliedHunkIndices?: number[];
+  /** Set when the post-apply stash pop hit conflicts. Apply itself succeeded; the named stash is preserved. */
+  stashConflict?: StashConflict;
 }
 /** Controls how many AI pipeline steps run and how deeply each reasons. */
 type ComposeDepth = 'quick' | 'balanced' | 'deep';
@@ -115,13 +141,28 @@ interface ComposeInput {
   /** Controls AI pipeline depth. 'quick' = single AI call. 'balanced' = 2-3 calls (default). 'deep' = 4+ calls with full analysis. */
   depth?: ComposeDepth;
   maxRetries?: number;
+  /**
+   * Output-token cap forwarded to every AI task in the pipeline. Defaults to
+   * `runAiLoop`'s 16384. Bump on very large diffs whose structured output
+   * (e.g. analyze's per-hunk annotations) overflows the cap mid-JSON; the
+   * validator will surface that as a JSON-parse failure with a "Response
+   * tail" preview if it happens.
+   */
+  maxTokens?: number;
   onProgress?: (event: ComposeProgressEvent) => void;
   onBeforeApply?: (plan: ComposePlan) => Promise<boolean>;
   /**
-   * Optional cancellation signal. Forwarded to every AI call and every git operation.
-   * On abort, the workflow throws `WorkflowError('CANCELLED')`.
+   * Optional cancellation token. Forwarded only to the AI loop (via the
+   * tasks the workflow runs). Git operations &mdash; collection, snapshot
+   * verification, applying, undo manifest persistence &mdash; run to
+   * completion regardless of whether `cancellation` was aborted; mid-flight
+   * cancellation of a git op risks a half-finished mutation, so by design
+   * only the AI loop is cancellable.
+   *
+   * On AI-loop abort, the workflow translates the native `AbortError` into
+   * `ComposeWorkflowError('CANCELLED')`.
    */
-  signal?: AbortSignal;
+  cancellation?: AbortSignal;
   /**
    * Called immediately before each model.generate invocation. Use for progress UI,
    * telemetry, or correlation. The library doesn't interpret the result.
@@ -131,7 +172,7 @@ interface ComposeInput {
   onAfterModelCall?: OnAfterModelCall;
   /**
    * Gating hook called immediately before each model.generate call. Returning
-   * `false` aborts the workflow with `WorkflowError('CANCELLED')`. Use for
+   * `false` aborts the workflow with `ComposeWorkflowError('CANCELLED')`. Use for
    * large-prompt confirmations, cost warnings, org policy checks, etc.
    */
   onBeforePrompt?: OnBeforePrompt;
@@ -151,6 +192,16 @@ interface ComposeInput {
    * values so the plan still references the authoritative collection.
    */
   hunkFilter?: (hunks: ComposeHunk[]) => Promise<ComposeHunk[]> | ComposeHunk[];
+  /**
+   * Predicate that returns true for hunks whose patch body should be replaced with a
+   * placeholder in AI prompts. Matching hunks keep their filename, hunk header, index,
+   * line counts, and rename metadata; only the body is masked. The apply path still uses
+   * the real content.
+   *
+   * Intended for `.aiexclude`/`.aiignore`/`.cursorignore`-style features: the AI assigns
+   * matching hunks to commits by filename alone, never seeing the diff body.
+   */
+  redactHunkContent?: RedactHunkContent;
   /**
    * Per-task prompt overrides, keyed by {@link ComposeTaskName}. Consumers with
    * existing prompt template services (server-driven templates, provider-specific
@@ -204,6 +255,17 @@ interface ComposeInput {
     name: string;
     email: string;
   } | undefined);
+  /**
+   * Apply only the listed commit ids from `plan.allOrderedCommits`. Hunks belonging to omitted
+   * commits (plus unassigned hunks, e.g. those dropped by `hunkFilter`) become unstaged WIP on
+   * top of the rewritten branch. Undefined applies every commit.
+   *
+   * On destructive targets (`rewrite-range`, or `branch`/`auto` with `preserveOriginal: false`)
+   * with `branch`/`commit-range` sources, HEAD must be non-detached and at the source's tip.
+   */
+  applyCommitIds?: string[];
+  /** Stash message used by the apply path when stashing pending workdir state. Defaults to `'compose backup'`. */
+  stashLabel?: string;
 }
 interface ComposePlan {
   analysis?: AnalysisResult;
@@ -331,6 +393,12 @@ interface ComposeResult {
    * Undefined when no filter ran.
    */
   hunksFilteredCount?: number;
+  /** See {@link ApplyComposePlanResult.appliedCommitIds}. */
+  appliedCommitIds?: string[];
+  /** See {@link ApplyComposePlanResult.unappliedHunkIndices}. */
+  unappliedHunkIndices?: number[];
+  /** See {@link ApplyComposePlanResult.stashConflict}. */
+  stashConflict?: StashConflict;
 }
 /**
  * Compose code changes into a clean set of commits and branches.
@@ -347,6 +415,11 @@ interface ComposeResult {
  * Caller is responsible for the `model` lifecycle. If `applyPlan` is provided, the AI
  * phases are skipped and the previously computed plan is re-applied; the workdir
  * snapshot in the plan is verified before applying.
+ *
+ * Cancellation only flows into the AI loop (via the tasks the workflow runs).
+ * Git operations are not cancellable mid-flight by design — they always run to
+ * completion. When the AI loop aborts, the workflow translates the native
+ * `AbortError` into `ComposeWorkflowError('CANCELLED')`.
  */
 declare function compose(input: ComposeInput): Promise<ComposeResult>;
 /**
@@ -357,15 +430,21 @@ declare function compose(input: ComposeInput): Promise<ComposeResult>;
  * consumers whose UX lets the user edit the plan before committing.
  *
  * For single-shot "plan and apply in one go", use {@link compose} directly.
+ *
+ * Cancellation handling matches {@link compose} — only the AI loop is
+ * cancellable; git operations run to completion.
  */
 declare function composePlan(input: ComposePlanInput): Promise<ComposePlanResult>;
 /**
  * Apply a previously computed plan (from {@link composePlan}) to the repository.
  *
  * Verifies the snapshot against the current workdir before applying — if the
- * subsets the plan touches have drifted, throws `WorkflowError('SAFETY_CHECK_FAILED')`.
+ * subsets the plan touches have drifted, throws `ComposeWorkflowError('SAFETY_CHECK_FAILED')`.
  * On success, returns an `undoId` that {@link undoCompose} can reverse.
+ *
+ * No AI runs in this path, so cancellation has no effect — the apply phase
+ * runs to completion regardless of whether `cancellation` was aborted.
  */
 declare function applyComposePlan(input: ApplyComposePlanInput): Promise<ApplyComposePlanResult>;
 //#endregion
-export { ApplyComposePlanInput, ApplyComposePlanResult, ComposeApplyPlan, type ComposeBranchPlan, type ComposeContext, ComposeDepth, ComposeInput, ComposePlan, ComposePlanInput, ComposePlanResult, ComposeProgressEvent, ComposeResult, type ComposeSource, ComposeStrategy, type ComposeTarget, applyComposePlan, compose, composePlan, defaultPhaseMessages };
+export { ApplyComposePlanInput, ApplyComposePlanResult, ComposeApplyPlan, type ComposeBranchPlan, type ComposeContext, ComposeDepth, ComposeInput, ComposePlan, ComposePlanInput, ComposePlanResult, ComposeProgressEvent, ComposeResult, type ComposeSource, ComposeStrategy, type ComposeTarget, type StashConflict, applyComposePlan, compose, composePlan, defaultPhaseMessages };

package/dist/workflows/compose.js

@@ -1,2 +1,3 @@
-import{WorkflowError as e,WorkflowInputError as t}from"../errors/workflow.js";import{throwIfCancelled as n}from"../cancellation.js";import{GitError as r}from"../errors/git.js";import{addUsage as i,emptyUsage as a}from"../ai/types.js";import{analyze as o}from"../tasks/analyze/analyze.js";import{composeGroup as s}from"../tasks/compose-group/compose-group.js";import{group as c}from"../tasks/group/group.js";import{order as l}from"../tasks/order/order.js";import{partition as u}from"../tasks/partition/partition.js";import{applyPatchToIndex as d,diffTree as f,forEachRef as p,readTree as m,revParse as h,writeTree as g}from"../git/port-dispatch.js";import{buildPatchForCommit as _}from"../git/utils/patch-builder.js";import{sha256 as v}from"../git/utils/crypto.js";import{collectFromSource as y}from"../git/diff-collector.js";import{verifySnapshot as b}from"../git/safety.js";import{applyToTarget as x}from"../git/apply-target.js";import{requireExec as S}from"../git/require-exec.js";import{extractConventions as C}from"../git/utils/conventions.js";import{randomUUID as w}from"node:crypto";import{unlinkSync as T}from"node:fs";import{tmpdir as E}from"node:os";import{join as D}from"node:path";import{UndoStore as O,capturePreOperationState as k,generateUndoId as A}from"@gitkraken/shared-tools";const j={collecting:{message:`Collecting changes…`,weight:5},composing:{message:`Composing commits…`,weight:40},"compose-grouping":{message:`Grouping changes into commits…`,weight:40},analyzing:{message:`Analyzing changes…`,weight:20},grouping:{message:`Grouping changes into commits…`,weight:25},ordering:{message:`Ordering commits…`,weight:15},partitioning:{message:`Subdividing branches…`,weight:20},verifying:{message:`Verifying…`,weight:5},applying:{message:`Applying to repository…`,weight:10}};async function M(i){if(!i.applyPlan&&!i.model)throw new t(`Either 'model' or 'applyPlan' must be provided`);if(i.applyPlan)return B(i);let{git:a,model:o,source:s={type:`workdir`},onProgress:c,onBeforeApply:l,signal:u}=i;n(u);let d=o,f=i.depth??`balanced`,p=i.target??G(s);q(s,p);let m=[];c?.({phase:`collecting`,...j.collecting});let h=Date.now(),g=await y(a,s,{signal:u});if(m.push({name:`collecting`,durationMs:Date.now()-h,attempts:1}),g.hunks.length===0)throw new r(`NO_CHANGES`,K(s));let{hunks:_,filteredCount:v}=await U(g.hunks,i.hunkFilter);if(_.length===0)throw new r(`NO_CHANGES`,K(s));let w=v!==void 0&&v>0?await W(a,g.snapshot,_,u):g.snapshot,T=await N(f,{hunks:_,collection:g,conventions:i.conventions??await C({git:a,author:i.conventionAuthor,signal:u}),existingBranchNames:await Y(a,u),groupMode:p.type===`auto`?`branches`:`commits`,target:p,model:d,instructions:i.instructions,context:i.context,strategy:i.strategy,maxRetries:i.maxRetries,onProgress:c,signal:u,onBeforeModelCall:i.onBeforeModelCall,onAfterModelCall:i.onAfterModelCall,onBeforePrompt:i.onBeforePrompt,session:i.session,promptOverrides:i.promptOverrides}),E={analysis:T.analysis,grouping:T.grouping,ordering:T.ordering,branches:T.branchPlans,allOrderedCommits:T.allOrderedCommits};if(m.push(...T.phases),l&&!await l(E))return{plan:E,snapshot:w,session:T.session,usage:T.usage,phases:m,source:{type:s.type===`branch`?`branch`:`workdir`,hunks:_,commitMessages:g.commitMessages,branchName:g.branchName,baseBranch:g.baseBranch},diffStats:V(_),feedbackTargetCallId:H(m),hunksFilteredCount:v};let D=await k(S(a,`capturing pre-operation state`),{signal:u});c?.({phase:`verifying`,...j.verifying});let O=Date.now(),A=await b(a,g.snapshot,{includeUnstaged:s.type===`workdir`&&!s.stagedOnly,includeUntracked:g.untrackedIncluded,signal:u});if(!A.valid)throw new e(`SAFETY_CHECK_FAILED`,`Safety check failed: ${A.error}`);m.push({name:`verifying`,durationMs:Date.now()-O,attempts:1}),c?.({phase:`applying`,...j.applying});let M=Date.now(),P=await x({git:a,target:p,branchPlans:T.branchPlans,allOrderedCommits:T.allOrderedCommits,hunks:g.hunks,snapshot:w,collection:g,signal:u,signing:i.signing,authorAttribution:i.authorAttribution});m.push({name:`applying`,durationMs:Date.now()-M,attempts:1});let F=await X(a,D,P.mutations,p,s,u);return{plan:E,snapshot:w,partitions:P.partitions,partitionGroups:P.partitionGroups,session:T.session,usage:T.usage,phases:m,source:{type:s.type===`branch`?`branch`:`workdir`,hunks:_,commitMessages:g.commitMessages,branchName:g.branchName,baseBranch:g.baseBranch},diffStats:V(_),commitShas:P.commitShas,undoId:F,feedbackTargetCallId:H(m),hunksFilteredCount:v}}function N(e,t){switch(e){case`quick`:return P(t);case`balanced`:return F(t);case`deep`:return L(t)}}async function P(e){return I(e,{lightweight:!0,skipOrder:!0})}async function F(e){return I(e,{includeAnalysis:!0})}async function I(e,t){let{hunks:r,collection:o,conventions:c,existingBranchNames:d,groupMode:f,target:p,model:m,instructions:h,context:g,strategy:_,maxRetries:v,onProgress:y,signal:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C}=e;n(b);let w=a(),T=[],E=await s({hunks:r,commitMessages:o.commitMessages,commitOrder:o.commitOrder,branchName:o.branchName,baseBranch:o.baseBranch,issueUrl:g?.issueUrl,pullRequestUrl:g?.pullRequestUrl,instructions:h,conventions:c,mode:f,strategy:_?.grouping,existingBranchNames:f===`branches`?d:void 0,includeAnalysis:t.includeAnalysis,lightweight:t.lightweight,condensed:t.condensed,model:m,session:e.session,maxRetries:v,onProgress:e=>y?.({phase:`compose-grouping`,...j[`compose-grouping`],event:e}),signal:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.[`compose-group`]});E.usage&&i(w,E.usage),T.push({name:`compose-grouping`,durationMs:E.durationMs,attempts:E.attempts,usage:E.usage,callIds:E.callIds});let D=E.session,O,k;if(t.skipOrder)O=E.result.branches.map(e=>({branchGroup:e,orderedCommitIds:e.commits.map(e=>e.id)})),k={branches:O.map(e=>({branchId:e.branchGroup.id,orderedCommitIds:e.orderedCommitIds})),rationale:``};else{let t=await l({branches:E.result.branches,hunks:r,instructions:h,model:m,session:E.session,maxRetries:v,onProgress:e=>y?.({phase:`ordering`,...j.ordering,event:e}),signal:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.order});t.usage&&i(w,t.usage),T.push({name:`ordering`,durationMs:t.durationMs,attempts:t.attempts,usage:t.usage,callIds:t.callIds}),D=t.session,k=t.result,O=E.result.branches.map(e=>({branchGroup:e,orderedCommitIds:k.branches.find(t=>t.branchId===e.id)?.orderedCommitIds??e.commits.map(e=>e.id)}))}if(p.type===`auto`){let t=new Set(d);for(let e of E.result.branches)e.name&&t.add(e.name);for(let n of O){let r=await u({commits:J(n.branchGroup,n.orderedCommitIds),orderedCommitIds:n.orderedCommitIds,sourceBranchName:n.branchGroup.name,instructions:h,conventions:c,strategy:_?.partition,existingBranchNames:t,model:m,maxRetries:v,onProgress:e=>y?.({phase:`partitioning`,...j.partitioning,branch:n.branchGroup.name,event:e}),signal:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.partition});r.usage&&i(w,r.usage),T.push({name:`partitioning:${n.branchGroup.name}`,durationMs:r.durationMs,attempts:r.attempts,usage:r.usage,callIds:r.callIds}),n.partitioning=r.result,D=r.session;for(let e of r.result.partitions)t.add(e.branchName)}}let A=O.flatMap(e=>J(e.branchGroup,e.orderedCommitIds));return{analysis:void 0,grouping:E.result,ordering:k,branchPlans:O,allOrderedCommits:A,session:D,usage:w,phases:T}}async function L(e){let{hunks:t,collection:r,conventions:s,existingBranchNames:d,groupMode:f,target:p,model:m,instructions:h,context:g,strategy:_,maxRetries:v,onProgress:y,signal:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C}=e;n(b);let w=a(),T=[],E=await o({hunks:t,commitMessages:r.commitMessages,commitOrder:r.commitOrder,branchName:r.branchName,baseBranch:r.baseBranch,issueUrl:g?.issueUrl,pullRequestUrl:g?.pullRequestUrl,instructions:h,model:m,session:e.session,maxRetries:v,onProgress:e=>y?.({phase:`analyzing`,...j.analyzing,event:e}),signal:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.analyze});E.usage&&i(w,E.usage),T.push({name:`analyzing`,durationMs:E.durationMs,attempts:E.attempts,usage:E.usage,callIds:E.callIds});let D=await c({hunks:t,commitMessages:r.commitMessages,instructions:h,conventions:s,mode:f,strategy:_?.grouping,existingBranchNames:f===`branches`?d:void 0,model:m,session:E.session,maxRetries:v,onProgress:e=>y?.({phase:`grouping`,...j.grouping,event:e}),signal:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.group});D.usage&&i(w,D.usage),T.push({name:`grouping`,durationMs:D.durationMs,attempts:D.attempts,usage:D.usage,callIds:D.callIds});let O=await l({branches:D.result.branches,hunks:t,instructions:h,model:m,session:D.session,maxRetries:v,onProgress:e=>y?.({phase:`ordering`,...j.ordering,event:e}),signal:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.order});O.usage&&i(w,O.usage),T.push({name:`ordering`,durationMs:O.durationMs,attempts:O.attempts,usage:O.usage,callIds:O.callIds});let k=D.result.branches.map(e=>({branchGroup:e,orderedCommitIds:O.result.branches.find(t=>t.branchId===e.id)?.orderedCommitIds??e.commits.map(e=>e.id)})),A=O.session;if(p.type===`auto`){let t=new Set(d);for(let e of D.result.branches)e.name&&t.add(e.name);for(let n of k){let r=await u({commits:J(n.branchGroup,n.orderedCommitIds),orderedCommitIds:n.orderedCommitIds,sourceBranchName:n.branchGroup.name,instructions:h,conventions:s,strategy:_?.partition,existingBranchNames:t,model:m,maxRetries:v,onProgress:e=>y?.({phase:`partitioning`,...j.partitioning,branch:n.branchGroup.name,event:e}),signal:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.partition});r.usage&&i(w,r.usage),T.push({name:`partitioning:${n.branchGroup.name}`,durationMs:r.durationMs,attempts:r.attempts,usage:r.usage,callIds:r.callIds}),n.partitioning=r.result,A=r.session;for(let e of r.result.partitions)t.add(e.branchName)}}let M=k.flatMap(e=>J(e.branchGroup,e.orderedCommitIds));return{analysis:E.result,grouping:D.result,ordering:O.result,branchPlans:k,allOrderedCommits:M,session:A,usage:w,phases:T}}async function R(e){let t=await M({...e,onBeforeApply:async()=>!1});return{plan:t.plan,snapshot:t.snapshot,source:t.source,session:t.session,usage:t.usage,phases:t.phases,feedbackTargetCallId:t.feedbackTargetCallId,hunksFilteredCount:t.hunksFilteredCount}}async function z(e){let t=await M({git:e.git,applyPlan:e.applyPlan,source:e.source,target:e.target,onProgress:e.onProgress,signal:e.signal,signing:e.signing,authorAttribution:e.authorAttribution});return{commitShas:t.commitShas,partitions:t.partitions,partitionGroups:t.partitionGroups,phases:t.phases,undoId:t.undoId}}async function B(t){let{git:i,applyPlan:o,onProgress:s,signal:c}=t;n(c);let{plan:l,snapshot:u,source:d}=o,f=t.source??d,p=t.target??o?.target??G(f);q(f,p);let m=await k(S(i,`capturing pre-operation state`),{signal:c}),h=[];s?.({phase:`collecting`,...j.collecting});let g=Date.now(),_=await y(i,f,{signal:c});if(h.push({name:`collecting`,durationMs:Date.now()-g,attempts:1}),_.hunks.length===0)throw new r(`NO_CHANGES`,K(f));if(_.snapshot.diffHash!==u.diffHash)throw new e(`SAFETY_CHECK_FAILED`,`Working directory has changed since the plan was created. Re-run compose to generate a new plan.`);s?.({phase:`verifying`,...j.verifying});let v=Date.now(),C=await b(i,_.snapshot,{includeUnstaged:f.type===`workdir`&&!f.stagedOnly,includeUntracked:_.untrackedIncluded,signal:c});if(!C.valid)throw new e(`SAFETY_CHECK_FAILED`,`Safety check failed: ${C.error}`);h.push({name:`verifying`,durationMs:Date.now()-v,attempts:1}),s?.({phase:`applying`,...j.applying});let w=Date.now(),T=await x({git:i,target:p,branchPlans:l.branches,allOrderedCommits:l.allOrderedCommits,hunks:_.hunks,snapshot:_.snapshot,collection:_,signal:c,signing:t.signing,authorAttribution:t.authorAttribution});h.push({name:`applying`,durationMs:Date.now()-w,attempts:1});let E=await X(i,m,T.mutations,p,f,c);return{plan:l,snapshot:_.snapshot,partitions:T.partitions,partitionGroups:T.partitionGroups,session:{messages:[],systemPrompt:``,completedSteps:{}},usage:a(),phases:h,source:{type:f.type===`branch`?`branch`:`workdir`,hunks:_.hunks,commitMessages:_.commitMessages,branchName:_.branchName,baseBranch:_.baseBranch},diffStats:V(_.hunks),commitShas:T.commitShas,undoId:E}}function V(e){let t=new Set,n=0,r=0;for(let i of e)t.add(i.fileName),n+=i.additions,r+=i.deletions;return{fileCount:t.size,hunkCount:e.length,addedLines:n,removedLines:r}}function H(e){for(let t=e.length-1;t>=0;t--){let n=e[t].callIds;if(n&&n.length>0)return n[n.length-1]}}async function U(e,t){if(!t)return{hunks:e,filteredCount:void 0};let n=await t(e);return{hunks:n,filteredCount:e.length-n.length}}async function W(e,t,n,r){let i=D(E(),`compose-filtered-idx-${w()}`),a={GIT_INDEX_FILE:i};try{await m(e,t.headSha,{indexEnv:a,signal:r});let i=_(n);i.length>0&&await d(e,i,{indexEnv:a,signal:r});let o=await g(e,{indexEnv:a,signal:r}),s=await f(e,t.headSha,o,{signal:r});return{...t,diffHash:v(s)}}finally{try{T(i)}catch{}}}function G(e){return e.type===`branch`?{type:`branch-replace`}:e.type===`commit-range`?{type:`rewrite-range`,branch:e.branch,rangeFrom:e.from,rangeTo:e.to}:{type:`head`}}function K(e){switch(e.type){case`workdir`:return`No changes found in working directory`;case`branch`:return`No changes found on branch '${e.name}'`;case`commit-range`:return`No changes found in range '${e.from}..${e.to}' on branch '${e.branch}'`}}function q(e,n){if(n.type===`branch-replace`&&e.type!==`branch`)throw new t(`target 'branch-replace' requires source type 'branch'`);if(n.type===`rewrite-range`&&e.type!==`commit-range`&&e.type!==`branch`)throw new t(`target 'rewrite-range' requires source type 'commit-range' or 'branch'`)}function J(t,n){return n.map(n=>{let r=t.commits.find(e=>e.id===n);if(!r)throw new e(`INTERNAL`,`Commit ${n} not found in branch '${t.id}'`);return r})}async function Y(e,t){let n=(await p(e,{format:`%(refname:short)`,prefix:`refs/heads/`,signal:t})).trim().split(`
-`).filter(Boolean);return new Set(n)}async function X(e,t,n,r,i,a){let o=A(),s=n.createdBranches.length||1,c=`compose: ${s} branch${s===1?``:`es`} from ${i.type}`,l=[...n.movedBranches];if(r.type===`head`&&t.headBranch){let n=await h(e,`HEAD`,{signal:a});n!==t.headSha&&l.push({name:t.headBranch,previousSha:t.headSha,newSha:n})}let u={version:1,id:o,createdAt:new Date().toISOString(),description:c,previousHead:{sha:t.headSha,branch:t.headBranch},workdirClean:t.workdirClean,workdirBackupSha:t.workdirBackupSha,createdBranches:n.createdBranches,deletedBranches:n.deletedBranches,movedBranches:l};return await new O(S(e,`undo manifest persistence`)).save(u,{signal:a}),o}export{z as applyComposePlan,M as compose,R as composePlan,j as defaultPhaseMessages};
+import{GitError as e}from"../errors/git.js";import{ComposeWorkflowError as t,ComposeWorkflowInputError as n}from"../errors/workflow.js";import{addUsage as r,emptyUsage as i}from"../ai/types.js";import{analyze as a}from"../tasks/analyze/analyze.js";import{composeGroup as o}from"../tasks/compose-group/compose-group.js";import{group as s}from"../tasks/group/group.js";import{order as c}from"../tasks/order/order.js";import{partition as l}from"../tasks/partition/partition.js";import{applyPatchToIndex as u,currentBranch as d,diffTree as f,forEachRef as p,log as m,mergeBase as h,readTree as g,revParse as _,writeTree as v}from"../git/port-dispatch.js";import{buildPatchForCommit as y}from"../git/utils/patch-builder.js";import{sha256 as b}from"../git/utils/crypto.js";import{collectFromSource as x}from"../git/diff-collector.js";import{verifySnapshot as S}from"../git/safety.js";import{applyToTarget as C}from"../git/apply-target.js";import{requireExec as w}from"../git/require-exec.js";import{validateRewriteRangeSafety as T}from"../git/safety-range.js";import{extractConventions as E}from"../git/utils/conventions.js";import{rethrowAsWorkflowError as D}from"../utils/cancellation.js";import{randomUUID as O}from"node:crypto";import{unlinkSync as k}from"node:fs";import{tmpdir as A}from"node:os";import{join as j}from"node:path";import{UndoStore as M,capturePreOperationState as N,generateUndoId as P}from"@gitkraken/shared-tools";const F={collecting:{message:`Collecting changes…`,weight:5},composing:{message:`Composing commits…`,weight:40},"compose-grouping":{message:`Grouping changes into commits…`,weight:40},analyzing:{message:`Analyzing changes…`,weight:20},grouping:{message:`Grouping changes into commits…`,weight:25},ordering:{message:`Ordering commits…`,weight:15},partitioning:{message:`Subdividing branches…`,weight:20},verifying:{message:`Verifying…`,weight:5},applying:{message:`Applying to repository…`,weight:10}};async function I(r){if(!r.applyPlan&&!r.model)throw new n(`Either 'model' or 'applyPlan' must be provided`);if(r.applyPlan)return re(r);let{git:i,model:a,source:o={type:`workdir`},onProgress:s,onBeforeApply:c,cancellation:l}=r,u=a,d=r.depth??`balanced`,f=r.target??await X(i,o);Q(o,f),await K(i,r.applyCommitIds,r.hunkFilter,o,f),await T({git:i,source:o,target:f});let p=[];s?.({phase:`collecting`,...F.collecting});let m=Date.now(),h=await x(i,o);if(p.push({name:`collecting`,durationMs:Date.now()-m,attempts:1}),h.hunks.length===0)throw new e(`NO_CHANGES`,Z(o));let{hunks:g,filteredCount:_}=await U(h.hunks,r.hunkFilter);if(g.length===0)throw new e(`NO_CHANGES`,Z(o));let v=_!==void 0&&_>0?await W(i,h.snapshot,g):h.snapshot,y={hunks:g,collection:h,conventions:r.conventions??await E({git:i,author:r.conventionAuthor}),existingBranchNames:await ie(i),groupMode:f.type===`auto`?`branches`:`commits`,target:f,model:u,instructions:r.instructions,context:r.context,strategy:r.strategy,maxRetries:r.maxRetries,maxTokens:r.maxTokens,onProgress:s,cancellation:l,onBeforeModelCall:r.onBeforeModelCall,onAfterModelCall:r.onAfterModelCall,onBeforePrompt:r.onBeforePrompt,session:r.session,promptOverrides:r.promptOverrides,redactHunkContent:r.redactHunkContent},b;try{b=await ee(d,y)}catch(e){D(e,l)}let O={analysis:b.analysis,grouping:b.grouping,ordering:b.ordering,branches:b.branchPlans,allOrderedCommits:b.allOrderedCommits};if(p.push(...b.phases),c&&!await c(O))return{plan:O,snapshot:v,session:b.session,usage:b.usage,phases:p,source:{type:o.type===`branch`?`branch`:`workdir`,hunks:g,commitMessages:h.commitMessages,branchName:h.branchName,baseBranch:h.baseBranch},diffStats:V(g),feedbackTargetCallId:H(p),hunksFilteredCount:_};let k=await N(w(i,`capturing pre-operation state`));s?.({phase:`verifying`,...F.verifying});let A=Date.now(),j=await S(i,h.snapshot,G(o,h));if(!j.valid)throw new t(`SAFETY_CHECK_FAILED`,`Safety check failed: ${j.error}`);p.push({name:`verifying`,durationMs:Date.now()-A,attempts:1});let M=q(b.allOrderedCommits,r.applyCommitIds),{leftoverHunks:P,leftoverPatch:I}=Y(M,h.hunks),L=P.length>0?await W(i,v,J(M,h.hunks)):v;s?.({phase:`applying`,...F.applying});let R=Date.now(),z=await C({git:i,source:o,target:f,branchPlans:b.branchPlans,allOrderedCommits:M,hunks:h.hunks,snapshot:L,collection:h,signing:r.signing,authorAttribution:r.authorAttribution,stashLabel:r.stashLabel,leftoverPatch:I});p.push({name:`applying`,durationMs:Date.now()-R,attempts:1});let B=await ae(i,k,z.mutations,f,o);return{plan:O,snapshot:L,partitions:z.partitions,partitionGroups:z.partitionGroups,session:b.session,usage:b.usage,phases:p,source:{type:o.type===`branch`?`branch`:`workdir`,hunks:g,commitMessages:h.commitMessages,branchName:h.branchName,baseBranch:h.baseBranch},diffStats:V(g),commitShas:z.commitShas,undoId:B,feedbackTargetCallId:H(p),hunksFilteredCount:_,appliedCommitIds:M.map(e=>e.id),unappliedHunkIndices:P.length>0?P.map(e=>e.index):void 0,stashConflict:z.stashConflict}}function ee(e,t){switch(e){case`quick`:return L(t);case`balanced`:return R(t);case`deep`:return B(t)}}async function L(e){return z(e,{lightweight:!0,skipOrder:!0})}async function R(e){return z(e,{includeAnalysis:!0})}async function z(e,t){let{hunks:n,collection:a,conventions:s,existingBranchNames:u,groupMode:d,target:f,model:p,instructions:m,context:h,strategy:g,maxRetries:_,maxTokens:v,onProgress:y,cancellation:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C}=e,w=i(),T=[],E=await o({hunks:n,commitMessages:a.commitMessages,commitOrder:a.commitOrder,branchName:a.branchName,baseBranch:a.baseBranch,issueUrl:h?.issueUrl,pullRequestUrl:h?.pullRequestUrl,instructions:m,conventions:s,mode:d,strategy:g?.grouping,existingBranchNames:d===`branches`?u:void 0,includeAnalysis:t.includeAnalysis,lightweight:t.lightweight,condensed:t.condensed,redactHunkContent:e.redactHunkContent,model:p,session:e.session,maxRetries:_,maxTokens:v,onProgress:e=>y?.({phase:`compose-grouping`,...F[`compose-grouping`],event:e}),cancellation:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.[`compose-group`]});E.usage&&r(w,E.usage),T.push({name:`compose-grouping`,durationMs:E.durationMs,attempts:E.attempts,usage:E.usage,callIds:E.callIds});let D=E.session,O,k;if(t.skipOrder)O=E.result.branches.map(e=>({branchGroup:e,orderedCommitIds:e.commits.map(e=>e.id)})),k={branches:O.map(e=>({branchId:e.branchGroup.id,orderedCommitIds:e.orderedCommitIds})),rationale:``};else{let t=await c({branches:E.result.branches,hunks:n,instructions:m,model:p,session:E.session,maxRetries:_,maxTokens:v,onProgress:e=>y?.({phase:`ordering`,...F.ordering,event:e}),cancellation:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.order});t.usage&&r(w,t.usage),T.push({name:`ordering`,durationMs:t.durationMs,attempts:t.attempts,usage:t.usage,callIds:t.callIds}),D=t.session,k=t.result,O=E.result.branches.map(e=>({branchGroup:e,orderedCommitIds:k.branches.find(t=>t.branchId===e.id)?.orderedCommitIds??e.commits.map(e=>e.id)}))}if(f.type===`auto`){let t=new Set(u);for(let e of E.result.branches)e.name&&t.add(e.name);for(let n of O){let i=await l({commits:$(n.branchGroup,n.orderedCommitIds),orderedCommitIds:n.orderedCommitIds,sourceBranchName:n.branchGroup.name,instructions:m,conventions:s,strategy:g?.partition,existingBranchNames:t,model:p,maxRetries:_,maxTokens:v,onProgress:e=>y?.({phase:`partitioning`,...F.partitioning,branch:n.branchGroup.name,event:e}),cancellation:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.partition});i.usage&&r(w,i.usage),T.push({name:`partitioning:${n.branchGroup.name}`,durationMs:i.durationMs,attempts:i.attempts,usage:i.usage,callIds:i.callIds}),n.partitioning=i.result,D=i.session;for(let e of i.result.partitions)t.add(e.branchName)}}let A=O.flatMap(e=>$(e.branchGroup,e.orderedCommitIds));return{analysis:void 0,grouping:E.result,ordering:k,branchPlans:O,allOrderedCommits:A,session:D,usage:w,phases:T}}async function B(e){let{hunks:t,collection:n,conventions:o,existingBranchNames:u,groupMode:d,target:f,model:p,instructions:m,context:h,strategy:g,maxRetries:_,maxTokens:v,onProgress:y,cancellation:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C}=e,w=i(),T=[],E=await a({hunks:t,commitMessages:n.commitMessages,commitOrder:n.commitOrder,branchName:n.branchName,baseBranch:n.baseBranch,issueUrl:h?.issueUrl,pullRequestUrl:h?.pullRequestUrl,instructions:m,redactHunkContent:e.redactHunkContent,model:p,session:e.session,maxRetries:_,maxTokens:v,onProgress:e=>y?.({phase:`analyzing`,...F.analyzing,event:e}),cancellation:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.analyze});E.usage&&r(w,E.usage),T.push({name:`analyzing`,durationMs:E.durationMs,attempts:E.attempts,usage:E.usage,callIds:E.callIds});let D=await s({hunks:t,commitMessages:n.commitMessages,instructions:m,conventions:o,mode:d,strategy:g?.grouping,existingBranchNames:d===`branches`?u:void 0,redactHunkContent:e.redactHunkContent,model:p,session:E.session,maxRetries:_,maxTokens:v,onProgress:e=>y?.({phase:`grouping`,...F.grouping,event:e}),cancellation:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.group});D.usage&&r(w,D.usage),T.push({name:`grouping`,durationMs:D.durationMs,attempts:D.attempts,usage:D.usage,callIds:D.callIds});let O=await c({branches:D.result.branches,hunks:t,instructions:m,model:p,session:D.session,maxRetries:_,maxTokens:v,onProgress:e=>y?.({phase:`ordering`,...F.ordering,event:e}),cancellation:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.order});O.usage&&r(w,O.usage),T.push({name:`ordering`,durationMs:O.durationMs,attempts:O.attempts,usage:O.usage,callIds:O.callIds});let k=D.result.branches.map(e=>({branchGroup:e,orderedCommitIds:O.result.branches.find(t=>t.branchId===e.id)?.orderedCommitIds??e.commits.map(e=>e.id)})),A=O.session;if(f.type===`auto`){let t=new Set(u);for(let e of D.result.branches)e.name&&t.add(e.name);for(let n of k){let i=await l({commits:$(n.branchGroup,n.orderedCommitIds),orderedCommitIds:n.orderedCommitIds,sourceBranchName:n.branchGroup.name,instructions:m,conventions:o,strategy:g?.partition,existingBranchNames:t,model:p,maxRetries:_,maxTokens:v,onProgress:e=>y?.({phase:`partitioning`,...F.partitioning,branch:n.branchGroup.name,event:e}),cancellation:b,onBeforeModelCall:x,onAfterModelCall:S,onBeforePrompt:C,promptOverride:e.promptOverrides?.partition});i.usage&&r(w,i.usage),T.push({name:`partitioning:${n.branchGroup.name}`,durationMs:i.durationMs,attempts:i.attempts,usage:i.usage,callIds:i.callIds}),n.partitioning=i.result,A=i.session;for(let e of i.result.partitions)t.add(e.branchName)}}let j=k.flatMap(e=>$(e.branchGroup,e.orderedCommitIds));return{analysis:E.result,grouping:D.result,ordering:O.result,branchPlans:k,allOrderedCommits:j,session:A,usage:w,phases:T}}async function te(e){let t=await I({...e,onBeforeApply:async()=>!1});return{plan:t.plan,snapshot:t.snapshot,source:t.source,session:t.session,usage:t.usage,phases:t.phases,feedbackTargetCallId:t.feedbackTargetCallId,hunksFilteredCount:t.hunksFilteredCount}}async function ne(e){let t=await I({git:e.git,applyPlan:e.applyPlan,source:e.source,target:e.target,onProgress:e.onProgress,signing:e.signing,authorAttribution:e.authorAttribution,applyCommitIds:e.applyCommitIds,stashLabel:e.stashLabel,hunkFilter:e.hunkFilter});return{commitShas:t.commitShas,partitions:t.partitions,partitionGroups:t.partitionGroups,phases:t.phases,undoId:t.undoId,appliedCommitIds:t.appliedCommitIds,unappliedHunkIndices:t.unappliedHunkIndices,stashConflict:t.stashConflict}}async function re(n){let{git:r,applyPlan:a,onProgress:o}=n,{plan:s,snapshot:c,source:l}=a,u=n.source??l,d=n.target??a?.target??await X(r,u);Q(u,d),await K(r,n.applyCommitIds,n.hunkFilter,u,d),await T({git:r,source:u,target:d});let f=await N(w(r,`capturing pre-operation state`)),p=[];o?.({phase:`collecting`,...F.collecting});let m=Date.now(),h=await x(r,u);if(p.push({name:`collecting`,durationMs:Date.now()-m,attempts:1}),h.hunks.length===0)throw new e(`NO_CHANGES`,Z(u));let{hunks:g}=await U(h.hunks,n.hunkFilter);if(g.length===0)throw new e(`NO_CHANGES`,Z(u));let _=g.length<h.hunks.length?await W(r,h.snapshot,g):h.snapshot,v={...h,hunks:g,snapshot:_};if(v.snapshot.diffHash!==c.diffHash)throw new t(`SAFETY_CHECK_FAILED`,`Working directory has changed since the plan was created. Re-run compose to generate a new plan.`);o?.({phase:`verifying`,...F.verifying});let y=Date.now(),b=await S(r,v.snapshot,G(u,v));if(!b.valid)throw new t(`SAFETY_CHECK_FAILED`,`Safety check failed: ${b.error}`);p.push({name:`verifying`,durationMs:Date.now()-y,attempts:1});let E=q(s.allOrderedCommits,n.applyCommitIds),{leftoverHunks:D,leftoverPatch:O}=Y(E,v.hunks),k=D.length>0?await W(r,v.snapshot,J(E,v.hunks)):v.snapshot;o?.({phase:`applying`,...F.applying});let A=Date.now(),j=await C({git:r,source:u,target:d,branchPlans:s.branches,allOrderedCommits:E,hunks:v.hunks,snapshot:k,collection:v,signing:n.signing,authorAttribution:n.authorAttribution,stashLabel:n.stashLabel,leftoverPatch:O});p.push({name:`applying`,durationMs:Date.now()-A,attempts:1});let M=await ae(r,f,j.mutations,d,u);return{plan:s,snapshot:k,partitions:j.partitions,partitionGroups:j.partitionGroups,session:{messages:[],systemPrompt:``,completedSteps:{}},usage:i(),phases:p,source:{type:u.type===`branch`?`branch`:`workdir`,hunks:v.hunks,commitMessages:v.commitMessages,branchName:v.branchName,baseBranch:v.baseBranch},diffStats:V(v.hunks),commitShas:j.commitShas,undoId:M,appliedCommitIds:E.map(e=>e.id),unappliedHunkIndices:D.length>0?D.map(e=>e.index):void 0,stashConflict:j.stashConflict}}function V(e){let t=new Set,n=0,r=0;for(let i of e)t.add(i.fileName),n+=i.additions,r+=i.deletions;return{fileCount:t.size,hunkCount:e.length,addedLines:n,removedLines:r}}function H(e){for(let t=e.length-1;t>=0;t--){let n=e[t].callIds;if(n&&n.length>0)return n[n.length-1]}}async function U(e,t){if(!t)return{hunks:e,filteredCount:void 0};let n=await t(e);return{hunks:n,filteredCount:e.length-n.length}}async function W(e,t,n){let r=t.baseSha??t.headSha,i=j(A(),`compose-filtered-idx-${O()}`),a={GIT_INDEX_FILE:i};try{await g(e,r,{indexEnv:a});let i=y(n);i.length>0&&await u(e,i,{indexEnv:a});let o=await f(e,r,await v(e,{indexEnv:a}));return{...t,diffHash:b(o)}}finally{try{k(i)}catch{}}}function G(e,t){return e.type===`workdir`?{includeUnstaged:!e.stagedOnly,includeUntracked:t.untrackedIncluded}:e.type===`commit-range`&&e.includeWorkdir?{includeStaged:e.includeWorkdir.includeStaged??!0,includeUnstaged:e.includeWorkdir.includeUnstaged??!0,includeUntracked:e.includeWorkdir.includeUntracked??!0}:{includeUnstaged:!1,includeUntracked:!1}}async function K(e,t,r,i,a){if(r==null&&t==null||i.type===`workdir`||!(a.type===`rewrite-range`||(a.type===`branch`||a.type===`auto`)&&a.preserveOriginal!==!0))return;let o=i.type===`branch`?await _(e,i.name):await _(e,i.to),s=await _(e,`HEAD`);if(await d(e)==null)throw new n(`Filtering and partial apply require HEAD to be on a branch (non-detached) when rewriting existing commits. Check out the source branch before composing.`);if(s!==o)throw new n(`Filtering and partial apply require HEAD to be at the source's tip (${o.slice(0,8)}); HEAD is at ${s.slice(0,8)}.`)}function q(e,t){if(t==null)return e;let r=new Set(t),i=e.filter(e=>r.has(e.id)),a=new Set(i.map(e=>e.id)),o=t.filter(e=>!a.has(e));if(o.length>0)throw new n(`applyCommitIds contains commit ids not found in plan.allOrderedCommits: ${o.join(`, `)}`);return i}function J(e,t){let n=new Set(e.flatMap(e=>e.hunkIndices));return t.filter(e=>n.has(e.index))}function Y(e,t){let n=new Set(e.flatMap(e=>e.hunkIndices)),r=t.filter(e=>!n.has(e.index));if(r.length===0)return{leftoverHunks:[],leftoverPatch:void 0};let i=y(r);return{leftoverHunks:r,leftoverPatch:i.length>0?i:void 0}}async function X(e,t){if(t.type===`branch`){let r=await _(e,t.name),i=(await m(e,{format:`%H`,range:`${await h(e,await _(e,t.mergeTarget??`main`),r)}..${r}`,reverse:!0,limit:1})).trim().split(`
+`)[0];if(!i)throw new n(`Cannot recompose branch '${t.name}': no commits between merge-base and branch tip.`);return{type:`rewrite-range`,branch:t.name,rangeFrom:i,rangeTo:r}}return t.type===`commit-range`?{type:`rewrite-range`,branch:t.branch,rangeFrom:t.from,rangeTo:t.to}:{type:`head`}}function Z(e){switch(e.type){case`workdir`:return`No changes found in working directory`;case`branch`:return`No changes found on branch '${e.name}'`;case`commit-range`:return`No changes found in range '${e.from}..${e.to}' on branch '${e.branch}'`}}function Q(e,t){if(t.type===`rewrite-range`&&e.type===`workdir`)throw new n(`target 'rewrite-range' is not valid with 'workdir' source`);if(t.type===`head`&&e.type!==`workdir`)throw new n(`target 'head' is not valid with '${e.type}' source — use 'branch', 'auto', or 'rewrite-range'`)}function $(e,n){return n.map(n=>{let r=e.commits.find(e=>e.id===n);if(!r)throw new t(`INTERNAL`,`Commit ${n} not found in branch '${e.id}'`);return r})}async function ie(e){let t=(await p(e,{format:`%(refname:short)`,prefix:`refs/heads/`})).trim().split(`
+`).filter(Boolean);return new Set(t)}async function ae(e,t,n,r,i){let a=P(),o=n.createdRefs.filter(e=>e.kind===`branch`).length||1,s=`compose: ${o} branch${o===1?``:`es`} from ${i.type}`,c=[...n.movedRefs];if(r.type===`head`&&t.headBranch){let n=await _(e,`HEAD`);n!==t.headSha&&c.push({kind:`branch`,name:t.headBranch,previousSha:t.headSha,newSha:n})}let l={version:1,id:a,createdAt:new Date().toISOString(),description:s,previousHead:{sha:t.headSha,branch:t.headBranch},workdirClean:t.workdirClean,workdirBackupSha:t.workdirBackupSha,createdRefs:n.createdRefs,deletedRefs:n.deletedRefs,movedRefs:c};return await new M(w(e,`undo manifest persistence`)).save(l),a}export{ne as applyComposePlan,I as compose,te as composePlan,F as defaultPhaseMessages};

package/dist/workflows/split.d.ts

@@ -2,6 +2,7 @@ import { PhaseDetail, ProgressEvent, TokenUsage } from "../ai/types.js";
 import { ComposeGitPort } from "../ports/git.js";
 import { BranchPartition, CommitDetail, ComposeHunk } from "../tasks/types.js";
 import { OnAfterModelCall, OnBeforeModelCall, OnBeforePrompt } from "../tasks/ai-loop.js";
+import { RedactHunkContent } from "../tasks/utils/redact.js";
 import { AnalysisResult } from "../tasks/analyze/types.js";
 import { ComposeSession } from "../tasks/session.js";
 import { PartitionResult } from "../tasks/partition/types.js";
@@ -15,16 +16,26 @@ interface SplitInput {
   baseBranch?: string;
   instructions?: string;
   maxRetries?: number;
+  /** Output-token cap forwarded to every AI task in the split pipeline. Defaults to `runAiLoop`'s 16384. */
+  maxTokens?: number;
   onProgress?: (event: SplitProgressEvent) => void;
   onBeforeApply?: (plan: SplitPlan) => Promise<boolean>;
   /**
-   * Optional cancellation signal. Forwarded to every AI call and every git operation.
-   * On abort, the workflow throws `WorkflowError('CANCELLED')`.
+   * Optional cancellation token. Forwarded only to the AI loop (via the
+   * `analyze` and `partition` task calls). Git operations &mdash; collection,
+   * pre-state capture, branch creation, undo manifest persistence &mdash; run
+   * to completion regardless of whether `cancellation` was aborted.
+   *
+   * On AI-loop abort, the workflow translates the native `AbortError` into
+   * `ComposeWorkflowError('CANCELLED')` so consumers only have to check for
+   * the workflow-domain shape.
    */
-  signal?: AbortSignal;
+  cancellation?: AbortSignal;
   onBeforeModelCall?: OnBeforeModelCall;
   onAfterModelCall?: OnAfterModelCall;
   onBeforePrompt?: OnBeforePrompt;
+  /** See {@link RedactHunkContent}. */
+  redactHunkContent?: RedactHunkContent;
 }
 interface SplitPlan {
   analysis: AnalysisResult;

package/dist/workflows/split.js

@@ -1,3 +1,3 @@
-import{throwIfCancelled as e}from"../cancellation.js";import{GitError as t}from"../errors/git.js";import{addUsage as n,emptyUsage as r}from"../ai/types.js";import{analyze as i}from"../tasks/analyze/analyze.js";import{partition as a}from"../tasks/partition/partition.js";import{forEachRef as o}from"../git/port-dispatch.js";import{createStackedBranches as s}from"../git/apply-branches.js";import{parseUnifiedDiff as c}from"../git/utils/hunk-parser.js";import{collectCommitsForSplit as l}from"../git/diff-collector.js";import{requireExec as u}from"../git/require-exec.js";import{defaultPhaseMessages as d}from"./compose.js";import{UndoStore as f,capturePreOperationState as p,generateUndoId as m}from"@gitkraken/shared-tools";async function h(o){let{git:f,model:m,branchName:h,baseBranch:v=`main`,instructions:y,maxRetries:b,onProgress:x,onBeforeApply:S,signal:C,onBeforeModelCall:w,onAfterModelCall:T,onBeforePrompt:E}=o;e(C);let D=r(),O=[];x?.({phase:`collecting`,...d.collecting});let k=Date.now(),{commits:A,branchSha:j}=await l(f,h,v,C);if(O.push({name:`collecting`,durationMs:Date.now()-k,attempts:1}),A.length===0)throw new t(`NO_CHANGES`,`No commits found between '${v}' and '${h}'`);if(A.length<2)throw new t(`NO_CHANGES`,`Too few commits to split. A branch needs at least 2 commits.`);let M=c(A.map(e=>e.diff).join(`
-`),`branch`),N=A.map(e=>({id:e.sha,message:e.message,explanation:``,hunkIndices:[]})),P=await i({hunks:M,commitMessages:A.map(e=>e.message),commitOrder:A.map(e=>e.sha),branchName:h,baseBranch:v,instructions:y,model:m,maxRetries:b,onProgress:e=>x?.({phase:`analyzing`,...d.analyzing,event:e}),signal:C,onBeforeModelCall:w,onAfterModelCall:T,onBeforePrompt:E});P.usage&&n(D,P.usage),O.push({name:`analyzing`,durationMs:P.durationMs,attempts:P.attempts,usage:P.usage,callIds:P.callIds});let F=await a({commits:N,orderedCommitIds:A.map(e=>e.sha),sourceBranchName:h,baseBranch:v,instructions:y,existingBranchNames:await g(f,C),model:m,session:P.session,maxRetries:b,onProgress:e=>x?.({phase:`partitioning`,...d.partitioning,event:e}),signal:C,onBeforeModelCall:w,onAfterModelCall:T,onBeforePrompt:E});F.usage&&n(D,F.usage),O.push({name:`partitioning`,durationMs:F.durationMs,attempts:F.attempts,usage:F.usage,callIds:F.callIds});let I={type:`branch`,hunks:M,commitMessages:A.map(e=>e.message),branchName:h,baseBranch:v},L={analysis:P.result,partitioning:F.result,commits:A};if(F.result.partitions.length<=1||S&&!await S(L))return{plan:L,partitions:F.result.partitions,session:F.session,usage:D,phases:O,source:I};let R=await p(u(f,`capturing pre-operation state`),{signal:C});x?.({phase:`applying`,...d.applying});let z=Date.now();await s({git:f,partitions:F.result.partitions,originalBranchName:h,originalBranchSha:j,signal:C}),O.push({name:`applying`,durationMs:Date.now()-z,attempts:1});let B=await _(f,R,F.result.partitions,h,j,C);return{plan:L,partitions:F.result.partitions,session:F.session,usage:D,phases:O,source:I,undoId:B}}async function g(e,t){let n=(await o(e,{format:`%(refname:short)`,prefix:`refs/heads/`,signal:t})).trim().split(`
-`).filter(Boolean);return new Set(n)}async function _(e,t,n,r,i,a){let o=m(),s=n.map(e=>{let t=e.commitIds[e.commitIds.length-1];return{name:e.branchName,sha:t}}),c={version:1,id:o,createdAt:new Date().toISOString(),description:`split: ${n.length} branches from '${r}'`,previousHead:{sha:t.headSha,branch:t.headBranch},workdirClean:t.workdirClean,workdirBackupSha:t.workdirBackupSha,createdBranches:s,deletedBranches:[{name:r,sha:i}],movedBranches:[]};return await new f(u(e,`undo manifest persistence`)).save(c,{signal:a}),o}export{h as split};
+import{GitError as e}from"../errors/git.js";import{addUsage as t,emptyUsage as n}from"../ai/types.js";import{analyze as r}from"../tasks/analyze/analyze.js";import{partition as i}from"../tasks/partition/partition.js";import{forEachRef as a}from"../git/port-dispatch.js";import{createStackedBranches as o}from"../git/apply-branches.js";import{parseUnifiedDiff as s}from"../git/utils/hunk-parser.js";import{collectCommitsForSplit as c}from"../git/diff-collector.js";import{requireExec as l}from"../git/require-exec.js";import{rethrowAsWorkflowError as u}from"../utils/cancellation.js";import{defaultPhaseMessages as d}from"./compose.js";import{UndoStore as f,capturePreOperationState as p,generateUndoId as m}from"@gitkraken/shared-tools";async function h(a){let{git:f,model:m,branchName:h,baseBranch:v=`main`,instructions:y,maxRetries:b,maxTokens:x,onProgress:S,onBeforeApply:C,cancellation:w,onBeforeModelCall:T,onAfterModelCall:E,onBeforePrompt:D}=a,O=n(),k=[];S?.({phase:`collecting`,...d.collecting});let A=Date.now(),{commits:j,branchSha:M}=await c(f,h,v);if(k.push({name:`collecting`,durationMs:Date.now()-A,attempts:1}),j.length===0)throw new e(`NO_CHANGES`,`No commits found between '${v}' and '${h}'`);if(j.length<2)throw new e(`NO_CHANGES`,`Too few commits to split. A branch needs at least 2 commits.`);let N=s(j.map(e=>e.diff).join(`
+`)),P=j.map(e=>({id:e.sha,message:e.message,explanation:``,hunkIndices:[]})),F;try{F=await r({hunks:N,commitMessages:j.map(e=>e.message),commitOrder:j.map(e=>e.sha),branchName:h,baseBranch:v,instructions:y,redactHunkContent:a.redactHunkContent,model:m,maxRetries:b,maxTokens:x,onProgress:e=>S?.({phase:`analyzing`,...d.analyzing,event:e}),cancellation:w,onBeforeModelCall:T,onAfterModelCall:E,onBeforePrompt:D})}catch(e){u(e,w)}F.usage&&t(O,F.usage),k.push({name:`analyzing`,durationMs:F.durationMs,attempts:F.attempts,usage:F.usage,callIds:F.callIds});let I=j.map(e=>e.sha),L=await g(f),R;try{R=await i({commits:P,orderedCommitIds:I,sourceBranchName:h,baseBranch:v,instructions:y,existingBranchNames:L,model:m,session:F.session,maxRetries:b,maxTokens:x,onProgress:e=>S?.({phase:`partitioning`,...d.partitioning,event:e}),cancellation:w,onBeforeModelCall:T,onAfterModelCall:E,onBeforePrompt:D})}catch(e){u(e,w)}R.usage&&t(O,R.usage),k.push({name:`partitioning`,durationMs:R.durationMs,attempts:R.attempts,usage:R.usage,callIds:R.callIds});let z={type:`branch`,hunks:N,commitMessages:j.map(e=>e.message),branchName:h,baseBranch:v},B={analysis:F.result,partitioning:R.result,commits:j};if(R.result.partitions.length<=1||C&&!await C(B))return{plan:B,partitions:R.result.partitions,session:R.session,usage:O,phases:k,source:z};let V=await p(l(f,`capturing pre-operation state`));S?.({phase:`applying`,...d.applying});let H=Date.now();await o({git:f,partitions:R.result.partitions,originalBranchName:h,originalBranchSha:M}),k.push({name:`applying`,durationMs:Date.now()-H,attempts:1});let U=await _(f,V,R.result.partitions,h,M);return{plan:B,partitions:R.result.partitions,session:R.session,usage:O,phases:k,source:z,undoId:U}}async function g(e){let t=(await a(e,{format:`%(refname:short)`,prefix:`refs/heads/`})).trim().split(`
+`).filter(Boolean);return new Set(t)}async function _(e,t,n,r,i){let a=m(),o=n.map(e=>({kind:`branch`,name:e.branchName,sha:e.commitIds[e.commitIds.length-1]})),s={version:1,id:a,createdAt:new Date().toISOString(),description:`split: ${n.length} branches from '${r}'`,previousHead:{sha:t.headSha,branch:t.headBranch},workdirClean:t.workdirClean,workdirBackupSha:t.workdirBackupSha,createdRefs:o,deletedRefs:[{kind:`branch`,name:r,sha:i}],movedRefs:[]};return await new f(l(e,`undo manifest persistence`)).save(s),a}export{h as split};

package/dist/workflows/types.d.ts

@@ -5,10 +5,13 @@
  * - `workdir`: collect from the working directory. Set `stagedOnly` to ignore unstaged changes,
  *   `noUntracked` to ignore untracked files.
  * - `branch`: collect the diff between `name` and `mergeTarget` (defaults to the upstream/base branch).
- * - `commit-range`: collect from a contiguous range of commits on a branch, with per-hunk author
- *   info derived from the owning commits. Used by "recompose this commit" / "recompose selected
- *   commits" flows. `from` is exclusive (parent of first commit), `to` is inclusive. For a
- *   single-commit recompose: `from = parent(commitSha)`, `to = commitSha`.
+ *   Internally translates to a commit range from `parent(first-commit-on-branch)` to `name`'s tip,
+ *   so the same rules apply as for `commit-range`.
+ * - `commit-range`: collect from a contiguous range of commits on a branch as a single combined
+ *   diff. Used by "recompose this commit" / "recompose selected commits" flows. Both `from` and
+ *   `to` are **inclusive** — they name the first and last commits being rewritten. For a
+ *   single-commit recompose: `from = commitSha`, `to = commitSha`. The library internally
+ *   computes `parent(from)` for git operations. `from` must be an ancestor of `to`.
  */
 type ComposeSource = {
   type: 'workdir';
@@ -20,20 +23,46 @@ type ComposeSource = {
   mergeTarget?: string;
 } | {
   type: 'commit-range';
-  branch: string;
-  from: string;
+  branch: string; /** First commit in the range to recompose (inclusive). Must be an ancestor of `to`. */
+  from: string; /** Last commit in the range to recompose (inclusive). */
   to: string;
+  includeWorkdir?: {
+    includeStaged?: boolean;
+    includeUnstaged?: boolean;
+    includeUntracked?: boolean;
+  };
 };
 /**
  * Where compose writes the result.
  *
- * - `head`: commit onto the current branch.
- * - `branch`: create or replace a single named branch.
- * - `branch-replace`: replace the source branch (only valid when source is `branch`).
- * - `auto`: create one branch per grouped concern, optionally subdividing into stacks.
- * - `rewrite-range`: rewrite a contiguous commit range on `branch`, preserving commits
- *   before `rangeFrom` (always) and commits after `rangeTo` (by cherry-pick when
- *   `preserveSuffix`). Used with `source: 'commit-range'` for mid-branch recompose.
+ * Legal source / target pairings:
+ *
+ * | source         | head | branch | auto | rewrite-range |
+ * | -------------- | :--: | :----: | :--: | :-----------: |
+ * | `workdir`      |  ✓   |   ✓    |  ✓   |       ✗       |
+ * | `branch`       |  ✗   |   ✓    |  ✓   |       ✓       |
+ * | `commit-range` |  ✗   |   ✓    |  ✓   |       ✓       |
+ *
+ * - `head`: write the output commits onto the current branch (workdir source only).
+ * - `branch`: create a new branch from the base commit and write the chain to it. The base is
+ *   HEAD for `workdir` source, or `parent(rangeFrom)` (equivalently `mergeBase` for `branch` source)
+ *   for `branch`/`commit-range` sources. `preserveOriginal` behavior:
+ *   - `workdir` source: `true` → WIP stays in the worktree; `false` → WIP is cleared from the
+ *     worktree (except hunks excluded by `hunkFilter` or workdir flags, and any partial-apply
+ *     leftover — those stay in their original location).
+ *   - `branch` source: `true` → source branch is preserved; `false` → source branch ref is deleted
+ *     once the full diff has been applied to the new branch.
+ *   - `commit-range` source: forced to `true` (the source commits always stay reachable from the
+ *     source branch). Passing `false` is a no-op.
+ * - `auto`: same as `branch` but the AI splits the work across one or more new branches or
+ *   stacks; the same `preserveOriginal` rules apply per source type.
+ * - `rewrite-range`: replace the source's commits in place. The new chain stacks on
+ *   `parent(rangeFrom)`. Every ref whose tip is a strict descendant of `rangeTo` gets its
+ *   downstream chain re-parented onto the new tip; refs at `rangeTo` itself move with the
+ *   source branch. Used with `source: 'commit-range'` for mid-branch recompose, or with
+ *   `source: 'branch'` to rewrite the entire branch in place. Partial apply (`applyCommitIds`)
+ *   and `hunkFilter` are supported on this target only when HEAD is on the source branch and
+ *   pointing at `rangeTo`.
  */
 type ComposeTarget = {
   type: 'head';
@@ -41,18 +70,17 @@ type ComposeTarget = {
   type: 'branch';
   name: string;
   preserveOriginal?: boolean;
-} | {
-  type: 'branch-replace';
 } | {
   type: 'auto';
   preserveOriginal?: boolean;
 } | {
   type: 'rewrite-range';
   branch: string;
-  rangeFrom: string;
+  /** First commit in the rewritten range (inclusive). The new chain stacks on
+   *  `parent(rangeFrom)`. */
+  rangeFrom: string; /** Last commit in the rewritten range (inclusive). */
   rangeTo: string; /** Commits before `rangeFrom` always stay; this flag is reserved for future semantics. Default true. */
-  preservePrefix?: boolean; /** When true (default), cherry-pick `rangeTo..branch-tip` onto the new range tip. */
-  preserveSuffix?: boolean;
+  preservePrefix?: boolean;
 };
 /** Optional context passed through to AI prompts (issue/PR URLs surface in commit messages). */
 interface ComposeContext {

package/dist/workflows/undo.d.ts

@@ -1,5 +1,5 @@
 import { ComposeGitPort } from "../ports/git.js";
-import { UndoId, UndoResult, UndoValidation } from "@gitkraken/shared-tools";
+import { UndoForceOptions, UndoId, UndoResult, UndoValidation } from "@gitkraken/shared-tools";
 
 //#region src/workflows/undo.d.ts
 interface UndoComposeInput {
@@ -7,27 +7,28 @@ interface UndoComposeInput {
   /** The undo ID returned by `compose()` or `split()`. */
   undoId: UndoId;
   /**
-   * When true, downgrades `branch_has_new_commits` blockers to warnings and
-   * proceeds. The `dirty_workdir` blocker is never force-able.
+   * When `true`, downgrades `branch_has_new_commits` blockers to warnings —
+   * shorthand for `{ branchHasNewCommits: true }`. Pass an object form to
+   * additionally bypass `dirty_workdir` (e.g., when rolling back from a
+   * stash-pop conflict where the dirty state is the operation's own
+   * leftover, not user work).
    */
-  force?: boolean;
+  force?: boolean | UndoForceOptions;
   /** Called before each undo step with a human-readable description. */
   onProgress?: (step: string) => void;
-  /** Optional cancellation signal. Forwarded to every git operation. */
-  signal?: AbortSignal;
 }
 interface ValidateUndoComposeInput {
   git: ComposeGitPort;
   /** The undo ID to validate. */
   undoId: UndoId;
-  /** Optional cancellation signal. Forwarded to every git operation. */
-  signal?: AbortSignal;
 }
 /**
  * Validate whether undoing a compose/split operation can safely proceed.
  *
  * Returns blockers (hard stops) and warnings (notable conditions). Does not
  * mutate the repository. Use this for dry-run checks before {@link undoCompose}.
+ *
+ * Not cancellable — undo work is git-only and runs to completion.
  */
 declare function validateUndoCompose(input: ValidateUndoComposeInput): Promise<UndoValidation>;
 /**
@@ -38,10 +39,14 @@ declare function validateUndoCompose(input: ValidateUndoComposeInput): Promise<U
  * mutations that were recorded. Returns a structured {@link UndoResult}.
  *
  * Safety:
- * - Refuses to proceed when the working directory has uncommitted changes.
+ * - Refuses to proceed when the working directory has uncommitted changes
+ *   unless `force.dirtyWorkdir` is set.
  * - Refuses when a branch created by the operation has been modified since
- *   (unless `force` is set).
+ *   unless `force` is set (or `force.branchHasNewCommits`).
  * - Best-effort on working directory restoration from stash backup.
+ *
+ * Not cancellable — undo runs to completion to avoid leaving the repo in
+ * a half-reversed state.
  */
 declare function undoCompose(input: UndoComposeInput): Promise<UndoResult>;
 /**
@@ -50,7 +55,9 @@ declare function undoCompose(input: UndoComposeInput): Promise<UndoResult>;
  * Returns IDs for all workflows that used the shared undo infrastructure
  * (compose, split, and any future packages). Each ID can be passed to
  * {@link validateUndoCompose} or {@link undoCompose}.
+ *
+ * Not cancellable — git-only operation that runs to completion.
  */
-declare function listUndoIds(git: ComposeGitPort, signal?: AbortSignal): Promise<UndoId[]>;
+declare function listUndoIds(git: ComposeGitPort): Promise<UndoId[]>;
 //#endregion
 export { UndoComposeInput, ValidateUndoComposeInput, listUndoIds, undoCompose, validateUndoCompose };

package/dist/workflows/undo.js

@@ -1 +1 @@
-import{requireExec as e}from"../git/require-exec.js";import{UndoStore as t,undoOperation as n,validateUndo as r}from"@gitkraken/shared-tools";async function i(t){return r({git:e(t.git,`undo validation`),manifestId:t.undoId,signal:t.signal})}async function a(t){return n({git:e(t.git,`undo execution`),manifestId:t.undoId,force:t.force,onProgress:t.onProgress,signal:t.signal})}async function o(n,r){return new t(e(n,`undo listing`)).list({signal:r})}export{o as listUndoIds,a as undoCompose,i as validateUndoCompose};
+import{requireExec as e}from"../git/require-exec.js";import{UndoStore as t,undoOperation as n,validateUndo as r}from"@gitkraken/shared-tools";async function i(t){return r({git:e(t.git,`undo validation`),manifestId:t.undoId})}async function a(t){return n({git:e(t.git,`undo execution`),manifestId:t.undoId,force:t.force,onProgress:t.onProgress})}async function o(n){return new t(e(n,`undo listing`)).list()}export{o as listUndoIds,a as undoCompose,i as validateUndoCompose};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitkraken/compose-tools",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "AI-powered organization of git changes into clean, atomic commits and branches.",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Axosoft, LLC dba GitKraken",
@@ -21,7 +21,7 @@
   ],
   "dependencies": {
     "zod": "^4.3.6",
-    "@gitkraken/shared-tools": "^0.1.0"
+    "@gitkraken/shared-tools": "^0.2.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/dist/cancellation.d.ts

@@ -1,20 +0,0 @@
-//#region src/cancellation.d.ts
-/**
- * Throws a `WorkflowError('CANCELLED')` if the signal has been aborted.
- *
- * Call at workflow phase boundaries so cancellation is observable even when
- * a consumer's adapter doesn't fully respect the signal on every operation.
- * Individual `git.exec` and `model.generate` calls should also receive the
- * signal via their options; this helper is the coarse-grained backstop.
- */
-declare function throwIfCancelled(signal?: AbortSignal): void;
-/**
- * Wraps a native `AbortError` (thrown by a signal-aware adapter) in a
- * `WorkflowError('CANCELLED')`. Rethrows non-cancellation errors unchanged.
- *
- * Use to normalize exceptions from `git.exec` or `model.generate` so consumers
- * only have to check for `WorkflowError` with code `'CANCELLED'`.
- */
-declare function wrapCancellation<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T>;
-//#endregion
-export { throwIfCancelled, wrapCancellation };

package/dist/cancellation.js

@@ -1 +0,0 @@
-import{WorkflowError as e}from"./errors/workflow.js";function t(t){if(t?.aborted)throw new e(`CANCELLED`,t.reason instanceof Error?t.reason.message:`Operation cancelled`)}function n(t,n){return t.catch(t=>{throw r(t)||n?.aborted?new e(`CANCELLED`,t instanceof Error?t.message:`Operation cancelled`,{cause:t}):t})}function r(e){return e instanceof Error&&(e.name===`AbortError`||e.name===`DOMException`)}export{t as throwIfCancelled,n as wrapCancellation};