dev-mcp-server 0.0.3 → 1.0.0

package/src/watcher/fileWatcher.js

@@ -0,0 +1,137 @@
+/**
+ * Watches the filesystem for changes and automatically re-ingests
+ * modified files into the knowledge base, keeping the index fresh.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../utils/logger');
+const ingester = require('../core/ingester');
+const indexer = require('../core/indexer');
+const { FILE_TYPE_MAP } = require('../utils/fileParser');
+
+const SUPPORTED_EXTS = new Set(Object.keys(FILE_TYPE_MAP));
+
+// Debounce time — wait this long after last change before re-ingesting
+const DEBOUNCE_MS = 1500;
+
+class FileWatcher {
+    constructor() {
+        this._watchers = new Map();    // dirPath → fs.FSWatcher
+        this._pending = new Map();     // filePath → timeout handle
+        this._stats = { ingested: 0, errors: 0, events: 0 };
+        this._isActive = false;
+    }
+
+    /**
+     * Watch a directory for changes
+     */
+    watch(dirPath, opts = {}) {
+        const abs = path.resolve(dirPath);
+        if (!fs.existsSync(abs)) throw new Error(`Directory not found: ${abs}`);
+        if (this._watchers.has(abs)) return { alreadyWatching: true, path: abs };
+
+        logger.info(`[Watcher] 👁️  Watching: ${abs}`);
+
+        const watcher = fs.watch(abs, { recursive: true }, (event, filename) => {
+            if (!filename) return;
+            const filePath = path.join(abs, filename);
+            const ext = path.extname(filename).toLowerCase();
+
+            // Skip unsupported files and build artifacts
+            if (!SUPPORTED_EXTS.has(ext)) return;
+            if (/node_modules|\.git|dist|build|\.bak/.test(filePath)) return;
+
+            this._stats.events++;
+            this._scheduleIngest(filePath);
+        });
+
+        watcher.on('error', (err) => {
+            logger.error(`[Watcher] Error watching ${abs}: ${err.message}`);
+        });
+
+        this._watchers.set(abs, watcher);
+        this._isActive = true;
+
+        return { watching: true, path: abs };
+    }
+
+    /**
+     * Stop watching a directory
+     */
+    unwatch(dirPath) {
+        const abs = path.resolve(dirPath);
+        const watcher = this._watchers.get(abs);
+        if (!watcher) return false;
+        watcher.close();
+        this._watchers.delete(abs);
+        logger.info(`[Watcher] Stopped watching: ${abs}`);
+        if (this._watchers.size === 0) this._isActive = false;
+        return true;
+    }
+
+    /**
+     * Stop all watchers
+     */
+    stopAll() {
+        for (const [dir, watcher] of this._watchers.entries()) {
+            watcher.close();
+            logger.info(`[Watcher] Stopped: ${dir}`);
+        }
+        this._watchers.clear();
+        for (const handle of this._pending.values()) clearTimeout(handle);
+        this._pending.clear();
+        this._isActive = false;
+    }
+
+    /**
+     * Schedule a debounced ingest for a file
+     */
+    _scheduleIngest(filePath) {
+        // Clear any pending ingest for this file
+        if (this._pending.has(filePath)) {
+            clearTimeout(this._pending.get(filePath));
+        }
+
+        const handle = setTimeout(async () => {
+            this._pending.delete(filePath);
+            await this._ingestFile(filePath);
+        }, DEBOUNCE_MS);
+
+        this._pending.set(filePath, handle);
+    }
+
+    async _ingestFile(filePath) {
+        if (!fs.existsSync(filePath)) {
+            // File deleted — remove from index
+            const store = require('../storage/store');
+            const removed = store.removeByPath(filePath);
+            if (removed > 0) {
+                indexer.invalidate();
+                logger.info(`[Watcher] Removed from index (deleted): ${path.basename(filePath)}`);
+            }
+            return;
+        }
+
+        try {
+            await ingester.ingestFile(filePath);
+            indexer.build();
+            this._stats.ingested++;
+            logger.info(`[Watcher] ♻️  Re-ingested: ${path.basename(filePath)}`);
+        } catch (err) {
+            this._stats.errors++;
+            logger.warn(`[Watcher] Failed to re-ingest ${path.basename(filePath)}: ${err.message}`);
+        }
+    }
+
+    getStatus() {
+        return {
+            isActive: this._isActive,
+            watchedDirs: [...this._watchers.keys()],
+            pendingIngests: this._pending.size,
+            stats: { ...this._stats },
+        };
+    }
+}
+
+module.exports = new FileWatcher();

package/src/worktrees/worktreeManager.js

@@ -0,0 +1,176 @@
+'use strict';
+/**
+ * Git worktrees let you check out a branch into a separate directory,
+ * letting agents work on risky changes without touching your main working tree.
+ *
+ * Workflow:
+ *   1. create(branch, path)   → checkout branch in isolated dir
+ *   2. run agents with cwd = worktree path
+ *   3. diff(name)             → see what changed
+ *   4. merge(name)            → merge back to current branch
+ *   5. remove(name)           → clean up
+ */
+
+const { execSync } = require('child_process');
+const { promisify } = require('util');
+const { exec } = require('child_process');
+const execAsync = promisify(exec);
+const fs = require('fs');
+const path = require('path');
+const logger = require('../utils/logger');
+
+const META_FILE = path.join(process.cwd(), 'data', 'worktrees.json');
+
+const run = async (cmd, cwd) => {
+    const { stdout, stderr } = await execAsync(cmd, { cwd: cwd || process.cwd(), timeout: 30000 });
+    return (stdout || '').trim();
+};
+
+class WorktreeManager {
+    constructor() {
+        this._worktrees = this._load();
+    }
+
+    _load() {
+        try { if (fs.existsSync(META_FILE)) return JSON.parse(fs.readFileSync(META_FILE, 'utf-8')); } catch { }
+        return {};
+    }
+    _save() { fs.writeFileSync(META_FILE, JSON.stringify(this._worktrees, null, 2)); }
+
+    /**
+     * Create a new worktree from a branch (creates branch if it doesn't exist)
+     */
+    async create(name, branch, opts = {}) {
+        const { cwd = process.cwd(), createBranch = true } = opts;
+
+        if (this._worktrees[name]) throw new Error(`Worktree "${name}" already exists`);
+
+        const worktreePath = path.join(os_tmpdir(), 'mcp-worktrees', name);
+        fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
+
+        // Check if branch exists
+        const branchExists = await run(`git branch --list "${branch}"`, cwd);
+        let addCmd;
+        if (!branchExists && createBranch) {
+            addCmd = `git worktree add -b "${branch}" "${worktreePath}"`;
+        } else {
+            addCmd = `git worktree add "${worktreePath}" "${branch}"`;
+        }
+
+        logger.info(`[Worktree] Creating: ${name} → ${worktreePath} (${branch})`);
+        await run(addCmd, cwd);
+
+        const entry = {
+            name,
+            branch,
+            path: worktreePath,
+            sourceCwd: cwd,
+            createdAt: new Date().toISOString(),
+            status: 'active',
+        };
+        this._worktrees[name] = entry;
+        this._save();
+
+        return entry;
+    }
+
+    /**
+     * List all worktrees
+     */
+    async list(cwd = process.cwd()) {
+        // Merge local metadata with git's actual worktree list
+        let gitList = [];
+        try {
+            const out = await run('git worktree list --porcelain', cwd);
+            const entries = out.split('\n\n').filter(Boolean);
+            gitList = entries.map(e => {
+                const lines = e.split('\n');
+                const p = lines.find(l => l.startsWith('worktree '))?.slice(9);
+                const b = lines.find(l => l.startsWith('branch '))?.slice(7);
+                return { path: p, branch: b };
+            });
+        } catch { }
+
+        return Object.values(this._worktrees).map(wt => ({
+            ...wt,
+            exists: fs.existsSync(wt.path),
+            gitTracked: gitList.some(g => g.path === wt.path),
+        }));
+    }
+
+    /**
+     * Get a worktree by name
+     */
+    get(name) {
+        return this._worktrees[name] || null;
+    }
+
+    /**
+     * Show diff between worktree and its base branch
+     */
+    async diff(name) {
+        const wt = this._worktrees[name];
+        if (!wt) throw new Error(`Worktree not found: ${name}`);
+        const diff = await run('git diff HEAD', wt.path);
+        const status = await run('git status --short', wt.path);
+        return { name, branch: wt.branch, diff, status, path: wt.path };
+    }
+
+    /**
+     * Get the git log for a worktree (commits made in it)
+     */
+    async log(name, limit = 5) {
+        const wt = this._worktrees[name];
+        if (!wt) throw new Error(`Worktree not found: ${name}`);
+        return run(`git log --oneline -${limit}`, wt.path);
+    }
+
+    /**
+     * Remove a worktree (prune from git + delete dir)
+     */
+    async remove(name, opts = {}) {
+        const { force = false } = opts;
+        const wt = this._worktrees[name];
+        if (!wt) throw new Error(`Worktree not found: ${name}`);
+
+        logger.info(`[Worktree] Removing: ${name}`);
+
+        try {
+            const forceFlag = force ? '--force' : '';
+            await run(`git worktree remove ${forceFlag} "${wt.path}"`, wt.sourceCwd);
+        } catch (e) {
+            if (force && fs.existsSync(wt.path)) {
+                fs.rmSync(wt.path, { recursive: true, force: true });
+            }
+        }
+
+        // Clean up branch if it was auto-created and not merged
+        delete this._worktrees[name];
+        this._save();
+
+        return { success: true, name, path: wt.path };
+    }
+
+    /**
+     * Stage and commit all changes in a worktree
+     */
+    async commit(name, message) {
+        const wt = this._worktrees[name];
+        if (!wt) throw new Error(`Worktree not found: ${name}`);
+        await run('git add .', wt.path);
+        const result = await run(`git commit -m "${message || 'MCP agent changes'}"`, wt.path);
+        return { name, result };
+    }
+
+    getStats() {
+        const wts = Object.values(this._worktrees);
+        return { total: wts.length, active: wts.filter(w => fs.existsSync(w.path)).length };
+    }
+}
+
+// Simple os tmpdir helper
+function os_tmpdir() {
+    return require('os').tmpdir();
+}
+
+module.exports = new WorktreeManager();