@abacus-ai/cli 2.0.0-canary.1 → 2.0.0-canary.2

package/src/lib/__tests__/ansi.test.ts

@@ -1,255 +0,0 @@
-// @vitest-environment node
-
-import { describe, expect, it, vi } from "vitest";
-
-import {
-  ANSI,
-  osc9,
-  osc777,
-  osc99,
-  osc9Progress,
-  osc1337ProgressClear,
-  osc1337ProgressState,
-  osc1337ProgressPercent,
-  ansiRegex,
-  stripAnsi,
-} from "../ansi.js";
-
-describe.concurrent("ansi", () => {
-  describe.concurrent("ANSI enum", () => {
-    it("should have correct escape character", () => {
-      expect(ANSI.ESC).toBe("\x1b");
-    });
-
-    it("should have correct bell character", () => {
-      expect(ANSI.BEL).toBe("\x07");
-    });
-
-    it("should have correct string terminator", () => {
-      expect(ANSI.ST).toBe("\x1b\\");
-    });
-
-    it("should construct focus reporting sequences correctly", () => {
-      expect(ANSI.ENABLE_FOCUS_REPORTING).toBe("\x1b[?1004h");
-      expect(ANSI.DISABLE_FOCUS_REPORTING).toBe("\x1b[?1004l");
-      expect(ANSI.FOCUS_IN).toBe("\x1b[I");
-      expect(ANSI.FOCUS_OUT).toBe("\x1b[O");
-    });
-
-    it("should construct cursor sequences correctly", () => {
-      expect(ANSI.SHOW_CURSOR).toBe("\x1b[?25h");
-      expect(ANSI.HIDE_CURSOR).toBe("\x1b[?25l");
-    });
-
-    it("should construct reset sequences correctly", () => {
-      expect(ANSI.RESET_SGR).toBe("\x1b[0m");
-      expect(ANSI.SOFT_RESET).toBe("\x1b[!p");
-      expect(ANSI.HARD_RESET).toBe("\x1bc");
-    });
-
-    it("should construct paste mode sequences correctly", () => {
-      expect(ANSI.ENABLE_BRACKETED_PASTE).toBe("\x1b[?2004h");
-      expect(ANSI.DISABLE_BRACKETED_PASTE).toBe("\x1b[?2004l");
-      expect(ANSI.PASTE_MODE_PREFIX).toBe("\x1b[200~");
-      expect(ANSI.PASTE_MODE_SUFFIX).toBe("\x1b[201~");
-    });
-
-    it("should construct style sequences correctly", () => {
-      expect(ANSI.DIM).toBe("\x1b[2m");
-      expect(ANSI.BOLD).toBe("\x1b[1m");
-    });
-  });
-
-  describe.concurrent("osc9", () => {
-    it("should format OSC 9 notification correctly", () => {
-      const result = osc9("test message");
-      expect(result).toBe("\x1b]9;\n\ntest message\x07");
-    });
-
-    it("should handle empty message", () => {
-      const result = osc9("");
-      expect(result).toBe("\x1b]9;\n\n\x07");
-    });
-  });
-
-  describe.concurrent("osc777", () => {
-    it("should format OSC 777 notification correctly", () => {
-      const result = osc777("Title", "Body");
-      expect(result).toBe("\x1b]777;notify;Title;Body\x07");
-    });
-
-    it("should handle empty title and body", () => {
-      const result = osc777("", "");
-      expect(result).toBe("\x1b]777;notify;;\x07");
-    });
-  });
-
-  describe.concurrent("osc99", () => {
-    it("should format OSC 99 notification correctly", () => {
-      // Mock Math.random to get predictable notification ID
-      const mockRandom = vi.spyOn(Math, "random").mockReturnValue(0.1234);
-      const result = osc99("Title", "Body");
-
-      // Should contain title and body parts
-      expect(result).toContain("]99;i=1234:d=0:p=title;Title\x1b\\");
-      expect(result).toContain("]99;i=1234:p=body;Body\x1b\\");
-      expect(result).toContain("]99;i=1234:d=1:a=focus;\x1b\\");
-
-      mockRandom.mockRestore();
-    });
-  });
-
-  describe.concurrent("osc9Progress", () => {
-    it("should format progress with state 0 (hide)", () => {
-      const result = osc9Progress(0);
-      expect(result).toBe("\x1b]9;4;0;0\x07\x1b]9;4;0;0\x1b\\");
-    });
-
-    it("should format progress with state 1 and percentage", () => {
-      const result = osc9Progress(1, 50);
-      expect(result).toBe("\x1b]9;4;1;50\x07\x1b]9;4;1;50\x1b\\");
-    });
-
-    it("should clamp progress to 0-100", () => {
-      expect(osc9Progress(1, -10)).toBe("\x1b]9;4;1;0\x07\x1b]9;4;1;0\x1b\\");
-      expect(osc9Progress(1, 150)).toBe("\x1b]9;4;1;100\x07\x1b]9;4;1;100\x1b\\");
-    });
-
-    it("should round progress values", () => {
-      expect(osc9Progress(1, 50.7)).toBe("\x1b]9;4;1;51\x07\x1b]9;4;1;51\x1b\\");
-    });
-  });
-
-  describe.concurrent("osc1337ProgressClear", () => {
-    it("should clear progress indicator", () => {
-      const result = osc1337ProgressClear();
-      expect(result).toBe("\x1b]1337;Progress=\x07\x1b]1337;Progress=\x1b\\");
-    });
-  });
-
-  describe.concurrent("osc1337ProgressState", () => {
-    it("should set progress state 0", () => {
-      const result = osc1337ProgressState(0);
-      expect(result).toBe("\x1b]1337;Progress=0\x07\x1b]1337;Progress=0\x1b\\");
-    });
-
-    it("should set progress state 1", () => {
-      const result = osc1337ProgressState(1);
-      expect(result).toBe("\x1b]1337;Progress=1\x07\x1b]1337;Progress=1\x1b\\");
-    });
-
-    it("should set progress state 2", () => {
-      const result = osc1337ProgressState(2);
-      expect(result).toBe("\x1b]1337;Progress=2\x07\x1b]1337;Progress=2\x1b\\");
-    });
-  });
-
-  describe.concurrent("osc1337ProgressPercent", () => {
-    it("should format progress with percentage only", () => {
-      const result = osc1337ProgressPercent(50);
-      expect(result).toBe("\x1b]1337;Progress=50\x07\x1b]1337;Progress=50\x1b\\");
-    });
-
-    it("should format progress with percentage and message", () => {
-      const result = osc1337ProgressPercent(75, "Loading...");
-      expect(result).toContain("]1337;Progress=75;Loading...\x07");
-      expect(result).toContain("]1337;Progress=message=Loading...;percent=75\x07");
-    });
-
-    it("should clamp percentage to 0-100", () => {
-      expect(osc1337ProgressPercent(-10)).toBe(
-        "\x1b]1337;Progress=0\x07\x1b]1337;Progress=0\x1b\\",
-      );
-      expect(osc1337ProgressPercent(150)).toBe(
-        "\x1b]1337;Progress=100\x07\x1b]1337;Progress=100\x1b\\",
-      );
-    });
-
-    it("should round percentage values", () => {
-      expect(osc1337ProgressPercent(50.7)).toBe(
-        "\x1b]1337;Progress=51\x07\x1b]1337;Progress=51\x1b\\",
-      );
-    });
-
-    it("should sanitize message content", () => {
-      const result = osc1337ProgressPercent(50, "test\x1b\x07\n\r;message");
-      // The sanitized message should not contain control chars or semicolons
-      // (they're replaced/removed in the message part, but \x1b is still in OSC wrapper)
-      expect(result).toContain("test  :message"); // \x1b and \x07 removed, \n\r become spaces, ; becomes :
-      // The message part should not have raw control characters
-      const messagePart = result.match(
-        new RegExp("Progress=\\d+;(.+?)[" + String.fromCharCode(7) + String.fromCharCode(27) + "]"),
-      )?.[1];
-      expect(messagePart).not.toContain("\x07");
-      expect(messagePart).not.toContain("\n");
-      expect(messagePart).not.toContain("\r");
-      expect(messagePart).not.toContain(";"); // Should be replaced with :
-    });
-
-    it("should truncate long messages", () => {
-      const longMessage = "a".repeat(200);
-      const result = osc1337ProgressPercent(50, longMessage);
-      // Message is truncated to 120 chars, but result includes OSC sequences
-      // Extract the message part to verify truncation
-      const messagePart = result.match(
-        new RegExp("Progress=\\d+;(.+?)[" + String.fromCharCode(7) + String.fromCharCode(27) + "]"),
-      )?.[1];
-      expect(messagePart?.length).toBeLessThanOrEqual(120);
-    });
-  });
-
-  describe.concurrent("ansiRegex", () => {
-    it("should match ANSI escape sequences", () => {
-      const regex = ansiRegex();
-      expect("\x1b[31mtest\x1b[0m".match(regex)).toHaveLength(2);
-    });
-
-    it("should match OSC sequences", () => {
-      const regex = ansiRegex();
-      expect("\x1b]0;title\x07".match(regex)).toHaveLength(1);
-    });
-
-    it("should match only first occurrence when onlyFirst is true", () => {
-      const regex = ansiRegex({ onlyFirst: true });
-      const matches = "\x1b[31mtest\x1b[0m".match(regex);
-      expect(matches).toHaveLength(1);
-    });
-
-    it("should match all occurrences when onlyFirst is false", () => {
-      const regex = ansiRegex({ onlyFirst: false });
-      const matches = "\x1b[31mtest\x1b[0m".match(regex);
-      expect(matches).toHaveLength(2);
-    });
-  });
-
-  describe.concurrent("stripAnsi", () => {
-    it("should strip ANSI codes from string", () => {
-      expect(stripAnsi("\x1b[31mtest\x1b[0m")).toBe("test");
-    });
-
-    it("should handle strings without ANSI codes", () => {
-      expect(stripAnsi("plain text")).toBe("plain text");
-    });
-
-    it("should handle empty strings", () => {
-      expect(stripAnsi("")).toBe("");
-    });
-
-    it("should throw error for non-string input", () => {
-      expect(() => stripAnsi(null as unknown as string)).toThrow(
-        "Expected a `string`, got `object`",
-      );
-      expect(() => stripAnsi(123 as unknown as string)).toThrow(
-        "Expected a `string`, got `number`",
-      );
-    });
-
-    it("should strip multiple ANSI codes", () => {
-      expect(stripAnsi("\x1b[31mred\x1b[0m \x1b[32mgreen\x1b[0m")).toBe("red green");
-    });
-
-    it("should strip OSC sequences", () => {
-      expect(stripAnsi("\x1b]0;title\x07")).toBe("");
-    });
-  });
-});

package/src/lib/__tests__/cli.test.ts

@@ -1,122 +0,0 @@
-// @vitest-environment node
-
-import { describe, expect, it } from "vitest";
-
-import { runCli } from "../cli.js";
-
-// TODO: The runCli function doesn't handle spawn errors (ENOENT).
-// When a non-existent command is spawned, the error is emitted asynchronously
-// and not caught by the generator, causing unhandled promise rejections.
-// Consider adding error handling to runCli to catch and handle spawn errors
-// (e.g., proc.on('error', ...) to yield error information or throw).
-
-describe.concurrent("cli", () => {
-  describe.concurrent("runCli", () => {
-    it("should yield output from stdout", async () => {
-      const command = process.platform === "win32" ? "echo" : "echo";
-      const args = ["hello world"];
-      const outputs: string[] = [];
-
-      for await (const output of runCli(command, args)) {
-        outputs.push(output);
-      }
-
-      // On Unix, echo outputs to stdout; on Windows, we might need different handling
-      // The output might include newlines, so we check if it contains our message
-      // Should have received some output
-      expect(outputs.length).toBeGreaterThanOrEqual(0);
-    }, 10000);
-
-    it("should yield output from stderr", async () => {
-      // Use a command that outputs to stderr
-      const command = process.platform === "win32" ? "cmd" : "sh";
-      const args =
-        process.platform === "win32" ? ["/c", "echo error >&2"] : ["-c", "echo error >&2"];
-
-      const outputs: string[] = [];
-
-      for await (const output of runCli(command, args)) {
-        outputs.push(output);
-      }
-
-      // Should have received some output
-      expect(outputs.length).toBeGreaterThanOrEqual(0);
-    }, 10000);
-
-    it("should handle commands that exit immediately", async () => {
-      const command = process.platform === "win32" ? "echo" : "echo";
-      const args = ["test"];
-      const outputs: string[] = [];
-
-      for await (const output of runCli(command, args)) {
-        outputs.push(output);
-      }
-
-      // Should complete without hanging
-      expect(true).toBe(true);
-    }, 10000);
-
-    it("should handle empty args array", async () => {
-      const command = process.platform === "win32" ? "echo" : "echo";
-      const args: string[] = [];
-      const outputs: string[] = [];
-
-      for await (const output of runCli(command, args)) {
-        outputs.push(output);
-      }
-
-      // Should complete without error
-      expect(true).toBe(true);
-    }, 10000);
-
-    it("should handle multiple output chunks", async () => {
-      // Use a command that outputs multiple lines
-      const command = process.platform === "win32" ? "echo" : "printf";
-      const args =
-        process.platform === "win32"
-          ? ["line1\nline2\nline3"]
-          : ["%s\n%s\n%s\n", "line1", "line2", "line3"];
-
-      const outputs: string[] = [];
-
-      for await (const output of runCli(command, args)) {
-        outputs.push(output);
-      }
-
-      // Should have received output
-      expect(outputs.length).toBeGreaterThanOrEqual(0);
-    }, 10000);
-
-    it("should terminate process on completion", async () => {
-      const command = process.platform === "win32" ? "echo" : "echo";
-      const args = ["test"];
-
-      // This test verifies the process is cleaned up
-      // We can't easily verify the process is killed, but we can verify
-      // the generator completes
-      const generator = runCli(command, args);
-      const outputs: string[] = [];
-
-      for await (const output of generator) {
-        outputs.push(output);
-      }
-
-      // Generator should complete
-      expect(true).toBe(true);
-    }, 10000);
-
-    it("should work with different command types", async () => {
-      // Test with a simple command available on most systems
-      const command = process.platform === "win32" ? "where" : "which";
-      const args = process.platform === "win32" ? ["echo"] : ["echo"];
-      const outputs: string[] = [];
-
-      for await (const output of runCli(command, args)) {
-        outputs.push(output);
-      }
-
-      // Should complete without error
-      expect(true).toBe(true);
-    }, 10000);
-  });
-});

package/src/lib/__tests__/commands.test.ts

@@ -1,325 +0,0 @@
-// @vitest-environment node
-
-import { describe, expect, it } from "vitest";
-
-import {
-  Command,
-  COMMAND_INFO,
-  getCommandInfo,
-  getAllCommands,
-  isValidCommand,
-  formatCommandHelp,
-  getCommandSuggestions,
-  getCommandWithDescription,
-  McpSubcommand,
-  MCP_COMMAND_INFO,
-  getMcpCommandInfo,
-  getAllMcpSubcommands,
-  isValidMcpSubcommand,
-  formatMcpCommandHelp,
-  parseMcpCommand,
-} from "../commands.js";
-
-describe.concurrent("commands", () => {
-  describe.concurrent("Command enum", () => {
-    it("should have all expected commands", () => {
-      expect(Command.Stop).toBe("/stop");
-      expect(Command.Quit).toBe("/quit");
-      expect(Command.Exit).toBe("/exit");
-      expect(Command.Q).toBe("/q");
-      expect(Command.Bye).toBe("/bye");
-      expect(Command.Clear).toBe("/clear");
-      expect(Command.New).toBe("/new");
-      expect(Command.Suggest).toBe("/");
-      expect(Command.Help).toBe("/help");
-      expect(Command.Sidebar).toBe("/sidebar");
-      expect(Command.Login).toBe("/login");
-      expect(Command.Logout).toBe("/logout");
-      expect(Command.Mcp).toBe("/mcp");
-    });
-  });
-
-  describe.concurrent("COMMAND_INFO", () => {
-    it("should have info for all commands", () => {
-      const commandsInInfo = COMMAND_INFO.map((info) => info.command);
-      const allCommands = Object.values(Command);
-
-      // Check that all commands have info (some commands like Quit, Exit, Q, Bye might share the same behavior)
-      expect(commandsInInfo.length).toBeGreaterThan(0);
-      expect(COMMAND_INFO.every((info) => allCommands.includes(info.command))).toBe(true);
-    });
-
-    it("should have valid structure for each command info", () => {
-      COMMAND_INFO.forEach((info) => {
-        expect(info).toHaveProperty("command");
-        expect(info).toHaveProperty("description");
-        expect(info).toHaveProperty("usage");
-        expect(typeof info.description).toBe("string");
-        expect(typeof info.usage).toBe("string");
-      });
-    });
-  });
-
-  describe.concurrent("getCommandInfo", () => {
-    it("should return command info for valid command", () => {
-      const info = getCommandInfo(Command.Stop);
-      expect(info).toBeDefined();
-      expect(info?.command).toBe(Command.Stop);
-      expect(info?.description).toBe("Stop the current streaming response");
-    });
-
-    it("should return undefined for command not in COMMAND_INFO", () => {
-      // Note: This tests the function behavior, but all commands should have info
-      // If this fails, it means a command is missing from COMMAND_INFO
-      const allCommands = Object.values(Command);
-      allCommands.forEach((cmd) => {
-        const info = getCommandInfo(cmd);
-        // At least Stop should have info
-        if (cmd === Command.Stop) {
-          expect(info).toBeDefined();
-        }
-      });
-    });
-  });
-
-  describe.concurrent("getAllCommands", () => {
-    it("should return all command values", () => {
-      const commands = getAllCommands();
-      expect(commands).toBeInstanceOf(Array);
-      expect(commands.length).toBeGreaterThan(0);
-      expect(commands).toContain(Command.Stop);
-      expect(commands).toContain(Command.Help);
-    });
-
-    it("should return all unique commands", () => {
-      const commands = getAllCommands();
-      const uniqueCommands = new Set(commands);
-      expect(commands.length).toBe(uniqueCommands.size);
-    });
-  });
-
-  describe.concurrent("isValidCommand", () => {
-    it("should return true for valid commands", () => {
-      expect(isValidCommand("/stop")).toBe(true);
-      expect(isValidCommand("/help")).toBe(true);
-      expect(isValidCommand("/clear")).toBe(true);
-    });
-
-    it("should return false for invalid commands", () => {
-      expect(isValidCommand("/invalid")).toBe(false);
-      expect(isValidCommand("stop")).toBe(false);
-      expect(isValidCommand("")).toBe(false);
-      expect(isValidCommand("/unknown")).toBe(false);
-    });
-  });
-
-  describe.concurrent("formatCommandHelp", () => {
-    it("should return a formatted help string", () => {
-      const help = formatCommandHelp();
-      expect(typeof help).toBe("string");
-      expect(help.length).toBeGreaterThan(0);
-    });
-
-    it("should include command information", () => {
-      const help = formatCommandHelp();
-      expect(help).toContain("Abacus.AI CLI");
-      expect(help).toContain("/stop");
-      expect(help).toContain("/help");
-    });
-
-    it("should format commands with proper alignment", () => {
-      const help = formatCommandHelp();
-      // Check that usage and description are aligned
-      const lines = help.split("\n");
-      const commandLines = lines.filter(
-        (line) => line.trim().startsWith("/") && line.includes(" "),
-      );
-      expect(commandLines.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe.concurrent("getCommandSuggestions", () => {
-    it("should return matching commands for partial input", () => {
-      const suggestions = getCommandSuggestions("help");
-      expect(suggestions).toContain(Command.Help);
-    });
-
-    it("should be case insensitive", () => {
-      const suggestions1 = getCommandSuggestions("HELP");
-      const suggestions2 = getCommandSuggestions("help");
-      expect(suggestions1).toEqual(suggestions2);
-    });
-
-    it("should return empty array for no matches", () => {
-      const suggestions = getCommandSuggestions("xyz123nonexistent");
-      expect(suggestions).toEqual([]);
-    });
-
-    it("should return all commands for empty string", () => {
-      const suggestions = getCommandSuggestions("");
-      expect(suggestions.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe.concurrent("getCommandWithDescription", () => {
-    it("should return command with description for valid command", () => {
-      const result = getCommandWithDescription(Command.Stop);
-      expect(result).toContain("/stop");
-      expect(result).toContain("Stop");
-    });
-
-    it("should return just command if info not found", () => {
-      // This tests edge case - in practice all commands should have info
-      const result = getCommandWithDescription(Command.Stop);
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe.concurrent("McpSubcommand enum", () => {
-    it("should have all expected subcommands", () => {
-      expect(McpSubcommand.Add).toBe("add");
-      expect(McpSubcommand.Remove).toBe("remove");
-      expect(McpSubcommand.List).toBe("list");
-      expect(McpSubcommand.Get).toBe("get");
-      expect(McpSubcommand.AddJson).toBe("add-json");
-      expect(McpSubcommand.Help).toBe("help");
-    });
-  });
-
-  describe.concurrent("MCP_COMMAND_INFO", () => {
-    it("should have info for all subcommands", () => {
-      const subcommandsInInfo = MCP_COMMAND_INFO.map((info) => info.subcommand);
-      const allSubcommands = Object.values(McpSubcommand);
-
-      allSubcommands.forEach((subcmd) => {
-        expect(subcommandsInInfo).toContain(subcmd);
-      });
-    });
-
-    it("should have valid structure for each subcommand info", () => {
-      MCP_COMMAND_INFO.forEach((info) => {
-        expect(info).toHaveProperty("subcommand");
-        expect(info).toHaveProperty("description");
-        expect(info).toHaveProperty("usage");
-        expect(typeof info.description).toBe("string");
-        expect(typeof info.usage).toBe("string");
-      });
-    });
-  });
-
-  describe.concurrent("getMcpCommandInfo", () => {
-    it("should return command info for valid subcommand", () => {
-      const info = getMcpCommandInfo(McpSubcommand.Add);
-      expect(info).toBeDefined();
-      expect(info?.subcommand).toBe(McpSubcommand.Add);
-      expect(info?.description).toBe("Add a server");
-    });
-
-    it("should return undefined for invalid subcommand", () => {
-      const info = getMcpCommandInfo("invalid" as McpSubcommand);
-      expect(info).toBeUndefined();
-    });
-  });
-
-  describe.concurrent("getAllMcpSubcommands", () => {
-    it("should return all subcommand values", () => {
-      const subcommands = getAllMcpSubcommands();
-      expect(subcommands).toBeInstanceOf(Array);
-      expect(subcommands.length).toBeGreaterThan(0);
-      expect(subcommands).toContain(McpSubcommand.Add);
-      expect(subcommands).toContain(McpSubcommand.List);
-    });
-  });
-
-  describe.concurrent("isValidMcpSubcommand", () => {
-    it("should return true for valid subcommands", () => {
-      expect(isValidMcpSubcommand("add")).toBe(true);
-      expect(isValidMcpSubcommand("list")).toBe(true);
-      expect(isValidMcpSubcommand("help")).toBe(true);
-    });
-
-    it("should return false for invalid subcommands", () => {
-      expect(isValidMcpSubcommand("invalid")).toBe(false);
-      expect(isValidMcpSubcommand("")).toBe(false);
-      expect(isValidMcpSubcommand("unknown")).toBe(false);
-    });
-  });
-
-  describe.concurrent("formatMcpCommandHelp", () => {
-    it("should return a formatted help string", () => {
-      const help = formatMcpCommandHelp();
-      expect(typeof help).toBe("string");
-      expect(help.length).toBeGreaterThan(0);
-    });
-
-    it("should include MCP command information", () => {
-      const help = formatMcpCommandHelp();
-      expect(help).toContain("MCP");
-      expect(help).toContain("add");
-      expect(help).toContain("list");
-    });
-  });
-
-  describe.concurrent("parseMcpCommand", () => {
-    it("should parse valid MCP command with subcommand", () => {
-      const result = parseMcpCommand("/mcp add server-name");
-      expect(result.subcommand).toBe(McpSubcommand.Add);
-      expect(result.args).toEqual(["server-name"]);
-    });
-
-    it("should parse command with multiple args", () => {
-      const result = parseMcpCommand("/mcp add server-name command arg1 arg2");
-      expect(result.subcommand).toBe(McpSubcommand.Add);
-      expect(result.args).toEqual(["server-name", "command", "arg1", "arg2"]);
-    });
-
-    it("should handle quoted arguments", () => {
-      const result = parseMcpCommand('/mcp add "server name" "command with spaces"');
-      expect(result.subcommand).toBe(McpSubcommand.Add);
-      expect(result.args).toEqual(["server name", "command with spaces"]);
-    });
-
-    it("should handle single-quoted arguments", () => {
-      const result = parseMcpCommand("/mcp add 'server name' 'command'");
-      expect(result.subcommand).toBe(McpSubcommand.Add);
-      expect(result.args).toEqual(["server name", "command"]);
-    });
-
-    it("should return empty args for non-MCP command", () => {
-      const result = parseMcpCommand("/help");
-      expect(result.subcommand).toBeUndefined();
-      expect(result.args).toEqual([]);
-    });
-
-    it("should handle command without subcommand", () => {
-      const result = parseMcpCommand("/mcp");
-      expect(result.subcommand).toBeUndefined();
-      expect(result.args).toEqual([]);
-    });
-
-    it("should handle invalid subcommand", () => {
-      const result = parseMcpCommand("/mcp invalid-subcommand arg1");
-      expect(result.subcommand).toBeUndefined();
-      // The first argument (subcommand) is removed from args even if invalid
-      expect(result.args).toEqual(["arg1"]);
-    });
-
-    it("should handle extra whitespace", () => {
-      const result = parseMcpCommand("/mcp   add   server-name   ");
-      expect(result.subcommand).toBe(McpSubcommand.Add);
-      expect(result.args).toEqual(["server-name"]);
-    });
-
-    it("should handle mixed quoted and unquoted args", () => {
-      const result = parseMcpCommand('/mcp add server-name "quoted arg" unquoted');
-      expect(result.subcommand).toBe(McpSubcommand.Add);
-      expect(result.args).toEqual(["server-name", "quoted arg", "unquoted"]);
-    });
-
-    it("should handle empty string", () => {
-      const result = parseMcpCommand("");
-      expect(result.subcommand).toBeUndefined();
-      expect(result.args).toEqual([]);
-    });
-  });
-});