@stratta/mcp 1.16.1 → 1.17.0

package/README.md

@@ -46,6 +46,21 @@ This package is what you want when:
   uploads a file from your disk to a project dossier;
 - you would simply rather run the server yourself.
 
+## Lighter setup: `--simple`
+
+By default the server announces all 59 tools (about 67,000 characters of
+schemas). `--simple` announces only the 10 norm-reading tools (about 11,000),
+which is enough for an agent that just reads norms:
+
+```bash
+claude mcp add stratta --scope user -- npx -y @stratta/mcp --simple
+```
+
+`--toolsets dossiers,sites` adds families (`norms` is always on; `dossiers`,
+`sites`, `ingest`), `--full` restores everything, and the `STRATTA_TOOLSETS`
+environment variable does the same. An unknown family is ignored. For the
+remote connector, use the **Tools** menu on https://stratta.ch/connections.
+
 ## Install
 
 ### Claude Code (recommended)
@@ -347,14 +362,14 @@ Requires Python ≥ 3.10 with PyMuPDF (`python -m pip install --user pymupdf`).
 Your organization reached one of its limits. The error names the dimension, your
 current count and the plan limit. Retrying will fail identically.
 
-| Limit           | Free  | Pro    | Max    | Team   |
-| --------------- | ----- | ------ | ------ | ------ |
-| Norms           | 1     | 15     | 60     | 75     |
-| Sections        | 1,000 | 15,000 | 60,000 | 75,000 |
-| Figures         | 60    | 750    | 3,000  | 3,750  |
-| Queries / month | 500   | 15,000 | 60,000 | 75,000 |
-| Members         | 1     | 1      | 1      | 5      |
-| Site sheet      | –     | –      | ✓      | ✓      |
+| Limit           | Free  | Pro    | Max    |
+| --------------- | ----- | ------ | ------ |
+| Norms           | 1     | 15     | 60     |
+| Sections        | 1,000 | 15,000 | 60,000 |
+| Figures         | 60    | 750    | 3,000  |
+| Queries / month | 500   | 10,000 | 40,000 |
+| Members         | 1     | 1      | 1      |
+| Site sheet      | –     | –      | ✓      |
 
 Beyond the included queries, paid plans bill the overage per thousand. An
 Enterprise contract scales seats, norms and queries further and includes the

package/dist/index.js

@@ -18,6 +18,8 @@ import { SESSION_ID, usageDigest } from './usage.js';
 import { SERVER_INSTRUCTIONS } from './tools/catalog.gen.js';
 import { registerResources } from './resources.js';
 import { registerPrompts } from './prompts.js';
+import { TOOLSET_CHOICE } from './mode.js';
+import { toolInChoice } from './tools/toolsets.gen.js';
 /**
  * Read from package.json rather than repeated in a literal. The previous
  * version announced `0.3.0` while the published package was `0.6.0`, so every
@@ -108,13 +110,15 @@ async function call(def, args) {
         };
     }
 }
+// `--simple` or `--toolsets` (ADR 57): an agent that only reads norms is
+// shown ten tools instead of fifty-nine.
 for (const def of [
     ...readTools,
     ...siteTools,
     ...dossierTools,
     ...libraryTools,
     ...ingestTools,
-]) {
+].filter((d) => toolInChoice(d.name, TOOLSET_CHOICE))) {
     server.registerTool(def.name, {
         title: def.title,
         description: def.description,
@@ -154,10 +158,17 @@ COMMANDES
   --version        Version installée
   --help           Cet écran
 
+OPTIONS DU SERVEUR
+  --simple                 Normes seules : dix outils, démarrage plus léger
+  --toolsets dossiers,sites  Normes plus les familles choisies
+                           (dossiers, sites, ingest)
+  STRATTA_TOOLSETS=...     Même réglage par variable d'environnement
+
 Sans commande, le serveur MCP démarre sur stdio : c'est ce que fait votre
 agent, vous n'avez pas à le lancer vous-même.
 
   Installation   claude mcp add stratta --scope user -- npx -y @stratta/mcp
+  Mode simple    claude mcp add stratta --scope user -- npx -y @stratta/mcp --simple
   Raccourci      npm install -g @stratta/mcp   puis   stratta doctor
   Documentation  https://stratta.ch/docs`);
 }

package/dist/mode.d.ts

@@ -0,0 +1,16 @@
+import { type ToolsetChoice } from './tools/toolsets.gen.js';
+/**
+ * Which tool families this server shows (ADR 57).
+ *
+ *     npx -y @stratta/mcp --simple            norms only, ten tools
+ *     npx -y @stratta/mcp --toolsets dossiers norms and dossiers
+ *     STRATTA_TOOLSETS=sites npx -y @stratta/mcp
+ *
+ * The flag wins over the variable. Nothing set: every tool, as before 1.17.
+ * An unknown word is dropped, never fatal: a server that refuses to start on
+ * a typo looks, from the agent, exactly like a server that hangs.
+ */
+export declare function readToolsetChoice(argv: ReadonlyArray<string>, env: Readonly<Record<string, string | undefined>>): ToolsetChoice;
+/** The choice as the server's `get_methodology` reads it; absent for full. */
+export declare function toolsetsParam(choice: ToolsetChoice): string | undefined;
+export declare const TOOLSET_CHOICE: ToolsetChoice;

package/dist/mode.js

@@ -0,0 +1,32 @@
+import { parseToolsets } from './tools/toolsets.gen.js';
+/**
+ * Which tool families this server shows (ADR 57).
+ *
+ *     npx -y @stratta/mcp --simple            norms only, ten tools
+ *     npx -y @stratta/mcp --toolsets dossiers norms and dossiers
+ *     STRATTA_TOOLSETS=sites npx -y @stratta/mcp
+ *
+ * The flag wins over the variable. Nothing set: every tool, as before 1.17.
+ * An unknown word is dropped, never fatal: a server that refuses to start on
+ * a typo looks, from the agent, exactly like a server that hangs.
+ */
+export function readToolsetChoice(argv, env) {
+    if (argv.includes('--simple'))
+        return parseToolsets('simple');
+    if (argv.includes('--full'))
+        return null;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith('--toolsets=')) {
+            return parseToolsets(arg.slice('--toolsets='.length));
+        }
+        if (arg === '--toolsets')
+            return parseToolsets(argv[i + 1]);
+    }
+    return parseToolsets(env.STRATTA_TOOLSETS);
+}
+/** The choice as the server's `get_methodology` reads it; absent for full. */
+export function toolsetsParam(choice) {
+    return choice === null ? undefined : choice.join(',');
+}
+export const TOOLSET_CHOICE = readToolsetChoice(process.argv.slice(2), process.env);

package/dist/prompts.js

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 import { PROMPTS } from './tools/catalog.gen.js';
+import { choiceHas } from './tools/toolsets.gen.js';
+import { TOOLSET_CHOICE } from './mode.js';
 /**
  * Prompts: the three ways a user starts a conversation with Stratta, as
  * slash commands in the clients that support them (Claude Code, Claude
@@ -20,6 +22,10 @@ export function renderPrompt(p, args) {
 }
 export function registerPrompts(server) {
     for (const p of PROMPTS) {
+        // A prompt that drives dossier tools is not offered without them.
+        if (p.name === 'resume-dossier' && !choiceHas(TOOLSET_CHOICE, 'dossiers')) {
+            continue;
+        }
         const shape = {};
         for (const a of p.args) {
             const s = z.string().describe(a.description);

package/dist/tools/read.js

@@ -1,3 +1,4 @@
+import { TOOLSET_CHOICE, toolsetsParam } from '../mode.js';
 import { z } from 'zod';
 import { api } from '../client.js';
 import { requireApiKey } from '../auth.js';
@@ -31,7 +32,11 @@ const edition = (tool) => z.string().optional().describe(param(tool, 'edition'))
 export const getMethodology = defineTool({
     ...headOf('get_methodology'),
     inputSchema: {},
-    run: (client) => client.action(api._mcp.getMethodology, { apiKey: requireApiKey() }),
+    run: (client) => client.action(api._mcp.getMethodology, {
+        apiKey: requireApiKey(),
+        // The dossier policy only when the dossier tools are shown (ADR 57).
+        toolsets: toolsetsParam(TOOLSET_CHOICE),
+    }),
     // One Markdown document, read at the start of every conversation.
     toContent: (result) => ({
         content: [{ type: 'text', text: result.text }],

package/dist/tools/toolsets.gen.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Tool families: which MCP tools an agent is shown (ADR 57).
+ *
+ * Fifty-nine tools cost a client that loads every schema up front about
+ * 13 500 tokens before the first question, and a long menu makes a model
+ * pick worse. Most conversations only read norms. So the catalogue is cut
+ * into families, the way GitHub's MCP server cuts its own into toolsets:
+ *
+ * - `norms` is always there: the method, the account, and the norm reader.
+ * - `dossiers` adds the project work: questions, findings, decisions,
+ *   attachments, templates, deliverables and the office's methods.
+ * - `sites` adds the site scan and its readings.
+ * - `ingest` adds the ingestion tools (stdio only: they read a local PDF).
+ *
+ * "Simple" is `norms` alone. "Full" is everything the transport serves, and
+ * stays the default: the published ChatGPT plugin is a snapshot of the full
+ * list, and changing what a connection sees is the user's choice, never ours.
+ *
+ * ⚠️ Read by the browser (the connections page) and by the generator of the
+ * npm package's catalogue: imports nothing, erasable TypeScript only. The
+ * npm package gets a verbatim copy (`toolsets.gen.ts`).
+ * `mcpToolsets.test.ts` checks that every catalogue tool has a family.
+ */
+export type Toolset = 'norms' | 'dossiers' | 'sites' | 'ingest';
+export declare const TOOLSETS: ReadonlyArray<Toolset>;
+/** The families a user can turn on or off; `norms` cannot be turned off. */
+export declare const OPTIONAL_TOOLSETS: ReadonlyArray<Toolset>;
+export declare const TOOLSET_OF: Readonly<Record<string, Toolset>>;
+/** A tool with no family is shown only in full mode, never hidden by mistake. */
+export declare function toolsetOf(name: string): Toolset | null;
+/**
+ * What a connection was set to. `null` means full: every tool the transport
+ * serves, the behaviour of every connection made before families existed.
+ */
+export type ToolsetChoice = ReadonlyArray<Toolset> | null;
+export declare const SIMPLE_TOOLSETS: ReadonlyArray<Toolset>;
+/**
+ * Read a choice written by a person or a flag: `simple`, `full`, `all`, or a
+ * comma list such as `dossiers,sites`. Unknown words are dropped rather than
+ * refused, so a typo degrades to fewer tools, never to a server that does not
+ * start. `norms` is always added back.
+ */
+export declare function parseToolsets(raw: string | null | undefined): ToolsetChoice;
+/** Whether a tool is shown under a choice. */
+export declare function toolInChoice(name: string, choice: ToolsetChoice): boolean;
+/** Whether the choice carries a family (a full choice carries all of them). */
+export declare function choiceHas(choice: ToolsetChoice, family: Toolset): boolean;
+/** The stored form: a sorted list, or `undefined` for full. */
+export declare function normalizeChoice(choice: ToolsetChoice): Toolset[] | undefined;

package/dist/tools/toolsets.gen.js

@@ -0,0 +1,130 @@
+// Generated by scripts/build-mcp-catalog.mjs from convex/mcpToolsets.ts.
+// Do not edit: change the source and run the script.
+export const TOOLSETS = [
+    'norms',
+    'dossiers',
+    'sites',
+    'ingest',
+];
+/** The families a user can turn on or off; `norms` cannot be turned off. */
+export const OPTIONAL_TOOLSETS = [
+    'dossiers',
+    'sites',
+    'ingest',
+];
+export const TOOLSET_OF = {
+    get_methodology: 'norms',
+    whoami: 'norms',
+    list_norms: 'norms',
+    get_toc: 'norms',
+    get_subtree: 'norms',
+    get_section: 'norms',
+    search_in_norm: 'norms',
+    search_corpus: 'norms',
+    get_cross_refs: 'norms',
+    get_figure: 'norms',
+    list_dossiers: 'dossiers',
+    open_dossier: 'dossiers',
+    load_dossier: 'dossiers',
+    open_question: 'dossiers',
+    save_finding: 'dossiers',
+    record_decision: 'dossiers',
+    resolve_question: 'dossiers',
+    list_attachments: 'dossiers',
+    read_attachment: 'dossiers',
+    search_in_dossier: 'dossiers',
+    add_attachment: 'dossiers',
+    list_templates: 'dossiers',
+    apply_template: 'dossiers',
+    draft_deliverable: 'dossiers',
+    write_section: 'dossiers',
+    list_skills: 'dossiers',
+    get_skill: 'dossiers',
+    list_questions: 'dossiers',
+    get_question: 'dossiers',
+    get_dossier_activity: 'dossiers',
+    list_exports: 'dossiers',
+    update_question: 'dossiers',
+    add_option: 'dossiers',
+    update_option: 'dossiers',
+    delete_option: 'dossiers',
+    delete_question: 'dossiers',
+    add_comment: 'dossiers',
+    update_entry: 'dossiers',
+    attach_entry: 'dossiers',
+    scan_site: 'sites',
+    get_boreholes: 'sites',
+    get_site_context: 'sites',
+    list_sites: 'sites',
+    get_site: 'sites',
+    get_site_section: 'sites',
+    list_site_overlays: 'sites',
+    get_groundwater_contours: 'sites',
+    list_site_photos: 'sites',
+    list_site_neighbours: 'sites',
+    ingest_status: 'ingest',
+    ingest_create_document: 'ingest',
+    ingest_create_sections: 'ingest',
+    ingest_attach_formula: 'ingest',
+    ingest_attach_table: 'ingest',
+    ingest_attach_cross_ref: 'ingest',
+    ingest_upload_figure: 'ingest',
+    ingest_normalize_cross_refs: 'ingest',
+    ingest_publish: 'ingest',
+    ingest_delete: 'ingest',
+};
+/** A tool with no family is shown only in full mode, never hidden by mistake. */
+export function toolsetOf(name) {
+    return TOOLSET_OF[name] ?? null;
+}
+export const SIMPLE_TOOLSETS = ['norms'];
+/**
+ * Read a choice written by a person or a flag: `simple`, `full`, `all`, or a
+ * comma list such as `dossiers,sites`. Unknown words are dropped rather than
+ * refused, so a typo degrades to fewer tools, never to a server that does not
+ * start. `norms` is always added back.
+ */
+export function parseToolsets(raw) {
+    const text = (raw ?? '').trim().toLowerCase();
+    if (!text || text === 'full' || text === 'all')
+        return null;
+    if (text === 'simple')
+        return SIMPLE_TOOLSETS;
+    const picked = new Set(['norms']);
+    for (const word of text.split(/[\s,]+/)) {
+        const alias = {
+            norm: 'norms',
+            normes: 'norms',
+            dossier: 'dossiers',
+            deliverables: 'dossiers',
+            livrables: 'dossiers',
+            site: 'sites',
+            ingestion: 'ingest',
+        };
+        const name = (alias[word] ?? word);
+        if (TOOLSETS.includes(name))
+            picked.add(name);
+    }
+    return TOOLSETS.filter((t) => picked.has(t));
+}
+/** Whether a tool is shown under a choice. */
+export function toolInChoice(name, choice) {
+    if (choice === null)
+        return true;
+    const family = toolsetOf(name);
+    return family !== null && choice.includes(family);
+}
+/** Whether the choice carries a family (a full choice carries all of them). */
+export function choiceHas(choice, family) {
+    return choice === null || choice.includes(family);
+}
+/** The stored form: a sorted list, or `undefined` for full. */
+export function normalizeChoice(choice) {
+    if (choice === null)
+        return undefined;
+    const set = new Set(['norms', ...choice]);
+    // Every family turned on is the same as full, and full is how it is stored.
+    if (TOOLSETS.every((t) => set.has(t)))
+        return undefined;
+    return TOOLSETS.filter((t) => set.has(t));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stratta/mcp",
   "mcpName": "ch.stratta/mcp",
-  "version": "1.16.1",
+  "version": "1.17.0",
   "description": "MCP server exposing the engineering norms your firm is licensed for (SIA / Eurocodes) to any MCP client, via Stratta TreeRAG.",
   "license": "UNLICENSED",
   "author": "SmartFlow <hello@stratta.ch>",

package/skills/consult-stratta/SKILL.md

@@ -68,4 +68,4 @@ Before drafting a document (project basis, use agreement, terrain chapter, verif
 - Do not expose internal identifiers unless the next Stratta tool call requires them.
 - Ingesting a new norm starts from a PDF on the user's own machine: it goes through the local `@stratta/mcp` server and its `ingest-norm` skill, never through the remote connector.
 
-methodology: v3
+methodology: v4