oh-memos-mcp 2.0.1 → 3.0.0

package/dist/canvas-format.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Symbolic task canvas — parse and render.
+ *
+ * A canvas is one Mermaid file. It is the whole truth: there is no parallel
+ * JSON sidecar, because two files describing one task drift apart the first
+ * time a write fails halfway. The cost of that choice is that the format has to
+ * survive a round trip exactly, which is what the tests pin down.
+ *
+ * The shape borrows the `NNN-Nn` node id from TencentDB Agent Memory, for the
+ * reason that made it work there: it is greppable. An id in a canvas, a commit
+ * message or a memory body all lead back to the same node.
+ *
+ * What is ours is the `ref`: an anchor with a scheme, so a node can point at a
+ * memory in the graph (`mem:`), a file the harness already offloaded (`file:`),
+ * or an inline remark (`note:`). Their design only ever pointed at local files.
+ */
+export declare const NODE_STATUSES: readonly ["todo", "doing", "done", "blocked"];
+export type NodeStatus = (typeof NODE_STATUSES)[number];
+export interface CanvasNode {
+    /** `NNN-Nn`, allocated monotonically and never reused. */
+    id: string;
+    status: NodeStatus;
+    summary: string;
+    /** `mem:<uuid>` | `file:<path>` | `note:<text>`, or null. */
+    ref: string | null;
+}
+export interface Canvas {
+    /** Three-digit canvas prefix; every node id starts with it. */
+    prefix: string;
+    taskGoal: string;
+    createdTime: string | null;
+    updatedTime: string | null;
+    nodes: CanvasNode[];
+}
+/** Cap on a rendered node summary. Long enough to be useful, short enough that
+ *  a 20-node canvas still costs a few hundred tokens rather than a few thousand. */
+export declare const SUMMARY_MAX = 120;
+/**
+ * Reduce a title to a filename-safe slug.
+ *
+ * The whitelist is `[a-z0-9-]` and nothing else — not a blacklist of dangerous
+ * characters, because that is the kind of list that is always missing one entry.
+ * `.` is outside the whitelist, so `..` cannot survive and traversal is
+ * structurally impossible rather than merely checked for.
+ *
+ * Returns "" when nothing usable remains (a purely CJK title, for instance);
+ * callers must have a fallback and must not write a file named "".
+ */
+export declare function slugify(input: string): string;
+/**
+ * Make text safe to sit inside a Mermaid `["..."]` label.
+ *
+ * Mermaid has no escape syntax inside a quoted label, so the only reliable move
+ * is to replace the characters that would terminate it with lookalikes. A
+ * summary is prose for a human to skim; swapping `"` for `'` costs nothing a
+ * reader will miss, and it makes `x"] --> EVIL["pwned` inert.
+ *
+ * Arrows are neutralised too: a literal `-->` inside a label does not break
+ * Mermaid, but it reads as an edge to anyone scanning the file, and to the
+ * regex in `parseCanvas` if it ever loosens.
+ */
+export declare function escapeLabel(text: string): string;
+/**
+ * Trim to `max` characters, counting by code point.
+ *
+ * `String.prototype.slice` counts UTF-16 units, so slicing a string of astral
+ * characters mid-pair yields a lone surrogate — which is not a character, and
+ * which some JSON consumers reject outright. Spreading into an array iterates
+ * code points, so a cut always lands on a boundary.
+ */
+export declare function truncateSummary(text: string, max?: number): string;
+/**
+ * Next unused node id for this canvas.
+ *
+ * Deliberately max+1 rather than filling gaps. A deleted `000-N2` may still be
+ * cited by a commit message, a memory body or another node's ref; handing that
+ * id to a new node would silently repoint every one of those citations. Ids are
+ * cheap, so they are spent rather than recycled.
+ */
+export declare function allocateNodeId(canvas: Canvas): string;
+export declare function renderCanvas(canvas: Canvas): string;
+/**
+ * Parse a canvas file.
+ *
+ * Never throws. A canvas is recovered state — it is read at the moment the
+ * model has just lost its context, which is the worst possible moment to hand
+ * back an exception. A damaged header costs the goal; a damaged line costs that
+ * line; everything still parseable is returned.
+ */
+export declare function parseCanvas(content: string): Canvas;
+export interface CanvasCounts {
+    done: number;
+    doing: number;
+    todo: number;
+    blocked: number;
+}
+export declare function countByStatus(canvas: Canvas): CanvasCounts;
+/** One-line digest for the progressive-disclosure index: enough to decide
+ *  whether to open the canvas, not enough to be worth injecting wholesale. */
+export declare function formatCanvasHeadline(canvas: Canvas): string;
+//# sourceMappingURL=canvas-format.d.ts.map

package/dist/canvas-format.js

@@ -0,0 +1,259 @@
+/**
+ * Symbolic task canvas — parse and render.
+ *
+ * A canvas is one Mermaid file. It is the whole truth: there is no parallel
+ * JSON sidecar, because two files describing one task drift apart the first
+ * time a write fails halfway. The cost of that choice is that the format has to
+ * survive a round trip exactly, which is what the tests pin down.
+ *
+ * The shape borrows the `NNN-Nn` node id from TencentDB Agent Memory, for the
+ * reason that made it work there: it is greppable. An id in a canvas, a commit
+ * message or a memory body all lead back to the same node.
+ *
+ * What is ours is the `ref`: an anchor with a scheme, so a node can point at a
+ * memory in the graph (`mem:`), a file the harness already offloaded (`file:`),
+ * or an inline remark (`note:`). Their design only ever pointed at local files.
+ */
+// ============================================================================
+// Types
+// ============================================================================
+export const NODE_STATUSES = ["todo", "doing", "done", "blocked"];
+/** Cap on a rendered node summary. Long enough to be useful, short enough that
+ *  a 20-node canvas still costs a few hundred tokens rather than a few thousand. */
+export const SUMMARY_MAX = 120;
+const STATUS_SET = new Set(NODE_STATUSES);
+// ============================================================================
+// slugify
+// ============================================================================
+const SLUG_MAX = 60;
+/**
+ * Reduce a title to a filename-safe slug.
+ *
+ * The whitelist is `[a-z0-9-]` and nothing else — not a blacklist of dangerous
+ * characters, because that is the kind of list that is always missing one entry.
+ * `.` is outside the whitelist, so `..` cannot survive and traversal is
+ * structurally impossible rather than merely checked for.
+ *
+ * Returns "" when nothing usable remains (a purely CJK title, for instance);
+ * callers must have a fallback and must not write a file named "".
+ */
+export function slugify(input) {
+    const lowered = String(input ?? "").toLowerCase();
+    const kept = lowered.replace(/[^a-z0-9]+/g, "-");
+    const collapsed = kept.replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+    return collapsed.slice(0, SLUG_MAX).replace(/-+$/g, "");
+}
+// ============================================================================
+// escapeLabel
+// ============================================================================
+/**
+ * Make text safe to sit inside a Mermaid `["..."]` label.
+ *
+ * Mermaid has no escape syntax inside a quoted label, so the only reliable move
+ * is to replace the characters that would terminate it with lookalikes. A
+ * summary is prose for a human to skim; swapping `"` for `'` costs nothing a
+ * reader will miss, and it makes `x"] --> EVIL["pwned` inert.
+ *
+ * Arrows are neutralised too: a literal `-->` inside a label does not break
+ * Mermaid, but it reads as an edge to anyone scanning the file, and to the
+ * regex in `parseCanvas` if it ever loosens.
+ */
+export function escapeLabel(text) {
+    return String(text ?? "")
+        .replace(/[\r\n]+/g, " ")
+        .replace(/"/g, "'")
+        .replace(/\[/g, "(")
+        .replace(/\]/g, ")")
+        .replace(/\{/g, "(")
+        .replace(/\}/g, ")")
+        .replace(/-->/g, "→")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+}
+// ============================================================================
+// truncateSummary
+// ============================================================================
+/**
+ * Trim to `max` characters, counting by code point.
+ *
+ * `String.prototype.slice` counts UTF-16 units, so slicing a string of astral
+ * characters mid-pair yields a lone surrogate — which is not a character, and
+ * which some JSON consumers reject outright. Spreading into an array iterates
+ * code points, so a cut always lands on a boundary.
+ */
+export function truncateSummary(text, max = SUMMARY_MAX) {
+    const chars = [...String(text ?? "")];
+    if (chars.length <= max)
+        return chars.join("");
+    if (max <= 1)
+        return chars.slice(0, Math.max(0, max)).join("");
+    return chars.slice(0, max - 1).join("") + "…";
+}
+// ============================================================================
+// allocateNodeId
+// ============================================================================
+const NODE_ID_RE = /^(\d{3})-N(\d+)$/;
+/**
+ * Next unused node id for this canvas.
+ *
+ * Deliberately max+1 rather than filling gaps. A deleted `000-N2` may still be
+ * cited by a commit message, a memory body or another node's ref; handing that
+ * id to a new node would silently repoint every one of those citations. Ids are
+ * cheap, so they are spent rather than recycled.
+ */
+export function allocateNodeId(canvas) {
+    const prefix = /^\d{3}$/.test(canvas.prefix) ? canvas.prefix : "000";
+    let max = 0;
+    for (const node of canvas.nodes) {
+        const m = NODE_ID_RE.exec(node.id);
+        if (!m || m[1] !== prefix)
+            continue;
+        const n = Number(m[2]);
+        if (Number.isFinite(n) && n > max)
+            max = n;
+    }
+    return `${prefix}-N${max + 1}`;
+}
+// ============================================================================
+// renderCanvas
+// ============================================================================
+/**
+ * A ref is carried in its own `<br/>` field and JSON-escaped.
+ *
+ * Windows paths are the reason: `C:\Users\x` contains backslashes, which JSON
+ * escapes and which must come back byte-identical or the anchor stops resolving.
+ * Label escaping is for prose; refs get JSON, which is lossless.
+ */
+function renderRef(ref) {
+    return JSON.stringify(ref).slice(1, -1).replace(/"/g, "\\u0022");
+}
+function parseRef(raw) {
+    try {
+        return JSON.parse(`"${raw}"`);
+    }
+    catch {
+        return raw;
+    }
+}
+export function renderCanvas(canvas) {
+    const meta = {
+        taskGoal: canvas.taskGoal,
+        createdTime: canvas.createdTime,
+        updatedTime: canvas.updatedTime,
+        prefix: canvas.prefix,
+    };
+    const lines = [
+        `%%${JSON.stringify(meta)}%%`,
+        "graph LR",
+    ];
+    for (const node of canvas.nodes) {
+        const parts = [
+            `status: ${node.status}`,
+            `summary: ${escapeLabel(truncateSummary(node.summary))}`,
+        ];
+        if (node.ref !== null)
+            parts.push(`ref: ${renderRef(node.ref)}`);
+        lines.push(`    ${node.id}["${parts.join("<br/>")}"]`);
+    }
+    // Edges are emitted after all node declarations so that a truncated file
+    // still yields every node it contains, rather than losing the tail to a
+    // dangling arrow.
+    for (let i = 1; i < canvas.nodes.length; i++) {
+        lines.push(`    ${canvas.nodes[i - 1].id} --> ${canvas.nodes[i].id}`);
+    }
+    return lines.join("\n") + "\n";
+}
+// ============================================================================
+// parseCanvas
+// ============================================================================
+/** Only a line that *starts* with a node declaration opens a node, so an id
+ *  mentioned inside a summary is read as prose, which is what it is. */
+const NODE_LINE_RE = /^\s*(\d{3}-N\d+)\["([\s\S]*?)"\]\s*$/;
+/**
+ * Parse a canvas file.
+ *
+ * Never throws. A canvas is recovered state — it is read at the moment the
+ * model has just lost its context, which is the worst possible moment to hand
+ * back an exception. A damaged header costs the goal; a damaged line costs that
+ * line; everything still parseable is returned.
+ */
+export function parseCanvas(content) {
+    const text = String(content ?? "");
+    const canvas = {
+        prefix: "000",
+        taskGoal: "",
+        createdTime: null,
+        updatedTime: null,
+        nodes: [],
+    };
+    const metaMatch = text.match(/^%%\{[\s\S]*?\}%%/);
+    let prefixFromHeader = false;
+    if (metaMatch) {
+        try {
+            const raw = metaMatch[0].slice(2, -2);
+            const parsed = JSON.parse(raw);
+            canvas.taskGoal = typeof parsed.taskGoal === "string" ? parsed.taskGoal : "";
+            canvas.createdTime = typeof parsed.createdTime === "string" ? parsed.createdTime : null;
+            canvas.updatedTime = typeof parsed.updatedTime === "string" ? parsed.updatedTime : null;
+            if (typeof parsed.prefix === "string" && /^\d{3}$/.test(parsed.prefix)) {
+                canvas.prefix = parsed.prefix;
+                prefixFromHeader = true;
+            }
+        }
+        catch {
+            // Corrupt header: the nodes below are still worth having.
+        }
+    }
+    const seen = new Set();
+    for (const line of text.split(/\r?\n/)) {
+        const m = NODE_LINE_RE.exec(line);
+        if (!m)
+            continue;
+        const id = m[1];
+        if (seen.has(id))
+            continue; // first declaration wins
+        seen.add(id);
+        const body = m[2];
+        const fields = body.split("<br/>");
+        let status = "todo";
+        let summary = "";
+        let ref = null;
+        for (const field of fields) {
+            const sep = field.indexOf(":");
+            if (sep === -1)
+                continue;
+            const key = field.slice(0, sep).trim().toLowerCase();
+            const value = field.slice(sep + 1).trim();
+            if (key === "status") {
+                status = STATUS_SET.has(value) ? value : "todo";
+            }
+            else if (key === "summary") {
+                summary = value;
+            }
+            else if (key === "ref") {
+                ref = parseRef(value);
+            }
+        }
+        canvas.nodes.push({ id, status, summary, ref });
+    }
+    if (!prefixFromHeader && canvas.nodes.length > 0) {
+        const m = NODE_ID_RE.exec(canvas.nodes[0].id);
+        if (m)
+            canvas.prefix = m[1];
+    }
+    return canvas;
+}
+export function countByStatus(canvas) {
+    const counts = { done: 0, doing: 0, todo: 0, blocked: 0 };
+    for (const node of canvas.nodes)
+        counts[node.status] += 1;
+    return counts;
+}
+/** One-line digest for the progressive-disclosure index: enough to decide
+ *  whether to open the canvas, not enough to be worth injecting wholesale. */
+export function formatCanvasHeadline(canvas) {
+    const c = countByStatus(canvas);
+    const goal = canvas.taskGoal || "(no goal recorded)";
+    return `${goal} — ${c.done} done / ${c.doing} doing / ${c.todo} todo${c.blocked > 0 ? ` / ${c.blocked} blocked` : ""}`;
+}
+//# sourceMappingURL=canvas-format.js.map

package/dist/canvas-store.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Symbolic task canvas — filesystem storage.
+ *
+ * Canvases live at `{cubesDir}/{cube_id}/canvas/{name}.mmd`, beside the cube
+ * whose task they describe. They are deliberately *not* written into Neo4j or
+ * Qdrant: a canvas is short-term session state that changes many times an hour,
+ * and paying an embedding round trip per status flip would be absurd. Long-term
+ * facts go through `memos_save`; the canvas points at them with a `mem:` ref.
+ *
+ * Two properties matter here, and both are about failing safely rather than
+ * failing loudly:
+ *
+ * 1. Every path is built by `canvasPath`, which rejects anything that would
+ *    escape the canvas directory. `cube_id` is derived from a caller-supplied
+ *    project path, so it is untrusted input too — not just the canvas name.
+ *
+ * 2. Writes are atomic (temp file + rename). A canvas is read at precisely the
+ *    moment context was lost, so a half-written file is worse than a stale one.
+ */
+import { type Canvas } from "./canvas-format.js";
+export declare class CanvasPathError extends Error {
+    constructor(message: string);
+}
+/**
+ * Resolve a canvas file path, or throw.
+ *
+ * The name is passed through `slugify`, whose whitelist excludes `.`, `/` and
+ * `\` — so `..`, absolute paths and nested segments cannot survive it. The
+ * post-resolve containment check is a second, independent line: if a future
+ * change to slugify ever lets something through, this still catches it.
+ */
+export declare function canvasPath(cubesDir: string, cubeId: string, name: string): string;
+/** Returns null when the canvas does not exist. A damaged file yields an empty
+ *  canvas rather than an exception — see `parseCanvas`. */
+export declare function loadCanvas(cubesDir: string, cubeId: string, name: string): Canvas | null;
+/** Writes atomically and returns the path written. */
+export declare function saveCanvas(cubesDir: string, cubeId: string, name: string, canvas: Canvas): string;
+export interface CanvasEntry {
+    /** Filename without the extension — the handle callers pass back in. */
+    name: string;
+    path: string;
+    canvas: Canvas;
+}
+/**
+ * Every canvas in a cube, sorted by name.
+ *
+ * Returns [] rather than throwing for a missing directory or a bad cube id:
+ * this feeds the context-resume index, which must never be the thing that
+ * breaks a session recovery.
+ */
+export declare function listCanvases(cubesDir: string, cubeId: string): CanvasEntry[];
+/**
+ * Next unused three-digit canvas prefix, or null once 999 is taken.
+ *
+ * Max+1, never gap-filling, for the same reason node ids are not recycled: a
+ * prefix appears inside every node id it minted, and reissuing it would make
+ * two canvases' ids ambiguous. Returning null instead of wrapping keeps the
+ * failure visible — a caller that has 1000 canvases in one cube has a different
+ * problem than a naming collision.
+ */
+export declare function nextPrefix(cubesDir: string, cubeId: string): string | null;
+//# sourceMappingURL=canvas-store.d.ts.map

package/dist/canvas-store.js

@@ -0,0 +1,187 @@
+/**
+ * Symbolic task canvas — filesystem storage.
+ *
+ * Canvases live at `{cubesDir}/{cube_id}/canvas/{name}.mmd`, beside the cube
+ * whose task they describe. They are deliberately *not* written into Neo4j or
+ * Qdrant: a canvas is short-term session state that changes many times an hour,
+ * and paying an embedding round trip per status flip would be absurd. Long-term
+ * facts go through `memos_save`; the canvas points at them with a `mem:` ref.
+ *
+ * Two properties matter here, and both are about failing safely rather than
+ * failing loudly:
+ *
+ * 1. Every path is built by `canvasPath`, which rejects anything that would
+ *    escape the canvas directory. `cube_id` is derived from a caller-supplied
+ *    project path, so it is untrusted input too — not just the canvas name.
+ *
+ * 2. Writes are atomic (temp file + rename). A canvas is read at precisely the
+ *    moment context was lost, so a half-written file is worse than a stale one.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { basename, join, resolve, sep } from "node:path";
+import { parseCanvas, renderCanvas, slugify } from "./canvas-format.js";
+export class CanvasPathError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CanvasPathError";
+    }
+}
+const CANVAS_DIR = "canvas";
+const CANVAS_EXT = ".mmd";
+/** `cube_id` is machine-derived (`detectCubeFromPath`), so this is a shape check
+ *  rather than a sanitiser — a value that does not look like a cube id is a bug
+ *  upstream, and guessing at what it meant would hide it. */
+const CUBE_ID_RE = /^[a-z0-9_]+$/;
+// ============================================================================
+// Path construction
+// ============================================================================
+/**
+ * Resolve a canvas file path, or throw.
+ *
+ * The name is passed through `slugify`, whose whitelist excludes `.`, `/` and
+ * `\` — so `..`, absolute paths and nested segments cannot survive it. The
+ * post-resolve containment check is a second, independent line: if a future
+ * change to slugify ever lets something through, this still catches it.
+ */
+export function canvasPath(cubesDir, cubeId, name) {
+    const rawName = String(name ?? "");
+    const rawCube = String(cubeId ?? "");
+    // A NUL truncates a path in some syscalls, so `a\u0000.mmd` could end up
+    // addressing `a`. slugify drops it anyway; reject explicitly rather than
+    // quietly accepting a name that was plainly an attack.
+    if (rawName.includes("\u0000") || rawCube.includes("\u0000")) {
+        throw new CanvasPathError("canvas name must not contain a NUL byte");
+    }
+    if (!CUBE_ID_RE.test(rawCube)) {
+        throw new CanvasPathError(`invalid cube_id: ${JSON.stringify(rawCube)}`);
+    }
+    const slug = slugify(rawName);
+    if (!slug) {
+        throw new CanvasPathError(`canvas name ${JSON.stringify(rawName)} contains no usable characters ` +
+            `(allowed: letters, digits, hyphen)`);
+    }
+    // slugify is lossy, so a name that only differs by stripped characters would
+    // silently collide with, or redirect to, another canvas. Refuse instead.
+    if (slug !== rawName.toLowerCase()) {
+        const looksLikePath = /[\\/]|\.\./.test(rawName);
+        if (looksLikePath) {
+            throw new CanvasPathError(`canvas name must be a bare name, not a path: ${JSON.stringify(rawName)}`);
+        }
+    }
+    const dir = resolve(cubesDir, rawCube, CANVAS_DIR);
+    const full = resolve(dir, `${slug}${CANVAS_EXT}`);
+    const dirWithSep = dir.endsWith(sep) ? dir : dir + sep;
+    if (!full.startsWith(dirWithSep) || basename(full) !== `${slug}${CANVAS_EXT}`) {
+        throw new CanvasPathError(`resolved path escapes the canvas directory: ${full}`);
+    }
+    return full;
+}
+function canvasDirFor(cubesDir, cubeId) {
+    if (!CUBE_ID_RE.test(String(cubeId ?? "")))
+        return null;
+    return resolve(cubesDir, cubeId, CANVAS_DIR);
+}
+// ============================================================================
+// Load / save
+// ============================================================================
+/** Returns null when the canvas does not exist. A damaged file yields an empty
+ *  canvas rather than an exception — see `parseCanvas`. */
+export function loadCanvas(cubesDir, cubeId, name) {
+    const path = canvasPath(cubesDir, cubeId, name);
+    if (!existsSync(path))
+        return null;
+    try {
+        return parseCanvas(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null; // unreadable (permissions, race) — treat as absent
+    }
+}
+/** Writes atomically and returns the path written. */
+export function saveCanvas(cubesDir, cubeId, name, canvas) {
+    const path = canvasPath(cubesDir, cubeId, name);
+    const dir = resolve(cubesDir, cubeId, CANVAS_DIR);
+    mkdirSync(dir, { recursive: true });
+    // Same directory as the target, so the rename cannot cross a filesystem
+    // boundary and degrade into a non-atomic copy.
+    const tmp = `${path}.${process.pid}.tmp`;
+    try {
+        writeFileSync(tmp, renderCanvas(canvas), "utf8");
+        renameSync(tmp, path);
+    }
+    catch (err) {
+        try {
+            if (existsSync(tmp))
+                unlinkSync(tmp);
+        }
+        catch {
+            // best effort: the write already failed, and masking that error with a
+            // cleanup error would lose the useful one
+        }
+        throw err;
+    }
+    return path;
+}
+/**
+ * Every canvas in a cube, sorted by name.
+ *
+ * Returns [] rather than throwing for a missing directory or a bad cube id:
+ * this feeds the context-resume index, which must never be the thing that
+ * breaks a session recovery.
+ */
+export function listCanvases(cubesDir, cubeId) {
+    const dir = canvasDirFor(cubesDir, cubeId);
+    if (!dir || !existsSync(dir))
+        return [];
+    let files;
+    try {
+        files = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const file of files) {
+        if (!file.endsWith(CANVAS_EXT))
+            continue;
+        const name = file.slice(0, -CANVAS_EXT.length);
+        const path = join(dir, file);
+        try {
+            entries.push({ name, path, canvas: parseCanvas(readFileSync(path, "utf8")) });
+        }
+        catch {
+            continue; // unreadable file should not hide the readable ones
+        }
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    return entries;
+}
+// ============================================================================
+// Prefix allocation
+// ============================================================================
+const PREFIX_RE = /^(\d{3})/;
+/**
+ * Next unused three-digit canvas prefix, or null once 999 is taken.
+ *
+ * Max+1, never gap-filling, for the same reason node ids are not recycled: a
+ * prefix appears inside every node id it minted, and reissuing it would make
+ * two canvases' ids ambiguous. Returning null instead of wrapping keeps the
+ * failure visible — a caller that has 1000 canvases in one cube has a different
+ * problem than a naming collision.
+ */
+export function nextPrefix(cubesDir, cubeId) {
+    let max = -1;
+    for (const entry of listCanvases(cubesDir, cubeId)) {
+        const m = PREFIX_RE.exec(entry.name);
+        if (!m)
+            continue;
+        const n = Number(m[1]);
+        if (Number.isFinite(n) && n > max)
+            max = n;
+    }
+    const next = max + 1;
+    if (next > 999)
+        return null;
+    return String(next).padStart(3, "0");
+}
+//# sourceMappingURL=canvas-store.js.map

package/dist/config.d.ts

@@ -10,6 +10,9 @@ export declare const logger: {
     error: (msg: string) => void;
     exception: (msg: string, err?: unknown) => void;
 };
+export type MemosMode = "full" | "lite";
+export declare const MEMOS_MODE: MemosMode;
+export declare const MEMOS_PROVIDER: string;
 export declare const MEMOS_URL: string;
 export declare const MEMOS_USER: string;
 export declare const MEMOS_DEFAULT_CUBE: string;