@mod-computer/cli 0.2.4 → 0.2.5

package/dist/services/automatic-file-tracker.js

@@ -1,303 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import chokidar from 'chokidar';
-import { detectMimeType, mimeTypeToCanvasType } from '@mod/mod-core';
-import { ModIgnoreService } from './modignore-service.js';
-import crypto from 'crypto';
-export class AutomaticFileTracker {
-    constructor(repo) {
-        this.debounceTimers = new Map();
-        this.fileHashes = new Map();
-        this.isTracking = false;
-        this.watchedFileCount = 0;
-        this.maxWatchedFiles = 2000;
-        this.filePathToDocumentId = new Map();
-        this.repo = repo;
-    }
-    async enableAutoTracking(options) {
-        if (this.isTracking) {
-            console.log('Automatic file tracking already enabled');
-            return;
-        }
-        const watchDirectory = options.watchDirectory || process.cwd();
-        const debounceMs = options.debounceMs || 500;
-        const verbose = options.verbose || false;
-        const preFilterEnabled = options.preFilterEnabled !== false; // Default true
-        const maxWatchedFiles = options.maxWatchedFiles || 2000;
-        const resourceMonitoring = options.resourceMonitoring !== false; // Default true
-        this.maxWatchedFiles = maxWatchedFiles;
-        if (resourceMonitoring) {
-            await this.checkFileDescriptorLimits();
-        }
-        console.log(`🔍 Starting automatic file tracking in: ${watchDirectory}`);
-        this.modIgnoreService = new ModIgnoreService(watchDirectory);
-        let trackableFiles = [];
-        if (preFilterEnabled) {
-            const filterResult = await this.modIgnoreService.preFilterDirectory(watchDirectory);
-            trackableFiles = filterResult.trackableFiles;
-            console.log(`📊 Pre-filter results: ${filterResult.totalFiles} total, ${filterResult.filteredFiles.length} passed filters, ${filterResult.trackableFiles.length} trackable`);
-            console.log(`📊 Excluded ${filterResult.excludedCount} files (${((filterResult.excludedCount / filterResult.totalFiles) * 100).toFixed(1)}%)`);
-            trackableFiles = this.validateResourceLimits(trackableFiles);
-        }
-        await this.initializeFileMappings(options.workspaceHandle, watchDirectory);
-        if (preFilterEnabled && trackableFiles.length > 0) {
-            // Watch specific pre-filtered files instead of entire directory
-            this.watcher = chokidar.watch(trackableFiles, {
-                ignoreInitial: true,
-                persistent: true,
-                followSymlinks: false
-            });
-            this.watchedFileCount = trackableFiles.length;
-        }
-        else {
-            // Fallback to directory watching with ignore patterns
-            this.watcher = chokidar.watch(watchDirectory, {
-                ignored: (filePath) => {
-                    return this.modIgnoreService.shouldIgnore(filePath, watchDirectory);
-                },
-                ignoreInitial: true,
-                persistent: true,
-                followSymlinks: false
-            });
-        }
-        this.watcher
-            .on('add', filePath => {
-            if (verbose)
-                console.log(`[tracker] File added: ${filePath}`);
-            this.handleFileEvent('add', filePath, options, debounceMs);
-        })
-            .on('change', filePath => {
-            if (verbose)
-                console.log(`[tracker] File changed: ${filePath}`);
-            this.handleFileEvent('change', filePath, options, debounceMs);
-        })
-            .on('unlink', filePath => {
-            if (verbose)
-                console.log(`[tracker] File deleted: ${filePath}`);
-            this.handleFileEvent('unlink', filePath, options, debounceMs);
-        });
-        this.isTracking = true;
-        console.log(`✅ Automatic file tracking enabled`);
-    }
-    async initializeFileMappings(workspaceHandle, watchDirectory) {
-        try {
-            // Get all files currently tracked in the workspace
-            const files = await workspaceHandle.file.list();
-            for (const file of files) {
-                // Create mapping from file path to document ID
-                const filePath = path.join(watchDirectory, file.name);
-                this.filePathToDocumentId.set(filePath, file.id);
-                // Initialize content hash if file exists on disk
-                if (fs.existsSync(filePath)) {
-                    const content = fs.readFileSync(filePath, 'utf8');
-                    const hash = this.getContentHash(content);
-                    this.fileHashes.set(filePath, hash);
-                }
-            }
-            console.log(`📁 Initialized tracking for ${files.length} files`);
-        }
-        catch (error) {
-            console.error('Failed to initialize file mappings:', error);
-        }
-    }
-    handleFileEvent(eventType, filePath, options, debounceMs) {
-        // Only track text/code files
-        if (!this.isTrackableFile(filePath))
-            return;
-        // Clear existing timer
-        const existingTimer = this.debounceTimers.get(filePath);
-        if (existingTimer) {
-            clearTimeout(existingTimer);
-        }
-        // Set new debounced timer
-        const timer = setTimeout(async () => {
-            try {
-                await this.processFileChange(eventType, filePath, options);
-            }
-            catch (error) {
-                console.error(`Failed to process ${eventType} for ${filePath}:`, error);
-            }
-        }, debounceMs);
-        this.debounceTimers.set(filePath, timer);
-    }
-    async processFileChange(eventType, filePath, options) {
-        const { workspaceHandle, verbose } = options;
-        switch (eventType) {
-            case 'add':
-                await this.handleFileAdd(filePath, workspaceHandle, verbose);
-                break;
-            case 'change':
-                await this.handleFileChange(filePath, workspaceHandle, verbose);
-                break;
-            case 'unlink':
-                await this.handleFileDelete(filePath, workspaceHandle, verbose);
-                break;
-        }
-    }
-    async handleFileAdd(filePath, workspaceHandle, verbose) {
-        if (!fs.existsSync(filePath))
-            return;
-        const stat = fs.statSync(filePath);
-        if (stat.isDirectory()) {
-            if (verbose)
-                console.log(`[tracker] Skipping directory: ${filePath}`);
-            return;
-        }
-        try {
-            const content = fs.readFileSync(filePath, 'utf8');
-            const fileName = path.basename(filePath);
-            const hash = this.getContentHash(content);
-            if (verbose) {
-                console.log(`[DEBUG AUTO-TRACKER] Creating file ${fileName}...`);
-            }
-            const mimeType = this.getMimeType(fileName);
-            const canvasType = mimeTypeToCanvasType(mimeType);
-            const documentData = {
-                text: content,
-                metadata: {
-                    type: canvasType, // Required for workspace container routing
-                    originalFilename: fileName
-                }
-            };
-            const documentHandle = await workspaceHandle.file.create(documentData, {
-                name: fileName,
-                mimeType: mimeType
-            });
-            this.filePathToDocumentId.set(filePath, documentHandle.documentId);
-            this.fileHashes.set(filePath, hash);
-            if (verbose) {
-                console.log(`✅ Added file: ${fileName} (${documentHandle.documentId})`);
-            }
-        }
-        catch (error) {
-            console.error(`Failed to add file ${path.basename(filePath)}:`, error);
-        }
-    }
-    async handleFileChange(filePath, workspaceHandle, verbose) {
-        if (!fs.existsSync(filePath))
-            return;
-        try {
-            const content = fs.readFileSync(filePath, 'utf8');
-            const newHash = this.getContentHash(content);
-            const oldHash = this.fileHashes.get(filePath);
-            if (newHash === oldHash)
-                return;
-            const documentId = this.filePathToDocumentId.get(filePath);
-            if (!documentId) {
-                // File not tracked yet, treat as new file
-                await this.handleFileAdd(filePath, workspaceHandle, verbose);
-                return;
-            }
-            const fileName = path.basename(filePath);
-            const mimeType = this.getMimeType(fileName);
-            const canvasType = mimeTypeToCanvasType(mimeType);
-            const documentData = {
-                text: content,
-                metadata: {
-                    type: canvasType, // Required for workspace container routing
-                    originalFilename: fileName
-                }
-            };
-            await workspaceHandle.file.update(documentId, documentData);
-            this.fileHashes.set(filePath, newHash);
-            if (verbose) {
-                const fileName = path.basename(filePath);
-                console.log(`🔄 Updated file: ${fileName}`);
-            }
-        }
-        catch (error) {
-            console.error(`Failed to update file ${path.basename(filePath)}:`, error);
-        }
-    }
-    async handleFileDelete(filePath, workspaceHandle, verbose) {
-        const documentId = this.filePathToDocumentId.get(filePath);
-        if (!documentId)
-            return;
-        try {
-            // For now, clean up local mappings - file.delete() method will be implemented later
-            this.filePathToDocumentId.delete(filePath);
-            this.fileHashes.delete(filePath);
-            if (verbose) {
-                const fileName = path.basename(filePath);
-                console.log(`🗑️ File deleted: ${fileName} (local cleanup completed)`);
-            }
-        }
-        catch (error) {
-            console.error(`Failed to handle deletion of ${path.basename(filePath)}:`, error);
-        }
-    }
-    isTrackableFile(filePath) {
-        const ext = path.extname(filePath).toLowerCase();
-        const 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'
-        ];
-        return trackableExtensions.includes(ext);
-    }
-    getMimeType(fileName) {
-        // Use centralized MIME type detection from mod-core
-        return detectMimeType(fileName);
-    }
-    getContentHash(content) {
-        return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
-    }
-    async disableAutoTracking() {
-        if (!this.isTracking)
-            return;
-        if (this.watcher) {
-            await this.watcher.close();
-            this.watcher = undefined;
-        }
-        // Clear all timers
-        for (const timer of this.debounceTimers.values()) {
-            clearTimeout(timer);
-        }
-        this.debounceTimers.clear();
-        this.isTracking = false;
-        console.log('🛑 Automatic file tracking disabled');
-    }
-    getTrackingStatus() {
-        const capacityUsed = this.watchedFileCount / this.maxWatchedFiles;
-        return {
-            isTracking: this.isTracking,
-            trackedFiles: this.filePathToDocumentId.size,
-            watchedFiles: this.watchedFileCount,
-            maxWatchedFiles: this.maxWatchedFiles,
-            capacityUsed: Math.round(capacityUsed * 100)
-        };
-    }
-    getModIgnoreStats() {
-        return this.modIgnoreService?.getPatternStats() || null;
-    }
-    async checkFileDescriptorLimits() {
-        try {
-            // Get current file descriptor usage (Node.js specific)
-            const fs = await import('fs');
-            // Check if we're approaching system limits by attempting to open a temporary file
-            // This is a simple heuristic since Node.js doesn't expose ulimit directly
-            const testFile = '/tmp/.mod-fd-test';
-            try {
-                fs.writeFileSync(testFile, 'test');
-                fs.unlinkSync(testFile);
-            }
-            catch (error) {
-                console.warn('⚠️ Warning: Potential file descriptor limit approaching');
-                throw new Error('File descriptor limit check failed - consider reducing maxWatchedFiles');
-            }
-        }
-        catch (error) {
-            console.warn('Could not check file descriptor limits:', error);
-        }
-    }
-    validateResourceLimits(trackableFiles) {
-        if (trackableFiles.length > this.maxWatchedFiles) {
-            console.warn(`⚠️ Warning: ${trackableFiles.length} trackable files exceeds limit of ${this.maxWatchedFiles}`);
-            console.warn('⚠️ Consider updating .modignore patterns or increasing maxWatchedFiles limit');
-            const limitedFiles = trackableFiles.slice(0, this.maxWatchedFiles);
-            console.warn(`⚠️ Limiting tracking to first ${this.maxWatchedFiles} files for performance`);
-            return limitedFiles;
-        }
-        return trackableFiles;
-    }
-}

package/dist/services/cli-orchestrator.js

@@ -1,227 +0,0 @@
-import { ThreadService } from '@mod/mod-core/services/thread-service';
-import { BranchableRepo } from '@mod/mod-core/services/branchable-repo';
-import { streamText, stepCountIs } from 'ai';
-import { createOpenAI } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-import { log } from './logger.js';
-function formatItemsToMessages(items, maxMessages = 20) {
-    return items
-        .sort((a, b) => {
-        const aTime = new Date(a.metadata?.createdAt || 0).getTime();
-        const bTime = new Date(b.metadata?.createdAt || 0).getTime();
-        if (aTime !== bTime)
-            return aTime - bTime;
-        return String(a.id || '').localeCompare(String(b.id || ''));
-    })
-        .slice(-maxMessages)
-        .map((item) => ({
-        role: item.userType === 'user' ? 'user' : 'assistant',
-        content: item.content,
-    }));
-}
-export async function* chatWithAgentCli({ repo, threadId, userMessage, user = { id: 'user-1', name: 'You', avatarUrl: '' }, workspace, agent, files = [], images = [], maxMessages = 20, tools = {}, apiKey, provider, modelName, ...opts }) {
-    const threadService = new ThreadService(repo);
-    // 1. Load thread and history
-    const thread = await threadService.getThread(threadId);
-    const items = await Promise.all((thread.itemIds || []).map((id) => threadService.getThreadItem(id)));
-    // 2. Prepare messages and persist user message
-    let messages = formatItemsToMessages(items, maxMessages);
-    messages = [...messages, { role: 'user', content: userMessage }];
-    // 3. Build session context with branch and task information
-    const context = await buildCLISessionContext({
-        repo,
-        threadId,
-        workspace,
-        user,
-        files,
-        images,
-        items,
-        agent
-    });
-    const instructions = typeof agent?.instructions === 'function' ? await agent.instructions(context) : (agent?.instructions || `You are ${agent?.name || 'Assistant'}. Help the user with their request.`);
-    const resolvedApiKey = (apiKey || process.env.OPENAI_API_KEY || process.env.OPENAI_API_TOKEN || process.env.OPENAI || process.env.ANTHROPIC_API_KEY || '').trim();
-    const selectedProvider = provider || opts.provider || 'openai';
-    let selectedModel = modelName || opts.modelName || agent?.defaultModel || 'gpt-4o';
-    // Normalize common aliases to real provider model IDs
-    if (selectedProvider === 'openai' && /^gpt-5\b/i.test(selectedModel)) {
-        selectedModel = 'gpt-4o';
-    }
-    const model = selectedProvider === 'openai'
-        ? createOpenAI({ apiKey: resolvedApiKey })(selectedModel)
-        : anthropic(selectedModel);
-    // Merge and wrap tools with context injection (so tool.execute receives context)
-    const mergedTools = {
-        ...(agent?.tools || {}),
-        ...(tools || {}),
-    };
-    const aiSDKTools = injectContextIntoTools(mergedTools, context);
-    // Debug logs for visibility
-    try {
-        log('[CLI Orchestrator] Provider:', selectedProvider);
-        log('[CLI Orchestrator] Model:', selectedModel);
-        log('[CLI Orchestrator] Instructions (first 200):', String(instructions || '').slice(0, 200));
-        log('[CLI Orchestrator] Tools:', Object.keys(aiSDKTools));
-        log('[CLI Orchestrator] Messages:', messages);
-    }
-    catch { }
-    const maxAgentSteps = Math.max(1, opts?.maxSteps ?? 6);
-    let lastAssistantItemId;
-    let lastReasoningItemId;
-    const processedToolResultIds = new Set();
-    async function* processStream(stream) {
-        const iter = stream.fullStream ?? stream.textStream ?? stream;
-        for await (const part of iter) {
-            const partType = part.type;
-            if (partType === 'reasoning' ||
-                partType === 'reasoning-delta' ||
-                partType === 'reasoning-start' ||
-                partType === 'reasoning-end' ||
-                partType === 'reasoning-part-delta' ||
-                partType === 'reasoning-part-finish') {
-                const delta = part.text || part.delta || '';
-                if (delta && delta.length > 0) {
-                    if (!lastReasoningItemId) {
-                        const item = await threadService.addReasoningToThread(threadId, delta, agent?.name || 'Assistant', agent?.iconUrl);
-                        lastReasoningItemId = item.id;
-                    }
-                    else {
-                        await threadService.addChunkToThreadItem(lastReasoningItemId, delta);
-                    }
-                }
-                yield { type: 'reasoning', content: delta };
-                continue;
-            }
-            if (part.type === 'text' || typeof part === 'string') {
-                const content = typeof part === 'string' ? part : part.text;
-                if (content) {
-                    if (!lastAssistantItemId) {
-                        const item = await threadService.addAssistantMessageToThread(threadId, content, agent?.name || 'Assistant', agent?.iconUrl);
-                        lastAssistantItemId = item.id;
-                    }
-                    else {
-                        await threadService.addChunkToThreadItem(lastAssistantItemId, content);
-                    }
-                }
-                yield { type: 'content', content };
-                continue;
-            }
-            if (part.type === 'tool-call') {
-                await threadService.addToolCallToThread(threadId, part, agent?.name || 'Assistant', agent?.iconUrl);
-                yield part;
-                continue;
-            }
-            if (part.type === 'tool-result') {
-                const toolCallId = String(part?.toolCallId || part?.id || `tool-${Date.now()}`);
-                if (toolCallId && processedToolResultIds.has(toolCallId)) {
-                    try {
-                        log('[CLI Orchestrator] duplicate tool-result skipped', toolCallId);
-                    }
-                    catch { }
-                }
-                else {
-                    if (toolCallId)
-                        processedToolResultIds.add(toolCallId);
-                    await threadService.addToolResultToThread(threadId, part, agent?.name || 'Assistant', agent?.iconUrl);
-                }
-                yield { type: 'tool-result', output: part };
-                continue;
-            }
-            if (part.type === 'error') {
-                yield { type: 'error', error: part.error };
-            }
-        }
-        try {
-            const summary = await stream.reasoningText?.catch(() => undefined);
-            if (summary && summary.trim().length > 0) {
-                if (!lastReasoningItemId) {
-                    const item = await threadService.addReasoningToThread(threadId, summary, agent?.name || 'Assistant', agent?.iconUrl);
-                    lastReasoningItemId = item.id;
-                }
-                else {
-                    await threadService.addChunkToThreadItem(lastReasoningItemId, summary);
-                }
-                yield { type: 'reasoning', content: summary };
-            }
-        }
-        catch { }
-    }
-    const stream = streamText({
-        model,
-        system: instructions,
-        tools: aiSDKTools,
-        messages,
-        stopWhen: stepCountIs(maxAgentSteps),
-    });
-    yield* processStream(stream);
-}
-function injectContextIntoTools(tools, context) {
-    const wrapped = {};
-    for (const [name, tool] of Object.entries(tools || {})) {
-        if (!tool || typeof tool !== 'object')
-            continue;
-        const exec = tool.execute;
-        if (exec && exec.constructor?.name === 'AsyncGeneratorFunction') {
-            wrapped[name] = {
-                ...tool,
-                async *execute(args) {
-                    const result = exec.call(tool, { ...(args || {}), context });
-                    for await (const chunk of result)
-                        yield chunk;
-                },
-            };
-        }
-        else if (typeof exec === 'function') {
-            wrapped[name] = {
-                ...tool,
-                async execute(args) {
-                    return exec.call(tool, { ...(args || {}), context });
-                },
-            };
-        }
-        else {
-            // If it already looks like an ai tool with parameters, keep as-is
-            wrapped[name] = tool;
-        }
-    }
-    return wrapped;
-}
-async function buildCLISessionContext({ repo, threadId, workspace, user, files = [], images = [], items, agent }) {
-    // Get branch context
-    const branchableRepo = new BranchableRepo(repo);
-    let activeBranch = undefined;
-    let activeThread = undefined;
-    try {
-        const branchCtx = await branchableRepo.getBranchContext(workspace.id);
-        if (branchCtx && branchCtx.activeBranchId && branchCtx.branchesDocId) {
-            const branchService = branchableRepo.getBranchService();
-            activeBranch = await branchService.getBranch(branchCtx.activeBranchId, branchCtx.branchesDocId);
-            // Get active task ID for this branch
-            const activeTaskId = await branchService.getActiveTaskId(branchCtx.activeBranchId, branchCtx.branchesDocId).catch(() => null);
-            // Build active thread context
-            activeThread = {
-                id: threadId,
-                name: 'CLI Thread',
-                branchId: activeBranch?.id || branchCtx.activeBranchId,
-                tasksDocId: activeTaskId,
-                metadata: {
-                    type: 'thread',
-                },
-            };
-        }
-    }
-    catch (e) {
-        console.warn('[CLI SessionContext] Could not fetch active branch:', e);
-    }
-    return {
-        repo,
-        user,
-        activeWorkspace: workspace, // Expected by tools
-        workspace, // For compatibility
-        agent,
-        files,
-        images,
-        items,
-        ...(activeBranch ? { activeBranch } : {}),
-        ...(activeThread ? { activeThread } : {}),
-    };
-}