@dinoxx/dinox-cli 1.0.17 → 1.0.19

package/dist/utils/tiptapMarkdownSchemaUtils.js

@@ -0,0 +1,394 @@
+const DINOX_COMMENT_REGEX = /^<!--\s*({[\s\S]*})\s*-->$/;
+const FRONTMATTER_BLOCK_RE = /^(?:\uFEFF)?---[ \t]*\n([\s\S]*?)\n---[ \t]*(?:\n|$)/;
+const EXACT_FRONTMATTER_BLOCK_RE = /^(?:\uFEFF)?---[ \t]*\n([\s\S]*?)\n---[ \t]*$/;
+const DEFAULT_FILE_TYPE = 'application/octet-stream';
+const IMAGE_WIDTH_PERCENT_ATTR = 'data-dinox-width-percent';
+const MEDIA_RESOURCE_ID_ATTR = 'data-resource-id';
+const MEDIA_STORAGE_KEY_ATTR = 'data-storage-key';
+const MIN_IMAGE_WIDTH_PERCENT = 40;
+const MAX_IMAGE_WIDTH_PERCENT = 100;
+const MIME_BY_EXTENSION = {
+    csv: 'text/csv',
+    gif: 'image/gif',
+    heic: 'image/heic',
+    html: 'text/html',
+    jpeg: 'image/jpeg',
+    jpg: 'image/jpeg',
+    js: 'text/javascript',
+    json: 'application/json',
+    m4a: 'audio/mp4',
+    md: 'text/markdown',
+    markdown: 'text/markdown',
+    mov: 'video/quicktime',
+    mp3: 'audio/mpeg',
+    mp4: 'video/mp4',
+    pdf: 'application/pdf',
+    png: 'image/png',
+    svg: 'image/svg+xml',
+    tar: 'application/x-tar',
+    ts: 'text/typescript',
+    tsx: 'text/tsx',
+    txt: 'text/plain',
+    wav: 'audio/wav',
+    webp: 'image/webp',
+    xml: 'application/xml',
+    yaml: 'application/yaml',
+    yml: 'application/yaml',
+    zip: 'application/zip',
+};
+function normalizeNonEmptyString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : '';
+}
+function normalizeOptionalString(value) {
+    const normalized = normalizeNonEmptyString(value);
+    return normalized || undefined;
+}
+function normalizeDimension(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+        return value;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+function normalizeBoolean(value) {
+    if (value === true) {
+        return true;
+    }
+    if (value === false || value == null) {
+        return undefined;
+    }
+    const normalized = String(value).trim().toLowerCase();
+    if (!normalized || normalized === 'false' || normalized === '0' || normalized === 'no') {
+        return undefined;
+    }
+    return true;
+}
+function parseHtmlAttributes(attrString) {
+    const attributes = {};
+    const regex = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+    let match = regex.exec(attrString);
+    while (match !== null) {
+        const [, rawKey, doubleQuoted, singleQuoted, bareValue] = match;
+        attributes[rawKey] = doubleQuoted ?? singleQuoted ?? bareValue ?? true;
+        match = regex.exec(attrString);
+    }
+    return attributes;
+}
+function getFileExtension(value) {
+    const sanitized = value.split(/[?#]/, 1)[0] ?? '';
+    const filename = sanitized.split('/').pop() ?? '';
+    const lastDotIndex = filename.lastIndexOf('.');
+    if (lastDotIndex < 0 || lastDotIndex === filename.length - 1) {
+        return '';
+    }
+    return filename.slice(lastDotIndex + 1).toLowerCase();
+}
+function parseSize(value) {
+    const numeric = typeof value === 'number' ? value : Number(value);
+    return Number.isFinite(numeric) && numeric > 0 ? Math.round(numeric) : 0;
+}
+export function parseMarkdownAttributes(attrString) {
+    if (!attrString.trim()) {
+        return {};
+    }
+    const attributes = {};
+    const regex = /(\w+)=(?:"([^"]*)"|'([^']*)')/g;
+    let match = regex.exec(attrString);
+    while (match !== null) {
+        const [, key, doubleQuoted, singleQuoted] = match;
+        attributes[key] = (doubleQuoted || singleQuoted || '').replace(/\\"/g, '"');
+        match = regex.exec(attrString);
+    }
+    return attributes;
+}
+export function serializeMarkdownAttributes(attrs, allowedKeys) {
+    const keys = allowedKeys ?? Object.keys(attrs);
+    return keys
+        .filter((key) => attrs[key] !== undefined && attrs[key] !== null && attrs[key] !== '')
+        .map((key) => `${key}="${String(attrs[key]).replace(/"/g, '\\"')}"`)
+        .join(' ');
+}
+export function normalizeMarkdownLineEndings(value) {
+    return value.replace(/\r\n?/g, '\n').replace(/^\uFEFF/, '');
+}
+export function normalizeFrontmatterRaw(raw) {
+    let value = typeof raw === 'string' ? raw : raw == null ? '' : String(raw);
+    value = normalizeMarkdownLineEndings(value);
+    const exactBlockMatch = value.match(EXACT_FRONTMATTER_BLOCK_RE);
+    if (exactBlockMatch) {
+        value = exactBlockMatch[1] ?? '';
+    }
+    return value.replace(/^\n+/, '').replace(/\n+$/, '');
+}
+export function buildFrontmatterMarkdownBlock(raw) {
+    const normalized = normalizeFrontmatterRaw(raw);
+    if (!normalized) {
+        return '';
+    }
+    return `---\n${normalized}\n---`;
+}
+export function extractMarkdownFrontmatter(markdown) {
+    const normalized = normalizeMarkdownLineEndings(markdown || '');
+    const match = normalized.match(FRONTMATTER_BLOCK_RE);
+    if (!match) {
+        return {
+            body: normalized,
+            frontmatter: null,
+        };
+    }
+    return {
+        body: normalized.slice(match[0].length).replace(/^\n+/, ''),
+        frontmatter: normalizeFrontmatterRaw(match[1] ?? ''),
+    };
+}
+export function normalizeStoredImageWidthPercent(value) {
+    if (value == null || value === '') {
+        return null;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        return null;
+    }
+    const rounded = Math.round(parsed);
+    const clamped = Math.min(MAX_IMAGE_WIDTH_PERCENT, Math.max(MIN_IMAGE_WIDTH_PERCENT, rounded));
+    return clamped >= MAX_IMAGE_WIDTH_PERCENT ? null : clamped;
+}
+export function parseImageWidthPercentFromStyle(styleValue) {
+    if (typeof styleValue !== 'string' || !styleValue.trim()) {
+        return null;
+    }
+    const match = styleValue.match(/(?:^|;)\s*width\s*:\s*([0-9]+(?:\.[0-9]+)?)\s*%/i);
+    if (!match) {
+        return null;
+    }
+    return normalizeStoredImageWidthPercent(match[1]);
+}
+export function buildImageWidthPercentStyle(widthPercent) {
+    const normalized = normalizeStoredImageWidthPercent(widthPercent);
+    return normalized == null ? null : `width: ${normalized}%;`;
+}
+export function normalizeDinoxImageAttrs(input) {
+    return {
+        alt: normalizeOptionalString(input.alt) ?? null,
+        height: normalizeDimension(input.height),
+        resourceId: normalizeOptionalString(input.resourceId) ?? null,
+        src: normalizeOptionalString(input.src) ?? null,
+        storageKey: normalizeOptionalString(input.storageKey) ?? null,
+        title: normalizeOptionalString(input.title) ?? null,
+        width: normalizeDimension(input.width),
+        widthPercent: normalizeStoredImageWidthPercent(input.widthPercent),
+    };
+}
+export function normalizeAudioMarkdownAttrs(input) {
+    const normalized = {};
+    const src = normalizeNonEmptyString(input.src);
+    if (src) {
+        normalized.src = src;
+    }
+    const title = normalizeNonEmptyString(input.title);
+    if (title) {
+        normalized.title = title;
+    }
+    const preload = normalizeNonEmptyString(input.preload);
+    if (preload) {
+        normalized.preload = preload;
+    }
+    const resourceId = normalizeNonEmptyString(input.resourceId ?? input[MEDIA_RESOURCE_ID_ATTR]);
+    if (resourceId) {
+        normalized.resourceId = resourceId;
+    }
+    const storageKey = normalizeNonEmptyString(input.storageKey ?? input[MEDIA_STORAGE_KEY_ATTR]);
+    if (storageKey) {
+        normalized.storageKey = storageKey;
+    }
+    return normalized;
+}
+export function normalizeVideoMarkdownAttrs(input) {
+    const normalized = {};
+    const src = normalizeNonEmptyString(input.src);
+    if (src) {
+        normalized.src = src;
+    }
+    const poster = normalizeNonEmptyString(input.poster);
+    if (poster) {
+        normalized.poster = poster;
+    }
+    const title = normalizeNonEmptyString(input.title);
+    if (title) {
+        normalized.title = title;
+    }
+    const resourceId = normalizeNonEmptyString(input.resourceId ?? input[MEDIA_RESOURCE_ID_ATTR]);
+    if (resourceId) {
+        normalized.resourceId = resourceId;
+    }
+    const storageKey = normalizeNonEmptyString(input.storageKey ?? input[MEDIA_STORAGE_KEY_ATTR]);
+    if (storageKey) {
+        normalized.storageKey = storageKey;
+    }
+    if (normalizeBoolean(input.autoplay)) {
+        normalized.autoplay = true;
+    }
+    if (normalizeBoolean(input.loop)) {
+        normalized.loop = true;
+    }
+    if (normalizeBoolean(input.muted)) {
+        normalized.muted = true;
+    }
+    if (normalizeBoolean(input.playsInline ?? input.playsinline ?? input['plays-inline'])) {
+        normalized.playsInline = true;
+    }
+    return normalized;
+}
+export function normalizeFileBlockAttrs(input) {
+    const name = normalizeNonEmptyString(input.name) || '未命名文件';
+    const type = normalizeNonEmptyString(input.type) || DEFAULT_FILE_TYPE;
+    return {
+        id: normalizeNonEmptyString(input.id) || generateId(),
+        name,
+        resourceId: normalizeOptionalString(input.resourceId),
+        size: parseSize(input.size),
+        src: normalizeNonEmptyString(input.src),
+        type,
+    };
+}
+export function inferMimeTypeFromHref(href) {
+    const extension = getFileExtension(href);
+    return extension ? MIME_BY_EXTENSION[extension] : undefined;
+}
+export function parseDinoxMarkdownComment(rawComment) {
+    if (typeof rawComment !== 'string') {
+        return null;
+    }
+    const normalized = rawComment.trim();
+    if (!normalized) {
+        return null;
+    }
+    const match = normalized.match(DINOX_COMMENT_REGEX);
+    if (!match) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(match[1]);
+        const kindValue = typeof parsed.kind === 'string' ? parsed.kind.trim().toLowerCase() : '';
+        const kind = kindValue === 'image' || kindValue === 'video' || kindValue === 'audio' || kindValue === 'file'
+            ? kindValue
+            : null;
+        const resourceId = typeof parsed.resourceId === 'string' && parsed.resourceId.trim()
+            ? parsed.resourceId.trim()
+            : null;
+        const widthPercent = normalizeStoredImageWidthPercent(parsed.widthPercent);
+        if (!kind && !resourceId && widthPercent == null) {
+            return null;
+        }
+        return {
+            kind,
+            resourceId,
+            widthPercent,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function extractAudioAttrsFromHtml(html) {
+    const rootMatch = html.match(/^<audio\b([^>]*)>/i);
+    if (!rootMatch) {
+        return null;
+    }
+    const rootAttrs = parseHtmlAttributes(rootMatch[1] || '');
+    const sourceMatch = html.match(/<source\b([^>]*)>/i);
+    const sourceAttrs = sourceMatch ? parseHtmlAttributes(sourceMatch[1] || '') : {};
+    const combined = {
+        ...rootAttrs,
+        src: rootAttrs.src ?? sourceAttrs.src,
+        resourceId: rootAttrs[MEDIA_RESOURCE_ID_ATTR],
+        storageKey: rootAttrs[MEDIA_STORAGE_KEY_ATTR],
+    };
+    const normalized = normalizeAudioMarkdownAttrs(combined);
+    return normalized.src ? normalized : null;
+}
+export function extractVideoAttrsFromHtml(html) {
+    const rootMatch = html.match(/^<video\b([^>]*)>/i);
+    if (!rootMatch) {
+        return null;
+    }
+    const rootAttrs = parseHtmlAttributes(rootMatch[1] || '');
+    const sourceMatch = html.match(/<source\b([^>]*)>/i);
+    const sourceAttrs = sourceMatch ? parseHtmlAttributes(sourceMatch[1] || '') : {};
+    const combined = {
+        ...rootAttrs,
+        src: rootAttrs.src ?? sourceAttrs.src,
+        resourceId: rootAttrs[MEDIA_RESOURCE_ID_ATTR],
+        storageKey: rootAttrs[MEDIA_STORAGE_KEY_ATTR],
+    };
+    const normalized = normalizeVideoMarkdownAttrs(combined);
+    return normalized.src ? normalized : null;
+}
+function isAsciiLetterOrDigit(charCode) {
+    return ((charCode >= 0x30 && charCode <= 0x39) ||
+        (charCode >= 0x41 && charCode <= 0x5a) ||
+        (charCode >= 0x61 && charCode <= 0x7a));
+}
+function isCjkChar(charCode) {
+    return charCode >= 0x4e00 && charCode <= 0x9fff;
+}
+function isHashtagPathSegmentChar(charCode) {
+    return isAsciiLetterOrDigit(charCode) || charCode === 0x5f || charCode === 0x2d || isCjkChar(charCode);
+}
+function isHashtagBoundaryBlockingChar(charCode) {
+    return isAsciiLetterOrDigit(charCode) || charCode === 0x5f || isCjkChar(charCode);
+}
+export function parseHashtagPath(source, hashIndex) {
+    if (hashIndex < 0 || hashIndex >= source.length || source.charCodeAt(hashIndex) !== 0x23) {
+        return null;
+    }
+    if (hashIndex > 0 && isHashtagBoundaryBlockingChar(source.charCodeAt(hashIndex - 1))) {
+        return null;
+    }
+    let index = hashIndex + 1;
+    let hasSegmentChar = false;
+    while (index < source.length) {
+        const charCode = source.charCodeAt(index);
+        if (isHashtagPathSegmentChar(charCode)) {
+            hasSegmentChar = true;
+            index += 1;
+            continue;
+        }
+        if (charCode === 0x2f) {
+            const nextIndex = index + 1;
+            if (!hasSegmentChar || nextIndex >= source.length) {
+                return null;
+            }
+            const nextCharCode = source.charCodeAt(nextIndex);
+            if (!isHashtagPathSegmentChar(nextCharCode)) {
+                return null;
+            }
+            hasSegmentChar = false;
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    if (!hasSegmentChar || index <= hashIndex + 1) {
+        return null;
+    }
+    const raw = source.slice(hashIndex, index);
+    return {
+        end: index,
+        label: raw.slice(1),
+        raw,
+    };
+}
+export function findHashtagPathStart(source) {
+    for (let index = 0; index < source.length; index += 1) {
+        if (source.charCodeAt(index) !== 0x23) {
+            continue;
+        }
+        if (parseHashtagPath(source, index)) {
+            return index;
+        }
+    }
+    return -1;
+}
+export { DEFAULT_FILE_TYPE, IMAGE_WIDTH_PERCENT_ATTR, MEDIA_RESOURCE_ID_ATTR, MEDIA_STORAGE_KEY_ATTR, };
+import { generateId } from './id.js';

package/dist/utils/updateNotice.d.ts

@@ -0,0 +1,7 @@
+export type UpdateNotice = {
+    current: string;
+    latest: string;
+    message: string;
+};
+export declare function isVersionNewer(candidate: string, current: string): boolean;
+export declare function getUpdateNotice(currentVersion: string, fetchImpl?: typeof fetch): Promise<UpdateNotice | null>;

package/dist/utils/updateNotice.js

@@ -0,0 +1,64 @@
+const PACKAGE_NAME = '@dinoxx/dinox-cli';
+const LATEST_VERSION_URL = 'https://registry.npmjs.org/@dinoxx%2Fdinox-cli/latest';
+let cachedUpdateNotice = null;
+let lastCheckedAt = 0;
+const UPDATE_CACHE_TTL_MS = 5 * 60 * 1000;
+function parseSemverParts(version) {
+    const base = version.trim().split('-', 1)[0] ?? '';
+    return base.split('.').map((part) => Number.parseInt(part, 10) || 0);
+}
+export function isVersionNewer(candidate, current) {
+    const left = parseSemverParts(candidate);
+    const right = parseSemverParts(current);
+    const maxLength = Math.max(left.length, right.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const lhs = left[index] ?? 0;
+        const rhs = right[index] ?? 0;
+        if (lhs > rhs) {
+            return true;
+        }
+        if (lhs < rhs) {
+            return false;
+        }
+    }
+    return false;
+}
+async function fetchLatestPublishedVersion(fetchImpl = fetch) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1500);
+    try {
+        const response = await fetchImpl(LATEST_VERSION_URL, {
+            headers: { Accept: 'application/json' },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const payload = await response.json();
+        return typeof payload.version === 'string' ? payload.version.trim() : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function getUpdateNotice(currentVersion, fetchImpl = fetch) {
+    const now = Date.now();
+    if (cachedUpdateNotice && now - lastCheckedAt < UPDATE_CACHE_TTL_MS) {
+        return cachedUpdateNotice.current === currentVersion ? cachedUpdateNotice : null;
+    }
+    const latestVersion = await fetchLatestPublishedVersion(fetchImpl);
+    lastCheckedAt = now;
+    if (!latestVersion || !isVersionNewer(latestVersion, currentVersion)) {
+        cachedUpdateNotice = null;
+        return null;
+    }
+    cachedUpdateNotice = {
+        current: currentVersion,
+        latest: latestVersion,
+        message: `Update available for ${PACKAGE_NAME}: ${currentVersion} -> ${latestVersion}`,
+    };
+    return cachedUpdateNotice;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {
@@ -9,6 +9,8 @@
     "prepublishOnly": "npm run build",
     "publish:npm": "sh ./publish-npm.sh",
     "publish:npm:dry-run": "sh ./publish-npm.sh --dry-run",
+    "skills:check": "tsx scripts/check-skills.ts",
+    "skills:sync": "tsx scripts/sync-skills-reference.ts",
     "start": "node dist/dinox.js",
     "test": "node --test --import tsx test/*.test.ts"
   },
@@ -30,21 +32,41 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.1021.0",
     "@node-rs/jieba": "^2.0.1",
     "@powersync/common": "^1.47.0",
     "@powersync/node": "^0.17.1",
     "@tiptap/core": "^3.20.0",
+    "@tiptap/extension-blockquote": "^3.20.0",
+    "@tiptap/extension-bold": "^3.20.0",
+    "@tiptap/extension-bullet-list": "^3.20.0",
+    "@tiptap/extension-code": "^3.20.0",
+    "@tiptap/extension-code-block": "^3.20.0",
+    "@tiptap/extension-document": "^3.20.0",
+    "@tiptap/extension-hard-break": "^3.20.0",
+    "@tiptap/extension-heading": "^3.20.0",
+    "@tiptap/extension-highlight": "^3.20.0",
+    "@tiptap/extension-horizontal-rule": "^3.20.0",
     "@tiptap/extension-image": "^3.20.0",
+    "@tiptap/extension-italic": "^3.20.0",
+    "@tiptap/extension-link": "^3.20.0",
     "@tiptap/extension-list": "^3.20.0",
+    "@tiptap/extension-mathematics": "^3.20.0",
+    "@tiptap/extension-paragraph": "^3.20.0",
+    "@tiptap/extension-strike": "^3.20.0",
     "@tiptap/extension-table": "^3.20.0",
-    "@tiptap/extension-unique-id": "^3.20.0",
+    "@tiptap/extension-table-cell": "^3.20.0",
+    "@tiptap/extension-table-header": "^3.20.0",
+    "@tiptap/extension-table-row": "^3.20.0",
+    "@tiptap/extension-text": "^3.20.0",
+    "@tiptap/extension-underline": "^3.20.0",
     "@tiptap/markdown": "^3.20.0",
-    "@tiptap/starter-kit": "^3.20.0",
     "better-sqlite3": "^12.6.2",
     "commander": "^14.0.3",
     "remark-gfm": "^4.0.1",
     "remark-parse": "^11.0.0",
     "remark-stringify": "^11.0.0",
+    "sharp": "^0.34.5",
     "strip-markdown": "^6.0.0",
     "unified": "^11.0.5",
     "uuidv7": "^1.0.2",