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

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([]);
-    });
-  });
-});

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

@@ -1,15 +0,0 @@
-// @vitest-environment node
-
-import { describe, expect, it } from "vitest";
-
-import { MAX_RECENT_CONVERSATIONS, TOOL_CALL_LIMIT } from "../constants.js";
-
-describe.concurrent("constants", () => {
-  it("should export MAX_RECENT_CONVERSATIONS as 25", () => {
-    expect(MAX_RECENT_CONVERSATIONS).toBe(25);
-  });
-
-  it("should export TOOL_CALL_LIMIT as Number.MAX_SAFE_INTEGER", () => {
-    expect(TOOL_CALL_LIMIT).toBe(Number.MAX_SAFE_INTEGER);
-  });
-});

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

@@ -1,25 +0,0 @@
-// @vitest-environment node
-
-import { describe, expect, it } from "vitest";
-
-import { Focusable } from "../focusables.js";
-
-describe.concurrent("focusables", () => {
-  it("should export Focusable enum with correct values", () => {
-    expect(Focusable.Composer).toBe("composer");
-    expect(Focusable.ModelSelector).toBe("model-selector");
-    expect(Focusable.Messages).toBe("messages");
-    expect(Focusable.Sidebar).toBe("sidebar");
-    expect(Focusable.ToolPermission).toBe("tool-permission");
-  });
-
-  it("should have all expected enum values", () => {
-    const values = Object.values(Focusable);
-    expect(values).toContain("composer");
-    expect(values).toContain("model-selector");
-    expect(values).toContain("messages");
-    expect(values).toContain("sidebar");
-    expect(values).toContain("tool-permission");
-    expect(values.length).toBe(5);
-  });
-});

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

@@ -1,231 +0,0 @@
-// @vitest-environment node
-
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
-import { describe, expect, it, beforeEach, afterEach } from "vitest";
-
-import { searchFiles } from "../fs.js";
-
-describe.concurrent("fs", () => {
-  let testDir: string;
-
-  beforeEach(async () => {
-    // Create a temporary directory for testing
-    testDir = join(tmpdir(), `fs-test-${Date.now()}`);
-    await mkdir(testDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    // Clean up test directory
-    await rm(testDir, { recursive: true, force: true });
-  });
-
-  describe.sequential("searchFiles", () => {
-    it("should return empty results for non-existent directory", async () => {
-      const nonExistentDir = join(testDir, "nonexistent");
-      const results: any[] = [];
-
-      for await (const result of searchFiles("test", { root: nonExistentDir })) {
-        results.push(result);
-      }
-
-      expect(results.length).toBe(0);
-    }, 15000);
-
-    it("should search files in a directory", async () => {
-      // Create test files
-      await writeFile(join(testDir, "test1.txt"), "content1");
-      await writeFile(join(testDir, "test2.js"), "content2");
-      await writeFile(join(testDir, "other.md"), "content3");
-
-      const results: any[] = [];
-      for await (const result of searchFiles("test", { root: testDir })) {
-        results.push(result);
-      }
-
-      expect(results.length).toBeGreaterThan(0);
-      const allPaths = results.flatMap((r) => r.paths);
-      expect(allPaths.some((p) => p.includes("test1") || p.includes("test2"))).toBe(true);
-    }, 15000);
-
-    it("should respect maxResults option", async () => {
-      // Create many test files
-      for (let i = 0; i < 20; i++) {
-        await writeFile(join(testDir, `file${i}.txt`), `content${i}`);
-      }
-
-      const results: any[] = [];
-      for await (const result of searchFiles("file", { root: testDir, maxResults: 5 })) {
-        results.push(result);
-      }
-
-      const allPaths = results.flatMap((r) => r.paths);
-      // Should respect maxResults (may yield multiple results as index builds)
-      expect(allPaths.length).toBeGreaterThanOrEqual(0);
-    }, 15000);
-
-    it("should handle empty query", async () => {
-      await writeFile(join(testDir, "file1.txt"), "content1");
-      await writeFile(join(testDir, "file2.txt"), "content2");
-
-      const results: any[] = [];
-      for await (const result of searchFiles("", { root: testDir })) {
-        results.push(result);
-      }
-
-      // Empty query should return baseline results
-      expect(results.length).toBeGreaterThanOrEqual(0);
-    }, 15000);
-
-    it("should handle includeHidden option", async () => {
-      await writeFile(join(testDir, ".hidden"), "hidden content");
-      await writeFile(join(testDir, "visible.txt"), "visible content");
-
-      const results: any[] = [];
-      for await (const result of searchFiles("hidden", {
-        root: testDir,
-        includeHidden: true,
-      })) {
-        results.push(result);
-      }
-
-      const allPaths = results.flatMap((r) => r.paths);
-      // With includeHidden, should find .hidden
-      expect(allPaths.length).toBeGreaterThanOrEqual(0);
-    }, 15000);
-
-    it("should exclude hidden files by default", async () => {
-      await writeFile(join(testDir, ".hidden"), "hidden content");
-      await writeFile(join(testDir, "visible.txt"), "visible content");
-
-      const results: any[] = [];
-      for await (const result of searchFiles("", { root: testDir })) {
-        results.push(result);
-      }
-
-      const allPaths = results.flatMap((r) => r.paths);
-      // Should not include .hidden in results by default
-      // (This is a behavior test - actual behavior depends on ripgrep)
-      expect(allPaths.length).toBeGreaterThanOrEqual(0);
-    }, 15000);
-
-    it("should handle globs option", async () => {
-      await writeFile(join(testDir, "file1.txt"), "content1");
-      await writeFile(join(testDir, "file2.js"), "content2");
-      await writeFile(join(testDir, "file3.md"), "content3");
-
-      const results: any[] = [];
-      for await (const result of searchFiles("file", {
-        root: testDir,
-        globs: ["*.txt", "*.js"],
-      })) {
-        results.push(result);
-      }
-
-      const allPaths = results.flatMap((r) => r.paths);
-      // Should filter by globs
-      expect(allPaths.length).toBeGreaterThanOrEqual(0);
-    }, 15000);
-
-    it("should handle ignoreGlobs option", async () => {
-      await writeFile(join(testDir, "include.txt"), "content1");
-      await writeFile(join(testDir, "exclude.js"), "content2");
-
-      const results: any[] = [];
-      for await (const result of searchFiles("", {
-        root: testDir,
-        ignoreGlobs: ["*.js"],
-      })) {
-        results.push(result);
-      }
-
-      const allPaths = results.flatMap((r) => r.paths);
-      // Should exclude files matching ignoreGlobs
-      expect(allPaths.length).toBeGreaterThanOrEqual(0);
-    }, 15000);
-
-    it("should handle nested directories", async () => {
-      const subDir = join(testDir, "sub", "nested");
-      await mkdir(subDir, { recursive: true });
-      await writeFile(join(subDir, "nested.txt"), "nested content");
-
-      const results: any[] = [];
-      for await (const result of searchFiles("nested", { root: testDir })) {
-        results.push(result);
-      }
-
-      const allPaths = results.flatMap((r) => r.paths);
-      expect(allPaths.some((p) => p.includes("nested"))).toBe(true);
-    }, 15000);
-
-    it("should yield results incrementally as index builds", async () => {
-      // Create files
-      for (let i = 0; i < 10; i++) {
-        await writeFile(join(testDir, `file${i}.txt`), `content${i}`);
-      }
-
-      const results: any[] = [];
-      for await (const result of searchFiles("file", { root: testDir })) {
-        results.push(result);
-        // Should yield at least one result
-        if (results.length > 0) {
-          break; // Exit early to test incremental behavior
-        }
-      }
-
-      // May yield cached results first, then updated results
-      expect(results.length).toBeGreaterThanOrEqual(0);
-    }, 15000);
-
-    it("should handle useRipgrep option", async () => {
-      await writeFile(join(testDir, "test.txt"), "content");
-
-      const results: any[] = [];
-      for await (const result of searchFiles("test", {
-        root: testDir,
-        useRipgrep: false,
-      })) {
-        results.push(result);
-      }
-
-      // Should work without ripgrep (fallback to file walk)
-      expect(results.length).toBeGreaterThanOrEqual(0);
-    }, 20000);
-
-    it("should handle useGitignore option", async () => {
-      await writeFile(join(testDir, ".gitignore"), "ignored.txt\n");
-      await writeFile(join(testDir, "ignored.txt"), "ignored");
-      await writeFile(join(testDir, "included.txt"), "included");
-
-      const results: any[] = [];
-      for await (const result of searchFiles("", {
-        root: testDir,
-        useGitignore: true,
-      })) {
-        results.push(result);
-      }
-
-      const allPaths = results.flatMap((r) => r.paths);
-      // Should respect .gitignore when useGitignore is true
-      expect(allPaths.length).toBeGreaterThanOrEqual(0);
-    }, 15000);
-
-    it("should return isDirectory flags correctly", async () => {
-      await mkdir(join(testDir, "subdir"), { recursive: true });
-      await writeFile(join(testDir, "file.txt"), "content");
-
-      const results: any[] = [];
-      for await (const result of searchFiles("", { root: testDir })) {
-        results.push(result);
-      }
-
-      // Check that isDirectory flags are present
-      if (results.length > 0) {
-        const firstResult = results[0];
-        expect(firstResult).toHaveProperty("isDirectory");
-        expect(Array.isArray(firstResult.isDirectory)).toBe(true);
-      }
-    }, 15000);
-  });
-});