feishu-md-sync 0.1.0

package/dist/status/run-status.js

@@ -0,0 +1,131 @@
+import { readFile } from 'node:fs/promises';
+import { canonicalMarkdown, canonicalMarkdownHash } from '../core/markdown-canonical.js';
+import { hashText, publishReceiptPath, readPublishReceipt } from '../receipts/publish-receipt.js';
+import { applyPublishTransformForProfile } from '../publish/profile-transform.js';
+export async function runStatus(input) {
+    return statusFromContext(await loadPublishStatusContext(input));
+}
+export async function loadPublishStatusContext(input) {
+    const localSource = await readFile(input.sourcePath, 'utf8');
+    const transform = applyPublishTransformForProfile(localSource, input.profile);
+    const remote = await input.adapter.fetchDocMarkdown({ doc: input.target.token });
+    const receipt = await readPublishReceipt({ cwd: input.cwd, target: input.target });
+    return {
+        cwd: input.cwd,
+        target: input.target,
+        sourcePath: input.sourcePath,
+        profile: input.profile,
+        localSource,
+        publishDraft: transform.markdown,
+        publishDraftCanonical: canonicalMarkdown(transform.markdown),
+        remoteMarkdown: remote.markdown,
+        remoteCanonical: canonicalMarkdown(remote.markdown),
+        remoteRevision: remote.revision,
+        receipt,
+        transformWarnings: transform.warnings
+    };
+}
+export function statusFromContext(context) {
+    const localSourceHash = hashText(context.localSource);
+    const publishDraftHash = hashText(context.publishDraft);
+    const publishDraftCanonicalHash = canonicalMarkdownHash(context.publishDraft);
+    const remoteSnapshotHash = hashText(context.remoteMarkdown);
+    const remoteCanonicalHash = canonicalMarkdownHash(context.remoteMarkdown);
+    const contentMatchesRemote = publishDraftCanonicalHash === remoteCanonicalHash;
+    const receiptPath = publishReceiptPath({ cwd: context.cwd, target: context.target });
+    if (!context.receipt) {
+        const state = 'untracked';
+        return {
+            target: context.target,
+            sourcePath: context.sourcePath,
+            profile: context.profile,
+            state,
+            localChanged: true,
+            remoteChanged: !contentMatchesRemote,
+            contentMatchesRemote,
+            hasReceipt: false,
+            receiptPath,
+            localSourceHash,
+            publishDraftHash,
+            publishDraftCanonicalHash,
+            remoteSnapshotHash,
+            remoteCanonicalHash,
+            remoteRevision: context.remoteRevision,
+            transformWarnings: context.transformWarnings,
+            recommendation: recommendationFor({ state, contentMatchesRemote })
+        };
+    }
+    const localChanged = context.receipt.publishDraftHash !== publishDraftHash;
+    const remoteChanged = context.receipt.remoteSnapshotHash !== remoteSnapshotHash;
+    const state = statusStateFor({ localChanged, remoteChanged });
+    return {
+        target: context.target,
+        sourcePath: context.sourcePath,
+        profile: context.profile,
+        state,
+        localChanged,
+        remoteChanged,
+        contentMatchesRemote,
+        hasReceipt: true,
+        receiptPath,
+        localSourceHash,
+        publishDraftHash,
+        publishDraftCanonicalHash,
+        remoteSnapshotHash,
+        remoteCanonicalHash,
+        remoteRevision: context.remoteRevision,
+        transformWarnings: context.transformWarnings,
+        recommendation: recommendationFor({ state, contentMatchesRemote })
+    };
+}
+function statusStateFor(input) {
+    if (input.localChanged && input.remoteChanged)
+        return 'diverged';
+    if (input.localChanged)
+        return 'local-changed';
+    if (input.remoteChanged)
+        return 'remote-changed';
+    return 'clean';
+}
+function recommendationFor(input) {
+    if (input.state === 'clean') {
+        return {
+            action: 'no-action',
+            reason: 'publish would be a no-op'
+        };
+    }
+    if (input.contentMatchesRemote) {
+        return {
+            action: 'publish-dry-run',
+            reason: 'content matches remote, but the publish receipt is stale'
+        };
+    }
+    if (input.state === 'local-changed') {
+        return {
+            action: 'publish-dry-run',
+            reason: 'local publish draft changed and remote still matches the last publish receipt'
+        };
+    }
+    if (input.state === 'remote-changed') {
+        return {
+            action: 'pull-review',
+            reason: 'remote changed since the last publish receipt'
+        };
+    }
+    if (input.state === 'diverged') {
+        return {
+            action: 'resolve-divergence',
+            reason: 'local publish draft and remote both changed since the last publish receipt'
+        };
+    }
+    if (input.contentMatchesRemote) {
+        return {
+            action: 'publish-dry-run',
+            reason: 'content matches remote, but no publish receipt exists for this target'
+        };
+    }
+    return {
+        action: 'adopt-or-replace',
+        reason: 'remote is untracked and differs from the current publish draft'
+    };
+}

package/dist/transform/include-tags.d.ts

@@ -0,0 +1,6 @@
+export declare function protectInlineSpans(line: string): {
+    protectedLine: string;
+    restore(value: string): string;
+};
+export declare function milvusOnly(value: string): string;
+export declare function dualProductName(): string;

package/dist/transform/include-tags.js

@@ -0,0 +1,22 @@
+export function protectInlineSpans(line) {
+    const spans = [];
+    const protect = (value) => {
+        const token = `\u0000${spans.length}\u0000`;
+        spans.push(value);
+        return token;
+    };
+    const protectedLine = line
+        .replace(/<include\b[\s\S]*?<\/include>/g, protect)
+        .replace(/`[^`]*`/g, protect)
+        .replace(/\[[^\]]+\]\([^)]+\)/g, protect);
+    return {
+        protectedLine,
+        restore: (value) => value.replace(/\u0000(\d+)\u0000/g, (_, index) => spans[Number(index)] ?? '')
+    };
+}
+export function milvusOnly(value) {
+    return `<include target="milvus">${value}</include>`;
+}
+export function dualProductName() {
+    return '<include target="milvus">Milvus</include><include target="zilliz">Zilliz Cloud</include>';
+}

package/dist/transform/zilliz-publish.d.ts

@@ -0,0 +1,5 @@
+export type PublishTransformResult = {
+    markdown: string;
+    warnings: string[];
+};
+export declare function applyZillizPublishTransform(markdown: string): PublishTransformResult;

package/dist/transform/zilliz-publish.js

@@ -0,0 +1,42 @@
+import { dualProductName, milvusOnly, protectInlineSpans } from './include-tags.js';
+const VERSIONED_MILVUS_PATTERN = /\bMilvus\s+v?\d+(?:\.\d+)*(?:\.x)?\b/;
+const ORDINARY_MILVUS_PATTERN = /\bMilvus(?!\s+v?\d)(?![-\w])/g;
+export function applyZillizPublishTransform(markdown) {
+    const warnings = [];
+    const lines = markdown.replace(/\r\n/g, '\n').split('\n');
+    let inCodeFence = false;
+    const transformed = lines.map((line) => {
+        if (/^```/.test(line.trim())) {
+            inCodeFence = !inCodeFence;
+            return line;
+        }
+        if (inCodeFence)
+            return line;
+        if (/^#{1,6}\s+/.test(line)) {
+            if (/\bMilvus\b/.test(line))
+                warnings.push(`Heading contains Milvus product wording and was not rewritten: ${line}`);
+            return line;
+        }
+        return transformLine(line);
+    }).join('\n');
+    return { markdown: transformed, warnings };
+}
+function transformLine(line) {
+    if (line.trim() === '')
+        return line;
+    const { protectedLine, restore } = protectInlineSpans(line);
+    const transformed = transformSentences(protectedLine);
+    return restore(transformed);
+}
+function transformSentences(line) {
+    return line
+        .split(/(?<=[.!?])(\s+)/)
+        .map((part) => {
+        if (/^\s+$/.test(part))
+            return part;
+        if (VERSIONED_MILVUS_PATTERN.test(part))
+            return milvusOnly(part);
+        return part.replace(ORDINARY_MILVUS_PATTERN, dualProductName());
+    })
+        .join('');
+}

package/dist/transform/zilliz-pull.d.ts

@@ -0,0 +1,6 @@
+import type { PublishProfileName } from '../profiles/publish-profile.js';
+export type PullTransformResult = {
+    markdown: string;
+    warnings: string[];
+};
+export declare function applyPullTransformForProfile(markdown: string, profile: PublishProfileName): PullTransformResult;

package/dist/transform/zilliz-pull.js

@@ -0,0 +1,34 @@
+const SUPPORTED_TARGETS = new Set(['milvus', 'zilliz']);
+const TAG_PATTERN = /<(include|exclude)\b([^>]*)>([\s\S]*?)<\/\1>/g;
+const TARGET_ATTR_PATTERN = /\btarget\s*=\s*["']([^"']+)["']/;
+export function applyPullTransformForProfile(markdown, profile) {
+    if (profile === 'none')
+        return { markdown, warnings: [] };
+    const warnings = [];
+    const transformed = markdown.replace(TAG_PATTERN, (full, tagName, attrs, content) => {
+        const targets = parseTargets(attrs);
+        if (!targets) {
+            warnings.push(`${tagName} tag without target attribute was left unchanged.`);
+            return full;
+        }
+        const unsupportedTargets = targets.filter((target) => !SUPPORTED_TARGETS.has(target));
+        if (unsupportedTargets.length > 0) {
+            warnings.push(`Unsupported ${tagName} target "${unsupportedTargets.join(', ')}"; left tag unchanged.`);
+            return full;
+        }
+        const matches = targets.includes(profile);
+        if (tagName === 'include')
+            return matches ? content : '';
+        return matches ? '' : content;
+    });
+    return { markdown: transformed, warnings };
+}
+function parseTargets(attrs) {
+    const match = attrs.match(TARGET_ATTR_PATTERN);
+    if (!match)
+        return undefined;
+    return match[1]
+        .split(/[,\s]+/)
+        .map((target) => target.trim())
+        .filter(Boolean);
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "feishu-md-sync",
+  "version": "0.1.0",
+  "description": "Dry-run-first sync between local Markdown and Feishu/Lark documents using the official lark-cli.",
+  "keywords": [
+    "feishu",
+    "lark",
+    "markdown",
+    "sync",
+    "cli"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/liyun95/feishu-md-sync.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://liyun95.github.io/feishu-md-sync/",
+  "bugs": {
+    "url": "https://github.com/liyun95/feishu-md-sync/issues"
+  },
+  "type": "module",
+  "bin": {
+    "feishu-md-sync": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "clean": "node scripts/clean-dist.mjs",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "prepack": "npm run build",
+    "test": "vitest run",
+    "test:live:feishu": "vitest run test/live-feishu-publish.test.ts && vitest run test/live-feishu-merge.test.ts",
+    "test:coverage": "vitest run --coverage",
+    "test:package": "npm run build && node scripts/package-smoke.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "dev": "tsx src/cli/index.ts"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.7"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@vitest/coverage-v8": "^3.2.4",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^3.2.4"
+  }
+}