@miadi/stateloom-mcp 0.2.1 → 0.2.3

package/dist/projectSwitch.d.ts

@@ -8,4 +8,17 @@ export interface SwitchResult {
     /** True when the new path equals the previous one. */
     unchanged: boolean;
 }
+export declare function chronicleRoot(env?: Record<string, string | undefined>): string;
+/**
+ * Resolve `miadi-chronicle://<episode>/[diagrams/]<name>[.smdf.json]` to the
+ * absolute path `<root>/<episode-dir>/diagrams/<name>.smdf.json`.
+ *
+ * Episode matching: exact folder name first; else a bare number matches
+ * `-episode-NNN-` folders. Episode numbers are NOT unique in the chronicle
+ * (011, 016, 043, 078, 083, 098, 120 are doubled) — ambiguity is a HARD
+ * ERROR naming every candidate, never a silent first match: a resolver that
+ * guesses writes the wrong episode into the record. A missing diagram file
+ * stays legitimate — naming it is how an episode's FIRST diagram is created.
+ */
+export declare function resolveChronicleUri(uri: string, env?: Record<string, string | undefined>): string;
 export declare function resolveProjectSwitch(next: string, previous: string): SwitchResult;

package/dist/projectSwitch.js

@@ -1,11 +1,74 @@
 /**
  * Pure logic behind the `set_project_file` MCP tool (path power — the agent
  * chooses which `.smdf.json` document the loom weaves).
+ *
+ * Two modalities, by William's orientation (2026-08-07): STANDALONE — a plain
+ * path, no episode, just designing — and RELATIONAL — the document lives
+ * inside a chronicle episode and is addressed as
+ * `miadi-chronicle://<episode>/<diagram>`, resolving over
+ * $MIADI_CHRONICLE_ROOT to `<episode-dir>/diagrams/<diagram>.smdf.json`.
+ * The relationship is carried by WHERE the file lives (the scalar truth of
+ * jgwill/Miadi#593); wheel edges stay derived/ceremonial, never minted here.
  */
-import { existsSync } from "fs";
-import { resolve } from "path";
+import { existsSync, readdirSync, statSync } from "fs";
+import { join, resolve } from "path";
+const CHRONICLE_SCHEME = /^miadi-chronicle:\/\//i;
+export function chronicleRoot(env = process.env) {
+    return env.MIADI_CHRONICLE_ROOT ?? "/srv/miadi/episodes/miadi-chronicle";
+}
+/**
+ * Resolve `miadi-chronicle://<episode>/[diagrams/]<name>[.smdf.json]` to the
+ * absolute path `<root>/<episode-dir>/diagrams/<name>.smdf.json`.
+ *
+ * Episode matching: exact folder name first; else a bare number matches
+ * `-episode-NNN-` folders. Episode numbers are NOT unique in the chronicle
+ * (011, 016, 043, 078, 083, 098, 120 are doubled) — ambiguity is a HARD
+ * ERROR naming every candidate, never a silent first match: a resolver that
+ * guesses writes the wrong episode into the record. A missing diagram file
+ * stays legitimate — naming it is how an episode's FIRST diagram is created.
+ */
+export function resolveChronicleUri(uri, env = process.env) {
+    const rest = uri.replace(CHRONICLE_SCHEME, "").replace(/[?#].*$/, "");
+    const segments = rest.split("/").filter(Boolean);
+    if (segments.length < 2) {
+        throw new Error(`chronicle address needs <episode>/<diagram> (got '${uri}') — e.g. miadi-chronicle://103/film-preprod`);
+    }
+    const episodeRef = segments[0];
+    const name = segments[segments.length - 1];
+    const root = chronicleRoot(env);
+    let dirs;
+    try {
+        dirs = readdirSync(root).filter((d) => {
+            try {
+                return statSync(join(root, d)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        throw new Error(`chronicle root not readable: ${root} (MIADI_CHRONICLE_ROOT)`);
+    }
+    let matches = dirs.filter((d) => d === episodeRef);
+    if (matches.length === 0 && /^\d+$/.test(episodeRef)) {
+        const num = String(parseInt(episodeRef, 10));
+        matches = dirs.filter((d) => {
+            const m = d.match(/-episode-0*(\d+)-/);
+            return m !== null && m[1] === num;
+        });
+    }
+    if (matches.length === 0) {
+        throw new Error(`no episode matches '${episodeRef}' under ${root}`);
+    }
+    if (matches.length > 1) {
+        throw new Error(`episode '${episodeRef}' is ambiguous — candidates:\n  ${matches.sort().join("\n  ")}\nName the full folder.`);
+    }
+    const file = name.endsWith(".json") ? name : `${name}.smdf.json`;
+    return join(root, matches[0], "diagrams", file);
+}
 export function resolveProjectSwitch(next, previous) {
-    const path = resolve(next);
+    const path = CHRONICLE_SCHEME.test(next) ? resolveChronicleUri(next) : resolve(next);
     if (!path.endsWith(".json")) {
         throw new Error(`project file must be a .json document (got '${path}') — the loom weaves .smdf.json files`);
     }

package/dist/server.js

@@ -36,6 +36,7 @@ import { z } from "zod";
 import { execFileSync, spawn } from "child_process";
 import { writeFileSync, readFileSync, mkdtempSync, rmSync, existsSync, statSync, realpathSync, } from "fs";
 import { basename, dirname, join, resolve } from "path";
+import { fileURLToPath } from "node:url";
 import { tmpdir } from "os";
 import { createBridgeClient } from "@miadi/stateloom-client";
 import { envAlias } from "@miadi/stateloom-protocol";
@@ -598,10 +599,27 @@ function glyph(direction) {
  * Every tool closes over module-level state (PROJECT_FILE, the bridge client),
  * so instances are interchangeable — building one is registration, not state.
  */
+/**
+ * The version a client sees in `serverInfo`, read from the manifest that npm
+ * actually shipped rather than typed in beside it. The literal here said 0.2.0
+ * while the package on the registry was 0.2.2 — two releases during which every
+ * agent that asked this server who it was got a confident wrong answer, and no
+ * test could catch it because the two numbers had no relationship to compare.
+ * Reading the manifest gives them one.
+ */
+const PACKAGE_VERSION = (() => {
+    try {
+        const manifest = resolve(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        return String(JSON.parse(readFileSync(manifest, "utf8")).version);
+    }
+    catch {
+        return "0.0.0-unknown";
+    }
+})();
 function buildServer() {
     const server = new McpServer({
         name: "stateloom-mcp",
-        version: "0.2.0",
+        version: PACKAGE_VERSION,
     });
     // Tools
     server.tool("create_state_machine", "Create a new state machine definition with namespace and name", { namespace: z.string(), name: z.string(), asynchronous: z.boolean().optional() }, async ({ namespace, name, asynchronous }) => {
@@ -787,7 +805,7 @@ function buildServer() {
             return { content: [{ type: "text", text: "No events defined yet." }] };
         return { content: [{ type: "text", text: events.join("\n") }] };
     });
-    server.tool("set_project_file", "Choose which .smdf.json path is the active document the loom weaves. Disk persistence AND the live bridge room (the hub keys rooms by this path) both re-point to it. A missing file is legitimate — create_state_machine or load_definition writes it next. Path must end in .json; convention is *.smdf.json.", { path: z.string() }, async ({ path }) => {
+    server.tool("set_project_file", "Choose the active document the loom weaves — two modalities. STANDALONE: any .smdf.json path. RELATIONAL: a chronicle address `miadi-chronicle://<episode>/<diagram>` resolving over $MIADI_CHRONICLE_ROOT to <episode-dir>/diagrams/<diagram>.smdf.json — an ambiguous episode number is a hard error naming the candidates. Disk persistence AND the live bridge room both re-point. A missing file is legitimate — naming it is how an episode's first diagram is created.", { path: z.string() }, async ({ path }) => {
         try {
             const r = resolveProjectSwitch(path, PROJECT_FILE);
             const denial = denyProjectSwitch(r.path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miadi/stateloom-mcp",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "MCP server for miadi-stateloom (formerly smcraft-mcp) — lets LLM agents design state machines through conversation",
   "repository": {
     "type": "git",
@@ -38,9 +38,9 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@miadi/stateloom-cli": "^0.1.2",
-    "@miadi/stateloom-client": "^0.1.1",
-    "@miadi/stateloom-protocol": "^0.1.3",
+    "@miadi/stateloom-cli": "^0.1.3",
+    "@miadi/stateloom-client": "^0.1.2",
+    "@miadi/stateloom-protocol": "^0.1.5",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "zod": "^4.3.6"
   },