@waymakeros/cli 2.0.0

package/dist/sync/reverse-sync.js

@@ -0,0 +1,773 @@
+/**
+ * ReverseSync: Commander → IDE Synchronization
+ *
+ * Subscribes to Commander taskboard changes and syncs them to IDE filesystem.
+ * Part of bidirectional Waymaker Sync.
+ */
+// Polyfill WebSocket for Node.js (required by Supabase Realtime)
+import WebSocket from 'ws';
+if (typeof globalThis.WebSocket === 'undefined') {
+    globalThis.WebSocket = WebSocket;
+}
+import { createClient } from '@supabase/supabase-js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { EventEmitter } from 'events';
+export class ReverseSync extends EventEmitter {
+    config;
+    supabase;
+    channel = null;
+    running = false;
+    fileMap = new Map(); // task_id → file_path
+    sectionMap = new Map(); // status_section_id → folder_name
+    pendingChanges = new Map();
+    syncTimer = null;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 10;
+    reconnectTimer = null;
+    supabaseToken = null;
+    tokenExpiresAt = null;
+    tokenRefreshTimer = null;
+    recentEvents = new Map(); // "taskId:eventType" → timestamp
+    dedupeWindowMs = 2000; // Ignore duplicate events within 2s
+    constructor(config) {
+        super();
+        this.config = config;
+        // Initialize Supabase client with anon key
+        // After token exchange, we'll call setAuth() with the Supabase JWT
+        this.supabase = createClient(config.supabaseUrl, config.supabaseKey);
+    }
+    /**
+     * Exchange OAuth token (wm_at_*) for a Supabase-compatible JWT
+     * This allows Realtime subscriptions to pass RLS policies
+     */
+    async exchangeTokenForSupabaseJWT() {
+        if (!this.config.apiKey?.startsWith('wm_at_')) {
+            console.error('[ReverseSync] No OAuth token available for exchange');
+            return false;
+        }
+        console.error('[ReverseSync] Exchanging OAuth token for Supabase JWT...');
+        try {
+            const response = await fetch(`${this.config.supabaseUrl}/functions/v1/auth-token-exchange`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.config.apiKey}`,
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                console.error(`[ReverseSync] Token exchange failed (${response.status}):`, errorText);
+                return false;
+            }
+            const data = await response.json();
+            if (!data.success || !data.supabaseToken) {
+                console.error('[ReverseSync] Token exchange response invalid:', data);
+                return false;
+            }
+            // Store the token and expiry
+            this.supabaseToken = data.supabaseToken;
+            this.tokenExpiresAt = new Date(data.expiresAt);
+            // Set the JWT for Realtime authentication
+            // The anon key remains as the API key, JWT is used for auth via setAuth()
+            this.supabase.realtime.setAuth(this.supabaseToken);
+            console.error('[ReverseSync] ✅ Token exchanged successfully');
+            console.error(`[ReverseSync]    User: ${data.userId}`);
+            console.error(`[ReverseSync]    Org: ${data.organizationId || 'none'}`);
+            console.error(`[ReverseSync]    Expires: ${data.expiresAt}`);
+            // Schedule token refresh before expiry (5 minutes before)
+            this.scheduleTokenRefresh();
+            return true;
+        }
+        catch (error) {
+            console.error('[ReverseSync] Token exchange error:', error);
+            return false;
+        }
+    }
+    /**
+     * Schedule automatic token refresh before expiry
+     */
+    scheduleTokenRefresh() {
+        // Clear any existing refresh timer
+        if (this.tokenRefreshTimer) {
+            clearTimeout(this.tokenRefreshTimer);
+            this.tokenRefreshTimer = null;
+        }
+        if (!this.tokenExpiresAt) {
+            return;
+        }
+        // Refresh 5 minutes before expiry
+        const refreshTime = this.tokenExpiresAt.getTime() - Date.now() - 5 * 60 * 1000;
+        if (refreshTime <= 0) {
+            // Token expires soon, refresh immediately
+            console.error('[ReverseSync] Token expiring soon, refreshing immediately...');
+            this.exchangeTokenForSupabaseJWT();
+            return;
+        }
+        console.error(`[ReverseSync] Token refresh scheduled in ${Math.round(refreshTime / 60000)} minutes`);
+        this.tokenRefreshTimer = setTimeout(async () => {
+            console.error('[ReverseSync] Refreshing Supabase token...');
+            const success = await this.exchangeTokenForSupabaseJWT();
+            if (success) {
+                // Re-authenticate the realtime channel
+                this.supabase.realtime.setAuth(this.supabaseToken);
+            }
+        }, refreshTime);
+    }
+    /**
+     * Start reverse sync - subscribe to task changes
+     */
+    async start() {
+        if (this.running) {
+            throw new Error('ReverseSync already running');
+        }
+        console.error('[ReverseSync] Starting...');
+        // Exchange OAuth token for Supabase JWT (required for Realtime RLS)
+        if (this.config.apiKey?.startsWith('wm_at_')) {
+            const tokenOk = await this.exchangeTokenForSupabaseJWT();
+            if (!tokenOk) {
+                console.error('[ReverseSync] ⚠️  Token exchange failed - Realtime may be blocked by RLS');
+                console.error('[ReverseSync]    Initial sync will still work, but live updates may not');
+            }
+        }
+        else {
+            console.error('[ReverseSync] ⚠️  No OAuth token - using anon key (RLS may block)');
+        }
+        // Load section mappings from database
+        await this.loadSectionMappings();
+        // Load existing task files to build file map
+        await this.loadExistingFiles();
+        // Perform initial sync of existing tasks
+        await this.performInitialSync();
+        // Subscribe to task changes
+        await this.subscribeToTaskChanges();
+        this.running = true;
+        console.error('[ReverseSync] ✅ Started');
+        this.emit('started');
+    }
+    /**
+     * Stop reverse sync
+     */
+    async stop() {
+        if (!this.running) {
+            return;
+        }
+        console.error('[ReverseSync] Stopping...');
+        // Unsubscribe from realtime
+        if (this.channel) {
+            await this.channel.unsubscribe();
+            this.channel = null;
+        }
+        // Clear pending changes
+        if (this.syncTimer) {
+            clearTimeout(this.syncTimer);
+            this.syncTimer = null;
+        }
+        // Clear reconnection timer
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        // Clear token refresh timer
+        if (this.tokenRefreshTimer) {
+            clearTimeout(this.tokenRefreshTimer);
+            this.tokenRefreshTimer = null;
+        }
+        this.running = false;
+        this.reconnectAttempts = 0;
+        this.supabaseToken = null;
+        this.tokenExpiresAt = null;
+        console.error('[ReverseSync] ✅ Stopped');
+        this.emit('stopped');
+    }
+    /**
+     * Subscribe to Supabase realtime for task changes
+     */
+    async subscribeToTaskChanges() {
+        console.error(`[ReverseSync] Subscribing to Realtime for board: ${this.config.taskboardId}`);
+        this.channel = this.supabase
+            .channel('task-changes')
+            .on('postgres_changes', {
+            event: '*', // Listen to INSERT, UPDATE, DELETE
+            schema: 'public',
+            table: 'tasks',
+            filter: `board_id=eq.${this.config.taskboardId}`,
+        }, (payload) => {
+            this.handleRealtimeEvent(payload);
+        })
+            .subscribe(async (status, err) => {
+            // Log ALL status changes for debugging
+            console.error(`[ReverseSync] Realtime status: ${status}${err ? ` (error: ${JSON.stringify(err)})` : ''}`);
+            if (status === 'SUBSCRIBED') {
+                console.error('[ReverseSync] ✅ Subscribed to task changes');
+                // Reset reconnect attempts on successful connection
+                this.reconnectAttempts = 0;
+                // Update board settings to reflect sync is active
+                await this.updateBoardSyncStatus(true);
+            }
+            else if (status === 'CLOSED') {
+                console.error('[ReverseSync] ⚠️  Subscription closed, reconnecting...');
+                this.handleReconnect();
+            }
+            else if (status === 'CHANNEL_ERROR') {
+                console.error('[ReverseSync] ❌ Subscription error, reconnecting...');
+                this.handleReconnect();
+            }
+            else if (status === 'TIMED_OUT') {
+                console.error('[ReverseSync] ⏰ Subscription timed out, reconnecting...');
+                this.handleReconnect();
+            }
+        });
+        // Log channel state after setup
+        console.error(`[ReverseSync] Channel created, waiting for connection...`);
+    }
+    /**
+     * Handle reconnection with exponential backoff
+     */
+    async handleReconnect() {
+        // Don't reconnect if we're not running
+        if (!this.running) {
+            return;
+        }
+        // Check if we've exceeded max attempts
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error(`[ReverseSync] ❌ Max reconnection attempts (${this.maxReconnectAttempts}) reached. Giving up.`);
+            console.error('[ReverseSync] Please restart the sync daemon manually.');
+            return;
+        }
+        this.reconnectAttempts++;
+        // Calculate backoff: 2^attempts seconds, capped at 60s
+        const backoffSeconds = Math.min(Math.pow(2, this.reconnectAttempts), 60);
+        console.error(`[ReverseSync] Reconnection attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts} in ${backoffSeconds}s...`);
+        // Clear existing channel
+        if (this.channel) {
+            try {
+                await this.channel.unsubscribe();
+            }
+            catch (error) {
+                // Ignore unsubscribe errors
+            }
+            this.channel = null;
+        }
+        // Schedule reconnection
+        this.reconnectTimer = setTimeout(async () => {
+            try {
+                await this.subscribeToTaskChanges();
+            }
+            catch (error) {
+                console.error('[ReverseSync] Reconnection failed:', error);
+                // Try again
+                this.handleReconnect();
+            }
+        }, backoffSeconds * 1000);
+    }
+    /**
+     * Update board sync status via edge function
+     */
+    async updateBoardSyncStatus(enabled) {
+        if (!this.config.apiKey) {
+            console.error('[ReverseSync] No API key configured - skipping board sync status update');
+            return;
+        }
+        try {
+            const edgeFunctionUrl = `${this.config.supabaseUrl}/functions/v1/commander-task-board-operations`;
+            const response = await fetch(edgeFunctionUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.config.apiKey}`,
+                },
+                body: JSON.stringify({
+                    action: 'update_board',
+                    id: this.config.taskboardId,
+                    settings: {
+                        sync_enabled: enabled,
+                        last_sync_at: new Date().toISOString(),
+                    },
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.text();
+                console.error('[ReverseSync] Failed to update board sync status:', error);
+            }
+            else {
+                console.error(`[ReverseSync] ✅ Board sync status updated: ${enabled ? 'enabled' : 'disabled'}`);
+            }
+        }
+        catch (error) {
+            console.error('[ReverseSync] Error updating board sync status:', error);
+        }
+    }
+    /**
+     * Handle realtime event from Supabase
+     */
+    handleRealtimeEvent(payload) {
+        const { eventType, new: newRecord, old: oldRecord } = payload;
+        // Use newRecord if it has an id, otherwise use oldRecord (for DELETE events)
+        const taskData = (newRecord?.id) ? newRecord : oldRecord;
+        if (!taskData || !taskData.id) {
+            console.error(`[ReverseSync] Error: Missing task data in ${eventType} event`, { newRecord, oldRecord });
+            return;
+        }
+        // Deduplicate: Supabase Realtime can fire 2 UPDATE events per change
+        const dedupeKey = `${taskData.id}:${eventType}`;
+        const now = Date.now();
+        const lastSeen = this.recentEvents.get(dedupeKey);
+        if (lastSeen && (now - lastSeen) < this.dedupeWindowMs) {
+            console.error(`[ReverseSync] Skipping duplicate ${eventType} for task ${taskData.id}`);
+            return;
+        }
+        this.recentEvents.set(dedupeKey, now);
+        // Clean up old entries periodically
+        if (this.recentEvents.size > 100) {
+            for (const [key, ts] of this.recentEvents) {
+                if (now - ts > this.dedupeWindowMs)
+                    this.recentEvents.delete(key);
+            }
+        }
+        console.error(`[ReverseSync] Received ${eventType} event for task:`, taskData.id);
+        const change = {
+            type: eventType,
+            task: taskData,
+            old: oldRecord,
+        };
+        // Queue change for processing (debounce rapid changes)
+        this.handleTaskChange(change);
+    }
+    /**
+     * Load section mappings from database for folder organization
+     */
+    async loadSectionMappings() {
+        console.error(`[ReverseSync] Loading section mappings for board: ${this.config.taskboardId}`);
+        try {
+            const { data: sections, error } = await this.supabase
+                .from('task_status_sections')
+                .select('id, name, board_id, position')
+                .eq('board_id', this.config.taskboardId)
+                .order('position', { ascending: true });
+            if (error) {
+                console.error('[ReverseSync] Error loading sections:', error);
+                throw error;
+            }
+            if (!sections || sections.length === 0) {
+                console.error('[ReverseSync] WARNING: No sections found for board');
+                return;
+            }
+            // Build section_id → folder_name mapping
+            for (const section of sections) {
+                const folderName = this.slugifyName(section.name);
+                this.sectionMap.set(section.id, folderName);
+                console.error(`[ReverseSync] Section: ${section.name} → ${folderName}/`);
+            }
+            console.error(`[ReverseSync] ✅ Loaded ${this.sectionMap.size} section mappings`);
+        }
+        catch (error) {
+            console.error('[ReverseSync] Error loading section mappings:', error);
+            // Non-fatal, continue without folder organization
+        }
+    }
+    /**
+     * Load existing task markdown files to build task_id → file_path map
+     * Scans tasks folder and all subdirectories (section folders)
+     */
+    async loadExistingFiles() {
+        const tasksDir = path.join(this.config.projectPath, this.config.tasksFolder);
+        try {
+            // Ensure directory exists
+            await fs.mkdir(tasksDir, { recursive: true });
+            // Read all items (files + directories)
+            const items = await fs.readdir(tasksDir, { withFileTypes: true });
+            // Process root-level .md files
+            const rootMdFiles = items.filter(item => item.isFile() && item.name.endsWith('.md'));
+            console.error(`[ReverseSync] Loading existing task files...`);
+            console.error(`[ReverseSync] Found ${rootMdFiles.length} files in root`);
+            for (const file of rootMdFiles) {
+                await this.loadTaskFile(file.name, tasksDir);
+            }
+            // Process subdirectories (section folders)
+            const subdirs = items.filter(item => item.isDirectory());
+            console.error(`[ReverseSync] Found ${subdirs.length} section folders`);
+            for (const dir of subdirs) {
+                const sectionPath = path.join(tasksDir, dir.name);
+                const sectionFiles = await fs.readdir(sectionPath);
+                const mdFiles = sectionFiles.filter(f => f.endsWith('.md'));
+                console.error(`[ReverseSync] Scanning ${dir.name}/ (${mdFiles.length} files)`);
+                for (const filename of mdFiles) {
+                    // Store relative path with section folder
+                    const relativePath = `${dir.name}/${filename}`;
+                    await this.loadTaskFile(relativePath, tasksDir);
+                }
+            }
+            console.error(`[ReverseSync] ✅ Loaded ${this.fileMap.size} task files`);
+        }
+        catch (error) {
+            console.error(`[ReverseSync] Error loading existing files:`, error);
+            // Non-fatal, continue with empty map
+        }
+    }
+    /**
+     * Load a single task file and add to file map
+     */
+    async loadTaskFile(relativePath, tasksDir) {
+        const fullPath = path.join(tasksDir, relativePath);
+        try {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            // Parse frontmatter to get task_id
+            const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+            if (!frontmatterMatch) {
+                console.error(`[ReverseSync] No frontmatter in ${relativePath}, skipping`);
+                return;
+            }
+            const frontmatter = frontmatterMatch[1];
+            // Match both formats:
+            // Old: task_id: "uuid" or task_id: 'uuid'
+            // New: task_id: uuid (under sync block, no quotes)
+            const taskIdMatch = frontmatter.match(/task_id: ["']?([a-f0-9-]+)["']?/);
+            if (taskIdMatch) {
+                const taskId = taskIdMatch[1];
+                this.fileMap.set(taskId, relativePath);
+                console.error(`[ReverseSync] Loaded: ${relativePath} → ${taskId}`);
+            }
+        }
+        catch (error) {
+            console.error(`[ReverseSync] Error reading ${relativePath}:`, error);
+        }
+    }
+    /**
+     * Perform initial sync of all existing tasks in the taskboard
+     *
+     * IMPORTANT: This does NOT create conflict files. On startup we simply:
+     * - Create files for tasks that exist in Commander but not locally
+     * - Skip files that already exist locally (trust local state)
+     *
+     * Conflict detection only happens on LIVE Realtime events (changes while daemon runs).
+     */
+    async performInitialSync() {
+        console.error('[ReverseSync] Performing initial sync (skip-if-exists mode)...');
+        try {
+            const { data: tasks, error } = await this.supabase
+                .from('tasks')
+                .select('id, title, description, status, status_section_id, priority, board_id, updated_at, created_at, metadata')
+                .eq('board_id', this.config.taskboardId)
+                .order('created_at', { ascending: false });
+            if (error) {
+                console.error('[ReverseSync] Error querying tasks:', error);
+                throw error;
+            }
+            if (!tasks || tasks.length === 0) {
+                console.error('[ReverseSync] No existing tasks found in taskboard');
+                return;
+            }
+            console.error(`[ReverseSync] Found ${tasks.length} tasks in Commander`);
+            // Create all section folders first
+            const tasksDir = path.join(this.config.projectPath, this.config.tasksFolder);
+            for (const [_sectionId, folderName] of this.sectionMap.entries()) {
+                const sectionPath = path.join(tasksDir, folderName);
+                try {
+                    await fs.mkdir(sectionPath, { recursive: true });
+                }
+                catch {
+                    // Folder may already exist
+                }
+            }
+            // Track statistics
+            let created = 0;
+            let skipped = 0;
+            // Process each task - simple logic: create if missing, skip if exists
+            for (const task of tasks) {
+                const existingFilePath = this.fileMap.get(task.id);
+                if (!existingFilePath) {
+                    // Task exists in Commander but no file in IDE → Create file
+                    await this.syncTaskToFile(task);
+                    created++;
+                }
+                else {
+                    // File already exists locally → Trust it, skip
+                    skipped++;
+                }
+            }
+            console.error('[ReverseSync] ✅ Initial sync complete:');
+            console.error(`[ReverseSync]    Created: ${created} files (new from Commander)`);
+            console.error(`[ReverseSync]    Skipped: ${skipped} files (already exist locally)`);
+            console.error(`[ReverseSync]    Watching for live changes...`);
+        }
+        catch (error) {
+            console.error('[ReverseSync] Error during initial sync:', error);
+            // Non-fatal, continue with realtime sync
+        }
+    }
+    /**
+     * Handle task change from Commander (debounced)
+     */
+    async handleTaskChange(change) {
+        const taskId = change.task.id;
+        // Add to pending changes (newer changes override older ones)
+        this.pendingChanges.set(taskId, change);
+        // Debounce: wait for sync interval before processing
+        if (this.syncTimer) {
+            clearTimeout(this.syncTimer);
+        }
+        this.syncTimer = setTimeout(() => {
+            this.processQueuedChanges();
+        }, this.config.syncIntervalMs);
+    }
+    /**
+     * Process all queued task changes
+     */
+    async processQueuedChanges() {
+        if (this.pendingChanges.size === 0) {
+            return;
+        }
+        console.error(`[ReverseSync] Processing ${this.pendingChanges.size} queued changes...`);
+        for (const [taskId, change] of this.pendingChanges) {
+            try {
+                switch (change.type) {
+                    case 'INSERT':
+                    case 'UPDATE':
+                        await this.syncTaskToFile(change.task);
+                        break;
+                    case 'DELETE':
+                        await this.deleteTaskFile(taskId);
+                        break;
+                }
+            }
+            catch (error) {
+                console.error(`[ReverseSync] Error processing ${change.type} for ${taskId}:`, error);
+                this.emit('error', error);
+            }
+        }
+        // Clear queue
+        this.pendingChanges.clear();
+        this.syncTimer = null;
+    }
+    /**
+     * Sync task to file (create or update)
+     */
+    async syncTaskToFile(task) {
+        // Get section folder (e.g., "backlog", "to-do", "in-progress")
+        const sectionFolder = task.status_section_id
+            ? this.sectionMap.get(task.status_section_id)
+            : null;
+        // Generate filename
+        const filename = this.generateFilename(task.title, task.id);
+        // Build new file path with section folder
+        const newFilePath = sectionFolder
+            ? `${sectionFolder}/${filename}`
+            : filename;
+        // Check if file exists
+        const existingFilePath = this.fileMap.get(task.id);
+        if (existingFilePath) {
+            // UPDATE: Check for conflicts
+            const hasConflict = await this.checkConflict(task.id, task);
+            if (hasConflict) {
+                console.error(`[ReverseSync] ⚠️  Conflict detected for task ${task.id}, applying latest timestamp wins`);
+                // Will overwrite - conflict resolution logs to sync_transactions
+            }
+            // Check if section changed (file needs to move)
+            if (existingFilePath !== newFilePath) {
+                console.error(`[ReverseSync] Task moved sections, relocating file: ${existingFilePath} → ${newFilePath}`);
+                // Delete old file
+                await this.deleteTaskFile(task.id);
+                // Write to new location
+                await this.writeTaskFile(task, newFilePath);
+            }
+            else {
+                // Update existing file (same location)
+                await this.writeTaskFile(task, existingFilePath);
+            }
+        }
+        else {
+            // INSERT: Create new file
+            await this.writeTaskFile(task, newFilePath);
+        }
+        this.emit('task-synced', {
+            taskId: task.id,
+            title: task.title,
+            operation: existingFilePath ? 'update' : 'create',
+        });
+    }
+    /**
+     * Convert task to markdown format
+     */
+    taskToMarkdown(task, existingDocumentId) {
+        const { id, title, description, status, priority, updated_at } = task;
+        // Convert status to checkbox
+        const checkbox = status === 'done' ? '[x]' : '[ ]';
+        // Map task status to sync status
+        const syncStatus = status === 'done' ? 'completed' : 'active';
+        // Build frontmatter with sync block for SyncEngine compatibility
+        // NOTE: Do NOT set ide_modified_at here - that field tracks actual IDE edits
+        // ReverseSync only sets commander_modified_at to track Commander's version
+        const frontmatter = [
+            '---',
+            'sync:',
+            '  type: task',
+            `  status: ${syncStatus}`,
+            `  task_id: ${id}`,
+            existingDocumentId ? `  document_id: ${existingDocumentId}` : null,
+            `  last_synced: '${new Date().toISOString()}'`,
+            `title: "${title.replace(/"/g, '\\"')}"`,
+            `status: "${status}"`,
+            priority ? `priority: "${priority}"` : null,
+            `commander_modified_at: "${updated_at}"`,
+            '---',
+        ].filter(Boolean).join('\n');
+        // Clean description - remove any existing ## Task, ## Notes, # Title sections
+        // to prevent accumulation from sync loop
+        let cleanDescription = description || '';
+        // Remove repeated title headers
+        cleanDescription = cleanDescription.replace(new RegExp(`^# ${title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*`, 'gm'), '');
+        // Remove ## Task sections and everything after (our template sections)
+        cleanDescription = cleanDescription.replace(/## Task[\s\S]*$/m, '').trim();
+        // Build content
+        const content = [
+            `# ${title}`,
+            '',
+            cleanDescription,
+            '',
+            '## Task',
+            '',
+            `- ${checkbox} ${title}`,
+            '',
+            '## Notes',
+            '',
+            '_Add your notes here_',
+        ].join('\n');
+        return `${frontmatter}\n\n${content}\n`;
+    }
+    /**
+     * Slugify a name for use in folder/file names
+     */
+    slugifyName(name) {
+        return name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '');
+    }
+    /**
+     * Generate filename from task title (slugified)
+     */
+    generateFilename(title, taskId) {
+        // Slugify: lowercase, replace spaces/special chars with hyphens
+        const slug = this.slugifyName(title).substring(0, 50); // Limit length
+        // Ensure uniqueness with short UUID suffix if needed
+        const filename = `${slug}.md`;
+        // Check if file exists with different task_id
+        const existingTaskId = Array.from(this.fileMap.entries()).find(([id, file]) => file === filename && id !== taskId)?.[0];
+        if (existingTaskId) {
+            // Add short UUID to make unique
+            const shortId = taskId.substring(0, 8);
+            return `${slug}-${shortId}.md`;
+        }
+        return filename;
+    }
+    /**
+     * Write task to markdown file
+     */
+    async writeTaskFile(task, filePath) {
+        const fullPath = path.join(this.config.projectPath, this.config.tasksFolder, filePath);
+        // Try to read existing file to preserve document_id
+        let existingDocumentId;
+        try {
+            const existingContent = await fs.readFile(fullPath, 'utf-8');
+            const frontmatterMatch = existingContent.match(/^---\n([\s\S]*?)\n---/);
+            if (frontmatterMatch) {
+                const docIdMatch = frontmatterMatch[1].match(/document_id: ["']?([a-f0-9-]+)["']?/);
+                if (docIdMatch) {
+                    existingDocumentId = docIdMatch[1];
+                }
+            }
+        }
+        catch {
+            // File doesn't exist yet, that's fine
+        }
+        const markdown = this.taskToMarkdown(task, existingDocumentId);
+        // Ensure directory exists
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        // Write file
+        await fs.writeFile(fullPath, markdown, 'utf-8');
+        // Update file map
+        this.fileMap.set(task.id, filePath);
+        console.error(`[ReverseSync] ✅ Created/Updated: ${filePath}`);
+    }
+    /**
+     * Delete task markdown file
+     */
+    async deleteTaskFile(taskId) {
+        const filePath = this.fileMap.get(taskId);
+        if (!filePath) {
+            console.error(`[ReverseSync] No file found for task: ${taskId}`);
+            return;
+        }
+        const fullPath = path.join(this.config.projectPath, this.config.tasksFolder, filePath);
+        try {
+            await fs.unlink(fullPath);
+            this.fileMap.delete(taskId);
+            console.error(`[ReverseSync] ✅ Deleted: ${filePath}`);
+        }
+        catch (error) {
+            console.error(`[ReverseSync] Failed to delete ${filePath}:`, error);
+        }
+    }
+    /**
+     * Check for conflicts between IDE file and Commander task
+     * Returns true if IDE file was modified after Commander task
+     */
+    async checkConflict(taskId, _task) {
+        const filePath = this.fileMap.get(taskId);
+        if (!filePath) {
+            return false; // No existing file, no conflict
+        }
+        const fullPath = path.join(this.config.projectPath, this.config.tasksFolder, filePath);
+        try {
+            // Read existing file
+            const content = await fs.readFile(fullPath, 'utf-8');
+            // Parse frontmatter to get ide_modified_at
+            const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+            if (!frontmatterMatch) {
+                return false; // No frontmatter, no conflict detection possible
+            }
+            const frontmatter = frontmatterMatch[1];
+            const ideModifiedMatch = frontmatter.match(/ide_modified_at: ["']([^"']+)["']/);
+            const commanderModifiedMatch = frontmatter.match(/commander_modified_at: ["']([^"']+)["']/);
+            // If no ide_modified_at, file was created by ReverseSync - no IDE edits, no conflict
+            if (!ideModifiedMatch) {
+                return false;
+            }
+            if (!commanderModifiedMatch) {
+                return false; // Missing commander timestamp, can't compare
+            }
+            const ideModifiedAt = new Date(ideModifiedMatch[1]);
+            const lastKnownCommander = new Date(commanderModifiedMatch[1]);
+            // Conflict if IDE was modified after the last known Commander timestamp we stored
+            const hasConflict = ideModifiedAt > lastKnownCommander;
+            if (hasConflict) {
+                console.error(`[ReverseSync] Conflict: IDE modified at ${ideModifiedAt.toISOString()}, last synced Commander at ${lastKnownCommander.toISOString()}`);
+                // Log conflict (latest wins, but we record it happened)
+                this.emit('conflict', {
+                    taskId,
+                    ideModifiedAt: ideModifiedAt.toISOString(),
+                    commanderModifiedAt: lastKnownCommander.toISOString(),
+                    resolution: 'commander-wins', // We're overwriting with Commander version
+                });
+            }
+            return hasConflict;
+        }
+        catch (error) {
+            console.error(`[ReverseSync] Error checking conflict for ${taskId}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Get current status
+     */
+    getStatus() {
+        return {
+            running: this.running,
+            subscribedTo: this.config.taskboardId,
+            filesTracked: this.fileMap.size,
+            pendingChanges: this.pendingChanges.size,
+        };
+    }
+}
+//# sourceMappingURL=reverse-sync.js.map