@thehumanpatternlab/hpl 0.0.1-alpha.5

package/dist/lib/notes.js

@@ -0,0 +1,62 @@
+import fs from "node:fs";
+import path from "node:path";
+import matter from "gray-matter";
+import { z } from "zod";
+const FrontmatterSchema = z.object({
+    id: z.string().optional(),
+    type: z.string().optional(),
+    title: z.string(),
+    subtitle: z.string().optional(),
+    published: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    summary: z.string().optional(),
+    readingTime: z.number().optional(),
+    status: z.enum(["published", "draft", "archived"]).optional(),
+    dept: z.string().optional(),
+    department_id: z.string().optional(),
+    shadow_density: z.number().optional(),
+    safer_landing: z.boolean().optional(),
+    slug: z.string().optional()
+});
+function slugFromFilename(filePath) {
+    const base = path.basename(filePath);
+    return base.replace(/\.mdx?$/i, "");
+}
+export function readNote(filePath, locale) {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = matter(raw);
+    const fm = FrontmatterSchema.parse(parsed.data ?? {});
+    const slug = (fm.slug && String(fm.slug).trim()) || slugFromFilename(filePath);
+    const body = parsed.content.trim();
+    const markdown = body.length > 0 ? body : raw.trim();
+    // Keep full attributes, but ensure key stuff exists
+    const title = (fm.title && String(fm.title).trim()) || "";
+    if (!title) {
+        throw new Error(`Missing required frontmatter: title (${filePath})`);
+    }
+    if (!markdown) {
+        throw new Error(`Missing required markdown content (${filePath})`);
+    }
+    return {
+        slug,
+        locale,
+        attributes: { ...fm, slug },
+        markdown
+    };
+}
+export function listMarkdownFiles(dir) {
+    const out = [];
+    const stack = [dir];
+    while (stack.length) {
+        const d = stack.pop();
+        const entries = fs.readdirSync(d, { withFileTypes: true });
+        for (const e of entries) {
+            const p = path.join(d, e.name);
+            if (e.isDirectory())
+                stack.push(p);
+            else if (e.isFile() && /\.mdx?$/i.test(e.name))
+                out.push(p);
+        }
+    }
+    return out.sort();
+}

package/dist/lib/output.js

@@ -0,0 +1,21 @@
+// Output is a contract. If it breaks, it should break loudly.
+function getRootCommand(cmd) {
+    let cur = cmd;
+    while (cur.parent)
+        cur = cur.parent;
+    return cur;
+}
+export function getOutputMode(cmd) {
+    const root = getRootCommand(cmd);
+    const opts = root.opts?.() ?? {};
+    return opts.json ? "json" : "human";
+}
+export function printJson(data) {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+export function printError(message) {
+    process.stderr.write(message + "\n");
+}
+export function printJsonError(message, extra) {
+    process.stderr.write(JSON.stringify({ ok: false, error: { message, extra } }, null, 2) + "\n");
+}

package/dist/sdk/LabClient.js

@@ -0,0 +1,94 @@
+// src/sdk/LabClient.ts
+export class LabClient {
+    baseUrl;
+    token;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.token = token;
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    headers() {
+        const h = {
+            'Content-Type': 'application/json'
+        };
+        if (this.token) {
+            h['Authorization'] = `Bearer ${this.token}`;
+        }
+        return h;
+    }
+    //
+    // ────────────────────────────────────────────────
+    //   PUBLIC ROUTES
+    // ────────────────────────────────────────────────
+    //
+    async getAllNotes() {
+        const res = await fetch(`${this.baseUrl}/`, {
+            method: 'GET',
+            headers: this.headers()
+        });
+        if (!res.ok)
+            throw new Error('Failed to fetch notes');
+        return res.json();
+    }
+    async getNoteBySlug(slug) {
+        const res = await fetch(`${this.baseUrl}/notes/${slug}`, {
+            method: 'GET',
+            headers: this.headers()
+        });
+        if (!res.ok)
+            throw new Error('Note not found');
+        return res.json();
+    }
+    //
+    // ────────────────────────────────────────────────
+    //   ADMIN ROUTES
+    // ────────────────────────────────────────────────
+    //
+    async getAdminNotes() {
+        const res = await fetch(`${this.baseUrl}/api/admin/notes`, {
+            method: 'GET',
+            credentials: 'include',
+            headers: this.headers()
+        });
+        if (!res.ok)
+            throw new Error('Failed to fetch admin notes');
+        return res.json();
+    }
+    async createOrUpdateNote(input) {
+        const res = await fetch(`${this.baseUrl}/api/admin/notes`, {
+            method: 'POST',
+            credentials: 'include',
+            headers: this.headers(),
+            body: JSON.stringify(input)
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throw new Error(err.error || 'Failed to save note');
+        }
+        return res.json();
+    }
+    async deleteNote(id) {
+        const res = await fetch(`${this.baseUrl}/api/admin/notes/${id}`, {
+            method: 'DELETE',
+            credentials: 'include',
+            headers: this.headers()
+        });
+        if (!res.ok)
+            throw new Error('Failed to delete note');
+        return res.json();
+    }
+    //
+    // ────────────────────────────────────────────────
+    //   HEALTH
+    // ────────────────────────────────────────────────
+    //
+    async health() {
+        const res = await fetch(`${this.baseUrl}/api/health`, {
+            method: 'GET',
+            headers: this.headers()
+        });
+        return res.json();
+    }
+}

package/dist/src/__tests__/config.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { SKULK_BASE_URL, SKULK_TOKEN } from '../lib/config.js';
+describe('env config', () => {
+    beforeEach(() => {
+        delete process.env.SKULK_BASE_URL;
+        delete process.env.SKULK_TOKEN;
+        delete process.env.HPL_API_BASE_URL;
+        delete process.env.HPL_TOKEN;
+    });
+    it('uses SKULK_TOKEN when set', () => {
+        process.env.SKULK_TOKEN = 'abc123';
+        expect(SKULK_TOKEN()).toBe('abc123');
+    });
+    it('uses SKULK_BASE_URL when set', () => {
+        process.env.SKULK_BASE_URL = 'https://example.com/api';
+        expect(SKULK_BASE_URL()).toBe('https://example.com/api');
+    });
+    it('override beats SKULK_BASE_URL', () => {
+        process.env.SKULK_BASE_URL = 'https://example.com/api';
+        expect(SKULK_BASE_URL('https://override.com/api')).toBe('https://override.com/api');
+    });
+});

package/dist/src/__tests__/outputContract.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+import { buildSyncReport } from '../cli/outputContract.js';
+describe('buildSyncReport (JSON contract)', () => {
+    it('counts synced in live mode (dryRun=false)', () => {
+        const report = buildSyncReport({
+            dryRun: false,
+            locale: 'en',
+            baseUrl: 'https://example.com/api',
+            results: [
+                { file: 'a.md', slug: 'a', status: 'ok', action: 'updated' },
+                { file: 'b.md', slug: 'b', status: 'ok', action: 'created' },
+            ],
+        });
+        expect(report.ok).toBe(true);
+        expect(report.summary).toEqual({
+            synced: 2,
+            dryRun: 0,
+            failed: 0,
+            total: 2,
+        });
+        expect(report.results.every((r) => r.written === true)).toBe(true);
+    });
+    it('counts dryRun in dry-run mode (dryRun=true)', () => {
+        const report = buildSyncReport({
+            dryRun: true,
+            results: [
+                { file: 'a.md', slug: 'a', status: 'dry-run' },
+                { file: 'b.md', slug: 'b', status: 'dry-run' },
+            ],
+        });
+        expect(report.ok).toBe(true);
+        expect(report.dryRun).toBe(true);
+        expect(report.summary).toEqual({
+            synced: 0,
+            dryRun: 2,
+            failed: 0,
+            total: 2,
+        });
+        expect(report.results.every((r) => r.written === false)).toBe(true);
+    });
+    it('normalizes legacy fail -> failed and keeps totals balanced', () => {
+        const report = buildSyncReport({
+            dryRun: false,
+            results: [
+                { file: 'a.md', slug: 'a', status: 'ok' },
+                { file: 'b.md', status: 'fail', error: 'boom' },
+            ],
+        });
+        expect(report.ok).toBe(false);
+        expect(report.summary).toEqual({
+            synced: 1,
+            dryRun: 0,
+            failed: 1,
+            total: 2,
+        });
+        expect(report.results[1].status).toBe('failed');
+    });
+});

package/dist/src/cli/output.js

@@ -0,0 +1,21 @@
+// Output is a contract. If it breaks, it should break loudly.
+function getRootCommand(cmd) {
+    let cur = cmd;
+    while (cur.parent)
+        cur = cur.parent;
+    return cur;
+}
+export function getOutputMode(cmd) {
+    const root = getRootCommand(cmd);
+    const opts = root.opts?.() ?? {};
+    return opts.json ? "json" : "human";
+}
+export function printJson(data) {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+export function printError(message) {
+    process.stderr.write(message + "\n");
+}
+export function printJsonError(message, extra) {
+    process.stderr.write(JSON.stringify({ ok: false, error: { message, extra } }, null, 2) + "\n");
+}

package/dist/src/cli/outputContract.js

@@ -0,0 +1,32 @@
+// src/cli/outputContract.ts
+import { buildSyncSummary } from "../sync/summary.js";
+function normalizeResult(r, dryRunFlag) {
+    const status = r.status === "fail" ? "failed" : "ok"; // "dry-run" is not a failure
+    // If any result claims "dry-run", treat it as dry-run even if flag is off (safety)
+    const effectiveDryRun = dryRunFlag || r.status === "dry-run";
+    return {
+        file: r.file,
+        slug: r.slug,
+        status,
+        action: r.action,
+        error: r.error,
+        // written only when not dry-run and ok
+        written: !effectiveDryRun && status === "ok",
+    };
+}
+export function buildSyncReport(args) {
+    const { results, dryRun, locale, baseUrl } = args;
+    const normalized = results.map((r) => normalizeResult(r, dryRun));
+    // IMPORTANT: pass the effective dryRun mode you used for written calc
+    // If you want to be ultra strict, you could compute effectiveDryRun = dryRun || any(r.status==="dry-run")
+    const effectiveDryRun = dryRun || results.some((r) => r.status === "dry-run");
+    const summary = buildSyncSummary(normalized, effectiveDryRun);
+    return {
+        ok: summary.failed === 0,
+        summary,
+        results: normalized,
+        dryRun: effectiveDryRun,
+        locale,
+        baseUrl,
+    };
+}

package/dist/src/commands/capabilities.js

@@ -0,0 +1,10 @@
+/* ===========================================================
+   🌌 HUMAN PATTERN LAB — COMMAND: capabilities
+   =========================================================== */
+import { getAlphaIntent } from "../contract/intents";
+import { ok } from "../contract/envelope";
+import { getCapabilitiesAlpha } from "../contract/capabilities";
+export function runCapabilities(commandName = "capabilities") {
+    const intent = getAlphaIntent("show_capabilities");
+    return ok(commandName, intent, getCapabilitiesAlpha());
+}

package/dist/src/commands/health.js

@@ -0,0 +1,48 @@
+/* ===========================================================
+   🌌 HUMAN PATTERN LAB — COMMAND: health
+   =========================================================== */
+import { z } from "zod";
+import { getAlphaIntent } from "../contract/intents";
+import { ok, err } from "../contract/envelope";
+import { EXIT } from "../contract/exitCodes";
+import { getJson, HttpError } from "../http/client";
+const HealthSchema = z.object({
+    status: z.string(),
+    dbPath: z.string().optional(),
+});
+export async function runHealth(commandName = "health") {
+    const intent = getAlphaIntent("check_health");
+    try {
+        const payload = await getJson("/health");
+        const parsed = HealthSchema.safeParse(payload);
+        if (!parsed.success) {
+            return {
+                envelope: err(commandName, intent, {
+                    code: "E_CONTRACT",
+                    message: "Health response did not match expected schema",
+                    details: parsed.error.flatten(),
+                }),
+                exitCode: EXIT.CONTRACT,
+            };
+        }
+        return { envelope: ok(commandName, intent, parsed.data), exitCode: EXIT.OK };
+    }
+    catch (e) {
+        if (e instanceof HttpError) {
+            const code = e.status && e.status >= 500 ? "E_SERVER" : "E_HTTP";
+            return {
+                envelope: err(commandName, intent, {
+                    code,
+                    message: `API request failed (${e.status ?? "unknown"})`,
+                    details: e.body ? e.body.slice(0, 500) : undefined,
+                }),
+                exitCode: e.status && e.status >= 500 ? EXIT.SERVER : EXIT.NETWORK,
+            };
+        }
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+            envelope: err(commandName, intent, { code: "E_UNKNOWN", message: msg }),
+            exitCode: EXIT.UNKNOWN,
+        };
+    }
+}

package/dist/src/commands/notes/get.js

@@ -0,0 +1,48 @@
+/* ===========================================================
+   🌌 HUMAN PATTERN LAB — COMMAND: notes get <slug>
+   =========================================================== */
+import { getAlphaIntent } from "../../contract/intents";
+import { ok, err } from "../../contract/envelope";
+import { EXIT } from "../../contract/exitCodes";
+import { getJson, HttpError } from "../../http/client";
+import { LabNoteSchema } from "../../types/labNotes";
+export async function runNotesGet(slug, commandName = "notes get") {
+    const intent = getAlphaIntent("render_lab_note");
+    try {
+        const payload = await getJson(`/lab-notes/${encodeURIComponent(slug)}`);
+        const parsed = LabNoteSchema.safeParse(payload);
+        if (!parsed.success) {
+            return {
+                envelope: err(commandName, intent, {
+                    code: "E_CONTRACT",
+                    message: "Lab Note did not match expected schema",
+                    details: parsed.error.flatten(),
+                }),
+                exitCode: EXIT.CONTRACT,
+            };
+        }
+        const note = parsed.data;
+        return { envelope: ok(commandName, intent, note), exitCode: EXIT.OK };
+    }
+    catch (e) {
+        if (e instanceof HttpError) {
+            if (e.status == 404) {
+                return {
+                    envelope: err(commandName, intent, { code: "E_NOT_FOUND", message: `No lab note found for slug: ${slug}` }),
+                    exitCode: EXIT.NOT_FOUND,
+                };
+            }
+            const code = e.status && e.status >= 500 ? "E_SERVER" : "E_HTTP";
+            return {
+                envelope: err(commandName, intent, {
+                    code,
+                    message: `API request failed (${e.status ?? "unknown"})`,
+                    details: e.body ? e.body.slice(0, 500) : undefined,
+                }),
+                exitCode: e.status && e.status >= 500 ? EXIT.SERVER : EXIT.NETWORK,
+            };
+        }
+        const msg = e instanceof Error ? e.message : String(e);
+        return { envelope: err(commandName, intent, { code: "E_UNKNOWN", message: msg }), exitCode: EXIT.UNKNOWN };
+    }
+}

package/dist/src/commands/notes/list.js

@@ -0,0 +1,43 @@
+/* ===========================================================
+   🌌 HUMAN PATTERN LAB — COMMAND: notes list
+   =========================================================== */
+import { getAlphaIntent } from "../../contract/intents";
+import { ok, err } from "../../contract/envelope";
+import { EXIT } from "../../contract/exitCodes";
+import { getJson, HttpError } from "../../http/client";
+import { LabNoteListSchema } from "../../types/labNotes";
+export async function runNotesList(commandName = "notes list") {
+    const intent = getAlphaIntent("render_lab_note");
+    try {
+        const payload = await getJson("/lab-notes");
+        const parsed = LabNoteListSchema.safeParse(payload);
+        if (!parsed.success) {
+            return {
+                envelope: err(commandName, intent, {
+                    code: "E_CONTRACT",
+                    message: "Lab Notes list did not match expected schema",
+                    details: parsed.error.flatten(),
+                }),
+                exitCode: EXIT.CONTRACT,
+            };
+        }
+        // Deterministic: preserve API order, but ensure stable array type.
+        const notes = parsed.data;
+        return { envelope: ok(commandName, intent, { count: notes.length, notes }), exitCode: EXIT.OK };
+    }
+    catch (e) {
+        if (e instanceof HttpError) {
+            const code = e.status && e.status >= 500 ? "E_SERVER" : "E_HTTP";
+            return {
+                envelope: err(commandName, intent, {
+                    code,
+                    message: `API request failed (${e.status ?? "unknown"})`,
+                    details: e.body ? e.body.slice(0, 500) : undefined,
+                }),
+                exitCode: e.status && e.status >= 500 ? EXIT.SERVER : EXIT.NETWORK,
+            };
+        }
+        const msg = e instanceof Error ? e.message : String(e);
+        return { envelope: err(commandName, intent, { code: "E_UNKNOWN", message: msg }), exitCode: EXIT.UNKNOWN };
+    }
+}

package/dist/src/commands/notesSync.js

@@ -0,0 +1,191 @@
+/* ===========================================================
+   🦊 THE HUMAN PATTERN LAB — SKULK CLI
+   -----------------------------------------------------------
+   Author: Ada (Founder, The Human Pattern Lab)
+   Assistant: Lyric (AI Lab Companion)
+   File: notesSync.ts
+   Module: Notes Command Suite
+   Lab Unit: SCMS — Systems & Code Management Suite
+   Status: Active
+   -----------------------------------------------------------
+   Purpose:
+     Implements `skulk notes sync` — syncing local markdown Lab Notes
+     to the Lab API with predictable behavior in both human and
+     automation contexts.
+   -----------------------------------------------------------
+   Key Behaviors:
+     - Human mode: readable progress + summaries
+     - JSON mode (--json): stdout emits ONLY valid JSON (contract)
+     - Errors: stderr only
+     - Exit codes: deterministic (non-zero only on failure)
+   -----------------------------------------------------------
+   Notes:
+     JSON output is a contract. If it breaks, it should break loudly.
+   =========================================================== */
+/**
+ * @file notesSync.ts
+ * @author Ada
+ * @assistant Lyric
+ * @lab-unit SCMS — Systems & Code Management Suite
+ * @since 2025-12-28
+ * @description Syncs markdown Lab Notes to the API via `skulk notes sync`.
+ *              Supports human + JSON output modes; JSON mode is stdout-pure.
+ */
+import { Command } from 'commander';
+import { SKULK_BASE_URL, SKULK_TOKEN } from '../lib/config.js';
+import { httpJson } from '../lib/http.js';
+import { listMarkdownFiles, readNote } from '../lib/notes.js';
+import { getOutputMode, printJson } from '../cli/output.js';
+import { buildSyncReport } from '../cli/outputContract.js';
+import fs from 'node:fs';
+async function upsertNote(baseUrl, token, note, locale) {
+    const payload = {
+        slug: note.slug,
+        title: note.attributes.title,
+        markdown: note.markdown,
+        locale,
+    };
+    if (!payload.slug || !payload.title || !payload.markdown) {
+        throw new Error(`Invalid note payload: slug/title/markdown missing for ${payload.slug ?? 'unknown'}`);
+    }
+    return httpJson({ baseUrl, token }, 'POST', '/lab-notes/upsert', payload);
+}
+export function notesSyncCommand() {
+    const notes = new Command('notes').description('Lab Notes commands');
+    notes
+        .command('sync')
+        .description('Sync local markdown notes to the API')
+        .option('--dir <path>', 'Directory containing markdown notes', './src/labnotes/en')
+        //.option("--dir <path>", "Directory containing markdown notes", "./labnotes/en")
+        .option('--locale <code>', 'Locale code', 'en')
+        .option('--base-url <url>', 'Override API base URL (ex: https://thehumanpatternlab.com/api)')
+        .option('--dry-run', 'Print what would be sent, but do not call the API', false)
+        .option('--only <slug>', 'Sync only a single note by slug')
+        .option('--limit <n>', 'Sync only the first N notes', (v) => parseInt(v, 10))
+        .action(async (opts, cmd) => {
+        const mode = getOutputMode(cmd); // "json" | "human"
+        const jsonError = (message, extra) => {
+            if (mode === 'json') {
+                process.stderr.write(JSON.stringify({ ok: false, error: { message, extra } }, null, 2) +
+                    '\n');
+            }
+            else {
+                console.error(message);
+                if (extra)
+                    console.error(extra);
+            }
+            process.exitCode = 1;
+        };
+        if (!fs.existsSync(opts.dir)) {
+            jsonError(`Notes directory not found: ${opts.dir}`, {
+                hint: `Try: skulk notes sync --dir "..\\\\the-human-pattern-lab\\\\src\\\\labnotes\\\\en"`,
+            });
+            return;
+        }
+        const baseUrl = SKULK_BASE_URL(opts.baseUrl);
+        const token = SKULK_TOKEN();
+        const files = listMarkdownFiles(opts.dir);
+        let selectedFiles = files;
+        if (opts.only) {
+            selectedFiles = files.filter((f) => f.toLowerCase().includes(opts.only.toLowerCase()));
+        }
+        if (opts.limit && Number.isFinite(opts.limit)) {
+            selectedFiles = selectedFiles.slice(0, opts.limit);
+        }
+        if (selectedFiles.length === 0) {
+            if (mode === 'json') {
+                printJson({
+                    ok: true,
+                    action: 'noop',
+                    message: 'No matching notes found.',
+                    matched: 0,
+                });
+            }
+            else {
+                console.log('No matching notes found.');
+            }
+            process.exitCode = 0;
+            return;
+        }
+        // Human-mode header chatter
+        if (mode === 'human') {
+            console.log(`Skulk syncing ${selectedFiles.length} note(s) from ${opts.dir}`);
+            console.log(`API: ${baseUrl}`);
+            console.log(`Locale: ${opts.locale}`);
+            console.log(opts.dryRun ? 'Mode: DRY RUN (no writes)' : 'Mode: LIVE (writing)');
+        }
+        let ok = 0;
+        let fail = 0;
+        const results = [];
+        for (const file of selectedFiles) {
+            try {
+                const note = readNote(file, opts.locale);
+                if (opts.dryRun) {
+                    ok++;
+                    results.push({
+                        file,
+                        slug: note.slug,
+                        status: 'dry-run',
+                    });
+                    if (mode === 'human') {
+                        console.log(`\n---\n${note.slug}\n${file}\nfrontmatter keys: ${Object.keys(note.attributes).join(', ')}`);
+                    }
+                    continue;
+                }
+                const res = await upsertNote(baseUrl, token, note, opts.locale);
+                ok++;
+                results.push({
+                    file,
+                    slug: note.slug,
+                    status: 'ok',
+                    action: res.action,
+                });
+                if (mode === 'human') {
+                    console.log(`✅ ${note.slug} (${res.action ?? 'ok'})`);
+                }
+            }
+            catch (e) {
+                fail++;
+                const msg = String(e);
+                results.push({
+                    file,
+                    status: 'fail',
+                    error: msg,
+                });
+                if (mode === 'human') {
+                    console.error(`❌ ${file}`);
+                    console.error(msg);
+                }
+            }
+        }
+        if (mode === 'json') {
+            const report = buildSyncReport({
+                results,
+                dryRun: Boolean(opts.dryRun),
+                locale: opts.locale,
+                baseUrl,
+            });
+            printJson(report);
+            if (!report.ok)
+                process.exitCode = 1;
+        }
+        else {
+            const report = buildSyncReport({
+                results,
+                dryRun: Boolean(opts.dryRun),
+                locale: opts.locale,
+                baseUrl,
+            });
+            const { synced, dryRun, failed } = report.summary;
+            if (report.dryRun) {
+                console.log(`\nDone. ${dryRun} note(s) would be synced (dry-run). Failures: ${failed}`);
+            }
+            else {
+                console.log(`\nDone. ${synced} note(s) synced successfully. Failures: ${failed}`);
+            }
+            if (!report.ok)
+                process.exitCode = 1;
+        }
+    });
+    return notes;
+}

package/dist/src/commands/version.js

@@ -0,0 +1,12 @@
+/* ===========================================================
+   🌌 HUMAN PATTERN LAB — COMMAND: version
+   =========================================================== */
+import { createRequire } from "node:module";
+import { getAlphaIntent } from "../contract/intents";
+import { ok } from "../contract/envelope";
+const require = createRequire(import.meta.url);
+const pkg = require("../../package.json");
+export function runVersion(commandName = "version") {
+    const intent = getAlphaIntent("show_version");
+    return ok(commandName, intent, { name: pkg.name, version: pkg.version });
+}