@tenonhq/dovetail-core 0.0.111 → 0.0.112

package/README.md

@@ -26,7 +26,7 @@ Quick reference:
 ```bash
 npx dove watch         # multi-scope watch + dashboard
 npx dove push          # build + push current files
-npx dove refresh       # pull manifest + new files
+npx dove refresh       # pull manifest + new files (aliases: pull, r)
 npx dove build         # local build only
 npx dove deploy        # deploy built artifacts
 npx dove dashboard     # update-set dashboard web UI

package/dist/commander.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureCli = configureCli;
 exports.initCommands = initCommands;
 const commands_1 = require("./commands");
 const allScopesCommands_1 = require("./allScopesCommands");
@@ -18,15 +19,26 @@ const clickupCommands_1 = require("./clickupCommands");
 const loginCommand_1 = require("./loginCommand");
 const knowledgeDiffCommand_1 = require("./knowledgeDiffCommand");
 const yargs_1 = __importDefault(require("yargs"));
-async function initCommands() {
+/**
+ * @description Registers every `dove` command, the global options, and the
+ * parser-strictness rules on a yargs instance. Split out from initCommands so
+ * tests can drive a fresh, non-exiting parser (see tests/commanderStrict.test.ts).
+ * @param {Argv} cli - A yargs instance to configure.
+ * @returns {Argv} The same instance, with all commands and options registered.
+ */
+function configureCli(cli) {
     const sharedOptions = {
         logLevel: {
             default: "info",
         },
     };
-    yargs_1.default
+    return cli
+        .scriptName("dove")
         .option("env", {
-        alias: "e",
+        // `--env-file` / `--envFile` are long-documented spellings and are parsed
+        // from raw argv in envArg.ts. Declaring them as aliases keeps `--help` and
+        // the parser honest about what is actually accepted.
+        alias: ["e", "env-file", "envFile"],
         type: "string",
         describe: "Path to a .env file to load for this command (default: .env in the project root). Lets one checkout target multiple instances.",
     })
@@ -65,7 +77,10 @@ async function initCommands() {
     }, async (args) => {
         await (0, allScopesCommands_1.watchAllScopesCommand)(args);
     })
-        .command(["refresh", "r"], "Pull latest manifest and file contents from the ServiceNow instance", (cmdArgs) => {
+        .command(
+    // `pull` is the verb people reach for ("pull before push") and it appears
+    // in downstream docs and scripts — alias it rather than silently no-op.
+    ["refresh", "r", "pull"], "Pull latest manifest and file contents from the ServiceNow instance", (cmdArgs) => {
         cmdArgs.options({
             ...sharedOptions,
             force: {
@@ -568,5 +583,17 @@ async function initCommands() {
     }, async function (args) {
         await (0, knowledgeDiffCommand_1.knowledgeDiffCommand)(args);
     })
-        .help().argv;
+        // An unrecognized command used to fall through the parser and exit 0, doing
+        // nothing — so `dove pull` (and any typo) looked like it had succeeded, which
+        // is the exact false confidence "pull before push" exists to prevent.
+        // strictCommands (not strict) is deliberate: it rejects unknown *commands*
+        // while still tolerating undeclared flags, so documented option spellings
+        // keep working. demandCommand turns a bare `dove` into help + exit 1.
+        .demandCommand(1, "Please specify a command (run `dove --help` to see them all)")
+        .strictCommands()
+        .recommendCommands()
+        .help();
+}
+async function initCommands() {
+    configureCli(yargs_1.default).argv;
 }

package/dist/tests/commanderStrict.test.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// --- Mock setup (must be before imports) ---
+//
+// Every command module is mocked: these tests exercise the parser (routing +
+// strictness), not the commands themselves, and the real handlers would hit
+// ServiceNow.
+jest.mock("../commands", () => ({
+    refreshCommand: jest.fn(),
+    pushCommand: jest.fn(),
+    downloadCommand: jest.fn(),
+    initCommand: jest.fn(),
+    buildCommand: jest.fn(),
+    deployCommand: jest.fn(),
+    statusCommand: jest.fn(),
+    taskClearCommand: jest.fn(),
+}));
+jest.mock("../allScopesCommands", () => ({
+    initScopesCommand: jest.fn(),
+    watchAllScopesCommand: jest.fn(),
+}));
+jest.mock("../updateSetCommands", () => ({
+    createUpdateSetCommand: jest.fn(),
+    switchUpdateSetCommand: jest.fn(),
+    listUpdateSetsCommand: jest.fn(),
+    showCurrentUpdateSetCommand: jest.fn(),
+    changeScopeCommand: jest.fn(),
+    showCurrentScopeCommand: jest.fn(),
+}));
+jest.mock("../dashboardCommand", () => ({ dashboardCommand: jest.fn() }));
+jest.mock("../schemaCommand", () => ({
+    schemaPullCommand: jest.fn(),
+    schemaDiffCommand: jest.fn(),
+    schemaSnapshotsCommand: jest.fn(),
+}));
+jest.mock("../claudeCommand", () => ({ initClaudeCommand: jest.fn() }));
+jest.mock("../createRecordCommand", () => ({ createRecordCommand: jest.fn() }));
+jest.mock("../deleteRecordCommand", () => ({ deleteRecordCommand: jest.fn() }));
+jest.mock("../reconcileCommand", () => ({ reconcileCommand: jest.fn() }));
+jest.mock("../migrateCommand", () => ({ migrateCommand: jest.fn() }));
+jest.mock("../loginCommand", () => ({ loginCommand: jest.fn() }));
+jest.mock("../knowledgeDiffCommand", () => ({ knowledgeDiffCommand: jest.fn() }));
+jest.mock("../clickupCommands", () => ({
+    clickupTasksCommand: jest.fn(),
+    clickupTaskCommand: jest.fn(),
+    clickupCreateCommand: jest.fn(),
+    clickupUpdateCommand: jest.fn(),
+    clickupCommentCommand: jest.fn(),
+    clickupSetupCommand: jest.fn(),
+    clickupTeamsCommand: jest.fn(),
+    clickupSpacesCommand: jest.fn(),
+    clickupListsCommand: jest.fn(),
+}));
+// --- Imports (after mocks) ---
+const yargs_1 = __importDefault(require("yargs/yargs"));
+const commander_1 = require("../commander");
+const commands_1 = require("../commands");
+/**
+ * @description Runs a fake `dove` invocation through a fresh, non-exiting parser.
+ * @param {string[]} args - Argv as the user would type it, minus the binary name.
+ * @returns {Promise<ParseResult>} The parse error (if any), yargs' captured output, and the parsed argv.
+ */
+async function run(args) {
+    const cli = (0, commander_1.configureCli)((0, yargs_1.default)([])).exitProcess(false);
+    const result = await new Promise(function (resolve) {
+        cli.parse(args, {}, function (error, argv, output) {
+            resolve({
+                error: error === null ? undefined : error,
+                output: output || "",
+                argv: (argv || {}),
+            });
+        });
+    });
+    // Command handlers are async; let their microtasks flush before asserting.
+    await new Promise(function (resolve) {
+        setImmediate(resolve);
+    });
+    return result;
+}
+beforeEach(function () {
+    jest.clearAllMocks();
+});
+describe("dove pull", function () {
+    it("routes `pull` to the refresh command", async function () {
+        const { error } = await run(["pull"]);
+        expect(error).toBeUndefined();
+        expect(commands_1.refreshCommand).toHaveBeenCalledTimes(1);
+    });
+    it("still routes the canonical `refresh` and its `r` alias", async function () {
+        await run(["refresh"]);
+        expect(commands_1.refreshCommand).toHaveBeenCalledTimes(1);
+        await run(["r"]);
+        expect(commands_1.refreshCommand).toHaveBeenCalledTimes(2);
+    });
+    it("passes refresh flags through the pull alias", async function () {
+        const { error, argv } = await run(["pull", "--scope", "x_cadso_core", "--force"]);
+        expect(error).toBeUndefined();
+        expect(argv.scope).toBe("x_cadso_core");
+        expect(argv.force).toBe(true);
+        expect(commands_1.refreshCommand).toHaveBeenCalledTimes(1);
+    });
+});
+describe("unknown commands", function () {
+    it("errors instead of silently succeeding", async function () {
+        const { error } = await run(["psuh"]);
+        expect(error).toBeDefined();
+        expect(String(error)).toContain("Unknown command");
+        expect(commands_1.pushCommand).not.toHaveBeenCalled();
+    });
+    it("suggests the closest real command on a typo", async function () {
+        const { error, output } = await run(["refesh"]);
+        expect(error).toBeDefined();
+        expect(output + String(error)).toContain("Did you mean refresh?");
+        expect(commands_1.refreshCommand).not.toHaveBeenCalled();
+    });
+    it("errors when no command is given at all", async function () {
+        const { error } = await run([]);
+        expect(error).toBeDefined();
+        expect(String(error)).toContain("Please specify a command");
+    });
+});
+describe("existing invocations keep working", function () {
+    it("accepts a known command", async function () {
+        const { error } = await run(["status"]);
+        expect(error).toBeUndefined();
+        expect(commands_1.statusCommand).toHaveBeenCalledTimes(1);
+    });
+    it("accepts push with its --diff flag and optional target positional", async function () {
+        const { error, argv } = await run(["push", "--diff", "main"]);
+        expect(error).toBeUndefined();
+        expect(argv.diff).toBe("main");
+        expect(commands_1.pushCommand).toHaveBeenCalledTimes(1);
+    });
+    it("accepts the documented --env-file spelling (not just --env)", async function () {
+        // strictCommands, not strict: undeclared flags stay tolerated and the
+        // documented env aliases all resolve to `env`. See envArg.ts.
+        const { error, argv } = await run(["status", "--env-file", ".env.prod"]);
+        expect(error).toBeUndefined();
+        expect(argv.env).toBe(".env.prod");
+    });
+    it("still routes nested subcommands", async function () {
+        const { error } = await run(["schema", "pull"]);
+        expect(error).toBeUndefined();
+    });
+    it("rejects an unknown nested subcommand", async function () {
+        const { error } = await run(["clickup", "taks"]);
+        expect(error).toBeDefined();
+    });
+});

package/dist/tests/cred.test.js

@@ -3,6 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// --- Mock setup (must be before imports) ---
+//
+// These tests assert on credential loading only. init() also boots the CLI
+// parser, which under Jest sees jest's own argv, finds no `dove` command, and
+// now exits 1 (the parser rejects unknown commands instead of silently
+// succeeding). Stub the parser so the credential assertions are what's tested.
+jest.mock("../commander", () => ({ initCommands: jest.fn() }));
+// --- Imports (after mocks) ---
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const bootstrap_1 = require("../bootstrap");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/dovetail-core",
-  "version": "0.0.111",
+  "version": "0.0.112",
   "description": "Next-gen file syncer",
   "license": "GPL-3.0",
   "main": "./dist/index.js",

package/release-manifest.json

@@ -1,7 +1,45 @@
 {
   "$schema": "dovetail-manifest/v1",
-  "generated_at": "2026-07-10T18:41:37.097Z",
+  "generated_at": "2026-07-14T18:00:31.248Z",
   "events": [
+    {
+      "$schema": "dovetail-release-event/v1",
+      "event_id": "dovetail-core@0.0.111",
+      "package": "@tenonhq/dovetail-core",
+      "version": "0.0.111",
+      "prev_version": "0.0.110",
+      "published_at": "2026-07-14T18:00:31.240Z",
+      "git": {
+        "sha": "c017d194ec18d0293a0a512f835dafcf49f16560",
+        "tag": "dovetail-core@0.0.111"
+      },
+      "semver_bump": "patch",
+      "commits": [
+        {
+          "sha": "c017d194e",
+          "subject": "feat(core): add --table filter to dove refresh (#218)",
+          "pr": 218
+        },
+        {
+          "sha": "34c5ae1ba",
+          "subject": "chore(release): @tenonhq/dovetail-deploy@0.0.2 [skip ci]"
+        },
+        {
+          "sha": "ef9e73505",
+          "subject": "chore(release): publish 2 packages [skip ci]"
+        },
+        {
+          "sha": "619cf397b",
+          "subject": "chore(release): @tenonhq/dovetail-dashboard@0.0.48 [skip ci]"
+        },
+        {
+          "sha": "534f517e4",
+          "subject": "chore(release): publish 3 packages [skip ci]"
+        }
+      ],
+      "exports_delta": null,
+      "narrative": null
+    },
     {
       "$schema": "dovetail-release-event/v1",
       "event_id": "dovetail-deploy@0.0.2",
@@ -1239,36 +1277,6 @@
       ],
       "exports_delta": null,
       "narrative": null
-    },
-    {
-      "$schema": "dovetail-release-event/v1",
-      "event_id": "dovetail-prettier-plugin@0.0.11",
-      "package": "@tenonhq/dovetail-prettier-plugin",
-      "version": "0.0.11",
-      "prev_version": "0.0.10",
-      "published_at": "2026-06-05T06:43:18.252Z",
-      "git": {
-        "sha": "71bdf9bba8bd5e3849a212a18d9ebc9241232b32",
-        "tag": "dovetail-prettier-plugin@0.0.11"
-      },
-      "semver_bump": "patch",
-      "commits": [
-        {
-          "sha": "71bdf9bba",
-          "subject": "fix: float internal dep ranges to ~0.0.x so consumers need no overrides (#148)",
-          "pr": 148
-        },
-        {
-          "sha": "9332fdf7a",
-          "subject": "chore(release): publish 20 packages [skip ci]"
-        },
-        {
-          "sha": "9046da774",
-          "subject": "chore(release): publish 19 packages [skip ci]"
-        }
-      ],
-      "exports_delta": null,
-      "narrative": null
     }
   ]
 }