ngwr 10.2.1 → 11.0.0

package/mcp/server.js

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+import { Catalog } from './catalog.js';
+import { TOOLS, callTool, validateArguments } from './tools.js';
+/**
+ * The ngwr MCP server — stdio, JSON-RPC 2.0, no dependencies.
+ *
+ * **Hand-rolled rather than built on the MCP SDK, and that is a deliberate
+ * trade.** This ships inside `ngwr`, whose only runtime dependency is `tslib`;
+ * an SDK would put a dependency tree behind every `npm i ngwr` for a feature most
+ * consumers never run. The protocol surface a tools-only server needs is a
+ * handful of methods and a framing rule.
+ *
+ * What that trade costs is that the error paths are the author's problem, and the
+ * first draft got several of them wrong in the same way: it answered the WRONG
+ * ID, or nothing at all. A client that never receives a response for an id does
+ * not fail — it waits, which is worse. Every branch here now ends in exactly one
+ * reply per request, and none for a notification.
+ *
+ * Run it with `npx ngwr-mcp`, or point a client at
+ * `node ./node_modules/ngwr/mcp/server.js`.
+ *
+ * @see https://modelcontextprotocol.io
+ */
+/** Versions this server knows how to speak. The newest is what it offers. */
+const PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
+/**
+ * How much unterminated input to hold before giving up on the line.
+ *
+ * No MCP limit exists to violate, but an unbounded buffer means a client that
+ * never sends a newline grows this process until the machine complains. 32 MB is
+ * far past any real message — the largest this server can be asked for is a few
+ * hundred kilobytes.
+ */
+const MAX_LINE_BYTES = 32 * 1024 * 1024;
+/**
+ * How many requests one batch may carry.
+ *
+ * Measured, not guessed: 58,000 entirely valid `get_ngwr_api` calls in one 6.8 MB
+ * batch made the single `JSON.stringify` of the reply array throw
+ * `RangeError: Invalid string length`, which killed the process with ZERO bytes
+ * written and none of the 58,000 ids answered — the exact failure this file's
+ * docblock says was eliminated. 30,000 entries already peaked at 3.3 GB of
+ * resident memory. No real client batches more than a handful.
+ */
+const MAX_BATCH = 256;
+const PARSE_ERROR = -32700;
+const INVALID_REQUEST = -32600;
+const METHOD_NOT_FOUND = -32601;
+const INVALID_PARAMS = -32602;
+const INTERNAL_ERROR = -32603;
+const catalog = new Catalog();
+/**
+ * Stdout carries the protocol and nothing else.
+ *
+ * A stray `console.log` anywhere in this process corrupts the stream and the
+ * client drops the connection — which is why diagnostics go to stderr, and why
+ * the catalog is read lazily rather than announced at start-up.
+ */
+function write(message) {
+    let line;
+    try {
+        line = JSON.stringify(message);
+    }
+    catch (error) {
+        // Serialising the reply is the last thing that can fail, and failing here
+        // used to take the process down before a single byte was written. An error
+        // the client can correlate is worth more than a crash.
+        line = JSON.stringify(err(null, INTERNAL_ERROR, `Reply could not be serialised: ${String(error)}`));
+    }
+    process.stdout.write(`${line}\n`);
+}
+function ok(id, result) {
+    return { jsonrpc: '2.0', id, result };
+}
+function err(id, code, message) {
+    return { jsonrpc: '2.0', id, error: { code, message } };
+}
+/** JSON-RPC allows a String, a Number or Null. Anything else is not an id. */
+function idOf(value) {
+    if (typeof value === 'string' || typeof value === 'number' || value === null)
+        return value;
+    return undefined;
+}
+/**
+ * One request to one response, or `null` for a notification.
+ *
+ * A notification is a request with NO `id` member — not one whose id is null,
+ * which §4 says must still be answered.
+ */
+function respond(message) {
+    if (typeof message !== 'object' || message === null || Array.isArray(message)) {
+        return err(null, INVALID_REQUEST, 'A request must be a JSON object.');
+    }
+    const request = message;
+    const notification = !('id' in request);
+    const id = notification ? null : idOf(request.id);
+    if (!notification && id === undefined) {
+        return err(null, INVALID_REQUEST, 'A request id must be a string, a number or null.');
+    }
+    const reply = (response) => (notification ? null : response);
+    if (request.jsonrpc !== '2.0') {
+        return reply(err(id ?? null, INVALID_REQUEST, 'Only JSON-RPC 2.0 is supported.'));
+    }
+    if (typeof request.method !== 'string') {
+        return reply(err(id ?? null, INVALID_REQUEST, 'A request needs a method name.'));
+    }
+    // `null` params reads as "none given". Lenient on purpose: clients send it for
+    // a method that takes nothing, and the version that let it through to a
+    // destructure threw — which the framing layer then reported as a PARSE error
+    // against a null id, so the real request was never answered at all.
+    const raw = request.params;
+    if (raw !== undefined && raw !== null && (typeof raw !== 'object' || Array.isArray(raw))) {
+        return reply(err(id ?? null, INVALID_PARAMS, 'Params must be an object.'));
+    }
+    const params = (raw ?? {});
+    try {
+        const response = handle(id ?? null, request.method, params);
+        return reply(response);
+    }
+    catch (error) {
+        // A handler that throws is an internal error against the REAL id. Blaming
+        // the parser, as the first version did, tells the client its message was
+        // malformed and leaves the id it is waiting on unanswered for ever.
+        return reply(err(id ?? null, INTERNAL_ERROR, error instanceof Error ? error.message : String(error)));
+    }
+}
+function handle(id, method, params) {
+    switch (method) {
+        case 'initialize': {
+            const asked = typeof params.protocolVersion === 'string' ? params.protocolVersion : '';
+            return ok(id, {
+                // Echo the client's version when it is one we speak, so an older client
+                // is not told to upgrade for a server that would have worked.
+                protocolVersion: PROTOCOL_VERSIONS.includes(asked)
+                    ? asked
+                    : PROTOCOL_VERSIONS[0],
+                capabilities: { tools: {} },
+                serverInfo: { name: 'ngwr', title: 'ngwr component catalog', version: catalog.version() },
+                instructions: 'Angular component library. Use search_ngwr first when you do not know an entry point name, ' +
+                    'then get_ngwr_api for exact signatures and get_ngwr_setup for the commands to wire it in.',
+            });
+        }
+        case 'ping':
+            return ok(id, {});
+        case 'tools/list':
+            return ok(id, { tools: TOOLS });
+        case 'tools/call': {
+            const name = params.name;
+            if (typeof name !== 'string')
+                return err(id, INVALID_PARAMS, 'tools/call needs a tool name.');
+            const tool = TOOLS.find(candidate => candidate.name === name);
+            // An unknown tool is a protocol error, not an answer. Returned as a
+            // successful call it reads to an agent like the reply to its question.
+            if (!tool) {
+                return err(id, INVALID_PARAMS, `Unknown tool: ${name}. Available: ${TOOLS.map(t => t.name).join(', ')}.`);
+            }
+            const args = (params.arguments ?? {});
+            if (typeof args !== 'object' || args === null || Array.isArray(args)) {
+                return err(id, INVALID_PARAMS, `${name}: arguments must be an object.`);
+            }
+            // The schema is published at `tools/list`; honouring it is what stops a
+            // wrong argument type reaching the tool and coming back as a raw V8
+            // TypeError in the agent's face.
+            const complaint = validateArguments(tool, args);
+            if (complaint)
+                return err(id, INVALID_PARAMS, `${name}: ${complaint}`);
+            try {
+                return ok(id, { content: [{ type: 'text', text: callTool(catalog, name, args) }] });
+            }
+            catch (error) {
+                // A tool that throws is a failed CALL, not a failed request: reporting it
+                // this way leaves the conversation intact and tells the agent what went
+                // wrong, where a JSON-RPC error just looks like a broken server.
+                return ok(id, {
+                    content: [
+                        { type: 'text', text: `${name} failed: ${error instanceof Error ? error.message : String(error)}` },
+                    ],
+                    isError: true,
+                });
+            }
+        }
+        default:
+            return err(id, METHOD_NOT_FOUND, `Unknown method: ${method}`);
+    }
+}
+/** One line in, at most one message out. Batches answer as a batch. */
+function dispatch(line) {
+    let message;
+    try {
+        message = JSON.parse(line);
+    }
+    catch {
+        write(err(null, PARSE_ERROR, 'Parse error'));
+        return;
+    }
+    // Batching is part of the two older protocol revisions this server offers, and
+    // silence is not a legal answer to any of them: the first version destructured
+    // the array, found no method, and dropped every id in it.
+    if (Array.isArray(message)) {
+        if (message.length === 0) {
+            write(err(null, INVALID_REQUEST, 'A batch must not be empty.'));
+            return;
+        }
+        if (message.length > MAX_BATCH) {
+            write(err(null, INVALID_REQUEST, `A batch may carry at most ${MAX_BATCH} requests.`));
+            return;
+        }
+        const responses = message.map(respond).filter((response) => response !== null);
+        if (responses.length > 0)
+            write(responses);
+        return;
+    }
+    const response = respond(message);
+    if (response)
+        write(response);
+}
+/**
+ * Newline-delimited JSON on stdin.
+ *
+ * Buffered across chunks: a message longer than one read arrives in pieces, and a
+ * parser that assumed one chunk per message would work in testing and drop every
+ * large `tools/call` in the field.
+ */
+let buffer = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+    buffer += chunk;
+    // `Buffer.byteLength`, not `.length`: the latter counts UTF-16 units, so
+    // 93 MB of three-byte characters passed a 32 MB cap untouched.
+    if (Buffer.byteLength(buffer, 'utf8') > MAX_LINE_BYTES) {
+        // Discard only the oversize LINE and resynchronise on the next one. Clearing
+        // the whole buffer threw away a complete, valid request that had already
+        // arrived behind it — answered with nothing, which is the one outcome this
+        // file is written to avoid.
+        const newline = buffer.indexOf('\n');
+        buffer = newline === -1 ? '' : buffer.slice(newline + 1);
+        write(err(null, INVALID_REQUEST, 'Message exceeded the maximum size and was discarded.'));
+    }
+    let newline = buffer.indexOf('\n');
+    while (newline !== -1) {
+        const line = buffer.slice(0, newline).trim();
+        buffer = buffer.slice(newline + 1);
+        newline = buffer.indexOf('\n');
+        if (line)
+            dispatch(line);
+    }
+});
+process.stdin.on('end', () => {
+    // A client that closes without a trailing newline still asked something. The
+    // version that exited here dropped it and reported success.
+    const last = buffer.trim();
+    buffer = '';
+    if (last)
+        dispatch(last);
+    // NOT `process.exit()`: writes to a pipe are asynchronous above the kernel
+    // buffer, and exiting discards whatever is still queued. A 1000-symbol
+    // `get_ngwr_setup` came back cut at exactly 65 536 bytes — mid-string, with a
+    // zero exit code. Setting the code and letting the loop drain sends all of it.
+    process.exitCode = 0;
+});
+// A client that dies without closing stdin leaves this writing into a broken
+// pipe. Exiting quietly is the correct end of a session, not a crash with a
+// stack trace.
+process.stdout.on('error', error => {
+    if (error.code === 'EPIPE')
+        process.exit(0);
+});

package/mcp/tools.js

@@ -0,0 +1,366 @@
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+import { declaredClasses, extractClass } from './api.js';
+const DOCS = 'https://ngwr.dev';
+/**
+ * The four tools, and why there are only four.
+ *
+ * Each one answers a question an agent actually has when it is holding this
+ * library for the first time: what is there, how do I use this one, what does it
+ * take, and what do I have to install. Anything else it can already do — the
+ * docs are prerendered HTML with a markdown twin at every URL, and the types are
+ * in the tarball. A tool per docs page would be a worse version of `fetch`.
+ */
+const TOOLS = [
+    {
+        name: 'search_ngwr',
+        description: 'Search the ngwr catalog by what you need ("date range picker", "wr-select", "virtual scroll"). ' +
+            'Returns matching entry points with their import line, selector and one-line description. ' +
+            'Start here when you do not already know the entry point name.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'What you are looking for.' },
+                limit: { type: 'number', description: 'Maximum results. Defaults to 10.' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'get_ngwr_component',
+        description: 'Everything about one entry point: description, selector, exports, import line, SCSS import, ' +
+            'documentation URL and the markdown twin of its docs page. Accepts an entry point ' +
+            '("ngwr/select", "select"), a symbol ("WrSelect") or a selector ("wr-select").',
+        inputSchema: {
+            type: 'object',
+            properties: { name: { type: 'string', description: 'Entry point, symbol or selector.' } },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'get_ngwr_api',
+        description: 'The public inputs, models, outputs and methods of one ngwr class, read out of the ' +
+            'declarations shipped in this package — so it is the published signature, not a copy of it. ' +
+            'Use instead of reading the .d.ts, which can be 60 KB for one component.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                symbol: { type: 'string', description: 'Class name, e.g. WrSelect.' },
+                kind: {
+                    type: 'string',
+                    enum: ['all', 'input', 'model', 'output', 'method', 'property'],
+                    description: 'Narrow the surface. Defaults to all.',
+                },
+            },
+            required: ['symbol'],
+        },
+    },
+    {
+        name: 'get_ngwr_setup',
+        description: 'The exact commands and providers needed to use one or more ngwr symbols in an app: ' +
+            'install, the `ng g ngwr:use` invocation that wires the import, the SCSS to load, and any ' +
+            'provider the symbol depends on. Returns commands to run; it never runs them.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                symbols: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Symbols you intend to use, e.g. ["WrSelect", "WrDialog"].',
+                },
+            },
+            required: ['symbols'],
+        },
+    },
+];
+/**
+ * Providers a symbol cannot work without.
+ *
+ * Hard-coded, and the list is short on purpose: these are the four cases where
+ * the component compiles, renders nothing useful, and gives no error that names
+ * the cause. Everything else is discoverable from the docs page.
+ */
+const REQUIRED_PROVIDERS = [
+    {
+        test: /^Wr(Dialog|Drawer|Toast|Popover|Popconfirm|ContextMenu|Select|Dropdown|CommandPalette|Cascader|Mention|DatePicker|Tour|Lightbox)/,
+        provider: "provideWrOverlay() // from 'ngwr/overlay'",
+        why: 'overlays render into an ngwr-owned container; without it they never appear',
+    },
+    {
+        test: /^WrIcon/,
+        provider: "provideWrIcons(lucideIcons({ … })) // from 'ngwr/icon' + 'ngwr/icon/adapters/lucide'",
+        why: 'icons resolve by name from a registry you populate',
+    },
+    {
+        test: /^WrDatePicker|^WrCalendar|^WrEventCalendar/,
+        provider: "provideWrDateAdapter(wrDateFnsAdapter) // from 'ngwr/date-adapter-fns'",
+        why: 'every date mode goes through an adapter; there is no built-in default',
+    },
+    {
+        test: /^WrT$|^WrI18n/,
+        provider: "provideWrI18n() + provideWrI18nStaticLoader({ en: wrEn }) // from 'ngwr/i18n'",
+        why: 'the pipe and directive read from a catalog you provide',
+    },
+];
+/**
+ * The published schema, actually enforced.
+ *
+ * A server that advertises `required: ["query"]` at `tools/list` and then accepts
+ * a call without it is lying in a way an agent cannot detect. Worse, three of the
+ * six wrong-argument shapes reached the tool body and came back as a raw V8
+ * `TypeError` — `symbols.map is not a function` — presented as the answer.
+ *
+ * Deliberately small: presence, and the handful of types these schemas use. This
+ * is not a JSON Schema implementation and should not grow into one.
+ */
+function validateArguments(tool, args) {
+    const schema = tool.inputSchema;
+    for (const name of schema.required ?? []) {
+        if (args[name] === undefined || args[name] === null)
+            return `\`${name}\` is required.`;
+    }
+    for (const [name, expected] of Object.entries(schema.properties ?? {})) {
+        const value = args[name];
+        if (value === undefined || value === null)
+            continue;
+        if (expected.type === 'array') {
+            if (!Array.isArray(value))
+                return `\`${name}\` must be an array.`;
+            const wanted = expected.items?.type ?? 'string';
+            const items = value;
+            if (items.some(item => typeof item !== wanted)) {
+                return `every item in \`${name}\` must be a ${wanted}.`;
+            }
+            continue;
+        }
+        if (expected.type && typeof value !== expected.type)
+            return `\`${name}\` must be a ${expected.type}.`;
+        // `enum` was published and unchecked, which failed in the worst possible
+        // shape: `kind: "Input"` answered successfully with ZERO members, and an
+        // agent has no way to tell that from a component with no inputs.
+        // `typeof` rather than `String(value)`: every `enum` property here is also
+        // `type: 'string'`, and stringifying an object would compare `[object Object]`.
+        if (expected.enum && (typeof value !== 'string' || !expected.enum.includes(value))) {
+            return `\`${name}\` must be one of ${expected.enum.join(', ')}.`;
+        }
+    }
+    return null;
+}
+function isText(value) {
+    return typeof value === 'string';
+}
+/** An argument as a string, or empty — never `[object Object]`. */
+function text(value) {
+    return isText(value) ? value : '';
+}
+/** Runs a tool and returns the text an agent will read. */
+function callTool(catalog, name, args) {
+    switch (name) {
+        // Bracket access and `text()`, because `args` genuinely IS an untyped bag off
+        // the wire. The server checks it against the tool's published schema first;
+        // this layer still refuses to stringify an object into `[object Object]`.
+        case 'search_ngwr':
+            return search(catalog, text(args['query']), Number(args['limit'] ?? 10));
+        case 'get_ngwr_component':
+            return component(catalog, text(args['name']));
+        case 'get_ngwr_api':
+            return api(catalog, text(args['symbol']), text(args['kind']) || 'all');
+        case 'get_ngwr_setup':
+            return setup(catalog, Array.isArray(args['symbols']) ? args['symbols'].filter(isText) : []);
+        default:
+            return `Unknown tool: ${name}. Available: ${TOOLS.map(tool => tool.name).join(', ')}.`;
+    }
+}
+/**
+ * Ranked search over the catalog.
+ *
+ * Scored rather than filtered, because the useful query is "date range picker"
+ * and the useful answer is `ngwr/date-picker` first. Name and selector matches
+ * outrank a description match, since a description mentions neighbours —
+ * `wr-drawer` names the bottom sheet, `wr-select` names the tag mode — and a
+ * substring hit there is weaker evidence than the name itself.
+ */
+function search(catalog, query, limit) {
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (terms.length === 0)
+        return 'Give me something to search for.';
+    const scored = catalog
+        .all()
+        .map(entry => ({ entry, score: score(entry, terms) }))
+        .filter(hit => hit.score > 0)
+        .sort((a, b) => b.score - a.score || a.entry.path.localeCompare(b.entry.path))
+        .slice(0, Math.max(1, Math.min(limit || 10, 40)));
+    if (scored.length === 0) {
+        return `Nothing in the ngwr catalog matches "${query}". The full list is ${DOCS}/llms.txt.`;
+    }
+    return scored
+        .map(({ entry }) => [
+        `## ${entry.path}`,
+        entry.selectors.length > 0 ? `selector: ${entry.selectors.join(', ')}` : null,
+        `import: ${entry.import}`,
+        entry.description,
+    ]
+        .filter(Boolean)
+        .join('\n'))
+        .join('\n\n');
+}
+function score(entry, terms) {
+    const name = entry.name.toLowerCase();
+    const selectors = entry.selectors.join(' ').toLowerCase();
+    const exports = entry.exports.join(' ').toLowerCase();
+    const description = entry.description.toLowerCase();
+    let total = 0;
+    for (const term of terms) {
+        if (name === term)
+            total += 100;
+        else if (name.includes(term))
+            total += 40;
+        if (selectors.includes(term))
+            total += 30;
+        if (exports.includes(term))
+            total += 20;
+        if (description.includes(term))
+            total += 5;
+    }
+    return total;
+}
+function component(catalog, name) {
+    const entry = catalog.find(name);
+    if (!entry)
+        return notFound(catalog, name);
+    const declarations = catalog.types(entry.path);
+    const classes = declarations ? declaredClasses(declarations).filter(symbol => entry.exports.includes(symbol)) : [];
+    const url = docsUrl(declarations, classes);
+    return [
+        `# ${entry.path}`,
+        '',
+        // An entry point with no description bullet answered with three blank lines.
+        ...(entry.description ? [entry.description, ''] : []),
+        entry.selectors.length > 0 ? `- selector: ${entry.selectors.join(', ')}` : null,
+        `- import: ${entry.import}`,
+        // Only when there is one to load: 58 entry points ship no stylesheet.
+        catalog.hasStyles(entry.path) ? `- styles: @use '${entry.path}';` : null,
+        `- exports: ${entry.exports.join(', ')}`,
+        classes.length > 0 ? `- classes with an API: ${classes.join(', ')} (use get_ngwr_api)` : null,
+        // From the class's own `@see`, never guessed. Half the catalog — directives,
+        // services, pipes, utils, every `*/testing` harness — has no page under
+        // `/reference/components/`, and a link that 404s is worse than none.
+        url ? `- docs: ${url}` : null,
+        url ? `- docs as markdown: ${url}.md` : null,
+    ]
+        .filter(line => line !== null)
+        .join('\n');
+}
+/** The documented URL of the first class that declares one. */
+function docsUrl(declarations, classes) {
+    if (!declarations)
+        return null;
+    for (const symbol of classes) {
+        const found = extractClass(declarations, symbol);
+        if (found?.docs?.startsWith('http'))
+            return found.docs.split(/\s/)[0];
+    }
+    return null;
+}
+function api(catalog, symbol, kind) {
+    const entry = catalog.find(symbol);
+    if (!entry)
+        return notFound(catalog, symbol);
+    const declarations = catalog.types(entry.path);
+    if (!declarations)
+        return `${entry.path} ships no declarations, so there is no API to read.`;
+    const found = extractClass(declarations, symbol);
+    if (!found) {
+        return `${symbol} is not a class in ${entry.path}. It exports: ${entry.exports.join(', ')}.`;
+    }
+    const wanted = kind === 'all' ? null : kind;
+    const members = found.members.filter(member => (wanted ? member.kind === wanted : member.kind !== 'property'));
+    return [
+        `# ${found.name} — ${entry.path}`,
+        '',
+        found.description,
+        '',
+        ...group(members, 'input'),
+        ...group(members, 'model'),
+        ...group(members, 'output'),
+        ...group(members, 'method'),
+        ...group(members, 'property'),
+        found.example ? `## Example\n${found.example}` : null,
+        found.docs ? `Docs: ${found.docs}` : null,
+    ]
+        .filter(line => line !== null)
+        .join('\n');
+}
+function group(members, kind) {
+    const matching = members.filter(member => member.kind === kind);
+    if (matching.length === 0)
+        return [];
+    return [
+        `## ${kind === 'property' ? 'properties' : `${kind}s`}`,
+        ...matching.map(member => {
+            const bits = [`- \`${member.name}\`: ${member.type}`];
+            if (member.alias)
+                bits.push(`(bound as \`${member.alias}\`)`);
+            if (member.required)
+                bits.push('(required)');
+            if (member.default)
+                bits.push(`default ${member.default}`);
+            if (member.description)
+                bits.push(`— ${member.description.replace(/\s+/g, ' ')}`);
+            return bits.join(' ');
+        }),
+        '',
+    ];
+}
+function setup(catalog, symbols) {
+    if (symbols.length === 0)
+        return 'Name at least one symbol, e.g. ["WrSelect"].';
+    const found = symbols.map(symbol => ({ symbol, entry: catalog.find(symbol) }));
+    const missing = found.filter(hit => !hit.entry).map(hit => hit.symbol);
+    const resolved = found.filter((hit) => hit.entry !== null);
+    const providers = REQUIRED_PROVIDERS.filter(required => resolved.some(hit => required.test.test(hit.symbol)));
+    return [
+        '# Setting these up',
+        '',
+        '## 1. Install',
+        'ng add ngwr',
+        '(prompts for styles, date adapter, density and theme, and prints a bootstrap snippet)',
+        '',
+        '## 2. Wire each symbol into the component that uses it',
+        ...resolved.map(hit => `ng g ngwr:use ${hit.symbol} --path src/app/some.component.ts   # ${hit.entry.path}`),
+        '',
+        '`--path` is a NAMED option, not positional — passing it bare fails with `Unknown argument`.',
+        '',
+        '## 3. Styles',
+        "@use 'ngwr';   // everything, or per component:",
+        // Only the entry points that ship one. `component()` was fixed for this and
+        // `setup()` was missed — which is worse here, because this tool's entire
+        // output is commands to run, and `@use 'ngwr/table/testing'` fails the build.
+        ...resolved.filter(hit => catalog.hasStyles(hit.entry.path)).map(hit => `@use '${hit.entry.path}';`),
+        '',
+        ...(providers.length > 0
+            ? [
+                '## 4. Providers these need',
+                ...providers.map(required => `${required.provider}\n   why: ${required.why}`),
+                '',
+            ]
+            : []),
+        ...(missing.length > 0 ? [`Not in the catalog: ${missing.join(', ')}. Try search_ngwr.`] : []),
+    ].join('\n');
+}
+function notFound(catalog, name) {
+    const near = catalog
+        .all()
+        .filter(entry => entry.name.includes(name.toLowerCase().replace(/^ngwr\//, '')))
+        .slice(0, 5)
+        .map(entry => entry.path);
+    return [
+        `No ngwr entry point matches "${name}".`,
+        near.length > 0 ? `Close: ${near.join(', ')}.` : 'Use search_ngwr to find one.',
+    ].join(' ');
+}
+export { TOOLS, callTool, validateArguments };

package/meter-group/styles/_index.scss

@@ -22,7 +22,7 @@
     transition: width var(--wr-transition-base);
 
     & + & {
-      margin-left: 2px;
+      margin-inline-start: 2px;
     }
   }