egregore-artifacts 0.1.0 → 0.2.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'];
+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);
 }
 
+// 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') {
   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;
@@ -49,9 +85,25 @@ try {
   const input = type === 'activity' ? (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/index.js

@@ -6,13 +6,15 @@ 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 { questTemplate } from './templates/quest.js';
 import { handoffTemplate } from './templates/handoff.js';
 import { activityTemplate } from './templates/activity.js';
+import { documentTemplate } from './templates/document.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 };
+const TEMPLATES = { quest: questTemplate, handoff: handoffTemplate, activity: activityTemplate, document: documentTemplate };
 
 export async function generateArtifact(type, input) {
   const template = TEMPLATES[type];
@@ -45,6 +47,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/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/templates/document.js

@@ -0,0 +1,52 @@
+// Generic document → React element tree
+import React from 'react';
+import { ArtifactHeader, SectionCard, TextBlock, ArtifactFooter } from '../components.js';
+
+const h = React.createElement;
+
+export function documentTemplate(doc) {
+  const sections = [];
+
+  // Header
+  sections.push(
+    h(ArtifactHeader, {
+      key: 'header',
+      title: doc.title,
+      type: 'document',
+      date: doc.date,
+      author: doc.author,
+      status: doc.status,
+      priority: 0,
+      projects: doc.frontmatter?.projects || [],
+    })
+  );
+
+  // Preamble (text before first ## heading)
+  if (doc.preamble) {
+    sections.push(
+      h(SectionCard, { key: 'preamble', label: null },
+        h(TextBlock, { text: doc.preamble, variant: 'lead' })
+      )
+    );
+  }
+
+  // Body sections
+  for (const section of doc.sections) {
+    sections.push(
+      h(SectionCard, { key: `s-${section.heading}`, label: section.heading },
+        h(TextBlock, { text: section.body })
+      )
+    );
+  }
+
+  // Footer
+  sections.push(
+    h(ArtifactFooter, {
+      key: 'footer',
+      generatedAt: new Date().toISOString(),
+      source: doc.source,
+    })
+  );
+
+  return h('div', null, ...sections);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "egregore-artifacts",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Generate branded HTML artifacts from Egregore data",
   "type": "module",
   "license": "MIT",