@systemdox/mcp-server 0.1.11

package/dist/lib/context-builder.js

@@ -0,0 +1,575 @@
+#!/usr/bin/env node
+
+// src/lib/language.ts
+var EXTENSION_MAP = {
+  ".py": { language: "python", categories: ["api", "backend", "data-access"] },
+  ".ts": { language: "typescript", categories: ["frontend", "api"] },
+  ".tsx": { language: "typescript", categories: ["frontend"] },
+  ".js": { language: "javascript", categories: ["frontend"] },
+  ".jsx": { language: "javascript", categories: ["frontend"] },
+  ".yaml": {
+    language: "cloudformation",
+    categories: ["infrastructure", "architecture"]
+  },
+  ".yml": {
+    language: "cloudformation",
+    categories: ["infrastructure", "architecture"]
+  },
+  ".json": { language: "json", categories: ["configuration"] },
+  ".css": { language: "css", categories: ["frontend"] },
+  ".html": { language: "html", categories: ["frontend"] },
+  ".sql": { language: "sql", categories: ["data-access"] },
+  ".sh": { language: "shell", categories: ["infrastructure"] },
+  ".bash": { language: "shell", categories: ["infrastructure"] },
+  ".tf": { language: "terraform", categories: ["infrastructure"] },
+  ".md": { language: "markdown", categories: ["documentation"] }
+};
+var PATH_CATEGORY_RULES = [
+  { pattern: /backend\/functions\//, categories: ["api", "backend"] },
+  { pattern: /backend\/layers\//, categories: ["backend"] },
+  { pattern: /backend\//, categories: ["backend"] },
+  { pattern: /apps\/app\//, categories: ["frontend"] },
+  { pattern: /apps\/website\//, categories: ["frontend"] },
+  { pattern: /apps\/portal\//, categories: ["frontend"] },
+  { pattern: /packages\/ui\//, categories: ["frontend"] },
+  { pattern: /infra\//, categories: ["infrastructure"] },
+  { pattern: /\.github\//, categories: ["infrastructure"] },
+  { pattern: /tests?\//, categories: ["testing"] },
+  { pattern: /spec/, categories: ["testing"] },
+  { pattern: /docs\/adr/, categories: ["architecture"] },
+  { pattern: /template\.yaml$/, categories: ["infrastructure", "architecture"] }
+];
+function detectLanguage(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return EXTENSION_MAP[ext];
+}
+function detectCategories(filePaths) {
+  const categories = /* @__PURE__ */ new Set();
+  for (const filePath of filePaths) {
+    const langInfo = detectLanguage(filePath);
+    if (langInfo) {
+      for (const cat of langInfo.categories) {
+        categories.add(cat);
+      }
+    }
+    for (const rule of PATH_CATEGORY_RULES) {
+      if (rule.pattern.test(filePath)) {
+        for (const cat of rule.categories) {
+          categories.add(cat);
+        }
+      }
+    }
+  }
+  return Array.from(categories);
+}
+function detectLanguages(filePaths) {
+  const languages = /* @__PURE__ */ new Set();
+  for (const filePath of filePaths) {
+    const info = detectLanguage(filePath);
+    if (info) languages.add(info.language);
+  }
+  return Array.from(languages);
+}
+
+// src/lib/scoring.ts
+var WEIGHT_PATH = 0.4;
+var WEIGHT_KEYWORD = 0.3;
+var WEIGHT_RECENCY = 0.15;
+var WEIGHT_SEVERITY = 0.15;
+var SEVERITY_SCORES = {
+  critical: 1,
+  high: 0.75,
+  medium: 0.5,
+  low: 0.25
+};
+var CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function truncateToTokens(text, maxTokens) {
+  const maxChars = Math.max(0, maxTokens) * CHARS_PER_TOKEN;
+  if (text.length <= maxChars) return { text, truncated: false };
+  const head = text.slice(0, maxChars);
+  const floor = Math.floor(maxChars * 0.75);
+  const paragraph = head.lastIndexOf("\n\n");
+  const line = head.lastIndexOf("\n");
+  let cut = maxChars;
+  if (paragraph >= floor) cut = paragraph;
+  else if (line >= floor) cut = line;
+  return { text: head.slice(0, cut).trimEnd(), truncated: true };
+}
+function scorePathMatch(item, languages, categories) {
+  if (languages.length === 0 && categories.length === 0) return 0.5;
+  let score = 0;
+  const itemLang = item.language?.toLowerCase() ?? "";
+  const itemCat = item.category?.toLowerCase() ?? "";
+  if (itemLang && languages.some((l) => itemLang.includes(l))) {
+    score += 0.6;
+  }
+  if (itemCat && categories.some((c) => itemCat.includes(c))) {
+    score += 0.4;
+  }
+  return Math.min(score, 1);
+}
+function scoreKeywordMatch(item, keywords) {
+  if (keywords.length === 0) return 0;
+  const searchable = `${item.title} ${item.content}`.toLowerCase();
+  let matches = 0;
+  for (const kw of keywords) {
+    if (searchable.includes(kw)) matches++;
+  }
+  return Math.min(matches / keywords.length, 1);
+}
+function scoreRecency(item) {
+  if (!item.updatedAt) return 0.5;
+  const now = Date.now();
+  const updated = new Date(item.updatedAt).getTime();
+  const daysSince = (now - updated) / (1e3 * 60 * 60 * 24);
+  if (daysSince <= 7) return 1;
+  if (daysSince <= 30) return 0.75;
+  if (daysSince <= 90) return 0.5;
+  return 0.25;
+}
+function scoreSeverity(item) {
+  if (!item.severity) return 0.5;
+  return SEVERITY_SCORES[item.severity] ?? 0.5;
+}
+function extractKeywords(text) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "can",
+    "shall",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "about",
+    "between",
+    "through",
+    "after",
+    "before",
+    "during",
+    "without",
+    "this",
+    "that",
+    "these",
+    "those",
+    "it",
+    "its",
+    "and",
+    "or",
+    "but",
+    "not",
+    "no",
+    "all",
+    "each",
+    "every",
+    "both",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "than",
+    "too",
+    "very",
+    "just",
+    "also",
+    "only",
+    "new",
+    "add",
+    "update",
+    "fix",
+    "change",
+    "make",
+    "use",
+    "get",
+    "set",
+    "need",
+    "want",
+    "implement",
+    "create"
+  ]);
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+}
+function scoreItems(items, taskDescription, filePaths) {
+  const languages = detectLanguages(filePaths);
+  const categories = detectCategories(filePaths);
+  const keywords = extractKeywords(taskDescription);
+  return items.map((item) => {
+    const pathScore = scorePathMatch(item, languages, categories);
+    const keywordScore = scoreKeywordMatch(item, keywords);
+    const recencyScore = scoreRecency(item);
+    const severityScore = scoreSeverity(item);
+    const score = pathScore * WEIGHT_PATH + keywordScore * WEIGHT_KEYWORD + recencyScore * WEIGHT_RECENCY + severityScore * WEIGHT_SEVERITY;
+    return {
+      type: item.type,
+      id: item.id,
+      title: item.title,
+      content: item.content,
+      score,
+      tokenEstimate: estimateTokens(item.content)
+    };
+  }).sort((a, b) => b.score - a.score);
+}
+function selectWithinBudget(items, maxTokens) {
+  const selected = [];
+  let tokensUsed = 0;
+  for (const item of items) {
+    if (tokensUsed + item.tokenEstimate > maxTokens) continue;
+    selected.push(item);
+    tokensUsed += item.tokenEstimate;
+  }
+  return { selected, tokensUsed, totalItems: items.length };
+}
+
+// src/lib/context-builder.ts
+var DEFAULT_BUDGET = 4e3;
+var RESERVE_TOKENS = 200;
+var GUARDRAIL_SHARE = 0.35;
+var MIN_BODY_TOKENS = 150;
+var MAX_HYDRATED = 8;
+var MAX_TAIL = 10;
+var TAIL_SHARE = 0.15;
+var TRUNCATION_NOTICE_TOKENS = 30;
+function formatGuardrail(g) {
+  let text = `## ${g.title} [${g.severity}]
+
+${g.description}`;
+  if (g.pattern) text += `
+
+**Bad:** \`\`\`
+${g.pattern}
+\`\`\``;
+  if (g.fix) text += `
+
+**Good:** \`\`\`
+${g.fix}
+\`\`\``;
+  return text;
+}
+function formatSpecHeadline(s) {
+  return `### ${s.name}
+\`spec_id: ${s.specId}\` \xB7 ${s.status} \xB7 ${s.requirementCount} requirements`;
+}
+function formatDocHeadline(d) {
+  return `### ${d.title}
+\`doc_id: ${d.id}\` \xB7 \`${d.repo_full_name}/${d.path}\` \xB7 ${d.doc_type}`;
+}
+function formatStack(entries) {
+  return entries.map(
+    (e) => `- ${e.name}${e.version ? ` v${e.version}` : ""}${e.notes ? ` \u2014 ${e.notes}` : ""}`
+  ).join("\n");
+}
+function formatRules(rules) {
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const r of rules) {
+    const cat = r.category || "other";
+    if (!byCategory.has(cat)) byCategory.set(cat, []);
+    byCategory.get(cat).push(r);
+  }
+  let text = "";
+  for (const [cat, catRules] of byCategory) {
+    text += `### ${cat.charAt(0).toUpperCase() + cat.slice(1)}
+`;
+    for (const r of catRules) {
+      text += `- ${r.text}
+`;
+    }
+    text += "\n";
+  }
+  return `## Project Rules (${rules.length})
+
+${text.trim()}`;
+}
+async function fetchSpecBody(api, specId) {
+  const spec = await api.get(
+    `/v1/specs/${encodeURIComponent(specId)}`
+  );
+  const parts = [];
+  if (spec.proposalContent) {
+    parts.push(`**Proposal**
+
+${spec.proposalContent}`);
+  }
+  for (const r of spec.requirements ?? []) {
+    parts.push(`**${r.name}**
+
+${r.content}`);
+  }
+  if (spec.taskContent) {
+    parts.push(`**Tasks**
+
+${spec.taskContent}`);
+  }
+  const body = parts.join("\n\n").trim();
+  if (!body) throw new Error("spec has no content");
+  return body;
+}
+async function fetchDocBody(api, docId) {
+  const doc = await api.get(
+    `/v1/docs/${encodeURIComponent(docId)}/content`
+  );
+  if (doc.error) throw new Error(doc.error);
+  const body = (doc.content ?? "").trim();
+  if (!body) throw new Error("document is empty");
+  return body;
+}
+async function hydrate(api, item, meta) {
+  try {
+    const body = meta.type === "spec" ? await fetchSpecBody(api, meta.id) : await fetchDocBody(api, meta.id);
+    return { item, meta, body };
+  } catch (err) {
+    return {
+      item,
+      meta,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function buildContext(api, { taskDescription, filePaths = [], maxTokens }) {
+  const budget = maxTokens ?? DEFAULT_BUDGET;
+  const [guardrails, specs, docs, stack, rules] = await Promise.all([
+    api.get("/v1/guardrails").catch(() => []),
+    api.get("/v1/specs").catch(() => []),
+    api.get("/v1/docs").catch(() => ({ items: [] })),
+    api.get("/v1/ai/settings/stack").catch(() => []),
+    api.get("/v1/standards/rules").catch(() => [])
+  ]);
+  const refs = /* @__PURE__ */ new Map();
+  const key = (type, id) => `${type}:${id}`;
+  const scorable = [
+    ...guardrails.map((g) => ({
+      type: "guardrail",
+      id: g.id,
+      title: g.title,
+      content: formatGuardrail(g),
+      category: g.category,
+      severity: g.severity,
+      updatedAt: g.updatedAt
+    })),
+    ...specs.filter((s) => s.status !== "archived").map((s) => {
+      refs.set(key("spec", s.specId), {
+        type: "spec",
+        id: s.specId,
+        title: s.name,
+        listLine: `- **${s.name}** \u2014 \`spec_id: ${s.specId}\` (${s.status}, ${s.requirementCount} requirements)`,
+        fetchHint: `get_specs(spec_id="${s.specId}")`
+      });
+      return {
+        type: "spec",
+        id: s.specId,
+        title: s.name,
+        content: formatSpecHeadline(s),
+        updatedAt: s.updatedAt
+      };
+    }),
+    ...docs.items.map((d) => {
+      refs.set(key("doc", d.id), {
+        type: "doc",
+        id: d.id,
+        title: d.title,
+        listLine: `- **${d.title}** \u2014 \`doc_id: ${d.id}\` (\`${d.repo_full_name}/${d.path}\`)`,
+        fetchHint: `get_docs(doc_id="${d.id}")`
+      });
+      return {
+        type: "doc",
+        id: d.id,
+        title: d.title,
+        content: formatDocHeadline(d),
+        category: d.doc_type === "adr" ? "architecture" : void 0,
+        updatedAt: d.synced_at
+      };
+    })
+  ];
+  const ranked = scoreItems(scorable, taskDescription, filePaths);
+  const sections = [];
+  let overhead = 0;
+  if (stack.length > 0) {
+    const section = `## Tech Stack
+
+${formatStack(stack)}`;
+    sections.push(section);
+    overhead += estimateTokens(section);
+  }
+  if (rules.length > 0) {
+    const section = formatRules(rules);
+    sections.push(section);
+    overhead += estimateTokens(section);
+  }
+  let remaining = budget - RESERVE_TOKENS - overhead;
+  const rankedGuardrails = ranked.filter((i) => i.type === "guardrail");
+  const { selected: selectedGuardrails, tokensUsed: guardrailTokens } = selectWithinBudget(
+    rankedGuardrails,
+    Math.max(0, Math.floor(remaining * GUARDRAIL_SHARE))
+  );
+  remaining -= guardrailTokens;
+  const rankedRefs = ranked.filter(
+    (i) => i.type === "spec" || i.type === "doc"
+  );
+  const avgHeadline = rankedRefs.length ? Math.ceil(
+    rankedRefs.slice(0, MAX_HYDRATED).reduce((sum, i) => sum + i.tokenEstimate, 0) / Math.min(rankedRefs.length, MAX_HYDRATED)
+  ) : 0;
+  const affordable = Math.floor(
+    Math.max(0, remaining) / (MIN_BODY_TOKENS + avgHeadline)
+  );
+  const shortlist = rankedRefs.slice(
+    0,
+    Math.max(0, Math.min(MAX_HYDRATED, affordable))
+  );
+  for (const item of shortlist) {
+    remaining -= item.tokenEstimate;
+  }
+  remaining = Math.max(0, remaining);
+  const hydrated = await Promise.all(
+    shortlist.map(
+      (item) => hydrate(api, item, refs.get(key(item.type, item.id)))
+    )
+  );
+  const tailCandidates = rankedRefs.slice(shortlist.length, shortlist.length + MAX_TAIL).map((i) => refs.get(key(i.type, i.id)));
+  const tailCost = tailCandidates.reduce(
+    (sum, m) => sum + estimateTokens(m.listLine),
+    0
+  );
+  const tailReserve = Math.min(
+    tailCost,
+    Math.floor(remaining * TAIL_SHARE)
+  );
+  const bodyBudgetStart = Math.max(0, remaining - tailReserve);
+  let bodyBudget = bodyBudgetStart;
+  let itemsLeft = hydrated.length;
+  let itemsWithBody = 0;
+  let bodyFailures = 0;
+  const blocks = [];
+  for (const h of hydrated) {
+    itemsLeft--;
+    const emit = (block) => {
+      bodyBudget -= Math.max(
+        0,
+        estimateTokens(block) - h.item.tokenEstimate
+      );
+      blocks.push(block);
+    };
+    if (h.error !== void 0) {
+      bodyFailures++;
+      emit(
+        `${h.item.content}
+
+_Body unavailable (${h.error}) \u2014 retry with \`${h.meta.fetchHint}\`._`
+      );
+      continue;
+    }
+    const available = Math.max(0, bodyBudget);
+    const allowance = Math.min(
+      Math.max(MIN_BODY_TOKENS, Math.floor(available / (itemsLeft + 1))),
+      available
+    );
+    if (allowance < MIN_BODY_TOKENS) {
+      emit(
+        `${h.item.content}
+
+_Body omitted (token budget exhausted) \u2014 fetch with \`${h.meta.fetchHint}\`._`
+      );
+      continue;
+    }
+    const { text: body2, truncated } = truncateToTokens(
+      h.body,
+      allowance - TRUNCATION_NOTICE_TOKENS
+    );
+    itemsWithBody++;
+    emit(
+      `${h.item.content}
+
+${body2}` + (truncated ? `
+
+_[truncated to fit the token budget \u2014 full text via \`${h.meta.fetchHint}\`]_` : "")
+    );
+  }
+  remaining = Math.max(0, remaining - (bodyBudgetStart - bodyBudget));
+  if (selectedGuardrails.length > 0) {
+    sections.push(
+      `## Checks (${selectedGuardrails.length})
+
+` + selectedGuardrails.map((i) => i.content).join("\n\n---\n\n")
+    );
+  }
+  if (blocks.length > 0) {
+    sections.push(
+      `## Relevant Specs & Docs (${blocks.length})
+
+_Full text of the highest-ranked items. Every item carries the ID to fetch it in full._
+
+` + blocks.join("\n\n---\n\n")
+    );
+  }
+  const tailLines = [];
+  for (const meta of tailCandidates) {
+    const cost = estimateTokens(meta.listLine);
+    if (cost > remaining) break;
+    tailLines.push(meta.listLine);
+    remaining -= cost;
+  }
+  if (tailLines.length > 0) {
+    sections.push(
+      `## Also Indexed (${tailLines.length})
+
+_Ranked lower \u2014 fetch with \`get_specs\` / \`get_docs\` if you need them._
+
+` + tailLines.join("\n")
+    );
+  }
+  const itemsListed = blocks.length - itemsWithBody + tailLines.length;
+  const itemsOmitted = ranked.length - selectedGuardrails.length - blocks.length - tailLines.length;
+  const body = sections.join("\n\n");
+  const tokensUsed = estimateTokens(body);
+  const stats = {
+    budget,
+    tokensUsed,
+    itemsWithBody,
+    bodyFailures,
+    itemsListed,
+    itemsOmitted: Math.max(0, itemsOmitted),
+    guardrails: selectedGuardrails.length
+  };
+  if (sections.length === 0) {
+    return { text: "No relevant context found for this task.", stats };
+  }
+  const footer = `
+
+---
+_Context: ${itemsWithBody} full text, ${itemsListed} listed, ${stats.itemsOmitted} omitted \xB7 ~${tokensUsed} of ${budget} tokens` + (bodyFailures > 0 ? ` \xB7 ${bodyFailures} body fetch(es) failed` : "") + `_`;
+  return { text: body + footer, stats };
+}
+export {
+  buildContext,
+  estimateTokens
+};

package/dist/lib/deprecation.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tool names are a public API: they are pinned in `.mcp.json` files and agent
+ * permission allowlists that customers have already committed to their own
+ * repositories. A rename is therefore additive — the new name is registered
+ * alongside the old one, and the old one keeps working.
+ *
+ * Nothing is removed before this date, and then only once usage telemetry shows
+ * no calls against the legacy name.
+ */
+export declare const LEGACY_TOOL_REMOVAL_EARLIEST = "2027-01-31";
+export declare function legacyToolDescription(canonical: string, description: string): string;

package/dist/lib/language.d.ts

@@ -0,0 +1,7 @@
+export interface LanguageInfo {
+    language: string;
+    categories: string[];
+}
+export declare function detectLanguage(filePath: string): LanguageInfo | undefined;
+export declare function detectCategories(filePaths: string[]): string[];
+export declare function detectLanguages(filePaths: string[]): string[];

package/dist/lib/scoring.d.ts

@@ -0,0 +1,35 @@
+export interface ScoredItem {
+    type: "guardrail" | "spec" | "doc" | "stack";
+    id: string;
+    title: string;
+    content: string;
+    score: number;
+    tokenEstimate: number;
+}
+interface ScorableItem {
+    type: "guardrail" | "spec" | "doc" | "stack";
+    id: string;
+    title: string;
+    content: string;
+    language?: string;
+    category?: string;
+    severity?: string;
+    updatedAt?: string;
+}
+export declare function estimateTokens(text: string): number;
+/**
+ * Clip text to a token allowance, backing off to the last paragraph or line
+ * break in the final quarter so the cut lands between thoughts rather than
+ * mid-sentence.
+ */
+export declare function truncateToTokens(text: string, maxTokens: number): {
+    text: string;
+    truncated: boolean;
+};
+export declare function scoreItems(items: ScorableItem[], taskDescription: string, filePaths: string[]): ScoredItem[];
+export declare function selectWithinBudget(items: ScoredItem[], maxTokens: number): {
+    selected: ScoredItem[];
+    tokensUsed: number;
+    totalItems: number;
+};
+export {};

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { SystemDoxApiClient } from "./lib/api-client.js";
+/**
+ * Build a SystemDox MCP server with all tools registered against the given
+ * API client. Shared by the stdio entry point (index.ts) and the hosted
+ * Streamable HTTP entry point (http.ts).
+ */
+export declare function createServer(apiClient: SystemDoxApiClient): McpServer;

package/dist/tools/create-guardrail.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { SystemDoxApiClient } from "../lib/api-client.js";
+export declare function registerCreateGuardrail(server: McpServer, apiClient: SystemDoxApiClient): void;

package/dist/tools/create-project-rule.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { SystemDoxApiClient } from "../lib/api-client.js";
+export declare function registerCreateProjectRule(server: McpServer, apiClient: SystemDoxApiClient): void;

package/dist/tools/create-prompt-template.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { SystemDoxApiClient } from "../lib/api-client.js";
+export declare function registerCreatePromptTemplate(server: McpServer, apiClient: SystemDoxApiClient): void;

package/dist/tools/get-context.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { SystemDoxApiClient } from "../lib/api-client.js";
+export declare function registerGetContext(server: McpServer, apiClient: SystemDoxApiClient): void;

package/dist/tools/get-docs.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { SystemDoxApiClient } from "../lib/api-client.js";
+export declare function registerGetDocs(server: McpServer, apiClient: SystemDoxApiClient): void;

package/dist/tools/get-guardrails.d.ts

@@ -0,0 +1,15 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { SystemDoxApiClient } from "../lib/api-client.js";
+export interface Guardrail {
+    id: string;
+    title: string;
+    description: string;
+    category: string;
+    severity: string;
+    pattern: string;
+    fix: string;
+    fitnessTest: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function registerGetGuardrails(server: McpServer, apiClient: SystemDoxApiClient): void;

package/dist/tools/get-planning-context.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { SystemDoxApiClient } from "../lib/api-client.js";
+export declare function registerGetPlanningContext(server: McpServer, apiClient: SystemDoxApiClient): void;

package/dist/tools/get-project-rules.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { SystemDoxApiClient } from "../lib/api-client.js";
+export interface ProjectRule {
+    id: string;
+    text: string;
+    category: string;
+    createdAt: string;
+}
+export declare function registerGetProjectRules(server: McpServer, apiClient: SystemDoxApiClient): void;