egregore-artifacts 0.1.0 → 0.3.0

package/bin/cli.js

@@ -4,25 +4,61 @@ import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 
-const [,, type, filePath] = process.argv;
+const KNOWN_TYPES = ['quest', 'handoff', 'activity', 'document', 'board', 'network'];
+const args = process.argv.slice(2);
 
-if (!type) {
+let type, filePath;
+
+if (args.length === 0) {
   console.error('Usage: egregore-artifacts <type> [file]');
+  console.error('       egregore-artifacts <file.md>        (auto-detects type)');
   console.error('');
-  console.error('Types: quest, handoff, activity');
+  console.error('Types: quest, handoff, activity, document');
   console.error('');
   console.error('Examples:');
   console.error('  egregore-artifacts quest memory/quests/artifact-generation.md');
   console.error('  egregore-artifacts handoff memory/handoffs/2026-03/31-cem-oss-security-audit.md');
-  console.error('  egregore-artifacts activity   (runs bin/activity-data.sh live)');
+  console.error('  egregore-artifacts activity');
+  console.error('  egregore-artifacts memory/knowledge/decisions/some-decision.md');
   process.exit(1);
 }
 
-if (!filePath && type !== 'activity') {
+// Parse flags
+let outputFile = null;
+let noOpen = false;
+const positional = [];
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--output' || args[i] === '-o') {
+    outputFile = args[++i];
+  } else if (args[i] === '--no-open') {
+    noOpen = true;
+  } else {
+    positional.push(args[i]);
+  }
+}
+
+// If first positional is a known type, use it. Otherwise treat it as a file path.
+if (KNOWN_TYPES.includes(positional[0])) {
+  type = positional[0];
+  filePath = positional[1];
+} else {
+  // Auto-detect: first arg is a file path
+  filePath = positional[0];
+  type = inferType(filePath);
+}
+
+if (!filePath && type !== 'activity' && type !== 'board' && type !== 'network') {
   console.error(`✗ Missing file path for type "${type}"`);
   process.exit(1);
 }
 
+function inferType(fp) {
+  if (!fp) return 'document';
+  if (fp.includes('/quests/')) return 'quest';
+  if (fp.includes('/handoffs/')) return 'handoff';
+  return 'document';
+}
+
 // Resolve file path relative to git repo root (not cwd)
 function resolveFile(fp) {
   if (!fp) return fp;
@@ -46,12 +82,28 @@ function resolveFile(fp) {
 }
 
 try {
-  const input = type === 'activity' ? (filePath || 'live') : resolveFile(filePath);
+  const input = (type === 'activity' || type === 'board' || type === 'network') ? (filePath || 'live') : resolveFile(filePath);
   const html = await generateArtifact(type, input);
   const slug = filePath ? filePath.split('/').pop().replace('.md', '') : new Date().toISOString().split('T')[0];
-  const outputPath = await openArtifact(html, `${type}-${slug}`);
-  console.log(`✓ Artifact generated: ${outputPath}`);
-  console.log('  Opening in browser...');
+
+  if (outputFile) {
+    // Write to specific file, don't open browser
+    fs.mkdirSync(path.dirname(path.resolve(outputFile)), { recursive: true });
+    fs.writeFileSync(outputFile, html);
+    console.log(`✓ Artifact written: ${outputFile}`);
+  } else if (noOpen) {
+    // Write to tmp, don't open browser (for piping/automation)
+    const os = await import('node:os');
+    const tmpDir = path.join(os.default.tmpdir(), 'egregore-artifacts');
+    fs.mkdirSync(tmpDir, { recursive: true });
+    const outPath = path.join(tmpDir, `${type}-${slug}-${Date.now()}.html`);
+    fs.writeFileSync(outPath, html);
+    console.log(outPath);
+  } else {
+    const outputPath = await openArtifact(html, `${type}-${slug}`);
+    console.log(`✓ Artifact generated: ${outputPath}`);
+    console.log('  Opening in browser...');
+  }
 } catch (err) {
   console.error(`✗ ${err.message}`);
   process.exit(1);

package/lib/components.js

@@ -74,7 +74,7 @@ export function ArtifactList({ artifacts }) {
         h('span', { className: 'eg-artifact-date' }, a.date),
         h('span', { className: 'eg-artifact-type' }, a.type),
         h('span', { className: 'eg-artifact-title' }, a.title),
-        a.author && h('span', { style: { color: colors.muted, fontSize: '13px', fontFamily: fonts.mono } }, `(${a.author})`),
+        a.author && h('span', { style: { color: 'var(--muted)', fontSize: '13px', fontFamily: fonts.mono } }, `(${a.author})`),
       )
     ),
   );
@@ -92,7 +92,7 @@ export function ContributorRow({ contributors }) {
           (c.name || '?')[0].toUpperCase()
         ),
         h('span', null, c.name),
-        c.role && h('span', { style: { color: colors.muted, fontSize: '12px' } }, c.role),
+        c.role && h('span', { style: { color: 'var(--muted)', fontSize: '12px' } }, c.role),
       )
     ),
   );

package/lib/index.js

@@ -6,13 +6,19 @@ import { renderToHtml, renderSpecToHtml } from './render.js';
 import { parseQuest } from './parsers/quest.js';
 import { parseHandoff } from './parsers/handoff.js';
 import { parseActivity } from './parsers/activity.js';
+import { parseDocument } from './parsers/document.js';
+import { parseBoard } from './parsers/board.js';
+import { parseNetwork } from './parsers/network.js';
 import { questTemplate } from './templates/quest.js';
 import { handoffTemplate } from './templates/handoff.js';
 import { activityTemplate } from './templates/activity.js';
+import { documentTemplate } from './templates/document.js';
+import { boardTemplate } from './templates/board.js';
+import { networkTemplate } from './templates/network.js';
 import { openInBrowser } from './open.js';
 
-const PARSERS = { quest: parseQuest, handoff: parseHandoff, activity: parseActivity };
-const TEMPLATES = { quest: questTemplate, handoff: handoffTemplate, activity: activityTemplate };
+const PARSERS = { quest: parseQuest, handoff: parseHandoff, activity: parseActivity, document: parseDocument, board: parseBoard, network: parseNetwork };
+const TEMPLATES = { quest: questTemplate, handoff: handoffTemplate, activity: activityTemplate, document: documentTemplate, board: boardTemplate, network: networkTemplate };
 
 export async function generateArtifact(type, input) {
   const template = TEMPLATES[type];
@@ -45,6 +51,7 @@ export async function openArtifact(html, title = 'Egregore Artifact') {
 
 export { parseQuest } from './parsers/quest.js';
 export { parseHandoff } from './parsers/handoff.js';
+export { parseDocument } from './parsers/document.js';
 export { renderSpecToHtml } from './render.js';
 export { catalog, getCatalogPrompt } from './catalog.js';
 export { registry } from './registry.js';

package/lib/markdown.js

@@ -26,6 +26,40 @@ export function renderMarkdown(text) {
       continue;
     }
 
+    // H1 heading (rare inside a document body; render as section-sized)
+    if (line.startsWith('# ')) {
+      elements.push(h('h2', {
+        key: elements.length,
+        style: {
+          fontFamily: fonts.serif,
+          fontSize: '28px',
+          fontWeight: 400,
+          lineHeight: 1.2,
+          margin: '1.75rem 0 0.75rem',
+          color: 'var(--black)',
+        },
+      }, inlineMarkdown(line.slice(2))));
+      i++;
+      continue;
+    }
+
+    // H2 heading
+    if (line.startsWith('## ')) {
+      elements.push(h('h3', {
+        key: elements.length,
+        style: {
+          fontFamily: fonts.serif,
+          fontSize: '22px',
+          fontWeight: 400,
+          lineHeight: 1.25,
+          margin: '1.5rem 0 0.5rem',
+          color: 'var(--black)',
+        },
+      }, inlineMarkdown(line.slice(3))));
+      i++;
+      continue;
+    }
+
     // H3 heading
     if (line.startsWith('### ')) {
       elements.push(h('h3', {
@@ -36,7 +70,7 @@ export function renderMarkdown(text) {
           fontWeight: 600,
           lineHeight: 1.3,
           margin: '1.5rem 0 0.5rem',
-          color: colors.black,
+          color: 'var(--black)',
         },
       }, inlineMarkdown(line.slice(4))));
       i++;
@@ -52,7 +86,7 @@ export function renderMarkdown(text) {
           fontSize: '15px',
           fontWeight: 600,
           margin: '1rem 0 0.25rem',
-          color: colors.black,
+          color: 'var(--black)',
         },
       }, inlineMarkdown(line.slice(5))));
       i++;
@@ -79,7 +113,7 @@ export function renderMarkdown(text) {
               marginBottom: '0.35rem',
               fontSize: '15px',
               lineHeight: 1.55,
-              color: colors.dark,
+              color: 'var(--dark)',
             },
           },
             h('span', {
@@ -90,7 +124,7 @@ export function renderMarkdown(text) {
                 width: '5px',
                 height: '5px',
                 borderRadius: '50%',
-                background: colors.terracotta,
+                background: 'var(--terracotta)',
               },
             }),
             inlineMarkdown(item),
@@ -128,8 +162,8 @@ export function renderMarkdown(text) {
                 width: '20px',
                 height: '20px',
                 borderRadius: '50%',
-                background: colors.terracotta,
-                color: colors.cream,
+                background: 'var(--terracotta)',
+                color: 'var(--cream)',
                 display: 'flex',
                 alignItems: 'center',
                 justifyContent: 'center',
@@ -158,7 +192,7 @@ export function renderMarkdown(text) {
       elements.push(h('pre', {
         key: elements.length,
         style: {
-          background: colors.terminalBg,
+          background: 'var(--terminal-bg)',
           color: 'rgba(255, 255, 255, 0.85)',
           fontFamily: fonts.mono,
           fontSize: '13px',
@@ -190,12 +224,15 @@ export function renderMarkdown(text) {
     if (paraLines.length > 0) {
       elements.push(h('p', {
         key: elements.length,
-        style: { margin: '0.5rem 0', fontSize: '15px', lineHeight: 1.6, color: colors.dark },
+        style: { margin: '0.5rem 0', fontSize: '15px', lineHeight: 1.6, color: 'var(--dark)' },
       }, inlineMarkdown(paraLines.join(' '))));
+    } else {
+      // Safety: nothing consumed this line. Skip it to avoid an infinite loop.
+      i++;
     }
   }
 
-  return h('div', null, ...elements);
+  return h('div', { style: { color: 'var(--dark)' } }, ...elements);
 }
 
 // Inline markdown: **bold**, *italic*, `code`, [link](url)
@@ -210,11 +247,11 @@ function inlineMarkdown(text) {
   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' },
+      className: 'eg-code',
     }, 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' },
+      key: key++, href: m[2], style: { color: 'var(--terracotta)', textDecoration: 'underline' },
     }, m[1]) },
   ];
 
@@ -285,11 +322,11 @@ function renderTable(lines, key) {
               style: {
                 textAlign: 'left',
                 padding: '8px 12px',
-                borderBottom: `2px solid ${colors.border}`,
+                borderBottom: '2px solid var(--border)',
                 fontFamily: fonts.mono,
                 fontSize: '12px',
                 fontWeight: 500,
-                color: colors.muted,
+                color: 'var(--muted)',
                 textTransform: 'uppercase',
                 letterSpacing: '0.04em',
                 whiteSpace: 'nowrap',
@@ -306,8 +343,8 @@ function renderTable(lines, key) {
                 key: j,
                 style: {
                   padding: '6px 12px',
-                  borderBottom: `1px solid rgba(224, 216, 204, 0.5)`,
-                  color: colors.dark,
+                  borderBottom: '1px solid var(--border)',
+                  color: 'var(--dark)',
                 },
               }, cell.trim())
             ),
@@ -347,7 +384,7 @@ export function renderMarkdownLite(text) {
 
     // 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)));
+      elements.push(h('h3', { key: elements.length, style: { fontFamily: fonts.serif, fontSize: '18px', fontWeight: 600, margin: '1.5rem 0 0.5rem', color: 'var(--black)' } }, line.slice(3)));
       i++;
       continue;
     }
@@ -369,7 +406,7 @@ export function renderMarkdownLite(text) {
     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));
+    elements.push(h('p', { key: elements.length, style: { margin: '0.5rem 0', fontSize: '14px', lineHeight: 1.6, color: 'var(--dark)' } }, line));
     i++;
   }
 

package/lib/parsers/board.js

@@ -0,0 +1,109 @@
+// Parse board data (JSON from memory/board/board.json) into structured data
+import fs from 'node:fs';
+import { execSync } from 'node:child_process';
+
+export function parseBoard(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 {
+    // Try to find board.json relative to git root
+    try {
+      const root = execSync('git rev-parse --show-toplevel 2>/dev/null', { encoding: 'utf-8' }).trim();
+      const boardPath = `${root}/memory/board/board.json`;
+      if (fs.existsSync(boardPath)) {
+        data = JSON.parse(fs.readFileSync(boardPath, 'utf-8'));
+      }
+    } catch {}
+    if (!data) throw new Error('No board data found. Expected memory/board/board.json');
+  }
+
+  const today = new Date().toISOString().split('T')[0];
+
+  // Flatten all cards from the hierarchy for person and timeline views
+  const allCards = [];
+  for (const activity of data.activities || []) {
+    if (activity.subactivities) {
+      for (const sub of activity.subactivities) {
+        for (const card of sub.cards || []) {
+          allCards.push({ ...card, activity: activity.label, subactivity: sub.label, activityId: activity.id, subactivityId: sub.id });
+        }
+      }
+    }
+    for (const card of activity.cards || []) {
+      allCards.push({ ...card, activity: activity.label, subactivity: null, activityId: activity.id, subactivityId: null });
+    }
+  }
+
+  // Group by person
+  const personMap = {};
+  for (const card of allCards) {
+    for (const owner of card.owners || []) {
+      if (!personMap[owner]) personMap[owner] = [];
+      personMap[owner].push(card);
+    }
+  }
+  const people = Object.entries(personMap)
+    .map(([name, cards]) => ({
+      name,
+      cards: cards.sort((a, b) => a.priority - b.priority),
+      stats: {
+        total: cards.length,
+        p0: cards.filter(c => c.priority === 0).length,
+        p1: cards.filter(c => c.priority === 1).length,
+        p2: cards.filter(c => c.priority === 2).length,
+        p3: cards.filter(c => c.priority === 3).length,
+        inProgress: cards.filter(c => c.status === 'in-progress').length,
+        todo: cards.filter(c => c.status === 'todo').length,
+        review: cards.filter(c => c.status === 'review').length,
+        done: cards.filter(c => c.status === 'done').length,
+      },
+    }))
+    .sort((a, b) => b.stats.p0 - a.stats.p0 || b.stats.total - a.stats.total);
+
+  // Timeline: cards with dates, sorted by startDate
+  const timeline = allCards
+    .filter(c => c.startDate || c.dueDate)
+    .sort((a, b) => (a.startDate || a.dueDate || '').localeCompare(b.startDate || b.dueDate || ''));
+
+  // Summary stats
+  const summary = {
+    totalCards: allCards.length,
+    byPriority: { P0: 0, P1: 0, P2: 0, P3: 0 },
+    byStatus: { todo: 0, 'in-progress': 0, review: 0, done: 0 },
+  };
+  for (const card of allCards) {
+    const pKey = `P${card.priority}`;
+    if (summary.byPriority[pKey] !== undefined) summary.byPriority[pKey]++;
+    if (summary.byStatus[card.status] !== undefined) summary.byStatus[card.status]++;
+  }
+
+  // Read org name
+  let org = 'Egregore';
+  try {
+    const root = execSync('git rev-parse --show-toplevel 2>/dev/null', { encoding: 'utf-8' }).trim();
+    const configPath = `${root}/egregore.json`;
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      org = config.org_name || org;
+    }
+  } catch {}
+
+  return {
+    title: `Project Board — ${org}`,
+    date: today,
+    org,
+    updatedBy: data.updatedBy,
+    updatedAt: data.updated,
+    activities: data.activities,
+    allCards,
+    people,
+    timeline,
+    summary,
+  };
+}

package/lib/parsers/document.js

@@ -0,0 +1,101 @@
+// Generic markdown document parser
+// Handles any .md file — extracts YAML frontmatter (if present) + body sections
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function parseDocument(filePath) {
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  const fileName = path.basename(filePath, '.md');
+
+  let frontmatter = {};
+  let body = raw;
+
+  // Extract YAML frontmatter if present
+  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (fmMatch) {
+    frontmatter = parseSimpleYaml(fmMatch[1]);
+    body = fmMatch[2];
+  }
+
+  // Extract title: frontmatter title > first H1 > filename
+  let title = frontmatter.title;
+  if (!title) {
+    const h1Match = body.match(/^#\s+(.+)$/m);
+    if (h1Match) {
+      title = h1Match[1];
+      // Remove the H1 from body since we'll render it as the header
+      body = body.replace(/^#\s+.+\n?/, '');
+    }
+  }
+  if (!title) {
+    title = fileName.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+  }
+
+  // Extract sections (## headings split the body)
+  const sections = [];
+  const sectionRegex = /^##\s+(.+)$/gm;
+  let lastIndex = 0;
+  let match;
+  let preamble = '';
+
+  // Collect all ## heading positions
+  const headings = [];
+  while ((match = sectionRegex.exec(body)) !== null) {
+    headings.push({ title: match[1], index: match.index, fullMatch: match[0] });
+  }
+
+  if (headings.length === 0) {
+    // No sections — entire body is content
+    preamble = body.trim();
+  } else {
+    // Text before first heading is preamble
+    preamble = body.slice(0, headings[0].index).trim();
+
+    for (let i = 0; i < headings.length; i++) {
+      const start = headings[i].index + headings[i].fullMatch.length;
+      const end = i + 1 < headings.length ? headings[i + 1].index : body.length;
+      sections.push({
+        heading: headings[i].title,
+        body: body.slice(start, end).trim(),
+      });
+    }
+  }
+
+  return {
+    title,
+    frontmatter,
+    preamble,
+    sections,
+    source: filePath,
+    date: frontmatter.date || frontmatter.started || null,
+    author: frontmatter.author || frontmatter.started_by || frontmatter.from || null,
+    status: frontmatter.status || null,
+  };
+}
+
+// Minimal YAML parser — handles key: value, key: [array], key: "quoted"
+function parseSimpleYaml(text) {
+  const result = {};
+  for (const line of text.split('\n')) {
+    const m = line.match(/^(\w[\w_-]*):\s*(.*)$/);
+    if (!m) continue;
+    const [, key, rawVal] = m;
+    let val = rawVal.trim();
+
+    // Array: [a, b, c]
+    if (val.startsWith('[') && val.endsWith(']')) {
+      val = val.slice(1, -1).split(',').map(s => s.trim().replace(/^["']|["']$/g, ''));
+    }
+    // Quoted string
+    else if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    // null
+    else if (val === 'null' || val === '') {
+      val = null;
+    }
+
+    result[key] = val;
+  }
+  return result;
+}

package/lib/parsers/network.js

@@ -0,0 +1,73 @@
+// Parse network/people data (JSON from memory/network/people.json)
+import fs from 'node:fs';
+import { execSync } from 'node:child_process';
+
+export function parseNetwork(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 {
+    try {
+      const root = execSync('git rev-parse --show-toplevel 2>/dev/null', { encoding: 'utf-8' }).trim();
+      const peoplePath = `${root}/memory/network/people.json`;
+      if (fs.existsSync(peoplePath)) {
+        data = JSON.parse(fs.readFileSync(peoplePath, 'utf-8'));
+      }
+    } catch {}
+    if (!data) throw new Error('No network data found. Expected memory/network/people.json');
+  }
+
+  const people = data.people || [];
+
+  // Collect all unique roles
+  const allRoles = [...new Set(people.flatMap(p => p.roles || []))].sort();
+
+  // Group by role
+  const byRole = {};
+  for (const role of allRoles) {
+    byRole[role] = people.filter(p => (p.roles || []).includes(role));
+  }
+
+  // Group by organization
+  const byOrg = {};
+  for (const person of people) {
+    const org = person.organization || 'Independent';
+    if (!byOrg[org]) byOrg[org] = [];
+    byOrg[org].push(person);
+  }
+
+  // Summary
+  const summary = {
+    totalPeople: people.length,
+    totalOrgs: Object.keys(byOrg).length,
+    byRole: Object.fromEntries(allRoles.map(r => [r, byRole[r].length])),
+  };
+
+  // Read org name
+  let org = 'Egregore';
+  try {
+    const root = execSync('git rev-parse --show-toplevel 2>/dev/null', { encoding: 'utf-8' }).trim();
+    const configPath = `${root}/egregore.json`;
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      org = config.org_name || org;
+    }
+  } catch {}
+
+  return {
+    title: `Network — ${org}`,
+    date: new Date().toISOString().split('T')[0],
+    org,
+    updatedBy: data.updatedBy,
+    people,
+    allRoles,
+    byRole,
+    byOrg,
+    summary,
+  };
+}