@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/tools/agents.d.ts

@@ -0,0 +1,173 @@
+/**
+ * system.agents — Query the agent catalog
+ * system.workflows — Query the workflow registry
+ *
+ * These tools expose the agent framework catalogs as discoverable MCP tools.
+ */
+export declare const systemAgentsTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            role: {
+                type: string;
+                description: string;
+            };
+            product: {
+                type: string;
+                description: string;
+            };
+            agent_id: {
+                type: string;
+                description: string;
+            };
+            include_persona: {
+                type: string;
+                description: string;
+            };
+            include_permissions: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (input: {
+        role?: string;
+        product?: string;
+        agent_id?: string;
+        include_persona?: boolean;
+        include_permissions?: boolean;
+    }) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        _ai_native: import("../ai-native/envelope.js").AiNativeResponse<{
+            total: number;
+            by_role: Record<string, number>;
+            agents: Record<string, unknown>[];
+        }>;
+    }>;
+};
+export declare const systemWorkflowsTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            workflow_id: {
+                type: string;
+                description: string;
+            };
+            agent_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (input: {
+        workflow_id?: string;
+        agent_id?: string;
+    }) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        _ai_native: import("../ai-native/envelope.js").AiNativeResponse<{
+            total: number;
+            workflows: {
+                workflow_id: string;
+                display_name: string;
+                description: string;
+                agents: string[];
+                trigger: string;
+                step_count: number;
+                steps: {
+                    id: string;
+                    agent: string;
+                    tool: string;
+                    description?: string;
+                    on_go?: string;
+                    on_fix?: string;
+                    on_block?: string;
+                    max_retries?: number;
+                    timeout_secs?: number;
+                    input?: Record<string, unknown>;
+                }[];
+            }[];
+        }>;
+    }>;
+};
+export declare const systemDispatchTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            workflow_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (input: {
+        action: "status" | "trigger" | "history";
+        workflow_id?: string;
+    }) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        _ai_native: import("../ai-native/envelope.js").AiNativeResponse<{
+            autopilot_level: import("../agents/types.js").AutopilotLevel;
+            autopilot_label: string;
+            dispatch_rules_count: number;
+            env_var: string;
+            env_value: string;
+        }>;
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        _ai_native: import("../ai-native/envelope.js").AiNativeResponse<{
+            error: string;
+        }>;
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        _ai_native: import("../ai-native/envelope.js").AiNativeResponse<{
+            decision: string;
+            workflow_id: string;
+            result: import("../agents/types.js").WorkflowResult;
+        }>;
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        _ai_native: import("../ai-native/envelope.js").AiNativeResponse<{
+            decision: import("../agents/types.js").DispatchDecision;
+        }>;
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        _ai_native: import("../ai-native/envelope.js").AiNativeResponse<{
+            total: number;
+            entries: import("../agents/feedback_loop.js").FeedbackEntry[];
+        }>;
+    }>;
+};

package/build/mcp/tools/agents.js

@@ -0,0 +1,303 @@
+/**
+ * system.agents — Query the agent catalog
+ * system.workflows — Query the workflow registry
+ *
+ * These tools expose the agent framework catalogs as discoverable MCP tools.
+ */
+import { readFile } from "fs/promises";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { infoResponse, renderForHuman } from "../ai-native/envelope.js";
+import { dispatch as dispatchSignal, readFeedbackLog, loadDispatchRules, } from "../agents/index.js";
+import { bitnetSignal } from "./bitnet/index.js";
+import { getAutopilotLevel } from "./vibe_pm/autopilot.js";
+import { executeWorkflow } from "../agents/workflow_engine.js";
+import { createToolExecutor } from "../agents/tool_executor.js";
+import { feedbackToSensor } from "../agents/feedback_loop.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CATALOGS_DIR = resolve(__dirname, "../../../catalogs");
+let agentCache = null;
+let workflowCache = null;
+let personaCache = null;
+let permissionCache = null;
+async function loadAgents() {
+    if (agentCache)
+        return agentCache;
+    try {
+        const raw = await readFile(resolve(CATALOGS_DIR, "agents.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        agentCache = parsed.agents;
+        return agentCache;
+    }
+    catch {
+        return [];
+    }
+}
+async function loadWorkflows() {
+    if (workflowCache)
+        return workflowCache;
+    try {
+        const raw = await readFile(resolve(CATALOGS_DIR, "workflows.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        workflowCache = parsed.workflows;
+        return workflowCache;
+    }
+    catch {
+        return [];
+    }
+}
+async function loadPersonas() {
+    if (personaCache)
+        return personaCache;
+    try {
+        const raw = await readFile(resolve(CATALOGS_DIR, "personas.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        personaCache = parsed.personas;
+        return personaCache;
+    }
+    catch {
+        return {};
+    }
+}
+async function loadPermissions() {
+    if (permissionCache)
+        return permissionCache;
+    try {
+        const raw = await readFile(resolve(CATALOGS_DIR, "permissions.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        permissionCache = parsed.permissions;
+        return permissionCache;
+    }
+    catch {
+        return {};
+    }
+}
+// ── system.agents ─────────────────────────────────────────────────────────────
+export const systemAgentsTool = {
+    name: "system.agents",
+    description: "List available AI agents with their roles, tools, and capabilities. Filter by role (orchestrator/executor/gate/risk/observer) or product (vibe_pm/musu/hive/cockpit/system).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            role: {
+                type: "string",
+                description: "Filter by agent role: orchestrator, executor, gate, risk, observer (optional)",
+            },
+            product: {
+                type: "string",
+                description: "Filter by product: vibe_pm, musu, hive, cockpit, system (optional)",
+            },
+            agent_id: {
+                type: "string",
+                description: "Get details for a specific agent by ID (optional)",
+            },
+            include_persona: {
+                type: "boolean",
+                description: "Include system prompt and behavior rules (default: false)",
+            },
+            include_permissions: {
+                type: "boolean",
+                description: "Include tool permission matrix (default: false)",
+            },
+        },
+        required: [],
+    },
+    handler: async (input) => {
+        const agents = await loadAgents();
+        let filtered = agents;
+        if (input.agent_id) {
+            filtered = filtered.filter((a) => a.agent_id === input.agent_id);
+        }
+        if (input.role) {
+            filtered = filtered.filter((a) => a.role === input.role);
+        }
+        if (input.product) {
+            filtered = filtered.filter((a) => a.product === input.product);
+        }
+        // Enrich with persona and permissions if requested
+        let enriched = filtered.map((a) => ({ ...a }));
+        if (input.include_persona || input.include_permissions) {
+            const [personas, permissions] = await Promise.all([
+                input.include_persona
+                    ? loadPersonas()
+                    : Promise.resolve({}),
+                input.include_permissions
+                    ? loadPermissions()
+                    : Promise.resolve({}),
+            ]);
+            enriched = enriched.map((a) => {
+                const id = a.agent_id;
+                if (input.include_persona && personas[id]) {
+                    a.persona = personas[id];
+                }
+                if (input.include_permissions && permissions[id]) {
+                    a.permissions = permissions[id];
+                }
+                return a;
+            });
+        }
+        const byRole = {};
+        for (const a of filtered) {
+            byRole[a.role] = (byRole[a.role] ?? 0) + 1;
+        }
+        const roleSummary = Object.entries(byRole)
+            .map(([r, n]) => `${n} ${r}`)
+            .join(", ");
+        const envelope = infoResponse({
+            total: enriched.length,
+            by_role: byRole,
+            agents: enriched,
+        }, `${enriched.length} agent(s): ${roleSummary}.`);
+        return {
+            content: [{ type: "text", text: renderForHuman(envelope) }],
+            _ai_native: envelope,
+        };
+    },
+};
+// ── system.workflows ──────────────────────────────────────────────────────────
+export const systemWorkflowsTool = {
+    name: "system.workflows",
+    description: "List available multi-agent workflows with their steps, agents, and signal routing. Query a specific workflow by ID for full step details.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            workflow_id: {
+                type: "string",
+                description: "Get details for a specific workflow by ID (optional)",
+            },
+            agent_id: {
+                type: "string",
+                description: "Filter workflows involving a specific agent (optional)",
+            },
+        },
+        required: [],
+    },
+    handler: async (input) => {
+        const workflows = await loadWorkflows();
+        let filtered = workflows;
+        if (input.workflow_id) {
+            filtered = filtered.filter((w) => w.workflow_id === input.workflow_id);
+        }
+        if (input.agent_id) {
+            filtered = filtered.filter((w) => w.agents.includes(input.agent_id));
+        }
+        const summaryLines = filtered.map((w) => ({
+            workflow_id: w.workflow_id,
+            display_name: w.display_name,
+            description: w.description,
+            agents: w.agents,
+            trigger: w.trigger ?? "manual",
+            step_count: w.steps.length,
+            steps: w.steps,
+        }));
+        const envelope = infoResponse({
+            total: filtered.length,
+            workflows: summaryLines,
+        }, `${filtered.length} workflow(s) available.`);
+        return {
+            content: [{ type: "text", text: renderForHuman(envelope) }],
+            _ai_native: envelope,
+        };
+    },
+};
+// ── system.dispatch ──────────────────────────────────────────────────────────
+export const systemDispatchTool = {
+    name: "system.dispatch",
+    description: "Automation dispatcher: check status, trigger signal→workflow dispatch, or view execution history. Controls the Sense→Decide→Act loop (BitNet → Dispatcher → Workflow Engine).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                enum: ["status", "trigger", "history"],
+                description: "status: show autopilot level + last signal. trigger: run dispatch now. history: recent execution log.",
+            },
+            workflow_id: {
+                type: "string",
+                description: "Force a specific workflow ID when action=trigger (optional)",
+            },
+        },
+        required: ["action"],
+    },
+    handler: async (input) => {
+        const basePath = process.cwd();
+        if (input.action === "status") {
+            const level = getAutopilotLevel();
+            const rules = await loadDispatchRules();
+            const levelLabels = {
+                0: "OBSERVE ONLY",
+                1: "SAFE AUTO (code-review-gate)",
+                2: "BUILD AUTO (+ build-and-test)",
+                3: "FULL AUTO (all except submit_decision)",
+            };
+            const envelope = infoResponse({
+                autopilot_level: level,
+                autopilot_label: levelLabels[level] ?? "unknown",
+                dispatch_rules_count: rules.length,
+                env_var: "VIBE_AUTOPILOT",
+                env_value: process.env.VIBE_AUTOPILOT ?? "0",
+            }, `Autopilot Level ${level}: ${levelLabels[level] ?? "unknown"}. ${rules.length} dispatch rules loaded.`);
+            return {
+                content: [{ type: "text", text: renderForHuman(envelope) }],
+                _ai_native: envelope,
+            };
+        }
+        if (input.action === "trigger") {
+            const level = getAutopilotLevel();
+            // Generate fresh BitNet signal
+            let signal;
+            try {
+                signal = await bitnetSignal({
+                    include_autopilot: true,
+                    event_source: "tool",
+                    workspace_root: basePath,
+                });
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                const envelope = infoResponse({ error: errMsg }, `BitNet signal generation failed: ${errMsg}`);
+                return {
+                    content: [{ type: "text", text: renderForHuman(envelope) }],
+                    _ai_native: envelope,
+                };
+            }
+            // Dispatch
+            const decision = await dispatchSignal(signal, level);
+            if (decision.action === "execute" && decision.plan.workflow_id) {
+                const workflowId = input.workflow_id ?? decision.plan.workflow_id;
+                const toolExecutor = createToolExecutor(basePath);
+                const result = await executeWorkflow(workflowId, signal, toolExecutor);
+                await feedbackToSensor(result, basePath);
+                const envelope = infoResponse({ decision: "execute", workflow_id: workflowId, result }, `Executed workflow ${workflowId}: ${result.final_status} (${result.steps.length} steps, ${result.total_duration_ms}ms)`);
+                return {
+                    content: [{ type: "text", text: renderForHuman(envelope) }],
+                    _ai_native: envelope,
+                };
+            }
+            // Non-execute decisions
+            const summaryText = decision.action === "propose"
+                ? `Proposed: ${decision.message}`
+                : decision.action === "block"
+                    ? `Blocked: ${decision.reason}`
+                    : `Skipped: ${decision.reason}`;
+            const envelope = infoResponse({ decision }, summaryText);
+            return {
+                content: [{ type: "text", text: renderForHuman(envelope) }],
+                _ai_native: envelope,
+            };
+        }
+        if (input.action === "history") {
+            const entries = await readFeedbackLog(basePath, 20);
+            const envelope = infoResponse({ total: entries.length, entries }, `${entries.length} recent dispatch execution(s).`);
+            return {
+                content: [{ type: "text", text: renderForHuman(envelope) }],
+                _ai_native: envelope,
+            };
+        }
+        const envelope = infoResponse({ error: `Unknown action: ${input.action}` }, `Unknown action: ${input.action}`);
+        return {
+            content: [{ type: "text", text: renderForHuman(envelope) }],
+            _ai_native: envelope,
+        };
+    },
+};

package/build/mcp/tools/bitnet/api.d.ts

@@ -0,0 +1,166 @@
+/**
+ * BitNet MCP Tools
+ * ================
+ *
+ * AI Auditor Agent for Vibe PM - Pre/Post check middleware.
+ *
+ * Tools:
+ *   - bitnet.check: Run BitNet audit on changed files
+ *   - bitnet.trace: Query audit trace history
+ *
+ * @module mcp/tools/bitnet
+ */
+import { z } from 'zod';
+import { type Plan } from '../../../license-manager.js';
+import type { ProgressReporter } from '../../progress.js';
+import type { McpLogger } from '../../mcp-logger.js';
+import type { BitNetCheckResult } from './types.js';
+import { bitnetCheckInputSchema, bitnetSignalInputSchema, bitnetScoutInputSchema, bitnetScoutOutputSchema, bitnetTraceInputSchema, bitnetTraceOutputSchema } from './schemas.js';
+export declare function bitnetCheck(input: z.infer<typeof bitnetCheckInputSchema>, progress?: ProgressReporter, log?: McpLogger): Promise<BitNetCheckResult>;
+export declare function bitnetTrace(input: z.infer<typeof bitnetTraceInputSchema>): Promise<z.infer<typeof bitnetTraceOutputSchema>>;
+interface CallToolResult {
+    [x: string]: unknown;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    structuredContent?: Record<string, unknown>;
+    isError?: boolean;
+}
+export declare function bitnetCheckHandler(input: z.infer<typeof bitnetCheckInputSchema>, extra?: unknown): Promise<CallToolResult>;
+export declare function bitnetTraceHandler(input: z.infer<typeof bitnetTraceInputSchema>): Promise<CallToolResult>;
+export declare function defineBitNetTools(): {
+    bitnetCheckInputSchema: z.ZodObject<{
+        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        context: z.ZodOptional<z.ZodString>;
+        project_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        context?: string | undefined;
+        files?: string[] | undefined;
+        project_id?: string | undefined;
+    }, {
+        context?: string | undefined;
+        files?: string[] | undefined;
+        project_id?: string | undefined;
+    }>;
+    bitnetTraceInputSchema: z.ZodObject<{
+        trace_id: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        project_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+        project_id?: string | undefined;
+        trace_id?: string | undefined;
+    }, {
+        project_id?: string | undefined;
+        trace_id?: string | undefined;
+        limit?: number | undefined;
+    }>;
+    bitnetCheckHandler: typeof bitnetCheckHandler;
+    bitnetTraceHandler: typeof bitnetTraceHandler;
+};
+export declare const BITNET_TOOL_DESCRIPTIONS: Record<string, string>;
+import type { BitNetSignal } from '../../generated/bitnet_signal.js';
+import { type AutopilotProposal } from '../vibe_pm/autopilot.js';
+/** Extended signal type with tier info */
+type TierInfo = {
+    plan: Plan;
+    concurrent_slots: {
+        used: number;
+        max: number;
+    };
+    pro_features_available: string[];
+};
+/** Extended BitNet signal with tier and autopilot */
+type ExtendedBitNetSignal = BitNetSignal & {
+    autopilot?: AutopilotProposal;
+    tier_info?: TierInfo;
+};
+/**
+ * Generate BitNet Signal for autonomous layer
+ * Combines: risk analysis + state guess + next actions + autopilot proposal
+ */
+export declare function bitnetSignal(input: z.infer<typeof bitnetSignalInputSchema>): Promise<ExtendedBitNetSignal>;
+/**
+ * MCP Tool Handler for bitnet.signal
+ */
+export declare function bitnetSignalHandler(input: z.infer<typeof bitnetSignalInputSchema>): Promise<CallToolResult>;
+/**
+ * Dispatch Scout trigger to Rust worker (`POST /v1/scout/dispatch`).
+ */
+export declare function bitnetScout(input: z.infer<typeof bitnetScoutInputSchema>): Promise<z.infer<typeof bitnetScoutOutputSchema>>;
+/**
+ * MCP Tool Handler for bitnet.scout.
+ */
+export declare function bitnetScoutHandler(input: z.infer<typeof bitnetScoutInputSchema>): Promise<CallToolResult>;
+export declare function defineBitNetToolsV2(): {
+    bitnetCheckInputSchema: z.ZodObject<{
+        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        context: z.ZodOptional<z.ZodString>;
+        project_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        context?: string | undefined;
+        files?: string[] | undefined;
+        project_id?: string | undefined;
+    }, {
+        context?: string | undefined;
+        files?: string[] | undefined;
+        project_id?: string | undefined;
+    }>;
+    bitnetTraceInputSchema: z.ZodObject<{
+        trace_id: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        project_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+        project_id?: string | undefined;
+        trace_id?: string | undefined;
+    }, {
+        project_id?: string | undefined;
+        trace_id?: string | undefined;
+        limit?: number | undefined;
+    }>;
+    bitnetSignalInputSchema: z.ZodObject<{
+        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        context: z.ZodOptional<z.ZodString>;
+        project_id: z.ZodOptional<z.ZodString>;
+        include_autopilot: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        event_source: z.ZodOptional<z.ZodEnum<["tool", "observer", "feedback"]>>;
+        workspace_root: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        include_autopilot: boolean;
+        context?: string | undefined;
+        files?: string[] | undefined;
+        project_id?: string | undefined;
+        event_source?: "tool" | "observer" | "feedback" | undefined;
+        workspace_root?: string | undefined;
+    }, {
+        context?: string | undefined;
+        files?: string[] | undefined;
+        project_id?: string | undefined;
+        include_autopilot?: boolean | undefined;
+        event_source?: "tool" | "observer" | "feedback" | undefined;
+        workspace_root?: string | undefined;
+    }>;
+    bitnetScoutInputSchema: z.ZodObject<{
+        trigger_type: z.ZodEnum<["dep_shift", "auth_touch", "gate_fix"]>;
+        payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        musu_url: z.ZodOptional<z.ZodString>;
+        bearer_token: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        trigger_type: "dep_shift" | "auth_touch" | "gate_fix";
+        payload: Record<string, unknown>;
+        musu_url?: string | undefined;
+        bearer_token?: string | undefined;
+    }, {
+        trigger_type: "dep_shift" | "auth_touch" | "gate_fix";
+        payload: Record<string, unknown>;
+        musu_url?: string | undefined;
+        bearer_token?: string | undefined;
+    }>;
+    bitnetCheckHandler: typeof bitnetCheckHandler;
+    bitnetTraceHandler: typeof bitnetTraceHandler;
+    bitnetSignalHandler: typeof bitnetSignalHandler;
+    bitnetScoutHandler: typeof bitnetScoutHandler;
+};
+export {};