@dinoxx/dinox-cli 1.1.0 → 2.0.0

package/dist/skills/retired.d.ts

@@ -0,0 +1,60 @@
+import { SKILLS_REPO_SLUG } from '../constants/links.js';
+export type RetiredSkill = Readonly<{
+    name: string;
+    replacement: string | null;
+    replacementNote?: string;
+    source: typeof SKILLS_REPO_SLUG;
+    skillFolderHash: string;
+}>;
+export type RetiredSkillsCleanupGuidance = Readonly<{
+    automaticRemoval: false;
+    inventoryCommand: string;
+    lockFile: string;
+    requiredMatchFields: readonly ['name', 'source', 'skillFolderHash'];
+    guidance: string;
+}>;
+export declare const RETIRED_SKILLS: readonly (Readonly<{
+    name: "create-note";
+    replacement: "dino-note";
+    source: "ryzencool/dinox-cli-skills";
+    skillFolderHash: "15a91b77e5032e614cbec95997de0f9697cee29c";
+}> | Readonly<{
+    name: "dinox";
+    replacement: "dino-dinox";
+    source: "ryzencool/dinox-cli-skills";
+    skillFolderHash: "3089a4b076fffd8d6579db26c520f0d97e225a30";
+}> | Readonly<{
+    name: "manage-boxes";
+    replacement: "dino-manage-boxes";
+    source: "ryzencool/dinox-cli-skills";
+    skillFolderHash: "49ffa648ab341bef20a9ea4696973d39c5c4e1c9";
+}> | Readonly<{
+    name: "manage-tags";
+    replacement: "dino-manage-tags";
+    source: "ryzencool/dinox-cli-skills";
+    skillFolderHash: "801f6cc91d225503ad67054f66ac024cb12d01cb";
+}> | Readonly<{
+    name: "search-notes";
+    replacement: "dino-note";
+    source: "ryzencool/dinox-cli-skills";
+    skillFolderHash: "88d3a95a3cb663b555e79be57d2135c0edbe8e0d";
+}> | Readonly<{
+    name: "view-note";
+    replacement: "dino-note";
+    source: "ryzencool/dinox-cli-skills";
+    skillFolderHash: "639ce5941e19d4f5ffc3a4b5870486e741ab2937";
+}> | Readonly<{
+    name: "dino-shared";
+    replacement: null;
+    replacementNote: "Runtime guidance is embedded in every current Dinox skill.";
+    source: "ryzencool/dinox-cli-skills";
+    skillFolderHash: "842fe8fd30020bf1b58718dcd438d78b4c7d8f33";
+}>)[];
+export declare const RETIRED_SKILLS_CLEANUP: Readonly<{
+    automaticRemoval: false;
+    inventoryCommand: string;
+    lockFile: string;
+    requiredMatchFields: readonly ["name", "source", "skillFolderHash"];
+    guidance: string;
+}>;
+export declare function formatRetiredSkillsSummary(): string;

package/dist/skills/retired.js

@@ -0,0 +1,58 @@
+import { SKILLS_INSTALLER_NAME, SKILLS_INSTALLER_VERSION, SKILLS_REPO_SLUG, } from '../constants/links.js';
+export const RETIRED_SKILLS = Object.freeze([
+    Object.freeze({
+        name: 'create-note',
+        replacement: 'dino-note',
+        source: SKILLS_REPO_SLUG,
+        skillFolderHash: '15a91b77e5032e614cbec95997de0f9697cee29c',
+    }),
+    Object.freeze({
+        name: 'dinox',
+        replacement: 'dino-dinox',
+        source: SKILLS_REPO_SLUG,
+        skillFolderHash: '3089a4b076fffd8d6579db26c520f0d97e225a30',
+    }),
+    Object.freeze({
+        name: 'manage-boxes',
+        replacement: 'dino-manage-boxes',
+        source: SKILLS_REPO_SLUG,
+        skillFolderHash: '49ffa648ab341bef20a9ea4696973d39c5c4e1c9',
+    }),
+    Object.freeze({
+        name: 'manage-tags',
+        replacement: 'dino-manage-tags',
+        source: SKILLS_REPO_SLUG,
+        skillFolderHash: '801f6cc91d225503ad67054f66ac024cb12d01cb',
+    }),
+    Object.freeze({
+        name: 'search-notes',
+        replacement: 'dino-note',
+        source: SKILLS_REPO_SLUG,
+        skillFolderHash: '88d3a95a3cb663b555e79be57d2135c0edbe8e0d',
+    }),
+    Object.freeze({
+        name: 'view-note',
+        replacement: 'dino-note',
+        source: SKILLS_REPO_SLUG,
+        skillFolderHash: '639ce5941e19d4f5ffc3a4b5870486e741ab2937',
+    }),
+    Object.freeze({
+        name: 'dino-shared',
+        replacement: null,
+        replacementNote: 'Runtime guidance is embedded in every current Dinox skill.',
+        source: SKILLS_REPO_SLUG,
+        skillFolderHash: '842fe8fd30020bf1b58718dcd438d78b4c7d8f33',
+    }),
+]);
+export const RETIRED_SKILLS_CLEANUP = Object.freeze({
+    automaticRemoval: false,
+    inventoryCommand: `npx --yes ${SKILLS_INSTALLER_NAME}@${SKILLS_INSTALLER_VERSION} list -g --json`,
+    lockFile: '~/.agents/.skill-lock.json',
+    requiredMatchFields: Object.freeze(['name', 'source', 'skillFolderHash']),
+    guidance: 'Use the inventory command to find candidates, then inspect the installer lock. Remove an installed skill only when its name, source, and skillFolderHash all match this official retired inventory. Never delete a skill directory or lock entry by name alone because unrelated skills can share an ID.',
+});
+export function formatRetiredSkillsSummary() {
+    return RETIRED_SKILLS.map((skill) => (skill.replacement
+        ? `${skill.name} -> ${skill.replacement}`
+        : `${skill.name} -> no direct replacement (${skill.replacementNote})`)).join('; ');
+}

package/dist/utils/deadline.d.ts

@@ -0,0 +1,8 @@
+export type DeadlineOptions = {
+    deadlineAtMs?: number;
+    maximumTimeoutMs: number;
+    createTimeoutError: () => Error;
+    runWhenExpired?: boolean;
+};
+export declare function remainingDeadlineMs(deadlineAtMs: number | undefined, maximumTimeoutMs: number, now?: () => number): number;
+export declare function runWithinDeadline<T>(run: () => Promise<T>, options: DeadlineOptions): Promise<T>;

package/dist/utils/deadline.js

@@ -0,0 +1,31 @@
+export function remainingDeadlineMs(deadlineAtMs, maximumTimeoutMs, now = Date.now) {
+    const maximum = Number.isFinite(maximumTimeoutMs)
+        ? Math.max(0, Math.floor(maximumTimeoutMs))
+        : 0;
+    if (deadlineAtMs === undefined) {
+        return maximum;
+    }
+    return Math.max(0, Math.min(maximum, Math.floor(deadlineAtMs - now())));
+}
+export async function runWithinDeadline(run, options) {
+    if (options.deadlineAtMs === undefined) {
+        return run();
+    }
+    const remainingMs = remainingDeadlineMs(options.deadlineAtMs, options.maximumTimeoutMs);
+    if (remainingMs <= 0 && !options.runWhenExpired) {
+        throw options.createTimeoutError();
+    }
+    const operation = Promise.resolve().then(run);
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(options.createTimeoutError()), Math.max(1, remainingMs));
+    });
+    try {
+        return await Promise.race([operation, timeout]);
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}

package/dist/utils/dryRun.d.ts

@@ -8,6 +8,25 @@ export type DryRunPreview = {
     inputs?: Record<string, unknown>;
     targets?: Array<Record<string, unknown>>;
     changes?: Record<string, unknown> | Array<Record<string, unknown>>;
+    stale?: boolean;
+    sync?: {
+        offline: boolean;
+        gate: {
+            ok: boolean;
+            reasons: string[];
+        } | null;
+    };
 };
+export type DryRunExecutionState = {
+    offline: boolean;
+    stale: boolean;
+    sync?: {
+        gate?: {
+            ok: boolean;
+            reasons: string[];
+        } | null;
+    };
+};
+export declare function attachDryRunExecutionState(preview: DryRunPreview, state: DryRunExecutionState): DryRunPreview;
 export declare function formatDryRunPreview(preview: DryRunPreview): string;
-export declare function printDryRunPreview(preview: DryRunPreview): void;
+export declare function printDryRunPreview(preview: DryRunPreview, state?: DryRunExecutionState): void;

package/dist/utils/dryRun.js

@@ -1,4 +1,14 @@
 import { getRequestedStructuredOutputFormat, printHumanReadableBlock, printSuccess, } from './output.js';
+export function attachDryRunExecutionState(preview, state) {
+    return {
+        ...preview,
+        stale: state.offline || state.stale,
+        sync: {
+            offline: state.offline,
+            gate: state.sync?.gate ?? null,
+        },
+    };
+}
 function formatValue(value) {
     if (value === null || value === undefined) {
         return String(value);
@@ -36,6 +46,14 @@ export function formatDryRunPreview(preview) {
         `Risk: ${preview.risk}`,
         `Summary: ${preview.summary}`,
     ];
+    if (typeof preview.stale === 'boolean') {
+        lines.push(`Freshness: ${preview.stale ? 'stale' : 'fresh'}`);
+    }
+    if (preview.sync) {
+        const gate = preview.sync.gate;
+        const gateSummary = gate ? (gate.ok ? 'ok' : `blocked (${gate.reasons.join(', ')})`) : 'not evaluated';
+        lines.push(`Sync: ${preview.sync.offline ? 'offline' : 'online'}; gate ${gateSummary}`);
+    }
     if (preview.warnings && preview.warnings.length > 0) {
         lines.push('');
         lines.push('Warnings:');
@@ -60,10 +78,11 @@ export function formatDryRunPreview(preview) {
     }
     return `${lines.join('\n')}\n`;
 }
-export function printDryRunPreview(preview) {
+export function printDryRunPreview(preview, state) {
+    const output = state ? attachDryRunExecutionState(preview, state) : preview;
     if (getRequestedStructuredOutputFormat()) {
-        printSuccess(preview);
+        printSuccess(output);
         return;
     }
-    printHumanReadableBlock(formatDryRunPreview(preview));
+    printHumanReadableBlock(formatDryRunPreview(output));
 }

package/dist/utils/errors.d.ts

@@ -6,6 +6,7 @@ export type DinoxErrorOptions = {
     suggestion?: string;
     suggestedAction?: SuggestedAction;
     recoverable?: boolean;
+    requiresProcessExit?: boolean;
 };
 export type SuggestedAction = {
     command: string;
@@ -34,6 +35,7 @@ export declare class DinoxError extends Error {
     readonly suggestion?: string;
     readonly suggestedAction?: SuggestedAction;
     readonly recoverable: boolean;
+    readonly requiresProcessExit: boolean;
     constructor(message: string, options?: DinoxErrorOptions);
 }
 export declare function isDinoxError(error: unknown): error is DinoxError;

package/dist/utils/errors.js

@@ -5,6 +5,7 @@ export class DinoxError extends Error {
     suggestion;
     suggestedAction;
     recoverable;
+    requiresProcessExit;
     constructor(message, options) {
         super(message);
         const code = normalizeErrorCode(options?.code ?? inferDinoxErrorCode(message));
@@ -18,6 +19,7 @@ export class DinoxError extends Error {
             ?? suggestedActionFromSuggestion(suggestion)
             ?? defaultSuggestedActionForCode(code, message);
         this.recoverable = options?.recoverable ?? true;
+        this.requiresProcessExit = options?.requiresProcessExit ?? false;
         if (options?.cause !== undefined) {
             // Node 16+ supports Error.cause.
             this.cause = options.cause;
@@ -147,7 +149,7 @@ function defaultSuggestionForCode(code) {
             return 'Run `dino auth status --format json`; if auth is missing, set DINOX_TOKEN or pipe a token to `dino auth login --token-stdin` in your own terminal.';
         case 'SYNC_REQUIRED':
         case 'SYNC_STALE':
-            return 'Run `dino sync --strict --sync-timeout 600000 --format json`, then retry the command.';
+            return 'Run `dino sync --strict --sync-timeout 20000 --format json`, then retry the command.';
         case 'UPLOAD_PENDING':
             return 'Run `dino doctor --fix --format json` to wait for pending uploads and inspect sync health.';
         case 'DAEMON_STALE':
@@ -163,7 +165,7 @@ function defaultSuggestionForCode(code) {
                 return 'Run `dino auth status --format json`; if auth is missing, set DINOX_TOKEN or pipe a token to `dino auth login --token-stdin` in your own terminal.';
             }
             if (normalized.startsWith('SYNC_')) {
-                return 'Run `dino sync --strict --sync-timeout 600000 --format json`, then retry the command.';
+                return 'Run `dino sync --strict --sync-timeout 20000 --format json`, then retry the command.';
             }
             if (normalized.startsWith('DAEMON_')) {
                 return 'Run `dino doctor --fix --format json` to restart a stale daemon and inspect local health.';
@@ -196,7 +198,7 @@ function defaultSuggestedActionForCode(code, message) {
     }
     if (normalized === 'SYNC_REQUIRED' || normalized === 'SYNC_STALE' || normalized.startsWith('SYNC_')) {
         return {
-            command: 'dino sync --strict --sync-timeout 600000 --format json',
+            command: 'dino sync --strict --sync-timeout 20000 --format json',
             reason: 'Refresh the local PowerSync cache and prove freshness before retrying the read.',
         };
     }

package/dist/utils/processExit.d.ts

@@ -0,0 +1 @@
+export declare function exitProcessAfterFlushing(exitCode: number, flushTimeoutMs?: number): Promise<never>;

package/dist/utils/processExit.js

@@ -0,0 +1,33 @@
+const DEFAULT_FLUSH_TIMEOUT_MS = 100;
+async function flushWritable(stream, timeoutMs) {
+    if (stream.destroyed || stream.writableEnded || !stream.writable) {
+        return;
+    }
+    await new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(finish, timeoutMs);
+        try {
+            stream.write('', finish);
+        }
+        catch {
+            finish();
+        }
+    });
+}
+export async function exitProcessAfterFlushing(exitCode, flushTimeoutMs = DEFAULT_FLUSH_TIMEOUT_MS) {
+    const timeoutMs = Number.isFinite(flushTimeoutMs)
+        ? Math.max(1, Math.floor(flushTimeoutMs))
+        : DEFAULT_FLUSH_TIMEOUT_MS;
+    await Promise.all([
+        flushWritable(process.stdout, timeoutMs),
+        flushWritable(process.stderr, timeoutMs),
+    ]);
+    process.exit(exitCode);
+}

package/dist/utils/updateNotice.d.ts

@@ -4,4 +4,5 @@ export type UpdateNotice = {
     message: string;
 };
 export declare function isVersionNewer(candidate: string, current: string): boolean;
+export declare function fetchLatestPublishedVersion(fetchImpl?: typeof fetch): Promise<string | null>;
 export declare function getUpdateNotice(currentVersion: string, fetchImpl?: typeof fetch): Promise<UpdateNotice | null>;

package/dist/utils/updateNotice.js

@@ -26,7 +26,7 @@ export function isVersionNewer(candidate, current) {
     }
     return false;
 }
-async function fetchLatestPublishedVersion(fetchImpl = fetch) {
+export async function fetchLatestPublishedVersion(fetchImpl = fetch) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 1500);
     try {

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {
     "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json && node scripts/add-shebang.mjs",
     "dev": "tsx src/dinox.ts",
-    "prepublishOnly": "pnpm run build",
+    "prepublishOnly": "pnpm run skills:check && pnpm run build",
     "publish:npm": "sh ./publish-npm.sh --no-bump",
-    "publish:npm:dry-run": "sh ./publish-npm.sh --dry-run",
+    "publish:npm:dry-run": "sh ./publish-npm.sh --dry-run --no-bump",
     "skills:check": "tsx scripts/check-skills.ts",
+    "skills:eval:triggers": "tsx scripts/evaluate-skill-triggers.ts",
     "skills:sync:standalone": "tsx scripts/sync-standalone-skills-repo.ts",
+    "skills:sync:standalone:check": "tsx scripts/sync-standalone-skills-repo.ts --check",
+    "skills:sync:standalone:dry-run": "tsx scripts/sync-standalone-skills-repo.ts --dry-run",
     "skills:sync": "tsx scripts/sync-skills-reference.ts",
+    "schema:sync:electron": "tsx scripts/sync-electron-powersync-schema.ts",
+    "schema:sync:electron:check": "tsx scripts/sync-electron-powersync-schema.ts --check",
     "start": "node dist/dinox.js",
     "test": "node scripts/run-tests.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json"
@@ -36,8 +41,8 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1021.0",
     "@node-rs/jieba": "^2.0.1",
-    "@powersync/common": "^1.57.0",
-    "@powersync/node": "^0.19.2",
+    "@powersync/common": "^2.3.1",
+    "@powersync/node": "^1.1.1",
     "@tiptap/core": "^3.20.0",
     "@tiptap/extension-blockquote": "^3.20.0",
     "@tiptap/extension-bold": "^3.20.0",