@dinoxx/dinox-cli 1.0.16 → 1.0.18

package/dist/commands/meta/index.js

@@ -0,0 +1,45 @@
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { printYaml } from '../../utils/output.js';
+import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
+import { getMetaSchema, getMetaStats } from './repo.js';
+async function syncBeforeMetaCommand(db, offline, timeoutMs) {
+    if (offline) {
+        return;
+    }
+    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
+}
+export function registerMetaCommands(program) {
+    const meta = program.command('meta').description('Query Dinox metadata');
+    meta
+        .command('stats')
+        .description('Get metadata stats (notes/tags/boxes)')
+        .action(async (_options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const config = resolveConfig(await loadConfig());
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeMetaCommand(db, offline, timeoutMs);
+            const stats = await getMetaStats(db);
+            printYaml({
+                stale: offline ? true : stale,
+                stats,
+            });
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+    meta
+        .command('schema')
+        .description('Get structured Dinox data schema for AI integrations')
+        .action(() => {
+        printYaml(getMetaSchema());
+    });
+    meta.action((_options, command) => {
+        command.outputHelp();
+    });
+}

package/dist/commands/meta/repo.d.ts

@@ -0,0 +1,27 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+export type MetaStats = {
+    notes_count: number;
+    tags_count: number;
+    boxes_count: number;
+    latest_note_updated_at: string | null;
+};
+export type MetaSchema = {
+    version: number;
+    entities: {
+        note_search_result: {
+            fields: string[];
+            meta_fields: string[];
+        };
+        note_context: {
+            fields: string[];
+        };
+        graph_stats: {
+            fields: string[];
+        };
+        meta_stats: {
+            fields: string[];
+        };
+    };
+};
+export declare function getMetaStats(db: AbstractPowerSyncDatabase): Promise<MetaStats>;
+export declare function getMetaSchema(): MetaSchema;

package/dist/commands/meta/repo.js

@@ -0,0 +1,71 @@
+export async function getMetaStats(db) {
+    const [notesRow, tagsRow, boxesRow, latestNoteRow] = await Promise.all([
+        db.getOptional(`
+      SELECT COUNT(1) AS count
+      FROM c_note n
+      WHERE n.is_del IS NULL OR n.is_del = 0
+      `, []),
+        db.getOptional(`
+      SELECT COUNT(1) AS count
+      FROM c_tag_node t
+      WHERE t.is_del IS NULL OR t.is_del = 0
+      `, []),
+        db.getOptional(`
+      SELECT COUNT(1) AS count
+      FROM c_zettel_box b
+      WHERE b.is_del IS NULL OR b.is_del = 0
+      `, []),
+        db.getOptional(`
+      SELECT MAX(COALESCE(n.updated_at, n.created_at)) AS latest
+      FROM c_note n
+      WHERE n.is_del IS NULL OR n.is_del = 0
+      `, []),
+    ]);
+    return {
+        notes_count: Number(notesRow?.count ?? 0),
+        tags_count: Number(tagsRow?.count ?? 0),
+        boxes_count: Number(boxesRow?.count ?? 0),
+        latest_note_updated_at: latestNoteRow?.latest ?? null,
+    };
+}
+export function getMetaSchema() {
+    return {
+        version: 1,
+        entities: {
+            note_search_result: {
+                fields: ['id', 'title', 'summary', 'tags', 'created_at', 'zettel_boxes'],
+                meta_fields: [
+                    'query',
+                    'returned_count',
+                    'total_count',
+                    'stale',
+                    'pagination.limit',
+                    'pagination.offset',
+                    'pagination.has_more',
+                    'fields',
+                    'applied_filters',
+                ],
+            },
+            note_context: {
+                fields: [
+                    'id',
+                    'title',
+                    'summary',
+                    'tags',
+                    'created_at',
+                    'updated_at',
+                    'is_del',
+                    'zettel_boxes',
+                    'links.backlinks',
+                    'links.outlinks',
+                ],
+            },
+            graph_stats: {
+                fields: ['notes_count', 'links_count', 'connected_notes_count', 'isolated_notes_count'],
+            },
+            meta_stats: {
+                fields: ['notes_count', 'tags_count', 'boxes_count', 'latest_note_updated_at'],
+            },
+        },
+    };
+}

package/dist/commands/notes/index.d.ts

@@ -1,11 +1,17 @@
 import { Command } from 'commander';
-import { type SearchedNote } from './repo.js';
+import { type NoteSearchField, type NoteSearchResultItem } from './searchOutput.js';
 type NoteSearchResponse = {
     meta: {
         query: string;
         returned_count: number;
         total_count: number;
         stale: boolean;
+        pagination: {
+            limit: number | null;
+            offset: number;
+            has_more: boolean;
+        };
+        fields: NoteSearchField[] | null;
         applied_filters: {
             include_deleted: boolean;
             tags_expression: string | null;
@@ -20,13 +26,17 @@ type NoteSearchResponse = {
             sql_expression: string | null;
         };
     };
-    notes: SearchedNote[];
+    notes: NoteSearchResultItem[];
 };
 type BuildNoteSearchResponseInput = {
     query: string;
-    notes: SearchedNote[];
+    notes: NoteSearchResultItem[];
+    totalCount: number;
     stale: boolean;
     includeDeleted: boolean;
+    limit?: number;
+    offset?: number;
+    fields?: NoteSearchField[];
     tagsExpression?: string;
     createdAtFrom?: string;
     createdAtTo?: string;

package/dist/commands/notes/index.js

@@ -9,8 +9,11 @@ import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
 import { syncNoteTokenIndex } from '../../powersync/tokenIndex.js';
-import { createNote, getNote, getNoteDetails, assertNotesUpdatable, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, resolveZettelBoxIdsForUpdate, searchNotes, softDeleteNote, updateNote, validateTagsForCreate, validateTagsForUpdate, } from './repo.js';
+import { createNote, getNote, getNoteContext, getNoteDetails, getNotePreview, assertNotesUpdatable, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, resolveZettelBoxIdsForUpdate, searchNotes, softDeleteNote, updateNote, validateTagsForCreate, validateTagsForUpdate, } from './repo.js';
+import { parseNoteSearchFields, projectNoteSearchFields, } from './searchOutput.js';
 import { parseCreatedAtRange } from './searchTime.js';
+const DEFAULT_NOTE_SEARCH_LIMIT = 50;
+const MAX_NOTE_SEARCH_LIMIT = 500;
 function parseNoteType(value) {
     const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
     if (normalized === 'note' || normalized === 'crawl') {
@@ -18,6 +21,63 @@ function parseNoteType(value) {
     }
     throw new DinoxError('--type must be one of: note, crawl');
 }
+function parseSearchLimit(value) {
+    if (value === undefined || value === null || value === '') {
+        return DEFAULT_NOTE_SEARCH_LIMIT;
+    }
+    if (typeof value !== 'string') {
+        throw new DinoxError('--limit must be a positive integer');
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new DinoxError('--limit must be a positive integer');
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new DinoxError('--limit must be a positive integer');
+    }
+    if (parsed > MAX_NOTE_SEARCH_LIMIT) {
+        throw new DinoxError(`--limit cannot be greater than ${MAX_NOTE_SEARCH_LIMIT}`);
+    }
+    return Math.trunc(parsed);
+}
+function parseSearchOffset(value) {
+    if (value === undefined || value === null || value === '') {
+        return 0;
+    }
+    if (typeof value !== 'string') {
+        throw new DinoxError('--offset must be a non-negative integer');
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new DinoxError('--offset must be a non-negative integer');
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        throw new DinoxError('--offset must be a non-negative integer');
+    }
+    return Math.trunc(parsed);
+}
+function parsePreviewLineCount(value) {
+    if (value === undefined || value === null || value === '') {
+        return 10;
+    }
+    if (typeof value !== 'string') {
+        throw new DinoxError('--lines must be a positive integer');
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new DinoxError('--lines must be a positive integer');
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new DinoxError('--lines must be a positive integer');
+    }
+    if (parsed > 500) {
+        throw new DinoxError('--lines cannot be greater than 500');
+    }
+    return Math.trunc(parsed);
+}
 async function parseStringInput(value) {
     return readStringOrFile(value);
 }
@@ -115,12 +175,23 @@ export function buildNoteSearchResponse(input) {
     const tagsExpression = input.tagsExpression?.trim() ?? '';
     const sqlExpression = input.sqlExpression?.trim() ?? '';
     const hasCreatedAtRange = Boolean(input.createdAtFrom || input.createdAtTo);
+    const offset = input.offset ?? 0;
+    const limit = input.limit ?? null;
+    const returnedCount = input.notes.length;
+    const totalCount = input.totalCount;
+    const hasMore = offset + returnedCount < totalCount;
     return {
         meta: {
             query,
-            returned_count: input.notes.length,
-            total_count: input.notes.length,
+            returned_count: returnedCount,
+            total_count: totalCount,
             stale: input.stale,
+            pagination: {
+                limit,
+                offset,
+                has_more: hasMore,
+            },
+            fields: input.fields && input.fields.length > 0 ? [...input.fields] : null,
             applied_filters: {
                 include_deleted: input.includeDeleted,
                 tags_expression: tagsExpression || null,
@@ -152,6 +223,9 @@ export function registerNoteCommands(program) {
         .option('--days <n>', 'recent N days by created_at (cannot be used with --from/--to)')
         .option('--box <string|@file>', 'zettel box names (JSON array/comma list), or [] for empty boxes')
         .option('--sql <expr>', 'SQL-like expression over id/content_md/summary/tags/zettel_boxes/created_at/type')
+        .option('--limit <n>', `maximum returned notes (default: ${DEFAULT_NOTE_SEARCH_LIMIT}, max: ${MAX_NOTE_SEARCH_LIMIT})`)
+        .option('--offset <n>', 'result offset for pagination (default: 0)')
+        .option('--fields <list>', 'comma-separated fields: id,title,summary,tags,created_at,zettel_boxes')
         .option('--include-deleted', 'include soft-deleted notes')
         .action(async (query, options, command) => {
         const globals = command.optsWithGlobals?.() ?? {};
@@ -174,6 +248,9 @@ export function registerNoteCommands(program) {
                 : { values: [], isExplicitEmptyArray: false };
             const zettelBoxIds = await resolveZettelBoxIdsForSearch(db, parsedBoxInput.values);
             const sqlExpression = typeof options.sql === 'string' ? options.sql.trim() : '';
+            const limit = parseSearchLimit(options.limit);
+            const offset = parseSearchOffset(options.offset);
+            const fields = parseNoteSearchFields(options.fields, '--fields');
             const rows = await searchNotes(db, keyword, {
                 includeDeleted: Boolean(options.includeDeleted),
                 tagsExpression: tagsExpression || undefined,
@@ -183,11 +260,18 @@ export function registerNoteCommands(program) {
                 matchEmptyZettelBoxes: parsedBoxInput.isExplicitEmptyArray,
                 sqlExpression: sqlExpression || undefined,
             });
+            const totalCount = rows.length;
+            const pagedRows = rows.slice(offset, offset + limit);
+            const projectedRows = projectNoteSearchFields(pagedRows, fields);
             const response = buildNoteSearchResponse({
                 query: keyword,
-                notes: rows,
+                notes: projectedRows,
+                totalCount,
                 stale: offline ? true : stale,
                 includeDeleted: Boolean(options.includeDeleted),
+                limit,
+                offset,
+                fields,
                 tagsExpression: tagsExpression || undefined,
                 createdAtFrom,
                 createdAtTo,
@@ -207,7 +291,8 @@ export function registerNoteCommands(program) {
         .command('get')
         .description('Get note by id')
         .argument('<id>', 'note id')
-        .action(async (id, _options, command) => {
+        .option('--context-only', 'return lightweight note context (title/tags/summary/links)')
+        .action(async (id, options, command) => {
         const globals = command.optsWithGlobals?.() ?? {};
         const offline = Boolean(globals.offline);
         const jsonOutput = Boolean(globals.json);
@@ -216,9 +301,25 @@ export function registerNoteCommands(program) {
         const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
         try {
             await syncBeforeNoteCommand(db, offline, timeoutMs);
+            if (options.contextOnly) {
+                const context = await getNoteContext(db, id);
+                if (!context) {
+                    throw new DinoxError(`Note not found: ${id}`, {
+                        code: 'NOTE_NOT_FOUND',
+                        suggestion: "Run 'dino note search <keyword>' to locate the note id.",
+                        recoverable: true,
+                    });
+                }
+                printYaml({ stale: offline ? true : stale, note: context });
+                return;
+            }
             const note = await getNote(db, id);
             if (!note) {
-                throw new DinoxError(`Note not found: ${id}`);
+                throw new DinoxError(`Note not found: ${id}`, {
+                    code: 'NOTE_NOT_FOUND',
+                    suggestion: "Run 'dino note search <keyword>' to locate the note id.",
+                    recoverable: true,
+                });
             }
             if (jsonOutput) {
                 printYaml({ stale, note });
@@ -240,6 +341,34 @@ export function registerNoteCommands(program) {
             await db.close().catch(() => undefined);
         }
     });
+    note
+        .command('preview')
+        .description('Preview the first N lines of note markdown')
+        .argument('<id>', 'note id')
+        .option('--lines <n>', 'number of lines to return (default: 10)')
+        .action(async (id, options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const config = resolveConfig(await loadConfig());
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const lines = parsePreviewLineCount(options.lines);
+        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeNoteCommand(db, offline, timeoutMs);
+            const preview = await getNotePreview(db, id, lines);
+            if (!preview) {
+                throw new DinoxError(`Note not found: ${id}`, {
+                    code: 'NOTE_NOT_FOUND',
+                    suggestion: "Run 'dino note search <keyword>' to locate the note id.",
+                    recoverable: true,
+                });
+            }
+            printYaml({ stale: offline ? true : stale, note: preview });
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
     note
         .command('detail')
         .description('Get full note details by id')

package/dist/commands/notes/repo.d.ts

@@ -41,6 +41,30 @@ export type NoteDetail = {
     content_md: string | null;
     zettel_boxes: string[];
 };
+export type NoteContext = {
+    id: string;
+    title: string;
+    summary: string;
+    tags: string[];
+    created_at: string | null;
+    updated_at: string | null;
+    is_del: number | null;
+    zettel_boxes: string[];
+    links: {
+        backlinks: number;
+        outlinks: number;
+    };
+};
+export type NotePreview = {
+    id: string;
+    title: string;
+    requested_lines: number;
+    total_lines: number;
+    returned_lines: number;
+    truncated: boolean;
+    preview: string;
+    updated_at: string | null;
+};
 export type UpdateNoteResult = {
     id: string;
     updated: boolean;
@@ -49,6 +73,8 @@ export type UpdateNoteResult = {
 };
 export declare function searchNotes(db: AbstractPowerSyncDatabase, query: string, options: SearchNotesOptions): Promise<SearchedNote[]>;
 export declare function getNote(db: AbstractPowerSyncDatabase, id: string): Promise<NoteRow | null>;
+export declare function getNoteContext(db: AbstractPowerSyncDatabase, id: string): Promise<NoteContext | null>;
+export declare function getNotePreview(db: AbstractPowerSyncDatabase, id: string, requestedLines: number): Promise<NotePreview | null>;
 export declare function getNoteDetails(db: AbstractPowerSyncDatabase, ids: string[]): Promise<NoteDetail[]>;
 export declare function getNoteDetail(db: AbstractPowerSyncDatabase, id: string): Promise<NoteDetail | null>;
 export declare function createNote(db: AbstractPowerSyncDatabase, input: {

package/dist/commands/notes/repo.js

@@ -495,6 +495,105 @@ export async function getNote(db, id) {
     WHERE id = ?
     `, [id]);
 }
+async function getLinkCount(db, direction, noteId) {
+    const [column, boundColumn] = direction === 'in'
+        ? ['src_note_id', 'dst_note_id']
+        : ['dst_note_id', 'src_note_id'];
+    const row = await db.getOptional(`
+    SELECT COUNT(1) AS count
+    FROM c_note_link l
+    JOIN c_note n ON n.id = l.${column}
+    WHERE l.${boundColumn} = ?
+      AND l.is_del = 0
+      AND (n.is_del IS NULL OR n.is_del = 0)
+    `, [noteId]);
+    return Number(row?.count ?? 0);
+}
+function buildPreviewText(contentMd, requestedLines) {
+    const normalized = (contentMd ?? '').replace(/\r\n/g, '\n');
+    if (!normalized) {
+        return {
+            preview: '',
+            totalLines: 0,
+            returnedLines: 0,
+            truncated: false,
+        };
+    }
+    const lines = normalized.split('\n');
+    const selected = lines.slice(0, requestedLines);
+    return {
+        preview: selected.join('\n'),
+        totalLines: lines.length,
+        returnedLines: selected.length,
+        truncated: selected.length < lines.length,
+    };
+}
+export async function getNoteContext(db, id) {
+    const row = await db.getOptional(`
+    SELECT
+      n.id,
+      n.title,
+      n.summary,
+      n.content_text,
+      n.tags,
+      n.created_at,
+      n.updated_at,
+      n.is_del,
+      n.zettel_boxes AS zettel_boxes_raw
+    FROM c_note n
+    WHERE n.id = ?
+    `, [id]);
+    if (!row) {
+        return null;
+    }
+    const boxIds = parseZettelBoxIds(row.zettel_boxes_raw);
+    const boxNameMap = await loadZettelBoxNameMap(db, boxIds);
+    const [backlinks, outlinks] = await Promise.all([
+        getLinkCount(db, 'in', id),
+        getLinkCount(db, 'out', id),
+    ]);
+    return {
+        id: row.id,
+        title: row.title?.trim() ?? '',
+        summary: resolveSummary(row.summary, row.content_text),
+        tags: parseStoredTags(row.tags),
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        is_del: row.is_del,
+        zettel_boxes: boxIds
+            .map((boxId) => boxNameMap.get(boxId))
+            .filter((name) => typeof name === 'string' && name.length > 0),
+        links: {
+            backlinks,
+            outlinks,
+        },
+    };
+}
+export async function getNotePreview(db, id, requestedLines) {
+    const row = await db.getOptional(`
+    SELECT
+      n.id,
+      n.title,
+      n.content_md,
+      n.updated_at
+    FROM c_note n
+    WHERE n.id = ?
+    `, [id]);
+    if (!row) {
+        return null;
+    }
+    const preview = buildPreviewText(row.content_md, requestedLines);
+    return {
+        id: row.id,
+        title: row.title?.trim() ?? '',
+        requested_lines: requestedLines,
+        total_lines: preview.totalLines,
+        returned_lines: preview.returnedLines,
+        truncated: preview.truncated,
+        preview: preview.preview,
+        updated_at: row.updated_at ?? null,
+    };
+}
 function mapNoteDetailRow(note, boxNameMap) {
     const boxIds = parseZettelBoxIds(note.zettel_boxes_raw);
     const zettelBoxes = boxIds

package/dist/commands/notes/searchOutput.d.ts

@@ -0,0 +1,6 @@
+import type { SearchedNote } from './repo.js';
+export declare const NOTE_SEARCH_FIELDS: readonly ["id", "title", "summary", "tags", "created_at", "zettel_boxes"];
+export type NoteSearchField = (typeof NOTE_SEARCH_FIELDS)[number];
+export type NoteSearchResultItem = Partial<SearchedNote>;
+export declare function parseNoteSearchFields(value: unknown, optionName: string): NoteSearchField[] | undefined;
+export declare function projectNoteSearchFields(notes: SearchedNote[], fields: NoteSearchField[] | undefined): NoteSearchResultItem[];

package/dist/commands/notes/searchOutput.js

@@ -0,0 +1,41 @@
+import { DinoxError } from '../../utils/errors.js';
+export const NOTE_SEARCH_FIELDS = ['id', 'title', 'summary', 'tags', 'created_at', 'zettel_boxes'];
+const NOTE_SEARCH_FIELD_SET = new Set(NOTE_SEARCH_FIELDS);
+export function parseNoteSearchFields(value, optionName) {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    let rawFields = [];
+    if (Array.isArray(value)) {
+        rawFields = value.map((item) => String(item).trim());
+    }
+    else if (typeof value === 'string') {
+        rawFields = value
+            .split(/[\n,，]/g)
+            .map((item) => item.trim());
+    }
+    else {
+        throw new DinoxError(`${optionName} must be a comma-separated string or string array`);
+    }
+    const normalized = Array.from(new Set(rawFields.filter(Boolean)));
+    if (normalized.length === 0) {
+        throw new DinoxError(`${optionName} must include at least one field`);
+    }
+    const invalidField = normalized.find((field) => !NOTE_SEARCH_FIELD_SET.has(field));
+    if (invalidField) {
+        throw new DinoxError(`${optionName} has unsupported field: ${invalidField}. Allowed: ${NOTE_SEARCH_FIELDS.join(', ')}`);
+    }
+    return normalized;
+}
+export function projectNoteSearchFields(notes, fields) {
+    if (!fields || fields.length === 0) {
+        return notes.map((note) => ({ ...note }));
+    }
+    return notes.map((note) => {
+        const item = {};
+        for (const field of fields) {
+            item[field] = note[field];
+        }
+        return item;
+    });
+}

package/dist/daemon/server.js

@@ -3,7 +3,7 @@ import { loadConfig } from '../config/store.js';
 import { resolveConfig } from '../config/resolve.js';
 import { connectPowerSync, waitForIdleDataFlow } from '../powersync/runtime.js';
 import { searchNotes, getNoteDetails } from '../commands/notes/repo.js';
-import { getBacklinks, getOutlinks, getRelatedNotes } from '../commands/graph/repo.js';
+import { getBacklinks, getGraphStats, getOutlinks, getRelatedNotes } from '../commands/graph/repo.js';
 import { searchTodoTasks } from '../commands/todo/repo.js';
 import { savePid, removePid } from './pid.js';
 import { getPackageVersion } from '../utils/version.js';
@@ -75,6 +75,9 @@ export class DaemonServer {
                 case 'graph.related':
                     const related = await getRelatedNotes(this.db, params.id, params.depth || 2);
                     return { id: req.id, ok: true, result: related };
+                case 'graph.stats':
+                    const graphStats = await getGraphStats(this.db);
+                    return { id: req.id, ok: true, result: graphStats };
                 case 'todo.search':
                     const todos = await searchTodoTasks(this.db, params.query || '', {
                         includeDeleted: false,

package/dist/dinox.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createCli } from './cli.js';
-import { isDinoxError } from './utils/errors.js';
+import { buildStructuredErrorPayload, isDinoxError } from './utils/errors.js';
 import { printYaml } from './utils/output.js';
 function normalizeArgv(argv) {
     // pnpm/npm script forwarding can prepend a standalone "--".
@@ -25,26 +25,18 @@ main().catch((error) => {
     const argv = process.argv;
     const json = shouldOutputJson(argv);
     const verbose = isVerbose(argv);
-    const message = error instanceof Error ? error.message : String(error);
-    const name = error instanceof Error ? error.name : 'Error';
-    const stack = error instanceof Error ? error.stack : undefined;
-    const details = isDinoxError(error) ? error.details : undefined;
+    const payload = buildStructuredErrorPayload(error, verbose);
     const exitCode = isDinoxError(error) ? error.exitCode : 1;
     process.exitCode = exitCode;
     if (json) {
         printYaml({
             ok: false,
-            error: {
-                name,
-                message,
-                ...(details !== undefined ? { details } : {}),
-                ...(verbose && stack ? { stack } : {}),
-            },
+            error: payload,
         });
         return;
     }
-    console.error(message);
-    if (verbose && stack) {
-        console.error(stack);
+    console.error(payload.message);
+    if (verbose && payload.stack) {
+        console.error(payload.stack);
     }
 });