@systemdox/mcp-server 0.1.11

package/dist/lib/api-client.d.ts

@@ -0,0 +1,14 @@
+import type { ServerConfig } from "./config.js";
+export declare class SystemDoxApiClient {
+    private config;
+    private cache;
+    constructor(config: ServerConfig);
+    validate(): Promise<void>;
+    get<T>(path: string, params?: Record<string, string>): Promise<T>;
+    post<T>(path: string, body: unknown): Promise<T>;
+    put<T>(path: string, body: unknown): Promise<T>;
+    private mutate;
+    invalidateCache(path?: string): void;
+    private buildUrl;
+    private fetchRaw;
+}

package/dist/lib/api-client.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+// src/lib/cache.ts
+var ResponseCache = class {
+  store = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(ttlMs) {
+    this.ttlMs = ttlMs;
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return void 0;
+    }
+    return entry.data;
+  }
+  set(key, data) {
+    this.store.set(key, {
+      data,
+      expiresAt: Date.now() + this.ttlMs
+    });
+  }
+  invalidate(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+
+// src/lib/api-client.ts
+var SystemDoxApiClient = class {
+  config;
+  cache;
+  constructor(config) {
+    this.config = config;
+    this.cache = new ResponseCache(config.cacheTtlMs);
+  }
+  async validate() {
+    const res = await this.fetchRaw("/v1/health");
+    if (!res.ok) {
+      throw new Error(
+        `SystemDox API authentication failed (${res.status}). Check your SYSTEMDOX_API_KEY.`
+      );
+    }
+  }
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    const cacheKey = url.toString();
+    const cached = this.cache.get(cacheKey);
+    if (cached !== void 0) return cached;
+    const res = await this.fetchRaw(path, params);
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`SystemDox API error ${res.status}: ${body}`);
+    }
+    const data = await res.json();
+    this.cache.set(cacheKey, data);
+    return data;
+  }
+  async post(path, body) {
+    return this.mutate("POST", path, body);
+  }
+  async put(path, body) {
+    return this.mutate("PUT", path, body);
+  }
+  async mutate(method, path, body) {
+    const url = this.buildUrl(path);
+    const res = await fetch(url, {
+      method,
+      headers: {
+        // The API Gateway authorizer only reads the Authorization header;
+        // X-API-Key is kept for backwards compatibility.
+        Authorization: `Bearer ${this.config.apiKey}`,
+        "X-API-Key": this.config.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`SystemDox API error ${res.status}: ${text}`);
+    }
+    return await res.json();
+  }
+  invalidateCache(path) {
+    if (path) {
+      this.cache.invalidate(this.buildUrl(path).toString());
+    } else {
+      this.cache.clear();
+    }
+  }
+  buildUrl(path, params) {
+    const base = this.config.apiUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}${path.startsWith("/") ? "" : "/"}${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    return url;
+  }
+  async fetchRaw(path, params) {
+    const url = this.buildUrl(path, params);
+    return fetch(url, {
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`,
+        "X-API-Key": this.config.apiKey,
+        Accept: "application/json"
+      }
+    });
+  }
+};
+export {
+  SystemDoxApiClient
+};

package/dist/lib/cache.d.ts

@@ -0,0 +1,9 @@
+export declare class ResponseCache {
+    private store;
+    private ttlMs;
+    constructor(ttlMs: number);
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, data: T): void;
+    invalidate(key: string): void;
+    clear(): void;
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,7 @@
+export interface ServerConfig {
+    apiKey: string;
+    apiUrl: string;
+    cacheTtlMs: number;
+    defaultOrg: string | undefined;
+}
+export declare function loadConfig(): ServerConfig;

package/dist/lib/context-builder.d.ts

@@ -0,0 +1,78 @@
+export { estimateTokens } from "./scoring.js";
+/**
+ * Structural subset of SystemDoxApiClient. Keeps the builder testable with a
+ * fake client and free of transport/auth concerns.
+ */
+export interface ContextApiClient {
+    get<T>(path: string, params?: Record<string, string>): Promise<T>;
+}
+export interface Guardrail {
+    id: string;
+    title: string;
+    description: string;
+    category: string;
+    severity: string;
+    pattern: string;
+    fix: string;
+    updatedAt: string;
+}
+export interface SpecSummary {
+    specId: string;
+    name: string;
+    status: string;
+    requirementCount: number;
+    updatedAt: string;
+}
+export interface DocListResponse {
+    items: Array<{
+        id: string;
+        repo_full_name: string;
+        path: string;
+        title: string;
+        doc_type: string;
+        size: number;
+        synced_at: string;
+    }>;
+}
+export interface TechStackEntry {
+    id: string;
+    name: string;
+    category: string;
+    version?: string;
+    notes?: string;
+}
+export interface ProjectRule {
+    id: string;
+    text: string;
+    category: string;
+    createdAt: string;
+}
+export interface BuildContextOptions {
+    taskDescription: string;
+    filePaths?: string[];
+    maxTokens?: number;
+}
+export interface ContextStats {
+    budget: number;
+    tokensUsed: number;
+    /** Ranked spec/doc items whose full text was fetched and included. */
+    itemsWithBody: number;
+    /** Items whose body fetch failed — listed by title + ID instead. */
+    bodyFailures: number;
+    /** Ranked items that appear only as a title + ID (no body fetched). */
+    itemsListed: number;
+    /** Ranked items that did not fit at all. */
+    itemsOmitted: number;
+    guardrails: number;
+}
+export interface ContextResult {
+    text: string;
+    stats: ContextStats;
+}
+/**
+ * Rank every context item against the task, then spend the token budget on the
+ * *bodies* of the highest-ranked specs and docs — fetched concurrently, clipped
+ * to a fair share of what's left, and always accompanied by the ID the agent
+ * needs to fetch the rest itself.
+ */
+export declare function buildContext(api: ContextApiClient, { taskDescription, filePaths, maxTokens }: BuildContextOptions): Promise<ContextResult>;