@table-bro/mcp 0.0.0-stage → 1.1.0

package/dist/generate/vanilla.js

@@ -0,0 +1,160 @@
+import { cssVariables } from '../spec/css-variables.js';
+import { cellDescription, colsValue, modelDescription } from './angular.js';
+import { byColumns, cellCode } from './cells.js';
+import { imports, literal, quote } from './code.js';
+import { configCode } from './config.js';
+import { BroFiltersCode } from './filters.js';
+import { BroNames } from './names.js';
+import { rowTypeCode } from './rows.js';
+/**
+ * The table for a page without a framework, in the skins bs and nv: an ES module with a function that renders
+ * <table-bro> into a container, with its cells, its filter drawer and its CSS variables. The module imports the config
+ * of the skin from its package; the setup of the project registers the skin with the optional elements of the table.
+ */
+export function vanillaTable(spec, skin, fillings, tagSuffix = '', extensions = []) {
+    const names = BroNames.of(spec, tagSuffix);
+    const folder = names.folder;
+    const config = spec.config ?? {};
+    const server = Boolean(config.server);
+    const filters = new BroFiltersCode(spec, fillings);
+    const hasFilters = filters.filters.length > 0;
+    const specRows = Boolean(spec.rows?.length) && !server;
+    const cells = (spec.cells ?? []).map(cell => cellCode(spec, cell, 'vanilla', fillings.cells?.[cell.name]?.[skin], tagSuffix));
+    const conf = configCode(spec, skin, fillings, '', tagSuffix, extensions);
+    const files = [];
+    const todo = [];
+    for (const cell of byColumns(spec, cells)) {
+        files.push({ path: `${folder}/${cell.file}.ts`, content: cell.content, description: cellDescription(cell) });
+        if (!cell.filled) {
+            todo.push(`${folder}/${cell.file}.ts: write the render() of the ${cell.cell.kind === 'details' ? 'row details' : 'cell'}: ${cell.cell.shows}`);
+        }
+    }
+    const actions = [
+        ...(spec.cells ?? []).filter(cell => cell.kind !== 'details').flatMap(cell => cell.actions ?? []),
+        ...(spec.toolbar?.buttons ?? []).map(button => button.action),
+        ...(spec.toolbar?.menu?.items ?? []).map(item => item.action)
+    ];
+    const detailsButton = spec.cols.some(col => col.component && 'element' in col.component && col.component.element === 'details-button');
+    const tableBro = [
+        ...conf.imports['@table-bro/core'], 'type BroCol', 'type TableBroHTMLElement',
+        ...(server ? ['type BroQuery'] : []),
+        ...(hasFilters ? ['dispatchAction', 'defineTableBroFilterDrawerContainer'] : []),
+        ...((hasFilters || detailsButton || server) ? ['events'] : [])
+    ];
+    const cssVars = Object.entries(spec.cssVars ?? {});
+    const tableVars = cssVars.filter(([name]) => cssVariables.find(item => item.name === name)?.target !== 'drawer');
+    const drawerVars = hasFilters ? cssVars.filter(([name]) => cssVariables.find(item => item.name === name)?.target !== 'table') : [];
+    const shadows = (config.shadowsEnabled !== false);
+    const body = [];
+    if (cells.length) {
+        body.push('  defineCustomElements();', '');
+    }
+    body.push('  const table = document.createElement(\'table-bro\');', '', `  table.id = '${names.tableId}';`, 
+    // The table reads its variables once a render, so they are set before configure
+    ...tableVars.map(([name, value]) => `  table.style.setProperty('${name}', '${value}');`), '', `  table.configure({cols${specRows ? ', rows' : ''}, conf});`);
+    if (!specRows && !server) {
+        body.push('', '  // TODO: load the rows and set them with table.replaceRows(rows)');
+    }
+    // The page delivers the rows of each query, as the page of Angular does: the first page of other filters or of
+    // another sort replaces the rows, the next pages of the same query add to them
+    if (server) {
+        body.push('', '  /** The filters and the sort of the rows the table has: another query starts from the first page. */', '  let loadedQuery: string = \'\';', '  /** The last query: an answer to an older one comes late and is left out. */', `  let lastQuery: BroQuery<${spec.rowType}> | undefined;`, '', `  const onQueryTable = (query: BroQuery<${spec.rowType}>): void => {`, '    const queryKey: string = JSON.stringify([query.filter, query.sort]);', '', '    lastQuery = query;', '', `    loadPage(query).then(({rows, total}: ${names.apiPageType}) => {`, '      if (query !== lastQuery) {', '        return;', '      }', '', '      // One batch for one delivery: the rows go with the total of the same answer; an empty answer to a query with', '      // a search or filters is the state of no rows found', '      if (queryKey !== loadedQuery) {', '        loadedQuery = queryKey;', '        table.replaceRows(rows, {total, emptyState: Object.values(query.filter ?? {}).some(value => value !== undefined && value !== null && value !== \'\') ? \'not-found\' : undefined});', '      } else {', '        table.appendRows(rows, {total});', '      }', '    }, () => {', '      // A failed load shows the failure state of the table', '      if (query === lastQuery) {', '        table.setState(\'fail\');', '      }', '    });', '  };');
+    }
+    const cases = [];
+    if (server) {
+        cases.push('      case events.filtersServerLoadedEvent:', '        onQueryTable(event.detail.data);', '        break;');
+    }
+    const customActions = [...new Set(actions)];
+    for (const action of customActions) {
+        const row = (spec.cells ?? []).some(cell => cell.actions?.includes(action));
+        cases.push(`      case ${quote(action)}:`, `        // TODO: ${row ? 'the row is event.detail.data?.row' : 'the action of the toolbar'}`, '        break;');
+    }
+    if (cases.length) {
+        body.push('', 
+        // The names of the custom actions let the switch narrow the data of the actions of the table
+        `  table.addEventListener<${spec.rowType}, ${customActions.map(quote).join(' | ') || 'never'}>('bro-action', event => {`, '    switch (event.detail.action) {', ...cases, '    }', '  });');
+    }
+    if (hasFilters) {
+        body.push('', '  // The filters live outside of the table, in the drawer next to it; the Filters button of the toolbar opens it', '  defineTableBroFilterDrawerContainer();', '', '  const drawer: HTMLElement = document.createElement(\'table-bro-filter-drawer-container\');', '', `  drawer.id = '${names.drawerId}';`, ...(shadows ? ['  drawer.className = \'bro-table-shadow-container\';'] : []), `  drawer.setAttribute('skin', '${skin}');`, ...drawerVars.map(([name, value]) => `  drawer.style.setProperty('${name}', '${value}');`), '', `  const filters = render${names.filtersClass}((value: ${names.filtersType}) => {`, '    dispatchAction(table, events.filtersFilterEvent, value);', '  });', '', '  drawer.append(table, filters);', '  container.append(drawer);');
+    }
+    else if (shadows) {
+        body.push('', '  // The shadows of the table fall into the margins of this element: the visible table takes its full width', '  const host: HTMLElement = document.createElement(\'div\');', '', '  host.className = \'bro-table-shadow-container\';', '  host.append(table);', '  container.append(host);');
+    }
+    else {
+        body.push('', '  container.append(table);');
+    }
+    // The table asks for the next pages and for the first page of other filters; the page asks for its first page
+    if (server) {
+        body.push('', `  onQueryTable({page: 1, pageSize: ${config.pageSize ?? 5}});`);
+    }
+    body.push('', '  return table;');
+    const localModules = {
+        [`./${names.kebab}`]: [`type ${spec.rowType}`, ...(hasFilters ? [`type ${names.filtersType}`] : [])],
+        ...Object.fromEntries(cells.map(cell => [`./${cell.file}`, [cell.className]])),
+        ...(hasFilters ? { [`./${names.filtersFile}`]: [`render${names.filtersClass}`] } : {})
+    };
+    const module = [
+        imports({ ...conf.imports, '@table-bro/core': tableBro, ...localModules }),
+        '',
+        ...conf.preamble.flatMap(declaration => [declaration, '']),
+        `const cols: BroCol<${spec.rowType}>[] = ${literal(colsValue(spec, skin, cells))};`,
+        '',
+        ...(specRows ? [`const rows: ${spec.rowType}[] = ${literal(spec.rows)};`, ''] : []),
+        `const conf: BroConfig<${spec.rowType}> = ${conf.code};`,
+        '',
+        `/** Renders the table of the type ${spec.rowType} into the container and returns it. */`,
+        `export function render${spec.rowType}Table(container: HTMLElement): TableBroHTMLElement {`,
+        ...body,
+        '}',
+        ...(server
+            ? [
+                '',
+                '/** An answer of your API: the rows of a page and the number of all rows. Replace it with the answer of your API. */',
+                `interface ${names.apiPageType} {`,
+                `  rows: ${spec.rowType}[];`,
+                '  total: number;',
+                '}',
+                '',
+                '/** A page of the query: the request of your API, and its answer as the rows of the table with their total. */',
+                `function loadPage(query: BroQuery<${spec.rowType}>): Promise<${names.apiPageType}> {`,
+                '  // TODO: the address of your API, and its parameters for the sort (query.sort), the search and the filters (query.filter)',
+                '  const params: URLSearchParams = new URLSearchParams({page: `${query.page}`, pageSize: `${query.pageSize}`});',
+                '',
+                `  return fetch(\`/api/${names.kebab}s?\${params}\`).then((response: Response) => {`,
+                '    if (!response.ok) {',
+                '      throw new Error(`${response.status} ${response.statusText}`);',
+                '    }',
+                '',
+                '    return response.json();',
+                '  });',
+                '}'
+            ]
+            : []),
+        ...(cells.length
+            ? [
+                '',
+                '/** The cells are Custom Elements: the table creates them by their tags, so they are defined before it. */',
+                'function defineCustomElements(): void {',
+                `  if (customElements.get(${quote(cells[0].tag)})) {`,
+                '    return;',
+                '  }',
+                '',
+                ...cells.map(cell => `  customElements.define(${quote(cell.tag)}, ${cell.className});`),
+                '}'
+            ]
+            : []),
+        ''
+    ].join('\n');
+    files.unshift({ path: `${folder}/${names.kebab}.ts`, content: rowTypeCode(spec), description: modelDescription(hasFilters) }, { path: `${folder}/${names.kebab}-table.ts`, content: module, description: `the table. Here are its columns, \`cols\`${specRows ? ', its rows, `rows`,' : ''} and its config, \`conf\`, and its rendering.` });
+    // The filters matter least to a reader: their form comes last
+    if (hasFilters) {
+        files.push({ path: `${folder}/${names.filtersFile}.ts`, content: filters.vanillaForm(skin), description: 'the filters of the drawer: their form, which gives the table its filter.' });
+    }
+    if (server) {
+        todo.push(`${folder}/${names.kebab}-table.ts: the address of your API in loadPage, and the map of the query of the table to its parameters and of its answer to the rows with their total`);
+    }
+    if (!specRows && !server) {
+        todo.push(`${folder}/${names.kebab}-table.ts: load the rows and set them with table.replaceRows(rows)`);
+    }
+    return { files, todo };
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from './docs/docs.js';
+export type { BroDocTopic } from './docs/topics.js';
+export type { BroMcpExtension } from './extension.js';
+export * from './generate/fillings.js';
+export * from './generate/generate-code.js';
+export type { BroGeneratedFile } from './generate/angular.js';
+export type { BroSetupStep, BroTarget } from './generate/setup.js';
+export * from './spec/builtin-specs.js';
+export * from './spec/css-variables.js';
+export * from './spec/schema.js';
+export * from './spec/skin-config.js';
+export * from './spec/spec.js';
+export * from './spec/validate-spec.js';
+export * from './version.js';

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from './docs/docs.js';
+export * from './generate/fillings.js';
+export * from './generate/generate-code.js';
+export * from './spec/builtin-specs.js';
+export * from './spec/css-variables.js';
+export * from './spec/schema.js';
+export * from './spec/skin-config.js';
+export * from './spec/spec.js';
+export * from './spec/validate-spec.js';
+export * from './version.js';

package/dist/project/inspect-project.d.ts

@@ -0,0 +1,53 @@
+import type { BroSpecSkin } from '../spec/spec.js';
+export interface BroProjectProblem {
+    code: string;
+    message: string;
+    fix: string;
+}
+/**
+ * The profile of the project of a developer: the answers an agent would collect from ten reads of files.
+ * The search goes by the text of the files, so a missing item means "not found", not "absent".
+ */
+export interface BroProjectProfile {
+    /** The folder that the profile describes. */
+    folder: string;
+    tableBro: {
+        version: string | null;
+        packages: Record<string, string>;
+        /** The installed paid modules with their part of the MCP server. */
+        extensions: string[];
+    };
+    framework: {
+        name: 'angular' | 'none';
+        version: string | null;
+    };
+    ui: {
+        material: string | null;
+        bootstrap: string | null;
+    };
+    skins: {
+        registered: BroSpecSkin[];
+        where: string[];
+    };
+    styles: string[];
+    customElements: {
+        tag: string;
+        file: string;
+    }[];
+    tables: string[];
+    problems: BroProjectProblem[];
+    /** The lists cut to their first items, with the number of the items each lost. */
+    omitted?: Partial<Record<BroProjectList, number>>;
+}
+type BroProjectList = 'styles' | 'customElements' | 'tables' | 'problems';
+/** Looks at a project as text: its packages, its setup of Table, Bro, its elements and its tables. */
+export declare function inspectProject(root: string): BroProjectProfile;
+/**
+ * The paid modules of the scope @table-bro-extended with a part of the MCP server: the field table-bro.mcp of their manifest,
+ * a file inside the package.
+ */
+export declare function findExtensions(root: string): {
+    name: string;
+    entry: string;
+}[];
+export {};

package/dist/project/inspect-project.js

@@ -0,0 +1,223 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { tableBroVersion } from '../version.js';
+const tableBroPackages = ['@table-bro/core', '@table-bro/angular', '@table-bro/angular-material', '@table-bro/bootstrap', '@table-bro/native'];
+/** The tags of the elements of the skins and of the core: a column may name them without a definition of the project. */
+const readyTags = /^bro-(mat|bs|nv)-|^bro-(switch|button|details-button|paginator|sort-header|text-ellipsis|toolbar|toolbar-main)$/;
+const sourceExtensions = ['.ts', '.html', '.js', '.mjs'];
+const skippedFolders = new Set(['node_modules', 'dist', '.angular', '.git', 'coverage', 'out-tsc', '.check']);
+const maxFiles = 5000;
+/** The longest walk: a folder with more folders than this is no project, as a home folder. */
+const maxFolders = 10000;
+/** The longest list of a profile: the profile of a big monorepo would fill the context of the agent. */
+const maxItems = 20;
+/** The first version of Table, Bro with an MCP server: an older project has no server of its version. */
+const firstMcpVersion = '1.1.0';
+/**
+ * An exact version, as npm installs it: the only text of the project that goes into the command of a fix. The project
+ * is foreign text, and an agent runs the commands of the fixes.
+ */
+const exactVersion = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$/;
+/** Looks at a project as text: its packages, its setup of Table, Bro, its elements and its tables. */
+export function inspectProject(root) {
+    const folderMissing = !fs.existsSync(root) || !fs.statSync(root).isDirectory();
+    const manifest = (folderMissing ? null : readJson(path.join(root, 'package.json'))) ?? {};
+    const declared = { ...manifest.dependencies, ...manifest.devDependencies };
+    const version = (name) => readJson(path.join(root, 'node_modules', name, 'package.json'))?.version ?? declared[name] ?? null;
+    const packages = Object.fromEntries(tableBroPackages.map(name => [name, version(name)]).filter(([, value]) => value));
+    const profile = {
+        folder: root,
+        tableBro: { version: version('@table-bro/core'), packages, extensions: findExtensions(root).map(extension => extension.name) },
+        framework: version('@angular/core') ? { name: 'angular', version: version('@angular/core') } : { name: 'none', version: null },
+        ui: { material: version('@angular/material'), bootstrap: version('bootstrap') },
+        skins: { registered: [], where: [] },
+        styles: angularStyles(root),
+        customElements: [],
+        tables: [],
+        problems: []
+    };
+    const selectors = [];
+    const walk = folderMissing ? { files: [], cut: false } : sourceFiles(root);
+    for (const file of walk.files) {
+        const text = readText(file);
+        // The paths of the profile have the slashes of the web on every system
+        const relative = path.relative(root, file).split(path.sep).join('/');
+        if (text === null) {
+            continue;
+        }
+        for (const [skin, pattern] of [
+            ['mat', /provideTableBroMatSkin\(|registerSkin\(\s*['"]mat['"]/],
+            ['bs', /from\s+['"]@table-bro\/bootstrap['"]|import\s+['"]@table-bro\/bootstrap['"]|registerSkin\(\s*['"]bs['"]/],
+            ['nv', /from\s+['"]@table-bro\/native['"]|import\s+['"]@table-bro\/native['"]|registerSkin\(\s*['"]nv['"]/]
+        ]) {
+            if (pattern.test(text) && !profile.skins.registered.includes(skin)) {
+                profile.skins.registered.push(skin);
+                profile.skins.where.push(relative);
+            }
+        }
+        for (const match of text.matchAll(/customElements\.define\(\s*['"]([a-z][a-z0-9-]*)['"]/g)) {
+            profile.customElements.push({ tag: match[1], file: relative });
+        }
+        // The tag a column names in component.selector; the selector of an Angular component, as the filters, is no such tag
+        for (const match of text.matchAll(/component:\s*\{[^{}]*?selector:\s*['"](bro-[a-z0-9-]+)['"]/g)) {
+            selectors.push({ tag: match[1], file: relative });
+        }
+        if (/<table-bro-ng\b|<table-bro-filter-drawer-container(-ng)?\b|createElement\(\s*['"]table-bro['"]\s*\)/.test(text)) {
+            profile.tables.push(relative);
+        }
+    }
+    profile.problems = problems(profile, selectors, Boolean(version('@angular/elements')));
+    if (walk.cut) {
+        profile.problems.unshift({ code: 'search-cut', message: `the search stopped after ${maxFiles} source files or ${maxFolders} folders: ${root} is larger than a project`, fix: 'pass the root of the project in path' });
+    }
+    // A folder that is no project: the other problems follow from it, so it comes first
+    if (folderMissing) {
+        profile.problems.unshift({ code: 'folder-missing', message: `${root} is not a folder`, fix: 'pass the root of the project in path, or start the server in it' });
+    }
+    else if (!fs.existsSync(path.join(root, 'package.json'))) {
+        profile.problems.unshift({ code: 'package-json-missing', message: `${root} has no package.json: it is not the root of a project`, fix: 'pass the root of the project in path, or start the server in it; for a new project create it first, as ng new for Angular' });
+    }
+    // The problems of the setup come before the tags, so a cut list keeps them
+    for (const list of ['styles', 'customElements', 'tables', 'problems']) {
+        const lost = profile[list].splice(maxItems).length;
+        if (lost) {
+            profile.omitted = { ...profile.omitted, [list]: lost };
+        }
+    }
+    return profile;
+}
+/**
+ * The paid modules of the scope @table-bro-extended with a part of the MCP server: the field table-bro.mcp of their manifest,
+ * a file inside the package.
+ */
+export function findExtensions(root) {
+    const scope = path.join(root, 'node_modules', '@table-bro-extended');
+    if (!fs.existsSync(scope)) {
+        return [];
+    }
+    return fs.readdirSync(scope).flatMap(folder => {
+        const directory = path.join(scope, folder);
+        const manifest = readJson(path.join(directory, 'package.json'));
+        const entry = manifest?.['table-bro.mcp'];
+        if (typeof entry !== 'string' || typeof manifest.name !== 'string') {
+            return [];
+        }
+        const file = path.resolve(directory, entry);
+        const relative = path.relative(directory, file);
+        return (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) ? [{ name: manifest.name, entry: file }] : [];
+    });
+}
+function problems(profile, selectors, elements) {
+    const list = [];
+    const { packages, version } = profile.tableBro;
+    const angular = profile.framework.name === 'angular';
+    if (!version) {
+        list.push({ code: 'table-bro-missing', message: '@table-bro/core is not found among the packages', fix: 'npm install @table-bro/core, the wrapper and the skin of the project, as get_docs with the topic setup says' });
+    }
+    else if (version.replace(/^[^\d]*/, '') !== tableBroVersion) {
+        const project = version.replace(/^[^\d]*/, '');
+        let fix = 'run the server of the version of Table, Bro of the project';
+        if (older(project, firstMcpVersion)) {
+            fix = `@table-bro/mcp starts with Table, Bro ${firstMcpVersion}: update the packages of Table, Bro of the project to ${tableBroVersion}, or check the answers of this server against the project`;
+        }
+        else if (exactVersion.test(project)) {
+            fix = `run the server of the same version: npx -y @table-bro/mcp@${project}`;
+        }
+        list.push({ code: 'version-mismatch', message: `this MCP server describes Table, Bro ${tableBroVersion}, the project has ${JSON.stringify(version)}`, fix });
+    }
+    if (angular && version && !packages['@table-bro/angular']) {
+        list.push({ code: 'wrapper-missing', message: 'the Angular wrapper @table-bro/angular is not found', fix: 'npm install @table-bro/angular' });
+    }
+    if (packages['@table-bro/angular-material'] && !profile.framework.version) {
+        list.push({ code: 'angular-missing', message: '@table-bro/angular-material needs Angular', fix: 'use the skin bs or nv without Angular' });
+    }
+    const usesMat = Boolean(packages['@table-bro/angular-material']) || profile.skins.registered.includes('mat');
+    if (usesMat && !elements) {
+        list.push({ code: 'elements-package-missing', message: 'the mat skin and the cells of Angular need @angular/elements', fix: 'npm install @angular/elements' });
+    }
+    for (const [skin, name] of [['mat', '@table-bro/angular-material'], ['bs', '@table-bro/bootstrap'], ['nv', '@table-bro/native']]) {
+        if (packages[name] && !profile.skins.registered.includes(skin)) {
+            list.push({ code: 'skin-not-registered', message: `the registration of the skin ${skin} is not found`, fix: 'see get_docs with the topic setup' });
+        }
+    }
+    if (angular && version) {
+        const core = profile.styles.some(style => /table-bro(\.min)?\.s?css$/.test(style));
+        const skinStyles = profile.styles.some(style => /table-bro\.(material|bootstrap|native)|table-(bootstrap|native)/.test(style));
+        if (!core || !skinStyles) {
+            list.push({ code: 'css-missing', message: `the CSS of ${!core ? 'the core' : 'the skin'} is not found in "styles" of angular.json`, fix: 'see get_docs with the topic setup' });
+        }
+    }
+    const defined = new Set(profile.customElements.map(element => element.tag));
+    for (const { tag, file } of selectors) {
+        if (!defined.has(tag) && !readyTags.test(tag)) {
+            list.push({ code: 'tag-not-defined', message: `${file} names the tag ${tag}, and its customElements.define is not found`, fix: `define ${tag} before the table is created` });
+        }
+    }
+    return list;
+}
+/** Whether the version a comes before the version b, as 1.0.2 before 1.1.0. */
+function older(a, b) {
+    const [first, second] = [a, b].map(version => version.split('.').map(part => parseInt(part, 10) || 0));
+    const index = first.findIndex((part, position) => part !== second[position]);
+    return index !== -1 && first[index] < second[index];
+}
+function angularStyles(root) {
+    const workspace = readJson(path.join(root, 'angular.json'));
+    if (!workspace?.projects) {
+        return [];
+    }
+    return Object.values(workspace.projects).flatMap(project => {
+        const styles = project?.architect?.build?.options?.styles ?? [];
+        return styles.map((style) => (typeof style === 'string') ? style : style.input);
+    });
+}
+/** The source files of a project, up to the limits of the walk; a folder that the server may not read stays out. */
+function sourceFiles(root) {
+    const files = [];
+    const stack = [root];
+    let folders = 0;
+    while (stack.length) {
+        if (files.length >= maxFiles || ++folders > maxFolders) {
+            return { files, cut: true };
+        }
+        const directory = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(directory, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (!skippedFolders.has(entry.name) && !entry.name.startsWith('.')) {
+                    stack.push(path.join(directory, entry.name));
+                }
+            }
+            else if (sourceExtensions.includes(path.extname(entry.name))) {
+                if (files.length >= maxFiles) {
+                    return { files, cut: true };
+                }
+                files.push(path.join(directory, entry.name));
+            }
+        }
+    }
+    return { files, cut: false };
+}
+/** The text of a file, or null for one that the server may not read. */
+function readText(file) {
+    try {
+        return fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/server/main.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createServer, enabledExtensions, loadExtensions } from './server.js';
+// The agent starts the server in the folder of the project: the project and its paid modules are there. A paid module
+// joins by its name only: --extension @table-bro-extended/island-details
+const root = process.cwd();
+const server = createServer(root, await loadExtensions(root, enabledExtensions(process.argv.slice(2))));
+await server.connect(new StdioServerTransport());

package/dist/server/server.d.ts

@@ -0,0 +1,17 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { BroMcpExtension } from '../extension.js';
+/** The paid modules that the arguments of the server name: --extension <package>, once for each module. */
+export declare function enabledExtensions(args: string[]): string[];
+/**
+ * Loads the parts of the server of the installed paid modules that the server is started with, from the scope
+ * @table-bro-extended only: the server runs no code of a package that nobody named. A module that fails to load, or has
+ * no part of the server, is left out with a message on stderr, and the server works without it.
+ * @param root - the folder of the project
+ * @param enabled - the packages of the modules that the arguments of the server name
+ */
+export declare function loadExtensions(root: string, enabled: string[]): Promise<BroMcpExtension[]>;
+/**
+ * The MCP server of Table, Bro: six tools over the pure functions of the package. It reads the project and writes
+ * nothing: the agent writes the files and shows the changes to the developer.
+ */
+export declare function createServer(root: string, extensions?: BroMcpExtension[]): McpServer;