@mod-computer/cli 0.2.4 → 0.2.5

package/dist/services/logger.js

@@ -1,44 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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 {
-        // NOTE: .mod directory creation disabled - config moved to ~/.mod/config
-        // ensureModDir();
-        const cfgPath = getConfigPath();
-        // Only create directory if config path is not in cwd (e.g., using MOD_CONFIG_PATH override)
-        const configDir = path.dirname(cfgPath);
-        if (!configDir.includes(process.cwd()) && !fs.existsSync(configDir)) {
-            fs.mkdirSync(configDir, { recursive: true });
-        }
-        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:`, error);
-    }
-}

package/dist/services/modignore-service.js

@@ -1,328 +0,0 @@
-// glassware[type="implementation", id="impl-cli-add-modignore-service--ae506406", requirements="requirement-cli-add-ignore-modignore--92ba9b60,requirement-cli-add-ignore-gitignore--054c4b53,requirement-cli-add-ignore-default--facbedfe,requirement-cli-add-ignore-negation--79b9bf48"]
-// spec: packages/mod-cli/specs/add.md
-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

@@ -1,244 +0,0 @@
-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 */ }
-    }
-}