@vibecodetown/mcp-server 1.3.1

package/build/mcp/index.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+// MVP Core Clinic - MCP Server
+// Tool count varies by VIBE_PROFILE (default: all)
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { fileURLToPath } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerAllTools } from "./tool-registry.js";
+import { parseTransportArgs, startHttpTransport } from "./transport/index.js";
+import { startEventLoop } from "./events/index.js";
+import { initPooledMapperClient } from "../mapper-worker/index.js";
+import { startAllComponents, registerShutdownHandlers, logStartupSummary, getDisabledComponents, } from "../startup/index.js";
+import { checkVersion, sendUsagePing, getClientId, needsUpdate, hasNewerVersion, } from "../coordinator/index.js";
+/**
+ * Vibe PM MCP Server
+ *
+ * Transport modes:
+ * - stdio (default): Standard I/O transport for Claude Desktop
+ * - http: HTTP transport for K8s deployment
+ *
+ * CLI Arguments:
+ *   --transport=http|stdio  (default: stdio)
+ *   --port=3000             (HTTP port, default: 3000)
+ *   --host=0.0.0.0          (HTTP host, default: 127.0.0.1)
+ *
+ * Environment Variables:
+ *   MCP_TRANSPORT=http|stdio
+ *   MCP_PORT=3000
+ *   MCP_HOST=0.0.0.0
+ *
+ * Profile-based tool loading:
+ * - VIBE_PROFILE=mvp    → 8 tools (최소)
+ * - VIBE_PROFILE=coding → 19 tools
+ * - VIBE_PROFILE=all    → all tools (기본값)
+ *
+ * See profile-config.ts for full profile definitions.
+ */
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SERVER_VERSION = (() => {
+    try {
+        const pkgPath = path.join(__dirname, "..", "package.json");
+        const raw = fs.readFileSync(pkgPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+})();
+console.error(`[vibe-pm] MVP Core v${SERVER_VERSION}`);
+// ============================================================
+// Version check and usage tracking (non-blocking)
+// ============================================================
+let cachedVersionInfo = null;
+async function checkVersionAsync() {
+    cachedVersionInfo = await checkVersion();
+    if (cachedVersionInfo) {
+        if (needsUpdate(SERVER_VERSION, cachedVersionInfo.minimum)) {
+            console.error(`[vibe-pm] ⚠️ Update required: v${SERVER_VERSION} → v${cachedVersionInfo.latest}`);
+            console.error(`[vibe-pm] Minimum supported: v${cachedVersionInfo.minimum}`);
+        }
+        else if (hasNewerVersion(SERVER_VERSION, cachedVersionInfo.latest)) {
+            console.error(`[vibe-pm] New version available: v${cachedVersionInfo.latest}`);
+        }
+    }
+}
+async function sendStartupPing() {
+    // Only ping once per day (simple dedup using env marker)
+    const today = new Date().toISOString().slice(0, 10);
+    const lastPingMarker = process.env._VIBE_LAST_PING;
+    if (lastPingMarker === today) {
+        return; // Already pinged today
+    }
+    // Set marker for this process
+    process.env._VIBE_LAST_PING = today;
+    await sendUsagePing({
+        client_id: getClientId(),
+        version: SERVER_VERSION,
+        events: [{ type: "mcp_start", count: 1 }],
+        plan: "FREE", // TODO: get from license manager
+        os: os.platform(),
+        arch: os.arch(),
+    });
+}
+const server = new McpServer({
+    name: "vibe-pm",
+    version: SERVER_VERSION
+});
+// MVP 도구 정의 (lazy import 기반)
+await registerAllTools(server);
+// ============================================================
+// Start all optional components (unified startup)
+//
+// Environment variables:
+//   VIBE_OBSERVER=1          - File system observer
+//   VIBE_MAPPER_POOL_ENABLED=1 - Mapper worker pool
+//   VIBE_BITNET_WORKER=1     - BitNet HTTP worker (standalone)
+//   VIBE_BITNET_POOL=1       - BitNet worker pool
+//   VIBE_BITNET_SERVER=1     - LlamaServer daemon
+//   VIBE_DASHBOARD=1         - Local dashboard server
+//   VIBE_MUSU=1              - Musu AI engine
+// ============================================================
+// Start event loop (file watcher based). MQ is optional; SSOT is file.
+let eventLoop = null;
+const startupResult = await startAllComponents();
+// Initialize event loop after components (uses workspace root = cwd)
+try {
+    eventLoop = startEventLoop(process.cwd());
+}
+catch (e) {
+    console.error(`[vibe-pm] Event loop start failed: ${e instanceof Error ? e.message : String(e)}`);
+}
+// Initialize pooled mapper client if mapper pool started
+const mapperPoolStatus = startupResult.components.find(c => c.name === "MapperPool");
+if (mapperPoolStatus?.running) {
+    try {
+        // Dynamically import to get the pool handle
+        const { getMapperPool } = await import("../mapper-worker/index.js");
+        const pool = getMapperPool();
+        if (pool) {
+            initPooledMapperClient(pool);
+        }
+    }
+    catch {
+        // Ignore - pool client init is optional
+    }
+}
+// Log startup summary
+logStartupSummary(startupResult);
+// Log disabled components hint
+const disabled = getDisabledComponents();
+if (disabled.length > 0) {
+    console.error(`[vibe-pm] Disabled: ${disabled.join(", ")}`);
+}
+// Register graceful shutdown handlers
+registerShutdownHandlers();
+// ============================================================
+// Start transport (HTTP or stdio)
+// ============================================================
+const transportOpts = parseTransportArgs();
+if (transportOpts.transport === "http") {
+    // HTTP mode for K8s deployment
+    const httpHandle = await startHttpTransport(server, {
+        port: transportOpts.port,
+        host: transportOpts.host,
+        version: SERVER_VERSION,
+    });
+    console.error(`[vibe-pm] MCP Server ready (HTTP mode)`);
+    console.error(`[vibe-pm] Endpoints:`);
+    console.error(`  GET  ${httpHandle.url}/healthz     - Liveness probe`);
+    console.error(`  GET  ${httpHandle.url}/readyz      - Readiness probe`);
+    console.error(`  GET  ${httpHandle.url}/mcp/tools   - List tools`);
+    console.error(`  POST ${httpHandle.url}/mcp/call    - Call tool`);
+    // Handle shutdown
+    process.on("SIGTERM", async () => {
+        console.error("[vibe-pm] SIGTERM received, shutting down...");
+        await eventLoop?.stop();
+        await httpHandle.close();
+        process.exit(0);
+    });
+    process.on("SIGINT", async () => {
+        console.error("[vibe-pm] SIGINT received, shutting down...");
+        await eventLoop?.stop();
+        await httpHandle.close();
+        process.exit(0);
+    });
+}
+else {
+    // stdio mode (default) for Claude Desktop
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`[vibe-pm] MCP Server ready (stdio mode)`);
+}
+// Graceful shutdown for stdio mode
+process.on("SIGINT", async () => {
+    await eventLoop?.stop();
+});
+process.on("SIGTERM", async () => {
+    await eventLoop?.stop();
+});
+// Non-blocking version check and usage ping
+Promise.all([
+    checkVersionAsync().catch(() => { }),
+    sendStartupPing().catch(() => { }),
+]).catch(() => { });

package/build/mcp/legacy_alias.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Legacy tool name → new vibe_pm.* tool name mapping
+ *
+ * These aliases are maintained for backward compatibility with existing clients.
+ * All legacy tools are deprecated and will be removed in a future version.
+ */
+export declare const LEGACY_ALIAS_MAPPING: Record<string, string>;
+/**
+ * Generate [DEPRECATED] description for legacy alias tools
+ */
+export declare function getLegacyDescription(legacyName: string, newName: string): string;
+/**
+ * Check if a tool name is a legacy alias
+ */
+export declare function isLegacyAlias(toolName: string): boolean;
+/**
+ * Resolve legacy tool name to new tool name
+ * Returns the original name if not a legacy alias
+ */
+export declare function resolveLegacyTool(toolName: string): string;
+/**
+ * Get all legacy alias names
+ */
+export declare function getLegacyAliasNames(): string[];
+/**
+ * Get the new tool name for a legacy alias
+ * Returns undefined if not a legacy alias
+ */
+export declare function getNewToolName(legacyName: string): string | undefined;

package/build/mcp/legacy_alias.js

@@ -0,0 +1,53 @@
+// src/mcp/legacy_alias.ts
+// Legacy tool name → vibe_pm.* mapping for backward compatibility
+// Spec: MCP_TOOL_SCHEMA_SPEC.md Section 3
+/**
+ * Legacy tool name → new vibe_pm.* tool name mapping
+ *
+ * These aliases are maintained for backward compatibility with existing clients.
+ * All legacy tools are deprecated and will be removed in a future version.
+ */
+export const LEGACY_ALIAS_MAPPING = {
+    // vibecode.* → vibe_pm.*
+    "vibecode.one_loop": "vibe_pm.inspect_code",
+    "vibecode.show_ask_queue": "vibe_pm.get_decision",
+    "vibecode.answer": "vibe_pm.submit_decision",
+    "vibecode.show_decisions": "vibe_pm.status",
+    // spec_high.* → vibe_pm.*
+    "spec_high.clinic_bridge": "vibe_pm.create_work_order",
+    "spec_high.validate": "vibe_pm.inspect_code",
+    // clinic.* → vibe_pm.*
+    "clinic.verify": "vibe_pm.inspect_code",
+};
+/**
+ * Generate [DEPRECATED] description for legacy alias tools
+ */
+export function getLegacyDescription(legacyName, newName) {
+    return `[DEPRECATED] Use ${newName} instead.`;
+}
+/**
+ * Check if a tool name is a legacy alias
+ */
+export function isLegacyAlias(toolName) {
+    return toolName in LEGACY_ALIAS_MAPPING;
+}
+/**
+ * Resolve legacy tool name to new tool name
+ * Returns the original name if not a legacy alias
+ */
+export function resolveLegacyTool(toolName) {
+    return LEGACY_ALIAS_MAPPING[toolName] ?? toolName;
+}
+/**
+ * Get all legacy alias names
+ */
+export function getLegacyAliasNames() {
+    return Object.keys(LEGACY_ALIAS_MAPPING);
+}
+/**
+ * Get the new tool name for a legacy alias
+ * Returns undefined if not a legacy alias
+ */
+export function getNewToolName(legacyName) {
+    return LEGACY_ALIAS_MAPPING[legacyName];
+}

package/build/mcp/metrics/collector.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Prometheus Metrics - Collector Implementation
+ */
+import type { MetricDefinition, MetricLabels, MetricRegistry, AnySample } from "./types.js";
+export declare class MetricCollector implements MetricRegistry {
+    private metrics;
+    private counterLabels;
+    register(definition: MetricDefinition): void;
+    incCounter(name: string, labels?: MetricLabels, value?: number): void;
+    setGauge(name: string, labels: MetricLabels, value: number): void;
+    observeHistogram(name: string, labels: MetricLabels, value: number): void;
+    observeSummary(name: string, labels: MetricLabels, value: number): void;
+    private cleanSummaryObservations;
+    collect(): AnySample[];
+    private collectCounter;
+    private collectGauge;
+    private collectHistogram;
+    private collectSummary;
+    exportText(): string;
+    reset(): void;
+}
+export declare function getGlobalRegistry(): MetricCollector;
+export declare function resetGlobalRegistry(): void;

package/build/mcp/metrics/collector.js

@@ -0,0 +1,270 @@
+/**
+ * Prometheus Metrics - Collector Implementation
+ */
+function labelsToKey(labels) {
+    const keys = Object.keys(labels).sort();
+    if (keys.length === 0)
+        return "";
+    return keys.map((k) => `${k}="${labels[k]}"`).join(",");
+}
+function formatLabels(labels) {
+    const keys = Object.keys(labels).sort();
+    if (keys.length === 0)
+        return "";
+    return `{${keys.map((k) => `${k}="${escapeLabel(labels[k])}"`).join(",")}}`;
+}
+function escapeLabel(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+function findBucketIndex(buckets, value) {
+    for (let i = 0; i < buckets.length; i++) {
+        if (value <= buckets[i])
+            return i;
+    }
+    return buckets.length;
+}
+function calculateQuantile(sortedValues, quantile) {
+    if (sortedValues.length === 0)
+        return 0;
+    if (sortedValues.length === 1)
+        return sortedValues[0];
+    const index = quantile * (sortedValues.length - 1);
+    const lower = Math.floor(index);
+    const upper = Math.ceil(index);
+    if (lower === upper)
+        return sortedValues[lower];
+    const fraction = index - lower;
+    return sortedValues[lower] * (1 - fraction) + sortedValues[upper] * fraction;
+}
+export class MetricCollector {
+    metrics = new Map();
+    counterLabels = new Map();
+    register(definition) {
+        if (this.metrics.has(definition.name))
+            return;
+        switch (definition.type) {
+            case "counter":
+                this.metrics.set(definition.name, { type: "counter", definition: definition, values: new Map() });
+                this.counterLabels.set(definition.name, new Map());
+                break;
+            case "gauge":
+                this.metrics.set(definition.name, { type: "gauge", definition: definition, values: new Map(), labels: new Map() });
+                break;
+            case "histogram":
+                this.metrics.set(definition.name, { type: "histogram", definition: definition, buckets: new Map(), sums: new Map(), counts: new Map(), labels: new Map() });
+                break;
+            case "summary":
+                const summaryDef = definition;
+                this.metrics.set(definition.name, { type: "summary", definition: summaryDef, observations: new Map(), sums: new Map(), counts: new Map(), labels: new Map(), maxAgeMs: summaryDef.maxAgeMs ?? 600000, timestamps: new Map() });
+                break;
+        }
+    }
+    incCounter(name, labels = {}, value = 1) {
+        const metric = this.metrics.get(name);
+        if (!metric || metric.type !== "counter")
+            return;
+        const key = labelsToKey(labels);
+        const current = metric.values.get(key) ?? 0;
+        metric.values.set(key, current + value);
+        const labelsMap = this.counterLabels.get(name);
+        if (labelsMap && !labelsMap.has(key))
+            labelsMap.set(key, labels);
+    }
+    setGauge(name, labels, value) {
+        const metric = this.metrics.get(name);
+        if (!metric || metric.type !== "gauge")
+            return;
+        const key = labelsToKey(labels);
+        metric.values.set(key, value);
+        metric.labels.set(key, labels);
+    }
+    observeHistogram(name, labels, value) {
+        const metric = this.metrics.get(name);
+        if (!metric || metric.type !== "histogram")
+            return;
+        const key = labelsToKey(labels);
+        const bucketCount = metric.definition.buckets.length + 1;
+        if (!metric.buckets.has(key)) {
+            metric.buckets.set(key, new Array(bucketCount).fill(0));
+            metric.sums.set(key, 0);
+            metric.counts.set(key, 0);
+            metric.labels.set(key, labels);
+        }
+        const buckets = metric.buckets.get(key);
+        const bucketIndex = findBucketIndex(metric.definition.buckets, value);
+        for (let i = bucketIndex; i < buckets.length; i++)
+            buckets[i]++;
+        metric.sums.set(key, (metric.sums.get(key) ?? 0) + value);
+        metric.counts.set(key, (metric.counts.get(key) ?? 0) + 1);
+    }
+    observeSummary(name, labels, value) {
+        const metric = this.metrics.get(name);
+        if (!metric || metric.type !== "summary")
+            return;
+        const key = labelsToKey(labels);
+        const now = Date.now();
+        if (!metric.observations.has(key)) {
+            metric.observations.set(key, []);
+            metric.timestamps.set(key, []);
+            metric.sums.set(key, 0);
+            metric.counts.set(key, 0);
+            metric.labels.set(key, labels);
+        }
+        metric.observations.get(key).push(value);
+        metric.timestamps.get(key).push(now);
+        metric.sums.set(key, (metric.sums.get(key) ?? 0) + value);
+        metric.counts.set(key, (metric.counts.get(key) ?? 0) + 1);
+        this.cleanSummaryObservations(metric, key, now);
+    }
+    cleanSummaryObservations(metric, key, now) {
+        const observations = metric.observations.get(key);
+        const timestamps = metric.timestamps.get(key);
+        if (!observations || !timestamps)
+            return;
+        const cutoff = now - metric.maxAgeMs;
+        let removeCount = 0;
+        for (let i = 0; i < timestamps.length; i++) {
+            if (timestamps[i] >= cutoff)
+                break;
+            removeCount++;
+        }
+        if (removeCount > 0) {
+            observations.splice(0, removeCount);
+            timestamps.splice(0, removeCount);
+        }
+    }
+    collect() {
+        const samples = [];
+        for (const storage of this.metrics.values()) {
+            switch (storage.type) {
+                case "counter":
+                    samples.push(this.collectCounter(storage));
+                    break;
+                case "gauge":
+                    samples.push(this.collectGauge(storage));
+                    break;
+                case "histogram":
+                    samples.push(this.collectHistogram(storage));
+                    break;
+                case "summary":
+                    samples.push(this.collectSummary(storage));
+                    break;
+            }
+        }
+        return samples;
+    }
+    collectCounter(storage) {
+        const values = [];
+        const labelsMap = this.counterLabels.get(storage.definition.name);
+        for (const [key, value] of storage.values)
+            values.push({ labels: labelsMap?.get(key) ?? {}, value });
+        return { definition: storage.definition, values };
+    }
+    collectGauge(storage) {
+        const values = [];
+        for (const [key, value] of storage.values)
+            values.push({ labels: storage.labels.get(key) ?? {}, value });
+        return { definition: storage.definition, values };
+    }
+    collectHistogram(storage) {
+        const values = [];
+        for (const [key, bucketCounts] of storage.buckets) {
+            const buckets = [];
+            for (let i = 0; i < storage.definition.buckets.length; i++)
+                buckets.push({ le: storage.definition.buckets[i], count: bucketCounts[i] });
+            buckets.push({ le: "+Inf", count: bucketCounts[bucketCounts.length - 1] });
+            values.push({ labels: storage.labels.get(key) ?? {}, buckets, sum: storage.sums.get(key) ?? 0, count: storage.counts.get(key) ?? 0 });
+        }
+        return { definition: storage.definition, values };
+    }
+    collectSummary(storage) {
+        const values = [];
+        const now = Date.now();
+        for (const [key, observations] of storage.observations) {
+            this.cleanSummaryObservations(storage, key, now);
+            const sorted = [...observations].sort((a, b) => a - b);
+            const quantiles = [];
+            for (const q of storage.definition.quantiles)
+                quantiles.push({ quantile: q, value: calculateQuantile(sorted, q) });
+            values.push({ labels: storage.labels.get(key) ?? {}, quantiles, sum: storage.sums.get(key) ?? 0, count: storage.counts.get(key) ?? 0 });
+        }
+        return { definition: storage.definition, values };
+    }
+    exportText() {
+        const samples = this.collect();
+        const lines = [];
+        for (const sample of samples) {
+            lines.push(`# HELP ${sample.definition.name} ${sample.definition.help}`);
+            lines.push(`# TYPE ${sample.definition.name} ${sample.definition.type}`);
+            switch (sample.definition.type) {
+                case "counter":
+                case "gauge":
+                    for (const val of sample.values)
+                        lines.push(`${sample.definition.name}${formatLabels(val.labels)} ${val.value}`);
+                    break;
+                case "histogram":
+                    for (const val of sample.values) {
+                        const baseLabels = formatLabels(val.labels);
+                        for (const bucket of val.buckets) {
+                            const allLabels = { ...val.labels, le: bucket.le === "+Inf" ? "+Inf" : bucket.le.toString() };
+                            lines.push(`${sample.definition.name}_bucket${formatLabels(allLabels)} ${bucket.count}`);
+                        }
+                        lines.push(`${sample.definition.name}_sum${baseLabels} ${val.sum}`);
+                        lines.push(`${sample.definition.name}_count${baseLabels} ${val.count}`);
+                    }
+                    break;
+                case "summary":
+                    for (const val of sample.values) {
+                        const baseLabels = formatLabels(val.labels);
+                        for (const q of val.quantiles) {
+                            const allLabels = { ...val.labels, quantile: q.quantile.toString() };
+                            lines.push(`${sample.definition.name}${formatLabels(allLabels)} ${q.value}`);
+                        }
+                        lines.push(`${sample.definition.name}_sum${baseLabels} ${val.sum}`);
+                        lines.push(`${sample.definition.name}_count${baseLabels} ${val.count}`);
+                    }
+                    break;
+            }
+            lines.push("");
+        }
+        return lines.join("\n");
+    }
+    reset() {
+        for (const storage of this.metrics.values()) {
+            switch (storage.type) {
+                case "counter":
+                    storage.values.clear();
+                    break;
+                case "gauge":
+                    storage.values.clear();
+                    storage.labels.clear();
+                    break;
+                case "histogram":
+                    storage.buckets.clear();
+                    storage.sums.clear();
+                    storage.counts.clear();
+                    storage.labels.clear();
+                    break;
+                case "summary":
+                    storage.observations.clear();
+                    storage.timestamps.clear();
+                    storage.sums.clear();
+                    storage.counts.clear();
+                    storage.labels.clear();
+                    break;
+            }
+        }
+        this.counterLabels.forEach((map) => map.clear());
+    }
+}
+let globalRegistry = null;
+export function getGlobalRegistry() {
+    if (!globalRegistry)
+        globalRegistry = new MetricCollector();
+    return globalRegistry;
+}
+export function resetGlobalRegistry() {
+    if (globalRegistry)
+        globalRegistry.reset();
+    globalRegistry = null;
+}

package/build/mcp/metrics/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Prometheus Metrics Module
+ */
+export type { MetricType, MetricLabels, MetricDefinition, CounterDefinition, GaugeDefinition, HistogramDefinition, SummaryDefinition, CounterValue, GaugeValue, HistogramValue, SummaryValue, AnySample, CounterSample, GaugeSample, HistogramSample, SummarySample, MetricRegistry, } from "./types.js";
+export { DEFAULT_LATENCY_BUCKETS, DEFAULT_QUEUE_BUCKETS, VIBE_PM_METRICS, METRICS_ENV_VARS, isMetricsEnabled, getMetricsPort, getMetricsPath, shouldIncludeProcessMetrics, } from "./types.js";
+export { MetricCollector, getGlobalRegistry, resetGlobalRegistry } from "./collector.js";
+export type { MetricsServerOptions } from "./server.js";
+export { registerDefaultMetrics, startMetricsServer, stopMetricsServer, isMetricsServerRunning, getMetricsServerInfo, maybeStartMetricsServer, incCounter, setGauge, observeHistogram, observeSummary, recordToolInvocation, recordPoolRequest, updatePoolMetrics, updateResourceMetrics, recordRecoveryAttempt, recordRecoveryAction, updateMemoryMetrics, recordMemorySync, recordMemoryQuery, updateBitNetWorkerMetrics, } from "./server.js";

package/build/mcp/metrics/index.js

@@ -0,0 +1,6 @@
+/**
+ * Prometheus Metrics Module
+ */
+export { DEFAULT_LATENCY_BUCKETS, DEFAULT_QUEUE_BUCKETS, VIBE_PM_METRICS, METRICS_ENV_VARS, isMetricsEnabled, getMetricsPort, getMetricsPath, shouldIncludeProcessMetrics, } from "./types.js";
+export { MetricCollector, getGlobalRegistry, resetGlobalRegistry } from "./collector.js";
+export { registerDefaultMetrics, startMetricsServer, stopMetricsServer, isMetricsServerRunning, getMetricsServerInfo, maybeStartMetricsServer, incCounter, setGauge, observeHistogram, observeSummary, recordToolInvocation, recordPoolRequest, updatePoolMetrics, updateResourceMetrics, recordRecoveryAttempt, recordRecoveryAction, updateMemoryMetrics, recordMemorySync, recordMemoryQuery, updateBitNetWorkerMetrics, } from "./server.js";

package/build/mcp/metrics/server.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Prometheus Metrics - HTTP Server
+ */
+import { MetricCollector } from "./collector.js";
+export declare function registerDefaultMetrics(registry: MetricCollector): void;
+export interface MetricsServerOptions {
+    port?: number;
+    path?: string;
+    registry?: MetricCollector;
+    registerDefaults?: boolean;
+}
+export declare function startMetricsServer(options?: MetricsServerOptions): Promise<{
+    port: number;
+    path: string;
+}>;
+export declare function stopMetricsServer(): Promise<void>;
+export declare function isMetricsServerRunning(): boolean;
+export declare function getMetricsServerInfo(): {
+    port: number;
+    path: string;
+} | null;
+export declare function maybeStartMetricsServer(options?: MetricsServerOptions): Promise<{
+    port: number;
+    path: string;
+} | null>;
+export declare function incCounter(name: string, labels?: Record<string, string>, value?: number): void;
+export declare function setGauge(name: string, labels: Record<string, string>, value: number): void;
+export declare function observeHistogram(name: string, labels: Record<string, string>, value: number): void;
+export declare function observeSummary(name: string, labels: Record<string, string>, value: number): void;
+export declare function recordToolInvocation(tool: string, durationMs: number, result: "success" | "error"): void;
+export declare function recordPoolRequest(type: "bitnet" | "mapper", workerId: string, durationMs: number, status: "success" | "error"): void;
+export declare function updatePoolMetrics(type: "bitnet" | "mapper", healthyCount: number, unhealthyCount: number, queueLength: number): void;
+export declare function updateResourceMetrics(cpuPercent: number, memoryPercent: number, memoryMb: number): void;
+export declare function recordRecoveryAttempt(tool: string, durationMs: number, result: "success" | "failed" | "max_attempts"): void;
+export declare function recordRecoveryAction(action: string, result: "success" | "failed"): void;
+export declare function updateMemoryMetrics(backend: string, docsCount: number, chunksCount: number): void;
+export declare function recordMemorySync(backend: string, mode: "full" | "incremental", durationMs: number): void;
+export declare function recordMemoryQuery(backend: string, durationMs: number): void;
+export declare function updateBitNetWorkerMetrics(workerId: string, modelLoaded: boolean, cacheHitRate: number, p95LatencyMs: number): void;