@dinoxx/dinox-cli 2.0.0 → 2.1.1

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

@@ -0,0 +1,8 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type NoteContext, type NoteDetail, type NoteExportItem, type NotePreview, type NoteRow } from './shared.js';
+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 getNoteExportItems(db: AbstractPowerSyncDatabase, ids: string[]): Promise<NoteExportItem[]>;

package/dist/commands/notes/repo/read.js

@@ -0,0 +1,321 @@
+// Note reads: single-note lookup, context, preview, detail, and export rows.
+import { DinoxError } from '../../../utils/errors.js';
+import { loadZettelBoxNameMap, normalizeStoredFlag, normalizeStoredStarred, parseStoredTags, parseZettelBoxIds, resolveSummary, } from './shared.js';
+export async function getNote(db, id) {
+    return db.getOptional(`
+    SELECT
+      id,
+      title,
+      content_md,
+      content_json,
+      content_text,
+      created_at,
+      updated_at,
+      is_del,
+      starred_at,
+      CASE WHEN starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
+      version
+    FROM c_note
+    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 IS NULL OR 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.starred_at,
+      CASE WHEN n.starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
+      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,
+        starred_at: row.starred_at ?? null,
+        is_starred: normalizeStoredStarred(row.is_starred),
+        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
+        .map((boxId) => boxNameMap.get(boxId))
+        .filter((name) => typeof name === 'string' && name.length > 0);
+    return {
+        id: note.id,
+        created_at: note.created_at,
+        updated_at: note.updated_at,
+        title: note.title,
+        type: note.type,
+        source: note.source,
+        tags: parseStoredTags(note.tags),
+        is_del: note.is_del,
+        is_pub: normalizeStoredFlag(note.is_pub),
+        properties: parseStoredNoteProperties(note.properties),
+        starred_at: note.starred_at ?? null,
+        is_starred: normalizeStoredStarred(note.is_starred),
+        content_md: note.content_md,
+        content_text: note.content_text,
+        content_json: parseStoredJsonValue(note.content_json),
+        zettel_boxes: zettelBoxes,
+    };
+}
+function parseStoredJsonValue(raw) {
+    const value = raw?.trim() ?? '';
+    if (!value) {
+        return null;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return raw;
+    }
+}
+function parseStoredNoteProperties(raw) {
+    const value = raw?.trim() ?? '';
+    if (!value) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (cause) {
+        throw new DinoxError('c_note.properties must be valid JSON', {
+            code: 'NOTE_INVALID_PROPERTIES',
+            details: { cause: cause instanceof Error ? cause.message : String(cause) },
+            recoverable: false,
+        });
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new DinoxError('c_note.properties must be a JSON object', {
+            code: 'NOTE_INVALID_PROPERTIES',
+            recoverable: false,
+        });
+    }
+    return Object.fromEntries(Object.entries(parsed));
+}
+function mapNoteExportRow(note, boxNameMap) {
+    const boxIds = parseZettelBoxIds(note.zettel_boxes_raw);
+    const boxes = boxIds
+        .map((boxId) => boxNameMap.get(boxId))
+        .filter((name) => typeof name === 'string' && name.length > 0);
+    return {
+        id: note.id,
+        created_at: note.created_at,
+        updated_at: note.updated_at,
+        title: note.title,
+        type: note.type,
+        source: note.source,
+        summary: note.summary,
+        tags: parseStoredTags(note.tags),
+        is_del: note.is_del,
+        is_pub: normalizeStoredFlag(note.is_pub),
+        properties: parseStoredNoteProperties(note.properties),
+        starred_at: note.starred_at ?? null,
+        is_starred: normalizeStoredStarred(note.is_starred),
+        content_md: note.content_md ?? '',
+        content_text: note.content_text,
+        content_json: parseStoredJsonValue(note.content_json),
+        box_ids: boxIds,
+        boxes,
+    };
+}
+export async function getNoteDetails(db, ids) {
+    const targetIds = Array.from(new Set(ids
+        .map((id) => id.trim())
+        .filter((id) => id.length > 0)));
+    if (targetIds.length === 0) {
+        return [];
+    }
+    const noteRowsById = new Map();
+    const chunkSize = 500;
+    for (let index = 0; index < targetIds.length; index += chunkSize) {
+        const batch = targetIds.slice(index, index + chunkSize);
+        const placeholders = batch.map(() => '?').join(', ');
+        const rows = await db.getAll(`
+      SELECT
+        id,
+        created_at,
+        updated_at,
+        title,
+        type,
+        source,
+        tags,
+        is_del,
+        is_pub,
+        properties,
+        starred_at,
+        CASE WHEN starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
+        content_md,
+        content_text,
+        content_json,
+        zettel_boxes AS zettel_boxes_raw
+      FROM c_note
+      WHERE id IN (${placeholders})
+      `, batch);
+        for (const row of rows) {
+            const id = row.id?.trim() ?? '';
+            if (!id || noteRowsById.has(id)) {
+                continue;
+            }
+            noteRowsById.set(id, row);
+        }
+    }
+    const allBoxIds = Array.from(new Set(Array.from(noteRowsById.values()).flatMap((row) => parseZettelBoxIds(row.zettel_boxes_raw))));
+    const boxNameMap = await loadZettelBoxNameMap(db, allBoxIds);
+    const details = [];
+    for (const id of targetIds) {
+        const row = noteRowsById.get(id);
+        if (!row) {
+            continue;
+        }
+        details.push(mapNoteDetailRow(row, boxNameMap));
+    }
+    return details;
+}
+export async function getNoteDetail(db, id) {
+    const details = await getNoteDetails(db, [id]);
+    return details[0] ?? null;
+}
+export async function getNoteExportItems(db, ids) {
+    const targetIds = Array.from(new Set(ids
+        .map((id) => id.trim())
+        .filter((id) => id.length > 0)));
+    if (targetIds.length === 0) {
+        return [];
+    }
+    const noteRowsById = new Map();
+    const chunkSize = 500;
+    for (let index = 0; index < targetIds.length; index += chunkSize) {
+        const batch = targetIds.slice(index, index + chunkSize);
+        const placeholders = batch.map(() => '?').join(', ');
+        const rows = await db.getAll(`
+      SELECT
+        id,
+        created_at,
+        updated_at,
+        title,
+        type,
+        source,
+        tags,
+        summary,
+        is_del,
+        is_pub,
+        properties,
+        starred_at,
+        CASE WHEN starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
+        content_md,
+        content_text,
+        content_json,
+        zettel_boxes AS zettel_boxes_raw
+      FROM c_note
+      WHERE id IN (${placeholders})
+      `, batch);
+        for (const row of rows) {
+            const id = row.id?.trim() ?? '';
+            if (!id || noteRowsById.has(id)) {
+                continue;
+            }
+            noteRowsById.set(id, row);
+        }
+    }
+    const allBoxIds = Array.from(new Set(Array.from(noteRowsById.values()).flatMap((row) => parseZettelBoxIds(row.zettel_boxes_raw))));
+    const boxNameMap = await loadZettelBoxNameMap(db, allBoxIds);
+    const items = [];
+    for (const id of targetIds) {
+        const row = noteRowsById.get(id);
+        if (!row) {
+            continue;
+        }
+        items.push(mapNoteExportRow(row, boxNameMap));
+    }
+    return items;
+}

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

@@ -0,0 +1,8 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+export declare function validateTagsForCreate(db: AbstractPowerSyncDatabase, requestedTags: string[], userId: string): Promise<string[]>;
+export declare function validateTagsForUpdate(db: AbstractPowerSyncDatabase, requestedTags: string[], userId: string): Promise<string[]>;
+export declare function validateTagsForBulk(db: AbstractPowerSyncDatabase, requestedTags: string[], userId: string): Promise<string[]>;
+export declare function resolveZettelBoxIdsForCreate(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
+export declare function resolveZettelBoxIdsForSearch(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
+export declare function resolveZettelBoxIdsForUpdate(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
+export declare function resolveZettelBoxIdsForBulk(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;

package/dist/commands/notes/repo/resolve.js

@@ -0,0 +1,187 @@
+// Tag validation and zettel box name/path resolution for note writes and search.
+import { DinoxError } from '../../../utils/errors.js';
+import { canonicalizeBoxPath, listBoxes } from '../../boxes/repo.js';
+import { listTags } from '../../tags/repo.js';
+import { normalizeLookupKey } from './shared.js';
+function normalizeZettelBoxLookupKey(value) {
+    return canonicalizeBoxPath(value).toLowerCase();
+}
+function buildZettelBoxRetryQuestion(intent, type) {
+    const command = intent === 'search'
+        ? 'dino note search'
+        : intent === 'update'
+            ? 'dino note update'
+            : intent === 'bulk'
+                ? 'dino note bulk'
+                : 'dino note create';
+    if (type === 'ambiguous') {
+        return `Do you want to specify box paths and retry \`${command}\`?`;
+    }
+    return `Do you want to add these missing boxes and retry \`${command}\`?`;
+}
+export async function validateTagsForCreate(db, requestedTags, userId) {
+    return validateTagsForWrite(db, requestedTags, userId, 'dino note create');
+}
+export async function validateTagsForUpdate(db, requestedTags, userId) {
+    return validateTagsForWrite(db, requestedTags, userId, 'dino note update');
+}
+export async function validateTagsForBulk(db, requestedTags, userId) {
+    return validateTagsForWrite(db, requestedTags, userId, 'dino note bulk');
+}
+async function validateTagsForWrite(db, requestedTags, userId, retryCommand) {
+    const normalizedUserId = userId.trim();
+    if (!normalizedUserId) {
+        throw new DinoxError('Tag validation requires the current userId. Run `dino auth login` first, or set DINOX_TOKEN and run an online command so the CLI can resolve the token identity.');
+    }
+    if (requestedTags.length === 0) {
+        return [];
+    }
+    const tags = await listTags(db, { userId: normalizedUserId });
+    const existingTagMap = new Map();
+    for (const tag of tags) {
+        const key = normalizeLookupKey(tag);
+        if (!key || existingTagMap.has(key)) {
+            continue;
+        }
+        existingTagMap.set(key, tag);
+    }
+    const resolved = [];
+    const seen = new Set();
+    const missing = [];
+    for (const requested of requestedTags) {
+        const key = normalizeLookupKey(requested);
+        if (!key || seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        const matched = existingTagMap.get(key);
+        if (!matched) {
+            missing.push(requested);
+            continue;
+        }
+        resolved.push(matched);
+    }
+    if (missing.length > 0) {
+        throw new DinoxError(`Unknown tags: ${missing.join(', ')}`, {
+            details: {
+                type: 'missing_tags',
+                missing,
+                knownCount: tags.length,
+                knownSample: tags.slice(0, 20),
+                question: `Do you want to add these missing tags and retry \`${retryCommand}\`?`,
+            },
+        });
+    }
+    return resolved;
+}
+export async function resolveZettelBoxIdsForCreate(db, requestedNames) {
+    return resolveZettelBoxIdsByName(db, requestedNames, 'create');
+}
+export async function resolveZettelBoxIdsForSearch(db, requestedNames) {
+    return resolveZettelBoxIdsByName(db, requestedNames, 'search');
+}
+export async function resolveZettelBoxIdsForUpdate(db, requestedNames) {
+    return resolveZettelBoxIdsByName(db, requestedNames, 'update');
+}
+export async function resolveZettelBoxIdsForBulk(db, requestedNames) {
+    return resolveZettelBoxIdsByName(db, requestedNames, 'bulk');
+}
+async function resolveZettelBoxIdsByName(db, requestedNames, intent) {
+    if (requestedNames.length === 0) {
+        return [];
+    }
+    const boxes = await listBoxes(db);
+    const availablePaths = Array.from(new Set(boxes.map((box) => box.path.trim()).filter(Boolean)));
+    const boxByPath = new Map();
+    const boxByName = new Map();
+    for (const box of boxes) {
+        const name = box.name.trim();
+        const path = canonicalizeBoxPath(box.path || name);
+        const pathKey = normalizeZettelBoxLookupKey(path);
+        if (pathKey && !boxByPath.has(pathKey)) {
+            boxByPath.set(pathKey, box.id);
+        }
+        const nameKey = normalizeLookupKey(name);
+        if (!nameKey) {
+            continue;
+        }
+        const current = boxByName.get(nameKey);
+        if (!current) {
+            boxByName.set(nameKey, {
+                name,
+                ids: [box.id],
+                paths: path ? [path] : [],
+            });
+            continue;
+        }
+        if (!current.ids.includes(box.id)) {
+            current.ids.push(box.id);
+        }
+        if (path && !current.paths.includes(path)) {
+            current.paths.push(path);
+        }
+    }
+    const resolvedIds = [];
+    const seenIds = new Set();
+    const missing = [];
+    const ambiguous = [];
+    const seenAmbiguous = new Set();
+    for (const requested of requestedNames) {
+        const pathKey = normalizeZettelBoxLookupKey(requested);
+        if (!pathKey) {
+            continue;
+        }
+        const pathMatchId = boxByPath.get(pathKey);
+        if (pathMatchId) {
+            if (!seenIds.has(pathMatchId)) {
+                seenIds.add(pathMatchId);
+                resolvedIds.push(pathMatchId);
+            }
+            continue;
+        }
+        const lookup = boxByName.get(normalizeLookupKey(requested));
+        if (!lookup) {
+            missing.push(requested);
+            continue;
+        }
+        if (lookup.ids.length > 1) {
+            const marker = `${requested.toLowerCase()}::${lookup.ids.join(',')}`;
+            if (!seenAmbiguous.has(marker)) {
+                seenAmbiguous.add(marker);
+                ambiguous.push({
+                    name: requested,
+                    ids: lookup.ids,
+                    paths: lookup.paths,
+                });
+            }
+            continue;
+        }
+        const id = lookup.ids[0];
+        if (!seenIds.has(id)) {
+            seenIds.add(id);
+            resolvedIds.push(id);
+        }
+    }
+    if (ambiguous.length > 0) {
+        throw new DinoxError(`Ambiguous zettel box names: ${ambiguous.map((item) => `${item.name} -> [${item.paths.join(', ')}]`).join('; ')}`, {
+            details: {
+                type: 'ambiguous_zettel_boxes',
+                ambiguous,
+                availablePathsSample: availablePaths.slice(0, 20),
+                question: buildZettelBoxRetryQuestion(intent, 'ambiguous'),
+            },
+        });
+    }
+    if (missing.length > 0) {
+        throw new DinoxError(`Unknown zettel box paths or names: ${missing.join(', ')}`, {
+            details: {
+                type: 'missing_zettel_boxes',
+                missing,
+                availableCount: availablePaths.length,
+                availablePathsSample: availablePaths.slice(0, 20),
+                question: buildZettelBoxRetryQuestion(intent, 'missing'),
+            },
+        });
+    }
+    return resolvedIds;
+}

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

@@ -0,0 +1,42 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type SearchNotesOptions, type SearchedNote } from './shared.js';
+/**
+ * JSON-safe note-search request. Box *names/paths* are carried (not resolved ids) so the
+ * same payload can be executed either in-process or sent to the daemon over the wire;
+ * id resolution happens inside {@link executeNoteSearch} against whichever db runs it.
+ */
+export type NoteSearchExecuteParams = {
+    keyword: string;
+    includeDeleted: boolean;
+    tagsExpression?: string;
+    createdAtFrom?: string;
+    createdAtTo?: string;
+    starred?: boolean;
+    boxValues: string[];
+    matchEmptyZettelBoxes: boolean;
+    sqlExpression?: string;
+    limit?: number;
+    offset?: number;
+};
+export type NoteSearchExecuteResult = {
+    rows: SearchedNote[];
+    totalCount: number;
+    /** Resolved zettel-box ids, surfaced so callers can echo them in response metadata. */
+    zettelBoxIds: string[];
+};
+/**
+ * Resolve box names to ids and run the note search. Shared by the local command path and
+ * the daemon RPC handler so both produce identical results from one implementation.
+ */
+export declare function executeNoteSearch(db: AbstractPowerSyncDatabase, params: NoteSearchExecuteParams): Promise<NoteSearchExecuteResult>;
+export declare function searchNotes(db: AbstractPowerSyncDatabase, query: string, options: SearchNotesOptions): Promise<SearchedNote[]>;
+type SearchNotesPageOptions = SearchNotesOptions & {
+    limit?: number;
+    offset?: number;
+};
+type SearchNotesPageResult = {
+    rows: SearchedNote[];
+    totalCount: number;
+};
+export declare function searchNotesPage(db: AbstractPowerSyncDatabase, query: string, options: SearchNotesPageOptions): Promise<SearchNotesPageResult>;
+export {};