@gitkraken/compose-tools 0.1.0

package/dist/errors/ai.d.ts

@@ -0,0 +1,10 @@
+//#region src/errors/ai.d.ts
+type AIErrorCode = 'VALIDATION_EXHAUSTED';
+declare class AIError extends Error {
+  readonly code: AIErrorCode;
+  constructor(code: AIErrorCode, message: string, options?: {
+    cause?: unknown;
+  });
+}
+//#endregion
+export { AIError, AIErrorCode };

package/dist/errors/ai.js

@@ -0,0 +1 @@
+var e=class extends Error{code;constructor(e,t,n){super(t,n),this.name=`AIError`,this.code=e}};export{e as AIError};

package/dist/errors/git.d.ts

@@ -0,0 +1,12 @@
+//#region src/errors/git.d.ts
+type GitErrorCode = 'BRANCH_NOT_FOUND' | 'OPERATION_FAILED' | 'SAFETY_CHECK_FAILED' | 'NO_CHANGES' | 'CHERRY_PICK_CONFLICT';
+declare class GitError extends Error {
+  readonly code: GitErrorCode;
+  readonly detail?: Record<string, unknown>;
+  constructor(code: GitErrorCode, message: string, options?: {
+    cause?: unknown;
+    detail?: Record<string, unknown>;
+  });
+}
+//#endregion
+export { GitError, GitErrorCode };

package/dist/errors/git.js

@@ -0,0 +1 @@
+var e=class extends Error{code;detail;constructor(e,t,n){super(t,n),this.name=`GitError`,this.code=e,this.detail=n?.detail}};export{e as GitError};

package/dist/errors/task.d.ts

@@ -0,0 +1,6 @@
+//#region src/errors/task.d.ts
+declare class TaskInputError extends Error {
+  constructor(message: string);
+}
+//#endregion
+export { TaskInputError };

package/dist/errors/task.js

@@ -0,0 +1 @@
+var e=class extends Error{constructor(e){super(e),this.name=`TaskInputError`}};export{e as TaskInputError};

package/dist/errors/workflow.d.ts

@@ -0,0 +1,13 @@
+//#region src/errors/workflow.d.ts
+type WorkflowErrorCode = 'SAFETY_CHECK_FAILED' | 'INTERNAL' | 'CANCELLED';
+declare class WorkflowInputError extends Error {
+  constructor(message: string);
+}
+declare class WorkflowError extends Error {
+  readonly code: WorkflowErrorCode;
+  constructor(code: WorkflowErrorCode, message: string, options?: {
+    cause?: unknown;
+  });
+}
+//#endregion
+export { WorkflowError, WorkflowErrorCode, WorkflowInputError };

package/dist/errors/workflow.js

@@ -0,0 +1 @@
+var e=class extends Error{constructor(e){super(e),this.name=`WorkflowInputError`}},t=class extends Error{code;constructor(e,t,n){super(t,n),this.name=`WorkflowError`,this.code=e}};export{t as WorkflowError,e as WorkflowInputError};

package/dist/git/apply-branches.d.ts

@@ -0,0 +1,28 @@
+import { ComposeGitPort } from "../ports/git.js";
+import { BranchPartition } from "../tasks/types.js";
+
+//#region src/git/apply-branches.d.ts
+interface ApplyBranchStructureParams {
+  git: ComposeGitPort;
+  /** Each entry: a branch name and the SHA it should point at. May include stacked partitions. */
+  branches: ApplyBranchEntry[];
+  originalBranchName?: string;
+  originalBranchSha?: string;
+  signal?: AbortSignal;
+}
+interface ApplyBranchEntry {
+  /** The partition(s) for this branch group. Each partition becomes a git branch. */
+  partitions: BranchPartition[];
+  /** The SHA of the tip commit for the entire branch group (last partition's last commit). */
+  tipSha: string;
+}
+declare function applyBranchStructure(params: ApplyBranchStructureParams): Promise<void>;
+declare function createStackedBranches(params: {
+  git: ComposeGitPort;
+  partitions: BranchPartition[];
+  originalBranchName?: string;
+  originalBranchSha?: string;
+  signal?: AbortSignal;
+}): Promise<void>;
+//#endregion
+export { ApplyBranchEntry, ApplyBranchStructureParams, applyBranchStructure, createStackedBranches };

package/dist/git/apply-branches.js

@@ -0,0 +1 @@
+import{checkout as e,createBranch as t,currentBranch as n,deleteBranch as r}from"./port-dispatch.js";async function i(i){let{git:a,branches:o,originalBranchName:s,originalBranchSha:c,signal:l}=i;if(l?.throwIfAborted(),s&&c){let i=await n(a,{signal:l})===s;i&&await e(a,c,{detach:!0,signal:l}),await r(a,s,{force:!0,signal:l});for(let e of o)for(let n of e.partitions){l?.throwIfAborted();let e=n.commitIds[n.commitIds.length-1];await t(a,n.branchName,e,{signal:l})}if(i&&o.length>0){let t=o[o.length-1],n=t.partitions[t.partitions.length-1];await e(a,n.branchName,{signal:l})}}else for(let e of o)for(let n of e.partitions){l?.throwIfAborted();let e=n.commitIds[n.commitIds.length-1];await t(a,n.branchName,e,{signal:l})}}async function a(e){return i({git:e.git,branches:[{partitions:e.partitions,tipSha:e.partitions[e.partitions.length-1].commitIds[e.partitions[e.partitions.length-1].commitIds.length-1]}],originalBranchName:e.originalBranchName,originalBranchSha:e.originalBranchSha,signal:e.signal})}export{i as applyBranchStructure,a as createStackedBranches};

package/dist/git/apply-target.d.ts

@@ -0,0 +1,39 @@
+import { ComposeGitPort, SigningConfig } from "../ports/git.js";
+import { BranchGroup, BranchPartition, CommitSuggestion, ComposeHunk } from "../tasks/types.js";
+import { PartitionResult } from "../tasks/partition/types.js";
+import { ComposeTarget } from "../workflows/types.js";
+import { ApplyMutations, SafetySnapshot } from "./types.js";
+import { CollectionResult } from "./diff-collector.js";
+
+//#region src/git/apply-target.d.ts
+interface ComposeBranchPlan {
+  branchGroup: BranchGroup;
+  orderedCommitIds: string[];
+  partitioning?: PartitionResult;
+}
+interface ApplyToTargetParams {
+  git: ComposeGitPort;
+  target: ComposeTarget;
+  branchPlans: ComposeBranchPlan[];
+  allOrderedCommits: CommitSuggestion[];
+  hunks: ComposeHunk[];
+  snapshot: SafetySnapshot;
+  collection: CollectionResult;
+  signal?: AbortSignal;
+  signing?: SigningConfig;
+  authorAttribution?: 'plurality' | 'first-hunk' | ((hunks: ComposeHunk[]) => {
+    name: string;
+    email: string;
+  } | undefined);
+}
+interface ApplyToTargetResult {
+  partitions?: BranchPartition[];
+  /** Partitions grouped by independent stack. Each inner array is one stack (root first, tip last). */
+  partitionGroups?: BranchPartition[][];
+  commitShas: Record<string, string>;
+  /** Git mutations performed during apply, for undo manifest construction. */
+  mutations: ApplyMutations;
+}
+declare function applyToTarget(params: ApplyToTargetParams): Promise<ApplyToTargetResult>;
+//#endregion
+export { ApplyToTargetParams, ApplyToTargetResult, ComposeBranchPlan, applyToTarget };

package/dist/git/apply-target.js

@@ -0,0 +1 @@
+import{GitError as e}from"../errors/git.js";import{cleanWorkdir as t,discardWorkdirChanges as n,revParse as r}from"./port-dispatch.js";import{applyBranchStructure as i}from"./apply-branches.js";import{applyCommitChain as a,applyRangeRewrite as o,applyRecompose as s,buildCommitChain as c}from"./commit-chain.js";import{verifyMultiBranchDiff as l,verifyResultingDiff as u}from"./safety.js";async function d(t){let{git:n,target:l,branchPlans:d,allOrderedCommits:m,hunks:h,snapshot:v,collection:y,signal:b,signing:x,authorAttribution:S}=t;if(b?.throwIfAborted(),l.type===`rewrite-range`){if(!y.branchName||!y.branchSha)throw new e(`OPERATION_FAILED`,`rewrite-range target requires a source that records branchName and branchSha (branch or commit-range).`);let{headSha:t,shaMap:r}=await c({git:n,baseSha:l.rangeFrom,commits:m,hunks:h,signal:b,signing:x,authorAttribution:S}),i=await o({git:n,branch:l.branch,rangeFrom:l.rangeFrom,rangeTo:l.rangeTo,newHeadSha:t,originalBranchSha:y.branchSha,preserveSuffix:l.preserveSuffix,signal:b});return{commitShas:Object.fromEntries(r),mutations:{createdBranches:[],deletedBranches:[],movedBranches:[{name:l.branch,previousSha:y.branchSha,newSha:i.finalTipSha}]}}}if(y.branchName&&!y.mergeBaseSha)throw new e(`OPERATION_FAILED`,`Branch source is missing mergeBaseSha — cannot determine base commit`);let C=y.mergeBaseSha??await r(n,`HEAD`,{signal:b});if(l.type===`auto`&&d.length>1)return f(n,C,d,h,v,y,l.preserveOriginal,b,x,S);if(l.type===`auto`&&d.length===1&&d[0].partitioning)return p(n,C,d[0],h,v,y,l.preserveOriginal,b,x,S);let{headSha:w,shaMap:T}=await c({git:n,baseSha:C,commits:m,hunks:h,signal:b,signing:x,authorAttribution:S}),E=Object.fromEntries(T),D=await u(n,C,w,v,b);if(!D.valid)throw new e(`SAFETY_CHECK_FAILED`,`Diff verification failed: ${D.error}`);if(l.type===`branch-replace`){if(!y.branchName||!y.branchSha)throw new e(`OPERATION_FAILED`,`branch-replace target requires a branch source with branchName and branchSha`);return await s({git:n,branchName:y.branchName,newHeadSha:w,originalBranchSha:y.branchSha,signal:b}),{commitShas:E,mutations:{createdBranches:[],deletedBranches:[],movedBranches:[{name:y.branchName,previousSha:y.branchSha,newSha:w}]}}}if(l.type===`branch`)return await a({git:n,newHeadSha:w,branchName:l.name,untrackedIncluded:y.untrackedIncluded,signal:b}),{commitShas:E,mutations:{createdBranches:[{name:l.name,sha:w}],deletedBranches:[],movedBranches:[]}};if(l.type===`auto`){let e=d[0]?.branchGroup.name||y.branchName;if(e){let t=!l.preserveOriginal&&y.branchName&&y.branchSha?{originalBranchName:y.branchName,originalBranchSha:y.branchSha}:{},r={branchName:e,title:d[0]?.branchGroup.title??``,description:d[0]?.branchGroup.description??``,commitIds:m.map(e=>e.id)};await i({git:n,branches:[{partitions:[r],tipSha:w}],...t,signal:b});let a=_([r],E,t.originalBranchName,t.originalBranchSha);return{partitions:[r],commitShas:E,mutations:a}}return await a({git:n,newHeadSha:w,untrackedIncluded:y.untrackedIncluded,signal:b}),{commitShas:E,mutations:g()}}return await a({git:n,newHeadSha:w,untrackedIncluded:y.untrackedIncluded,signal:b}),{commitShas:E,mutations:g()}}async function f(r,a,o,s,u,d,f,p,g,v){let y=[],b=[],x=[],S=[],C={};for(let e of o){p?.throwIfAborted();let t=m(e),{headSha:n,shaMap:i}=await c({git:r,baseSha:a,commits:t,hunks:s,signal:p,signing:g,authorAttribution:v});x.push(n);for(let[e,t]of i)C[e]=t;if(e.partitioning&&e.partitioning.partitions.length>1){let t=h(e.partitioning.partitions,i);y.push(...t),b.push(t),S.push({partitions:t,tipSha:n})}else{let r={branchName:e.branchGroup.name,title:e.branchGroup.title,description:e.branchGroup.description,commitIds:t.map(e=>i.get(e.id)??e.id)};y.push(r),b.push([r]),S.push({partitions:[r],tipSha:n})}}let w=await l(r,a,x,u,p);if(!w.valid)throw new e(`SAFETY_CHECK_FAILED`,`Diff verification failed: ${w.error}`);let T=!f&&d.branchName&&d.branchSha?{originalBranchName:d.branchName,originalBranchSha:d.branchSha}:{};return await i({git:r,branches:S,...T,signal:p}),!d.branchName&&!f&&(await n(r,void 0,{signal:p}),d.untrackedIncluded&&await t(r,{signal:p})),{partitions:y,partitionGroups:b,commitShas:C,mutations:_(y,C,T.originalBranchName,T.originalBranchSha)}}async function p(r,o,s,l,d,f,p,v,y,b){let{headSha:x,shaMap:S}=await c({git:r,baseSha:o,commits:m(s),hunks:l,signal:v,signing:y,authorAttribution:b}),C=await u(r,o,x,d,v);if(!C.valid)throw new e(`SAFETY_CHECK_FAILED`,`Diff verification failed: ${C.error}`);let w=h(s.partitioning.partitions,S),T=Object.fromEntries(S);if(w.length>1){let e=!p&&f.branchName&&f.branchSha?{originalBranchName:f.branchName,originalBranchSha:f.branchSha}:{};return await i({git:r,branches:[{partitions:w,tipSha:x}],...e,signal:v}),!f.branchName&&!p&&(await n(r,void 0,{signal:v}),f.untrackedIncluded&&await t(r,{force:!0,directories:!0,signal:v})),{partitions:w,commitShas:T,mutations:_(w,T,e.originalBranchName,e.originalBranchSha)}}return await a({git:r,newHeadSha:x,untrackedIncluded:f.untrackedIncluded,signal:v}),{partitions:w,commitShas:T,mutations:g()}}function m(t){return t.orderedCommitIds.map(n=>{let r=t.branchGroup.commits.find(e=>e.id===n);if(!r)throw new e(`OPERATION_FAILED`,`Commit ${n} not found in branch '${t.branchGroup.id}'`);return r})}function h(t,n){return t.map(t=>({...t,commitIds:t.commitIds.map(t=>{let r=n.get(t);if(!r)throw new e(`OPERATION_FAILED`,`No SHA found for commit ID '${t}'`);return r})}))}function g(){return{createdBranches:[],deletedBranches:[],movedBranches:[]}}function _(e,t,n,r){let i=e.map(e=>{let n=e.commitIds[e.commitIds.length-1];return{name:e.branchName,sha:t[n]??n}}),a=[];return n&&r&&a.push({name:n,sha:r}),{createdBranches:i,deletedBranches:a,movedBranches:[]}}export{d as applyToTarget};

package/dist/git/commit-chain.d.ts

@@ -0,0 +1,87 @@
+import { ComposeGitPort, SigningConfig } from "../ports/git.js";
+import { CommitSuggestion, ComposeHunk } from "../tasks/types.js";
+
+//#region src/git/commit-chain.d.ts
+type AuthorAttributionStrategy = 'plurality' | 'first-hunk' | ((hunks: ComposeHunk[]) => {
+  name: string;
+  email: string;
+} | undefined);
+interface BuildCommitChainParams {
+  git: ComposeGitPort;
+  baseSha: string;
+  commits: CommitSuggestion[];
+  hunks: ComposeHunk[];
+  signal?: AbortSignal;
+  signing?: SigningConfig;
+  authorAttribution?: AuthorAttributionStrategy;
+}
+interface BuildCommitChainResult {
+  headSha: string;
+  /** Maps each CommitSuggestion.id to the real git SHA created for it */
+  shaMap: Map<string, string>;
+}
+declare function buildCommitChain(params: BuildCommitChainParams): Promise<BuildCommitChainResult>;
+interface ApplyCommitChainParams {
+  git: ComposeGitPort;
+  newHeadSha: string;
+  branchName?: string;
+  /**
+   * Whether untracked files were included in the compose.
+   * When true, untracked files are staged before stashing to avoid
+   * conflicts between stash pop and the newly committed tree.
+   */
+  untrackedIncluded?: boolean;
+  signal?: AbortSignal;
+}
+declare function applyCommitChain(params: ApplyCommitChainParams): Promise<void>;
+interface ApplyRecomposeParams {
+  git: ComposeGitPort;
+  branchName: string;
+  newHeadSha: string;
+  originalBranchSha: string;
+  signal?: AbortSignal;
+}
+declare function applyRecompose(params: ApplyRecomposeParams): Promise<void>;
+interface ApplyRangeRewriteParams {
+  git: ComposeGitPort;
+  /** Branch whose tip will be updated to the result. */
+  branch: string;
+  /** Resolved SHA: parent of the first commit in the rewritten range. */
+  rangeFrom: string;
+  /** Resolved SHA: last commit in the rewritten range. */
+  rangeTo: string;
+  /** Resolved SHA: new tip of the range after the library applied its commit chain on top of `rangeFrom`. */
+  newHeadSha: string;
+  /** Resolved SHA: branch tip before the operation started. */
+  originalBranchSha: string;
+  /** When true (default), cherry-pick commits in `rangeTo..originalBranchSha` onto `newHeadSha`. */
+  preserveSuffix?: boolean;
+  signal?: AbortSignal;
+}
+interface ApplyRangeRewriteResult {
+  /** Final branch tip SHA after range rewrite + (optional) suffix cherry-picks. */
+  finalTipSha: string;
+  /** SHAs that were successfully cherry-picked, in order applied. Empty when preserveSuffix=false or no suffix. */
+  preservedSuffixShas: string[];
+}
+/**
+ * Rewrite a contiguous range of commits on a branch in-place.
+ *
+ * Given that the library has already built a new commit chain on top of
+ * `rangeFrom` (available at `newHeadSha`), this replays any commits that were
+ * after `rangeTo` on the original branch onto the new tip via cherry-pick, so
+ * work done later on the branch is preserved.
+ *
+ * Behavior:
+ *   1. Stash the user's workdir if dirty (restored in the caller via finally).
+ *   2. If `preserveSuffix` (default true) and the range didn't reach the branch
+ *      tip, cherry-pick every commit in `rangeTo..originalBranchSha` onto
+ *      `newHeadSha`. On conflict, abort the cherry-pick and throw
+ *      `GitError('CHERRY_PICK_CONFLICT', …)` — repo state is left safe.
+ *   3. `update-ref` the branch to the final tip.
+ *   4. If the user was on the branch, `reset --hard` to the final tip so their
+ *      checked-out state follows the rewrite.
+ */
+declare function applyRangeRewrite(params: ApplyRangeRewriteParams): Promise<ApplyRangeRewriteResult>;
+//#endregion
+export { ApplyCommitChainParams, ApplyRangeRewriteParams, ApplyRangeRewriteResult, ApplyRecomposeParams, AuthorAttributionStrategy, BuildCommitChainParams, BuildCommitChainResult, applyCommitChain, applyRangeRewrite, applyRecompose, buildCommitChain };

package/dist/git/commit-chain.js

@@ -0,0 +1,6 @@
+import{GitError as e}from"../errors/git.js";import{applyPatchToIndex as t,checkout as n,cherryPick as r,cherryPickAbort as i,commitTree as a,currentBranch as o,listUntracked as s,log as c,readTree as l,reset as u,revParse as d,stageAll as f,stashPop as p,stashPush as m,statusPorcelain as h,updateRef as g,writeTree as _}from"./port-dispatch.js";import{buildPatchForCommit as v}from"./utils/patch-builder.js";import{randomUUID as y}from"node:crypto";import*as b from"node:fs";import*as x from"node:os";import*as S from"node:path";async function C(n){let{git:r,baseSha:i,commits:o,hunks:s,signal:c,signing:u,authorAttribution:d=`plurality`}=n;c?.throwIfAborted();let f=S.join(x.tmpdir(),`compose-idx-${y()}`),p=i,m=new Map,h=new Set;try{for(let n of o){c?.throwIfAborted();let i=n.hunkIndices.map(t=>{let n=s.find(e=>e.index===t);if(!n)throw new e(`OPERATION_FAILED`,`Hunk index ${t} not found`);return n}),o=v(i.map(e=>h.has(e.diffHeader)?{...e,diffHeader:P(e.diffHeader,e.fileName)}:e));if(!o.trim())throw new e(`OPERATION_FAILED`,`Empty patch for commit: ${n.message}`);let g={GIT_INDEX_FILE:f};await l(r,p,{indexEnv:g,signal:c});try{await t(r,o,{indexEnv:g,signal:c})}catch(t){let r=t instanceof Error?t.message:String(t);throw new e(`OPERATION_FAILED`,`git apply failed for commit '${n.message.split(`
+`)[0]}': ${r}`,{cause:t})}for(let e of i)e.originalFileName&&e.diffHeader.includes(`rename from`)&&h.add(e.diffHeader);let y=await _(r,{indexEnv:g,signal:c}),b=A(i,d),x=M(n.message,b.coAuthors),S=await a(r,y,[p],x,{signal:c,signing:u,author:b.author});m.set(n.id,S),p=S}return{headSha:p,shaMap:m}}finally{N(f)}}async function w(e){let{git:t,newHeadSha:r,branchName:i,untrackedIncluded:a,signal:o}=e;o?.throwIfAborted(),a&&await T(t,o);let s=await O(t,o);try{i?await n(t,i,{createBranch:!0,startPoint:r,signal:o}):await u(t,r,`hard`,{signal:o})}catch(e){throw s&&await k(t,o),e}s&&await k(t,o)}async function T(e,t){let n=await s(e,{signal:t});n.length>0&&await f(e,{paths:n,signal:t})}async function E(e){let{git:t,branchName:n,newHeadSha:r,signal:i}=e;if(i?.throwIfAborted(),await g(t,`refs/heads/${n}`,r,{signal:i}),await o(t,{signal:i})===n){let e=await O(t,i);try{await u(t,r,`hard`,{signal:i})}catch(n){throw e&&await k(t,i),n}e&&await k(t,i)}}async function D(t){let{git:a,branch:s,rangeTo:l,newHeadSha:f,originalBranchSha:p,preserveSuffix:m=!0,signal:h}=t;h?.throwIfAborted();let _=await o(a,{signal:h})===s,v=[],y=f;if(m&&l!==p){let t=(await c(a,{format:`%H`,range:`${l}..${p}`,reverse:!0,signal:h})).trim().split(`
+`).filter(Boolean);if(t.length>0){let o=await O(a,h);try{await n(a,f,{detach:!0,signal:h});for(let n of t){h?.throwIfAborted();try{await r(a,n,{signal:h}),v.push(n)}catch(t){throw await i(a,{signal:h}).catch(()=>{}),new e(`CHERRY_PICK_CONFLICT`,`Could not preserve commit ${n.slice(0,8)} after rewriting the range. Cherry-pick aborted; no changes were made to the branch.`,{cause:t,detail:{conflictingCommit:n,successfullyCherryPicked:[...v]}})}}y=await d(a,`HEAD`,{signal:h})}finally{o&&await k(a,h)}}}if(await g(a,`refs/heads/${s}`,y,{signal:h}),_){let e=await O(a,h);try{await n(a,s,{signal:h}),await u(a,y,`hard`,{signal:h})}finally{e&&await k(a,h)}}return{finalTipSha:y,preservedSuffixShas:v}}async function O(e,t){return(await h(e,{signal:t})).trim()?(await m(e,{message:`compose backup`,includeUntracked:!0,signal:t}),!0):!1}async function k(e,t){try{await p(e,{signal:t})}catch{}}function A(e,t){let n=e.filter(e=>e.author!=null);if(n.length===0)return{author:void 0,coAuthors:[]};let r;if(typeof t==`function`)r=t(e);else if(t===`first-hunk`)r=n[0].author;else{let e=new Map;for(let t of n){let n=j(t.author),r=e.get(n);r?r.count++:e.set(n,{identity:t.author,count:1})}let t=0;for(let{identity:n,count:i}of e.values())i>t&&(r=n,t=i)}let i=new Map;for(let t of e){t.author&&i.set(j(t.author),t.author);for(let e of t.coAuthors??[])i.set(j(e),e)}let a=r?j(r):null,o=[];for(let[e,t]of i)e!==a&&o.push(t);return{author:r,coAuthors:o}}function j(e){return`${e.name.toLowerCase()}\0${e.email.toLowerCase()}`}function M(e,t){if(t.length===0)return e;let n=t.map(e=>`Co-authored-by: ${e.name} <${e.email}>`).join(`
+`);return`${e.trimEnd()}\n\n${n}\n`}function N(e){try{b.unlinkSync(e)}catch{}}function P(e,t){let n=e.split(`
+`),r=[];for(let e of n)e.startsWith(`diff --git `)?r.push(`diff --git a/${t} b/${t}`):e.startsWith(`similarity index`)||e.startsWith(`rename from`)||e.startsWith(`rename to`)||(e.startsWith(`--- a/`)?r.push(`--- a/${t}`):r.push(e));return r.join(`
+`)}export{w as applyCommitChain,D as applyRangeRewrite,E as applyRecompose,C as buildCommitChain};

package/dist/git/diff-collector.d.ts

@@ -0,0 +1,80 @@
+import { ComposeGitPort } from "../ports/git.js";
+import { CommitDetail, ComposeHunk } from "../tasks/types.js";
+import { ComposeSource } from "../workflows/types.js";
+import { SafetySnapshot } from "./types.js";
+
+//#region src/git/diff-collector.d.ts
+interface BranchCommitInfo {
+  sha: string;
+  message: string;
+}
+interface WorkingDiffResult {
+  hunks: ComposeHunk[];
+  snapshot: SafetySnapshot;
+  combinedDiff: string;
+}
+interface BranchDiffResult {
+  hunks: ComposeHunk[];
+  commits: BranchCommitInfo[];
+  snapshot: SafetySnapshot;
+  combinedDiff: string;
+}
+interface SplitCollectionResult {
+  commits: CommitDetail[];
+  mergeBaseSha: string;
+  branchSha: string;
+}
+interface CollectionResult {
+  hunks: ComposeHunk[];
+  snapshot: SafetySnapshot;
+  combinedDiff: string;
+  commitMessages?: string[];
+  commitOrder?: string[];
+  branchName?: string;
+  baseBranch?: string;
+  branchSha?: string;
+  mergeBaseSha?: string;
+  untrackedIncluded: boolean;
+}
+interface CollectOptions {
+  signal?: AbortSignal;
+}
+declare function collectFromSource(git: ComposeGitPort, source: ComposeSource, options?: CollectOptions): Promise<CollectionResult>;
+interface WorkingDiffOptions {
+  includeUnstaged: boolean;
+  includeUntracked: boolean;
+}
+declare function collectWorkingDiffs(git: ComposeGitPort, options: WorkingDiffOptions, signal?: AbortSignal): Promise<WorkingDiffResult>;
+declare function collectBranchDiffs(git: ComposeGitPort, branchName: string, baseBranch: string, signal?: AbortSignal): Promise<BranchDiffResult>;
+/**
+ * Collect hunks from a contiguous range of commits on a branch, tagging each
+ * hunk with the author of the commit that introduced it.
+ *
+ * `from` is exclusive, `to` is inclusive — so single-commit recompose is
+ * `from = parent(sha), to = sha`. The returned `combinedDiff` is the
+ * tree-to-tree diff `from..to`; per-commit patches are re-parsed to get author
+ * attribution, then the hunks from those per-commit parses are what's returned
+ * (ordered by commit, then by file/hunk within each commit).
+ *
+ * The snapshot records `branchSha = to` and `baseSha = from` so the apply
+ * phase can re-verify the range state hasn't drifted.
+ */
+declare function collectCommitRangeDiffs(git: ComposeGitPort, branchName: string, from: string, to: string, signal?: AbortSignal): Promise<BranchDiffResult>;
+declare function collectCommitsForSplit(git: ComposeGitPort, branchName: string, baseBranch: string, signal?: AbortSignal): Promise<SplitCollectionResult>;
+/**
+ * Compute per-source content hashes alongside the authoritative combined hash.
+ *
+ * Stored on {@link SafetySnapshot.sourceHashes} for diagnostic purposes — when
+ * a combined-hash verify fails, the library compares per-source hashes against
+ * the current state to tell the consumer which subset drifted.
+ *
+ * Currently uses `git.exec` directly (cheap, diagnostic-only). Consumers
+ * without `exec` don't get per-source hashes — they still get the combined
+ * verify path with a generic error message.
+ */
+declare function collectSourceHashes(git: ComposeGitPort, options: {
+  includeUnstaged: boolean;
+  includeUntracked: boolean;
+}, signal?: AbortSignal): Promise<SafetySnapshot['sourceHashes']>;
+//#endregion
+export { BranchCommitInfo, BranchDiffResult, CollectOptions, CollectionResult, SplitCollectionResult, WorkingDiffOptions, WorkingDiffResult, collectBranchDiffs, collectCommitRangeDiffs, collectCommitsForSplit, collectFromSource, collectSourceHashes, collectWorkingDiffs };

package/dist/git/diff-collector.js

@@ -0,0 +1,8 @@
+import{GitError as e}from"../errors/git.js";import{createBranch as t,diffTree as n,gitDir as r,log as i,mergeBase as a,revParse as o,revParseVerify as s,stageAll as c,writeTree as l}from"./port-dispatch.js";import{sha256 as u}from"./utils/crypto.js";import{parseUnifiedDiff as d}from"./utils/hunk-parser.js";import{withUntrackedInTempIndex as f}from"./utils/temp-index.js";import{randomUUID as p}from"node:crypto";import{copyFileSync as m,unlinkSync as h}from"node:fs";import{tmpdir as g}from"node:os";import{join as _}from"node:path";async function v(e,t,n){let{signal:r}=n??{};if(r?.throwIfAborted(),t.type===`workdir`){let n=!t.stagedOnly&&!t.noUntracked;return{...await y(e,{includeUnstaged:!t.stagedOnly,includeUntracked:n},r),untrackedIncluded:n}}if(t.type===`commit-range`){let n=await T(e,t.branch,t.from,t.to,r);return{hunks:n.hunks,snapshot:n.snapshot,combinedDiff:n.combinedDiff,commitMessages:n.commits.map(e=>e.message),commitOrder:n.commits.map(e=>e.sha),branchName:t.branch,baseBranch:void 0,branchSha:n.snapshot.branchSha,mergeBaseSha:n.snapshot.baseSha,untrackedIncluded:!1}}let i=t.mergeTarget??`main`,a=await w(e,t.name,i,r);return{hunks:a.hunks,snapshot:a.snapshot,combinedDiff:a.combinedDiff,commitMessages:a.commits.map(e=>e.message),commitOrder:a.commits.map(e=>e.sha),branchName:t.name,baseBranch:i,branchSha:a.snapshot.branchSha,mergeBaseSha:a.snapshot.baseSha,untrackedIncluded:!1}}async function y(e,t,n){let r=t.includeUnstaged||t.includeUntracked;return t.includeUntracked?S(e,r,n):b(e,r,n)}async function b(e,t,n){let r=await o(e,`HEAD`,{signal:n}),i=await x(e,r,t,n);return{hunks:d(i,`staged`),snapshot:k(i,r,void 0,void 0,await A(e,{includeUnstaged:t,includeUntracked:!1},n)),combinedDiff:i}}async function x(e,t,i,a){if(!i)return n(e,t,await l(e,{signal:a}),{signal:a});let o=_(await r(e,{signal:a}),`index`),s=_(g(),`compose-snapshot-idx-${p()}`);try{m(o,s);let r={GIT_INDEX_FILE:s};return await c(e,{trackedOnly:!0,indexEnv:r,signal:a}),n(e,t,await l(e,{indexEnv:r,signal:a}),{signal:a})}finally{try{h(s)}catch{}}}async function S(e,t,r){return f(e,async i=>{await C(e,i,t,r);let a=await l(e,{indexEnv:i,signal:r}),s=await o(e,`HEAD`,{signal:r}),c=await n(e,s,a,{signal:r});return{hunks:d(c,`staged`),snapshot:k(c,s,void 0,void 0,await A(e,{includeUnstaged:t,includeUntracked:!0},r)),combinedDiff:c}},r)}async function C(e,t,n,r){n&&await c(e,{trackedOnly:!0,indexEnv:t,signal:r}),await c(e,{indexEnv:t,signal:r})}async function w(e,t,r,s){let c=await O(e,t,s),l=await a(e,await O(e,r,s),c,{signal:s}),u=await o(e,c,{signal:s}),f=await n(e,l,c,{signal:s});return{hunks:d(f,`branch`),commits:j(await i(e,{format:`%H%n%s%n---END---`,range:`${l}..${c}`,signal:s})),snapshot:k(f,await o(e,`HEAD`,{signal:s}),u,l),combinedDiff:f}}async function T(t,r,a,s,c){await O(t,r,c);let l=await o(t,a,{signal:c}),u=await o(t,s,{signal:c}),f=E(await i(t,{format:`%H%n%an%n%ae%n%aI%n%B%n---COMMIT-END---`,range:`${l}..${u}`,reverse:!0,signal:c}));if(f.length===0)throw new e(`NO_CHANGES`,`No commits in range '${a}..${s}' on branch '${r}'.`);let p=[],m=0;for(let e of f){c?.throwIfAborted();let r=d(await n(t,`${e.sha}^`,e.sha,{signal:c}),`branch`,m);for(let t of r)t.sourceCommitSha=e.sha,t.author={name:e.authorName,email:e.authorEmail,date:e.authorDate};p.push(...r),m+=r.length}let h=await n(t,l,u,{signal:c}),g=k(h,await o(t,`HEAD`,{signal:c}),u,l);return{hunks:p,commits:f.map(e=>({sha:e.sha,message:e.message})),snapshot:g,combinedDiff:h}}function E(e){let t=[],n=e.split(`---COMMIT-END---`).filter(e=>e.trim());for(let e of n){let n=e.replace(/^\n+/,``).split(`
+`);if(n.length<5)continue;let r=n[0],i=n[1],a=n[2],o=n[3],s=n.slice(4).join(`
+`).trimEnd(),c=o?new Date(o):void 0,l=c&&!Number.isNaN(c.getTime())?c:void 0;t.push({sha:r,authorName:i,authorEmail:a,authorDate:l,message:s})}return t}async function D(e,t,r,s){let c=await O(e,t,s),l=await a(e,await O(e,r,s),c,{signal:s}),u=await o(e,c,{signal:s}),d=(await i(e,{format:`%H`,range:`${l}..${c}`,reverse:!0,signal:s})).trim().split(`
+`).filter(Boolean),f=[];for(let t of d){s?.throwIfAborted();let[r,a,o]=await Promise.all([i(e,{format:`%B`,sha:t,signal:s}).then(e=>e.trim()),n(e,`${t}^`,t,{signal:s}),n(e,`${t}^`,t,{binary:!1,nameOnly:!0,signal:s})]),c=o.trim().split(`
+`).filter(Boolean);f.push({sha:t,message:r,diff:a,filesChanged:c})}return{commits:f,mergeBaseSha:l,branchSha:u}}async function O(n,r,i){if(await s(n,`refs/heads/${r}`,{signal:i})||await s(n,r,{signal:i}))return r;if(await s(n,`origin/${r}`,{signal:i}))return await t(n,r,`origin/${r}`,{signal:i}),r;throw new e(`BRANCH_NOT_FOUND`,`Branch '${r}' not found locally or on origin. Run 'git fetch' if the branch exists on the remote.`)}function k(e,t,n,r,i){return{diffHash:u(e),headSha:t,branchSha:n,baseSha:r,sourceHashes:i}}async function A(e,t,n){if(!e.exec)return;let r={};try{r.staged=u(await e.exec([`diff`,`--cached`,`--binary`,`HEAD`],{signal:n}))}catch{}if(t.includeUnstaged)try{r.unstaged=u(await e.exec([`diff`,`--binary`],{signal:n}))}catch{}if(t.includeUntracked)try{let t=(await e.exec([`ls-files`,`--others`,`--exclude-standard`],{signal:n})).trim().split(`
+`).filter(Boolean);if(t.length>0){let i=[];for(let r of t){n?.throwIfAborted();try{let t=await e.exec([`hash-object`,`--`,r],{signal:n});i.push(`${r}:${t.trim()}`)}catch{}}r.untracked=u(i.join(`
+`))}else r.untracked=u(``)}catch{}return Object.keys(r).length>0?r:void 0}function j(e){let t=[],n=e.split(`---END---`).filter(e=>e.trim());for(let e of n){let n=e.trim().split(`
+`);n.length>=2&&t.push({sha:n[0],message:n[1]})}return t}export{w as collectBranchDiffs,T as collectCommitRangeDiffs,D as collectCommitsForSplit,v as collectFromSource,A as collectSourceHashes,y as collectWorkingDiffs};

package/dist/git/index.d.ts

@@ -0,0 +1,7 @@
+import { ApplyBranchEntry, ApplyBranchStructureParams, applyBranchStructure, createStackedBranches } from "./apply-branches.js";
+import { SafetySnapshot } from "./types.js";
+import { BranchCommitInfo, BranchDiffResult, CollectionResult, SplitCollectionResult, WorkingDiffOptions, WorkingDiffResult, collectBranchDiffs, collectCommitsForSplit, collectFromSource, collectWorkingDiffs } from "./diff-collector.js";
+import { ApplyToTargetParams, ApplyToTargetResult, ComposeBranchPlan, applyToTarget } from "./apply-target.js";
+import { ApplyCommitChainParams, ApplyRecomposeParams, BuildCommitChainParams, BuildCommitChainResult, applyCommitChain, applyRecompose, buildCommitChain } from "./commit-chain.js";
+import { verifyMultiBranchDiff, verifyResultingDiff, verifySnapshot } from "./safety.js";
+export { type ApplyBranchEntry, type ApplyBranchStructureParams, type ApplyCommitChainParams, type ApplyRecomposeParams, type ApplyToTargetParams, type ApplyToTargetResult, type BranchCommitInfo, type BranchDiffResult, type BuildCommitChainParams, type BuildCommitChainResult, type CollectionResult, type ComposeBranchPlan, type SafetySnapshot, type SplitCollectionResult, type WorkingDiffOptions, type WorkingDiffResult, applyBranchStructure, applyCommitChain, applyRecompose, applyToTarget, buildCommitChain, collectBranchDiffs, collectCommitsForSplit, collectFromSource, collectWorkingDiffs, createStackedBranches, verifyMultiBranchDiff, verifyResultingDiff, verifySnapshot };

package/dist/git/index.js

@@ -0,0 +1 @@
+import{applyBranchStructure as e,createStackedBranches as t}from"./apply-branches.js";import{applyCommitChain as n,applyRecompose as r,buildCommitChain as i}from"./commit-chain.js";import{collectBranchDiffs as a,collectCommitsForSplit as o,collectFromSource as s,collectWorkingDiffs as c}from"./diff-collector.js";import{verifyMultiBranchDiff as l,verifyResultingDiff as u,verifySnapshot as d}from"./safety.js";import{applyToTarget as f}from"./apply-target.js";export{e as applyBranchStructure,n as applyCommitChain,r as applyRecompose,f as applyToTarget,i as buildCommitChain,a as collectBranchDiffs,o as collectCommitsForSplit,s as collectFromSource,c as collectWorkingDiffs,t as createStackedBranches,l as verifyMultiBranchDiff,u as verifyResultingDiff,d as verifySnapshot};

package/dist/git/port-dispatch.d.ts

@@ -0,0 +1,34 @@
+import { ApplyPatchOptions, CheckoutOptions, CleanOptions, CommitTreeOptions, ComposeGitPort, DeleteBranchOptions, DiffTreeOptions, ForEachRefOptions, IndexScopedOptions, LogOptions, OpOptions, StageAllOptions, StashPushOptions, UpdateRefOptions } from "../ports/git.js";
+
+//#region src/git/port-dispatch.d.ts
+declare function revParse(git: ComposeGitPort, ref: string, opts?: OpOptions): Promise<string>;
+declare function revParseVerify(git: ComposeGitPort, ref: string, opts?: OpOptions): Promise<string | null>;
+declare function gitDir(git: ComposeGitPort, opts?: OpOptions): Promise<string>;
+declare function currentBranch(git: ComposeGitPort, opts?: OpOptions): Promise<string | null>;
+declare function mergeBase(git: ComposeGitPort, a: string, b: string, opts?: OpOptions): Promise<string>;
+declare function diffTree(git: ComposeGitPort, from: string, to: string, opts?: DiffTreeOptions): Promise<string>;
+declare function log(git: ComposeGitPort, opts: LogOptions): Promise<string>;
+declare function forEachRef(git: ComposeGitPort, opts: ForEachRefOptions): Promise<string>;
+declare function writeTree(git: ComposeGitPort, opts?: IndexScopedOptions): Promise<string>;
+declare function readTree(git: ComposeGitPort, sha: string, opts?: IndexScopedOptions): Promise<void>;
+declare function stageAll(git: ComposeGitPort, opts?: StageAllOptions): Promise<void>;
+declare function statusPorcelain(git: ComposeGitPort, opts?: OpOptions): Promise<string>;
+declare function listUntracked(git: ComposeGitPort, opts?: OpOptions): Promise<string[]>;
+declare function showFile(git: ComposeGitPort, ref: string, path: string, opts?: OpOptions): Promise<string>;
+declare function getConfig(git: ComposeGitPort, key: string, opts?: OpOptions): Promise<string | null>;
+declare function commitTree(git: ComposeGitPort, tree: string, parents: string[], message: string, opts?: CommitTreeOptions): Promise<string>;
+declare function applyPatchToIndex(git: ComposeGitPort, patch: string, opts?: ApplyPatchOptions): Promise<void>;
+declare function mergeTree(git: ComposeGitPort, a: string, b: string, opts?: OpOptions): Promise<string>;
+declare function createBranch(git: ComposeGitPort, name: string, startPoint: string, opts?: OpOptions): Promise<void>;
+declare function deleteBranch(git: ComposeGitPort, name: string, opts?: DeleteBranchOptions): Promise<void>;
+declare function updateRef(git: ComposeGitPort, ref: string, sha: string, opts?: UpdateRefOptions): Promise<void>;
+declare function checkout(git: ComposeGitPort, ref: string, opts?: CheckoutOptions): Promise<void>;
+declare function reset(git: ComposeGitPort, ref: string, mode: 'soft' | 'mixed' | 'hard', opts?: OpOptions): Promise<void>;
+declare function cleanWorkdir(git: ComposeGitPort, opts?: CleanOptions): Promise<void>;
+declare function discardWorkdirChanges(git: ComposeGitPort, paths?: string[], opts?: OpOptions): Promise<void>;
+declare function stashPush(git: ComposeGitPort, opts?: StashPushOptions): Promise<void>;
+declare function stashPop(git: ComposeGitPort, opts?: OpOptions): Promise<void>;
+declare function cherryPick(git: ComposeGitPort, sha: string, opts?: OpOptions): Promise<void>;
+declare function cherryPickAbort(git: ComposeGitPort, opts?: OpOptions): Promise<void>;
+//#endregion
+export { applyPatchToIndex, checkout, cherryPick, cherryPickAbort, cleanWorkdir, commitTree, createBranch, currentBranch, deleteBranch, diffTree, discardWorkdirChanges, forEachRef, getConfig, gitDir, listUntracked, log, mergeBase, mergeTree, readTree, reset, revParse, revParseVerify, showFile, stageAll, stashPop, stashPush, statusPorcelain, updateRef, writeTree };

package/dist/git/port-dispatch.js

@@ -0,0 +1,3 @@
+import{ComposeGitPortMissingOpError as e}from"../ports/git.js";function t(t,n){throw new e(t,n)}async function n(e,n,r){return e.revParse?e.revParse(n,r):e.exec?(await e.exec([`rev-parse`,n],{signal:r?.signal})).trim():t(`revParse`)}async function r(e,n,r){if(e.revParseVerify)return e.revParseVerify(n,r);if(e.exec)try{return(await e.exec([`rev-parse`,`--verify`,n],{signal:r?.signal})).trim()}catch{return null}return t(`revParseVerify`)}async function i(e,n){return e.gitDir?e.gitDir(n):e.exec?(await e.exec([`rev-parse`,`--absolute-git-dir`],{signal:n?.signal})).trim():t(`gitDir`)}async function a(e,n){if(e.currentBranch)return e.currentBranch(n);if(e.exec)try{return(await e.exec([`symbolic-ref`,`--short`,`HEAD`],{signal:n?.signal})).trim()||null}catch{return null}return t(`currentBranch`)}async function o(e,n,r,i){return e.mergeBase?e.mergeBase(n,r,i):e.exec?(await e.exec([`merge-base`,n,r],{signal:i?.signal})).trim():t(`mergeBase`)}async function s(e,n,r,i){if(e.diffTree)return e.diffTree(n,r,i);if(e.exec){let t=[`diff`];return i?.binary!==!1&&t.push(`--binary`),i?.nameOnly&&t.push(`--name-only`),t.push(n,r),e.exec(t,{signal:i?.signal})}return t(`diffTree`)}async function c(e,n){if(e.log)return e.log(n);if(e.exec){let t=[`log`,`--format=${n.format}`];return n.noMerges&&t.push(`--no-merges`),n.reverse&&t.push(`--reverse`),n.limit!=null&&t.push(`-n`,String(n.limit)),n.author&&t.push(`--author=${n.author}`),n.sha?t.push(`-1`,n.sha):n.range&&t.push(n.range),e.exec(t,{signal:n.signal})}return t(`log`)}async function l(e,n){if(e.forEachRef)return e.forEachRef(n);if(e.exec){let t=[`for-each-ref`,`--format=${n.format}`];return n.sort&&t.push(`--sort=${n.sort}`),n.prefix&&t.push(n.prefix),n.limit!=null&&t.push(`--count=${n.limit}`),e.exec(t,{signal:n.signal})}return t(`forEachRef`)}async function u(e,n){return e.writeTree?e.writeTree(n):e.exec?(await e.exec([`write-tree`],{env:n?.indexEnv,signal:n?.signal})).trim():t(`writeTree`)}async function d(e,n,r){if(e.readTree)return e.readTree(n,r);if(e.exec){await e.exec([`read-tree`,n],{env:r?.indexEnv,signal:r?.signal});return}return t(`readTree`)}async function f(e,n){if(e.stageAll)return e.stageAll(n);if(e.exec){let t=[`add`];n?.intentToAdd?t.push(`-N`):n?.trackedOnly?t.push(`-u`):n?.paths||t.push(`-A`),n?.paths&&t.push(`--`,...n.paths),await e.exec(t,{env:n?.indexEnv,signal:n?.signal});return}return t(`stageAll`)}async function p(e,n){return e.statusPorcelain?e.statusPorcelain(n):e.exec?e.exec([`status`,`--porcelain`],{signal:n?.signal}):t(`statusPorcelain`)}async function m(e,n){return e.listUntracked?e.listUntracked(n):e.exec?(await e.exec([`ls-files`,`--others`,`--exclude-standard`],{signal:n?.signal})).trim().split(`
+`).filter(Boolean):t(`listUntracked`)}async function h(e,n,r,i){return e.showFile?e.showFile(n,r,i):e.exec?e.exec([`show`,`${n}:${r}`],{signal:i?.signal}):t(`showFile`)}async function g(e,n,r){if(e.getConfig)return e.getConfig(n,r);if(e.exec)try{return(await e.exec([`config`,n],{signal:r?.signal})).trim()||null}catch{return null}return t(`getConfig`)}async function _(e,n,r,i,a){if(e.commitTree)return e.commitTree(n,r,i,a);if(e.exec){let t=[`commit-tree`,n];for(let e of r)t.push(`-p`,e);t.push(`-m`,i),a?.signing?.enabled&&t.push(a.signing.signingKey?`-S${a.signing.signingKey}`:`-S`);let o={};return a?.author&&(o.GIT_AUTHOR_NAME=a.author.name,o.GIT_AUTHOR_EMAIL=a.author.email,o.GIT_COMMITTER_NAME=a.author.name,o.GIT_COMMITTER_EMAIL=a.author.email,a.author.date&&(o.GIT_AUTHOR_DATE=a.author.date.toISOString())),a?.signing?.gpgProgram&&(o.GIT_GPG_PROGRAM=a.signing.gpgProgram),(await e.exec(t,{env:Object.keys(o).length?o:void 0,signal:a?.signal})).trim()}return t(`commitTree`)}async function v(e,n,r){if(e.applyPatchToIndex)return e.applyPatchToIndex(n,r);if(e.exec){let t=[`apply`,`--cached`];r?.allowBinaryReplacement!==!1&&t.push(`--allow-binary-replacement`),await e.exec(t,{env:r?.indexEnv,stdin:n,signal:r?.signal});return}return t(`applyPatchToIndex`)}async function y(e,n,r,i){return e.mergeTree?e.mergeTree(n,r,i):e.exec?(await e.exec([`merge-tree`,`--write-tree`,n,r],{signal:i?.signal})).trim().split(`
+`)[0]:t(`mergeTree`)}async function b(e,n,r,i){if(e.createBranch)return e.createBranch(n,r,i);if(e.exec){await e.exec([`branch`,n,r],{signal:i?.signal});return}return t(`createBranch`)}async function x(e,n,r){if(e.deleteBranch)return e.deleteBranch(n,r);if(e.exec){await e.exec([`branch`,r?.force?`-D`:`-d`,n],{signal:r?.signal});return}return t(`deleteBranch`)}async function S(e,n,r,i){if(e.updateRef)return e.updateRef(n,r,i);if(e.exec){if(i?.remove){await e.exec([`update-ref`,`-d`,n],{signal:i?.signal});return}let t=[`update-ref`,n,r];i?.previousSha&&t.push(i.previousSha),await e.exec(t,{signal:i?.signal});return}return t(`updateRef`)}async function C(e,n,r){if(e.checkout)return e.checkout(n,r);if(e.exec){let t=[`checkout`];r?.createBranch&&t.push(`-b`),r?.detach&&t.push(`--detach`),t.push(n),r?.createBranch&&r?.startPoint&&t.push(r.startPoint),await e.exec(t,{signal:r?.signal});return}return t(`checkout`)}async function w(e,n,r,i){if(e.reset)return e.reset(n,r,i);if(e.exec){await e.exec([`reset`,`--${r}`,n],{signal:i?.signal});return}return t(`reset`)}async function T(e,n){if(e.cleanWorkdir)return e.cleanWorkdir(n);if(e.exec){let t=`-`;n?.force!==!1&&(t+=`f`),n?.directories!==!1&&(t+=`d`),t===`-`&&(t=`-fd`),await e.exec([`clean`,t],{signal:n?.signal});return}return t(`cleanWorkdir`)}async function E(e,n,r){if(e.discardWorkdirChanges)return e.discardWorkdirChanges(n,r);if(e.exec){let t=[`checkout`,`--`,...n?.length?n:[`.`]];await e.exec(t,{signal:r?.signal});return}return t(`discardWorkdirChanges`)}async function D(e,n){if(e.stashPush)return e.stashPush(n);if(e.exec){let t=[`stash`,`push`];n?.includeUntracked&&t.push(`--include-untracked`),n?.message&&t.push(`-m`,n.message),await e.exec(t,{signal:n?.signal});return}return t(`stashPush`)}async function O(e,n){if(e.stashPop)return e.stashPop(n);if(e.exec){await e.exec([`stash`,`pop`],{signal:n?.signal});return}return t(`stashPop`)}async function k(e,n,r){if(e.cherryPick)return e.cherryPick(n,r);if(e.exec){await e.exec([`cherry-pick`,n],{signal:r?.signal});return}return t(`cherryPick`)}async function A(e,n){if(e.cherryPickAbort)return e.cherryPickAbort(n);if(e.exec){await e.exec([`cherry-pick`,`--abort`],{signal:n?.signal});return}return t(`cherryPickAbort`)}export{v as applyPatchToIndex,C as checkout,k as cherryPick,A as cherryPickAbort,T as cleanWorkdir,_ as commitTree,b as createBranch,a as currentBranch,x as deleteBranch,s as diffTree,E as discardWorkdirChanges,l as forEachRef,g as getConfig,i as gitDir,m as listUntracked,c as log,o as mergeBase,y as mergeTree,d as readTree,w as reset,n as revParse,r as revParseVerify,h as showFile,f as stageAll,O as stashPop,D as stashPush,p as statusPorcelain,S as updateRef,u as writeTree};

package/dist/git/require-exec.d.ts

@@ -0,0 +1,17 @@
+import { ComposeGitPort } from "../ports/git.js";
+import { GitPort } from "@gitkraken/shared-tools";
+
+//#region src/git/require-exec.d.ts
+/**
+ * Extract an exec-shaped `GitPort` from a `ComposeGitPort`, throwing a workflow
+ * error when `exec` is absent.
+ *
+ * The shared undo infrastructure (`UndoStore`, `undoOperation`, `validateUndo`,
+ * `capturePreOperationState`) still speaks raw exec. Flows that need to hand
+ * off to them funnel through this helper. A future refactor can switch those
+ * flows to named ops; until then, consumers that want undo support must
+ * provide exec.
+ */
+declare function requireExec(git: ComposeGitPort, feature: string): GitPort;
+//#endregion
+export { requireExec };

package/dist/git/require-exec.js

@@ -0,0 +1 @@
+import{WorkflowError as e}from"../errors/workflow.js";function t(t,n){if(!t.exec)throw new e(`INTERNAL`,`${n} requires 'exec' on the ComposeGitPort. Provide an exec implementation, or upgrade to a library version that routes this via high-level ops.`);return{exec:t.exec}}export{t as requireExec};

package/dist/git/safety.d.ts

@@ -0,0 +1,22 @@
+import { ComposeGitPort } from "../ports/git.js";
+import { SafetySnapshot } from "./types.js";
+
+//#region src/git/safety.d.ts
+declare function verifySnapshot(git: ComposeGitPort, snapshot: SafetySnapshot, options: {
+  includeUnstaged: boolean;
+  includeUntracked: boolean;
+  signal?: AbortSignal;
+}): Promise<{
+  valid: boolean;
+  error?: string;
+}>;
+declare function verifyResultingDiff(git: ComposeGitPort, baseSha: string, newHeadSha: string, snapshot: SafetySnapshot, signal?: AbortSignal): Promise<{
+  valid: boolean;
+  error?: string;
+}>;
+declare function verifyMultiBranchDiff(git: ComposeGitPort, baseSha: string, branchHeadShas: string[], snapshot: SafetySnapshot, signal?: AbortSignal): Promise<{
+  valid: boolean;
+  error?: string;
+}>;
+//#endregion
+export { verifyMultiBranchDiff, verifyResultingDiff, verifySnapshot };

package/dist/git/safety.js

@@ -0,0 +1 @@
+import{commitTree as e,diffTree as t,gitDir as n,mergeTree as r,revParse as i,stageAll as a,writeTree as o}from"./port-dispatch.js";import{sha256 as s}from"./utils/crypto.js";import{withUntrackedInTempIndex as c}from"./utils/temp-index.js";import{collectSourceHashes as l}from"./diff-collector.js";import{randomUUID as u}from"node:crypto";import{copyFileSync as d,unlinkSync as f}from"node:fs";import{tmpdir as p}from"node:os";import{join as m}from"node:path";async function h(e,t,n){let{signal:r}=n;return r?.throwIfAborted(),t.branchSha&&t.baseSha?y(e,t,r):g(e,t,n)}async function g(e,n,r){let{signal:l}=r,u=await i(e,`HEAD`,{signal:l});if(u!==n.headSha)return{valid:!1,error:`HEAD changed from ${n.headSha} to ${u}`};let d;if(d=r.includeUntracked?await c(e,async n=>(r.includeUnstaged&&await a(e,{trackedOnly:!0,indexEnv:n,signal:l}),await a(e,{indexEnv:n,signal:l}),t(e,u,await o(e,{indexEnv:n,signal:l}),{signal:l})),l):r.includeUnstaged?await v(e,u,l):await t(e,u,await o(e,{signal:l}),{signal:l}),s(d)!==n.diffHash){let t=await _(e,n,r);return t.length>0?{valid:!1,error:`Working directory ${t.join(` and `)} ${t.length===1?`has`:`have`} changed since the AI analysis`}:{valid:!1,error:`Working directory changes have been modified since the AI analysis`}}return{valid:!0}}async function _(e,t,n){if(!t.sourceHashes)return[];let r=await l(e,{includeUnstaged:n.includeUnstaged,includeUntracked:n.includeUntracked},n.signal);if(!r)return[];let i=[];return t.sourceHashes.staged!=null&&r.staged!==t.sourceHashes.staged&&i.push(`staged changes`),t.sourceHashes.unstaged!=null&&r.unstaged!==t.sourceHashes.unstaged&&i.push(`unstaged changes`),t.sourceHashes.untracked!=null&&r.untracked!==t.sourceHashes.untracked&&i.push(`untracked files`),i}async function v(e,r,i){let s=m(await n(e,{signal:i}),`index`),c=m(p(),`compose-verify-idx-${u()}`);try{d(s,c);let n={GIT_INDEX_FILE:c};return await a(e,{trackedOnly:!0,indexEnv:n,signal:i}),t(e,r,await o(e,{indexEnv:n,signal:i}),{signal:i})}finally{try{f(c)}catch{}}}async function y(e,n,r){return await i(e,n.branchSha,{signal:r})===n.branchSha?s(await t(e,n.baseSha,n.branchSha,{signal:r}))===n.diffHash?{valid:!0}:{valid:!1,error:`Branch diff has changed since the AI analysis`}:{valid:!1,error:`Branch has been modified since the AI analysis`}}async function b(e,n,r,i,a){return s(await t(e,n,r,{signal:a}))===i.diffHash?{valid:!0}:{valid:!1,error:`Output diff does not match input — the commit chain does not reproduce the original changes`}}async function x(n,i,a,o,c){if(a.length===1)return b(n,i,a[0],o,c);let l=a[0];for(let t=1;t<a.length;t++)c?.throwIfAborted(),l=await e(n,await r(n,l,a[t],{signal:c}),[l,a[t]],`verify merge`,{signal:c});return s(await t(n,i,l,{signal:c}))===o.diffHash?{valid:!0}:{valid:!1,error:`Combined diff of all branches does not match the original changes`}}export{x as verifyMultiBranchDiff,b as verifyResultingDiff,h as verifySnapshot};

package/dist/git/types.d.ts

@@ -0,0 +1,43 @@
+//#region src/git/types.d.ts
+/**
+ * Hash-based fingerprint of the diff at the start of an AI-driven compose pass.
+ *
+ * Captured during collection and re-checked at apply time to ensure the working
+ * tree (or branch state) hasn't drifted between when the AI saw the diff and
+ * when commits are written. Distinct from undo manifests, which record what
+ * was changed for rollback purposes.
+ *
+ * `diffHash` is the authoritative combined hash. `sourceHashes` additionally
+ * stores per-source fingerprints for workdir sources so verification failures
+ * can report which subset drifted.
+ */
+interface SafetySnapshot {
+  diffHash: string;
+  headSha: string;
+  branchSha?: string;
+  baseSha?: string;
+  /** Per-source content hashes. Populated for workdir source; undefined for branch. */
+  sourceHashes?: {
+    /** Hash of `git diff --cached` output (HEAD to index). */staged?: string; /** Hash of `git diff` output (index to working tree, tracked files only). */
+    unstaged?: string; /** Hash of synthesized diff for untracked files (or null if none). */
+    untracked?: string;
+  };
+}
+/** Tracks the git mutations performed during an apply phase, for undo manifest construction. */
+interface ApplyMutations {
+  createdBranches: {
+    name: string;
+    sha: string;
+  }[];
+  deletedBranches: {
+    name: string;
+    sha: string;
+  }[];
+  movedBranches: {
+    name: string;
+    previousSha: string;
+    newSha: string;
+  }[];
+}
+//#endregion
+export { ApplyMutations, SafetySnapshot };

package/dist/git/types.js

@@ -0,0 +1 @@
+export{};

package/dist/git/utils/conventions.d.ts

@@ -0,0 +1,33 @@
+import { ComposeGitPort } from "../../ports/git.js";
+
+//#region src/git/utils/conventions.d.ts
+interface CommitConventions {
+  format: 'conventional-commits' | 'plain' | 'unknown';
+  prefixes?: string[];
+  scopeStyle?: 'parenthesized' | 'none';
+  casing?: 'lowercase' | 'capitalized';
+  issueRefPattern?: string;
+  samples: string[];
+}
+interface BranchConventions {
+  format: 'prefixed' | 'issue-number' | 'plain' | 'unknown';
+  prefixes?: string[];
+  separator?: string;
+  samples: string[];
+}
+interface ConventionDescriptor {
+  commits: CommitConventions;
+  branches: BranchConventions;
+  sources: string[];
+  promptFragment: string;
+}
+interface ExtractConventionsOptions {
+  git: ComposeGitPort;
+  author?: string;
+  commitLimit?: number;
+  branchLimit?: number;
+  signal?: AbortSignal;
+}
+declare function extractConventions(options: ExtractConventionsOptions): Promise<ConventionDescriptor>;
+//#endregion
+export { CommitConventions, ConventionDescriptor, extractConventions };

package/dist/git/utils/conventions.js

@@ -0,0 +1,10 @@
+import{forEachRef as e,getConfig as t,log as n,showFile as r}from"../port-dispatch.js";const i=/^(feat|fix|refactor|chore|docs|style|test|perf|ci|build|revert)(\(.+?\))?!?:\s/,a=[{re:/\(#\d+\)/,label:`(#NNN)`},{re:/#\d+/,label:`#NNN`},{re:/[A-Z]{2,}-\d+/,label:`PROJ-NNN`}],o=/^(feat|fix|chore|feature|hotfix|bugfix|refactor|release|support)\//,s=/^(\d+)-|^([A-Z]{2,}-\d+)-/,c=new Set([`main`,`master`,`develop`,`development`,`staging`,`production`]);async function l(e){let{git:t,commitLimit:n=30,branchLimit:r=15,signal:i}=e;i?.throwIfAborted();let a=[],o=e.author??await T(t,i),[s,c,l]=await Promise.all([u(t,a,i),f(t,n,o,i),p(t,r,i)]),d=m(c,s),g=h(l);return{commits:d,branches:g,sources:a,promptFragment:b(d,g)}}async function u(e,t,n){let r={hasConventionalCommitsDep:!1,hasCommitizen:!1},i=await C(e,`package.json`,n);if(i)try{let e=JSON.parse(i),n={...e.dependencies??{},...e.devDependencies??{}};n[`@commitlint/config-conventional`]&&(r.hasConventionalCommitsDep=!0,t.push(`package.json (@commitlint/config-conventional)`)),(e.config?.commitizen||n.commitizen)&&(r.hasCommitizen=!0,t.push(`package.json (commitizen)`))}catch{}for(let i of[`.commitlintrc.json`,`.commitlintrc.yml`,`.commitlintrc.yaml`]){let a=await C(e,i,n);if(a){t.push(i);let e=d(a);e.length>0&&(r.commitlintTypes=e);break}}for(let i of[`commitlint.config.js`,`commitlint.config.cjs`,`commitlint.config.mjs`])if(await w(e,i,n)){t.push(i),r.commitlintTypes||(r.hasConventionalCommitsDep=!0);break}let a=await C(e,`.gitmessage`,n);return a&&(r.gitMessageTemplate=a.trim(),t.push(`.gitmessage`)),r}function d(e){try{let t=JSON.parse(e)?.rules?.[`type-enum`];if(Array.isArray(t)){let e=t.find(e=>Array.isArray(e));if(Array.isArray(e))return e.filter(e=>typeof e==`string`)}}catch{let t=e.match(/type-enum[^[]*\[([^\]]+)\]/);if(t)return t[1].split(`,`).map(e=>e.trim().replace(/['"]/g,``)).filter(Boolean)}return[]}async function f(e,t,r,i){try{let a=(await n(e,{format:`%s`,noMerges:!0,limit:t,author:r,signal:i})).trim().split(`
+`).filter(Boolean);return r&&a.length<5?(await n(e,{format:`%s`,noMerges:!0,limit:t,signal:i})).trim().split(`
+`).filter(Boolean):a}catch{return[]}}async function p(t,n,r){try{return(await e(t,{format:`%(refname:short)`,prefix:`refs/heads/`,sort:`-committerdate`,limit:n+5,signal:r})).trim().split(`
+`).filter(Boolean).filter(e=>!c.has(e)&&!e.startsWith(`release/`)).slice(0,n)}catch{return[]}}function m(e,t){if(e.length===0)return{format:t.hasConventionalCommitsDep||t.hasCommitizen?`conventional-commits`:`unknown`,prefixes:t.commitlintTypes,samples:[]};let n=e.filter(e=>i.test(e)),r=n.length/e.length>.6||t.hasConventionalCommitsDep||t.hasCommitizen,a,o;if(r){let e=new Set,r=0;for(let t of n){let n=t.match(i);n&&(e.add(n[1]),n[2]&&r++)}a=t.commitlintTypes??[...e].sort(),o=r/Math.max(n.length,1)>.3?`parenthesized`:`none`}let s=g(e,r),c=_(e),l=v(e,r?a:void 0);return{format:r?`conventional-commits`:`plain`,prefixes:a,scopeStyle:o,casing:s,issueRefPattern:c,samples:l}}function h(e){if(e.length===0)return{format:`unknown`,samples:[]};let t=e.filter(e=>o.test(e)),n=e.filter(e=>s.test(e));if(t.length/e.length>.5){let n=new Set;for(let e of t){let t=e.match(o);t&&n.add(t[1])}return{format:`prefixed`,prefixes:[...n].sort(),separator:`/`,samples:y(e,[...n])}}return n.length/e.length>.5?{format:`issue-number`,separator:`-`,samples:e.slice(0,5)}:{format:e.length>=3?`plain`:`unknown`,samples:e.slice(0,5)}}function g(e,t){let n=0,r=0;for(let a of e){let e=(t?a.replace(i,``):a).trim()[0];e&&(e===e.toUpperCase()&&e!==e.toLowerCase()?r++:n++)}if(!(n+r<3)){if(n/(n+r)>.7)return`lowercase`;if(r/(n+r)>.7)return`capitalized`}}function _(e){for(let{re:t,label:n}of a)if(e.filter(e=>t.test(e)).length/e.length>.2)return n}function v(e,t){if(!t||t.length===0)return e.slice(0,5);let n=[],r=new Set;for(let i of t){let t=e.find(e=>e.startsWith(`${i}(`)||e.startsWith(`${i}:`));if(t&&!r.has(t)&&(n.push(t),r.add(t),n.length>=5))break}for(let t of e){if(n.length>=5)break;r.has(t)||(n.push(t),r.add(t))}return n}function y(e,t){let n=[],r=new Set;for(let i of t){let t=e.find(e=>e.startsWith(`${i}/`));if(t&&!r.has(t)&&(n.push(t),r.add(t),n.length>=5))break}for(let t of e){if(n.length>=5)break;r.has(t)||(n.push(t),r.add(t))}return n}function b(e,t){let n=[`## Repository conventions
+`];return n.push(x(e)),n.push(S(t)),n.push(`Match these conventions in your output.`),n.join(`
+`)}function x(e){if(e.format===`unknown`&&e.samples.length===0)return`Commit messages: No clear convention detected. Use clear, concise messages.
+`;let t=[];if(e.format===`conventional-commits`){let n=e.scopeStyle===`parenthesized`?` with scope in parentheses`:``;t.push(`Commit messages follow Conventional Commits format${n}: type${e.scopeStyle===`parenthesized`?`(scope)`:``}: description`),e.prefixes?.length&&t.push(`Allowed types: ${e.prefixes.join(`, `)}`)}else t.push(`Commit messages use plain English format.`);if(e.casing&&t.push(`${e.casing===`capitalized`?`Capitalized`:`Lowercase`} first word after any prefix.`),e.issueRefPattern&&t.push(`Issues often referenced as ${e.issueRefPattern}.`),e.samples.length>0){t.push(`Examples:`);for(let n of e.samples)t.push(`- ${n}`)}return`${t.join(`
+`)}\n`}function S(e){if(e.format===`unknown`&&e.samples.length===0)return`Branch names: No clear convention detected. Use descriptive kebab-case names.
+`;let t=[];if(e.format===`prefixed`){let n=e.separator??`/`;t.push(`Branch names use type${n}kebab-case-slug format.`),e.prefixes?.length&&t.push(`Common prefixes: ${e.prefixes.join(`, `)}`)}else e.format===`issue-number`?t.push(`Branch names start with an issue number followed by a kebab-case description.`):t.push(`Branch names use descriptive kebab-case format.`);if(e.samples.length>0){t.push(`Examples:`);for(let n of e.samples)t.push(`- ${n}`)}return`${t.join(`
+`)}\n`}async function C(e,t,n){try{return await r(e,`HEAD`,t,{signal:n})}catch{return null}}async function w(e,t,n){try{return await r(e,`HEAD`,t,{signal:n}),!0}catch{return!1}}async function T(e,n){let r=await t(e,`user.email`,{signal:n});if(r)return r;let i=await t(e,`user.name`,{signal:n});if(i)return i}export{l as extractConventions};

package/dist/git/utils/crypto.d.ts

@@ -0,0 +1,4 @@
+//#region src/git/utils/crypto.d.ts
+declare function sha256(text: string): string;
+//#endregion
+export { sha256 };

package/dist/git/utils/crypto.js

@@ -0,0 +1 @@
+import{createHash as e}from"node:crypto";function t(t){return e(`sha256`).update(t).digest(`hex`)}export{t as sha256};

package/dist/git/utils/hunk-parser.d.ts

@@ -0,0 +1,6 @@
+import { ComposeHunk } from "../../tasks/types.js";
+
+//#region src/git/utils/hunk-parser.d.ts
+declare function parseUnifiedDiff(diffText: string, source: ComposeHunk['source'], startIndex?: number): ComposeHunk[];
+//#endregion
+export { parseUnifiedDiff };

package/dist/git/utils/hunk-parser.js

@@ -0,0 +1,7 @@
+const e=/^diff --git /m,t=/^@@ /m;function n(e,t,n=0){if(!e.trim())return[];let a=r(e),o=[],s=n;for(let e of a){let{diffHeader:n,fileName:r,originalFileName:a,isRename:c,isBinary:l,binaryPatchData:u,hunkSections:d}=i(e);if(l){o.push({index:s++,fileName:r,diffHeader:n,hunkHeader:``,content:`Binary file change`,additions:0,deletions:0,source:t,isRename:c,originalFileName:a,isBinary:!0,binaryPatchData:u});continue}if(d.length===0){o.push({index:s++,fileName:r,diffHeader:n,hunkHeader:c?`rename`:``,content:c?`Rename from ${a}\nRename to ${r}`:``,additions:0,deletions:0,source:t,isRename:c,originalFileName:a});continue}for(let e of d)o.push({index:s++,fileName:r,diffHeader:n,hunkHeader:e.header,content:e.content,additions:e.additions,deletions:e.deletions,source:t,isRename:!1,originalFileName:a})}return o}function r(t){let n=[],r=t.split(e);for(let e=1;e<r.length;e++)n.push(`diff --git ${r[e]}`);return n}function i(e){let n=e.indexOf(`
+GIT binary patch
+`);if(n!==-1){let t=e.slice(0,n).trimEnd(),r=e.slice(n+1),i=a(t),{isRename:s,originalFileName:c}=o(t);return{diffHeader:t,fileName:i,originalFileName:c,isRename:s,isBinary:!0,binaryPatchData:r,hunkSections:[]}}let r=e.search(t),i,c;r===-1?(i=e.trimEnd(),c=``):(i=e.slice(0,r).trimEnd(),c=e.slice(r));let l=a(i),{isRename:u,originalFileName:d}=o(i),f=c?s(c):[];return{diffHeader:i,fileName:l,originalFileName:d,isRename:u,isBinary:!1,hunkSections:f}}function a(e){let t=e.split(`
+`);for(let e of t)if(e.startsWith(`+++ b/`))return e.slice(6);for(let e of t)if(e.startsWith(`rename to `))return e.slice(10);return t[0]?.match(/^diff --git a\/.+ b\/(.+)$/)?.[1]??`unknown`}function o(e){let t=e.split(`
+`),n,r=!1;for(let e of t)e.startsWith(`rename from `)&&(n=e.slice(12),r=!0);return{isRename:r,originalFileName:n}}function s(e){let t=[],n=e.split(`
+`),r=``,i=[];for(let e of n)e.startsWith(`@@ `)?(r&&t.push(c(r,i)),r=e,i=[]):r&&i.push(e);return r&&t.push(c(r,i)),t}function c(e,t){for(;t.length>0&&t[t.length-1]===``;)t.pop();let n=0,r=0;for(let e of t)e.startsWith(`+`)&&!e.startsWith(`+++`)?n++:e.startsWith(`-`)&&!e.startsWith(`---`)&&r++;return{header:e,content:t.join(`
+`),additions:n,deletions:r}}export{n as parseUnifiedDiff};

package/dist/git/utils/patch-builder.d.ts

@@ -0,0 +1,6 @@
+import { ComposeHunk } from "../../tasks/types.js";
+
+//#region src/git/utils/patch-builder.d.ts
+declare function buildPatchForCommit(hunks: ComposeHunk[]): string;
+//#endregion
+export { buildPatchForCommit };