stego-cli 0.3.3 → 0.4.0

package/dist/comments/comments-command.js

@@ -1,68 +1,173 @@
 import fs from "node:fs";
 import path from "node:path";
-import { addCommentToManuscript } from "./add-comment.js";
+import { addCommentToState, clearResolvedInState, deleteCommentInState, ensureNoParseErrors, loadCommentDocumentState, renderStateDocument, replyToCommentInState, serializeLoadedState, setCommentStatusInState, syncAnchorsInState } from "./comment-domain.js";
 import { CommentsCommandError } from "./errors.js";
 /** Handles `stego comments ...` command group. */
 export async function runCommentsCommand(options, cwd) {
     const [subcommand, manuscriptArg] = options._;
-    if (subcommand !== "add") {
-        throw new CommentsCommandError("INVALID_USAGE", 2, "Unknown comments subcommand. Use: stego comments add <manuscript> [--message <text> | --input <path|->].");
+    if (!subcommand) {
+        throw new CommentsCommandError("INVALID_USAGE", 2, "Comments subcommand is required. Use: read, add, reply, set-status, delete, clear-resolved, sync-anchors.");
     }
     if (!manuscriptArg) {
-        throw new CommentsCommandError("INVALID_USAGE", 2, "Manuscript path is required. Use: stego comments add <manuscript> ...");
+        throw new CommentsCommandError("INVALID_USAGE", 2, "Manuscript path is required. Use: stego comments <subcommand> <manuscript> ...");
     }
     const outputFormat = parseOutputFormat(readString(options, "format"));
-    const messageOption = readString(options, "message");
-    const inputOption = readString(options, "input");
-    if (messageOption && inputOption) {
-        throw new CommentsCommandError("INVALID_USAGE", 2, "Use exactly one payload mode: --message <text> OR --input <path|->.", outputFormat);
+    const manuscriptPath = path.resolve(cwd, manuscriptArg);
+    const raw = readManuscript(manuscriptPath, manuscriptArg);
+    let state = loadCommentDocumentState(raw);
+    switch (subcommand) {
+        case "read": {
+            emitSuccess({
+                operation: "read",
+                manuscript: manuscriptPath,
+                state: serializeLoadedState(state)
+            }, outputFormat, `Read comments for ${path.relative(cwd, manuscriptPath) || manuscriptPath}.`);
+            return;
+        }
+        case "add": {
+            ensureMutableState(state, outputFormat);
+            const addInput = resolveAddInput(options, cwd, outputFormat);
+            const result = runMutation(manuscriptPath, state, outputFormat, () => addCommentToState(raw, state, addInput), (mutationResult) => mutationResult.comments);
+            state = result.state;
+            emitSuccess({
+                operation: "add",
+                manuscript: manuscriptPath,
+                commentId: result.meta.commentId,
+                state: serializeLoadedState(state)
+            }, outputFormat, `Added ${result.meta.commentId} to ${path.relative(cwd, manuscriptPath) || manuscriptPath}.`);
+            return;
+        }
+        case "reply": {
+            ensureMutableState(state, outputFormat);
+            const commentId = requireCommentId(options, outputFormat);
+            const { message, author } = resolveReplyInput(options, cwd, outputFormat);
+            const result = runMutation(manuscriptPath, state, outputFormat, () => replyToCommentInState(state, { commentId, message, author }), (mutationResult) => mutationResult.comments);
+            state = result.state;
+            emitSuccess({
+                operation: "reply",
+                manuscript: manuscriptPath,
+                commentId: result.meta.commentId,
+                state: serializeLoadedState(state)
+            }, outputFormat, `Added reply ${result.meta.commentId} in ${path.relative(cwd, manuscriptPath) || manuscriptPath}.`);
+            return;
+        }
+        case "set-status": {
+            ensureMutableState(state, outputFormat);
+            const commentId = requireCommentId(options, outputFormat);
+            const status = parseStatus(readString(options, "status"), outputFormat);
+            const thread = options.thread === true;
+            const result = runMutation(manuscriptPath, state, outputFormat, () => setCommentStatusInState(state, { commentId, status, thread }), (mutationResult) => mutationResult.comments);
+            state = result.state;
+            emitSuccess({
+                operation: "set-status",
+                manuscript: manuscriptPath,
+                status,
+                changedIds: result.meta.changedIds,
+                state: serializeLoadedState(state)
+            }, outputFormat, `Updated ${result.meta.changedIds.length} comment(s) to '${status}'.`);
+            return;
+        }
+        case "delete": {
+            ensureMutableState(state, outputFormat);
+            const commentId = requireCommentId(options, outputFormat);
+            const result = runMutation(manuscriptPath, state, outputFormat, () => deleteCommentInState(state, commentId), (mutationResult) => mutationResult.comments);
+            state = result.state;
+            emitSuccess({
+                operation: "delete",
+                manuscript: manuscriptPath,
+                removed: result.meta.removed,
+                state: serializeLoadedState(state)
+            }, outputFormat, `Deleted ${result.meta.removed} comment(s).`);
+            return;
+        }
+        case "clear-resolved": {
+            ensureMutableState(state, outputFormat);
+            const result = runMutation(manuscriptPath, state, outputFormat, () => clearResolvedInState(state), (mutationResult) => mutationResult.comments);
+            state = result.state;
+            emitSuccess({
+                operation: "clear-resolved",
+                manuscript: manuscriptPath,
+                removed: result.meta.removed,
+                state: serializeLoadedState(state)
+            }, outputFormat, `Cleared ${result.meta.removed} resolved comment(s).`);
+            return;
+        }
+        case "sync-anchors": {
+            ensureMutableState(state, outputFormat);
+            const payload = readInputPayload(requireInputPath(options, outputFormat), cwd, outputFormat);
+            const syncInput = parseSyncInput(payload, outputFormat);
+            const result = runMutation(manuscriptPath, state, outputFormat, () => syncAnchorsInState(raw, state, syncInput), (mutationResult) => mutationResult.comments);
+            state = result.state;
+            emitSuccess({
+                operation: "sync-anchors",
+                manuscript: manuscriptPath,
+                updatedCount: result.meta.updatedCount,
+                deletedCount: result.meta.deletedCount,
+                state: serializeLoadedState(state)
+            }, outputFormat, `Synced anchors (${result.meta.updatedCount} updated, ${result.meta.deletedCount} deleted).`);
+            return;
+        }
+        default:
+            throw new CommentsCommandError("INVALID_USAGE", 2, `Unknown comments subcommand '${subcommand}'. Use: read, add, reply, set-status, delete, clear-resolved, sync-anchors.`, outputFormat);
     }
-    if (!messageOption && !inputOption) {
-        throw new CommentsCommandError("INVALID_USAGE", 2, "Missing payload. Provide --message <text> or --input <path|->.", outputFormat);
+}
+function runMutation(manuscriptPath, state, outputFormat, run, getComments) {
+    let mutationResult;
+    try {
+        mutationResult = run();
     }
-    const payload = inputOption ? readInputPayload(inputOption, cwd, outputFormat) : undefined;
-    const payloadMessage = coerceNonEmptyString(payload?.message, "Input payload 'message' must be a non-empty string.", outputFormat);
-    const payloadAuthor = coerceOptionalString(payload?.author, "Input payload 'author' must be a string if provided.", outputFormat);
-    const payloadRange = payload?.range !== undefined
-        ? parsePayloadRange(payload.range, outputFormat)
-        : undefined;
-    const payloadMeta = payload?.meta !== undefined
-        ? coerceOptionalObject(payload.meta, "Input payload 'meta' must be an object if provided.", outputFormat)
-        : undefined;
-    const optionRange = parseRangeFromOptions(options, outputFormat);
-    const finalMessage = (messageOption ?? payloadMessage ?? "").trim();
-    if (!finalMessage) {
-        throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Comment message cannot be empty.", outputFormat);
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CommentsCommandError("INVALID_PAYLOAD", 4, message, outputFormat);
     }
-    const finalAuthor = (readString(options, "author") ?? payloadAuthor ?? "Saurus").trim() || "Saurus";
-    const finalRange = optionRange ?? payloadRange;
-    let result;
+    const nextComments = getComments(mutationResult);
+    const nextText = renderStateDocument(state, nextComments);
     try {
-        result = addCommentToManuscript({
-            manuscriptPath: manuscriptArg,
-            cwd,
-            message: finalMessage,
-            author: finalAuthor,
-            range: finalRange,
-            sourceMeta: payloadMeta
-        });
+        fs.writeFileSync(manuscriptPath, nextText, "utf8");
     }
     catch (error) {
-        if (error instanceof CommentsCommandError && outputFormat === "json" && error.outputFormat !== "json") {
-            throw new CommentsCommandError(error.code, error.exitCode, error.message, outputFormat);
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CommentsCommandError("WRITE_FAILURE", 6, `Failed to update manuscript: ${message}`, outputFormat);
+    }
+    const nextState = loadCommentDocumentState(nextText);
+    return {
+        meta: mutationResult,
+        state: nextState
+    };
+}
+function ensureMutableState(state, outputFormat) {
+    try {
+        ensureNoParseErrors(state);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CommentsCommandError("COMMENT_APPENDIX_INVALID", 5, message, outputFormat);
+    }
+}
+function readManuscript(absolutePath, originalArg) {
+    try {
+        const stat = fs.statSync(absolutePath);
+        if (!stat.isFile()) {
+            throw new CommentsCommandError("INVALID_USAGE", 2, `Manuscript file not found: ${originalArg}`);
         }
-        throw error;
     }
-    if (outputFormat === "json") {
-        console.log(JSON.stringify(result, null, 2));
-        return;
+    catch {
+        throw new CommentsCommandError("INVALID_USAGE", 2, `Manuscript file not found: ${originalArg}`);
+    }
+    try {
+        return fs.readFileSync(absolutePath, "utf8");
     }
-    const relativePath = path.relative(cwd, result.manuscript) || result.manuscript;
-    if (result.anchor.type === "selection") {
-        console.log(`Added ${result.commentId} to ${relativePath} (selection anchor).`);
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CommentsCommandError("INVALID_USAGE", 2, `Unable to read manuscript: ${message}`);
+    }
+}
+function emitSuccess(payload, outputFormat, textMessage) {
+    if (outputFormat === "json") {
+        console.log(JSON.stringify({ ok: true, ...payload }, null, 2));
         return;
     }
-    console.log(`Added ${result.commentId} to ${relativePath} (file-level anchor).`);
+    console.log(textMessage);
 }
 function readString(options, key) {
     const value = options[key];
@@ -77,6 +182,13 @@ function parseOutputFormat(raw) {
     }
     throw new CommentsCommandError("INVALID_USAGE", 2, "Invalid --format value. Use 'text' or 'json'.");
 }
+function requireInputPath(options, outputFormat) {
+    const value = readString(options, "input");
+    if (!value) {
+        throw new CommentsCommandError("INVALID_USAGE", 2, "--input <path|-> is required for this command.", outputFormat);
+    }
+    return value;
+}
 function readInputPayload(inputPath, cwd, outputFormat) {
     let rawJson = "";
     try {
@@ -100,6 +212,160 @@ function readInputPayload(inputPath, cwd, outputFormat) {
     }
     return parsed;
 }
+function resolveAddInput(options, cwd, outputFormat) {
+    const messageOption = readString(options, "message");
+    const inputOption = readString(options, "input");
+    if (messageOption && inputOption) {
+        throw new CommentsCommandError("INVALID_USAGE", 2, "Use exactly one payload mode: --message <text> OR --input <path|->.", outputFormat);
+    }
+    if (!messageOption && !inputOption) {
+        throw new CommentsCommandError("INVALID_USAGE", 2, "Missing payload. Provide --message <text> or --input <path|->.", outputFormat);
+    }
+    const payload = inputOption ? readInputPayload(inputOption, cwd, outputFormat) : undefined;
+    const payloadMessage = coerceNonEmptyString(payload?.message, "Input payload 'message' must be a non-empty string.", outputFormat);
+    const payloadAuthor = coerceOptionalString(payload?.author, "Input payload 'author' must be a string if provided.", outputFormat);
+    const payloadMeta = payload?.meta !== undefined
+        ? coerceOptionalObject(payload.meta, "Input payload 'meta' must be an object if provided.", outputFormat)
+        : undefined;
+    const optionRange = parseRangeFromOptions(options, outputFormat);
+    const optionCursorLine = parseCursorLineOption(readString(options, "cursor-line"), outputFormat);
+    const payloadRange = payload?.range !== undefined
+        ? parsePayloadRange(payload.range, outputFormat)
+        : undefined;
+    const payloadAnchor = payload?.anchor !== undefined
+        ? parseAnchorPayload(payload.anchor, outputFormat)
+        : undefined;
+    const finalMessage = (messageOption ?? payloadMessage ?? "").trim();
+    if (!finalMessage) {
+        throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Comment message cannot be empty.", outputFormat);
+    }
+    const finalAuthor = (readString(options, "author") ?? payloadAuthor ?? "Saurus").trim() || "Saurus";
+    const anchor = {
+        range: optionRange ?? payloadAnchor?.range ?? payloadRange,
+        cursorLine: optionCursorLine ?? payloadAnchor?.cursorLine,
+        excerpt: payloadAnchor?.excerpt
+    };
+    const resolvedAnchor = anchor.range || anchor.cursorLine !== undefined || anchor.excerpt
+        ? anchor
+        : undefined;
+    return {
+        message: finalMessage,
+        author: finalAuthor,
+        anchor: resolvedAnchor,
+        meta: payloadMeta
+    };
+}
+function resolveReplyInput(options, cwd, outputFormat) {
+    const messageOption = readString(options, "message");
+    const inputOption = readString(options, "input");
+    if (messageOption && inputOption) {
+        throw new CommentsCommandError("INVALID_USAGE", 2, "Use exactly one payload mode: --message <text> OR --input <path|->.", outputFormat);
+    }
+    if (!messageOption && !inputOption) {
+        throw new CommentsCommandError("INVALID_USAGE", 2, "Missing payload. Provide --message <text> or --input <path|->.", outputFormat);
+    }
+    const payload = inputOption ? readInputPayload(inputOption, cwd, outputFormat) : undefined;
+    const payloadMessage = coerceNonEmptyString(payload?.message, "Input payload 'message' must be a non-empty string.", outputFormat);
+    const payloadAuthor = coerceOptionalString(payload?.author, "Input payload 'author' must be a string if provided.", outputFormat);
+    const finalMessage = (messageOption ?? payloadMessage ?? "").trim();
+    if (!finalMessage) {
+        throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Reply cannot be empty.", outputFormat);
+    }
+    const finalAuthor = (readString(options, "author") ?? payloadAuthor ?? "Saurus").trim() || "Saurus";
+    return {
+        message: finalMessage,
+        author: finalAuthor
+    };
+}
+function parseSyncInput(payload, outputFormat) {
+    const candidate = payload;
+    const updates = candidate.updates === undefined
+        ? []
+        : parseAnchorUpdates(candidate.updates, outputFormat);
+    const deleteIdsRaw = candidate.delete_ids ?? candidate.deleteIds;
+    const deleteIds = deleteIdsRaw === undefined
+        ? []
+        : parseDeleteIds(deleteIdsRaw, outputFormat);
+    return {
+        updates,
+        deleteIds
+    };
+}
+function parseAnchorUpdates(raw, outputFormat) {
+    if (!Array.isArray(raw)) {
+        throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Input payload 'updates' must be an array.", outputFormat);
+    }
+    const updates = [];
+    for (const candidate of raw) {
+        if (!isPlainObject(candidate)) {
+            throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Each update must be an object.", outputFormat);
+        }
+        const id = typeof candidate.id === "string" ? candidate.id.trim().toUpperCase() : "";
+        if (!/^CMT-\d{4,}$/.test(id)) {
+            throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Each update.id must be a comment id like CMT-0001.", outputFormat);
+        }
+        const start = isPlainObject(candidate.start) ? candidate.start : undefined;
+        const end = isPlainObject(candidate.end) ? candidate.end : undefined;
+        if (!start || !end) {
+            throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Each update must include start and end positions.", outputFormat);
+        }
+        const parsed = {
+            id,
+            start: {
+                line: parseJsonPositiveInt(start.line, "updates[].start.line", outputFormat),
+                col: parseJsonNonNegativeInt(start.col, "updates[].start.col", outputFormat)
+            },
+            end: {
+                line: parseJsonPositiveInt(end.line, "updates[].end.line", outputFormat),
+                col: parseJsonNonNegativeInt(end.col, "updates[].end.col", outputFormat)
+            }
+        };
+        const valid = parsed.start.line < parsed.end.line
+            || (parsed.start.line === parsed.end.line && parsed.start.col < parsed.end.col);
+        if (!valid) {
+            throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Each update range end must be after start.", outputFormat);
+        }
+        updates.push(parsed);
+    }
+    return updates;
+}
+function parseDeleteIds(raw, outputFormat) {
+    if (!Array.isArray(raw)) {
+        throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Input payload 'delete_ids' must be an array.", outputFormat);
+    }
+    const ids = [];
+    for (const value of raw) {
+        if (typeof value !== "string") {
+            throw new CommentsCommandError("INVALID_PAYLOAD", 4, "delete_ids values must be strings.", outputFormat);
+        }
+        const normalized = value.trim().toUpperCase();
+        if (!/^CMT-\d{4,}$/.test(normalized)) {
+            throw new CommentsCommandError("INVALID_PAYLOAD", 4, `Invalid delete_ids entry '${value}'.`, outputFormat);
+        }
+        ids.push(normalized);
+    }
+    return ids;
+}
+function parseAnchorPayload(raw, outputFormat) {
+    if (!isPlainObject(raw)) {
+        throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Input payload 'anchor' must be an object.", outputFormat);
+    }
+    const parsed = raw;
+    const range = parsed.range !== undefined
+        ? parsePayloadRange(parsed.range, outputFormat)
+        : undefined;
+    const cursorLine = parsed.cursor_line !== undefined
+        ? parseJsonPositiveInt(parsed.cursor_line, "anchor.cursor_line", outputFormat)
+        : undefined;
+    const excerpt = parsed.excerpt !== undefined
+        ? coerceOptionalString(parsed.excerpt, "Input payload 'anchor.excerpt' must be a string if provided.", outputFormat)
+        : undefined;
+    return {
+        range,
+        cursorLine,
+        excerpt
+    };
+}
 function parseRangeFromOptions(options, outputFormat) {
     const rawStartLine = readString(options, "start-line");
     const rawStartCol = readString(options, "start-col");
@@ -115,43 +381,53 @@ function parseRangeFromOptions(options, outputFormat) {
         throw new CommentsCommandError("INVALID_USAGE", 2, "Range options must include all of --start-line, --start-col, --end-line, --end-col.", outputFormat);
     }
     const range = {
-        startLine: parseNonNegativeInt(rawStartLine, "--start-line", outputFormat),
+        startLine: parsePositiveInt(rawStartLine, "--start-line", outputFormat),
         startCol: parseNonNegativeInt(rawStartCol, "--start-col", outputFormat),
-        endLine: parseNonNegativeInt(rawEndLine, "--end-line", outputFormat),
+        endLine: parsePositiveInt(rawEndLine, "--end-line", outputFormat),
         endCol: parseNonNegativeInt(rawEndCol, "--end-col", outputFormat)
     };
     validateRange(range, outputFormat);
     return range;
 }
+function parseCursorLineOption(raw, outputFormat) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    return parsePositiveInt(raw, "--cursor-line", outputFormat);
+}
 function parsePayloadRange(raw, outputFormat) {
     if (!isPlainObject(raw)) {
-        throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Input payload 'range' must be an object.", outputFormat);
+        throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Input payload range must be an object.", outputFormat);
     }
     const parsed = raw;
     const start = parsed.start;
     const end = parsed.end;
     if (!isPlainObject(start) || !isPlainObject(end)) {
-        throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Input payload 'range' must include 'start' and 'end' objects.", outputFormat);
-    }
-    const normalized = {
-        start: {
-            line: parseJsonNonNegativeInt(start.line, "range.start.line", outputFormat),
-            col: parseJsonNonNegativeInt(start.col, "range.start.col", outputFormat)
-        },
-        end: {
-            line: parseJsonNonNegativeInt(end.line, "range.end.line", outputFormat),
-            col: parseJsonNonNegativeInt(end.col, "range.end.col", outputFormat)
-        }
-    };
+        throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Input payload range must include start and end objects.", outputFormat);
+    }
     const range = {
-        startLine: normalized.start.line,
-        startCol: normalized.start.col,
-        endLine: normalized.end.line,
-        endCol: normalized.end.col
+        startLine: parseJsonPositiveInt(start.line, "range.start.line", outputFormat),
+        startCol: parseJsonNonNegativeInt(start.col, "range.start.col", outputFormat),
+        endLine: parseJsonPositiveInt(end.line, "range.end.line", outputFormat),
+        endCol: parseJsonNonNegativeInt(end.col, "range.end.col", outputFormat)
     };
     validateRange(range, outputFormat);
     return range;
 }
+function requireCommentId(options, outputFormat) {
+    const commentId = readString(options, "comment-id")?.trim().toUpperCase();
+    if (!commentId || !/^CMT-\d{4,}$/.test(commentId)) {
+        throw new CommentsCommandError("INVALID_USAGE", 2, "--comment-id CMT-#### is required.", outputFormat);
+    }
+    return commentId;
+}
+function parseStatus(raw, outputFormat) {
+    const normalized = (raw ?? "").trim().toLowerCase();
+    if (normalized === "open" || normalized === "resolved") {
+        return normalized;
+    }
+    throw new CommentsCommandError("INVALID_USAGE", 2, "--status must be 'open' or 'resolved'.", outputFormat);
+}
 function validateRange(range, outputFormat) {
     const startsBeforeEnd = range.startLine < range.endLine
         || (range.startLine === range.endLine && range.startCol < range.endCol);
@@ -159,16 +435,32 @@ function validateRange(range, outputFormat) {
         throw new CommentsCommandError("INVALID_PAYLOAD", 4, "Range end must be after range start.", outputFormat);
     }
 }
+function parsePositiveInt(raw, label, outputFormat) {
+    if (!/^\d+$/.test(raw)) {
+        throw new CommentsCommandError("INVALID_USAGE", 2, `${label} must be a positive integer.`, outputFormat);
+    }
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value) || value < 1) {
+        throw new CommentsCommandError("INVALID_USAGE", 2, `${label} must be a positive integer.`, outputFormat);
+    }
+    return value;
+}
 function parseNonNegativeInt(raw, label, outputFormat) {
     if (!/^\d+$/.test(raw)) {
         throw new CommentsCommandError("INVALID_USAGE", 2, `${label} must be a non-negative integer.`, outputFormat);
     }
     const value = Number.parseInt(raw, 10);
-    if (!Number.isFinite(value)) {
+    if (!Number.isFinite(value) || value < 0) {
         throw new CommentsCommandError("INVALID_USAGE", 2, `${label} must be a non-negative integer.`, outputFormat);
     }
     return value;
 }
+function parseJsonPositiveInt(raw, label, outputFormat) {
+    if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 1) {
+        throw new CommentsCommandError("INVALID_PAYLOAD", 4, `${label} must be a positive integer.`, outputFormat);
+    }
+    return raw;
+}
 function parseJsonNonNegativeInt(raw, label, outputFormat) {
     if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) {
         throw new CommentsCommandError("INVALID_PAYLOAD", 4, `${label} must be a non-negative integer.`, outputFormat);

package/dist/metadata/metadata-command.js

@@ -0,0 +1,127 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { normalizeFrontmatterRecord, parseMarkdownDocument, serializeMarkdownDocument } from "./metadata-domain.js";
+export async function runMetadataCommand(options, cwd) {
+    const [subcommand, markdownArg] = options._;
+    if (!subcommand) {
+        throw new Error("Metadata subcommand is required. Use: read, apply.");
+    }
+    if (!markdownArg) {
+        throw new Error("Markdown path is required. Use: stego metadata <subcommand> <path>.");
+    }
+    const outputFormat = parseOutputFormat(readString(options, "format"));
+    const absolutePath = path.resolve(cwd, markdownArg);
+    const raw = readFile(absolutePath, markdownArg);
+    switch (subcommand) {
+        case "read": {
+            const parsed = parseMarkdownDocument(raw);
+            emit({
+                ok: true,
+                operation: "read",
+                state: {
+                    path: absolutePath,
+                    hasFrontmatter: parsed.hasFrontmatter,
+                    lineEnding: parsed.lineEnding,
+                    frontmatter: parsed.frontmatter,
+                    body: parsed.body
+                }
+            }, outputFormat);
+            return;
+        }
+        case "apply": {
+            const inputPath = requireInputPath(options);
+            const payload = readInputPayload(inputPath, cwd);
+            const frontmatter = normalizeFrontmatterRecord(payload.frontmatter);
+            const body = typeof payload.body === "string" ? payload.body : undefined;
+            const hasFrontmatter = typeof payload.hasFrontmatter === "boolean" ? payload.hasFrontmatter : undefined;
+            const existing = parseMarkdownDocument(raw);
+            const next = {
+                lineEnding: existing.lineEnding,
+                hasFrontmatter: hasFrontmatter ?? (existing.hasFrontmatter || Object.keys(frontmatter).length > 0),
+                frontmatter,
+                body: body ?? existing.body
+            };
+            const nextText = serializeMarkdownDocument(next);
+            const changed = nextText !== raw;
+            if (changed) {
+                fs.writeFileSync(absolutePath, nextText, "utf8");
+            }
+            const reparsed = parseMarkdownDocument(nextText);
+            emit({
+                ok: true,
+                operation: "apply",
+                changed,
+                state: {
+                    path: absolutePath,
+                    hasFrontmatter: reparsed.hasFrontmatter,
+                    lineEnding: reparsed.lineEnding,
+                    frontmatter: reparsed.frontmatter,
+                    body: reparsed.body
+                }
+            }, outputFormat);
+            return;
+        }
+        default:
+            throw new Error(`Unknown metadata subcommand '${subcommand}'. Use: read, apply.`);
+    }
+}
+function emit(payload, format) {
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+        return;
+    }
+    if (payload.operation === "read") {
+        process.stdout.write(`Read metadata for ${payload.state.path} (${Object.keys(payload.state.frontmatter).length} keys).\n`);
+        return;
+    }
+    process.stdout.write(`${payload.changed ? "Updated" : "No changes for"} metadata in ${payload.state.path}.\n`);
+}
+function parseOutputFormat(raw) {
+    if (!raw || raw === "text") {
+        return "text";
+    }
+    if (raw === "json") {
+        return "json";
+    }
+    throw new Error("Invalid --format value. Use 'text' or 'json'.");
+}
+function readString(options, key) {
+    const value = options[key];
+    return typeof value === "string" ? value : undefined;
+}
+function requireInputPath(options) {
+    const inputPath = readString(options, "input");
+    if (!inputPath) {
+        throw new Error("--input <path|-> is required for 'metadata apply'.");
+    }
+    return inputPath;
+}
+function readInputPayload(inputPath, cwd) {
+    const raw = inputPath === "-"
+        ? fs.readFileSync(process.stdin.fd, "utf8")
+        : fs.readFileSync(path.resolve(cwd, inputPath), "utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("Input payload is not valid JSON.");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("Input payload must be a JSON object.");
+    }
+    return parsed;
+}
+function readFile(filePath, originalArg) {
+    try {
+        const stat = fs.statSync(filePath);
+        if (!stat.isFile()) {
+            throw new Error();
+        }
+    }
+    catch {
+        throw new Error(`Markdown file not found: ${originalArg}`);
+    }
+    return fs.readFileSync(filePath, "utf8");
+}