eidosmd 0.1.0

package/dist/src/commands/browser.js

@@ -0,0 +1,40 @@
+// `eidos browser`: the root in a local web page, on this machine only.
+import { spawn } from 'node:child_process';
+import { loadRoot } from '../context.js';
+import { EXIT_OK, print } from '../output.js';
+export const DEFAULT_PORT = 6180;
+function openInBrowser(url) {
+    const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    try {
+        spawn(command, args, { detached: true, stdio: 'ignore' }).unref();
+    }
+    catch {
+        // a machine with no opener still gets the URL on the terminal
+    }
+}
+export async function runBrowser(globals, options, cwd = process.cwd()) {
+    // Fail now, on the terminal, if there is no root, rather than on the first request.
+    const context = loadRoot(globals, cwd);
+    // Loaded here so the markdown renderer never costs the other commands their startup.
+    const { createServer, listen } = await import('../core/server.js');
+    const server = createServer({ cwd, root: context.root });
+    const port = await listen(server, options.port);
+    const url = `http://127.0.0.1:${port}/`;
+    print(`eidos browser: ${context.root}`, `  ${url}  (this machine only; press Ctrl+C to stop)`);
+    if (port !== options.port) {
+        print(`  port ${options.port} was busy`);
+    }
+    if (options.open) {
+        openInBrowser(url);
+    }
+    await new Promise((resolve) => {
+        const stop = () => {
+            server.close();
+            resolve();
+        };
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+    });
+    return EXIT_OK;
+}

package/dist/src/commands/check.js

@@ -0,0 +1,61 @@
+// `eidos check`: validate the root, or the named blueprints, against the
+// root's own framework. Findings print grouped by file; the exit code says
+// whether anything was an error.
+import path from 'node:path';
+import { checkRoot } from '../core/check.js';
+import { standardVersion } from '../paths.js';
+import { CliError, EXIT_FINDINGS, EXIT_OK, print, printJson } from '../output.js';
+function mark(finding) {
+    return finding.level === 'error' ? '✗' : '⚠';
+}
+export function runCheck(context, paths, options) {
+    let only;
+    if (paths.length > 0) {
+        only = new Set();
+        for (const given of paths) {
+            const resolved = path.resolve(context.cwd, given);
+            const match = context.blueprints.find((blueprint) => path.resolve(blueprint.path) === resolved);
+            if (!match) {
+                throw new CliError(`${given} is not a blueprint in ${context.root} (not in a declared collection, or an index.md)`);
+            }
+            only.add(match.path);
+        }
+    }
+    const report = checkRoot(context.framework, context.blueprints, { only, standardVersion: standardVersion() });
+    const failed = report.errors > 0 || (options.strict && report.warnings > 0);
+    if (options.json) {
+        printJson({
+            ok: !failed,
+            strict: options.strict,
+            root: report.root,
+            eidos_version: report.eidosVersion,
+            naming: report.naming,
+            blueprints: report.blueprints,
+            collections: report.collections,
+            errors: report.errors,
+            warnings: report.warnings,
+            findings: report.findings,
+        });
+        return failed ? EXIT_FINDINGS : EXIT_OK;
+    }
+    const scope = only ? `${report.blueprints} blueprint${report.blueprints === 1 ? '' : 's'}` : `${report.blueprints} blueprints in ${report.collections} collections`;
+    print(`${path.basename(report.root)}  (Eidos ${report.eidosVersion ?? 'unversioned'} · ${report.naming})  ${scope}`);
+    let current;
+    const codeWidth = Math.max(0, ...report.findings.map((finding) => finding.code.length));
+    for (const finding of report.findings) {
+        if (finding.path !== current) {
+            current = finding.path;
+            print('', finding.path ?? '(root)');
+        }
+        print(`  ${mark(finding)} ${finding.code.padEnd(codeWidth)}  ${finding.message}`);
+    }
+    print('');
+    if (report.findings.length === 0) {
+        print('✓ no findings');
+    }
+    else {
+        const parts = [`${report.errors} error${report.errors === 1 ? '' : 's'}`, `${report.warnings} warning${report.warnings === 1 ? '' : 's'}`];
+        print(`${failed ? '✗' : '⚠'} ${parts.join(', ')}${options.strict && report.errors === 0 && report.warnings > 0 ? ' (--strict)' : ''}`);
+    }
+    return failed ? EXIT_FINDINGS : EXIT_OK;
+}

package/dist/src/commands/convert.js

@@ -0,0 +1,30 @@
+// `eidos convert`: move a markdown root to Framework.yaml, the form the CLI works in.
+import path from 'node:path';
+import { loadRoot } from '../context.js';
+import { convertToYaml } from '../core/convert.js';
+import { EXIT_OK, print, printJson } from '../output.js';
+export function runConvert(globals, options, cwd = process.cwd()) {
+    const context = loadRoot(globals, cwd, { allowMarkdown: true });
+    const display = (file) => path.relative(cwd, file) || file;
+    if (context.framework.format === 'yaml') {
+        if (options.json) {
+            printJson({ converted: false, framework_file: display(context.framework.file), reason: 'already YAML' });
+        }
+        else {
+            print(`${display(context.framework.file)} is already the YAML form; nothing to convert`);
+        }
+        return EXIT_OK;
+    }
+    const result = convertToYaml(context.framework, options.dryRun);
+    if (options.json) {
+        printJson({ converted: !options.dryRun, dry_run: options.dryRun, framework_file: display(result.written), removed: result.removed.map(display), actions: result.actions.map(display) });
+        return EXIT_OK;
+    }
+    print(...result.actions.map(display));
+    print('', `${options.dryRun ? 'would convert' : 'converted'}: ${display(context.framework.file)} → ${display(result.written)}, index inside it`);
+    print("  left behind: the markdown form's prose (section intros, comments); each collection's description travelled. Keep anything that matters in the root's README.");
+    if (!options.dryRun) {
+        print('  next: eidos check');
+    }
+    return EXIT_OK;
+}

package/dist/src/commands/framework.js

@@ -0,0 +1,76 @@
+// `eidos framework`: what the root's framework document declares, as a human
+// summary, as JSON an agent can read instead of parsing the file, or as the
+// YAML document a scriptable root keeps on disk.
+import path from 'node:path';
+import { frameworkToDocument, serializeDocument } from '../core/framework-structured.js';
+import { CliError, EXIT_OK, print, printJson } from '../output.js';
+export function frameworkJson(framework) {
+    return {
+        root: framework.root,
+        file: path.relative(framework.root, framework.file).split(path.sep).join('/'),
+        format: framework.format,
+        ...frameworkToDocument(framework),
+    };
+}
+export function runFramework(context, options) {
+    const { framework } = context;
+    if (options.as !== undefined) {
+        if (options.as !== 'yaml') {
+            throw new CliError('--as takes yaml (the markdown form is authored, not generated)');
+        }
+        process.stdout.write(serializeDocument(frameworkToDocument(framework)));
+        return EXIT_OK;
+    }
+    if (options.json) {
+        printJson(frameworkJson(framework));
+        return EXIT_OK;
+    }
+    print(`${path.basename(framework.root)}  (Eidos ${framework.eidosVersion ?? 'unversioned'} · ${framework.naming} · ${path.basename(framework.file)})`, framework.root);
+    if (framework.problems.length > 0) {
+        print('', 'Problems');
+        for (const problem of framework.problems) {
+            print(`  ✗ ${problem}`);
+        }
+    }
+    if (framework.topLevel.length > 0) {
+        print('', 'Top-level');
+        for (const doc of framework.topLevel) {
+            print(`  ${doc.title} (${doc.path})${doc.description ? ` — ${doc.description}` : ''}`);
+        }
+    }
+    print('', 'Collections');
+    for (const collection of framework.collections) {
+        const tags = [];
+        if (collection.framing) {
+            tags.push('framing');
+        }
+        if (collection.grouping) {
+            tags.push(`grouped by ${collection.grouping.label}${collection.grouping.property ? ` (\`${collection.grouping.property}\`)` : ''}`);
+        }
+        if (collection.canvas) {
+            tags.push(collection.canvas.mode === 'file' ? 'canvas: file' : `canvas: card${collection.canvas.section ? ` from ## ${collection.canvas.section}` : ''}`);
+        }
+        print(`  ${collection.name}${tags.length > 0 ? `  (${tags.join(' · ')})` : ''}`);
+        if (collection.description) {
+            print(`    ${collection.description}`);
+        }
+        const flavors = collection.flavors.map((flavor) => `${flavor.name}${flavor.isDefault ? ' (default)' : ''}`);
+        print(`    flavors: ${flavors.length > 0 ? flavors.join(', ') : 'none declared'}`);
+        if (collection.grouping && collection.grouping.groups.length > 0) {
+            print(`    groups: ${collection.grouping.groups.map((group) => group.name).join(', ')}`);
+        }
+    }
+    print('', 'Schema');
+    print(`  core:   ${framework.schema.core.map((property) => property.name).join(', ')}`);
+    if (framework.schema.custom.length === 0) {
+        print('  custom: none');
+    }
+    else {
+        print('  custom:');
+        for (const property of framework.schema.custom) {
+            const scope = property.appliesTo === 'all' ? 'all' : property.appliesTo.join(', ');
+            print(`    ${property.name} (${property.type}, ${scope}) — ${property.meaning}`);
+        }
+    }
+    return EXIT_OK;
+}

package/dist/src/commands/index.js

@@ -0,0 +1,64 @@
+// `eidos index`: regenerate each collection's index.md, or verify them with --check.
+import path from 'node:path';
+import { buildIndexes } from '../core/index-leaf.js';
+import { findCollection } from '../core/framework.js';
+import { CliError, EXIT_FINDINGS, EXIT_OK, print, printError, printJson } from '../output.js';
+export function runIndex(context, options) {
+    let collections;
+    if (options.collection.length > 0) {
+        collections = options.collection.map((name) => {
+            const found = findCollection(context.framework, name);
+            if (!found) {
+                throw new CliError(`collection '${name}' is not declared in Framework.md`);
+            }
+            return found;
+        });
+    }
+    if (context.framework.collections.length === 0) {
+        throw new CliError('no collections declared in _eidos/Framework.md (## Collections)');
+    }
+    const results = buildIndexes(context.framework, context.blueprints, { collections, check: options.check });
+    const stale = results.some((result) => result.status === 'stale');
+    const missingSummary = results.flatMap((result) => result.missingSummary);
+    if (options.json) {
+        printJson({
+            ok: !stale,
+            check: options.check,
+            indexes: results.map((result) => ({
+                collection: result.collection.name,
+                path: path.relative(context.root, result.file).split(path.sep).join('/'),
+                status: result.status,
+                blueprints: result.count,
+            })),
+            missing_summary: missingSummary,
+        });
+        return stale ? EXIT_FINDINGS : EXIT_OK;
+    }
+    for (const result of results) {
+        const relFile = path.relative(context.root, result.file).split(path.sep).join('/');
+        const count = `${result.count} blueprint${result.count === 1 ? '' : 's'}`;
+        switch (result.status) {
+            case 'folder-missing':
+                printError(`  ✗ ${result.collection.name}: folder not found (${path.dirname(result.file)})`);
+                break;
+            case 'stale':
+                print(`  ✗ stale: ${relFile}`);
+                break;
+            case 'current':
+                print(`  ✓ current: ${result.collection.name} (${count})`);
+                break;
+            case 'written':
+                print(`  ✓ ${result.collection.name}: ${count} → ${relFile}`);
+                break;
+        }
+    }
+    if (missingSummary.length > 0) {
+        printError('\nblueprints needing a summary (write one with the owner):');
+        printError(missingSummary.map((file) => `  · ${file}`).join('\n'));
+    }
+    if (stale) {
+        printError('\n✗ indexes are stale; run: eidos index');
+        return EXIT_FINDINGS;
+    }
+    return EXIT_OK;
+}

package/dist/src/commands/init.js

@@ -0,0 +1,66 @@
+// `eidos init`: create a root from a bundled seed.
+import path from 'node:path';
+import { installSeed, InstallError, listSeeds } from '../core/seed.js';
+import { isNaming, NAMINGS } from '../core/naming.js';
+import { seedsDir } from '../paths.js';
+import { CliError, EXIT_OK, print, printJson } from '../output.js';
+export function runInit(rootArg, options, cwd = process.cwd()) {
+    if (!isNaming(options.naming)) {
+        throw new CliError(`--naming must be one of: ${NAMINGS.join(', ')}`);
+    }
+    const naming = options.naming;
+    const known = listSeeds(seedsDir).map((seed) => seed.name);
+    if (!known.includes(options.seed)) {
+        throw new CliError(`no seed '${options.seed}'; bundled seeds: ${known.join(', ')}`);
+    }
+    const root = path.resolve(cwd, rootArg ?? 'Blueprints');
+    let result;
+    try {
+        result = installSeed({
+            seedsDir,
+            seed: options.seed,
+            root,
+            naming,
+            groups: options.group,
+            product: options.product ?? null,
+            date: options.date,
+            dryRun: options.dryRun,
+        });
+    }
+    catch (cause) {
+        if (cause instanceof InstallError) {
+            throw new CliError(cause.message);
+        }
+        throw cause;
+    }
+    if (options.json) {
+        printJson({
+            root: result.root,
+            seed: result.seed,
+            eidos_version: result.eidosVersion,
+            naming: result.naming,
+            framework_file: result.frameworkFile,
+            collections: result.collections,
+            grouped_collection: result.groupedCollection,
+            groups: result.groups,
+            scaffolded: result.scaffolded,
+            actions: result.actions,
+            dry_run: options.dryRun,
+        });
+        return EXIT_OK;
+    }
+    const display = (text) => text.split(root).join(path.relative(cwd, root) || '.').split(seedsDir).join('<seeds>');
+    print(...result.actions.map(display));
+    const verb = options.dryRun ? 'would install' : 'installed';
+    print('', `${verb}: seed '${result.seed}' (Eidos ${result.eidosVersion ?? '?'}) → ${display(result.root)}, naming ${result.naming}, framework ${display(result.frameworkFile)}`);
+    let collections = `  collections: ${result.collections.join(', ')}`;
+    if (result.groups.length > 0 && result.groupedCollection) {
+        collections += `; groups under ${result.groupedCollection}: ${result.groups.join(', ')}`;
+    }
+    print(collections);
+    if (result.scaffolded.length > 0) {
+        print(`  blank frames: ${result.scaffolded.join(', ')}`);
+    }
+    print(`  still yours: the README's one-liner, each group's description in ${path.basename(result.frameworkFile)}, and every scaffolded blueprint's summary and body.`, '  next: eidos instructions overview');
+    return EXIT_OK;
+}

package/dist/src/commands/instructions.js

@@ -0,0 +1,40 @@
+// `eidos instructions`: the workflow an agent follows in a root, one guide at
+// a time, and `eidos standard`: the text of the standard this CLI carries.
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { instructionsDir, readStandard, standardVersion } from '../paths.js';
+import { CliError, EXIT_OK, print } from '../output.js';
+export const GUIDES = [
+    { name: 'overview', summary: 'Required first read before answering any request in a root' },
+    { name: 'authoring', summary: 'How to place, scaffold, fill, and check a blueprint with the owner' },
+    { name: 'validating', summary: 'How to run a check, read its findings, and report a review' },
+    { name: 'configuring', summary: 'How to add a collection, a flavor, or a property, and keep the Framework current' },
+    { name: 'init-required', summary: 'How to create a root when there is none here' },
+];
+export function guideText(name) {
+    const file = path.join(instructionsDir, `${name}.md`);
+    if (!existsSync(file)) {
+        throw new CliError(`no guide '${name}'; guides: ${GUIDES.map((guide) => guide.name).join(', ')}`);
+    }
+    return readFileSync(file, 'utf8');
+}
+export function runInstructions(guide) {
+    if (guide !== undefined) {
+        process.stdout.write(guideText(guide));
+        return EXIT_OK;
+    }
+    print('Eidos instructions', '', 'Start here:', "  'eidos instructions overview'            Required first read before answering any request", "  'eidos <command> --help'                 Show options, output, and examples", '', 'Guides:');
+    for (const entry of GUIDES) {
+        print(`  ${entry.name}`, `    'eidos instructions ${entry.name}'`, `      -> ${entry.summary}`);
+    }
+    print('', `The standard itself: 'eidos standard' (Eidos ${standardVersion()})`);
+    return EXIT_OK;
+}
+export function runStandard(options) {
+    if (options.version) {
+        print(standardVersion());
+        return EXIT_OK;
+    }
+    process.stdout.write(readStandard());
+    return EXIT_OK;
+}

package/dist/src/commands/list.js

@@ -0,0 +1,73 @@
+// `eidos list`: the blueprints in the root, filterable by collection, group,
+// flavor, or any property value.
+import { blueprintId, blueprintTitle, propertyString, resolveFlavor } from '../core/blueprint.js';
+import { findCollection } from '../core/framework.js';
+import { CliError, EXIT_OK, print, printJson, table } from '../output.js';
+export function blueprintJson(blueprint) {
+    const { flavor, declared } = resolveFlavor(blueprint);
+    return {
+        id: blueprintId(blueprint),
+        title: blueprintTitle(blueprint),
+        summary: propertyString(blueprint, 'summary'),
+        collection: blueprint.collection.name,
+        group: blueprint.group,
+        flavor: flavor?.name ?? declared,
+        path: blueprint.rel,
+        properties: blueprint.properties ?? {},
+    };
+}
+function matchesWhere(blueprint, clause) {
+    const eq = clause.indexOf('=');
+    if (eq === -1) {
+        throw new CliError(`--where expects key=value, got '${clause}'`);
+    }
+    const key = clause.slice(0, eq).trim();
+    const wanted = clause.slice(eq + 1).trim().toLowerCase();
+    const value = blueprint.properties?.[key];
+    if (value === undefined || value === null) {
+        return wanted === '';
+    }
+    if (Array.isArray(value)) {
+        return value.some((item) => String(item).toLowerCase() === wanted);
+    }
+    return String(value).toLowerCase() === wanted;
+}
+export function runList(context, collectionArg, options) {
+    let selected = context.blueprints;
+    if (collectionArg !== undefined) {
+        const collection = findCollection(context.framework, collectionArg);
+        if (!collection) {
+            const known = context.framework.collections.map((candidate) => candidate.name).join(', ');
+            throw new CliError(`no collection '${collectionArg}' (declared: ${known})`);
+        }
+        selected = selected.filter((blueprint) => blueprint.collection === collection);
+    }
+    if (options.group !== undefined) {
+        const wanted = options.group.toLowerCase();
+        selected = selected.filter((blueprint) => blueprint.group?.toLowerCase() === wanted);
+    }
+    if (options.flavor !== undefined) {
+        const wanted = options.flavor.toLowerCase();
+        selected = selected.filter((blueprint) => resolveFlavor(blueprint).flavor?.name.toLowerCase() === wanted);
+    }
+    for (const clause of options.where) {
+        selected = selected.filter((blueprint) => matchesWhere(blueprint, clause));
+    }
+    if (options.json) {
+        printJson(selected.map(blueprintJson));
+        return EXIT_OK;
+    }
+    if (selected.length === 0) {
+        print('no blueprints match');
+        return EXIT_OK;
+    }
+    const rows = selected.map((blueprint) => [
+        blueprintId(blueprint) ?? '(no id)',
+        blueprintTitle(blueprint),
+        blueprint.group === null ? blueprint.collection.name : `${blueprint.collection.name}/${blueprint.group}`,
+        resolveFlavor(blueprint).flavor?.name ?? '?',
+    ]);
+    print(...table([['ID', 'TITLE', 'COLLECTION', 'FLAVOR'], ...rows]));
+    print('', `${selected.length} blueprint${selected.length === 1 ? '' : 's'}`);
+    return EXIT_OK;
+}

package/dist/src/commands/new.js

@@ -0,0 +1,68 @@
+// `eidos new`: scaffold one blueprint, born conforming.
+import { mkdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { scaffoldBlueprint, ScaffoldError } from '../core/scaffold.js';
+import { CliError, EXIT_OK, print, printJson } from '../output.js';
+function parseSet(clauses) {
+    const out = {};
+    for (const clause of clauses) {
+        const eq = clause.indexOf('=');
+        if (eq === -1) {
+            throw new CliError(`--set expects key=value, got '${clause}'`);
+        }
+        out[clause.slice(0, eq).trim()] = clause.slice(eq + 1);
+    }
+    return out;
+}
+export function runNew(context, collection, titleWords, options) {
+    let result;
+    try {
+        result = scaffoldBlueprint(context.framework, context.blueprints, {
+            collection,
+            title: titleWords.join(' '),
+            flavor: options.flavor ?? null,
+            group: options.group ?? null,
+            id: options.id ?? null,
+            summary: options.summary ?? null,
+            set: parseSet(options.set),
+            date: options.date,
+        });
+    }
+    catch (cause) {
+        if (cause instanceof ScaffoldError) {
+            throw new CliError(cause.message);
+        }
+        throw cause;
+    }
+    if (!options.dryRun) {
+        mkdirSync(path.dirname(result.path), { recursive: true });
+        writeFileSync(result.path, result.content, 'utf8');
+    }
+    if (options.json) {
+        printJson({
+            path: result.rel,
+            absolute_path: result.path,
+            id: result.id,
+            collection: result.collection.name,
+            group: result.group,
+            flavor: result.flavor.name,
+            dry_run: options.dryRun,
+            notes: result.notes,
+            content: options.dryRun ? result.content : undefined,
+        });
+        return EXIT_OK;
+    }
+    if (options.dryRun) {
+        print(`would write ${result.rel}:`, '', result.content);
+    }
+    else {
+        print(`✓ ${result.rel}  (${result.collection.name}, ${result.flavor.kind}.${result.flavor.name}, id ${result.id})`);
+    }
+    for (const note of result.notes) {
+        print(`  ! ${note}`);
+    }
+    if (!options.dryRun) {
+        print('  next: fill the summary and the body with the owner, then `eidos check` and `eidos index`');
+    }
+    return EXIT_OK;
+}

package/dist/src/commands/seeds.js

@@ -0,0 +1,40 @@
+// `eidos seeds`: the bundled starting frameworks, read from their own Framework.md.
+import { listSeeds } from '../core/seed.js';
+import { seedsDir } from '../paths.js';
+import { EXIT_OK, print, printJson } from '../output.js';
+export function runSeeds(options) {
+    const seeds = listSeeds(seedsDir);
+    if (options.json) {
+        printJson(seeds.map((seed) => ({
+            name: seed.name,
+            eidos_version: seed.framework.eidosVersion,
+            collections: seed.framework.collections.map((collection) => ({
+                name: collection.name,
+                framing: collection.framing,
+                description: collection.description,
+                grouping: collection.grouping?.label ?? null,
+                flavors: collection.flavors.map((flavor) => ({ name: flavor.name, description: flavor.description, default: flavor.isDefault })),
+            })),
+        })));
+        return EXIT_OK;
+    }
+    for (const seed of seeds) {
+        print('', `${seed.name}  (Eidos ${seed.framework.eidosVersion ?? '?'})`);
+        for (const collection of seed.framework.collections) {
+            let role = 'flat';
+            if (collection.framing) {
+                role = 'framing';
+            }
+            else if (collection.grouping) {
+                role = `grouped by ${collection.grouping.label.toLowerCase()}`;
+            }
+            print(`  ${collection.name} — ${role}`, `    ${collection.description}`);
+            for (const flavor of collection.flavors) {
+                const marker = flavor.isDefault ? ' (default)' : '';
+                print(flavor.description ? `    · ${flavor.name} — ${flavor.description}${marker}` : `    · ${flavor.name}${marker}`);
+            }
+        }
+    }
+    print('', 'install one: eidos init [root] --seed <name> [--naming <convention>] [--group <Group>]... [--product <Name>]');
+    return EXIT_OK;
+}

package/dist/src/commands/show.js

@@ -0,0 +1,24 @@
+// `eidos show`: one blueprint, by id, filename, or path; the file as written,
+// or with --json its properties and sections parsed out.
+import { readFileSync } from 'node:fs';
+import { resolveBlueprint } from '../core/blueprint.js';
+import { CliError, EXIT_OK, printJson } from '../output.js';
+import { blueprintJson } from './list.js';
+export function runShow(context, ref, options) {
+    const blueprint = resolveBlueprint(ref, context.blueprints, context.cwd);
+    if (!blueprint) {
+        throw new CliError(`no blueprint '${ref}' (by id, filename, or path); try: eidos list`);
+    }
+    if (options.json) {
+        printJson({
+            ...blueprintJson(blueprint),
+            absolute_path: blueprint.path,
+            frontmatter_error: blueprint.frontmatterError,
+            sections: blueprint.sections.map((section) => ({ heading: section.heading.text, body: section.body })),
+            body: blueprint.body,
+        });
+        return EXIT_OK;
+    }
+    process.stdout.write(readFileSync(blueprint.path, 'utf8'));
+    return EXIT_OK;
+}