sequant 2.9.0 → 2.11.0

package/dist/src/lib/phase-spinner.d.ts

@@ -1,146 +0,0 @@
-/**
- * Phase Spinner - Animated spinner with elapsed time for phase execution
- *
- * Wraps the cli-ui spinner with:
- * - Elapsed time tracking (updates every 5 seconds)
- * - Phase progress indicator (e.g., "spec (1/3)")
- * - Integration with ShutdownManager for graceful cleanup
- *
- * @example
- * ```typescript
- * const spinner = new PhaseSpinner({
- *   phase: 'exec',
- *   phaseIndex: 2,
- *   totalPhases: 3,
- *   shutdownManager,
- * });
- *
- * spinner.start();
- * // ... phase execution
- * spinner.succeed(); // Shows "✓ exec (2/3) (45s)"
- * ```
- */
-import type { ShutdownManager } from "./shutdown.js";
-/**
- * Options for creating a PhaseSpinner
- */
-export interface PhaseSpinnerOptions {
-    /** Phase name (e.g., "spec", "exec", "qa") */
-    phase: string;
-    /** Current phase index (1-based) */
-    phaseIndex: number;
-    /** Total number of phases */
-    totalPhases: number;
-    /** Optional ShutdownManager for graceful cleanup */
-    shutdownManager?: ShutdownManager;
-    /** Optional prefix for indentation (default: "    ") */
-    prefix?: string;
-    /** Optional quality loop iteration (shows "iteration N" if > 1) */
-    iteration?: number;
-}
-/**
- * Format elapsed time in human-readable format
- *
- * @param seconds - Elapsed time in seconds
- * @returns Formatted string (e.g., "45s", "2m 15s", "1h 5m")
- */
-export declare function formatElapsedTime(seconds: number): string;
-/**
- * PhaseSpinner - Animated spinner with elapsed time and phase progress
- *
- * Features:
- * - Animated spinner (or text fallback) via cli-ui
- * - Elapsed time tracking with automatic updates
- * - Phase progress indicator (e.g., "exec (2/3)")
- * - ShutdownManager integration for graceful Ctrl+C cleanup
- * - Pause/resume for verbose streaming output
- */
-export declare class PhaseSpinner {
-    private spinner;
-    private startTime;
-    private intervalId;
-    private disposed;
-    private paused;
-    private readonly phase;
-    private readonly phaseIndex;
-    private readonly totalPhases;
-    private readonly shutdownManager?;
-    private readonly prefix;
-    private readonly iteration?;
-    private readonly cleanupName;
-    constructor(options: PhaseSpinnerOptions);
-    /**
-     * Format the spinner text with phase, progress, and elapsed time
-     */
-    private formatText;
-    /**
-     * Update the spinner text with current elapsed time
-     */
-    private updateElapsedTime;
-    /**
-     * Start the spinner
-     *
-     * Begins the animation and elapsed time tracking.
-     */
-    start(): PhaseSpinner;
-    /**
-     * Mark the phase as succeeded
-     *
-     * Stops the spinner and shows a checkmark with total duration.
-     */
-    succeed(customText?: string): PhaseSpinner;
-    /**
-     * Mark the phase as failed
-     *
-     * Stops the spinner and shows an error indicator with message.
-     */
-    fail(error?: string): PhaseSpinner;
-    /**
-     * Stop the spinner without success/fail indication
-     *
-     * Use this for cleanup or when the phase is interrupted.
-     */
-    stop(): PhaseSpinner;
-    /**
-     * Pause the spinner (for verbose streaming output)
-     *
-     * Temporarily stops the animation without disposing.
-     * Call resume() to continue.
-     */
-    pause(): PhaseSpinner;
-    /**
-     * Resume the spinner after pause
-     *
-     * Restarts the animation with updated elapsed time.
-     */
-    resume(): PhaseSpinner;
-    /**
-     * Check if the spinner is currently active
-     */
-    get isSpinning(): boolean;
-    /**
-     * Get the total elapsed time in seconds
-     */
-    get elapsedSeconds(): number;
-    /**
-     * Dispose of the spinner and clean up resources
-     *
-     * Called automatically by succeed(), fail(), or stop().
-     * Safe to call multiple times.
-     */
-    dispose(): void;
-    /**
-     * Clear the elapsed time update interval
-     */
-    private clearInterval;
-    /**
-     * Unregister from ShutdownManager
-     */
-    private unregisterCleanup;
-}
-/**
- * Create a PhaseSpinner with the given options
- *
- * Convenience function matching the pattern of cli-ui.spinner().
- */
-export declare function phaseSpinner(options: PhaseSpinnerOptions): PhaseSpinner;

package/dist/src/lib/phase-spinner.js

@@ -1,255 +0,0 @@
-/**
- * Phase Spinner - Animated spinner with elapsed time for phase execution
- *
- * Wraps the cli-ui spinner with:
- * - Elapsed time tracking (updates every 5 seconds)
- * - Phase progress indicator (e.g., "spec (1/3)")
- * - Integration with ShutdownManager for graceful cleanup
- *
- * @example
- * ```typescript
- * const spinner = new PhaseSpinner({
- *   phase: 'exec',
- *   phaseIndex: 2,
- *   totalPhases: 3,
- *   shutdownManager,
- * });
- *
- * spinner.start();
- * // ... phase execution
- * spinner.succeed(); // Shows "✓ exec (2/3) (45s)"
- * ```
- */
-import { spinner as createSpinner } from "./cli-ui.js";
-/**
- * Elapsed time update interval in milliseconds
- */
-const ELAPSED_UPDATE_INTERVAL_MS = 5000;
-/**
- * Format elapsed time in human-readable format
- *
- * @param seconds - Elapsed time in seconds
- * @returns Formatted string (e.g., "45s", "2m 15s", "1h 5m")
- */
-export function formatElapsedTime(seconds) {
-    if (seconds < 60) {
-        return `${Math.floor(seconds)}s`;
-    }
-    if (seconds < 3600) {
-        const minutes = Math.floor(seconds / 60);
-        const remainingSeconds = Math.floor(seconds % 60);
-        return remainingSeconds > 0
-            ? `${minutes}m ${remainingSeconds}s`
-            : `${minutes}m`;
-    }
-    const hours = Math.floor(seconds / 3600);
-    const remainingMinutes = Math.floor((seconds % 3600) / 60);
-    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
-}
-/**
- * PhaseSpinner - Animated spinner with elapsed time and phase progress
- *
- * Features:
- * - Animated spinner (or text fallback) via cli-ui
- * - Elapsed time tracking with automatic updates
- * - Phase progress indicator (e.g., "exec (2/3)")
- * - ShutdownManager integration for graceful Ctrl+C cleanup
- * - Pause/resume for verbose streaming output
- */
-export class PhaseSpinner {
-    spinner;
-    startTime = 0;
-    intervalId = null;
-    disposed = false;
-    paused = false;
-    phase;
-    phaseIndex;
-    totalPhases;
-    shutdownManager;
-    prefix;
-    iteration;
-    cleanupName;
-    constructor(options) {
-        this.phase = options.phase;
-        this.phaseIndex = options.phaseIndex;
-        this.totalPhases = options.totalPhases;
-        this.shutdownManager = options.shutdownManager;
-        this.prefix = options.prefix ?? "    ";
-        this.iteration = options.iteration;
-        this.cleanupName = `phase-spinner-${options.phase}`;
-        // Create the underlying spinner with initial text
-        this.spinner = createSpinner(this.formatText(0));
-    }
-    /**
-     * Format the spinner text with phase, progress, and elapsed time
-     */
-    formatText(elapsedSeconds) {
-        const progress = `(${this.phaseIndex}/${this.totalPhases})`;
-        const elapsed = elapsedSeconds > 0 ? ` ${formatElapsedTime(elapsedSeconds)}` : "";
-        const iterationSuffix = this.iteration && this.iteration > 1
-            ? ` [iteration ${this.iteration}]`
-            : "";
-        return `${this.prefix}${this.phase} ${progress}...${elapsed}${iterationSuffix}`;
-    }
-    /**
-     * Update the spinner text with current elapsed time
-     */
-    updateElapsedTime() {
-        if (this.disposed || this.paused)
-            return;
-        const elapsedSeconds = (Date.now() - this.startTime) / 1000;
-        this.spinner.text = this.formatText(elapsedSeconds);
-    }
-    /**
-     * Start the spinner
-     *
-     * Begins the animation and elapsed time tracking.
-     */
-    start() {
-        if (this.disposed)
-            return this;
-        this.startTime = Date.now();
-        this.spinner.start(this.formatText(0));
-        // Start elapsed time update interval
-        this.intervalId = setInterval(() => {
-            this.updateElapsedTime();
-        }, ELAPSED_UPDATE_INTERVAL_MS);
-        // Register with ShutdownManager for graceful cleanup
-        if (this.shutdownManager) {
-            this.shutdownManager.registerCleanup(this.cleanupName, async () => {
-                this.stop();
-            });
-        }
-        return this;
-    }
-    /**
-     * Mark the phase as succeeded
-     *
-     * Stops the spinner and shows a checkmark with total duration.
-     */
-    succeed(customText) {
-        if (this.disposed)
-            return this;
-        this.clearInterval();
-        this.unregisterCleanup();
-        const elapsedSeconds = (Date.now() - this.startTime) / 1000;
-        const duration = formatElapsedTime(elapsedSeconds);
-        const progress = `(${this.phaseIndex}/${this.totalPhases})`;
-        const text = customText ?? `${this.prefix}${this.phase} ${progress} (${duration})`;
-        this.spinner.succeed(text);
-        this.disposed = true;
-        return this;
-    }
-    /**
-     * Mark the phase as failed
-     *
-     * Stops the spinner and shows an error indicator with message.
-     */
-    fail(error) {
-        if (this.disposed)
-            return this;
-        this.clearInterval();
-        this.unregisterCleanup();
-        const elapsedSeconds = (Date.now() - this.startTime) / 1000;
-        const duration = formatElapsedTime(elapsedSeconds);
-        const progress = `(${this.phaseIndex}/${this.totalPhases})`;
-        const errorSuffix = error ? `: ${error}` : "";
-        const text = `${this.prefix}${this.phase} ${progress} (${duration})${errorSuffix}`;
-        this.spinner.fail(text);
-        this.disposed = true;
-        return this;
-    }
-    /**
-     * Stop the spinner without success/fail indication
-     *
-     * Use this for cleanup or when the phase is interrupted.
-     */
-    stop() {
-        if (this.disposed)
-            return this;
-        this.clearInterval();
-        this.unregisterCleanup();
-        this.spinner.stop();
-        this.disposed = true;
-        return this;
-    }
-    /**
-     * Pause the spinner (for verbose streaming output)
-     *
-     * Temporarily stops the animation without disposing.
-     * Call resume() to continue.
-     */
-    pause() {
-        if (this.disposed || this.paused)
-            return this;
-        this.paused = true;
-        this.spinner.stop();
-        return this;
-    }
-    /**
-     * Resume the spinner after pause
-     *
-     * Restarts the animation with updated elapsed time.
-     */
-    resume() {
-        if (this.disposed || !this.paused)
-            return this;
-        this.paused = false;
-        const elapsedSeconds = (Date.now() - this.startTime) / 1000;
-        this.spinner.start(this.formatText(elapsedSeconds));
-        return this;
-    }
-    /**
-     * Check if the spinner is currently active
-     */
-    get isSpinning() {
-        return this.spinner.isSpinning && !this.disposed && !this.paused;
-    }
-    /**
-     * Get the total elapsed time in seconds
-     */
-    get elapsedSeconds() {
-        if (this.startTime === 0)
-            return 0;
-        return (Date.now() - this.startTime) / 1000;
-    }
-    /**
-     * Dispose of the spinner and clean up resources
-     *
-     * Called automatically by succeed(), fail(), or stop().
-     * Safe to call multiple times.
-     */
-    dispose() {
-        if (this.disposed)
-            return;
-        this.clearInterval();
-        this.unregisterCleanup();
-        this.spinner.stop();
-        this.disposed = true;
-    }
-    /**
-     * Clear the elapsed time update interval
-     */
-    clearInterval() {
-        if (this.intervalId !== null) {
-            clearInterval(this.intervalId);
-            this.intervalId = null;
-        }
-    }
-    /**
-     * Unregister from ShutdownManager
-     */
-    unregisterCleanup() {
-        if (this.shutdownManager) {
-            this.shutdownManager.unregisterCleanup(this.cleanupName);
-        }
-    }
-}
-/**
- * Create a PhaseSpinner with the given options
- *
- * Convenience function matching the pattern of cli-ui.spinner().
- */
-export function phaseSpinner(options) {
-    return new PhaseSpinner(options);
-}

package/dist/src/lib/workflow/pr-operations.d.ts

@@ -1,86 +0,0 @@
-/**
- * PR Operations Module
- *
- * Handles pre-PR and PR creation operations:
- * - Checkpoint commits for chain recovery
- * - Lockfile change detection and dependency reinstall
- * - Pre-PR rebase onto origin/main
- * - PR creation with existing-PR detection
- *
- * @module pr-operations
- */
-/**
- * Result of a pre-PR rebase operation
- */
-export interface RebaseResult {
-    /** Whether the rebase was performed */
-    performed: boolean;
-    /** Whether the rebase succeeded */
-    success: boolean;
-    /** Whether dependencies were reinstalled */
-    reinstalled: boolean;
-    /** Error message if rebase failed */
-    error?: string;
-}
-/**
- * Result of PR creation
- */
-export interface PRCreationResult {
-    /** Whether PR creation was attempted */
-    attempted: boolean;
-    /** Whether PR was created successfully (or already existed) */
-    success: boolean;
-    /** PR number */
-    prNumber?: number;
-    /** PR URL */
-    prUrl?: string;
-    /** Error message if failed */
-    error?: string;
-}
-/**
- * Create a checkpoint commit in the worktree after QA passes
- * This allows recovery in case later issues in the chain fail
- * @internal Exported for testing
- */
-export declare function createCheckpointCommit(worktreePath: string, issueNumber: number, verbose: boolean): boolean;
-/**
- * Check if any lockfile changed during a rebase and re-run install if needed.
- * This prevents dependency drift when the lockfile was updated on main.
- * @param worktreePath Path to the worktree
- * @param packageManager Package manager to use for install
- * @param verbose Whether to show verbose output
- * @param preRebaseRef Git ref pointing to pre-rebase HEAD (defaults to ORIG_HEAD,
- *        which git sets automatically after rebase). Using ORIG_HEAD captures all
- *        lockfile changes across multi-commit rebases, unlike HEAD~1 which only
- *        checks the last commit.
- * @returns true if reinstall was performed, false otherwise
- * @internal Exported for testing
- */
-export declare function reinstallIfLockfileChanged(worktreePath: string, packageManager: string | undefined, verbose: boolean, preRebaseRef?: string): boolean;
-/**
- * Rebase the worktree branch onto origin/main before PR creation.
- * This ensures the branch is up-to-date and prevents lockfile drift.
- *
- * @param worktreePath Path to the worktree
- * @param issueNumber Issue number (for logging)
- * @param packageManager Package manager to use if reinstall needed
- * @param verbose Whether to show verbose output
- * @returns RebaseResult indicating success/failure and whether reinstall was performed
- * @internal Exported for testing
- */
-export declare function rebaseBeforePR(worktreePath: string, issueNumber: number, packageManager: string | undefined, verbose: boolean): RebaseResult;
-/**
- * Push branch and create a PR after successful QA.
- *
- * Handles both fresh PR creation and detection of existing PRs.
- * Failures are warnings — they don't fail the run.
- *
- * @param worktreePath Path to the worktree
- * @param issueNumber Issue number
- * @param issueTitle Issue title (for PR title)
- * @param branch Branch name
- * @param verbose Whether to show verbose output
- * @returns PRCreationResult with PR info or error
- * @internal Exported for testing
- */
-export declare function createPR(worktreePath: string, issueNumber: number, issueTitle: string, branch: string, verbose: boolean, labels?: string[]): PRCreationResult;