@mod-computer/cli 0.1.0

package/dist/commands/workspace.js

@@ -0,0 +1,423 @@
+import { createModWorkspace } from '@mod/mod-core';
+import { readModConfig, writeModConfig } from '../services/mod-config.js';
+import fs from 'fs';
+import path from 'path';
+export async function workspaceCommand(args, repo) {
+    const [subcommand, ...rest] = args;
+    switch (subcommand) {
+        case 'create':
+            await handleCreateWorkspace(rest, repo);
+            break;
+        case 'list':
+            await handleListWorkspaces(rest, repo);
+            break;
+        case 'switch':
+            await handleSwitchWorkspace(rest, repo);
+            break;
+        case 'info':
+            await handleWorkspaceInfo(rest, repo);
+            break;
+        case 'delete':
+            await handleDeleteWorkspace(rest, repo);
+            break;
+        case 'rename':
+            await handleRenameWorkspace(rest, repo);
+            break;
+        default:
+            if (!subcommand) {
+                await handleListWorkspaces([], repo);
+            }
+            else {
+                console.error('Usage: mod workspace <create|list|switch|info|delete|rename> [options]');
+                console.error('Available commands:');
+                console.error('  create <name>           Create new workspace and set as active');
+                console.error('  list                    List all available workspaces');
+                console.error('  switch <name-or-id>     Switch to a different workspace');
+                console.error('  info [name-or-id]       Show workspace details');
+                console.error('  delete <name-or-id>     Delete a workspace');
+                console.error('  rename <name-or-id> <new-name>  Rename a workspace');
+                process.exit(1);
+            }
+    }
+    process.exit(0);
+}
+async function handleCreateWorkspace(args, repo) {
+    const [name, ...flags] = args;
+    if (!name) {
+        console.error('Usage: mod workspace create <name> [--description <desc>]');
+        process.exit(1);
+    }
+    let description;
+    const descIndex = flags.indexOf('--description');
+    if (descIndex !== -1 && descIndex + 1 < flags.length) {
+        description = flags[descIndex + 1];
+    }
+    try {
+        const modWorkspace = createModWorkspace(repo);
+        console.log(`Creating workspace: ${name}...`);
+        const workspaceHandle = await modWorkspace.createWorkspace({
+            name: name,
+            description: description
+        });
+        // Get the main branch ID for the newly created workspace
+        const branches = await workspaceHandle.branch.list();
+        const mainBranch = branches.find(b => b.metadata?.type === 'main') || branches[0];
+        if (!mainBranch) {
+            throw new Error('Failed to find main branch in newly created workspace');
+        }
+        const config = (readModConfig() || {});
+        const updatedConfig = {
+            ...config,
+            workspaceId: workspaceHandle.id,
+            workspaceName: name,
+            activeBranchId: mainBranch.id, // Set to main branch ID
+            lastWorkspaceSwitch: new Date().toISOString()
+        };
+        const recentWorkspaces = updatedConfig.recentWorkspaces || [];
+        const existingIndex = recentWorkspaces.findIndex(w => w.id === workspaceHandle.id);
+        const workspaceRef = {
+            id: workspaceHandle.id,
+            name: name,
+            lastAccessed: new Date().toISOString(),
+            accessCount: existingIndex !== -1 ? recentWorkspaces[existingIndex].accessCount + 1 : 1
+        };
+        if (existingIndex !== -1) {
+            recentWorkspaces[existingIndex] = workspaceRef;
+        }
+        else {
+            recentWorkspaces.unshift(workspaceRef);
+            // Keep only last 10 workspaces
+            updatedConfig.recentWorkspaces = recentWorkspaces.slice(0, 10);
+        }
+        writeModConfig(updatedConfig);
+        await invalidateWorkspaceCache();
+        console.log(`✓ Created and switched to workspace: ${name} (${workspaceHandle.id})`);
+        if (description) {
+            console.log(`  Description: ${description}`);
+        }
+    }
+    catch (error) {
+        console.error('Failed to create workspace:', error);
+        console.log('Try running: mod workspace list to check available workspaces');
+        process.exit(1);
+    }
+}
+async function handleListWorkspaces(args, repo) {
+    try {
+        const modWorkspace = createModWorkspace(repo);
+        const workspaces = await getWorkspacesWithCache(modWorkspace);
+        if (workspaces.length === 0) {
+            console.log('No workspaces found.');
+            console.log('Create a new workspace with: mod workspace create <name>');
+            return;
+        }
+        const config = readModConfig();
+        const activeWorkspaceId = config?.workspaceId;
+        console.log('Available workspaces:');
+        workspaces.forEach((workspace, index) => {
+            const isActive = activeWorkspaceId && workspace.id === activeWorkspaceId;
+            const indicator = isActive ? '* ' : '  ';
+            const quickNumber = index < 9 ? `[${index + 1}] ` : '    ';
+            console.log(`${indicator}${quickNumber}${workspace.name} (${workspace.id})`);
+            if (workspace.description) {
+                console.log(`     ${workspace.description}`);
+            }
+            const stats = [
+                `${workspace.fileCount} files`,
+                `${workspace.branchCount} branches`,
+                `updated ${formatRelativeTime(workspace.lastModified)}`
+            ].join(', ');
+            console.log(`     ${stats}`);
+        });
+        if (workspaces.length > 1) {
+            console.log('\nQuick switch: mod workspace switch <number>');
+        }
+    }
+    catch (error) {
+        console.error('Failed to list workspaces:', error);
+        process.exit(1);
+    }
+}
+async function handleSwitchWorkspace(args, repo) {
+    const [nameOrId] = args;
+    if (!nameOrId) {
+        console.error('Usage: mod workspace switch <name-or-id>');
+        process.exit(1);
+    }
+    try {
+        const modWorkspace = createModWorkspace(repo);
+        const targetWorkspace = await resolveWorkspace(nameOrId, modWorkspace);
+        if (!targetWorkspace) {
+            console.error(`Workspace not found: ${nameOrId}`);
+            console.log('Available workspaces:');
+            const workspaces = await getWorkspacesWithCache(modWorkspace);
+            workspaces.forEach((w) => console.log(`  ${w.name} (${w.id})`));
+            process.exit(1);
+        }
+        const config = (readModConfig() || {});
+        const updatedConfig = {
+            ...config,
+            workspaceId: targetWorkspace.id,
+            workspaceName: targetWorkspace.name,
+            activeBranchId: undefined, // Reset to main branch
+            lastWorkspaceSwitch: new Date().toISOString()
+        };
+        const recentWorkspaces = updatedConfig.recentWorkspaces || [];
+        const existingIndex = recentWorkspaces.findIndex(w => w.id === targetWorkspace.id);
+        const workspaceRef = {
+            id: targetWorkspace.id,
+            name: targetWorkspace.name,
+            lastAccessed: new Date().toISOString(),
+            accessCount: existingIndex !== -1 ? recentWorkspaces[existingIndex].accessCount + 1 : 1
+        };
+        if (existingIndex !== -1) {
+            recentWorkspaces[existingIndex] = workspaceRef;
+        }
+        else {
+            recentWorkspaces.unshift(workspaceRef);
+            updatedConfig.recentWorkspaces = recentWorkspaces.slice(0, 10);
+        }
+        writeModConfig(updatedConfig);
+        console.log(`✓ Switched to workspace: ${targetWorkspace.name} (${targetWorkspace.id})`);
+    }
+    catch (error) {
+        console.error('Failed to switch workspace:', error);
+        process.exit(1);
+    }
+}
+async function handleWorkspaceInfo(args, repo) {
+    const [nameOrId] = args;
+    try {
+        const modWorkspace = createModWorkspace(repo);
+        let targetWorkspace;
+        if (nameOrId) {
+            const resolved = await resolveWorkspace(nameOrId, modWorkspace);
+            if (!resolved) {
+                console.error(`Workspace not found: ${nameOrId}`);
+                process.exit(1);
+            }
+            targetWorkspace = resolved;
+        }
+        else {
+            const config = readModConfig();
+            if (!config?.workspaceId) {
+                console.error('No active workspace configured');
+                console.log('Set a workspace with: mod workspace switch <name>');
+                process.exit(1);
+            }
+            const resolved = await resolveWorkspace(config.workspaceId, modWorkspace);
+            if (!resolved) {
+                console.error('Current workspace not found');
+                process.exit(1);
+            }
+            targetWorkspace = resolved;
+        }
+        console.log(`Workspace: ${targetWorkspace.name}`);
+        console.log(`ID: ${targetWorkspace.id}`);
+        if (targetWorkspace.description) {
+            console.log(`Description: ${targetWorkspace.description}`);
+        }
+        console.log(`Files: ${targetWorkspace.fileCount}`);
+        console.log(`Branches: ${targetWorkspace.branchCount}`);
+        console.log(`Last Updated: ${formatAbsoluteTime(targetWorkspace.lastModified)}`);
+        if (targetWorkspace.permissions.length > 0) {
+            console.log(`Permissions: ${targetWorkspace.permissions.join(', ')}`);
+        }
+        const config = readModConfig();
+        if (config?.workspaceId === targetWorkspace.id && config?.activeBranchId) {
+            console.log(`Active Branch: ${config.activeBranchId}`);
+        }
+        else {
+            console.log('Active Branch: main');
+        }
+    }
+    catch (error) {
+        console.error('Failed to get workspace info:', error);
+        process.exit(1);
+    }
+}
+async function handleDeleteWorkspace(args, repo) {
+    const [nameOrId] = args;
+    if (!nameOrId) {
+        console.error('Usage: mod workspace delete <name-or-id>');
+        process.exit(1);
+    }
+    try {
+        const modWorkspace = createModWorkspace(repo);
+        const targetWorkspace = await resolveWorkspace(nameOrId, modWorkspace);
+        if (!targetWorkspace) {
+            console.error(`Workspace not found: ${nameOrId}`);
+            process.exit(1);
+        }
+        console.log(`WARNING: This will permanently delete workspace "${targetWorkspace.name}"`);
+        console.log(`Files: ${targetWorkspace.fileCount}, Branches: ${targetWorkspace.branchCount}`);
+        console.log('Type "yes" to confirm deletion:');
+        // Simple confirmation - in a real implementation you might want to use a proper prompt library
+        const confirm = process.env.MOD_AUTO_CONFIRM === 'yes' ? 'yes' : 'no';
+        if (confirm !== 'yes') {
+            console.log('Deletion cancelled');
+            return;
+        }
+        // Note: Actual deletion would need to be implemented in ModWorkspace interface
+        // For now, just remove from config if it's the active workspace
+        const config = readModConfig();
+        if (config?.workspaceId === targetWorkspace.id) {
+            const updatedConfig = { ...config };
+            delete updatedConfig.workspaceId;
+            delete updatedConfig.workspaceName;
+            delete updatedConfig.activeBranchId;
+            writeModConfig(updatedConfig);
+        }
+        await invalidateWorkspaceCache();
+        console.log(`✓ Workspace "${targetWorkspace.name}" scheduled for deletion`);
+        console.log('Note: Full deletion implementation pending ModWorkspace.deleteWorkspace() interface');
+    }
+    catch (error) {
+        console.error('Failed to delete workspace:', error);
+        process.exit(1);
+    }
+}
+async function handleRenameWorkspace(args, repo) {
+    const [nameOrId, newName] = args;
+    if (!nameOrId || !newName) {
+        console.error('Usage: mod workspace rename <name-or-id> <new-name>');
+        process.exit(1);
+    }
+    try {
+        const modWorkspace = createModWorkspace(repo);
+        const targetWorkspace = await resolveWorkspace(nameOrId, modWorkspace);
+        if (!targetWorkspace) {
+            console.error(`Workspace not found: ${nameOrId}`);
+            process.exit(1);
+        }
+        const existingWorkspaces = await getWorkspacesWithCache(modWorkspace);
+        const isDuplicate = existingWorkspaces.some((w) => w.name === newName && w.id !== targetWorkspace.id);
+        if (isDuplicate) {
+            console.error(`Workspace name "${newName}" already exists`);
+            process.exit(1);
+        }
+        // Note: Actual rename would need to be implemented in ModWorkspace interface
+        // For now, update local config if this is the active workspace
+        const config = readModConfig();
+        if (config?.workspaceId === targetWorkspace.id) {
+            const updatedConfig = { ...config, workspaceName: newName };
+            writeModConfig(updatedConfig);
+        }
+        await invalidateWorkspaceCache();
+        console.log(`✓ Workspace renamed from "${targetWorkspace.name}" to "${newName}"`);
+        console.log('Note: Full rename implementation pending ModWorkspace.renameWorkspace() interface');
+    }
+    catch (error) {
+        console.error('Failed to rename workspace:', error);
+        process.exit(1);
+    }
+}
+async function resolveWorkspace(nameOrId, modWorkspace) {
+    const workspaces = await getWorkspacesWithCache(modWorkspace);
+    // First try exact ID match
+    let match = workspaces.find((w) => w.id === nameOrId);
+    if (match)
+        return match;
+    // Then try exact name match
+    match = workspaces.find((w) => w.name === nameOrId);
+    if (match)
+        return match;
+    // Try numbered quick-switch (1-9)
+    const num = parseInt(nameOrId);
+    if (!isNaN(num) && num >= 1 && num <= workspaces.length) {
+        return workspaces[num - 1];
+    }
+    // Finally try fuzzy name matching
+    const fuzzyMatches = workspaces.filter((w) => w.name.toLowerCase().includes(nameOrId.toLowerCase()));
+    if (fuzzyMatches.length === 1) {
+        return fuzzyMatches[0];
+    }
+    return null;
+}
+async function getWorkspacesWithCache(modWorkspace) {
+    const cacheDir = '.mod/.cache';
+    const cachePath = path.join(cacheDir, 'workspaces.json');
+    // Ensure cache directory exists
+    if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+    }
+    // Check if cache exists and is recent (under 5 minutes old)
+    if (fs.existsSync(cachePath)) {
+        const stats = fs.statSync(cachePath);
+        const ageMinutes = (Date.now() - stats.mtime.getTime()) / (1000 * 60);
+        if (ageMinutes < 5) {
+            try {
+                const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+                return cache.workspaces;
+            }
+            catch (error) {
+                // Cache is corrupted, fall through to refresh
+            }
+        }
+    }
+    try {
+        const workspaceHandles = await modWorkspace.listWorkspaces();
+        // Convert WorkspaceHandle[] to CachedWorkspace format
+        const workspaces = [];
+        for (const handle of workspaceHandles) {
+            // Get additional workspace data if available
+            let fileCount = 0;
+            let branchCount = 1;
+            try {
+                const files = await handle.file.list();
+                fileCount = files.length;
+                const branches = await handle.branch.list();
+                branchCount = branches.length || 1;
+            }
+            catch (error) {
+                // Ignore errors when fetching additional data
+            }
+            workspaces.push({
+                id: handle.id,
+                name: handle.name,
+                description: undefined, // Not available from handle
+                fileCount,
+                branchCount,
+                lastModified: new Date().toISOString(), // Would need to be tracked properly
+                permissions: [] // Would need to be populated from permission system
+            });
+        }
+        const cache = {
+            lastUpdate: new Date().toISOString(),
+            workspaces: workspaces,
+            nameIndex: workspaces.reduce((index, w) => {
+                index[w.name] = w.id;
+                return index;
+            }, {})
+        };
+        fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+        return workspaces;
+    }
+    catch (error) {
+        console.warn('Failed to fetch workspaces:', error);
+        return [];
+    }
+}
+async function invalidateWorkspaceCache() {
+    const cachePath = '.mod/.cache/workspaces.json';
+    if (fs.existsSync(cachePath)) {
+        fs.unlinkSync(cachePath);
+    }
+}
+// Utility functions for time formatting
+function formatRelativeTime(isoString) {
+    const date = new Date(isoString);
+    const now = new Date();
+    const diffHours = Math.floor((now.getTime() - date.getTime()) / (1000 * 60 * 60));
+    if (diffHours < 1)
+        return 'just now';
+    if (diffHours < 24)
+        return `${diffHours}h ago`;
+    if (diffHours < 24 * 7)
+        return `${Math.floor(diffHours / 24)}d ago`;
+    return `${Math.floor(diffHours / (24 * 7))}w ago`;
+}
+function formatAbsoluteTime(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleString();
+}

package/dist/components/conflict-resolution-ui.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+const options = [
+    {
+        key: 'local',
+        label: 'Keep Local',
+        description: 'Keep the local version and skip remote',
+        color: 'blue',
+    },
+    {
+        key: 'remote',
+        label: 'Keep Remote',
+        description: 'Overwrite local with remote version',
+        color: 'green',
+    },
+    {
+        key: 'both',
+        label: 'Keep Both',
+        description: 'Keep local and save remote with suffix',
+        color: 'yellow',
+    },
+    {
+        key: 'skip',
+        label: 'Skip',
+        description: 'Skip this file for now',
+        color: 'gray',
+    },
+];
+export default function ConflictResolutionUI({ conflict, onResolve, onCancel, }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    useInput((input, key) => {
+        if (key.downArrow) {
+            setSelectedIndex((prev) => (prev + 1) % options.length);
+        }
+        else if (key.upArrow) {
+            setSelectedIndex((prev) => (prev - 1 + options.length) % options.length);
+        }
+        else if (key.return) {
+            onResolve(options[selectedIndex].key);
+        }
+        else if (key.escape && onCancel) {
+            onCancel();
+        }
+    });
+    const formatFileSize = (bytes) => {
+        if (!bytes)
+            return 'Unknown size';
+        if (bytes < 1024)
+            return `${bytes} B`;
+        if (bytes < 1024 * 1024)
+            return `${(bytes / 1024).toFixed(1)} KB`;
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    };
+    const formatDate = (dateString) => {
+        if (!dateString)
+            return 'Unknown date';
+        try {
+            return new Date(dateString).toLocaleString();
+        }
+        catch {
+            return dateString;
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "red", children: "\uD83D\uDD25 File Conflict Detected" }) }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, paddingX: 2, children: [_jsxs(Text, { bold: true, color: "white", children: ["File: ", conflict.fileName] }), _jsxs(Text, { color: "gray", children: ["Path: ", conflict.localPath] })] }), _jsxs(Box, { flexDirection: "row", marginBottom: 1, paddingX: 2, children: [_jsxs(Box, { flexDirection: "column", width: "50%", children: [_jsx(Text, { bold: true, color: "blue", children: "\uD83D\uDCC1 Local Version" }), _jsxs(Text, { color: "gray", children: ["Size: ", formatFileSize(conflict.localSize)] }), _jsxs(Text, { color: "gray", children: ["Modified: ", formatDate(conflict.localModified)] })] }), _jsxs(Box, { flexDirection: "column", width: "50%", children: [_jsx(Text, { bold: true, color: "green", children: "\u2601\uFE0F Remote Version" }), _jsxs(Text, { color: "gray", children: ["Size: ", formatFileSize(conflict.remoteSize)] }), _jsxs(Text, { color: "gray", children: ["Modified: ", formatDate(conflict.remoteModified)] })] })] }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "white", children: "How would you like to resolve this conflict?" }) }), options.map((option, index) => (_jsxs(Box, { marginLeft: 2, children: [_jsxs(Text, { color: selectedIndex === index ? 'white' : 'gray', backgroundColor: selectedIndex === index ? option.color : undefined, bold: selectedIndex === index, children: [selectedIndex === index ? '▶ ' : '  ', option.label] }), _jsx(Box, { marginLeft: 1, children: _jsxs(Text, { color: "gray", children: ["- ", option.description] }) })] }, option.key)))] }), _jsx(Box, { marginTop: 1, paddingX: 2, children: _jsxs(Text, { color: "gray", dimColor: true, children: ["Use \u2191\u2193 arrow keys to navigate, Enter to select", onCancel ? ', Esc to cancel' : ''] }) })] }));
+}
+export function BatchConflictResolutionUI({ conflicts, onResolveAll, onResolveOne, onCancel, }) {
+    const [currentIndex, setCurrentIndex] = useState(0);
+    const [resolutions, setResolutions] = useState({});
+    const [showBatchOptions, setShowBatchOptions] = useState(false);
+    const [selectedBatchOption, setSelectedBatchOption] = useState(0);
+    const batchOptions = [
+        { key: 'local', label: 'Keep All Local', description: 'Keep all local versions' },
+        { key: 'remote', label: 'Keep All Remote', description: 'Overwrite all with remote versions' },
+        { key: 'both', label: 'Keep All Both', description: 'Keep all local and save remote with suffix' },
+    ];
+    useInput((input, key) => {
+        if (showBatchOptions) {
+            if (key.downArrow) {
+                setSelectedBatchOption((prev) => (prev + 1) % batchOptions.length);
+            }
+            else if (key.upArrow) {
+                setSelectedBatchOption((prev) => (prev - 1 + batchOptions.length) % batchOptions.length);
+            }
+            else if (key.return) {
+                const resolution = batchOptions[selectedBatchOption].key;
+                const allResolutions = {};
+                conflicts.forEach(conflict => {
+                    allResolutions[conflict.fileName] = resolution;
+                });
+                onResolveAll(allResolutions);
+            }
+            else if (key.escape) {
+                setShowBatchOptions(false);
+            }
+        }
+        else {
+            if (input === 'a') {
+                setShowBatchOptions(true);
+            }
+            else if (key.escape && onCancel) {
+                onCancel();
+            }
+        }
+    });
+    const handleResolveOne = (resolution) => {
+        const conflict = conflicts[currentIndex];
+        setResolutions(prev => ({ ...prev, [conflict.fileName]: resolution }));
+        onResolveOne(conflict.fileName, resolution);
+        if (currentIndex < conflicts.length - 1) {
+            setCurrentIndex(prev => prev + 1);
+        }
+    };
+    if (showBatchOptions) {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "yellow", children: "\uD83D\uDD25 Batch Conflict Resolution" }) }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Apply the same resolution to all ", conflicts.length, " conflicts:"] }) }), batchOptions.map((option, index) => (_jsxs(Box, { marginLeft: 2, marginBottom: 1, children: [_jsxs(Text, { color: selectedBatchOption === index ? 'white' : 'gray', backgroundColor: selectedBatchOption === index ? 'blue' : undefined, bold: selectedBatchOption === index, children: [selectedBatchOption === index ? '▶ ' : '  ', option.label] }), _jsx(Box, { marginLeft: 1, children: _jsxs(Text, { color: "gray", children: ["- ", option.description] }) })] }, option.key))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", dimColor: true, children: "Use \u2191\u2193 arrow keys to navigate, Enter to apply to all, Esc to go back" }) })] }));
+    }
+    const currentConflict = conflicts[currentIndex];
+    const resolvedCount = Object.keys(resolutions).length;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, paddingX: 1, children: _jsxs(Text, { color: "yellow", children: ["Conflict ", currentIndex + 1, " of ", conflicts.length, " (", resolvedCount, " resolved)"] }) }), _jsx(ConflictResolutionUI, { conflict: currentConflict, onResolve: handleResolveOne }), _jsx(Box, { marginTop: 1, paddingX: 2, children: _jsx(Text, { color: "gray", dimColor: true, children: "Press 'a' for batch resolution options, Esc to cancel" }) })] }));
+}

package/dist/components/messages.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+const MessageList = React.memo(({ messages, parseContentSegments, messageKeyProp }) => (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: messages.length === 0 ? (_jsx(Text, { color: "gray", children: "No messages yet. Type to start the thread." })) : (messages.map((m, i) => (_jsxs(Text, { children: [_jsxs(Text, { color: "yellow", children: [new Date(m.timestamp).toLocaleTimeString(), " "] }), _jsxs(Text, { color: m.userType === 'user' ? 'cyan' : 'magenta', children: [m.userType === 'user' ? (m.user?.name || 'You') : 'Assistant', ":"] }), ' ', parseContentSegments(m.text).map((seg, idx) => seg.isBold ? (_jsx(Text, { bold: true, color: "whiteBright", children: seg.text }, idx)) : (_jsx(Text, { children: seg.text }, idx)))] }, `${m.id || i}-${m._contentHash || m.text.length}`)))) })));
+export default MessageList;

package/dist/components/thread.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import MessageList from './messages.js';
+const ThreadView = React.memo(({ activeThread, messages, parseContentSegments, messageKeyProp }) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Thread: ", _jsx(Text, { color: "green", children: activeThread.name })] }), _jsx(MessageList, { messages: messages, parseContentSegments: parseContentSegments, messageKeyProp: messageKeyProp }), _jsxs(Text, { color: "cyan", children: ["Type ", _jsx(Text, { bold: true, children: "/branch" }), " to switch threads."] })] }));
+});
+export default ThreadView;

package/dist/config/features.js

@@ -0,0 +1,72 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+export const FEATURES = {
+    STATUS: 'status',
+    WORKSPACE_MANAGEMENT: 'workspace-management',
+    WORKSPACE_BRANCHING: 'workspace-branching',
+    TASK_MANAGEMENT: 'task-management',
+    FILE_OPERATIONS: 'file-operations',
+    AGENT_INTEGRATIONS: 'agent-integrations',
+    SYNC_OPERATIONS: 'sync-operations',
+    WATCH_OPERATIONS: 'watch-operations',
+    CONNECTOR_INTEGRATIONS: 'connector-integrations',
+    AUTH: 'auth'
+};
+let releaseProfile = null;
+export function isFeatureEnabled(feature) {
+    if (process.env.NODE_ENV === 'development') {
+        const envVar = `MOD_FEATURE_${feature.toUpperCase().replace('-', '_')}`;
+        if (process.env[envVar] === 'true')
+            return true;
+        if (process.env[envVar] === 'false')
+            return false;
+    }
+    if (!releaseProfile) {
+        releaseProfile = loadReleaseProfile();
+    }
+    return releaseProfile[feature] ?? false;
+}
+function loadReleaseProfile() {
+    const profileName = process.env.MOD_RELEASE_PROFILE || 'development';
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const profilePath = path.join(__dirname, 'release-profiles', `${profileName}.json`);
+        if (fs.existsSync(profilePath)) {
+            const profileData = fs.readFileSync(profilePath, 'utf8');
+            return JSON.parse(profileData);
+        }
+        throw new Error(`Profile ${profileName} not found`);
+    }
+    catch (error) {
+        if (profileName === 'development') {
+            return {
+                [FEATURES.STATUS]: true,
+                [FEATURES.WORKSPACE_MANAGEMENT]: true,
+                [FEATURES.WORKSPACE_BRANCHING]: true,
+                [FEATURES.TASK_MANAGEMENT]: true,
+                [FEATURES.FILE_OPERATIONS]: true,
+                [FEATURES.AGENT_INTEGRATIONS]: true,
+                [FEATURES.SYNC_OPERATIONS]: true,
+                [FEATURES.WATCH_OPERATIONS]: true,
+                [FEATURES.CONNECTOR_INTEGRATIONS]: true
+            };
+        }
+        // Fallback to minimal profile for unknown profiles
+        return {
+            [FEATURES.STATUS]: true,
+            [FEATURES.WORKSPACE_MANAGEMENT]: false,
+            [FEATURES.WORKSPACE_BRANCHING]: false,
+            [FEATURES.TASK_MANAGEMENT]: false,
+            [FEATURES.FILE_OPERATIONS]: false,
+            [FEATURES.AGENT_INTEGRATIONS]: false,
+            [FEATURES.SYNC_OPERATIONS]: false,
+            [FEATURES.WATCH_OPERATIONS]: false,
+            [FEATURES.CONNECTOR_INTEGRATIONS]: false
+        };
+    }
+}
+export function resetFeatureCache() {
+    releaseProfile = null;
+}

package/dist/config/release-profiles/development.json

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

package/dist/config/release-profiles/mvp.json

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

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

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