@dinoxx/dinox-cli 1.1.1 → 2.0.0

package/dist/commands/skills/index.js

@@ -0,0 +1,468 @@
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { SKILLS_INSTALL_AGENTS, SKILLS_INSTALLER_NAME, SKILLS_INSTALLER_VERSION, } from '../../constants/links.js';
+import { RETIRED_SKILLS } from '../../skills/retired.js';
+import { DinoxError } from '../../utils/errors.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
+import { registerCommandGroup } from '../descriptor/register.js';
+import { FORMAT_OPTIONS } from '../schema/globalOptions.js';
+const MAX_CAPTURED_INSTALLER_OUTPUT_BYTES = 64 * 1024;
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function defaultLockFilePath() {
+    return path.join(homedir(), '.agents', '.skill-lock.json');
+}
+async function defaultReadLockFile(lockFilePath) {
+    return readFile(lockFilePath, 'utf8');
+}
+function absentScan(lockFilePath) {
+    const skills = RETIRED_SKILLS.map((skill) => ({
+        name: skill.name,
+        replacement: skill.replacement,
+        ...('replacementNote' in skill ? { replacementNote: skill.replacementNote } : {}),
+        status: 'absent',
+        expected: {
+            source: skill.source,
+            skillFolderHash: skill.skillFolderHash,
+        },
+        observed: null,
+        mismatches: [],
+    }));
+    return {
+        lockFile: lockFilePath,
+        lockFound: false,
+        lockVersion: null,
+        summary: {
+            total: skills.length,
+            absent: skills.length,
+            safeToRemove: 0,
+            conflict: 0,
+        },
+        skills,
+    };
+}
+function invalidLockError(lockFilePath, message, cause) {
+    return new DinoxError(`Invalid skills installer lock at ${lockFilePath}: ${message}`, {
+        code: 'SKILLS_LOCK_INVALID',
+        cause,
+        details: { lockFile: lockFilePath },
+        suggestion: 'Inspect the lock file without deleting it, then rerun `dino skills doctor --format json`.',
+        recoverable: true,
+    });
+}
+export async function scanRetiredSkillsLock(lockFilePath = defaultLockFilePath(), readLockFile = defaultReadLockFile) {
+    let raw;
+    try {
+        raw = await readLockFile(lockFilePath);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return absentScan(lockFilePath);
+        }
+        throw new DinoxError(`Failed to read skills installer lock at ${lockFilePath}`, {
+            code: 'SKILLS_LOCK_READ_FAILED',
+            cause: error,
+            details: { lockFile: lockFilePath },
+            suggestion: 'Check file permissions, then rerun `dino skills doctor --format json`.',
+            recoverable: true,
+        });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw invalidLockError(lockFilePath, 'file is not valid JSON', error);
+    }
+    if (!isRecord(parsed) || !isRecord(parsed.skills)) {
+        throw invalidLockError(lockFilePath, 'expected an object with a skills map');
+    }
+    const entries = parsed.skills;
+    const skills = RETIRED_SKILLS.map((skill) => {
+        if (!Object.prototype.hasOwnProperty.call(entries, skill.name)) {
+            return {
+                name: skill.name,
+                replacement: skill.replacement,
+                ...('replacementNote' in skill ? { replacementNote: skill.replacementNote } : {}),
+                status: 'absent',
+                expected: {
+                    source: skill.source,
+                    skillFolderHash: skill.skillFolderHash,
+                },
+                observed: null,
+                mismatches: [],
+            };
+        }
+        const rawEntry = entries[skill.name];
+        const entry = isRecord(rawEntry) ? rawEntry : {};
+        const observed = {
+            source: typeof entry.source === 'string' ? entry.source : null,
+            skillFolderHash: typeof entry.skillFolderHash === 'string' ? entry.skillFolderHash : null,
+        };
+        const mismatches = [];
+        if (observed.source !== skill.source)
+            mismatches.push('source');
+        if (observed.skillFolderHash !== skill.skillFolderHash)
+            mismatches.push('skillFolderHash');
+        return {
+            name: skill.name,
+            replacement: skill.replacement,
+            ...('replacementNote' in skill ? { replacementNote: skill.replacementNote } : {}),
+            status: mismatches.length === 0 ? 'safe-to-remove' : 'conflict',
+            expected: {
+                source: skill.source,
+                skillFolderHash: skill.skillFolderHash,
+            },
+            observed,
+            mismatches,
+        };
+    });
+    return {
+        lockFile: lockFilePath,
+        lockFound: true,
+        lockVersion: typeof parsed.version === 'number' ? parsed.version : null,
+        summary: {
+            total: skills.length,
+            absent: skills.filter((skill) => skill.status === 'absent').length,
+            safeToRemove: skills.filter((skill) => skill.status === 'safe-to-remove').length,
+            conflict: skills.filter((skill) => skill.status === 'conflict').length,
+        },
+        skills,
+    };
+}
+function appendBoundedOutput(current, chunk) {
+    const currentBytes = Buffer.byteLength(current, 'utf8');
+    if (currentBytes >= MAX_CAPTURED_INSTALLER_OUTPUT_BYTES)
+        return current;
+    const remaining = MAX_CAPTURED_INSTALLER_OUTPUT_BYTES - currentBytes;
+    return current + chunk.subarray(0, remaining).toString('utf8');
+}
+export function resolveSkillsRemoveInvocation(skillNames, platform = process.platform) {
+    const args = [
+        '--yes',
+        `${SKILLS_INSTALLER_NAME}@${SKILLS_INSTALLER_VERSION}`,
+        'remove',
+        '-g',
+        ...SKILLS_INSTALL_AGENTS.flatMap((agent) => ['-a', agent]),
+        '--skill',
+        ...skillNames,
+        '-y',
+    ];
+    const displayCommand = ['npx', ...args].join(' ');
+    if (platform === 'win32') {
+        return {
+            command: ['npx.cmd', ...args].join(' '),
+            args: [],
+            shell: true,
+            displayCommand,
+        };
+    }
+    return {
+        command: 'npx',
+        args,
+        shell: false,
+        displayCommand,
+    };
+}
+export function runSkillsRemoval(skillNames) {
+    const invocation = resolveSkillsRemoveInvocation(skillNames);
+    return new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
+        const child = spawn(invocation.command, invocation.args, {
+            shell: invocation.shell,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        child.stdout.on('data', (chunk) => {
+            stdout = appendBoundedOutput(stdout, chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr = appendBoundedOutput(stderr, chunk);
+        });
+        child.once('error', (error) => {
+            reject(new DinoxError(`Failed to start the skills installer: ${error.message}`, {
+                code: 'SKILLS_MIGRATION_FAILED',
+                cause: error,
+                details: {
+                    command: invocation.displayCommand,
+                },
+                suggestion: 'Verify that Node.js and npx are available, then rerun `dino skills migrate --confirm --format json`.',
+                recoverable: true,
+            }));
+        });
+        child.once('close', (exitCode) => {
+            resolve({ invocation, exitCode, stdout, stderr });
+        });
+    });
+}
+function resolveDependencies(overrides) {
+    return {
+        getLockFilePath: defaultLockFilePath,
+        readLockFile: defaultReadLockFile,
+        runRemoval: runSkillsRemoval,
+        ...overrides,
+    };
+}
+function replacementLabel(skill) {
+    if (skill.replacement)
+        return skill.replacement;
+    return skill.replacementNote ?? 'no direct replacement';
+}
+function printScan(scan) {
+    printHumanReadableLine(`skills lock: ${scan.lockFile} (${scan.lockFound ? 'found' : 'not found'})`);
+    for (const skill of scan.skills) {
+        if (skill.status === 'conflict') {
+            printHumanReadableLine(`${skill.name}: conflict; replacement: ${replacementLabel(skill)}; observed source=${skill.observed?.source ?? 'missing'} hash=${skill.observed?.skillFolderHash ?? 'missing'}`);
+            continue;
+        }
+        printHumanReadableLine(`${skill.name}: ${skill.status}; replacement: ${replacementLabel(skill)}`);
+    }
+    printHumanReadableLine(`summary: safe-to-remove=${scan.summary.safeToRemove} conflict=${scan.summary.conflict} absent=${scan.summary.absent}`);
+}
+function installerPayload(skillNames) {
+    return {
+        name: SKILLS_INSTALLER_NAME,
+        version: SKILLS_INSTALLER_VERSION,
+        scope: 'global',
+        agents: [...SKILLS_INSTALL_AGENTS],
+        command: skillNames.length > 0
+            ? resolveSkillsRemoveInvocation(skillNames).displayCommand
+            : null,
+    };
+}
+function safeSkillNames(scan) {
+    return scan.skills
+        .filter((skill) => skill.status === 'safe-to-remove')
+        .map((skill) => skill.name);
+}
+function conflictSkillNames(scan) {
+    return scan.skills
+        .filter((skill) => skill.status === 'conflict')
+        .map((skill) => skill.name);
+}
+function scanStatus(scan, name) {
+    return scan.skills.find((skill) => skill.name === name)?.status ?? null;
+}
+async function rescanForVerification(dependencies, lockFilePath) {
+    try {
+        return await scanRetiredSkillsLock(lockFilePath, dependencies.readLockFile);
+    }
+    catch (error) {
+        throw new DinoxError('Failed to verify the retired skills migration', {
+            code: 'SKILLS_MIGRATION_VERIFICATION_FAILED',
+            cause: error,
+            details: { lockFile: lockFilePath },
+            suggestion: 'Run `dino skills doctor --format json` and inspect the lock before retrying.',
+            recoverable: true,
+        });
+    }
+}
+export function createSkillsCommandGroup(overrides = {}) {
+    const dependencies = resolveDependencies(overrides);
+    return {
+        name: 'skills',
+        description: 'Inspect and safely migrate installed Dinox agent skills',
+        commands: [
+            {
+                name: 'doctor',
+                description: 'Inspect the skills installer lock for safely removable retired Dinox skills',
+                schema: {
+                    path: 'skills.doctor',
+                    risk: 'read',
+                    auth: 'none',
+                    globalOptions: FORMAT_OPTIONS,
+                    output: {
+                        type: 'structured',
+                        summary: 'Retired skill status from the global skills installer lock',
+                        fields: ['lockFile', 'lockFound', 'lockVersion', 'summary', 'skills'],
+                    },
+                    examples: ['dino skills doctor', 'dino skills doctor --format json'],
+                },
+                action: async (_context) => {
+                    const scan = await scanRetiredSkillsLock(dependencies.getLockFilePath(), dependencies.readLockFile);
+                    if (getRequestedStructuredOutputFormat()) {
+                        printSuccess(scan);
+                        return;
+                    }
+                    printScan(scan);
+                },
+            },
+            {
+                name: 'migrate',
+                description: 'Preview or confirm safe removal of retired Dinox skills',
+                options: [
+                    {
+                        flags: '--dry-run',
+                        description: 'Preview safe removals without changing installed skills (default)',
+                        type: 'boolean',
+                    },
+                    {
+                        flags: '--confirm',
+                        description: 'Execute the reviewed migration using the pinned public skills installer',
+                        type: 'boolean',
+                    },
+                ],
+                schema: {
+                    path: 'skills.migrate',
+                    risk: 'high-risk-write',
+                    auth: 'none',
+                    globalOptions: FORMAT_OPTIONS,
+                    output: {
+                        type: 'structured',
+                        summary: 'Retired skill migration plan or verified removal result',
+                        fields: [
+                            'mode',
+                            'confirmed',
+                            'installer',
+                            'before',
+                            'plannedRemoval',
+                            'conflicts',
+                            'removed',
+                            'after',
+                            'verified',
+                        ],
+                    },
+                    examples: [
+                        'dino skills migrate --dry-run --format json',
+                        'dino skills migrate --confirm --format json',
+                    ],
+                },
+                action: async (context) => {
+                    const explicitDryRun = Boolean(context.options.dryRun);
+                    const confirmed = Boolean(context.options.confirm);
+                    if (explicitDryRun && confirmed) {
+                        throw new DinoxError('--dry-run cannot be used together with --confirm', {
+                            code: 'USAGE_ERROR',
+                            suggestion: 'Run `dino skills migrate --dry-run --format json`, review the plan, then rerun with `--confirm`.',
+                            recoverable: true,
+                        });
+                    }
+                    const lockFilePath = dependencies.getLockFilePath();
+                    const before = await scanRetiredSkillsLock(lockFilePath, dependencies.readLockFile);
+                    const plannedRemoval = safeSkillNames(before);
+                    const conflicts = conflictSkillNames(before);
+                    const installer = installerPayload(plannedRemoval);
+                    if (!confirmed) {
+                        const payload = {
+                            mode: 'dry-run',
+                            confirmed: false,
+                            installer,
+                            before,
+                            plannedRemoval,
+                            conflicts,
+                            removed: [],
+                            after: null,
+                            verified: false,
+                        };
+                        if (getRequestedStructuredOutputFormat()) {
+                            printSuccess(payload);
+                            return;
+                        }
+                        printHumanReadableLine('mode: dry-run');
+                        printScan(before);
+                        printHumanReadableLine(`would remove: ${plannedRemoval.join(', ') || 'none'}`);
+                        printHumanReadableLine('no changes made; use --confirm only after reviewing this plan');
+                        return;
+                    }
+                    if (plannedRemoval.length === 0) {
+                        const after = await rescanForVerification(dependencies, lockFilePath);
+                        const payload = {
+                            mode: 'migrate',
+                            confirmed: true,
+                            installer,
+                            before,
+                            plannedRemoval,
+                            conflicts,
+                            removed: [],
+                            after,
+                            verified: true,
+                        };
+                        if (getRequestedStructuredOutputFormat()) {
+                            printSuccess(payload);
+                            return;
+                        }
+                        printHumanReadableLine('mode: migrate');
+                        printScan(after);
+                        printHumanReadableLine('removed: none');
+                        printHumanReadableLine('verified: yes');
+                        return;
+                    }
+                    const preExecution = await scanRetiredSkillsLock(lockFilePath, dependencies.readLockFile);
+                    const changedCandidates = plannedRemoval.filter((name) => scanStatus(preExecution, name) !== 'safe-to-remove');
+                    if (changedCandidates.length > 0) {
+                        throw new DinoxError('The skills installer lock changed before migration execution', {
+                            code: 'SKILLS_MIGRATION_PRECONDITION_FAILED',
+                            exitCode: 5,
+                            details: {
+                                lockFile: lockFilePath,
+                                changedCandidates,
+                                before,
+                                preExecution,
+                            },
+                            suggestion: 'Run `dino skills doctor --format json`, review the new status, then retry the migration.',
+                            recoverable: true,
+                        });
+                    }
+                    const execution = await dependencies.runRemoval(plannedRemoval);
+                    const after = await rescanForVerification(dependencies, lockFilePath);
+                    if (execution.exitCode !== 0) {
+                        throw new DinoxError(`The skills installer exited with code ${execution.exitCode ?? 'unknown'}`, {
+                            code: 'SKILLS_MIGRATION_FAILED',
+                            details: {
+                                command: execution.invocation.displayCommand,
+                                exitCode: execution.exitCode,
+                                ...(execution.stdout.trim() ? { stdout: execution.stdout.trim() } : {}),
+                                ...(execution.stderr.trim() ? { stderr: execution.stderr.trim() } : {}),
+                                after,
+                            },
+                            suggestion: 'Run `dino skills doctor --format json` before deciding whether to retry.',
+                            recoverable: true,
+                        });
+                    }
+                    const remainingCandidates = plannedRemoval.filter((name) => scanStatus(after, name) !== 'absent');
+                    const unexpectedlyRemovedConflicts = conflicts.filter((name) => scanStatus(after, name) === 'absent');
+                    if (remainingCandidates.length > 0 || unexpectedlyRemovedConflicts.length > 0) {
+                        throw new DinoxError('Retired skills migration verification failed', {
+                            code: 'SKILLS_MIGRATION_VERIFICATION_FAILED',
+                            details: {
+                                command: execution.invocation.displayCommand,
+                                remainingCandidates,
+                                unexpectedlyRemovedConflicts,
+                                before,
+                                after,
+                            },
+                            suggestion: 'Run `dino skills doctor --format json` and inspect every conflict before taking further action.',
+                            recoverable: true,
+                        });
+                    }
+                    const payload = {
+                        mode: 'migrate',
+                        confirmed: true,
+                        installer,
+                        before,
+                        plannedRemoval,
+                        conflicts,
+                        removed: [...plannedRemoval],
+                        after,
+                        verified: true,
+                    };
+                    if (getRequestedStructuredOutputFormat()) {
+                        printSuccess(payload);
+                        return;
+                    }
+                    printHumanReadableLine('mode: migrate');
+                    printHumanReadableLine(`removed: ${plannedRemoval.join(', ')}`);
+                    printHumanReadableLine(`conflicts preserved: ${conflicts.join(', ') || 'none'}`);
+                    printHumanReadableLine('verified: yes');
+                },
+            },
+        ],
+    };
+}
+export const skillsCommandGroup = createSkillsCommandGroup();
+export function registerSkillsCommands(program, overrides = {}) {
+    registerCommandGroup(program, createSkillsCommandGroup(overrides));
+}

package/dist/commands/storage/index.js

@@ -53,7 +53,7 @@ async function runStorageUpload(context) {
                 storageUrl: plan.storageUrl,
                 selectionSource: plan.selectionSource,
                 overwrite: options.overwrite === true,
-            }));
+            }), runtime);
             return;
         }
         const result = await uploadFileToStorage(db, {
@@ -117,7 +117,7 @@ async function runStorageTest(context) {
                 storageUrl: plan.storageUrl,
                 sizeBytes: plan.sizeBytes,
                 selectionSource: plan.selectionSource,
-            }));
+            }), runtime);
             return;
         }
         const result = await testStorageUpload(db, {

package/dist/commands/sync.js

@@ -42,7 +42,8 @@ export async function executeSyncCommand(context, overrides = {}) {
         config,
         offline: false,
         timeoutMs: remainingTimeoutMs(),
-        deadlineAtMs: operationDeadlineAtMs,
+        deadlineAtMs,
+        operationDeadlineAtMs,
         waitForInitialSync: false,
         expectedTokenFingerprint: config.auth.tokenFingerprint ?? null,
         cleanupFailureMode: 'throw',

package/dist/commands/tags/index.js

@@ -6,6 +6,7 @@ import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
 import { commandStale, printStaleCacheWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
+import { assertWriteConfirmationProvided, parseExpectedCount } from '../writeConfirmation.js';
 import { addTag, inspectAddTag, listTags } from './repo.js';
 import { getTagStats, getTagTree, inspectTagCleanup, mergeTag, moveTag, renameTag, suggestTagMerges, } from './operations.js';
 const TAG_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
@@ -67,7 +68,7 @@ async function runTagAdd(context) {
                     userId: identity.userId,
                     emoji,
                 })),
-            }));
+            }), runtime);
             return;
         }
         const result = await addTag(runtime.db, {
@@ -114,7 +115,7 @@ async function runTagRename(context) {
                 summary: `Rename tag "${result.fromPath}" to "${result.toPath}".`,
                 inputs: { path, new_name: newName },
                 changes: { updated_tags: result.updatedTags, updated_notes: result.updatedNotes },
-            }));
+            }), runtime);
             return;
         }
         await waitForMutationUpload(runtime);
@@ -139,7 +140,7 @@ async function runTagMove(context) {
                 summary: `Move tag "${result.fromPath}" to "${result.toPath}".`,
                 inputs: { path, to },
                 changes: { updated_tags: result.updatedTags, updated_notes: result.updatedNotes },
-            }));
+            }), runtime);
             return;
         }
         await waitForMutationUpload(runtime);
@@ -149,9 +150,17 @@ async function runTagMove(context) {
 async function runTagMerge(context) {
     const from = requireArg(context.args.from, 'Source tag path is required');
     const to = requireArg(context.args.to, 'Target tag path is required');
+    const dryRun = Boolean(context.options.dryRun);
+    const expectedCount = parseExpectedCount(context.options.expectedCount);
+    const writeOptions = {
+        dryRun,
+        confirm: Boolean(context.options.confirm),
+        expectedCount,
+    };
+    assertWriteConfirmationProvided('Tag merge', writeOptions);
     await withTagWriteRuntime(context, async ({ runtime, userId }) => {
-        const result = await mergeTag(runtime.db, { from, to, userId }, { dryRun: Boolean(context.options.dryRun) });
-        if (Boolean(context.options.dryRun)) {
+        const result = await mergeTag(runtime.db, { from, to, userId }, writeOptions);
+        if (dryRun) {
             printDryRunPreview(buildTagMutationDryRunPreview({
                 config: runtime.config,
                 offline: runtime.offline,
@@ -159,12 +168,15 @@ async function runTagMerge(context) {
                 action: 'merge_tag',
                 risk: 'high-risk-write',
                 summary: `Merge tag subtree "${result.fromPath}" into "${result.toPath}".`,
-                inputs: { from, to },
+                inputs: { from, to, expected_count: expectedCount },
                 changes: {
+                    affected_count: result.affectedCount,
+                    soft_deleted_tag_count: result.softDeletedTagIds.length,
+                    updated_note_count: result.updatedNotes.length,
                     soft_deleted_tag_ids: result.softDeletedTagIds,
                     updated_notes: result.updatedNotes,
                 },
-            }));
+            }), runtime);
             return;
         }
         await waitForMutationUpload(runtime);
@@ -193,7 +205,7 @@ async function runTagCleanup(context) {
                 summary: `Inspect tag cleanup candidates (${result.issues.length} issues).`,
                 inputs: {},
                 targets: result.issues,
-            }));
+            }), runtime);
             return;
         }
         printSuccess({ stale: commandStale(runtime), ...result });
@@ -328,7 +340,11 @@ export const tagCommandGroup = {
                 { syntax: '<from>', description: 'Source tag path' },
                 { syntax: '<to>', description: 'Target tag path' },
             ],
-            options: [{ flags: '--dry-run', description: 'Preview the write without executing it' }],
+            options: [
+                { flags: '--expected-count <n>', description: 'Required for real writes; must equal source tags plus notes affected', type: 'number' },
+                { flags: '--confirm', description: 'Required for real writes after reviewing a dry run', type: 'boolean' },
+                { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
+            ],
             schema: {
                 path: 'tag.merge',
                 risk: 'high-risk-write',
@@ -337,9 +353,12 @@ export const tagCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Tag merge result',
-                    fields: ['fromId', 'toId', 'fromPath', 'toPath', 'softDeletedTagIds', 'updatedNotes', 'stale'],
+                    fields: ['fromId', 'toId', 'fromPath', 'toPath', 'softDeletedTagIds', 'updatedNotes', 'affectedCount', 'stale'],
                 },
-                examples: ['dino tag merge "ai" "AI" --format json --dry-run'],
+                examples: [
+                    'dino tag merge "ai" "AI" --format json --dry-run',
+                    'dino tag merge "ai" "AI" --expected-count 4 --confirm --format json',
+                ],
             },
             action: runTagMerge,
         },

package/dist/commands/tags/operations.d.ts

@@ -1,4 +1,5 @@
 import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type ConfirmedWriteOptions } from '../writeConfirmation.js';
 import type { TagListItem } from './model.js';
 export type TagTreeNode = TagListItem & {
     isActual: boolean;
@@ -63,6 +64,7 @@ export type TagMergeResult = {
         before: string[];
         after: string[];
     }>;
+    affectedCount: number;
 };
 export type TagSuggestResult = {
     suggestions: Array<{
@@ -98,8 +100,6 @@ export declare function renameTag(db: AbstractPowerSyncDatabase, input: TagRenam
 export declare function moveTag(db: AbstractPowerSyncDatabase, input: TagMoveInput, options?: {
     dryRun?: boolean;
 }): Promise<TagRenameMoveResult>;
-export declare function mergeTag(db: AbstractPowerSyncDatabase, input: TagMergeInput, options?: {
-    dryRun?: boolean;
-}): Promise<TagMergeResult>;
+export declare function mergeTag(db: AbstractPowerSyncDatabase, input: TagMergeInput, options?: ConfirmedWriteOptions): Promise<TagMergeResult>;
 export declare function inspectTagCleanup(db: AbstractPowerSyncDatabase, input?: TagReadInput): Promise<TagCleanupResult>;
 export declare function suggestTagMerges(db: AbstractPowerSyncDatabase, input?: TagReadInput): Promise<TagSuggestResult>;