cool-workflow 0.2.3 → 0.2.5

package/dist/cli/entry.js

@@ -15,7 +15,7 @@
 // so byte content there is unaffected; cli-color-env.case.js exercises
 // the FORCE_COLOR/NO_COLOR/CW_NO_COLOR branches explicitly.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.recoveryHint = recoveryHint;
+exports.recoveryHint = void 0;
 exports.runCli = runCli;
 exports.main = main;
 const parseargv_1 = require("./parseargv");
@@ -25,6 +25,13 @@ const parseargv_2 = require("./parseargv");
 const capability_table_1 = require("../core/capability-table");
 const term_1 = require("../shell/term");
 const io_1 = require("./io");
+const recovery_hint_1 = require("../core/format/recovery-hint");
+// recoveryHint now lives in core/format/recovery-hint.ts (a core/-layer
+// file, so mcp/server.ts can use it too without crossing the mcp/-may-
+// never-import-cli/ layer rule). Re-exported here so every existing
+// importer of `recoveryHint` from this file keeps working unchanged.
+var recovery_hint_2 = require("../core/format/recovery-hint");
+Object.defineProperty(exports, "recoveryHint", { enumerable: true, get: function () { return recovery_hint_2.recoveryHint; } });
 /** MILESTONE 2: `version` is now a pure projection of the capability
  *  table's `version` row — there is exactly one place its print text
  *  lives (core/capability-table.ts's cli handler), not a second
@@ -39,23 +46,6 @@ function printVersion() {
     const result = row?.cli?.handler({ positionals: [], options: {} });
     process.stdout.write(result?.text ?? "");
 }
-/** src/cli.ts:18-29 — map a top-level error message to ONE copy-pasteable
- *  recovery command. Content-based so it stays correct regardless of which
- *  call site threw; returns undefined rather than a wrong guess. */
-function recoveryHint(message) {
-    const m = message.toLowerCase();
-    if (m.startsWith("unknown command"))
-        return "cw help";
-    if (m.includes("not configured") || m.includes("agent backend"))
-        return "cw doctor";
-    if (m.includes("missing") && m.includes("repo"))
-        return 'cw -q "<question>" -dir <project-folder>';
-    if (m.includes("app") && (m.includes("not found") || m.includes("not available")))
-        return "cw app list";
-    if (m.includes("run id") || m.includes("run not found"))
-        return "cw run list";
-    return undefined;
-}
 async function runCli(argv = process.argv.slice(2)) {
     const args = (0, parseargv_1.parseArgv)(argv);
     // Top-level flags: accept --version / -v / --help / -h before command lookup.
@@ -77,6 +67,8 @@ async function runCli(argv = process.argv.slice(2)) {
         args.options["agent-command"] = "builtin:codex";
     if (args.options.gemini)
         args.options["agent-command"] = "builtin:gemini";
+    if (args.options.opencode)
+        args.options["agent-command"] = "builtin:opencode";
     if (args.options.deepseek)
         args.options["agent-command"] = "builtin:deepseek";
     // -dir / --dir / -d is a second name for --repo; an explicit --repo wins
@@ -152,7 +144,7 @@ function main(argv = process.argv.slice(2)) {
             return;
         const message = error instanceof Error ? error.message : String(error);
         process.stderr.write(`${(0, term_1.bold)("cw:", process.stderr)} ${(0, term_1.red)(message, process.stderr)}\n`);
-        const hint = recoveryHint(message);
+        const hint = (0, recovery_hint_1.recoveryHint)(message);
         if (hint)
             process.stderr.write(`  ${(0, term_1.dim)("Try:", process.stderr)} ${hint}\n`);
         process.exitCode = 1;

package/dist/cli/global-flags.js

@@ -0,0 +1,113 @@
+"use strict";
+// cli/global-flags.ts — the shared global CLI flag set, plus the TTY-gated
+// unknown-flag warning for capability rows that declare `flagsComplete`
+// (core/capability-data.ts's CliBinding).
+//
+// WHY: an unknown flag used to be dropped without a sound — `cw doctor
+// --jsno` ran fine, printed the human report, and exited 0, so a typo of
+// `--json` was easy to miss. A full allowlist check for EVERY command is
+// not safe (a missed name means a FALSE warning, and many scripted and
+// conformance callers assert stderr === ""), so the design here is
+// incremental and fail-open:
+//   - only a row that declares `flagsComplete: true` is ever checked, and
+//     a row earns that mark only after its handler's option reads have
+//     been checked against source, one by one;
+//   - the warning is ONE line to stderr, printed ONLY when stderr is a
+//     real interactive terminal (same injectable-stream gate as
+//     shell/workbench-host.ts's printServeHint) — a piped, scripted, or
+//     conformance run can never see it;
+//   - stdout bytes and the exit code never change.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLOBAL_CLI_FLAGS = void 0;
+exports.unknownFlagKeys = unknownFlagKeys;
+exports.warnUnknownFlags = warnUnknownFlags;
+/** Every option key the shared CLI front door reads for ANY command, so a
+ *  `flagsComplete` row's check never flags them. Built by reading the
+ *  actual consumers:
+ *   - cli/entry.ts: `version`/`v`, `help`/`h`, the vendor shorthands
+ *     `claude`/`codex`/`gemini`/`deepseek` (each sets `agent-command`),
+ *     `repo`/`dir` (`--dir`/`-d` is a global alias for `--repo`),
+ *     `verbose`, `no-color`, `full`, `quiet`, `question` (`-q`), and the
+ *     `--resume --run <id>` continuation pair;
+ *   - cli/dispatch.ts + core/util/cli-args.ts's wantsJson: `json`,
+ *     `format`;
+ *   - cli/parseargv.ts's short-alias table: `link` (`-l`),
+ *     `agent-command` (`-a`) — the short spellings map to these long
+ *     names before any handler sees them;
+ *   - the doctor/fix handlers' shared working-dir override: `cwd`.
+ *  Keys are the POST-parse spellings (what lands in `args.options`). */
+exports.GLOBAL_CLI_FLAGS = [
+    "agent-command",
+    "claude",
+    "codex",
+    "cwd",
+    "deepseek",
+    "dir",
+    "format",
+    "full",
+    "gemini",
+    "h",
+    "help",
+    "json",
+    "link",
+    "no-color",
+    "question",
+    "quiet",
+    "repo",
+    "resume",
+    "run",
+    "v",
+    "verbose",
+    "version",
+];
+/** "changed-from" -> "changedFrom". A name with no dash comes back as-is. */
+function kebabToCamel(name) {
+    return name.replace(/-([a-z0-9])/g, (_, ch) => ch.toUpperCase());
+}
+/** "changedFrom" -> "changed-from". A name with no capitals comes back as-is. */
+function camelToKebab(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+/** The option key a declared flag help entry documents: the first token
+ *  of its display name, without the leading dashes ("--changed-from REF"
+ *  -> "changed-from"). */
+function flagNameToKey(name) {
+    return name.trim().split(/\s+/)[0].replace(/^-+/, "");
+}
+/** The full accepted-key set for one row: the row's declared flags plus
+ *  the global set, each in BOTH its kebab-case and camelCase spelling. */
+function knownKeysFor(cli) {
+    const known = new Set();
+    const add = (key) => {
+        known.add(key);
+        known.add(kebabToCamel(key));
+        known.add(camelToKebab(key));
+    };
+    for (const name of exports.GLOBAL_CLI_FLAGS)
+        add(name);
+    for (const flag of cli.flags ?? [])
+        add(flagNameToKey(flag.name));
+    return known;
+}
+/** The option keys this row does not know about (pure; exported for unit
+ *  tests). Empty unless the row declares `flagsComplete`. */
+function unknownFlagKeys(cli, options) {
+    if (!cli.flagsComplete)
+        return [];
+    const known = knownKeysFor(cli);
+    return Object.keys(options).filter((key) => !known.has(key));
+}
+/** Write ONE warning line to `stream` when a `flagsComplete` row got an
+ *  option it does not read — and only when the stream is a real TTY, so
+ *  no piped caller, script, or conformance case can ever see it. stdout
+ *  and the exit code are untouched either way. */
+function warnUnknownFlags(cli, options, stream = process.stderr) {
+    if (!stream.isTTY)
+        return;
+    const unknown = unknownFlagKeys(cli, options);
+    if (unknown.length === 0)
+        return;
+    const label = unknown.length === 1 ? "flag" : "flags";
+    const list = unknown.map((key) => `--${key}`).join(", ");
+    stream.write(`cw: warning: unknown ${label} ${list} (see: cw help ${cli.path[0]})\n`);
+}

package/dist/cli/io.js

@@ -1,8 +1,12 @@
 "use strict";
 // cli/io.ts — shared CLI input/output helpers.
 //
-// Byte-exact port of src/cli/io.ts in the old build. Pure + zero-dep: arg
-// coercion + JSON stdout. See SPEC/cli-surface.md "Shared io helpers".
+// Byte-exact port of src/cli/io.ts in the old build. Pure + zero-dep JSON
+// stdout, plus one impure TTY-aware help formatter. See SPEC/cli-surface.md
+// "Shared io helpers". Arg-coercion helpers (`required`/`optionalArg`/
+// `wantsJson`) moved to core/util/cli-args.ts (architecture-review P2) —
+// wiring/capability-table/*.ts needed them directly, and a cli/-layer file
+// may not be imported by wiring/ (scripts/purity-gate.js's layer rule).
 //
 // MILESTONE 11 (reporting/observability) adds `styledHelp` — the one
 // place `formatHelp()`'s plain text gets its "Cool Workflow" header
@@ -11,10 +15,7 @@
 // shell/term.ts's env/TTY read.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.styledHelp = styledHelp;
-exports.required = required;
-exports.optionalArg = optionalArg;
 exports.printJson = printJson;
-exports.wantsJson = wantsJson;
 const help_1 = require("../core/format/help");
 const safe_json_1 = require("../core/format/safe-json");
 const term_1 = require("../shell/term");
@@ -24,17 +25,6 @@ function styledHelp() {
     const text = (0, help_1.formatHelp)();
     return text.replace(/^Cool Workflow\n/, `${(0, term_1.bold)("Cool Workflow")}\n`);
 }
-/** Require a positional/option value or fail with a copy-pasteable recovery tip. */
-function required(value, label) {
-    if (!value) {
-        throw new Error(`Missing ${label}.\n  Tip: find run ids with "cw run list" or create one with "cw quickstart"`);
-    }
-    return value;
-}
-/** Normalize an optional CLI arg to a trimmed non-empty string, else undefined. */
-function optionalArg(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
 /** Machine payload to stdout (stdout = data; never colored, never chrome).
  *  Byte-capped via safeJsonStringify — an aggregate result too large to be
  *  useful (or large enough to blow V8's string limit) prints a small
@@ -42,7 +32,3 @@ function optionalArg(value) {
 function printJson(value) {
     process.stdout.write(`${(0, safe_json_1.safeJsonStringify)(value)}\n`);
 }
-/** True when the caller asked for JSON output (`--json` or `--format json`). */
-function wantsJson(options) {
-    return Boolean(options.json || options.format === "json");
-}

package/dist/cli/parseargv.js

@@ -140,13 +140,19 @@ function levenshtein(a, b) {
 }
 /** src/orchestrator.ts:875-887 — nearest known command by edit distance.
  *  Gives `undefined` when the input is under 2 chars, or when the best
- *  distance is over 3 or over half the input length. */
+ *  distance is over 3 or over half the input length. Never gives back the
+ *  input itself: a caller only asks for a suggestion when the input did
+ *  NOT resolve, so a distance-0 self-match (an alias token like
+ *  `audit-run` that IS in KNOWN_COMMANDS but has no help rows of its own)
+ *  was a hint that pointed at the very thing the user just typed. */
 function suggestCommand(input) {
     if (!input || input.length < 2)
         return undefined;
     let best;
     let bestDistance = Infinity;
     for (const candidate of exports.KNOWN_COMMANDS) {
+        if (candidate === input)
+            continue;
         const distance = levenshtein(input, candidate);
         if (distance < bestDistance) {
             bestDistance = distance;