@1agh/maude 0.15.0 → 0.16.0

package/README.md

@@ -1,9 +1,7 @@
-# Maude — Claude Code marketplace
+# Maude
 
 A personal marketplace of Claude Code plugins. Two plugins today, plus a `maude` CLI for scaffolding and running the bundled dev tooling.
 
-> **Renamed from `md-claude`.** See [`docs/MIGRATING-MD-CLAUDE-TO-MAUDE.md`](./docs/MIGRATING-MD-CLAUDE-TO-MAUDE.md) if you came from the old name.
-
 > **📚 Full docs: https://maude.iagh.cz** (or browse the source under [`site/content/docs/`](./site/content/docs/) until the public URL lands).
 > Contributing? See [CONTRIBUTING.md](./CONTRIBUTING.md). Security? See [SECURITY.md](./SECURITY.md).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1agh/maude",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Marketplace of Claude Code plugins by Michal Dovrtěl: `design` (canvas-first design iteration) + `flow` (generic agentic workflow loop with .ai second brain). Ships the `maude` CLI (with `mdcc` legacy alias) to scaffold workspace, run the design dev server, and manage configs.",
   "type": "module",
   "engines": {
@@ -39,13 +39,13 @@
     "prepublishOnly": "bash scripts/check-version-parity.sh"
   },
   "optionalDependencies": {
-    "@1agh/maude-darwin-arm64": "0.15.0",
-    "@1agh/maude-darwin-x64": "0.15.0",
-    "@1agh/maude-linux-arm64": "0.15.0",
-    "@1agh/maude-linux-arm64-musl": "0.15.0",
-    "@1agh/maude-linux-x64": "0.15.0",
-    "@1agh/maude-linux-x64-musl": "0.15.0",
-    "@1agh/maude-win32-x64": "0.15.0"
+    "@1agh/maude-darwin-arm64": "0.16.0",
+    "@1agh/maude-darwin-x64": "0.16.0",
+    "@1agh/maude-linux-arm64": "0.16.0",
+    "@1agh/maude-linux-arm64-musl": "0.16.0",
+    "@1agh/maude-linux-x64": "0.16.0",
+    "@1agh/maude-linux-x64-musl": "0.16.0",
+    "@1agh/maude-win32-x64": "0.16.0"
   },
   "files": [
     "cli",

package/plugins/design/dev-server/api.ts

@@ -78,6 +78,19 @@ async function findFiles(absRoot: string, prefix: string, exts: string[]): Promi
 
 // ---------- Comments ----------
 
+/**
+ * Phase 6 — single reply on a comment thread. `id` is `r_<hex>`; persists inside
+ * the parent `Comment.thread[]`. Bodies are bounded the same way as comment
+ * bodies (4000 chars), and `@handle` tokens in `body` flow into the parent's
+ * `mentions[]` union.
+ */
+export interface Reply {
+  id: string;
+  author: string;
+  body: string;
+  created: string;
+}
+
 export interface Comment {
   id: string;
   file: string;
@@ -91,6 +104,19 @@ export interface Comment {
   status: 'open' | 'resolved';
   created: string;
   resolved_at: string | null;
+  // Phase 6 — author + threading + mentions. Default-filled on read for legacy
+  // comments missing these fields (see `loadCommentsForFile`); persisted on next
+  // write. `author` defaults to the local `git config user.name` resolved at
+  // create time, `thread` to `[]`, `mentions` to `[]`.
+  author: string;
+  thread: Reply[];
+  mentions: string[];
+}
+
+export interface GitCommitter {
+  name: string;
+  email: string;
+  commits: number;
 }
 
 export interface Api {
@@ -102,6 +128,9 @@ export interface Api {
   commentsAdd(payload: Partial<Comment> & { file: string; text: string }): Promise<Comment | null>;
   commentsPatch(id: string, patch: Partial<Comment>): Promise<Comment | null>;
   commentsDelete(id: string): Promise<boolean>;
+  commentsAddReply(id: string, payload: { body: string; author?: string }): Promise<Comment | null>;
+  gitCommitters(): Promise<GitCommitter[]>;
+  parseMentions(text: string): string[];
   // Canvas state
   loadCanvasState(file: string): Promise<Record<string, unknown> | null>;
   saveCanvasState(file: string, state: Record<string, unknown>): Promise<void>;
@@ -147,12 +176,26 @@ export function createApi(ctx: Context, onCommentsChanged: (file: string) => voi
     try {
       const raw = await Bun.file(commentsPath(file)).text();
       const arr = JSON.parse(raw);
-      return Array.isArray(arr) ? arr : [];
+      if (!Array.isArray(arr)) return [];
+      // Phase 6 — default-fill `author` / `thread` / `mentions` for legacy
+      // rows. No write-back here; the on-disk shape stays stable until the
+      // next mutation persists the upgraded record.
+      return arr.map(backfillComment);
     } catch {
       return [];
     }
   }
 
+  function backfillComment(raw: unknown): Comment {
+    const c = (raw ?? {}) as Partial<Comment>;
+    return {
+      ...(c as Comment),
+      author: typeof c.author === 'string' ? c.author : '',
+      thread: Array.isArray(c.thread) ? c.thread : [],
+      mentions: Array.isArray(c.mentions) ? c.mentions : [],
+    };
+  }
+
   async function saveCommentsForFile(file: string, list: Comment[]) {
     await Bun.write(commentsPath(file), JSON.stringify(list, null, 2));
   }
@@ -172,7 +215,8 @@ export function createApi(ctx: Context, onCommentsChanged: (file: string) => voi
         const arr = JSON.parse(raw);
         if (!Array.isArray(arr) || arr.length === 0) continue;
         const file = arr[0]?.file as string | undefined;
-        if (file) out[file] = arr;
+        // Backfill legacy rows so callers see the v2 shape uniformly.
+        if (file) out[file] = arr.map(backfillComment);
       } catch {
         /* ignore */
       }
@@ -184,10 +228,111 @@ export function createApi(ctx: Context, onCommentsChanged: (file: string) => voi
     return `c_${crypto.randomBytes(6).toString('hex')}`;
   }
 
+  function newReplyId(): string {
+    return `r_${crypto.randomBytes(6).toString('hex')}`;
+  }
+
+  // ---------- Git author resolution ----------
+  //
+  // Author defaults flow from `git config user.name` resolved against the
+  // repo root. Cached for the lifetime of the process — the local git
+  // identity doesn't shift mid-session and `Bun.spawn` is cheap-but-not-free.
+
+  let cachedGitUser: string | null = null;
+  let cachedGitUserAttempted = false;
+  async function gitCurrentUser(): Promise<string> {
+    if (cachedGitUserAttempted) return cachedGitUser ?? '';
+    cachedGitUserAttempted = true;
+    try {
+      const proc = Bun.spawn(['git', 'config', 'user.name'], {
+        cwd: paths.repoRoot,
+        stdout: 'pipe',
+        stderr: 'pipe',
+      });
+      const out = await new Response(proc.stdout).text();
+      await proc.exited;
+      const name = out.trim();
+      cachedGitUser = name || null;
+    } catch {
+      cachedGitUser = null;
+    }
+    return cachedGitUser ?? '';
+  }
+
+  // `git shortlog -sne` against the repo head — cached for 60 s so the
+  // @mention popup doesn't re-fork git on every keystroke.
+  let cachedCommitters: GitCommitter[] | null = null;
+  let cachedCommittersAt = 0;
+  async function gitCommitters(): Promise<GitCommitter[]> {
+    const now = Date.now();
+    if (cachedCommitters && now - cachedCommittersAt < 60_000) return cachedCommitters;
+    try {
+      const proc = Bun.spawn(['git', 'shortlog', '-sne', 'HEAD'], {
+        cwd: paths.repoRoot,
+        stdout: 'pipe',
+        stderr: 'pipe',
+      });
+      const text = await new Response(proc.stdout).text();
+      await proc.exited;
+      const lines = text
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean)
+        .slice(0, 20);
+      const out: GitCommitter[] = [];
+      for (const line of lines) {
+        // Format: `<spaces><count>\t<name> <<email>>`
+        const m = line.match(/^(\d+)\s+(.+?)\s+<([^>]+)>$/);
+        if (!m) continue;
+        const commits = Number(m[1]);
+        const name = m[2]?.trim() ?? '';
+        const email = m[3]?.trim() ?? '';
+        if (!name) continue;
+        out.push({ name, email, commits });
+      }
+      cachedCommitters = out;
+      cachedCommittersAt = now;
+      return out;
+    } catch {
+      cachedCommitters = cachedCommitters ?? [];
+      cachedCommittersAt = now;
+      return cachedCommitters;
+    }
+  }
+
+  /**
+   * Extract `@handle` tokens from free text. Deduped, returns the literal
+   * `@name` form (matching what the autocomplete inserts), so a comment with
+   * `"@ada @lin @ada"` collapses to `["@ada","@lin"]`.
+   */
+  function parseMentions(text: string): string[] {
+    const out: string[] = [];
+    const seen = new Set<string>();
+    if (typeof text !== 'string' || !text) return out;
+    const re = /@[\w][\w.-]*/g;
+    for (const m of text.matchAll(re)) {
+      const tok = m[0];
+      if (!tok || seen.has(tok)) continue;
+      seen.add(tok);
+      out.push(tok);
+    }
+    return out;
+  }
+
+  function mentionsUnion(c: Comment): string[] {
+    const all = [c.text, ...c.thread.map((r) => r.body)].join('\n');
+    return parseMentions(all);
+  }
+
   async function commentsAdd(payload: Partial<Comment> & { file: string; text: string }) {
     if (!payload || typeof payload.file !== 'string' || !payload.file) return null;
     if (typeof payload.text !== 'string' || !payload.text.trim()) return null;
     const list = await loadCommentsForFile(payload.file);
+    const text = String(payload.text).trim().slice(0, 4000);
+    const author =
+      typeof payload.author === 'string' && payload.author.trim()
+        ? payload.author.trim().slice(0, 120)
+        : await gitCurrentUser();
     const c: Comment = {
       id: newCommentId(),
       file: payload.file,
@@ -197,10 +342,13 @@ export function createApi(ctx: Context, onCommentsChanged: (file: string) => voi
       classes: String(payload.classes || ''),
       bounds: payload.bounds ?? null,
       html_excerpt: String(payload.html_excerpt || '').slice(0, 2000),
-      text: String(payload.text).trim().slice(0, 4000),
+      text,
       status: 'open',
       created: new Date().toISOString(),
       resolved_at: null,
+      author,
+      thread: [],
+      mentions: parseMentions(text),
     };
     list.push(c);
     await saveCommentsForFile(payload.file, list);
@@ -208,6 +356,37 @@ export function createApi(ctx: Context, onCommentsChanged: (file: string) => voi
     return c;
   }
 
+  async function commentsAddReply(
+    id: string,
+    payload: { body: string; author?: string }
+  ): Promise<Comment | null> {
+    if (!payload || typeof payload.body !== 'string' || !payload.body.trim()) return null;
+    const all = await loadAllComments();
+    for (const [file, list] of Object.entries(all)) {
+      const i = list.findIndex((c) => c.id === id);
+      if (i < 0) continue;
+      const entry = list[i];
+      if (!entry) continue;
+      const body = payload.body.trim().slice(0, 4000);
+      const author =
+        typeof payload.author === 'string' && payload.author.trim()
+          ? payload.author.trim().slice(0, 120)
+          : await gitCurrentUser();
+      const reply: Reply = {
+        id: newReplyId(),
+        author,
+        body,
+        created: new Date().toISOString(),
+      };
+      entry.thread = [...entry.thread, reply];
+      entry.mentions = mentionsUnion(entry);
+      await saveCommentsForFile(file, list);
+      onCommentsChanged(file);
+      return entry;
+    }
+    return null;
+  }
+
   async function commentsPatch(id: string, patch: Partial<Comment>) {
     const all = await loadAllComments();
     for (const [file, list] of Object.entries(all)) {
@@ -221,6 +400,7 @@ export function createApi(ctx: Context, onCommentsChanged: (file: string) => voi
       }
       if (typeof patch.text === 'string' && patch.text.trim()) {
         entry.text = patch.text.trim().slice(0, 4000);
+        entry.mentions = mentionsUnion(entry);
       }
       await saveCommentsForFile(file, list);
       onCommentsChanged(file);
@@ -662,6 +842,9 @@ export function createApi(ctx: Context, onCommentsChanged: (file: string) => voi
     commentsAdd,
     commentsPatch,
     commentsDelete,
+    commentsAddReply,
+    gitCommitters,
+    parseMentions,
     loadCanvasState,
     saveCanvasState,
     loadCanvasMeta,

package/plugins/design/dev-server/canvas-shell.tsx

@@ -42,6 +42,7 @@ import {
   type ViewportControllerHandle,
   useViewportControllerContext,
 } from './canvas-lib.tsx';
+import { CommentsOverlay } from './comments-overlay.tsx';
 import {
   ContextMenuProvider,
   type ContextRegistry,
@@ -469,17 +470,89 @@ function CanvasRouter({
         setHoverEl(null);
       },
       onDropComment: ({ clientX, clientY }) => {
-        const target = resolveHoverTarget(document, clientX, clientY, { deep: true });
-        if (!target) return;
+        // First try deep mode — preferred when the user clicks exactly on
+        // a stamped element. When the deep hit lands on an element with
+        // `pointer-events: none` (decorative <svg> children, overlay icons),
+        // elementFromPoint propagates past it and `resolveHoverTarget`
+        // returns null because the next-closest hit is `.dc-artboard-body`
+        // itself.
+        let target = resolveHoverTarget(document, clientX, clientY, { deep: true });
+        if (!target) target = resolveHoverTarget(document, clientX, clientY, { deep: false });
+        // Phase 6 fallback — when both resolveHoverTarget passes bail (the
+        // `hit === bodyEl` early-exit triggers on `pointer-events: none`
+        // decorations), enumerate every element under the click point and
+        // climb the first one that has `data-cd-id`. This is how clicks on
+        // SVG logos / icon glyphs land on the actual stamped wrapper.
+        if (!target && typeof document.elementsFromPoint === 'function') {
+          const stack = document.elementsFromPoint(clientX, clientY);
+          for (const candidate of stack) {
+            const stamped = (candidate as Element).closest?.('[data-cd-id]') as HTMLElement | null;
+            if (!stamped) continue;
+            if (!stamped.closest('.dc-artboard-body')) continue;
+            const artboardEl = stamped.closest('[data-dc-screen]');
+            target = {
+              el: stamped,
+              cdId: stamped.getAttribute('data-cd-id'),
+              artboardId: artboardEl?.getAttribute('data-dc-screen') ?? null,
+            };
+            break;
+          }
+        }
+        if (!target) {
+          // Floating comment fallback — no element anchor, just a click
+          // point. The overlay still renders a pin at the stored bounds.
+          if (typeof window === 'undefined' || typeof document === 'undefined') return;
+          const floatingSel: Selection = {
+            file: deriveFile(),
+            id: undefined,
+            selector: '',
+            artboardId: null,
+            tag: '',
+            classes: '',
+            text: '',
+            dom_path: [],
+            bounds: { x: clientX - 12, y: clientY - 12, w: 24, h: 24 },
+            html: '',
+          };
+          try {
+            document.dispatchEvent(
+              new CustomEvent('cm:open-composer', {
+                detail: { selection: floatingSel, clientX, clientY },
+              })
+            );
+          } catch {
+            /* ignore */
+          }
+          try {
+            window.parent.postMessage({ dgn: 'comment-compose', selection: floatingSel }, '*');
+          } catch {
+            /* parent detached */
+          }
+          return;
+        }
         const sel = hoverTargetToSelection(target);
         // Commit the target to the selection set so the halo persists while
-        // the shell-side composer is open. The user clears by:
-        //   - submit / cancel on the composer (shell posts `force-clear`)
+        // the composer is open. The user clears by:
+        //   - submit / cancel on the composer (overlay dispatches force-clear)
         //   - pressing Esc inside the canvas (router's onEscape → clear)
         //   - clicking another element in comment mode (this handler runs
         //     again and replaces)
         selSet.replace(sel);
-        if (typeof window === 'undefined') return;
+        if (typeof window === 'undefined' || typeof document === 'undefined') return;
+        // Phase 6 — open the in-place composer inside the iframe at the click
+        // point. Custom event is iframe-local so the overlay can subscribe
+        // without round-tripping through the parent shell.
+        try {
+          document.dispatchEvent(
+            new CustomEvent('cm:open-composer', {
+              detail: { selection: sel, clientX, clientY },
+            })
+          );
+        } catch {
+          /* CustomEvent absent — fall through to legacy parent path */
+        }
+        // Still post to parent for back-compat with any legacy `.html` mocks
+        // whose inspector script consumes `comment-compose`.
         try {
           window.parent.postMessage({ dgn: 'comment-compose', selection: sel }, '*');
         } catch {
@@ -492,6 +565,7 @@ function CanvasRouter({
   return (
     <>
       {children}
+      <CommentsOverlay />
       <AnnotationsLayer />
       <ToolPalette />
       <HoverHalo el={hoverEl} />