@dinoxx/dinox-cli 1.0.20 → 1.0.21

package/dist/skills/check.d.ts

@@ -2,5 +2,5 @@ export type SkillCheckIssue = {
     skill: string;
     message: string;
 };
-export declare function checkSkillContent(skill: string, content: string, skillDir?: string): SkillCheckIssue[];
+export declare function checkSkillContent(skill: string, content: string, skillDir?: string, expectedVersion?: string): SkillCheckIssue[];
 export declare function checkSkillsDirectory(skillsDir: string): SkillCheckIssue[];

package/dist/skills/check.js

@@ -5,6 +5,7 @@ const EXEMPT_SHARED_REFERENCE = new Set(['dino-dinox', 'dino-shared']);
 const SHARED_REFERENCE_PATTERN = /\.\.\/dino-shared\/SKILL\.md/;
 const BINS_PATTERN = /^metadata:\s*[\s\S]*?^  requires:\s*[\s\S]*?^    bins:\s*\[(.*?)\]\s*$/m;
 const CLI_HELP_PATTERN = /^metadata:\s*[\s\S]*?^  cliHelp:\s*.+$/m;
+const SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
 const commandSchemas = listCommandSchemas();
 const commandSchemaPrefixes = commandSchemas
     .map((schema) => ({
@@ -166,7 +167,7 @@ function checkMarkdownDocument(skill, content, relativePath, skillDir) {
     }
     return issues;
 }
-export function checkSkillContent(skill, content, skillDir) {
+export function checkSkillContent(skill, content, skillDir, expectedVersion) {
     const issues = [];
     const parsed = parseFrontmatter(content);
     if (!parsed) {
@@ -183,6 +184,19 @@ export function checkSkillContent(skill, content, skillDir) {
     if (!/^description:\s*/m.test(frontmatter)) {
         issues.push({ skill, message: "Frontmatter is missing 'description'." });
     }
+    const versionMatch = frontmatter.match(/^version:\s*(.+)$/m);
+    if (!versionMatch) {
+        issues.push({ skill, message: "Frontmatter is missing 'version'." });
+    }
+    else {
+        const version = versionMatch[1]?.trim() ?? '';
+        if (!SEMVER_PATTERN.test(version)) {
+            issues.push({ skill, message: "Frontmatter 'version' must be a semver string." });
+        }
+        if (expectedVersion && version !== expectedVersion) {
+            issues.push({ skill, message: `Frontmatter version must match skills/VERSION (${expectedVersion}).` });
+        }
+    }
     if (!/^metadata:\s*$/m.test(frontmatter)) {
         issues.push({ skill, message: "Frontmatter is missing 'metadata'." });
     }
@@ -230,6 +244,17 @@ export function checkSkillContent(skill, content, skillDir) {
 }
 export function checkSkillsDirectory(skillsDir) {
     const issues = [];
+    const versionFile = path.join(skillsDir, 'VERSION');
+    let expectedVersion;
+    if (!fs.existsSync(versionFile)) {
+        issues.push({ skill: 'VERSION', message: 'Missing skills/VERSION.' });
+    }
+    else {
+        expectedVersion = fs.readFileSync(versionFile, 'utf8').trim();
+        if (!SEMVER_PATTERN.test(expectedVersion)) {
+            issues.push({ skill: 'VERSION', message: 'skills/VERSION must contain a semver string.' });
+        }
+    }
     const entries = fs.readdirSync(skillsDir, { withFileTypes: true })
         .filter((entry) => entry.isDirectory())
         .map((entry) => entry.name)
@@ -241,7 +266,7 @@ export function checkSkillsDirectory(skillsDir) {
             continue;
         }
         const content = fs.readFileSync(skillFile, 'utf8');
-        issues.push(...checkSkillContent(skill, content, path.dirname(skillFile)));
+        issues.push(...checkSkillContent(skill, content, path.dirname(skillFile), expectedVersion));
         const markdownFiles = walkMarkdownFiles(path.dirname(skillFile))
             .filter((file) => file !== skillFile);
         for (const markdownFile of markdownFiles) {

package/dist/utils/authToken.d.ts

@@ -1,2 +1,4 @@
+export declare const DINOX_TOKEN_ENV_VAR = "DINOX_TOKEN";
 export declare function normalizeAuthToken(value: unknown): string | undefined;
+export declare function readEnvAuthToken(env?: NodeJS.ProcessEnv): string | undefined;
 export declare function toAuthorizationHeaderValue(token: string): string;

package/dist/utils/authToken.js

@@ -1,3 +1,4 @@
+export const DINOX_TOKEN_ENV_VAR = 'DINOX_TOKEN';
 export function normalizeAuthToken(value) {
     if (typeof value !== 'string') {
         return undefined;
@@ -6,12 +7,16 @@ export function normalizeAuthToken(value) {
     if (!trimmed) {
         return undefined;
     }
-    if (trimmed.toLowerCase().startsWith('bearer ')) {
-        const withoutPrefix = trimmed.slice('bearer '.length).trim();
+    const bearerMatch = trimmed.match(/^bearer(?:\s+(.+))?$/i);
+    if (bearerMatch) {
+        const withoutPrefix = bearerMatch[1]?.trim();
         return withoutPrefix || undefined;
     }
     return trimmed;
 }
+export function readEnvAuthToken(env = process.env) {
+    return normalizeAuthToken(env[DINOX_TOKEN_ENV_VAR]);
+}
 export function toAuthorizationHeaderValue(token) {
     // Backend expects a standard Authorization header. Be defensive: callers may pass
     // a full "Bearer ..." header value or a raw token.

package/dist/utils/noteContentEngine.d.ts

@@ -0,0 +1,333 @@
+export type TiptapJsonNode = {
+    type: string;
+    attrs?: Record<string, unknown>;
+    content?: TiptapJsonNode[];
+    marks?: Array<Record<string, unknown>>;
+    text?: string;
+    [key: string]: unknown;
+};
+export type NoteContentEditErrorCode = 'invalid_plan' | 'invalid_content' | 'content_conflict' | 'target_not_found' | 'target_conflict';
+export declare class NoteContentEditError extends Error {
+    readonly code: NoteContentEditErrorCode;
+    readonly details?: unknown | undefined;
+    constructor(code: NoteContentEditErrorCode, message: string, details?: unknown | undefined);
+}
+export declare const NOTE_CONTENT_EDIT_OPERATION_TYPES: readonly ["insertBlocksAfter", "insertBlocksBefore", "replaceBlocks", "deleteBlocks", "replaceText", "updateBlockAttrs", "replaceContainerContent"];
+type InlineSpec = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'hardBreak';
+} | {
+    type: 'hashtag';
+    id?: string | null;
+    label?: string | null;
+    path?: string | null;
+    fullPath?: string | null;
+} | {
+    type: 'bidlink';
+    id: string;
+    label?: string | null;
+    href?: string | null;
+    linkType?: string | null;
+} | {
+    type: 'inlineMath';
+    text: string;
+};
+export type NoteBlockSpec = {
+    type: 'paragraph' | 'blockquote';
+    text?: string;
+    inline?: InlineSpec[];
+} | {
+    type: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    text?: string;
+    inline?: InlineSpec[];
+} | {
+    type: 'bulletList' | 'orderedList';
+    items: string[];
+} | {
+    type: 'taskList';
+    items: Array<string | {
+        text: string;
+        checked?: boolean | null;
+    }>;
+} | {
+    type: 'codeBlock';
+    language?: string | null;
+    text: string;
+} | {
+    type: 'horizontalRule';
+} | {
+    type: 'image';
+    src?: string | null;
+    alt?: string | null;
+    title?: string | null;
+    resourceId?: string | null;
+    storageKey?: string | null;
+    caption?: string | null;
+    showCaption?: boolean | null;
+} | {
+    type: 'video' | 'audio';
+    src?: string | null;
+    title?: string | null;
+    poster?: string | null;
+    preload?: string | null;
+    resourceId?: string | null;
+    storageKey?: string | null;
+    autoplay?: boolean | null;
+    loop?: boolean | null;
+    muted?: boolean | null;
+    playsInline?: boolean | null;
+} | {
+    type: 'file';
+    id?: string | null;
+    src?: string | null;
+    name?: string | null;
+    mimeType?: string | null;
+    size?: number | null;
+    resourceId?: string | null;
+    storageKey?: string | null;
+} | {
+    type: 'table';
+    rows: Array<{
+        cells: string[];
+        header?: boolean | null;
+    }>;
+} | {
+    type: 'mermaid';
+    code: string;
+} | {
+    type: 'mindgraph';
+    markdown: string;
+};
+export type NoteEditTarget = {
+    anchorId?: string;
+    anchorIds?: string[];
+    nodeIndex?: number;
+    nodeRange?: string;
+    expectedTextHash?: string;
+    expectedNodeHash?: string;
+    expectedTextSnippet?: string;
+    textMatch?: string;
+};
+export type NoteEditOperation = {
+    op: 'insertBlocksAfter' | 'insertBlocksBefore';
+    target: NoteEditTarget;
+    blocks: NoteBlockSpec[];
+    reason?: string;
+} | {
+    op: 'replaceBlocks';
+    target: NoteEditTarget;
+    blocks: NoteBlockSpec[];
+    allowProtectedReplace?: boolean;
+    reason?: string;
+} | {
+    op: 'deleteBlocks';
+    target: NoteEditTarget;
+    allowProtectedDelete?: boolean;
+    reason?: string;
+} | {
+    op: 'replaceText';
+    target: NoteEditTarget;
+    matchText: string;
+    replacementText: string;
+    replaceAll?: boolean;
+    reason?: string;
+} | {
+    op: 'updateBlockAttrs';
+    target: NoteEditTarget;
+    attrs: Record<string, unknown>;
+    reason?: string;
+} | {
+    op: 'replaceContainerContent';
+    target: NoteEditTarget;
+    blocks: NoteBlockSpec[];
+    reason?: string;
+};
+export type NoteEditPatch = {
+    base: {
+        contentHash: string;
+        updatedAt?: string | null;
+        version?: number | null;
+    };
+    operations: NoteEditOperation[];
+};
+export type NoteBlockDescriptor = {
+    anchorId: string;
+    hasStableAnchor: boolean;
+    nodeIndex: number;
+    nodeRange: string;
+    type: string;
+    editMode: string;
+    level: number | null;
+    text: string;
+    textPreview: string;
+    textHash: string;
+    nodeHash: string;
+    charCount: number;
+    attrs?: Record<string, unknown>;
+};
+export declare function normalizeTiptapDocument(value: unknown): TiptapJsonNode;
+export declare function buildNoteEditContext(input: {
+    noteId: string;
+    title?: string | null;
+    contentJson?: unknown;
+    document?: unknown;
+    updatedAt?: string | null;
+    version?: number | null;
+}): {
+    noteId: string;
+    title: string;
+    contentHash: string;
+    updatedAt: string | null;
+    version: number | null;
+    document: TiptapJsonNode;
+    blocks: {
+        anchorId: string;
+        hasStableAnchor: boolean;
+        nodeIndex: number;
+        nodeRange: string;
+        type: string;
+        editMode: string;
+        level: number | null;
+        text: string;
+        textPreview: string;
+        textHash: string;
+        nodeHash: string;
+        charCount: number;
+        attrs: Record<string, unknown> | undefined;
+    }[];
+    chunks: {
+        index: number;
+        nodeRange: string;
+        anchorIds: string[];
+        textPreview: string;
+        charCount: number;
+        estimatedTokens: number;
+    }[];
+    totalCharCount: number;
+    estimatedTokens: number;
+};
+export declare function applyNoteEditPatch(input: {
+    noteId: string;
+    title?: string | null;
+    contentJson?: unknown;
+    updatedAt?: string | null;
+    version?: number | null;
+    createAnchorId?: (node: TiptapJsonNode, index: number) => string;
+    patch: NoteEditPatch;
+}): {
+    noteId: string;
+    changed: boolean;
+    before: {
+        noteId: string;
+        title: string;
+        contentHash: string;
+        updatedAt: string | null;
+        version: number | null;
+        document: TiptapJsonNode;
+        blocks: {
+            anchorId: string;
+            hasStableAnchor: boolean;
+            nodeIndex: number;
+            nodeRange: string;
+            type: string;
+            editMode: string;
+            level: number | null;
+            text: string;
+            textPreview: string;
+            textHash: string;
+            nodeHash: string;
+            charCount: number;
+            attrs: Record<string, unknown> | undefined;
+        }[];
+        chunks: {
+            index: number;
+            nodeRange: string;
+            anchorIds: string[];
+            textPreview: string;
+            charCount: number;
+            estimatedTokens: number;
+        }[];
+        totalCharCount: number;
+        estimatedTokens: number;
+    };
+    after: {
+        noteId: string;
+        title: string;
+        contentHash: string;
+        updatedAt: string | null;
+        version: number | null;
+        document: TiptapJsonNode;
+        blocks: {
+            anchorId: string;
+            hasStableAnchor: boolean;
+            nodeIndex: number;
+            nodeRange: string;
+            type: string;
+            editMode: string;
+            level: number | null;
+            text: string;
+            textPreview: string;
+            textHash: string;
+            nodeHash: string;
+            charCount: number;
+            attrs: Record<string, unknown> | undefined;
+        }[];
+        chunks: {
+            index: number;
+            nodeRange: string;
+            anchorIds: string[];
+            textPreview: string;
+            charCount: number;
+            estimatedTokens: number;
+        }[];
+        totalCharCount: number;
+        estimatedTokens: number;
+    };
+    projection: {
+        document: TiptapJsonNode;
+        content_json: string;
+        content_text: string;
+        content_md: string;
+        images: string;
+        bid_links: string;
+        contentHash: string;
+    };
+    appliedOperations: number;
+    operationResults: {
+        operationIndex: number;
+        type: "insertBlocksAfter" | "insertBlocksBefore" | "replaceBlocks" | "deleteBlocks" | "replaceText" | "updateBlockAttrs" | "replaceContainerContent";
+        success: boolean;
+        target: string;
+        nodeRange: string;
+        error: null;
+    }[];
+};
+export declare function projectNoteContent(document: TiptapJsonNode): {
+    document: TiptapJsonNode;
+    content_json: string;
+    content_text: string;
+    content_md: string;
+    images: string;
+    bid_links: string;
+    contentHash: string;
+};
+export declare function topNodes(document: TiptapJsonNode): TiptapJsonNode[];
+export declare function parseNodeRangeString(spec: string, total: number): {
+    start: number;
+    end: number;
+};
+export declare function serializeAnchoredMarkdown(nodes: TiptapJsonNode[], blocks: NoteBlockDescriptor[], startIndex?: number): string;
+export declare function serializeAnchoredShorthand(nodes: TiptapJsonNode[], blocks: NoteBlockDescriptor[], startIndex?: number): string;
+export declare function blockTextHash(blocks: NoteBlockDescriptor[], start: number, end: number): string;
+export declare function blockNodeHash(blocks: NoteBlockDescriptor[], start: number, end: number): string;
+export declare function getNoteContentReadInstructions(): string;
+export declare function getNoteContentSchemaSummary(): {
+    version: string;
+    readFormat: string;
+    editProtocol: string;
+    operations: ("insertBlocksAfter" | "insertBlocksBefore" | "replaceBlocks" | "deleteBlocks" | "replaceText" | "updateBlockAttrs" | "replaceContainerContent")[];
+};
+export {};