@geml/geml 1.4.2 → 1.4.4

package/dist/history.d.ts

@@ -70,6 +70,16 @@ export declare function listRevisions(historyPath: string): RevisionInfo[];
 /** Resolve a revision selector to its id + reconstructed full text. Selectors:
  *  `-N` (N revisions back from current; `-0` is the tip), `latest`/`current`, or
  *  an unambiguous id prefix/suffix (the same forms `restore` accepts). */
+/** Resolve a revision selector to its id, for EVERY command that takes one.
+ *
+ *  There is exactly one selector grammar — `0` (the tip), `-N` (N revisions
+ *  back), or an unambiguous revision id (prefix, suffix, or exact) — and it is
+ *  the grammar `history log` prints in its first column, so its output is
+ *  copy-pasteable into `revert --rev`, `history show`, and `history restore`
+ *  alike. Keeping this in one function is what makes that true: it used to be
+ *  written twice, and the copy in `restore` never grew the `0`/`-N` arm, so the
+ *  selectors `history log` advertised were rejected by `history show`. */
+export declare function resolveRevision(h: History, selector: string): string;
 export declare function resolveContent(historyPath: string, selector: string): {
     id: string;
     text: string;

package/dist/history.js

@@ -591,12 +591,7 @@ export function verify(historyPath, gemlPath) {
 }
 export function restore(o) {
     const h = parseHistory(o.historyPath);
-    // accept an unambiguous id prefix
-    const ids = [...h.revisions.keys()];
-    const matches = ids.filter((x) => x === o.revision || x.startsWith(o.revision) || x.endsWith(o.revision));
-    if (matches.length !== 1)
-        throw new Error(`history: revision selector "${o.revision}" matched ${matches.length} revisions`);
-    const target = matches[0];
+    const target = resolveRevision(h, o.revision); // `0` | `-N` | id — see resolveRevision
     const content = reconstruct(h, target);
     if (o.write) {
         if (existsSync(o.gemlPath)) {
@@ -648,27 +643,33 @@ export function listRevisions(historyPath) {
 /** Resolve a revision selector to its id + reconstructed full text. Selectors:
  *  `-N` (N revisions back from current; `-0` is the tip), `latest`/`current`, or
  *  an unambiguous id prefix/suffix (the same forms `restore` accepts). */
-export function resolveContent(historyPath, selector) {
-    const h = parseHistory(historyPath);
-    const chain = chainFrom(h); // chain[0] = current tip
-    let id;
-    const off = /^-(\d+)$/.exec(selector);
+/** Resolve a revision selector to its id, for EVERY command that takes one.
+ *
+ *  There is exactly one selector grammar — `0` (the tip), `-N` (N revisions
+ *  back), or an unambiguous revision id (prefix, suffix, or exact) — and it is
+ *  the grammar `history log` prints in its first column, so its output is
+ *  copy-pasteable into `revert --rev`, `history show`, and `history restore`
+ *  alike. Keeping this in one function is what makes that true: it used to be
+ *  written twice, and the copy in `restore` never grew the `0`/`-N` arm, so the
+ *  selectors `history log` advertised were rejected by `history show`. */
+export function resolveRevision(h, selector) {
+    const off = /^(0|-\d+)$/.exec(selector);
     if (off) {
-        const n = Number(off[1]);
+        const chain = chainFrom(h); // chain[0] = current tip
+        const n = Math.abs(Number(selector)); // "0" -> 0 (tip), "-1" -> 1 back, …
         if (n >= chain.length)
-            throw new Error(`history: offset -${n} is out of range (only ${chain.length} revision(s))`);
-        id = chain[n].id;
-    }
-    else if (selector === "latest" || selector === "current") {
-        id = chain[0].id;
-    }
-    else {
-        const ids = [...h.revisions.keys()];
-        const matches = ids.filter((x) => x === selector || x.startsWith(selector) || x.endsWith(selector));
-        if (matches.length !== 1)
-            throw new Error(`history: revision selector "${selector}" matched ${matches.length} revisions`);
-        id = matches[0];
+            throw new Error(`history: offset ${selector} is out of range (only ${chain.length} revision(s))`);
+        return chain[n].id;
     }
+    const ids = [...h.revisions.keys()];
+    const matches = ids.filter((x) => x === selector || x.startsWith(selector) || x.endsWith(selector));
+    if (matches.length !== 1)
+        throw new Error(`history: revision selector "${selector}" matched ${matches.length} revisions`);
+    return matches[0];
+}
+export function resolveContent(historyPath, selector) {
+    const h = parseHistory(historyPath);
+    const id = resolveRevision(h, selector);
     return { id, text: reconstruct(h, id) };
 }
 /** Walk the chain newest→oldest; return the first revision whose block (as

package/dist/inline.js

@@ -1,10 +1,10 @@
 // GEML reference parser — Milestone 2: inline content (§5).
 //
-// Parses the inline grammar of flow blocks (paragraphs, headings, list items):
-// escapes, code spans, inline math, images, links, auto-references, footnote
-// references, then emphasis/strong/strike — in the §5.3 priority order. Every
-// internal/cross-document reference is reported to a `RefSink` so the document
-// layer can resolve and validate it at build time (§8).
+// Parses the inline grammar of unfenced blocks (paragraphs, headings, list
+// items): escapes, code spans, inline math, images, links, auto-references,
+// footnote references, then emphasis/strong/strike — in the §5.3 priority order.
+// Every internal/cross-document reference is reported to a `RefSink` so the
+// document layer can resolve and validate it at build time (§8).
 import { parseAttrs } from "./attrs.js";
 const MAX_INLINE_NESTING = 100; // cap parseInline<->scanAtoms recursion (R2-7 DoS)
 // §4: the source pattern of a `{{key}}` metadata reference. Owned here as the
@@ -455,8 +455,8 @@ export function parseInline(s, line, sink, depth = 0) {
         // call stack (R2-7). Degrade the over-deep content to text — emphasis only,
         // no further link recursion — and flag it; never throw RangeError.
         const diags = sink.diags;
-        if (Array.isArray(diags) && !diags.some((d) => d.message.startsWith("inline nesting too deep")))
-            diags.push({ severity: "error", message: `inline nesting too deep (max ${MAX_INLINE_NESTING})`, line });
+        if (Array.isArray(diags) && !diags.some((d) => d.code === "inline-nesting-too-deep"))
+            diags.push({ severity: "error", code: "inline-nesting-too-deep", message: `inline nesting too deep (max ${MAX_INLINE_NESTING})`, line });
         return mergeText(emphasize(s));
     }
     const atoms = scanAtoms(s, line, sink, depth);

package/dist/mcp.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+export interface McpOptions {
+    root: string;
+    history: boolean;
+}
+/** Configure the server. Exported so the suite can point it at a temp dir. */
+export declare function configure(o: Partial<McpOptions>): McpOptions;
+export declare function resolveInRoot(file: string): string;
+export interface Tool {
+    name: string;
+    description: string;
+    inputSchema: unknown;
+    run: (args: Record<string, any>) => unknown;
+}
+export declare const TOOLS: Tool[];
+export declare function handleLine(line: string, write?: (s: string) => void): void;
+export declare const MCP_USAGE = "usage: geml mcp --root <dir> [--no-history]\n\n  Serve GEML document CRUD over the MCP stdio transport (JSON-RPC 2.0).\n\n  --root <dir>        REQUIRED. Root directory holding the .geml documents.\n                      Relative paths resolve against the server process's CWD,\n                      which the CLIENT chooses \u2014 pass an absolute path.\n                      Every path a client names is confined to this directory;\n                      a client cannot widen or override it.\n  --no-history        Do not auto-commit a .gemlhistory revision before each\n                      write. Default is to commit, so geml_revert_block always\n                      has a revision to undo to.\n\n  Register with a client:\n    claude mcp add geml -- geml mcp --root /abs/path/to/docs";
+export declare function parseArgs(args: string[]): McpOptions;