@mod-computer/cli 0.1.0 → 0.2.1

package/dist/commands/diff.js

@@ -0,0 +1,182 @@
+// glassware[type="implementation", id="impl-cli-diff-cmd--2caa2bcb", requirements="requirement-cli-diff-cmd--cfd908be,requirement-cli-diff-requires-workspace--a4b7f1ce,requirement-cli-diff-unified--a9889945,requirement-cli-diff-color--23d3ed12,requirement-cli-diff-stat--364f0431,requirement-cli-diff-direction-default--e6c9d2de,requirement-cli-diff-direction-workspace--dc23c716"]
+// spec: packages/mod-cli/specs/file-directory.md
+import { createModWorkspace } from '@mod/mod-core';
+import { readWorkspaceConnection } from '../lib/storage.js';
+import { readLocalFile, localFileExists, isBinaryFile } from '../lib/local-fs.js';
+import { computeDiff, formatUnifiedDiff, formatDiffStat, calculateDiffStats, getWorkspaceContent, isBinaryContent, } from '../lib/diff.js';
+import path from 'path';
+// glassware[type="implementation", id="impl-cli-diff-requires-workspace--257badd4", requirements="requirement-cli-diff-requires-workspace--a4b7f1ce,requirement-cli-fd-error-no-workspace--1919b4fb"]
+function requireWorkspaceConnection() {
+    const currentDir = process.cwd();
+    const connection = readWorkspaceConnection(currentDir);
+    if (!connection) {
+        console.error('Error: Not connected to a workspace.');
+        console.error('Run `mod init` to connect this directory first.');
+        process.exit(1);
+    }
+    return {
+        workspaceId: connection.workspaceId,
+        workspaceName: connection.workspaceName,
+        workspacePath: connection.path,
+    };
+}
+function parseArgs(args) {
+    const options = {
+        workspace: false,
+        stat: false,
+        noColor: false,
+        context: 3,
+    };
+    let filePath;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--workspace' || arg === '-w') {
+            options.workspace = true;
+        }
+        else if (arg === '--stat') {
+            options.stat = true;
+        }
+        else if (arg === '--no-color') {
+            options.noColor = true;
+        }
+        else if (arg === '--context' && args[i + 1]) {
+            options.context = parseInt(args[i + 1], 10) || 3;
+            i++;
+        }
+        else if (arg.startsWith('--context=')) {
+            options.context = parseInt(arg.slice('--context='.length), 10) || 3;
+        }
+        else if (!arg.startsWith('-') && !filePath) {
+            filePath = arg;
+        }
+    }
+    // Check if terminal supports color
+    if (!process.stdout.isTTY) {
+        options.noColor = true;
+    }
+    return { filePath, options };
+}
+// glassware[type="implementation", id="impl-cli-fd-perf-diff--61c6010d", requirements="requirement-cli-fd-perf-diff--43c2078c"]
+export async function diffCommand(args, repo) {
+    const { workspaceId, workspacePath } = requireWorkspaceConnection();
+    const { filePath, options } = parseArgs(args);
+    try {
+        const modWorkspace = createModWorkspace(repo);
+        const workspaceHandle = await modWorkspace.openWorkspace(workspaceId);
+        // Get workspace files
+        const workspaceFiles = await workspaceHandle.file.list();
+        // If specific file requested, diff only that file
+        const filesToDiff = filePath
+            ? workspaceFiles.filter(f => (f.metadata?.path || f.name) === filePath)
+            : workspaceFiles;
+        if (filePath && filesToDiff.length === 0) {
+            console.error(`Error: File not found in workspace: ${filePath}`);
+            console.error("Run `mod ls` to see workspace files.");
+            process.exit(1);
+        }
+        const diffResults = [];
+        for (const file of filesToDiff) {
+            const wsPath = file.metadata?.path || file.name;
+            const localPath = path.join(workspacePath, wsPath);
+            // Check if local file exists
+            const localExists = await localFileExists(localPath);
+            const localContent = localExists ? await readLocalFile(localPath) : null;
+            // Get workspace content
+            let wsContent = '';
+            try {
+                const handle = await workspaceHandle.file.get(file.id);
+                if (handle) {
+                    const doc = handle.doc();
+                    wsContent = getWorkspaceContent(doc?.content);
+                }
+            }
+            catch {
+                continue; // Skip files we can't load
+            }
+            // Skip if no differences
+            if (localContent === wsContent) {
+                continue;
+            }
+            // Check for binary
+            const localIsBinary = localContent !== null && (await isBinaryFile(localPath) || isBinaryContent(localContent));
+            const wsIsBinary = isBinaryContent(wsContent);
+            if (localIsBinary || wsIsBinary) {
+                const localStats = localContent !== null ? localContent.length : 0;
+                const wsStats = wsContent.length;
+                diffResults.push({
+                    path: wsPath,
+                    additions: 0,
+                    deletions: 0,
+                    diffOutput: `Binary files differ (workspace: ${formatBytes(wsStats)}, local: ${formatBytes(localStats)})`,
+                    isBinary: true,
+                });
+                continue;
+            }
+            // Compute diff based on direction
+            let oldContent;
+            let newContent;
+            let oldLabel;
+            let newLabel;
+            if (options.workspace) {
+                // Show workspace changes (what would come from workspace)
+                oldContent = localContent || '';
+                newContent = wsContent;
+                oldLabel = `local:${wsPath}`;
+                newLabel = `workspace:${wsPath}`;
+            }
+            else {
+                // Show local changes (what would go to workspace)
+                oldContent = wsContent;
+                newContent = localContent || '';
+                oldLabel = `workspace:${wsPath}`;
+                newLabel = `local:${wsPath}`;
+            }
+            // Compute unified diff
+            const hunks = computeDiff(oldContent, newContent, options.context);
+            if (hunks.length === 0) {
+                continue; // No differences
+            }
+            const stats = calculateDiffStats(hunks);
+            // Format with color if supported
+            const diffOutput = formatUnifiedDiff(oldLabel, newLabel, hunks, !options.noColor);
+            diffResults.push({
+                path: wsPath,
+                additions: stats.additions,
+                deletions: stats.deletions,
+                diffOutput,
+                isBinary: false,
+            });
+        }
+        if (diffResults.length === 0) {
+            console.log('No differences.');
+            return;
+        }
+        // Show diffstat summary if requested
+        if (options.stat) {
+            const statOutput = formatDiffStat(diffResults.map(r => ({
+                path: r.path,
+                additions: r.additions,
+                deletions: r.deletions,
+            })), !options.noColor);
+            console.log(statOutput);
+            return;
+        }
+        // Output diffs
+        for (const result of diffResults) {
+            console.log(result.diffOutput);
+            console.log('');
+        }
+    }
+    catch (error) {
+        console.error('Error computing diff:', error.message);
+        process.exit(1);
+    }
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+}

package/dist/commands/index.js

@@ -1,16 +1,28 @@
 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 { lsCommand } from './ls.js';
+import { rmCommand } from './rm.js';
+import { mvCommand } from './mv.js';
+import { statusCommand } from './status.js';
+import { diffCommand } from './diff.js';
+import { addCommand } from './add.js';
+import { membersCommand } from './members.js';
+import { commentCommand } from './comment.js';
+import { traceCommand } from './trace.js';
 import { FEATURES, isFeatureEnabled } from '../config/features.js';
+// Alias for 'mod signin' -> 'mod auth login'
+const signinCommand = (args, repo) => {
+    return authCommand(['login', ...args], repo);
+};
 const allCommands = {
     'auth': authCommand,
-    'spec': specCommand,
+    'signin': signinCommand, // Alias for 'auth login'
     'sync': syncCommand,
     'agents-run': agentsRunCommand,
     'claude-sync': claudeSyncCommand,
@@ -18,10 +30,19 @@ const allCommands = {
     'workspace': workspaceCommand,
     'init': initCommand,
     'recover': recoverCommand,
+    'ls': lsCommand,
+    'rm': rmCommand,
+    'mv': mvCommand,
+    'status': statusCommand,
+    'diff': diffCommand,
+    'add': addCommand,
+    'members': membersCommand,
+    'comment': commentCommand,
+    'trace': traceCommand,
 };
 const commandFeatureMapping = {
     'auth': FEATURES.AUTH,
-    'spec': FEATURES.TASK_MANAGEMENT, // Spec tracking, not in MVP
+    'signin': FEATURES.AUTH, // Alias for 'auth login'
     'sync': FEATURES.WATCH_OPERATIONS,
     'agents-run': FEATURES.AGENT_INTEGRATIONS,
     'claude-sync': FEATURES.AGENT_INTEGRATIONS, // Claude projects sync, separate from file sync daemon
@@ -29,6 +50,15 @@ const commandFeatureMapping = {
     '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
+    'ls': FEATURES.FILE_OPERATIONS,
+    'rm': FEATURES.FILE_OPERATIONS,
+    'mv': FEATURES.FILE_OPERATIONS,
+    'status': FEATURES.FILE_OPERATIONS,
+    'diff': FEATURES.FILE_OPERATIONS,
+    'add': FEATURES.FILE_OPERATIONS, // Add files to workspace
+    'members': FEATURES.MEMBER_MANAGEMENT, // Workspace member management
+    'comment': FEATURES.FILE_OPERATIONS, // Comment metadata operations
+    'trace': FEATURES.TRACING, // Trace management and reporting
 };
 const registry = {};
 for (const [commandName, commandHandler] of Object.entries(allCommands)) {