@avantmedia/af 0.0.1

package/utils/openspec.ts

@@ -0,0 +1,54 @@
+import { execSync } from 'node:child_process';
+
+/**
+ * Represents an ongoing change from OpenSpec
+ */
+export interface OngoingChange {
+    /** The change ID (e.g., "add-user-auth") */
+    id: string;
+    /** The task progress status (e.g., "3/8 tasks" or "✓ Complete") */
+    status: string;
+}
+
+/**
+ * Parse the output of `openspec list --changes` to extract ongoing changes.
+ *
+ * @param output - The raw output from `openspec list --changes`
+ * @returns Array of ongoing changes with their IDs and statuses
+ */
+export function parseOpenspecListOutput(output: string): OngoingChange[] {
+    const changes: OngoingChange[] = [];
+    const lines = output.split('\n');
+
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines and the "Changes:" header
+        if (!trimmed || trimmed === 'Changes:') continue;
+
+        // Parse lines like "  add-user-auth     3/8 tasks" or "  my-change     ✓ Complete"
+        // The ID is the first word, status is everything after
+        const match = trimmed.match(/^(\S+)\s+(.+)$/);
+        if (match) {
+            changes.push({
+                id: match[1],
+                status: match[2].trim(),
+            });
+        }
+    }
+
+    return changes;
+}
+
+/**
+ * List all ongoing changes from OpenSpec.
+ *
+ * @returns Array of ongoing changes, or empty array if command fails
+ */
+export function listOngoingChanges(): OngoingChange[] {
+    try {
+        const output = execSync('openspec list --changes', { encoding: 'utf-8' });
+        return parseOpenspecListOutput(output);
+    } catch {
+        return [];
+    }
+}

package/utils/output.ts

@@ -0,0 +1,104 @@
+/**
+ * Terminal output utilities with Ink-based components for consistent CLI formatting.
+ * Provides backward-compatible wrapper functions that use chalk (from Ink's dependency).
+ *
+ * For interactive UI, import and use Ink components directly via render().
+ * These functions are optimized for static, one-off messages.
+ */
+
+import chalk from 'chalk';
+
+/**
+ * ANSI color codes for terminal output.
+ * Kept for backward compatibility but deprecated in favor of chalk.
+ * @deprecated Use chalk directly or Ink components for better control
+ */
+export const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+
+/**
+ * Display a success message in green.
+ * @param message - The success message to display
+ */
+export function success(message: string): void {
+    console.log(chalk.green(message));
+}
+
+/**
+ * Display an error message in red.
+ * @param message - The error message to display
+ */
+export function error(message: string): void {
+    console.error(chalk.red(message));
+}
+
+/**
+ * Display an informational message in cyan.
+ * @param message - The info message to display
+ */
+export function info(message: string): void {
+    console.log(chalk.cyan(message));
+}
+
+/**
+ * Display a warning message in yellow.
+ * @param message - The warning message to display
+ */
+export function warn(message: string): void {
+    console.log(chalk.yellow(message));
+}
+
+/**
+ * Display a header message in blue with emphasis.
+ * Useful for section titles or major status updates.
+ * @param message - The header text to display
+ */
+export function header(message: string): void {
+    console.log();
+    console.log(chalk.blue(message));
+}
+
+/**
+ * Display a section message in bold (using color for emphasis).
+ * Useful for sub-sections or grouped content.
+ * @param message - The section text to display
+ */
+export function section(message: string): void {
+    console.log();
+    console.log(chalk.cyan(message));
+}
+
+/**
+ * Display a list item with an optional symbol prefix.
+ * @param message - The list item text to display
+ * @param symbol - Optional symbol to prefix (default: '•')
+ */
+export function listItem(message: string, symbol: string = '•'): void {
+    console.log(`  ${chalk.gray(symbol)} ${message}`);
+}
+
+/**
+ * Create a clickable hyperlink using OSC 8 escape sequences.
+ * In terminals that support OSC 8 (iTerm2, GNOME Terminal, Windows Terminal, etc.),
+ * the text will be displayed as a clickable link. In unsupported terminals,
+ * the text is displayed without the URL (graceful degradation).
+ *
+ * @param text - The visible text to display
+ * @param url - The URL to open when clicked
+ * @returns A string with OSC 8 escape sequences
+ */
+export function link(text: string, url: string): string {
+    // OSC 8 format: \x1b]8;;URL\x07TEXT\x1b]8;;\x07
+    // - \x1b]8;; starts the hyperlink with URL
+    // - \x07 (BEL) terminates the URL
+    // - TEXT is displayed
+    // - \x1b]8;;\x07 closes the hyperlink
+    return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
+}

package/utils/proposal.ts

@@ -0,0 +1,160 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { error as logError } from './output.ts';
+
+/**
+ * Extract the proposal title from the first line of a proposal.md file.
+ * Strips leading '#', whitespace, and optional "Proposal: " prefix.
+ *
+ * @param proposalPath - Path to the proposal.md file
+ * @returns The extracted title, or null if extraction fails
+ */
+export function extractProposalTitle(proposalPath: string): string | null {
+    try {
+        const content = readFileSync(proposalPath, 'utf-8');
+        const firstLine = content.split('\n')[0];
+
+        if (!firstLine) {
+            return null;
+        }
+
+        // Remove leading '#' and whitespace
+        let title = firstLine.replace(/^#+\s*/, '');
+
+        // Remove "Proposal: " prefix if present (case-insensitive)
+        title = title.replace(/^Proposal:\s*/i, '');
+
+        // Trim any remaining whitespace
+        title = title.trim();
+
+        return title || null;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Get the most recently created change directory in openspec/changes.
+ * This is useful for determining which proposal was just created.
+ *
+ * @param changesDir - Optional path to changes directory (defaults to 'openspec/changes')
+ * @returns The change ID of the most recent change, or null if none found
+ */
+export function getLatestChangeId(changesDir: string = 'openspec/changes'): string | null {
+    try {
+        const entries = readdirSync(changesDir);
+
+        let latestTime = 0;
+        let latestId: string | null = null;
+
+        for (const entry of entries) {
+            if (entry === 'archive') {
+                continue;
+            }
+
+            const fullPath = join(changesDir, entry);
+            const stats = statSync(fullPath);
+
+            if (stats.isDirectory() && stats.mtimeMs > latestTime) {
+                latestTime = stats.mtimeMs;
+                latestId = entry;
+            }
+        }
+
+        return latestId;
+    } catch (error) {
+        logError(`Error getting latest change ID: ${error}`);
+        return null;
+    }
+}
+
+/**
+ * Represents an active change with its title and task progress.
+ */
+export interface ActiveChange {
+    id: string;
+    title: string | null;
+    completedTasks: number;
+    totalTasks: number;
+}
+
+/**
+ * Parse a tasks.md file and count completed and total tasks.
+ * Tasks are markdown checkbox lines: `- [ ]` (uncompleted) or `- [x]` (completed).
+ *
+ * @param tasksPath - Path to the tasks.md file
+ * @returns Object with completed and total task counts
+ */
+function countTasks(tasksPath: string): { completed: number; total: number } {
+    try {
+        const content = readFileSync(tasksPath, 'utf-8');
+        const lines = content.split('\n');
+
+        let completed = 0;
+        let total = 0;
+
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('- [x]') || trimmed.startsWith('- [X]')) {
+                completed++;
+                total++;
+            } else if (trimmed.startsWith('- [ ]')) {
+                total++;
+            }
+        }
+
+        return { completed, total };
+    } catch {
+        return { completed: 0, total: 0 };
+    }
+}
+
+/**
+ * Get all active changes with their titles and task progress.
+ *
+ * @param changesDir - Optional path to changes directory (defaults to 'openspec/changes')
+ * @returns Array of active changes sorted alphabetically by ID
+ */
+export function getActiveChanges(changesDir: string = 'openspec/changes'): ActiveChange[] {
+    try {
+        if (!existsSync(changesDir)) {
+            return [];
+        }
+
+        const entries = readdirSync(changesDir);
+        const changes: ActiveChange[] = [];
+
+        for (const entry of entries) {
+            if (entry === 'archive') {
+                continue;
+            }
+
+            const fullPath = join(changesDir, entry);
+            const stats = statSync(fullPath);
+
+            if (!stats.isDirectory()) {
+                continue;
+            }
+
+            const proposalPath = join(fullPath, 'proposal.md');
+            const tasksPath = join(fullPath, 'tasks.md');
+
+            const title = extractProposalTitle(proposalPath);
+            const { completed, total } = countTasks(tasksPath);
+
+            changes.push({
+                id: entry,
+                title,
+                completedTasks: completed,
+                totalTasks: total,
+            });
+        }
+
+        // Sort alphabetically by ID
+        changes.sort((a, b) => a.id.localeCompare(b.id));
+
+        return changes;
+    } catch {
+        return [];
+    }
+}

package/utils/resources.ts

@@ -0,0 +1,64 @@
+/**
+ * Resource file utilities for extracting bundled resource files.
+ * Handles both development mode (files on disk) and compiled mode (embedded in binary).
+ */
+
+import { mkdirSync, writeFileSync, copyFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { RESOURCE_FILES, isCompiled, type ResourceFile } from '../generated/setup-manifest.ts';
+
+/**
+ * Get the project root directory where resources/ folder is located.
+ * In development mode, this is relative to this source file.
+ * In compiled mode, files are embedded and this isn't used.
+ */
+function getProjectRoot(): string {
+    // import.meta.dirname gives us the directory of this file (utils/)
+    // We need to go up one level to get to the project root
+    return dirname(import.meta.dirname);
+}
+
+/**
+ * Get a resource file entry by name.
+ */
+export function getResource(name: string): ResourceFile | undefined {
+    return RESOURCE_FILES.find(r => r.name === name);
+}
+
+/**
+ * Extract a resource file to a target path.
+ * Works in both development mode (copies from disk) and compiled mode (extracts from binary).
+ *
+ * @param name - The resource file name (e.g., "copy-prompt-reporter.ts")
+ * @param targetPath - The absolute path to write the file to
+ * @throws Error if the resource is not found
+ */
+export async function extractResource(name: string, targetPath: string): Promise<void> {
+    const resource = getResource(name);
+    if (!resource) {
+        throw new Error(`Resource not found: ${name}`);
+    }
+
+    // Ensure target directory exists
+    mkdirSync(dirname(targetPath), { recursive: true });
+
+    if (isCompiled()) {
+        // In compiled mode, use Bun.file() to read from $bunfs virtual filesystem
+        const content = await Bun.file(resource.embeddedPath).bytes();
+        writeFileSync(targetPath, content);
+    } else {
+        // In development mode, copy from source directory relative to project root
+        const sourcePath = join(getProjectRoot(), 'resources', resource.name);
+        copyFileSync(sourcePath, targetPath);
+    }
+}
+
+/**
+ * List all available resource files.
+ */
+export function listResources(): string[] {
+    return RESOURCE_FILES.map(r => r.name);
+}
+
+// Re-export for convenience
+export { isCompiled };

package/utils/setup-files.ts

@@ -0,0 +1,230 @@
+/**
+ * Setup file utilities for copying bundled configuration files.
+ * Handles both development mode (files on disk) and compiled mode (embedded in binary).
+ */
+
+import { existsSync, mkdirSync, writeFileSync, copyFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { SETUP_FILES, isCompiled, type SetupFile } from '../generated/setup-manifest.ts';
+
+export type ConflictResolution = 'overwrite' | 'skip' | 'overwrite-all' | 'skip-all';
+
+export interface SetupResult {
+    copied: string[];
+    skipped: string[];
+    errors: Array<{ path: string; error: string }>;
+}
+
+export interface FileInfo {
+    file: SetupFile;
+    targetPath: string;
+    exists: boolean;
+    /** OpenCode target path for command files (null for skills) */
+    openCodePath?: string;
+    openCodeExists?: boolean;
+}
+
+/**
+ * Get the Claude target directory (user's home directory).
+ */
+export function getTargetDir(): string {
+    return homedir();
+}
+
+/**
+ * Get the OpenCode config directory.
+ */
+export function getOpenCodeDir(): string {
+    return join(homedir(), '.config', 'opencode');
+}
+
+/**
+ * Check if a file is a command file (not a skill).
+ */
+function isCommandFile(relativePath: string): boolean {
+    return relativePath.includes('.claude/commands/');
+}
+
+/**
+ * Get OpenCode target path for a Claude command file.
+ * Returns null for non-command files (skills are shared via ~/.claude/skills/).
+ */
+export function getOpenCodeCommandPath(claudePath: string): string | null {
+    // Only transform command files
+    if (!claudePath.includes('/commands/')) return null;
+
+    // ~/.claude/commands/foo.md → ~/.config/opencode/command/foo.md
+    return claudePath
+        .replace(join(homedir(), '.claude'), join(homedir(), '.config', 'opencode'))
+        .replace('/commands/', '/command/');
+}
+
+/**
+ * List all files that would be copied, with conflict info.
+ * Includes OpenCode target paths for command files.
+ */
+export function listSetupFiles(): FileInfo[] {
+    const targetDir = getTargetDir();
+
+    return SETUP_FILES.map(file => {
+        const targetPath = join(targetDir, file.relativePath);
+        const openCodePath = isCommandFile(file.relativePath)
+            ? getOpenCodeCommandPath(targetPath)
+            : undefined;
+
+        return {
+            file,
+            targetPath,
+            exists: existsSync(targetPath),
+            openCodePath: openCodePath ?? undefined,
+            openCodeExists: openCodePath ? existsSync(openCodePath) : undefined,
+        };
+    });
+}
+
+/**
+ * Get the project root directory where setup/ folder is located.
+ * In development mode, this is relative to this source file.
+ * In compiled mode, files are embedded and this isn't used.
+ */
+function getProjectRoot(): string {
+    // import.meta.dirname gives us the directory of this file (utils/)
+    // We need to go up one level to get to the project root
+    return dirname(import.meta.dirname);
+}
+
+/**
+ * Copy a single file from embedded source to target.
+ */
+export async function copySetupFile(file: SetupFile, targetPath: string): Promise<void> {
+    // Ensure target directory exists
+    mkdirSync(dirname(targetPath), { recursive: true });
+
+    if (isCompiled()) {
+        // In compiled mode, use Bun.file() to read from $bunfs virtual filesystem
+        const content = await Bun.file(file.embeddedPath).bytes();
+        writeFileSync(targetPath, content);
+    } else {
+        // In development mode, copy from source directory relative to project root
+        const sourcePath = join(getProjectRoot(), 'setup', file.relativePath);
+        copyFileSync(sourcePath, targetPath);
+    }
+}
+
+/**
+ * Perform the full setup operation.
+ * Copies files to both Claude and OpenCode directories.
+ * @param resolveConflict - Callback for conflict resolution
+ */
+export async function performSetup(
+    resolveConflict: (targetPath: string) => Promise<ConflictResolution>,
+): Promise<SetupResult> {
+    const result: SetupResult = {
+        copied: [],
+        skipped: [],
+        errors: [],
+    };
+
+    let skipAll = false;
+    let overwriteAll = false;
+
+    const files = listSetupFiles();
+
+    for (const { file, targetPath, exists, openCodePath, openCodeExists } of files) {
+        // Handle Claude target
+        try {
+            if (exists && !overwriteAll && !skipAll) {
+                const resolution = await resolveConflict(targetPath);
+
+                if (resolution === 'skip-all') {
+                    skipAll = true;
+                    result.skipped.push(targetPath);
+                    // Also skip OpenCode path
+                    if (openCodePath) {
+                        result.skipped.push(openCodePath);
+                    }
+                    continue;
+                }
+                if (resolution === 'overwrite-all') {
+                    overwriteAll = true;
+                }
+                if (resolution === 'skip') {
+                    result.skipped.push(targetPath);
+                    // Also skip OpenCode path
+                    if (openCodePath) {
+                        result.skipped.push(openCodePath);
+                    }
+                    continue;
+                }
+            } else if (exists && skipAll) {
+                result.skipped.push(targetPath);
+                if (openCodePath) {
+                    result.skipped.push(openCodePath);
+                }
+                continue;
+            }
+
+            await copySetupFile(file, targetPath);
+            result.copied.push(targetPath);
+        } catch (err) {
+            result.errors.push({
+                path: targetPath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+
+        // Handle OpenCode target (commands only)
+        if (openCodePath) {
+            try {
+                // Check for conflict on OpenCode path separately
+                if (openCodeExists && !overwriteAll && !skipAll) {
+                    const resolution = await resolveConflict(openCodePath);
+
+                    if (resolution === 'skip-all') {
+                        skipAll = true;
+                        result.skipped.push(openCodePath);
+                        continue;
+                    }
+                    if (resolution === 'overwrite-all') {
+                        overwriteAll = true;
+                    }
+                    if (resolution === 'skip') {
+                        result.skipped.push(openCodePath);
+                        continue;
+                    }
+                } else if (openCodeExists && skipAll) {
+                    result.skipped.push(openCodePath);
+                    continue;
+                }
+
+                await copySetupFile(file, openCodePath);
+                result.copied.push(openCodePath);
+            } catch (err) {
+                result.errors.push({
+                    path: openCodePath,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Get count of setup files for display purposes.
+ */
+export function getSetupFileCount(): number {
+    return SETUP_FILES.length;
+}
+
+// Re-export for convenience
+export { isCompiled };
+
+/**
+ * Get the count of OpenCode command files for display purposes.
+ */
+export function getOpenCodeCommandCount(): number {
+    return SETUP_FILES.filter(f => isCommandFile(f.relativePath)).length;
+}