designmd-forge 1.2.0

package/dist/tools/browse.js

@@ -0,0 +1,232 @@
+import { z } from 'zod';
+import { loadIndex, listCategories, searchDesigns } from '../services/designStore.js';
+import { SOURCE_REPO, SOURCE_LICENSE, SOURCE_BY_PLATFORM, PLATFORMS } from '../constants.js';
+const ListDesignsInputSchema = z
+    .object({
+    category: z
+        .string()
+        .optional()
+        .describe("Optional exact category name to filter by (see designmd_list_categories for valid values, e.g. 'Fintech & Crypto' or 'Mobile')."),
+    platform: z
+        .enum(PLATFORMS)
+        .optional()
+        .describe("Optional platform to filter by: 'web' (VoltAgent desktop design systems) or 'mobile' (TrustOtc mobile archetypes). Omit for both."),
+})
+    .strict();
+const SearchDesignsInputSchema = z
+    .object({
+    query: z
+        .string()
+        .min(1, 'Query must not be empty')
+        .max(200, 'Query must not exceed 200 characters')
+        .describe("Free-text search terms matched against each design's title, slug, category, and description (e.g. 'dark fintech dashboard', 'warm minimal serif', 'automotive luxury black', 'mobile dark pro tool')."),
+    category: z
+        .string()
+        .optional()
+        .describe('Optional exact category name to restrict the search to.'),
+    platform: z
+        .enum(PLATFORMS)
+        .optional()
+        .describe("Optional platform to restrict the search to: 'web' or 'mobile'. Omit for both."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe('Maximum number of results to return (default 10, max 50).'),
+})
+    .strict();
+const ListCategoriesInputSchema = z
+    .object({
+    platform: z
+        .enum(PLATFORMS)
+        .optional()
+        .describe("Optional platform to restrict the category listing to: 'web' or 'mobile'. Omit for both."),
+})
+    .strict();
+export function registerBrowseTools(server) {
+    server.registerTool('designmd_list_categories', {
+        title: 'List DESIGN.md Categories',
+        description: `List every category present in the local DESIGN.md collection, with a count of designs in each.
+
+This is a read-only tool. Call it first if you don't know what categories exist (e.g. "Fintech & Crypto", "Automotive", "AI & LLM Platforms", "Mobile") before filtering designmd_list_designs or designmd_search_designs by category. The "Mobile" category holds the TrustOtc mobile archetypes.
+
+Args:
+  - platform (web|mobile, optional): restrict the listing to one platform's categories. Omit for all.
+
+Returns:
+  JSON with schema:
+  {
+    "source": string,          // primary (web) upstream repo URL
+    "license": string,         // "MIT"
+    "sources": { "web": string, "mobile": string, "ios": string },  // upstream repo per platform
+    "categories": [
+      { "name": string, "count": number }
+    ]
+  }`,
+        inputSchema: ListCategoriesInputSchema.shape,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params) => {
+        const index = loadIndex();
+        const designs = params.platform
+            ? index.designs.filter((d) => d.platform === params.platform)
+            : index.designs;
+        const categories = listCategories()
+            .map((name) => ({
+            name,
+            count: designs.filter((d) => d.category === name).length,
+        }))
+            .filter((c) => c.count > 0);
+        const output = {
+            source: SOURCE_REPO,
+            license: SOURCE_LICENSE,
+            sources: SOURCE_BY_PLATFORM,
+            categories,
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
+            structuredContent: output,
+        };
+    });
+    server.registerTool('designmd_list_designs', {
+        title: 'List All DESIGN.md Files',
+        description: `List every design system available in the local DESIGN.md collection, optionally filtered by category.
+
+Each entry includes a title, slug, category, and a one-line description — enough to browse and pick candidates before calling designmd_get_design_md for the full file. Does NOT return full DESIGN.md content (use designmd_get_design_md for that).
+
+Data comes from a local snapshot of VoltAgent/awesome-design-md (MIT licensed). These are reverse-engineered design tokens (colors, type, spacing, components) extracted from publicly visible CSS — no logos, trademarks, or copyrighted imagery are included.
+
+Args:
+  - category (string, optional): Exact category name to filter by. Omit to list all.
+
+Returns:
+  JSON with schema:
+  {
+    "source": string,
+    "license": string,
+    "total": number,
+    "designs": [
+      { "slug": string, "title": string, "category": string, "short_description": string }
+    ]
+  }
+
+Examples:
+  - Use when: "what design systems do you have for crypto/fintech sites?" -> category="Fintech & Crypto"
+  - Use when: "show me everything available" -> no category
+  - Don't use when: you already know the exact slug and just want the file (use designmd_get_design_md instead)`,
+        inputSchema: ListDesignsInputSchema.shape,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params) => {
+        const index = loadIndex();
+        const filtered = index.designs.filter((d) => {
+            if (params.platform && d.platform !== params.platform)
+                return false;
+            if (params.category && d.category.toLowerCase() !== params.category.toLowerCase())
+                return false;
+            return true;
+        });
+        if (params.category && filtered.length === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `No designs found for category "${params.category}". Call designmd_list_categories to see valid category names.`,
+                    },
+                ],
+            };
+        }
+        const output = {
+            source: SOURCE_REPO,
+            license: SOURCE_LICENSE,
+            total: filtered.length,
+            designs: filtered.map((d) => ({
+                slug: d.slug,
+                title: d.title,
+                category: d.category,
+                platform: d.platform ?? 'web',
+                short_description: d.short_description,
+            })),
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
+            structuredContent: output,
+        };
+    });
+    server.registerTool('designmd_search_designs', {
+        title: 'Search DESIGN.md Files',
+        description: `Search the local DESIGN.md collection by free-text query against title, slug, category, and description text.
+
+Use this when you have a vibe/keyword in mind ("dark cinematic AI product", "warm editorial serif brand", "minimal black and white luxury automotive") rather than an exact site name. Results are ranked by relevance score (title and slug matches weigh highest). Does NOT return full DESIGN.md content — call designmd_get_design_md with the returned slug for that.
+
+Args:
+  - query (string, required): Free-text search terms, 1-200 characters.
+  - category (string, optional): Restrict results to one exact category.
+  - limit (number, optional): Max results, 1-50 (default 10).
+
+Returns:
+  JSON with schema:
+  {
+    "query": string,
+    "total_matches": number,
+    "results": [
+      { "slug": string, "title": string, "category": string, "short_description": string, "score": number }
+    ]
+  }
+  Returns an empty "results" array (not an error) if nothing matches.
+
+Examples:
+  - Use when: "find me something dark and terminal-y for a dev tool" -> query="dark terminal developer"
+  - Use when: "any luxury car brands with black and gold?" -> query="luxury black gold automotive"
+  - Don't use when: you already know the exact site slug (use designmd_get_design_md directly)`,
+        inputSchema: SearchDesignsInputSchema.shape,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params) => {
+        const results = searchDesigns(params.query, {
+            category: params.category,
+            platform: params.platform,
+            limit: params.limit,
+        });
+        if (results.length === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `No designs matched query "${params.query}"${params.category ? ` in category "${params.category}"` : ''}. Try broader or different terms, or call designmd_list_designs to browse everything.`,
+                    },
+                ],
+            };
+        }
+        const output = {
+            query: params.query,
+            total_matches: results.length,
+            results: results.map((r) => ({
+                slug: r.slug,
+                title: r.title,
+                category: r.category,
+                platform: r.platform ?? 'web',
+                short_description: r.short_description,
+                score: r.score,
+            })),
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
+            structuredContent: output,
+        };
+    });
+}

package/dist/tools/diff.js

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { getEntryBySlug, readDesignMdContent } from '../services/designStore.js';
+import { diffDesignMdContent } from '../services/linter.js';
+const SideSchema = z
+    .object({
+    content: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Raw DESIGN.md markdown for this side (e.g. a draft you're writing)."),
+    slug: z
+        .string()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("Slug of a bundled reference design for this side (e.g. 'stripe')."),
+})
+    .strict()
+    .refine((s) => (s.content ? 1 : 0) + (s.slug ? 1 : 0) === 1, {
+    message: "Provide exactly one of 'content' or 'slug' per side",
+});
+const DiffInputSchema = z
+    .object({
+    before: SideSchema.describe('The baseline DESIGN.md side (before).'),
+    after: SideSchema.describe('The changed DESIGN.md side (after).'),
+})
+    .strict();
+async function resolveSide(side) {
+    if (side.content)
+        return side.content;
+    const entry = getEntryBySlug(side.slug);
+    if (!entry)
+        throw new Error(`No design found for slug '${side.slug}'`);
+    return readDesignMdContent(entry.slug);
+}
+function countTokenChanges(result) {
+    let count = 0;
+    for (const set of Object.values(result.tokens ?? {})) {
+        count += set.added.length + set.removed.length + set.modified.length;
+    }
+    return count;
+}
+export function registerDiffTool(server) {
+    server.registerTool('designmd_diff', {
+        title: 'Diff Two DESIGN.md Files',
+        description: `Compare two DESIGN.md documents with the official @google/design.md CLI's diff command.\n\nIt diffs declared design tokens (colors, typography, rounded, spacing, components) and reports a "regression" flag — whether the after file introduced a token regression compared to before. Use it to spot changes between a draft and the version you're building on, or to check that an edit didn't silently lose a token.\n\nEach side (before and after) is given EITHER as raw "content" markdown (a file you're drafting) OR a bundled "slug" (e.g. 'stripe'). Mixing is fine: compare a bundled reference against your own draft.\n\nThis validates TOKEN regressions only — it does not judge prose quality (see designmd_get_authoring_guide for that).\n\nArgs:\n  - before: { content | slug }  (exactly one) — the baseline side\n  - after:  { content | slug }  (exactly one) — the changed side\n\nReturns:\n  JSON with schema:\n  {\n    "tokens": { "<group>": { "added": [], "removed": [], "modified": [] } },  // per token group\n    "findings": { "before": {errors,warnings,infos}, "after": {...}, "delta": {errors,warnings} },\n    "regression": boolean\n  }\n  A human-readable one-line summary is prepended to the output text.\n\nExamples:\n  - Use when: "did my edit to the draft change any color tokens?" -> before={content: draft-before}, after={content: draft-after}\n  - Use when: "how does my draft compare to Stripe's tokens?" -> before={slug: "stripe"}, after={content: my-draft}\n  - Don't use when: you only want structure/validation of one file (use designmd_lint)`,
+        inputSchema: DiffInputSchema.shape,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params) => {
+        let before;
+        let after;
+        try {
+            before = await resolveSide(params.before);
+            after = await resolveSide(params.after);
+        }
+        catch (err) {
+            return {
+                content: [
+                    { type: 'text', text: `Error: ${err instanceof Error ? err.message : String(err)}` },
+                ],
+                isError: true,
+            };
+        }
+        let result;
+        try {
+            result = await diffDesignMdContent(before, after);
+        }
+        catch (err) {
+            return {
+                content: [
+                    { type: 'text', text: `Error: ${err instanceof Error ? err.message : String(err)}` },
+                ],
+                isError: true,
+            };
+        }
+        const changes = countTokenChanges(result);
+        const summaryLine = `diff: ${changes} token change(s); ${result.findings.delta.errors} new error(s), ${result.findings.delta.warnings} new warning(s); regression: ${result.regression}`;
+        return {
+            content: [{ type: 'text', text: `${summaryLine}\n${JSON.stringify(result, null, 2)}` }],
+            structuredContent: result,
+        };
+    });
+}

package/dist/tools/getDesign.js

@@ -0,0 +1,216 @@
+import { z } from 'zod';
+import { getEntryBySlug, readDesignMdContent } from '../services/designStore.js';
+import { CANONICAL_SECTIONS, getSection, findComponentGroup, } from '../services/sectionParser.js';
+import { CHARACTER_LIMIT, SOURCE_LICENSE, SOURCE_BY_PLATFORM, } from '../constants.js';
+const FLAVORS = ['swiftui', 'expo', 'android'];
+const flavorSuffix = (flavor) => `-${flavor}`;
+const GetDesignMdInputSchema = z
+    .object({
+    slug: z
+        .string()
+        .min(1)
+        .max(100)
+        .describe("The exact slug of the design to fetch, as returned by designmd_list_designs or designmd_search_designs (e.g. 'stripe', 'ios-spotify', 'midnight-pro')."),
+    section: z
+        .enum(CANONICAL_SECTIONS)
+        .optional()
+        .describe(`Optional: fetch only one section instead of the whole file. One of: ${CANONICAL_SECTIONS.join(', ')}. Omit to get the full file. Use "dos_and_donts" specifically when you only need behavioral guardrails, not token values — see designmd_get_guardrails for a purpose-built shortcut to that. Works best against the framework-neutral spec (no flavor).`),
+    flavor: z
+        .enum(FLAVORS)
+        .optional()
+        .describe("Optional: for an iOS design (platform 'ios'), fetch the paste-ready framework implementation instead of the neutral spec. One of: swiftui, expo, android. Only iOS designs ship these variants. Omit for the framework-neutral DESIGN.md."),
+    component: z
+        .string()
+        .min(1)
+        .max(60)
+        .optional()
+        .describe("Optional: for the framework-neutral spec (not used with 'flavor'), fetch just ONE component sub-group of the Component Stylings section (e.g. 'navigation', 'buttons', 'cards', 'inputs'). Matches the '### ' sub-headings inside that section; names vary per design, so the match is best-effort. Returns the matched group's content. Use only on the neutral spec."),
+})
+    .strict();
+export function registerGetDesignTool(server) {
+    server.registerTool('designmd_get_design_md', {
+        title: 'Get Full DESIGN.md File',
+        description: `Fetch DESIGN.md content for one design system by slug — either the full file, or (with the optional "section" param) just one section.
+
+The returned file follows the Stitch DESIGN.md format: visual theme, color palette with hex values, typography hierarchy, component styling (buttons, cards, inputs, nav), layout/spacing principles, depth/elevation, do's and don'ts, responsive behavior, and an agent prompt guide. Content is sourced from local snapshots of VoltAgent/awesome-design-md (web), TrustOtc/awesome-mobile-design-md (mobile archetypes), and Meliwat/awesome-ios-design-md (iOS app systems; MIT licensed) — reverse-engineered design specs only, no logos or copyrighted imagery.
+
+IMPORTANT for whoever consumes this output (agent or human): color hex codes and type scales are NOT enough to reproduce a brand's visual decisions. Token-only usage — e.g. applying a brand color as a background tint, or giving every card the same shadow — commonly produces output that has the right values but wrong decisions. Always read and follow the "Do's and Don'ts" section (or call designmd_get_guardrails) alongside any tokens, not just the color/typography sections in isolation.
+
+Args:
+  - slug (string, required): Exact slug, e.g. "stripe", "ios-spotify", "midnight-pro". Get valid slugs from designmd_list_designs or designmd_search_designs first if unsure.
+  - section (string, optional): One of ${CANONICAL_SECTIONS.join(', ')}. Fetch just this section instead of the whole file — useful to avoid flooding context with irrelevant tokens when only one aspect (e.g. "components" or "dos_and_donts") is needed. Omit for the full file.
+  - flavor (swiftui|expo|android, optional): For iOS designs only, fetch the framework implementation variant instead of the neutral spec. Omit for the neutral file.
+  - component (string, optional): On the framework-neutral spec only (not with flavor), fetch just ONE component sub-group of the Component Stylings section (e.g. "navigation", "buttons", "cards"). Best-effort match against the file's "### " sub-headings.
+
+Returns:
+  The raw Markdown content (full file, requested section, component group, or flavor variant) as text, plus a structuredContent object:
+  {
+    "slug": string,
+    "title": string,
+    "category": string,
+    "platform": "web" | "mobile" | "ios",
+    "flavor": string | null,   // null when the neutral spec was returned
+    "component": string | null, // the requested component sub-group, or null
+    "source": string,
+    "license": string,
+    "section": string | null,  // the effective section, or null if full file
+    "content": string   // markdown, may be truncated if extremely long (truncation is noted)
+  }
+
+Error Handling:
+  - Returns "Error: No design found for slug '<slug>'" with suggestions if the slug doesn't exist — call designmd_search_designs first to find the correct slug.
+  - Returns "Error: Section '<section>' not found in '<slug>'" if that file doesn't have that section (not all files include every canonical section).
+  - Returns an error if a flavor is requested for a non-iOS design, or if the flavor variant is missing.
+
+Examples:
+  - Use when: "get me the Stripe design system" -> slug="stripe"
+  - Use when: "just the color palette for Notion" -> slug="notion", section="colors"
+  - Use when: "give me the SwiftUI implementation of Spotify's iOS app" -> slug="ios-spotify", flavor="swiftui"
+  - Use when: user picked a result from designmd_search_designs -> pass that result's slug
+  - Don't use when: you don't know which site you want yet (use designmd_search_designs or designmd_list_designs first)`,
+        inputSchema: GetDesignMdInputSchema.shape,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params) => {
+        const entry = getEntryBySlug(params.slug);
+        if (!entry) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: No design found for slug '${params.slug}'. Call designmd_search_designs or designmd_list_designs to find the correct slug.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (params.flavor && entry.platform !== 'ios') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: Design '${params.slug}' (platform ${entry.platform}) has no '${params.flavor}' flavor variant — only iOS designs ship framework implementations. Omit flavor to fetch the neutral spec.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const variantSlug = params.flavor
+            ? `${entry.slug}${flavorSuffix(params.flavor)}`
+            : entry.slug;
+        let fullContent;
+        try {
+            fullContent = readDesignMdContent(variantSlug);
+        }
+        catch {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: No '${params.flavor}' flavor variant available for '${params.slug}'. Try the neutral spec (omit flavor), or check the slugs via designmd_list_designs.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        let content;
+        let section = params.section ?? null;
+        if (params.component && params.flavor) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: Cannot combine 'component' (a refinement of the framework-neutral spec) with 'flavor' (a framework implementation). Fetch one or the other.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (params.component && params.section && params.section !== 'components') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: 'component' is a sub-group of the Component Stylings section, so it can't be combined with section '${params.section}'. Omit section (or use section=components).`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (params.component) {
+            const compSec = getSection(fullContent, 'components');
+            if (!compSec) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: Design '${params.slug}' has no Component Stylings section to search within.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const { group, available } = findComponentGroup(compSec.content, params.component);
+            if (!group) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: No component group matching '${params.component}' found in '${params.slug}'. Available groups: ${available.length ? available.join(', ') : 'none'}.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            section = 'components';
+            content = group.content;
+        }
+        else if (params.section) {
+            const found = getSection(fullContent, params.section);
+            if (!found) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: Section '${params.section}' not found in '${params.slug}'. Not every file includes every canonical section. Try designmd_get_design_md without a section to see what's available, or call designmd_get_guardrails for the do's/don'ts specifically.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            content = found.content;
+        }
+        else {
+            content = fullContent;
+        }
+        let truncated = false;
+        if (content.length > CHARACTER_LIMIT) {
+            content = content.slice(0, CHARACTER_LIMIT);
+            truncated = true;
+        }
+        const platform = (entry.platform ?? 'web');
+        const output = {
+            slug: entry.slug,
+            title: entry.title,
+            category: entry.category,
+            platform,
+            flavor: params.flavor ?? null,
+            component: params.component ?? null,
+            source: SOURCE_BY_PLATFORM[platform],
+            license: SOURCE_LICENSE,
+            section,
+            content,
+            ...(truncated
+                ? { truncated: true, note: `Content truncated at ${CHARACTER_LIMIT} characters.` }
+                : {}),
+        };
+        return {
+            content: [{ type: 'text', text: content }],
+            structuredContent: output,
+        };
+    });
+}

package/dist/tools/guardrails.js

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { getEntryBySlug, readDesignMdContent } from '../services/designStore.js';
+import { getSection } from '../services/sectionParser.js';
+import { SOURCE_REPO, SOURCE_LICENSE } from '../constants.js';
+const GetGuardrailsInputSchema = z
+    .object({
+    slug: z
+        .string()
+        .min(1)
+        .max(100)
+        .describe("The exact slug of the design, as returned by designmd_list_designs or designmd_search_designs (e.g. 'stripe', 'linear.app', 'tesla')."),
+})
+    .strict();
+export function registerGuardrailsTool(server) {
+    server.registerTool('designmd_get_guardrails', {
+        title: "Get Design Guardrails (Do's and Don'ts)",
+        description: `Fetch ONLY the "Do's and Don'ts" section for one design system — the behavioral rules, not the color/typography/spacing token values.
+
+Why this exists: color hex codes and type scales tell an agent WHAT the values are, but not HOW to use them. In practice, agents given only tokens tend to make token-correct but decision-wrong choices — e.g. applying a brand accent color as a background tint on every info banner, or giving every card component the same shadow weight regardless of hierarchy. The Do's and Don'ts section is where a DESIGN.md file encodes exactly those usage rules and anti-patterns. Call this tool (or designmd_get_design_md with section="dos_and_donts") whenever you're about to generate UI from a design system and want to sanity-check decisions, not just token values.
+
+Args:
+  - slug (string, required): Exact slug, e.g. "stripe", "notion", "tesla".
+
+Returns:
+  JSON with schema:
+  {
+    "slug": string,
+    "title": string,
+    "source": string,
+    "license": string,
+    "guardrails": string   // raw markdown of the Do's and Don'ts section
+  }
+
+Error Handling:
+  - Returns "Error: No design found for slug '<slug>'" if the slug doesn't exist.
+  - Returns "Error: No Do's and Don'ts section found for '<slug>'" in the rare case a file doesn't include one — fall back to designmd_get_design_md for the full file.
+
+Examples:
+  - Use when: "before you build this settings screen, what should I avoid with the Stripe style?" -> slug="stripe"
+  - Use when: you already fetched a design's tokens and are about to generate a component -> call this alongside, don't skip it
+  - Don't use when: you need the actual color/type values (use designmd_get_design_md with section="colors" or "typography", or the full file)`,
+        inputSchema: GetGuardrailsInputSchema.shape,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params) => {
+        const entry = getEntryBySlug(params.slug);
+        if (!entry) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: No design found for slug '${params.slug}'. Call designmd_search_designs or designmd_list_designs to find the correct slug.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const fullContent = readDesignMdContent(entry.slug);
+        const found = getSection(fullContent, 'dos_and_donts');
+        if (!found) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: No Do's and Don'ts section found for '${entry.slug}'. Fall back to designmd_get_design_md for the full file.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const output = {
+            slug: entry.slug,
+            title: entry.title,
+            source: SOURCE_REPO,
+            license: SOURCE_LICENSE,
+            guardrails: found.content,
+        };
+        return {
+            content: [{ type: 'text', text: found.content }],
+            structuredContent: output,
+        };
+    });
+}