mockpit 2.0.0 → 3.0.0

package/dist/server/jump.js

@@ -0,0 +1,175 @@
+// Search to jump: find a design by anything the user might remember it by, its
+// title, a state, a variant's name or note, a question, or its area. It reads
+// what `listJumpRows` hands it, which never includes surfaces, so a big
+// workspace costs its metadata and not its pages. This project comes first, then
+// the others. Runtime-agnostic (no node imports).
+import { isLive, openAsks } from "./types.js";
+const MAX_HERE = 20;
+const MAX_ELSEWHERE = 12;
+// A design whose variants all carry the word shouldn't push every other design off the list.
+const MAX_PER_DESIGN = 3;
+const SNIPPET = 90;
+// Precision before recall: what a design is called beats what was once said about it.
+const RANK = {
+    exact: 0,
+    prefix: 1,
+    word: 2,
+    title: 3,
+    state: 4,
+    variant: 5,
+    area: 6,
+    question: 7,
+    description: 8,
+};
+// "Cafe" finds "Café", and "food" finds "Food".
+const fold = (s) => s.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase();
+function clip(text, term) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    if (flat.length <= SNIPPET)
+        return flat;
+    const at = Math.max(0, fold(flat).indexOf(term));
+    const start = at < SNIPPET / 3 ? 0 : at - Math.floor(SNIPPET / 3);
+    const cut = flat.slice(start, start + SNIPPET).trim();
+    return `${start > 0 ? "…" : ""}${cut}${start + SNIPPET < flat.length ? "…" : ""}`;
+}
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function allHits(rows, terms, whole) {
+    const byDesign = new Map();
+    for (const v of rows.variants) {
+        const list = byDesign.get(v.designId);
+        if (list)
+            list.push(v);
+        else
+            byDesign.set(v.designId, [v]);
+    }
+    const has = (text) => {
+        const f = fold(text);
+        return terms.every((t) => f.includes(t));
+    };
+    const out = [];
+    const areasSeen = new Set();
+    for (const m of rows.designs) {
+        const variants = byDesign.get(m.id) ?? [];
+        const base = {
+            project: m.project,
+            id: m.id,
+            slug: m.slug,
+            title: m.title,
+            kind: m.kind,
+            width: m.widths[0] ?? null,
+            area: m.area,
+            open: openAsks(m).length,
+            designArchived: !!m.archivedAt,
+            inUse: variants.some((v) => v.status === "accepted"),
+            text: null,
+            state: null,
+            variant: null,
+            archived: false,
+        };
+        const mine = [];
+        const add = (rank, match, extra = {}) => mine.push({ hit: { ...base, match, ...extra }, rank, updatedAt: m.updatedAt });
+        const title = fold(m.title);
+        if (title === whole)
+            add(RANK.exact, "title");
+        else if (title.startsWith(whole))
+            add(RANK.prefix, "title");
+        else if (terms.every((t) => new RegExp(`(^|[^\\p{L}\\p{N}])${escapeRe(t)}`, "u").test(title)))
+            add(RANK.word, "title");
+        else if (has(m.title) || has(m.slug))
+            add(RANK.title, "title");
+        for (const state of m.states) {
+            if (has(state))
+                add(RANK.state, "state", { text: state, state });
+        }
+        const namesSeen = new Set();
+        for (const v of variants) {
+            const gone = !isLive(v.status);
+            const tail = gone ? 0.5 : 0;
+            // A variant named "default" says nothing the design's title doesn't.
+            if (v.variant !== "default" && !namesSeen.has(v.variant) && has(v.variant)) {
+                namesSeen.add(v.variant);
+                add(RANK.variant + tail, "variant", {
+                    text: v.variant,
+                    state: v.state,
+                    variant: v.variant,
+                    archived: gone,
+                });
+            }
+            if (v.description && has(v.description)) {
+                add(RANK.description + tail, "description", {
+                    text: clip(v.description, terms[0]),
+                    state: v.state,
+                    variant: v.variant,
+                    archived: gone,
+                });
+            }
+        }
+        for (const ask of m.asks) {
+            if (has(ask.text)) {
+                add(RANK.question, "question", {
+                    text: clip(ask.text, terms[0]),
+                    state: ask.state ?? null,
+                });
+            }
+        }
+        mine.sort((a, b) => a.rank - b.rank);
+        out.push(...mine.slice(0, MAX_PER_DESIGN));
+        if (m.area && has(m.area) && !areasSeen.has(`${m.project}\n${m.area}`)) {
+            areasSeen.add(`${m.project}\n${m.area}`);
+            out.push({
+                hit: {
+                    ...base,
+                    id: null,
+                    slug: null,
+                    title: m.area,
+                    kind: null,
+                    width: null,
+                    match: "area",
+                    open: 0,
+                    designArchived: false,
+                    inUse: false,
+                },
+                rank: RANK.area,
+                updatedAt: m.updatedAt,
+            });
+        }
+    }
+    return out;
+}
+export function jumpHits(rows, query, project) {
+    const whole = fold(query).trim().replace(/\s+/g, " ");
+    const terms = whole.split(" ").filter(Boolean);
+    if (!terms.length)
+        return [];
+    const order = (a, b) => a.rank - b.rank || b.updatedAt.localeCompare(a.updatedAt);
+    const all = allHits(rows, terms, whole);
+    const here = all.filter((h) => h.hit.project === project).sort(order);
+    const elsewhere = all.filter((h) => h.hit.project !== project).sort(order);
+    return [...here.slice(0, MAX_HERE), ...elsewhere.slice(0, MAX_ELSEWHERE)].map((h) => h.hit);
+}
+// The designs this browser opened last, in that order, as they are called now: a
+// renamed one follows, and a deleted one drops out.
+export function recentHits(rows, ids) {
+    const wanted = new Map(ids.map((id, i) => [id, i]));
+    const inUse = new Set(rows.variants.filter((v) => v.status === "accepted").map((v) => v.designId));
+    return rows.designs
+        .filter((m) => wanted.has(m.id))
+        .sort((a, b) => wanted.get(a.id) - wanted.get(b.id))
+        .map((m) => ({
+        project: m.project,
+        id: m.id,
+        slug: m.slug,
+        title: m.title,
+        kind: m.kind,
+        width: m.widths[0] ?? null,
+        area: m.area,
+        match: "title",
+        text: null,
+        state: null,
+        variant: null,
+        archived: false,
+        open: openAsks(m).length,
+        designArchived: !!m.archivedAt,
+        inUse: inUse.has(m.id),
+    }));
+}

package/dist/server/knobs.d.ts

@@ -1,4 +1,4 @@
-import type { ExplicitKnob, KnobConfig, Knobs, KnobValue, Mock, Post } from "./types.ts";
+import type { ExplicitKnob, KnobConfig, Knobs, KnobValue, Design, Post } from "./types.ts";
 export type Checked<T> = {
     ok: true;
     value: T;
@@ -10,10 +10,10 @@ export declare function explicitKnob(config: KnobConfig): ExplicitKnob;
 export declare function checkKnobConfig(path: string, raw: unknown): Checked<KnobConfig>;
 export declare function checkKnobs(raw: unknown): Checked<Knobs>;
 export declare function checkKnobValue(path: string, config: KnobConfig, value: unknown): Checked<KnobValue>;
-export declare function knobFor(path: string, mock: Pick<Mock, "knobs">, posts: (Pick<Post, "knobs"> & {
+export declare function knobFor(path: string, design: Pick<Design, "knobs">, posts: (Pick<Post, "knobs"> & {
     surfaces?: Post["surfaces"];
 })[]): KnobConfig | undefined;
-export declare function checkKnobValues(raw: unknown, mock: Pick<Mock, "knobs">, posts: (Pick<Post, "knobs"> & {
+export declare function checkKnobValues(raw: unknown, design: Pick<Design, "knobs">, posts: (Pick<Post, "knobs"> & {
     surfaces?: Post["surfaces"];
 })[], what: string): Checked<Record<string, KnobValue>>;
 export declare function discreteChoices(config: KnobConfig): number | null;

package/dist/server/knobs.js

@@ -293,12 +293,12 @@ export function checkKnobValue(path, config, value) {
         }
     }
 }
-// The declared knob for a path: the mock's own, else a variant's override,
+// The declared knob for a path: the design's own, else a variant's override,
 // else the knob a variant's slot implies (fills.ts), so an option can `set` a
 // slot's fill without the agent declaring anything.
-export function knobFor(path, mock, posts) {
-    if (Object.hasOwn(mock.knobs, path))
-        return mock.knobs[path];
+export function knobFor(path, design, posts) {
+    if (Object.hasOwn(design.knobs, path))
+        return design.knobs[path];
     for (const p of posts)
         if (p.knobs && Object.hasOwn(p.knobs, path))
             return p.knobs[path];
@@ -311,7 +311,7 @@ export function knobFor(path, mock, posts) {
     }
     return undefined;
 }
-export function checkKnobValues(raw, mock, posts, what) {
+export function checkKnobValues(raw, design, posts, what) {
     if (raw === undefined || raw === null)
         return { ok: true, value: {} };
     if (typeof raw !== "object" || Array.isArray(raw)) {
@@ -319,7 +319,7 @@ export function checkKnobValues(raw, mock, posts, what) {
     }
     const out = {};
     for (const [path, value] of Object.entries(raw)) {
-        const config = knobFor(path, mock, posts);
+        const config = knobFor(path, design, posts);
         if (config === undefined)
             return { ok: false, error: `${what}: no knob "${path}" is declared` };
         const checked = checkKnobValue(path, config, value);

package/dist/server/mcpHttp.d.ts

@@ -11,13 +11,16 @@ export interface McpFlows {
     tree: Flow<[query: {
         project?: string;
     }]>;
+    decisions: Flow<[query: {
+        project?: string;
+    }]>;
     get: Flow<[ref: unknown, query: {
         project?: unknown;
         body?: boolean;
         history?: boolean;
     }]>;
     ask: Flow<[ref: unknown, body: any, ctx: FlowContext]>;
-    exportMock: Flow<[
+    exportDesign: Flow<[
         ref: unknown,
         query: {
             project?: unknown;
@@ -27,6 +30,7 @@ export interface McpFlows {
         ctx: FlowContext
     ]>;
     say: Flow<[ref: unknown, body: any, ctx: FlowContext]>;
+    move: Flow<[ref: unknown, body: any, ctx: FlowContext]>;
     feedback: Flow<[query: {
         session?: unknown;
         project?: unknown;

package/dist/server/mcpHttp.js

@@ -12,16 +12,16 @@ export function unwrap(result) {
     return result.body;
 }
 // `edit` is one verb with two shapes: `rename` or `areaOrder` edits the
-// project, anything else edits the mock. Shared by both MCP transports' HTTP
+// project, anything else edits the design. Shared by both MCP transports' HTTP
 // side and `run`.
 export function editCall(flows, args, ctx, project) {
     if (args.rename === undefined && args.areaOrder === undefined) {
-        return flows.edit(args.mock, args, ctx);
+        return flows.edit(args.design, args, ctx);
     }
-    if (args.mock !== undefined) {
+    if (args.design !== undefined) {
         return Promise.resolve({
             status: 400,
-            body: { error: '"rename" and "areaOrder" edit the project; edit the mock without them' },
+            body: { error: '"rename" and "areaOrder" edit the project; edit the design without them' },
         });
     }
     if (!project) {
@@ -63,14 +63,17 @@ export function registerMcp(app, deps) {
             case "publish":
                 return unwrap(await flows.publish(args, ctx));
             case "ask":
-                return unwrap(await flows.ask(args.mock, args, ctx));
+                return unwrap(await flows.ask(args.design, args, ctx));
             case "read":
-                if (args.mock === undefined && args.tree === true) {
+                if (args.decisions === true) {
+                    return unwrap(await flows.decisions({ project: args.project }));
+                }
+                if (args.design === undefined && args.tree === true) {
                     return unwrap(await flows.tree({ project: args.project }));
                 }
-                if (args.mock === undefined)
+                if (args.design === undefined)
                     return unwrap(await flows.list({ project: args.project }));
-                return unwrap(await flows.get(args.mock, {
+                return unwrap(await flows.get(args.design, {
                     project: args.project,
                     body: args.body === true,
                     history: args.history === true,
@@ -78,9 +81,11 @@ export function registerMcp(app, deps) {
             case "feedback":
                 return unwrap(await flows.feedback({ session: args.session, project: args.project }, ctx));
             case "say":
-                return unwrap(await flows.say(args.mock, args, ctx));
+                return unwrap(await flows.say(args.design, args, ctx));
+            case "move":
+                return unwrap(await flows.move(args.design, args, ctx));
             case "export":
-                return unwrap(await flows.exportMock(args.mock, args, ctx));
+                return unwrap(await flows.exportDesign(args.design, args, ctx));
             case "edit":
                 return unwrap(await editCall(flows, args, ctx, await namedProject(args)));
             case "upload": {
@@ -119,7 +124,7 @@ export function registerMcp(app, deps) {
     app.post("/mcp", async (c) => {
         const rpc = (id, result) => c.json({ jsonrpc: "2.0", id, result });
         // `?mode=code` is the opt-in codemode catalog for clients without a
-        // harness of their own: one `run` tool instead of the mock tools.
+        // harness of their own: one `run` tool instead of the design tools.
         const code = c.req.query("mode") === "code";
         const rpcError = (id, code, message, status = 200) => c.json({ jsonrpc: "2.0", id, error: { code, message } }, status);
         let msg;