argsbarg 1.4.1 → 1.4.3

package/src/index.test.ts

@@ -19,12 +19,14 @@ import {
 } from "./mcp/tools.ts";
 import { applyShellEnv, loadEnvFile } from "./mcp/env.ts";
 import { buildToolCallSuccess } from "./mcp/result.ts";
+import { generateSkillBundle } from "./skill/generate.ts";
+import { cliSkillInstall } from "./skill/install.ts";
 import { ParseKind, parse, postParseValidate } from "./parse.ts";
 import { cliSchemaJson } from "./schema.ts";
 import { cliValidateRoot } from "./validate.ts";
 import { expect, test } from "bun:test";
 import { $ } from "bun";
-import { mkdtempSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -334,7 +336,7 @@ test("trailing options include parent-scoped flags", () => {
   expect(pr.opts["json"]).toBe("1");
 });
 
-test("varargs tail does not parse trailing options", () => {
+test("varargs tail parses trailing options", () => {
   const root: CliCommand = {
     key: "app",
     description: "",
@@ -365,8 +367,8 @@ test("varargs tail does not parse trailing options", () => {
   cliValidateRoot(root);
   const pr = postParseValidate(root, parse(root, ["x", "./file", "--json"]));
   expect(pr.kind).toBe(ParseKind.Ok);
-  expect(pr.args).toEqual(["./file", "--json"]);
-  expect(pr.opts["json"]).toBeUndefined();
+  expect(pr.args).toEqual(["./file"]);
+  expect(pr.opts["json"]).toBe("1");
 });
 
 test("stops parsing options at --", () => {
@@ -727,7 +729,7 @@ async function mcpRequest(
   opts?: { script?: string; env?: Record<string, string> },
 ): Promise<Map<string | number, object>> {
   const script = opts?.script ?? "examples/nested.ts";
-  const proc = Bun.spawn(["bun", "run", script, "mcp"], {
+  const proc = Bun.spawn(["bun", "run", script, "ai", "mcp"], {
     stdin: "pipe",
     stdout: "pipe",
     stderr: "pipe",
@@ -775,7 +777,7 @@ test("collectMcpTools lists user leaf commands only", () => {
   expect(names).toContain("stat_owner_lookup");
   expect(names).toContain("read");
   expect(names).not.toContain("hidden");
-  expect(names).not.toContain("mcp");
+  expect(names).not.toContain("ai");
   expect(names).not.toContain("completion");
   const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
   expect(lookup.description).toBe("stat owner lookup — Resolve owner info.");
@@ -807,19 +809,34 @@ test("mcpToolCallToArgv expands varargs positionals", () => {
   expect(argv).toEqual(["read", "a", "b"]);
 });
 
-test("reserved command name mcp is rejected", () => {
+test("reserved command name ai is rejected", () => {
   const root: CliCommand = {
     key: "app",
     description: "",
     commands: [
       {
-        key: "mcp",
+        key: "ai",
         description: "bad",
         handler: () => {},
       },
     ],
   };
-  expect(() => cliValidateRoot(root)).toThrow(/Reserved command name: mcp/);
+  expect(() => cliValidateRoot(root)).toThrow(/Reserved command name: ai/);
+});
+
+test("top-level command name mcp is allowed", () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "mcp",
+        description: "user command",
+        handler: () => {},
+      },
+    ],
+  };
+  expect(() => cliValidateRoot(root)).not.toThrow();
 });
 
 test("mcpServer on non-root node is rejected", () => {
@@ -997,10 +1014,10 @@ test("MCP ping returns empty result", async () => {
   expect(res.result).toEqual({});
 });
 
-test("minimal.ts mcp without opt-in fails", async () => {
-  const { stderr, exitCode } = await $`bun run examples/minimal.ts mcp`.nothrow().quiet();
+test("minimal.ts ai mcp without opt-in fails", async () => {
+  const { stderr, exitCode } = await $`bun run examples/minimal.ts ai mcp`.nothrow().quiet();
   expect(exitCode).toBe(1);
-  expect(stderr.toString()).toContain("mcp");
+  expect(stderr.toString()).toContain("MCP is not enabled");
 });
 
 test("ctx.invocation is cli via cliRun", async () => {
@@ -1330,4 +1347,433 @@ test("MCP envFile loads vars for tool handlers", async () => {
   const res = responses.get(15) as { result: { isError: boolean; content: { text: string }[] } };
   expect(res.result.isError).toBe(false);
   expect(res.result.content[0]!.text.trim()).toBe("file-value");
+});
+
+// ── v1.3 parser ergonomics ────────────────────────────────────────────────────
+
+function varargsReadFixture(): CliCommand {
+  return {
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "read",
+        description: "Read files.",
+        options: [
+          {
+            name: "json",
+            description: "",
+            kind: CliOptionKind.Presence,
+          },
+        ],
+        positionals: [
+          {
+            name: "files",
+            description: "",
+            kind: CliOptionKind.String,
+            argMin: 0,
+            argMax: 0,
+          },
+        ],
+        handler: () => {},
+      },
+    ],
+  };
+}
+
+function nestedDocsFallbackFixture(): CliCommand {
+  return {
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "docs",
+        description: "Documentation commands.",
+        fallbackCommand: "guide",
+        fallbackMode: CliFallbackMode.MissingOnly,
+        commands: [
+          {
+            key: "guide",
+            description: "User guide.",
+            handler: () => {},
+          },
+          {
+            key: "api",
+            description: "API reference.",
+            handler: () => {},
+          },
+        ],
+      },
+    ],
+  };
+}
+
+test("nested fallback routes to default when argv exhausted at router", () => {
+  const root = nestedDocsFallbackFixture();
+  cliValidateRoot(root);
+  const pr = postParseValidate(root, parse(root, ["docs"]));
+  expect(pr.kind).toBe(ParseKind.Ok);
+  expect(pr.path).toEqual(["docs", "guide"]);
+});
+
+test("nested fallback MissingOrUnknown routes unknown token to default", () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "docs",
+        description: "Documentation commands.",
+        fallbackCommand: "guide",
+        fallbackMode: CliFallbackMode.MissingOrUnknown,
+        commands: [
+          {
+            key: "guide",
+            description: "User guide.",
+            positionals: [
+              {
+                name: "topic",
+                description: "",
+                kind: CliOptionKind.String,
+                argMin: 0,
+                argMax: 0,
+              },
+            ],
+            handler: () => {},
+          },
+          {
+            key: "api",
+            description: "API reference.",
+            handler: () => {},
+          },
+        ],
+      },
+    ],
+  };
+  cliValidateRoot(root);
+  const pr = postParseValidate(root, parse(root, ["docs", "extra-topic"]));
+  expect(pr.kind).toBe(ParseKind.Ok);
+  expect(pr.path).toEqual(["docs", "guide"]);
+  expect(pr.args).toEqual(["extra-topic"]);
+});
+
+test("nested fallback MissingOnly errors on unknown subcommand", () => {
+  const root = nestedDocsFallbackFixture();
+  cliValidateRoot(root);
+  const pr = parse(root, ["docs", "nope"]);
+  expect(pr.kind).toBe(ParseKind.Error);
+  expect(pr.errorMsg).toContain("Unknown subcommand");
+});
+
+test("cliValidateRoot rejects invalid nested fallbackCommand", () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "docs",
+        description: "",
+        fallbackCommand: "missing",
+        commands: [
+          {
+            key: "guide",
+            description: "",
+            handler: () => {},
+          },
+        ],
+      },
+    ],
+  };
+  expect(() => cliValidateRoot(root)).toThrow(/fallbackCommand 'missing' is not a child of 'docs'/);
+});
+
+test("cliValidateRoot accepts nested fallbackCommand when child exists", () => {
+  const root = nestedDocsFallbackFixture();
+  expect(() => cliValidateRoot(root)).not.toThrow();
+});
+
+test("nested router scoped help does not route to fallback", () => {
+  const root = nestedDocsFallbackFixture();
+  cliValidateRoot(root);
+  const pr = parse(root, ["docs", "--help"]);
+  expect(pr.kind).toBe(ParseKind.Help);
+  expect(pr.helpPath).toEqual(["docs"]);
+  expect(pr.helpExplicit).toBe(true);
+  const help = cliHelpRender(root, pr.helpPath, false);
+  expect(help).toContain("api");
+  expect(help).toContain("guide");
+});
+
+test("varargs trailing option after positionals via cliInvoke", async () => {
+  const root = varargsReadFixture();
+  cliValidateRoot(root);
+  const pr = postParseValidate(root, parse(root, ["read", "file.txt", "--json"]));
+  expect(pr.kind).toBe(ParseKind.Ok);
+  expect(pr.args).toEqual(["file.txt"]);
+  expect(pr.opts["json"]).toBe("1");
+});
+
+test("varargs option before positionals", () => {
+  const root = varargsReadFixture();
+  cliValidateRoot(root);
+  const pr = postParseValidate(root, parse(root, ["read", "--json", "file.txt"]));
+  expect(pr.kind).toBe(ParseKind.Ok);
+  expect(pr.args).toEqual(["file.txt"]);
+  expect(pr.opts["json"]).toBe("1");
+});
+
+test("varargs multiple files then trailing option", () => {
+  const root = varargsReadFixture();
+  cliValidateRoot(root);
+  const pr = postParseValidate(root, parse(root, ["read", "a.txt", "b.txt", "--json"]));
+  expect(pr.kind).toBe(ParseKind.Ok);
+  expect(pr.args).toEqual(["a.txt", "b.txt"]);
+  expect(pr.opts["json"]).toBe("1");
+});
+
+test("varargs double dash forces positional", () => {
+  const root = varargsReadFixture();
+  cliValidateRoot(root);
+  const pr = postParseValidate(root, parse(root, ["read", "file.txt", "--", "--json"]));
+  expect(pr.kind).toBe(ParseKind.Ok);
+  expect(pr.args).toEqual(["file.txt", "--json"]);
+  expect(pr.opts["json"]).toBeUndefined();
+});
+
+test("varargs unknown flag errors", async () => {
+  const root = varargsReadFixture();
+  cliValidateRoot(root);
+  const result = await cliInvoke(root, ["read", "--unknown"]);
+  expect(result.kind).toBe("error");
+  expect(result.stderr).toContain("--unknown");
+});
+
+test("varargs scoped help in tail", () => {
+  const root = varargsReadFixture();
+  cliValidateRoot(root);
+  const pr = parse(root, ["read", "file.txt", "--help"]);
+  expect(pr.kind).toBe(ParseKind.Help);
+  expect(pr.helpPath).toContain("read");
+  expect(pr.helpExplicit).toBe(true);
+});
+
+test("ctx.positional returns single slot value", async () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "x",
+        description: "",
+        positionals: [{ name: "path", description: "", kind: CliOptionKind.String }],
+        handler: (ctx) => {
+          captured = ctx.positional("path");
+        },
+      },
+    ],
+  };
+  let captured: string | string[] | undefined;
+  cliValidateRoot(root);
+  await cliInvoke(root, ["x", "./file"]);
+  expect(captured).toBe("./file");
+});
+
+test("ctx.positional returns varargs array", async () => {
+  const root = varargsReadFixture();
+  let captured: string | string[] | undefined;
+  root.commands![0]!.handler = (ctx) => {
+    captured = ctx.positional("files");
+  };
+  cliValidateRoot(root);
+  await cliInvoke(root, ["read", "a.txt", "b.txt"]);
+  expect(captured).toEqual(["a.txt", "b.txt"]);
+});
+
+test("ctx.positional returns undefined for absent optional slot", async () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "x",
+        description: "",
+        positionals: [
+          { name: "opt", description: "", kind: CliOptionKind.String, argMin: 0, argMax: 1 },
+        ],
+        handler: (ctx) => {
+          captured = ctx.positional("opt");
+        },
+      },
+    ],
+  };
+  let captured: string | string[] | undefined;
+  cliValidateRoot(root);
+  await cliInvoke(root, ["x"]);
+  expect(captured).toBeUndefined();
+});
+
+test("ctx.positional varargs matches ctx.args", async () => {
+  const root = varargsReadFixture();
+  let positional: string | string[] | undefined;
+  let args: string[] = [];
+  root.commands![0]!.handler = (ctx) => {
+    positional = ctx.positional("files");
+    args = ctx.args;
+  };
+  cliValidateRoot(root);
+  await cliInvoke(root, ["read", "a.txt", "b.txt"]);
+  expect(positional).toEqual(args);
+});
+
+test("mcpToolCallToArgv coerces comma-separated string for varargs", () => {
+  const tools = collectMcpTools(nestedMcpFixture);
+  const read = tools.find((t) => t.name === "read")!;
+  const argv = mcpToolCallToArgv(nestedMcpFixture, read, { files: "a,b" });
+  expect(argv).toEqual(["read", "a", "b"]);
+});
+
+test("mcpToolCallToArgv coerces single string for varargs", () => {
+  const tools = collectMcpTools(nestedMcpFixture);
+  const read = tools.find((t) => t.name === "read")!;
+  const argv = mcpToolCallToArgv(nestedMcpFixture, read, { files: "a" });
+  expect(argv).toEqual(["read", "a"]);
+});
+
+test("mcpToolCallToArgv array varargs unchanged", () => {
+  const tools = collectMcpTools(nestedMcpFixture);
+  const read = tools.find((t) => t.name === "read")!;
+  const argv = mcpToolCallToArgv(nestedMcpFixture, read, { files: ["a", "b"] });
+  expect(argv).toEqual(["read", "a", "b"]);
+});
+
+test("mcpToolCallToArgv empty string varargs appends nothing", () => {
+  const tools = collectMcpTools(nestedMcpFixture);
+  const read = tools.find((t) => t.name === "read")!;
+  const argv = mcpToolCallToArgv(nestedMcpFixture, read, { files: "" });
+  expect(argv).toEqual(["read"]);
+});
+
+// ── AI builtins and skills ────────────────────────────────────────────────────
+
+test("aiSkill on non-root node is rejected", () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "x",
+        description: "",
+        aiSkill: { enabled: false },
+        handler: () => {},
+      },
+    ],
+  };
+  expect(() => cliValidateRoot(root)).toThrow(/aiSkill is only supported on the program root/);
+});
+
+test("generateSkillBundle includes frontmatter and command catalog", () => {
+  const bundle = generateSkillBundle(nestedMcpFixture, "cursor");
+  expect(bundle.dirName).toBe("nested_ts");
+  expect(bundle.skillMd).toMatch(/^---\nname: nested_ts\n/);
+  expect(bundle.skillMd).toContain("stat owner lookup");
+  expect(bundle.skillMd).toContain("ai mcp");
+  expect(bundle.referenceMd).toContain("```json");
+  expect(() => JSON.parse(bundle.referenceMd.match(/```json\n([\s\S]*?)\n```/)![1]!)).not.toThrow();
+});
+
+test("cliSkillInstall writes project Cursor skill files", () => {
+  const cwd = mkdtempSync(join(tmpdir(), "argsbarg-skill-"));
+  const prev = process.cwd();
+  process.chdir(cwd);
+  try {
+    const msg = cliSkillInstall(nestedMcpFixture, "cursor", { force: true });
+    expect(msg).toContain(".cursor/skills/nested_ts/");
+    const skillDir = join(cwd, ".cursor", "skills", "nested_ts");
+    expect(existsSync(join(skillDir, "SKILL.md"))).toBe(true);
+    expect(existsSync(join(skillDir, "reference.md"))).toBe(true);
+    expect(readFileSync(join(skillDir, "SKILL.md"), "utf8")).toContain("stat owner lookup");
+  } finally {
+    process.chdir(prev);
+    rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test("cliSkillInstall global uses HOME skills directory", () => {
+  const home = mkdtempSync(join(tmpdir(), "argsbarg-home-"));
+  const prevHome = process.env.HOME;
+  process.env.HOME = home;
+  try {
+    const msg = cliSkillInstall(nestedMcpFixture, "cursor", { global: true, force: true });
+    expect(msg).toContain(join(home, ".cursor", "skills", "nested_ts"));
+    expect(existsSync(join(home, ".cursor", "skills", "nested_ts", "SKILL.md"))).toBe(true);
+  } finally {
+    if (prevHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = prevHome;
+    }
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("cliSkillInstall fails when directory exists without force", () => {
+  const cwd = mkdtempSync(join(tmpdir(), "argsbarg-skill-dup-"));
+  const prev = process.cwd();
+  process.chdir(cwd);
+  const prevExit = process.exit;
+  let exitCode = 0;
+  process.exit = ((code?: number) => {
+    exitCode = code ?? 0;
+    throw new Error("exit");
+  }) as typeof process.exit;
+  try {
+    cliSkillInstall(nestedMcpFixture, "cursor", { force: true });
+    try {
+      cliSkillInstall(nestedMcpFixture, "cursor", {});
+    } catch {
+      // expected exit throw
+    }
+    expect(exitCode).toBe(1);
+  } finally {
+    process.exit = prevExit;
+    process.chdir(prev);
+    rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test("cliSkillInstall claude target uses .claude/skills", () => {
+  const cwd = mkdtempSync(join(tmpdir(), "argsbarg-skill-claude-"));
+  const prev = process.cwd();
+  process.chdir(cwd);
+  try {
+    const msg = cliSkillInstall(nestedMcpFixture, "claude", { force: true });
+    expect(msg).toContain(".claude/skills/nested_ts/");
+    expect(readFileSync(join(cwd, ".claude", "skills", "nested_ts", "SKILL.md"), "utf8")).toContain(
+      "Claude Code",
+    );
+  } finally {
+    process.chdir(prev);
+    rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test("ai skill cursor fails when aiSkill disabled", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "argsbarg-skill-off-"));
+  const script = join(dir, "skill-off.ts");
+  writeFileSync(
+    script,
+    `import { cliRun, CliCommand } from ${JSON.stringify(join(import.meta.dir, "index.ts"))};
+const cli: CliCommand = {
+  key: "offapp",
+  description: "demo",
+  aiSkill: { enabled: false },
+  commands: [{ key: "x", description: "x", handler: () => {} }],
+};
+await cliRun(cli);
+`,
+    "utf8",
+  );
+  const { stderr, exitCode } = await $`bun run ${script} ai skill cursor`.nothrow().quiet();
+  expect(exitCode).toBe(1);
+  expect(stderr.toString()).toContain("AI skills are disabled");
 });

package/src/mcp/tools.ts

@@ -150,7 +150,7 @@ export function collectMcpTools(root: CliCommand): McpToolDef[] {
   /** Walks the command tree and appends leaf tools. */
   function walk(cmd: CliCommand, path: string[]): void {
     if ("handler" in cmd && cmd.handler) {
-      if (cmd.key === "completion" || cmd.key === "mcp") {
+      if (cmd.key === "completion" || cmd.key === "ai") {
         return;
       }
       if (cmd.mcpTool?.enabled === false) {
@@ -232,12 +232,20 @@ export function mcpToolCallToArgv(
     const { argMin = 1, argMax = 1 } = p;
 
     if (argMax === 0) {
-      if (!Array.isArray(val)) {
-        return { error: `Missing argument: ${p.name}` };
-      }
-      for (const item of val) {
-        argv.push(String(item));
+      const raw = args[p.name];
+      let items: string[];
+      if (Array.isArray(raw)) {
+        items = raw.map(String);
+      } else if (typeof raw === "string") {
+        items = raw.includes(",")
+          ? raw.split(",").map((s) => s.trim()).filter(Boolean)
+          : raw.trim()
+            ? [raw.trim()]
+            : [];
+      } else {
+        items = [];
       }
+      argv.push(...items);
       continue;
     }
 

package/src/parse.ts

@@ -231,11 +231,6 @@ export function collectOptionDefs(root: CliCommand, path: string[]): CliOption[]
   return defs;
 }
 
-/** True when every positional slot has bounded arity (no `argMax: 0` varargs tail). */
-function allowsTrailingOptions(positionals: CliCommand["positionals"]): boolean {
-  return (positionals ?? []).every((p) => (p.argMax ?? 1) !== 0);
-}
-
 /** Fills `args` for a leaf from `startIdx` according to `node.positionals`. */
 function finishLeaf(
   node: CliCommand,
@@ -244,7 +239,7 @@ function finishLeaf(
   path: string[],
   opts: Record<string, string>,
   optionDefs: CliOption[],
-  forcePositionals: boolean,
+  forcePositionalsIn: boolean,
 ): ParseResult {
   /** Builds a parse error for positional consumption failures. */
   function errorResult(msg: string): ParseResult {
@@ -263,6 +258,7 @@ function finishLeaf(
 
   let idx = startIdx;
   const args: string[] = [];
+  let forcePositionals = forcePositionalsIn;
 
   for (const p of node.positionals ?? []) {
     const { argMin = 1, argMax = 1 } = p;
@@ -288,9 +284,37 @@ function finishLeaf(
     let count = 0;
     if (argMax === 0) {
       while (idx < argv.length) {
-        args.push(argv[idx]);
-        idx += 1;
-        count += 1;
+        const tok = argv[idx];
+
+        if (!forcePositionals && tok === "--") {
+          forcePositionals = true;
+          idx++;
+          continue;
+        }
+
+        if (!forcePositionals && isHelpTok(tok)) {
+          return helpResult(path, true);
+        }
+
+        if (!forcePositionals && tok.startsWith("-")) {
+          // MUST be false — lenient mode swallows unknown flags as positionals silently
+          const tailRep = consumeOptions(optionDefs, false, argv, idx, opts);
+          if (tailRep.report.err) {
+            return errorResult(tailRep.report.err);
+          }
+          if (tailRep.report.sawDoubleDash) {
+            forcePositionals = true;
+          }
+          if (tailRep.nextIndex > idx) {
+            idx = tailRep.nextIndex;
+            continue;
+          }
+          return errorResult(`Unexpected option token: ${tok}`);
+        }
+
+        args.push(tok);
+        idx++;
+        count++;
       }
     } else {
       while (count < argMax && idx < argv.length) {
@@ -305,7 +329,7 @@ function finishLeaf(
   }
 
   if (idx < argv.length) {
-    if (forcePositionals || !allowsTrailingOptions(node.positionals)) {
+    if (forcePositionals) {
       return errorResult("Unexpected extra arguments");
     }
 
@@ -483,6 +507,19 @@ export function parse(root: CliCommand, argv: string[]): ParseResult {
 
     if (i >= argv.length) {
       if ((current.commands ?? []).length > 0) {
+        const fb = current.fallbackCommand;
+        const fm = current.fallbackMode ?? CliFallbackMode.MissingOnly;
+        if (
+          fb !== undefined &&
+          (fm === CliFallbackMode.MissingOnly || fm === CliFallbackMode.MissingOrUnknown)
+        ) {
+          const fbNode = findChild(current.commands ?? [], fb);
+          if (fbNode) {
+            path.push(fb);
+            current = fbNode;
+            continue;
+          }
+        }
         return helpResult(path, false);
       }
       return finishLeaf(current, i, argv, path, opts, collectOptionDefs(root, path), forcePositionals);
@@ -513,6 +550,21 @@ export function parse(root: CliCommand, argv: string[]): ParseResult {
     }
 
     if ((current.commands ?? []).length > 0) {
+      const fb = current.fallbackCommand;
+      const fm = current.fallbackMode ?? CliFallbackMode.MissingOnly;
+      const canRouteUnknown =
+        fb !== undefined &&
+        (fm === CliFallbackMode.MissingOrUnknown || fm === CliFallbackMode.UnknownOnly);
+
+      if (canRouteUnknown) {
+        const fbNode = findChild(current.commands ?? [], fb!);
+        if (fbNode) {
+          path.push(fb!);
+          current = fbNode;
+          continue;
+        }
+      }
+
       return {
         kind: ParseKind.Error,
         path,