@grainulation/mill 1.0.0

package/lib/formats/yaml.js

@@ -0,0 +1,144 @@
+/**
+ * mill format: yaml
+ *
+ * Converts compilation.json to YAML output.
+ * Simple JSON-to-YAML serializer — handles objects, arrays, strings,
+ * numbers, booleans, and nulls. No external dependencies.
+ * Zero dependencies — node built-in only.
+ */
+
+export const name = 'yaml';
+export const extension = '.yaml';
+export const mimeType = 'text/yaml; charset=utf-8';
+export const description = 'YAML serialization of compilation data';
+
+/**
+ * Convert a compilation object to YAML.
+ * @param {object} compilation - The compilation.json content
+ * @returns {string} YAML output
+ */
+export function convert(compilation) {
+  const lines = [];
+  lines.push('# Auto-generated by mill yaml format');
+  lines.push('');
+  lines.push(toYaml(compilation, 0));
+  return lines.join('\n');
+}
+
+function toYaml(value, indent) {
+  if (value === null || value === undefined) {
+    return 'null';
+  }
+  if (typeof value === 'boolean') {
+    return value ? 'true' : 'false';
+  }
+  if (typeof value === 'number') {
+    return String(value);
+  }
+  if (typeof value === 'string') {
+    return yamlString(value, indent);
+  }
+  if (Array.isArray(value)) {
+    return yamlArray(value, indent);
+  }
+  if (typeof value === 'object') {
+    return yamlObject(value, indent);
+  }
+  return String(value);
+}
+
+function yamlString(str, indent) {
+  // Use block scalar for multi-line strings
+  if (str.includes('\n')) {
+    const pad = ' '.repeat(indent + 2);
+    const indented = str.split('\n').map(line => pad + line).join('\n');
+    return '|\n' + indented;
+  }
+  // Quote if the string contains special YAML characters or could be misinterpreted
+  if (needsQuoting(str)) {
+    return "'" + str.replace(/'/g, "''") + "'";
+  }
+  return str;
+}
+
+function needsQuoting(str) {
+  if (str === '') return true;
+  if (str === 'true' || str === 'false' || str === 'null' || str === 'yes' || str === 'no') return true;
+  if (/^[0-9]/.test(str) && !isNaN(Number(str))) return true;
+  if (/[:{}\[\],&*?|>!%#@`"']/.test(str)) return true;
+  if (/^\s|\s$/.test(str)) return true;
+  if (str.startsWith('- ') || str.startsWith('? ')) return true;
+  return false;
+}
+
+function yamlArray(arr, indent) {
+  if (arr.length === 0) return '[]';
+  const pad = ' '.repeat(indent);
+  const items = [];
+  for (const item of arr) {
+    if (item !== null && typeof item === 'object' && !Array.isArray(item)) {
+      // Object items: first key on same line as -, rest indented
+      const keys = Object.keys(item);
+      if (keys.length === 0) {
+        items.push(pad + '- {}');
+      } else {
+        const firstKey = keys[0];
+        const firstVal = toYaml(item[firstKey], indent + 4);
+        const firstLine = isScalar(item[firstKey])
+          ? `${pad}- ${firstKey}: ${firstVal}`
+          : `${pad}- ${firstKey}:\n${indentBlock(firstVal, indent + 4)}`;
+        const rest = keys.slice(1).map(key => {
+          const val = toYaml(item[key], indent + 4);
+          if (isScalar(item[key])) {
+            return `${pad}  ${key}: ${val}`;
+          }
+          return `${pad}  ${key}:\n${indentBlock(val, indent + 4)}`;
+        });
+        items.push([firstLine, ...rest].join('\n'));
+      }
+    } else if (Array.isArray(item)) {
+      const nested = toYaml(item, indent + 2);
+      items.push(`${pad}-\n${indentBlock(nested, indent + 2)}`);
+    } else {
+      items.push(`${pad}- ${toYaml(item, indent + 2)}`);
+    }
+  }
+  return '\n' + items.join('\n');
+}
+
+function yamlObject(obj, indent) {
+  const keys = Object.keys(obj);
+  if (keys.length === 0) return '{}';
+  const pad = ' '.repeat(indent);
+  const entries = [];
+  for (const key of keys) {
+    const val = obj[key];
+    const yamlKey = needsQuoting(key) ? `'${key.replace(/'/g, "''")}'` : key;
+    if (isScalar(val)) {
+      entries.push(`${pad}${yamlKey}: ${toYaml(val, indent + 2)}`);
+    } else {
+      const nested = toYaml(val, indent + 2);
+      if (nested.startsWith('\n')) {
+        entries.push(`${pad}${yamlKey}:${nested}`);
+      } else {
+        entries.push(`${pad}${yamlKey}:\n${indentBlock(nested, indent + 2)}`);
+      }
+    }
+  }
+  return '\n' + entries.join('\n');
+}
+
+function isScalar(value) {
+  return value === null || value === undefined ||
+    typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+
+function indentBlock(text, indent) {
+  const pad = ' '.repeat(indent);
+  return text.split('\n').map(line => {
+    if (line.trim() === '') return '';
+    // Only add padding if the line doesn't already have it
+    if (line.startsWith(pad)) return line;
+    return pad + line;
+  }).join('\n');
+}

package/lib/formats.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const pdf = require('./exporters/pdf.js');
+const csv = require('./exporters/csv.js');
+const markdown = require('./exporters/markdown.js');
+const jsonLd = require('./exporters/json-ld.js');
+const static_ = require('./publishers/static.js');
+const clipboard = require('./publishers/clipboard.js');
+
+const EXPORTERS = {
+  pdf,
+  csv,
+  markdown,
+  'json-ld': jsonLd,
+};
+
+const PUBLISHERS = {
+  static: static_,
+  clipboard,
+};
+
+/**
+ * Detect the likely format of an input file by extension.
+ */
+function detectFormat(filePath) {
+  const ext = filePath.split('.').pop().toLowerCase();
+  const map = {
+    html: 'html',
+    htm: 'html',
+    md: 'markdown',
+    json: 'json',
+    csv: 'csv',
+    jsonld: 'json-ld',
+  };
+  return map[ext] || 'unknown';
+}
+
+function getExporter(name) {
+  return EXPORTERS[name] || null;
+}
+
+function getPublisher(name) {
+  return PUBLISHERS[name] || null;
+}
+
+function listExportFormats() {
+  return Object.keys(EXPORTERS);
+}
+
+function listPublishTargets() {
+  return Object.keys(PUBLISHERS);
+}
+
+module.exports = {
+  detectFormat,
+  getExporter,
+  getPublisher,
+  listExportFormats,
+  listPublishTargets,
+};

package/lib/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const formats = require('./formats.js');
+
+const name = 'mill';
+const version = require('../package.json').version;
+const description = 'Turn wheat sprint artifacts into shareable formats';
+
+module.exports = {
+  name,
+  version,
+  description,
+  ...formats,
+};

package/lib/json-ld-common.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * json-ld-common.js — Shared JSON-LD vocabulary for mill
+ *
+ * Both the ESM format (formats/json-ld.js) and the CJS exporter
+ * (exporters/json-ld.js) use the same schema.org/Report structure.
+ * This module is the single source of truth for that vocabulary.
+ *
+ * CJS module so both CJS exporters and ESM formats can consume it.
+ */
+
+const CONTEXT = {
+  '@vocab': 'https://schema.org/',
+  wheat: 'https://grainulation.com/ns/wheat#',
+  claim: 'wheat:Claim',
+  confidence: 'wheat:confidence',
+  evidenceTier: 'wheat:evidenceTier',
+  claimType: 'wheat:claimType',
+  sprintId: 'wheat:sprintId',
+};
+
+function claimToJsonLd(claim) {
+  const body = claim.content || claim.text || '';
+  const evidenceTier = typeof claim.evidence === 'string'
+    ? claim.evidence
+    : (claim.evidence?.tier ?? claim.evidence_tier ?? null);
+
+  return {
+    '@type': 'claim',
+    '@id': `wheat:claim/${claim.id}`,
+    identifier: claim.id,
+    claimType: claim.type,
+    text: body,
+    description: body,
+    confidence: claim.confidence ?? null,
+    evidenceTier,
+    dateCreated: claim.created || claim.timestamp || null,
+    ...(claim.tags?.length ? { keywords: claim.tags.join(', ') } : {}),
+    ...(claim.status ? { status: claim.status } : {}),
+  };
+}
+
+function buildReport(meta, claims, certificate) {
+  return {
+    '@context': CONTEXT,
+    '@type': 'Report',
+    '@id': `wheat:sprint/${meta.sprint || 'unknown'}`,
+    name: meta.sprint || meta.question || 'Wheat Sprint Report',
+    description: meta.question || '',
+    dateCreated: (certificate && certificate.compiled_at) || new Date().toISOString(),
+    ...(meta.audience ? { audience: { '@type': 'Audience', name: meta.audience } } : {}),
+    hasPart: {
+      '@type': 'ItemList',
+      numberOfItems: claims.length,
+      itemListElement: claims.map((claim, i) => ({
+        '@type': 'ListItem',
+        position: i + 1,
+        item: claimToJsonLd(claim),
+      })),
+    },
+    ...((certificate && certificate.sha256) ? {
+      identifier: {
+        '@type': 'PropertyValue',
+        name: 'certificate-sha256',
+        value: certificate.sha256,
+      },
+    } : {}),
+  };
+}
+
+module.exports = { CONTEXT, claimToJsonLd, buildReport };

package/lib/publishers/clipboard.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFile } = require('node:child_process');
+
+/**
+ * Copy formatted output to system clipboard.
+ * Uses pbcopy (macOS), xclip (Linux), or clip (Windows).
+ */
+
+function getClipboardCommand() {
+  switch (process.platform) {
+    case 'darwin':
+      return { cmd: 'pbcopy', args: [] };
+    case 'linux':
+      return { cmd: 'xclip', args: ['-selection', 'clipboard'] };
+    case 'win32':
+      return { cmd: 'clip', args: [] };
+    default:
+      return null;
+  }
+}
+
+function copyToClipboard(text) {
+  return new Promise((resolve, reject) => {
+    const clip = getClipboardCommand();
+    if (!clip) {
+      reject(new Error(`Clipboard not supported on ${process.platform}`));
+      return;
+    }
+
+    const proc = execFile(clip.cmd, clip.args, (err) => {
+      if (err) reject(new Error(`Clipboard copy failed: ${err.message}`));
+      else resolve();
+    });
+
+    proc.stdin.write(text);
+    proc.stdin.end();
+  });
+}
+
+async function publishClipboard(inputPath) {
+  const stat = fs.statSync(inputPath);
+
+  let content;
+  if (stat.isDirectory()) {
+    // If directory, list the files
+    const files = fs.readdirSync(inputPath).filter((f) => !f.startsWith('.'));
+    content = files.map((f) => {
+      const full = path.join(inputPath, f);
+      return fs.readFileSync(full, 'utf-8');
+    }).join('\n\n---\n\n');
+  } else {
+    content = fs.readFileSync(inputPath, 'utf-8');
+  }
+
+  await copyToClipboard(content);
+
+  const size = Buffer.byteLength(content, 'utf-8');
+  return {
+    message: `Copied to clipboard (${size} bytes)`,
+  };
+}
+
+module.exports = {
+  name: 'clipboard',
+  description: 'Copy formatted output to system clipboard',
+  publish: publishClipboard,
+};

package/lib/publishers/static.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+function esc(s) { return String(s || '').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;').replace(/'/g,'&#39;'); }
+
+/**
+ * Generate a static site from sprint output directory.
+ * Creates an index.html that links to all artifacts with
+ * a dark-themed navigation page.
+ */
+
+const TEMPLATE = (title, items) => `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${title}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+      background: #111;
+      color: #e5e5e5;
+      min-height: 100vh;
+      padding: 2rem;
+    }
+    h1 {
+      color: #d97706;
+      font-size: 1.8rem;
+      margin-bottom: 0.5rem;
+    }
+    .subtitle {
+      color: #888;
+      margin-bottom: 2rem;
+      font-size: 0.9rem;
+    }
+    .artifacts {
+      display: grid;
+      grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+      gap: 1rem;
+    }
+    .card {
+      background: #1a1a1a;
+      border: 1px solid #333;
+      border-radius: 8px;
+      padding: 1.2rem;
+      transition: border-color 0.2s;
+    }
+    .card:hover { border-color: #d97706; }
+    .card a {
+      color: #d97706;
+      text-decoration: none;
+      font-weight: 600;
+      font-size: 1.05rem;
+    }
+    .card a:hover { text-decoration: underline; }
+    .card .meta {
+      color: #888;
+      font-size: 0.8rem;
+      margin-top: 0.4rem;
+    }
+    footer {
+      margin-top: 3rem;
+      color: #555;
+      font-size: 0.75rem;
+      text-align: center;
+    }
+  </style>
+</head>
+<body>
+  <h1>${title}</h1>
+  <p class="subtitle">Generated by mill</p>
+  <div class="artifacts">
+    ${items}
+  </div>
+  <footer>Built with @grainulation/mill</footer>
+</body>
+</html>
+`;
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function scanDir(dir, base) {
+  const entries = [];
+  for (const name of fs.readdirSync(dir)) {
+    const full = path.join(dir, name);
+    const stat = fs.statSync(full);
+    const real = fs.realpathSync(full);
+    if (!real.startsWith(fs.realpathSync(base))) continue;
+    if (stat.isFile() && !name.startsWith('.')) {
+      const rel = path.relative(base, full);
+      entries.push({
+        name,
+        path: rel,
+        size: stat.size,
+        ext: path.extname(name).slice(1).toLowerCase(),
+        modified: stat.mtime,
+      });
+    } else if (stat.isDirectory() && !name.startsWith('.') && name !== '_site') {
+      entries.push(...scanDir(full, base));
+    }
+  }
+  return entries;
+}
+
+async function publishStatic(inputDir, outputDir) {
+  const outDir = outputDir || path.join(inputDir, '_site');
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
+  }
+
+  const entries = scanDir(inputDir, inputDir);
+
+  // Copy all files to _site
+  for (const entry of entries) {
+    const src = path.join(inputDir, entry.path);
+    const dest = path.join(outDir, entry.path);
+    const destDir = path.dirname(dest);
+    if (!fs.existsSync(destDir)) {
+      fs.mkdirSync(destDir, { recursive: true });
+    }
+    fs.copyFileSync(src, dest);
+  }
+
+  // Build index
+  const sprintName = path.basename(path.resolve(inputDir));
+  const cards = entries.map((e) => `
+    <div class="card">
+      <a href="${esc(e.path)}">${esc(e.name)}</a>
+      <div class="meta">${e.ext.toUpperCase()} &middot; ${formatBytes(e.size)}</div>
+    </div>`).join('\n');
+
+  const html = TEMPLATE(`Sprint: ${sprintName}`, cards);
+  fs.writeFileSync(path.join(outDir, 'index.html'), html, 'utf-8');
+
+  return {
+    outputPath: outDir,
+    message: `Static site written to ${outDir} (${entries.length} artifacts)`,
+  };
+}
+
+module.exports = {
+  name: 'static',
+  description: 'Generate a static site from sprint outputs',
+  publish: publishStatic,
+};