egregore-artifacts 0.1.0

package/lib/markdown.js

@@ -0,0 +1,377 @@
+// Lightweight markdown → React elements converter
+// Handles: **bold**, *italic*, `code`, ### headings, [links](url), tables, lists
+import React from 'react';
+import { colors, fonts } from './tokens.js';
+
+const h = React.createElement;
+
+export function renderMarkdown(text) {
+  if (!text) return null;
+
+  const lines = text.split('\n');
+  const elements = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+
+    // Table detection — starts with |
+    if (line.trim().startsWith('|') && line.includes('|', 1)) {
+      const tableLines = [];
+      while (i < lines.length && lines[i].trim().startsWith('|')) {
+        tableLines.push(lines[i]);
+        i++;
+      }
+      elements.push(renderTable(tableLines, elements.length));
+      continue;
+    }
+
+    // H3 heading
+    if (line.startsWith('### ')) {
+      elements.push(h('h3', {
+        key: elements.length,
+        style: {
+          fontFamily: fonts.serif,
+          fontSize: '18px',
+          fontWeight: 600,
+          lineHeight: 1.3,
+          margin: '1.5rem 0 0.5rem',
+          color: colors.black,
+        },
+      }, inlineMarkdown(line.slice(4))));
+      i++;
+      continue;
+    }
+
+    // H4 heading
+    if (line.startsWith('#### ')) {
+      elements.push(h('h4', {
+        key: elements.length,
+        style: {
+          fontFamily: fonts.sans,
+          fontSize: '15px',
+          fontWeight: 600,
+          margin: '1rem 0 0.25rem',
+          color: colors.black,
+        },
+      }, inlineMarkdown(line.slice(5))));
+      i++;
+      continue;
+    }
+
+    // Unordered list item
+    if (line.match(/^[-*] /)) {
+      const listItems = [];
+      while (i < lines.length && lines[i].match(/^[-*] /)) {
+        listItems.push(lines[i].replace(/^[-*] /, ''));
+        i++;
+      }
+      elements.push(h('ul', {
+        key: elements.length,
+        style: { listStyle: 'none', padding: 0, margin: '0.5rem 0' },
+      },
+        ...listItems.map((item, j) =>
+          h('li', {
+            key: j,
+            style: {
+              position: 'relative',
+              paddingLeft: '1.25rem',
+              marginBottom: '0.35rem',
+              fontSize: '15px',
+              lineHeight: 1.55,
+              color: colors.dark,
+            },
+          },
+            h('span', {
+              style: {
+                position: 'absolute',
+                left: 0,
+                top: '9px',
+                width: '5px',
+                height: '5px',
+                borderRadius: '50%',
+                background: colors.terracotta,
+              },
+            }),
+            inlineMarkdown(item),
+          )
+        ),
+      ));
+      continue;
+    }
+
+    // Ordered list item
+    if (line.match(/^\d+\.\s/)) {
+      const listItems = [];
+      while (i < lines.length && lines[i].match(/^\d+\.\s/)) {
+        listItems.push(lines[i].replace(/^\d+\.\s*/, ''));
+        i++;
+      }
+      elements.push(h('ol', {
+        key: elements.length,
+        style: { listStyle: 'none', padding: 0, margin: '0.5rem 0', counterReset: 'step' },
+      },
+        ...listItems.map((item, j) =>
+          h('li', {
+            key: j,
+            style: {
+              display: 'flex',
+              gap: '8px',
+              marginBottom: '0.35rem',
+              fontSize: '15px',
+              lineHeight: 1.55,
+            },
+          },
+            h('span', {
+              style: {
+                flexShrink: 0,
+                width: '20px',
+                height: '20px',
+                borderRadius: '50%',
+                background: colors.terracotta,
+                color: colors.cream,
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                fontSize: '11px',
+                fontFamily: fonts.mono,
+                fontWeight: 600,
+                marginTop: '2px',
+              },
+            }, String(j + 1)),
+            h('span', null, inlineMarkdown(item)),
+          )
+        ),
+      ));
+      continue;
+    }
+
+    // Code block
+    if (line.startsWith('```')) {
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].startsWith('```')) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      i++; // skip closing ```
+      elements.push(h('pre', {
+        key: elements.length,
+        style: {
+          background: colors.terminalBg,
+          color: 'rgba(255, 255, 255, 0.85)',
+          fontFamily: fonts.mono,
+          fontSize: '13px',
+          lineHeight: 1.6,
+          padding: '1rem',
+          borderRadius: '8px',
+          overflowX: 'auto',
+          margin: '0.75rem 0',
+        },
+      }, h('code', null, codeLines.join('\n'))));
+      continue;
+    }
+
+    // Empty line — spacer
+    if (line.trim() === '') {
+      i++;
+      continue;
+    }
+
+    // Paragraph — collect consecutive non-special lines
+    const paraLines = [];
+    while (i < lines.length && lines[i].trim() !== '' &&
+           !lines[i].startsWith('#') && !lines[i].startsWith('|') &&
+           !lines[i].startsWith('```') && !lines[i].match(/^[-*] /) &&
+           !lines[i].match(/^\d+\.\s/)) {
+      paraLines.push(lines[i]);
+      i++;
+    }
+    if (paraLines.length > 0) {
+      elements.push(h('p', {
+        key: elements.length,
+        style: { margin: '0.5rem 0', fontSize: '15px', lineHeight: 1.6, color: colors.dark },
+      }, inlineMarkdown(paraLines.join(' '))));
+    }
+  }
+
+  return h('div', null, ...elements);
+}
+
+// Inline markdown: **bold**, *italic*, `code`, [link](url)
+// Finds whichever pattern appears earliest in the string
+function inlineMarkdown(text) {
+  if (!text) return text;
+
+  const parts = [];
+  let remaining = text;
+  let key = 0;
+
+  const patterns = [
+    { re: /`([^`]+)`/, render: (m) => h('code', {
+      key: key++,
+      style: { fontFamily: fonts.mono, fontSize: '0.88em', background: 'rgba(59, 45, 33, 0.06)', padding: '2px 5px', borderRadius: '3px' },
+    }, m[1]) },
+    { re: /\*\*(.+?)\*\*/, render: (m) => h('strong', { key: key++, style: { fontWeight: 600 } }, m[1]) },
+    { re: /\[([^\]]+)\]\(([^)]+)\)/, render: (m) => h('a', {
+      key: key++, href: m[2], style: { color: colors.terracotta, textDecoration: 'underline' },
+    }, m[1]) },
+  ];
+
+  let iterations = 0;
+  while (remaining.length > 0 && iterations++ < 500) {
+    // Find the earliest matching pattern
+    let earliest = null;
+    let earliestIdx = Infinity;
+
+    for (const pat of patterns) {
+      const m = remaining.match(pat.re);
+      if (m && m.index < earliestIdx) {
+        earliest = { match: m, pattern: pat };
+        earliestIdx = m.index;
+      }
+    }
+
+    if (!earliest) {
+      parts.push(h(React.Fragment, { key: key++ }, remaining));
+      break;
+    }
+
+    // Push text before the match
+    if (earliestIdx > 0) {
+      parts.push(h(React.Fragment, { key: key++ }, remaining.slice(0, earliestIdx)));
+    }
+
+    // Render the matched pattern
+    parts.push(earliest.pattern.render(earliest.match));
+
+    // Advance past the match
+    remaining = remaining.slice(earliestIdx + earliest.match[0].length);
+  }
+
+  return parts.length === 1 ? parts[0] : parts;
+}
+
+// Simple text (no nesting, just returns a fragment)
+function inlineMarkdownSimple(text, key) {
+  return h(React.Fragment, { key }, text);
+}
+
+// Render markdown table
+function renderTable(lines, key) {
+  // Parse header
+  const headerCells = parseTableRow(lines[0]);
+  // Skip separator row (|---|---|)
+  const startRow = lines[1]?.match(/^\|[\s-:|]+\|$/) ? 2 : 1;
+  const bodyRows = lines.slice(startRow).map(parseTableRow);
+
+  return h('div', {
+    key,
+    style: { overflowX: 'auto', margin: '0.75rem 0' },
+  },
+    h('table', {
+      style: {
+        width: '100%',
+        borderCollapse: 'collapse',
+        fontSize: '14px',
+        lineHeight: 1.5,
+      },
+    },
+      h('thead', null,
+        h('tr', null,
+          ...headerCells.map((cell, j) =>
+            h('th', {
+              key: j,
+              style: {
+                textAlign: 'left',
+                padding: '8px 12px',
+                borderBottom: `2px solid ${colors.border}`,
+                fontFamily: fonts.mono,
+                fontSize: '12px',
+                fontWeight: 500,
+                color: colors.muted,
+                textTransform: 'uppercase',
+                letterSpacing: '0.04em',
+                whiteSpace: 'nowrap',
+              },
+            }, cell.trim())
+          ),
+        ),
+      ),
+      h('tbody', null,
+        ...bodyRows.map((cells, i) =>
+          h('tr', { key: i },
+            ...cells.map((cell, j) =>
+              h('td', {
+                key: j,
+                style: {
+                  padding: '6px 12px',
+                  borderBottom: `1px solid rgba(224, 216, 204, 0.5)`,
+                  color: colors.dark,
+                },
+              }, cell.trim())
+            ),
+          )
+        ),
+      ),
+    ),
+  );
+}
+
+function parseTableRow(line) {
+  return line.replace(/^\|/, '').replace(/\|$/, '').split('|');
+}
+
+// Lightweight markdown renderer — tables + paragraphs only, no inline regex
+// Use for large attachments where full inlineMarkdown is too expensive
+export function renderMarkdownLite(text) {
+  if (!text) return null;
+
+  const lines = text.split('\n');
+  const elements = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+
+    // Table
+    if (line.trim().startsWith('|') && line.includes('|', 1)) {
+      const tableLines = [];
+      while (i < lines.length && lines[i].trim().startsWith('|')) {
+        tableLines.push(lines[i]);
+        i++;
+      }
+      elements.push(renderTable(tableLines, elements.length));
+      continue;
+    }
+
+    // H2/H3 heading
+    if (line.startsWith('## ')) {
+      elements.push(h('h3', { key: elements.length, style: { fontFamily: fonts.serif, fontSize: '18px', fontWeight: 600, margin: '1.5rem 0 0.5rem', color: colors.black } }, line.slice(3)));
+      i++;
+      continue;
+    }
+
+    // Bullet
+    if (line.match(/^[-*] /)) {
+      const items = [];
+      while (i < lines.length && lines[i].match(/^[-*] /)) {
+        items.push(lines[i].replace(/^[-*] /, ''));
+        i++;
+      }
+      elements.push(h('ul', { key: elements.length, style: { listStyle: 'disc', paddingLeft: '1.5rem', margin: '0.5rem 0' } },
+        ...items.map((item, j) => h('li', { key: j, style: { fontSize: '14px', lineHeight: 1.5, marginBottom: '0.25rem' } }, item)),
+      ));
+      continue;
+    }
+
+    // Empty line
+    if (line.trim() === '') { i++; continue; }
+
+    // Paragraph
+    elements.push(h('p', { key: elements.length, style: { margin: '0.5rem 0', fontSize: '14px', lineHeight: 1.6, color: colors.dark } }, line));
+    i++;
+  }
+
+  return h('div', null, ...elements);
+}

package/lib/open.js

@@ -0,0 +1,12 @@
+// Cross-platform browser opening — adapted from packages/create-egregore/lib/auth.js
+import { execFile } from 'node:child_process';
+
+export function openInBrowser(url) {
+  if (process.platform === 'darwin') {
+    execFile('open', [url], () => {});
+  } else if (process.platform === 'win32') {
+    execFile('cmd', ['/c', 'start', '', url], () => {});
+  } else {
+    execFile('xdg-open', [url], () => {});
+  }
+}

package/lib/parsers/activity.js

@@ -0,0 +1,138 @@
+// Parse activity data (JSON from bin/activity-data.sh) into structured data
+import fs from 'node:fs';
+import { execSync } from 'node:child_process';
+
+export function parseActivity(input) {
+  let data;
+
+  if (typeof input === 'string' && fs.existsSync(input)) {
+    data = JSON.parse(fs.readFileSync(input, 'utf-8'));
+  } else if (typeof input === 'string' && input.startsWith('{')) {
+    data = JSON.parse(input);
+  } else if (typeof input === 'object') {
+    data = input;
+  } else {
+    const raw = execSync('bash bin/activity-data.sh 2>/dev/null', { encoding: 'utf-8' });
+    data = JSON.parse(raw);
+  }
+
+  // data.date may be pre-formatted ("Apr 03") — normalize to YYYY-MM-DD
+  const today = new Date().toISOString().split('T')[0];
+
+  return {
+    title: `Activity Report — ${data.org || 'Egregore'}`,
+    date: today,
+    me: data.me,
+    org: data.org,
+
+    // Group my sessions: collapse untitled runs, use relative dates
+    mySessions: groupSessions(data.my_sessions || [], today),
+
+    teamSessions: (data.team_sessions || [])
+      .filter(s => s.topic) // hide unnamed sessions
+      .slice(0, 15)
+      .map(s => ({
+        date: relativeDate(s.date, today),
+        topic: s.topic,
+        by: s.by,
+      })),
+
+    quests: (data.quests || []).map(q => ({
+      name: q.title || q.quest || q.name || q.id,
+      slug: q.quest || q.slug,
+      status: q.status || 'active',
+      artifacts: q.artifacts || q.artifactCount || 0,
+      daysSince: q.daysSince || 0,
+      score: q.score || 0,
+    })),
+
+    handoffsToMe: (data.handoffs_to_me || []).map(h => ({
+      date: relativeDate(h.date, today),
+      topic: h.topic,
+      from: h.author || h.from || h.by,
+      status: h.status,
+      summary: h.summary,
+    })),
+
+    pendingQuestions: (data.pending_questions || []).map(q => ({
+      topic: q.topic,
+      from: q.from,
+      date: relativeDate(q.created?.split('T')[0], today),
+    })),
+
+    prs: (data.prs || []).map(p => ({
+      number: p.number,
+      title: p.title,
+      repo: p.repo,
+      state: p.state,
+      author: p.author,
+    })),
+
+    todos: data.todos_merged || {},
+
+    trends: data.trends || null,
+
+    knowledgeGap: data.knowledge_gap || null,
+    orphans: data.orphans || null,
+    graphStatus: data.graph_status,
+  };
+}
+
+function relativeDate(dateStr, today) {
+  if (!dateStr) return '';
+  if (dateStr === today) return 'Today';
+
+  const d = new Date(dateStr + 'T00:00:00');
+  const t = new Date(today + 'T00:00:00');
+  const diffDays = Math.round((t - d) / (1000 * 60 * 60 * 24));
+
+  if (diffDays === 1) return 'Yesterday';
+  if (diffDays < 7) return `${diffDays}d ago`;
+  if (diffDays < 30) return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+  return dateStr;
+}
+
+function groupSessions(sessions, today) {
+  const grouped = [];
+  const seen = new Set(); // deduplicate by topic+date
+  let i = 0;
+
+  while (i < sessions.length) {
+    const s = sessions[i];
+    const date = relativeDate(s.date, today);
+
+    if (s.topic) {
+      const key = `${s.date}:${s.topic}`;
+      if (seen.has(key)) {
+        // Same session handed to multiple people — merge handedTo
+        const existing = grouped.find(g => g._key === key);
+        if (existing && s.handedTo) {
+          existing.handedTo = existing.handedTo
+            ? `${existing.handedTo}, ${s.handedTo}`
+            : s.handedTo;
+        }
+        i++;
+      } else {
+        seen.add(key);
+        grouped.push({ date, topic: s.topic, handedTo: s.handedTo, _key: key });
+        i++;
+      }
+    } else {
+      // Untitled — count consecutive same-date untitled sessions
+      let count = 0;
+      const sameDate = s.date;
+      while (i < sessions.length && !sessions[i].topic && sessions[i].date === sameDate) {
+        count++;
+        i++;
+      }
+      if (count === 1) {
+        grouped.push({ date, topic: '(session)', handedTo: null });
+      } else {
+        grouped.push({ date, topic: `(${count} sessions)`, handedTo: null });
+      }
+    }
+  }
+
+  // Clean up internal keys
+  return grouped.map(({ _key, ...rest }) => rest);
+}

package/lib/parsers/handoff.js

@@ -0,0 +1,159 @@
+// Parse handoff markdown into structured data
+// Handoff format: # title, **Key**: Value metadata, ## sections
+// Detects referenced memory files and inlines their content
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+
+export function parseHandoff(input) {
+  let content;
+  let inputDir = null;
+
+  if (typeof input === 'string' && (input.endsWith('.md') || input.includes('/'))) {
+    if (!fs.existsSync(input)) throw new Error(`File not found: ${input}`);
+    content = fs.readFileSync(input, 'utf-8');
+    inputDir = path.dirname(input);
+  } else if (typeof input === 'string') {
+    content = input;
+  } else {
+    throw new Error('parseHandoff expects a file path or markdown string');
+  }
+
+  const title = extractTitle(content);
+  const meta = extractMeta(content);
+  const sections = extractSections(content);
+
+  // Detect referenced files (memory/*.md paths in backticks) and inline them
+  const attachments = extractReferencedFiles(content, inputDir);
+
+  return {
+    title,
+    ...meta,
+    summary: sections.Summary || sections.Briefing || null,
+    currentState: sections['Current State'] || null,
+    decisions: extractBullets(sections.Decisions || sections['Key Decisions'] || ''),
+    openThreads: extractThreads(sections['Open Threads'] || sections['Open Questions'] || ''),
+    nextSteps: extractOrderedList(sections['Next Steps'] || ''),
+    entryPoints: extractBullets(sections['Entry Points'] || ''),
+    context: sections.Context || null,
+    attachments,
+    // Catch-all for non-standard sections
+    extraSections: Object.entries(sections)
+      .filter(([k]) => !['Summary', 'Briefing', 'Current State', 'Decisions',
+        'Key Decisions', 'Open Threads', 'Open Questions', 'Next Steps',
+        'Entry Points', 'Context'].includes(k))
+      .filter(([, v]) => v && v.trim())
+      .map(([heading, body]) => ({ heading, body })),
+  };
+}
+
+function extractReferencedFiles(content, inputDir) {
+  const attachments = [];
+  // Find backtick-wrapped paths that look like memory files
+  const refs = content.matchAll(/`(memory\/[^`]+\.md)`/g);
+
+  // Resolve git root for file lookup
+  let gitRoot = null;
+  try {
+    gitRoot = execSync('git rev-parse --show-toplevel 2>/dev/null', { encoding: 'utf-8' }).trim();
+  } catch {}
+
+  const seen = new Set();
+  for (const ref of refs) {
+    const refPath = ref[1];
+    if (seen.has(refPath)) continue; // deduplicate
+    seen.add(refPath);
+
+    // Try to find the file
+    const candidates = [
+      inputDir && path.resolve(inputDir, '..', '..', refPath), // from handoffs/2026-XX/ up to repo root
+      gitRoot && path.join(gitRoot, refPath),
+      refPath,
+    ].filter(Boolean);
+
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) {
+        const fileContent = fs.readFileSync(candidate, 'utf-8');
+        const fileTitle = extractTitle(fileContent) || path.basename(refPath, '.md');
+        attachments.push({ title: fileTitle, path: refPath, content: fileContent });
+        break;
+      }
+    }
+  }
+
+  return attachments;
+}
+
+function extractTitle(content) {
+  const match = content.match(/^# (?:Handoff:\s*)?(.+)/m);
+  return match ? match[1].trim() : 'Untitled Handoff';
+}
+
+function extractMeta(content) {
+  const result = {};
+  const metaPatterns = [
+    [/\*\*Date\*\*:\s*(.+)/i, 'date'],
+    [/\*\*Author\*\*:\s*(.+)/i, 'author'],
+    [/\*\*To\*\*:\s*(.+)/i, 'to'],
+    [/\*\*Project\*\*:\s*(.+)/i, 'project'],
+    [/\*\*Source\*\*:\s*(.+)/i, 'source'],
+    [/\*\*Branch\*\*:\s*(.+)/i, 'branch'],
+  ];
+
+  for (const [pattern, key] of metaPatterns) {
+    const match = content.match(pattern);
+    if (match) result[key] = match[1].trim();
+  }
+
+  // Parse 'to' as array
+  if (result.to) {
+    result.to = result.to.split(/,\s*/).map(s => s.trim());
+  }
+
+  return result;
+}
+
+function extractSections(content) {
+  const sections = {};
+  // Split on ## headings, capturing the heading text
+  const parts = content.split(/^## /m).slice(1); // skip everything before first ##
+
+  for (const part of parts) {
+    const newlineIdx = part.indexOf('\n');
+    if (newlineIdx === -1) continue;
+    const heading = part.slice(0, newlineIdx).trim();
+    // Strip --- horizontal rules from body but keep all other content
+    const body = part.slice(newlineIdx + 1).replace(/^---\s*$/gm, '').trim();
+    if (heading && body) {
+      sections[heading] = body;
+    }
+  }
+
+  return sections;
+}
+
+function extractBullets(text) {
+  if (!text) return [];
+  return text.split('\n')
+    .filter(l => l.match(/^[-*] /))
+    .map(l => l.replace(/^[-*] /, '').trim())
+    .filter(Boolean);
+}
+
+function extractThreads(text) {
+  if (!text) return [];
+  return text.split('\n')
+    .filter(l => l.match(/^- \[[ x]\]/))
+    .map(l => ({
+      done: l.includes('[x]'),
+      text: l.replace(/^- \[[ x]\]\s*/, '').trim(),
+    }));
+}
+
+function extractOrderedList(text) {
+  if (!text) return [];
+  return text.split('\n')
+    .filter(l => l.match(/^\d+\.\s/))
+    .map(l => l.replace(/^\d+\.\s*/, '').trim())
+    .filter(Boolean);
+}