@mod-computer/cli 0.1.0

package/dist/config/release-profiles/v0.2.json

@@ -0,0 +1,11 @@
+{
+  "status": true,
+  "workspace-management": true,
+  "workspace-branching": true,
+  "task-management": false,
+  "file-operations": false,
+  "agent-integrations": false,
+  "sync-operations": false,
+  "watch-operations": false,
+  "connector-integrations": false
+}

package/dist/containers/branches-container.js

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,214 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,27 @@
+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);
+                } })] }));
+}