stego-cli 0.4.1 → 0.4.2

package/dist/stego-cli/src/modules/comments/application/comment-operations.js

@@ -0,0 +1,457 @@
+import path from "node:path";
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { addCommentToState, clearResolvedInState, deleteCommentInState, ensureNoParseErrors, loadCommentDocumentState, renderStateDocument, replyToCommentInState, serializeLoadedState, setCommentStatusInState, syncAnchorsInState } from "../../../../../shared/src/domain/comments/index.js";
+import { COMMENT_ID_PATTERN, normalizeCommentId, normalizeCommentStatus } from "../domain/comment-policy.js";
+import { readJsonPayload, readManuscript, resolveManuscriptPath, writeManuscript } from "../infra/comments-repo.js";
+export function executeCommentsOperation(input) {
+    const manuscriptPath = resolveManuscriptPath(input.cwd, input.manuscriptArg);
+    const raw = readManuscript(manuscriptPath, input.manuscriptArg);
+    let state = loadCommentDocumentState(raw);
+    const displayPath = path.relative(input.cwd, manuscriptPath) || manuscriptPath;
+    switch (input.subcommand) {
+        case "read":
+            return {
+                payload: {
+                    ok: true,
+                    operation: "read",
+                    manuscript: manuscriptPath,
+                    state: serializeLoadedState(state)
+                },
+                textMessage: `Read comments for ${displayPath}.`
+            };
+        case "add": {
+            ensureMutableState(state);
+            const addInput = resolveAddInput(input.options, input.cwd);
+            const result = runMutation(manuscriptPath, state, () => addCommentToState(raw, state, addInput));
+            state = result.state;
+            return {
+                payload: {
+                    ok: true,
+                    operation: "add",
+                    manuscript: manuscriptPath,
+                    commentId: result.meta.commentId,
+                    state: serializeLoadedState(state)
+                },
+                textMessage: `Added ${result.meta.commentId} to ${displayPath}.`
+            };
+        }
+        case "reply": {
+            ensureMutableState(state);
+            const commentId = requireCommentId(input.options);
+            const { message, author } = resolveReplyInput(input.options, input.cwd);
+            const result = runMutation(manuscriptPath, state, () => replyToCommentInState(state, { commentId, message, author }));
+            state = result.state;
+            return {
+                payload: {
+                    ok: true,
+                    operation: "reply",
+                    manuscript: manuscriptPath,
+                    commentId: result.meta.commentId,
+                    state: serializeLoadedState(state)
+                },
+                textMessage: `Added reply ${result.meta.commentId} in ${displayPath}.`
+            };
+        }
+        case "set-status": {
+            ensureMutableState(state);
+            const commentId = requireCommentId(input.options);
+            const status = parseStatus(readStringOption(input.options, "status"));
+            const thread = readBooleanOption(input.options, "thread");
+            const result = runMutation(manuscriptPath, state, () => setCommentStatusInState(state, { commentId, status, thread }));
+            state = result.state;
+            return {
+                payload: {
+                    ok: true,
+                    operation: "set-status",
+                    manuscript: manuscriptPath,
+                    status,
+                    changedIds: result.meta.changedIds,
+                    state: serializeLoadedState(state)
+                },
+                textMessage: `Updated ${result.meta.changedIds.length} comment(s) to '${status}'.`
+            };
+        }
+        case "delete": {
+            ensureMutableState(state);
+            const commentId = requireCommentId(input.options);
+            const result = runMutation(manuscriptPath, state, () => deleteCommentInState(state, commentId));
+            state = result.state;
+            return {
+                payload: {
+                    ok: true,
+                    operation: "delete",
+                    manuscript: manuscriptPath,
+                    removed: result.meta.removed,
+                    state: serializeLoadedState(state)
+                },
+                textMessage: `Deleted ${result.meta.removed} comment(s).`
+            };
+        }
+        case "clear-resolved": {
+            ensureMutableState(state);
+            const result = runMutation(manuscriptPath, state, () => clearResolvedInState(state));
+            state = result.state;
+            return {
+                payload: {
+                    ok: true,
+                    operation: "clear-resolved",
+                    manuscript: manuscriptPath,
+                    removed: result.meta.removed,
+                    state: serializeLoadedState(state)
+                },
+                textMessage: `Cleared ${result.meta.removed} resolved comment(s).`
+            };
+        }
+        case "sync-anchors": {
+            ensureMutableState(state);
+            const payload = readJsonPayload(requireInputPath(input.options), input.cwd);
+            const syncInput = parseSyncInput(payload);
+            const result = runMutation(manuscriptPath, state, () => syncAnchorsInState(raw, state, syncInput));
+            state = result.state;
+            return {
+                payload: {
+                    ok: true,
+                    operation: "sync-anchors",
+                    manuscript: manuscriptPath,
+                    updatedCount: result.meta.updatedCount,
+                    deletedCount: result.meta.deletedCount,
+                    state: serializeLoadedState(state)
+                },
+                textMessage: `Synced anchors (${result.meta.updatedCount} updated, ${result.meta.deletedCount} deleted).`
+            };
+        }
+        default:
+            throw new CliError("INVALID_USAGE", `Unknown comments subcommand '${input.subcommand}'. Use: read, add, reply, set-status, delete, clear-resolved, sync-anchors.`);
+    }
+}
+function runMutation(manuscriptPath, state, run) {
+    let mutationResult;
+    try {
+        mutationResult = run();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliError("INVALID_PAYLOAD", message);
+    }
+    const nextText = renderStateDocument(state, mutationResult.comments);
+    writeManuscript(manuscriptPath, nextText);
+    const nextState = loadCommentDocumentState(nextText);
+    return {
+        meta: mutationResult,
+        state: nextState
+    };
+}
+function ensureMutableState(state) {
+    try {
+        ensureNoParseErrors(state);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliError("COMMENT_APPENDIX_INVALID", message);
+    }
+}
+function requireInputPath(options) {
+    const value = readStringOption(options, "input");
+    if (!value) {
+        throw new CliError("INVALID_USAGE", "--input <path|-> is required for this command.");
+    }
+    return value;
+}
+function resolveAddInput(options, cwd) {
+    const messageOption = readStringOption(options, "message");
+    const inputOption = readStringOption(options, "input");
+    if (messageOption && inputOption) {
+        throw new CliError("INVALID_USAGE", "Use exactly one payload mode: --message <text> OR --input <path|->.");
+    }
+    if (!messageOption && !inputOption) {
+        throw new CliError("INVALID_USAGE", "Missing payload. Provide --message <text> or --input <path|->.");
+    }
+    const payload = inputOption ? readJsonPayload(inputOption, cwd) : undefined;
+    const payloadMessage = coerceNonEmptyString(payload?.message, "Input payload 'message' must be a non-empty string.");
+    const payloadAuthor = coerceOptionalString(payload?.author, "Input payload 'author' must be a string if provided.");
+    const payloadMeta = payload?.meta !== undefined
+        ? coerceOptionalObject(payload.meta, "Input payload 'meta' must be an object if provided.")
+        : undefined;
+    const optionRange = parseRangeFromOptions(options);
+    const optionCursorLine = parseCursorLineOption(readStringOption(options, "cursorLine", "cursor-line"));
+    const payloadRange = payload?.range !== undefined
+        ? parsePayloadRange(payload.range)
+        : undefined;
+    const payloadAnchor = payload?.anchor !== undefined
+        ? parseAnchorPayload(payload.anchor)
+        : undefined;
+    const finalMessage = (messageOption ?? payloadMessage ?? "").trim();
+    if (!finalMessage) {
+        throw new CliError("INVALID_PAYLOAD", "Comment message cannot be empty.");
+    }
+    const finalAuthor = (readStringOption(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) {
+    const messageOption = readStringOption(options, "message");
+    const inputOption = readStringOption(options, "input");
+    if (messageOption && inputOption) {
+        throw new CliError("INVALID_USAGE", "Use exactly one payload mode: --message <text> OR --input <path|->.");
+    }
+    if (!messageOption && !inputOption) {
+        throw new CliError("INVALID_USAGE", "Missing payload. Provide --message <text> or --input <path|->.");
+    }
+    const payload = inputOption ? readJsonPayload(inputOption, cwd) : undefined;
+    const payloadMessage = coerceNonEmptyString(payload?.message, "Input payload 'message' must be a non-empty string.");
+    const payloadAuthor = coerceOptionalString(payload?.author, "Input payload 'author' must be a string if provided.");
+    const finalMessage = (messageOption ?? payloadMessage ?? "").trim();
+    if (!finalMessage) {
+        throw new CliError("INVALID_PAYLOAD", "Reply cannot be empty.");
+    }
+    const finalAuthor = (readStringOption(options, "author") ?? payloadAuthor ?? "Saurus").trim() || "Saurus";
+    return {
+        message: finalMessage,
+        author: finalAuthor
+    };
+}
+function parseSyncInput(payload) {
+    const candidate = payload;
+    const updates = candidate.updates === undefined
+        ? []
+        : parseAnchorUpdates(candidate.updates);
+    const deleteIdsRaw = candidate.delete_ids ?? candidate.deleteIds;
+    const deleteIds = deleteIdsRaw === undefined
+        ? []
+        : parseDeleteIds(deleteIdsRaw);
+    return {
+        updates,
+        deleteIds
+    };
+}
+function parseAnchorUpdates(raw) {
+    if (!Array.isArray(raw)) {
+        throw new CliError("INVALID_PAYLOAD", "Input payload 'updates' must be an array.");
+    }
+    const updates = [];
+    for (const candidate of raw) {
+        if (!isPlainObject(candidate)) {
+            throw new CliError("INVALID_PAYLOAD", "Each update must be an object.");
+        }
+        const id = typeof candidate.id === "string" ? normalizeCommentId(candidate.id) : "";
+        if (!COMMENT_ID_PATTERN.test(id)) {
+            throw new CliError("INVALID_PAYLOAD", "Each update.id must be a comment id like CMT-0001.");
+        }
+        const start = isPlainObject(candidate.start) ? candidate.start : undefined;
+        const end = isPlainObject(candidate.end) ? candidate.end : undefined;
+        if (!start || !end) {
+            throw new CliError("INVALID_PAYLOAD", "Each update must include start and end positions.");
+        }
+        const parsed = {
+            id,
+            start: {
+                line: parseJsonPositiveInt(start.line, "updates[].start.line"),
+                col: parseJsonNonNegativeInt(start.col, "updates[].start.col")
+            },
+            end: {
+                line: parseJsonPositiveInt(end.line, "updates[].end.line"),
+                col: parseJsonNonNegativeInt(end.col, "updates[].end.col")
+            }
+        };
+        const valid = parsed.start.line < parsed.end.line
+            || (parsed.start.line === parsed.end.line && parsed.start.col < parsed.end.col);
+        if (!valid) {
+            throw new CliError("INVALID_PAYLOAD", "Each update range end must be after start.");
+        }
+        updates.push(parsed);
+    }
+    return updates;
+}
+function parseDeleteIds(raw) {
+    if (!Array.isArray(raw)) {
+        throw new CliError("INVALID_PAYLOAD", "Input payload 'delete_ids' must be an array.");
+    }
+    const ids = [];
+    for (const value of raw) {
+        if (typeof value !== "string") {
+            throw new CliError("INVALID_PAYLOAD", "delete_ids values must be strings.");
+        }
+        const normalized = normalizeCommentId(value);
+        if (!COMMENT_ID_PATTERN.test(normalized)) {
+            throw new CliError("INVALID_PAYLOAD", `Invalid delete_ids entry '${value}'.`);
+        }
+        ids.push(normalized);
+    }
+    return ids;
+}
+function parseAnchorPayload(raw) {
+    if (!isPlainObject(raw)) {
+        throw new CliError("INVALID_PAYLOAD", "Input payload 'anchor' must be an object.");
+    }
+    const parsed = raw;
+    const range = parsed.range !== undefined
+        ? parsePayloadRange(parsed.range)
+        : undefined;
+    const cursorLine = parsed.cursor_line !== undefined
+        ? parseJsonPositiveInt(parsed.cursor_line, "anchor.cursor_line")
+        : undefined;
+    const excerpt = parsed.excerpt !== undefined
+        ? coerceOptionalString(parsed.excerpt, "Input payload 'anchor.excerpt' must be a string if provided.")
+        : undefined;
+    return {
+        range,
+        cursorLine,
+        excerpt
+    };
+}
+function parseRangeFromOptions(options) {
+    const rawStartLine = readStringOption(options, "startLine", "start-line");
+    const rawStartCol = readStringOption(options, "startCol", "start-col");
+    const rawEndLine = readStringOption(options, "endLine", "end-line");
+    const rawEndCol = readStringOption(options, "endCol", "end-col");
+    const values = [rawStartLine, rawStartCol, rawEndLine, rawEndCol];
+    const hasAny = values.some((value) => value !== undefined);
+    const hasAll = values.every((value) => value !== undefined);
+    if (!hasAny) {
+        return undefined;
+    }
+    if (!hasAll) {
+        throw new CliError("INVALID_USAGE", "Range options must include all of --start-line, --start-col, --end-line, --end-col.");
+    }
+    const range = {
+        startLine: parsePositiveInt(rawStartLine, "--start-line"),
+        startCol: parseNonNegativeInt(rawStartCol, "--start-col"),
+        endLine: parsePositiveInt(rawEndLine, "--end-line"),
+        endCol: parseNonNegativeInt(rawEndCol, "--end-col")
+    };
+    validateRange(range);
+    return range;
+}
+function parseCursorLineOption(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    return parsePositiveInt(raw, "--cursor-line");
+}
+function parsePayloadRange(raw) {
+    if (!isPlainObject(raw)) {
+        throw new CliError("INVALID_PAYLOAD", "Input payload range must be an object.");
+    }
+    const parsed = raw;
+    if (!isPlainObject(parsed.start) || !isPlainObject(parsed.end)) {
+        throw new CliError("INVALID_PAYLOAD", "Input payload range must include start and end objects.");
+    }
+    const range = {
+        startLine: parseJsonPositiveInt(parsed.start.line, "range.start.line"),
+        startCol: parseJsonNonNegativeInt(parsed.start.col, "range.start.col"),
+        endLine: parseJsonPositiveInt(parsed.end.line, "range.end.line"),
+        endCol: parseJsonNonNegativeInt(parsed.end.col, "range.end.col")
+    };
+    validateRange(range);
+    return range;
+}
+function requireCommentId(options) {
+    const commentId = normalizeCommentId(readStringOption(options, "commentId", "comment-id") ?? "");
+    if (!COMMENT_ID_PATTERN.test(commentId)) {
+        throw new CliError("INVALID_USAGE", "--comment-id CMT-#### is required.");
+    }
+    return commentId;
+}
+function parseStatus(raw) {
+    const normalized = normalizeCommentStatus(raw ?? "");
+    if (normalized) {
+        return normalized;
+    }
+    throw new CliError("INVALID_USAGE", "--status must be 'open' or 'resolved'.");
+}
+function validateRange(range) {
+    const startsBeforeEnd = range.startLine < range.endLine
+        || (range.startLine === range.endLine && range.startCol < range.endCol);
+    if (!startsBeforeEnd) {
+        throw new CliError("INVALID_PAYLOAD", "Range end must be after range start.");
+    }
+}
+function parsePositiveInt(raw, label) {
+    if (!/^\d+$/.test(raw)) {
+        throw new CliError("INVALID_USAGE", `${label} must be a positive integer.`);
+    }
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value) || value < 1) {
+        throw new CliError("INVALID_USAGE", `${label} must be a positive integer.`);
+    }
+    return value;
+}
+function parseNonNegativeInt(raw, label) {
+    if (!/^\d+$/.test(raw)) {
+        throw new CliError("INVALID_USAGE", `${label} must be a non-negative integer.`);
+    }
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value) || value < 0) {
+        throw new CliError("INVALID_USAGE", `${label} must be a non-negative integer.`);
+    }
+    return value;
+}
+function parseJsonPositiveInt(raw, label) {
+    if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 1) {
+        throw new CliError("INVALID_PAYLOAD", `${label} must be a positive integer.`);
+    }
+    return raw;
+}
+function parseJsonNonNegativeInt(raw, label) {
+    if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) {
+        throw new CliError("INVALID_PAYLOAD", `${label} must be a non-negative integer.`);
+    }
+    return raw;
+}
+function coerceNonEmptyString(value, message) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new CliError("INVALID_PAYLOAD", message);
+    }
+    return value;
+}
+function coerceOptionalString(value, message) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new CliError("INVALID_PAYLOAD", message);
+    }
+    return value;
+}
+function coerceOptionalObject(value, message) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isPlainObject(value)) {
+        throw new CliError("INVALID_PAYLOAD", message);
+    }
+    return value;
+}
+function readStringOption(options, ...keys) {
+    for (const key of keys) {
+        const value = options[key];
+        if (typeof value === "string") {
+            return value;
+        }
+        if (typeof value === "number") {
+            return String(value);
+        }
+    }
+    return undefined;
+}
+function readBooleanOption(options, ...keys) {
+    return keys.some((key) => options[key] === true);
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/stego-cli/src/modules/comments/commands/comments-add.js

@@ -0,0 +1,40 @@
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { writeJson, writeText } from "../../../app/output-renderer.js";
+import { executeCommentsOperation } from "../application/comment-operations.js";
+import { parseCommentsOutputFormat } from "../infra/comments-repo.js";
+export function registerCommentsAddCommand(registry) {
+    registry.register({
+        name: "comments add <manuscript>",
+        description: "Add a new comment",
+        allowUnknownOptions: true,
+        options: [
+            { flags: "--message <text>", description: "Comment text" },
+            { flags: "--author <name>", description: "Comment author" },
+            { flags: "--input <path>", description: "JSON payload path or '-'" },
+            { flags: "--start-line <line>", description: "Anchor start line (1-based)" },
+            { flags: "--start-col <col>", description: "Anchor start column (0-based)" },
+            { flags: "--end-line <line>", description: "Anchor end line (1-based)" },
+            { flags: "--end-col <col>", description: "Anchor end column (0-based)" },
+            { flags: "--cursor-line <line>", description: "Paragraph cursor line fallback" },
+            { flags: "--format <format>", description: "text|json" }
+        ],
+        action: (context) => {
+            const manuscriptArg = context.positionals[0];
+            if (!manuscriptArg) {
+                throw new CliError("INVALID_USAGE", "Manuscript path is required. Use: stego comments add <manuscript> ...");
+            }
+            const outputFormat = parseCommentsOutputFormat(context.options.format);
+            const result = executeCommentsOperation({
+                subcommand: "add",
+                cwd: context.cwd,
+                manuscriptArg,
+                options: context.options
+            });
+            if (outputFormat === "json") {
+                writeJson(result.payload);
+                return;
+            }
+            writeText(result.textMessage);
+        }
+    });
+}

package/dist/stego-cli/src/modules/comments/commands/comments-clear-resolved.js

@@ -0,0 +1,32 @@
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { writeJson, writeText } from "../../../app/output-renderer.js";
+import { executeCommentsOperation } from "../application/comment-operations.js";
+import { parseCommentsOutputFormat } from "../infra/comments-repo.js";
+export function registerCommentsClearResolvedCommand(registry) {
+    registry.register({
+        name: "comments clear-resolved <manuscript>",
+        description: "Clear resolved comments",
+        allowUnknownOptions: true,
+        options: [
+            { flags: "--format <format>", description: "text|json" }
+        ],
+        action: (context) => {
+            const manuscriptArg = context.positionals[0];
+            if (!manuscriptArg) {
+                throw new CliError("INVALID_USAGE", "Manuscript path is required. Use: stego comments clear-resolved <manuscript>.");
+            }
+            const outputFormat = parseCommentsOutputFormat(context.options.format);
+            const result = executeCommentsOperation({
+                subcommand: "clear-resolved",
+                cwd: context.cwd,
+                manuscriptArg,
+                options: context.options
+            });
+            if (outputFormat === "json") {
+                writeJson(result.payload);
+                return;
+            }
+            writeText(result.textMessage);
+        }
+    });
+}

package/dist/stego-cli/src/modules/comments/commands/comments-delete.js

@@ -0,0 +1,33 @@
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { writeJson, writeText } from "../../../app/output-renderer.js";
+import { executeCommentsOperation } from "../application/comment-operations.js";
+import { parseCommentsOutputFormat } from "../infra/comments-repo.js";
+export function registerCommentsDeleteCommand(registry) {
+    registry.register({
+        name: "comments delete <manuscript>",
+        description: "Delete a comment",
+        allowUnknownOptions: true,
+        options: [
+            { flags: "--comment-id <id>", description: "Comment id (CMT-####)" },
+            { flags: "--format <format>", description: "text|json" }
+        ],
+        action: (context) => {
+            const manuscriptArg = context.positionals[0];
+            if (!manuscriptArg) {
+                throw new CliError("INVALID_USAGE", "Manuscript path is required. Use: stego comments delete <manuscript> ...");
+            }
+            const outputFormat = parseCommentsOutputFormat(context.options.format);
+            const result = executeCommentsOperation({
+                subcommand: "delete",
+                cwd: context.cwd,
+                manuscriptArg,
+                options: context.options
+            });
+            if (outputFormat === "json") {
+                writeJson(result.payload);
+                return;
+            }
+            writeText(result.textMessage);
+        }
+    });
+}

package/dist/stego-cli/src/modules/comments/commands/comments-read.js

@@ -0,0 +1,32 @@
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { writeJson, writeText } from "../../../app/output-renderer.js";
+import { executeCommentsOperation } from "../application/comment-operations.js";
+import { parseCommentsOutputFormat } from "../infra/comments-repo.js";
+export function registerCommentsReadCommand(registry) {
+    registry.register({
+        name: "comments read <manuscript>",
+        description: "Read comments state",
+        allowUnknownOptions: true,
+        options: [
+            { flags: "--format <format>", description: "text|json" }
+        ],
+        action: (context) => {
+            const manuscriptArg = context.positionals[0];
+            if (!manuscriptArg) {
+                throw new CliError("INVALID_USAGE", "Manuscript path is required. Use: stego comments read <manuscript>.");
+            }
+            const outputFormat = parseCommentsOutputFormat(context.options.format);
+            const result = executeCommentsOperation({
+                subcommand: "read",
+                cwd: context.cwd,
+                manuscriptArg,
+                options: context.options
+            });
+            if (outputFormat === "json") {
+                writeJson(result.payload);
+                return;
+            }
+            writeText(result.textMessage);
+        }
+    });
+}

package/dist/stego-cli/src/modules/comments/commands/comments-reply.js

@@ -0,0 +1,36 @@
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { writeJson, writeText } from "../../../app/output-renderer.js";
+import { executeCommentsOperation } from "../application/comment-operations.js";
+import { parseCommentsOutputFormat } from "../infra/comments-repo.js";
+export function registerCommentsReplyCommand(registry) {
+    registry.register({
+        name: "comments reply <manuscript>",
+        description: "Reply to an existing comment",
+        allowUnknownOptions: true,
+        options: [
+            { flags: "--comment-id <id>", description: "Comment id (CMT-####)" },
+            { flags: "--message <text>", description: "Reply text" },
+            { flags: "--author <name>", description: "Reply author" },
+            { flags: "--input <path>", description: "JSON payload path or '-'" },
+            { flags: "--format <format>", description: "text|json" }
+        ],
+        action: (context) => {
+            const manuscriptArg = context.positionals[0];
+            if (!manuscriptArg) {
+                throw new CliError("INVALID_USAGE", "Manuscript path is required. Use: stego comments reply <manuscript> ...");
+            }
+            const outputFormat = parseCommentsOutputFormat(context.options.format);
+            const result = executeCommentsOperation({
+                subcommand: "reply",
+                cwd: context.cwd,
+                manuscriptArg,
+                options: context.options
+            });
+            if (outputFormat === "json") {
+                writeJson(result.payload);
+                return;
+            }
+            writeText(result.textMessage);
+        }
+    });
+}

package/dist/stego-cli/src/modules/comments/commands/comments-set-status.js

@@ -0,0 +1,35 @@
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { writeJson, writeText } from "../../../app/output-renderer.js";
+import { executeCommentsOperation } from "../application/comment-operations.js";
+import { parseCommentsOutputFormat } from "../infra/comments-repo.js";
+export function registerCommentsSetStatusCommand(registry) {
+    registry.register({
+        name: "comments set-status <manuscript>",
+        description: "Set comment status",
+        allowUnknownOptions: true,
+        options: [
+            { flags: "--comment-id <id>", description: "Comment id (CMT-####)" },
+            { flags: "--status <status>", description: "open|resolved" },
+            { flags: "--thread", description: "Apply status to the whole thread" },
+            { flags: "--format <format>", description: "text|json" }
+        ],
+        action: (context) => {
+            const manuscriptArg = context.positionals[0];
+            if (!manuscriptArg) {
+                throw new CliError("INVALID_USAGE", "Manuscript path is required. Use: stego comments set-status <manuscript> ...");
+            }
+            const outputFormat = parseCommentsOutputFormat(context.options.format);
+            const result = executeCommentsOperation({
+                subcommand: "set-status",
+                cwd: context.cwd,
+                manuscriptArg,
+                options: context.options
+            });
+            if (outputFormat === "json") {
+                writeJson(result.payload);
+                return;
+            }
+            writeText(result.textMessage);
+        }
+    });
+}