@mod-computer/cli 0.1.0

package/dist/services/logger.js

@@ -0,0 +1,44 @@
+import * as fs from 'fs';
+import * as path from 'path';
+// Evaluate debug flag at call time to allow dotenv to load later
+function isDebugEnabled() {
+    return Boolean(process.env.MOD_CLI_DEBUG) || Boolean(process.env.DEBUG);
+}
+const LOG_DIR = path.resolve(process.cwd(), '.mod');
+const LOG_FILE = path.join(LOG_DIR, 'cli-debug.log');
+function ensureLogDir() {
+    try {
+        fs.mkdirSync(LOG_DIR, { recursive: true });
+    }
+    catch { }
+}
+export function log(...args) {
+    if (!isDebugEnabled())
+        return;
+    try {
+        ensureLogDir();
+        const line = `[${new Date().toISOString()}] ${args.map(a => safeStringify(a)).join(' ')}\n`;
+        fs.appendFileSync(LOG_FILE, line, 'utf8');
+        // Also mirror to stderr so it doesn't interfere with Ink UI
+        try {
+            console.error(line.trimEnd());
+        }
+        catch { }
+    }
+    catch { }
+}
+function safeStringify(v) {
+    try {
+        if (typeof v === 'string')
+            return v;
+        return JSON.stringify(v);
+    }
+    catch {
+        try {
+            return String(v);
+        }
+        catch {
+            return '[unprintable]';
+        }
+    }
+}

package/dist/services/mod-config.js

@@ -0,0 +1,61 @@
+import fs from 'fs';
+import path from 'path';
+const MOD_DIR = '.mod';
+const CONFIG_FILE = 'config.json';
+function getConfigPath() {
+    const override = process.env.MOD_CONFIG_PATH;
+    if (override && typeof override === 'string' && override.trim() !== '') {
+        return override;
+    }
+    return path.join(process.cwd(), MOD_DIR, CONFIG_FILE);
+}
+function ensureModDir() {
+    const modDirPath = path.join(process.cwd(), MOD_DIR);
+    if (!fs.existsSync(modDirPath)) {
+        fs.mkdirSync(modDirPath, { recursive: true });
+    }
+}
+export function readModConfig() {
+    // Preferred: .mod/config.json
+    const cfgPath = getConfigPath();
+    if (fs.existsSync(cfgPath)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+            return config || {};
+        }
+        catch {
+            return null;
+        }
+    }
+    // Legacy migration: root .mod file containing JSON
+    const legacyPath = path.join(process.cwd(), '.mod');
+    if (fs.existsSync(legacyPath) && fs.statSync(legacyPath).isFile()) {
+        try {
+            const legacy = JSON.parse(fs.readFileSync(legacyPath, 'utf8'));
+            const migrated = {};
+            if (legacy && typeof legacy.workspaceId === 'string')
+                migrated.workspaceId = legacy.workspaceId;
+            if (legacy && typeof legacy.activeBranchId === 'string')
+                migrated.activeBranchId = legacy.activeBranchId;
+            return migrated;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+export function writeModConfig(update) {
+    try {
+        ensureModDir();
+        const cfgPath = getConfigPath();
+        const current = fs.existsSync(cfgPath)
+            ? JSON.parse(fs.readFileSync(cfgPath, 'utf8'))
+            : {};
+        const next = { ...current, ...update };
+        fs.writeFileSync(cfgPath, JSON.stringify(next, null, 2), 'utf8');
+    }
+    catch (error) {
+        console.error(`Failed to write .mod/config.json:`, error);
+    }
+}

package/dist/services/modignore-service.js

@@ -0,0 +1,326 @@
+import fs from 'fs';
+import path from 'path';
+export class ModIgnoreService {
+    constructor(workingDirectory) {
+        this.patterns = [];
+        this.defaultPatterns = [
+            'node_modules/',
+            '*/node_modules/*',
+            '.git/',
+            '.DS_Store',
+            'Thumbs.db',
+            '*.log',
+            'npm-debug.log*',
+            'yarn-debug.log*',
+            '.env',
+            '.env.*',
+            'dist/',
+            'build/',
+            '.next/',
+            '.nuxt/',
+            'coverage/',
+            '.nyc_output/',
+            '*.tmp',
+            '*.temp',
+            '*.swp',
+            '*.swo',
+            '.cache/',
+            '.vscode/',
+            '.idea/',
+            '.automerge-data/',
+            'package-lock.json',
+            'yarn.lock',
+            'pnpm-lock.yaml',
+            '.mod/.cache',
+        ];
+        this.trackableExtensions = [
+            '.md', '.txt', '.js', '.ts', '.jsx', '.tsx', '.json', '.yaml', '.yml',
+            '.py', '.java', '.cpp', '.c', '.h', '.css', '.scss', '.html', '.xml',
+            '.sql', '.go', '.rs', '.php', '.rb', '.swift', '.kt', '.scala'
+        ];
+        this.loadIgnoreFile(workingDirectory);
+    }
+    /**
+     * Load .modignore file from the working directory
+     */
+    loadIgnoreFile(workingDirectory) {
+        // Start with default patterns
+        this.patterns = this.defaultPatterns.map(pattern => this.parsePattern(pattern));
+        const ignoreFilePath = path.join(workingDirectory, '.modignore');
+        try {
+            if (fs.existsSync(ignoreFilePath)) {
+                const content = fs.readFileSync(ignoreFilePath, 'utf8');
+                const lines = content.split('\n')
+                    .map(line => line.trim())
+                    .filter(line => line && !line.startsWith('#')); // Remove comments and empty lines
+                for (const line of lines) {
+                    this.patterns.push(this.parsePattern(line));
+                }
+            }
+        }
+        catch (err) {
+            console.warn('Warning: Could not read .modignore file:', err);
+        }
+    }
+    /**
+     * Parse a single ignore pattern
+     */
+    parsePattern(pattern) {
+        let cleanPattern = pattern.trim();
+        const isNegation = cleanPattern.startsWith('!');
+        if (isNegation) {
+            cleanPattern = cleanPattern.slice(1);
+        }
+        const isDirectory = cleanPattern.endsWith('/');
+        if (isDirectory) {
+            cleanPattern = cleanPattern.slice(0, -1);
+        }
+        return {
+            pattern: cleanPattern,
+            isNegation,
+            isDirectory,
+        };
+    }
+    /**
+     * Check if a file path should be ignored
+     */
+    shouldIgnore(filePath, workingDirectory) {
+        // Always ignore .mod and .modignore files
+        const relativePath = path.relative(workingDirectory, filePath);
+        const fileName = path.basename(filePath);
+        if (fileName === '.mod' || fileName === '.modignore') {
+            return true;
+        }
+        // Check if it's a directory
+        const isDirectory = fs.existsSync(filePath) && fs.statSync(filePath).isDirectory();
+        let shouldIgnore = false;
+        for (const { pattern, isNegation, isDirectory: patternIsDirectory } of this.patterns) {
+            const matches = this.matchesPattern(relativePath, pattern, isDirectory, patternIsDirectory);
+            if (matches) {
+                shouldIgnore = !isNegation;
+            }
+        }
+        return shouldIgnore;
+    }
+    /**
+     * Check if a path matches a pattern
+     */
+    matchesPattern(relativePath, pattern, isDirectory, patternIsDirectory) {
+        // If pattern is for directories only, skip non-directories
+        if (patternIsDirectory && !isDirectory) {
+            return false;
+        }
+        // Convert pattern to regex
+        const regexPattern = this.patternToRegex(pattern);
+        const regex = new RegExp(regexPattern);
+        // Check direct match
+        if (regex.test(relativePath)) {
+            return true;
+        }
+        // Check if any parent directory matches (for directory patterns)
+        const pathParts = relativePath.split(path.sep);
+        for (let i = 0; i < pathParts.length; i++) {
+            const partialPath = pathParts.slice(0, i + 1).join(path.sep);
+            if (regex.test(partialPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Convert a glob pattern to a regex pattern
+     */
+    patternToRegex(pattern) {
+        // Escape special regex characters except * and ?
+        let regex = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        // Handle ** globstar patterns first (before single *)
+        regex = regex.replace(/\*\*/g, '(?:.*[\\\\/])?.*'); // ** matches zero or more directories
+        // Convert remaining glob patterns to regex
+        regex = regex.replace(/\*/g, '[^\\\\/]*'); // * matches any characters except path separators
+        regex = regex.replace(/\?/g, '.'); // ? matches any single character
+        // Handle directory separators
+        regex = regex.replace(/\\\//g, '[\\\\/]'); // Handle both / and \ path separators
+        // For patterns ending with /, match anything under that directory
+        if (pattern.endsWith('/')) {
+            regex = regex.replace(/\$/, '(?:[\\\\/].*)?$');
+        }
+        // Anchor the pattern
+        if (!regex.startsWith('(?:.*[\\\\/])?.*') && !regex.startsWith('^')) {
+            regex = '^' + regex;
+        }
+        if (!regex.endsWith('.*') && !regex.endsWith('$')) {
+            regex = regex + '$';
+        }
+        return regex;
+    }
+    /**
+     * Get all loaded patterns (for debugging)
+     */
+    getPatterns() {
+        return [...this.patterns];
+    }
+    /**
+     * Filter a list of file paths, removing ignored ones
+     */
+    filterIgnored(filePaths, workingDirectory) {
+        return filePaths.filter(filePath => !this.shouldIgnore(filePath, workingDirectory));
+    }
+    async preFilterDirectory(workingDirectory) {
+        const result = {
+            totalFiles: 0,
+            filteredFiles: [],
+            excludedCount: 0,
+            trackableFiles: []
+        };
+        await this.scanDirectoryRecursive(workingDirectory, workingDirectory, result);
+        result.trackableFiles = result.filteredFiles.filter(filePath => this.isTrackableFile(filePath));
+        return result;
+    }
+    async scanDirectoryRecursive(dirPath, rootPath, result) {
+        try {
+            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dirPath, entry.name);
+                if (entry.isDirectory()) {
+                    // Check if directory should be ignored before recursing
+                    if (!this.shouldIgnore(fullPath, rootPath)) {
+                        await this.scanDirectoryRecursive(fullPath, rootPath, result);
+                    }
+                    else {
+                        try {
+                            const excludedCount = await this.countFilesInDirectory(fullPath);
+                            result.excludedCount += excludedCount;
+                        }
+                        catch (error) {
+                            console.warn(`Failed to count files in excluded directory ${fullPath}:`, error);
+                        }
+                    }
+                }
+                else if (entry.isFile()) {
+                    result.totalFiles++;
+                    if (!this.shouldIgnore(fullPath, rootPath)) {
+                        result.filteredFiles.push(fullPath);
+                    }
+                    else {
+                        result.excludedCount++;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to scan directory ${dirPath}:`, error);
+        }
+    }
+    async countFilesInDirectory(dirPath) {
+        try {
+            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+            let count = 0;
+            for (const entry of entries) {
+                if (entry.isFile()) {
+                    count++;
+                }
+                else if (entry.isDirectory()) {
+                    count += await this.countFilesInDirectory(path.join(dirPath, entry.name));
+                }
+            }
+            return count;
+        }
+        catch (error) {
+            return 0;
+        }
+    }
+    isTrackableFile(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        return this.trackableExtensions.includes(ext);
+    }
+    getPatternStats() {
+        return {
+            totalPatterns: this.patterns.length,
+            defaultPatterns: this.defaultPatterns.length,
+            customPatterns: Math.max(0, this.patterns.length - this.defaultPatterns.length)
+        };
+    }
+    /**
+     * Create a default .modignore file in the specified directory
+     */
+    static createDefaultIgnoreFile(workingDirectory) {
+        const ignoreFilePath = path.join(workingDirectory, '.modignore');
+        if (fs.existsSync(ignoreFilePath)) {
+            return; // Don't overwrite existing file
+        }
+        const defaultContent = `# Mod Ignore File
+# Patterns to exclude from mod sync operations
+
+# Dependencies
+node_modules/
+vendor/
+
+# Build outputs
+dist/
+build/
+out/
+target/
+
+# Environment files
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Logs
+*.log
+logs/
+
+# Runtime data
+pids/
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage directory used by tools like istanbul
+coverage/
+.nyc_output/
+
+# Cache directories
+.cache/
+.npm/
+.yarn/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.temp
+*.swp
+*.swo
+*~
+
+# IDE files
+.vscode/
+.idea/
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+# Automerge data
+.automerge-data/
+`;
+        try {
+            fs.writeFileSync(ignoreFilePath, defaultContent, 'utf8');
+            console.log('Created default .modignore file');
+        }
+        catch (err) {
+            console.warn('Warning: Could not create .modignore file:', err);
+        }
+    }
+}

package/dist/services/sync-daemon.js

@@ -0,0 +1,244 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { readModConfig } from './mod-config.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class SyncDaemon {
+    constructor() {
+        this.syncQueue = [];
+        this.cacheDir = path.join(process.cwd(), '.mod', '.cache');
+        this.stateFilePath = path.join(this.cacheDir, 'sync-daemon.json');
+        this.pidFilePath = path.join(this.cacheDir, 'sync-daemon.pid');
+    }
+    async start(options = {}) {
+        try {
+            const currentState = await this.getState();
+            if (currentState && currentState.status === 'running' && !options.force) {
+                if (await this.isProcessRunning(currentState.pid)) {
+                    throw new Error(`Daemon is already running (PID: ${currentState.pid})`);
+                }
+            }
+            await fs.mkdir(this.cacheDir, { recursive: true });
+            const cfg = readModConfig();
+            if (!cfg?.workspaceId) {
+                throw new Error('No active workspace found in .mod/config.json');
+            }
+            const daemonProcess = spawn(process.execPath, [
+                path.join(__dirname, '../daemon-worker.js'),
+                '--workspace-id', cfg.workspaceId,
+                '--active-branch', cfg.activeBranchId || 'main',
+                '--working-dir', process.cwd()
+            ], {
+                detached: true,
+                stdio: options.verbose ? 'inherit' : 'ignore',
+                cwd: process.cwd(),
+                env: { ...process.env, MOD_DAEMON_MODE: 'true' }
+            });
+            daemonProcess.unref();
+            const initialState = {
+                pid: daemonProcess.pid,
+                status: 'starting',
+                startedAt: new Date().toISOString(),
+                lastActivity: new Date().toISOString(),
+                workspaceId: cfg.workspaceId,
+                activeBranchId: cfg.activeBranchId,
+                watchedFiles: 0,
+                crashCount: 0,
+                uptime: 0
+            };
+            await this.saveState(initialState);
+            await fs.writeFile(this.pidFilePath, daemonProcess.pid.toString(), 'utf8');
+            console.log(`✅ Sync daemon started (PID: ${daemonProcess.pid})`);
+            console.log(`📁 Working directory: ${process.cwd()}`);
+            console.log(`🔗 Workspace: ${cfg.workspaceId}`);
+            await this.waitForDaemonReady(daemonProcess.pid, 5000);
+        }
+        catch (error) {
+            console.error('Failed to start sync daemon:', error);
+            throw error;
+        }
+    }
+    async stop(options = {}) {
+        try {
+            const currentState = await this.getState();
+            if (!currentState || currentState.status === 'stopped') {
+                console.log('Daemon is not running');
+                return;
+            }
+            if (!(await this.isProcessRunning(currentState.pid))) {
+                console.log('Daemon process not found (cleaning up stale state)');
+                await this.cleanup();
+                return;
+            }
+            console.log(`🛑 Stopping daemon (PID: ${currentState.pid})...`);
+            await this.updateState({ status: 'stopping' });
+            // Send SIGTERM for graceful shutdown
+            process.kill(currentState.pid, 'SIGTERM');
+            const shutdownTimeout = 10000; // 10 seconds
+            let gracefulShutdown = false;
+            for (let i = 0; i < shutdownTimeout / 100; i++) {
+                if (!(await this.isProcessRunning(currentState.pid))) {
+                    gracefulShutdown = true;
+                    break;
+                }
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            if (!gracefulShutdown) {
+                if (options.force) {
+                    console.log('⚠️  Forcing daemon shutdown...');
+                    process.kill(currentState.pid, 'SIGKILL');
+                }
+                else {
+                    throw new Error('Daemon did not shut down gracefully. Use --force to kill the process.');
+                }
+            }
+            await this.cleanup();
+            console.log('✅ Sync daemon stopped');
+        }
+        catch (error) {
+            console.error('Failed to stop sync daemon:', error);
+            throw error;
+        }
+    }
+    async restart(options = {}) {
+        console.log('🔄 Restarting sync daemon...');
+        await this.stop(options);
+        await new Promise(resolve => setTimeout(resolve, 1000)); // Brief pause
+        await this.start(options);
+    }
+    async status() {
+        try {
+            const state = await this.getState();
+            if (!state) {
+                return null;
+            }
+            const isRunning = await this.isProcessRunning(state.pid);
+            if (!isRunning && state.status !== 'stopped') {
+                // Process died unexpectedly
+                await this.updateState({
+                    status: 'crashed',
+                    lastError: 'Process terminated unexpectedly'
+                });
+                state.status = 'crashed';
+            }
+            // Calculate uptime if running
+            if (state.status === 'running') {
+                state.uptime = Date.now() - new Date(state.startedAt).getTime();
+            }
+            return state;
+        }
+        catch (error) {
+            console.error('Failed to get daemon status:', error);
+            return null;
+        }
+    }
+    async handleCrash(pid, error) {
+        const state = await this.getState();
+        if (!state)
+            return;
+        const crashCount = (state.crashCount || 0) + 1;
+        await this.updateState({
+            status: 'crashed',
+            crashCount,
+            lastError: error || 'Process crashed unexpectedly',
+            lastActivity: new Date().toISOString()
+        });
+        const backoffDelay = Math.min(1000 * Math.pow(2, crashCount - 1), 30000); // Max 30 seconds
+        console.error(`💥 Daemon crashed (attempt ${crashCount}). Restarting in ${backoffDelay}ms...`);
+        if (crashCount <= 5) { // Max 5 restart attempts
+            setTimeout(async () => {
+                try {
+                    await this.start({ autoRestart: true });
+                }
+                catch (restartError) {
+                    console.error('Failed to restart daemon after crash:', restartError);
+                }
+            }, backoffDelay);
+        }
+        else {
+            console.error('❌ Maximum crash restart attempts exceeded. Manual restart required.');
+        }
+    }
+    async addToSyncQueue(item) {
+        const queueItem = {
+            id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: new Date().toISOString(),
+            retryCount: 0,
+            ...item
+        };
+        if (item.priority === 'high') {
+            this.syncQueue.unshift(queueItem);
+        }
+        else {
+            this.syncQueue.push(queueItem);
+        }
+        await this.processSyncQueue();
+    }
+    async processSyncQueue() {
+        while (this.syncQueue.length > 0) {
+            const item = this.syncQueue.shift();
+            try {
+                // Process sync operation here
+                await this.updateState({ lastActivity: new Date().toISOString() });
+            }
+            catch (error) {
+                console.error(`Failed to process sync queue item ${item.id}:`, error);
+                if (item.retryCount < 3) {
+                    item.retryCount++;
+                    setTimeout(() => this.syncQueue.push(item), 1000 * item.retryCount);
+                }
+            }
+        }
+    }
+    async getState() {
+        try {
+            const data = await fs.readFile(this.stateFilePath, 'utf8');
+            return JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveState(state) {
+        await fs.writeFile(this.stateFilePath, JSON.stringify(state, null, 2), 'utf8');
+    }
+    async updateState(updates) {
+        const currentState = await this.getState();
+        if (currentState) {
+            const newState = { ...currentState, ...updates };
+            await this.saveState(newState);
+        }
+    }
+    async isProcessRunning(pid) {
+        try {
+            process.kill(pid, 0); // Signal 0 checks if process exists without killing
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async waitForDaemonReady(pid, timeoutMs) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeoutMs) {
+            const state = await this.getState();
+            if (state && state.pid === pid && state.status === 'running') {
+                return;
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        throw new Error('Daemon failed to start within timeout period');
+    }
+    async cleanup() {
+        try {
+            await fs.unlink(this.pidFilePath);
+        }
+        catch { /* ignore */ }
+        try {
+            await fs.unlink(this.stateFilePath);
+        }
+        catch { /* ignore */ }
+    }
+}