@mod-computer/cli 0.2.4 → 0.2.5

package/dist/containers/branches-container.js

@@ -1,140 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useRef, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
-import { readModConfig, writeModConfig } from '../services/mod-config.js';
-import { BranchService } from '@mod/mod-core/services/branch-service';
-import { ThreadService } from '@mod/mod-core/services/thread-service';
-export default function BranchesContainer({ repo, workspace, onSelect }) {
-    const [threads, setThreads] = useState([]);
-    const [idx, setIdx] = useState(0);
-    const [error, setError] = useState(null);
-    const desiredBranchRef = useRef(null);
-    useEffect(() => {
-        try {
-            desiredBranchRef.current = readModConfig()?.activeBranchId || null;
-        }
-        catch {
-            desiredBranchRef.current = null;
-        }
-    }, []);
-    useEffect(() => {
-        let cancelled = false;
-        let subHandle = null;
-        (async () => {
-            try {
-                if (!workspace)
-                    return;
-                const wsHandle = await repo.find(workspace.id);
-                let wsDoc = await wsHandle.doc();
-                if (!wsDoc && !cancelled) {
-                    const deadline = Date.now() + 5000;
-                    while (!wsDoc && Date.now() < deadline) {
-                        try {
-                            wsDoc = await wsHandle.doc();
-                        }
-                        catch { }
-                        if (wsDoc)
-                            break;
-                        await new Promise(r => setTimeout(r, 120));
-                    }
-                }
-                const branchesDocId = wsDoc?.branchesDocId;
-                const buildList = async () => {
-                    try {
-                        const branchService = new BranchService(repo);
-                        const branches = await branchService.getBranchesForWorkspace(branchesDocId);
-                        const list = [];
-                        for (const b of (branches || [])) {
-                            const bId = String(b?.id || '');
-                            if (!bId)
-                                continue;
-                            const tId = b?.threadId ? String(b.threadId) : bId;
-                            list.push({
-                                id: tId,
-                                name: b?.name || 'Thread',
-                                branchId: bId,
-                                hasThread: Boolean(b?.threadId),
-                            });
-                        }
-                        if (!cancelled)
-                            setThreads(list);
-                        if (!cancelled && desiredBranchRef.current) {
-                            const matchIdx = list.findIndex(t => t.branchId === desiredBranchRef.current);
-                            if (matchIdx >= 0) {
-                                setIdx(matchIdx);
-                                desiredBranchRef.current = null;
-                            }
-                        }
-                    }
-                    catch (e) {
-                        if (!cancelled)
-                            setError(e?.message || 'Failed to load threads');
-                    }
-                };
-                if (!branchesDocId) {
-                    if (!cancelled)
-                        setThreads([]);
-                    return;
-                }
-                // Subscribe to branchesDoc hydration and rebuild on change
-                try {
-                    subHandle = await repo.find(branchesDocId);
-                    const onChange = async () => { await buildList(); };
-                    try {
-                        subHandle.on && subHandle.on('change', onChange);
-                    }
-                    catch { }
-                }
-                catch { }
-                await buildList();
-            }
-            catch (e) {
-                if (!cancelled)
-                    setError(e?.message || 'Failed to load threads');
-            }
-        })();
-        return () => { cancelled = true; try {
-            subHandle && subHandle.off && subHandle.off('change');
-        }
-        catch { } ; };
-    }, [repo, workspace]);
-    useInput((input, key) => {
-        if (key.downArrow)
-            setIdx(i => Math.min(i + 1, Math.max(0, threads.length - 1)));
-        else if (key.upArrow)
-            setIdx(i => Math.max(i - 1, 0));
-        else if (key.return) {
-            (async () => {
-                const t = threads[idx];
-                if (!t)
-                    return;
-                let next = t;
-                if (t.branchId)
-                    writeModConfig({ activeBranchId: t.branchId });
-                // If id equals branchId, there is no thread yet; create lazily now
-                if (t.branchId && String(t.id) === String(t.branchId)) {
-                    try {
-                        const wsHandle = await repo.find(workspace.id);
-                        const threadService = new ThreadService(repo);
-                        const createdId = await threadService.createThread(t.name || 'New Thread', t.branchId);
-                        // Persist on branch for branch-first model
-                        try {
-                            const bService = new BranchService(repo);
-                            const wsDoc = await wsHandle.doc();
-                            if (wsDoc?.branchesDocId) {
-                                await bService.setThreadId(t.branchId, createdId, wsDoc.branchesDocId);
-                            }
-                        }
-                        catch { }
-                        next = { ...t, id: createdId, hasThread: true };
-                    }
-                    catch { }
-                }
-                onSelect(next);
-            })();
-        }
-    });
-    if (error)
-        return _jsx(Text, { color: "red", children: error });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Branches (threads)" }), threads.length === 0 ? (_jsx(Text, { color: "gray", children: "No threads" })) : (threads.map((t, i) => (_jsxs(Text, { color: i === idx ? 'green' : undefined, children: [t.name, ' ', _jsxs(Text, { color: "gray", children: ["(", t.branchId || 'no-branch', ")", t.hasThread === false ? ' — no thread (will create on select)' : ''] })] }, t.id)))), _jsx(Text, { color: "cyan", children: "Enter to select" })] }));
-}

package/dist/containers/directory-container.js

@@ -1,92 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
-import { useDirectoryStore, useDirectoryLoader } from '../stores/use-directory-store.js';
-import fs from 'fs';
-import path from 'path';
-export default function DirectoryPageContainer({ repo, selectedWorkspace, selectedThread }) {
-    const { loadRootDirectory } = useDirectoryLoader();
-    const items = useDirectoryStore((s) => s.items);
-    const rootIds = useDirectoryStore((s) => s.rootIds);
-    const loading = useDirectoryStore((s) => s.loading);
-    const error = useDirectoryStore((s) => s.error);
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    const [status, setStatus] = useState(null);
-    useEffect(() => {
-        let cancelled = false;
-        async function loadOnly() {
-            loadRootDirectory({ repo, selectedWorkspace, selectedThread });
-        }
-        loadOnly();
-        return () => {
-            cancelled = true;
-        };
-    }, [repo, selectedWorkspace, selectedThread, loadRootDirectory]);
-    useInput((input, key) => {
-        if (key.downArrow) {
-            setSelectedIndex(i => Math.min(i + 1, rootIds.length - 1));
-        }
-        else if (key.upArrow) {
-            setSelectedIndex(i => Math.max(i - 1, 0));
-        }
-        else if (key.return && key.shift) {
-            // TODO: Handle Shift+Enter (expand/collapse folder)
-        }
-        else if (key.return) {
-            // Handle Enter (open file/folder)
-            const id = rootIds[selectedIndex];
-            const item = items[id];
-            if (item && item.type === 'file') {
-                openFileInEditor(item).catch(e => setStatus('Failed to open file: ' + e.message));
-            }
-            // TODO: Handle folder navigation
-        }
-    });
-    async function openFileInEditor(item) {
-        setStatus('Updating working directory...');
-        // 1. Fetch file content from Automerge in branch context
-        let content = '';
-        let fileWrap = null;
-        try {
-            const { BranchableRepo } = await import('@mod/mod-core/services/branchable-repo');
-            const br = new BranchableRepo(repo);
-            const branchId = selectedThread?.branchId || selectedThread?.id;
-            const workspaceId = selectedWorkspace?.id;
-            fileWrap = await br.openHandle(item.id, { branchId, workspaceId });
-            const fileDoc = fileWrap.doc();
-            content = (fileDoc.content || fileDoc.text || fileDoc.markdown || '');
-        }
-        catch {
-            // Fallback to plain repo handle
-            const fh = await repo.find(item.id);
-            const d = await fh.doc();
-            content = d.content || d.text || '';
-            fileWrap = fh;
-        }
-        // 2. Write to working directory (materialize)
-        try {
-            const fileName = (item?.name || `${item.id}.txt`);
-            const outPath = path.resolve(process.cwd(), fileName);
-            // Ensure parent directory exists
-            fs.mkdirSync(path.dirname(outPath), { recursive: true });
-            fs.writeFileSync(outPath, content ?? '', 'utf8');
-            setStatus(`Wrote ${fileName} to working directory.`);
-        }
-        catch (e) {
-            setStatus(`Failed to write file: ${e.message}`);
-        }
-        setTimeout(() => setStatus(null), 2000);
-    }
-    if (loading)
-        return _jsx(Text, { children: "Loading files..." });
-    if (error)
-        return _jsx(Text, { color: "red", children: error });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Files & Folders (root)" }), rootIds.length === 0 ? (_jsx(Text, { color: "gray", children: "No files or folders found." })) : (rootIds.map((id, idx) => {
-                const item = items[id];
-                if (!item)
-                    return null;
-                // Make key unique by prefixing with type and index
-                const key = `${item.type}-${item.id}-${idx}`;
-                return (_jsxs(Text, { color: idx === selectedIndex ? 'green' : undefined, children: [item.type === 'folder' ? '\ud83d\udcc1' : '\ud83d\udcc4', " ", item.name] }, key));
-            })), status && _jsx(Text, { color: "yellow", children: status })] }));
-}

package/dist/containers/thread-container.js

@@ -1,214 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { useEffect, useState, useCallback } from 'react';
-import ThreadView from '../components/thread.js';
-import { CLIThreadService } from '../services/thread-service.js';
-import { log } from '../services/logger.js';
-export default function ThreadPageContainer({ repo, activeThread, workspace, pendingChatInput, onChatInputHandled, handleInputSubmit, }) {
-    // Remove input state, only use for agent stream if needed
-    const [messages, setMessages] = useState([]);
-    const [agentChunks, setAgentChunks] = useState([]);
-    const [threadService, setThreadService] = useState(null);
-    // Helper to parse bold (**bold**) in content for CLI
-    const parseContentSegments = useCallback((content) => {
-        const segments = [];
-        let currentIndex = 0;
-        while (currentIndex < content.length) {
-            const boldStart = content.indexOf('**', currentIndex);
-            if (boldStart === -1) {
-                segments.push({ text: content.slice(currentIndex), isBold: false });
-                break;
-            }
-            if (boldStart > currentIndex) {
-                segments.push({ text: content.slice(currentIndex, boldStart), isBold: false });
-            }
-            const boldEnd = content.indexOf('**', boldStart + 2);
-            if (boldEnd === -1) {
-                segments.push({ text: content.slice(currentIndex), isBold: false });
-                break;
-            }
-            segments.push({ text: content.slice(boldStart + 2, boldEnd), isBold: true });
-            currentIndex = boldEnd + 2;
-        }
-        return segments;
-    }, []);
-    // Setup thread service
-    useEffect(() => {
-        setThreadService(new CLIThreadService(repo));
-    }, [repo]);
-    // Subscribe to thread changes for real-time updates
-    useEffect(() => {
-        if (!activeThread || !repo)
-            return;
-        let cancelled = false;
-        let messageUnsubs = [];
-        let threadUnsub;
-        async function subscribe() {
-            const threadId = activeThread.id;
-            let tHandle;
-            try {
-                tHandle = await repo.find(threadId);
-            }
-            catch (e) {
-                console.warn('[CLI][Thread] thread handle not available yet, will retry on next tick');
-                return;
-            }
-            async function updateMessagesAndSubs() {
-                if (cancelled)
-                    return;
-                let tDoc;
-                try {
-                    tDoc = tHandle.doc();
-                }
-                catch {
-                    return;
-                }
-                const itemIds = Array.isArray(tDoc?.itemIds) ? tDoc.itemIds : [];
-                // Unsubscribe previous message listeners
-                messageUnsubs.forEach(unsub => unsub());
-                // Subscribe to all message docs
-                const results = await Promise.allSettled(itemIds.map(id => repo.find(id)));
-                const messageHandles = results
-                    .filter(r => r.status === 'fulfilled')
-                    .map(r => r.value);
-                function updateMessages() {
-                    if (cancelled)
-                        return;
-                    const msgs = [];
-                    for (const h of messageHandles) {
-                        try {
-                            const mDoc = h.doc();
-                            msgs.push({
-                                id: mDoc.id,
-                                text: mDoc.content || mDoc.text || '',
-                                timestamp: mDoc.timestamp || Date.now(),
-                                userType: mDoc.userType || 'assistant',
-                                user: mDoc.user || null,
-                                _contentHash: (mDoc.content || mDoc.text || '').length,
-                            });
-                        }
-                        catch { }
-                    }
-                    setMessages(msgs);
-                }
-                messageUnsubs = messageHandles.map(h => {
-                    h.on('change', updateMessages);
-                    return () => h.off('change', updateMessages);
-                });
-                updateMessages();
-            }
-            tHandle.on('change', updateMessagesAndSubs);
-            threadUnsub = () => tHandle.off('change', updateMessagesAndSubs);
-            await updateMessagesAndSubs();
-        }
-        subscribe();
-        return () => {
-            cancelled = true;
-            messageUnsubs.forEach(unsub => unsub());
-            if (threadUnsub)
-                threadUnsub();
-        };
-    }, [activeThread, repo]);
-    // If pendingChatInput changes, send it as a message
-    useEffect(() => {
-        if (pendingChatInput && pendingChatInput.trim() !== '') {
-            handleChatInput(pendingChatInput);
-            onChatInputHandled();
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [pendingChatInput]);
-    // Handle chat/command input
-    const handleChatInput = async (value) => {
-        // Navigation commands are handled by App
-        if (value.trim().startsWith('/')) {
-            handleInputSubmit(value);
-            return;
-        }
-        if (!activeThread || !threadService || !workspace || !repo)
-            return;
-        const wsHandle = await repo.find(workspace.id);
-        const wsDoc = await wsHandle.doc();
-        // Support @agent mention override (e.g., "@dev: fix this bug")
-        const extractAgentMention = (text) => {
-            const leading = text.replace(/^\s+/, '');
-            const match = leading.match(/^@([a-zA-Z][\w-]*)\b:?\s*/);
-            if (!match)
-                return null;
-            const name = match[1].toLowerCase();
-            const message = leading.slice(match[0].length);
-            return { name, message };
-        };
-        async function loadAgentByName(name) {
-            const n = String(name || '').toLowerCase();
-            try {
-                if (n === 'dev' || n === 'developer') {
-                    const url = new URL('../../../mod-agents/dev-agent/dist/index.mjs', import.meta.url).toString();
-                    const mod = await import(url);
-                    try {
-                        log('[ThreadContainer] loaded dev agent module keys:', Object.keys(mod));
-                    }
-                    catch { }
-                    return mod.devAgent || mod.default?.devAgent || mod.default || mod;
-                }
-                if (n === 'planner' || n === 'plan') {
-                    const url = new URL('../../../mod-agents/planner/dist/index.mjs', import.meta.url).toString();
-                    const mod = await import(url);
-                    try {
-                        log('[ThreadContainer] loaded planner agent module keys:', Object.keys(mod));
-                    }
-                    catch { }
-                    return mod.plannerAgent || mod.default?.plannerAgent || mod.default || mod;
-                }
-                if (n === 'general' || n === 'assistant') {
-                    const url = new URL('../../../mod-agents/dev-agent/dist/index.mjs', import.meta.url).toString();
-                    const mod = await import(url);
-                    try {
-                        log('[ThreadContainer] loaded general agent module keys:', Object.keys(mod));
-                    }
-                    catch { }
-                    return mod.devAgent || mod.default?.devAgent || mod.default || mod;
-                }
-            }
-            catch (e) {
-                try {
-                    log('[ThreadContainer] loadAgentByName error:', String(e));
-                }
-                catch { }
-            }
-            return undefined;
-        }
-        // Prefer explicit @agent mention without loading a default agent first to avoid unnecessary module graphs
-        let textToSend = value;
-        const mention = extractAgentMention(value);
-        let agent;
-        if (mention) {
-            agent = (await loadAgentByName(mention.name)) || { id: mention.name, name: mention.name };
-            textToSend = mention.message.trimStart();
-        }
-        else {
-            const baseAgentId = (wsDoc.activeAgents && wsDoc.activeAgents[0]) || 'general';
-            agent = (await loadAgentByName(baseAgentId)) || { id: baseAgentId, name: baseAgentId };
-        }
-        // 3. Stream agent chat (user message + agent response)
-        let sawChunk = false;
-        setAgentChunks([]); // Clear previous stream
-        try {
-            for await (const chunk of threadService.streamAgentChat({
-                threadId: activeThread.id,
-                userMessage: textToSend,
-                user: { id: 'user-1', name: 'You' },
-                workspace: wsDoc,
-                agent,
-            })) {
-                sawChunk = true;
-                setAgentChunks(prev => [...prev, chunk]); // Add chunk to static stream
-            }
-            if (!sawChunk) {
-                // Optionally show a message or log
-            }
-        }
-        catch (err) {
-            // Optionally show error
-        }
-    };
-    return (_jsx(_Fragment, { children: _jsx(ThreadView, { activeThread: activeThread, messages: Array.isArray(messages) ? messages : [], parseContentSegments: parseContentSegments, messageKeyProp: "_contentHash" }) }));
-}

package/dist/containers/threads-container.js

@@ -1,27 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect } from 'react';
-import { Box, Text } from 'ink';
-import SelectInput from 'ink-select-input';
-import { useThreadsStore } from '../stores/use-threads-store.js';
-export default function ThreadsListContainer({ repo, workspace, onSelect }) {
-    const threads = useThreadsStore(s => s.threads);
-    const loading = useThreadsStore(s => s.loading);
-    const error = useThreadsStore(s => s.error);
-    const fetchThreads = useThreadsStore(s => s.fetchThreads);
-    useEffect(() => {
-        if (repo && workspace)
-            fetchThreads(repo, workspace);
-    }, [repo, workspace, fetchThreads]);
-    if (loading)
-        return _jsx(Text, { children: "Loading threads..." });
-    if (error)
-        return _jsxs(Text, { color: "red", children: ["Error: ", error] });
-    if (!threads.length)
-        return _jsx(Text, { children: "No threads found in workspace." });
-    const items = threads.map(t => ({ label: t.name, value: t.id }));
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Select a thread:" }), _jsx(SelectInput, { items: items, onSelect: item => {
-                    const thread = threads.find(t => t.id === item.value);
-                    if (thread)
-                        onSelect(thread);
-                } })] }));
-}

package/dist/containers/workspaces-container.js

@@ -1,27 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect } from 'react';
-import { Box, Text } from 'ink';
-import SelectInput from 'ink-select-input';
-import { useWorkspacesStore } from '../stores/use-workspaces-store.js';
-export default function WorkspacesListContainer({ repo, onSelect }) {
-    const workspaces = useWorkspacesStore(s => s.workspaces);
-    const loading = useWorkspacesStore(s => s.loading);
-    const error = useWorkspacesStore(s => s.error);
-    const fetchWorkspaces = useWorkspacesStore(s => s.fetchWorkspaces);
-    useEffect(() => {
-        if (repo)
-            fetchWorkspaces(repo);
-    }, [repo, fetchWorkspaces]);
-    if (loading)
-        return _jsx(Text, { children: "Loading workspaces..." });
-    if (error)
-        return _jsxs(Text, { color: "red", children: ["Error: ", error] });
-    if (!workspaces.length)
-        return _jsx(Text, { children: "No workspaces found in root doc." });
-    const items = workspaces.map(w => ({ label: w.name, value: w.id }));
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Select a workspace:" }), _jsx(SelectInput, { items: items, onSelect: item => {
-                    const ws = workspaces.find(w => w.id === item.value);
-                    if (ws)
-                        onSelect(ws);
-                } })] }));
-}

package/dist/daemon/conflict-resolution.js

@@ -1,172 +0,0 @@
-// glassware[type="implementation", id="impl-conflict-resolution--323bddc9", requirements="requirement-cli-sync-conflict-lww--626f73f4,requirement-cli-sync-conflict-log--7ac92a94"]
-/**
- * Conflict resolution for bidirectional sync.
- * Implements last-write-wins strategy with conflict logging.
- */
-import fs from 'fs';
-import path from 'path';
-import { getLogsDir } from '../lib/storage.js';
-/**
- * Resolve a conflict between local and remote file states.
- * Uses last-write-wins strategy with local preference for concurrent edits.
- *
- * @param local - Local file state
- * @param remote - Remote file state (from Automerge doc)
- * @returns Resolution decision
- */
-export function resolveConflict(local, remote) {
-    // If content hashes match, no conflict (same content)
-    if (local.contentHash && remote.contentHash && local.contentHash === remote.contentHash) {
-        return {
-            resolution: 'use-local', // Doesn't matter, they're the same
-            reason: 'Content identical (same hash)',
-        };
-    }
-    // If local file hasn't been modified since last sync, use remote
-    // Check both timestamp AND content hash difference to handle cases where
-    // remote metadata.updatedAt isn't updated (e.g., web editor edits)
-    if (!local.modified) {
-        // Local hasn't changed, so any remote difference should be applied
-        if (remote.updatedAt > local.lastSyncedAt) {
-            return {
-                resolution: 'use-remote',
-                reason: 'Local unchanged, remote updated (by timestamp)',
-            };
-        }
-        // Even if timestamp isn't newer, if content is different, use remote
-        // This handles cases where the web editor doesn't update metadata.updatedAt
-        if (local.contentHash && remote.contentHash && local.contentHash !== remote.contentHash) {
-            return {
-                resolution: 'use-remote',
-                reason: 'Local unchanged, remote content differs',
-            };
-        }
-    }
-    // If local was modified and remote hasn't changed since last sync, use local
-    if (local.modified && remote.updatedAt <= local.lastSyncedAt) {
-        return {
-            resolution: 'use-local',
-            reason: 'Local modified, remote unchanged since last sync',
-        };
-    }
-    // Both modified concurrently - local wins (user's active work takes precedence)
-    // Future enhancement: implement actual merge for text files
-    return {
-        resolution: 'use-local',
-        reason: 'Both modified concurrently, local wins (user active work)',
-    };
-}
-/**
- * Get the path to the conflict log file.
- */
-export function getConflictLogPath() {
-    return path.join(getLogsDir(), 'conflicts.log');
-}
-/**
- * Log a conflict record to the conflicts log file.
- */
-export function logConflict(conflict) {
-    const logPath = getConflictLogPath();
-    const logDir = path.dirname(logPath);
-    // Ensure log directory exists
-    if (!fs.existsSync(logDir)) {
-        fs.mkdirSync(logDir, { recursive: true });
-    }
-    const line = `${conflict.timestamp} [${conflict.resolution.toUpperCase()}] ${conflict.path} ` +
-        `(local: ${conflict.localTimestamp}, remote: ${conflict.remoteTimestamp}) - ${conflict.reason}\n`;
-    fs.appendFileSync(logPath, line);
-}
-/**
- * Create a conflict record and log it.
- */
-export function recordConflict(local, remote, resolution, reason) {
-    const record = {
-        path: local.path,
-        localTimestamp: local.localMtime,
-        remoteTimestamp: remote.updatedAt,
-        resolution,
-        timestamp: new Date().toISOString(),
-        reason,
-    };
-    logConflict(record);
-    return record;
-}
-/**
- * Read recent conflicts from the log file.
- * @param limit - Maximum number of conflicts to return
- * @returns Array of conflict records (most recent first)
- */
-export function readRecentConflicts(limit = 100) {
-    const logPath = getConflictLogPath();
-    if (!fs.existsSync(logPath)) {
-        return [];
-    }
-    try {
-        const content = fs.readFileSync(logPath, 'utf-8');
-        const lines = content.trim().split('\n').filter(Boolean);
-        // Parse lines and return most recent first
-        return lines
-            .slice(-limit)
-            .reverse()
-            .map(parseLine)
-            .filter((record) => record !== null);
-    }
-    catch (error) {
-        console.warn('[conflict-resolution] Could not read conflict log');
-        return [];
-    }
-}
-/**
- * Parse a conflict log line back into a record.
- * Format: TIMESTAMP [RESOLUTION] PATH (local: TIMESTAMP, remote: TIMESTAMP) - REASON
- */
-function parseLine(line) {
-    const match = line.match(/^(\S+) \[(\w+-\w+)\] (.+?) \(local: ([^,]+), remote: ([^)]+)\) - (.+)$/);
-    if (!match) {
-        return null;
-    }
-    return {
-        timestamp: match[1],
-        resolution: match[2],
-        path: match[3],
-        localTimestamp: match[4],
-        remoteTimestamp: match[5],
-        reason: match[6],
-    };
-}
-/**
- * ConflictResolver - manages conflict resolution for a sync session.
- */
-export class ConflictResolver {
-    constructor(logger = console.log) {
-        this.conflictCount = 0;
-        this.log = logger;
-    }
-    /**
-     * Check and resolve a potential conflict between local and remote states.
-     * @returns The resolution decision and whether a conflict was detected
-     */
-    checkAndResolve(local, remote) {
-        const { resolution, reason } = resolveConflict(local, remote);
-        // It's only a "conflict" if both sides were modified
-        const isConflict = local.modified && remote.updatedAt > local.lastSyncedAt;
-        if (isConflict) {
-            this.conflictCount++;
-            recordConflict(local, remote, resolution, reason);
-            this.log(`[conflict] ${local.path}: ${reason} → ${resolution}`);
-        }
-        return { resolution, reason, isConflict };
-    }
-    /**
-     * Get the number of conflicts detected in this session.
-     */
-    getConflictCount() {
-        return this.conflictCount;
-    }
-    /**
-     * Reset the conflict count (e.g., at start of new sync session).
-     */
-    resetCount() {
-        this.conflictCount = 0;
-    }
-}