@avantmedia/af 0.0.1

package/commands/stop-hook.ts

@@ -0,0 +1,90 @@
+import { spawnSync } from 'node:child_process';
+import { getStopHookConfig } from '../utils/config.ts';
+import { info } from '../utils/output.ts';
+
+/**
+ * Get changed files from git.
+ * Combines staged, unstaged, and untracked files.
+ */
+function getChangedFiles(): string[] {
+    const files = new Set<string>();
+
+    // Staged changes
+    const staged = spawnSync('git', ['diff', '--name-only', '--cached'], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (staged.status === 0 && staged.stdout) {
+        for (const file of staged.stdout.trim().split('\n')) {
+            if (file) files.add(file);
+        }
+    }
+
+    // Unstaged changes
+    const unstaged = spawnSync('git', ['diff', '--name-only'], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (unstaged.status === 0 && unstaged.stdout) {
+        for (const file of unstaged.stdout.trim().split('\n')) {
+            if (file) files.add(file);
+        }
+    }
+
+    // Untracked files
+    const untracked = spawnSync('git', ['ls-files', '--others', '--exclude-standard'], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (untracked.status === 0 && untracked.stdout) {
+        for (const file of untracked.stdout.trim().split('\n')) {
+            if (file) files.add(file);
+        }
+    }
+
+    return Array.from(files);
+}
+
+/**
+ * Filter out files that match any of the ignored path prefixes.
+ */
+function filterIgnoredPaths(files: string[], ignoredPaths: string[]): string[] {
+    return files.filter(file => !ignoredPaths.some(prefix => file.startsWith(prefix)));
+}
+
+/**
+ * Handle the 'stop-hook' command.
+ * Conditionally runs e2e tests based on changed files.
+ *
+ * @returns Exit code: 0 (success/skipped), 2 (e2e failed)
+ */
+export async function handleStopHook(): Promise<number> {
+    const config = getStopHookConfig();
+
+    const changedFiles = getChangedFiles();
+    const relevantFiles = filterIgnoredPaths(changedFiles, config.ignoredPaths);
+
+    if (relevantFiles.length === 0) {
+        info('No relevant file changes detected, skipping e2e tests');
+        return 0;
+    }
+
+    info(`Running e2e tests (${relevantFiles.length} relevant file(s) changed)`);
+    console.log(relevantFiles.join('\n'));
+
+    // Parse the command into parts
+    const parts = config.command.split(/\s+/);
+    const cmd = parts[0];
+    const args = parts.slice(1);
+
+    const result = spawnSync(cmd, args, {
+        stdio: 'inherit',
+        shell: true,
+    });
+
+    if (result.status !== 0) {
+        return 2;
+    }
+
+    return 0;
+}

package/commands/todo.ts

@@ -0,0 +1,208 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { error, colors } from '../utils/output.ts';
+
+/**
+ * Represents a single task from tasks.md
+ */
+interface Task {
+    text: string;
+    completed: boolean;
+    indent: number;
+}
+
+/**
+ * Represents a section in tasks.md (e.g., "Implementation Tasks")
+ */
+interface Section {
+    title: string;
+    tasks: Task[];
+}
+
+/**
+ * Represents all task data for a single change
+ */
+interface ChangeTaskData {
+    changeId: string;
+    sections: Section[];
+    totalTasks: number;
+    completedTasks: number;
+}
+
+/**
+ * Parse a tasks.md file and extract structured task data.
+ *
+ * @param filePath - Path to the tasks.md file
+ * @returns Parsed task data with sections and completion counts
+ */
+async function parseTasksFile(filePath: string): Promise<{
+    sections: Section[];
+    totalTasks: number;
+    completedTasks: number;
+}> {
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+
+        const sections: Section[] = [];
+        let currentSection: Section | null = null;
+        let totalTasks = 0;
+        let completedTasks = 0;
+
+        for (const line of lines) {
+            // Match section headers (## Header)
+            const sectionMatch = line.match(/^## (.+)$/);
+            if (sectionMatch) {
+                if (currentSection) {
+                    sections.push(currentSection);
+                }
+                currentSection = {
+                    title: sectionMatch[1].trim(),
+                    tasks: [],
+                };
+                continue;
+            }
+
+            // Match task items (- [ ] or - [x])
+            const taskMatch = line.match(/^(\s*)- \[([ xX])\] (.+)$/);
+            if (taskMatch) {
+                const [, indentStr, checkbox, text] = taskMatch;
+                const indent = indentStr.length;
+                const isCompleted = checkbox.toLowerCase() === 'x';
+
+                const task: Task = {
+                    text: text.trim(),
+                    completed: isCompleted,
+                    indent,
+                };
+
+                if (currentSection) {
+                    currentSection.tasks.push(task);
+                }
+
+                totalTasks++;
+                if (isCompleted) {
+                    completedTasks++;
+                }
+            }
+        }
+
+        // Push the last section
+        if (currentSection) {
+            sections.push(currentSection);
+        }
+
+        return { sections, totalTasks, completedTasks };
+    } catch (_error) {
+        // If file doesn't exist or can't be read, return empty data
+        return { sections: [], totalTasks: 0, completedTasks: 0 };
+    }
+}
+
+/**
+ * Get all active change directories from openspec/changes/.
+ * Excludes the 'archive' directory.
+ *
+ * @returns Array of change directory names
+ */
+async function getActiveChanges(): Promise<string[]> {
+    try {
+        const changesDir = join(process.cwd(), 'openspec', 'changes');
+        const entries = await readdir(changesDir, { withFileTypes: true });
+
+        return entries
+            .filter(entry => entry.isDirectory() && entry.name !== 'archive')
+            .map(entry => entry.name);
+    } catch (_error) {
+        // Directory doesn't exist or can't be read
+        return [];
+    }
+}
+
+/**
+ * Format and display a single change's tasks with visual formatting.
+ *
+ * @param changeData - The change task data to display
+ */
+function displayChange(changeData: ChangeTaskData): void {
+    const { changeId, sections, totalTasks, completedTasks } = changeData;
+
+    // Display change header with progress
+    const progressText = `${completedTasks}/${totalTasks} tasks completed`;
+    console.log(
+        `${colors.blue}┌─ ${changeId}${colors.reset} ${colors.gray}(${progressText})${colors.reset}`,
+    );
+    console.log(`${colors.blue}│${colors.reset}`);
+
+    // Display each section and its tasks
+    for (const section of sections) {
+        if (section.tasks.length === 0) continue;
+
+        console.log(
+            `${colors.blue}│${colors.reset}  ${colors.cyan}${section.title}${colors.reset}`,
+        );
+
+        for (const task of section.tasks) {
+            const checkbox = task.completed
+                ? `${colors.green}☑${colors.reset}`
+                : `${colors.gray}☐${colors.reset}`;
+            const indent = ' '.repeat(task.indent / 4); // Convert spaces to visual indent
+            console.log(`${colors.blue}│${colors.reset}  ${indent}${checkbox} ${task.text}`);
+        }
+
+        console.log(`${colors.blue}│${colors.reset}`);
+    }
+
+    // Display bottom border
+    console.log(`${colors.blue}└${'─'.repeat(40)}${colors.reset}`);
+    console.log('');
+}
+
+/**
+ * Handle the 'todo' command.
+ * Displays all TODO items from active OpenSpec changes.
+ *
+ * @param hasArgs - Whether any arguments were provided to the command
+ * @returns Exit code (0 for success, 1 for error)
+ */
+export async function handleTodo(hasArgs: boolean): Promise<number> {
+    // Reject if arguments were provided
+    if (hasArgs) {
+        error('Error: todo command does not accept arguments');
+        console.error('Usage: af todo');
+        return 1;
+    }
+
+    // Get all active changes
+    const changes = await getActiveChanges();
+
+    if (changes.length === 0) {
+        console.log('No active changes found.');
+        return 0;
+    }
+
+    // Display header
+    console.log(`\n${colors.cyan}📋 TODO Items${colors.reset}\n`);
+
+    // Process each change
+    for (const changeId of changes) {
+        const tasksPath = join(process.cwd(), 'openspec', 'changes', changeId, 'tasks.md');
+        const { sections, totalTasks, completedTasks } = await parseTasksFile(tasksPath);
+
+        if (totalTasks === 0) {
+            // Skip changes with no tasks
+            continue;
+        }
+
+        const changeData: ChangeTaskData = {
+            changeId,
+            sections,
+            totalTasks,
+            completedTasks,
+        };
+
+        displayChange(changeData);
+    }
+
+    return 0;
+}

package/commands/versions.ts

@@ -0,0 +1,150 @@
+import {
+    getCurrentHeadCommit,
+    hasUncommittedChanges,
+    isGitRepository,
+    listWorktrees,
+    pushWorktree,
+    resetWorktree,
+} from '../git-worktree.ts';
+import { info, success, error } from '../utils/output.ts';
+
+/**
+ * Force-pushes all version worktrees (matching /v\d+/ pattern) to their remote repositories.
+ *
+ * @returns Exit code (0 for success, 1 for error)
+ */
+export async function handleVersionsPush(): Promise<number> {
+    try {
+        // 1. Validate we're in a git repository
+        if (!isGitRepository()) {
+            error('Error: Not in a git repository');
+            return 1;
+        }
+
+        // 2. Enumerate worktrees and filter by /v\d+/ pattern
+        const allWorktrees = listWorktrees();
+        const versionPattern = /^v\d+$/;
+        const matchingWorktrees = allWorktrees.filter(wt => versionPattern.test(wt.branch));
+
+        // Handle case where no matching worktrees are found
+        if (matchingWorktrees.length === 0) {
+            info('No worktrees with branches matching /v\\d+/ pattern found.');
+            return 0;
+        }
+
+        // 3. Push each worktree
+        for (const worktree of matchingWorktrees) {
+            info(`Pushing worktree ${worktree.branch}...`);
+            try {
+                pushWorktree(worktree.path);
+            } catch (err) {
+                if (err instanceof Error) {
+                    error(err.message);
+                } else {
+                    error(`Failed to push worktree '${worktree.branch}'`);
+                }
+                return 1;
+            }
+        }
+
+        // 4. Display success summary
+        const branchNames = matchingWorktrees.map(wt => wt.branch).join(', ');
+        success(`Successfully pushed ${matchingWorktrees.length} worktree(s): ${branchNames}`);
+        return 0;
+    } catch (err) {
+        if (err instanceof Error) {
+            error(`Error: ${err.message}`);
+        } else {
+            error('An unexpected error occurred');
+        }
+        return 1;
+    }
+}
+
+/**
+ * Resets all version worktrees (matching /v\d+/ pattern) to the current branch HEAD.
+ *
+ * @returns Exit code (0 for success, 1 for error)
+ */
+export async function handleVersionsReset(): Promise<number> {
+    try {
+        // 1. Validate we're in a git repository
+        if (!isGitRepository()) {
+            error('Error: Not in a git repository');
+            return 1;
+        }
+
+        // 2. Get current HEAD commit
+        const targetRevision = getCurrentHeadCommit();
+
+        // 3. Enumerate worktrees and filter by /v\d+/ pattern
+        const allWorktrees = listWorktrees();
+        const versionPattern = /^v\d+$/;
+        const matchingWorktrees = allWorktrees.filter(wt => versionPattern.test(wt.branch));
+
+        // Handle case where no matching worktrees are found
+        if (matchingWorktrees.length === 0) {
+            info('No worktrees with branches matching /v\\d+/ pattern found.');
+            return 0;
+        }
+
+        // 4. Check each worktree for uncommitted changes
+        const worktreesWithChanges: string[] = [];
+        for (const worktree of matchingWorktrees) {
+            try {
+                if (hasUncommittedChanges(worktree.path)) {
+                    worktreesWithChanges.push(worktree.branch);
+                }
+            } catch (err) {
+                if (err instanceof Error) {
+                    error(err.message);
+                } else {
+                    error(`Failed to check worktree '${worktree.branch}'`);
+                }
+                return 1;
+            }
+        }
+
+        // 5. If any worktree has uncommitted changes, report and exit
+        if (worktreesWithChanges.length > 0) {
+            error('Error: Cannot reset worktrees with uncommitted changes');
+            for (const worktree of matchingWorktrees) {
+                if (worktreesWithChanges.includes(worktree.branch)) {
+                    console.error(
+                        `Worktree '${worktree.branch}' at ${worktree.path} has uncommitted changes`,
+                    );
+                }
+            }
+            console.error('\nPlease commit or stash changes and try again.');
+            console.error('You can check the status by running: git status');
+            return 1;
+        }
+
+        // 6. Reset each worktree
+        for (const worktree of matchingWorktrees) {
+            info(`Resetting worktree ${worktree.branch}...`);
+            try {
+                resetWorktree(worktree.path, targetRevision);
+            } catch (err) {
+                if (err instanceof Error) {
+                    error(err.message);
+                } else {
+                    error(`Failed to reset worktree '${worktree.branch}'`);
+                }
+                return 1;
+            }
+        }
+
+        // 7. Display success summary
+        const branchNames = matchingWorktrees.map(wt => wt.branch).join(', ');
+        success(`Successfully reset ${matchingWorktrees.length} worktree(s): ${branchNames}`);
+        return 0;
+    } catch (err) {
+        if (err instanceof Error) {
+            error(`Error: ${err.message}`);
+        } else {
+            error('An unexpected error occurred');
+        }
+        return 1;
+    }
+}