@rigkit/cli 0.2.7 → 0.2.8

package/README.md

@@ -7,7 +7,7 @@ npm i -g @rigkit/cli
 rig init
 rig plan
 rig ls
-rig plan github:owner/repo
+rig -chdir=examples/smoke plan
 ```
 
 `rig init` asks for a project name, Freestyle API key, and package manager. It creates a project folder containing a workflow-based `rig.config.ts`, `.env`, `.env.example`, `package.json`, and local ignore rules.
@@ -16,10 +16,19 @@ Interactive terminals use Inquirer prompts and a chalk/log-update run timeline.
 
 Interactive providers can ask the CLI to open provider-owned URLs. For example, Freestyle terminal sessions are served by the Freestyle provider, while the CLI only opens the presented URL in a browser.
 
-Workspace-specific operations run as `rig run <workspace> <operation>`, for example `rig run website-workspace open-cmux` or `rig run website-workspace remove -y`.
+Workspace lifecycle commands are built in: `rig create <workspace>` creates a
+workspace and `rig rm <workspace>` removes one. Workspace-specific operations
+defined by the project run as `rig run <workspace> <operation>`, for example
+`rig run website-workspace open-cmux`.
 
 `rig ls` lists workspaces for the selected project. `rig ls snapshots` lists cached snapshot runs, and `rig ls config` shows the resolved project paths.
 
-Remote GitHub targets are materialized into `~/.rigkit/projects`, use state outside the checkout, and require explicit trust before installing dependencies or executing the remote config.
+Use Terraform-style global context options before the command to select another
+project or config:
+
+```bash
+rig -chdir=examples/smoke plan
+rig -chdir=examples/global-fragments -config=api.rig.config.ts apply
+```
 
 Projects should install matching `@rigkit/sdk` versions locally.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigkit/cli",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "type": "module",
   "repository": {
     "type": "git",
@@ -22,12 +22,9 @@
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "inquirer": "^13.4.3",
-    "log-symbols": "^7.0.1",
-    "log-update": "^8.0.0",
-    "ora": "^9.4.0",
-    "@rigkit/provider-cmux": "0.2.7",
-    "@rigkit/runtime-client": "0.2.7",
-    "@rigkit/engine": "0.2.7"
+    "@rigkit/provider-cmux": "0.2.8",
+    "@rigkit/runtime-client": "0.2.8",
+    "@rigkit/engine": "0.2.8"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/cli.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { projectIdFor, runtimeFingerprintFor, runtimePaths, SUPPORTED_RUNTIME_API_VERSION } from "@rigkit/runtime-client";
@@ -24,7 +24,9 @@ describe("CLI entrypoint", () => {
     expect(rootHelp.stderr).toBe("");
     expect(rootHelp.stdout).toContain("rig ");
     expect(rootHelp.stdout).toContain("plan        Plan project workflow changes");
+    expect(rootHelp.stdout).toContain("rm          Remove a workspace");
     expect(rootHelp.stdout).toContain("run         Run a workspace operation");
+    expect(rootHelp.stdout).toContain("cache       Inspect and clear Rigkit cache");
 
     const version = await runCli(["version"]);
     expect(version.exitCode).toBe(0);
@@ -36,7 +38,9 @@ describe("CLI entrypoint", () => {
     expect(help.stderr).toBe("");
     expect(help.stdout).toContain("rig ");
     expect(help.stdout).toContain("plan        Plan project workflow changes");
+    expect(help.stdout).toContain("rm          Remove a workspace");
     expect(help.stdout).toContain("run         Run a workspace operation");
+    expect(help.stdout).toContain("cache       Inspect and clear Rigkit cache");
   });
 
   test("rejects operation shorthand at the root", async () => {
@@ -52,7 +56,7 @@ describe("CLI entrypoint", () => {
 
     expect(result.exitCode).toBe(0);
     expect(result.stderr).toBe("");
-    expect(result.stdout.trim()).toBe("version\tshow CLI version");
+    expect(result.stdout.trim()).toBe("version\tshow CLI version\t\tCommands");
   });
 
   test("discovers projects without starting a runtime", async () => {
@@ -77,11 +81,54 @@ describe("CLI entrypoint", () => {
     }
   });
 
+  test("shows named config choices when the default config is missing", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "rigkit-cli-named-configs-"));
+    writeFileSync(join(cwd, "api.rig.config.ts"), "export default {}\n");
+    writeFileSync(join(cwd, "web.rig.config.ts"), "export default {}\n");
+
+    try {
+      const result = await runCli(["create", "--json"], { cwd });
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stdout).toBe("");
+      expect(result.stderr).toContain("No Rigkit config found from");
+      expect(result.stderr).toContain("Found named Rigkit configs");
+      expect(result.stderr).toContain("api.rig.config.ts");
+      expect(result.stderr).toContain("web.rig.config.ts");
+      expect(result.stderr).toContain("rig -chdir=. -config=api.rig.config.ts <command>");
+    } finally {
+      rmSync(cwd, { recursive: true, force: true });
+    }
+  });
+
+  test("clears all global fragment cache without loading a config", async () => {
+    const rigkitHome = mkdtempSync(join(tmpdir(), "rigkit-cli-cache-"));
+    const fragmentDir = join(rigkitHome, "fragments", "sha256-test");
+    mkdirSync(fragmentDir, { recursive: true });
+    writeFileSync(join(fragmentDir, "state.sqlite"), "");
+
+    try {
+      const result = await runCli(["cache", "clear", "--global", "--all", "--json"], {
+        env: { RIGKIT_HOME: rigkitHome },
+      });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stderr).toBe("");
+      expect(JSON.parse(result.stdout)).toMatchObject({
+        ok: true,
+        scope: "global-all",
+      });
+      expect(existsSync(fragmentDir)).toBe(false);
+    } finally {
+      rmSync(rigkitHome, { recursive: true, force: true });
+    }
+  });
+
   test("lists workspaces from the project runtime", async () => {
     const projectDir = mkdtempSync(join(tmpdir(), "rigkit-cli-ls-"));
 
     await withWorkspaceRuntime({ projectDir }, async ({ env }) => {
-      const result = await runCli(["-C", projectDir, "ls"], { env });
+      const result = await runCli([`-chdir=${projectDir}`, "ls"], { env });
 
       expect(result.exitCode).toBe(0);
       expect(result.stderr).toBe("");
@@ -94,7 +141,7 @@ describe("CLI entrypoint", () => {
     const projectDir = mkdtempSync(join(tmpdir(), "rigkit-cli-ls-json-"));
 
     await withWorkspaceRuntime({ projectDir }, async ({ env }) => {
-      const result = await runCli(["-C", projectDir, "ls", "--json"], { env });
+      const result = await runCli([`-chdir=${projectDir}`, "ls", "--json"], { env });
 
       expect(result.exitCode).toBe(0);
       expect(result.stderr).toBe("");
@@ -112,7 +159,7 @@ describe("CLI entrypoint", () => {
     const projectDir = mkdtempSync(join(tmpdir(), "rigkit-cli-create-name-"));
 
     await withWorkspaceRuntime({ projectDir }, async ({ env }) => {
-      const result = await runCli(["-C", projectDir, "create", "--name", "some workspace", "--json"], { env });
+      const result = await runCli([`-chdir=${projectDir}`, "create", "--name", "some workspace", "--json"], { env });
 
       expect(result.exitCode).toBe(1);
       expect(result.stdout).toBe("");
@@ -120,6 +167,34 @@ describe("CLI entrypoint", () => {
     });
   });
 
+  test("accepts create name as a positional argument", async () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-cli-create-positional-"));
+
+    await withWorkspaceRuntime({ projectDir }, async ({ env }) => {
+      const result = await runCli([`-chdir=${projectDir}`, "create", "new-workspace", "--json"], { env });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stderr).toBe("");
+      expect(JSON.parse(result.stdout)).toMatchObject({
+        name: "new-workspace",
+      });
+    });
+  });
+
+  test("removes a workspace with the built-in rm command", async () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-cli-rm-"));
+
+    await withWorkspaceRuntime({ projectDir }, async ({ env }) => {
+      const result = await runCli([`-chdir=${projectDir}`, "rm", "api", "-y", "--json"], { env });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stderr).toBe("");
+      expect(JSON.parse(result.stdout)).toMatchObject({
+        name: "api",
+      });
+    });
+  });
+
   test("requires discovered projects for operation --all", async () => {
     const cwd = mkdtempSync(join(tmpdir(), "rigkit-cli-run-all-"));
 
@@ -196,10 +271,11 @@ async function withWorkspaceRuntime(
   writeFileSync(paths.tokenPath, `${token}\n`);
 
   const now = new Date(0).toISOString();
+  let runResult: unknown = undefined;
   const server = Bun.serve({
     hostname: "127.0.0.1",
     port: 0,
-    fetch(request) {
+    async fetch(request) {
       if (request.headers.get("authorization") !== `Bearer ${token}`) {
         return runtimeJson({ error: { message: "Unauthorized" } }, { status: 401 });
       }
@@ -240,6 +316,7 @@ async function withWorkspaceRuntime(
             description: "Create a workspace",
             createsWorkspace: true,
             cli: {
+              positionals: [{ name: "name", index: 0 }],
               options: [{ name: "name", flag: "--name", required: true, type: "string" }],
             },
             inputSchema: {
@@ -251,9 +328,64 @@ async function withWorkspaceRuntime(
               required: ["name"],
             },
           }],
-          workspaceOperations: [],
+          workspaceOperations: [{
+            id: "remove",
+            kind: "workspace-action",
+            source: "core",
+            title: "Remove",
+            description: "remove workspace",
+            cli: {
+              options: [{ name: "yes", flag: "--yes", aliases: ["-y"], type: "boolean", runtime: false }],
+            },
+            inputSchema: {
+              type: "object",
+              additionalProperties: false,
+              properties: {},
+            },
+          }],
         });
       }
+      if (pathname === "/runs") {
+        const body = await request.json() as { operation?: string; input?: { name?: string } };
+        runResult = body.operation === "api/remove"
+          ? {
+            id: "workspace-api",
+            name: "api",
+            workflow: "smoke",
+            ctx: {},
+            createdAt: now,
+            updatedAt: now,
+          }
+          : {
+            id: "workspace-new",
+            name: body.input?.name ?? "new-workspace",
+            workflow: "smoke",
+            ctx: {},
+            createdAt: now,
+            updatedAt: now,
+          };
+        return runtimeJson({
+          runId: "run-test",
+          operation: body.operation ?? "test",
+          status: "running",
+          eventsUrl: "/runs/run-test/events",
+          sessionUrl: "",
+        }, { status: 202 });
+      }
+      if (pathname === "/runs/run-test/events") {
+        return new Response(
+          `data: ${JSON.stringify({
+            type: "run.completed",
+            result: runResult,
+          })}\n\n`,
+          {
+            headers: {
+              "content-type": "text/event-stream",
+              "x-rigkit-api-version": String(SUPPORTED_RUNTIME_API_VERSION),
+            },
+          },
+        );
+      }
       return runtimeJson({ error: { message: "Not found" } }, { status: 404 });
     },
   });