@mindstudio-ai/remy 0.1.34 → 0.1.35

package/dist/subagents/designExpert/data/sources/dev/serve.mjs

@@ -0,0 +1,244 @@
+/**
+ * Lightweight dev server for visualizing and managing design expert data.
+ *
+ * Zero dependencies — uses Node's built-in http module.
+ * Reads/writes fonts.json and inspiration.json in the parent directory.
+ *
+ * Usage: node src/subagents/designExpert/data/dev/serve.mjs
+ */
+
+import { createServer } from 'node:http';
+import { readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const dataDir = join(__dirname, '..');
+const fontsPath = join(dataDir, 'fonts.json');
+const inspirationPath = join(dataDir, 'inspiration.json');
+
+// ---------------------------------------------------------------------------
+// JSON helpers
+// ---------------------------------------------------------------------------
+
+function readJson(path) {
+  return JSON.parse(readFileSync(path, 'utf-8'));
+}
+
+function writeJson(path, data) {
+  const tmp = path + '.tmp';
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
+  renameSync(tmp, path);
+}
+
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', (chunk) => (body += chunk));
+    req.on('end', () => {
+      try {
+        resolve(JSON.parse(body));
+      } catch {
+        reject(new Error('Invalid JSON'));
+      }
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Route helpers
+// ---------------------------------------------------------------------------
+
+function json(res, data, status = 200) {
+  res.writeHead(status, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(data));
+}
+
+function notFound(res) {
+  res.writeHead(404);
+  res.end('Not found');
+}
+
+function error(res, msg, status = 400) {
+  json(res, { error: msg }, status);
+}
+
+// ---------------------------------------------------------------------------
+// Server
+// ---------------------------------------------------------------------------
+
+const server = createServer(async (req, res) => {
+  const url = new URL(req.url, `http://${req.headers.host}`);
+  const path = url.pathname;
+  const method = req.method;
+
+  // CORS for dev
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+  if (method === 'OPTIONS') {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  try {
+    // Serve HTML
+    if (path === '/' && method === 'GET') {
+      const html = readFileSync(join(__dirname, 'index.html'), 'utf-8');
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(html);
+      return;
+    }
+
+    if (path === '/specimens/fonts' && method === 'GET') {
+      const html = readFileSync(join(__dirname, 'specimens-fonts.html'), 'utf-8');
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(html);
+      return;
+    }
+
+    if (path === '/specimens/pairings' && method === 'GET') {
+      const html = readFileSync(join(__dirname, 'specimens-pairings.html'), 'utf-8');
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(html);
+      return;
+    }
+
+    // --- Fonts API ---
+
+    if (path === '/api/fonts' && method === 'GET') {
+      return json(res, readJson(fontsPath));
+    }
+
+    if (path === '/api/fonts' && method === 'POST') {
+      const font = await parseBody(req);
+      const data = readJson(fontsPath);
+      if (data.fonts.some((f) => f.slug === font.slug)) {
+        return error(res, `Font with slug "${font.slug}" already exists`);
+      }
+      data.fonts.push(font);
+      writeJson(fontsPath, data);
+      return json(res, { ok: true, count: data.fonts.length }, 201);
+    }
+
+    const fontDeleteMatch = path.match(/^\/api\/fonts\/(.+)$/);
+    if (fontDeleteMatch && method === 'DELETE') {
+      const slug = decodeURIComponent(fontDeleteMatch[1]);
+      const data = readJson(fontsPath);
+      const before = data.fonts.length;
+      data.fonts = data.fonts.filter((f) => f.slug !== slug);
+      // Also remove pairings that reference this font
+      data.pairings = data.pairings.filter(
+        (p) => p.heading.slug !== slug && p.body.slug !== slug,
+      );
+      if (data.fonts.length === before) {
+        return error(res, `Font "${slug}" not found`, 404);
+      }
+      writeJson(fontsPath, data);
+      return json(res, { ok: true, count: data.fonts.length });
+    }
+
+    // --- Pairings API ---
+
+    if (path === '/api/pairings' && method === 'POST') {
+      const pairing = await parseBody(req);
+      const data = readJson(fontsPath);
+      data.pairings.push(pairing);
+      writeJson(fontsPath, data);
+      return json(res, { ok: true, count: data.pairings.length }, 201);
+    }
+
+    const pairingDeleteMatch = path.match(/^\/api\/pairings\/(\d+)$/);
+    if (pairingDeleteMatch && method === 'DELETE') {
+      const index = parseInt(pairingDeleteMatch[1], 10);
+      const data = readJson(fontsPath);
+      if (index < 0 || index >= data.pairings.length) {
+        return error(res, 'Pairing index out of range', 404);
+      }
+      data.pairings.splice(index, 1);
+      writeJson(fontsPath, data);
+      return json(res, { ok: true, count: data.pairings.length });
+    }
+
+    // --- Inspiration API ---
+
+    if (path === '/api/inspiration' && method === 'GET') {
+      return json(res, readJson(inspirationPath));
+    }
+
+    if (path === '/api/inspiration' && method === 'POST') {
+      const entry = await parseBody(req);
+      const data = readJson(inspirationPath);
+      data.images.push(entry);
+      writeJson(inspirationPath, data);
+      return json(res, { ok: true, count: data.images.length }, 201);
+    }
+
+    const inspirationDeleteMatch = path.match(/^\/api\/inspiration\/(\d+)$/);
+    if (inspirationDeleteMatch && method === 'DELETE') {
+      const index = parseInt(inspirationDeleteMatch[1], 10);
+      const data = readJson(inspirationPath);
+      if (index < 0 || index >= data.images.length) {
+        return error(res, 'Image index out of range', 404);
+      }
+      data.images.splice(index, 1);
+      writeJson(inspirationPath, data);
+      return json(res, { ok: true, count: data.images.length });
+    }
+
+    if (path === '/api/inspiration/analyze' && method === 'POST') {
+      const { url } = await parseBody(req);
+      if (!url) return error(res, 'url is required');
+
+      const promptFile = join(dataDir, '..', 'prompts', 'tool-prompts', 'design-analysis.md');
+      const prompt = readFileSync(promptFile, 'utf-8').trim();
+
+      try {
+        const result = execSync(
+          `mindstudio analyze-image --prompt ${JSON.stringify(prompt)} --image-url ${JSON.stringify(url)} --output-key analysis --no-meta`,
+          { encoding: 'utf-8', timeout: 120000 },
+        ).trim();
+        return json(res, { url, analysis: result });
+      } catch (err) {
+        return error(res, `Analysis failed: ${err.message}`, 500);
+      }
+    }
+
+    if (path === '/api/inspiration/dedup' && method === 'POST') {
+      const data = readJson(inspirationPath);
+      const seen = new Set();
+      const deduped = [];
+      for (const img of data.images) {
+        if (!seen.has(img.url)) {
+          seen.add(img.url);
+          deduped.push(img);
+        }
+      }
+      const removed = data.images.length - deduped.length;
+      data.images = deduped;
+      writeJson(inspirationPath, data);
+      return json(res, { ok: true, removed, count: deduped.length });
+    }
+
+    notFound(res);
+  } catch (err) {
+    error(res, err.message, 500);
+  }
+});
+
+const PORT = parseInt(process.env.PORT || '3333', 10);
+server.listen(PORT, () => {
+  console.log(`Design data dev tool: http://localhost:${PORT}`);
+  // Try to open in browser
+  try {
+    const cmd =
+      process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+          ? 'start'
+          : 'xdg-open';
+    execSync(`${cmd} http://localhost:${PORT}`, { stdio: 'ignore' });
+  } catch {}
+});

package/dist/subagents/designExpert/data/sources/dev/specimens-fonts.html

@@ -0,0 +1,126 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=1440" />
+<title>Font Specimens</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+    background: #fff;
+    color: #000;
+    width: 1440px;
+  }
+  .row {
+    height: 200px;
+    width: 1440px;
+    border-bottom: 1px solid #ddd;
+    padding: 24px 40px;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    overflow: hidden;
+  }
+  .name {
+    font-size: 12px;
+    font-weight: 600;
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+    color: #999;
+    margin-bottom: 12px;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+  .preview-large {
+    font-size: 42px;
+    line-height: 1.1;
+    margin-bottom: 8px;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+  .preview-medium {
+    font-size: 24px;
+    line-height: 1.3;
+    color: #333;
+    margin-bottom: 8px;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+  .preview-small {
+    font-size: 15px;
+    line-height: 1.5;
+    color: #666;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+</style>
+</head>
+<body>
+<script>
+const CSS_URL_PATTERN = 'https://api.fontshare.com/v2/css?f[]={slug}@{weights}&display=swap';
+
+function loadFont(font) {
+  let cssUrl;
+  if (font.source === 'fontshare') {
+    cssUrl = CSS_URL_PATTERN
+      .replace('{slug}', font.slug)
+      .replace('{weights}', font.weights.join(','));
+  } else if (font.cssUrl) {
+    cssUrl = font.cssUrl;
+  } else {
+    return;
+  }
+  const link = document.createElement('link');
+  link.rel = 'stylesheet';
+  link.href = cssUrl;
+  document.head.appendChild(link);
+}
+
+async function init() {
+  const params = new URLSearchParams(window.location.search);
+  const page = parseInt(params.get('page') || '1', 10);
+  const perPage = 40;
+
+  const res = await fetch('/api/fonts');
+  const data = await res.json();
+  const allFonts = [...data.fonts].sort((a, b) => a.name.localeCompare(b.name));
+  const totalPages = Math.ceil(allFonts.length / perPage);
+  const fonts = allFonts.slice((page - 1) * perPage, page * perPage);
+
+  document.title = `Font Specimens — Page ${page}/${totalPages}`;
+
+  fonts.forEach(f => loadFont(f));
+
+  // Wait for fonts to load
+  await new Promise(r => setTimeout(r, 3000));
+
+  fonts.forEach(font => {
+    const midWeight = font.weights[Math.floor(font.weights.length / 2)] || 400;
+    const lightWeight = font.weights[0] || 400;
+    const heavyWeight = font.weights[font.weights.length - 1] || 400;
+
+    const row = document.createElement('div');
+    row.className = 'row';
+    row.innerHTML = `
+      <div class="name">${font.name} &middot; ${font.category} &middot; ${font.source}</div>
+      <div class="preview-large" style="font-family: '${font.name}'; font-weight: ${heavyWeight}">
+        The quick brown fox jumps over the lazy dog
+      </div>
+      <div class="preview-medium" style="font-family: '${font.name}'; font-weight: ${midWeight}">
+        Pack my box with five dozen liquor jugs &mdash; 0123456789
+      </div>
+      <div class="preview-small" style="font-family: '${font.name}'; font-weight: ${lightWeight}">
+        A wizard's job is to vex chumps quickly in fog. The five boxing wizards jump quickly. How vexingly quick daft zebras jump!
+      </div>
+    `;
+    document.body.appendChild(row);
+  });
+}
+
+init();
+</script>
+</body>
+</html>

package/dist/subagents/designExpert/data/sources/dev/specimens-pairings.html

@@ -0,0 +1,114 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=1440" />
+<title>Pairing Specimens</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+    background: #fff;
+    color: #000;
+    width: 1440px;
+  }
+  .row {
+    height: 240px;
+    width: 1440px;
+    border-bottom: 1px solid #ddd;
+    padding: 24px 40px;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    overflow: hidden;
+  }
+  .meta {
+    font-size: 12px;
+    font-weight: 600;
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+    color: #999;
+    margin-bottom: 16px;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+  .heading {
+    font-size: 48px;
+    line-height: 1.1;
+    margin-bottom: 12px;
+  }
+  .body {
+    font-size: 17px;
+    line-height: 1.6;
+    color: #444;
+    max-width: 800px;
+  }
+</style>
+</head>
+<body>
+<script>
+const CSS_URL_PATTERN = 'https://api.fontshare.com/v2/css?f[]={slug}@{weights}&display=swap';
+const loaded = new Set();
+
+function loadFontBySlug(slug, fonts) {
+  if (loaded.has(slug)) return;
+  loaded.add(slug);
+  const font = fonts.find(f => f.slug === slug);
+  if (!font) return;
+  let cssUrl;
+  if (font.source === 'fontshare') {
+    cssUrl = CSS_URL_PATTERN
+      .replace('{slug}', font.slug)
+      .replace('{weights}', font.weights.join(','));
+  } else if (font.cssUrl) {
+    cssUrl = font.cssUrl;
+  } else {
+    return;
+  }
+  const link = document.createElement('link');
+  link.rel = 'stylesheet';
+  link.href = cssUrl;
+  document.head.appendChild(link);
+}
+
+async function init() {
+  const params = new URLSearchParams(window.location.search);
+  const page = parseInt(params.get('page') || '1', 10);
+  const perPage = 33;
+
+  const res = await fetch('/api/fonts');
+  const data = await res.json();
+  const fonts = data.fonts;
+  const allPairings = data.pairings;
+  const totalPages = Math.ceil(allPairings.length / perPage);
+  const pairings = allPairings.slice((page - 1) * perPage, page * perPage);
+
+  document.title = `Pairing Specimens — Page ${page}/${totalPages}`;
+
+  pairings.forEach(p => {
+    loadFontBySlug(p.heading.slug, fonts);
+    loadFontBySlug(p.body.slug, fonts);
+  });
+
+  // Wait for fonts to load
+  await new Promise(r => setTimeout(r, 3000));
+
+  pairings.forEach(p => {
+    const row = document.createElement('div');
+    row.className = 'row';
+    row.innerHTML = `
+      <div class="meta">${p.heading.font} (${p.heading.weight}) + ${p.body.font} (${p.body.weight})</div>
+      <div class="heading" style="font-family: '${p.heading.font}'; font-weight: ${p.heading.weight}">
+        The quick brown fox jumps over the lazy dog
+      </div>
+      <div class="body" style="font-family: '${p.body.font}'; font-weight: ${p.body.weight}">
+        Good design is as little design as possible. Less, but better — because it concentrates on the essential aspects, and the products are not burdened with non-essentials. Back to purity, back to simplicity.
+      </div>
+    `;
+    document.body.appendChild(row);
+  });
+}
+
+init();
+</script>
+</body>
+</html>

package/dist/subagents/designExpert/data/{fonts.json → sources/fonts.json}

@@ -497,41 +497,6 @@
       "source": "fontshare",
       "description": "This sans-serif displays monolinear stroke weight with no stress angle and a geometric construction evident in the circular bowls of letters like 'o' and 'd'. The typeface features a high x-height relative to cap height, regular width proportions, and moderately open apertures in characters such as 'c', 'e', and 'a'. Terminals are primarily flat-cut, the 'g' uses a double-story form, and the overall structure shows rationalized geometric forms with subtle optical corrections rather than pure geometric circles."
     },
-    {
-      "name": "Outfit",
-      "slug": "outfit",
-      "category": "Sans",
-      "variable": true,
-      "weights": [
-        100,
-        200,
-        300,
-        400,
-        500,
-        600,
-        700,
-        800,
-        900
-      ],
-      "italics": false,
-      "source": "fontshare",
-      "description": "This grotesque sans-serif displays monolinear stroke weight with no stress angle and flat-cut terminals throughout. The typeface features a high x-height relative to cap height, regular width proportions, and moderately open apertures in letters like 'e' and 'a'. Notable characteristics include a single-story 'a', geometric construction with slightly squared curves, and consistent stroke endings that create a sturdy, utilitarian appearance."
-    },
-    {
-      "name": "Lora",
-      "slug": "lora",
-      "category": "Serif",
-      "variable": true,
-      "weights": [
-        400,
-        500,
-        600,
-        700
-      ],
-      "italics": true,
-      "source": "fontshare",
-      "description": "This serif typeface exhibits moderate stroke contrast with a vertical stress and features thick, unbracketed slab serifs with squared terminals. The construction shows a high x-height relative to cap height, regular width proportions, and moderately open apertures in letters like 'e' and 'a'. Notable characteristics include a double-story 'g', robust slab terminals on ascenders and descenders, and a rational, geometric construction typical of Egyptian or Clarendon-style serifs."
-    },
     {
       "name": "Plus Jakarta Sans",
       "slug": "plus-jakarta-sans",
@@ -841,22 +806,6 @@
       "source": "fontshare",
       "description": "This sans-serif typeface exhibits monolinear stroke weight with no stress angle and a geometric construction characterized by circular bowls and consistent proportions. The apertures are moderately open in letters like 'c' and 'e', while terminals are flat-cut and perpendicular to stroke direction. The x-height is relatively high compared to the cap height, and the overall width is regular with a double-story 'g' and single-story 'a', typical of geometric sans-serifs with rationalized, optically-corrected forms."
     },
-    {
-      "name": "Space Grotesk",
-      "slug": "space-grotesk",
-      "category": "Sans",
-      "variable": true,
-      "weights": [
-        300,
-        400,
-        500,
-        600,
-        700
-      ],
-      "italics": false,
-      "source": "fontshare",
-      "description": "This grotesque sans-serif displays monolinear stroke weight with no stress angle and flat-cut terminals throughout. The typeface features a high x-height relative to cap height, moderate to open apertures in letters like 'c', 'e', and 'a', and regular width proportions. Notable glyphs include a single-story 'a' and 'g', with the construction showing rationalized, geometric tendencies typical of neo-grotesque design, particularly visible in the circular bowls and optically-corrected curves."
-    },
     {
       "name": "Pramukh Rounded",
       "slug": "pramukh-rounded",
@@ -1344,28 +1293,6 @@
       "cssUrl": "https://fonts.cdnfonts.com/css/reglo",
       "description": "This sans-serif typeface exhibits monolinear stroke weight with no stress angle and flat-cut terminals throughout. The letterforms display a condensed width with a high x-height relative to the cap height, and apertures in c, e, and s are moderately closed. The construction is grotesque with distinctive features including a single-story 'a', closed aperture in the 'g', and compact proportions that emphasize vertical compression over horizontal space."
     },
-    {
-      "name": "Poppins",
-      "slug": "poppins",
-      "category": "Sans",
-      "source": "google-fonts",
-      "googleFontsFamily": "Poppins",
-      "weights": [
-        100,
-        200,
-        300,
-        400,
-        500,
-        600,
-        700,
-        800,
-        900
-      ],
-      "italics": true,
-      "cssUrl": "https://fonts.googleapis.com/css2?family=Poppins:wght@100;200;300;400;500;600;700;800;900&display=swap",
-      "variable": true,
-      "description": "This sans-serif typeface exhibits monolinear stroke weight with no stress angle and a geometric construction characterized by circular bowls and optically-corrected curves. The letterforms feature closed apertures in characters like 'e' and 'a', with a single-story 'a' and 'g', and terminals are flat-cut perpendicular to stroke direction. The x-height is high relative to cap height, proportions are regular width, and distinctive features include perfectly circular dots on 'i' and 'j', and uniform stroke terminals throughout."
-    },
     {
       "name": "Oswald",
       "slug": "oswald",
@@ -1915,18 +1842,6 @@
         "weight": 400
       }
     },
-    {
-      "heading": {
-        "font": "Melodrama",
-        "slug": "melodrama",
-        "weight": 500
-      },
-      "body": {
-        "font": "Nunito",
-        "slug": "nunito",
-        "weight": 400
-      }
-    },
     {
       "heading": {
         "font": "Tanker",
@@ -2419,18 +2334,6 @@
         "weight": 400
       }
     },
-    {
-      "heading": {
-        "font": "Syne",
-        "slug": "syne",
-        "weight": 700
-      },
-      "body": {
-        "font": "Plus Jakarta Sans",
-        "slug": "plus-jakarta-sans",
-        "weight": 400
-      }
-    },
     {
       "heading": {
         "font": "Libre Baskerville",