@dinoxx/dinox-cli 1.0.15 → 1.0.17

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/client.d.ts

@@ -0,0 +1,2 @@
+export declare function sendDaemonRequest(method: string, params?: unknown): Promise<unknown>;
+export declare function isDaemonRunning(): Promise<boolean>;

package/dist/daemon/client.js

@@ -0,0 +1,86 @@
+import { request as httpRequest } from 'node:http';
+import { DEFAULT_DAEMON_PORT } from './types.js';
+import { readPid } from './pid.js';
+const DEFAULT_DAEMON_REQUEST_TIMEOUT_MS = 2_000;
+const MAX_DAEMON_RESPONSE_BYTES = 5 * 1024 * 1024;
+export async function sendDaemonRequest(method, params) {
+    const pidInfo = readPid();
+    const port = pidInfo?.port || DEFAULT_DAEMON_PORT;
+    const request = {
+        id: Date.now().toString(),
+        method,
+        params,
+    };
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finalize = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(value);
+        };
+        const data = JSON.stringify(request);
+        const options = {
+            hostname: '127.0.0.1',
+            port,
+            path: '/',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(data),
+            },
+            timeout: DEFAULT_DAEMON_REQUEST_TIMEOUT_MS,
+        };
+        const req = httpRequest(options, (res) => {
+            const statusCode = res.statusCode ?? 0;
+            const chunks = [];
+            let totalBytes = 0;
+            res.on('data', (chunk) => {
+                totalBytes += chunk.length;
+                if (totalBytes > MAX_DAEMON_RESPONSE_BYTES) {
+                    req.destroy(new Error('Daemon response too large'));
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            res.on('end', () => {
+                try {
+                    const body = Buffer.concat(chunks).toString('utf-8');
+                    if (statusCode < 200 || statusCode >= 300) {
+                        finalize(new Error(`Daemon request failed (HTTP ${statusCode || 'unknown'}): ${body || '(empty)'}`));
+                        return;
+                    }
+                    const response = JSON.parse(body);
+                    if (response.ok) {
+                        finalize(undefined, response.result);
+                    }
+                    else {
+                        finalize(new Error(response.error || 'Unknown error'));
+                    }
+                }
+                catch (error) {
+                    finalize(error);
+                }
+            });
+        });
+        req.on('timeout', () => {
+            req.destroy(new Error('Daemon request timed out'));
+        });
+        req.on('error', (error) => finalize(error));
+        req.write(data);
+        req.end();
+    });
+}
+export async function isDaemonRunning() {
+    try {
+        await sendDaemonRequest('ping');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/daemon/ensure.d.ts

@@ -0,0 +1 @@
+export declare function ensureDaemonRunning(): Promise<void>;

package/dist/daemon/ensure.js

@@ -0,0 +1,23 @@
+import { spawn } from 'child_process';
+import { isDaemonRunning } from './client.js';
+import { DEFAULT_DAEMON_PORT } from './types.js';
+export async function ensureDaemonRunning() {
+    if (await isDaemonRunning()) {
+        return;
+    }
+    console.log('Starting daemon...');
+    const args = ['daemon', 'start', '--port', String(DEFAULT_DAEMON_PORT), '--no-detach'];
+    const child = spawn(process.argv[0], [process.argv[1], ...args], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    for (let i = 0; i < 10; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        if (await isDaemonRunning()) {
+            console.log('Daemon started');
+            return;
+        }
+    }
+    throw new Error('Failed to start daemon');
+}

package/dist/daemon/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerDaemonCommands(program: Command): void;