@avantmedia/af 0.0.1

package/components/layout.tsx

@@ -0,0 +1,70 @@
+import { createElement } from 'react';
+import { Box, Text } from 'ink';
+
+/**
+ * Props for Header component
+ */
+export interface HeaderProps {
+    children: string;
+}
+
+/**
+ * Header component (blue with newline before)
+ * Displays a section header in blue text with spacing
+ */
+export function Header({ children }: HeaderProps) {
+    return (
+        <Box flexDirection="column">
+            <Text>{''}</Text>
+            <Text color="blue">{children}</Text>
+        </Box>
+    );
+}
+
+/**
+ * Props for Section component
+ */
+export interface SectionProps {
+    children: string;
+}
+
+/**
+ * Section component (cyan with newline before)
+ * Displays a sub-section header in cyan text with spacing
+ */
+export function Section({ children }: SectionProps) {
+    return (
+        <Box flexDirection="column">
+            <Text>{''}</Text>
+            <Text color="cyan">{children}</Text>
+        </Box>
+    );
+}
+
+/**
+ * Props for ListItem component
+ */
+export interface ListItemProps {
+    children: string;
+    symbol?: string;
+}
+
+/**
+ * ListItem component (gray symbol with indentation)
+ * Displays a list item with a symbol prefix and indentation
+ */
+export function ListItem({ children, symbol = '•' }: ListItemProps) {
+    return (
+        <Box>
+            <Text> </Text>
+            <Text color="gray">{symbol}</Text>
+            <Text> {children}</Text>
+        </Box>
+    );
+}
+
+// Helper functions to create elements without JSX (for use in .ts files)
+export const createHeader = (children: string) => createElement(Header, { children });
+export const createSection = (children: string) => createElement(Section, { children });
+export const createListItem = (children: string, symbol?: string) =>
+    createElement(ListItem, { children, symbol });

package/components/messages.tsx

@@ -0,0 +1,48 @@
+import { createElement } from 'react';
+import { Text } from 'ink';
+
+/**
+ * Props for message components
+ */
+export interface MessageProps {
+    message: string;
+    children?: never;
+}
+
+/**
+ * Success message component (green)
+ * Displays a success message in green text
+ */
+export function Success({ message }: MessageProps) {
+    return <Text color="green">{message}</Text>;
+}
+
+/**
+ * Error message component (red)
+ * Displays an error message in red text
+ */
+export function Error({ message }: MessageProps) {
+    return <Text color="red">{message}</Text>;
+}
+
+/**
+ * Info message component (cyan)
+ * Displays an informational message in cyan text
+ */
+export function Info({ message }: MessageProps) {
+    return <Text color="cyan">{message}</Text>;
+}
+
+/**
+ * Warning message component (yellow)
+ * Displays a warning message in yellow text
+ */
+export function Warn({ message }: MessageProps) {
+    return <Text color="yellow">{message}</Text>;
+}
+
+// Helper functions to create elements without JSX (for use in .ts files)
+export const createSuccess = (message: string) => createElement(Success, { message });
+export const createError = (message: string) => createElement(Error, { message });
+export const createInfo = (message: string) => createElement(Info, { message });
+export const createWarn = (message: string) => createElement(Warn, { message });

package/components/progress.tsx

@@ -0,0 +1,71 @@
+import { Box, Text } from 'ink';
+import { useEffect, useState } from 'react';
+
+/**
+ * Props for Spinner component
+ */
+export interface SpinnerProps {
+    label?: string;
+}
+
+/**
+ * Spinner component with rotating animation
+ * Displays an animated spinner with optional label
+ */
+export function Spinner({ label }: SpinnerProps) {
+    const [frame, setFrame] = useState(0);
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame(prevFrame => (prevFrame + 1) % frames.length);
+        }, 80);
+
+        return () => clearInterval(timer);
+    }, [frames.length]);
+
+    return (
+        <Box>
+            <Text color="cyan">{frames[frame]}</Text>
+            {label && <Text> {label}</Text>}
+        </Box>
+    );
+}
+
+/**
+ * Props for ProgressBar component
+ */
+export interface ProgressBarProps {
+    /** Current progress value (0-100) */
+    value: number;
+    /** Width of the progress bar in characters (default: 40) */
+    width?: number;
+    /** Optional label to display */
+    label?: string;
+    /** Show percentage (default: true) */
+    showPercentage?: boolean;
+}
+
+/**
+ * ProgressBar component with visual bar display
+ * Displays a progress bar with percentage and optional label
+ */
+export function ProgressBar({ value, width = 40, label, showPercentage = true }: ProgressBarProps) {
+    const percentage = Math.min(100, Math.max(0, value));
+    const filledWidth = Math.round((percentage / 100) * width);
+    const emptyWidth = width - filledWidth;
+
+    const filledBar = '█'.repeat(filledWidth);
+    const emptyBar = '░'.repeat(emptyWidth);
+
+    return (
+        <Box flexDirection="column">
+            {label && <Text>{label}</Text>}
+            <Box>
+                <Text color="green">{filledBar}</Text>
+                <Text color="gray">{emptyBar}</Text>
+                {showPercentage && <Text> {percentage.toFixed(0)}%</Text>}
+            </Box>
+        </Box>
+    );
+}

package/components/select.tsx

@@ -0,0 +1,90 @@
+import { Box, Text, useInput } from 'ink';
+import { useState } from 'react';
+
+/**
+ * Option for Select component
+ */
+export interface SelectOption {
+    label: string;
+    value: string;
+}
+
+/**
+ * Props for Select component
+ */
+export interface SelectProps {
+    /** Array of options to choose from */
+    options: SelectOption[];
+    /** Callback when an option is selected */
+    onSelect?: (value: string) => void;
+    /** Enable multi-select mode (default: false) */
+    multiSelect?: boolean;
+    /** Callback for multi-select completion */
+    onSubmit?: (values: string[]) => void;
+}
+
+/**
+ * Select component with keyboard navigation
+ * Provides option selection with up/down arrow keys and Enter to confirm
+ */
+export function Select({ options, onSelect, multiSelect = false, onSubmit }: SelectProps) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [selectedValues, setSelectedValues] = useState<Set<string>>(new Set());
+
+    useInput((input, key) => {
+        if (key.upArrow) {
+            setSelectedIndex(prev => (prev > 0 ? prev - 1 : options.length - 1));
+        } else if (key.downArrow) {
+            setSelectedIndex(prev => (prev < options.length - 1 ? prev + 1 : 0));
+        } else if (key.return) {
+            const selectedOption = options[selectedIndex];
+            if (multiSelect) {
+                // Toggle selection in multi-select mode
+                setSelectedValues(prev => {
+                    const next = new Set(prev);
+                    if (next.has(selectedOption.value)) {
+                        next.delete(selectedOption.value);
+                    } else {
+                        next.add(selectedOption.value);
+                    }
+                    return next;
+                });
+            } else {
+                // Single select mode
+                onSelect?.(selectedOption.value);
+            }
+        } else if (input === ' ' && multiSelect) {
+            // Space bar submits in multi-select mode
+            onSubmit?.(Array.from(selectedValues));
+        }
+    });
+
+    return (
+        <Box flexDirection="column">
+            {options.map((option, index) => {
+                const isHighlighted = index === selectedIndex;
+                const isSelected = selectedValues.has(option.value);
+                const indicator = multiSelect
+                    ? isSelected
+                        ? '[✓]'
+                        : '[ ]'
+                    : isHighlighted
+                      ? '›'
+                      : ' ';
+
+                return (
+                    <Box key={option.value}>
+                        <Text color={isHighlighted ? 'cyan' : undefined}>
+                            {indicator} {option.label}
+                        </Text>
+                    </Box>
+                );
+            })}
+            {multiSelect && (
+                <Box marginTop={1}>
+                    <Text color="gray">Press Enter to toggle, Space to submit</Text>
+                </Box>
+            )}
+        </Box>
+    );
+}

package/components/status-display.tsx

@@ -0,0 +1,74 @@
+import { Box, Text } from 'ink';
+
+/**
+ * Status type for display
+ */
+export type StatusType = 'pending' | 'running' | 'success' | 'error';
+
+/**
+ * Single status line item
+ */
+export interface StatusLine {
+    id: string;
+    message: string;
+    status: StatusType;
+}
+
+/**
+ * Props for StatusDisplay component
+ */
+export interface StatusDisplayProps {
+    /** Array of status lines to display */
+    statuses: StatusLine[];
+}
+
+/**
+ * Get the appropriate icon for a status type
+ */
+function getStatusIcon(status: StatusType): string {
+    switch (status) {
+        case 'pending':
+            return '○';
+        case 'running':
+            return '⟳';
+        case 'success':
+            return '✓';
+        case 'error':
+            return '✗';
+    }
+}
+
+/**
+ * Get the appropriate color for a status type
+ */
+function getStatusColor(status: StatusType): string {
+    switch (status) {
+        case 'pending':
+            return 'gray';
+        case 'running':
+            return 'cyan';
+        case 'success':
+            return 'green';
+        case 'error':
+            return 'red';
+    }
+}
+
+/**
+ * StatusDisplay component for tracking multiple operations
+ * Displays multiple status lines that can be independently updated
+ */
+export function StatusDisplay({ statuses }: StatusDisplayProps) {
+    return (
+        <Box flexDirection="column">
+            {statuses.map(statusLine => (
+                <Box key={statusLine.id}>
+                    <Text color={getStatusColor(statusLine.status)}>
+                        {getStatusIcon(statusLine.status)}
+                    </Text>
+                    <Text> {statusLine.message}</Text>
+                </Box>
+            ))}
+        </Box>
+    );
+}

package/components/table.tsx

@@ -0,0 +1,79 @@
+import { Box, Text } from 'ink';
+
+/**
+ * Column definition for Table component
+ */
+export interface TableColumn<T> {
+    /** Column header text */
+    header: string;
+    /** Key or accessor function to get the cell value */
+    accessor: keyof T | ((row: T) => string | number);
+    /** Optional width (auto-calculated if not provided) */
+    width?: number;
+}
+
+/**
+ * Props for Table component
+ */
+export interface TableProps<T> {
+    /** Array of data rows */
+    data: T[];
+    /** Column definitions */
+    columns: TableColumn<T>[];
+}
+
+/**
+ * Table component with flexible column layout
+ * Uses Flexbox for column layout with automatic width calculation
+ */
+export function Table<T>({ data, columns }: TableProps<T>) {
+    // Helper function to get cell value
+    const getCellValue = (row: T, column: TableColumn<T>): string => {
+        if (typeof column.accessor === 'function') {
+            return String(column.accessor(row));
+        }
+        return String(row[column.accessor]);
+    };
+
+    // Calculate column widths based on content if not specified
+    const columnWidths = columns.map(column => {
+        if (column.width) {
+            return column.width;
+        }
+
+        // Calculate based on header and data content
+        const headerLength = column.header.length;
+        const maxDataLength = Math.max(...data.map(row => getCellValue(row, column).length), 0);
+
+        return Math.max(headerLength, maxDataLength);
+    });
+
+    return (
+        <Box flexDirection="column">
+            {/* Header row */}
+            <Box>
+                {columns.map((column, index) => (
+                    <Box key={column.header} width={columnWidths[index] + 2}>
+                        <Text bold color="cyan">
+                            {column.header.padEnd(columnWidths[index])}
+                        </Text>
+                    </Box>
+                ))}
+            </Box>
+
+            {/* Data rows */}
+            {data.map((row, rowIndex) => (
+                <Box key={rowIndex}>
+                    {columns.map((column, colIndex) => {
+                        const cellValue = getCellValue(row, column);
+                        return (
+                            <Box key={colIndex} width={columnWidths[colIndex] + 2}>
+                                <Text>{cellValue.padEnd(columnWidths[colIndex])}</Text>
+                            </Box>
+                        );
+                    })}
+                </Box>
+            ))}
+        </Box>
+    );
+}

package/generated/setup-manifest.ts

@@ -0,0 +1,67 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ * Generated by scripts/generate-setup-manifest.ts
+ *
+ * This file embeds all setup files and resources into the compiled binary using
+ * Bun's file import attribute. Regenerate after modifying setup/ or resources/ contents.
+ */
+
+import file_claude_commands_start_work_md from '../setup/.claude/commands/start-work.md' with { type: 'file' };
+import file_claude_commands_complete_work_md from '../setup/.claude/commands/complete-work.md' with { type: 'file' };
+import file_claude_commands_e2e_md from '../setup/.claude/commands/e2e.md' with { type: 'file' };
+import file_claude_commands_commit_work_md from '../setup/.claude/commands/commit-work.md' with { type: 'file' };
+import file_claude_skills_pm_SKILL_md from '../setup/.claude/skills/pm/SKILL.md' with { type: 'file' };
+import file_claude_skills_pm_templates_bug_fix_md from '../setup/.claude/skills/pm/templates/bug-fix.md' with { type: 'file' };
+import file_claude_skills_pm_templates_ui_component_md from '../setup/.claude/skills/pm/templates/ui-component.md' with { type: 'file' };
+import file_claude_skills_pm_templates_api_endpoint_md from '../setup/.claude/skills/pm/templates/api-endpoint.md' with { type: 'file' };
+import file_claude_skills_pm_templates_feature_md from '../setup/.claude/skills/pm/templates/feature.md' with { type: 'file' };
+
+import resource_copy_prompt_reporter_ts from '../resources/copy-prompt-reporter.ts' with { type: 'file' };
+
+import extension_avantmedia_openspec_0_1_0_vsix from '../vscode-extension/avantmedia-openspec-0.1.0.vsix' with { type: 'file' };
+
+export interface SetupFile {
+    /** Path relative to setup/ folder (e.g., ".claude/settings.local.json") */
+    relativePath: string;
+    /** Path to embedded file (bun internal path or dev file path) */
+    embeddedPath: string;
+}
+
+export interface ResourceFile {
+    /** File name (e.g., "copy-prompt-reporter.ts") */
+    name: string;
+    /** Path to embedded file (bun internal path or dev file path) */
+    embeddedPath: string;
+}
+
+export const SETUP_FILES: SetupFile[] = [
+    { relativePath: '.claude/commands/start-work.md', embeddedPath: file_claude_commands_start_work_md },
+    { relativePath: '.claude/commands/complete-work.md', embeddedPath: file_claude_commands_complete_work_md },
+    { relativePath: '.claude/commands/e2e.md', embeddedPath: file_claude_commands_e2e_md },
+    { relativePath: '.claude/commands/commit-work.md', embeddedPath: file_claude_commands_commit_work_md },
+    { relativePath: '.claude/skills/pm/SKILL.md', embeddedPath: file_claude_skills_pm_SKILL_md },
+    { relativePath: '.claude/skills/pm/templates/bug-fix.md', embeddedPath: file_claude_skills_pm_templates_bug_fix_md },
+    { relativePath: '.claude/skills/pm/templates/ui-component.md', embeddedPath: file_claude_skills_pm_templates_ui_component_md },
+    { relativePath: '.claude/skills/pm/templates/api-endpoint.md', embeddedPath: file_claude_skills_pm_templates_api_endpoint_md },
+    { relativePath: '.claude/skills/pm/templates/feature.md', embeddedPath: file_claude_skills_pm_templates_feature_md },
+];
+
+export const RESOURCE_FILES: ResourceFile[] = [
+    { name: 'copy-prompt-reporter.ts', embeddedPath: resource_copy_prompt_reporter_ts },
+];
+
+export interface ExtensionFile {
+    /** File name (e.g., "openspec-0.1.0.vsix") */
+    name: string;
+    /** Path to embedded file (bun internal path or dev file path) */
+    embeddedPath: string;
+}
+
+export const EXTENSION_FILE: ExtensionFile | null = { name: 'avantmedia-openspec-0.1.0.vsix', embeddedPath: extension_avantmedia_openspec_0_1_0_vsix };
+
+/**
+ * Check if running from compiled binary (embedded files contain $bunfs in path)
+ */
+export function isCompiled(): boolean {
+    return SETUP_FILES.length > 0 && SETUP_FILES[0].embeddedPath.includes('$bunfs');
+}

package/git-worktree.ts

@@ -0,0 +1,184 @@
+import { execSync } from 'node:child_process';
+
+export interface Worktree {
+    path: string;
+    branch: string;
+}
+
+/**
+ * Checks if the current directory is inside a git repository.
+ *
+ * @returns true if inside a git repository, false otherwise
+ */
+export function isGitRepository(): boolean {
+    try {
+        execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Gets the current HEAD commit hash.
+ *
+ * @returns The current HEAD commit hash
+ * @throws Error if unable to get HEAD commit
+ */
+export function getCurrentHeadCommit(): string {
+    try {
+        const commit = execSync('git rev-parse HEAD', { encoding: 'utf-8' }).trim();
+        return commit;
+    } catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to get current HEAD commit: ${error.message}`);
+        }
+        throw new Error('Failed to get current HEAD commit');
+    }
+}
+
+/**
+ * Lists all git worktrees in the repository.
+ *
+ * Parses the output of `git worktree list --porcelain` to extract
+ * worktree paths and their associated branches.
+ *
+ * @returns Array of worktree objects with path and branch information
+ * @throws Error if unable to list worktrees
+ */
+export function listWorktrees(): Worktree[] {
+    try {
+        const output = execSync('git worktree list --porcelain', { encoding: 'utf-8' });
+        return parseWorktreeList(output);
+    } catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to list worktrees: ${error.message}`);
+        }
+        throw new Error('Failed to list worktrees');
+    }
+}
+
+/**
+ * Parses the porcelain output from `git worktree list --porcelain`.
+ *
+ * The porcelain format outputs each worktree as a block separated by blank lines:
+ * worktree <path>
+ * HEAD <sha>
+ * branch <branch-ref>
+ *
+ * @param output The raw output from git worktree list --porcelain
+ * @returns Array of parsed worktree objects
+ */
+function parseWorktreeList(output: string): Worktree[] {
+    const worktrees: Worktree[] = [];
+    const lines = output.trim().split('\n');
+
+    let currentPath: string | null = null;
+    let currentBranch: string | null = null;
+
+    for (const line of lines) {
+        if (line.startsWith('worktree ')) {
+            currentPath = line.substring('worktree '.length);
+        } else if (line.startsWith('branch ')) {
+            const branchRef = line.substring('branch '.length);
+            currentBranch = getWorktreeBranch(branchRef);
+        } else if (line === '') {
+            // End of worktree block
+            if (currentPath && currentBranch) {
+                worktrees.push({ path: currentPath, branch: currentBranch });
+            }
+            currentPath = null;
+            currentBranch = null;
+        }
+    }
+
+    // Handle last worktree if file doesn't end with blank line
+    if (currentPath && currentBranch) {
+        worktrees.push({ path: currentPath, branch: currentBranch });
+    }
+
+    return worktrees;
+}
+
+/**
+ * Extracts the branch name from a git branch reference.
+ *
+ * Converts refs/heads/branch-name to branch-name
+ *
+ * @param branchRef The full branch reference (e.g., "refs/heads/main")
+ * @returns The branch name without the refs/heads/ prefix
+ */
+export function getWorktreeBranch(branchRef: string): string {
+    if (branchRef.startsWith('refs/heads/')) {
+        return branchRef.substring('refs/heads/'.length);
+    }
+    return branchRef;
+}
+
+/**
+ * Checks if a worktree has uncommitted changes.
+ *
+ * Uses `git status --porcelain` which outputs a blank string when clean,
+ * or non-empty output when there are changes.
+ *
+ * @param worktreePath The path to the worktree to check
+ * @returns true if the worktree has uncommitted changes, false if clean
+ * @throws Error if unable to check git status
+ */
+export function hasUncommittedChanges(worktreePath: string): boolean {
+    try {
+        const output = execSync('git status --porcelain', {
+            cwd: worktreePath,
+            encoding: 'utf-8',
+        });
+        return output.trim().length > 0;
+    } catch (error) {
+        if (error instanceof Error) {
+            throw new Error(
+                `Failed to check git status in worktree '${worktreePath}': ${error.message}`,
+            );
+        }
+        throw new Error(`Failed to check git status in worktree '${worktreePath}'`);
+    }
+}
+
+/**
+ * Resets a worktree to a specific revision using `git reset --hard`.
+ *
+ * @param worktreePath The path to the worktree to reset
+ * @param revision The git revision (commit hash, branch, tag) to reset to
+ * @throws Error if the reset operation fails
+ */
+export function resetWorktree(worktreePath: string, revision: string): void {
+    try {
+        execSync(`git reset --hard ${revision}`, {
+            cwd: worktreePath,
+            stdio: 'ignore',
+        });
+    } catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to reset worktree '${worktreePath}': ${error.message}`);
+        }
+        throw new Error(`Failed to reset worktree '${worktreePath}'`);
+    }
+}
+
+/**
+ * Force-pushes a worktree to its remote repository.
+ *
+ * @param worktreePath The path to the worktree to push
+ * @throws Error if the push operation fails
+ */
+export function pushWorktree(worktreePath: string): void {
+    try {
+        execSync('git push --force', {
+            cwd: worktreePath,
+            stdio: 'ignore',
+        });
+    } catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to push worktree '${worktreePath}': ${error.message}`);
+        }
+        throw new Error(`Failed to push worktree '${worktreePath}'`);
+    }
+}