@wirecat/cli-core 0.428.0 → 0.429.0

package/CHANGELOG.md

@@ -7,6 +7,17 @@ shape of this file.
 
 ## Unreleased
 
+## 0.429.0 — 25.10.2026
+
+### Added
+
+- **`@wirecat/cli-core/cli/start` gives a bin `startCli` without the rest of `./cli`**, and **a bare `--version` or `-V` is answered before the program loads**. Importing `./cli` for `startCli` loaded about 1,000 files before the program even ran; `./cli/start` loads about 50 (`check:dist` keeps it under 80). The version is `app.version` and a newline on stdout, exit 0 — what Commander printed. Nothing else runs for it: no SQLite swap, no crash handler, and no notice a tool's `run` prints. `--version` with any other word (`--version --json`, `personal --version`) goes through the program as before. `startCli` and `run()` load the first-run questions, the store and the consent prompt only when a command asks them: the program module alone now loads about 320 files, not 850 (the `./cli` barrel a CLI imports still loads them all).
+- **`store reset --dry-run` lists what a reset would empty and deletes nothing**: the store's files, their bytes,
+  every data table with its row count (search indexes are left out: they are rebuilt from those tables), whether a
+  backup comes first, and `in_use` — whether a serve or another process has the file open now, which the real reset
+  refuses (`null` where the system cannot say). It reads without a write lock, so it answers while a sync runs, and
+  it runs under `<PREFIX>_READ_ONLY`. A desktop app shows the list in its confirmation dialog.
+
 ## 0.428.0 — 25.10.2026
 
 ### Changed — may break callers

package/dist/cli/entry.d.ts

@@ -2,6 +2,7 @@ import { type ChildProcess, type SpawnOptions } from "node:child_process";
 import type { ErrorReason } from "@wirecat/cli-base/standards";
 import type { Command } from "commander";
 import { type AppIdentity } from "../ports/app.js";
+export type { AppIdentity };
 /** What `startCli` hands the CLI's own program: the process, wired once. */
 export interface EntryContext {
     /** `process.argv` without the runtime and the script. */

package/dist/cli/entry.js

@@ -1,10 +1,8 @@
 import { spawn } from "node:child_process";
 import { CliError, catchCrashes } from "@wirecat/cli-base";
-import { readOnlyLockOf } from "../ports/app.js";
+import { envName, readOnlyLockOf } from "../ports/app.js";
 import { ensureSqlite } from "../sqlite-runtime.js";
-import { readSecret } from "../terminal/prompt.js";
-import { commandPathOf } from "./command-contract.js";
-import { setupAtStart } from "./first-run.js";
+import { logVersion } from "./argv-log.js";
 const processIo = () => ({
     argv: process.argv,
     env: process.env,
@@ -26,6 +24,8 @@ const processIo = () => ({
 export const startCli = async (entry) => {
     const io = { ...processIo(), ...entry.io };
     const args = io.argv.slice(2);
+    if (args.length === 1 && (args[0] === "--version" || args[0] === "-V"))
+        return printVersion(entry.app, io);
     const tty = io.stdout.isTTY === true;
     const release = catchCrashes({
         cli: entry.app.command,
@@ -62,6 +62,10 @@ export const startCli = async (entry) => {
             // The first-run questions write the shared config; a dry run writes nothing.
             if (command.optsWithGlobals().dryRun === true)
                 return;
+            const [{ setupAtStart }, { commandPathOf }] = await Promise.all([
+                import("./first-run.js"),
+                import("./command-contract.js"),
+            ]);
             await setupAtStart({
                 command: entry.app.command,
                 env: io.env,
@@ -75,6 +79,7 @@ export const startCli = async (entry) => {
         ask: async (question, command) => {
             if (headless(command) || io.stdin.isTTY !== true)
                 return false;
+            const { readSecret } = await import("../terminal/prompt.js");
             const answer = await readSecret(`${question} [y/N] `, {
                 input: io.stdin,
                 output: io.stderr,
@@ -112,6 +117,16 @@ export const startCli = async (entry) => {
     else if (code !== undefined)
         io.setExitCode(code);
 };
+/**
+ * Answered before the program loads, which is most of a start: an agent asks for the version to learn whether the
+ * tool is there at all. Only the bare flag — anything else on the line goes through the program as before.
+ */
+const printVersion = (app, io) => {
+    const argvLog = io.env[envName(app, "TEST_ARGV_LOG")];
+    if (argvLog)
+        logVersion(argvLog);
+    io.stdout.write(`${app.version}\n`);
+};
 /** Help and the version were printed already; help for a missing command is a usage mistake, as in `run()`. */
 const commanderExit = (error) => {
     if (!(error instanceof Error))

package/dist/cli/first-run.js

@@ -4,13 +4,8 @@ import { delimiter, join } from "node:path";
 import { installerOf, updateCommand } from "@wirecat/cli-base/update";
 import { LANGUAGES } from "../search/languages.js";
 import { DEFAULT_STEMMERS } from "../search/stem.js";
-import { openCache } from "../store/open.js";
 import { storePath } from "../store/path.js";
 import { sharedConfigPath } from "../store/shared-config.js";
-import { openStore } from "../store/store.js";
-import { readSecret } from "../terminal/prompt.js";
-import { WIRECAT_TOOLS } from "./help/first-screen.js";
-import { buildStems } from "./messenger/store-maintenance-command.js";
 import { QUESTIONS, readSetupAnswers, unanswered, writeSetupAnswers, } from "./setup-answers.js";
 /** Commands that run without first-run questions: they serve agents, help, or open the store themselves. */
 const SKIPPED = new Set(["help", "guide", "completion", "mcp", "serve", "server", "update", "store"]);
@@ -86,6 +81,8 @@ const suggested = (env, contentLanguages) => {
     return (own.length ? own : LANGUAGES.filter(({ code }) => code === "en" || code === system)).map(({ name }) => name);
 };
 const askLanguages = async ({ command, env, io, contentLanguages }) => {
+    // The store and its maintenance are most of cli-core; every command runs this file, few ever ask.
+    const { openStore } = await import("../store/store.js");
     const store = await openStore({ env });
     let rebuild = false;
     try {
@@ -117,6 +114,10 @@ const askLanguages = async ({ command, env, io, contentLanguages }) => {
     }
     if (!rebuild)
         return;
+    const [{ openCache }, { buildStems }] = await Promise.all([
+        import("../store/open.js"),
+        import("./messenger/store-maintenance-command.js"),
+    ]);
     const database = await openCache(storePath(env));
     try {
         buildStems(database, (note) => io.say(`  ${note}`), { force: true });
@@ -128,6 +129,7 @@ const askLanguages = async ({ command, env, io, contentLanguages }) => {
 const askTools = async (run) => {
     const { command, env, io } = run;
     const installed = run.installed ?? ((name) => onPath(name, env));
+    const { WIRECAT_TOOLS } = await import("./help/first-screen.js");
     const others = WIRECAT_TOOLS.filter((tool) => tool.command !== command);
     const missing = others.filter((tool) => !installed(tool.command));
     io.say("Other WireCat tools — they share this store, so one search finds everything:");
@@ -213,7 +215,7 @@ export const setupAtStart = async (start) => {
         contentLanguages: start.contentLanguages,
         all: start.path[0] === "setup",
         io: {
-            ask: (prompt) => readSecret(prompt, { input, echo: true }),
+            ask: async (prompt) => (await import("../terminal/prompt.js")).readSecret(prompt, { input, echo: true }),
             say: (text) => process.stderr.write(`${text}\n`),
         },
     }).catch((error) => {

package/dist/cli/messenger/store-maintenance-command.js

@@ -12,7 +12,7 @@ import { migrate } from "../../store/migrations.js";
 import { openCache } from "../../store/open.js";
 import { storePath } from "../../store/path.js";
 import { deleteCopy, repairStore } from "../../store/repair.js";
-import { drainNoteIndex, fillSearchIndex, fillStems, involvementStoreOver, noteIndexState, openStore, orphanPointers, pendingNormalization, resetAttachmentWords, resetNoteIndex, resetSearchIndex, resetStems, searchIndexState, stemmerCache, stemsState, } from "../../store/store.js";
+import { drainNoteIndex, fillSearchIndex, fillStems, involvementStoreOver, noteIndexState, openSqlite, openStore, orphanPointers, pendingNormalization, resetAttachmentWords, resetNoteIndex, resetSearchIndex, resetStems, searchIndexState, stemmerCache, stemsState, } from "../../store/store.js";
 import { environmentOf, outputFor } from "../context.js";
 import { destroysNothing, LOCAL_READ, LOCAL_WRITE } from "../effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "../envelope.js";
@@ -45,6 +45,16 @@ const reading = async (path, read) => {
         database.close();
     }
 };
+/** For a command that only reads: the connection refuses writes, and opening sets no journal mode. */
+const readingOnly = async (path, read) => {
+    const { database } = await openSqlite(path, { readOnly: true });
+    try {
+        return read(database);
+    }
+    finally {
+        database.close();
+    }
+};
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export const storeSummary = async (env) => {
     const path = storePath(env);
@@ -630,22 +640,30 @@ const quiesce = async (path, messenger, then, warn, waitMs = STORE_LOCK_WAIT_MS)
     }
 };
 /**
- * For a store this build cannot migrate: a backup beside it, then an empty store at this build's
- * schema. The backup is made before anything is deleted, and its path is said before the delete.
+ * For a store this build cannot migrate, or one the owner wants empty: a backup beside it, then an empty
+ * store at this build's schema. The backup is made before anything is deleted, and its path is said before
+ * the delete. A new file rather than `DELETE FROM` every table: deleted rows would stay readable in free
+ * pages until a VACUUM, and every table comes back in this build's shape.
  */
 const resetCommand = (messenger) => annotate(new Command("reset"), { output: { entity: "store_reset" }, effects: LOCAL_WRITE })
     .summary("back up the local archive and replace it with an empty one")
     .description("back the store up beside itself, then delete it and start an empty one at this build's schema; asks first, or --yes")
     .option("--no-backup", "delete the store without backing it up first")
-    .action(async function ({ backup: keep }) {
+    .option("--dry-run", "list every table it would empty, with its rows, and delete nothing")
+    .action(async function ({ backup: keep, dryRun }) {
     const { renderer } = outputFor(this);
     const { command } = messenger.app;
-    const path = storePath(environmentOf(this).env ?? process.env);
+    const env = environmentOf(this).env ?? process.env;
+    const path = storePath(env);
     if (!existsSync(path)) {
         result(this, { path, exists: false, reset: false });
         renderer.note(`no store at ${path} — nothing to reset; the first \`${command}\` command that reads a chat creates it`);
         return;
     }
+    if (dryRun) {
+        result(this, await resetPreview(path, messenger, env, keep));
+        return;
+    }
     refuseWhileServing(this, messenger);
     if (this.optsWithGlobals().yes !== true) {
         const what = `this deletes the store at ${path} and starts an empty one, ${keep ? "after a backup beside it" : "with no backup"}`;
@@ -674,7 +692,7 @@ const resetCommand = (messenger) => annotate(new Command("reset"), { output: { e
         });
         renderer.note(`backed the store up to ${backup}`);
     }
-    for (const suffix of ["", "-wal", "-shm"])
+    for (const suffix of STORE_PARTS)
         rmSync(`${path}${suffix}`, { force: true });
     await (await openStore({ path, command })).close();
     const schema = await reading(path, (database) => schemaOf(database).version);
@@ -683,5 +701,43 @@ const resetCommand = (messenger) => annotate(new Command("reset"), { output: { e
         ? `the store is empty at schema ${schema}; \`${command} store restore ${backup}\` puts the old one back once a build can read it`
         : `the store is empty at schema ${schema}; there is no backup`);
 });
+const STORE_PARTS = ["", "-wal", "-shm"];
+/**
+ * What a reset would delete, read without a write lock so it answers while a sync runs. `in_use` is what the
+ * real run would refuse over now; `null` where this system cannot say who has the file open.
+ */
+const resetPreview = async (path, messenger, env, keep) => {
+    const files = STORE_PARTS.map((suffix) => `${path}${suffix}`).filter((file) => existsSync(file));
+    const holders = holdersOf(files.map((file) => realpathSync(file)));
+    const serving = servingProfiles(messenger.app, env).length > 0;
+    const read = await readingOnly(path, (database) => ({
+        schema: schemaOf(database).version,
+        tables: emptiedTables(database),
+    }));
+    return {
+        path,
+        exists: true,
+        reset: false,
+        dryRun: true,
+        files,
+        bytes: files.reduce((sum, file) => sum + bytesOf(file), 0),
+        schema: read.schema,
+        tables: read.tables,
+        backupFirst: keep,
+        inUse: serving || (holders === undefined ? null : holders.length > 0),
+    };
+};
+/** The tables that hold data; a search index and its shadow tables are rebuilt from them, so they are left out. */
+const emptiedTables = (database) => {
+    const all = database
+        .prepare("SELECT name, sql FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
+        .all()
+        .map((row) => ({ name: String(row.name), virtual: /^\s*CREATE\s+VIRTUAL/i.test(String(row.sql)) }));
+    const indexes = all.filter((table) => table.virtual).map((table) => `${table.name}_`);
+    return all
+        .filter((table) => !table.virtual && table.name !== "schema_migrations")
+        .filter((table) => !indexes.some((prefix) => table.name.startsWith(prefix)))
+        .map((table) => ({ name: table.name, rows: count(database, `"${table.name}"`) }));
+};
 const isoOf = (value) => new Date(Number(value)).toISOString();
 const messageOf = (error) => (error instanceof Error ? error.message : String(error));

package/dist/cli/shared-command-exports.d.ts

@@ -4,8 +4,8 @@ export declare const generatedApiCommand: (api: import("./bot/api.js").ApiComman
 export declare const botCommand: (bot: import("./index.js").BotMessenger) => import("commander").Command;
 export declare const botMcpCommand: (bot: import("./index.js").BotMessenger) => import("commander").Command;
 export declare const botMessagesCommand: (bot: import("./index.js").BotMessenger) => import("commander").Command;
-export declare const commandsCommand: (app: import("./index.js").AppIdentity) => import("commander").Command;
-export declare const configCommand: (app: import("./index.js").AppIdentity, config: {
+export declare const commandsCommand: (app: import("./entry.js").AppIdentity) => import("commander").Command;
+export declare const configCommand: (app: import("./entry.js").AppIdentity, config: {
     resolveSettings: (flags?: import("./settings.js").GlobalFlags, options?: import("./settings.js").ResolveOptions) => import("./settings.js").Settings & object;
     configuredProfiles: (options?: import("./settings.js").ResolveOptions) => string[];
     changeSetting: (path: string, { profile, setting, value, kind, root, }: {
@@ -172,7 +172,7 @@ export declare const configCommand: (app: import("./index.js").AppIdentity, conf
 }, args_2?: {
     permissionKey?: import("./permission-keys.js").PermissionKeyOf;
 } | undefined) => import("commander").Command;
-export declare const guideCommand: (app: Pick<import("./index.js").AppIdentity, "command">, options: import("./guide.js").GuideOptions) => import("commander").Command;
+export declare const guideCommand: (app: Pick<import("./entry.js").AppIdentity, "command">, options: import("./guide.js").GuideOptions) => import("commander").Command;
 export declare const addMeetingBatchCommand: (program: import("commander").Command, deps: {
     reader: import("../meetings/batch.js").MeetingBatchReader;
     input: (path: string, signal?: AbortSignal) => Promise<string>;
@@ -410,7 +410,7 @@ export declare const tasksCommand: (messenger: import("./index.js").Messenger) =
 export declare const tasksStatsCommand: (messenger: import("./index.js").Messenger) => import("commander").Command;
 export declare const topicsCommand: (messenger: import("./index.js").Messenger) => import("commander").Command;
 export declare const watchCommand: (messenger: import("./index.js").Messenger) => import("commander").Command;
-export declare const runsCommand: (app: import("./index.js").AppIdentity) => import("commander").Command;
-export declare const skillCommand: (app: import("./index.js").AppIdentity, skill: URL) => import("commander").Command;
-export declare const upgradeCommand: (app: import("./index.js").AppIdentity, packageName: string, contextFor: (command: import("commander").Command) => import("./upgrade-command.js").UpgradeContext) => import("commander").Command;
-export declare const modelCatalogueCommand: (app: import("./index.js").AppIdentity, options: import("./model-catalogue-command.js").ModelCatalogueOptions) => import("commander").Command;
+export declare const runsCommand: (app: import("./entry.js").AppIdentity) => import("commander").Command;
+export declare const skillCommand: (app: import("./entry.js").AppIdentity, skill: URL) => import("commander").Command;
+export declare const upgradeCommand: (app: import("./entry.js").AppIdentity, packageName: string, contextFor: (command: import("commander").Command) => import("./upgrade-command.js").UpgradeContext) => import("commander").Command;
+export declare const modelCatalogueCommand: (app: import("./entry.js").AppIdentity, options: import("./model-catalogue-command.js").ModelCatalogueOptions) => import("commander").Command;

package/dist/entities/index.d.ts

@@ -9773,6 +9773,20 @@ export declare const ENTITIES: {
         readonly path: v.StringSchema<undefined>;
         readonly exists: v.LiteralSchema<false, undefined>;
         readonly reset: v.LiteralSchema<false, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly path: v.StringSchema<undefined>;
+        readonly exists: v.LiteralSchema<true, undefined>;
+        readonly reset: v.LiteralSchema<false, undefined>;
+        readonly dry_run: v.LiteralSchema<true, undefined>;
+        readonly files: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly schema: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly tables: v.ArraySchema<v.StrictObjectSchema<{
+            readonly name: v.StringSchema<undefined>;
+            readonly rows: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        }, undefined>, undefined>;
+        readonly backup_first: v.BooleanSchema<undefined>;
+        readonly in_use: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
     }, undefined>, v.StrictObjectSchema<{
         readonly path: v.StringSchema<undefined>;
         readonly exists: v.LiteralSchema<true, undefined>;

package/dist/entities/store-maintenance.d.ts

@@ -346,6 +346,20 @@ export declare const storeReset: v.UnionSchema<[v.StrictObjectSchema<{
     readonly path: v.StringSchema<undefined>;
     readonly exists: v.LiteralSchema<false, undefined>;
     readonly reset: v.LiteralSchema<false, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<true, undefined>;
+    readonly reset: v.LiteralSchema<false, undefined>;
+    readonly dry_run: v.LiteralSchema<true, undefined>;
+    readonly files: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly schema: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly tables: v.ArraySchema<v.StrictObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly rows: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    readonly backup_first: v.BooleanSchema<undefined>;
+    readonly in_use: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
 }, undefined>, v.StrictObjectSchema<{
     readonly path: v.StringSchema<undefined>;
     readonly exists: v.LiteralSchema<true, undefined>;

package/dist/entities/store-maintenance.js

@@ -147,6 +147,18 @@ export const storeRestore = v.strictObject({
 });
 export const storeReset = v.union([
     v.strictObject({ ...absent.entries, reset: v.literal(false) }),
+    v.strictObject({
+        path: text,
+        exists: v.literal(true),
+        reset: v.literal(false),
+        dry_run: v.literal(true),
+        files: v.array(text),
+        bytes: count,
+        schema: count,
+        tables: v.array(v.strictObject({ name: text, rows: count })),
+        backup_first: v.boolean(),
+        in_use: v.nullable(v.boolean()),
+    }),
     v.strictObject({
         path: text,
         exists: v.literal(true),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.428.0",
+  "version": "0.429.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",
@@ -48,6 +48,10 @@
       "types": "./dist/cli/index.d.ts",
       "default": "./dist/cli/index.js"
     },
+    "./cli/start": {
+      "types": "./dist/cli/entry.d.ts",
+      "default": "./dist/cli/entry.js"
+    },
     "./sends": {
       "types": "./dist/sends/index.d.ts",
       "default": "./dist/sends/index.js"

package/parity.json

@@ -4611,6 +4611,7 @@
     "store reset": {
       "in": "all",
       "options": {
+        "--dry-run": "all",
         "--no-backup": "all"
       }
     },