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

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);
-  });
-});

package/src/lib/__tests__/markdown.test.tsx

@@ -1,348 +0,0 @@
-import styles from "ansi-styles";
-import React from "react";
-import stripAnsi from "strip-ansi";
-import { afterEach, describe, expect, it } from "vitest";
-
-import { ThemeProvider } from "../../theme/context.js";
-import { CodeBlock } from "../markdown/code-block.js";
-import { Link } from "../markdown/link.js";
-import { Markdown } from "../markdown/markdown.js";
-import { cleanup, logInk, render } from "../test-utils.js";
-
-const TestWrapper = ({ children }: React.PropsWithChildren) => (
-  <ThemeProvider>{children}</ThemeProvider>
-);
-
-describe.concurrent("markdown components", () => {
-  afterEach(() => {
-    cleanup();
-  });
-
-  describe.concurrent("Link", () => {
-    it("should render link with href and children", () => {
-      const ink = render(
-        <TestWrapper>
-          <Link href="https://example.com">Example Link</Link>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-
-      expect(output).toContain("Example Link");
-    });
-
-    it("should render link with different href", () => {
-      const ink = render(
-        <TestWrapper>
-          <Link href="https://test.com">Test</Link>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain("Test");
-    });
-
-    it("should handle empty children", () => {
-      const ink = render(
-        <TestWrapper>
-          <Link href="https://example.com">{""}</Link>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      // Should render without error
-      expect(output).toBeDefined();
-    });
-  });
-
-  describe.concurrent("CodeBlock", () => {
-    it("should render code block with children", () => {
-      const ink = render(
-        <TestWrapper>
-          <CodeBlock language="javascript">const x = 1;</CodeBlock>
-        </TestWrapper>,
-      );
-      // Code is syntax highlighted, so strip ANSI codes for comparison
-      logInk(ink);
-      const frame = ink.lastFrame();
-      expect(frame).toBeDefined();
-      const output = stripAnsi(frame!);
-      expect(output).toContain("const x = 1;");
-    });
-
-    it("should render code block without language", () => {
-      const ink = render(
-        <TestWrapper>
-          <CodeBlock>plain code</CodeBlock>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain("plain code");
-    });
-
-    it("should handle unsupported language", () => {
-      const ink = render(
-        <TestWrapper>
-          <CodeBlock language="nonexistent-lang">code</CodeBlock>
-        </TestWrapper>,
-      );
-      // Should fallback to plain text
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain("code");
-    });
-
-    it("should handle empty code", () => {
-      const ink = render(
-        <TestWrapper>
-          <CodeBlock language="javascript"></CodeBlock>
-        </TestWrapper>,
-      );
-      // Should render without error
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toBeDefined();
-    });
-  });
-
-  describe.concurrent("Markdown", () => {
-    it("should render simple markdown text", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>Hello world</Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain("Hello world");
-    });
-
-    it("should render markdown with code span", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>This is `code` inline</Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain("code");
-    });
-
-    it("should render markdown with code block", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>
-            {`\`\`\`javascript
-const x = 1;
-\`\`\``}
-          </Markdown>
-        </TestWrapper>,
-      );
-      // Code is syntax highlighted, so strip ANSI codes for comparison
-      logInk(ink);
-      const frame = ink.lastFrame();
-      expect(frame).toBeDefined();
-      const output = stripAnsi(frame!);
-      expect(output).toContain("const x = 1;");
-    });
-
-    it("should render markdown with link", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>[Example](https://example.com)</Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain("Example");
-      expect(output).toContain("https://example.com");
-    });
-
-    it("should render markdown with headers", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown># Header 1\n## Header 2</Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain("Header 1");
-      expect(output).toContain("Header 2");
-    });
-
-    it("should render markdown with list", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>
-            {`- Item 1
-- Item 2
-- Item 3`}
-          </Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain("Item 1");
-      expect(output).toContain("Item 2");
-      expect(output).toContain("Item 3");
-    });
-
-    it("should render markdown with numbered list", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>
-            {`1. First
-2. Second
-3. Third`}
-          </Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain("First");
-      expect(output).toContain("Second");
-      expect(output).toContain("Third");
-    });
-
-    it("should render markdown with blockquote", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>{"> This is a quote"}</Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain("This is a quote");
-    });
-
-    it("should render markdown with bold", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>**text1** text2</Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain(`${styles.bold.open}text1${styles.bold.close} text2`);
-    });
-
-    it("should render markdown with italic", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>*text1* text2</Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain(`${styles.italic.open}text1${styles.italic.close} text2`);
-    });
-
-    it("should render markdown with strikethrough", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>~text1~ text2</Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain(
-        `${styles.strikethrough.open}text1${styles.strikethrough.close} text2`,
-      );
-    });
-
-    it("should render markdown with italic using underscore", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>_text1_ text2</Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain(`${styles.italic.open}text1${styles.italic.close} text2`);
-    });
-
-    it("should render markdown with bold, italic, and strikethrough text", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>**text1** *text2* _text3_ ~text4~ text5</Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      const outputs = output?.split(" ");
-      expect(outputs).toBeDefined();
-      expect(outputs![0]).toContain(`${styles.bold.open}text1${styles.bold.close}`);
-      expect(outputs![1]).toContain(`${styles.italic.open}text2${styles.italic.close}`);
-      expect(outputs![2]).toContain(`${styles.italic.open}text3${styles.italic.close}`);
-      expect(outputs![3]).toContain(
-        `${styles.strikethrough.open}text4${styles.strikethrough.close}`,
-      );
-      expect(outputs![4]).toContain("text5");
-    });
-
-    it("should handle nested formatting correctly (italic with bold inside)", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>_**bold**_</Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      // The outer _ should render as italic, inner ** as bold
-      expect(output).toContain(styles.italic.open);
-      expect(output).toContain(styles.bold.open);
-      expect(output).toContain("bold");
-    });
-
-    it("should handle nested formatting correctly (italic with bold inside using asterisk)", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>*__bold__*</Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      // The outer * should render as italic, inner __ as bold
-      expect(output).toContain(styles.italic.open);
-      expect(output).toContain(styles.bold.open);
-      expect(output).toContain("bold");
-    });
-
-    it("should handle empty markdown", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>{""}</Markdown>
-        </TestWrapper>,
-      );
-      // Should render without error
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toBeDefined();
-    });
-
-    it("should handle complex markdown", () => {
-      const ink = render(
-        <TestWrapper>
-          <Markdown>
-            {`# Title
-
-This is a paragraph with **bold** and *italic* text.
-
-\`\`\`javascript
-const code = 'example';
-\`\`\`
-
-[Link](https://example.com)`}
-          </Markdown>
-        </TestWrapper>,
-      );
-      logInk(ink);
-      const output = ink.lastFrame();
-      expect(output).toContain("Title");
-      expect(output).toContain("paragraph");
-      expect(output).toContain("code");
-      expect(output).toContain("Link");
-    });
-  });
-});