@mod-computer/cli 0.1.0

package/dist/commands/index.js

@@ -0,0 +1,43 @@
+import { agentsRunCommand } from './agents-run.js';
+import { authCommand } from './auth.js';
+import { branchCommand } from './branch.js';
+import { specCommand } from './spec.js';
+import { workspaceCommand } from './workspace.js';
+import { claudeSyncCommand } from './claude-sync.js';
+import { syncCommand } from './sync.js';
+import { initCommand } from './init.js';
+import { recoverCommand } from './recover.js';
+import { FEATURES, isFeatureEnabled } from '../config/features.js';
+const allCommands = {
+    'auth': authCommand,
+    'spec': specCommand,
+    'sync': syncCommand,
+    'agents-run': agentsRunCommand,
+    'claude-sync': claudeSyncCommand,
+    'branch': branchCommand,
+    'workspace': workspaceCommand,
+    'init': initCommand,
+    'recover': recoverCommand,
+};
+const commandFeatureMapping = {
+    'auth': FEATURES.AUTH,
+    'spec': FEATURES.TASK_MANAGEMENT, // Spec tracking, not in MVP
+    'sync': FEATURES.WATCH_OPERATIONS,
+    'agents-run': FEATURES.AGENT_INTEGRATIONS,
+    'claude-sync': FEATURES.AGENT_INTEGRATIONS, // Claude projects sync, separate from file sync daemon
+    'branch': FEATURES.WORKSPACE_BRANCHING,
+    'workspace': FEATURES.WORKSPACE_MANAGEMENT,
+    'init': FEATURES.SYNC_OPERATIONS, // Use existing feature flag for command installation
+    'recover': FEATURES.STATUS, // Recovery command always available when status is enabled
+};
+const registry = {};
+for (const [commandName, commandHandler] of Object.entries(allCommands)) {
+    const requiredFeature = commandFeatureMapping[commandName];
+    if (requiredFeature && isFeatureEnabled(requiredFeature)) {
+        registry[commandName] = commandHandler;
+    }
+}
+export function buildCommandRegistry() {
+    return registry;
+}
+export default registry;

package/dist/commands/init.js

@@ -0,0 +1,378 @@
+#!/usr/bin/env node
+/**
+ * Init command for installing Claude commands and workspace initialization
+ * Installs versioned command files from CLI package to user's .claude/commands directory
+ * Creates a new workspace if none exists in the current directory
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createModWorkspace } from '@mod/mod-core';
+import { readModConfig, writeModConfig } from '../services/mod-config.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function initCommand(args, repo) {
+    const subcommand = args[0];
+    if (subcommand === 'list' || args.includes('--list')) {
+        await listAvailableCommands();
+        process.exit(0);
+    }
+    try {
+        const workspaceStatus = await checkWorkspaceStatus(repo);
+        await ensureClaudeCommandsDirectory();
+        const availableCommands = await discoverAvailableCommands();
+        const installedCommands = await getInstalledCommands();
+        const commandsToInstall = await determineCommandsToInstall(availableCommands, installedCommands, args.includes('--force'));
+        if (commandsToInstall.length > 0) {
+            displayInstallationPlan(commandsToInstall);
+            const shouldProceed = args.includes('--force') || await confirmInstallation(commandsToInstall);
+            if (!shouldProceed) {
+                console.log('Installation cancelled');
+                process.exit(0);
+            }
+            await installCommands(commandsToInstall);
+        }
+        const finalWorkspaceStatus = await handleWorkspaceInitialization(workspaceStatus, repo);
+        displayInitializationSuccess(commandsToInstall, finalWorkspaceStatus);
+        process.exit(0);
+    }
+    catch (error) {
+        handleInstallationError(error);
+    }
+}
+async function ensureClaudeCommandsDirectory() {
+    const claudeDir = path.join(process.cwd(), '.claude');
+    const commandsDir = path.join(claudeDir, 'commands');
+    try {
+        if (!fs.existsSync(claudeDir)) {
+            fs.mkdirSync(claudeDir, { recursive: true, mode: 0o755 });
+        }
+        if (!fs.existsSync(commandsDir)) {
+            fs.mkdirSync(commandsDir, { recursive: true, mode: 0o755 });
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to create .claude/commands directory: ${error.message}`);
+    }
+}
+async function discoverAvailableCommands() {
+    // Navigate from dist/commands/init.js to package root commands/
+    // __dirname is dist/commands, so go up two levels to package root
+    const packageRoot = path.resolve(__dirname, '../..');
+    const commandsSourceDir = path.join(packageRoot, 'commands');
+    if (!fs.existsSync(commandsSourceDir)) {
+        console.warn('⚠️  No commands directory found in CLI package');
+        return [];
+    }
+    const commands = [];
+    const files = fs.readdirSync(commandsSourceDir).filter(f => f.endsWith('.md'));
+    for (const filename of files) {
+        const filePath = path.join(commandsSourceDir, filename);
+        const content = fs.readFileSync(filePath, 'utf8');
+        const metadata = parseFrontmatter(content);
+        commands.push({
+            filename,
+            path: filePath,
+            metadata,
+            content
+        });
+    }
+    return commands;
+}
+async function getInstalledCommands() {
+    const commandsDir = path.join(process.cwd(), '.claude', 'commands');
+    const installed = new Map();
+    if (!fs.existsSync(commandsDir)) {
+        return installed;
+    }
+    const files = fs.readdirSync(commandsDir).filter(f => f.endsWith('.md'));
+    for (const filename of files) {
+        const filePath = path.join(commandsDir, filename);
+        try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const metadata = parseFrontmatter(content);
+            installed.set(filename, metadata);
+        }
+        catch (error) {
+            console.warn(`⚠️  Could not read metadata from ${filename}: ${error.message}`);
+        }
+    }
+    return installed;
+}
+function parseFrontmatter(content) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+        // Return default metadata for files without frontmatter - they need to be updated
+        return {
+            version: '0.0.0', // Old version to trigger update
+            updated: '1970-01-01',
+            checksum: '',
+            description: undefined
+        };
+    }
+    const frontmatterText = frontmatterMatch[1];
+    const metadata = {};
+    // Simple YAML parsing for required fields
+    const lines = frontmatterText.split('\n');
+    for (const line of lines) {
+        const match = line.match(/^(\w+):\s*(.+)$/);
+        if (match) {
+            const [, key, value] = match;
+            metadata[key] = value.trim().replace(/^["']|["']$/g, '');
+        }
+    }
+    return {
+        version: metadata.version || '1.0.0',
+        updated: metadata.updated || new Date().toISOString(),
+        checksum: metadata.checksum || '',
+        description: metadata.description
+    };
+}
+async function determineCommandsToInstall(available, installed, force) {
+    const toInstall = [];
+    for (const command of available) {
+        const installedMetadata = installed.get(command.filename);
+        if (force || !installedMetadata) {
+            toInstall.push(command);
+            continue;
+        }
+        // Compare versions
+        if (compareVersions(command.metadata.version, installedMetadata.version) > 0) {
+            toInstall.push(command);
+        }
+    }
+    return toInstall;
+}
+function compareVersions(v1, v2) {
+    const parts1 = v1.split('.').map(n => parseInt(n, 10));
+    const parts2 = v2.split('.').map(n => parseInt(n, 10));
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+        const part1 = parts1[i] || 0;
+        const part2 = parts2[i] || 0;
+        if (part1 > part2)
+            return 1;
+        if (part1 < part2)
+            return -1;
+    }
+    return 0;
+}
+async function listAvailableCommands() {
+    console.log('📋 Available Claude Commands:\n');
+    try {
+        const commands = await discoverAvailableCommands();
+        if (commands.length === 0) {
+            console.log('   No commands available');
+            return;
+        }
+        for (const command of commands) {
+            console.log(`   ${command.filename.replace('.md', '')}`);
+            console.log(`   ├── Version: ${command.metadata.version}`);
+            if (command.metadata.description) {
+                console.log(`   └── Description: ${command.metadata.description}`);
+            }
+            else {
+                console.log(`   └── Updated: ${command.metadata.updated}`);
+            }
+            console.log();
+        }
+    }
+    catch (error) {
+        console.error('❌ Error listing commands:', error.message);
+    }
+}
+function displayInstallationPlan(commands) {
+    console.log('📦 Installing Claude Commands:\n');
+    for (const command of commands) {
+        console.log(`   ${command.filename.replace('.md', '')} (v${command.metadata.version})`);
+    }
+    console.log();
+}
+async function confirmInstallation(commands) {
+    // In a real implementation, this would use an interactive prompt library
+    // For now, we'll assume confirmation
+    return true;
+}
+async function installCommands(commands) {
+    const commandsDir = path.join(process.cwd(), '.claude', 'commands');
+    const tempFiles = [];
+    try {
+        // Install to temporary files first for atomic operation
+        for (const command of commands) {
+            const tempPath = path.join(commandsDir, `${command.filename}.tmp`);
+            const finalPath = path.join(commandsDir, command.filename);
+            const contentWithChecksum = await updateChecksumInContent(command.content);
+            fs.writeFileSync(tempPath, contentWithChecksum, 'utf8');
+            tempFiles.push(tempPath);
+        }
+        // Move all temp files to final locations atomically
+        for (let i = 0; i < commands.length; i++) {
+            const tempPath = tempFiles[i];
+            const finalPath = path.join(commandsDir, commands[i].filename);
+            fs.renameSync(tempPath, finalPath);
+        }
+    }
+    catch (error) {
+        cleanup(tempFiles);
+        throw error;
+    }
+}
+async function updateChecksumInContent(content) {
+    // Use dynamic import for crypto in ESM
+    const crypto = await import('crypto');
+    const contentHash = crypto
+        .createHash('sha256')
+        .update(content)
+        .digest('hex')
+        .substring(0, 16);
+    // Update checksum in frontmatter
+    // First, remove any existing checksum lines
+    const withoutChecksum = content.replace(/^(\s*)checksum:\s*\S*$/gm, '');
+    // Then add the new checksum after the frontmatter opening
+    return withoutChecksum.replace(/^(---\n)([\s\S]*?)(---)/, `$1$2checksum: ${contentHash}\n$3`);
+}
+function cleanup(tempFiles) {
+    for (const file of tempFiles) {
+        try {
+            if (fs.existsSync(file)) {
+                fs.unlinkSync(file);
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️  Could not clean up temporary file ${file}: ${error.message}`);
+        }
+    }
+}
+function displayInitializationSuccess(commands, workspaceStatus) {
+    console.log('✅ Initialization Complete!\n');
+    if (commands.length > 0) {
+        console.log(`📦 Installed ${commands.length} Claude command(s):\n`);
+        for (const command of commands) {
+            const commandName = command.filename.replace('.md', '');
+            console.log(`   /${commandName} - ${command.metadata.description || 'Mod workflow command'}`);
+        }
+        console.log();
+    }
+    else {
+        console.log('✅ All Claude commands are up to date\n');
+    }
+    if (workspaceStatus.created) {
+        console.log(`🚀 Created new workspace: "${workspaceStatus.workspaceName}"`);
+    }
+    else {
+        console.log(`📁 Using existing workspace: "${workspaceStatus.workspaceName}"`);
+    }
+    console.log('\n💡 Usage:');
+    console.log('   Open Claude Code and type "/" to see available commands');
+    console.log('   Use "mod workspace list" to see all workspaces');
+    console.log('   Commands are available in your .claude/commands directory\n');
+}
+async function checkWorkspaceStatus(repo) {
+    try {
+        const config = await readModConfig();
+        if (config && config.workspaceId) {
+            let workspaceName = 'Existing Workspace';
+            // Try to get the actual workspace name from the workspace service
+            if (repo) {
+                try {
+                    const modWorkspace = createModWorkspace(repo);
+                    const workspaces = await modWorkspace.listWorkspaces();
+                    const currentWorkspace = workspaces.find(w => w.id === config.workspaceId);
+                    if (currentWorkspace) {
+                        workspaceName = currentWorkspace.name;
+                    }
+                }
+                catch (error) {
+                    // Fallback to generic name if we can't fetch workspace details
+                    console.warn('⚠️  Could not fetch workspace name, using generic name');
+                }
+            }
+            return {
+                exists: true,
+                created: false,
+                workspaceName,
+                workspaceId: config.workspaceId
+            };
+        }
+        // No existing workspace found
+        return {
+            exists: false,
+            created: false,
+            workspaceName: 'New Workspace',
+            workspaceId: undefined
+        };
+    }
+    catch (error) {
+        // No config file exists, so no workspace
+        return {
+            exists: false,
+            created: false,
+            workspaceName: 'New Workspace',
+            workspaceId: undefined
+        };
+    }
+}
+async function handleWorkspaceInitialization(workspaceStatus, repo) {
+    if (workspaceStatus.exists) {
+        return workspaceStatus;
+    }
+    try {
+        const modWorkspace = createModWorkspace(repo);
+        const workspaceName = generateWorkspaceName();
+        console.log(`🚀 Creating new workspace: "${workspaceName}"...`);
+        const workspace = await modWorkspace.createWorkspace({
+            name: workspaceName
+        });
+        const config = {
+            workspaceId: workspace.id,
+            activeBranchId: undefined
+        };
+        await writeModConfig(config);
+        return {
+            exists: false,
+            created: true,
+            workspaceName: workspace.name,
+            workspaceId: workspace.id
+        };
+    }
+    catch (error) {
+        console.warn(`⚠️  Failed to create workspace: ${error.message}`);
+        console.log('   Continuing with command installation only.');
+        return {
+            exists: false,
+            created: false,
+            workspaceName: 'Failed to create',
+            workspaceId: undefined
+        };
+    }
+}
+function generateWorkspaceName() {
+    const currentDir = path.basename(process.cwd());
+    const timestamp = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+    // Use directory name if it's meaningful, otherwise use timestamp
+    if (currentDir && currentDir !== '.' && currentDir !== '/' && currentDir.length > 1) {
+        return currentDir.charAt(0).toUpperCase() + currentDir.slice(1);
+    }
+    return `Workspace-${timestamp}`;
+}
+function handleInstallationError(error) {
+    console.error('❌ Initialization failed:');
+    if (error.code === 'EACCES' || error.code === 'EPERM') {
+        console.error('   Permission denied. Try running with appropriate permissions.');
+        console.error('   Make sure you have write access to the .claude/commands directory.');
+    }
+    else if (error.code === 'ENOSPC') {
+        console.error('   Insufficient disk space.');
+    }
+    else if (error.code === 'ENOTDIR') {
+        console.error('   Invalid directory structure. Ensure .claude is a directory, not a file.');
+    }
+    else {
+        console.error(`   ${error.message}`);
+    }
+    console.error('\n🔧 Troubleshooting:');
+    console.error('   - Ensure you have write permissions in the current directory');
+    console.error('   - Try running "mod init --force" to overwrite existing files');
+    console.error('   - Check that .claude is not a file (should be a directory)');
+    console.error('   - For workspace issues, try "mod workspace create <name>" separately');
+    process.exit(1);
+}

package/dist/commands/recover.js

@@ -0,0 +1,207 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { readModConfig, writeModConfig } from '../services/mod-config.js';
+export async function recoverCommand(args, repo) {
+    const [action] = args;
+    if (!action || !['automerge', 'workspace', 'branches'].includes(action)) {
+        console.error('Usage: mod recover <automerge|workspace|branches>');
+        console.error('  automerge  - Attempt to recover corrupted Automerge storage');
+        console.error('  workspace  - Reset workspace configuration');
+        console.error('  branches   - Recreate corrupted branch documents');
+        process.exit(1);
+    }
+    switch (action) {
+        case 'automerge':
+            await handleAutomergeRecovery(repo);
+            break;
+        case 'workspace':
+            await handleWorkspaceRecovery();
+            break;
+        case 'branches':
+            await handleBranchRecovery(repo);
+            break;
+    }
+}
+async function handleAutomergeRecovery(repo) {
+    console.log('🔧 Attempting Automerge storage recovery...');
+    const storageDir = process.env.MOD_AUTOMERGE_STORAGE_DIR
+        ? path.resolve(process.env.MOD_AUTOMERGE_STORAGE_DIR)
+        : path.resolve('./.automerge-data');
+    if (!fs.existsSync(storageDir)) {
+        console.log('No Automerge storage directory found. Nothing to recover.');
+        return;
+    }
+    console.log(`Scanning storage directory: ${storageDir}`);
+    // Create backup of corrupted storage
+    const backupDir = `${storageDir}.backup.${Date.now()}`;
+    try {
+        console.log(`Creating backup at: ${backupDir}`);
+        fs.cpSync(storageDir, backupDir, { recursive: true });
+    }
+    catch (error) {
+        console.warn('Could not create backup:', error);
+    }
+    // Test document loading to identify corrupted documents
+    const corruptedDocs = [];
+    const validDocs = [];
+    const allDocIds = [];
+    const scanDirectory = (dir) => {
+        try {
+            const items = fs.readdirSync(dir);
+            for (const item of items) {
+                const itemPath = path.join(dir, item);
+                const stat = fs.statSync(itemPath);
+                if (stat.isDirectory()) {
+                    scanDirectory(itemPath);
+                }
+                else if (itemPath.includes('/incremental/')) {
+                    // This is an Automerge incremental storage file
+                    // Extract document ID from path like: 3K/9QuxnF8NM8g71nvphZYzgxsxxJ/incremental/...
+                    const pathParts = path.relative(storageDir, itemPath).split(path.sep);
+                    if (pathParts.length >= 3 && pathParts[2] === 'incremental') {
+                        const docId = `${pathParts[0]}${pathParts[1]}`;
+                        if (!allDocIds.includes(docId)) {
+                            allDocIds.push(docId);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`Error scanning directory ${dir}:`, error);
+        }
+    };
+    scanDirectory(storageDir);
+    console.log(`Found ${allDocIds.length} document files to test...`);
+    // Test each document by actually trying to load it
+    for (const docId of allDocIds) {
+        try {
+            const handle = await repo.find(docId);
+            const doc = await handle.doc();
+            if (doc) {
+                validDocs.push(docId);
+            }
+        }
+        catch (error) {
+            const errorMessage = String(error?.message || error || '');
+            if (errorMessage.includes('corrupt') || errorMessage.includes('deflate') || errorMessage.includes('unable to parse chunk')) {
+                corruptedDocs.push(docId);
+                console.log(`  💥 Corrupted: ${docId}`);
+            }
+            else {
+                // Other errors might not be corruption
+                console.warn(`  ⚠️  Error loading ${docId}: ${errorMessage.substring(0, 100)}`);
+            }
+        }
+    }
+    console.log(`Found ${validDocs.length} valid documents and ${corruptedDocs.length} potentially corrupted documents`);
+    if (corruptedDocs.length > 0) {
+        console.log('\nCorrupted documents detected:');
+        corruptedDocs.slice(0, 5).forEach(docId => {
+            console.log(`  ${docId}`);
+        });
+        if (corruptedDocs.length > 5) {
+            console.log(`  ... and ${corruptedDocs.length - 5} more`);
+        }
+        // Offer to remove corrupted documents
+        console.log('\n⚠️  This will remove corrupted documents and may cause data loss.');
+        console.log('💡 Backup created at:', backupDir);
+        // Auto-proceed with recovery
+        console.log('Proceeding with corruption cleanup...');
+        let removedCount = 0;
+        for (const docId of corruptedDocs) {
+            try {
+                // Find and remove the corrupted document files
+                // DocId format: 3K9QuxnF8NM8g71nvphZYzgxsxxJ -> 3K/9QuxnF8NM8g71nvphZYzgxsxxJ
+                const prefix = docId.substring(0, 2);
+                const suffix = docId.substring(2);
+                const docDir = path.join(storageDir, prefix, suffix);
+                if (fs.existsSync(docDir)) {
+                    // Remove the entire document directory
+                    fs.rmSync(docDir, { recursive: true, force: true });
+                    removedCount++;
+                    console.log(`  🗑️  Removed document directory: ${prefix}/${suffix}`);
+                }
+                // Check if parent directory is empty
+                const parentDir = path.join(storageDir, prefix);
+                try {
+                    const remainingFiles = fs.readdirSync(parentDir);
+                    if (remainingFiles.length === 0) {
+                        fs.rmdirSync(parentDir);
+                        console.log(`  🗑️  Removed empty prefix directory: ${prefix}`);
+                    }
+                }
+                catch { }
+            }
+            catch (error) {
+                console.warn(`Could not remove corrupted document ${docId}:`, error);
+            }
+        }
+        console.log(`✅ Removed ${removedCount} corrupted document files`);
+        console.log('🔄 Please restart the application and try your command again');
+    }
+    else {
+        console.log('✅ No corrupted documents detected in Automerge storage');
+    }
+}
+async function handleWorkspaceRecovery() {
+    console.log('🔧 Resetting workspace configuration...');
+    const configPath = '.mod/config.json';
+    if (fs.existsSync(configPath)) {
+        console.log(`Backing up current config to ${configPath}.backup`);
+        fs.copyFileSync(configPath, `${configPath}.backup`);
+    }
+    // Reset to minimal config
+    const minimalConfig = {};
+    writeModConfig(minimalConfig);
+    console.log('✅ Workspace configuration reset');
+    console.log('💡 Run "mod workspace list" to see available workspaces');
+    console.log('💡 Run "mod workspace switch <workspace-name>" to select a workspace');
+}
+async function handleBranchRecovery(repo) {
+    console.log('🔧 Attempting branch recovery...');
+    const cfg = readModConfig();
+    if (!cfg?.workspaceId) {
+        console.error('No workspace configured. Run "mod recover workspace" first.');
+        process.exit(1);
+    }
+    try {
+        // Try to access the workspace
+        const wsHandle = await repo.find(cfg.workspaceId);
+        const workspace = await wsHandle.doc();
+        if (!workspace) {
+            console.error('Workspace document is corrupted or missing');
+            console.log('💡 Run "mod recover automerge" to fix storage corruption');
+            process.exit(1);
+        }
+        const workspaceData = workspace;
+        console.log(`✅ Workspace "${workspaceData.title || 'Untitled'}" is accessible`);
+        // Try to access branches document
+        if (workspaceData.branchesDocId) {
+            try {
+                const branchesHandle = await repo.find(workspaceData.branchesDocId);
+                const branchesDoc = await branchesHandle.doc();
+                const branchesData = branchesDoc;
+                if (branchesData && branchesData.branches) {
+                    console.log(`✅ Found ${Object.keys(branchesData.branches).length} branches`);
+                    console.log('Branches appear to be intact');
+                }
+                else {
+                    console.log('⚠️  Branches document exists but appears empty');
+                }
+            }
+            catch (error) {
+                console.error('Branches document is corrupted:', error);
+                console.log('💡 Run "mod recover automerge" to fix storage corruption');
+            }
+        }
+        else {
+            console.log('⚠️  Workspace has no branches document ID');
+        }
+    }
+    catch (error) {
+        console.error('Failed to access workspace:', error);
+        console.log('💡 Run "mod recover automerge" to fix storage corruption');
+        process.exit(1);
+    }
+}