@rigkit/cli 0.2.8 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigkit/cli",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "type": "module",
   "repository": {
     "type": "git",
@@ -22,9 +22,9 @@
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "inquirer": "^13.4.3",
-    "@rigkit/provider-cmux": "0.2.8",
-    "@rigkit/runtime-client": "0.2.8",
-    "@rigkit/engine": "0.2.8"
+    "@rigkit/provider-cmux": "0.2.10",
+    "@rigkit/engine": "0.2.10",
+    "@rigkit/runtime-client": "0.2.10"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/cli.test.ts

@@ -43,6 +43,76 @@ describe("CLI entrypoint", () => {
     expect(help.stdout).toContain("cache       Inspect and clear Rigkit cache");
   });
 
+  test("prints an update notice when latest metadata is newer", async () => {
+    const rigkitHome = mkdtempSync(join(tmpdir(), "rigkit-cli-update-"));
+    const latestVersion = nextPatchVersion(RIGKIT_CLI_VERSION);
+    const server = Bun.serve({
+      hostname: "127.0.0.1",
+      port: 0,
+      fetch() {
+        return Response.json({
+          version: latestVersion,
+          installerUrl: "https://www.rigkit.dev/install",
+        });
+      },
+    });
+
+    try {
+      const result = await runCli(["doctor", "--cli"], {
+        env: {
+          RIGKIT_HOME: rigkitHome,
+          RIGKIT_UPDATE_CHECK: "1",
+          RIGKIT_UPDATE_TIMEOUT_MS: "2000",
+          RIGKIT_UPDATE_URL: `http://127.0.0.1:${server.port}/latest.json`,
+        },
+      });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain(RIGKIT_CLI_VERSION);
+      expect(result.stderr).toContain(`rig ${latestVersion} is available`);
+      expect(result.stderr).toContain("update with: curl -fsSL https://www.rigkit.dev/install | sh");
+    } finally {
+      server.stop(true);
+      rmSync(rigkitHome, { recursive: true, force: true });
+    }
+  });
+
+  test("does not print update notices for JSON output", async () => {
+    const rigkitHome = mkdtempSync(join(tmpdir(), "rigkit-cli-update-json-"));
+    let requests = 0;
+    const server = Bun.serve({
+      hostname: "127.0.0.1",
+      port: 0,
+      fetch() {
+        requests += 1;
+        return Response.json({
+          version: nextPatchVersion(RIGKIT_CLI_VERSION),
+          installerUrl: "https://www.rigkit.dev/install",
+        });
+      },
+    });
+
+    try {
+      const result = await runCli(["doctor", "--cli", "--json"], {
+        env: {
+          RIGKIT_HOME: rigkitHome,
+          RIGKIT_UPDATE_CHECK: "1",
+          RIGKIT_UPDATE_URL: `http://127.0.0.1:${server.port}/latest.json`,
+        },
+      });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stderr).toBe("");
+      expect(JSON.parse(result.stdout)).toMatchObject({
+        cliVersion: RIGKIT_CLI_VERSION,
+      });
+      expect(requests).toBe(0);
+    } finally {
+      server.stop(true);
+      rmSync(rigkitHome, { recursive: true, force: true });
+    }
+  });
+
   test("rejects operation shorthand at the root", async () => {
     const result = await runCli(["unknown"]);
 
@@ -124,6 +194,31 @@ describe("CLI entrypoint", () => {
     }
   });
 
+  test("does not render a success marker when cache invalidation is a no-op", async () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-cli-cache-invalidate-"));
+
+    await withWorkspaceRuntime({ projectDir, cacheInvalidated: 0 }, async ({ env }) => {
+      const result = await runCli([`-chdir=${projectDir}`, "cache", "invalidate", "missing-task"], { env });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stderr).toBe("");
+      expect(result.stdout.trim()).toBe("no cache entries invalidated");
+      expect(result.stdout).not.toContain("✓");
+    });
+  });
+
+  test("preserves JSON output for zero cache invalidations", async () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-cli-cache-invalidate-json-"));
+
+    await withWorkspaceRuntime({ projectDir, cacheInvalidated: 0 }, async ({ env }) => {
+      const result = await runCli([`-chdir=${projectDir}`, "cache", "invalidate", "missing-task", "--json"], { env });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stderr).toBe("");
+      expect(JSON.parse(result.stdout)).toEqual({ ok: true, invalidated: 0 });
+    });
+  });
+
   test("lists workspaces from the project runtime", async () => {
     const projectDir = mkdtempSync(join(tmpdir(), "rigkit-cli-ls-"));
 
@@ -241,6 +336,7 @@ async function runCli(
     stderr: "pipe",
     env: {
       ...process.env,
+      RIGKIT_UPDATE_CHECK: "0",
       ...options.env,
       FORCE_COLOR: "0",
       NO_COLOR: "1",
@@ -255,8 +351,14 @@ async function runCli(
   return { exitCode, stdout, stderr };
 }
 
+function nextPatchVersion(version: string): string {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return "999.0.0";
+  return `${match[1]}.${match[2]}.${Number(match[3]) + 1}`;
+}
+
 async function withWorkspaceRuntime(
-  input: { projectDir: string },
+  input: { projectDir: string; cacheInvalidated?: number },
   run: (context: { env: Record<string, string> }) => Promise<void>,
 ): Promise<void> {
   const rigkitHome = mkdtempSync(join(tmpdir(), "rigkit-home-"));
@@ -306,6 +408,9 @@ async function withWorkspaceRuntime(
           }],
         });
       }
+      if (pathname === "/cache/invalidate") {
+        return runtimeJson({ ok: true, invalidated: input.cacheInvalidated ?? 1 });
+      }
       if (pathname === "/operations") {
         return runtimeJson({
           operations: [{

package/src/cli.ts

@@ -25,6 +25,7 @@ import { initProject, normalizeMachineName, type InitProjectResult } from "./ini
 import { openExternalTarget } from "./interaction.ts";
 import { createRunPresenter, type RunPresenter } from "./run-presenter.ts";
 import { createRunLogger, type RunLogger } from "./run-logger.ts";
+import { maybePrintUpdateNotice } from "./update-check.ts";
 import {
   completeRig,
   formatCompletionItems,
@@ -220,6 +221,14 @@ async function runCli(argv: string[]): Promise<void> {
       await runHelp(makeInvocation(rootOptions(program)));
     });
 
+  program.hook("postAction", async (_thisCommand, actionCommand) => {
+    await maybePrintUpdateNotice({
+      commandName: actionCommand.name(),
+      currentVersion: RIGKIT_CLI_VERSION,
+      json: commandWantsJson(program, actionCommand),
+    });
+  });
+
   program
     .command("init")
     .description("Initialize a Rigkit project")
@@ -408,6 +417,11 @@ function rootOptions(program: Command): GlobalOptions {
   };
 }
 
+function commandWantsJson(program: Command, actionCommand: Command): boolean {
+  const options = actionCommand.opts<{ json?: boolean }>();
+  return Boolean(rootOptions(program).json || options.json);
+}
+
 function parsePackageManagerOption(value: string | undefined): PackageManager | undefined {
   if (value === undefined) return undefined;
   if (isPackageManager(value)) return value;
@@ -1144,6 +1158,10 @@ async function runCacheInvalidate(invocation: CliInvocation, options: CacheInval
     printJson(result);
     return;
   }
+  if (result.invalidated === 0) {
+    console.log(ui.dim("no cache entries invalidated"));
+    return;
+  }
   console.log(
     `${ui.ok(ui.sym.ok)} invalidated ${result.invalidated} cache ${result.invalidated === 1 ? "entry" : "entries"}`,
   );

package/src/completion.test.ts

@@ -15,7 +15,7 @@ describe("CLI completion", () => {
         currentIndex: 2,
       });
 
-      expect(items.map((item) => item.value)).toEqual(["api", "web"]);
+      expect(items.map((item) => item.value)).toEqual(["api", "web", "--json", "--help"]);
       expect(items[0]?.description).toBe("created 2h ago");
     });
   });
@@ -43,7 +43,7 @@ describe("CLI completion", () => {
         currentIndex: 3,
       });
 
-      expect(items.map((item) => item.value)).toEqual(["api", "web"]);
+      expect(items.map((item) => item.value)).toEqual(["api", "web", "--json", "--help"]);
     });
   });
 
@@ -128,7 +128,7 @@ describe("CLI completion", () => {
         words: ["rig", "run", ""],
         currentIndex: 2,
       });
-      expect(roots.map((item) => item.value)).toEqual(["api", "web"]);
+      expect(roots.map((item) => item.value)).toEqual(["api", "web", "--json", "--help"]);
       expect(roots[0]).toMatchObject({ description: "created 2h ago" });
 
       const exactWorkspace = await completeRig({
@@ -143,7 +143,7 @@ describe("CLI completion", () => {
         words: ["rig", "run", "api", ""],
         currentIndex: 3,
       });
-      expect(workspaceAfterSpace.map((item) => item.value)).toEqual(["remove", "open-cmux"]);
+      expect(workspaceAfterSpace.map((item) => item.value)).toEqual(["remove", "open-cmux", "--json", "--help"]);
 
       const operationPrefix = await completeRig({
         cwd: projectDir,
@@ -162,7 +162,7 @@ describe("CLI completion", () => {
         words: ["rig", "rm", ""],
         currentIndex: 2,
       });
-      expect(workspaces.map((item) => item.value)).toEqual(["api", "web"]);
+      expect(workspaces.map((item) => item.value)).toEqual(["api", "web", "-y", "--yes", "--all", "--json", "--help"]);
 
       const flags = await completeRig({
         cwd: projectDir,
@@ -204,7 +204,7 @@ describe("CLI completion", () => {
       currentIndex: 2,
     });
 
-    expect(subcommands.map((item) => item.value)).toEqual(["ls", "clear"]);
+    expect(subcommands.map((item) => item.value)).toEqual(["ls", "clear", "invalidate"]);
 
     const clearFlags = await completeRig({
       cwd: process.cwd(),
@@ -217,9 +217,129 @@ describe("CLI completion", () => {
       "--global",
       "--all",
       "--json",
+      "--help",
     ]);
   });
 
+  test("completes project operation flags and workflow values", async () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-completion-"));
+    await withWorkspaceRuntime({ projectDir }, async () => {
+      const flags = await completeRig({
+        cwd: projectDir,
+        words: ["rig", "apply", "--"],
+        currentIndex: 2,
+      });
+
+      expect(flags.map((item) => item.value)).toEqual([
+        "--workflow",
+        "--dry-run",
+        "--all",
+        "--discover",
+        "--json",
+        "--help",
+      ]);
+
+      const workflowValues = await completeRig({
+        cwd: projectDir,
+        words: ["rig", "apply", "--workflow", ""],
+        currentIndex: 3,
+      });
+      expect(workflowValues.map((item) => item.value)).toEqual(["smoke", "api"]);
+
+      const inlineWorkflow = await completeRig({
+        cwd: projectDir,
+        words: ["rig", "apply", "--workflow=s"],
+        currentIndex: 2,
+      });
+      expect(inlineWorkflow.map((item) => item.value)).toEqual(["--workflow=smoke"]);
+    });
+  });
+
+  test("completes workspace operation flags and enum values", async () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-completion-"));
+    await withWorkspaceRuntime({ projectDir }, async () => {
+      const flags = await completeRig({
+        cwd: projectDir,
+        words: ["rig", "run", "api", "open-cmux", "--"],
+        currentIndex: 4,
+      });
+
+      expect(flags.map((item) => item.value)).toEqual(["--layout", "--json", "--help"]);
+
+      const values = await completeRig({
+        cwd: projectDir,
+        words: ["rig", "run", "api", "open-cmux", "--layout", ""],
+        currentIndex: 5,
+      });
+      expect(values.map((item) => item.value)).toEqual(["tabs", "splits"]);
+    });
+  });
+
+  test("completes cache invalidate targets and flags", async () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-completion-"));
+    await withWorkspaceRuntime({ projectDir }, async () => {
+      const targets = await completeRig({
+        cwd: projectDir,
+        words: ["rig", "cache", "invalidate", ""],
+        currentIndex: 3,
+      });
+
+      expect(targets.map((item) => item.value)).toEqual([
+        "install-tooling",
+        "build",
+        "--all",
+        "-y",
+        "--yes",
+        "--json",
+        "--help",
+      ]);
+
+      const flags = await completeRig({
+        cwd: projectDir,
+        words: ["rig", "cache", "invalidate", "--"],
+        currentIndex: 3,
+      });
+      expect(flags.map((item) => item.value)).toEqual(["--all", "--yes", "--json", "--help"]);
+    });
+  });
+
+  test("completes static command flags and option values", async () => {
+    const initFlags = await completeRig({
+      cwd: process.cwd(),
+      words: ["rig", "init", "--"],
+      currentIndex: 2,
+    });
+    expect(initFlags.map((item) => item.value)).toEqual([
+      "--name",
+      "--api-key",
+      "--package-manager",
+      "--force",
+      "--json",
+      "--help",
+    ]);
+
+    const packageManagers = await completeRig({
+      cwd: process.cwd(),
+      words: ["rig", "init", "--package-manager", "p"],
+      currentIndex: 3,
+    });
+    expect(packageManagers.map((item) => item.value)).toEqual(["pnpm"]);
+
+    const doctorFlags = await completeRig({
+      cwd: process.cwd(),
+      words: ["rig", "doctor", "--"],
+      currentIndex: 2,
+    });
+    expect(doctorFlags.map((item) => item.value)).toEqual(["--cli", "--json", "--help"]);
+
+    const completionShells = await completeRig({
+      cwd: process.cwd(),
+      words: ["rig", "completion", ""],
+      currentIndex: 2,
+    });
+    expect(completionShells.map((item) => item.value)).toEqual(["bash", "fish", "zsh", "--help"]);
+  });
+
   test("formats shell completion items", () => {
     const items = [{ value: "api", description: "vm-api" }];
 
@@ -254,7 +374,7 @@ describe("CLI completion", () => {
       currentIndex: 2,
     });
 
-    expect(items.map((item) => item.value)).toEqual(["workspaces", "snapshots", "config", "--json"]);
+    expect(items.map((item) => item.value)).toEqual(["workspaces", "snapshots", "config", "--json", "--help"]);
   });
 });
 
@@ -321,9 +441,139 @@ async function withWorkspaceRuntime(
           ],
         });
       }
+      if (pathname === "/workflows") {
+        return runtimeJson({
+          workflows: [
+            {
+              name: "smoke",
+              providers: [],
+              nodes: ["install-tooling", "build"],
+              operations: ["plan", "apply", "create"],
+              createsWorkspace: true,
+            },
+            {
+              name: "api",
+              providers: [],
+              nodes: ["install-tooling"],
+              operations: ["plan", "apply"],
+              createsWorkspace: false,
+            },
+          ],
+        });
+      }
+      if (pathname === "/cache") {
+        const nowMs = Date.now();
+        return runtimeJson({
+          entries: [
+            {
+              scope: "local",
+              workflow: "smoke",
+              nodePath: "install-tooling",
+              nodeName: "install-tooling",
+              nodeKind: "task",
+              runId: "run-install",
+              invalidated: false,
+              createdAt: new Date(nowMs - 60_000).toISOString(),
+            },
+            {
+              scope: "local",
+              workflow: "smoke",
+              nodePath: "build",
+              nodeName: "build",
+              nodeKind: "task",
+              runId: "run-build",
+              invalidated: false,
+              createdAt: new Date(nowMs - 30_000).toISOString(),
+            },
+            {
+              scope: "local",
+              workflow: "smoke",
+              nodePath: "old-task",
+              nodeName: "old-task",
+              nodeKind: "task",
+              runId: "run-old",
+              invalidated: true,
+              createdAt: new Date(nowMs - 10_000).toISOString(),
+            },
+            {
+              scope: "global",
+              workflow: "smoke",
+              nodePath: "base",
+              nodeName: "base",
+              nodeKind: "task",
+              runId: "run-base",
+              invalidated: false,
+              createdAt: new Date(nowMs - 5_000).toISOString(),
+              fragmentHash: "fragment",
+            },
+          ],
+        });
+      }
       if (pathname === "/operations") {
         return runtimeJson({
           operations: [
+            {
+              id: "plan",
+              kind: "command",
+              source: "core",
+              title: "Plan",
+              description: "Show cached and pending steps",
+              cli: {
+                options: [{ name: "workflow", flag: "--workflow" }],
+              },
+              inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  workflow: { type: "string", enum: ["smoke", "api"] },
+                },
+              },
+            },
+            {
+              id: "apply",
+              kind: "command",
+              source: "core",
+              title: "Apply",
+              description: "Resolve the workflow",
+              cli: {
+                options: [
+                  { name: "workflow", flag: "--workflow" },
+                  { name: "dryRun", flag: "--dry-run", type: "boolean" },
+                ],
+              },
+              inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  workflow: { type: "string", enum: ["smoke", "api"] },
+                  dryRun: { type: "boolean" },
+                },
+              },
+            },
+            {
+              id: "create",
+              kind: "command",
+              source: "core",
+              title: "Create",
+              description: "Create a workspace",
+              createsWorkspace: true,
+              cli: {
+                positionals: [{ name: "name", index: 0 }],
+                options: [
+                  { name: "workflow", flag: "--workflow" },
+                  { name: "name", flag: "--name", required: true },
+                ],
+              },
+              inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                required: ["name"],
+                properties: {
+                  workflow: { type: "string", enum: ["smoke", "api"] },
+                  name: { type: "string" },
+                },
+              },
+            },
             {
               id: "ssh",
               kind: "command",
@@ -365,10 +615,15 @@ async function withWorkspaceRuntime(
               source: "config",
               title: "Open cmux",
               description: "open cmux",
+              cli: {
+                options: [{ name: "layout", flag: "--layout", type: "string" }],
+              },
               inputSchema: {
                 type: "object",
                 additionalProperties: false,
-                properties: {},
+                properties: {
+                  layout: { type: "string", enum: ["tabs", "splits"] },
+                },
               },
             },
           ],