@dinoxx/dinox-cli 1.0.19 → 1.0.21

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

@@ -0,0 +1,84 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type NoteContentBlockDescriptor, type NoteContentOutlineItem } from './contentEngine.js';
+export type NoteContentPatchOperation = {
+    kind: 'appendSection';
+    heading: string;
+    content: string;
+} | {
+    kind: 'appendToHeading';
+    headingPath: string;
+    content: string;
+} | {
+    kind: 'replaceSection';
+    headingPath: string;
+    content: string;
+    allowProtectedReplace?: boolean;
+} | {
+    kind: 'replaceBlock';
+    match: string;
+    content: string;
+    allowProtectedReplace?: boolean;
+};
+export type NoteContentReadResult = {
+    noteId: string;
+    title: string;
+    readToken: string;
+    readTokenExpiresAt: string;
+    base: {
+        contentHash: string;
+        updatedAt: string | null;
+        version: number | null;
+    };
+    content: string;
+    outline: NoteContentOutlineItem[];
+    blocks: NoteContentBlockDescriptor[];
+    derived: {
+        hashtags: string[];
+        images: string[];
+        bidLinks: Array<{
+            id: string;
+            type: string;
+        }>;
+    };
+};
+export type NoteContentPatchPlan = {
+    noteId: string;
+    title: string;
+    operation: NoteContentPatchOperation['kind'];
+    changed: boolean;
+    beforeHash: string;
+    afterHash: string;
+    beforeContent: string;
+    afterContent: string;
+    beforeBlocks: NoteContentBlockDescriptor[];
+    afterBlocks: NoteContentBlockDescriptor[];
+    derived: {
+        beforeHashtags: string[];
+        afterHashtags: string[];
+        images: string[];
+        bidLinks: Array<{
+            id: string;
+            type: string;
+        }>;
+    };
+    target?: Record<string, unknown>;
+};
+export type NoteContentPatchResult = Omit<NoteContentPatchPlan, 'beforeContent' | 'afterContent'> & {
+    saved: boolean;
+};
+export declare function planMarkdownPatch(input: {
+    id: string;
+    title: string;
+    contentMd: string;
+    operation: NoteContentPatchOperation;
+}): NoteContentPatchPlan;
+export declare function readNoteContentForPatch(db: AbstractPowerSyncDatabase, id: string): Promise<NoteContentReadResult>;
+export declare function planNoteContentPatch(db: AbstractPowerSyncDatabase, input: {
+    id: string;
+    operation: NoteContentPatchOperation;
+}): Promise<NoteContentPatchPlan>;
+export declare function applyNoteContentPatch(db: AbstractPowerSyncDatabase, input: {
+    id: string;
+    readToken: string;
+    operation: NoteContentPatchOperation;
+}): Promise<NoteContentPatchResult>;

package/dist/commands/notes/contentPatch.js

@@ -0,0 +1,337 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getDataDir } from '../../config/paths.js';
+import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
+import { DinoxError } from '../../utils/errors.js';
+import { generateId } from '../../utils/id.js';
+import { nowIsoUtc } from '../../utils/time.js';
+import { applyJsonPatchToDocument, buildNoteContentBlocks, buildNoteContentOutline, getNoteContentHash, parseStoredNoteDocument, projectNoteContent, } from './contentEngine.js';
+const READ_TOKEN_TTL_MS = 30 * 60 * 1000;
+const MAX_STORED_READ_TOKENS = 500;
+const TOKEN_STORE_FILE = 'note-content-read-tokens.json';
+function normalizeVersion(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function canonicalTagPath(value) {
+    return value
+        .split(/[\\/]+/g)
+        .map((segment) => segment.trim())
+        .filter(Boolean)
+        .join('/');
+}
+function tagPathKey(value) {
+    return canonicalTagPath(value).toLowerCase();
+}
+async function loadTagReferenceLookup(db) {
+    const rows = await db.getAll(`
+    SELECT
+      TRIM(COALESCE(id, '')) AS id,
+      TRIM(COALESCE(full_path, path_key, '')) AS full_path,
+      TRIM(COALESCE(path_key, full_path, '')) AS path_key
+    FROM c_tag_node
+    WHERE TRIM(COALESCE(id, '')) <> ''
+      AND TRIM(COALESCE(full_path, path_key, '')) <> ''
+      AND (is_del IS NULL OR is_del = 0)
+      AND (is_actual IS NULL OR is_actual != 0)
+    ORDER BY
+      updated_at DESC,
+      created_at DESC,
+      id DESC
+    `, []);
+    const byId = new Map();
+    const byPathKey = new Map();
+    for (const row of rows) {
+        const id = row.id?.trim() ?? '';
+        const path = canonicalTagPath(row.full_path ?? row.path_key ?? '');
+        if (!id || !path) {
+            continue;
+        }
+        byId.set(id, path);
+        const key = tagPathKey(path);
+        if (key && !byPathKey.has(key)) {
+            byPathKey.set(key, { id, path });
+        }
+    }
+    return { byId, byPathKey };
+}
+function createHashtagReferenceResolver(lookup, options) {
+    return ({ id, path }) => {
+        const pathFromId = id ? lookup.byId.get(id) : undefined;
+        const resolvedPath = canonicalTagPath(pathFromId ?? path);
+        if (!resolvedPath) {
+            return null;
+        }
+        const match = lookup.byPathKey.get(tagPathKey(resolvedPath));
+        if (match) {
+            return match;
+        }
+        if (options.strictMissingPaths) {
+            throw new DinoxError(`Unknown tag path in note content: ${resolvedPath}. Create it with \`dino tag add "${resolvedPath}"\` before patching.`);
+        }
+        return { id: id || resolvedPath, path: resolvedPath };
+    };
+}
+function tokenStorePath() {
+    return path.join(getDataDir(), TOKEN_STORE_FILE);
+}
+async function loadTokenStore(nowMs = Date.now()) {
+    const filePath = tokenStorePath();
+    let tokens = [];
+    try {
+        const raw = await fs.readFile(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed.tokens)) {
+            tokens = parsed.tokens.filter((token) => typeof token?.token === 'string' &&
+                typeof token.noteId === 'string' &&
+                typeof token.contentHash === 'string' &&
+                typeof token.expiresAt === 'string');
+        }
+    }
+    catch (error) {
+        if (!error || typeof error !== 'object' || !('code' in error) || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    return {
+        tokens: tokens
+            .filter((token) => Date.parse(token.expiresAt) > nowMs)
+            .slice(-MAX_STORED_READ_TOKENS),
+    };
+}
+async function saveTokenStore(store) {
+    const filePath = tokenStorePath();
+    await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const tmpPath = `${filePath}.${generateId()}.tmp`;
+    await fs.writeFile(tmpPath, `${JSON.stringify(store, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    if (process.platform !== 'win32') {
+        await fs.chmod(tmpPath, 0o600).catch(() => undefined);
+    }
+    await fs.rename(tmpPath, filePath);
+}
+async function rememberReadToken(input) {
+    const nowMs = Date.now();
+    const store = await loadTokenStore(nowMs);
+    const expiresAt = new Date(nowMs + READ_TOKEN_TTL_MS).toISOString();
+    const token = {
+        token: generateId(),
+        noteId: input.noteId,
+        contentHash: input.contentHash,
+        updatedAt: input.updatedAt,
+        version: input.version,
+        createdAt: new Date(nowMs).toISOString(),
+        expiresAt,
+    };
+    store.tokens.push(token);
+    store.tokens = store.tokens.slice(-MAX_STORED_READ_TOKENS);
+    await saveTokenStore(store);
+    return token;
+}
+async function consumeReadToken(tokenId) {
+    const normalized = tokenId.trim();
+    if (!normalized) {
+        throw new DinoxError('Missing --read-token. Run `dino note content-read <id>` before editing.');
+    }
+    const store = await loadTokenStore();
+    const token = store.tokens.find((candidate) => candidate.token === normalized);
+    if (!token) {
+        throw new DinoxError('read token is expired or unknown. Run `dino note content-read <id>` again.');
+    }
+    return token;
+}
+async function forgetReadToken(tokenId) {
+    const store = await loadTokenStore();
+    const next = store.tokens.filter((token) => token.token !== tokenId);
+    if (next.length !== store.tokens.length) {
+        await saveTokenStore({ tokens: next });
+    }
+}
+async function readNoteContentRow(db, id) {
+    const noteId = id.trim();
+    if (!noteId) {
+        throw new DinoxError('Note id is required');
+    }
+    const row = await db.getOptional(`
+    SELECT id, title, content_md, content_json, content_text, updated_at, version, is_del
+    FROM c_note
+    WHERE id = ?
+    `, [noteId]);
+    if (!row) {
+        throw new DinoxError(`Note not found: ${noteId}`);
+    }
+    if (Number(row.is_del ?? 0) !== 0) {
+        throw new DinoxError(`Note has been deleted: ${noteId}`);
+    }
+    return row;
+}
+async function getNoteTableColumns(db) {
+    const rows = await db.getAll('PRAGMA table_info(c_note)', []);
+    return new Set(rows.map((row) => row.name?.trim().toLowerCase() ?? '').filter(Boolean));
+}
+async function updateNoteContentProjection(tx, input) {
+    const columns = await getNoteTableColumns(tx);
+    const setParts = [
+        'content_md = ?',
+        'content_json = ?',
+        'content_text = ?',
+    ];
+    const params = [input.contentMd, input.contentJson, input.contentText];
+    if (columns.has('images')) {
+        setParts.push('images = ?');
+        params.push(JSON.stringify(input.images));
+    }
+    if (columns.has('tags')) {
+        setParts.push('tags = ?');
+        params.push(JSON.stringify(input.tags));
+    }
+    if (columns.has('bid_links')) {
+        setParts.push('bid_links = ?');
+        params.push(JSON.stringify(input.bidLinks));
+    }
+    setParts.push('updated_at = ?');
+    params.push(nowIsoUtc());
+    setParts.push('version = COALESCE(version, 0) + 1');
+    params.push(input.rowId);
+    await tx.execute(`
+    UPDATE c_note
+    SET ${setParts.join(',\n        ')}
+    WHERE id = ?
+    `, params);
+}
+function buildPatchPlan(input) {
+    const document = parseStoredNoteDocument({
+        contentJson: input.contentJson,
+        contentMd: input.contentMd,
+    });
+    const enginePlan = applyJsonPatchToDocument(document, input.operation, {
+        resolveHashtagReference: input.resolveHashtagReference,
+    });
+    return {
+        noteId: input.id,
+        title: input.title,
+        operation: enginePlan.operation,
+        changed: enginePlan.changed,
+        beforeHash: enginePlan.beforeHash,
+        afterHash: enginePlan.afterHash,
+        beforeContent: enginePlan.beforeContent,
+        afterContent: enginePlan.afterContent,
+        beforeBlocks: enginePlan.beforeBlocks,
+        afterBlocks: enginePlan.afterBlocks,
+        derived: {
+            beforeHashtags: enginePlan.beforeProjection.hashtags,
+            afterHashtags: enginePlan.afterProjection.hashtags,
+            images: enginePlan.afterProjection.images,
+            bidLinks: enginePlan.afterProjection.bidLinks,
+        },
+        target: enginePlan.target,
+        afterProjection: enginePlan.afterProjection,
+    };
+}
+export function planMarkdownPatch(input) {
+    const { afterProjection: _afterProjection, ...plan } = buildPatchPlan({
+        id: input.id,
+        title: input.title,
+        contentJson: null,
+        contentMd: input.contentMd,
+        operation: input.operation,
+    });
+    return plan;
+}
+export async function readNoteContentForPatch(db, id) {
+    const row = await readNoteContentRow(db, id);
+    const tagLookup = await loadTagReferenceLookup(db);
+    const document = parseStoredNoteDocument({
+        contentJson: row.content_json,
+        contentMd: row.content_md,
+    });
+    const projection = projectNoteContent(document, {
+        resolveHashtagReference: createHashtagReferenceResolver(tagLookup, { strictMissingPaths: false }),
+    });
+    const contentHash = getNoteContentHash(document);
+    const version = normalizeVersion(row.version);
+    const token = await rememberReadToken({
+        noteId: row.id,
+        contentHash,
+        updatedAt: row.updated_at ?? null,
+        version,
+    });
+    return {
+        noteId: row.id,
+        title: row.title?.trim() ?? '',
+        readToken: token.token,
+        readTokenExpiresAt: token.expiresAt,
+        base: {
+            contentHash,
+            updatedAt: row.updated_at ?? null,
+            version,
+        },
+        content: projection.contentMd,
+        outline: buildNoteContentOutline(projection.document),
+        blocks: buildNoteContentBlocks(projection.document),
+        derived: {
+            hashtags: projection.hashtags,
+            images: projection.images,
+            bidLinks: projection.bidLinks,
+        },
+    };
+}
+export async function planNoteContentPatch(db, input) {
+    const row = await readNoteContentRow(db, input.id);
+    const tagLookup = await loadTagReferenceLookup(db);
+    const { afterProjection: _afterProjection, ...plan } = buildPatchPlan({
+        id: row.id,
+        title: row.title?.trim() ?? '',
+        contentJson: row.content_json,
+        contentMd: row.content_md,
+        operation: input.operation,
+        resolveHashtagReference: createHashtagReferenceResolver(tagLookup, { strictMissingPaths: true }),
+    });
+    return plan;
+}
+export async function applyNoteContentPatch(db, input) {
+    const token = await consumeReadToken(input.readToken);
+    const result = await withPowerSyncWriteTransaction(db, async (tx) => {
+        const tagLookup = await loadTagReferenceLookup(tx);
+        const row = await readNoteContentRow(tx, input.id);
+        if (row.id !== token.noteId) {
+            throw new DinoxError('read token does not match target note. Run `dino note content-read <id>` again.');
+        }
+        const currentDocument = parseStoredNoteDocument({
+            contentJson: row.content_json,
+            contentMd: row.content_md,
+        });
+        if (token.updatedAt !== (row.updated_at ?? null) ||
+            token.version !== normalizeVersion(row.version) ||
+            token.contentHash !== getNoteContentHash(currentDocument)) {
+            await forgetReadToken(token.token);
+            throw new DinoxError('Note content changed after content-read. Run `dino note content-read <id>` again.');
+        }
+        const plan = buildPatchPlan({
+            id: row.id,
+            title: row.title?.trim() ?? '',
+            contentJson: row.content_json,
+            contentMd: row.content_md,
+            operation: input.operation,
+            resolveHashtagReference: createHashtagReferenceResolver(tagLookup, { strictMissingPaths: true }),
+        });
+        if (plan.changed) {
+            await updateNoteContentProjection(tx, {
+                rowId: row.id,
+                contentMd: plan.afterProjection.contentMd,
+                contentJson: plan.afterProjection.contentJson,
+                contentText: plan.afterProjection.contentText,
+                tags: plan.afterProjection.hashtags,
+                images: plan.afterProjection.images,
+                bidLinks: plan.afterProjection.bidLinks,
+            });
+        }
+        const { afterProjection: _afterProjection, ...publicPlan } = plan;
+        return publicPlan;
+    });
+    await forgetReadToken(token.token);
+    const { beforeContent: _beforeContent, afterContent: _afterContent, ...publicResult } = result;
+    return {
+        ...publicResult,
+        saved: result.changed,
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { CommandExecutionContext } from '../descriptor/types.js';
+export declare function runNoteContentRead({ command, options, args }: CommandExecutionContext): Promise<void>;
+export declare function runNotePatch({ command, options, args }: CommandExecutionContext): Promise<void>;

package/dist/commands/notes/contentPatchCommand.js

@@ -0,0 +1,126 @@
+import { printDryRunPreview } from '../../utils/dryRun.js';
+import { DinoxError } from '../../utils/errors.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
+import { commandStale, printStaleCacheWarning, printUploadDisabledWarning, waitForMutationUpload, } from '../runtime.js';
+import { applyNoteContentPatch, planNoteContentPatch, readNoteContentForPatch, } from './contentPatch.js';
+import { parseStringInput, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
+function requireNoteId(id) {
+    const normalized = id?.trim() ?? '';
+    if (!normalized) {
+        throw new DinoxError('Note id is required');
+    }
+    return normalized;
+}
+async function selectPatchOperation(options) {
+    const candidates = [
+        { kind: 'appendSection', value: options.appendSection },
+        { kind: 'appendToHeading', value: options.appendToHeading },
+        { kind: 'replaceSection', value: options.replaceSection },
+        { kind: 'replaceBlock', value: options.replaceBlock ? 'true' : undefined },
+    ];
+    const selected = candidates.filter((entry) => typeof entry.value === 'string');
+    if (selected.length !== 1) {
+        throw new DinoxError('Provide exactly one patch operation: --append-section, --append-to-heading, --replace-section, or --replace-block');
+    }
+    if (typeof options.content !== 'string') {
+        throw new DinoxError('--content <string|@file> is required');
+    }
+    const content = await parseStringInput(options.content);
+    const { kind, value } = selected[0];
+    if (kind === 'appendSection') {
+        return { kind: 'appendSection', heading: value, content };
+    }
+    if (kind === 'appendToHeading') {
+        return { kind: 'appendToHeading', headingPath: value, content };
+    }
+    if (kind === 'replaceSection') {
+        return {
+            kind: 'replaceSection',
+            headingPath: value,
+            content,
+            allowProtectedReplace: options.allowProtectedReplace === true,
+        };
+    }
+    if (typeof options.match !== 'string') {
+        throw new DinoxError('--match <string|@file> is required with --replace-block');
+    }
+    return {
+        kind: 'replaceBlock',
+        match: await parseStringInput(options.match),
+        content,
+        allowProtectedReplace: options.allowProtectedReplace === true,
+    };
+}
+export async function runNoteContentRead({ command, options, args }) {
+    const readOptions = options;
+    const id = requireNoteId(args.id);
+    await withNoteDatabase(command, async (runtime) => {
+        await syncBeforeNoteCommand(runtime);
+        const result = await readNoteContentForPatch(runtime.db, id);
+        const { content, ...rest } = result;
+        const payload = readOptions.includeContent
+            ? { ...rest, content, stale: commandStale(runtime) }
+            : { ...rest, stale: commandStale(runtime) };
+        printSuccess(payload);
+    });
+}
+export async function runNotePatch({ command, options, args }) {
+    const patchOptions = options;
+    const id = requireNoteId(args.id);
+    const operation = await selectPatchOperation(patchOptions);
+    const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    await withNoteDatabase(command, async (runtime) => {
+        const { db, config, offline } = runtime;
+        await syncBeforeNoteCommand(runtime);
+        if (patchOptions.dryRun) {
+            const plan = await planNoteContentPatch(db, { id, operation });
+            printDryRunPreview({
+                dry_run: true,
+                command: 'dino note patch',
+                action: 'patch_note_content',
+                risk: 'write',
+                summary: `Preview ${plan.operation} for note "${plan.title}" (${plan.noteId}); content ${plan.changed ? 'would change' : 'is unchanged'}.`,
+                warnings: [
+                    'Run `dino note content-read <id> --format json` before the real edit and pass the returned readToken as --read-token.',
+                    ...(offline ? ['Execution would run in offline mode and only use the local cache.'] : []),
+                    ...(!offline && !config.powersync.uploadBaseUrl
+                        ? ['Execution would be local-only because powersync.uploadBaseUrl is unset.']
+                        : []),
+                ],
+                inputs: {
+                    id,
+                    operation: plan.operation,
+                },
+                targets: [{ id: plan.noteId, title: plan.title, ...plan.target }],
+                changes: {
+                    before_hash: plan.beforeHash,
+                    after_hash: plan.afterHash,
+                    before_chars: plan.beforeContent.length,
+                    after_chars: plan.afterContent.length,
+                    changed: plan.changed,
+                },
+            });
+            return;
+        }
+        const readToken = patchOptions.readToken?.trim() ?? '';
+        if (!readToken) {
+            throw new DinoxError('Real note content edits require --read-token from `dino note content-read <id>`.');
+        }
+        const result = await applyNoteContentPatch(db, { id, readToken, operation });
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
+        const payload = {
+            ok: true,
+            ...result,
+            stale: commandStale(runtime),
+        };
+        if (structuredOutput) {
+            printSuccess(payload);
+            return;
+        }
+        printHumanReadableLine(result.saved ? 'Patched note content' : 'No changes');
+        printHumanReadableLine(`before_hash: ${result.beforeHash}`);
+        printHumanReadableLine(`after_hash: ${result.afterHash}`);
+        printStaleCacheWarning(runtime);
+    });
+}