@1agh/maude 0.30.0 → 0.31.0

package/apps/studio/client/panels/chat-markdown.jsx

@@ -0,0 +1,138 @@
+// Compact, XSS-safe markdown renderer for the ACP chat feed. Builds React nodes
+// directly (never innerHTML) so agent output can't inject markup. Covers the
+// subset a coding agent actually emits: fenced code blocks, headings, bullet +
+// numbered lists, bold / italic / inline code, and http(s) links. Anything else
+// falls through as plain (pre-wrapped) text. No new dependency.
+
+function safeHref(url) {
+  // Only allow http(s) — never javascript:/data:/etc.
+  return /^https?:\/\//i.test(url) ? url : null;
+}
+
+// Inline tokenizer: `code`, **bold**, *italic*, [text](url).
+const INLINE_RE = /(`[^`]+`)|(\*\*[^*]+\*\*)|(\*[^*\n]+\*)|(\[[^\]]+\]\([^)\s]+\))/g;
+
+function inline(text) {
+  const out = [];
+  let last = 0;
+  let key = 0;
+  let m;
+  INLINE_RE.lastIndex = 0;
+  // biome-ignore lint/suspicious/noAssignInExpressions: standard regex exec loop
+  while ((m = INLINE_RE.exec(text)) !== null) {
+    if (m.index > last) out.push(text.slice(last, m.index));
+    const tok = m[0];
+    if (tok.startsWith('`')) {
+      out.push(<code key={key++}>{tok.slice(1, -1)}</code>);
+    } else if (tok.startsWith('**')) {
+      out.push(<strong key={key++}>{tok.slice(2, -2)}</strong>);
+    } else if (tok.startsWith('*')) {
+      out.push(<em key={key++}>{tok.slice(1, -1)}</em>);
+    } else {
+      const link = /\[([^\]]+)\]\(([^)\s]+)\)/.exec(tok);
+      const href = link && safeHref(link[2]);
+      out.push(
+        href ? (
+          <a key={key++} href={href} target="_blank" rel="noreferrer noopener">
+            {link[1]}
+          </a>
+        ) : (
+          link ? link[1] : tok
+        )
+      );
+    }
+    last = m.index + tok.length;
+  }
+  if (last < text.length) out.push(text.slice(last));
+  return out;
+}
+
+export function Markdown({ text }) {
+  const lines = String(text).split('\n');
+  const blocks = [];
+  let i = 0;
+  let key = 0;
+
+  const isList = (l) => /^\s*[-*]\s/.test(l) || /^\s*\d+\.\s/.test(l);
+
+  while (i < lines.length) {
+    const line = lines[i];
+
+    // Fenced code block.
+    if (line.trimStart().startsWith('```')) {
+      const buf = [];
+      i++;
+      while (i < lines.length && !lines[i].trimStart().startsWith('```')) {
+        buf.push(lines[i]);
+        i++;
+      }
+      i++; // closing fence
+      blocks.push(
+        <pre key={key++} className="chat-code">
+          <code>{buf.join('\n')}</code>
+        </pre>
+      );
+      continue;
+    }
+
+    // Heading → a styled paragraph (chat doesn't want giant h1s).
+    if (/^#{1,6}\s/.test(line)) {
+      blocks.push(
+        <p key={key++} className="chat-md-h">
+          {inline(line.replace(/^#{1,6}\s/, ''))}
+        </p>
+      );
+      i++;
+      continue;
+    }
+
+    // List (consecutive list lines).
+    if (isList(line)) {
+      const ordered = /^\s*\d+\.\s/.test(line);
+      const items = [];
+      while (i < lines.length && isList(lines[i])) {
+        items.push(<li key={items.length}>{inline(lines[i].replace(/^\s*(?:[-*]|\d+\.)\s/, ''))}</li>);
+        i++;
+      }
+      blocks.push(
+        ordered ? (
+          <ol key={key++} className="chat-md-list">
+            {items}
+          </ol>
+        ) : (
+          <ul key={key++} className="chat-md-list">
+            {items}
+          </ul>
+        )
+      );
+      continue;
+    }
+
+    // Blank line → paragraph separator.
+    if (line.trim() === '') {
+      i++;
+      continue;
+    }
+
+    // Paragraph: gather consecutive non-special lines.
+    const buf = [line];
+    i++;
+    while (
+      i < lines.length &&
+      lines[i].trim() !== '' &&
+      !lines[i].trimStart().startsWith('```') &&
+      !/^#{1,6}\s/.test(lines[i]) &&
+      !isList(lines[i])
+    ) {
+      buf.push(lines[i]);
+      i++;
+    }
+    blocks.push(
+      <p key={key++} className="chat-md-p">
+        {inline(buf.join('\n'))}
+      </p>
+    );
+  }
+
+  return <>{blocks}</>;
+}

package/apps/studio/client/panels/git-grouping.js

@@ -0,0 +1,86 @@
+// Pure grouping helpers for the Changes panel (GitPanel.jsx) — framework-free so
+// they unit-test without a DOM. DDR-115 follow-up: group changed files by parent
+// canvas + its supporting sidecars (same-stem `.meta.json`, slug-matched
+// `.annotations.svg`), mirroring the server's `expandSidecars` notion of "travels
+// with the canvas" so the visual grouping is honest with what a unit commits.
+
+export const CANVAS_RE = /\.(tsx|html)$/i;
+export const META_RE = /\.meta\.json$/i;
+export const ANNOT_RE = /\.annotations\.svg$/i;
+
+/** Display name for a file (last path segment, sidecar/canvas extension stripped). */
+export function baseName(p) {
+  const s = (String(p).split('/').pop() || String(p)).replace(ANNOT_RE, '').replace(META_RE, '');
+  return s.replace(/\.(tsx|html|css|svg|json)$/i, '');
+}
+
+/** Friendly label for a collapsed supporting file under a canvas. */
+export function supportLabel(p) {
+  if (META_RE.test(p)) return 'Layout & settings';
+  if (ANNOT_RE.test(p)) return 'Annotations';
+  return baseName(p);
+}
+
+export function stripDesignRel(p, designRel) {
+  const s = String(p).replace(/^\/+|\/+$/g, '');
+  const prefix = `${(designRel || '.design').replace(/^\/+|\/+$/g, '')}/`;
+  return s.startsWith(prefix) ? s.slice(prefix.length) : s;
+}
+
+/** Mirror api.ts `fileSlug`: repo-relative canvas path → annotation slug, so the
+ *  slug-named `<slug>.annotations.svg` (which is NOT a same-stem sibling) can be
+ *  attached to its parent canvas. */
+export function canvasSlug(p, designRel) {
+  return stripDesignRel(p, designRel)
+    .replace(/\//g, '-')
+    .replace(/\s+/g, '_')
+    .replace(CANVAS_RE, '')
+    .replace(/^\.+/, '')
+    .toLowerCase();
+}
+
+/**
+ * Group changed files into canvas "units" — a parent canvas + its supporting
+ * sidecars. Files with no parent canvas in the changeset become standalone
+ * "other" units (config, DS tokens, an orphan sidecar).
+ *
+ * @param {{path: string, status: string}[]} files
+ * @param {string} designRel
+ * @returns {{ canvasUnits: Unit[], otherUnits: Unit[] }}
+ *   where Unit = { key, kind: 'canvas'|'other', primary, supporting: file[] }
+ */
+export function buildUnits(files, designRel) {
+  const canvases = files.filter((f) => CANVAS_RE.test(f.path));
+  const canvasByBase = new Map(); // base path (no ext) → canvas file
+  const canvasBySlug = new Map(); // annotation slug → canvas file
+  for (const c of canvases) {
+    canvasByBase.set(c.path.replace(CANVAS_RE, ''), c);
+    canvasBySlug.set(canvasSlug(c.path, designRel), c);
+  }
+  const supporting = new Map(); // canvas.path → sidecar[]
+  const consumed = new Set(); // sidecar paths attached to a canvas
+  const attach = (canvas, f) => {
+    const arr = supporting.get(canvas.path);
+    if (arr) arr.push(f);
+    else supporting.set(canvas.path, [f]);
+    consumed.add(f.path);
+  };
+  for (const f of files) {
+    if (META_RE.test(f.path)) {
+      const c = canvasByBase.get(f.path.replace(META_RE, ''));
+      if (c) attach(c, f);
+    } else if (ANNOT_RE.test(f.path)) {
+      const c = canvasBySlug.get(stripDesignRel(f.path, designRel).replace(ANNOT_RE, '').toLowerCase());
+      if (c) attach(c, f);
+    }
+  }
+  const byName = (a, b) => baseName(a.primary.path).localeCompare(baseName(b.primary.path));
+  const canvasUnits = canvases
+    .map((c) => ({ key: c.path, kind: 'canvas', primary: c, supporting: supporting.get(c.path) ?? [] }))
+    .sort(byName);
+  const otherUnits = files
+    .filter((f) => !CANVAS_RE.test(f.path) && !consumed.has(f.path))
+    .map((f) => ({ key: f.path, kind: 'other', primary: f, supporting: [] }))
+    .sort(byName);
+  return { canvasUnits, otherUnits };
+}

package/apps/studio/client/styles/0-reset.css

@@ -11,6 +11,10 @@ html, body {
   line-height: 1.45;
   -webkit-font-smoothing: antialiased;
   -moz-osx-font-smoothing: grayscale;
+  /* WebKit (Safari + WKWebView) text inflation can re-grow text that the canvas
+     scales down during zoom-out, undoing the shrink. Pin it off. No-op on Blink. */
+  -webkit-text-size-adjust: 100%;
+  text-size-adjust: 100%;
 }
 
 button { font: inherit; }