@cloudglab/confluence-cli 0.0.1

package/dist/api/endpoints.js

@@ -0,0 +1,85 @@
+export const CONFLUENCE_7_13_7_ENDPOINTS = [
+    { method: "GET", path: "/accessmode", group: "accessmode", write: false },
+    { method: "GET", path: "/audit", group: "audit", write: false },
+    { method: "POST", path: "/audit", group: "audit", write: true },
+    { method: "GET", path: "/audit/export", group: "audit", write: false },
+    { method: "GET", path: "/audit/retention", group: "audit", write: false },
+    { method: "PUT", path: "/audit/retention", group: "audit", write: true },
+    { method: "GET", path: "/audit/since", group: "audit", write: false },
+    { method: "GET", path: "/content", group: "content", write: false },
+    { method: "POST", path: "/content", group: "content", write: true },
+    { method: "GET", path: "/content/search", group: "content", write: false },
+    { method: "POST", path: "/content/blueprint/instance/{draftId}", group: "content", write: true },
+    { method: "PUT", path: "/content/blueprint/instance/{draftId}", group: "content", write: true },
+    { method: "PUT", path: "/content/{contentId}", group: "content", write: true },
+    { method: "GET", path: "/content/{id}", group: "content", write: false },
+    { method: "DELETE", path: "/content/{id}", group: "content", write: true },
+    { method: "GET", path: "/content/{id}/child", group: "content-child", write: false },
+    { method: "GET", path: "/content/{id}/child/attachment", group: "attachment", write: false },
+    { method: "POST", path: "/content/{id}/child/attachment", group: "attachment", write: true },
+    { method: "PUT", path: "/content/{id}/child/attachment/{attachmentId}", group: "attachment", write: true },
+    { method: "POST", path: "/content/{id}/child/attachment/{attachmentId}/data", group: "attachment", write: true },
+    { method: "GET", path: "/content/{id}/child/comment", group: "content-child", write: false },
+    { method: "GET", path: "/content/{id}/child/{type}", group: "content-child", write: false },
+    { method: "GET", path: "/content/{id}/descendant", group: "content-descendant", write: false },
+    { method: "GET", path: "/content/{id}/descendant/{type}", group: "content-descendant", write: false },
+    { method: "GET", path: "/content/{id}/history", group: "content-history", write: false },
+    { method: "GET", path: "/content/{id}/history/{version}/macro/hash/{hash}", group: "content-macro", write: false },
+    { method: "GET", path: "/content/{id}/history/{version}/macro/id/{macroId}", group: "content-macro", write: false },
+    { method: "GET", path: "/content/{id}/label", group: "label", write: false },
+    { method: "POST", path: "/content/{id}/label", group: "label", write: true },
+    { method: "DELETE", path: "/content/{id}/label", group: "label", write: true },
+    { method: "DELETE", path: "/content/{id}/label/{label}", group: "label", write: true },
+    { method: "GET", path: "/content/{id}/property", group: "content-property", write: false },
+    { method: "POST", path: "/content/{id}/property", group: "content-property", write: true },
+    { method: "POST", path: "/content/{id}/property/{key}", group: "content-property", write: true },
+    { method: "GET", path: "/content/{id}/property/{key}", group: "content-property", write: false },
+    { method: "PUT", path: "/content/{id}/property/{key}", group: "content-property", write: true },
+    { method: "DELETE", path: "/content/{id}/property/{key}", group: "content-property", write: true },
+    { method: "GET", path: "/content/{id}/restriction/byOperation", group: "restriction", write: false },
+    { method: "GET", path: "/content/{id}/restriction/byOperation/{operationKey}", group: "restriction", write: false },
+    { method: "POST", path: "/contentbody/convert/{to}", group: "contentbody", write: true },
+    { method: "GET", path: "/group", group: "group", write: false },
+    { method: "GET", path: "/group/{groupName}", group: "group", write: false },
+    { method: "GET", path: "/group/{groupName}/member", group: "group", write: false },
+    { method: "GET", path: "/longtask", group: "longtask", write: false },
+    { method: "GET", path: "/longtask/{id}", group: "longtask", write: false },
+    { method: "GET", path: "/search", group: "search", write: false },
+    { method: "GET", path: "/space", group: "space", write: false },
+    { method: "POST", path: "/space", group: "space", write: true },
+    { method: "POST", path: "/space/_private", group: "space", write: true },
+    { method: "GET", path: "/space/{spaceKey}", group: "space", write: false },
+    { method: "PUT", path: "/space/{spaceKey}", group: "space", write: true },
+    { method: "DELETE", path: "/space/{spaceKey}", group: "space", write: true },
+    { method: "GET", path: "/space/{spaceKey}/content", group: "space-content", write: false },
+    { method: "GET", path: "/space/{spaceKey}/content/{type}", group: "space-content", write: false },
+    { method: "GET", path: "/space/{spaceKey}/property", group: "space-property", write: false },
+    { method: "POST", path: "/space/{spaceKey}/property", group: "space-property", write: true },
+    { method: "POST", path: "/space/{spaceKey}/property/{key}", group: "space-property", write: true },
+    { method: "GET", path: "/space/{spaceKey}/property/{key}", group: "space-property", write: false },
+    { method: "PUT", path: "/space/{spaceKey}/property/{key}", group: "space-property", write: true },
+    { method: "DELETE", path: "/space/{spaceKey}/property/{key}", group: "space-property", write: true },
+    { method: "GET", path: "/user", group: "user", write: false },
+    { method: "GET", path: "/user/anonymous", group: "user", write: false },
+    { method: "GET", path: "/user/current", group: "user", write: false },
+    { method: "GET", path: "/user/memberof", group: "user", write: false },
+    { method: "POST", path: "/user/watch/content/{contentId}", group: "watch", write: true },
+    { method: "GET", path: "/user/watch/content/{contentId}", group: "watch", write: false },
+    { method: "DELETE", path: "/user/watch/content/{contentId}", group: "watch", write: true },
+    { method: "POST", path: "/user/watch/space/{spaceKey}", group: "watch", write: true },
+    { method: "GET", path: "/user/watch/space/{spaceKey}", group: "watch", write: false },
+    { method: "DELETE", path: "/user/watch/space/{spaceKey}", group: "watch", write: true },
+    { method: "GET", path: "/webhooks", group: "webhooks", write: false },
+    { method: "POST", path: "/webhooks", group: "webhooks", write: true },
+    { method: "GET", path: "/webhooks/{webhookId}", group: "webhooks", write: false },
+    { method: "PUT", path: "/webhooks/{webhookId}", group: "webhooks", write: true },
+    { method: "DELETE", path: "/webhooks/{webhookId}", group: "webhooks", write: true },
+    { method: "GET", path: "/webhooks/{webhookId}/latest", group: "webhooks", write: false },
+    { method: "GET", path: "/webhooks/{webhookId}/statistics", group: "webhooks", write: false },
+    { method: "GET", path: "/webhooks/{webhookId}/statistics/summary", group: "webhooks", write: false },
+    { method: "POST", path: "/webhooks/test", group: "webhooks", write: true },
+];
+export function findEndpoint(method, path) {
+    return CONFLUENCE_7_13_7_ENDPOINTS.find((endpoint) => endpoint.method === method && endpoint.path === path);
+}
+//# sourceMappingURL=endpoints.js.map

package/dist/api/index.d.ts

@@ -0,0 +1,148 @@
+import type { ConfluenceConfig } from "../types/common.js";
+import type { RestMethod } from "./endpoints.js";
+export interface ContentBody {
+    storage?: {
+        value: string;
+        representation: "storage";
+    };
+    view?: {
+        value: string;
+        representation: "view";
+    };
+    wiki?: {
+        value: string;
+        representation: "wiki";
+    };
+}
+export interface ConfluenceContent {
+    id: string;
+    type: string;
+    title: string;
+    space?: {
+        key: string;
+        name?: string;
+    };
+    version?: {
+        number: number;
+        by?: {
+            displayName?: string;
+        };
+        when?: string;
+    };
+    ancestors?: Array<{
+        id: string;
+        title: string;
+    }>;
+    body?: ContentBody;
+    _links?: Record<string, string>;
+}
+export interface ConfluencePage<T> {
+    results: T[];
+    size: number;
+    limit?: number;
+    start?: number;
+    _links?: Record<string, string>;
+}
+export interface ConfluenceLabel {
+    prefix?: string;
+    name: string;
+}
+export interface ConfluenceAttachment {
+    id: string;
+    type: "attachment";
+    title: string;
+    version?: {
+        number: number;
+    };
+    metadata?: {
+        mediaType?: string;
+    };
+    _links?: Record<string, string>;
+}
+export declare class ConfluenceApi {
+    private readonly http;
+    constructor(config: ConfluenceConfig);
+    search(cql: string, limit?: number): Promise<{
+        results: ConfluenceContent[];
+        size: number;
+    }>;
+    getContent(id: string, expand?: string): Promise<ConfluenceContent>;
+    findContent(input: {
+        space?: string;
+        title?: string;
+        type?: string;
+        limit?: number;
+        expand?: string;
+    }): Promise<ConfluencePage<ConfluenceContent>>;
+    createContent(input: {
+        space: string;
+        title: string;
+        body: string;
+        representation: "wiki" | "storage";
+        parentId?: string;
+    }): Promise<ConfluenceContent>;
+    updateContent(input: {
+        id: string;
+        title: string;
+        body: string;
+        representation: "wiki" | "storage";
+        version: number;
+        parentId?: string;
+    }): Promise<ConfluenceContent>;
+    deleteContent(id: string): Promise<unknown>;
+    getChildren(id: string, type?: string, expand?: string, limit?: number): Promise<ConfluencePage<ConfluenceContent>>;
+    getComments(id: string, expand?: string, limit?: number): Promise<ConfluencePage<ConfluenceContent>>;
+    addComment(input: {
+        pageId: string;
+        body: string;
+        representation: "wiki" | "storage";
+        location?: "inline" | "footer";
+    }): Promise<ConfluenceContent>;
+    addInlineComment(input: {
+        pageId: string;
+        selection: string;
+        body: string;
+        representation: "wiki" | "storage";
+    }): Promise<ConfluenceContent>;
+    setContentProperty(contentId: string, key: string, value: unknown): Promise<unknown>;
+    setContentProperties(contentId: string, properties: Array<{
+        key: string;
+        value: unknown;
+    }>): Promise<void>;
+    getLabels(id: string, limit?: number): Promise<ConfluencePage<ConfluenceLabel>>;
+    addLabels(id: string, labels: string[]): Promise<ConfluencePage<ConfluenceLabel>>;
+    deleteLabel(id: string, label: string): Promise<unknown>;
+    listAttachments(id: string, limit?: number): Promise<ConfluencePage<ConfluenceAttachment>>;
+    uploadAttachment(input: {
+        pageId: string;
+        filename: string;
+        data: Buffer;
+        comment?: string;
+        minorEdit?: boolean;
+        contentType?: string;
+    }): Promise<ConfluencePage<ConfluenceAttachment>>;
+    updateAttachmentData(input: {
+        pageId: string;
+        attachmentId: string;
+        filename: string;
+        data: Buffer;
+        comment?: string;
+        minorEdit?: boolean;
+        contentType?: string;
+    }): Promise<ConfluencePage<ConfluenceAttachment>>;
+    downloadAttachment(downloadPath: string): Promise<{
+        data: Buffer;
+        headers: Record<string, unknown>;
+    }>;
+    listSpaces(limit?: number): Promise<ConfluencePage<{
+        key: string;
+        name: string;
+    }>>;
+    getSpace(spaceKey: string): Promise<{
+        key: string;
+        name: string;
+    }>;
+    getCurrentUser(): Promise<unknown>;
+    convertBody(to: "storage" | "view" | "export_view" | "styled_view", body: unknown): Promise<unknown>;
+    request<T>(method: RestMethod, path: string, query?: Record<string, unknown>, body?: unknown): Promise<T>;
+}

package/dist/api/index.js

@@ -0,0 +1,143 @@
+import { ConfluenceHttpClient } from "../core/http.js";
+import { findAndAnnotateSelection } from "../core/inline-comment.js";
+export class ConfluenceApi {
+    http;
+    constructor(config) {
+        this.http = new ConfluenceHttpClient(config);
+    }
+    search(cql, limit = 25) {
+        return this.http.get("/content/search", { cql, limit, expand: "space,version" });
+    }
+    getContent(id, expand = "body.storage,version,space,ancestors,metadata.labels") {
+        return this.http.get(`/content/${encodeURIComponent(id)}`, { expand });
+    }
+    findContent(input) {
+        return this.http.get("/content", {
+            spaceKey: input.space,
+            title: input.title,
+            type: input.type ?? "page",
+            limit: input.limit ?? 25,
+            expand: input.expand ?? "space,version",
+        });
+    }
+    async createContent(input) {
+        return this.http.post("/content", {
+            type: "page",
+            title: input.title,
+            space: { key: input.space },
+            ancestors: input.parentId ? [{ id: input.parentId }] : undefined,
+            body: { [input.representation]: { value: input.body, representation: input.representation } },
+        });
+    }
+    async updateContent(input) {
+        return this.http.put(`/content/${encodeURIComponent(input.id)}`, {
+            id: input.id,
+            type: "page",
+            title: input.title,
+            ancestors: input.parentId ? [{ id: input.parentId }] : undefined,
+            version: { number: input.version },
+            body: { [input.representation]: { value: input.body, representation: input.representation } },
+        });
+    }
+    deleteContent(id) {
+        return this.http.delete(`/content/${encodeURIComponent(id)}`);
+    }
+    getChildren(id, type, expand = "space,version", limit = 25) {
+        const suffix = type ? `/${encodeURIComponent(type)}` : "";
+        return this.http.get(`/content/${encodeURIComponent(id)}/child${suffix}`, { expand, limit });
+    }
+    getComments(id, expand = "body.storage,version", limit = 25) {
+        return this.http.get(`/content/${encodeURIComponent(id)}/child/comment`, { expand, limit });
+    }
+    addComment(input) {
+        return this.http.post("/content", {
+            type: "comment",
+            container: { id: input.pageId, type: "page" },
+            body: { [input.representation]: { value: input.body, representation: input.representation } },
+            extensions: input.location ? { location: input.location } : undefined,
+        });
+    }
+    async addInlineComment(input) {
+        // 1. 先创建评论，拿到 comment ID（Server 版 marker.ac:ref = commentId）
+        const comment = await this.addComment({
+            pageId: input.pageId,
+            body: input.body,
+            representation: input.representation,
+            location: "inline",
+        });
+        // 2. 拉取当前页面 storage body + version
+        const page = await this.getContent(input.pageId, "body.storage,version,title");
+        const storageBody = page.body?.storage?.value;
+        if (!storageBody)
+            throw new Error("Page has no storage-format body.");
+        // 3. 在 storage 中定位选中文字并注入 marker（ref = commentId）
+        const result = findAndAnnotateSelection(storageBody, input.selection, comment.id);
+        if (!result) {
+            // 回滚：删除刚创建的无关联评论
+            await this.deleteContent(comment.id).catch(() => { });
+            const preview = input.selection.slice(0, 80);
+            throw new Error(`Selected text "${preview}${input.selection.length > 80 ? "..." : ""}" not found in page body. The text may span XML boundary, exist inside a macro, or differ from the storage format.`);
+        }
+        // 4. 更新页面 body（版本 +1），注入 marker
+        const version = (page.version?.number ?? 0) + 1;
+        await this.updateContent({
+            id: input.pageId,
+            title: page.title,
+            body: result.annotatedBody,
+            representation: "storage",
+            version,
+        });
+        // 5. 设置评论的 Content Properties（标记为 inline comment）
+        await this.setContentProperties(comment.id, [
+            { key: "inline-comment", value: "true" },
+            { key: "inline-marker-ref", value: comment.id },
+            { key: "inline-original-selection", value: input.selection },
+        ]);
+        return comment;
+    }
+    async setContentProperty(contentId, key, value) {
+        return this.http.post(`/content/${encodeURIComponent(contentId)}/property`, { key, value });
+    }
+    async setContentProperties(contentId, properties) {
+        for (const prop of properties) {
+            await this.setContentProperty(contentId, prop.key, prop.value);
+        }
+    }
+    getLabels(id, limit = 100) {
+        return this.http.get(`/content/${encodeURIComponent(id)}/label`, { limit });
+    }
+    addLabels(id, labels) {
+        return this.http.post(`/content/${encodeURIComponent(id)}/label`, labels.map((name) => ({ prefix: "global", name })));
+    }
+    deleteLabel(id, label) {
+        return this.http.delete(`/content/${encodeURIComponent(id)}/label/${encodeURIComponent(label)}`);
+    }
+    listAttachments(id, limit = 100) {
+        return this.http.get(`/content/${encodeURIComponent(id)}/child/attachment`, { limit, expand: "version,metadata" });
+    }
+    uploadAttachment(input) {
+        return this.http.postMultipart(`/content/${encodeURIComponent(input.pageId)}/child/attachment`, { comment: input.comment, minorEdit: input.minorEdit }, [{ fieldName: "file", filename: input.filename, data: input.data, contentType: input.contentType }]);
+    }
+    updateAttachmentData(input) {
+        return this.http.postMultipart(`/content/${encodeURIComponent(input.pageId)}/child/attachment/${encodeURIComponent(input.attachmentId)}/data`, { comment: input.comment, minorEdit: input.minorEdit }, [{ fieldName: "file", filename: input.filename, data: input.data, contentType: input.contentType }]);
+    }
+    downloadAttachment(downloadPath) {
+        return this.http.getBuffer(downloadPath);
+    }
+    listSpaces(limit = 25) {
+        return this.http.get("/space", { limit });
+    }
+    getSpace(spaceKey) {
+        return this.http.get(`/space/${encodeURIComponent(spaceKey)}`);
+    }
+    getCurrentUser() {
+        return this.http.get("/user/current");
+    }
+    convertBody(to, body) {
+        return this.http.post(`/contentbody/convert/${encodeURIComponent(to)}`, body);
+    }
+    request(method, path, query, body) {
+        return this.http.request(method, path, query, body);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/bin/confluence-reader.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/confluence-reader.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { runCli } from "../cli.js";
+await runCli(["--role", "reader", ...process.argv.slice(2)]).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=confluence-reader.js.map

package/dist/bin/confluence-writer.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/confluence-writer.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { runCli } from "../cli.js";
+await runCli(["--role", "writer", ...process.argv.slice(2)]).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=confluence-writer.js.map

package/dist/bin/confluence.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/confluence.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { runCli } from "../cli.js";
+try {
+    await runCli(process.argv.slice(2));
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+}
+//# sourceMappingURL=confluence.js.map

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare function runCli(argv: string[]): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,154 @@
+import { parseCommandInput } from "./core/cli-registry.js";
+import { BUILTIN_COMMAND_NAMES, getBuiltinCommandHelp, printCommandHelp, printCommandList, printHelp, renderChangelog, } from "./core/cli-output.js";
+import { buildRegistryForCommand, getAvailableCommandNames } from "./core/manifest.js";
+import { runInstallCommand, runUninstallCommand, runUpdateCommand } from "./install.js";
+import { runDailyUpdateProbe } from "./update-probe.js";
+import { VERSION } from "./version.js";
+export async function runCli(argv) {
+    const { command, commandArgs, role } = parseCli(argv);
+    const registeredCommandNames = await getAvailableCommandNames(role);
+    const commandNames = [...new Set([...BUILTIN_COMMAND_NAMES, ...registeredCommandNames])]
+        .sort((left, right) => left.localeCompare(right));
+    await runDailyUpdateProbe(command);
+    if (command === "help" && commandArgs[0] && !commandArgs[0].startsWith("--")) {
+        const builtinHelp = getBuiltinCommandHelp(commandArgs[0]);
+        if (builtinHelp) {
+            process.stdout.write(`${builtinHelp}\n`);
+            return;
+        }
+        const targetRegistry = await buildRegistryForCommand(role, commandArgs[0]);
+        printCommandHelp(targetRegistry, commandArgs[0]);
+        return;
+    }
+    const helpIndex = commandArgs.indexOf("--help");
+    if (command && helpIndex >= 0) {
+        const builtinHelp = getBuiltinCommandHelp(command);
+        if (builtinHelp) {
+            process.stdout.write(`${builtinHelp}\n`);
+            return;
+        }
+        const targetRegistry = await buildRegistryForCommand(role, command);
+        printCommandHelp(targetRegistry, command);
+        return;
+    }
+    if (!command || command === "help") {
+        printHelp(role, registeredCommandNames);
+        return;
+    }
+    if (command === "list") {
+        const listOptions = parseListOptions(commandArgs);
+        if (listOptions.raw) {
+            process.stdout.write(`${commandNames.join("\n")}\n`);
+            return;
+        }
+        printCommandList(role, registeredCommandNames);
+        return;
+    }
+    if (command === "version") {
+        ensureNoUnexpectedArgs("version", commandArgs);
+        process.stdout.write(`${VERSION}\n`);
+        return;
+    }
+    if (command === "changelog") {
+        const options = parseChangelogOptions(commandArgs);
+        process.stdout.write(`${await renderChangelog(options)}\n`);
+        return;
+    }
+    if (command === "install") {
+        await runInstallCommand(commandArgs);
+        return;
+    }
+    if (command === "update" || command === "upgrade") {
+        await runUpdateCommand(commandArgs);
+        return;
+    }
+    if (command === "uninstall" || command === "remove") {
+        await runUninstallCommand(commandArgs);
+        return;
+    }
+    const commandRegistry = await buildRegistryForCommand(role, command);
+    const selected = commandRegistry.get(command);
+    if (!selected) {
+        throw new Error(`Unknown command: ${command}`);
+    }
+    const input = parseCommandInput(selected.schema, commandArgs);
+    const result = await selected.handler(input);
+    process.stdout.write(`${result.content[0]?.text ?? ""}\n`);
+}
+function parseListOptions(args) {
+    const unexpectedArgs = args.filter((arg) => arg !== "--raw");
+    if (unexpectedArgs.length > 0) {
+        throw new Error(`list 不支持额外参数: ${unexpectedArgs.join(" ")}`);
+    }
+    return { raw: args.includes("--raw") };
+}
+function ensureNoUnexpectedArgs(commandName, args) {
+    if (args.length > 0) {
+        throw new Error(`${commandName} 不支持额外参数: ${args.join(" ")}`);
+    }
+}
+function parseChangelogOptions(args) {
+    const options = { limit: 5, raw: false };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--raw") {
+            options.raw = true;
+            continue;
+        }
+        if (arg === "--limit" || arg.startsWith("--limit=")) {
+            const value = arg.startsWith("--limit=") ? arg.slice("--limit=".length) : args[++index];
+            if (value === undefined)
+                throw new Error("changelog --limit 需要一个值");
+            if (value === "all") {
+                options.limit = "all";
+                continue;
+            }
+            const parsed = Number(value);
+            if (!Number.isInteger(parsed) || parsed <= 0) {
+                throw new Error(`changelog --limit 必须是正整数或 all，收到: ${value}`);
+            }
+            options.limit = parsed;
+            continue;
+        }
+        if (arg === "--version" || arg.startsWith("--version=")) {
+            const value = arg.startsWith("--version=") ? arg.slice("--version=".length) : args[++index];
+            if (!value)
+                throw new Error("changelog --version 需要一个值");
+            options.version = value;
+            continue;
+        }
+        if (arg === "--since" || arg.startsWith("--since=")) {
+            const value = arg.startsWith("--since=") ? arg.slice("--since=".length) : args[++index];
+            if (!value)
+                throw new Error("changelog --since 需要一个值");
+            options.since = value;
+            continue;
+        }
+        throw new Error(`changelog 不支持参数: ${arg}`);
+    }
+    return options;
+}
+function parseCli(argv) {
+    const args = [...argv];
+    let role = "full";
+    const inlineRoleIndex = args.findIndex((arg) => arg.startsWith("--role=") || arg.startsWith("-r="));
+    if (inlineRoleIndex >= 0) {
+        const value = args[inlineRoleIndex].split("=", 2)[1];
+        if (value !== "full" && value !== "reader" && value !== "writer") {
+            throw new Error(`无效 role: ${value}`);
+        }
+        role = value;
+        args.splice(inlineRoleIndex, 1);
+    }
+    const roleIndex = args.indexOf("--role");
+    if (roleIndex >= 0) {
+        const value = args[roleIndex + 1];
+        if (value !== "full" && value !== "reader" && value !== "writer") {
+            throw new Error("--role must be full, reader, or writer");
+        }
+        role = value;
+        args.splice(roleIndex, 2);
+    }
+    return { command: args[0], commandArgs: args.slice(1), role };
+}
+//# sourceMappingURL=cli.js.map

package/dist/core/api-provider.d.ts

@@ -0,0 +1,3 @@
+import { ConfluenceApi } from "../api/index.js";
+export declare function setApi(nextApi: ConfluenceApi): void;
+export declare function getApi(): ConfluenceApi;

package/dist/core/api-provider.js

@@ -0,0 +1,13 @@
+import { ConfluenceApi } from "../api/index.js";
+import { loadConfluenceConfig } from "./config.js";
+let api = null;
+export function setApi(nextApi) {
+    api = nextApi;
+}
+export function getApi() {
+    if (api)
+        return api;
+    api = new ConfluenceApi(loadConfluenceConfig());
+    return api;
+}
+//# sourceMappingURL=api-provider.js.map

package/dist/core/changelog.d.ts

@@ -0,0 +1,7 @@
+export interface ChangelogSection {
+    version: string;
+    date: string;
+    content: string;
+}
+export declare function loadChangelogRaw(): Promise<string>;
+export declare function loadChangelogSections(): Promise<ChangelogSection[]>;

package/dist/core/changelog.js

@@ -0,0 +1,42 @@
+import { readFile } from "node:fs/promises";
+const VERSION_HEADING_REGEX = /^##\s+(\d+\.\d+\.\d+)\s*-\s*(\d{4}-\d{2}-\d{2})\s*$/;
+export async function loadChangelogRaw() {
+    const changelogUrl = new URL("../../CHANGELOG.md", import.meta.url);
+    try {
+        return await readFile(changelogUrl, "utf8");
+    }
+    catch {
+        throw new Error("未找到 CHANGELOG.md");
+    }
+}
+export async function loadChangelogSections() {
+    const text = await loadChangelogRaw();
+    const sections = [];
+    const lines = text.split("\n");
+    let current = null;
+    for (const line of lines) {
+        const match = line.match(VERSION_HEADING_REGEX);
+        if (match) {
+            if (current) {
+                sections.push({
+                    version: current.version,
+                    date: current.date,
+                    content: current.lines.join("\n").trimEnd(),
+                });
+            }
+            current = { version: match[1], date: match[2], lines: [line] };
+        }
+        else if (current) {
+            current.lines.push(line);
+        }
+    }
+    if (current) {
+        sections.push({
+            version: current.version,
+            date: current.date,
+            content: current.lines.join("\n").trimEnd(),
+        });
+    }
+    return sections;
+}
+//# sourceMappingURL=changelog.js.map