@travisennis/acai 0.0.1

package/test/config.test.ts

@@ -0,0 +1,200 @@
+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

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,48 @@
+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

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

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "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"
+}