@grainulation/mill 1.0.0 → 1.0.2

package/lib/formats/{static-site.js → static-site.mjs}

@@ -7,10 +7,11 @@
  * Zero dependencies — node built-in only.
  */
 
-export const name = 'static-site';
-export const extension = '.json';
-export const mimeType = 'application/json; charset=utf-8';
-export const description = 'Hugo-compatible static site manifest (file tree as JSON)';
+export const name = "static-site";
+export const extension = ".json";
+export const mimeType = "application/json; charset=utf-8";
+export const description =
+  "Hugo-compatible static site manifest (file tree as JSON)";
 
 /**
  * Convert a compilation object to a static site manifest.
@@ -22,148 +23,159 @@ export function convert(compilation) {
   const meta = compilation.meta || {};
   const certificate = compilation.certificate || {};
 
-  const sprintName = meta.sprint || 'sprint';
-  const question = meta.question || '';
-  const audience = meta.audience || '';
+  const sprintName = meta.sprint || "sprint";
+  const question = meta.question || "";
+  const audience = meta.audience || "";
 
   const files = {};
 
   // Hugo config
-  files['config.yaml'] = buildConfig(sprintName, question);
+  files["config.yaml"] = buildConfig(sprintName, question);
 
   // Index page
-  files['content/_index.md'] = buildIndex(sprintName, question, audience, claims);
+  files["content/_index.md"] = buildIndex(
+    sprintName,
+    question,
+    audience,
+    claims,
+  );
 
   // Per-type section pages
   const groups = {};
   for (const claim of claims) {
-    const type = claim.type || 'other';
+    const type = claim.type || "other";
     if (!groups[type]) groups[type] = [];
     groups[type].push(claim);
   }
 
   for (const [type, group] of Object.entries(groups)) {
-    files[`content/claims/${type}/_index.md`] = buildSectionIndex(type, group.length);
+    files[`content/claims/${type}/_index.md`] = buildSectionIndex(
+      type,
+      group.length,
+    );
 
     for (const claim of group) {
-      const id = claim.id || 'unknown';
+      const id = claim.id || "unknown";
       files[`content/claims/${type}/${id}.md`] = buildClaimPage(claim);
     }
   }
 
   // Data file: full claims array
-  files['data/claims.json'] = JSON.stringify(claims, null, 2);
+  files["data/claims.json"] = JSON.stringify(claims, null, 2);
 
   // Data file: certificate
   if (Object.keys(certificate).length > 0) {
-    files['data/certificate.json'] = JSON.stringify(certificate, null, 2);
+    files["data/certificate.json"] = JSON.stringify(certificate, null, 2);
   }
 
   // Data file: meta
-  files['data/meta.json'] = JSON.stringify(meta, null, 2);
+  files["data/meta.json"] = JSON.stringify(meta, null, 2);
 
   const manifest = {
-    generator: 'mill',
+    generator: "mill",
     sprint: sprintName,
     claimCount: claims.length,
     files,
   };
 
-  return JSON.stringify(manifest, null, 2) + '\n';
+  return JSON.stringify(manifest, null, 2) + "\n";
 }
 
 function buildConfig(sprintName, question) {
   const lines = [];
-  lines.push(`baseURL: "https://your-site.example.com/${sanitizeSlug(sprintName)}/"  # Update with your domain`);
+  lines.push(
+    `baseURL: "https://your-site.example.com/${sanitizeSlug(sprintName)}/"  # Update with your domain`,
+  );
   lines.push(`title: "${escYaml(sprintName)}"`);
   lines.push(`theme: "mill-default"`);
   lines.push('languageCode: "en-us"');
-  lines.push('');
-  lines.push('params:');
+  lines.push("");
+  lines.push("params:");
   lines.push(`  question: "${escYaml(question)}"`);
   lines.push(`  generator: "mill"`);
-  return lines.join('\n') + '\n';
+  return lines.join("\n") + "\n";
 }
 
 function buildIndex(sprintName, question, audience, claims) {
   const lines = [];
-  lines.push('---');
+  lines.push("---");
   lines.push(`title: "${escYaml(sprintName)}"`);
   lines.push(`description: "${escYaml(question)}"`);
   lines.push('type: "index"');
-  lines.push('---');
-  lines.push('');
+  lines.push("---");
+  lines.push("");
   lines.push(`# ${sprintName}`);
-  lines.push('');
+  lines.push("");
   if (question) lines.push(`**Question:** ${question}`);
   if (audience) lines.push(`**Audience:** ${audience}`);
-  lines.push('');
+  lines.push("");
   lines.push(`**Total claims:** ${claims.length}`);
 
   // Type summary
   const typeCounts = {};
   for (const c of claims) {
-    const t = c.type || 'other';
+    const t = c.type || "other";
     typeCounts[t] = (typeCounts[t] || 0) + 1;
   }
-  lines.push('');
+  lines.push("");
   for (const [type, count] of Object.entries(typeCounts)) {
     lines.push(`- ${type}: ${count}`);
   }
 
-  return lines.join('\n') + '\n';
+  return lines.join("\n") + "\n";
 }
 
 function buildSectionIndex(type, count) {
   const lines = [];
-  lines.push('---');
+  lines.push("---");
   lines.push(`title: "${escYaml(type)}"`);
   lines.push(`type: "section"`);
-  lines.push('---');
-  lines.push('');
-  lines.push(`${count} ${type} claim${count !== 1 ? 's' : ''}.`);
-  return lines.join('\n') + '\n';
+  lines.push("---");
+  lines.push("");
+  lines.push(`${count} ${type} claim${count !== 1 ? "s" : ""}.`);
+  return lines.join("\n") + "\n";
 }
 
 function buildClaimPage(claim) {
-  const id = claim.id || 'unknown';
-  const type = claim.type || '';
-  const content = claim.content || claim.text || '';
+  const id = claim.id || "unknown";
+  const type = claim.type || "";
+  const content = claim.content || claim.text || "";
   const evidence = getEvidence(claim);
-  const status = claim.status || '';
+  const status = claim.status || "";
   const tags = Array.isArray(claim.tags) ? claim.tags : [];
-  const confidence = claim.confidence != null ? claim.confidence : '';
+  const confidence = claim.confidence != null ? claim.confidence : "";
 
   const lines = [];
-  lines.push('---');
+  lines.push("---");
   lines.push(`title: "${escYaml(id)}"`);
   lines.push(`type: "${escYaml(type)}"`);
   lines.push(`evidence: "${escYaml(evidence)}"`);
   lines.push(`status: "${escYaml(status)}"`);
-  if (confidence !== '') lines.push(`confidence: ${confidence}`);
-  if (tags.length > 0) lines.push(`tags: [${tags.map(t => `"${escYaml(t)}"`).join(', ')}]`);
-  lines.push('---');
-  lines.push('');
+  if (confidence !== "") lines.push(`confidence: ${confidence}`);
+  if (tags.length > 0)
+    lines.push(`tags: [${tags.map((t) => `"${escYaml(t)}"`).join(", ")}]`);
+  lines.push("---");
+  lines.push("");
   lines.push(content);
-  return lines.join('\n') + '\n';
+  return lines.join("\n") + "\n";
 }
 
 function getEvidence(claim) {
-  if (typeof claim.evidence === 'string') return claim.evidence;
-  if (typeof claim.evidence === 'object' && claim.evidence !== null) {
-    return claim.evidence.tier || claim.evidence_tier || '';
+  if (typeof claim.evidence === "string") return claim.evidence;
+  if (typeof claim.evidence === "object" && claim.evidence !== null) {
+    return claim.evidence.tier || claim.evidence_tier || "";
   }
-  return claim.evidence_tier || '';
+  return claim.evidence_tier || "";
 }
 
 function escYaml(str) {
-  if (str == null) return '';
+  if (str == null) return "";
   return String(str).replace(/"/g, '\\"');
 }
 
 function sanitizeSlug(str) {
   return String(str)
     .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
 }

package/lib/formats/{treemap.js → treemap.mjs}

@@ -6,10 +6,11 @@
  * Zero dependencies — node built-in only.
  */
 
-export const name = 'treemap';
-export const extension = '.json';
-export const mimeType = 'application/json; charset=utf-8';
-export const description = 'Claims as nested JSON for D3 treemap visualization (grouped by type)';
+export const name = "treemap";
+export const extension = ".json";
+export const mimeType = "application/json; charset=utf-8";
+export const description =
+  "Claims as nested JSON for D3 treemap visualization (grouped by type)";
 
 /**
  * Convert a compilation object to D3 treemap JSON.
@@ -18,12 +19,12 @@ export const description = 'Claims as nested JSON for D3 treemap visualization (
  */
 export function convert(compilation) {
   const claims = compilation.claims || [];
-  const sprintName = compilation.meta?.sprint || 'sprint';
+  const sprintName = compilation.meta?.sprint || "sprint";
 
   // Group claims by type
   const groups = {};
   for (const claim of claims) {
-    const type = claim.type || 'other';
+    const type = claim.type || "other";
     if (!groups[type]) groups[type] = [];
     groups[type].push(claim);
   }
@@ -32,17 +33,17 @@ export function convert(compilation) {
     name: sprintName,
     children: Object.entries(groups).map(([type, group]) => ({
       name: type,
-      children: group.map(claim => {
+      children: group.map((claim) => {
         const node = {
-          name: claim.id || '',
+          name: claim.id || "",
           value: claim.confidence != null ? claim.confidence : 1,
           evidence: getEvidence(claim),
         };
 
-        const content = claim.content || claim.text || '';
+        const content = claim.content || claim.text || "";
         if (content) node.content = content;
 
-        const status = claim.status || '';
+        const status = claim.status || "";
         if (status) node.status = status;
 
         const tags = Array.isArray(claim.tags) ? claim.tags : [];
@@ -53,13 +54,13 @@ export function convert(compilation) {
     })),
   };
 
-  return JSON.stringify(tree, null, 2) + '\n';
+  return JSON.stringify(tree, null, 2) + "\n";
 }
 
 function getEvidence(claim) {
-  if (typeof claim.evidence === 'string') return claim.evidence;
-  if (typeof claim.evidence === 'object' && claim.evidence !== null) {
-    return claim.evidence.tier || claim.evidence_tier || '';
+  if (typeof claim.evidence === "string") return claim.evidence;
+  if (typeof claim.evidence === "object" && claim.evidence !== null) {
+    return claim.evidence.tier || claim.evidence_tier || "";
   }
-  return claim.evidence_tier || '';
+  return claim.evidence_tier || "";
 }

package/lib/formats/typescript-defs.mjs

@@ -0,0 +1,150 @@
+/**
+ * mill format: typescript-defs
+ *
+ * Converts compilation.json to TypeScript .d.ts definitions.
+ * Derives union types from actual claim data values.
+ * Zero dependencies — node built-in only.
+ */
+
+export const name = "typescript-defs";
+export const extension = ".d.ts";
+export const mimeType = "text/plain; charset=utf-8";
+export const description =
+  "TypeScript type definitions derived from compilation data";
+
+/**
+ * Convert a compilation object to TypeScript .d.ts definitions.
+ * @param {object} compilation - The compilation.json content
+ * @returns {string} TypeScript definition output
+ */
+export function convert(compilation) {
+  const claims = compilation.claims || [];
+  const meta = compilation.meta || {};
+  const conflicts = compilation.conflicts || [];
+  const certificate = compilation.certificate || {};
+
+  const claimTypes = uniqueSorted(claims.map((c) => c.type).filter(Boolean));
+  const evidenceTiers = uniqueSorted(
+    claims
+      .map((c) => {
+        if (typeof c.evidence === "string") return c.evidence;
+        return c.evidence?.tier ?? c.evidence_tier ?? null;
+      })
+      .filter(Boolean),
+  );
+  const statuses = uniqueSorted(claims.map((c) => c.status).filter(Boolean));
+
+  const lines = [];
+
+  lines.push("// Auto-generated by mill typescript-defs format");
+  lines.push("// Derived from compilation data — do not edit manually");
+  lines.push("");
+
+  // ClaimType union
+  lines.push(`export type ClaimType = ${unionType(claimTypes)};`);
+  lines.push("");
+
+  // EvidenceTier union
+  lines.push(`export type EvidenceTier = ${unionType(evidenceTiers)};`);
+  lines.push("");
+
+  // ClaimStatus union
+  lines.push(`export type ClaimStatus = ${unionType(statuses)};`);
+  lines.push("");
+
+  // Evidence interface
+  lines.push("export interface Evidence {");
+  lines.push("  tier: EvidenceTier;");
+  lines.push("  source?: string;");
+  lines.push("}");
+  lines.push("");
+
+  // Source interface
+  lines.push("export interface ClaimSource {");
+  lines.push("  origin?: string;");
+  lines.push("  artifact?: string;");
+  lines.push("}");
+  lines.push("");
+
+  // Claim interface
+  lines.push("export interface Claim {");
+  lines.push("  id: string;");
+  lines.push("  type: ClaimType;");
+  lines.push("  content: string;");
+  lines.push("  evidence: EvidenceTier | Evidence;");
+  lines.push("  status: ClaimStatus;");
+  lines.push("  confidence?: number;");
+  lines.push("  source?: string | ClaimSource;");
+  lines.push("  tags?: string[];");
+  lines.push("  created?: string;");
+  lines.push("}");
+  lines.push("");
+
+  // Meta interface
+  lines.push("export interface Meta {");
+  lines.push("  sprint?: string;");
+  lines.push("  question?: string;");
+  lines.push("  audience?: string;");
+  for (const key of Object.keys(meta)) {
+    if (!["sprint", "question", "audience"].includes(key)) {
+      lines.push(`  ${sanitizeKey(key)}?: ${inferTsType(meta[key])};`);
+    }
+  }
+  lines.push("}");
+  lines.push("");
+
+  // Conflict interface
+  lines.push("export interface Conflict {");
+  lines.push("  ids?: string[];");
+  lines.push("  description?: string;");
+  lines.push("  reason?: string;");
+  lines.push("  resolution?: string;");
+  lines.push("}");
+  lines.push("");
+
+  // Certificate interface
+  lines.push("export interface Certificate {");
+  lines.push("  compiled_at?: string;");
+  lines.push("  sha256?: string;");
+  lines.push("  claim_count?: number;");
+  for (const key of Object.keys(certificate)) {
+    if (!["compiled_at", "sha256", "claim_count"].includes(key)) {
+      lines.push(`  ${sanitizeKey(key)}?: ${inferTsType(certificate[key])};`);
+    }
+  }
+  lines.push("}");
+  lines.push("");
+
+  // Compilation interface
+  lines.push("export interface Compilation {");
+  lines.push("  meta: Meta;");
+  lines.push("  claims: Claim[];");
+  lines.push("  conflicts: Conflict[];");
+  lines.push("  certificate: Certificate;");
+  lines.push("}");
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+function uniqueSorted(arr) {
+  return [...new Set(arr)].sort();
+}
+
+function unionType(values) {
+  if (values.length === 0) return "string";
+  return values.map((v) => `'${v}'`).join(" | ");
+}
+
+function sanitizeKey(key) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `'${key}'`;
+}
+
+function inferTsType(value) {
+  if (value === null || value === undefined) return "unknown";
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "string") return "string";
+  if (Array.isArray(value)) return "unknown[]";
+  return "Record<string, unknown>";
+}

package/lib/formats/{yaml.js → yaml.mjs}

@@ -7,10 +7,10 @@
  * 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';
+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.
@@ -19,29 +19,29 @@ export const description = 'YAML serialization of compilation data';
  */
 export function convert(compilation) {
   const lines = [];
-  lines.push('# Auto-generated by mill yaml format');
-  lines.push('');
+  lines.push("# Auto-generated by mill yaml format");
+  lines.push("");
   lines.push(toYaml(compilation, 0));
-  return lines.join('\n');
+  return lines.join("\n");
 }
 
 function toYaml(value, indent) {
   if (value === null || value === undefined) {
-    return 'null';
+    return "null";
   }
-  if (typeof value === 'boolean') {
-    return value ? 'true' : 'false';
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
   }
-  if (typeof value === 'number') {
+  if (typeof value === "number") {
     return String(value);
   }
-  if (typeof value === 'string') {
+  if (typeof value === "string") {
     return yamlString(value, indent);
   }
   if (Array.isArray(value)) {
     return yamlArray(value, indent);
   }
-  if (typeof value === 'object') {
+  if (typeof value === "object") {
     return yamlObject(value, indent);
   }
   return String(value);
@@ -49,10 +49,13 @@ function toYaml(value, indent) {
 
 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;
+  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)) {
@@ -62,39 +65,46 @@ function yamlString(str, indent) {
 }
 
 function needsQuoting(str) {
-  if (str === '') return true;
-  if (str === 'true' || str === 'false' || str === 'null' || str === 'yes' || str === 'no') return true;
+  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;
+  if (str.startsWith("- ") || str.startsWith("? ")) return true;
   return false;
 }
 
 function yamlArray(arr, indent) {
-  if (arr.length === 0) return '[]';
-  const pad = ' '.repeat(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)) {
+    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 + '- {}');
+        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 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'));
+        items.push([firstLine, ...rest].join("\n"));
       }
     } else if (Array.isArray(item)) {
       const nested = toYaml(item, indent + 2);
@@ -103,13 +113,13 @@ function yamlArray(arr, indent) {
       items.push(`${pad}- ${toYaml(item, indent + 2)}`);
     }
   }
-  return '\n' + items.join('\n');
+  return "\n" + items.join("\n");
 }
 
 function yamlObject(obj, indent) {
   const keys = Object.keys(obj);
-  if (keys.length === 0) return '{}';
-  const pad = ' '.repeat(indent);
+  if (keys.length === 0) return "{}";
+  const pad = " ".repeat(indent);
   const entries = [];
   for (const key of keys) {
     const val = obj[key];
@@ -118,27 +128,35 @@ function yamlObject(obj, indent) {
       entries.push(`${pad}${yamlKey}: ${toYaml(val, indent + 2)}`);
     } else {
       const nested = toYaml(val, indent + 2);
-      if (nested.startsWith('\n')) {
+      if (nested.startsWith("\n")) {
         entries.push(`${pad}${yamlKey}:${nested}`);
       } else {
         entries.push(`${pad}${yamlKey}:\n${indentBlock(nested, indent + 2)}`);
       }
     }
   }
-  return '\n' + entries.join('\n');
+  return "\n" + entries.join("\n");
 }
 
 function isScalar(value) {
-  return value === null || value === undefined ||
-    typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+  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');
+  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");
 }