@jamie-tam/forge 6.0.0

package/dist/manifest.js

@@ -0,0 +1,90 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+/** SHA-256 hash of file contents */
+export function hashFile(filePath) {
+    const content = readFileSync(filePath);
+    return createHash("sha256").update(content).digest("hex");
+}
+/** Recursively collect all files under a directory with their hashes, relative to base */
+export function collectHashes(dir, base) {
+    const result = {};
+    if (!existsSync(dir))
+        return result;
+    for (const entry of readdirSync(dir)) {
+        const fullPath = join(dir, entry);
+        const relPath = relative(base, fullPath);
+        if (statSync(fullPath).isDirectory()) {
+            Object.assign(result, collectHashes(fullPath, base));
+        }
+        else {
+            result[relPath] = hashFile(fullPath);
+        }
+    }
+    return result;
+}
+/** Read existing manifest from forge.json */
+export function readManifest(forgeJsonPath) {
+    if (!existsSync(forgeJsonPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(forgeJsonPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Write manifest to forge.json */
+export function writeManifest(forgeJsonPath, manifest) {
+    writeFileSync(forgeJsonPath, JSON.stringify(manifest, null, 2) + "\n");
+}
+/**
+ * Classify files into categories for update/uninstall operations.
+ * Compares installed manifest against current state and new source.
+ */
+export function classifyFiles(installedFiles, currentFiles, sourceFiles) {
+    const result = {
+        unchanged: [],
+        forgeUpdated: [],
+        userModified: [],
+        userOnly: [],
+        stale: [],
+        newFiles: [],
+    };
+    // Check files that were installed
+    for (const [file, installedHash] of Object.entries(installedFiles)) {
+        const currentHash = currentFiles[file];
+        const sourceHash = sourceFiles[file];
+        if (!sourceHash) {
+            // Forge no longer ships this file
+            result.stale.push(file);
+        }
+        else if (!currentHash) {
+            // File was deleted by user — forge will re-create
+            result.newFiles.push(file);
+        }
+        else if (currentHash === installedHash && sourceHash === installedHash) {
+            // Nobody changed it
+            result.unchanged.push(file);
+        }
+        else if (currentHash === installedHash && sourceHash !== installedHash) {
+            // Forge updated, user didn't touch — safe overwrite
+            result.forgeUpdated.push(file);
+        }
+        else if (currentHash !== installedHash && sourceHash === installedHash) {
+            // User modified, forge didn't change — preserve user version
+            result.userOnly.push(file);
+        }
+        else if (currentHash !== installedHash && sourceHash !== installedHash) {
+            // Both changed — conflict
+            result.userModified.push(file);
+        }
+    }
+    // Check files in source that weren't previously installed
+    for (const file of Object.keys(sourceFiles)) {
+        if (!installedFiles[file]) {
+            result.newFiles.push(file);
+        }
+    }
+    return result;
+}

package/dist/merge.js

@@ -0,0 +1,77 @@
+/**
+ * Marker-based merge for co-edited files (CLAUDE.md, AGENTS.md).
+ *
+ * Files are partitioned into user-owned zones (before/after markers)
+ * and a framework-managed zone (between markers). On update, the
+ * framework zone is replaced while user content is preserved.
+ */
+export const FORGE_START = "<!-- FORGE:START — do not edit between markers; updated by forge -->";
+export const FORGE_END = "<!-- FORGE:END -->";
+/** Count non-overlapping occurrences of `needle` as a full line in `text`. */
+function countMarkerLines(text, needle) {
+    let count = 0;
+    for (const line of text.split("\n")) {
+        if (line.trim() === needle)
+            count++;
+    }
+    return count;
+}
+/** Find the byte offset of a marker line within `text`. Returns -1 if not found. */
+function markerOffset(text, needle) {
+    const lines = text.split("\n");
+    let offset = 0;
+    for (const line of lines) {
+        if (line.trim() === needle)
+            return offset;
+        offset += line.length + 1; // +1 for the \n
+    }
+    return -1;
+}
+/** True if content contains exactly one START and one END marker in correct order. */
+export function hasForgeMarkers(content) {
+    return (countMarkerLines(content, FORGE_START) === 1 &&
+        countMarkerLines(content, FORGE_END) === 1 &&
+        markerOffset(content, FORGE_START) < markerOffset(content, FORGE_END));
+}
+/**
+ * Extract the forge block (START line through END line, inclusive) from content.
+ * Returns the block string and the before/after slices.
+ */
+function splitAtMarkers(content) {
+    if (!hasForgeMarkers(content))
+        return null;
+    const startOffset = markerOffset(content, FORGE_START);
+    const endOffset = markerOffset(content, FORGE_END);
+    const endLineEnd = content.indexOf("\n", endOffset);
+    const blockEnd = endLineEnd === -1 ? content.length : endLineEnd + 1;
+    return {
+        before: content.slice(0, startOffset),
+        block: content.slice(startOffset, blockEnd),
+        after: content.slice(blockEnd),
+    };
+}
+/**
+ * Merge framework content from `template` into `existing` using markers.
+ *
+ * - Extracts the FORGE block from both strings.
+ * - Replaces the existing block with the template block.
+ * - Preserves user content outside the markers exactly as-is.
+ *
+ * Returns the merged string, or null if merge is not possible
+ * (legacy file without markers, corrupted markers, duplicate markers).
+ *
+ * Throws if the template is missing valid markers (developer error).
+ */
+export function mergeForgeBlock(existing, template) {
+    // Validate template — missing markers is a developer bug
+    const tParts = splitAtMarkers(template);
+    if (!tParts) {
+        throw new Error("Template is missing valid FORGE:START/FORGE:END markers. This is a bug in the template.");
+    }
+    // Parse existing — missing/invalid markers means legacy file
+    const eParts = splitAtMarkers(existing);
+    if (!eParts)
+        return null;
+    // Replace the framework block, preserve user content
+    return eParts.before + tParts.block + eParts.after;
+}

package/dist/paths.js

@@ -0,0 +1,36 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/** Root of the forge package (one level up from dist/) */
+export const PACKAGE_ROOT = resolve(__dirname, "..");
+/** Source asset directories inside the package */
+export const SOURCE = {
+    agents: resolve(PACKAGE_ROOT, "agents"),
+    commands: resolve(PACKAGE_ROOT, "commands"),
+    skills: resolve(PACKAGE_ROOT, "skills"),
+    rules: resolve(PACKAGE_ROOT, "rules"),
+    protocols: resolve(PACKAGE_ROOT, "protocols"),
+    references: resolve(PACKAGE_ROOT, "references"),
+    hooks: resolve(PACKAGE_ROOT, "hooks"),
+    templates: resolve(PACKAGE_ROOT, "templates"),
+    claudeMdTemplate: resolve(PACKAGE_ROOT, "hooks", "templates", "CLAUDE.md.template"),
+    agentsMdTemplate: resolve(PACKAGE_ROOT, "hooks", "templates", "AGENTS.md.template"),
+};
+/** Target directories inside the user's project */
+export function targets(projectRoot) {
+    const claude = resolve(projectRoot, ".claude");
+    return {
+        claude,
+        agents: resolve(claude, "agents"),
+        commands: resolve(claude, "commands"),
+        skills: resolve(claude, "skills"),
+        rules: resolve(claude, "rules"),
+        protocols: resolve(claude, "protocols"),
+        references: resolve(claude, "references"),
+        claudeMd: resolve(claude, "CLAUDE.md"),
+        agentsMd: resolve(projectRoot, "AGENTS.md"),
+        templates: resolve(claude, "templates"),
+        forgeState: resolve(projectRoot, ".forge"),
+        forgeJson: resolve(projectRoot, ".forge", "forge.json"),
+    };
+}

package/dist/uninstall.js

@@ -0,0 +1,216 @@
+import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { cwd } from "node:process";
+import { SOURCE, targets } from "./paths.js";
+import { readManifest } from "./manifest.js";
+/**
+ * Remove only forge-managed files from a project.
+ * Uses the installed manifest (forge.json) when available for precision.
+ * Falls back to comparing against source package if manifest lacks file tracking.
+ */
+export async function uninstall(opts) {
+    const projectRoot = cwd();
+    const t = targets(projectRoot);
+    if (!existsSync(t.forgeJson)) {
+        console.log("Forge is not installed in this project.");
+        return;
+    }
+    const manifest = readManifest(t.forgeJson);
+    const prefix = opts.dryRun ? "Would remove" : "Removed";
+    console.log(`forge uninstall${opts.dryRun ? " --dry-run" : ""}${opts.purge ? " --purge" : ""}\n`);
+    let removedCount = 0;
+    let preservedCount = 0;
+    // Strategy: use manifest file list if available, fall back to source comparison
+    if (manifest?.files && Object.keys(manifest.files).length > 0) {
+        // Manifest-based removal — precise
+        console.log("Using installed file manifest for precise removal.\n");
+        for (const relPath of Object.keys(manifest.files)) {
+            const target = join(t.claude, relPath);
+            if (existsSync(target)) {
+                if (!opts.dryRun)
+                    rmSync(target);
+                console.log(`  ${prefix}: .claude/${relPath}`);
+                removedCount++;
+            }
+        }
+        // Clean up empty directories left behind
+        if (!opts.dryRun) {
+            for (const relPath of Object.keys(manifest.files)) {
+                let dir = dirname(join(t.claude, relPath));
+                while (dir !== t.claude && existsSync(dir)) {
+                    if (readdirSync(dir).length === 0) {
+                        rmSync(dir, { recursive: true });
+                    }
+                    else {
+                        break;
+                    }
+                    dir = dirname(dir);
+                }
+            }
+        }
+    }
+    else {
+        // Fallback: compare against source package
+        console.log("No file manifest — using source comparison.\n");
+        // Remove flat-dir assets
+        for (const [label, src, dest] of [
+            ["agents", SOURCE.agents, t.agents],
+            ["commands", SOURCE.commands, t.commands],
+            ["protocols", SOURCE.protocols, t.protocols],
+        ]) {
+            if (!existsSync(src) || !existsSync(dest))
+                continue;
+            const forgeFiles = readdirSync(src).filter((f) => f.endsWith(".md"));
+            for (const file of forgeFiles) {
+                const target = join(dest, file);
+                if (existsSync(target)) {
+                    if (!opts.dryRun)
+                        rmSync(target);
+                    console.log(`  ${prefix}: ${label}/${file}`);
+                    removedCount++;
+                }
+            }
+            if (!opts.dryRun && existsSync(dest) && readdirSync(dest).length === 0) {
+                rmSync(dest, { recursive: true });
+            }
+        }
+        // Remove tree-dir assets
+        for (const [label, src, dest] of [
+            ["skills", SOURCE.skills, t.skills],
+            ["templates", SOURCE.templates, t.templates],
+        ]) {
+            if (!existsSync(src) || !existsSync(dest))
+                continue;
+            const forgeDirs = readdirSync(src).filter((f) => statSync(join(src, f)).isDirectory());
+            for (const dir of forgeDirs) {
+                const target = join(dest, dir);
+                if (existsSync(target)) {
+                    if (!opts.dryRun)
+                        rmSync(target, { recursive: true });
+                    console.log(`  ${prefix}: ${label}/${dir}/`);
+                    removedCount++;
+                }
+            }
+            if (!opts.dryRun && existsSync(dest) && readdirSync(dest).length === 0) {
+                rmSync(dest, { recursive: true });
+            }
+        }
+        // Remove references (per-file in subdirs, same structure as rules)
+        if (existsSync(SOURCE.references) && existsSync(t.references)) {
+            for (const subdir of readdirSync(SOURCE.references)) {
+                const srcSub = join(SOURCE.references, subdir);
+                const destSub = join(t.references, subdir);
+                if (!statSync(srcSub).isDirectory() || !existsSync(destSub))
+                    continue;
+                for (const file of readdirSync(srcSub).filter((f) => f.endsWith(".md"))) {
+                    const target = join(destSub, file);
+                    if (existsSync(target)) {
+                        if (!opts.dryRun)
+                            rmSync(target);
+                        console.log(`  ${prefix}: references/${subdir}/${file}`);
+                        removedCount++;
+                    }
+                }
+                if (!opts.dryRun && existsSync(destSub) && readdirSync(destSub).length === 0) {
+                    rmSync(destSub, { recursive: true });
+                }
+            }
+            if (!opts.dryRun && existsSync(t.references) && readdirSync(t.references).length === 0) {
+                rmSync(t.references, { recursive: true });
+            }
+        }
+        // Remove rules (per-file in subdirs)
+        if (existsSync(SOURCE.rules) && existsSync(t.rules)) {
+            for (const subdir of readdirSync(SOURCE.rules)) {
+                const srcSub = join(SOURCE.rules, subdir);
+                const destSub = join(t.rules, subdir);
+                if (!statSync(srcSub).isDirectory() || !existsSync(destSub))
+                    continue;
+                for (const file of readdirSync(srcSub).filter((f) => f.endsWith(".md"))) {
+                    const target = join(destSub, file);
+                    if (existsSync(target)) {
+                        if (!opts.dryRun)
+                            rmSync(target);
+                        console.log(`  ${prefix}: rules/${subdir}/${file}`);
+                        removedCount++;
+                    }
+                }
+                if (!opts.dryRun && existsSync(destSub) && readdirSync(destSub).length === 0) {
+                    rmSync(destSub, { recursive: true });
+                }
+            }
+            if (!opts.dryRun && existsSync(t.rules) && readdirSync(t.rules).length === 0) {
+                rmSync(t.rules, { recursive: true });
+            }
+        }
+    }
+    // Check for user files that survived
+    for (const dir of [t.agents, t.commands, t.skills, t.rules, t.references, t.protocols, t.templates]) {
+        if (existsSync(dir)) {
+            const remaining = readdirSync(dir).length;
+            if (remaining > 0) {
+                preservedCount += remaining;
+            }
+        }
+    }
+    // Remove hooks (always forge-managed)
+    const hooksDir = join(t.claude, "hooks");
+    if (existsSync(hooksDir)) {
+        if (!opts.dryRun)
+            rmSync(hooksDir, { recursive: true });
+        console.log(`  ${prefix}: hooks/`);
+    }
+    const settingsLocal = join(t.claude, "settings.local.json");
+    if (existsSync(settingsLocal)) {
+        if (!opts.dryRun)
+            rmSync(settingsLocal);
+        console.log(`  ${prefix}: settings.local.json`);
+    }
+    // CLAUDE.md and AGENTS.md — only with --force
+    if (opts.force) {
+        if (existsSync(t.claudeMd)) {
+            if (!opts.dryRun)
+                rmSync(t.claudeMd);
+            console.log(`  ${prefix}: CLAUDE.md`);
+        }
+        if (existsSync(t.agentsMd)) {
+            if (!opts.dryRun)
+                rmSync(t.agentsMd);
+            console.log(`  ${prefix}: AGENTS.md`);
+        }
+    }
+    else {
+        if (existsSync(t.claudeMd))
+            console.log("  Preserved: CLAUDE.md (use --force to remove)");
+        if (existsSync(t.agentsMd))
+            console.log("  Preserved: AGENTS.md (use --force to remove)");
+    }
+    // .forge/ state — only with --purge
+    if (opts.purge) {
+        if (existsSync(t.forgeState)) {
+            if (!opts.dryRun)
+                rmSync(t.forgeState, { recursive: true });
+            console.log(`  ${prefix}: .forge/ (state, manifests, decisions, gotchas)`);
+        }
+    }
+    else if (existsSync(t.forgeState)) {
+        if (!opts.dryRun) {
+            // Remove forge.json (install marker) but keep user state
+            if (existsSync(t.forgeJson))
+                rmSync(t.forgeJson);
+        }
+        console.log("  Preserved: .forge/ state (use --purge to remove)");
+    }
+    // Clean up .claude/ if empty
+    if (!opts.dryRun && existsSync(t.claude)) {
+        const remaining = readdirSync(t.claude);
+        if (remaining.length === 0) {
+            rmSync(t.claude, { recursive: true });
+            console.log("  Removed: empty .claude/");
+        }
+    }
+    const summary = [`${removedCount} forge files removed`];
+    if (preservedCount > 0)
+        summary.push(`${preservedCount} user files preserved`);
+    console.log(`\n${opts.dryRun ? "Dry run complete" : "Forge uninstalled"}. ${summary.join(", ")}.`);
+}

package/dist/update.js

@@ -0,0 +1,158 @@
+import { existsSync, readdirSync, readFileSync, rmdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { cwd } from "node:process";
+import { SOURCE, targets } from "./paths.js";
+import { init } from "./init.js";
+import { classifyFiles, collectHashes, readManifest } from "./manifest.js";
+/**
+ * Recursively walk `dir` bottom-up; remove any empty subdirectories.
+ * Leaves `dir` itself untouched even if it becomes empty (caller decides).
+ * Silently skips on read/rm errors — empty-dir cleanup is best-effort.
+ */
+function pruneEmptyDirs(dir) {
+    if (!existsSync(dir))
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const child = join(dir, entry);
+        let st;
+        try {
+            st = statSync(child);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory()) {
+            pruneEmptyDirs(child);
+            try {
+                if (readdirSync(child).length === 0) {
+                    rmdirSync(child);
+                }
+            }
+            catch {
+                // not empty or unreadable — leave it
+            }
+        }
+    }
+}
+export async function update(opts) {
+    const projectRoot = cwd();
+    const t = targets(projectRoot);
+    if (!existsSync(t.forgeJson)) {
+        console.log("Forge not initialized. Run 'forge init' first.");
+        return;
+    }
+    const manifest = readManifest(t.forgeJson);
+    if (!manifest) {
+        console.log("Corrupt forge.json. Run 'forge init --force' to re-install.");
+        return;
+    }
+    const pkg = JSON.parse(readFileSync(resolve(SOURCE.agents, "..", "package.json"), "utf-8"));
+    if (manifest.version === pkg.version && !opts.force) {
+        console.log(`Already at v${manifest.version}. Use --force to re-sync.`);
+        return;
+    }
+    console.log(`forge update: v${manifest.version} → v${pkg.version}\n`);
+    // Collect current state of installed files
+    const currentFiles = {};
+    for (const dir of [t.agents, t.commands, t.skills, t.rules, t.references, t.protocols, t.templates]) {
+        if (existsSync(dir)) {
+            Object.assign(currentFiles, collectHashes(dir, t.claude));
+        }
+    }
+    // Collect source files (what the new version ships)
+    const sourceFiles = {};
+    for (const [src, prefix] of [
+        [SOURCE.agents, "agents"],
+        [SOURCE.commands, "commands"],
+        [SOURCE.skills, "skills"],
+        [SOURCE.rules, "rules"],
+        [SOURCE.references, "references"],
+        [SOURCE.protocols, "protocols"],
+        [SOURCE.templates, "templates"],
+    ]) {
+        if (existsSync(src)) {
+            const hashes = collectHashes(src, resolve(src, ".."));
+            Object.assign(sourceFiles, hashes);
+        }
+    }
+    // Classify files
+    const installedFiles = manifest.files || {};
+    const classified = classifyFiles(installedFiles, currentFiles, sourceFiles);
+    // Report what will happen
+    console.log("Update plan:");
+    if (classified.newFiles.length)
+        console.log(`  + ${classified.newFiles.length} new files`);
+    if (classified.forgeUpdated.length)
+        console.log(`  ~ ${classified.forgeUpdated.length} forge-updated (safe to overwrite)`);
+    if (classified.stale.length)
+        console.log(`  - ${classified.stale.length} stale (forge no longer ships)`);
+    if (classified.userOnly.length)
+        console.log(`  ✓ ${classified.userOnly.length} user-modified (forge unchanged — preserving)`);
+    if (classified.unchanged.length)
+        console.log(`  = ${classified.unchanged.length} unchanged`);
+    // Handle conflicts (both forge and user changed)
+    if (classified.userModified.length > 0) {
+        console.log(`\n  ⚠ ${classified.userModified.length} conflicts (both forge and user changed):`);
+        for (const f of classified.userModified) {
+            console.log(`    ${f}`);
+        }
+        if (!opts.force) {
+            console.log("\n  Use --force to overwrite conflicts, or manually merge these files.");
+            console.log("  Without --force, conflicting files are skipped.");
+        }
+        else {
+            console.log("\n  --force: forge version will overwrite user changes.");
+        }
+    }
+    if (opts.dryRun) {
+        console.log("\n--dry-run: No files were changed.");
+        return;
+    }
+    // Step 1: Remove stale files
+    for (const file of classified.stale) {
+        const target = join(t.claude, file);
+        if (existsSync(target)) {
+            rmSync(target);
+            console.log(`  Removed: ${file}`);
+        }
+    }
+    // Step 1b: Prune directories that became empty after stale-file removal.
+    // Only walks forge-owned subtrees under .claude/ — never touches the .claude/
+    // root itself (which the user owns and may contain other things).
+    for (const dir of [t.agents, t.commands, t.skills, t.rules, t.references, t.protocols, t.templates]) {
+        pruneEmptyDirs(dir);
+    }
+    // Step 2: Back up user-customized files before re-sync
+    // userOnly = user changed, forge didn't — always preserve
+    // userModified = both changed — preserve unless --force
+    const backups = new Map();
+    for (const file of classified.userOnly) {
+        const target = join(t.claude, file);
+        if (existsSync(target)) {
+            backups.set(file, readFileSync(target));
+        }
+    }
+    if (!opts.force) {
+        for (const file of classified.userModified) {
+            const target = join(t.claude, file);
+            if (existsSync(target)) {
+                backups.set(file, readFileSync(target));
+            }
+        }
+    }
+    // Step 3: Re-sync (init with force:true to overwrite forge-updated files)
+    await init({ force: true, mergeMarkers: true });
+    // Step 4: Restore user-customized files from backup
+    for (const [file, content] of backups) {
+        const target = join(t.claude, file);
+        writeFileSync(target, content);
+        console.log(`  Preserved: ${file}`);
+    }
+}

package/dist/verify-manifest.js

@@ -0,0 +1,65 @@
+/**
+ * `npx @jamie-tam/forge verify-manifest [path]` — v5 work-manifest verifier CLI.
+ *
+ * Spec: templates/manifests/v5/SCHEMA.md §5.2.
+ *
+ * Exit codes:
+ *   0  No errors
+ *   1  Verification errors (errors written to stdout)
+ *   2  Internal error (file not found, bad YAML syntax, etc.)
+ */
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { readManifest, } from "./work-manifest.js";
+/** Per SCHEMA.md §5.2: exit 2 = "internal error (file not found, bad YAML, etc.)";
+ *  exit 1 = verification errors. These error codes denote internal class. */
+const INTERNAL_ERROR_CODES = new Set([
+    "E_FILE_NOT_FOUND",
+    "E_YAML_PARSE",
+]);
+function chooseExitCode(errors) {
+    if (errors.length === 0)
+        return 0;
+    // If ALL errors are internal-class → exit 2. Otherwise verification → exit 1.
+    // (A mixed list signals real verification work; user fixes those.)
+    return errors.every((e) => INTERNAL_ERROR_CODES.has(e.code)) ? 2 : 1;
+}
+export async function verifyManifestCli(opts) {
+    const path = resolve(opts.path);
+    if (!existsSync(path)) {
+        return emitErrors(opts.json, [
+            { code: "E_FILE_NOT_FOUND", message: `manifest not found: ${path}`, path },
+        ]);
+    }
+    const result = readManifest(path);
+    if (!result.ok)
+        return emitErrors(opts.json, result.errors);
+    return emitOk(opts.json, result, `${opts.path} OK (schema=${result.schema})`);
+}
+function emitOk(json, result, msg) {
+    if (json) {
+        process.stdout.write(JSON.stringify({ ok: true, schema: result.schema, warnings: result.warnings ?? [] }) + "\n");
+    }
+    else {
+        console.log(msg);
+        for (const w of result.warnings ?? []) {
+            console.warn(`${w.code}  ${w.path}`);
+            console.warn(`  ${w.message}`);
+        }
+    }
+    return 0;
+}
+function emitErrors(json, errors) {
+    const exitCode = chooseExitCode(errors);
+    if (json) {
+        process.stdout.write(JSON.stringify({ ok: false, errors }) + "\n");
+    }
+    else {
+        for (const err of errors) {
+            console.error(`${err.code}  ${err.path}`);
+            console.error(`  ${err.message}`);
+        }
+        console.error(`\n${errors.length} error(s).`);
+    }
+    return exitCode;
+}