enterprise-architect-mcp 2.1.0

package/dist/model-session.js

@@ -0,0 +1,172 @@
+import { ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { openDatabase } from "./database.js";
+import { listQeaPathCandidates, resolveQeaTarget, } from "./resolve-qea-path.js";
+import { readRememberedPath, rememberPath } from "./remembered-path.js";
+/** Long enough to go and find the file, short enough not to hang the conversation. */
+const PROMPT_TIMEOUT_MS = 5 * 60_000;
+const HOW_TO_CONFIGURE = "Provide it as a CLI argument, in the EA_QEA_PATH environment variable, " +
+    "or as EA_QEA_PATH in a .env file in the working directory.";
+export function describeSource(source) {
+    switch (source) {
+        case "argument":
+            return "the command line";
+        case "environment":
+            return "the EA_QEA_PATH environment variable";
+        case "dotenv":
+            return "EA_QEA_PATH in .env";
+        case "remembered":
+            return "a previous answer to the path prompt";
+        case "prompt":
+            return "your answer to the path prompt";
+    }
+}
+const reasonOf = (err) => (err instanceof Error ? err.message : String(err));
+/** Tool errors reach the client as the message verbatim, which still owes callers structured JSON. */
+const modelUnavailable = (message) => new Error(JSON.stringify({ error: "no_model", message, howToConfigure: HOW_TO_CONFIGURE }, null, 2));
+export class ModelSession {
+    server;
+    cliArg;
+    db;
+    opened;
+    opening;
+    /** A rejected answer is not remembered, so the next prompt has to carry the reason itself. */
+    lastPromptFailure;
+    constructor(server, cliArg) {
+        this.server = server;
+        this.cliArg = cliArg;
+    }
+    origin() {
+        return this.opened;
+    }
+    /** Startup diagnostics only: reports what is configured without opening anything. */
+    reportConfiguration() {
+        const candidates = this.candidates();
+        if (candidates.length === 0) {
+            console.error("mcp-server-ea: no model configured — will ask for one on first use.");
+            return;
+        }
+        for (const candidate of candidates) {
+            const target = resolve(candidate.configured);
+            const status = existsSync(target) ? "exists, not opened yet" : "NOT FOUND";
+            console.error(`mcp-server-ea: ${describeSource(candidate.source)} → "${target}" (${status})`);
+        }
+    }
+    database() {
+        if (this.db)
+            return Promise.resolve(this.db);
+        // Concurrent tool calls must share one attempt, or they each raise a prompt.
+        this.opening ??= this.open().finally(() => {
+            this.opening = undefined;
+        });
+        return this.opening;
+    }
+    candidates() {
+        const configured = listQeaPathCandidates(this.cliArg);
+        const remembered = readRememberedPath();
+        return remembered
+            ? [...configured, { source: "remembered", configured: remembered }]
+            : configured;
+    }
+    async open() {
+        const candidates = this.candidates();
+        const ignored = [];
+        const canAsk = Boolean(this.server.server.getClientCapabilities()?.elicitation);
+        for (const [index, candidate] of candidates.entries()) {
+            try {
+                return this.adopt(candidate, {
+                    ignored,
+                    shadowed: candidates.slice(index + 1).filter((c) => c.configured !== candidate.configured),
+                });
+            }
+            catch (err) {
+                const reason = reasonOf(err);
+                // Skipping a broken source only buys the user's answer a turn where an answer is possible.
+                // Without a prompt there is nothing to protect, and falling through would quietly open some
+                // other session's model. An explicit argument is this run's intent, never a stale default.
+                if (candidate.source === "argument" || !canAsk) {
+                    throw modelUnavailable(`${reason} — configured by ${describeSource(candidate.source)}.`);
+                }
+                ignored.push({ ...candidate, reason });
+                console.error(`mcp-server-ea: ignoring ${describeSource(candidate.source)} ("${candidate.configured}") — ${reason}`);
+            }
+        }
+        const answer = await this.ask(this.promptReason(ignored));
+        let db;
+        try {
+            db = this.adopt(answer, { ignored, shadowed: [] });
+        }
+        catch (err) {
+            // Remembering a path that does not open would make every later session start broken.
+            this.lastPromptFailure = `${reasonOf(err)}.`;
+            throw modelUnavailable(`${this.lastPromptFailure} Ask again to try another path.`);
+        }
+        this.lastPromptFailure = undefined;
+        try {
+            rememberPath(answer.configured);
+        }
+        catch (err) {
+            // Persisting the answer is a convenience; the model is already open and the call must not fail.
+            console.error(`mcp-server-ea: could not remember the path — ${reasonOf(err)}`);
+        }
+        return db;
+    }
+    /** Opens a candidate and, on success, makes it this session's model. */
+    adopt(candidate, context) {
+        const path = resolveQeaTarget(candidate.configured);
+        const db = openDatabase(path);
+        this.db = db;
+        this.opened = { ...candidate, ...context };
+        console.error(`mcp-server-ea: opened "${path}" from ${describeSource(candidate.source)}`);
+        return db;
+    }
+    promptReason(ignored) {
+        if (this.lastPromptFailure) {
+            return `That path did not work — ${this.lastPromptFailure}`;
+        }
+        if (ignored.length > 0) {
+            return `The model configured by ${describeSource(ignored[0].source)} could not be opened — ${ignored[0].reason}.`;
+        }
+        return "No Enterprise Architect model is configured yet.";
+    }
+    async ask(reason) {
+        if (!this.server.server.getClientCapabilities()?.elicitation) {
+            throw modelUnavailable(`${reason} This client cannot prompt for one.`);
+        }
+        let result;
+        try {
+            result = await this.server.server.elicitInput({
+                message: `${reason} Where is your .qea export?`,
+                requestedSchema: {
+                    type: "object",
+                    properties: {
+                        qea_path: {
+                            type: "string",
+                            title: "Model path",
+                            description: "Full path to a .qea file, or to a folder containing one — " +
+                                "the newest .qea in that folder is used.",
+                        },
+                    },
+                    required: ["qea_path"],
+                },
+            }, { timeout: PROMPT_TIMEOUT_MS });
+        }
+        catch (err) {
+            if (err.code === ErrorCode.RequestTimeout) {
+                throw modelUnavailable("The model path prompt went unanswered. Ask again to retry, or set it up permanently.");
+            }
+            throw err;
+        }
+        if (result.action !== "accept") {
+            throw modelUnavailable("No model path was given, so there is nothing to read. Ask again to retry, or set it up permanently.");
+        }
+        const configured = String(result.content?.qea_path ?? "").trim();
+        if (!configured) {
+            // An empty value would resolve to the working directory and open whatever it finds there.
+            this.lastPromptFailure = "the answer was empty.";
+            throw modelUnavailable("No path was entered. Ask again to try another path.");
+        }
+        return { source: "prompt", configured };
+    }
+}

package/dist/package-path.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from "./database.js";
+export declare function buildPackagePath(db: Database, packageId: number): string;

package/dist/package-path.js

@@ -0,0 +1,36 @@
+/**
+ * Build the full package path from root to the given package, dot-separated.
+ * Uses a preloaded package map memoized per database connection.
+ */
+const packageMaps = new WeakMap();
+function getPackageMap(db) {
+    let map = packageMaps.get(db);
+    if (map)
+        return map;
+    map = new Map();
+    const rows = db
+        .prepare("SELECT Package_ID, Name, Parent_ID FROM t_package")
+        .all();
+    for (const row of rows) {
+        map.set(row.Package_ID, { name: row.Name, parentId: row.Parent_ID });
+    }
+    packageMaps.set(db, map);
+    return map;
+}
+export function buildPackagePath(db, packageId) {
+    const map = getPackageMap(db);
+    const parts = [];
+    let current = packageId;
+    const visited = new Set();
+    while (current > 0) {
+        if (visited.has(current))
+            break;
+        visited.add(current);
+        const pkg = map.get(current);
+        if (!pkg)
+            break;
+        parts.unshift(pkg.name);
+        current = pkg.parentId;
+    }
+    return parts.join(".");
+}

package/dist/remembered-path.d.ts

@@ -0,0 +1,5 @@
+/** Where the answer to the path prompt is kept, so it is asked once and not every start. */
+export declare function configFilePath(): string;
+export declare function readRememberedPath(): string | undefined;
+export declare function rememberPath(qeaPath: string): void;
+export declare function forgetPath(): void;

package/dist/remembered-path.js

@@ -0,0 +1,43 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const APP_DIR = "enterprise-architect-mcp";
+/** Where the answer to the path prompt is kept, so it is asked once and not every start. */
+export function configFilePath() {
+    const override = process.env.EA_MCP_CONFIG_DIR;
+    if (override)
+        return join(override, "config.json");
+    const base = process.platform === "win32"
+        ? process.env.APPDATA || join(homedir(), "AppData", "Roaming")
+        : process.platform === "darwin"
+            ? join(homedir(), "Library", "Application Support")
+            : process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+    return join(base, APP_DIR, "config.json");
+}
+export function readRememberedPath() {
+    const file = configFilePath();
+    if (!existsSync(file))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf-8"));
+        if (typeof parsed !== "object" || parsed === null)
+            return undefined;
+        const value = parsed.qeaPath;
+        return typeof value === "string" && value.trim() ? value.trim() : undefined;
+    }
+    catch {
+        // A corrupt config must not stop the server — it just means nothing is remembered.
+        return undefined;
+    }
+}
+export function rememberPath(qeaPath) {
+    const file = configFilePath();
+    mkdirSync(dirname(file), { recursive: true });
+    // The file records where one person's model lives, so it is written for that person only.
+    writeFileSync(file, `${JSON.stringify({ qeaPath }, null, 2)}\n`, { encoding: "utf-8", mode: 0o600 });
+}
+export function forgetPath() {
+    const file = configFilePath();
+    if (existsSync(file))
+        writeFileSync(file, `${JSON.stringify({}, null, 2)}\n`, "utf-8");
+}

package/dist/resolve-qea-path.d.ts

@@ -0,0 +1,26 @@
+/** Which configuration source supplied the path. */
+export type QeaPathSource = "argument" | "environment" | "dotenv" | "remembered" | "prompt";
+export interface QeaPathCandidate {
+    source: QeaPathSource;
+    /** The value as configured, before resolution or directory scanning. */
+    configured: string;
+}
+export interface RejectedCandidate extends QeaPathCandidate {
+    reason: string;
+}
+export interface QeaPathOrigin extends QeaPathCandidate {
+    /** Higher-priority sources that were tried and could not be opened. */
+    ignored: RejectedCandidate[];
+    /** Lower-priority sources carrying a different value — a forgotten setting shows up here. */
+    shadowed: QeaPathCandidate[];
+}
+/**
+ * The configured sources in priority order, without touching the filesystem
+ * beyond reading .env.
+ *
+ * An empty source counts as unset, so a skipped ${input:...} in VS Code
+ * (substituted as "") drops out here.
+ */
+export declare function listQeaPathCandidates(cliArg?: string): QeaPathCandidate[];
+/** Turns a configured value into a concrete .qea file path. */
+export declare function resolveQeaTarget(target: string): string;

package/dist/resolve-qea-path.js

@@ -0,0 +1,58 @@
+import { existsSync, statSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+/**
+ * The configured sources in priority order, without touching the filesystem
+ * beyond reading .env.
+ *
+ * An empty source counts as unset, so a skipped ${input:...} in VS Code
+ * (substituted as "") drops out here.
+ */
+export function listQeaPathCandidates(cliArg) {
+    const candidates = [
+        { source: "argument", configured: cliArg || undefined },
+        { source: "environment", configured: process.env.EA_QEA_PATH || undefined },
+        { source: "dotenv", configured: loadFromDotEnv() },
+    ];
+    return candidates.filter((c) => c.configured !== undefined);
+}
+/** Turns a configured value into a concrete .qea file path. */
+export function resolveQeaTarget(target) {
+    const resolved = resolve(target);
+    if (!existsSync(resolved)) {
+        // Quoted so leading/trailing whitespace in the path is visible.
+        throw new Error(`Path not found: "${resolved}"`);
+    }
+    if (statSync(resolved).isDirectory()) {
+        return findNewestQea(resolved);
+    }
+    return resolved;
+}
+function findNewestQea(dir) {
+    const files = readdirSync(dir)
+        .filter((f) => f.endsWith(".qea"))
+        .map((f) => {
+        const fullPath = join(dir, f);
+        return { path: fullPath, mtime: statSync(fullPath).mtimeMs };
+    })
+        .sort((a, b) => b.mtime - a.mtime);
+    if (files.length === 0) {
+        throw new Error(`No .qea files found in directory: "${dir}"`);
+    }
+    return files[0].path;
+}
+function loadFromDotEnv() {
+    const envPath = join(process.cwd(), ".env");
+    if (!existsSync(envPath))
+        return undefined;
+    const content = readFileSync(envPath, "utf-8");
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("#") || !trimmed)
+            continue;
+        const match = trimmed.match(/^EA_QEA_PATH\s*=\s*(.+)$/);
+        if (match) {
+            return match[1].trim().replace(/^["']|["']$/g, "");
+        }
+    }
+    return undefined;
+}

package/dist/text.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Text handling for EA model content: entity decoding, case folding, markup type, link extraction.
+ */
+/**
+ * Decode HTML numeric and named character entities, preserving structural escapes.
+ * &#NNN; and &#xHH; → character. Named entities (e.g. á) → character.
+ * < > & are preserved — they are structural escapes, not encoded text.
+ */
+export declare function decodeEntities(html: string | null): string | null;
+/**
+ * Fold text for case- and diacritic-insensitive matching.
+ * Lowercase → NFD decomposition → strip combining marks → map non-decomposing letters.
+ *
+ * Lowercasing first is what lets `İ` reduce to `i`: its lowercase form carries a
+ * combining dot that the mark strip then removes.
+ */
+export declare function foldText(s: string): string;
+/**
+ * Locale used to order names for display. `EA_LOCALE` overrides; otherwise the
+ * host default applies, since the model's language is not knowable from the export.
+ */
+export declare const orderingLocale: string | undefined;
+/** Order two model names, tolerating nulls. Accented initials sort in place, not after `Z`. */
+export declare function compareNames(a: string | null | undefined, b: string | null | undefined): number;
+/** The content type declared for all EA model text fields. */
+export declare const EA_TEXT_CONTENT_TYPE = "text/html; ea-dialect";
+export interface ExtractedLink {
+    href: string;
+    scheme: string | null;
+    resolvable: boolean;
+}
+/**
+ * Extract <a href="..."> targets from EA HTML text.
+ * Model-internal schemes ($element://, $diagram://, $feature://, $package://) are resolvable.
+ * Everything else is external.
+ */
+export declare function extractLinks(html: string | null): ExtractedLink[];

package/dist/text.js

@@ -0,0 +1,152 @@
+/**
+ * Text handling for EA model content: entity decoding, case folding, markup type, link extraction.
+ */
+/**
+ * Named HTML character entities appearing in EA notes.
+ *
+ * Covers Latin-1 Supplement and Latin Extended-A in full — every accented letter
+ * used by a European Latin-script language — rather than one language's subset,
+ * so an export in any of them decodes the same way. Numeric entities dominate in
+ * practice; named ones arrive with text pasted from Word and other HTML sources.
+ */
+const NAMED_ENTITIES = {
+    // Latin-1 Supplement, uppercase
+    Agrave: "À", Aacute: "Á", Acirc: "Â", Atilde: "Ã", Auml: "Ä", Aring: "Å", AElig: "Æ",
+    Ccedil: "Ç", Egrave: "È", Eacute: "É", Ecirc: "Ê", Euml: "Ë",
+    Igrave: "Ì", Iacute: "Í", Icirc: "Î", Iuml: "Ï",
+    ETH: "Ð", Ntilde: "Ñ", Ograve: "Ò", Oacute: "Ó", Ocirc: "Ô", Otilde: "Õ", Ouml: "Ö", Oslash: "Ø",
+    Ugrave: "Ù", Uacute: "Ú", Ucirc: "Û", Uuml: "Ü", Yacute: "Ý", THORN: "Þ",
+    // Latin-1 Supplement, lowercase
+    szlig: "ß",
+    agrave: "à", aacute: "á", acirc: "â", atilde: "ã", auml: "ä", aring: "å", aelig: "æ",
+    ccedil: "ç", egrave: "è", eacute: "é", ecirc: "ê", euml: "ë",
+    igrave: "ì", iacute: "í", icirc: "î", iuml: "ï",
+    eth: "ð", ntilde: "ñ", ograve: "ò", oacute: "ó", ocirc: "ô", otilde: "õ", ouml: "ö", oslash: "ø",
+    ugrave: "ù", uacute: "ú", ucirc: "û", uuml: "ü", yacute: "ý", thorn: "þ", yuml: "ÿ",
+    // Latin Extended-A
+    Amacr: "Ā", amacr: "ā", Abreve: "Ă", abreve: "ă", Aogon: "Ą", aogon: "ą",
+    Cacute: "Ć", cacute: "ć", Ccirc: "Ĉ", ccirc: "ĉ", Cdot: "Ċ", cdot: "ċ", Ccaron: "Č", ccaron: "č",
+    Dcaron: "Ď", dcaron: "ď", Dstrok: "Đ", dstrok: "đ",
+    Emacr: "Ē", emacr: "ē", Ebreve: "Ĕ", ebreve: "ĕ", Edot: "Ė", edot: "ė",
+    Eogon: "Ę", eogon: "ę", Ecaron: "Ě", ecaron: "ě",
+    Gcirc: "Ĝ", gcirc: "ĝ", Gbreve: "Ğ", gbreve: "ğ", Gdot: "Ġ", gdot: "ġ", Gcedil: "Ģ", gcedil: "ģ",
+    Hcirc: "Ĥ", hcirc: "ĥ", Hstrok: "Ħ", hstrok: "ħ",
+    Itilde: "Ĩ", itilde: "ĩ", Imacr: "Ī", imacr: "ī", Ibreve: "Ĭ", ibreve: "ĭ",
+    Iogon: "Į", iogon: "į", Idot: "İ", imath: "ı", IJlig: "IJ", ijlig: "ij",
+    Jcirc: "Ĵ", jcirc: "ĵ",
+    Kcedil: "Ķ", kcedil: "ķ", kgreen: "ĸ",
+    Lacute: "Ĺ", lacute: "ĺ", Lcedil: "Ļ", lcedil: "ļ", Lcaron: "Ľ", lcaron: "ľ",
+    Lmidot: "Ŀ", lmidot: "ŀ", Lstrok: "Ł", lstrok: "ł",
+    Nacute: "Ń", nacute: "ń", Ncedil: "Ņ", ncedil: "ņ", Ncaron: "Ň", ncaron: "ň",
+    napos: "ʼn", ENG: "Ŋ", eng: "ŋ",
+    Omacr: "Ō", omacr: "ō", Obreve: "Ŏ", obreve: "ŏ", Odblac: "Ő", odblac: "ő",
+    OElig: "Œ", oelig: "œ",
+    Racute: "Ŕ", racute: "ŕ", Rcedil: "Ŗ", rcedil: "ŗ", Rcaron: "Ř", rcaron: "ř",
+    Sacute: "Ś", sacute: "ś", Scirc: "Ŝ", scirc: "ŝ", Scedil: "Ş", scedil: "ş",
+    Scaron: "Š", scaron: "š",
+    Tcedil: "Ţ", tcedil: "ţ", Tcaron: "Ť", tcaron: "ť", Tstrok: "Ŧ", tstrok: "ŧ",
+    Utilde: "Ũ", utilde: "ũ", Umacr: "Ū", umacr: "ū", Ubreve: "Ŭ", ubreve: "ŭ",
+    Uring: "Ů", uring: "ů", Udblac: "Ű", udblac: "ű", Uogon: "Ų", uogon: "ų",
+    Wcirc: "Ŵ", wcirc: "ŵ", Ycirc: "Ŷ", ycirc: "ŷ", Yuml: "Ÿ",
+    Zacute: "Ź", zacute: "ź", Zdot: "Ż", zdot: "ż", Zcaron: "Ž", zcaron: "ž",
+    // Punctuation and symbols common in analyst prose
+    nbsp: "\u00A0", quot: '"', apos: "'", shy: "\u00AD",
+    ndash: "–", mdash: "—", lsquo: "‘", rsquo: "’", sbquo: "‚",
+    ldquo: "“", rdquo: "”", bdquo: "„", lsaquo: "‹", rsaquo: "›",
+    laquo: "«", raquo: "»", hellip: "…", bull: "•",
+    dagger: "†", Dagger: "‡", permil: "‰",
+    euro: "€", cent: "¢", pound: "£", yen: "¥", curren: "¤",
+    copy: "©", reg: "®", trade: "™", sect: "§", para: "¶", middot: "·",
+    deg: "°", plusmn: "±", times: "×", divide: "÷", micro: "µ", not: "¬",
+    iexcl: "¡", iquest: "¿", brvbar: "¦", uml: "¨", macr: "¯", acute: "´", cedil: "¸",
+    ordf: "ª", ordm: "º", sup1: "¹", sup2: "²", sup3: "³",
+    frac14: "¼", frac12: "½", frac34: "¾",
+};
+/**
+ * Decode HTML numeric and named character entities, preserving structural escapes.
+ * &#NNN; and &#xHH; → character. Named entities (e.g. á) → character.
+ * < > & are preserved — they are structural escapes, not encoded text.
+ */
+export function decodeEntities(html) {
+    if (html == null)
+        return null;
+    // Named entities may carry digits (frac12, sup2), so the name branch is alphanumeric.
+    return html.replace(/&(#[xX]?[0-9a-fA-F]+|[a-zA-Z][a-zA-Z0-9]*);/g, (match, entity) => {
+        // Preserve structural escapes
+        if (entity === "lt" || entity === "gt" || entity === "amp")
+            return match;
+        // Numeric: &#NNN; or &#xHH; (case-insensitive x)
+        if (entity.startsWith("#")) {
+            const isHex = entity[1] === "x" || entity[1] === "X";
+            const code = isHex
+                ? parseInt(entity.slice(2), 16)
+                : parseInt(entity.slice(1), 10);
+            if (isNaN(code) || code < 0 || code > 0x10FFFF)
+                return match;
+            return String.fromCodePoint(code);
+        }
+        // Named entity
+        return NAMED_ENTITIES[entity] ?? match;
+    });
+}
+/**
+ * Latin letters that carry no canonical decomposition, so NFD leaves them intact.
+ * The stroke, ligature and sharp-s forms are the ones a mark-stripping fold misses:
+ * "Łódź" folds to "lodz" only if `ł` is mapped explicitly.
+ */
+const NON_DECOMPOSING_FOLDS = {
+    "ß": "ss", "æ": "ae", "œ": "oe", "ij": "ij",
+    "ø": "o", "ł": "l", "ŀ": "l", "đ": "d", "ð": "d", "þ": "th",
+    "ħ": "h", "ŧ": "t", "ŋ": "n", "ı": "i", "ĸ": "k", "ʼn": "n",
+};
+const NON_DECOMPOSING_RE = new RegExp(`[${Object.keys(NON_DECOMPOSING_FOLDS).join("")}]`, "g");
+/**
+ * Fold text for case- and diacritic-insensitive matching.
+ * Lowercase → NFD decomposition → strip combining marks → map non-decomposing letters.
+ *
+ * Lowercasing first is what lets `İ` reduce to `i`: its lowercase form carries a
+ * combining dot that the mark strip then removes.
+ */
+export function foldText(s) {
+    return s
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(NON_DECOMPOSING_RE, (c) => NON_DECOMPOSING_FOLDS[c]);
+}
+/**
+ * Locale used to order names for display. `EA_LOCALE` overrides; otherwise the
+ * host default applies, since the model's language is not knowable from the export.
+ */
+export const orderingLocale = process.env.EA_LOCALE || undefined;
+const nameCollator = new Intl.Collator(orderingLocale);
+/** Order two model names, tolerating nulls. Accented initials sort in place, not after `Z`. */
+export function compareNames(a, b) {
+    return nameCollator.compare(a || "", b || "");
+}
+/** The content type declared for all EA model text fields. */
+export const EA_TEXT_CONTENT_TYPE = "text/html; ea-dialect";
+const MODEL_INTERNAL_SCHEMES = new Set(["$element", "$diagram", "$feature", "$package"]);
+/**
+ * Extract <a href="..."> targets from EA HTML text.
+ * Model-internal schemes ($element://, $diagram://, $feature://, $package://) are resolvable.
+ * Everything else is external.
+ */
+export function extractLinks(html) {
+    if (html == null)
+        return [];
+    const links = [];
+    const re = /href="([^"]+)"/g;
+    let m;
+    while ((m = re.exec(html)) !== null) {
+        const href = m[1];
+        const schemeMatch = href.match(/^(\$?[a-zA-Z][a-zA-Z0-9+.-]*):/);
+        const scheme = schemeMatch ? schemeMatch[1] : null;
+        links.push({
+            href,
+            scheme,
+            resolvable: scheme != null && MODEL_INTERNAL_SCHEMES.has(scheme),
+        });
+    }
+    return links;
+}

package/dist/tools/annotations.d.ts

@@ -0,0 +1,3 @@
+import type { ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
+/** The server only ever reads a local .qea export: no writes, no network, no side effects. */
+export declare const READ_ONLY: ToolAnnotations;

package/dist/tools/annotations.js

@@ -0,0 +1,5 @@
+/** The server only ever reads a local .qea export: no writes, no network, no side effects. */
+export const READ_ONLY = {
+    readOnlyHint: true,
+    openWorldHint: false,
+};

package/dist/tools/connectors.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ModelAccess } from "../model-session.js";
+export declare function configureConnectorTools(server: McpServer, model: ModelAccess): void;