@teamix-evo/mcp 0.3.0

package/dist/cli.js

@@ -0,0 +1,1130 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/groups/registry.ts
+import { z } from "zod";
+
+// src/manifest-loader.ts
+import { readFileSync, existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { UiPackageManifestSchema } from "@teamix-evo/registry";
+function resolveManifestPath(startDir = process.cwd()) {
+  const envPath = process.env.TEAMIX_EVO_UI_MANIFEST;
+  if (envPath && existsSync(envPath)) {
+    return envPath;
+  }
+  let dir = resolve(startDir);
+  for (let i = 0; i < 16; i++) {
+    const candidate = join(
+      dir,
+      "node_modules",
+      "@teamix-evo",
+      "ui",
+      "manifest.json"
+    );
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(
+    [
+      "Could not locate @teamix-evo/ui/manifest.json.",
+      `Tried env TEAMIX_EVO_UI_MANIFEST + walking up from ${startDir}.`,
+      "Either install @teamix-evo/ui in the consumer project, or set TEAMIX_EVO_UI_MANIFEST to an absolute path."
+    ].join(" ")
+  );
+}
+function loadManifest(path) {
+  const manifestPath = path ?? resolveManifestPath();
+  const raw = JSON.parse(readFileSync(manifestPath, "utf-8"));
+  const result = UiPackageManifestSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error(
+      `Invalid manifest at ${manifestPath}: ${result.error.message}`
+    );
+  }
+  return {
+    manifest: result.data,
+    rootDir: dirname(manifestPath)
+  };
+}
+function loadMeta(entry, rootDir) {
+  if (!entry.meta) return null;
+  const path = join(rootDir, entry.meta);
+  if (!existsSync(path)) return null;
+  const text = readFileSync(path, "utf-8");
+  return parseFrontmatter(text);
+}
+function parseFrontmatter(text) {
+  const FM_RE2 = /^---\s*\n([\s\S]*?)\n---\s*\n?/;
+  const match = text.match(FM_RE2);
+  if (!match) {
+    return { frontmatter: {}, body: text };
+  }
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    const m = line.match(/^([A-Za-z_][\w-]*)\s*:\s*(.+?)\s*$/);
+    if (m) fm[m[1]] = m[2].replace(/^['"]|['"]$/g, "");
+  }
+  return {
+    frontmatter: fm,
+    body: text.slice(match[0].length)
+  };
+}
+
+// src/groups/registry.ts
+var ListComponentsInput = z.object({
+  status: z.enum(["stable", "experimental", "deprecated"]).optional()
+});
+var GetComponentMetaInput = z.object({
+  id: z.string().min(1)
+});
+var FindComponentsInput = z.object({
+  query: z.string().min(1),
+  limit: z.number().int().positive().max(100).optional()
+});
+var TOOLS = [
+  {
+    name: "list_components",
+    description: "List all UI components in the @teamix-evo/ui registry. Optionally filter by status (stable / experimental / deprecated). Returns id, name, description, status, registryDependencies \u2014 small enough for the model to scan whole.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          enum: ["stable", "experimental", "deprecated"],
+          description: "Filter by maturity status."
+        }
+      }
+    }
+  },
+  {
+    name: "get_component_meta",
+    description: "Fetch the full registry entry + parsed meta.md for a single component by id. Returns props schema reference, registryDependencies, npm dependencies, AI generation rules, and the component description.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: 'Component id (e.g. "button", "data-table").'
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "find_components",
+    description: 'Substring match over component id / name / description. Use when you need a component but don\'t know its exact id (e.g. "find a component supporting async search and pagination"). Returns up to `limit` matches (default 10). Note: substring match is a v0.1 implementation; semantic search is planned for v0.7 (see ADR 0009).',
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Free-text query."
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 100,
+          description: "Max matches to return (default 10)."
+        }
+      },
+      required: ["query"]
+    }
+  }
+];
+var TOOL_NAMES = new Set(TOOLS.map((t) => t.name));
+function pickListEntry(entry) {
+  return {
+    id: entry.id,
+    name: entry.name,
+    type: entry.type,
+    description: entry.description,
+    status: entry.status,
+    deprecatedReason: entry.deprecatedReason,
+    replacedBy: entry.replacedBy,
+    registryDependencies: entry.registryDependencies ?? []
+  };
+}
+function createRegistryGroup(opts = {}) {
+  let cache = opts.loaded ?? null;
+  function getManifest() {
+    if (!cache) cache = loadManifest();
+    return cache;
+  }
+  return {
+    name: "registry",
+    tools: TOOLS,
+    async handle(name, args) {
+      if (!TOOL_NAMES.has(name)) return void 0;
+      if (name === "list_components") {
+        const input = ListComponentsInput.parse(args ?? {});
+        const { manifest } = getManifest();
+        const entries = manifest.entries.filter((e) => e.type === "component").filter((e) => input.status ? e.status === input.status : true).map(pickListEntry);
+        return {
+          content: [{ type: "text", text: JSON.stringify(entries, null, 2) }]
+        };
+      }
+      if (name === "get_component_meta") {
+        const input = GetComponentMetaInput.parse(args);
+        const { manifest, rootDir } = getManifest();
+        const entry = manifest.entries.find((e) => e.id === input.id);
+        if (!entry) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Component not found: ${input.id}. Use list_components to discover ids.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const meta = loadMeta(entry, rootDir);
+        const payload = {
+          entry,
+          meta: meta ?? null
+        };
+        return {
+          content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+        };
+      }
+      if (name === "find_components") {
+        const input = FindComponentsInput.parse(args);
+        const limit = input.limit ?? 10;
+        const q = input.query.toLowerCase();
+        const { manifest } = getManifest();
+        const matches = manifest.entries.filter((e) => e.type === "component").filter((e) => {
+          return e.id.toLowerCase().includes(q) || e.name.toLowerCase().includes(q) || e.description.toLowerCase().includes(q);
+        }).slice(0, limit).map(pickListEntry);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  query: input.query,
+                  limit,
+                  count: matches.length,
+                  results: matches
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      return void 0;
+    }
+  };
+}
+
+// src/groups/adr.ts
+import { z as z2 } from "zod";
+
+// src/adr-loader.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+function resolveAdrRoot(startDir = process.cwd()) {
+  const envPath = process.env.TEAMIX_EVO_ADR_ROOT;
+  if (envPath && existsSync2(envPath)) {
+    return envPath;
+  }
+  let dir = resolve2(startDir);
+  for (let i = 0; i < 16; i++) {
+    const candidates = [
+      join2(dir, "docs", "adr"),
+      join2(dir, ".teamix-evo", "adr")
+    ];
+    for (const c of candidates) {
+      if (existsSync2(c)) return c;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(
+    [
+      "Could not locate ADR directory.",
+      `Tried env TEAMIX_EVO_ADR_ROOT + walking up from ${startDir} for docs/adr/ or .teamix-evo/adr/.`,
+      "Either run from a teamix-evo monorepo, or set TEAMIX_EVO_ADR_ROOT to an absolute path."
+    ].join(" ")
+  );
+}
+var SKIP_FILES = /* @__PURE__ */ new Set(["README.md", "_template.md"]);
+var ID_RE = /^(\d{4})-/;
+var H1_RE = /^#\s+\d{4}\.\s+(.+?)\s*$/m;
+var STATUS_RE = /^-\s+\*\*Status\*\*:\s*(.+?)\s*$/m;
+var DATE_RE = /^-\s+\*\*Date\*\*:\s*(.+?)\s*$/m;
+var REGION_RE = /^-\s+\*\*Region\*\*:\s*(.+?)\s*$/m;
+function parseAdr(slug, filePath) {
+  const idMatch = slug.match(ID_RE);
+  if (!idMatch) return null;
+  const id = idMatch[1];
+  const text = readFileSync2(filePath, "utf-8");
+  const titleMatch = text.match(H1_RE);
+  const statusMatch = text.match(STATUS_RE);
+  const dateMatch = text.match(DATE_RE);
+  const regionMatch = text.match(REGION_RE);
+  return {
+    id,
+    slug,
+    title: titleMatch?.[1] ?? slug,
+    status: statusMatch?.[1] ?? "",
+    date: dateMatch?.[1] ?? "",
+    region: regionMatch?.[1] ?? "",
+    filePath
+  };
+}
+function loadAdrIndex(rootDir) {
+  const root = rootDir ?? resolveAdrRoot();
+  const files = readdirSync(root).filter(
+    (f) => f.endsWith(".md") && !SKIP_FILES.has(f)
+  );
+  const entries = [];
+  for (const f of files) {
+    const slug = f.replace(/\.md$/, "");
+    const entry = parseAdr(slug, join2(root, f));
+    if (entry) entries.push(entry);
+  }
+  entries.sort((a, b) => a.id.localeCompare(b.id));
+  return { rootDir: root, entries };
+}
+function findAdr(loaded, idOrSlug) {
+  const needle = idOrSlug.trim();
+  if (/^\d{4}$/.test(needle)) {
+    return loaded.entries.find((e) => e.id === needle) ?? null;
+  }
+  return loaded.entries.find((e) => e.slug === needle) ?? loaded.entries.find((e) => e.id === needle) ?? null;
+}
+function loadAdrContent(entry) {
+  return readFileSync2(entry.filePath, "utf-8");
+}
+
+// src/groups/adr.ts
+var ListInput = z2.object({
+  /** Match `Status` line by substring (case-insensitive). */
+  status: z2.string().min(1).optional()
+});
+var GetInput = z2.object({
+  /** ADR id ("0011") or full slug ("0011-mcp-single-package-multi-group"). */
+  id: z2.string().min(1)
+});
+var FindInput = z2.object({
+  query: z2.string().min(1),
+  limit: z2.number().int().positive().max(50).optional(),
+  /**
+   * When true, returns a snippet (~200 chars) around each match so the model
+   * can decide whether to fetch the full ADR. Defaults to true.
+   */
+  withSnippets: z2.boolean().optional()
+});
+var TOOLS2 = [
+  {
+    name: "adr_list",
+    description: 'List all Architecture Decision Records (ADRs) in docs/adr/. Returns id (4-digit), slug, title, status, date, region for each. Use this as the first call to discover which decisions exist before drilling into one with adr_get. Filter by status substring (e.g. "Accepted" / "Proposed" / "Superseded") to narrow down.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          description: 'Optional case-insensitive substring filter against the ADR Status line. Examples: "Accepted", "Proposed", "Superseded".'
+        }
+      }
+    }
+  },
+  {
+    name: "adr_get",
+    description: 'Fetch the full markdown body of one ADR by id ("0011") or slug ("0011-mcp-single-package-multi-group"). Returns the entry metadata + raw markdown so the model can cite specific sections (Context / Decision / Consequences / Source). Use after adr_list / adr_find to read a specific decision in full.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: 'ADR id ("0011") or full slug ("0011-mcp-single-package-multi-group").'
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "adr_find",
+    description: 'Substring search across ADR titles and bodies (case-insensitive). Use when you remember a phrase ("source-mirror", "lint-core", "no baseline") but not which ADR it lives in. Returns up to `limit` matches (default 10) with optional snippets (~200 chars around each match). Combine with adr_get for the full text.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Free-text query." },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 50,
+          description: "Max matches to return (default 10)."
+        },
+        withSnippets: {
+          type: "boolean",
+          description: "Include ~200-char snippet around each match (default true)."
+        }
+      },
+      required: ["query"]
+    }
+  }
+];
+var TOOL_NAMES2 = new Set(TOOLS2.map((t) => t.name));
+function pickEntry(e) {
+  return {
+    id: e.id,
+    slug: e.slug,
+    title: e.title,
+    status: e.status,
+    date: e.date,
+    region: e.region
+  };
+}
+var SNIPPET_RADIUS = 100;
+function snippet(text, index) {
+  const start = Math.max(0, index - SNIPPET_RADIUS);
+  const end = Math.min(text.length, index + SNIPPET_RADIUS);
+  const prefix = start > 0 ? "\u2026" : "";
+  const suffix = end < text.length ? "\u2026" : "";
+  return prefix + text.slice(start, end).replace(/\s+/g, " ").trim() + suffix;
+}
+function createAdrGroup(opts = {}) {
+  let cache = opts.loaded ?? null;
+  function getIndex() {
+    if (!cache) cache = loadAdrIndex();
+    return cache;
+  }
+  return {
+    name: "adr",
+    tools: TOOLS2,
+    async handle(name, args) {
+      if (!TOOL_NAMES2.has(name)) return void 0;
+      if (name === "adr_list") {
+        const input = ListInput.parse(args ?? {});
+        const idx = getIndex();
+        const needle = input.status?.toLowerCase();
+        const entries = idx.entries.filter(
+          (e) => needle ? e.status.toLowerCase().includes(needle) : true
+        ).map(pickEntry);
+        return {
+          content: [{ type: "text", text: JSON.stringify(entries, null, 2) }]
+        };
+      }
+      if (name === "adr_get") {
+        const input = GetInput.parse(args);
+        const idx = getIndex();
+        const entry = findAdr(idx, input.id);
+        if (!entry) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `ADR not found: ${input.id}. Use adr_list to discover ids.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const text = loadAdrContent(entry);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                { entry: pickEntry(entry), content: text },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (name === "adr_find") {
+        const input = FindInput.parse(args);
+        const limit = input.limit ?? 10;
+        const withSnippets = input.withSnippets ?? true;
+        const needle = input.query.toLowerCase();
+        const idx = getIndex();
+        const matches = [];
+        for (const entry of idx.entries) {
+          const body = loadAdrContent(entry).toLowerCase();
+          const titleHit = entry.title.toLowerCase().includes(needle);
+          if (!titleHit && !body.includes(needle)) continue;
+          const snippets = [];
+          if (withSnippets) {
+            const rawBody = loadAdrContent(entry);
+            let from2 = 0;
+            for (let i = 0; i < 3; i++) {
+              const at = rawBody.toLowerCase().indexOf(needle, from2);
+              if (at < 0) break;
+              snippets.push(snippet(rawBody, at));
+              from2 = at + needle.length;
+            }
+          }
+          let hits = titleHit ? 1 : 0;
+          let from = 0;
+          for (; ; ) {
+            const at = body.indexOf(needle, from);
+            if (at < 0) break;
+            hits++;
+            from = at + needle.length;
+          }
+          matches.push({
+            entry: pickEntry(entry),
+            ...withSnippets ? { snippets } : {},
+            hitCount: hits
+          });
+        }
+        matches.sort((a, b) => b.hitCount - a.hitCount);
+        const sliced = matches.slice(0, limit);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  query: input.query,
+                  limit,
+                  count: sliced.length,
+                  totalMatchingAdrs: matches.length,
+                  results: sliced
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      return void 0;
+    }
+  };
+}
+
+// src/groups/skills.ts
+import { z as z3 } from "zod";
+
+// src/skills-loader.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync } from "fs";
+import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
+import {
+  SkillsPackageManifestSchema
+} from "@teamix-evo/registry";
+function resolveSkillsRoot(startDir = process.cwd()) {
+  const envPath = process.env.TEAMIX_EVO_SKILLS_ROOT;
+  if (envPath && existsSync3(join3(envPath, "manifest.json"))) {
+    return envPath;
+  }
+  let dir = resolve3(startDir);
+  for (let i = 0; i < 16; i++) {
+    const candidates = [
+      join3(dir, "packages", "skills"),
+      join3(dir, "node_modules", "@teamix-evo", "skills")
+    ];
+    for (const c of candidates) {
+      if (existsSync3(join3(c, "manifest.json"))) return c;
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(
+    [
+      "Could not locate @teamix-evo/skills root.",
+      `Tried env TEAMIX_EVO_SKILLS_ROOT + walking up from ${startDir}.`,
+      "Either install @teamix-evo/skills or run from a monorepo, or set TEAMIX_EVO_SKILLS_ROOT to an absolute path."
+    ].join(" ")
+  );
+}
+function loadSkillsManifest(rootDir) {
+  const root = rootDir ?? resolveSkillsRoot();
+  const manifestPath = join3(root, "manifest.json");
+  const raw = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+  const parsed = SkillsPackageManifestSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid skills manifest at ${manifestPath}: ${parsed.error.message}`
+    );
+  }
+  return { rootDir: root, manifest: parsed.data };
+}
+var FM_RE = /^---\s*\n([\s\S]*?)\n---\s*\n?/;
+function parseFrontmatter2(text) {
+  const m = text.match(FM_RE);
+  if (!m) return { frontmatter: {}, body: text };
+  const fm = {};
+  for (const line of m[1].split("\n")) {
+    const kv = line.match(/^([A-Za-z_][\w-]*)\s*:\s*(.+?)\s*$/);
+    if (kv) fm[kv[1]] = kv[2].replace(/^['"]|['"]$/g, "");
+  }
+  return { frontmatter: fm, body: text.slice(m[0].length) };
+}
+function loadSkillContent(entry, rootDir) {
+  const sourcePath = join3(rootDir, entry.source);
+  if (!existsSync3(sourcePath)) return null;
+  let skillMdPath;
+  let attachments = [];
+  const dirCandidate = join3(sourcePath, "SKILL.md");
+  if (existsSync3(dirCandidate)) {
+    skillMdPath = dirCandidate;
+    try {
+      attachments = readdirSync2(sourcePath).filter((f) => f.endsWith(".md") && f !== "SKILL.md").filter((f) => {
+        try {
+          return statSync(join3(sourcePath, f)).isFile();
+        } catch {
+          return false;
+        }
+      });
+    } catch {
+      attachments = [];
+    }
+  } else {
+    skillMdPath = sourcePath;
+  }
+  const text = readFileSync3(skillMdPath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter2(text);
+  return {
+    entry,
+    text,
+    body,
+    frontmatter,
+    filePath: skillMdPath,
+    attachments
+  };
+}
+function findSkill(loaded, idOrName) {
+  const needle = idOrName.trim();
+  return loaded.manifest.skills.find((s) => s.id === needle) ?? loaded.manifest.skills.find((s) => s.name === needle) ?? null;
+}
+
+// src/groups/skills.ts
+var ListInput2 = z3.object({});
+var GetInput2 = z3.object({
+  id: z3.string().min(1)
+});
+var FindInput2 = z3.object({
+  query: z3.string().min(1),
+  limit: z3.number().int().positive().max(50).optional(),
+  /**
+   * Scope: 'description' (default — fast, only matches the AI trigger contract)
+   * or 'body' (slower — matches across SKILL.md prose, useful for "where do we
+   * mention X" questions).
+   */
+  scope: z3.enum(["description", "body", "all"]).optional()
+});
+var TOOLS3 = [
+  {
+    name: "skills_list",
+    description: "List all SKILL.md entries shipped by @teamix-evo/skills. Returns id, name, description (the AI trigger contract), version, source path, ides, updateStrategy. Use this to discover which skills exist before invoking one via the IDE's skill mechanism.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "skills_get",
+    description: "Fetch the full SKILL.md content (frontmatter + body) for one skill by id or name. Also lists attachment files (sibling .md docs the skill references). Use after skills_list / skills_find to read the actual rules / decision tree / checklist that the skill encodes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Skill id or name (matches manifest.skills[].id or .name)."
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "skills_find",
+    description: 'Substring search across skill descriptions and bodies. Default scope is `description` (matches the AI trigger contract \u2014 fast). Set `scope: "body"` to search SKILL.md prose, or `scope: "all"` for both. Use when you remember a phrase ("token refresh", "design review", "drift scan") but not the skill id.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Free-text query." },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 50,
+          description: "Max matches to return (default 10)."
+        },
+        scope: {
+          type: "string",
+          enum: ["description", "body", "all"],
+          description: 'Where to search: "description" (frontmatter, default), "body" (SKILL.md prose), or "all".'
+        }
+      },
+      required: ["query"]
+    }
+  }
+];
+var TOOL_NAMES3 = new Set(TOOLS3.map((t) => t.name));
+function pickEntry2(s) {
+  return {
+    id: s.id,
+    name: s.name,
+    description: s.description,
+    version: s.version,
+    source: s.source,
+    ides: s.ides ?? [],
+    updateStrategy: s.updateStrategy ?? "managed",
+    template: s.template ?? false
+  };
+}
+function createSkillsGroup(opts = {}) {
+  let cache = opts.loaded ?? null;
+  function getManifest() {
+    if (!cache) cache = loadSkillsManifest();
+    return cache;
+  }
+  return {
+    name: "skills",
+    tools: TOOLS3,
+    async handle(name, args) {
+      if (!TOOL_NAMES3.has(name)) return void 0;
+      if (name === "skills_list") {
+        ListInput2.parse(args ?? {});
+        const { manifest } = getManifest();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(manifest.skills.map(pickEntry2), null, 2)
+            }
+          ]
+        };
+      }
+      if (name === "skills_get") {
+        const input = GetInput2.parse(args);
+        const loaded = getManifest();
+        const entry = findSkill(loaded, input.id);
+        if (!entry) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Skill not found: ${input.id}. Use skills_list to discover ids.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const content = loadSkillContent(entry, loaded.rootDir);
+        if (!content) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Skill source missing on disk for "${entry.id}" (expected at ${entry.source}). Check packages/skills installation.`
+              }
+            ],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  entry: pickEntry2(entry),
+                  attachments: content.attachments,
+                  content: content.text
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (name === "skills_find") {
+        const input = FindInput2.parse(args);
+        const limit = input.limit ?? 10;
+        const scope = input.scope ?? "description";
+        const needle = input.query.toLowerCase();
+        const loaded = getManifest();
+        const matches = [];
+        for (const entry of loaded.manifest.skills) {
+          const descHit = scope !== "body" && entry.description.toLowerCase().includes(needle);
+          let bodyHit = false;
+          if (scope === "body" || scope === "all") {
+            const content = loadSkillContent(entry, loaded.rootDir);
+            if (content) {
+              bodyHit = content.text.toLowerCase().includes(needle);
+            }
+          }
+          if (!descHit && !bodyHit) continue;
+          matches.push({
+            entry: pickEntry2(entry),
+            hitIn: descHit && bodyHit ? "both" : descHit ? "description" : "body"
+          });
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  query: input.query,
+                  scope,
+                  limit,
+                  count: Math.min(matches.length, limit),
+                  totalMatches: matches.length,
+                  results: matches.slice(0, limit)
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      return void 0;
+    }
+  };
+}
+
+// src/groups/design.ts
+import { z as z4 } from "zod";
+
+// src/design-loader.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { dirname as dirname4, join as join4, resolve as resolve4 } from "path";
+function resolveDesignRoot(startDir = process.cwd()) {
+  const envPath = process.env.TEAMIX_EVO_DESIGN_ROOT;
+  if (envPath && existsSync4(envPath)) {
+    return envPath;
+  }
+  let dir = resolve4(startDir);
+  for (let i = 0; i < 16; i++) {
+    const candidate = join4(dir, ".teamix-evo", "design");
+    if (existsSync4(candidate)) return candidate;
+    const parent = dirname4(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function loadDesign(rootDir) {
+  const root = rootDir ?? resolveDesignRoot();
+  if (!root) return null;
+  let variant = null;
+  const lockPath = join4(root, "pack.lock.json");
+  if (existsSync4(lockPath)) {
+    try {
+      const raw = JSON.parse(readFileSync4(lockPath, "utf-8"));
+      variant = typeof raw.variant === "string" ? raw.variant : null;
+    } catch {
+      variant = null;
+    }
+  }
+  return { rootDir: root, variant };
+}
+var PRINCIPLE_HEADING_RE = /^#{2,3}\s+(P\d+)\s*[·:]\s*(.+?)\s*$/;
+function readPrinciples(loaded) {
+  const filePath = join4(loaded.rootDir, "philosophy", "principles.md");
+  if (!existsSync4(filePath)) {
+    return {
+      principles: [],
+      sourcePath: null,
+      note: "philosophy/principles.md not found in this project. Run `teamix-evo design init <variant>` to install it."
+    };
+  }
+  const text = readFileSync4(filePath, "utf-8");
+  const lines = text.split(/\r?\n/);
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(PRINCIPLE_HEADING_RE);
+    if (!m) continue;
+    let def = "";
+    for (let j = i + 1; j < lines.length && j < i + 8; j++) {
+      const candidate = lines[j].trim();
+      if (!candidate) continue;
+      if (/^#{1,6}\s/.test(candidate)) break;
+      def = candidate.replace(/^[*_>\s-]+/, "").trim();
+      break;
+    }
+    out.push({ id: m[1], name: m[2].trim(), oneLineDef: def });
+  }
+  return { principles: out, sourcePath: filePath };
+}
+function resolveTokensDir(loaded) {
+  const projectRoot = dirname4(loaded.rootDir);
+  const lifted = join4(projectRoot, "tokens");
+  if (existsSync4(lifted)) return lifted;
+  const legacy = join4(loaded.rootDir, "foundations", "tokens");
+  if (existsSync4(legacy)) return legacy;
+  return null;
+}
+function readTokens(loaded) {
+  const tokensDir = resolveTokensDir(loaded);
+  const out = { sources: [] };
+  if (!tokensDir) {
+    out.note = ".teamix-evo/tokens/ not found in this project (and no legacy foundations/tokens/).";
+    return out;
+  }
+  const tryJson = (rel) => {
+    const fp = join4(tokensDir, rel);
+    if (!existsSync4(fp)) return void 0;
+    out.sources.push(fp);
+    try {
+      return JSON.parse(readFileSync4(fp, "utf-8"));
+    } catch {
+      return void 0;
+    }
+  };
+  const tryText = (rel) => {
+    const fp = join4(tokensDir, rel);
+    if (!existsSync4(fp)) return void 0;
+    out.sources.push(fp);
+    return readFileSync4(fp, "utf-8");
+  };
+  out.base = tryJson("base.tokens.json");
+  out.semantic = tryJson("semantic.tokens.json");
+  out.themeCss = tryText("tokens.theme.css");
+  out.overridesCss = tryText("tokens.overrides.css");
+  return out;
+}
+var VARIANT_PREFIX_RE = /^(cloud|opentrek|uni-manager|enterprise)-/i;
+function readPatternIndex(loaded) {
+  const patternsDir = join4(loaded.rootDir, "patterns");
+  if (!existsSync4(patternsDir)) return [];
+  const out = [];
+  for (const name of readdirSync3(patternsDir)) {
+    if (!name.endsWith(".md")) continue;
+    const fp = join4(patternsDir, name);
+    try {
+      if (!statSync2(fp).isFile()) continue;
+    } catch {
+      continue;
+    }
+    const stem = name.replace(/\.md$/, "");
+    const text = readFileSync4(fp, "utf-8");
+    const titleMatch = text.match(/^#\s+(.+?)\s*$/m);
+    out.push({
+      id: stem,
+      title: titleMatch ? titleMatch[1] : stem,
+      sourcePath: fp,
+      variantSpecific: VARIANT_PREFIX_RE.test(stem)
+    });
+  }
+  return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+function readPatternContent(loaded, id) {
+  const stem = id.replace(/\.md$/, "");
+  const fp = join4(loaded.rootDir, "patterns", `${stem}.md`);
+  if (!existsSync4(fp)) return null;
+  return {
+    id: stem,
+    sourcePath: fp,
+    content: readFileSync4(fp, "utf-8")
+  };
+}
+function readBrand(loaded) {
+  const brandDir = join4(loaded.rootDir, "brand");
+  const out = {};
+  if (!existsSync4(brandDir)) {
+    out.note = "brand/ not present \u2014 this design variant does not ship brand-specific tone / voice / examples.";
+    return out;
+  }
+  for (const key of ["tone", "voice", "examples"]) {
+    const fp = join4(brandDir, `${key}.md`);
+    if (existsSync4(fp)) {
+      out[key] = { sourcePath: fp, content: readFileSync4(fp, "utf-8") };
+    }
+  }
+  return out;
+}
+
+// src/groups/design.ts
+var EmptyInput = z4.object({});
+var GetPatternInput = z4.object({
+  id: z4.string().min(1)
+});
+var TOOLS4 = [
+  {
+    name: "design_list_principles",
+    description: 'List the design principles defined by the consumer project\'s installed design variant. Reads `.teamix-evo/design/philosophy/principles.md` and parses headings of the form `## P1 \xB7 Name`. Returns id, display name, and a one-line definition for each. Use this when the user asks about "the four principles", "design philosophy", or to ground a design review in the variant\'s stated values. Returns `{ principles: [], note: "..." }` if the project hasn\'t installed a design pack.',
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "design_get_tokens",
+    description: "Fetch the consumer project's design tokens \u2014 parsed JSON from `.teamix-evo/tokens/base.tokens.json` and `semantic.tokens.json`, plus raw text of `tokens.theme.css` (variant theme) and `tokens.overrides.css` (user-owned overrides) when present. Use when AI needs to know what semantic colors / spacing / radii are available before writing component styles. JSON is for introspection; CSS is for copy-paste. Each tool result lists `sources` so you can cite paths.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "design_list_patterns",
+    description: "Index every pattern in `.teamix-evo/design/patterns/*.md` (page types, journeys, flows, plus variant-specific markers like `cloud-*`, `opentrek-*`, `uni-manager-*`). Returns `{ id, title, sourcePath, variantSpecific }` for each. Use this before `design_get_pattern` to discover which patterns exist. When both a baseline (`page-types`) and a variant-specific (`cloud-page-types`) entry are available, prefer the variant-specific one for projects that match.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "design_get_pattern",
+    description: "Fetch the full markdown body of one pattern by id (filename stem, e.g. `page-types` or `cloud-page-types`). Use after `design_list_patterns` discovered the id. Returns the raw markdown plus `sourcePath`. Returns isError if the id does not exist \u2014 call `design_list_patterns` first to discover available ids.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: 'Pattern id \u2014 filename stem under `patterns/`, e.g. "page-types", "cloud-page-types".'
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "design_get_brand",
+    description: "Fetch the consumer project's variant-specific brand voice \u2014 `brand/tone.md`, `brand/voice.md`, `brand/examples.md`. Each is optional; the response contains only the files that exist. Some variants (like `_template` or `default`) ship no brand content \u2014 that's not an error, the response simply lists no entries. Use this when generating or reviewing user-facing copy, error messages, empty states, or onboarding text where brand voice matters.",
+    inputSchema: { type: "object", properties: {} }
+  }
+];
+var TOOL_NAMES4 = new Set(TOOLS4.map((t) => t.name));
+var NO_DESIGN_NOTE = ".teamix-evo/design/ not found in this project. Run `npx teamix-evo design init <variant>` to install a design pack.";
+function createDesignGroup(opts = {}) {
+  let cache = opts.loaded === void 0 ? void 0 : opts.loaded;
+  function getDesign() {
+    if (cache === void 0) cache = loadDesign(opts.rootDir);
+    return cache;
+  }
+  return {
+    name: "design",
+    tools: TOOLS4,
+    async handle(name, args) {
+      if (!TOOL_NAMES4.has(name)) return void 0;
+      const loaded = getDesign();
+      if (name === "design_list_principles") {
+        EmptyInput.parse(args ?? {});
+        if (!loaded) {
+          return jsonResult({ principles: [], sourcePath: null, note: NO_DESIGN_NOTE });
+        }
+        return jsonResult(readPrinciples(loaded));
+      }
+      if (name === "design_get_tokens") {
+        EmptyInput.parse(args ?? {});
+        if (!loaded) {
+          return jsonResult({ sources: [], note: NO_DESIGN_NOTE });
+        }
+        return jsonResult(readTokens(loaded));
+      }
+      if (name === "design_list_patterns") {
+        EmptyInput.parse(args ?? {});
+        if (!loaded) {
+          return jsonResult({ patterns: [], note: NO_DESIGN_NOTE });
+        }
+        return jsonResult({
+          variant: loaded.variant,
+          patterns: readPatternIndex(loaded)
+        });
+      }
+      if (name === "design_get_pattern") {
+        const input = GetPatternInput.parse(args);
+        if (!loaded) {
+          return {
+            content: [{ type: "text", text: NO_DESIGN_NOTE }],
+            isError: true
+          };
+        }
+        const result = readPatternContent(loaded, input.id);
+        if (!result) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Pattern not found: ${input.id}. Use design_list_patterns to discover available ids.`
+              }
+            ],
+            isError: true
+          };
+        }
+        return jsonResult(result);
+      }
+      if (name === "design_get_brand") {
+        EmptyInput.parse(args ?? {});
+        if (!loaded) {
+          return jsonResult({ note: NO_DESIGN_NOTE });
+        }
+        return jsonResult(readBrand(loaded));
+      }
+      return void 0;
+    }
+  };
+}
+function jsonResult(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+
+// src/server.ts
+function createServer(opts = {}) {
+  const groups = [
+    createRegistryGroup(opts.registry),
+    createAdrGroup(opts.adr),
+    createSkillsGroup(opts.skills),
+    createDesignGroup(opts.design)
+    // Future: createScenarioGroup(opts.scenario), // ADR 0011, v0.8
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const group of groups) {
+    for (const tool of group.tools) {
+      if (seen.has(tool.name)) {
+        throw new Error(
+          `Duplicate MCP tool name across groups: ${tool.name}. Each group must use unique tool names \u2014 see ADR 0011 \xA75.`
+        );
+      }
+      seen.add(tool.name);
+    }
+  }
+  const allTools = groups.flatMap((g) => g.tools);
+  const server = new Server(
+    {
+      name: "@teamix-evo/mcp",
+      version: "0.2.0"
+    },
+    {
+      capabilities: { tools: {} }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: allTools
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params;
+    for (const group of groups) {
+      const result = await group.handle(name, args);
+      if (result !== void 0) return result;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Unknown tool: ${name}. Use tools/list to discover available tools.`
+        }
+      ],
+      isError: true
+    };
+  });
+  return server;
+}
+
+// src/cli.ts
+async function main() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("[teamix-evo-mcp] fatal:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map