@jacobbubu/md-to-lark 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 jacobbubu
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,171 @@
+# md-to-lark
+
+[中文说明](./README_zh.md)
+
+`md-to-lark` publishes Markdown (GFM) content to Feishu docs through a repeatable pipeline.
+
+It is not a one-off rendering script. The pipeline covers input preparation, title policy, asset detection and upload, Mermaid rendering, table enhancement, dry-run, and stage-by-stage artifacts for debugging.
+
+## Repository And Package Name
+
+- GitHub repository: [jacobbubu/md-to-lark](https://github.com/jacobbubu/md-to-lark)
+- The npm package metadata is configured as `@jacobbubu/md-to-lark`
+- The dependency `@jacobbubu/md-zh-format` remains unchanged
+
+Notes:
+
+- The commands in this README are still focused on local development and verification.
+- Once the package is actually published to npm, it can be installed as `@jacobbubu/md-to-lark`.
+
+## What It Is Good For
+
+- Publishing a single Markdown file to a Feishu doc
+- Recursively publishing multiple `.md` files from a directory
+- Preparing local assets, remote images, and standalone URLs before publish
+- Running a full dry-run without writing to Feishu
+- Rewriting Markdown before publish with presets
+
+## Quick Start
+
+Install dependencies first:
+
+```bash
+npm install
+```
+
+Then prepare `.env`:
+
+```bash
+cp .env.sample .env
+```
+
+At minimum, make sure these values are valid:
+
+```env
+LARK_APP_ID="xxx"
+LARK_APP_SECRET="xxx"
+LARK_TOKEN_TYPE=tenant
+LARK_FOLDER_TOKEN="xxx"
+```
+
+Notes:
+
+- `--dry-run` still validates Feishu configuration first. It is not a zero-config mode.
+- As long as `--doc` is not provided, `LARK_FOLDER_TOKEN` is required for single-file, directory, dry-run, and real publish modes.
+
+The first run should use a built-in sample:
+
+```bash
+npm run publish:md -- --input ./test-md/comp/comp.md --dry-run
+```
+
+This runs the full pipeline without actually writing to Feishu. After that looks correct, remove `--dry-run`:
+
+```bash
+npm run publish:md -- --input ./test-md/comp/comp.md
+```
+
+## Common Commands
+
+Basic publish:
+
+```bash
+npm run publish:md -- --input ./test-md/comp/comp.md
+npm run publish:md -- --input ./test-md/comp/comp.md --dry-run
+npm run publish:md -- --input ./test-md
+```
+
+Target document and title:
+
+```bash
+npm run publish:md -- --input ./test-md/comp/comp.md --doc <document_id>
+npm run publish:md -- --input ./test-md --title "Team Notes"
+npm run publish:md -- --input ./test-md/comp/comp.md --no-date-prefix
+```
+
+Presets, Mermaid, and stage artifacts:
+
+```bash
+npm run publish:md -- --input ./test-md/comp/comp.md --preset medium --dry-run
+npm run publish:md -- --input ./test-md/comp/comp.md --preset zh-format --dry-run
+npm run publish:md -- --input ./test-md/mermaid.md --mermaid-target board --dry-run
+npm run publish:md -- --input ./test-md/comp/comp.md --pipeline-cache-dir ./out/debug-cache --dry-run
+```
+
+Debugging and helper scripts:
+
+```bash
+npm run dev:playground
+npm run example:module
+npm run fetch:board-data -- --doc <document_id> --index 1
+```
+
+## Testing
+
+Default local verification:
+
+```bash
+npm run check
+npm test
+```
+
+Live Feishu end-to-end tests:
+
+```bash
+npm run test:e2e
+npm run test:e2e:watch
+```
+
+Notes:
+
+- `npm test` only runs local tests and never writes to Feishu.
+- `npm run test:e2e` runs real Feishu end-to-end tests and requires a local `.env-test`.
+- `.env-test` is already ignored by Git and can be prepared from `.env-test.example`.
+
+## Release Process
+
+Releases are now driven by `semantic-release`.
+
+- Only pushes to `main` can trigger a real release
+- Version numbers are calculated from commit messages
+- GitHub Releases and npm publishing are both handled automatically
+- `CHANGELOG.md` is maintained by CI
+
+Required repository setup:
+
+- GitHub Actions must be enabled
+- The repository must have an `NPM_TOKEN` secret with publish permission for `@jacobbubu/md-to-lark`
+- Commits merged into `main` should continue to use Conventional Commit style such as `feat:` and `fix:`
+
+Guardrails:
+
+- Non-`main` branches do not trigger the release workflow
+- Non-`main` branches can still run local checks, tests, and build verification
+- npm publishing is expected to happen only through the `main` branch CI flow
+
+## Core Capabilities
+
+- Single-file and recursive directory publish
+- Title derivation, title prefix, and single-H1 promotion
+- Local attachment and image detection with real upload
+- Remote image download and standalone URL preparation
+- Mermaid `text-drawing` and `board` output paths
+- Table width heuristics and numeric-column right alignment
+- Chinese Markdown formatting preset (`zh-format`)
+- Stage cache output from `00-source` to `05-publish`
+- Programmatic access through `publishMdToLark`
+
+## Where To Read Next
+
+README is only the entry point. It does not repeat the full parameter reference or implementation details.
+
+1. [docs/README.md](./docs/README.md)
+2. [overview.md](./docs/01-getting-started/overview.md)
+3. [quickstart.md](./docs/01-getting-started/quickstart.md)
+4. [presets.md](./docs/02-guides/presets.md)
+5. [cli-reference.md](./docs/03-reference/cli-reference.md)
+6. [architecture-overview.md](./docs/04-internals/architecture-overview.md)
+
+If this is your first time using the project, read in this order:
+
+`01-getting-started -> 02-guides -> 03-reference -> 04-internals`

package/dist/btt/build-tree.js

@@ -0,0 +1,79 @@
+import { getLarkBlockTypeName } from '../lark/block-types.js';
+function pickRootBlockId(documentId, blocks, blocksById) {
+    if (blocks.length === 0) {
+        throw new Error(`No blocks returned for document "${documentId}".`);
+    }
+    const pageRoot = blocks.find((block) => block.block_type === 1);
+    if (pageRoot) {
+        return pageRoot.block_id;
+    }
+    const orphan = blocks.find((block) => !blocksById.has(block.parent_id));
+    if (orphan) {
+        return orphan.block_id;
+    }
+    const first = blocks[0];
+    if (!first) {
+        throw new Error(`No root block found for document "${documentId}".`);
+    }
+    return first.block_id;
+}
+function cloneBlock(block) {
+    return JSON.parse(JSON.stringify(block));
+}
+function buildNode(blockId, ctx, visiting) {
+    const block = ctx.blocksById.get(blockId);
+    if (!block) {
+        throw new Error(`Block "${blockId}" is missing while building BTT.`);
+    }
+    if (visiting.has(blockId)) {
+        throw new Error(`Cycle detected in block tree at "${blockId}".`);
+    }
+    visiting.add(blockId);
+    const children = [];
+    for (const childId of block.children ?? []) {
+        if (!ctx.blocksById.has(childId)) {
+            ctx.missingChildren.add(childId);
+            continue;
+        }
+        children.push(buildNode(childId, ctx, visiting));
+    }
+    visiting.delete(blockId);
+    return {
+        blockId: block.block_id,
+        parentId: block.parent_id,
+        blockType: block.block_type,
+        blockTypeName: getLarkBlockTypeName(block.block_type),
+        rawBlock: cloneBlock(block),
+        children,
+    };
+}
+function toFlatBlocks(blocks) {
+    const output = {};
+    for (const block of blocks) {
+        output[block.block_id] = cloneBlock(block);
+    }
+    return output;
+}
+export function buildBTT(documentId, blocks) {
+    const blocksById = new Map();
+    for (const block of blocks) {
+        blocksById.set(block.block_id, block);
+    }
+    const rootBlockId = pickRootBlockId(documentId, blocks, blocksById);
+    const ctx = {
+        blocksById,
+        missingChildren: new Set(),
+    };
+    const root = buildNode(rootBlockId, ctx, new Set());
+    return {
+        schema: 'BTT',
+        version: '1.0.0',
+        documentId,
+        generatedAt: new Date().toISOString(),
+        rootBlockId,
+        totalBlocks: blocks.length,
+        missingChildren: Array.from(ctx.missingChildren),
+        root,
+        flatBlocks: toFlatBlocks(blocks),
+    };
+}

package/dist/btt/index.js

@@ -0,0 +1 @@
+export { buildBTT } from './build-tree.js';

package/dist/btt/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/publish-md-to-lark.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { getPublishMdUsage, runPublishMdToLarkCli } from '../commands/publish-md/index.js';
+async function main() {
+    try {
+        await runPublishMdToLarkCli(process.argv.slice(2), process.env);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        console.error('');
+        console.error(getPublishMdUsage());
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/commands/publish-md/args.js

@@ -0,0 +1,224 @@
+function usage() {
+    return [
+        'Usage: npm run publish:md -- --input <file.md|dir> [--title <doc_title_or_prefix>] [--date-prefix|--no-date-prefix] [--preset <preset_name_or_module_path>] [--folder <folder_token>] [--doc <document_id>] [--download-remote-images|--no-download-remote-images] [--yt-dlp-path <path>] [--yt-dlp-cookies-path <path>] [--pipeline-cache-dir <dir>] [--mermaid-target <text-drawing|board>] [--mermaid-board-syntax-type <int>] [--mermaid-board-style-type <int>] [--mermaid-board-diagram-type <int>] [--dry-run] [--help|-h]',
+        '',
+        'Options:',
+        '  --input   Markdown file path, or directory path (publish all *.md recursively).',
+        '  --title   Single-file title. In directory mode this is used as title prefix.',
+        '  --date-prefix      Enable date prefix in final title: YYYYMMDD-<title>. Default: enabled.',
+        '  --no-date-prefix   Disable date prefix in final title.',
+        '  --preset  Optional preset module path (js/mjs/cjs/ts) or built-in name (e.g. medium). Used to transform markdown before publish pipeline.',
+        '  --folder  Feishu folder token. Default: LARK_FOLDER_TOKEN from .env',
+        '  --doc     Existing Feishu document id (single-file only). If set, publish directly into this doc (and clear content first).',
+        '  --download-remote-images    Enable prepare-stage remote image pre-download + link rewrite.',
+        '  --no-download-remote-images Disable prepare-stage remote image pre-download.',
+        '  --yt-dlp-path               Optional yt-dlp executable path for standalone URL extraction.',
+        '  --yt-dlp-cookies-path       Optional cookie file path passed to yt-dlp --cookies.',
+        '  --pipeline-cache-dir        Pipeline cache root directory. Default: ./out/pipeline-cache',
+        '  --mermaid-target            Mermaid render target: text-drawing (default) or board.',
+        '  --mermaid-board-syntax-type Optional integer syntax_type for board createPlantuml (default: 2).',
+        '  --mermaid-board-style-type  Optional integer style_type for board createPlantuml.',
+        '  --mermaid-board-diagram-type Optional integer diagram_type for board createPlantuml.',
+        '  --dry-run Build pipeline and print patch stats only, do not call Feishu API.',
+        '  --help, -h Show this help message and exit.',
+        '',
+        'Notes:',
+        '  1) Local image/file paths are uploaded to Feishu and replaced by token.',
+        '  2) Mermaid code fences can be rendered as text-drawing (block_type=40) or board (block_type=43).',
+        '  3) Tables use width heuristics + numeric-column right align + row/column expansion strategy when size > 9.',
+        '  4) Final title uses date prefix by default (YYYYMMDD-<title>); disable with --no-date-prefix or LARK_TITLE_DATE_PREFIX=false.',
+        '  5) If markdown has exactly one h1 and --title is not provided, that h1 becomes doc title, then removed from content, and remaining headings are promoted by one level.',
+        '  6) Stage cache layout per markdown: 00-source, 01-prepare, 02-hast, 03-last, 04-btt, 05-publish.',
+        '  7) Prepare stage can pre-download remote markdown images and optional yt-dlp URL lines.',
+        '  8) Leading YAML/TOML frontmatter is rewritten as fenced code block (yaml/toml), so it stays visible and will not be parsed as headings.',
+        '  9) Missing local asset files are skipped/degraded to text fallback; publish will not fail only because a referenced local path is absent.',
+        '',
+        'Examples:',
+        '  npm run publish:md -- --input ./docs/a.md',
+        '  npm run publish:md -- --input ./docs --title Weekly --folder <token>',
+        '  npm run publish:md -- --input ./docs/a.md --doc <document_id>',
+        '  npm run publish:md -- --input ./docs/a.md --dry-run',
+    ].join('\n');
+}
+export function getPublishMdUsage() {
+    return usage();
+}
+export function hasPublishMdHelpFlag(argv) {
+    return argv.includes('--help') || argv.includes('-h');
+}
+export function parsePublishMdArgs(argv, env = process.env) {
+    let inputPath = '';
+    let title = '';
+    let titleDatePrefix;
+    let presetPath = '';
+    let folderToken = (env.LARK_FOLDER_TOKEN ?? '').trim();
+    let documentId;
+    let downloadRemoteImages;
+    let ytDlpPath = '';
+    let ytDlpCookiesPath = '';
+    let pipelineCacheDir = '';
+    let mermaidTarget;
+    let mermaidBoardSyntaxType;
+    let mermaidBoardStyleType;
+    let mermaidBoardDiagramType;
+    let dryRun = false;
+    const parseNonNegativeInt = (name, value) => {
+        const parsed = Number.parseInt(value, 10);
+        if (!Number.isFinite(parsed) || parsed < 0) {
+            throw new Error(`${name} must be a non-negative integer, received: ${value}`);
+        }
+        return parsed;
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (!arg)
+            continue;
+        if (arg === '--input') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('Missing value for --input.');
+            inputPath = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '--title') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('Missing value for --title.');
+            title = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '--date-prefix') {
+            titleDatePrefix = true;
+            continue;
+        }
+        if (arg === '--no-date-prefix') {
+            titleDatePrefix = false;
+            continue;
+        }
+        if (arg === '--folder') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('Missing value for --folder.');
+            folderToken = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '--preset') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('Missing value for --preset.');
+            presetPath = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '--doc') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('Missing value for --doc.');
+            documentId = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '--download-remote-images') {
+            downloadRemoteImages = true;
+            continue;
+        }
+        if (arg === '--no-download-remote-images') {
+            downloadRemoteImages = false;
+            continue;
+        }
+        if (arg === '--yt-dlp-path') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('Missing value for --yt-dlp-path.');
+            ytDlpPath = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '--yt-dlp-cookies-path') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('Missing value for --yt-dlp-cookies-path.');
+            ytDlpCookiesPath = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '--pipeline-cache-dir') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('Missing value for --pipeline-cache-dir.');
+            pipelineCacheDir = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '--mermaid-target') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('Missing value for --mermaid-target.');
+            mermaidTarget = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '--mermaid-board-syntax-type') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('Missing value for --mermaid-board-syntax-type.');
+            mermaidBoardSyntaxType = parseNonNegativeInt('--mermaid-board-syntax-type', value);
+            i += 1;
+            continue;
+        }
+        if (arg === '--mermaid-board-style-type') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('Missing value for --mermaid-board-style-type.');
+            mermaidBoardStyleType = parseNonNegativeInt('--mermaid-board-style-type', value);
+            i += 1;
+            continue;
+        }
+        if (arg === '--mermaid-board-diagram-type') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('Missing value for --mermaid-board-diagram-type.');
+            mermaidBoardDiagramType = parseNonNegativeInt('--mermaid-board-diagram-type', value);
+            i += 1;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            dryRun = true;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            throw new Error(`Unknown option: ${arg}`);
+        }
+        if (!inputPath) {
+            inputPath = arg;
+            continue;
+        }
+        throw new Error(`Unexpected extra argument: ${arg}`);
+    }
+    if (!inputPath.trim()) {
+        throw new Error('Input path is required. Use --input <file.md|dir>.');
+    }
+    if (!documentId && !folderToken) {
+        throw new Error('Folder token is required when --doc is not provided. Use --folder or set LARK_FOLDER_TOKEN.');
+    }
+    return {
+        inputPath: inputPath.trim(),
+        ...(title.trim() ? { title: title.trim() } : {}),
+        ...(titleDatePrefix === undefined ? {} : { titleDatePrefix }),
+        ...(presetPath.trim() ? { presetPath: presetPath.trim() } : {}),
+        folderToken,
+        ...(documentId ? { documentId: documentId.trim() } : {}),
+        ...(downloadRemoteImages === undefined ? {} : { downloadRemoteImages }),
+        ...(ytDlpPath.trim() ? { ytDlpPath: ytDlpPath.trim() } : {}),
+        ...(ytDlpCookiesPath.trim() ? { ytDlpCookiesPath: ytDlpCookiesPath.trim() } : {}),
+        ...(pipelineCacheDir.trim() ? { pipelineCacheDir: pipelineCacheDir.trim() } : {}),
+        ...(mermaidTarget ? { mermaidTarget } : {}),
+        ...(mermaidBoardSyntaxType === undefined ? {} : { mermaidBoardSyntaxType }),
+        ...(mermaidBoardStyleType === undefined ? {} : { mermaidBoardStyleType }),
+        ...(mermaidBoardDiagramType === undefined ? {} : { mermaidBoardDiagramType }),
+        dryRun,
+    };
+}

package/dist/commands/publish-md/command.js

@@ -0,0 +1,97 @@
+import { getPublishMdUsage, hasPublishMdHelpFlag, parsePublishMdArgs } from './args.js';
+import { resolvePublishInputSet } from './input-resolver.js';
+import { loadMarkdownPreset } from './preset-loader.js';
+import { createDocument, listFolderChildren, normalizeDocumentId } from '../../lark/docx/ops.js';
+import { processSingleMarkdownFile } from '../../publish/process-file.js';
+import { buildPublishRuntime, logPublishRuntimeSummary } from '../../publish/runtime.js';
+import { sleep } from '../../shared/rate-limiter.js';
+export { getPublishMdUsage, parsePublishMdArgs };
+function buildFolderDocIndex(entries) {
+    const byTitle = new Map();
+    for (const entry of entries) {
+        if (entry.type !== 'docx')
+            continue;
+        const title = entry.name;
+        const token = entry.token;
+        if (!title || !token)
+            continue;
+        const current = byTitle.get(title);
+        if (current) {
+            current.push(token);
+        }
+        else {
+            byTitle.set(title, [token]);
+        }
+    }
+    return byTitle;
+}
+function prependDocIntoFolderIndex(index, title, documentId) {
+    const current = index.get(title);
+    if (current) {
+        if (!current.includes(documentId)) {
+            current.unshift(documentId);
+        }
+        return;
+    }
+    index.set(title, [documentId]);
+}
+function createFolderDocumentResolver(runtime, options) {
+    let folderDocIndex = null;
+    const ensureFolderDocIndex = async () => {
+        if (folderDocIndex)
+            return folderDocIndex;
+        if (!options.folderToken) {
+            throw new Error('Folder token is required when publishing without --doc.');
+        }
+        const files = await listFolderChildren(runtime.sdkClient, options.folderToken, runtime.authOptions, runtime.docxLimiter);
+        folderDocIndex = buildFolderDocIndex(files);
+        return folderDocIndex;
+    };
+    return async (title) => {
+        const byTitle = await ensureFolderDocIndex();
+        const sameNameDocs = byTitle.get(title) ?? [];
+        if (sameNameDocs.length > 0) {
+            return sameNameDocs[0] ?? '';
+        }
+        const documentId = await createDocument(runtime.sdkClient, options.folderToken, title, runtime.authOptions, runtime.docxLimiter);
+        prependDocIntoFolderIndex(byTitle, title, documentId);
+        return documentId;
+    };
+}
+export async function publishMdToLark(options, env = process.env) {
+    const inputSet = await resolvePublishInputSet(options.inputPath);
+    const markdownPreset = await loadMarkdownPreset(options.presetPath);
+    if (options.documentId && inputSet.markdownFiles.length !== 1) {
+        throw new Error('--doc only supports single markdown input file.');
+    }
+    const runtime = buildPublishRuntime(options, env, markdownPreset);
+    logPublishRuntimeSummary(runtime, inputSet.markdownFiles.length, inputSet.mode);
+    const normalizedDocumentId = options.documentId ? normalizeDocumentId(options.documentId) : undefined;
+    const resolveTargetDocumentId = options.dryRun || normalizedDocumentId
+        ? undefined
+        : createFolderDocumentResolver(runtime, options);
+    for (let index = 0; index < inputSet.markdownFiles.length; index += 1) {
+        const markdownPath = inputSet.markdownFiles[index];
+        const perFileOptions = normalizedDocumentId ? { ...options, documentId: normalizedDocumentId } : options;
+        await processSingleMarkdownFile({
+            runtime,
+            inputSet,
+            options: perFileOptions,
+            markdownPath,
+            index,
+            ...(resolveTargetDocumentId ? { resolveTargetDocumentId } : {}),
+        });
+        if (!options.dryRun && index < inputSet.markdownFiles.length - 1 && runtime.publishCooldownMs > 0) {
+            console.log(`[${index + 1}/${inputSet.markdownFiles.length}] Cooldown ${runtime.publishCooldownMs}ms before next markdown...`);
+            await sleep(runtime.publishCooldownMs);
+        }
+    }
+}
+export async function runPublishMdToLarkCli(argv, env = process.env) {
+    if (hasPublishMdHelpFlag(argv)) {
+        console.log(getPublishMdUsage());
+        return;
+    }
+    const options = parsePublishMdArgs(argv, env);
+    await publishMdToLark(options, env);
+}

package/dist/commands/publish-md/index.js

@@ -0,0 +1 @@
+export { getPublishMdUsage, parsePublishMdArgs, publishMdToLark, runPublishMdToLarkCli } from './command.js';

package/dist/commands/publish-md/input-resolver.js

@@ -0,0 +1,48 @@
+import { readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+export function isMarkdownFilePath(filePath) {
+    return /\.md$/i.test(filePath);
+}
+async function collectMarkdownFilesRecursive(dirPath) {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            const nested = await collectMarkdownFilesRecursive(fullPath);
+            files.push(...nested);
+            continue;
+        }
+        if (entry.isFile() && isMarkdownFilePath(entry.name)) {
+            files.push(fullPath);
+        }
+    }
+    files.sort((a, b) => a.localeCompare(b, 'en'));
+    return files;
+}
+export async function resolvePublishInputSet(inputPath) {
+    const absolute = path.resolve(inputPath);
+    const stats = await stat(absolute);
+    if (stats.isFile()) {
+        if (!isMarkdownFilePath(absolute)) {
+            throw new Error(`Input file is not .md: ${absolute}`);
+        }
+        return {
+            mode: 'single',
+            rootPath: path.dirname(absolute),
+            markdownFiles: [absolute],
+        };
+    }
+    if (stats.isDirectory()) {
+        const markdownFiles = await collectMarkdownFilesRecursive(absolute);
+        if (markdownFiles.length === 0) {
+            throw new Error(`No .md files found under directory: ${absolute}`);
+        }
+        return {
+            mode: 'directory',
+            rootPath: absolute,
+            markdownFiles,
+        };
+    }
+    throw new Error(`Input path is neither file nor directory: ${absolute}`);
+}

package/dist/commands/publish-md/mermaid-render.js

@@ -0,0 +1,17 @@
+import { DEFAULT_MERMAID_RENDER_CONFIG, } from '../../lark/docx/render-types.js';
+export { DEFAULT_MERMAID_BOARD_SYNTAX_TYPE } from '../../lark/docx/render-types.js';
+const TEXT_DRAWING_TARGET_ALIASES = new Set(['text-drawing', 'text_drawing', 'textdrawing', 'text']);
+const BOARD_TARGET_ALIASES = new Set(['board', 'whiteboard', 'canvas']);
+export function normalizeMermaidRenderTarget(raw) {
+    const normalized = raw?.trim().toLowerCase() ?? '';
+    if (!normalized) {
+        return DEFAULT_MERMAID_RENDER_CONFIG.target;
+    }
+    if (TEXT_DRAWING_TARGET_ALIASES.has(normalized)) {
+        return 'text-drawing';
+    }
+    if (BOARD_TARGET_ALIASES.has(normalized)) {
+        return 'board';
+    }
+    throw new Error(`Invalid mermaid target "${raw}". Expected one of: text-drawing, board (aliases: text_drawing, textdrawing, whiteboard, canvas).`);
+}