aiwcli 0.9.0

package/dist/lib/generic-merge.js

@@ -0,0 +1,105 @@
+/**
+ * @file Generic merge utilities for configuration merging.
+ *
+ * This module provides reusable utilities for merging arrays with deduplication
+ * and merging configuration objects by event type. Used by hook merger modules
+ * to eliminate code duplication.
+ *
+ * ## Usage
+ * ```typescript
+ * import { mergeArraysWithDedup, mergeConfigByEventType } from '../lib/generic-merge.js'
+ *
+ * // Merge arrays with custom equality
+ * const merged = mergeArraysWithDedup(existing, template, (a, b) => a.id === b.id)
+ *
+ * // Merge config objects by event type
+ * const mergedConfig = mergeConfigByEventType(
+ *   existingConfig,
+ *   templateConfig,
+ *   (existing, template) => mergeArraysWithDedup(existing, template, areEqual)
+ * )
+ * ```
+ *
+ * @module lib/generic-merge
+ */
+/**
+ * Merge two arrays with deduplication based on custom equality function.
+ *
+ * Items from the template array are appended to the existing array only if
+ * no equivalent item exists. Order is preserved: existing items first.
+ *
+ * @template T - Type of array elements
+ * @param existing - Existing array (preserved in order)
+ * @param template - Template array to merge (items appended if not duplicate)
+ * @param areEqual - Function to check if two items are equivalent
+ * @returns New merged array with duplicates removed
+ *
+ * @example
+ * ```typescript
+ * const merged = mergeArraysWithDedup(
+ *   [{id: 1, name: 'a'}],
+ *   [{id: 1, name: 'b'}, {id: 2, name: 'c'}],
+ *   (a, b) => a.id === b.id
+ * )
+ * // Result: [{id: 1, name: 'a'}, {id: 2, name: 'c'}]
+ * ```
+ */
+export function mergeArraysWithDedup(existing, template, areEqual) {
+    const merged = [...existing];
+    for (const templateItem of template) {
+        const isDuplicate = merged.some((existingItem) => areEqual(existingItem, templateItem));
+        if (!isDuplicate) {
+            merged.push(templateItem);
+        }
+    }
+    return merged;
+}
+/**
+ * Merge configuration objects organized by event type.
+ *
+ * Each configuration maps event types to arrays of items. This function
+ * merges configurations by:
+ * 1. Collecting all event types from both configurations
+ * 2. For each event type, merging the arrays using the provided merge function
+ *
+ * @template TEventType - Type of event type keys (typically string union)
+ * @template TItem - Type of items in the arrays
+ * @template TConfig - Type of the configuration object
+ * @param existing - Existing configuration (may be undefined)
+ * @param template - Template configuration to merge (may be undefined)
+ * @param mergeArrays - Function to merge arrays for a single event type
+ * @returns New merged configuration
+ *
+ * @example
+ * ```typescript
+ * const mergedConfig = mergeConfigByEventType(
+ *   {click: [handler1], hover: [handler2]},
+ *   {click: [handler3], focus: [handler4]},
+ *   (existing, template) => mergeArraysWithDedup(existing, template, areEqual)
+ * )
+ * // Result: {click: [handler1, handler3], hover: [handler2], focus: [handler4]}
+ * ```
+ */
+export function mergeConfigByEventType(existing, template, mergeArrays) {
+    // If no template, return existing (or empty object)
+    if (!template || Object.keys(template).length === 0) {
+        return (existing || {});
+    }
+    // If no existing, return template
+    if (!existing || Object.keys(existing).length === 0) {
+        return template;
+    }
+    const merged = {};
+    // Get all unique event types from both configurations
+    const allEventTypes = new Set([
+        ...Object.keys(existing),
+        ...Object.keys(template),
+    ]);
+    // Merge each event type
+    for (const eventType of allEventTypes) {
+        const existingItems = existing[eventType] || [];
+        const templateItems = template[eventType] || [];
+        merged[eventType] = mergeArrays(existingItems, templateItems);
+    }
+    return merged;
+}

package/dist/lib/git/branch.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @file Git branch operations.
+ *
+ * Provides utilities for checking, getting, and deleting git branches.
+ *
+ * @module lib/git/branch
+ */
+import type { GitCommandOptions } from './types.js';
+/**
+ * Check if a git branch exists (local).
+ *
+ * @param branchName - Name of the branch to check
+ * @returns True if branch exists locally
+ *
+ * @example
+ * ```typescript
+ * if (await branchExists('feature-branch')) {
+ *   console.log('Branch exists')
+ * }
+ * ```
+ */
+export declare function branchExists(branchName: string): boolean;
+/**
+ * Get the current git branch name.
+ *
+ * @returns Current branch name
+ * @throws Error if not in a git repository or unable to determine branch
+ *
+ * @example
+ * ```typescript
+ * const branch = getCurrentBranch()
+ * console.log(`Currently on: ${branch}`)
+ * ```
+ */
+export declare function getCurrentBranch(): string;
+/**
+ * Determine which main branch exists (main or master).
+ *
+ * Returns 'main' if it exists (preferred), 'master' if it exists,
+ * or null if neither exists.
+ *
+ * @returns 'main', 'master', or null
+ *
+ * @example
+ * ```typescript
+ * const mainBranch = getMainBranch()
+ * if (mainBranch) {
+ *   console.log(`Main branch: ${mainBranch}`)
+ * }
+ * ```
+ */
+export declare function getMainBranch(): null | string;
+/**
+ * Delete a git branch (local and remote if exists).
+ *
+ * @param branchName - Name of the branch to delete
+ * @param options - Command options including debug logging
+ * @throws Error if unable to delete branch
+ *
+ * @example
+ * ```typescript
+ * await deleteBranch('feature-branch', {
+ *   debugLog: (msg) => console.debug(msg)
+ * })
+ * ```
+ */
+export declare function deleteBranch(branchName: string, options?: GitCommandOptions): void;

package/dist/lib/git/branch.js

@@ -0,0 +1,155 @@
+/**
+ * @file Git branch operations.
+ *
+ * Provides utilities for checking, getting, and deleting git branches.
+ *
+ * @module lib/git/branch
+ */
+import { execSync } from 'node:child_process';
+/**
+ * Check if a git branch exists (local).
+ *
+ * @param branchName - Name of the branch to check
+ * @returns True if branch exists locally
+ *
+ * @example
+ * ```typescript
+ * if (await branchExists('feature-branch')) {
+ *   console.log('Branch exists')
+ * }
+ * ```
+ */
+export function branchExists(branchName) {
+    try {
+        execSync(`git show-ref --verify refs/heads/${branchName}`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the current git branch name.
+ *
+ * @returns Current branch name
+ * @throws Error if not in a git repository or unable to determine branch
+ *
+ * @example
+ * ```typescript
+ * const branch = getCurrentBranch()
+ * console.log(`Currently on: ${branch}`)
+ * ```
+ */
+export function getCurrentBranch() {
+    try {
+        const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return branch;
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`Failed to get current branch: ${err.message}`);
+    }
+}
+/**
+ * Determine which main branch exists (main or master).
+ *
+ * Returns 'main' if it exists (preferred), 'master' if it exists,
+ * or null if neither exists.
+ *
+ * @returns 'main', 'master', or null
+ *
+ * @example
+ * ```typescript
+ * const mainBranch = getMainBranch()
+ * if (mainBranch) {
+ *   console.log(`Main branch: ${mainBranch}`)
+ * }
+ * ```
+ */
+export function getMainBranch() {
+    // Check for 'main' first (more modern convention)
+    try {
+        execSync('git show-ref --verify refs/heads/main', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return 'main';
+    }
+    catch {
+        // main doesn't exist, try master
+    }
+    // Check for 'master'
+    try {
+        execSync('git show-ref --verify refs/heads/master', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return 'master';
+    }
+    catch {
+        // neither exists
+        return null;
+    }
+}
+/**
+ * Delete a git branch (local and remote if exists).
+ *
+ * @param branchName - Name of the branch to delete
+ * @param options - Command options including debug logging
+ * @throws Error if unable to delete branch
+ *
+ * @example
+ * ```typescript
+ * await deleteBranch('feature-branch', {
+ *   debugLog: (msg) => console.debug(msg)
+ * })
+ * ```
+ */
+export function deleteBranch(branchName, options) {
+    const { debugLog } = options || {};
+    // Platform-specific branch name escaping
+    const escapedBranch = process.platform === 'win32'
+        ? `"${branchName.replaceAll('"', String.raw `\"`)}"` // Windows: double quotes
+        : `'${branchName.replaceAll('\'', String.raw `'\''`)}'`; // Unix/macOS: single quotes
+    // Delete local branch
+    debugLog?.(`Deleting local branch '${branchName}'...`);
+    try {
+        execSync(`git branch -D ${escapedBranch}`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch (error) {
+        const err = error;
+        // If branch doesn't exist (orphaned worktree), that's fine - just log it
+        if (err.message?.includes('not found')) {
+            debugLog?.(`Branch '${branchName}' not found (orphaned worktree)`);
+            return;
+        }
+        // For other errors, throw
+        throw new Error(`Failed to delete branch: ${err.message}`);
+    }
+    // Check if remote branch exists
+    try {
+        execSync(`git show-ref --verify refs/remotes/origin/${branchName}`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Remote branch exists, delete it
+        debugLog?.(`Deleting remote branch '${branchName}'...`);
+        execSync(`git push origin --delete ${escapedBranch}`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch {
+        // Remote branch doesn't exist, skip deletion
+        debugLog?.('No remote branch to delete');
+    }
+}

package/dist/lib/git/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file Git utilities module.
+ *
+ * Provides reusable git operations for branch, worktree, and safety checks.
+ *
+ * @module lib/git
+ */
+export { branchExists, deleteBranch, getCurrentBranch, getMainBranch } from './branch.js';
+export { hasMergeRequest, hasUnpushedCommits } from './safety-checks.js';
+export type { GitCommandOptions, WorktreeInfo } from './types.js';
+export { createWorktree, deleteWorktreeFolder, getAllWorktrees, getWorktreePath } from './worktree.js';

package/dist/lib/git/index.js

@@ -0,0 +1,13 @@
+/**
+ * @file Git utilities module.
+ *
+ * Provides reusable git operations for branch, worktree, and safety checks.
+ *
+ * @module lib/git
+ */
+// Branch operations
+export { branchExists, deleteBranch, getCurrentBranch, getMainBranch } from './branch.js';
+// Safety checks
+export { hasMergeRequest, hasUnpushedCommits } from './safety-checks.js';
+// Worktree operations
+export { createWorktree, deleteWorktreeFolder, getAllWorktrees, getWorktreePath } from './worktree.js';

package/dist/lib/git/safety-checks.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @file Git safety check operations.
+ *
+ * Provides utilities for checking if branches are safe to delete.
+ *
+ * @module lib/git/safety-checks
+ */
+import type { GitCommandOptions } from './types.js';
+/**
+ * Check if a branch has unpushed commits.
+ *
+ * Returns true if there are commits not pushed to remote, or if
+ * the branch has no remote tracking branch (safer assumption).
+ *
+ * @param branchName - Name of the branch to check
+ * @param options - Command options including debug logging
+ * @returns True if there are unpushed commits
+ *
+ * @example
+ * ```typescript
+ * if (hasUnpushedCommits('feature-branch')) {
+ *   console.log('Branch has unpushed commits, cannot delete')
+ * }
+ * ```
+ */
+export declare function hasUnpushedCommits(branchName: string, options?: GitCommandOptions): boolean;
+/**
+ * Check if a branch has an open merge request/pull request.
+ *
+ * Uses GitHub CLI (gh) to check for open PRs. Returns false if gh is
+ * not available or if unable to check.
+ *
+ * @param branchName - Name of the branch to check
+ * @param options - Command options including debug logging
+ * @returns True if an open PR exists for this branch
+ *
+ * @example
+ * ```typescript
+ * if (hasMergeRequest('feature-branch')) {
+ *   console.log('Branch has an open PR, cannot delete')
+ * }
+ * ```
+ */
+export declare function hasMergeRequest(branchName: string, options?: GitCommandOptions): boolean;

package/dist/lib/git/safety-checks.js

@@ -0,0 +1,102 @@
+/**
+ * @file Git safety check operations.
+ *
+ * Provides utilities for checking if branches are safe to delete.
+ *
+ * @module lib/git/safety-checks
+ */
+import { execSync } from 'node:child_process';
+/**
+ * Check if a branch has unpushed commits.
+ *
+ * Returns true if there are commits not pushed to remote, or if
+ * the branch has no remote tracking branch (safer assumption).
+ *
+ * @param branchName - Name of the branch to check
+ * @param options - Command options including debug logging
+ * @returns True if there are unpushed commits
+ *
+ * @example
+ * ```typescript
+ * if (hasUnpushedCommits('feature-branch')) {
+ *   console.log('Branch has unpushed commits, cannot delete')
+ * }
+ * ```
+ */
+export function hasUnpushedCommits(branchName, options) {
+    const { debugLog } = options || {};
+    try {
+        // Check if remote branch exists first
+        const escapedBranch = branchName.replaceAll('\'', String.raw `'\''`);
+        try {
+            execSync(`git show-ref --verify refs/remotes/origin/${escapedBranch}`, {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch {
+            // No remote branch - treat as having unpushed commits (safer)
+            debugLog?.(`Branch '${branchName}' has no remote tracking branch`);
+            return true;
+        }
+        // Check if there are commits ahead of remote
+        const output = execSync(`git rev-list origin/${escapedBranch}..${escapedBranch} --count`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        const commitCount = Number.parseInt(output, 10);
+        return commitCount > 0;
+    }
+    catch (error) {
+        // If we can't determine, err on the side of caution
+        debugLog?.(`Error checking unpushed commits for '${branchName}': ${error}`);
+        return true;
+    }
+}
+/**
+ * Check if a branch has an open merge request/pull request.
+ *
+ * Uses GitHub CLI (gh) to check for open PRs. Returns false if gh is
+ * not available or if unable to check.
+ *
+ * @param branchName - Name of the branch to check
+ * @param options - Command options including debug logging
+ * @returns True if an open PR exists for this branch
+ *
+ * @example
+ * ```typescript
+ * if (hasMergeRequest('feature-branch')) {
+ *   console.log('Branch has an open PR, cannot delete')
+ * }
+ * ```
+ */
+export function hasMergeRequest(branchName, options) {
+    const { debugLog } = options || {};
+    try {
+        // Check if gh CLI is available
+        try {
+            execSync('gh --version', {
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch {
+            // gh CLI not available, can't check for PRs
+            debugLog?.('gh CLI not available, skipping PR check');
+            return false;
+        }
+        // Check for open PRs for this branch
+        const escapedBranch = branchName.replaceAll('\'', String.raw `'\''`);
+        const output = execSync(`gh pr list --head '${escapedBranch}' --state open --json number`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        // Parse JSON output
+        const prs = JSON.parse(output);
+        return prs.length > 0;
+    }
+    catch (error) {
+        // If we can't determine, assume no PR (less conservative than unpushed commits)
+        debugLog?.(`Error checking for PR on branch '${branchName}': ${error}`);
+        return false;
+    }
+}

package/dist/lib/git/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file Git-related type definitions.
+ *
+ * @module lib/git/types
+ */
+/**
+ * Information about a git worktree.
+ */
+export interface WorktreeInfo {
+    /**
+     * Branch name, or null if detached HEAD.
+     */
+    branch: null | string;
+    /**
+     * Commit hash of the worktree HEAD.
+     */
+    head: string;
+    /**
+     * Absolute path to the worktree directory.
+     */
+    path: string;
+}
+/**
+ * Options for git command execution.
+ */
+export interface GitCommandOptions {
+    /**
+     * Optional debug logging function.
+     */
+    debugLog?: (message: string) => void;
+}

package/dist/lib/git/types.js

@@ -0,0 +1,6 @@
+/**
+ * @file Git-related type definitions.
+ *
+ * @module lib/git/types
+ */
+export {};

package/dist/lib/git/worktree.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @file Git worktree operations.
+ *
+ * Provides utilities for managing git worktrees.
+ *
+ * @module lib/git/worktree
+ */
+import type { GitCommandOptions, WorktreeInfo } from './types.js';
+/**
+ * Get all worktrees in the repository.
+ *
+ * @returns Array of worktree info objects
+ * @throws Error if unable to list worktrees
+ *
+ * @example
+ * ```typescript
+ * const worktrees = getAllWorktrees()
+ * for (const wt of worktrees) {
+ *   console.log(`${wt.branch}: ${wt.path}`)
+ * }
+ * ```
+ */
+export declare function getAllWorktrees(): WorktreeInfo[];
+/**
+ * Get the worktree path for a branch.
+ *
+ * @param branchName - Name of the branch
+ * @returns Worktree path if found, null otherwise
+ *
+ * @example
+ * ```typescript
+ * const path = getWorktreePath('main')
+ * if (path) {
+ *   console.log(`Main branch worktree: ${path}`)
+ * }
+ * ```
+ */
+export declare function getWorktreePath(branchName: string): null | string;
+/**
+ * Create a git worktree with the specified branch name.
+ *
+ * @param branchName - Name of the branch to create
+ * @param worktreePath - Path where the worktree should be created
+ * @returns Promise that resolves when worktree is created
+ * @throws Error if unable to create worktree
+ *
+ * @example
+ * ```typescript
+ * await createWorktree('feature-branch', '/path/to/worktree')
+ * ```
+ */
+export declare function createWorktree(branchName: string, worktreePath: string): Promise<void>;
+/**
+ * Delete a worktree folder and remove worktree from git.
+ *
+ * @param worktreePath - Path to the worktree to delete
+ * @param options - Command options including debug logging
+ * @throws Error if unable to delete worktree folder
+ *
+ * @example
+ * ```typescript
+ * await deleteWorktreeFolder('/path/to/worktree', {
+ *   debugLog: (msg) => console.debug(msg)
+ * })
+ * ```
+ */
+export declare function deleteWorktreeFolder(worktreePath: string, options?: GitCommandOptions): Promise<void>;