@mod-computer/cli 0.1.0 → 0.2.1

package/dist/config/features.js

@@ -11,7 +11,9 @@ export const FEATURES = {
     SYNC_OPERATIONS: 'sync-operations',
     WATCH_OPERATIONS: 'watch-operations',
     CONNECTOR_INTEGRATIONS: 'connector-integrations',
-    AUTH: 'auth'
+    AUTH: 'auth',
+    MEMBER_MANAGEMENT: 'member-management',
+    TRACING: 'tracing'
 };
 let releaseProfile = null;
 export function isFeatureEnabled(feature) {
@@ -28,7 +30,7 @@ export function isFeatureEnabled(feature) {
     return releaseProfile[feature] ?? false;
 }
 function loadReleaseProfile() {
-    const profileName = process.env.MOD_RELEASE_PROFILE || 'development';
+    const profileName = process.env.MOD_RELEASE_PROFILE || 'mvp';
     try {
         const __filename = fileURLToPath(import.meta.url);
         const __dirname = path.dirname(__filename);
@@ -50,7 +52,10 @@ function loadReleaseProfile() {
                 [FEATURES.AGENT_INTEGRATIONS]: true,
                 [FEATURES.SYNC_OPERATIONS]: true,
                 [FEATURES.WATCH_OPERATIONS]: true,
-                [FEATURES.CONNECTOR_INTEGRATIONS]: true
+                [FEATURES.CONNECTOR_INTEGRATIONS]: true,
+                [FEATURES.AUTH]: true,
+                [FEATURES.MEMBER_MANAGEMENT]: true,
+                [FEATURES.TRACING]: true
             };
         }
         // Fallback to minimal profile for unknown profiles

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

@@ -7,5 +7,8 @@
   "agent-integrations": true,
   "sync-operations": true,
   "watch-operations": true,
-  "connector-integrations": true
+  "connector-integrations": true,
+  "auth": true,
+  "member-management": true,
+  "tracing": true
 }

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

@@ -3,10 +3,12 @@
   "workspace-management": true,
   "workspace-branching": false,
   "task-management": false,
-  "file-operations": false,
+  "file-operations": true,
   "agent-integrations": false,
   "sync-operations": true,
   "watch-operations": true,
   "connector-integrations": false,
-  "auth": true
+  "auth": true,
+  "member-management": true,
+  "tracing": true
 }

package/dist/daemon/conflict-resolution.js

@@ -0,0 +1,172 @@
+// glassware[type="implementation", id="impl-conflict-resolution--323bddc9", requirements="requirement-cli-sync-conflict-lww--626f73f4,requirement-cli-sync-conflict-log--7ac92a94"]
+/**
+ * Conflict resolution for bidirectional sync.
+ * Implements last-write-wins strategy with conflict logging.
+ */
+import fs from 'fs';
+import path from 'path';
+import { getLogsDir } from '../lib/storage.js';
+/**
+ * Resolve a conflict between local and remote file states.
+ * Uses last-write-wins strategy with local preference for concurrent edits.
+ *
+ * @param local - Local file state
+ * @param remote - Remote file state (from Automerge doc)
+ * @returns Resolution decision
+ */
+export function resolveConflict(local, remote) {
+    // If content hashes match, no conflict (same content)
+    if (local.contentHash && remote.contentHash && local.contentHash === remote.contentHash) {
+        return {
+            resolution: 'use-local', // Doesn't matter, they're the same
+            reason: 'Content identical (same hash)',
+        };
+    }
+    // If local file hasn't been modified since last sync, use remote
+    // Check both timestamp AND content hash difference to handle cases where
+    // remote metadata.updatedAt isn't updated (e.g., web editor edits)
+    if (!local.modified) {
+        // Local hasn't changed, so any remote difference should be applied
+        if (remote.updatedAt > local.lastSyncedAt) {
+            return {
+                resolution: 'use-remote',
+                reason: 'Local unchanged, remote updated (by timestamp)',
+            };
+        }
+        // Even if timestamp isn't newer, if content is different, use remote
+        // This handles cases where the web editor doesn't update metadata.updatedAt
+        if (local.contentHash && remote.contentHash && local.contentHash !== remote.contentHash) {
+            return {
+                resolution: 'use-remote',
+                reason: 'Local unchanged, remote content differs',
+            };
+        }
+    }
+    // If local was modified and remote hasn't changed since last sync, use local
+    if (local.modified && remote.updatedAt <= local.lastSyncedAt) {
+        return {
+            resolution: 'use-local',
+            reason: 'Local modified, remote unchanged since last sync',
+        };
+    }
+    // Both modified concurrently - local wins (user's active work takes precedence)
+    // Future enhancement: implement actual merge for text files
+    return {
+        resolution: 'use-local',
+        reason: 'Both modified concurrently, local wins (user active work)',
+    };
+}
+/**
+ * Get the path to the conflict log file.
+ */
+export function getConflictLogPath() {
+    return path.join(getLogsDir(), 'conflicts.log');
+}
+/**
+ * Log a conflict record to the conflicts log file.
+ */
+export function logConflict(conflict) {
+    const logPath = getConflictLogPath();
+    const logDir = path.dirname(logPath);
+    // Ensure log directory exists
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+    const line = `${conflict.timestamp} [${conflict.resolution.toUpperCase()}] ${conflict.path} ` +
+        `(local: ${conflict.localTimestamp}, remote: ${conflict.remoteTimestamp}) - ${conflict.reason}\n`;
+    fs.appendFileSync(logPath, line);
+}
+/**
+ * Create a conflict record and log it.
+ */
+export function recordConflict(local, remote, resolution, reason) {
+    const record = {
+        path: local.path,
+        localTimestamp: local.localMtime,
+        remoteTimestamp: remote.updatedAt,
+        resolution,
+        timestamp: new Date().toISOString(),
+        reason,
+    };
+    logConflict(record);
+    return record;
+}
+/**
+ * Read recent conflicts from the log file.
+ * @param limit - Maximum number of conflicts to return
+ * @returns Array of conflict records (most recent first)
+ */
+export function readRecentConflicts(limit = 100) {
+    const logPath = getConflictLogPath();
+    if (!fs.existsSync(logPath)) {
+        return [];
+    }
+    try {
+        const content = fs.readFileSync(logPath, 'utf-8');
+        const lines = content.trim().split('\n').filter(Boolean);
+        // Parse lines and return most recent first
+        return lines
+            .slice(-limit)
+            .reverse()
+            .map(parseLine)
+            .filter((record) => record !== null);
+    }
+    catch (error) {
+        console.warn('[conflict-resolution] Could not read conflict log');
+        return [];
+    }
+}
+/**
+ * Parse a conflict log line back into a record.
+ * Format: TIMESTAMP [RESOLUTION] PATH (local: TIMESTAMP, remote: TIMESTAMP) - REASON
+ */
+function parseLine(line) {
+    const match = line.match(/^(\S+) \[(\w+-\w+)\] (.+?) \(local: ([^,]+), remote: ([^)]+)\) - (.+)$/);
+    if (!match) {
+        return null;
+    }
+    return {
+        timestamp: match[1],
+        resolution: match[2],
+        path: match[3],
+        localTimestamp: match[4],
+        remoteTimestamp: match[5],
+        reason: match[6],
+    };
+}
+/**
+ * ConflictResolver - manages conflict resolution for a sync session.
+ */
+export class ConflictResolver {
+    constructor(logger = console.log) {
+        this.conflictCount = 0;
+        this.log = logger;
+    }
+    /**
+     * Check and resolve a potential conflict between local and remote states.
+     * @returns The resolution decision and whether a conflict was detected
+     */
+    checkAndResolve(local, remote) {
+        const { resolution, reason } = resolveConflict(local, remote);
+        // It's only a "conflict" if both sides were modified
+        const isConflict = local.modified && remote.updatedAt > local.lastSyncedAt;
+        if (isConflict) {
+            this.conflictCount++;
+            recordConflict(local, remote, resolution, reason);
+            this.log(`[conflict] ${local.path}: ${reason} → ${resolution}`);
+        }
+        return { resolution, reason, isConflict };
+    }
+    /**
+     * Get the number of conflicts detected in this session.
+     */
+    getConflictCount() {
+        return this.conflictCount;
+    }
+    /**
+     * Reset the conflict count (e.g., at start of new sync session).
+     */
+    resetCount() {
+        this.conflictCount = 0;
+    }
+}

package/dist/daemon/content-hash.js

@@ -0,0 +1,31 @@
+// glassware[type="implementation", id="impl-content-hash--dba4e6e0", requirements="requirement-cli-sync-content-hash--cc8aff1f"]
+/**
+ * Content hash utilities for change detection.
+ * Uses SHA-256 to compute content hashes for efficient change detection.
+ */
+import { createHash } from 'crypto';
+/**
+ * Compute SHA-256 hash of content for change detection.
+ * Returns hex-encoded hash string.
+ */
+export function computeContentHash(content) {
+    const hash = createHash('sha256');
+    if (typeof content === 'string') {
+        hash.update(content, 'utf-8');
+    }
+    else {
+        hash.update(content);
+    }
+    return hash.digest('hex');
+}
+/**
+ * Check if content has changed by comparing hashes.
+ * @returns true if content has changed, false if unchanged
+ */
+export function hasContentChanged(newContent, existingHash) {
+    if (!existingHash) {
+        return true; // No existing hash means it's new
+    }
+    const newHash = computeContentHash(newContent);
+    return newHash !== existingHash;
+}