@travisennis/acai 0.0.1 → 0.0.2

package/test/config.test.ts

@@ -1,200 +0,0 @@
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-
-import { ConfigManager, DirectoryProvider } from "../source/config.ts";
-
-// Helper to create and cleanup a temp directory
-async function withTempDir<T>(fn: (dir: string) => Promise<T>) {
-  const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "acai-test-"));
-  try {
-    return await fn(tmp);
-  } finally {
-    // best-effort cleanup
-    try {
-      await fs.rm(tmp, { recursive: true, force: true });
-    } catch {}
-  }
-}
-
-test("DirectoryProvider.ensurePath async and sync create directories", async () => {
-  await withTempDir(async (tmp) => {
-    const base = path.join(tmp, "base");
-    const dp = new DirectoryProvider(base);
-
-    const asyncDir = await dp.ensurePath("async-sub");
-    const stat = await fs.stat(asyncDir);
-    assert(stat.isDirectory(), "async-created path should be a directory");
-
-    const syncDir = dp.ensurePathSync("sync-sub");
-    const stat2 = await fs.stat(syncDir);
-    assert(stat2.isDirectory(), "sync-created path should be a directory");
-  });
-});
-
-test("ConfigManager.ensureAppConfig creates default app config in HOME", async () => {
-  await withTempDir(async (tmpHome) => {
-    const oldHome = process.env.HOME;
-    try {
-      process.env.HOME = tmpHome;
-
-      const mgr = new ConfigManager();
-      const cfg = await mgr.ensureAppConfig("acai");
-
-      // Defaults expected
-      assert.equal((cfg as Record<string, unknown>).notify, true);
-      assert.equal(
-        ((cfg as Record<string, unknown>).tools as Record<string, unknown>)
-          .maxTokens as number,
-        30000,
-      );
-
-      const configPath = path.join(tmpHome, ".acai", "acai.json");
-      const data = JSON.parse(await fs.readFile(configPath, "utf8"));
-      assert.equal(data.notify, true);
-      assert.equal(data.tools.maxTokens, 30000);
-    } finally {
-      if (oldHome !== undefined) process.env.HOME = oldHome;
-    }
-  });
-});
-
-test("writeProjectLearnedRulesFile creates project rules file inside .acai", async () => {
-  await withTempDir(async (tmpProject) => {
-    const oldCwd = process.cwd();
-    try {
-      process.chdir(tmpProject);
-      const mgr = new ConfigManager();
-
-      await mgr.writeProjectLearnedRulesFile("# rules\nhello");
-
-      const target = path.join(
-        tmpProject,
-        ".acai",
-        "rules",
-        "learned-rules.md",
-      );
-      const content = await fs.readFile(target, "utf8");
-      assert(content.includes("hello"));
-
-      // readProjectLearnedRulesFile should return the same content
-      const read = await mgr.readProjectLearnedRulesFile();
-      assert(read.includes("hello"));
-    } finally {
-      process.chdir(oldCwd);
-    }
-  });
-});
-
-test("writeCachedLearnedRulesFile and readCachedLearnedRulesFile in HOME", async () => {
-  await withTempDir(async (tmpHome) => {
-    const oldHome = process.env.HOME;
-    try {
-      process.env.HOME = tmpHome;
-      const mgr = new ConfigManager();
-
-      await mgr.writeCachedLearnedRulesFile("cached rules\nabc");
-      const content = await mgr.readCachedLearnedRulesFile();
-      assert(content.includes("abc"));
-
-      // Removing file should cause read to return empty string
-      const filePath = path.join(tmpHome, ".acai", "rules", "learned-rules.md");
-      await fs.rm(filePath);
-      const missing = await mgr.readCachedLearnedRulesFile();
-      assert.equal(missing, "");
-    } finally {
-      if (oldHome !== undefined) process.env.HOME = oldHome;
-    }
-  });
-});
-
-test("readAppConfig returns {} for missing and throws for malformed", async () => {
-  await withTempDir(async (tmpHome) => {
-    const oldHome = process.env.HOME;
-    try {
-      process.env.HOME = tmpHome;
-      const mgr = new ConfigManager();
-
-      const missing = await mgr.readAppConfig("nonexistent");
-      assert.deepEqual(missing, {});
-
-      // Create malformed JSON
-      const cfgDir = path.join(tmpHome, ".acai");
-      await fs.mkdir(cfgDir, { recursive: true });
-      const cfgPath = path.join(cfgDir, "bad.json");
-      await fs.writeFile(cfgPath, "{ invalid json", "utf8");
-
-      let threw = false;
-      try {
-        await mgr.readAppConfig("bad");
-      } catch (_e) {
-        threw = true;
-      }
-      assert.equal(threw, true, "readAppConfig should throw on malformed JSON");
-    } finally {
-      if (oldHome !== undefined) process.env.HOME = oldHome;
-    }
-  });
-});
-
-test("readProjectConfig merges app and project configs with project precedence", async () => {
-  await withTempDir(async (tmpHome) => {
-    const oldHome = process.env.HOME;
-    const oldCwd = process.cwd();
-    try {
-      process.env.HOME = tmpHome;
-      const projectDir = path.join(tmpHome, "proj");
-      await fs.mkdir(projectDir, { recursive: true });
-      process.chdir(projectDir);
-
-      // write app config in HOME
-      const appCfgDir = path.join(tmpHome, ".acai");
-      await fs.mkdir(appCfgDir, { recursive: true });
-      const appCfg = { tools: { maxTokens: 100 }, notify: true };
-      await fs.writeFile(
-        path.join(appCfgDir, "acai.json"),
-        JSON.stringify(appCfg),
-        "utf8",
-      );
-
-      // write project config overriding tools.maxTokens and notify
-      const projCfgDir = path.join(projectDir, ".acai");
-      await fs.mkdir(path.join(projCfgDir), { recursive: true });
-      const projCfg = { tools: { maxTokens: 50 }, notify: false };
-      await fs.writeFile(
-        path.join(projCfgDir, "acai.json"),
-        JSON.stringify(projCfg),
-        "utf8",
-      );
-
-      const mgr = new ConfigManager();
-      const merged = await mgr.readProjectConfig();
-      assert.equal(merged.tools.maxTokens, 50);
-      assert.equal(merged.notify, false);
-    } finally {
-      if (oldHome !== undefined) process.env.HOME = oldHome;
-      process.chdir(oldCwd);
-    }
-  });
-});
-
-test("readAgentsFile and writeAgentsFile operate in CWD", async () => {
-  await withTempDir(async (tmpCwd) => {
-    const oldCwd = process.cwd();
-    try {
-      process.chdir(tmpCwd);
-      const mgr = new ConfigManager();
-
-      const initial = await mgr.readAgentsFile();
-      assert.equal(initial, "");
-
-      await mgr.writeAgentsFile("# Agents\nagent1");
-      const content = await mgr.readAgentsFile();
-      assert(content.includes("agent1"));
-    } finally {
-      process.chdir(oldCwd);
-    }
-  });
-});

package/test/terminal/markdown-utils.test.ts

@@ -1,124 +0,0 @@
-import { strict as assert } from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-  getListNumber,
-  isMarkdown,
-} from "../../source/terminal/markdown-utils.ts";
-
-describe("isMarkdown", () => {
-  it("should return true for markdown headings", () => {
-    assert.strictEqual(isMarkdown("# Heading 1"), true);
-    assert.strictEqual(isMarkdown("## Heading 2"), true);
-    assert.strictEqual(isMarkdown("### Heading 3"), true);
-    assert.strictEqual(isMarkdown("#### Heading 4"), true);
-    assert.strictEqual(isMarkdown("##### Heading 5"), true);
-    assert.strictEqual(isMarkdown("###### Heading 6"), true);
-  });
-
-  it("should return true for markdown bold text", () => {
-    assert.strictEqual(isMarkdown("**bold text**"), true);
-    assert.strictEqual(isMarkdown("__bold text__"), true);
-  });
-
-  it("should return true for markdown italic text", () => {
-    assert.strictEqual(isMarkdown("*italic text*"), true);
-    assert.strictEqual(isMarkdown("_italic text_"), true);
-  });
-
-  it("should return true for markdown code blocks", () => {
-    assert.strictEqual(isMarkdown("`code`"), true);
-    assert.strictEqual(isMarkdown("```code block```"), true);
-  });
-
-  it("should return true for markdown links", () => {
-    assert.strictEqual(isMarkdown("(alt text](url)"), true);
-  });
-
-  it("should return true for markdown blockquotes", () => {
-    assert.strictEqual(isMarkdown("> blockquote"), true);
-  });
-
-  it("should return true for markdown unordered lists", () => {
-    assert.strictEqual(isMarkdown("- list item"), true);
-    assert.strictEqual(isMarkdown("* list item"), true);
-    assert.strictEqual(isMarkdown("+ list item"), true);
-  });
-
-  it("should return true for markdown ordered lists", () => {
-    assert.strictEqual(isMarkdown("1. list item"), true);
-  });
-
-  it("should return true for markdown horizontal rules", () => {
-    assert.strictEqual(isMarkdown("---"), true);
-  });
-
-  it("should return true for markdown images", () => {
-    assert.strictEqual(isMarkdown("![alt text](url)"), true);
-  });
-
-  it("should return false for plain text", () => {
-    assert.strictEqual(isMarkdown("This is plain text."), false);
-  });
-
-  it("should return false for an empty string", () => {
-    assert.strictEqual(isMarkdown(""), false);
-  });
-
-  it("should return true for mixed markdown content", () => {
-    assert.strictEqual(
-      isMarkdown("# Heading\nSome *italic* and **bold** text."),
-      true,
-    );
-  });
-});
-
-describe("getListNumber", () => {
-  it("should return arabic numerals for depth 0", () => {
-    assert.strictEqual(getListNumber(0, 1), "1");
-    assert.strictEqual(getListNumber(0, 10), "10");
-    assert.strictEqual(getListNumber(0, 0), "0"); // Though practically, list numbers start from 1
-  });
-
-  it("should return arabic numerals for depth 1", () => {
-    assert.strictEqual(getListNumber(1, 1), "1");
-    assert.strictEqual(getListNumber(1, 5), "5");
-  });
-
-  it("should return lowercase letters for depth 2", () => {
-    assert.strictEqual(getListNumber(2, 1), "a");
-    assert.strictEqual(getListNumber(2, 26), "z");
-    assert.strictEqual(getListNumber(2, 27), "aa");
-    assert.strictEqual(getListNumber(2, 0), "");
-  });
-
-  it("should return lowercase Roman numerals for depth 3", () => {
-    assert.strictEqual(getListNumber(3, 1), "i");
-    assert.strictEqual(getListNumber(3, 4), "iv");
-    assert.strictEqual(getListNumber(3, 9), "ix");
-    assert.strictEqual(getListNumber(3, 10), "x");
-    assert.strictEqual(getListNumber(3, 40), "xl");
-    assert.strictEqual(getListNumber(3, 0), "");
-  });
-
-  it("should return arabic numerals for depth greater than 3 (default case)", () => {
-    assert.strictEqual(getListNumber(4, 1), "1");
-    assert.strictEqual(getListNumber(10, 5), "5");
-  });
-
-  it("should handle various numbers for depth 1 list (arabic)", () => {
-    assert.strictEqual(getListNumber(1, 123), "123");
-  });
-
-  it("should handle various numbers for depth 2 list (letters)", () => {
-    assert.strictEqual(getListNumber(2, 52), "az");
-    assert.strictEqual(getListNumber(2, 702), "zz");
-    assert.strictEqual(getListNumber(2, 703), "aaa");
-  });
-
-  it("should handle various numbers for depth 3 list (roman)", () => {
-    assert.strictEqual(getListNumber(3, 49), "xlix");
-    assert.strictEqual(getListNumber(3, 99), "xcix");
-    assert.strictEqual(getListNumber(3, 499), "cdxcix");
-    assert.strictEqual(getListNumber(3, 1994), "mcmxciv");
-  });
-});

package/test/tools/bash-tool.test.ts

@@ -1,58 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { config } from "../../source/config.ts";
-import { createBashTool } from "../../source/tools/bash.ts";
-
-// Minimal token counter mock
-const tokenCounter = { count: (s: string) => s.length } as const;
-
-await config.readProjectConfig();
-
-const baseDir = process.cwd();
-
-describe("bash tool path validation for git message flags", () => {
-  const { bash } = createBashTool({
-    baseDir,
-    tokenCounter,
-    autoAcceptAll: true,
-  });
-
-  async function run(command: string) {
-    const toolImpl = bash as unknown as {
-      execute: (
-        args: { command: string; cwd: string; timeout: number },
-        meta: { toolCallId: string },
-      ) => Promise<string>;
-    };
-    const result = await toolImpl.execute(
-      { command, cwd: baseDir, timeout: 1000 },
-      { toolCallId: "t1" },
-    );
-    return String(result);
-  }
-
-  it("allows commit messages with /copy", async () => {
-    const res = await run('echo ok && git commit -m "docs: mention /copy"');
-    assert.ok(!res.includes("references path outside"));
-  });
-
-  it("allows URLs in messages", async () => {
-    const res = await run('git commit -m "URL https://example.com/p/a/t/h"');
-    assert.ok(!res.includes("references path outside"));
-  });
-
-  it("rejects absolute path in git add", async () => {
-    const res = await run("git add /etc/hosts");
-    assert.ok(res.includes("references path outside"));
-  });
-
-  it("rejects commit -F with file outside", async () => {
-    const res = await run("git commit -F /tmp/message.txt");
-    assert.ok(res.includes("references path outside"));
-  });
-
-  it("handles multiple -m flags", async () => {
-    const res = await run('git commit -m "first /copy" -m "second /path"');
-    assert.ok(!res.includes("references path outside"));
-  });
-});

package/test/tools/code-interpreter.test.ts

@@ -1,91 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-  CodeInterpreterTool,
-  createCodeInterpreterTool,
-} from "../../source/tools/code-interpreter.ts";
-
-// Helper to run the tool easily
-async function runTool(input: {
-  code: string;
-  timeoutSeconds?: number;
-}): Promise<{ ok: boolean; value: unknown }> {
-  const events: Array<{ event: string; data: unknown }> = [];
-  const { [CodeInterpreterTool.name]: tool } = createCodeInterpreterTool({
-    sendData: async (msg) => {
-      events.push({ event: msg.event, data: msg.data });
-    },
-  });
-
-  const output = await tool.execute(
-    input as never,
-    { toolCallId: "t1" } as never,
-  );
-  if (typeof output === "string" && output.startsWith("{")) {
-    return { ok: true, value: JSON.parse(output) };
-  }
-  return { ok: false, value: output };
-}
-
-describe("code-interpreter tool", () => {
-  it("executes simple console.log", async () => {
-    const res = await runTool({ code: "console.log('ok');" });
-    assert.equal(res.ok, true);
-    const v = res.value as { stdout: string; stderr: string; exitCode: number };
-    assert.equal(v.exitCode, 0);
-    assert.equal(v.stdout.trim(), "ok");
-    // Ignore stderr in this test due to environment-specific Node warnings.
-    assert.equal(typeof v.stderr, "string");
-  });
-
-  it("enforces timeout", async () => {
-    const res = await runTool({ code: "for(;;){}", timeoutSeconds: 1 });
-    assert.equal(res.ok, false);
-    assert.equal(res.value, "Script timed out");
-  });
-
-  it("allows fs within cwd", async () => {
-    const code = `
-      import { writeFileSync, readFileSync, rmSync } from 'node:fs';
-      writeFileSync('tmp_test_file.txt', 'hello', { encoding: 'utf8' });
-      const s = readFileSync('tmp_test_file.txt', { encoding: 'utf8' });
-      console.log(s);
-      rmSync('tmp_test_file.txt', { force: true });
-    `;
-    const res = await runTool({ code });
-    assert.equal(res.ok, true);
-    const v = res.value as { stdout: string };
-    assert.equal(v.stdout.trim(), "hello");
-  });
-
-  it("denies fs outside cwd", async () => {
-    const code = `
-      import { writeFileSync } from 'node:fs';
-      import { resolve } from 'node:path';
-      writeFileSync(resolve('..', 'should_not_write.txt'), 'x', { encoding: 'utf8' });
-      console.log('done');
-    `;
-    const res = await runTool({ code });
-    assert.equal(res.ok, false);
-    assert.match(String(res.value), /Process exited with code|permission/i);
-  });
-
-  it("denies child_process", async () => {
-    const code = `
-      import { spawnSync } from 'node:child_process';
-      const r = spawnSync('node', ['-v']);
-      console.log(String(r.stdout || ''));
-    `;
-    const res = await runTool({ code });
-    assert.equal(res.ok, false);
-  });
-
-  it("denies network", async () => {
-    const code = `
-      import https from 'node:https';
-      https.get('https://example.com', (res) => { console.log('status', res.statusCode); }).on('error', (e) => { console.error(String(e)); });
-    `;
-    const res = await runTool({ code });
-    assert.equal(res.ok, false);
-  });
-});

package/test/tools/command-validation.test.ts

@@ -1,48 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import { CommandValidation } from "../../source/tools/command-validation.ts";
-
-describe("CommandValidation", () => {
-  const allowedCommands = ["ls", "pwd", "echo", "grep", "sleep"];
-  const validator = new CommandValidation(allowedCommands);
-
-  describe("Valid Commands", () => {
-    it("allows ls && pwd", () => {
-      assert.strictEqual(validator.isValid("ls && pwd"), true);
-    });
-
-    it("allows echo 'hi' || ls", () => {
-      assert.strictEqual(validator.isValid("echo 'hi' || ls"), true);
-    });
-
-    it("allows ls; pwd", () => {
-      assert.strictEqual(validator.isValid("ls; pwd"), true);
-    });
-
-    it("allows ls | grep .ts", () => {
-      assert.strictEqual(validator.isValid("ls | grep .ts"), true);
-    });
-
-    it("allows sleep 1 &", () => {
-      assert.strictEqual(validator.isValid("sleep 1 &"), true);
-    });
-  });
-
-  describe("Invalid Commands", () => {
-    it("blocks ls > file (unsafe operator)", () => {
-      assert.strictEqual(validator.isValid("ls > file"), false);
-    });
-
-    it("blocks echo $(date) (unsafe operator)", () => {
-      assert.strictEqual(validator.isValid("echo $(date)"), false);
-    });
-
-    it("blocks rm -rf / (disallowed command)", () => {
-      assert.strictEqual(validator.isValid("rm -rf /"), false);
-    });
-
-    it("blocks empty command", () => {
-      assert.strictEqual(validator.isValid(""), false);
-    });
-  });
-});

package/tsconfig.build.json

@@ -1,9 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": ["test", "**/*.test.ts"],
-  "compilerOptions": {
-    "rootDir": "source",
-    "outDir": "dist"
-  }
-}
-

package/tsconfig.json

@@ -1,30 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "./dist",
-    "target": "ESNext",
-    "module": "ESNext",
-    "declaration": true,
-    "composite": true,
-    "moduleResolution": "Bundler",
-    "strict": true,
-    "allowUnusedLabels": false,
-    "allowUnreachableCode": false,
-    "exactOptionalPropertyTypes": false,
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitOverride": true,
-    "noImplicitReturns": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "noUncheckedIndexedAccess": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "isolatedModules": true,
-    "checkJs": true,
-    "skipLibCheck": true,
-    "rewriteRelativeImportExtensions": true,
-    "types": ["node"],
-    "lib": ["ESNext"]
-  },
-  "include": ["source/**/*.ts"],
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "_version": "2.0.0"
-}