@thehumanpatternlab/hpl 0.0.1-alpha.5 → 1.0.0

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

@@ -1,16 +1,35 @@
 /* ===========================================================
-   🌌 HUMAN PATTERN LAB — COMMAND: notes get <slug>
+   🦊 THE HUMAN PATTERN LAB — HPL CLI
+   -----------------------------------------------------------
+   File: get.ts
+   Role: Notes subcommand: `hpl notes get <slug>`
+   Author: Ada (The Human Pattern Lab)
+   Assistant: Lyric
+   Lab Unit: SCMS — Systems & Code Management Suite
+   Status: Active
+   -----------------------------------------------------------
+   Design:
+     - Core function returns { envelope, exitCode }
+     - Commander adapter decides json vs human rendering
+     - Markdown is canonical (content_markdown)
    =========================================================== */
-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") {
+import { Command } from "commander";
+import { getOutputMode, printJson } from "../../cli/output.js";
+import { renderText } from "../../render/text.js";
+import { LabNoteDetailSchema } from "../../types/labNotes.js";
+import { getAlphaIntent } from "../../contract/intents.js";
+import { ok, err } from "../../contract/envelope.js";
+import { EXIT } from "../../contract/exitCodes.js";
+import { getJson, HttpError } from "../../http/client.js";
+/**
+ * Core: fetch a single published Lab Note (detail).
+ * Returns structured envelope + exitCode (no printing here).
+ */
+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);
+        const parsed = LabNoteDetailSchema.safeParse(payload);
         if (!parsed.success) {
             return {
                 envelope: err(commandName, intent, {
@@ -21,14 +40,16 @@ export async function runNotesGet(slug, commandName = "notes get") {
                 exitCode: EXIT.CONTRACT,
             };
         }
-        const note = parsed.data;
-        return { envelope: ok(commandName, intent, note), exitCode: EXIT.OK };
+        return { envelope: ok(commandName, intent, parsed.data), exitCode: EXIT.OK };
     }
     catch (e) {
         if (e instanceof HttpError) {
-            if (e.status == 404) {
+            if (e.status === 404) {
                 return {
-                    envelope: err(commandName, intent, { code: "E_NOT_FOUND", message: `No lab note found for slug: ${slug}` }),
+                    envelope: err(commandName, intent, {
+                        code: "E_NOT_FOUND",
+                        message: `No lab note found for slug: ${slug}`,
+                    }),
                     exitCode: EXIT.NOT_FOUND,
                 };
             }
@@ -46,3 +67,22 @@ export async function runNotesGet(slug, commandName = "notes get") {
         return { envelope: err(commandName, intent, { code: "E_UNKNOWN", message: msg }), exitCode: EXIT.UNKNOWN };
     }
 }
+/**
+ * Commander: `hpl notes get <slug>`
+ */
+export function notesGetSubcommand() {
+    return new Command("get")
+        .description("Get a Lab Note by slug (contract: render_lab_note)")
+        .argument("<slug>", "Lab Note slug")
+        .action(async (slug, opts, cmd) => {
+        const mode = getOutputMode(cmd);
+        const { envelope, exitCode } = await runNotesGet(slug, "notes.get");
+        if (mode === "json") {
+            printJson(envelope);
+        }
+        else {
+            renderText(envelope);
+        }
+        process.exitCode = exitCode;
+    });
+}

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

@@ -1,16 +1,37 @@
 /* ===========================================================
-   🌌 HUMAN PATTERN LAB — COMMAND: notes list
+   🦊 THE HUMAN PATTERN LAB — HPL CLI
+   -----------------------------------------------------------
+   File: list.ts
+   Role: Notes subcommand: `hpl notes list`
+   Author: Ada (The Human Pattern Lab)
+   Assistant: Lyric
+   Lab Unit: SCMS — Systems & Code Management Suite
+   Status: Active
+   -----------------------------------------------------------
+   Design:
+     - Core function returns { envelope, exitCode }
+     - Commander adapter decides json vs human rendering
+     - JSON mode emits stdout-only structured data
    =========================================================== */
-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") {
+import { Command } from "commander";
+import { getOutputMode, printJson } from "../../cli/output.js";
+import { formatTags, renderTable, safeLine } from "../../render/table.js";
+import { renderText } from "../../render/text.js";
+import { LabNotePreviewListSchema } from "../../types/labNotes.js";
+import { getAlphaIntent } from "../../contract/intents.js";
+import { ok, err } from "../../contract/envelope.js";
+import { EXIT } from "../../contract/exitCodes.js";
+import { getJson, HttpError } from "../../http/client.js";
+/**
+ * Core: fetch the published lab note previews.
+ * Returns structured envelope + exitCode (no printing here).
+ */
+export async function runNotesList(commandName = "notes.list", locale) {
     const intent = getAlphaIntent("render_lab_note");
     try {
-        const payload = await getJson("/lab-notes");
-        const parsed = LabNoteListSchema.safeParse(payload);
+        const qp = locale ? `?locale=${encodeURIComponent(locale)}` : "";
+        const payload = await getJson(`/lab-notes${qp}`);
+        const parsed = LabNotePreviewListSchema.safeParse(payload);
         if (!parsed.success) {
             return {
                 envelope: err(commandName, intent, {
@@ -21,9 +42,7 @@ export async function runNotesList(commandName = "notes list") {
                 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 };
+        return { envelope: ok(commandName, intent, parsed.data), exitCode: EXIT.OK };
     }
     catch (e) {
         if (e instanceof HttpError) {
@@ -41,3 +60,40 @@ export async function runNotesList(commandName = "notes list") {
         return { envelope: err(commandName, intent, { code: "E_UNKNOWN", message: msg }), exitCode: EXIT.UNKNOWN };
     }
 }
+/* ----------------------------------------
+   Helper: human table renderer for notes
+----------------------------------------- */
+function renderNotesListTable(envelope) {
+    const rows = Array.isArray(envelope?.data) ? envelope.data : [];
+    const cols = [
+        { header: "Title", width: 32, value: (r) => safeLine(r?.title ?? "-") },
+        { header: "Slug", width: 26, value: (r) => safeLine(r?.slug ?? "-") },
+        { header: "Locale", width: 6, value: (r) => safeLine(r?.locale ?? "-") },
+        { header: "Type", width: 8, value: (r) => safeLine(r?.type ?? "-") },
+        { header: "Tags", width: 24, value: (r) => formatTags(r?.tags) },
+    ];
+    console.log(renderTable(rows, cols));
+}
+/* ----------------------------------------
+   Subcommand builder
+----------------------------------------- */
+export function notesListSubcommand() {
+    return new Command("list")
+        .description("List published Lab Notes (contract: render_lab_note)")
+        .action(async (opts, cmd) => {
+        const mode = getOutputMode(cmd);
+        const { envelope, exitCode } = await runNotesList("notes.list", opts.locale);
+        if (mode === "json") {
+            printJson(envelope);
+        }
+        else {
+            try {
+                renderNotesListTable(envelope);
+            }
+            catch {
+                renderText(envelope);
+            }
+        }
+        process.exitCode = exitCode;
+    });
+}

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

@@ -0,0 +1,36 @@
+/* ===========================================================
+   🦊 THE HUMAN PATTERN LAB — HPL CLI
+   -----------------------------------------------------------
+   File: notes.ts
+   Role: Notes command assembler (domain root)
+   Author: Ada (The Human Pattern Lab)
+   Assistant: Lyric
+   Lab Unit: SCMS — Systems & Code Management Suite
+   Status: Active
+   -----------------------------------------------------------
+   Purpose:
+     Defines the `hpl notes` command tree and mounts subcommands:
+       - hpl notes list
+       - hpl notes get <slug>
+       - hpl notes sync
+   -----------------------------------------------------------
+   Design:
+     - This file is wiring only (no network calls, no rendering)
+     - Subcommands own their own output logic and contracts
+   =========================================================== */
+import { Command } from "commander";
+import { notesListSubcommand } from "./list.js";
+import { notesGetSubcommand } from "./get.js";
+import { notesSyncSubcommand } from "./notesSync.js";
+import { notesCreateSubcommand } from "./create.js";
+import { notesUpdateSubcommand } from "./update.js";
+export function notesCommand() {
+    const notes = new Command("notes").description("Lab Notes commands");
+    // Subcommands
+    notes.addCommand(notesListSubcommand());
+    notes.addCommand(notesGetSubcommand());
+    notes.addCommand(notesCreateSubcommand());
+    notes.addCommand(notesUpdateSubcommand());
+    notes.addCommand(notesSyncSubcommand());
+    return notes;
+}

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

@@ -0,0 +1,221 @@
+/* ===========================================================
+   🦊 THE HUMAN PATTERN LAB — HPL CLI
+   -----------------------------------------------------------
+   File: notesSync.ts
+   Role: Notes subcommand: `hpl notes sync`
+   Author: Ada (The Human Pattern Lab)
+   Assistant: Lyric
+   Lab Unit: SCMS — Systems & Code Management Suite
+   Status: Active
+   -----------------------------------------------------------
+   Purpose:
+     Sync local markdown Lab Notes to the Lab API with predictable
+     behavior in both human and automation contexts.
+
+     Supports content-ledger workflows via --content-repo (clones
+     the content repo locally, then syncs from it).
+   -----------------------------------------------------------
+   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)
+   =========================================================== */
+import fs from "node:fs";
+import path from "node:path";
+import { Command } from "commander";
+import { HPL_BASE_URL, HPL_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 { resolveContentRepo } from "../../lib/contentRepo.js";
+import { LabNoteUpsertSchema } from "../../types/labNotes.js";
+async function upsertNote(baseUrl, token, note, locale) {
+    const payload = {
+        slug: note.slug,
+        title: note.attributes.title,
+        markdown: note.markdown,
+        locale,
+        // Optional fields if your note parser provides them
+        subtitle: note.attributes.subtitle,
+        summary: note.attributes.summary,
+        tags: note.attributes.tags,
+        published: note.attributes.published,
+        status: note.attributes.status,
+        type: note.attributes.type,
+        dept: note.attributes.dept,
+    };
+    const parsed = LabNoteUpsertSchema.safeParse(payload);
+    if (!parsed.success) {
+        throw new Error(`Invalid LabNoteUpsertPayload: ${parsed.error.message}`);
+    }
+    return httpJson({ baseUrl, token }, "POST", "/lab-notes/upsert", parsed.data);
+}
+/**
+ * Commander: `hpl notes sync`
+ */
+export function notesSyncSubcommand() {
+    return new Command("sync")
+        .description("Sync markdown notes to the API")
+        // IMPORTANT: do NOT default --dir here (it conflicts with repo-first flows)
+        .option("--dir <path>", "Directory containing markdown notes")
+        .option("--content-repo <repo>", "GitHub owner/name or URL for Lab Notes content repo (or HPL_CONTENT_REPO env)")
+        .option("--content-ref <ref>", "Branch, tag, or SHA to checkout (default: main)")
+        .option("--content-subdir <path>", "Subdirectory inside repo containing labnotes (default: labnotes)")
+        .option("--cache-dir <path>", "Local cache directory for cloned content repos")
+        .option("--locale <code>", "Locale code", "en")
+        .option("--base-url <url>", "Override API base URL (ex: https://api.thehumanpatternlab.com)")
+        .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;
+        };
+        // -----------------------------
+        // Resolve content source → rootDir
+        // -----------------------------
+        const envRepo = String(process.env.SKULK_CONTENT_REPO ?? "").trim();
+        const repoArg = String(opts.contentRepo ?? "").trim() || envRepo;
+        const dirRaw = String(opts.dir ?? "").trim();
+        const dirArg = dirRaw || (!repoArg ? "./src/labnotes/en" : "");
+        const ref = String(opts.contentRef ?? "main").trim() || "main";
+        const subdir = String(opts.contentSubdir ?? "labnotes").trim() || "labnotes";
+        const cacheDir = String(opts.cacheDir ?? "").trim() || undefined;
+        if (dirArg && repoArg) {
+            jsonError("Use only one content source: either --dir OR --content-repo (or SKULK_CONTENT_REPO), not both.", { dir: dirArg, contentRepo: repoArg });
+            return;
+        }
+        let rootDir;
+        let source;
+        try {
+            if (repoArg) {
+                const resolved = await resolveContentRepo({
+                    repo: repoArg,
+                    ref,
+                    cacheDir,
+                    quietStdout: mode === "json", // keep stdout clean for JSON mode
+                });
+                rootDir = path.join(resolved.dir, subdir);
+                source = { kind: "repo", repo: repoArg, ref, subdir, dir: rootDir };
+            }
+            else {
+                rootDir = dirArg;
+                source = { kind: "dir", dir: rootDir };
+            }
+        }
+        catch (e) {
+            jsonError("Failed to resolve content source.", {
+                error: String(e),
+                repo: repoArg || undefined,
+                dir: dirArg || undefined,
+            });
+            return;
+        }
+        if (!fs.existsSync(rootDir)) {
+            jsonError(`Notes directory not found: ${rootDir}`, {
+                hintRepo: "If using repo mode, verify the repo contains labnotes/<locale>/",
+                hintDir: `Try: hpl notes sync --dir "..\\\\the-human-pattern-lab\\\\src\\\\labnotes\\\\en"`,
+                source,
+            });
+            return;
+        }
+        // -----------------------------
+        // Continue with existing sync flow
+        // -----------------------------
+        const baseUrl = HPL_BASE_URL(opts.baseUrl);
+        const token = HPL_TOKEN();
+        const files = listMarkdownFiles(rootDir);
+        let selectedFiles = files;
+        if (opts.only) {
+            selectedFiles = files.filter((f) => f.toLowerCase().includes(String(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,
+                    source,
+                });
+            }
+            else {
+                console.log("No matching notes found.");
+            }
+            process.exitCode = 0;
+            return;
+        }
+        if (mode === "human") {
+            console.log(`HPL syncing ${selectedFiles.length} note(s) from ${rootDir}`);
+            if (source.kind === "repo") {
+                console.log(`Content Repo: ${source.repo} @ ${source.ref} (${source.subdir})`);
+            }
+            console.log(`API: ${baseUrl}`);
+            console.log(`Locale: ${opts.locale}`);
+            console.log(opts.dryRun ? "Mode: DRY RUN (no writes)" : "Mode: LIVE (writing)");
+        }
+        const results = [];
+        for (const file of selectedFiles) {
+            try {
+                const note = readNote(file, opts.locale);
+                if (opts.dryRun) {
+                    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);
+                results.push({ file, slug: note.slug, status: "ok", action: res.action });
+                if (mode === "human") {
+                    console.log(`✅ ${note.slug} (${res.action ?? "ok"})`);
+                }
+            }
+            catch (e) {
+                const msg = String(e);
+                results.push({ file, status: "fail", error: msg });
+                if (mode === "human") {
+                    console.error(`❌ ${file}`);
+                    console.error(msg);
+                }
+            }
+        }
+        const report = buildSyncReport({
+            results,
+            dryRun: Boolean(opts.dryRun),
+            locale: opts.locale,
+            baseUrl,
+        });
+        if (mode === "json") {
+            // Attach source without rewriting your contract builder (minimal + safe).
+            printJson({ ...report, source });
+            if (!report.ok)
+                process.exitCode = 1;
+        }
+        else {
+            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;
+        }
+    });
+}

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

@@ -0,0 +1,217 @@
+/* ===========================================================
+   🦊 THE HUMAN PATTERN LAB — HPL CLI
+   -----------------------------------------------------------
+   File: update.ts
+   Role: Notes subcommand: `hpl notes update`
+   Author: Ada (The Human Pattern Lab)
+   Assistant: Claude
+   Lab Unit: SCMS — Systems & Code Management Suite
+   Status: Active
+   -----------------------------------------------------------
+   Purpose:
+     Update an existing Lab Note via API using the upsert endpoint.
+     Supports both markdown file input and inline content.
+   -----------------------------------------------------------
+   Design:
+     - Core function returns { envelope, exitCode }
+     - Commander adapter decides json vs human rendering
+     - Requires authentication via HPL_TOKEN
+     - Uses upsert endpoint (same as create)
+   =========================================================== */
+import fs from "node:fs";
+import { Command } from "commander";
+import { getOutputMode, printJson } from "../../cli/output.js";
+import { renderText } from "../../render/text.js";
+import { LabNoteUpsertSchema } from "../../types/labNotes.js";
+import { HPL_TOKEN } from "../../lib/config.js";
+import { getAlphaIntent } from "../../contract/intents.js";
+import { ok, err } from "../../contract/envelope.js";
+import { EXIT } from "../../contract/exitCodes.js";
+import { postJson, HttpError } from "../../http/client.js";
+/**
+ * Core: update an existing Lab Note.
+ * Returns structured envelope + exitCode (no printing here).
+ */
+export async function runNotesUpdate(options, commandName = "notes.update") {
+    const intent = getAlphaIntent("update_lab_note");
+    // Authentication check
+    const token = HPL_TOKEN();
+    if (!token) {
+        return {
+            envelope: err(commandName, intent, {
+                code: "E_AUTH",
+                message: "Authentication required. Set HPL_TOKEN environment variable or configure token in ~/.humanpatternlab/hpl.json",
+            }),
+            exitCode: EXIT.AUTH,
+        };
+    }
+    // Get markdown content if provided
+    let markdown;
+    if (options.file) {
+        if (!fs.existsSync(options.file)) {
+            return {
+                envelope: err(commandName, intent, {
+                    code: "E_NOT_FOUND",
+                    message: `File not found: ${options.file}`,
+                }),
+                exitCode: EXIT.NOT_FOUND,
+            };
+        }
+        try {
+            markdown = fs.readFileSync(options.file, "utf-8");
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return {
+                envelope: err(commandName, intent, {
+                    code: "E_IO",
+                    message: `Failed to read file: ${msg}`,
+                }),
+                exitCode: EXIT.IO,
+            };
+        }
+    }
+    else if (options.markdown) {
+        markdown = options.markdown;
+    }
+    // For updates, we need at least title OR markdown
+    if (!options.title && !markdown) {
+        return {
+            envelope: err(commandName, intent, {
+                code: "E_VALIDATION",
+                message: "Must provide at least --title or --markdown/--file for update",
+            }),
+            exitCode: EXIT.VALIDATION,
+        };
+    }
+    // Build payload - use required fields from what's provided
+    // The API will handle partial updates if it supports them, 
+    // or we provide what we have
+    const payload = {
+        slug: options.slug,
+    };
+    if (options.title)
+        payload.title = options.title;
+    if (markdown)
+        payload.markdown = markdown;
+    if (options.locale)
+        payload.locale = options.locale;
+    if (options.subtitle)
+        payload.subtitle = options.subtitle;
+    if (options.summary)
+        payload.summary = options.summary;
+    if (options.tags)
+        payload.tags = options.tags;
+    if (options.published)
+        payload.published = options.published;
+    if (options.status)
+        payload.status = options.status;
+    if (options.type)
+        payload.type = options.type;
+    if (options.dept)
+        payload.dept = options.dept;
+    // The upsert endpoint requires title and markdown
+    // For an update operation, if these aren't provided, we should fetch the existing note first
+    if (!payload.title || !payload.markdown) {
+        return {
+            envelope: err(commandName, intent, {
+                code: "E_VALIDATION",
+                message: "Update requires both --title and (--markdown or --file). For partial updates, use the API directly or fetch the existing note first.",
+            }),
+            exitCode: EXIT.VALIDATION,
+        };
+    }
+    // Validate payload
+    const parsed = LabNoteUpsertSchema.safeParse(payload);
+    if (!parsed.success) {
+        return {
+            envelope: err(commandName, intent, {
+                code: "E_VALIDATION",
+                message: "Invalid note data",
+                details: parsed.error.flatten(),
+            }),
+            exitCode: EXIT.VALIDATION,
+        };
+    }
+    // Make API request
+    try {
+        const response = await postJson("/lab-notes/upsert", parsed.data, token);
+        return {
+            envelope: ok(commandName, intent, {
+                slug: response.slug,
+                action: response.action ?? "updated",
+                message: `Lab Note ${response.action ?? "updated"}: ${response.slug}`,
+            }),
+            exitCode: EXIT.OK,
+        };
+    }
+    catch (e) {
+        if (e instanceof HttpError) {
+            if (e.status === 401 || e.status === 403) {
+                return {
+                    envelope: err(commandName, intent, {
+                        code: "E_AUTH",
+                        message: "Authentication failed. Check your HPL_TOKEN.",
+                    }),
+                    exitCode: EXIT.AUTH,
+                };
+            }
+            if (e.status === 404) {
+                return {
+                    envelope: err(commandName, intent, {
+                        code: "E_NOT_FOUND",
+                        message: `No lab note found for slug: ${options.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,
+        };
+    }
+}
+/**
+ * Commander: `hpl notes update`
+ */
+export function notesUpdateSubcommand() {
+    return new Command("update")
+        .description("Update an existing Lab Note (contract: update_lab_note)")
+        .argument("<slug>", "Note slug to update")
+        .option("--title <title>", "Note title")
+        .option("--markdown <text>", "Markdown content (inline)")
+        .option("--file <path>", "Path to markdown file")
+        .option("--locale <code>", "Locale code")
+        .option("--subtitle <text>", "Note subtitle")
+        .option("--summary <text>", "Note summary")
+        .option("--tags <tags>", "Comma-separated tags", (val) => val.split(",").map((t) => t.trim()))
+        .option("--published <date>", "Publication date (ISO format)")
+        .option("--status <status>", "Note status (draft|published|archived)")
+        .option("--type <type>", "Note type (labnote|paper|memo|lore|weather)")
+        .option("--dept <dept>", "Department code")
+        .action(async (slug, opts, cmd) => {
+        const mode = getOutputMode(cmd);
+        const { envelope, exitCode } = await runNotesUpdate({ ...opts, slug }, "notes.update");
+        if (mode === "json") {
+            printJson(envelope);
+        }
+        else {
+            renderText(envelope);
+        }
+        process.exitCode = exitCode;
+    });
+}

package/dist/src/commands/notesSync.js

@@ -58,7 +58,7 @@ export function notesSyncCommand() {
         .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('--base-url <url>', 'Override API base URL (ex: https://api.thehumanpatternlab.com)')
         .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))