@stratta/mcp 0.12.1 → 0.13.0

package/README.md

@@ -34,7 +34,7 @@ https://stratta.ch/mcp
 That is the shorter path, the one the dashboard walks you through for Claude,
 ChatGPT, Claude Code, Codex, Cursor, VS Code, Gemini CLI and Windsurf, and the
 only one that works in an agent running in the cloud (claude.ai, ChatGPT). It
-serves 32 of the 33 tools below, **ingestion included**: the pre-pass script is
+serves 35 of the 36 tools below, **ingestion included**: the pre-pass script is
 downloaded from https://stratta.ch/ingest-prepass.py when it is not on disk.
 See https://stratta.ch/docs/en/guides/connect-remote.
 
@@ -176,7 +176,7 @@ named `E2E dossier <timestamp>` and does not delete it.
 
 ## Tools exposed
 
-33 tools, generated from one catalogue shared with the remote connector (which
+36 tools, generated from one catalogue shared with the remote connector (which
 serves the same 33 minus `add_attachment`).
 
 **Read** (10 tools — query the norms of your workspace):
@@ -194,6 +194,14 @@ serves the same 33 minus `add_attachment`).
 | `get_figure`      | Retrieve a figure inline (base64 ImageContent).                                         |
 | `get_cross_refs`  | Outgoing cross-refs from a section to other norms.                                      |
 
+**Site** (3 tools — what public Swiss registers know about a plot):
+
+| Tool               | Purpose                                                                                                                             |
+| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
+| `scan_site`        | Collect municipality, parcel, elevation, geology, nearby boreholes, polluted sites, hazards and noise class around a Swiss address. |
+| `get_site_context` | Read what the scan settled, and — separately — what it could not, with the reason.                                                  |
+| `get_boreholes`    | Read the boreholes nearest the site with their logged strata, SIA 261 ground class, water table, and links to cantonal documents.   |
+
 **Dossier** (13 tools — keep what was decided on a project):
 
 | Tool                | Purpose                                                                                                |

package/dist/index.js

@@ -12,6 +12,7 @@ import { confirmWithUser } from './confirm.js';
 import { readTools } from './tools/read.js';
 import { ingestTools } from './tools/ingest.js';
 import { dossierTools } from './tools/dossier.js';
+import { siteTools } from './tools/site.js';
 import { SESSION_ID, usageDigest } from './usage.js';
 import { SERVER_INSTRUCTIONS } from './tools/catalog.gen.js';
 import { registerResources } from './resources.js';
@@ -102,7 +103,12 @@ async function call(def, args) {
         };
     }
 }
-for (const def of [...readTools, ...dossierTools, ...ingestTools]) {
+for (const def of [
+    ...readTools,
+    ...siteTools,
+    ...dossierTools,
+    ...ingestTools,
+]) {
     server.registerTool(def.name, {
         title: def.title,
         description: def.description,

package/dist/tools/catalog.gen.js

@@ -194,6 +194,64 @@ export const CATALOG = [
             "figureId": "Figure identifier from the figures array of get_section."
         }
     },
+    {
+        "name": "scan_site",
+        "title": "Scan a site",
+        "description": "Collect what public Swiss registers know about a building site: municipality, parcel, ground elevation, geology, nearby boreholes with their strata, polluted sites, groundwater protection, natural hazards, noise sensitivity. Give a Swiss address; it is geocoded server-side against swisstopo, so do not pass coordinates you inferred. Open the dossier first with open_dossier: one site per dossier. The scan runs in the background and takes a few seconds; read the result with get_site_context. It is a survey of public registers, never a geotechnical study.",
+        "annotations": {
+            "readOnlyHint": false,
+            "destructiveHint": false,
+            "idempotentHint": false,
+            "openWorldHint": true
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "dossierId": "Dossier id returned by open_dossier or list_dossiers.",
+            "address": "The street address in Switzerland, as the user wrote it: \"Av. de Rhodanie 58, Lausanne\".",
+            "radius": "How far around the site to look for boreholes and constraints, in metres (50 to 500, default 300)."
+        }
+    },
+    {
+        "name": "get_boreholes",
+        "title": "Read the boreholes of a site",
+        "description": "Read the boreholes a site scan found, nearest first, with their logged strata (depth interval, description, period), depth, year, SIA 261 ground class when logged, water table when logged, and links to the cantonal documents. Call it after get_site_context when the question turns on what the ground is actually made of. Each borehole is one observation at one point: quote it with its distance, never interpolate between two of them, and never derive a design value from a layer description.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "siteId": "Site id returned by scan_site.",
+            "limit": "How many boreholes to return, nearest first (1 to 40, default 8). Ask for more only when the nearest ones did not answer.",
+            "withStrataOnly": "Return only the boreholes whose strata were read. Use it when the layers are the point; the count of what was left out still travels in `total`."
+        }
+    },
+    {
+        "name": "get_site_context",
+        "title": "Read a site scan",
+        "description": "Read what a site scan found, grouped by topic, each value with its source and the date THE DATA was current. Returns two separate lists: what the registers settled, and what they could NOT settle, with the reason. Report the second list to the user in full: it is what a bid has to budget for. Never derive a design value (friction angle, bearing capacity, modulus) from a geological description returned here; state what the register says and that a local investigation is required.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "siteId": "Site id returned by scan_site."
+        }
+    },
     {
         "name": "list_dossiers",
         "title": "Project dossiers",

package/dist/tools/site.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export declare const scanSite: import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    address: z.ZodString;
+    /**
+     * ⚠️ Bounded here as well as on the server. The server clamps rather than
+     * refusing, so a model asking for five kilometres would silently get five
+     * hundred metres and describe a radius it did not receive.
+     */
+    radius: z.ZodOptional<z.ZodNumber>;
+}>;
+export declare const getSiteContext: import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+}>;
+/**
+ * The boreholes, with their logs.
+ *
+ * ⚠️ A separate call rather than a bigger `get_site_context`: a Geneva radius
+ * holds a hundred and eight boreholes, and pouring their logs into every read
+ * of the fiche would make the cheap call expensive for every question that
+ * never looks at a log.
+ */
+export declare const getBoreholes: import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+    /**
+     * ⚠️ Bounded here as well as on the server. The server clamps rather than
+     * refusing, so a model asking for two hundred would silently get forty and
+     * describe a list it did not receive.
+     */
+    limit: z.ZodOptional<z.ZodNumber>;
+    withStrataOnly: z.ZodOptional<z.ZodBoolean>;
+}>;
+export declare const siteTools: (import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    address: z.ZodString;
+    /**
+     * ⚠️ Bounded here as well as on the server. The server clamps rather than
+     * refusing, so a model asking for five kilometres would silently get five
+     * hundred metres and describe a radius it did not receive.
+     */
+    radius: z.ZodOptional<z.ZodNumber>;
+}> | import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+}> | import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+    /**
+     * ⚠️ Bounded here as well as on the server. The server clamps rather than
+     * refusing, so a model asking for two hundred would silently get forty and
+     * describe a list it did not receive.
+     */
+    limit: z.ZodOptional<z.ZodNumber>;
+    withStrataOnly: z.ZodOptional<z.ZodBoolean>;
+}>)[];

package/dist/tools/site.js

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import { api } from '../client.js';
+import { requireApiKey } from '../auth.js';
+import { catalogEntry, param } from './catalog.gen.js';
+import { defineTool } from './define.js';
+/**
+ * The three site tools: what public Swiss registers know about a plot.
+ *
+ * `scan_site` starts the collection, `get_site_context` reads what came back.
+ * They are split because the scan queries a dozen federal and cantonal
+ * services and takes a few seconds; a single blocking tool would either time
+ * out or return half a fiche.
+ *
+ * ⚠️ `get_site_context` returns what could NOT be established as a separate,
+ * first-class list. That list is the point: "no borehole within three hundred
+ * metres, molasse likely but unconfirmed, budget for three drillings" is the
+ * sentence worth money when pricing a bid, and an agent that only reads the
+ * settled facts will present the fiche as complete.
+ */
+const headOf = (name) => {
+    const entry = catalogEntry(name);
+    return {
+        name,
+        title: entry.title,
+        description: entry.description,
+        annotations: entry.annotations,
+    };
+};
+export const scanSite = defineTool({
+    ...headOf('scan_site'),
+    inputSchema: {
+        dossierId: z.string().min(1).describe(param('scan_site', 'dossierId')),
+        address: z.string().min(3).max(200).describe(param('scan_site', 'address')),
+        /**
+         * ⚠️ Bounded here as well as on the server. The server clamps rather than
+         * refusing, so a model asking for five kilometres would silently get five
+         * hundred metres and describe a radius it did not receive.
+         */
+        radius: z
+            .number()
+            .int()
+            .min(50)
+            .max(500)
+            .optional()
+            .describe(param('scan_site', 'radius')),
+    },
+    run: (client, args) => client.action(api.sitesApi.scanSite, {
+        apiKey: requireApiKey(),
+        dossierId: args.dossierId,
+        address: args.address,
+        radius: args.radius,
+    }),
+});
+export const getSiteContext = defineTool({
+    ...headOf('get_site_context'),
+    inputSchema: {
+        siteId: z.string().min(1).describe(param('get_site_context', 'siteId')),
+    },
+    run: (client, args) => client.action(api.sitesApi.getSiteContext, {
+        apiKey: requireApiKey(),
+        siteId: args.siteId,
+    }),
+});
+/**
+ * The boreholes, with their logs.
+ *
+ * ⚠️ A separate call rather than a bigger `get_site_context`: a Geneva radius
+ * holds a hundred and eight boreholes, and pouring their logs into every read
+ * of the fiche would make the cheap call expensive for every question that
+ * never looks at a log.
+ */
+export const getBoreholes = defineTool({
+    ...headOf('get_boreholes'),
+    inputSchema: {
+        siteId: z.string().min(1).describe(param('get_boreholes', 'siteId')),
+        /**
+         * ⚠️ Bounded here as well as on the server. The server clamps rather than
+         * refusing, so a model asking for two hundred would silently get forty and
+         * describe a list it did not receive.
+         */
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(40)
+            .optional()
+            .describe(param('get_boreholes', 'limit')),
+        withStrataOnly: z
+            .boolean()
+            .optional()
+            .describe(param('get_boreholes', 'withStrataOnly')),
+    },
+    run: (client, args) => client.action(api.sitesApi.getBoreholes, {
+        apiKey: requireApiKey(),
+        siteId: args.siteId,
+        limit: args.limit,
+        withStrataOnly: args.withStrataOnly,
+    }),
+});
+export const siteTools = [scanSite, getSiteContext, getBoreholes];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stratta/mcp",
   "mcpName": "ch.stratta/mcp",
-  "version": "0.12.1",
+  "version": "0.13.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/scripts/ingest-prepass.py

@@ -412,6 +412,14 @@ def extract_chapters(
             per_page[meta["pageStart"]] += 1
         return {p - 1 for p, n in per_page.items() if n >= 3}
 
+    # A règlement (SIA 144) is cut in articles, "Art. 7 Titre", a Eurocode
+    # in "Section 7 Titre". The passes below would take table rows for
+    # chapters and lose the whole text outside any section; a labelled
+    # layout is unambiguous, so it is read first and wins outright.
+    labelled = infer_labelled_chapters(doc, skip)
+    if len(labelled) >= 3:
+        return recover_missing_chapters(doc, prune_chapters(labelled), skip)
+
     for pattern in (CHAP_UPPER_RE, CHAP_MIXED_RE):
         chapters = scan(pattern, skip)
         extra = toc_like_pages(chapters)
@@ -422,10 +430,77 @@ def extract_chapters(
 
     for num, meta in infer_unnumbered_chapters(doc, skip).items():
         chapters.setdefault(num, meta)
+
     chapters = prune_chapters(chapters)
     return recover_missing_chapters(doc, chapters, skip)
 
 
+LABEL_RE = re.compile(
+    r"^(Art\.?|Section|Chapitre|Kapitel|Abschnitt)\s*(\d{1,3})\b[\s:_.\u2013-]*(.*?)(?:\s+(\d{1,3}))?$"
+)
+
+
+def infer_labelled_chapters(doc: "fitz.Document", skip: set[int]) -> dict[str, dict]:
+    """Chapters from labelled headings: "Art. 7 Titre" (a règlement, SIA 144)
+    or "Section 7 Titre" (a Eurocode adopted as SIA 267.001).
+
+    Two sources, because neither is complete on its own:
+
+    - the **contents page** (three or more labelled lines on one page) gives
+      clean titles, and for a règlement the printed page number
+      ("Art. 1 But et modalités de l'appel d'offres 6");
+    - the **body** gives where each heading really starts. In a règlement the
+      OCR merges the margin column with the text ("Art. 1 1.1 L'enjeu…"), so
+      the body knows the page but not the title; in a Eurocode the body line
+      is "Section 2 _ Bases du calcul geotechnique", usable but often without
+      its accents.
+
+    A number seen in both takes its title from the contents and its page from
+    the body. A number seen only in the contents takes the printed page plus
+    the offset the pairs establish; only in the body, the body's title.
+    """
+    contents: dict[str, tuple[str, int | None]] = {}
+    body: dict[str, tuple[str, int]] = {}
+    for pageno in range(doc.page_count):
+        if pageno in skip:
+            continue
+        hits: list[tuple[str, str, int | None]] = []
+        for line in (l.strip() for l in page_lines(doc, pageno)):
+            m = LABEL_RE.match(line)
+            if not m:
+                continue
+            title = clean(m.group(3))
+            printed = int(m.group(4)) if m.group(4) else None
+            hits.append((m.group(2), title, printed))
+        if len({h[0] for h in hits}) >= 3:
+            for num, title, printed in hits:
+                if title and plausible_title(title):
+                    contents.setdefault(num, (title, printed))
+        else:
+            for num, title, printed in hits:
+                body.setdefault(num, (title, pageno + 1))
+
+    offsets = sorted(
+        body[num][1] - printed
+        for num, (_t, printed) in contents.items()
+        if printed is not None and num in body and body[num][1] > printed
+    )
+    offset = offsets[len(offsets) // 2] if offsets else None
+
+    found: dict[str, dict] = {}
+    for num in sorted(set(contents) | set(body), key=int):
+        c_title, printed = contents.get(num, ("", None))
+        b_title, b_page = body.get(num, ("", None))
+        title = c_title or b_title
+        page = b_page
+        if page is None and printed is not None and offset is not None:
+            page = printed + offset
+        if not title or page is None or not (1 <= page <= doc.page_count):
+            continue
+        found[num] = {"title": title, "pageStart": page}
+    return found
+
+
 SCOPE_TITLE_RE = re.compile(
     r"^(DOMAINE D.APPLICATION|GELTUNGSBEREICH|CAMPO D.APPLICAZIONE|SCOPE)\b", re.I
 )
@@ -721,6 +796,13 @@ def locate_heading(lines: list[str], node: dict) -> int:
             if line.strip().lower().startswith(needle):
                 return i
         return -1
+    if path.isdigit():
+        labelled = re.compile(
+            r"^(?:Art\.?|Section|Chapitre|Kapitel|Abschnitt)\s*" + path + r"\b"
+        )
+        for i, line in enumerate(lines):
+            if labelled.match(line.strip()):
+                return i
     prefix = path + " "
     for i, line in enumerate(lines):
         s = line.strip()