@mod-computer/cli 0.1.0

package/dist/services/thread-notification-service.js

@@ -0,0 +1,50 @@
+export class ThreadNotificationService {
+    constructor(repo) {
+        this.repo = repo;
+    }
+    /**
+     * Add a file update notification to the thread
+     * For now, this just logs the notification - can be enhanced later
+     */
+    async addFileUpdateNotification(threadId, fileName, action) {
+        try {
+            const message = this.getNotificationMessage(fileName, action);
+            // For now, just log the notification
+            // TODO: Later integrate with actual thread message system
+            console.log(`📢 ${message}`);
+        }
+        catch (error) {
+            console.error(`Failed to add file update notification:`, error);
+        }
+    }
+    /**
+     * Generate notification message based on action
+     */
+    getNotificationMessage(fileName, action) {
+        const emoji = this.getActionEmoji(action);
+        const verb = this.getActionVerb(action);
+        return `${emoji} ${fileName} ${verb}`;
+    }
+    /**
+     * Get emoji for action type
+     */
+    getActionEmoji(action) {
+        switch (action) {
+            case 'updated': return '📝';
+            case 'created': return '✨';
+            case 'deleted': return '🗑️';
+            default: return '📄';
+        }
+    }
+    /**
+     * Get verb for action type
+     */
+    getActionVerb(action) {
+        switch (action) {
+            case 'updated': return 'updated';
+            case 'created': return 'created';
+            case 'deleted': return 'deleted';
+            default: return 'changed';
+        }
+    }
+}

package/dist/services/thread-service.js

@@ -0,0 +1,147 @@
+import { ThreadService as CoreThreadService } from '@mod/mod-core/services/thread-service';
+import { BranchService } from '@mod/mod-core/services/branch-service';
+import { chatWithAgentCli } from './cli-orchestrator.js';
+import { log } from './logger.js';
+export class CLIThreadService {
+    // private ai: typeof runAgentWithStream; // Placeholder for orchestrator/agent logic
+    constructor(repo) {
+        this.core = new CoreThreadService(repo);
+        this.repo = repo;
+        // this.ai = runAgentWithStream; // Assign orchestrator/agent logic as needed
+    }
+    async getThreads(workspaceId) {
+        const wsHandle = await this.repo.find(workspaceId);
+        const workspace = (await wsHandle.doc());
+        if (!workspace || !workspace.branchesDocId)
+            return [];
+        const branchService = new BranchService(this.repo);
+        const threads = [];
+        try {
+            const branches = await branchService.getBranchesForWorkspace(workspace.branchesDocId);
+            for (const branch of branches) {
+                const threadId = branch?.threadId;
+                if (!threadId)
+                    continue;
+                try {
+                    const thread = await this.core.getThread(threadId);
+                    if (thread)
+                        threads.push(thread);
+                }
+                catch (err) {
+                    log('[CLIThreadService] Failed to load thread', {
+                        branchId: branch?.id,
+                        threadId,
+                        err,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            log('[CLIThreadService] Failed to load branches for workspace', {
+                workspaceId,
+                err,
+            });
+        }
+        return threads;
+    }
+    async getThread(threadId) {
+        return this.core.getThread(threadId);
+    }
+    async createThread(name, branchId, workspaceId) {
+        const threadId = await this.core.createThread(name, branchId);
+        try {
+            const branchService = new BranchService(this.repo);
+            const wsHandle = await this.repo.find(workspaceId);
+            const workspace = (await wsHandle.doc());
+            if (workspace?.branchesDocId) {
+                await branchService.setThreadId(branchId, threadId, workspace.branchesDocId);
+            }
+            wsHandle.change((doc) => {
+                doc.activeThreadId = threadId;
+            });
+        }
+        catch (err) {
+            log('[CLIThreadService] Failed to persist threadId on branch', {
+                branchId,
+                workspaceId,
+                err,
+            });
+        }
+        return threadId;
+    }
+    /**
+     * Stream agent chat for a thread in the CLI.
+     * Yields agent response chunks for UI updates.
+     */
+    async *streamAgentChat({ threadId, userMessage, user = { id: 'user-1', name: 'You', avatarUrl: '' }, workspace, agent, files = [], images = [], maxMessages = 20, ...opts }) {
+        // 1) Persist user message immediately
+        await this.core.addThreadItemToThread(threadId, userMessage, user.id, user.name, user.avatarUrl, { workspaceId: workspace.id });
+        // 2) Start CLI-native orchestrator stream
+        const apiKey = (process.env.OPENAI_API_KEY || process.env.OPENAI_API_TOKEN || process.env.OPENAI || process.env.ANTHROPIC_API_KEY || '').trim();
+        try {
+            try {
+                log('[CLIThreadService] Starting stream with agent:', {
+                    name: agent?.name,
+                    id: agent?.id,
+                    defaultModel: agent?.defaultModel,
+                    tools: agent?.tools ? Object.keys(agent.tools) : [],
+                });
+            }
+            catch { }
+            for await (const part of chatWithAgentCli({
+                repo: this.repo,
+                threadId,
+                userMessage,
+                user,
+                workspace,
+                agent: agent || { name: 'Assistant', instructions: 'Be helpful.' },
+                files,
+                images,
+                apiKey,
+                tools: (agent && agent.tools) || {},
+            })) {
+                const p = part;
+                if (p.type === 'content' && p.content) {
+                    yield { type: 'content', content: p.content };
+                }
+                else if (p.type === 'tool-call') {
+                    yield p;
+                }
+                else if (p.type === 'tool-result') {
+                    yield { type: 'tool-result', output: p.output };
+                }
+                else if (p.type === 'error') {
+                    yield { type: 'error', error: String(p.error) };
+                }
+            }
+        }
+        catch (err) {
+            const msg = `orchestrator import/stream failed: ${err?.message || String(err)}`;
+            yield { type: 'error', error: msg };
+            try {
+                await this.core.addAssistantMessageToThread(threadId, msg, agent?.name || 'Assistant');
+            }
+            catch { }
+        }
+    }
+    async sendUserMessage(threadId, message, agentConfig) {
+        // 1. Add user message to thread (core)
+        // const threadRepo = new ThreadRepository(this.repo);
+        // await threadRepo.addThreadItem(
+        // 	threadId,
+        // 	message,
+        // 	[], // contextDocumentIds
+        // 	true, // addToThread
+        // 	'user-1', // userId
+        // 	'You', // userName
+        // 	undefined, // userAvatarUrl
+        // 	{type: 'message'},
+        // );
+        // 2. TODO: Start agent stream (mod-ai)
+        // 3. TODO: As agent responses stream in, append to thread
+        // 4. TODO: Notify UI of updates (if needed)
+    }
+    subscribeToThread(threadId, callback) {
+        // TODO: Implement Automerge doc subscription for reactivity
+    }
+}

package/dist/stores/use-directory-store.js

@@ -0,0 +1,96 @@
+import { createStore } from 'zustand';
+import { useStore } from 'zustand';
+import { BranchableRepo } from '@mod/mod-core/services/branchable-repo';
+import { readModConfig } from '../services/mod-config.js';
+export const directoryStore = createStore((set, get) => ({
+    items: {},
+    rootIds: [],
+    currentPath: [],
+    expandedFolders: {},
+    loading: false,
+    error: null,
+    setItems: (items, rootIds) => set(() => ({
+        items: Object.fromEntries(items.map((i) => [i.id, i])),
+        rootIds,
+    })),
+    setCurrentPath: (path) => set(() => ({ currentPath: path })),
+    setExpanded: (folderId, expanded) => set((state) => ({
+        expandedFolders: { ...state.expandedFolders, [folderId]: expanded }
+    })),
+    setLoading: (loading) => set(() => ({ loading })),
+    setError: (error) => set(() => ({ error })),
+    reset: () => set(() => ({
+        items: {},
+        rootIds: [],
+        currentPath: [],
+        expandedFolders: {},
+        loading: false,
+        error: null,
+    })),
+    async loadRootDirectory({ repo, selectedWorkspace, selectedThread }) {
+        set({ loading: true, error: null });
+        try {
+            if (!repo) {
+                set({ error: 'No repo available', loading: false });
+                return;
+            }
+            const effectiveWorkspaceId = (selectedWorkspace && selectedWorkspace.id) || readModConfig()?.workspaceId;
+            if (!effectiveWorkspaceId) {
+                set({ error: 'No workspace selected or configured (.mod/config.json)', loading: false });
+                return;
+            }
+            const branchContext = new BranchableRepo(repo);
+            // Resolve branchId for consistent branch-aware view (prefer config > workspace.activeBranchId > selectedThread)
+            let resolvedBranchId = undefined;
+            try {
+                resolvedBranchId = readModConfig()?.activeBranchId;
+                if (!resolvedBranchId) {
+                    const wsHandle = await repo.find(effectiveWorkspaceId);
+                    const wsDoc = await wsHandle.doc();
+                    resolvedBranchId = wsDoc?.activeBranchId;
+                }
+                if (!resolvedBranchId && selectedThread?.branchId) {
+                    resolvedBranchId = selectedThread.branchId;
+                }
+            }
+            catch { }
+            const wsWrap = await branchContext.openHandle(effectiveWorkspaceId, { branchId: (resolvedBranchId || undefined), workspaceId: effectiveWorkspaceId });
+            const wsDoc = wsWrap.doc();
+            const fileRefs = wsDoc.fileRefs || [];
+            const folders = wsDoc.folders || [];
+            // Build root-level items and dedupe by name to avoid duplicates
+            const itemMapByName = {};
+            for (const f of folders) {
+                if (!f.parentId) {
+                    const item = { id: f.id, name: f.name, type: 'folder', parentId: f.parentId || null };
+                    if (!itemMapByName[item.name])
+                        itemMapByName[item.name] = item;
+                }
+            }
+            for (const f of fileRefs) {
+                if (!f.folderId) {
+                    const item = { id: f.id, name: f.name, type: 'file', parentId: f.folderId || null };
+                    if (!itemMapByName[item.name])
+                        itemMapByName[item.name] = item;
+                }
+            }
+            const items = Object.values(itemMapByName).sort((a, b) => a.name.localeCompare(b.name));
+            const rootIds = items.map(i => i.id);
+            get().setItems(items, rootIds);
+        }
+        catch (err) {
+            set({ error: err.message || 'Failed to load directory' });
+        }
+        finally {
+            set({ loading: false });
+        }
+    },
+}));
+// React hook for using the vanilla store in components
+export const useDirectoryStore = (selector) => useStore(directoryStore, selector);
+// Custom hook for loading directory (merged from use-directory)
+export function useDirectoryLoader() {
+    const loadRootDirectory = useDirectoryStore((s) => s.loadRootDirectory);
+    const reset = useDirectoryStore((s) => s.reset);
+    return { loadRootDirectory, reset };
+}

package/dist/stores/use-threads-store.js

@@ -0,0 +1,46 @@
+import { create } from 'zustand';
+import { BranchService } from '@mod/mod-core/services/branch-service';
+export const useThreadsStore = create((set) => ({
+    threads: [],
+    loading: false,
+    error: null,
+    fetchThreads: async (repo, selected) => {
+        if (!selected || !repo)
+            return;
+        set({ loading: true, error: null });
+        try {
+            const wsHandle = await repo.find(selected.id);
+            const wsDoc = wsHandle.doc();
+            const threadList = [];
+            if (wsDoc?.branchesDocId) {
+                const branchService = new BranchService(repo);
+                const branches = await branchService.getBranchesForWorkspace(wsDoc.branchesDocId);
+                for (const branch of branches || []) {
+                    const branchId = String(branch?.id || '');
+                    if (!branchId)
+                        continue;
+                    const threadId = branch?.threadId ? String(branch.threadId) : branchId;
+                    let threadDoc = null;
+                    try {
+                        const tHandle = await repo.find(threadId);
+                        threadDoc = tHandle.doc();
+                    }
+                    catch { }
+                    threadList.push({
+                        id: String(threadDoc?.id || threadId),
+                        name: threadDoc?.name || branch?.name || 'Untitled',
+                        branchId,
+                        hasThread: Boolean(branch?.threadId),
+                    });
+                }
+            }
+            set({ threads: threadList });
+        }
+        catch (err) {
+            set({ error: err.message || String(err) });
+        }
+        finally {
+            set({ loading: false });
+        }
+    },
+}));

package/dist/stores/use-workspaces-store.js

@@ -0,0 +1,32 @@
+import { create } from 'zustand';
+export const useWorkspacesStore = create((set) => ({
+    workspaces: [],
+    loading: false,
+    error: null,
+    fetchWorkspaces: async (repo) => {
+        set({ loading: true, error: null });
+        try {
+            // const rootDocId = '3RrsuQCaieHkXPUNSsq3UhEAxnHW';
+            // const rootDocId = 'rY75AHsEfNx1vKnrtpdfmo5dyjr';
+            // const rootDocId = '2a9anXJNoBxstgrhRJfkBGS3uxs';
+            // const rootDocId = '3pW2EWyQPrshmj4Y1KqEo7sMTqxV';
+            const rootDocId = 'KRkJrMQeNQo9bTwSsoKZBxcpz1y';
+            const wsHandle = await repo.find(rootDocId);
+            const doc = wsHandle.doc();
+            const workspacesRaw = doc.workspaces || [];
+            const workspacesList = (Array.isArray(workspacesRaw)
+                ? workspacesRaw
+                : []).map((w) => ({
+                id: w.id || '',
+                name: w.name || w.title || 'Untitled',
+            }));
+            set({ workspaces: workspacesList });
+        }
+        catch (err) {
+            set({ error: err.message || String(err) });
+        }
+        finally {
+            set({ loading: false });
+        }
+    },
+}));

package/dist/types/config.js

@@ -0,0 +1,16 @@
+// glassware[type=implementation, id=cli-config-types, requirements=req-cli-storage-config-1,req-cli-storage-config-2]
+/**
+ * Default settings values.
+ */
+export const DEFAULT_SETTINGS = {
+    syncDebounceMs: 100,
+    logLevel: 'info',
+};
+/**
+ * Default config for new installations.
+ */
+export const DEFAULT_CONFIG = {
+    version: 1,
+    auth: null,
+    settings: DEFAULT_SETTINGS,
+};

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export * from './config.js';
+export * from './workspace-connection.js';

package/dist/types/workspace-connection.js

@@ -0,0 +1,2 @@
+// glassware[type=implementation, id=cli-workspace-connection-types, requirements=req-cli-storage-conn-1,req-cli-storage-conn-3]
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,67 @@
+{
+	"name": "@mod-computer/cli",
+	"version": "0.1.0",
+	"license": "MIT",
+	"bin": {
+		"mod": "dist/cli.bundle.js"
+	},
+	"type": "module",
+	"engines": {
+		"node": ">=16"
+	},
+	"scripts": {
+		"build": "tsc && node fix-imports.js && cp -r source/config/release-profiles dist/config/",
+		"build:bundle": "node build-bundle.js",
+		"prepublishOnly": "pnpm build:bundle",
+		"dev": "tsc --watch",
+		"test": "vitest run",
+		"package": "node build-for-docs.js"
+	},
+	"files": [
+		"dist",
+		"commands"
+	],
+	"dependencies": {
+		"@automerge/automerge": "^3.1.2",
+		"@automerge/automerge-repo": "^2.3.1",
+		"@automerge/automerge-repo-network-websocket": "^2.3.1",
+		"@automerge/automerge-repo-storage-nodefs": "^2.3.1",
+		"@ai-sdk/anthropic": "2.0.0-beta.3",
+		"@ai-sdk/openai": "2.0.0-beta.5",
+		"ai": "5.0.0-beta.11",
+		"chokidar": "^4.0.3",
+		"dotenv": "^17.1.0",
+		"ink": "^6.0.1",
+		"ink-select-input": "^6.2.0",
+		"ink-text-input": "^6.0.0",
+		"meow": "^11.0.0",
+		"react": "19.1.0",
+		"react-dom": "19.1.0",
+		"zustand": "^5.0.6"
+	},
+	"devDependencies": {
+		"@mod/mod-core": "workspace:*",
+		"esbuild": "^0.24.0",
+		"@babel/cli": "^7.21.0",
+		"@babel/preset-react": "^7.18.6",
+		"@types/ink": "^2.0.3",
+		"@types/ink-select-input": "^3.0.5",
+		"@types/ink-text-input": "^2.0.5",
+		"@types/meow": "^5.0.0",
+		"@types/node": "^24.0.10",
+		"@types/react": "^19.1.8",
+		"@vdemedes/prettier-config": "^2.0.1",
+		"chalk": "^5.2.0",
+		"eslint-config-xo-react": "^0.27.0",
+		"eslint-plugin-react": "^7.32.2",
+		"eslint-plugin-react-hooks": "^4.6.0",
+		"import-jsx": "^5.0.0",
+		"ink-testing-library": "^3.0.0",
+		"prettier": "^2.8.7",
+		"react-test-renderer": "^19.1.0",
+		"ts-node": "^10.9.2",
+		"typescript": "^5.8.3",
+		"vitest": "^1.6.1"
+	},
+	"prettier": "@vdemedes/prettier-config"
+}