From 4386a177592a3fe0382c9abe35c9bedfcf662e92 Mon Sep 17 00:00:00 2001
From: Alisue <lambdalisue@gmail.com>
Date: Fri, 9 Jan 2026 21:59:16 +0900
Subject: [PATCH 1/2] fix(@probitas/probitas): allow --deno-reload as boolean
 flag

Previously extractDenoOptions() enforced that only --deno-no-* options
could be used without values, causing --deno-reload to fail. This was
incorrect because Deno's --reload flag accepts optional values:
  --reload        (reload all dependencies)
  --reload=<mods> (reload specific modules)

Changes:
- Removed strict validation from extractDenoOptions() to allow any
  --deno-* option without '=' to be treated as a boolean flag
- Connected -r/--reload option to denoArgs (was previously unused)
- Updated documentation to clarify "with value" vs "without value"
- Added comprehensive tests for extractDenoOptions()

Now these are all equivalent:
  probitas run -r
  probitas run --reload
  probitas run --deno-reload
---
 assets/usage-list.txt    |  4 +-
 assets/usage-run.txt     |  4 +-
 src/cli/commands/list.ts | 13 ++++++-
 src/cli/commands/run.ts  | 13 ++++++-
 src/cli/utils.ts         | 21 +++--------
 src/cli/utils_test.ts    | 79 ++++++++++++++++++++++++++++++++++++++++
 6 files changed, 110 insertions(+), 24 deletions(-)

diff --git a/assets/usage-list.txt b/assets/usage-list.txt
index 9f51f1a..4005981 100644
--- a/assets/usage-list.txt
+++ b/assets/usage-list.txt
@@ -18,8 +18,8 @@ Options:
   --no-env                   Skip loading .env file
   -r, --reload               Reload dependencies before running
   --deno-<option>[=<value>] Pass options to deno subprocess
-                            Value options: --deno-config=custom.json, --deno-lock=custom.lock
-                            Boolean flags: --deno-no-lock, --deno-no-prompt
+                            With value: --deno-config=custom.json, --deno-reload=jsr:@std/http
+                            Without value: --deno-reload, --deno-no-lock, --deno-no-prompt
 
 Selector Format:
   [!][type:]value
diff --git a/assets/usage-run.txt b/assets/usage-run.txt
index 2311985..7413fe5 100644
--- a/assets/usage-run.txt
+++ b/assets/usage-run.txt
@@ -30,8 +30,8 @@ Options:
   -d, --debug               Debug output (maximum detail)
   --no-color                Disable colored output
   --deno-<option>[=<value>] Pass options to deno subprocess
-                            Value options: --deno-config=custom.json, --deno-lock=custom.lock
-                            Boolean flags: --deno-no-lock, --deno-no-prompt
+                            With value: --deno-config=custom.json, --deno-reload=jsr:@std/http
+                            Without value: --deno-reload, --deno-no-lock, --deno-no-prompt
 
 Selector Format:
   [!][type:]value
diff --git a/src/cli/commands/list.ts b/src/cli/commands/list.ts
index 714c83c..76d14a9 100644
--- a/src/cli/commands/list.ts
+++ b/src/cli/commands/list.ts
@@ -102,11 +102,20 @@ export async function listCommand(
     // Configure logging with determined log level
     try {
       await configureLogging(logLevel);
-      logger.debug("List command started", { args, cwd, logLevel, denoArgs });
     } catch {
       // Silently ignore logging configuration errors (e.g., in test environments)
     }
 
+    // Add --reload to denoArgs if -r/--reload is specified
+    const finalDenoArgs = parsed.reload ? [...denoArgs, "--reload"] : denoArgs;
+
+    logger.debug("List command started", {
+      args,
+      cwd,
+      logLevel,
+      denoArgs: finalDenoArgs,
+    });
+
     // Load environment variables before loading configuration
     // This allows config files to reference environment variables
     await loadEnvironment(cwd, {
@@ -172,7 +181,7 @@ export async function listCommand(
     const { allScenarios, filteredScenarios } = await runListSubprocess(
       scenarioFiles,
       selectors,
-      denoArgs,
+      finalDenoArgs,
       cwd,
     );
 
diff --git a/src/cli/commands/run.ts b/src/cli/commands/run.ts
index f1fd8fd..34797f2 100644
--- a/src/cli/commands/run.ts
+++ b/src/cli/commands/run.ts
@@ -125,7 +125,16 @@ export async function runCommand(
 
     // Configure logging with determined log level
     await configureLogging(logLevel);
-    logger.debug("Run command started", { args, cwd, logLevel, denoArgs });
+
+    // Add --reload to denoArgs if -r/--reload is specified
+    const finalDenoArgs = parsed.reload ? [...denoArgs, "--reload"] : denoArgs;
+
+    logger.debug("Run command started", {
+      args,
+      cwd,
+      logLevel,
+      denoArgs: finalDenoArgs,
+    });
 
     // Load environment variables before loading configuration
     // This allows config files to reference environment variables
@@ -212,7 +221,7 @@ export async function runCommand(
       timeout,
       stepOptions,
       logLevel,
-      denoArgs,
+      denoArgs: finalDenoArgs,
       cwd,
       signal,
     });
diff --git a/src/cli/utils.ts b/src/cli/utils.ts
index 5da114d..43c4f90 100644
--- a/src/cli/utils.ts
+++ b/src/cli/utils.ts
@@ -22,8 +22,8 @@ export interface ExtractDenoOptionsResult {
  * Options starting with --deno- are extracted and converted to
  * the corresponding deno option (e.g., --deno-config becomes --config).
  *
- * Value-taking options must use `=` syntax (e.g., `--deno-config=path`).
- * Boolean flags work without values (e.g., `--deno-no-lock`).
+ * Options with `=` are passed as value options (e.g., `--deno-config=path` → `--config=path`).
+ * Options without `=` are passed as boolean flags (e.g., `--deno-reload` → `--reload`).
  *
  * @param args - Command-line arguments
  * @returns Extracted deno args and remaining args
@@ -35,8 +35,9 @@ export interface ExtractDenoOptionsResult {
  *   "--selector", "foo",
  *   "--deno-lock=custom/deno.lock",
  *   "--deno-no-prompt",
+ *   "--deno-reload",
  * ]);
- * // denoArgs: ["--config=custom/deno.json", "--lock=custom/deno.lock", "--no-prompt"]
+ * // denoArgs: ["--config=custom/deno.json", "--lock=custom/deno.lock", "--no-prompt", "--reload"]
  * // remainingArgs: ["--selector", "foo"]
  * ```
  */
@@ -46,20 +47,8 @@ export function extractDenoOptions(args: string[]): ExtractDenoOptionsResult {
 
   for (const arg of args) {
     if (arg.startsWith("--deno-")) {
-      const optionBody = arg.slice(7); // e.g., "config=path" or "no-prompt"
-      const hasValue = optionBody.includes("=");
-      const name = hasValue ? optionBody.split("=")[0] : optionBody;
-
-      // Value-taking options must use `=` syntax (e.g., --deno-config=path).
-      // Boolean flags follow the Deno `no-*` convention (e.g., --deno-no-lock).
-      if (!hasValue && !name.startsWith("no-")) {
-        throw new Error(
-          `Deno option "--deno-${name}" requires a value. ` +
-            `Use "--deno-${name}=<value>" syntax.`,
-        );
-      }
-
       // Convert --deno-xxx to --xxx (preserving =value if present)
+      const optionBody = arg.slice(7); // e.g., "config=path" or "reload"
       const denoArg = "--" + optionBody;
       denoArgs.push(denoArg);
     } else {
diff --git a/src/cli/utils_test.ts b/src/cli/utils_test.ts
index 5d24109..bc49303 100644
--- a/src/cli/utils_test.ts
+++ b/src/cli/utils_test.ts
@@ -12,6 +12,7 @@ import {
 } from "@std/assert";
 import { describe, it } from "@std/testing/bdd";
 import {
+  extractDenoOptions,
   getVersion,
   parsePositiveInteger,
   parseTimeout,
@@ -21,6 +22,84 @@ import {
 import { JSONReporter, ListReporter } from "@probitas/reporter";
 
 describe("utils", () => {
+  describe("extractDenoOptions", () => {
+    it("extracts --deno-* options with values", () => {
+      const result = extractDenoOptions([
+        "--deno-config=custom/deno.json",
+        "--selector",
+        "foo",
+        "--deno-lock=custom/deno.lock",
+      ]);
+      assertEquals(result.denoArgs, [
+        "--config=custom/deno.json",
+        "--lock=custom/deno.lock",
+      ]);
+      assertEquals(result.remainingArgs, ["--selector", "foo"]);
+    });
+
+    it("extracts --deno-no-* boolean flags", () => {
+      const result = extractDenoOptions([
+        "--deno-no-prompt",
+        "--deno-no-lock",
+        "scenarios/",
+      ]);
+      assertEquals(result.denoArgs, ["--no-prompt", "--no-lock"]);
+      assertEquals(result.remainingArgs, ["scenarios/"]);
+    });
+
+    it("extracts --deno-reload without value as boolean flag", () => {
+      const result = extractDenoOptions([
+        "--deno-reload",
+        "scenarios/",
+      ]);
+      assertEquals(result.denoArgs, ["--reload"]);
+      assertEquals(result.remainingArgs, ["scenarios/"]);
+    });
+
+    it("extracts --deno-reload with value", () => {
+      const result = extractDenoOptions([
+        "--deno-reload=jsr:@std/http",
+        "scenarios/",
+      ]);
+      assertEquals(result.denoArgs, ["--reload=jsr:@std/http"]);
+      assertEquals(result.remainingArgs, ["scenarios/"]);
+    });
+
+    it("extracts --deno-check without value as boolean flag", () => {
+      const result = extractDenoOptions([
+        "--deno-check",
+        "scenarios/",
+      ]);
+      assertEquals(result.denoArgs, ["--check"]);
+      assertEquals(result.remainingArgs, ["scenarios/"]);
+    });
+
+    it("extracts --deno-check with value", () => {
+      const result = extractDenoOptions([
+        "--deno-check=all",
+        "scenarios/",
+      ]);
+      assertEquals(result.denoArgs, ["--check=all"]);
+      assertEquals(result.remainingArgs, ["scenarios/"]);
+    });
+
+    it("extracts any --deno-* option without value as boolean flag", () => {
+      const result = extractDenoOptions([
+        "--deno-config",
+        "--deno-lock",
+        "scenarios/",
+      ]);
+      assertEquals(result.denoArgs, ["--config", "--lock"]);
+      assertEquals(result.remainingArgs, ["scenarios/"]);
+    });
+
+    it("returns empty arrays when no deno options", () => {
+      const result = extractDenoOptions(["--selector", "foo"]);
+      assertEquals(result.denoArgs, []);
+      assertEquals(result.remainingArgs, ["--selector", "foo"]);
+    });
+  });
+
   describe("resolveReporter", () => {
     const reporters = [
       { name: "list", class: ListReporter },

From f9ccd4ae1bdfd8582ace41335ee0b7db6d9fb73b Mon Sep 17 00:00:00 2001
From: Alisue <lambdalisue@gmail.com>
Date: Fri, 9 Jan 2026 22:10:57 +0900
Subject: [PATCH 2/2] feat(@probitas/probitas): add cache command to
 pre-download dependencies

Users often need to pre-download scenario dependencies before running
tests, especially in CI/CD environments or when working offline. The
new `probitas cache` command wraps `deno cache` with the same file
discovery and configuration patterns as other CLI commands.

Changes:
- Added `probitas cache` command that runs `deno cache` on scenarios
- Extended _deno.ts helper to support -r/--reload option
- Created usage-cache.txt help documentation
- Updated README and main help with cache command

Usage:
  probitas cache              # Cache all scenario dependencies
  probitas cache -r           # Force re-download
  probitas cache api/         # Cache specific directory
  probitas cache --include "e2e/**/*.probitas.ts"

The command follows the same patterns as fmt/lint/check for consistency
and automatically discovers scenario files using probitas.json config.
---
 README.md                 |  3 +++
 assets/usage-cache.txt    | 30 ++++++++++++++++++++++++++++++
 assets/usage.txt          |  1 +
 src/cli.ts                |  4 ++++
 src/cli/commands/_deno.ts | 12 +++++++++---
 src/cli/commands/cache.ts | 27 +++++++++++++++++++++++++++
 src/cli/commands/mod.ts   |  1 +
 7 files changed, 75 insertions(+), 3 deletions(-)
 create mode 100644 assets/usage-cache.txt
 create mode 100644 src/cli/commands/cache.ts

diff --git a/README.md b/README.md
index caaa1cb..8a7079d 100644
--- a/README.md
+++ b/README.md
@@ -487,6 +487,9 @@ probitas list [options]
 # Initialize configuration file
 probitas init
 
+# Cache scenario dependencies
+probitas cache [options]
+
 # Format scenario files
 probitas fmt
 
diff --git a/assets/usage-cache.txt b/assets/usage-cache.txt
new file mode 100644
index 0000000..4253ed7
--- /dev/null
+++ b/assets/usage-cache.txt
@@ -0,0 +1,30 @@
+probitas cache - Cache scenario dependencies
+
+Usage: probitas cache [options] [paths...]
+
+Arguments:
+  [paths...]  Scenario files or directories
+              Defaults to current directory
+
+Options:
+  -h, --help             Show help message
+  -r, --reload           Force re-download of cached dependencies
+  --include <pattern>    Include pattern for file discovery
+  --exclude <pattern>    Exclude pattern for file discovery
+  --config <path>        Path to probitas config file
+  -v, --verbose          Verbose output
+  -q, --quiet            Suppress output
+  -d, --debug            Debug output
+
+Note:
+  Runs `deno cache` on discovered scenario files to pre-download dependencies.
+  Uses includes/excludes from probitas config (same as run/list).
+
+Examples:
+  probitas cache                    # Cache dependencies for all scenarios
+  probitas cache api/               # Cache dependencies in api directory
+  probitas cache -r                 # Force re-download all dependencies
+  probitas cache -r api/            # Force re-download for api directory
+  probitas cache --include "e2e/**/*.probitas.ts"
+
+Documentation: https://probitas-test.github.io/documents/
diff --git a/assets/usage.txt b/assets/usage.txt
index f27b1d3..37f2274 100644
--- a/assets/usage.txt
+++ b/assets/usage.txt
@@ -6,6 +6,7 @@ Commands:
   init     Initialize a new probitas project
   run      Run scenarios
   list     List available scenarios
+  cache    Cache scenario dependencies (runs deno cache)
   fmt      Format scenario files (runs deno fmt)
   lint     Lint scenario files (runs deno lint)
   check    Type-check scenario files (runs deno check)
diff --git a/src/cli.ts b/src/cli.ts
index ca56e35..d2e7ff1 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -7,6 +7,7 @@
 import { parseArgs } from "@std/cli";
 import { getLogger } from "@logtape/logtape";
 import { EXIT_CODE } from "./cli/constants.ts";
+import { cacheCommand } from "./cli/commands/cache.ts";
 import { checkCommand } from "./cli/commands/check.ts";
 import { fmtCommand } from "./cli/commands/fmt.ts";
 import { initCommand } from "./cli/commands/init.ts";
@@ -81,6 +82,9 @@ export async function main(args: string[]): Promise<number> {
     case "list":
       return await listCommand(commandArgs, cwd);
 
+    case "cache":
+      return await cacheCommand(commandArgs, cwd);
+
     case "fmt":
       return await fmtCommand(commandArgs, cwd);
 
diff --git a/src/cli/commands/_deno.ts b/src/cli/commands/_deno.ts
index 4dbdbf4..17148e7 100644
--- a/src/cli/commands/_deno.ts
+++ b/src/cli/commands/_deno.ts
@@ -26,6 +26,10 @@ export interface DenoSubcommandOptions {
   usageAsset: string;
   /** Extra arguments to pass to the deno command */
   extraArgs?: readonly string[];
+  /** Enable -r/--reload option support */
+  supportReload?: boolean;
+  /** Use deno.json/deno.lock config (default: false, adds --no-config) */
+  useConfig?: boolean;
 }
 
 /**
@@ -46,13 +50,14 @@ export async function runDenoSubcommand(
   try {
     const parsed = parseArgs(args, {
       string: ["config", "include", "exclude"],
-      boolean: ["help", "quiet", "verbose", "debug"],
+      boolean: ["help", "quiet", "verbose", "debug", "reload"],
       collect: ["include", "exclude"],
       alias: {
         h: "help",
         v: "verbose",
         q: "quiet",
         d: "debug",
+        r: "reload",
       },
       default: {
         include: undefined,
@@ -108,10 +113,11 @@ export async function runDenoSubcommand(
       fileCount: scenarioFiles.length,
     });
 
-    // Run deno command with --no-config
+    // Run deno command (with --no-config unless useConfig is true)
     const denoArgs = [
       subcommand,
-      "--no-config",
+      ...(options.useConfig ? [] : ["--no-config"]),
+      ...(options.supportReload && parsed.reload ? ["--reload"] : []),
       ...(options.extraArgs ?? []),
       ...scenarioFiles,
     ];
diff --git a/src/cli/commands/cache.ts b/src/cli/commands/cache.ts
new file mode 100644
index 0000000..7502ed1
--- /dev/null
+++ b/src/cli/commands/cache.ts
@@ -0,0 +1,27 @@
+/**
+ * Cache command for Probitas CLI
+ *
+ * Runs `deno cache` on discovered scenario files to pre-download dependencies.
+ *
+ * @module
+ */
+
+import { runDenoSubcommand } from "./_deno.ts";
+
+/**
+ * Run the cache command
+ *
+ * @param args - Command-line arguments
+ * @param cwd - Current working directory
+ * @returns Exit code
+ */
+export async function cacheCommand(
+  args: string[],
+  cwd: string,
+): Promise<number> {
+  return await runDenoSubcommand("cache", args, cwd, {
+    usageAsset: "usage-cache.txt",
+    supportReload: true,
+    useConfig: true,
+  });
+}
diff --git a/src/cli/commands/mod.ts b/src/cli/commands/mod.ts
index f433415..b9661f8 100644
--- a/src/cli/commands/mod.ts
+++ b/src/cli/commands/mod.ts
@@ -4,6 +4,7 @@
  * @module
  */
 
+export { cacheCommand } from "./cache.ts";
 export { checkCommand } from "./check.ts";
 export { fmtCommand } from "./fmt.ts";
 export { initCommand } from "./init.ts";