@avantmedia/af 0.0.1

package/commands/worktree.ts

@@ -0,0 +1,424 @@
+import { execSync, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, copyFileSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import {
+    hasUncommittedChanges,
+    listWorktrees,
+    resetWorktree,
+    type Worktree,
+} from '../git-worktree.ts';
+import { error, info, success } from '../utils/output.ts';
+
+/**
+ * Check if we're in a git repository.
+ *
+ * @returns true if in a git repository, false otherwise
+ */
+export function isGitRepository(): boolean {
+    try {
+        execSync('git rev-parse --is-inside-work-tree', { stdio: 'pipe' });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Get the root directory of the current git repository.
+ *
+ * @returns The absolute path to the git root, or null if not in a repo
+ */
+export function getGitRoot(): string | null {
+    try {
+        return execSync('git rev-parse --show-toplevel', { stdio: 'pipe' }).toString().trim();
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Check if a worktree already exists at the given path.
+ *
+ * @param path - The path to check
+ * @returns true if a directory exists at the path
+ */
+export function worktreeExists(path: string): boolean {
+    return existsSync(path);
+}
+
+/**
+ * Parse .git/info/exclude file and return patterns.
+ * Filters out comments and empty lines.
+ *
+ * @param gitRoot - The root of the git repository
+ * @returns Array of exclude patterns
+ */
+export function parseGitInfoExclude(gitRoot: string): string[] {
+    const excludePath = join(gitRoot, '.git', 'info', 'exclude');
+
+    if (!existsSync(excludePath)) {
+        return [];
+    }
+
+    try {
+        const content = readFileSync(excludePath, 'utf-8');
+        return content
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line.length > 0 && !line.startsWith('#'));
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Find files matching patterns in .git/info/exclude using git ls-files.
+ * Uses git's native pattern matching to avoid reimplementing gitignore logic.
+ *
+ * @param gitRoot - The root of the git repository
+ * @returns Array of file paths that are excluded
+ */
+export function findExcludedFiles(gitRoot: string): string[] {
+    const excludePath = join(gitRoot, '.git', 'info', 'exclude');
+
+    if (!existsSync(excludePath)) {
+        return [];
+    }
+
+    try {
+        // Use git ls-files to find files matching exclude patterns
+        const result = execSync(`git ls-files --others --ignored --exclude-from="${excludePath}"`, {
+            cwd: gitRoot,
+            stdio: 'pipe',
+        });
+        const files = result.toString().trim().split('\n').filter(Boolean);
+        return files;
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Get the list of files to copy to the new worktree.
+ * Includes .env, .env.local, and files matching .git/info/exclude patterns.
+ *
+ * @param gitRoot - The root of the git repository
+ * @returns Array of file paths to copy
+ */
+export function getFilesToCopy(gitRoot: string): string[] {
+    const files: string[] = [];
+
+    // Add .env files if they exist
+    const envFiles = ['.env', '.env.local'];
+    for (const envFile of envFiles) {
+        const envPath = join(gitRoot, envFile);
+        if (existsSync(envPath)) {
+            files.push(envFile);
+        }
+    }
+
+    // Add files from .git/info/exclude
+    const excludedFiles = findExcludedFiles(gitRoot);
+    files.push(...excludedFiles);
+
+    // Remove duplicates
+    return [...new Set(files)];
+}
+
+/**
+ * Copy a file to the worktree, creating parent directories if needed.
+ *
+ * @param sourceRoot - The source git root directory
+ * @param targetRoot - The target worktree directory
+ * @param relativePath - The relative path of the file to copy
+ * @returns true if copy succeeded, false otherwise
+ */
+export function copyFileToWorktree(
+    sourceRoot: string,
+    targetRoot: string,
+    relativePath: string,
+): boolean {
+    const sourcePath = join(sourceRoot, relativePath);
+    const targetPath = join(targetRoot, relativePath);
+
+    try {
+        // Create parent directories if needed
+        const targetDir = dirname(targetPath);
+        if (!existsSync(targetDir)) {
+            mkdirSync(targetDir, { recursive: true });
+        }
+
+        copyFileSync(sourcePath, targetPath);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Create a git worktree at the specified path.
+ *
+ * @param name - The name of the worktree (used for branch name and directory)
+ * @param detach - If true, create with detached HEAD instead of new branch
+ * @returns Object with success status and optional error message
+ */
+export function createWorktree(
+    name: string,
+    detach: boolean = false,
+): { success: boolean; error?: string; path?: string } {
+    const gitRoot = getGitRoot();
+    if (!gitRoot) {
+        return { success: false, error: 'Not in a git repository' };
+    }
+
+    // Calculate target path as sibling directory
+    const parentDir = dirname(gitRoot);
+    const targetPath = resolve(parentDir, name);
+
+    // Check if target already exists
+    if (worktreeExists(targetPath)) {
+        return { success: false, error: `Directory already exists: ${targetPath}` };
+    }
+
+    // Build git worktree add command
+    const args = detach
+        ? ['worktree', 'add', '--detach', targetPath]
+        : ['worktree', 'add', '-b', name, targetPath];
+
+    const result = spawnSync('git', args, { cwd: gitRoot, stdio: 'pipe' });
+
+    if (result.status !== 0) {
+        const stderr = result.stderr?.toString().trim() || 'Unknown error';
+        return { success: false, error: stderr };
+    }
+
+    return { success: true, path: targetPath };
+}
+
+/**
+ * Handle the 'worktree new <name>' command.
+ * Creates a new git worktree as a sibling directory and copies env files.
+ *
+ * @param name - The name for the worktree (also used as branch name)
+ * @param detach - If true, create with detached HEAD instead of new branch
+ * @returns Exit code (0 for success, 1 for error)
+ */
+export function handleWorktreeNew(name: string | undefined, detach: boolean = false): number {
+    // Validate name is provided
+    if (!name || name.trim() === '') {
+        error('Error: worktree new requires a name');
+        console.error('Usage: af worktree new <name> [--detach]');
+        return 1;
+    }
+
+    // Check if in a git repository
+    if (!isGitRepository()) {
+        error('Error: Not in a git repository');
+        return 1;
+    }
+
+    const gitRoot = getGitRoot();
+    if (!gitRoot) {
+        error('Error: Could not determine git root');
+        return 1;
+    }
+
+    // Create the worktree
+    info(`Creating worktree '${name}'${detach ? ' (detached)' : ' with new branch'}...`);
+    const result = createWorktree(name, detach);
+
+    if (!result.success) {
+        error(`Error: ${result.error}`);
+        return 1;
+    }
+
+    const targetPath = result.path!;
+    success(`Worktree created at ${targetPath}`);
+
+    // Copy files
+    const filesToCopy = getFilesToCopy(gitRoot);
+    if (filesToCopy.length > 0) {
+        info(`Copying ${filesToCopy.length} file(s)...`);
+        let copied = 0;
+        for (const file of filesToCopy) {
+            if (copyFileToWorktree(gitRoot, targetPath, file)) {
+                copied++;
+            }
+        }
+        success(`Copied ${copied} file(s)`);
+    }
+
+    return 0;
+}
+
+/**
+ * Get the current worktree information if running from within a worktree.
+ *
+ * Compares the current working directory against the list of worktrees
+ * to determine if we're in a worktree (excluding the main repository).
+ *
+ * @returns The current worktree if in one, or null if in the main repository
+ */
+export function getCurrentWorktree(): Worktree | null {
+    const currentPath = getGitRoot();
+    if (!currentPath) {
+        return null;
+    }
+
+    const worktrees = listWorktrees();
+
+    // The first worktree in the list is typically the main repository
+    // We need to find if current path matches any non-main worktree
+    for (let i = 1; i < worktrees.length; i++) {
+        if (worktrees[i].path === currentPath) {
+            return worktrees[i];
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Find a worktree by its branch name.
+ *
+ * @param name - The branch name to search for
+ * @returns The worktree if found, or null
+ */
+export function findWorktreeByName(name: string): Worktree | null {
+    const worktrees = listWorktrees();
+    return worktrees.find(wt => wt.branch === name) || null;
+}
+
+/**
+ * Get the main repository's worktree (the first in the list).
+ *
+ * @returns The main repository worktree, or null if not in a repo
+ */
+export function getMainWorktree(): Worktree | null {
+    const worktrees = listWorktrees();
+    return worktrees.length > 0 ? worktrees[0] : null;
+}
+
+/**
+ * Handle the 'worktree reset [name]' command.
+ * Resets a worktree to the current HEAD revision.
+ *
+ * @param name - Optional worktree name (branch). If not provided, resets current worktree.
+ * @returns Exit code (0 for success, 1 for error)
+ */
+export function handleWorktreeReset(name: string | undefined): number {
+    // Check if in a git repository
+    if (!isGitRepository()) {
+        error('Error: Not in a git repository');
+        return 1;
+    }
+
+    let targetWorktree: Worktree | null;
+
+    if (name) {
+        // Find worktree by name
+        targetWorktree = findWorktreeByName(name);
+        if (!targetWorktree) {
+            error(`Error: Worktree '${name}' not found`);
+            return 1;
+        }
+    } else {
+        // Use current worktree
+        targetWorktree = getCurrentWorktree();
+        if (!targetWorktree) {
+            error(
+                'Error: Not in a worktree. Specify a worktree name or run from within a worktree.',
+            );
+            return 1;
+        }
+    }
+
+    // Get the main repository to get its HEAD commit
+    const mainWorktree = getMainWorktree();
+    if (!mainWorktree) {
+        error('Error: Could not find main repository');
+        return 1;
+    }
+
+    // Get current HEAD commit from the main repository
+    let targetRevision: string;
+    try {
+        targetRevision = execSync('git rev-parse HEAD', {
+            cwd: mainWorktree.path,
+            encoding: 'utf-8',
+        }).trim();
+    } catch (err) {
+        if (err instanceof Error) {
+            error(`Error: Failed to get current HEAD commit: ${err.message}`);
+        } else {
+            error('Error: Failed to get current HEAD commit');
+        }
+        return 1;
+    }
+
+    // Check for uncommitted changes
+    try {
+        if (hasUncommittedChanges(targetWorktree.path)) {
+            error('Error: Cannot reset worktree with uncommitted changes');
+            console.error(`Worktree '${targetWorktree.branch}' at ${targetWorktree.path}`);
+            console.error('\nPlease commit or stash changes and try again.');
+            console.error('You can check the status by running: git status');
+            return 1;
+        }
+    } catch (err) {
+        if (err instanceof Error) {
+            error(err.message);
+        } else {
+            error(`Failed to check worktree '${targetWorktree.branch}'`);
+        }
+        return 1;
+    }
+
+    // Reset the worktree
+    info(`Resetting worktree ${targetWorktree.branch}...`);
+    try {
+        resetWorktree(targetWorktree.path, targetRevision);
+    } catch (err) {
+        if (err instanceof Error) {
+            error(err.message);
+        } else {
+            error(`Failed to reset worktree '${targetWorktree.branch}'`);
+        }
+        return 1;
+    }
+
+    success(`Successfully reset worktree '${targetWorktree.branch}'`);
+    return 0;
+}
+
+/**
+ * Handle the 'worktree' command routing.
+ *
+ * @param args - Command arguments after 'worktree'
+ * @returns Exit code (0 for success, 1 for error)
+ */
+export async function handleWorktree(args: string[]): Promise<number> {
+    const [subcommand, ...restArgs] = args;
+
+    if (subcommand === 'new') {
+        // Parse arguments
+        const detach = restArgs.includes('--detach');
+        const name = restArgs.find(arg => !arg.startsWith('--'));
+        return handleWorktreeNew(name, detach);
+    }
+
+    if (subcommand === 'reset') {
+        const name = restArgs.find(arg => !arg.startsWith('--'));
+        return handleWorktreeReset(name);
+    }
+
+    if (!subcommand) {
+        error('Error: worktree command requires a subcommand');
+        console.error("Run 'af help worktree' for more information.");
+        return 1;
+    }
+
+    error(`Error: Unknown worktree subcommand: ${subcommand}`);
+    console.error("Run 'af help worktree' for available subcommands.");
+    return 1;
+}

package/components/change-select.tsx

@@ -0,0 +1,71 @@
+import { Box, Text, useApp, useInput } from 'ink';
+import React, { useState } from 'react';
+import type { OngoingChange } from '../utils/openspec.ts';
+
+/**
+ * Props for ChangeSelect component
+ */
+export interface ChangeSelectProps {
+    /** Array of ongoing changes to choose from */
+    changes: OngoingChange[];
+    /** Callback when a change is selected */
+    onSelect: (changeId: string) => void;
+    /** Callback when selection is cancelled */
+    onCancel: () => void;
+    /** Custom prompt text to display (default: "Select a change:") */
+    prompt?: string;
+}
+
+/**
+ * Interactive change selection component for commands that need to select from ongoing changes.
+ * Allows users to select from multiple ongoing changes using keyboard navigation.
+ */
+export function ChangeSelect({
+    changes,
+    onSelect,
+    onCancel,
+    prompt = 'Select a change:',
+}: ChangeSelectProps) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const { exit } = useApp();
+
+    useInput((input, key) => {
+        if (key.upArrow) {
+            setSelectedIndex(prev => (prev > 0 ? prev - 1 : changes.length - 1));
+        } else if (key.downArrow) {
+            setSelectedIndex(prev => (prev < changes.length - 1 ? prev + 1 : 0));
+        } else if (key.return) {
+            const selectedChange = changes[selectedIndex];
+            onSelect(selectedChange.id);
+        } else if (key.escape || (key.ctrl && input === 'c')) {
+            onCancel();
+            exit();
+        }
+    });
+
+    return (
+        <Box flexDirection="column">
+            <Box marginBottom={1}>
+                <Text bold color="cyan">
+                    {prompt}
+                </Text>
+            </Box>
+            {changes.map((change, index) => {
+                const isHighlighted = index === selectedIndex;
+                const indicator = isHighlighted ? '›' : ' ';
+
+                return (
+                    <Box key={change.id}>
+                        <Text color={isHighlighted ? 'cyan' : undefined}>
+                            {indicator} {change.id}
+                        </Text>
+                        <Text color="gray"> ({change.status})</Text>
+                    </Box>
+                );
+            })}
+            <Box marginTop={1}>
+                <Text color="gray">↑/↓ to navigate, Enter to select, Esc to cancel</Text>
+            </Box>
+        </Box>
+    );
+}

package/components/confirm.tsx

@@ -0,0 +1,41 @@
+import { Box, Text, useInput } from 'ink';
+
+/**
+ * Props for Confirm component
+ */
+export interface ConfirmProps {
+    /** The question to ask the user */
+    message: string;
+    /** Default value (default: false) */
+    defaultValue?: boolean;
+    /** Callback when user confirms (true) or denies (false) */
+    onConfirm?: (confirmed: boolean) => void;
+}
+
+/**
+ * Confirm component for yes/no prompts
+ * Accepts y/n or yes/no input
+ */
+export function Confirm({ message, defaultValue = false, onConfirm }: ConfirmProps) {
+    useInput(input => {
+        const normalized = input.toLowerCase();
+
+        if (normalized === 'y' || normalized === 'yes') {
+            onConfirm?.(true);
+        } else if (normalized === 'n' || normalized === 'no') {
+            onConfirm?.(false);
+        } else if (input === '') {
+            // Enter with no input uses default
+            onConfirm?.(defaultValue);
+        }
+    });
+
+    const hint = defaultValue ? '(Y/n)' : '(y/N)';
+
+    return (
+        <Box>
+            <Text>{message} </Text>
+            <Text color="gray">{hint}</Text>
+        </Box>
+    );
+}

package/components/file-conflict.tsx

@@ -0,0 +1,52 @@
+import { Box, Text, useInput } from 'ink';
+import type { ConflictResolution } from '../utils/setup-files.ts';
+
+/**
+ * Props for FileConflict component
+ */
+export interface FileConflictProps {
+    /** The file path that has a conflict */
+    filePath: string;
+    /** Callback when user makes a resolution choice */
+    onResolve: (resolution: ConflictResolution) => void;
+}
+
+/**
+ * Interactive component for resolving file conflicts during setup.
+ * Displays the conflicting file path and accepts keyboard input:
+ * - y: Overwrite this file
+ * - n: Skip this file
+ * - a: Overwrite all remaining files
+ * - s: Skip all remaining files
+ */
+export function FileConflict({ filePath, onResolve }: FileConflictProps) {
+    useInput(input => {
+        const key = input.toLowerCase();
+        switch (key) {
+            case 'y':
+                onResolve('overwrite');
+                break;
+            case 'n':
+                onResolve('skip');
+                break;
+            case 'a':
+                onResolve('overwrite-all');
+                break;
+            case 's':
+                onResolve('skip-all');
+                break;
+        }
+    });
+
+    return (
+        <Box flexDirection="column">
+            <Box>
+                <Text color="yellow">File exists: </Text>
+                <Text>{filePath}</Text>
+            </Box>
+            <Box marginTop={1}>
+                <Text color="gray">[y] Overwrite [n] Skip [a] Overwrite all [s] Skip all</Text>
+            </Box>
+        </Box>
+    );
+}

package/components/input.tsx

@@ -0,0 +1,53 @@
+import { Box, Text, useInput } from 'ink';
+import { useState } from 'react';
+
+/**
+ * Props for TextInput component
+ */
+export interface TextInputProps {
+    /** Placeholder text to display when input is empty */
+    placeholder?: string;
+    /** Initial value of the input */
+    value?: string;
+    /** Callback when input value changes */
+    onChange?: (value: string) => void;
+    /** Callback when user presses Enter */
+    onSubmit?: (value: string) => void;
+}
+
+/**
+ * TextInput component for user text input
+ * Provides controlled text input with keyboard handling
+ */
+export function TextInput({
+    placeholder = '',
+    value: initialValue = '',
+    onChange,
+    onSubmit,
+}: TextInputProps) {
+    const [value, setValue] = useState(initialValue);
+
+    useInput((input, key) => {
+        if (key.return) {
+            // Enter key pressed
+            onSubmit?.(value);
+        } else if (key.backspace || key.delete) {
+            // Backspace/Delete key pressed
+            const newValue = value.slice(0, -1);
+            setValue(newValue);
+            onChange?.(newValue);
+        } else if (!key.ctrl && !key.meta && !key.escape) {
+            // Regular character input
+            const newValue = value + input;
+            setValue(newValue);
+            onChange?.(newValue);
+        }
+    });
+
+    return (
+        <Box>
+            <Text>{value || <Text color="gray">{placeholder}</Text>}</Text>
+            <Text color="cyan">█</Text>
+        </Box>
+    );
+}