opencode-swarm 7.59.1 → 7.61.0

package/dist/worktree/index.d.ts

@@ -0,0 +1,5 @@
+export type { AutoCommitSkip, AutoCommitSuccess, CleanCheckFailure, CleanCheckSuccess, CleanFailure, CleanSuccess, ProvisionFailure, ProvisionSuccess, RemoveFailure, RemoveSuccess, } from './core';
+export { _internals as coreInternals, assertCleanWorkingTree, autoCommitDirty, checkPathBudget, cleanUntrackedFiles, isCleanWorktree, makeWorktreeBranchName, provisionWorktree, removeWorktree, shortenWorktreePath, } from './core';
+export type { CleanupFailure, CleanupSuccess, ConflictHandlingError, ConflictInfo, DirtyMergeFailure, DirtyMergePartial, DirtyMergeSuccess, MergeConflict, MergeFailure, MergeSuccess, OrphanCleanupResult, StartupRecoveryResult, } from './merge';
+export { _internals as mergeInternals, attemptMergeBackFromDirty, cleanupOrphanedBranches, getMergeStrategy, handleMergeConflict, mergeLaneBranch, postMergeCleanup, startupOrphanRecovery, } from './merge';
+export * from './types';

package/dist/worktree/merge.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Merge-back operations for lean turbo parallel lanes.
+ *
+ * Provides four public functions for merging lane branches back into
+ * the primary worktree, cleaning up lane branches, and handling merge
+ * conflicts. All subprocess calls go through the `_internals` DI seam
+ * so tests can replace the real `bunSpawn` without leaking across Bun's
+ * shared test-runner process.
+ *
+ * @module merge-back
+ */
+import { bunSpawn } from '../utils/bun-compat';
+import type { MergeStrategy } from './types';
+/**
+ * Test-only dependency-injection seam. Production code calls
+ * `_internals.bunSpawn(...)` so tests can replace the function on this object
+ * without touching the real `../../utils/bun-compat` module — `mock.module`
+ * from `bun:test` leaks across files in Bun's shared test-runner process,
+ * which would corrupt unrelated suites that import `bun-compat`. Mutating this
+ * local object is file-scoped and trivially restorable via `afterEach`.
+ */
+export declare const _internals: {
+    bunSpawn: typeof bunSpawn;
+    /** Test seam for process.platform — allows non-Windows CIs to exercise Windows paths. */
+    platform: string;
+    /** Test seam for sleep — allows tests to skip real delays. */
+    sleep: (ms: number) => Promise<void>;
+};
+export interface MergeSuccess {
+    merged: true;
+    strategy: string;
+}
+export interface MergeConflict {
+    conflict: true;
+    files: string[];
+    message: string;
+}
+export interface MergeFailure {
+    error: string;
+}
+export interface CleanupSuccess {
+    cleaned: true;
+}
+export interface CleanupFailure {
+    error: string;
+    partial?: boolean;
+}
+export interface ConflictInfo {
+    files: string[];
+    message: string;
+    aborted: true;
+}
+export interface ConflictHandlingError {
+    error: string;
+    aborted: boolean;
+}
+export interface DirtyMergeSuccess {
+    merged: true;
+    strategy: string;
+    autoCommitted: boolean;
+    cleaned: boolean;
+}
+export interface DirtyMergePartial {
+    partial: true;
+    stage: string;
+    autoCommitted: boolean;
+    cleaned: boolean;
+    message: string;
+}
+export interface DirtyMergeFailure {
+    failed: true;
+    stage: string;
+    message: string;
+}
+export interface OrphanCleanupResult {
+    removed: string[];
+    skipped: string[];
+    errors: Array<{
+        branch: string;
+        error: string;
+    }>;
+}
+export interface StartupRecoveryResult {
+    prunedWorktrees: boolean;
+    remainingBranches: string[];
+    warnings: string[];
+}
+/**
+ * Reads the merge strategy from the lean turbo configuration.
+ *
+ * Returns `config.merge_strategy` if set, otherwise defaults to `'merge'`.
+ * This is a pure function — no subprocess calls.
+ *
+ * @param config - Lean turbo configuration.
+ * @returns The merge strategy to use: `'merge'`, `'rebase'`, or `'cherry-pick'`.
+ */
+export declare function getMergeStrategy(config: {
+    mergeStrategy?: MergeStrategy;
+    merge_strategy?: MergeStrategy;
+}): MergeStrategy;
+/**
+ * Merges a lane branch back into the primary worktree using the specified
+ * strategy.
+ *
+ * On conflict, automatically aborts the in-progress merge/rebase/cherry-pick
+ * to restore the working tree to a clean state, then returns conflict details.
+ *
+ * @param primaryDir - The main project root (cwd for all git commands).
+ * @param branchName - The lane branch name (e.g. `swarm-lane/<sessionId>/<laneId>`).
+ * @param strategy   - Merge strategy to use.
+ * @returns Discriminated union: success, conflict, or failure.
+ */
+export declare function mergeLaneBranch(primaryDir: string, branchName: string, strategy: MergeStrategy): Promise<MergeSuccess | MergeConflict | MergeFailure>;
+/**
+ * Cleans up a lane branch after a successful merge.
+ *
+ * Deletes the lane branch and prunes stale worktree metadata (DD-9).
+ * Reports partial success if branch deletion fails but worktree prune succeeds.
+ *
+ * @param directory  - The project root (cwd for git commands).
+ * @param branchName - The lane branch name to delete.
+ * @returns Discriminated union: success, partial failure, or full failure.
+ */
+export declare function postMergeCleanup(directory: string, branchName: string): Promise<CleanupSuccess | CleanupFailure>;
+/**
+ * Handles a merge conflict by listing conflicted files and aborting the
+ * in-progress operation to restore the working tree to a clean state.
+ *
+ * Uses a strategy-specific abort command so the correct git sub-command
+ * is invoked (`merge --abort`, `rebase --abort`, or `cherry-pick --abort`).
+ * Using the wrong abort command would leave the repository in a dirty state.
+ *
+ * @param primaryDir - The main project root (cwd for all git commands).
+ * @param branchName - The lane branch name that caused the conflict.
+ *   Retained for logging and future conflict-reporting use.
+ * @param strategy - The merge strategy that is currently in progress.
+ * @returns Discriminated union: conflict info or handling error.
+ */
+export declare function handleMergeConflict(primaryDir: string, _branchName: string, strategy: MergeStrategy): Promise<ConflictInfo | ConflictHandlingError>;
+/**
+ * Attempts to merge a lane branch back from a potentially dirty worktree
+ * using progressive cleanup (DD-7).
+ *
+ * Pipeline:
+ * 1. Auto-commit dirty state in the worktree
+ * 2. Clean untracked files
+ * 3. Attempt the merge-back
+ *
+ * Each step is fault-tolerant: failures log a warning and continue.
+ * Only when both auto-commit AND clean fail (not just skip) does the
+ * pipeline abandon early with `{ failed: true, stage: 'cleanup' }`.
+ *
+ * @param worktreePath - Absolute path to the lane worktree directory.
+ * @param branchName   - The lane branch name (e.g. `swarm-lane/<sessionId>/<laneId>`).
+ * @param primaryDir   - The main project root (cwd for merge commands).
+ * @param strategy     - Merge strategy to use.
+ * @returns Discriminated union: success, partial, or failure.
+ */
+export declare function attemptMergeBackFromDirty(worktreePath: string, branchName: string, primaryDir: string, strategy: MergeStrategy): Promise<DirtyMergeSuccess | DirtyMergePartial | DirtyMergeFailure>;
+/**
+ * Cleans up orphaned swarm-lane branches that do not belong to any active session.
+ *
+ * Lists all branches matching `swarm-lane/*`, identifies orphans (branches whose
+ * session ID is not in `activeSessionIds`), force-deletes them, and prunes stale
+ * worktree metadata.
+ *
+ * @param directory        - The project root (cwd for all git commands).
+ * @param activeSessionIds - Session IDs that are still active; their branches are skipped.
+ * @returns Result with arrays of removed, skipped, and errored branch names.
+ */
+export declare function cleanupOrphanedBranches(directory: string, activeSessionIds?: string[]): Promise<OrphanCleanupResult>;
+/**
+ * Performs startup orphan recovery: prunes stale worktrees, then identifies
+ * any remaining orphaned swarm-lane branches for warning.
+ *
+ * This is designed to run at session startup (DD-3). It does NOT delete branches —
+ * it reports them as warnings so the caller can decide on further action.
+ *
+ * @param directory        - The project root (cwd for all git commands).
+ * @param activeSessionIds - Session IDs that are still active; their branches are expected.
+ * @returns Result indicating whether pruning happened, orphaned branches, and warnings.
+ */
+export declare function startupOrphanRecovery(directory: string, activeSessionIds?: string[]): Promise<StartupRecoveryResult>;

package/dist/worktree/types.d.ts

@@ -0,0 +1,46 @@
+export type WorktreePurpose = 'lane' | 'session';
+export type MergeStrategy = 'merge' | 'rebase' | 'cherry-pick';
+export type DependencyPreparationStrategy = 'skip' | 'copy' | 'link';
+export interface WorktreeOptions {
+    worktreeDir?: string;
+    mergeStrategy?: MergeStrategy;
+    purpose: WorktreePurpose;
+    depsStrategy?: DependencyPreparationStrategy;
+    /**
+     * `purpose` uses `swarm/<purpose>/<sessionId>/<id>`.
+     * `legacy-lane` preserves the PR #1188 Lean Turbo branch contract.
+     */
+    branchStyle?: 'purpose' | 'legacy-lane';
+}
+export interface WorktreeHandle {
+    worktreePath: string;
+    branchName: string;
+    purpose: WorktreePurpose;
+    id: string;
+    sessionId: string;
+}
+export interface WorktreeFailure {
+    error: string;
+}
+export type WorktreeProvisionResult = WorktreeHandle | WorktreeFailure;
+export interface WorktreePolicyConfig {
+    policy: 'auto' | 'required' | 'disabled';
+    merge_strategy: MergeStrategy;
+    worktree_dir?: string;
+    deps_strategy: DependencyPreparationStrategy;
+}
+export interface ConflictReport {
+    branchName: string;
+    files: string[];
+    message: string;
+}
+export type MergeBackResult = {
+    merged: true;
+    strategy: MergeStrategy;
+} | {
+    conflict: true;
+    files: string[];
+    message: string;
+} | {
+    error: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.59.1",
+	"version": "7.61.0",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",