mcp-coordinator 0.4.0 → 0.5.0

package/dist/src/tree-sitter-extractor.d.ts

@@ -0,0 +1,36 @@
+import type { Metrics } from "./metrics.js";
+/**
+ * Tree-sitter symbol extractor.
+ *
+ * Loads grammars asynchronously at boot. extract() runs synchronously per call
+ * so it slots into the existing synchronous file_activity ingest path.
+ *
+ * Naming table per language documented in the v0.6 spec:
+ * - top-level fn / arrow assigned to const → `name`
+ * - class member  → `Class.method`
+ * - anonymous default export → `<file_basename>:default`
+ * - re-exports, anonymous IIFE → not emitted
+ */
+export declare class TreeSitterExtractor {
+    private grammars;
+    private ready;
+    private grammarsLoaded;
+    private totalGrammars;
+    private metrics?;
+    constructor(metrics?: Metrics);
+    load(): Promise<void>;
+    status(): {
+        ok: boolean;
+        grammars_loaded: number;
+        total_grammars: number;
+        optional: true;
+    };
+    /**
+     * Extract qualified symbol names from `content`. Returns null on parse
+     * failure, unsupported extension, or grammar not loaded.
+     * Caps output at 200 entries (per spec).
+     */
+    extract(filePath: string, content: string, _changedRanges: Array<[number, number]> | null): string[] | null;
+    private extToKey;
+    private walk;
+}

package/dist/src/tree-sitter-extractor.js

@@ -0,0 +1,354 @@
+import path from "path";
+// ---------------------------------------------------------------------------
+// Go receiver helpers (module-level so HANDLERS closure can reference them)
+// ---------------------------------------------------------------------------
+function goReceiverType(recv) {
+    if (!recv)
+        return null;
+    for (let i = 0; i < recv.namedChildCount; i++) {
+        const found = findGoTypeIdent(recv.namedChild(i));
+        if (found)
+            return found;
+    }
+    return null;
+}
+function findGoTypeIdent(node) {
+    if (!node)
+        return null;
+    if (node.type === "type_identifier")
+        return node.text;
+    if (node.type === "pointer_type") {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const found = findGoTypeIdent(node.namedChild(i));
+            if (found)
+                return found;
+        }
+    }
+    if (node.type === "parameter_declaration") {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child.type !== "identifier") {
+                const found = findGoTypeIdent(child);
+                if (found)
+                    return found;
+            }
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// HANDLERS registry — one entry per language key
+// ---------------------------------------------------------------------------
+const HANDLERS = {
+    ts: {
+        classNodeTypes: new Set(["class_declaration"]),
+        fnNodeTypes: new Set(["function_declaration", "method_definition"]),
+        varDeclTypes: new Set(["variable_declarator"]),
+        exportStmtTypes: new Set(["export_statement"]),
+    },
+    tsx: {
+        classNodeTypes: new Set(["class_declaration"]),
+        fnNodeTypes: new Set(["function_declaration", "method_definition"]),
+        varDeclTypes: new Set(["variable_declarator"]),
+        exportStmtTypes: new Set(["export_statement"]),
+    },
+    js: {
+        classNodeTypes: new Set(["class_declaration"]),
+        fnNodeTypes: new Set(["function_declaration", "method_definition"]),
+        varDeclTypes: new Set(["variable_declarator"]),
+        exportStmtTypes: new Set(["export_statement"]),
+    },
+    py: {
+        classNodeTypes: new Set(["class_definition"]),
+        fnNodeTypes: new Set(["function_definition"]),
+    },
+    go: {
+        classNodeTypes: new Set(),
+        fnNodeTypes: new Set(["function_declaration", "method_declaration"]),
+        extractFnName: (node, rawName, classCtx, _ctx) => {
+            if (node.type === "method_declaration") {
+                const recv = node.childForFieldName?.("receiver");
+                const recvType = goReceiverType(recv);
+                if (recvType && rawName)
+                    return `${recvType}.${rawName}`;
+                return rawName;
+            }
+            if (classCtx && rawName)
+                return `${classCtx}.${rawName}`;
+            return rawName;
+        },
+    },
+    rust: {
+        classNodeTypes: new Set(),
+        fnNodeTypes: new Set(["function_item"]),
+        containerNodeTypes: new Set(["impl_item"]),
+        extractContainerName: (node) => node.childForFieldName?.("type")?.text ?? null,
+    },
+    java: {
+        classNodeTypes: new Set(["class_declaration"]),
+        fnNodeTypes: new Set(["method_declaration"]),
+    },
+    cs: {
+        classNodeTypes: new Set(["class_declaration", "interface_declaration", "struct_declaration", "record_declaration"]),
+        fnNodeTypes: new Set(["method_declaration", "constructor_declaration", "property_declaration"]),
+        containerNodeTypes: new Set(["namespace_declaration"]),
+        extractContainerName: (_node) => null,
+    },
+    c: {
+        // C: function name lives in declarator field, not "name" field
+        classNodeTypes: new Set(),
+        fnNodeTypes: new Set(["function_definition"]),
+        extractFnName: (node, _rawName, classCtx, _ctx) => {
+            // function_definition -> declarator (function_declarator) -> declarator (identifier)
+            const decl = node.childForFieldName?.("declarator");
+            const name = decl?.childForFieldName?.("declarator")?.text ?? decl?.namedChild?.(0)?.text ?? null;
+            if (name && classCtx)
+                return `${classCtx}.${name}`;
+            return name;
+        },
+    },
+    cpp: {
+        // C++: class_specifier has "name" field; function name via declarator chain
+        classNodeTypes: new Set(["class_specifier", "struct_specifier"]),
+        fnNodeTypes: new Set(["function_definition"]),
+        extractFnName: (node, _rawName, classCtx, _ctx) => {
+            const decl = node.childForFieldName?.("declarator");
+            const name = decl?.childForFieldName?.("declarator")?.text ?? decl?.namedChild?.(0)?.text ?? null;
+            if (name && classCtx)
+                return `${classCtx}.${name}`;
+            return name;
+        },
+    },
+    ruby: {
+        classNodeTypes: new Set(["class"]),
+        fnNodeTypes: new Set(["method", "singleton_method"]),
+        containerNodeTypes: new Set(["module"]),
+        extractContainerName: (node) => node.childForFieldName?.("name")?.text ?? null,
+    },
+    php: {
+        classNodeTypes: new Set(["class_declaration", "interface_declaration", "trait_declaration"]),
+        fnNodeTypes: new Set(["method_declaration", "function_definition"]),
+        containerNodeTypes: new Set(["namespace_definition"]),
+        extractContainerName: (_node) => null,
+    },
+    kotlin: {
+        // Kotlin: class/object have no "name" field — use namedChild(0) (type_identifier)
+        // function_declaration has no "name" field — use namedChild(0) (simple_identifier)
+        classNodeTypes: new Set(),
+        fnNodeTypes: new Set(["function_declaration"]),
+        containerNodeTypes: new Set(["class_declaration", "object_declaration"]),
+        extractContainerName: (node) => node.namedChild(0)?.text ?? null,
+        extractFnName: (node, _rawName, classCtx, _ctx) => {
+            const name = node.namedChild(0)?.text ?? null;
+            if (name && classCtx)
+                return `${classCtx}.${name}`;
+            return name;
+        },
+    },
+    swift: {
+        classNodeTypes: new Set(["class_declaration", "struct_declaration", "protocol_declaration"]),
+        fnNodeTypes: new Set(["function_declaration"]),
+        containerNodeTypes: new Set(["extension_declaration"]),
+        extractContainerName: (node) => node.childForFieldName?.("type")?.text
+            ?? node.namedChild(0)?.text
+            ?? null,
+    },
+    bash: {
+        classNodeTypes: new Set(),
+        fnNodeTypes: new Set(["function_definition"]),
+    },
+};
+/**
+ * Tree-sitter symbol extractor.
+ *
+ * Loads grammars asynchronously at boot. extract() runs synchronously per call
+ * so it slots into the existing synchronous file_activity ingest path.
+ *
+ * Naming table per language documented in the v0.6 spec:
+ * - top-level fn / arrow assigned to const → `name`
+ * - class member  → `Class.method`
+ * - anonymous default export → `<file_basename>:default`
+ * - re-exports, anonymous IIFE → not emitted
+ */
+export class TreeSitterExtractor {
+    grammars = new Map();
+    ready = false;
+    grammarsLoaded = 0;
+    totalGrammars = 15;
+    metrics;
+    constructor(metrics) {
+        this.metrics = metrics;
+    }
+    async load() {
+        const tryLoad = async (key, modName, sub) => {
+            try {
+                const tsMod = await import("tree-sitter").catch(() => null);
+                const langMod = await import(modName).catch(() => null);
+                if (!tsMod || !langMod)
+                    return;
+                const Parser = tsMod.default || tsMod;
+                const parser = new Parser();
+                const langObj = langMod.default || langMod;
+                const language = sub ? langObj[sub] : langObj;
+                if (!language)
+                    return;
+                parser.setLanguage(language);
+                this.grammars.set(key, { parser, language });
+                this.grammarsLoaded++;
+            }
+            catch {
+                // optionalDependency — silently skip when unavailable
+            }
+        };
+        await tryLoad("ts", "tree-sitter-typescript", "typescript");
+        await tryLoad("tsx", "tree-sitter-typescript", "tsx");
+        await tryLoad("js", "tree-sitter-javascript");
+        await tryLoad("py", "tree-sitter-python");
+        await tryLoad("go", "tree-sitter-go");
+        await tryLoad("rust", "tree-sitter-rust");
+        await tryLoad("java", "tree-sitter-java");
+        await tryLoad("cs", "tree-sitter-c-sharp");
+        await tryLoad("c", "tree-sitter-c");
+        await tryLoad("cpp", "tree-sitter-cpp");
+        await tryLoad("ruby", "tree-sitter-ruby");
+        await tryLoad("php", "tree-sitter-php", "php");
+        await tryLoad("kotlin", "tree-sitter-kotlin");
+        await tryLoad("swift", "tree-sitter-swift");
+        await tryLoad("bash", "tree-sitter-bash");
+        this.ready = true;
+    }
+    status() {
+        return {
+            ok: this.ready && this.grammarsLoaded > 0,
+            grammars_loaded: this.grammarsLoaded,
+            total_grammars: this.totalGrammars,
+            optional: true,
+        };
+    }
+    /**
+     * Extract qualified symbol names from `content`. Returns null on parse
+     * failure, unsupported extension, or grammar not loaded.
+     * Caps output at 200 entries (per spec).
+     */
+    extract(filePath, content, _changedRanges) {
+        const ext = path.extname(filePath).toLowerCase();
+        const key = this.extToKey(ext);
+        if (!key)
+            return null;
+        const grammar = this.grammars.get(key);
+        if (!grammar)
+            return null;
+        let tree;
+        try {
+            tree = grammar.parser.parse(content);
+        }
+        catch {
+            this.metrics?.treeSitterParseFailures.inc();
+            return null;
+        }
+        if (!tree || !tree.rootNode || tree.rootNode.hasError) {
+            this.metrics?.treeSitterParseFailures.inc();
+            return null;
+        }
+        const symbols = [];
+        this.walk(tree.rootNode, symbols, key, path.basename(filePath, ext));
+        return symbols.slice(0, 200);
+    }
+    extToKey(ext) {
+        switch (ext) {
+            case ".ts": return "ts";
+            case ".tsx": return "tsx";
+            case ".js":
+            case ".jsx":
+            case ".mjs":
+            case ".cjs": return "js";
+            case ".py": return "py";
+            case ".go": return "go";
+            case ".rs": return "rust";
+            case ".java": return "java";
+            case ".cs": return "cs";
+            case ".c":
+            case ".h": return "c";
+            case ".cpp":
+            case ".cc":
+            case ".cxx":
+            case ".hpp":
+            case ".hh": return "cpp";
+            case ".rb": return "ruby";
+            case ".php": return "php";
+            case ".kt":
+            case ".kts": return "kotlin";
+            case ".swift": return "swift";
+            case ".sh":
+            case ".bash": return "bash";
+            default: return null;
+        }
+    }
+    walk(node, out, lang, basename, classCtx = null) {
+        if (out.length >= 200)
+            return;
+        const handler = HANDLERS[lang];
+        if (!handler)
+            return;
+        const type = node.type;
+        const nameField = handler.classNameField ?? "name";
+        const nameNode = node.childForFieldName?.(nameField);
+        const ctx = { out, lang, basename };
+        // 1. Class-like containers
+        if (handler.classNodeTypes.has(type)) {
+            const className = nameNode?.text ?? null;
+            for (let i = 0; i < node.namedChildCount; i++) {
+                this.walk(node.namedChild(i), out, lang, basename, className);
+            }
+            return;
+        }
+        // 2. Non-class containers (Rust impl, Ruby module, C# namespace, etc.)
+        if (handler.containerNodeTypes?.has(type)) {
+            const containerName = handler.extractContainerName?.(node) ?? null;
+            for (let i = 0; i < node.namedChildCount; i++) {
+                this.walk(node.namedChild(i), out, lang, basename, containerName);
+            }
+            return;
+        }
+        // 3. Function-like leaves
+        if (handler.fnNodeTypes.has(type)) {
+            const rawName = node.childForFieldName?.("name")?.text ?? null;
+            let emitted;
+            if (handler.extractFnName) {
+                emitted = handler.extractFnName(node, rawName, classCtx, ctx);
+            }
+            else {
+                emitted = rawName;
+                if (emitted && classCtx)
+                    emitted = `${classCtx}.${emitted}`;
+            }
+            if (emitted)
+                out.push(emitted);
+            return;
+        }
+        // 4. Variable declarators (const X = () => …)
+        if (handler.varDeclTypes?.has(type)) {
+            const valNode = node.childForFieldName?.("value");
+            if (valNode && (valNode.type === "arrow_function" || valNode.type === "function_expression")) {
+                const name = node.childForFieldName?.("name")?.text;
+                if (name)
+                    out.push(name);
+            }
+            return;
+        }
+        // 5. Anonymous default exports
+        if (handler.exportStmtTypes?.has(type)) {
+            const decl = node.namedChild(0);
+            if (decl && (decl.type === "arrow_function" ||
+                (decl.type === "function_declaration" && !decl.childForFieldName?.("name")))) {
+                out.push(`${basename}:default`);
+                return;
+            }
+            // Named export — fall through to recurse so class/fn inside are captured
+        }
+        // Recurse
+        for (let i = 0; i < node.namedChildCount; i++) {
+            this.walk(node.namedChild(i), out, lang, basename, classCtx);
+        }
+    }
+}

package/dist/src/working-files-tracker.d.ts

@@ -0,0 +1,42 @@
+import { type Logger } from "./logger.js";
+import type { Metrics } from "./metrics.js";
+/**
+ * Tracks files an agent is currently editing (between PreToolUse and
+ * PostToolUse hooks). Distinct from file_activity — that's an append-only
+ * historical log; this is current state with TTL.
+ *
+ * Lifecycle:
+ *   PreToolUse  → start(agent, file, ttlMin)  → UPSERT row
+ *   PostToolUse → stop(agent, file)            → DELETE row
+ *   Sweeper     → sweepExpired()               → DELETE rows past claim_until
+ *   Agent LWT   → clearForAgent(agent)         → DELETE all rows for agent
+ */
+export declare class WorkingFilesTracker {
+    private sweeperHandle;
+    private log;
+    private metrics?;
+    constructor(logger?: Logger, metrics?: Metrics);
+    /**
+     * Start (or refresh) a working-files claim. Idempotent: re-calling with
+     * the same (agent_id, file_path) updates last_activity_at + claim_until
+     * without erroring.
+     */
+    start(agentId: string, filePath: string, ttlMinutes: number): void;
+    /**
+     * Stop a working-files claim. No-op when no row matches (PostToolUse can
+     * arrive after a TTL eviction or before the matching PreToolUse on slow Pre).
+     */
+    stop(agentId: string, filePath: string): void;
+    /** Returns number of rows evicted. */
+    sweepExpired(): number;
+    /** Called when an agent goes offline (MQTT LWT). Returns rows deleted. */
+    clearForAgent(agentId: string): number;
+    /**
+     * Background sweeper. unref() so it doesn't keep the loop alive at shutdown.
+     * Idempotent — second call is a no-op until stopSweeper().
+     */
+    startSweeper(intervalMs?: number): void;
+    stopSweeper(): void;
+    /** Read in-flight files map: file_path → set<agent_id>, excluding caller. */
+    getIndex(filePaths: string[], excludeAgentId: string): Map<string, Set<string>>;
+}

package/dist/src/working-files-tracker.js

@@ -0,0 +1,111 @@
+import { getDb } from "./database.js";
+import { silentLogger } from "./logger.js";
+/**
+ * Tracks files an agent is currently editing (between PreToolUse and
+ * PostToolUse hooks). Distinct from file_activity — that's an append-only
+ * historical log; this is current state with TTL.
+ *
+ * Lifecycle:
+ *   PreToolUse  → start(agent, file, ttlMin)  → UPSERT row
+ *   PostToolUse → stop(agent, file)            → DELETE row
+ *   Sweeper     → sweepExpired()               → DELETE rows past claim_until
+ *   Agent LWT   → clearForAgent(agent)         → DELETE all rows for agent
+ */
+export class WorkingFilesTracker {
+    sweeperHandle = null;
+    log;
+    metrics;
+    constructor(logger, metrics) {
+        this.log = logger || silentLogger;
+        this.metrics = metrics;
+    }
+    /**
+     * Start (or refresh) a working-files claim. Idempotent: re-calling with
+     * the same (agent_id, file_path) updates last_activity_at + claim_until
+     * without erroring.
+     */
+    start(agentId, filePath, ttlMinutes) {
+        const db = getDb();
+        const existing = db.prepare("SELECT 1 FROM working_files WHERE agent_id = ? AND file_path = ?")
+            .get(agentId, filePath);
+        db.prepare(`INSERT INTO working_files (agent_id, file_path, started_at, last_activity_at, claim_until)
+       VALUES (?, ?, strftime('%Y-%m-%dT%H:%M:%SZ', 'now'), strftime('%Y-%m-%dT%H:%M:%SZ', 'now'), strftime('%Y-%m-%dT%H:%M:%SZ', 'now', '+' || CAST(? AS TEXT) || ' minutes'))
+       ON CONFLICT(agent_id, file_path) DO UPDATE SET
+         last_activity_at = strftime('%Y-%m-%dT%H:%M:%SZ', 'now'),
+         claim_until      = strftime('%Y-%m-%dT%H:%M:%SZ', 'now', '+' || CAST(? AS TEXT) || ' minutes')`).run(agentId, filePath, ttlMinutes, ttlMinutes);
+        this.metrics?.workingFilesStarts.inc({ result: existing ? "updated" : "inserted" });
+    }
+    /**
+     * Stop a working-files claim. No-op when no row matches (PostToolUse can
+     * arrive after a TTL eviction or before the matching PreToolUse on slow Pre).
+     */
+    stop(agentId, filePath) {
+        const db = getDb();
+        db.prepare("DELETE FROM working_files WHERE agent_id = ? AND file_path = ?")
+            .run(agentId, filePath);
+    }
+    /** Returns number of rows evicted. */
+    sweepExpired() {
+        const db = getDb();
+        const result = db.prepare("DELETE FROM working_files WHERE claim_until < strftime('%Y-%m-%dT%H:%M:%SZ', 'now')").run();
+        const evicted = Number(result.changes ?? 0);
+        if (this.metrics) {
+            const count = db.prepare("SELECT COUNT(*) AS c FROM working_files").get().c;
+            this.metrics.workingFilesActive.set(count);
+        }
+        return evicted;
+    }
+    /** Called when an agent goes offline (MQTT LWT). Returns rows deleted. */
+    clearForAgent(agentId) {
+        const db = getDb();
+        const result = db.prepare("DELETE FROM working_files WHERE agent_id = ?").run(agentId);
+        return Number(result.changes ?? 0);
+    }
+    /**
+     * Background sweeper. unref() so it doesn't keep the loop alive at shutdown.
+     * Idempotent — second call is a no-op until stopSweeper().
+     */
+    startSweeper(intervalMs = 60000) {
+        if (this.sweeperHandle)
+            return;
+        this.sweeperHandle = setInterval(() => {
+            try {
+                const evicted = this.sweepExpired();
+                if (evicted > 0)
+                    this.log.info({ evicted }, "working_files sweep");
+            }
+            catch (err) {
+                this.log.warn({ err }, "working_files sweep failed");
+            }
+        }, intervalMs);
+        if (typeof this.sweeperHandle.unref === "function")
+            this.sweeperHandle.unref();
+    }
+    stopSweeper() {
+        if (this.sweeperHandle) {
+            clearInterval(this.sweeperHandle);
+            this.sweeperHandle = null;
+        }
+    }
+    /** Read in-flight files map: file_path → set<agent_id>, excluding caller. */
+    getIndex(filePaths, excludeAgentId) {
+        const index = new Map();
+        if (filePaths.length === 0)
+            return index;
+        const db = getDb();
+        const placeholders = filePaths.map(() => "?").join(",");
+        const rows = db.prepare(`SELECT DISTINCT file_path, agent_id FROM working_files
+       WHERE file_path IN (${placeholders})
+         AND agent_id != ?
+         AND claim_until > strftime('%Y-%m-%dT%H:%M:%SZ', 'now')`).all(...filePaths, excludeAgentId);
+        for (const r of rows) {
+            let set = index.get(r.file_path);
+            if (!set) {
+                set = new Set();
+                index.set(r.file_path, set);
+            }
+            set.add(r.agent_id);
+        }
+        return index;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-coordinator",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "mcpName": "io.github.swoofer/mcp-coordinator",
   "description": "Embedded MQTT broker + MCP server for multi-agent coordination",
   "type": "module",
@@ -77,6 +77,23 @@
     "typescript": "^5.7.0",
     "vitest": "^4.1.0"
   },
+  "optionalDependencies": {
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-typescript": "^0.21.2",
+    "tree-sitter-javascript": "^0.21.4",
+    "tree-sitter-python": "^0.21.0",
+    "tree-sitter-go": "^0.21.0",
+    "tree-sitter-rust": "^0.21.2",
+    "tree-sitter-java": "^0.21.0",
+    "tree-sitter-c-sharp": "^0.21.3",
+    "tree-sitter-c": "^0.21.0",
+    "tree-sitter-cpp": "^0.22.0",
+    "tree-sitter-ruby": "^0.21.0",
+    "tree-sitter-php": "^0.22.0",
+    "tree-sitter-kotlin": "^0.3.0",
+    "tree-sitter-swift": "^0.6.0",
+    "tree-sitter-bash": "^0.21.0"
+  },
   "engines": {
     "node": ">=20"
   }