@jagilber-org/index-server 1.19.1

package/dist/dashboard/server/routes/api.usage.routes.d.ts

@@ -0,0 +1,57 @@
+/**
+ * API Usage Routes — Request execution and monitoring.
+ *
+ * Manages API request execution (retry, rate-limit enforcement, auth, transforms)
+ * and the monitoring event bus. Depends on EndpointManager for endpoint config.
+ */
+import type { EndpointManager, APIAuthentication, RetryConfig, DataMapping } from './api.instructions.routes.js';
+export interface APIRequest {
+    id: string;
+    endpointId: string;
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: unknown;
+    timestamp: number;
+    timeout: number;
+}
+export interface APIResponse {
+    requestId: string;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: unknown;
+    responseTime: number;
+    timestamp: number;
+    error?: string;
+}
+export interface APIMonitoringEvent {
+    type: string;
+    timestamp: number;
+    data: Record<string, unknown>;
+}
+export declare class UsageManager {
+    private readonly endpointMgr;
+    private readonly monitoringCallbacks;
+    constructor(endpointMgr: EndpointManager);
+    executeRequest(endpointId: string, data?: unknown, overrides?: Partial<APIRequest>): Promise<APIResponse>;
+    executeWithRetry(request: APIRequest, retryConfig: RetryConfig): Promise<APIResponse>;
+    performHTTPRequest(request: APIRequest): Promise<APIResponse>;
+    private simulateHTTPRequest;
+    private shouldRetry;
+    private shouldRetryError;
+    private calculateRetryDelay;
+    applyAuthentication(request: APIRequest, auth: APIAuthentication): void;
+    resolveConfigValue(value: string): string;
+    applySafeTransform(data: any, transformSpec: string): any;
+    applySafeFieldTransform(value: any, transform: string): any;
+    applyFieldMappings(data: unknown, mappings: DataMapping['fieldMappings']): unknown;
+    private getNestedValue;
+    private setNestedValue;
+    private validateData;
+    private collectMetrics;
+    logAPIEvent(type: string, data: Record<string, unknown>): void;
+    onAPIEvent(callback: (event: APIMonitoringEvent) => void): void;
+    processRequestQueues(): void;
+    sleep(ms: number): Promise<void>;
+}

package/dist/dashboard/server/routes/api.usage.routes.js

@@ -0,0 +1,374 @@
+"use strict";
+/**
+ * API Usage Routes — Request execution and monitoring.
+ *
+ * Manages API request execution (retry, rate-limit enforcement, auth, transforms)
+ * and the monitoring event bus. Depends on EndpointManager for endpoint config.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageManager = void 0;
+// ── UsageManager ─────────────────────────────────────────────────────────────────────
+class UsageManager {
+    endpointMgr;
+    monitoringCallbacks = [];
+    constructor(endpointMgr) {
+        this.endpointMgr = endpointMgr;
+    }
+    async executeRequest(endpointId, data, overrides) {
+        const endpoint = this.endpointMgr.getEndpoint(endpointId);
+        if (!endpoint)
+            throw new Error(`Endpoint not found: ${endpointId}`);
+        if (!this.endpointMgr.checkRateLimit(endpointId)) {
+            throw new Error(`Rate limit exceeded for endpoint: ${endpointId}`);
+        }
+        const requestId = `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const request = {
+            id: requestId,
+            endpointId,
+            method: endpoint.method,
+            url: endpoint.url,
+            headers: { ...endpoint.headers, ...(overrides?.headers || {}) },
+            body: data,
+            timestamp: Date.now(),
+            timeout: overrides?.timeout || endpoint.timeout
+        };
+        this.applyAuthentication(request, endpoint.authentication);
+        if (data && endpoint.dataMapping.requestTransform) {
+            try {
+                request.body = this.applySafeTransform(data, endpoint.dataMapping.requestTransform);
+            }
+            catch (error) {
+                console.error('Request transform error:', error);
+            }
+        }
+        if (endpoint.validation.validateRequest && endpoint.validation.requestSchema) {
+            const valid = this.validateData(request.body, endpoint.validation.requestSchema);
+            if (!valid && endpoint.validation.strictMode) {
+                throw new Error('Request validation failed');
+            }
+        }
+        if (endpoint.monitoring.logRequests) {
+            this.logAPIEvent('request', { endpointId, requestId, url: request.url, method: request.method });
+        }
+        const response = await this.executeWithRetry(request, endpoint.retryConfig);
+        if (endpoint.dataMapping.responseTransform) {
+            try {
+                response.body = this.applySafeTransform(response.body, endpoint.dataMapping.responseTransform);
+            }
+            catch (error) {
+                console.error('Response transform error:', error);
+            }
+        }
+        if (endpoint.dataMapping.fieldMappings.length > 0) {
+            response.body = this.applyFieldMappings(response.body, endpoint.dataMapping.fieldMappings);
+        }
+        if (endpoint.validation.validateResponse && endpoint.validation.responseSchema) {
+            const valid = this.validateData(response.body, endpoint.validation.responseSchema);
+            if (!valid && endpoint.validation.strictMode) {
+                console.warn('Response validation failed for endpoint:', endpointId);
+            }
+        }
+        if (endpoint.monitoring.logResponses) {
+            this.logAPIEvent('response', {
+                endpointId,
+                requestId,
+                status: response.status,
+                responseTime: response.responseTime
+            });
+        }
+        if (response.error && endpoint.monitoring.logErrors) {
+            this.logAPIEvent('error', { endpointId, requestId, error: response.error, status: response.status });
+        }
+        if (endpoint.monitoring.collectMetrics) {
+            this.collectMetrics(endpointId, response);
+        }
+        return response;
+    }
+    async executeWithRetry(request, retryConfig) {
+        let lastError = null;
+        let attempt = 0;
+        while (attempt <= retryConfig.maxAttempts) {
+            try {
+                const response = await this.performHTTPRequest(request);
+                if (this.shouldRetry(response, retryConfig)) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                return response;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                attempt++;
+                if (attempt > retryConfig.maxAttempts)
+                    break;
+                if (!this.shouldRetryError(lastError, retryConfig))
+                    break;
+                const delay = this.calculateRetryDelay(attempt, retryConfig);
+                await this.sleep(delay);
+            }
+        }
+        return {
+            requestId: request.id,
+            status: 0,
+            statusText: 'Request Failed',
+            headers: {},
+            body: null,
+            responseTime: 0,
+            timestamp: Date.now(),
+            error: lastError?.message || 'Unknown error'
+        };
+    }
+    async performHTTPRequest(request) {
+        const startTime = Date.now();
+        try {
+            const response = await this.simulateHTTPRequest(request);
+            return {
+                requestId: request.id,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                body: response.body,
+                responseTime: Date.now() - startTime,
+                timestamp: Date.now()
+            };
+        }
+        catch (error) {
+            throw new Error(`Network error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async simulateHTTPRequest(request) {
+        await this.sleep(Math.random() * 100 + 50);
+        const scenarios = [
+            { weight: 0.8, status: 200, statusText: 'OK', body: { success: true, data: 'Response data' } },
+            { weight: 0.1, status: 429, statusText: 'Too Many Requests', body: { error: 'Rate limit exceeded' } },
+            { weight: 0.05, status: 500, statusText: 'Internal Server Error', body: { error: 'Server error' } },
+            { weight: 0.05, status: 503, statusText: 'Service Unavailable', body: { error: 'Service unavailable' } }
+        ];
+        const random = Math.random();
+        let cumulative = 0;
+        for (const scenario of scenarios) {
+            cumulative += scenario.weight;
+            if (random <= cumulative) {
+                return { status: scenario.status, statusText: scenario.statusText, headers: { 'Content-Type': 'application/json' }, body: scenario.body };
+            }
+        }
+        return { status: 200, statusText: 'OK', headers: { 'Content-Type': 'application/json' }, body: { success: true, data: request.body } };
+    }
+    shouldRetry(response, retryConfig) {
+        if (!retryConfig.enabled)
+            return false;
+        if (response.status >= 500 || response.status === 429) {
+            return retryConfig.retryOn.includes('server_error') || retryConfig.retryOn.includes('rate_limit');
+        }
+        return false;
+    }
+    shouldRetryError(error, retryConfig) {
+        if (!retryConfig.enabled)
+            return false;
+        const message = error.message.toLowerCase();
+        if (message.includes('timeout') && retryConfig.retryOn.includes('timeout'))
+            return true;
+        if ((message.includes('network') || message.includes('fetch')) && retryConfig.retryOn.includes('network_error'))
+            return true;
+        return false;
+    }
+    calculateRetryDelay(attempt, retryConfig) {
+        let delay;
+        switch (retryConfig.backoffStrategy) {
+            case 'linear':
+                delay = retryConfig.baseDelay * attempt;
+                break;
+            case 'exponential':
+                delay = retryConfig.baseDelay * Math.pow(2, attempt - 1);
+                break;
+            case 'fixed':
+            default:
+                delay = retryConfig.baseDelay;
+                break;
+        }
+        return Math.min(delay, retryConfig.maxDelay);
+    }
+    applyAuthentication(request, auth) {
+        switch (auth.type) {
+            case 'api_key': {
+                const keyName = auth.config.keyName;
+                const keyValue = this.resolveConfigValue(auth.config.keyValue);
+                request.headers[keyName] = keyValue;
+                break;
+            }
+            case 'bearer_token': {
+                const token = this.resolveConfigValue(auth.config.token);
+                request.headers['Authorization'] = `Bearer ${token}`;
+                break;
+            }
+            case 'basic_auth': {
+                const username = this.resolveConfigValue(auth.config.username);
+                const password = this.resolveConfigValue(auth.config.password);
+                const credentials = Buffer.from(`${username}:${password}`).toString('base64');
+                request.headers['Authorization'] = `Basic ${credentials}`;
+                break;
+            }
+            case 'oauth2':
+                console.warn('OAuth2 authentication not fully implemented');
+                break;
+            case 'custom': {
+                const customHeaders = auth.config.headers;
+                Object.assign(request.headers, customHeaders);
+                break;
+            }
+            case 'none':
+            default:
+                break;
+        }
+    }
+    resolveConfigValue(value) {
+        if (value.startsWith('${') && value.endsWith('}')) {
+            const envVar = value.slice(2, -1);
+            return process.env[envVar] || value;
+        }
+        return value;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    applySafeTransform(data, transformSpec) {
+        if (!data || !transformSpec)
+            return data;
+        const dotPath = transformSpec.trim().match(/^(?:data|response|value)\.(.+)$/);
+        if (dotPath) {
+            const parts = dotPath[1].split('.');
+            let result = data;
+            for (const part of parts) {
+                if (result == null || typeof result !== 'object')
+                    return data;
+                result = result[part];
+            }
+            return result;
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    applySafeFieldTransform(value, transform) {
+        const t = transform.trim();
+        if (t === 'String(value)' || t === 'value.toString()')
+            return String(value);
+        if (t === 'Number(value)' || t === 'parseInt(value)')
+            return Number(value);
+        if (t === 'Boolean(value)')
+            return Boolean(value);
+        if (t === 'JSON.parse(value)') {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value;
+            }
+        }
+        if (t === 'JSON.stringify(value)')
+            return JSON.stringify(value);
+        if (t === 'value.toLowerCase()')
+            return typeof value === 'string' ? value.toLowerCase() : value;
+        if (t === 'value.toUpperCase()')
+            return typeof value === 'string' ? value.toUpperCase() : value;
+        if (t === 'value.trim()')
+            return typeof value === 'string' ? value.trim() : value;
+        const dotPath = t.match(/^value\.(.+)$/);
+        if (dotPath) {
+            let result = value;
+            for (const part of dotPath[1].split('.')) {
+                if (result == null || typeof result !== 'object')
+                    return value;
+                result = result[part];
+            }
+            return result;
+        }
+        return value;
+    }
+    applyFieldMappings(data, mappings) {
+        if (!data || typeof data !== 'object' || !Array.isArray(mappings))
+            return data;
+        const result = { ...data };
+        mappings.forEach(mapping => {
+            const sourceValue = this.getNestedValue(result, mapping.source);
+            let targetValue = sourceValue;
+            if (mapping.transform) {
+                try {
+                    targetValue = this.applySafeFieldTransform(sourceValue, mapping.transform);
+                }
+                catch (error) {
+                    console.error('Field mapping transform error:', error);
+                }
+            }
+            this.setNestedValue(result, mapping.target, targetValue);
+        });
+        return result;
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, key) => {
+            return current && typeof current === 'object' ? current[key] : undefined;
+        }, obj);
+    }
+    setNestedValue(obj, path, value) {
+        const keys = path.split('.');
+        const lastKey = keys.pop();
+        const target = keys.reduce((current, key) => {
+            if (!current[key] || typeof current[key] !== 'object')
+                current[key] = {};
+            return current[key];
+        }, obj);
+        target[lastKey] = value;
+    }
+    validateData(data, _schema) {
+        try {
+            if (typeof data !== 'object' || data === null)
+                return false;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    collectMetrics(endpointId, response) {
+        this.logAPIEvent('metrics', {
+            endpointId,
+            responseTime: response.responseTime,
+            status: response.status,
+            success: response.status >= 200 && response.status < 300
+        });
+    }
+    logAPIEvent(type, data) {
+        const event = { type, timestamp: Date.now(), data };
+        this.monitoringCallbacks.forEach(callback => {
+            try {
+                callback(event);
+            }
+            catch (error) {
+                console.error('API monitoring callback error:', error);
+            }
+        });
+    }
+    onAPIEvent(callback) {
+        this.monitoringCallbacks.push(callback);
+    }
+    processRequestQueues() {
+        this.endpointMgr.requestQueue.forEach((requests, endpointId) => {
+            if (requests.length === 0)
+                return;
+            const endpoint = this.endpointMgr.getEndpoint(endpointId);
+            if (!endpoint?.rateLimit.enabled)
+                return;
+            if (this.endpointMgr.checkRateLimit(endpointId)) {
+                const request = requests.shift();
+                if (request) {
+                    this.executeRequest(endpointId, request.body, {
+                        headers: request.headers,
+                        timeout: request.timeout
+                    }).catch(error => {
+                        console.error('Queued request execution error:', error);
+                    });
+                }
+            }
+        });
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.UsageManager = UsageManager;

package/dist/dashboard/server/routes/embeddings.routes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Embeddings Routes
+ * Route: GET /embeddings/projection — PCA-project embeddings to 2D for visualization.
+ */
+import { Router } from 'express';
+export declare function createEmbeddingsRoutes(embeddingPathOverride?: string): Router;

package/dist/dashboard/server/routes/embeddings.routes.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * Embeddings Routes
+ * Route: GET /embeddings/projection — PCA-project embeddings to 2D for visualization.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmbeddingsRoutes = createEmbeddingsRoutes;
+const express_1 = require("express");
+const node_fs_1 = __importDefault(require("node:fs"));
+const runtimeConfig_js_1 = require("../../../config/runtimeConfig.js");
+const embeddingService_js_1 = require("../../../services/embeddingService.js");
+const indexContext_js_1 = require("../../../services/indexContext.js");
+// ---------------------------------------------------------------------------
+// Category derivation from instruction ID (shared rules)
+// ---------------------------------------------------------------------------
+const categoryRules_js_1 = require("../../../services/categoryRules.js");
+// ---------------------------------------------------------------------------
+// PCA via power iteration (no dependencies)
+// ---------------------------------------------------------------------------
+function mean(vectors) {
+    const n = vectors.length;
+    const d = vectors[0].length;
+    const m = new Array(d).fill(0);
+    for (const v of vectors)
+        for (let i = 0; i < d; i++)
+            m[i] += v[i];
+    for (let i = 0; i < d; i++)
+        m[i] /= n;
+    return m;
+}
+function subtract(a, b) {
+    return a.map((v, i) => v - b[i]);
+}
+function dot(a, b) {
+    let s = 0;
+    for (let i = 0; i < a.length; i++)
+        s += a[i] * b[i];
+    return s;
+}
+function norm(v) {
+    return Math.sqrt(dot(v, v));
+}
+function scale(v, s) {
+    return v.map(x => x * s);
+}
+/** Compute the top principal component via power iteration. */
+function powerIteration(centered, dims, iterations = 100) {
+    // random init
+    let pc = Array.from({ length: dims }, () => Math.random() - 0.5);
+    const n = norm(pc);
+    if (n > 0)
+        pc = scale(pc, 1 / n);
+    for (let iter = 0; iter < iterations; iter++) {
+        const newPc = new Array(dims).fill(0);
+        for (const row of centered) {
+            const d = dot(row, pc);
+            for (let j = 0; j < dims; j++)
+                newPc[j] += d * row[j];
+        }
+        const len = norm(newPc);
+        if (len === 0)
+            break;
+        pc = scale(newPc, 1 / len);
+    }
+    return pc;
+}
+/** Deflate: remove component along given direction */
+function deflate(centered, pc) {
+    return centered.map(row => {
+        const proj = dot(row, pc);
+        return row.map((v, i) => v - proj * pc[i]);
+    });
+}
+/** PCA project to 2D */
+function pcaProject(vectors) {
+    if (vectors.length === 0)
+        return [];
+    const dims = vectors[0].length;
+    if (vectors.length === 1) {
+        return [{ x: 0, y: 0 }];
+    }
+    const mu = mean(vectors);
+    let centered = vectors.map(v => subtract(v, mu));
+    const pc1 = powerIteration(centered, dims);
+    centered = deflate(centered, pc1);
+    const pc2 = powerIteration(centered, dims);
+    return vectors.map(v => {
+        const c = subtract(v, mu);
+        return { x: dot(c, pc1), y: dot(c, pc2) };
+    });
+}
+// ---------------------------------------------------------------------------
+// Cosine similarity stats
+// ---------------------------------------------------------------------------
+function cosineSimilarity(a, b) {
+    const na = norm(a);
+    const nb = norm(b);
+    if (na === 0 || nb === 0)
+        return 0;
+    return dot(a, b) / (na * nb);
+}
+function computeStats(ids, vectors, topK = 10) {
+    let sumSim = 0;
+    let minSim = 1;
+    let maxSim = -1;
+    let pairCount = 0;
+    let sumNorm = 0;
+    const topPairs = [];
+    for (let i = 0; i < vectors.length; i++) {
+        sumNorm += norm(vectors[i]);
+    }
+    // Sample up to 5000 pairs for large collections
+    const maxPairs = 5000;
+    const allPairs = (vectors.length * (vectors.length - 1)) / 2;
+    const sampleRate = allPairs > maxPairs ? maxPairs / allPairs : 1;
+    for (let i = 0; i < vectors.length; i++) {
+        for (let j = i + 1; j < vectors.length; j++) {
+            if (sampleRate < 1 && Math.random() > sampleRate)
+                continue;
+            const sim = cosineSimilarity(vectors[i], vectors[j]);
+            sumSim += sim;
+            if (sim < minSim)
+                minSim = sim;
+            if (sim > maxSim)
+                maxSim = sim;
+            pairCount++;
+            if (topPairs.length < topK || sim > topPairs[topPairs.length - 1].similarity) {
+                topPairs.push({ a: ids[i], b: ids[j], similarity: Math.round(sim * 1000) / 1000 });
+                topPairs.sort((a, b) => b.similarity - a.similarity);
+                if (topPairs.length > topK)
+                    topPairs.pop();
+            }
+        }
+    }
+    return {
+        stats: {
+            avgCosineSim: pairCount > 0 ? Math.round((sumSim / pairCount) * 1000) / 1000 : 0,
+            minCosineSim: pairCount > 0 ? Math.round(minSim * 1000) / 1000 : 0,
+            maxCosineSim: pairCount > 0 ? Math.round(maxSim * 1000) / 1000 : 0,
+            avgNorm: vectors.length > 0 ? Math.round((sumNorm / vectors.length) * 1000) / 1000 : 0,
+        },
+        similarPairs: topPairs,
+    };
+}
+// ---------------------------------------------------------------------------
+// Route factory
+// ---------------------------------------------------------------------------
+function createEmbeddingsRoutes(embeddingPathOverride) {
+    const router = (0, express_1.Router)();
+    router.get('/embeddings/projection', (_req, res) => {
+        try {
+            const embeddingPath = embeddingPathOverride ?? (0, runtimeConfig_js_1.getRuntimeConfig)().semantic.embeddingPath ?? '';
+            if (!embeddingPath || !node_fs_1.default.existsSync(embeddingPath)) {
+                return res.status(404).json({
+                    success: false,
+                    error: 'Embeddings file not found',
+                });
+            }
+            const raw = node_fs_1.default.readFileSync(embeddingPath, 'utf-8');
+            const data = JSON.parse(raw);
+            const ids = Object.keys(data.embeddings);
+            const vectors = ids.map(id => data.embeddings[id]);
+            if (ids.length === 0) {
+                return res.json({
+                    success: true,
+                    count: 0,
+                    dimensions: 0,
+                    model: data.modelName,
+                    points: [],
+                    stats: { avgCosineSim: 0, minCosineSim: 0, maxCosineSim: 0, avgNorm: 0 },
+                    similarPairs: [],
+                });
+            }
+            const dims = vectors[0].length;
+            const projected = pcaProject(vectors);
+            const points = ids.map((id, i) => ({
+                id,
+                x: Math.round(projected[i].x * 10000) / 10000,
+                y: Math.round(projected[i].y * 10000) / 10000,
+                category: (0, categoryRules_js_1.deriveCategory)(id),
+                norm: Math.round(norm(vectors[i]) * 10000) / 10000,
+            }));
+            const { stats, similarPairs } = computeStats(ids, vectors);
+            return res.json({
+                success: true,
+                count: ids.length,
+                dimensions: dims,
+                model: data.modelName,
+                points,
+                stats,
+                similarPairs,
+            });
+        }
+        catch (err) {
+            return res.status(500).json({
+                success: false,
+                error: 'Failed to compute projection',
+                message: err.message,
+            });
+        }
+    });
+    // POST /embeddings/compute — trigger embedding computation for all instructions
+    router.post('/embeddings/compute', async (_req, res) => {
+        try {
+            const config = (0, runtimeConfig_js_1.getRuntimeConfig)();
+            const sem = config.semantic;
+            if (!sem.enabled) {
+                return res.status(400).json({
+                    success: false,
+                    error: 'Semantic embeddings are disabled',
+                    hint: 'Set INDEX_SERVER_SEMANTIC_ENABLED=1 and restart the server',
+                });
+            }
+            const state = (0, indexContext_js_1.ensureLoaded)();
+            if (!state || !state.list || state.list.length === 0) {
+                return res.status(400).json({
+                    success: false,
+                    error: 'No instructions loaded in index',
+                });
+            }
+            const start = performance.now();
+            const embeddings = await (0, embeddingService_js_1.getInstructionEmbeddings)(state.list, state.hash, sem.embeddingPath, sem.model, sem.cacheDir, sem.device, sem.localOnly);
+            const elapsed = (performance.now() - start).toFixed(0);
+            const count = Object.keys(embeddings).length;
+            return res.json({
+                success: true,
+                count,
+                model: sem.model,
+                device: sem.device,
+                elapsedMs: Number(elapsed),
+                embeddingPath: sem.embeddingPath,
+            });
+        }
+        catch (err) {
+            return res.status(500).json({
+                success: false,
+                error: 'Failed to compute embeddings',
+                message: err.message,
+            });
+        }
+    });
+    return router;
+}

package/dist/dashboard/server/routes/graph.routes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Graph Routes
+ * Routes: GET /graph/mermaid, GET /graph/categories, GET /graph/instructions, GET /graph/relations
+ */
+import { Router } from 'express';
+export declare function createGraphRoutes(): Router;