@mod-computer/cli 0.1.1 → 0.2.1

package/dist/commands/workspace.js

@@ -1,7 +1,8 @@
-import { createModWorkspace } from '@mod/mod-core';
-import { readModConfig, writeModConfig } from '../services/mod-config.js';
-import fs from 'fs';
-import path from 'path';
+// glassware[type="implementation", id="cli-workspace-command--7ef7e657", requirements="requirement-cli-init-ux-2--b69b045f,requirement-cli-init-ux-3--3dde4846,requirement-cli-init-app-1--1c2b11b4"]
+// spec: packages/mod-cli/specs/workspaces.md
+import { createModWorkspace, createModUser } from '@mod/mod-core';
+import { listWorkspaceConnections, readWorkspaceConnection, writeWorkspaceConnection, deleteWorkspaceConnection, readConfig, } from '../lib/storage.js';
+import { input, select, validateWorkspaceName } from '../lib/prompts.js';
 export async function workspaceCommand(args, repo) {
     const [subcommand, ...rest] = args;
     switch (subcommand) {
@@ -9,415 +10,438 @@ export async function workspaceCommand(args, repo) {
             await handleCreateWorkspace(rest, repo);
             break;
         case 'list':
-            await handleListWorkspaces(rest, repo);
+            await handleListWorkspaces();
             break;
-        case 'switch':
-            await handleSwitchWorkspace(rest, repo);
+        case 'list-remote':
+            await handleListRemoteWorkspaces(repo);
+            break;
+        case 'connect':
+            await handleConnectWorkspace(rest, repo);
             break;
         case 'info':
-            await handleWorkspaceInfo(rest, repo);
+            await handleWorkspaceInfo();
+            break;
+        case 'disconnect':
+            await handleDisconnectWorkspace();
             break;
-        case 'delete':
-            await handleDeleteWorkspace(rest, repo);
+        case 'register':
+            await handleRegisterWorkspaces(repo);
             break;
-        case 'rename':
-            await handleRenameWorkspace(rest, repo);
+        case 'clear':
+            await handleClearWorkspace(rest, repo);
             break;
         default:
             if (!subcommand) {
-                await handleListWorkspaces([], repo);
+                await handleListWorkspaces();
             }
             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');
+                console.error('Usage: mod workspace <create|list|list-remote|connect|info|disconnect|register|clear>');
+                console.error('');
+                console.error('Commands:');
+                console.error('  create [name]              Create new workspace in current directory');
+                console.error('  list                       List all locally connected workspaces');
+                console.error('  list-remote                List all workspaces from your user account');
+                console.error('  connect <id> [--name ...]  Connect current directory to existing workspace');
+                console.error('  info                       Show current directory workspace info');
+                console.error('  disconnect                 Disconnect current directory from workspace');
+                console.error('  register                   Register connected workspaces to your account');
+                console.error('  clear [id]                 Delete all files from a workspace (DESTRUCTIVE)');
                 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>]');
+    const currentDir = process.cwd();
+    // Check if already connected
+    const existing = readWorkspaceConnection(currentDir);
+    if (existing) {
+        console.log(`Already connected to workspace: ${existing.workspaceName}`);
+        console.log('');
+        console.log('To create a new workspace, first disconnect:');
+        console.log('  mod workspace disconnect');
         process.exit(1);
     }
-    let description;
-    const descIndex = flags.indexOf('--description');
-    if (descIndex !== -1 && descIndex + 1 < flags.length) {
-        description = flags[descIndex + 1];
+    // Get workspace name
+    let name = args[0];
+    if (!name) {
+        const dirName = currentDir.split('/').pop() || 'workspace';
+        const defaultName = dirName.charAt(0).toUpperCase() + dirName.slice(1);
+        name = await input('Workspace name', {
+            default: defaultName,
+            validate: validateWorkspaceName,
+        });
+    }
+    else {
+        const validationError = validateWorkspaceName(name);
+        if (validationError) {
+            console.error(`Invalid workspace name: ${validationError}`);
+            process.exit(1);
+        }
     }
+    console.log('Creating workspace...');
     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
+        // No branching by default (enableBranching: true to opt-in)
+        const workspace = await modWorkspace.createWorkspace({ name });
+        // Wait for workspace document to sync to server
+        console.log('Syncing to server...');
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        const connection = {
+            path: currentDir,
+            workspaceId: workspace.id,
+            workspaceName: workspace.name,
+            connectedAt: new Date().toISOString(),
+            lastSyncedAt: new Date().toISOString(),
         };
-        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}`);
-        }
+        writeWorkspaceConnection(currentDir, connection);
+        console.log('');
+        console.log(`Created workspace: ${workspace.name}`);
+        console.log(`ID: ${workspace.id}`);
+        console.log(`Path: ${currentDir}`);
+        console.log('');
+        console.log('Run `mod sync start` to begin tracking changes');
     }
     catch (error) {
-        console.error('Failed to create workspace:', error);
-        console.log('Try running: mod workspace list to check available workspaces');
+        console.error('Failed to create workspace:', error.message);
         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>');
-        }
+async function handleListWorkspaces() {
+    const connections = listWorkspaceConnections();
+    if (connections.length === 0) {
+        console.log('No workspaces connected.');
+        console.log('');
+        console.log('To connect a directory to a workspace:');
+        console.log('  cd /path/to/project');
+        console.log('  mod init');
+        return;
     }
-    catch (error) {
-        console.error('Failed to list workspaces:', error);
+    const currentDir = process.cwd();
+    const currentConnection = readWorkspaceConnection(currentDir);
+    console.log('Connected workspaces:');
+    console.log('');
+    for (const conn of connections) {
+        const isCurrent = currentConnection?.workspaceId === conn.workspaceId &&
+            currentConnection?.path === conn.path;
+        const marker = isCurrent ? '* ' : '  ';
+        console.log(`${marker}${conn.workspaceName}`);
+        console.log(`    Path: ${conn.path}`);
+        console.log(`    ID: ${conn.workspaceId}`);
+        console.log(`    Connected: ${formatDate(conn.connectedAt)}`);
+        console.log('');
+    }
+    if (currentConnection) {
+        console.log(`Current directory is connected to: ${currentConnection.workspaceName}`);
+    }
+    else {
+        console.log('Current directory is not connected to any workspace.');
+        console.log('Run `mod init` to connect.');
+    }
+}
+async function handleWorkspaceInfo() {
+    const currentDir = process.cwd();
+    const connection = readWorkspaceConnection(currentDir);
+    if (!connection) {
+        console.log('Current directory is not connected to a workspace.');
+        console.log('');
+        console.log('To connect:');
+        console.log('  mod init');
         process.exit(1);
     }
+    console.log(`Workspace: ${connection.workspaceName}`);
+    console.log(`ID: ${connection.workspaceId}`);
+    console.log(`Path: ${connection.path}`);
+    console.log(`Connected: ${formatDate(connection.connectedAt)}`);
+    console.log(`Last synced: ${formatDate(connection.lastSyncedAt)}`);
 }
-async function handleSwitchWorkspace(args, repo) {
-    const [nameOrId] = args;
-    if (!nameOrId) {
-        console.error('Usage: mod workspace switch <name-or-id>');
+async function handleDisconnectWorkspace() {
+    const currentDir = process.cwd();
+    const connection = readWorkspaceConnection(currentDir);
+    if (!connection) {
+        console.log('Current directory is not connected to a workspace.');
         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})`);
+    const choice = await select('Disconnect from workspace?', [
+        { label: 'Yes, disconnect', value: 'yes' },
+        { label: 'Cancel', value: 'no' },
+    ]);
+    if (choice === 'no') {
+        console.log('Cancelled.');
+        return;
     }
-    catch (error) {
-        console.error('Failed to switch workspace:', error);
+    const deleted = deleteWorkspaceConnection(currentDir);
+    if (deleted) {
+        console.log(`Disconnected from workspace: ${connection.workspaceName}`);
+        console.log('');
+        console.log('The workspace data is preserved. To reconnect:');
+        console.log('  mod init');
+    }
+    else {
+        console.error('Failed to disconnect.');
         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}`);
+async function handleRegisterWorkspaces(repo) {
+    const config = readConfig();
+    if (!config.auth) {
+        console.log('Not signed in.');
+        console.log('');
+        console.log('Sign in first with: mod auth login');
+        process.exit(1);
+    }
+    if (!config.auth.userDocId) {
+        console.log('User document ID not found.');
+        console.log('');
+        console.log('Try logging in again: mod auth login');
+        process.exit(1);
+    }
+    const connections = listWorkspaceConnections();
+    if (connections.length === 0) {
+        console.log('No connected workspaces found.');
+        console.log('');
+        console.log('Connect a directory to a workspace with: mod init');
+        return;
+    }
+    console.log(`Registering ${connections.length} workspace(s) to your user account...`);
+    console.log('');
+    const modUser = createModUser(repo);
+    const userDocId = config.auth.userDocId;
+    console.log('Using user document:', userDocId);
+    let registered = 0;
+    for (const conn of connections) {
+        try {
+            await modUser.addWorkspace(userDocId, conn.workspaceId);
+            console.log(`✓ Registered: ${conn.workspaceName}`);
+            registered++;
         }
-        else {
-            console.log('Active Branch: main');
+        catch (error) {
+            console.warn(`  Failed to register ${conn.workspaceName}: ${error.message}`);
         }
     }
-    catch (error) {
-        console.error('Failed to get workspace info:', error);
+    console.log('');
+    console.log(`✓ Registered ${registered} of ${connections.length} workspaces`);
+    console.log('');
+    // Wait for changes to sync to server
+    console.log('Syncing changes to server...');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    console.log('');
+    console.log('These workspaces should now appear in the web app.');
+}
+async function handleListRemoteWorkspaces(repo) {
+    const config = readConfig();
+    if (!config.auth) {
+        console.log('Not signed in.');
+        console.log('');
+        console.log('Sign in first with: mod auth login');
         process.exit(1);
     }
-}
-async function handleDeleteWorkspace(args, repo) {
-    const [nameOrId] = args;
-    if (!nameOrId) {
-        console.error('Usage: mod workspace delete <name-or-id>');
+    if (!config.auth.userDocId) {
+        console.log('User document ID not found.');
+        console.log('');
+        console.log('Try logging in again: mod auth login');
         process.exit(1);
     }
+    console.log('Fetching workspaces from your user account...');
+    console.log('');
     try {
-        const modWorkspace = createModWorkspace(repo);
-        const targetWorkspace = await resolveWorkspace(nameOrId, modWorkspace);
-        if (!targetWorkspace) {
-            console.error(`Workspace not found: ${nameOrId}`);
+        const modUser = createModUser(repo);
+        const userDocId = config.auth.userDocId;
+        // Get the user doc
+        const userHandle = await repo.find(userDocId);
+        await userHandle.whenReady();
+        const userDoc = userHandle.doc();
+        if (!userDoc) {
+            console.log('Could not load user document.');
             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;
+        // Access workspaces from user doc
+        const workspaceRefs = userDoc.workspaceIds || [];
+        if (workspaceRefs.length === 0) {
+            console.log('No workspaces found in your account.');
+            console.log('');
+            console.log('To register your local workspaces:');
+            console.log('  mod workspace register');
+            process.exit(0);
         }
-        // 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);
+        console.log(`Found ${workspaceRefs.length} workspace(s):\n`);
+        for (const wsId of workspaceRefs) {
+            console.log(`  ${wsId}`);
+            // Try to load workspace name
+            try {
+                const wsHandle = await repo.find(wsId);
+                await wsHandle.whenReady();
+                const ws = wsHandle.doc();
+                if (ws && ws.name) {
+                    console.log(`    Name: ${ws.name}`);
+                }
+            }
+            catch (e) {
+                // Workspace might not be available
+            }
+            console.log('');
         }
-        await invalidateWorkspaceCache();
-        console.log(`✓ Workspace "${targetWorkspace.name}" scheduled for deletion`);
-        console.log('Note: Full deletion implementation pending ModWorkspace.deleteWorkspace() interface');
+        console.log('To connect to a workspace:');
+        console.log('  mod workspace connect <workspace-id> <workspace-name>');
     }
     catch (error) {
-        console.error('Failed to delete workspace:', error);
+        console.error('Failed to fetch workspaces:', error.message);
         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>');
+async function handleConnectWorkspace(args, repo) {
+    const currentDir = process.cwd();
+    // Check if already connected
+    const existing = readWorkspaceConnection(currentDir);
+    if (existing) {
+        console.log(`Already connected to workspace: ${existing.workspaceName}`);
+        console.log('');
+        console.log('To connect to a different workspace, first disconnect:');
+        console.log('  mod workspace disconnect');
         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);
+    // Parse args: first positional is workspace ID, --name is optional override
+    let workspaceId;
+    let nameOverride;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--name' && args[i + 1]) {
+            nameOverride = args[i + 1];
+            i++; // Skip the next arg
         }
-        // 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);
+        else if (!workspaceId && !args[i].startsWith('--')) {
+            workspaceId = args[i];
         }
-        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);
+    if (!workspaceId) {
+        console.error('Usage: mod workspace connect <workspace-id> [--name <display-name>]');
+        console.error('');
+        console.error('To see available workspaces:');
+        console.error('  mod workspace list-remote');
         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) {
+    console.log(`Connecting to workspace...`);
+    console.log(`ID: ${workspaceId}`);
+    console.log('');
+    try {
+        // Fetch workspace to verify it exists and get name
+        const modWorkspace = createModWorkspace(repo);
+        const workspaceHandle = await modWorkspace.openWorkspace(workspaceId);
+        // Use override name if provided, otherwise fetch from workspace
+        const workspaceName = nameOverride || workspaceHandle.name || 'Untitled Workspace';
+        console.log(`Workspace: ${workspaceName}`);
+        // Create connection
+        const connection = {
+            path: currentDir,
+            workspaceId: workspaceId,
+            workspaceName: workspaceName,
+            connectedAt: new Date().toISOString(),
+            lastSyncedAt: new Date().toISOString(),
+        };
+        writeWorkspaceConnection(currentDir, connection);
+        // Register workspace to user document so it shows in web app
+        const config = readConfig();
+        if (config.auth?.userDocId) {
             try {
-                const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
-                return cache.workspaces;
+                console.log('Registering workspace to your account...');
+                const modUser = createModUser(repo);
+                await modUser.addWorkspace(config.auth.userDocId, workspaceId);
+                // Wait for sync
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                console.log('✓ Workspace registered to your account');
             }
             catch (error) {
-                // Cache is corrupted, fall through to refresh
+                console.warn('Note: Could not register workspace to account:', error.message);
             }
         }
+        console.log('✓ Connected successfully');
+        console.log('');
+        console.log('To import files from this directory:');
+        console.log('  mod init');
+        console.log('  > Select "Resume file import"');
+    }
+    catch (error) {
+        console.error('Failed to connect to workspace:', error.message);
+        process.exit(1);
+    }
+}
+async function handleClearWorkspace(args, repo) {
+    const [workspaceId] = args;
+    if (!workspaceId) {
+        const currentDir = process.cwd();
+        const connection = readWorkspaceConnection(currentDir);
+        if (!connection) {
+            console.error('No workspace specified and current directory is not connected.');
+            console.error('');
+            console.error('Usage: mod workspace clear <workspace-id>');
+            console.error('   or: mod workspace clear (when in a connected directory)');
+            process.exit(1);
+        }
+        console.log(`Current workspace: ${connection.workspaceName}`);
+        console.log(`ID: ${connection.workspaceId}`);
     }
+    else {
+        console.log(`Workspace ID: ${workspaceId}`);
+    }
+    console.log('');
+    console.warn('⚠️  WARNING: This will delete ALL files from the workspace.');
+    console.warn('⚠️  This action CANNOT be undone.');
+    console.log('');
+    const confirmation = await select('Are you absolutely sure?', [
+        { label: 'No, cancel', value: 'no' },
+        { label: 'Yes, delete all files', value: 'yes' },
+    ]);
+    if (confirmation === 'no') {
+        console.log('Cancelled.');
+        return;
+    }
+    const targetWorkspaceId = workspaceId || readWorkspaceConnection(process.cwd()).workspaceId;
     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;
+        console.log('Loading workspace...');
+        const modWorkspace = createModWorkspace(repo);
+        const workspaceHandle = await modWorkspace.openWorkspace(targetWorkspaceId);
+        console.log('Fetching files...');
+        const files = await workspaceHandle.file.list();
+        console.log(`Found ${files.length} files to delete`);
+        if (files.length === 0) {
+            console.log('Workspace is already empty.');
+            return;
+        }
+        console.log('Deleting files...');
+        let deleted = 0;
+        for (const file of files) {
             try {
-                const files = await handle.file.list();
-                fileCount = files.length;
-                const branches = await handle.branch.list();
-                branchCount = branches.length || 1;
+                await workspaceHandle.file.delete(file.id);
+                deleted++;
+                if (deleted % 50 === 0) {
+                    console.log(`  Deleted ${deleted}/${files.length} files...`);
+                }
             }
             catch (error) {
-                // Ignore errors when fetching additional data
+                console.warn(`  Failed to delete ${file.name}:`, error instanceof Error ? error.message : error);
             }
-            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;
+        console.log('');
+        console.log(`✓ Deleted ${deleted} files`);
+        console.log('');
+        console.log('The workspace is now empty. You can import files again with:');
+        console.log('  mod init');
+        console.log('  > Select "Resume file import"');
     }
     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);
+        console.error('Failed to clear workspace:', error.message);
+        process.exit(1);
     }
 }
-// Utility functions for time formatting
-function formatRelativeTime(isoString) {
+function formatDate(isoString) {
     const date = new Date(isoString);
     const now = new Date();
-    const diffHours = Math.floor((now.getTime() - date.getTime()) / (1000 * 60 * 60));
+    const diffMs = now.getTime() - date.getTime();
+    const diffHours = Math.floor(diffMs / (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();
+    return date.toLocaleDateString();
 }