@mod-computer/cli 0.2.3 → 0.2.5

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

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

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

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

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

@@ -1,54 +0,0 @@
-import { create } from 'zustand';
-import { readConfig } from '../lib/storage.js';
-export const useWorkspacesStore = create((set) => ({
-    workspaces: [],
-    loading: false,
-    error: null,
-    fetchWorkspaces: async (repo) => {
-        set({ loading: true, error: null });
-        try {
-            const config = readConfig();
-            const userDocId = config.auth?.userDocId;
-            if (!userDocId) {
-                set({ workspaces: [], error: 'Not authenticated. Run `mod auth login` first.' });
-                return;
-            }
-            // Fetch workspaces from user document
-            const userHandle = await repo.find(userDocId);
-            await userHandle.whenReady();
-            const userDoc = userHandle.doc();
-            if (!userDoc) {
-                set({ workspaces: [], error: 'Could not load user document.' });
-                return;
-            }
-            const workspaceIds = userDoc.workspaceIds || [];
-            const workspacesList = [];
-            // Load workspace metadata for each workspace
-            for (const wsId of workspaceIds) {
-                try {
-                    const wsHandle = await repo.find(wsId);
-                    await wsHandle.whenReady();
-                    const ws = wsHandle.doc();
-                    workspacesList.push({
-                        id: wsId,
-                        name: ws?.title || ws?.name || 'Untitled',
-                    });
-                }
-                catch {
-                    // Workspace might not be available, add with just ID
-                    workspacesList.push({
-                        id: wsId,
-                        name: 'Untitled',
-                    });
-                }
-            }
-            set({ workspaces: workspacesList });
-        }
-        catch (err) {
-            set({ error: err.message || String(err) });
-        }
-        finally {
-            set({ loading: false });
-        }
-    },
-}));

package/dist/types/add-types.js

@@ -1,99 +0,0 @@
-// glassware[type="implementation", id="impl-cli-add-types--03cec234", requirements="requirement-cli-add-types--e6c546b5"]
-// spec: packages/mod-cli/specs/add.md
-/**
- * Create a typed AddError
- */
-export function createAddError(code, message, path, cause) {
-    return { code, message, path, cause };
-}
-/**
- * Check if an error is an AddError
- */
-export function isAddError(error) {
-    return (typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        'message' in error);
-}
-/**
- * Error strategy mapping - defines how each error type should be handled
- */
-export const ERROR_STRATEGIES = {
-    // Input validation - abort
-    INVALID_PATH: { action: 'abort', userMessage: 'Show error, exit' },
-    PATH_OUTSIDE_WORKSPACE: { action: 'abort', userMessage: 'Show error, exit' },
-    NOT_CONNECTED: { action: 'abort', userMessage: 'Show error, suggest `mod init`' },
-    // File validation - skip
-    FILE_TOO_LARGE: { action: 'skip', userMessage: 'Warning, continue' },
-    PERMISSION_DENIED: { action: 'skip', userMessage: 'Warning, continue' },
-    ENCODING_ERROR: { action: 'fallback', userMessage: 'Auto-convert to binary, continue' },
-    CIRCULAR_SYMLINK: { action: 'skip', userMessage: 'Warning, continue' },
-    // Workspace errors - abort/skip
-    WORKSPACE_NOT_FOUND: { action: 'abort', userMessage: 'Show error, exit' },
-    FOLDER_NOT_FOUND: { action: 'skip', userMessage: 'Warning, continue' },
-    FOLDER_LIMIT_EXCEEDED: { action: 'skip', userMessage: 'Warning, continue' },
-    // Automerge errors - retry
-    DOC_CREATE_FAILED: { action: 'retry', maxRetries: 3, userMessage: 'Retry, then skip' },
-    DOC_UPDATE_FAILED: { action: 'retry', maxRetries: 3, userMessage: 'Retry, then skip' },
-    SYNC_FAILED: { action: 'retry', maxRetries: 3, userMessage: 'Retry, then skip' },
-    HANDLE_TIMEOUT: { action: 'retry', maxRetries: 3, userMessage: 'Retry, then skip' },
-    // System errors - abort
-    OUT_OF_MEMORY: { action: 'abort', userMessage: 'Show error, suggest smaller batch' },
-    CANCELLED: { action: 'abort', userMessage: 'Show progress, exit' },
-    UNKNOWN: { action: 'skip', userMessage: 'Log error, continue' },
-};
-/**
- * Get the error strategy for an error code
- */
-export function getErrorStrategy(code) {
-    return ERROR_STRATEGIES[code];
-}
-/**
- * Constants for add operation
- */
-export const ADD_CONSTANTS = {
-    /** Maximum concurrent file document creations */
-    PARALLEL_FILE_LIMIT: 10,
-    /** Maximum binary file size in bytes (100KB) */
-    MAX_BINARY_SIZE: 100 * 1024,
-    /** Progress update throttle in ms */
-    PROGRESS_THROTTLE_MS: 100,
-    /** Retry attempts for document operations */
-    MAX_RETRIES: 3,
-    /** Backoff multiplier for retries in ms */
-    RETRY_BACKOFF_MS: 100,
-    /** Memory limit in bytes (200MB) */
-    MEMORY_LIMIT: 200 * 1024 * 1024,
-    /** Small add threshold (no progress bar) */
-    SMALL_ADD_THRESHOLD: 100,
-    /** Medium add threshold (spinner) */
-    MEDIUM_ADD_THRESHOLD: 1000,
-};
-/**
- * Known text file extensions
- */
-export const TEXT_EXTENSIONS = new Set([
-    '.txt', '.md', '.js', '.ts', '.tsx', '.jsx', '.json', '.yaml', '.yml',
-    '.toml', '.xml', '.html', '.css', '.scss', '.py', '.rb', '.go', '.rs',
-    '.java', '.c', '.cpp', '.h', '.sh', '.sql', '.graphql', '.vue', '.svelte',
-    '.astro', '.php', '.kt', '.scala', '.swift', '.dockerfile', '.tf', '.hcl',
-    '.ps1', '.bat', '.cmd', '.env', '.gitignore', '.editorconfig', '.prettierrc',
-    '.eslintrc', '.babelrc', 'makefile', 'dockerfile', '.lock'
-]);
-/**
- * Default ignore patterns
- */
-export const DEFAULT_IGNORE_PATTERNS = [
-    'node_modules/',
-    '.git/',
-    'dist/',
-    'build/',
-    '.mod/',
-    '*.log',
-    '.DS_Store',
-    'Thumbs.db',
-    '.env',
-    '.env.local',
-    '.env.*',
-    'secrets/',
-];

package/dist/types/config.js

@@ -1,16 +0,0 @@
-// glassware[type="implementation", id="cli-config-types--dd74d8f7", requirements="requirement-cli-storage-config-1--6e0f731a,requirement-cli-storage-config-2--f95aa032"]
-/**
- * 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

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

package/dist/types/workspace-connection.js

@@ -1,53 +0,0 @@
-// glassware[type="implementation", id="cli-workspace-connection-types--13014cb2", requirements="requirement-cli-storage-conn-1--ce1b8ad9,requirement-cli-storage-conn-3--6536b6b2,requirement-cli-init-data-1--9f55757e"]
-// glassware[type="implementation", id="impl-cli-ws-type-connection--5c50b266", requirements="requirement-cli-ws-type-connection--bc33fa7a,requirement-cli-ws-conn-path--1a1a1301,requirement-cli-ws-conn-workspace-id--39acf87e,requirement-cli-ws-conn-name--791b4633,requirement-cli-ws-conn-connected-at--2ac4aba8,requirement-cli-ws-conn-last-synced--9b1ee720"]
-// spec: packages/mod-cli/specs/workspaces.md, packages/mod-cli/specs/initialization.md
-import path from 'path';
-// ISO 8601 regex pattern for timestamp validation
-const ISO8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
-// glassware[type="implementation", id="impl-cli-ws-conn-validate--c0c28675", requirements="requirement-cli-ws-conn-validate-path--1278682d,requirement-cli-ws-conn-validate-id--826810aa,requirement-cli-ws-conn-validate-timestamps--77971858"]
-/**
- * Validate a WorkspaceConnection object
- */
-export function validateWorkspaceConnection(conn) {
-    const errors = [];
-    if (!conn || typeof conn !== 'object') {
-        return {
-            valid: false,
-            errors: [{ field: 'root', message: 'Connection must be an object', code: 'REQUIRED' }]
-        };
-    }
-    const c = conn;
-    // Validate path - must be absolute
-    if (typeof c.path !== 'string' || !c.path) {
-        errors.push({ field: 'path', message: 'path is required', code: 'REQUIRED' });
-    }
-    else if (!path.isAbsolute(c.path)) {
-        errors.push({ field: 'path', message: 'path must be absolute', code: 'INVALID_PATH' });
-    }
-    // Validate workspaceId - must be non-empty string
-    if (typeof c.workspaceId !== 'string' || !c.workspaceId) {
-        errors.push({ field: 'workspaceId', message: 'workspaceId is required', code: 'REQUIRED' });
-    }
-    // Validate workspaceName - must be non-empty string
-    if (typeof c.workspaceName !== 'string' || !c.workspaceName) {
-        errors.push({ field: 'workspaceName', message: 'workspaceName is required', code: 'REQUIRED' });
-    }
-    // Validate connectedAt - must be ISO 8601
-    if (typeof c.connectedAt !== 'string' || !c.connectedAt) {
-        errors.push({ field: 'connectedAt', message: 'connectedAt is required', code: 'REQUIRED' });
-    }
-    else if (!ISO8601_REGEX.test(c.connectedAt)) {
-        errors.push({ field: 'connectedAt', message: 'connectedAt must be ISO 8601 format', code: 'INVALID_FORMAT' });
-    }
-    // Validate lastSyncedAt - must be ISO 8601
-    if (typeof c.lastSyncedAt !== 'string' || !c.lastSyncedAt) {
-        errors.push({ field: 'lastSyncedAt', message: 'lastSyncedAt is required', code: 'REQUIRED' });
-    }
-    else if (!ISO8601_REGEX.test(c.lastSyncedAt)) {
-        errors.push({ field: 'lastSyncedAt', message: 'lastSyncedAt must be ISO 8601 format', code: 'INVALID_FORMAT' });
-    }
-    return {
-        valid: errors.length === 0,
-        errors
-    };
-}

package/dist/types.js

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