enterprise-architect-mcp 2.1.0

package/LICENSE

@@ -0,0 +1,190 @@
+EUROPEAN UNION PUBLIC LICENCE v. 1.2
+EUPL © the European Union 2007, 2016
+
+This European Union Public Licence (the ‘EUPL’) applies to the Work (as defined below) which is provided under the
+terms of this Licence. Any use of the Work, other than as authorised under this Licence is prohibited (to the extent such
+use is covered by a right of the copyright holder of the Work).
+The Work is provided under the terms of this Licence when the Licensor (as defined below) has placed the following
+notice immediately following the copyright notice for the Work:
+                          Licensed under the EUPL
+or has expressed by any other means his willingness to license under the EUPL.
+
+1.Definitions
+In this Licence, the following terms have the following meaning:
+— ‘The Licence’:this Licence.
+— ‘The Original Work’:the work or software distributed or communicated by the Licensor under this Licence, available
+as Source Code and also as Executable Code as the case may be.
+— ‘Derivative Works’:the works or software that could be created by the Licensee, based upon the Original Work or
+modifications thereof. This Licence does not define the extent of modification or dependence on the Original Work
+required in order to classify a work as a Derivative Work; this extent is determined by copyright law applicable in
+the country mentioned in Article 15.
+— ‘The Work’:the Original Work or its Derivative Works.
+— ‘The Source Code’:the human-readable form of the Work which is the most convenient for people to study and
+modify.
+— ‘The Executable Code’:any code which has generally been compiled and which is meant to be interpreted by
+a computer as a program.
+— ‘The Licensor’:the natural or legal person that distributes or communicates the Work under the Licence.
+— ‘Contributor(s)’:any natural or legal person who modifies the Work under the Licence, or otherwise contributes to
+the creation of a Derivative Work.
+— ‘The Licensee’ or ‘You’:any natural or legal person who makes any usage of the Work under the terms of the
+Licence.
+— ‘Distribution’ or ‘Communication’:any act of selling, giving, lending, renting, distributing, communicating,
+transmitting, or otherwise making available, online or offline, copies of the Work or providing access to its essential
+functionalities at the disposal of any other natural or legal person.
+
+2.Scope of the rights granted by the Licence
+The Licensor hereby grants You a worldwide, royalty-free, non-exclusive, sublicensable licence to do the following, for
+the duration of copyright vested in the Original Work:
+— use the Work in any circumstance and for all usage,
+— reproduce the Work,
+— modify the Work, and make Derivative Works based upon the Work,
+— communicate to the public, including the right to make available or display the Work or copies thereof to the public
+and perform publicly, as the case may be, the Work,
+— distribute the Work or copies thereof,
+— lend and rent the Work or copies thereof,
+— sublicense rights in the Work or copies thereof.
+Those rights can be exercised on any media, supports and formats, whether now known or later invented, as far as the
+applicable law permits so.
+In the countries where moral rights apply, the Licensor waives his right to exercise his moral right to the extent allowed
+by law in order to make effective the licence of the economic rights here above listed.
+The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to any patents held by the Licensor, to the
+extent necessary to make use of the rights granted on the Work under this Licence.
+
+3.Communication of the Source Code
+The Licensor may provide the Work either in its Source Code form, or as Executable Code. If the Work is provided as
+Executable Code, the Licensor provides in addition a machine-readable copy of the Source Code of the Work along with
+each copy of the Work that the Licensor distributes or indicates, in a notice following the copyright notice attached to
+the Work, a repository where the Source Code is easily and freely accessible for as long as the Licensor continues to
+distribute or communicate the Work.
+
+4.Limitations on copyright
+Nothing in this Licence is intended to deprive the Licensee of the benefits from any exception or limitation to the
+exclusive rights of the rights owners in the Work, of the exhaustion of those rights or of other applicable limitations
+thereto.
+
+5.Obligations of the Licensee
+The grant of the rights mentioned above is subject to some restrictions and obligations imposed on the Licensee. Those
+obligations are the following:
+
+Attribution right: The Licensee shall keep intact all copyright, patent or trademarks notices and all notices that refer to
+the Licence and to the disclaimer of warranties. The Licensee must include a copy of such notices and a copy of the
+Licence with every copy of the Work he/she distributes or communicates. The Licensee must cause any Derivative Work
+to carry prominent notices stating that the Work has been modified and the date of modification.
+
+Copyleft clause: If the Licensee distributes or communicates copies of the Original Works or Derivative Works, this
+Distribution or Communication will be done under the terms of this Licence or of a later version of this Licence unless
+the Original Work is expressly distributed only under this version of the Licence — for example by communicating
+‘EUPL v. 1.2 only’. The Licensee (becoming Licensor) cannot offer or impose any additional terms or conditions on the
+Work or Derivative Work that alter or restrict the terms of the Licence.
+
+Compatibility clause: If the Licensee Distributes or Communicates Derivative Works or copies thereof based upon both
+the Work and another work licensed under a Compatible Licence, this Distribution or Communication can be done
+under the terms of this Compatible Licence. For the sake of this clause, ‘Compatible Licence’ refers to the licences listed
+in the appendix attached to this Licence. Should the Licensee's obligations under the Compatible Licence conflict with
+his/her obligations under this Licence, the obligations of the Compatible Licence shall prevail.
+
+Provision of Source Code: When distributing or communicating copies of the Work, the Licensee will provide
+a machine-readable copy of the Source Code or indicate a repository where this Source will be easily and freely available
+for as long as the Licensee continues to distribute or communicate the Work.
+Legal Protection: This Licence does not grant permission to use the trade names, trademarks, service marks, or names
+of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the copyright notice.
+
+6.Chain of Authorship
+The original Licensor warrants that the copyright in the Original Work granted hereunder is owned by him/her or
+licensed to him/her and that he/she has the power and authority to grant the Licence.
+Each Contributor warrants that the copyright in the modifications he/she brings to the Work are owned by him/her or
+licensed to him/her and that he/she has the power and authority to grant the Licence.
+Each time You accept the Licence, the original Licensor and subsequent Contributors grant You a licence to their contributions
+to the Work, under the terms of this Licence.
+
+7.Disclaimer of Warranty
+The Work is a work in progress, which is continuously improved by numerous Contributors. It is not a finished work
+and may therefore contain defects or ‘bugs’ inherent to this type of development.
+For the above reason, the Work is provided under the Licence on an ‘as is’ basis and without warranties of any kind
+concerning the Work, including without limitation merchantability, fitness for a particular purpose, absence of defects or
+errors, accuracy, non-infringement of intellectual property rights other than copyright as stated in Article 6 of this
+Licence.
+This disclaimer of warranty is an essential part of the Licence and a condition for the grant of any rights to the Work.
+
+8.Disclaimer of Liability
+Except in the cases of wilful misconduct or damages directly caused to natural persons, the Licensor will in no event be
+liable for any direct or indirect, material or moral, damages of any kind, arising out of the Licence or of the use of the
+Work, including without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss
+of data or any commercial damage, even if the Licensor has been advised of the possibility of such damage. However,
+the Licensor will be liable under statutory product liability laws as far such laws apply to the Work.
+
+9.Additional agreements
+While distributing the Work, You may choose to conclude an additional agreement, defining obligations or services
+consistent with this Licence. However, if accepting obligations, You may act only on your own behalf and on your sole
+responsibility, not on behalf of the original Licensor or any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against such Contributor by
+the fact You have accepted any warranty or additional liability.
+
+10.Acceptance of the Licence
+The provisions of this Licence can be accepted by clicking on an icon ‘I agree’ placed under the bottom of a window
+displaying the text of this Licence or by affirming consent in any other similar way, in accordance with the rules of
+applicable law. Clicking on that icon indicates your clear and irrevocable acceptance of this Licence and all of its terms
+and conditions.
+Similarly, you irrevocably accept this Licence and all of its terms and conditions by exercising any rights granted to You
+by Article 2 of this Licence, such as the use of the Work, the creation by You of a Derivative Work or the Distribution
+or Communication by You of the Work or copies thereof.
+
+11.Information to the public
+In case of any Distribution or Communication of the Work by means of electronic communication by You (for example,
+by offering to download the Work from a remote location) the distribution channel or media (for example, a website)
+must at least provide to the public the information requested by the applicable law regarding the Licensor, the Licence
+and the way it may be accessible, concluded, stored and reproduced by the Licensee.
+
+12.Termination of the Licence
+The Licence and the rights granted hereunder will terminate automatically upon any breach by the Licensee of the terms
+of the Licence.
+Such a termination will not terminate the licences of any person who has received the Work from the Licensee under
+the Licence, provided such persons remain in full compliance with the Licence.
+
+13.Miscellaneous
+Without prejudice of Article 9 above, the Licence represents the complete agreement between the Parties as to the
+Work.
+If any provision of the Licence is invalid or unenforceable under applicable law, this will not affect the validity or
+enforceability of the Licence as a whole. Such provision will be construed or reformed so as necessary to make it valid
+and enforceable.
+The European Commission may publish other linguistic versions or new versions of this Licence or updated versions of
+the Appendix, so far this is required and reasonable, without reducing the scope of the rights granted by the Licence.
+New versions of the Licence will be published with a unique version number.
+All linguistic versions of this Licence, approved by the European Commission, have identical value. Parties can take
+advantage of the linguistic version of their choice.
+
+14.Jurisdiction
+Without prejudice to specific agreement between parties,
+— any litigation resulting from the interpretation of this License, arising between the European Union institutions,
+bodies, offices or agencies, as a Licensor, and any Licensee, will be subject to the jurisdiction of the Court of Justice
+of the European Union, as laid down in article 272 of the Treaty on the Functioning of the European Union,
+— any litigation arising between other parties and resulting from the interpretation of this License, will be subject to
+the exclusive jurisdiction of the competent court where the Licensor resides or conducts its primary business.
+
+15.Applicable Law
+Without prejudice to specific agreement between parties,
+— this Licence shall be governed by the law of the European Union Member State where the Licensor has his seat,
+resides or has his registered office,
+— this licence shall be governed by Belgian law if the Licensor has no seat, residence or registered office inside
+a European Union Member State.
+
+
+                                                         Appendix
+
+‘Compatible Licences’ according to Article 5 EUPL are:
+— GNU General Public License (GPL) v. 2, v. 3
+— GNU Affero General Public License (AGPL) v. 3
+— Open Software License (OSL) v. 2.1, v. 3.0
+— Eclipse Public License (EPL) v. 1.0
+— CeCILL v. 2.0, v. 2.1
+— Mozilla Public Licence (MPL) v. 2
+— GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3
+— Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for works other than software
+— European Union Public Licence (EUPL) v. 1.1, v. 1.2
+— Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong Reciprocity (LiLiQ-R+).
+
+The European Commission may update this Appendix to later versions of the above licences without producing
+a new version of the EUPL, as long as they provide the rights granted in Article 2 of this Licence and protect the
+covered Source Code from exclusive appropriation.
+All other changes or additions to this Appendix require the production of a new EUPL version.

package/README.md

@@ -0,0 +1,226 @@
+# Enterprise Architect MCP Server
+
+[![npm version](https://img.shields.io/npm/v/enterprise-architect-mcp.svg)](https://www.npmjs.com/package/enterprise-architect-mcp)
+[![Node.js](https://img.shields.io/node/v/enterprise-architect-mcp.svg)](https://nodejs.org)
+[![License: EUPL-1.2](https://img.shields.io/badge/license-EUPL--1.2-blue.svg)](LICENSE)
+[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_server-0098FF?logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect?url=vscode%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522enterprise-architect%2522%252C%2522command%2522%253A%2522npx%2522%252C%2522args%2522%253A%255B%2522-y%2522%252C%2522enterprise-architect-mcp%2522%255D%257D)
+[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install_server-24bfa5?logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522enterprise-architect%2522%252C%2522command%2522%253A%2522npx%2522%252C%2522args%2522%253A%255B%2522-y%2522%252C%2522enterprise-architect-mcp%2522%255D%257D)
+
+A read-only [Model Context Protocol](https://modelcontextprotocol.io) (MCP) server for Sparx Enterprise Architect `.qea` exports. Gives AI agents access to EA analysis models — search elements, navigate packages, read use case scenarios, and traverse connectors — without a running EA instance.
+
+Works with any MCP client (VS Code / GitHub Copilot, Claude Desktop, Cursor, Windsurf). Reads the `.qea` SQLite export directly, never writes to it, and every response carries completeness metadata so an agent can tell a truncated answer from a complete one.
+
+**Keywords:** MCP server · Sparx Enterprise Architect · `.qea` · UML · use case scenarios · package tree · connectors · diagrams · model search · AI agent tooling
+
+## Prerequisites
+
+- **Node.js 22+** (uses the built-in `node:sqlite` module)
+- A `.qea` file exported from Sparx Enterprise Architect
+
+## Installation
+
+### VS Code / GitHub Copilot
+
+The quickest route is the **Install in VS Code** badge at the top of this page. There is nothing to
+fill in: the server asks for your `.qea` path the first time an agent queries the model, and
+remembers the answer for next time.
+
+To register it from a terminal instead, which is handier for scripting or a shared setup, use one
+CLI call:
+
+```powershell
+code --add-mcp '{\"name\":\"enterprise-architect\",\"command\":\"npx\",\"args\":[\"-y\",\"enterprise-architect-mcp\"]}'
+```
+
+The `\"` sequences are for the `code` shim, which re-parses the argument after PowerShell has
+already handed it over — escaping with PowerShell's own backtick, or using `--%`, still arrives with
+the quotes stripped. The single quotes stop PowerShell from touching the string. On bash or zsh the
+plain form works instead:
+
+```bash
+code --add-mcp '{"name":"enterprise-architect","command":"npx","args":["-y","enterprise-architect-mcp"]}'
+```
+
+To configure it by hand instead, add to your project's `.vscode/mcp.json`:
+
+```json
+{
+  "servers": {
+    "enterprise-architect": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "enterprise-architect-mcp"]
+    }
+  }
+}
+```
+
+Nothing personal is in that file, so it can be committed as-is and each developer answers the prompt
+once on their own machine. If you would rather not be asked at all, name the path up front — as a
+trailing argument, in an `env` block, or in a gitignored `.env` in your workspace root:
+
+```ini
+EA_QEA_PATH=C:\EA\exports\model.qea
+```
+
+### Claude Desktop
+
+The same path-less configuration goes in `claude_desktop_config.json` (`%APPDATA%\Claude\` on
+Windows, `~/Library/Application Support/Claude/` on macOS):
+
+```json
+{
+  "mcpServers": {
+    "enterprise-architect": {
+      "command": "npx",
+      "args": ["-y", "enterprise-architect-mcp"]
+    }
+  }
+}
+```
+
+Claude Desktop does not run the server from a workspace folder, so a `.env` there is not reliable.
+If the client cannot show the path prompt at all, the server says so instead of failing silently, and
+you can name the path in an `env` block:
+
+```json
+"env": { "EA_QEA_PATH": "C:\\EA\\exports\\model.qea" }
+```
+
+To run straight from source instead of npm, use `"args": ["-y", "github:mm6502/enterprise-architect-mcp"]`.
+
+## Configuration
+
+The server does not need a path to start. It looks for one when an agent first queries the model, and
+takes the first source that actually opens:
+
+1. **CLI argument** — `mcp-server-ea C:\path\to\model.qea`
+2. **Environment variable** — `EA_QEA_PATH` (set in an `env` block or system env)
+3. **`.env` file** — `EA_QEA_PATH=...` in a `.env` file in the working directory
+4. **A remembered answer** — whatever you last told the prompt
+5. **The prompt** — the client asks, and a working answer is remembered for next time
+
+A source naming a path that cannot be opened is **skipped** rather than fatal, so the next source gets
+its turn. The reason goes to the server log, and once some later source opens, `ea_get_model_info`
+lists it under `ignored`. That is deliberate — a sample value left in an `env` block would otherwise
+outrank every answer you could give, and answering the prompt would never help. The cost is that a
+genuine typo is demoted quietly, so check `ea_get_model_info` if the server opens a different model
+than you expected.
+
+Skipping is only worth it when an answer can take the skipped source's place, so two cases stay
+fatal: a path you passed **on the command line** (that is this run's explicit instruction, not a
+stale default), and any broken source in a client that **cannot show a prompt** — falling through
+there would quietly open some other model instead of telling you.
+
+Answers are remembered per machine, in `%APPDATA%\enterprise-architect-mcp\` on Windows,
+`~/Library/Application Support/enterprise-architect-mcp/` on macOS, and `$XDG_CONFIG_HOME` (or
+`~/.config`) elsewhere; set `EA_MCP_CONFIG_DIR` to keep that file somewhere else. A path that does
+not open is never remembered, so asking again is enough to correct a mistyped answer.
+
+If the path points to a **directory**, the server automatically picks the newest `.qea` file by
+modification time. Pointing at your export folder means new exports are picked up without
+reconfiguring anything.
+
+### Name ordering
+
+Matching is locale-independent — search folds case and diacritics across European Latin alphabets,
+so `Straße`, `Łódź` and `Győr` are found however they are typed or entity-encoded.
+
+The enumeration tools — `ea_search`, `ea_list_elements`, `ea_list_diagrams` — do not order by name
+at all. They order by the model's internal identity: stable and repeatable, but artificial, so
+nothing should be read into which row follows which. That is a deliberate trade. Alphabetical
+ordering under SQLite's binary collation sorts every accented initial after `Z`, and since these
+tools return a window rather than the whole set, it does not merely reorder the list — it pushes
+accented names out of the window entirely. Measured on a real export, names with an accented
+initial filled 1.3% of visible slots under binary ordering against 3.0% under identity order, in a
+model where they make up 3.9% of all names.
+
+Only `ea_get_scenarios` still orders names by locale, where the whole set is always returned and no
+name can be cut off. `EA_LOCALE` pins that ordering to a BCP 47 tag (`sk`, `pl`, `hu`, `de`, …) in
+an `env` block or system env; unset, the host default applies. It does not affect matching.
+
+### Paging and narrowing
+
+The enumeration tools return a window, not a sample. Each response carries `totalMatched`,
+`returned`, `offset` and `truncated`, and when rows remain, a `continuation` naming the next call —
+following it repeatedly visits every match once and terminates. Raising `limit` is not the way to
+read a large set; advancing `offset` is.
+
+When far more rows match than one window could hold, the response also carries a `breakdown` of how
+they distribute. Its keys are parameter names and its values are argument values, so a breakdown is
+a prompt to narrow — by `objectType`, `stereotype`, or `diagramType` — rather than to page through
+thousands of rows.
+
+### Naming the path up front
+
+If you would rather never see the prompt — a CI job, a shared image, or simply a preference — put
+the path in a gitignored `.env` in the working directory. Copy the template:
+
+```powershell
+Copy-Item .env.example .env
+```
+
+Then set your local path in `.env`:
+
+```ini
+EA_QEA_PATH=C:\EA\exports\model.qea
+```
+
+A directory works too — the newest `.qea` file in it is used:
+
+```ini
+EA_QEA_PATH=C:\EA\exports\
+```
+
+The `.env` file is gitignored — each developer sets their own path without affecting the shared
+config. It is also never committed, which is why it is the one route every new user has to set up by
+hand; answering the prompt once is what makes that unnecessary.
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `ea_search` | Full-text search across elements, attributes, operations, and constraints. Case- and diacritic-insensitive across European Latin alphabets, decodes entity-encoded text. |
+| `ea_get_element` | Full element detail — attributes, operations, diagrams it appears on, constraints (pre/post/invariant/process). Flags whether attribute multiplicity is contrastive. |
+| `ea_list_elements` | List elements in a package, optionally filtered by type. Windowed: reports the total and pages with `offset`. |
+| `ea_get_connectors` | Relationships for an element — includes feature-link resolution (which attribute/operation each end attaches to). |
+| `ea_get_diagram_elements` | Elements and connectors on a diagram, including implied connectors and feature links. |
+| `ea_get_scenarios` | Use case scenario steps with all attributes (trigger, uses, result, link, state) and scenario notes. |
+| `ea_get_package_tree` | Navigate the package hierarchy with recursive depth. |
+| `ea_list_diagrams` | Search diagrams by name, type and package. Windowed like the tools above. |
+| `ea_resolve` | Resolve analyst references (braced GUID or plain name) to model candidates with full package path. Falls back to name-prefix matching for analyst codes; every candidate carries a `match` of `guid`, `exact`, or `prefix`. |
+| `ea_get_schema` | Introspect the model's database schema — tables, columns, indexes, rowid alias. |
+| `ea_get_model_info` | Identity of the open export — file name, size, modification date, server version, and which configuration source the path came from. |
+
+### Response contract
+
+Every tool returns structured JSON with:
+
+- `_meta.sourceTables` — which database tables were consulted
+- `totalMatched` / `returned` / `truncated` — completeness metadata on every collection
+- `continuation` — exact call to retrieve the full set when truncated
+- `isError: true` + `{ error: "not_found" }` for non-existent subjects (distinct from empty results)
+
+Two fields exist to stop an inexact answer from being read as a confirmed one:
+
+- `ea_resolve` — `match` is always present; only `prefix` is an inexact match
+- `ea_get_element` — `_meta.attributes.multiplicityIsUniform: true` means the element's attributes show no multiplicity contrast, so `1..1` is not evidence of requiredness
+
+## Example Prompts
+
+Once connected, try prompts like:
+
+- "Search for elements related to 'legal entity'"
+- "Show me the package structure under the root"
+- "What are the use case scenarios for UC_SUBMIT_APPLICATION?"
+- "What elements and connectors are on diagram 0103 Application Processing?"
+- "Resolve the reference {3F2A7C10-5B4D-4e8a-9C1F-27D6E8B0A4F3}"
+- "What columns does t_connector have?"
+- "Which diagrams does element a7680 appear on?"
+
+## License
+
+Copyright (c) 2026 Michal Mracka
+
+Licensed under the EUPL — see [LICENSE](LICENSE) for the full text.
+

package/dist/database.d.ts

@@ -0,0 +1,3 @@
+import { DatabaseSync } from "node:sqlite";
+export type Database = DatabaseSync;
+export declare function openDatabase(path: string): Database;

package/dist/database.js

@@ -0,0 +1,25 @@
+import { DatabaseSync } from "node:sqlite";
+import { existsSync } from "node:fs";
+export function openDatabase(path) {
+    if (!existsSync(path)) {
+        throw new Error(`QEA file not found: "${path}"`);
+    }
+    let db;
+    try {
+        db = new DatabaseSync(path, { readOnly: true });
+    }
+    catch (err) {
+        throw new Error(`Failed to open database: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Sanity check: verify it's an EA export
+    try {
+        db.prepare("SELECT COUNT(*) FROM t_object").get();
+    }
+    catch {
+        db.close();
+        throw new Error(`File is not a valid Enterprise Architect export (missing t_object table): "${path}"`);
+    }
+    // Performance: increase cache
+    db.exec("PRAGMA cache_size = -64000"); // 64MB cache
+    return db;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { ModelSession } from "./model-session.js";
+import { configureAllTools } from "./tools.js";
+import { packageVersion } from "./version.js";
+const argv = yargs(hideBin(process.argv))
+    .scriptName("mcp-server-ea")
+    .usage("Usage: $0 [qea-path]")
+    .version(packageVersion)
+    .command("$0 [qea-path]", "Enterprise Architect MCP Server", (yargs) => {
+    yargs.positional("qea-path", {
+        describe: "Path to .qea file or directory containing .qea files. " +
+            "Falls back to EA_QEA_PATH env var, .env in CWD, a remembered answer, " +
+            "then asking the client. If a directory is given, the newest .qea file is used.",
+        type: "string",
+    });
+})
+    .help()
+    .parseSync();
+const server = new McpServer({
+    name: "Enterprise Architect MCP Server",
+    version: packageVersion,
+}, {
+    instructions: `This server provides read-only access to a Sparx Enterprise Architect analysis model (.qea export).
+
+Response shape contract:
+- Every response is structured JSON — no tool returns unstructured text, even for empty results.
+- Every collection carries totalMatched, returned, truncated (always present, even when truncated: false).
+- _meta.sourceTables lists which database tables the response draws from.
+- ea_get_diagram_elements returns per-collection metadata in _meta.elements and _meta.connectors (not top-level) because it returns two independent collections.
+- The enumeration tools (ea_search, ea_list_elements, ea_list_diagrams) return a window: they accept offset, echo it back, and order results deterministically. That order is stable but artificial — not alphabetical and not the analyst's tree order — so never infer meaning from adjacency.
+- When truncated: true, a continuation object provides the exact call that returns the next window. Following it repeatedly visits every matching row once and terminates; do not raise limit to fetch a large set in one call.
+- When far more rows match than one window holds, a breakdown object reports how they distribute. Every key in it is a parameter name and every value is an argument value, so a breakdown is an invitation to narrow the next call rather than page through the set. Each axis reports totalMatched/returned/truncated for its own list of distinct values, not for rows, and rows carrying no value on that axis are not counted — so the counts need not sum to the response's totalMatched.
+- Not-found errors (non-existent element/package/diagram ID) return isError: true with structured JSON — distinct from a valid empty result.
+- When reporting that something is absent from the model, cite totalMatched, truncated and _meta.sourceTables from the response that supports the claim. An empty result is not evidence of absence unless the subject is confirmed to exist.
+
+Text fields (Note, Notes, notes) use EA's HTML dialect: lists (<ol>, <ul>, <li>), bold (<b>), anchors (<a href>). No div/span/script. Structural escapes (&lt; &gt; &amp;) are preserved. Embedded model links ($element://, $diagram://) appear as <a href> targets. Character entities (&#225; etc.) are decoded to characters.
+
+Use ea_* tools when the user asks about:
+- Business analysis, use cases, requirements, screens, classes, or domain model elements
+- Application architecture, components, interfaces, or their relationships
+- Use case scenarios / flows — all step attributes (trigger, uses, result, link) and scenario notes are returned
+- How elements relate to each other — connectors include feature-link resolution showing which attribute or operation each end attaches to
+- Package/module structure of the analysis model
+- Diagram contents — elements AND connectors (including implied connectors with both ends on the diagram)
+- Which diagrams an element appears on (returned by ea_get_element)
+- Constraints and business rules on elements (pre-conditions, post-conditions, invariants, process rules)
+- Resolving analyst references (GUIDs, names) to model nodes
+- What database tables and columns the model export contains
+- Which export file the server has open
+
+Do NOT use ea_* tools for:
+- Azure DevOps work items, bugs, tasks, PRs, or repositories (use ado server instead)
+- Source code, builds, or deployments
+
+Typical workflow: ea_search → ea_get_element → ea_get_connectors / ea_get_scenarios
+Reference resolution: ea_resolve (GUID or name) → ea_get_element or ea_get_diagram_elements
+Discovery: ea_list_diagrams to find diagrams, ea_get_schema to explore the model's tables
+Provenance: ea_get_model_info to identify the export file`,
+});
+const session = new ModelSession(server, argv["qea-path"]);
+configureAllTools(server, session);
+const transport = new StdioServerTransport();
+await server.connect(transport);
+session.reportConfiguration();

package/dist/model-session.d.ts

@@ -0,0 +1,29 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type Database } from "./database.js";
+import { type QeaPathOrigin, type QeaPathSource } from "./resolve-qea-path.js";
+/** What the tools need from the session: a database, and where it came from. */
+export interface ModelAccess {
+    database(): Promise<Database>;
+    origin(): QeaPathOrigin | undefined;
+}
+export declare function describeSource(source: QeaPathSource): string;
+export declare class ModelSession implements ModelAccess {
+    private readonly server;
+    private readonly cliArg?;
+    private db?;
+    private opened?;
+    private opening?;
+    /** A rejected answer is not remembered, so the next prompt has to carry the reason itself. */
+    private lastPromptFailure?;
+    constructor(server: McpServer, cliArg?: string | undefined);
+    origin(): QeaPathOrigin | undefined;
+    /** Startup diagnostics only: reports what is configured without opening anything. */
+    reportConfiguration(): void;
+    database(): Promise<Database>;
+    private candidates;
+    private open;
+    /** Opens a candidate and, on success, makes it this session's model. */
+    private adopt;
+    private promptReason;
+    private ask;
+}