ashlrcode 1.0.0 → 2.1.0

package/src/__tests__/hooks.test.ts

@@ -1,145 +0,0 @@
-import { test, expect, describe } from "bun:test";
-import { runPreToolHooks, runPostToolHooks } from "../config/hooks.ts";
-import type { HooksConfig, HookDefinition } from "../config/hooks.ts";
-
-describe("runPreToolHooks", () => {
-  test("returns allow when no hooks are configured", async () => {
-    const result = await runPreToolHooks({}, "Bash", { command: "ls" });
-    expect(result.action).toBe("allow");
-  });
-
-  test("returns allow when no hooks match", async () => {
-    const hooks: HooksConfig = {
-      preToolUse: [{ toolName: "Write", action: "deny" }],
-    };
-    const result = await runPreToolHooks(hooks, "Bash", {});
-    expect(result.action).toBe("allow");
-  });
-
-  test("denies when exact toolName matches deny hook", async () => {
-    const hooks: HooksConfig = {
-      preToolUse: [{ toolName: "Bash", action: "deny", message: "no bash" }],
-    };
-    const result = await runPreToolHooks(hooks, "Bash", {});
-    expect(result.action).toBe("deny");
-    expect(result.message).toBe("no bash");
-  });
-
-  test("allows when exact toolName matches allow hook", async () => {
-    const hooks: HooksConfig = {
-      preToolUse: [{ toolName: "Read", action: "allow" }],
-    };
-    const result = await runPreToolHooks(hooks, "Read", {});
-    expect(result.action).toBe("allow");
-  });
-
-  test("matches glob patterns in toolName", async () => {
-    const hooks: HooksConfig = {
-      preToolUse: [{ toolName: "Bash*", action: "deny", message: "no bash" }],
-    };
-    const result = await runPreToolHooks(hooks, "BashTool", {});
-    expect(result.action).toBe("deny");
-  });
-
-  test("matches wildcard * to any tool", async () => {
-    const hooks: HooksConfig = {
-      preToolUse: [{ toolName: "*", action: "deny", message: "all blocked" }],
-    };
-    const result = await runPreToolHooks(hooks, "AnyTool", {});
-    expect(result.action).toBe("deny");
-    expect(result.message).toBe("all blocked");
-  });
-
-  test("matches inputPattern against serialized input", async () => {
-    const hooks: HooksConfig = {
-      preToolUse: [
-        {
-          inputPattern: "rm\\s+-rf",
-          action: "deny",
-          message: "dangerous command",
-        },
-      ],
-    };
-    const result = await runPreToolHooks(hooks, "Bash", {
-      command: "rm -rf /",
-    });
-    expect(result.action).toBe("deny");
-  });
-
-  test("does not match inputPattern when pattern is absent from input", async () => {
-    const hooks: HooksConfig = {
-      preToolUse: [{ inputPattern: "rm\\s+-rf", action: "deny" }],
-    };
-    const result = await runPreToolHooks(hooks, "Bash", { command: "ls -la" });
-    expect(result.action).toBe("allow");
-  });
-
-  test("matches when both toolName and inputPattern match", async () => {
-    const hooks: HooksConfig = {
-      preToolUse: [
-        {
-          toolName: "Bash",
-          inputPattern: "sudo",
-          action: "deny",
-          message: "no sudo",
-        },
-      ],
-    };
-    // Both match
-    const result = await runPreToolHooks(hooks, "Bash", {
-      command: "sudo rm foo",
-    });
-    expect(result.action).toBe("deny");
-
-    // toolName matches but inputPattern doesn't
-    const result2 = await runPreToolHooks(hooks, "Bash", { command: "ls" });
-    expect(result2.action).toBe("allow");
-  });
-
-  test("hook with no toolName or inputPattern matches everything", async () => {
-    const hooks: HooksConfig = {
-      preToolUse: [{ action: "deny", message: "global deny" }],
-    };
-    const result = await runPreToolHooks(hooks, "AnyTool", {});
-    expect(result.action).toBe("deny");
-  });
-
-  test("runs command-based hook and denies on non-zero exit", async () => {
-    const hooks: HooksConfig = {
-      preToolUse: [{ toolName: "Bash", command: "exit 1" }],
-    };
-    const result = await runPreToolHooks(hooks, "Bash", {});
-    expect(result.action).toBe("deny");
-  });
-
-  test("runs command-based hook and allows on zero exit", async () => {
-    const hooks: HooksConfig = {
-      preToolUse: [{ toolName: "Bash", command: "exit 0" }],
-    };
-    const result = await runPreToolHooks(hooks, "Bash", {});
-    expect(result.action).toBe("allow");
-  });
-});
-
-describe("runPostToolHooks", () => {
-  test("runs without error with no hooks", async () => {
-    // Should not throw
-    await runPostToolHooks({}, "Bash", {}, "output");
-  });
-
-  test("runs without error with matching hook", async () => {
-    const hooks: HooksConfig = {
-      postToolUse: [{ toolName: "Bash", command: "true" }],
-    };
-    // Fire and forget, should not throw
-    await runPostToolHooks(hooks, "Bash", {}, "output");
-  });
-
-  test("does not run hooks that don't match", async () => {
-    const hooks: HooksConfig = {
-      postToolUse: [{ toolName: "Write", command: "exit 1" }],
-    };
-    // Should not throw because the hook shouldn't match "Bash"
-    await runPostToolHooks(hooks, "Bash", {}, "output");
-  });
-});

package/src/__tests__/keybindings.test.ts

@@ -1,159 +0,0 @@
-import { test, expect, describe, beforeEach } from "bun:test";
-import {
-  getAction,
-  getBindings,
-  setBinding,
-  resetBindings,
-  InputHistory,
-} from "../ui/keybindings.ts";
-
-beforeEach(() => {
-  resetBindings();
-});
-
-describe("default bindings", () => {
-  test("default bindings are loaded", () => {
-    const bindings = getBindings();
-    expect(bindings.length).toBeGreaterThan(0);
-
-    const actions = bindings.map((b) => b.action);
-    expect(actions).toContain("exit");
-    expect(actions).toContain("mode-switch");
-    expect(actions).toContain("autocomplete");
-    expect(actions).toContain("clear-screen");
-    expect(actions).toContain("undo");
-  });
-});
-
-describe("getAction", () => {
-  test("matches ctrl+c to exit", () => {
-    // ctrl+c: key="c", ctrl=true, shift=false, meta=false
-    const action = getAction("c", true, false, false);
-    expect(action).toBe("exit");
-  });
-
-  test("matches shift+tab to mode-switch", () => {
-    // shift+tab: key="tab", ctrl=false, shift=true, meta=false
-    const action = getAction("tab", false, true, false);
-    expect(action).toBe("mode-switch");
-  });
-
-  test("matches ctrl+l to clear-screen", () => {
-    const action = getAction("l", true, false, false);
-    expect(action).toBe("clear-screen");
-  });
-
-  test("returns null for unbound key", () => {
-    const action = getAction("q", true, true, true);
-    expect(action).toBeNull();
-  });
-
-  test("matches plain arrow keys", () => {
-    expect(getAction("up", false, false, false)).toBe("history-prev");
-    expect(getAction("down", false, false, false)).toBe("history-next");
-  });
-});
-
-describe("setBinding", () => {
-  test("overrides an existing binding", () => {
-    // Change exit from ctrl+c to ctrl+q
-    setBinding("exit", "ctrl+q");
-
-    // Old combo should not match
-    expect(getAction("c", true, false, false)).toBeNull();
-    // New combo should match
-    expect(getAction("q", true, false, false)).toBe("exit");
-  });
-
-  test("adds a new binding", () => {
-    setBinding("custom-action", "ctrl+shift+x");
-    const action = getAction("x", true, true, false);
-    expect(action).toBe("custom-action");
-  });
-});
-
-describe("InputHistory", () => {
-  test("push and prev navigation", () => {
-    const history = new InputHistory();
-    history.push("first");
-    history.push("second");
-    history.push("third");
-
-    // prev goes from most recent backwards
-    expect(history.prev("")).toBe("third");
-    expect(history.prev("")).toBe("second");
-    expect(history.prev("")).toBe("first");
-  });
-
-  test("prev returns null on empty history", () => {
-    const history = new InputHistory();
-    expect(history.prev("")).toBeNull();
-  });
-
-  test("next navigates forward", () => {
-    const history = new InputHistory();
-    history.push("first");
-    history.push("second");
-    history.push("third");
-
-    // Navigate to the beginning
-    history.prev("");
-    history.prev("");
-    history.prev("");
-
-    // Navigate forward
-    expect(history.next()).toBe("second");
-    expect(history.next()).toBe("third");
-  });
-
-  test("next returns empty string when past end (clears input)", () => {
-    const history = new InputHistory();
-    history.push("hello");
-
-    history.prev(""); // go to "hello"
-    expect(history.next()).toBe(""); // past the end clears input
-  });
-
-  test("next returns null when not navigating", () => {
-    const history = new InputHistory();
-    history.push("hello");
-    // Without calling prev first, index is -1
-    expect(history.next()).toBeNull();
-  });
-
-  test("push resets navigation index", () => {
-    const history = new InputHistory();
-    history.push("first");
-    history.push("second");
-
-    // Navigate back
-    history.prev("");
-    expect(history.prev("")).toBe("first");
-
-    // Push new entry resets index
-    history.push("third");
-    expect(history.prev("")).toBe("third");
-  });
-
-  test("does not push duplicate consecutive entries", () => {
-    const history = new InputHistory();
-    history.push("same");
-    history.push("same");
-    history.push("same");
-
-    // Only one entry should exist
-    expect(history.prev("")).toBe("same");
-    // Going further back returns null (stays at index 0)
-    const second = history.prev("");
-    expect(second).toBe("same"); // stays at same since it's the only entry
-  });
-
-  test("wraps at beginning (stays at first entry)", () => {
-    const history = new InputHistory();
-    history.push("only");
-
-    expect(history.prev("")).toBe("only");
-    // Calling prev again stays at the first entry
-    expect(history.prev("")).toBe("only");
-  });
-});

package/src/__tests__/model-patches.test.ts

@@ -1,82 +0,0 @@
-import { test, expect, describe } from "bun:test";
-import { getModelPatches, listPatches } from "../agent/model-patches.ts";
-
-describe("Model Patches", () => {
-  describe("getModelPatches", () => {
-    test("matches grok models (not grok-4-1-fast)", () => {
-      const result = getModelPatches("grok-4");
-      expect(result.names).toContain("Grok verbosity control");
-      expect(result.names).not.toContain("Grok fast mode");
-      expect(result.combinedSuffix).toContain("Be concise");
-    });
-
-    test("matches grok-4-1-fast specifically", () => {
-      const result = getModelPatches("grok-4-1-fast");
-      expect(result.names).toContain("Grok fast mode");
-      // The generic grok pattern uses negative lookahead to exclude grok-4-1-fast
-      expect(result.names).not.toContain("Grok verbosity control");
-      expect(result.combinedSuffix).toContain("fast mode");
-    });
-
-    test("matches claude sonnet", () => {
-      const result = getModelPatches("claude-3.5-sonnet");
-      expect(result.names).toContain("Sonnet conciseness");
-      expect(result.combinedSuffix).toContain("concise");
-    });
-
-    test("matches claude opus", () => {
-      const result = getModelPatches("claude-opus-4");
-      expect(result.names).toContain("Opus thoroughness");
-      expect(result.combinedSuffix).toContain("thorough");
-    });
-
-    test("returns empty for unknown model", () => {
-      const result = getModelPatches("some-random-model-v1");
-      expect(result.names).toEqual([]);
-      expect(result.combinedSuffix).toBe("");
-    });
-
-    test("anchored patterns don't match substrings incorrectly", () => {
-      // "grok" pattern is anchored with ^, so "my-grok" shouldn't match
-      const result = getModelPatches("my-grok-variant");
-      expect(result.names).not.toContain("Grok verbosity control");
-      expect(result.names).not.toContain("Grok fast mode");
-
-      // "claude" pattern is anchored with ^, so "not-claude-sonnet" shouldn't match
-      const result2 = getModelPatches("not-claude-sonnet");
-      expect(result2.names).not.toContain("Sonnet conciseness");
-
-      // "deepseek" anchored
-      const result3 = getModelPatches("my-deepseek");
-      expect(result3.names).not.toContain("DeepSeek format control");
-    });
-
-    test("matches case-insensitively", () => {
-      const result = getModelPatches("Claude-3.5-Sonnet");
-      expect(result.names).toContain("Sonnet conciseness");
-    });
-  });
-
-  describe("listPatches", () => {
-    test("returns all patches", () => {
-      const patches = listPatches();
-      expect(patches.length).toBeGreaterThanOrEqual(7);
-
-      const names = patches.map((p) => p.name);
-      expect(names).toContain("Grok verbosity control");
-      expect(names).toContain("Grok fast mode");
-      expect(names).toContain("Sonnet conciseness");
-      expect(names).toContain("Opus thoroughness");
-      expect(names).toContain("OpenAI reasoning");
-      expect(names).toContain("DeepSeek format control");
-      expect(names).toContain("Local model constraints");
-    });
-
-    test("returns a copy (not the internal array)", () => {
-      const a = listPatches();
-      const b = listPatches();
-      expect(a).not.toBe(b);
-      expect(a).toEqual(b);
-    });
-  });
-});

package/src/__tests__/permissions-rules.test.ts

@@ -1,121 +0,0 @@
-import { test, expect, describe, beforeEach } from "bun:test";
-import {
-  checkRules,
-  setRules,
-  getRules,
-  resetPermissionsForTests,
-  type PermissionRule,
-} from "../config/permissions.ts";
-
-beforeEach(() => {
-  resetPermissionsForTests();
-});
-
-describe("matchesToolPattern (via checkRules)", () => {
-  // matchesToolPattern is internal, so we test it through checkRules.
-
-  test("exact match", () => {
-    setRules([{ tool: "Bash", action: "deny" }]);
-    expect(checkRules("Bash")).toBe("deny");
-    expect(checkRules("Read")).toBeNull();
-  });
-
-  test("prefix glob (e.g. 'File*')", () => {
-    setRules([{ tool: "File*", action: "allow" }]);
-    expect(checkRules("FileRead")).toBe("allow");
-    expect(checkRules("FileWrite")).toBe("allow");
-    expect(checkRules("Bash")).toBeNull();
-  });
-
-  test("suffix glob (e.g. '*Bash')", () => {
-    setRules([{ tool: "*Bash", action: "deny" }]);
-    expect(checkRules("DangerousBash")).toBe("deny");
-    expect(checkRules("Bash")).toBe("deny");
-    expect(checkRules("Read")).toBeNull();
-  });
-
-  test("wildcard '*' matches everything", () => {
-    setRules([{ tool: "*", action: "ask" }]);
-    expect(checkRules("Bash")).toBe("ask");
-    expect(checkRules("Read")).toBe("ask");
-    expect(checkRules("AnythingAtAll")).toBe("ask");
-  });
-});
-
-describe("checkRules", () => {
-  test("matches tool name + inputPattern", () => {
-    setRules([
-      { tool: "Bash", inputPattern: "rm\\s+-rf", action: "deny" },
-    ]);
-    expect(checkRules("Bash", { command: "rm -rf /" })).toBe("deny");
-  });
-
-  test("returns null when no rule matches", () => {
-    setRules([{ tool: "Bash", action: "deny" }]);
-    expect(checkRules("Write")).toBeNull();
-  });
-
-  test("returns null when tool matches but inputPattern does not", () => {
-    setRules([
-      { tool: "Bash", inputPattern: "sudo", action: "deny" },
-    ]);
-    expect(checkRules("Bash", { command: "ls -la" })).toBeNull();
-  });
-
-  test("matches with regex inputPattern", () => {
-    setRules([
-      { tool: "Bash", inputPattern: "\\bsudo\\b", action: "deny" },
-    ]);
-    expect(checkRules("Bash", { command: "sudo apt install" })).toBe("deny");
-    expect(checkRules("Bash", { command: "pseudocode" })).toBeNull();
-  });
-
-  test("first matching rule wins", () => {
-    setRules([
-      { tool: "Bash", inputPattern: "sudo", action: "deny" },
-      { tool: "Bash", action: "allow" },
-    ]);
-    // The first rule matches sudo commands
-    expect(checkRules("Bash", { command: "sudo rm" })).toBe("deny");
-    // The second rule catches all other Bash
-    expect(checkRules("Bash", { command: "ls" })).toBe("allow");
-  });
-
-  test("invalid regex in inputPattern is skipped", () => {
-    setRules([
-      { tool: "Bash", inputPattern: "[invalid", action: "deny" },
-      { tool: "Bash", action: "allow" },
-    ]);
-    // First rule has bad regex and is skipped; second rule matches
-    expect(checkRules("Bash", { command: "anything" })).toBe("allow");
-  });
-
-  test("no input provided — rules without inputPattern still match", () => {
-    setRules([{ tool: "Bash", action: "deny" }]);
-    expect(checkRules("Bash")).toBe("deny");
-  });
-});
-
-describe("setRules and getRules", () => {
-  test("setRules replaces rules and getRules returns them", () => {
-    const rules: PermissionRule[] = [
-      { tool: "Bash", action: "deny" },
-      { tool: "Read", action: "allow" },
-    ];
-    setRules(rules);
-    expect(getRules()).toBe(rules);
-  });
-
-  test("getRules returns empty array initially", () => {
-    expect(getRules()).toEqual([]);
-  });
-});
-
-describe("resetPermissionsForTests", () => {
-  test("clears all rules", () => {
-    setRules([{ tool: "Bash", action: "deny" }]);
-    expect(getRules().length).toBe(1);
-    resetPermissionsForTests();
-    expect(getRules()).toEqual([]);
-  });
-});

package/src/__tests__/permissions.test.ts

@@ -1,108 +0,0 @@
-import { test, expect, describe, beforeEach, afterEach } from "bun:test";
-import { existsSync, mkdtempSync, rmSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import {
-  checkPermission,
-  allowForSession,
-  getPermissionState,
-  recordPermission,
-  resetPermissionsForTests,
-} from "../config/permissions.ts";
-import { setConfigDirForTests } from "../config/settings.ts";
-
-let configDir: string;
-
-beforeEach(() => {
-  configDir = mkdtempSync(join(tmpdir(), "ashlrcode-permissions-test-"));
-  setConfigDirForTests(configDir);
-  resetPermissionsForTests();
-});
-
-afterEach(() => {
-  resetPermissionsForTests();
-  setConfigDirForTests(null);
-  if (existsSync(configDir)) rmSync(configDir, { recursive: true, force: true });
-});
-
-describe("checkPermission", () => {
-  // Note: tests interact with module-level state. The permission module uses
-  // a global singleton state. We test the logic as-is.
-
-  test("auto-allows read-only tools", () => {
-    expect(checkPermission("Read")).toBe("allow");
-    expect(checkPermission("Glob")).toBe("allow");
-    expect(checkPermission("Grep")).toBe("allow");
-    expect(checkPermission("AskUser")).toBe("allow");
-    expect(checkPermission("WebFetch")).toBe("allow");
-    expect(checkPermission("Agent")).toBe("allow");
-  });
-
-  test("returns 'ask' for unknown non-read-only tools", () => {
-    // A tool not in the auto-allow list and not in any permission set
-    expect(checkPermission("SomeRandomTool_" + Date.now())).toBe("ask");
-  });
-
-  test("allowForSession makes tool return 'allow'", () => {
-    const toolName = `SessionTool_${Date.now()}`;
-    expect(checkPermission(toolName)).toBe("ask");
-    allowForSession(toolName);
-    expect(checkPermission(toolName)).toBe("allow");
-  });
-});
-
-describe("recordPermission", () => {
-  test("always_allow persists and changes check result", async () => {
-    const toolName = `AlwaysAllowTool_${Date.now()}`;
-    expect(checkPermission(toolName)).toBe("ask");
-    await recordPermission(toolName, "always_allow");
-    expect(checkPermission(toolName)).toBe("allow");
-    // Clean up: remove from state
-    const state = getPermissionState();
-    state.alwaysAllow.delete(toolName);
-  });
-
-  test("always_deny persists and changes check result", async () => {
-    const toolName = `AlwaysDenyTool_${Date.now()}`;
-    await recordPermission(toolName, "always_deny");
-    expect(checkPermission(toolName)).toBe("deny");
-    // Clean up
-    const state = getPermissionState();
-    state.alwaysDeny.delete(toolName);
-  });
-
-  test("always_allow removes from alwaysDeny", async () => {
-    const toolName = `FlipTool_${Date.now()}`;
-    await recordPermission(toolName, "always_deny");
-    expect(checkPermission(toolName)).toBe("deny");
-    await recordPermission(toolName, "always_allow");
-    expect(checkPermission(toolName)).toBe("allow");
-    // Clean up
-    const state = getPermissionState();
-    state.alwaysAllow.delete(toolName);
-  });
-
-  test("always_deny removes from alwaysAllow", async () => {
-    const toolName = `FlipTool2_${Date.now()}`;
-    await recordPermission(toolName, "always_allow");
-    expect(checkPermission(toolName)).toBe("allow");
-    await recordPermission(toolName, "always_deny");
-    expect(checkPermission(toolName)).toBe("deny");
-    // Clean up
-    const state = getPermissionState();
-    state.alwaysDeny.delete(toolName);
-  });
-
-  test("allow_once does not persist", async () => {
-    const toolName = `OnceTool_${Date.now()}`;
-    await recordPermission(toolName, "allow_once");
-    // Still "ask" because allow_once doesn't persist
-    expect(checkPermission(toolName)).toBe("ask");
-  });
-
-  test("deny_once does not persist", async () => {
-    const toolName = `DenyOnceTool_${Date.now()}`;
-    await recordPermission(toolName, "deny_once");
-    expect(checkPermission(toolName)).toBe("ask");
-  });
-});

package/src/__tests__/project-config.test.ts

@@ -1,63 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { loadProjectConfig } from "../config/project-config.ts";
-import { setConfigDirForTests } from "../config/settings.ts";
-
-describe("loadProjectConfig", () => {
-  let rootDir: string;
-  let configDir: string;
-
-  beforeEach(() => {
-    rootDir = mkdtempSync(join(tmpdir(), "ashlrcode-project-config-"));
-    configDir = join(rootDir, ".config");
-    mkdirSync(configDir, { recursive: true });
-    setConfigDirForTests(configDir);
-  });
-
-  afterEach(() => {
-    setConfigDirForTests(null);
-    if (existsSync(rootDir)) rmSync(rootDir, { recursive: true, force: true });
-  });
-
-  test("loads global, parent, and cwd instructions in increasing precedence order", async () => {
-    const parentDir = join(rootDir, "workspace");
-    const childDir = join(parentDir, "app");
-    mkdirSync(childDir, { recursive: true });
-
-    writeFileSync(join(configDir, "ASHLR.md"), "global rule", "utf-8");
-    writeFileSync(join(parentDir, "ASHLR.md"), "parent rule", "utf-8");
-    writeFileSync(join(childDir, "CLAUDE.md"), "child rule", "utf-8");
-
-    const config = await loadProjectConfig(childDir);
-
-    expect(config.sources).toEqual([
-      join(configDir, "ASHLR.md"),
-      join(parentDir, "ASHLR.md"),
-      join(childDir, "CLAUDE.md"),
-    ]);
-    expect(config.instructions.indexOf("global rule")).toBeLessThan(
-      config.instructions.indexOf("parent rule")
-    );
-    expect(config.instructions.indexOf("parent rule")).toBeLessThan(
-      config.instructions.indexOf("child rule")
-    );
-  });
-
-  test("walks ancestor directories and includes both ASHLR.md and CLAUDE.md", async () => {
-    const parentDir = join(rootDir, "workspace");
-    const childDir = join(parentDir, "app");
-    mkdirSync(childDir, { recursive: true });
-
-    writeFileSync(join(rootDir, "ASHLR.md"), "root rule", "utf-8");
-    writeFileSync(join(parentDir, "CLAUDE.md"), "parent claude", "utf-8");
-
-    const config = await loadProjectConfig(childDir);
-
-    expect(config.sources).toContain(join(rootDir, "ASHLR.md"));
-    expect(config.sources).toContain(join(parentDir, "CLAUDE.md"));
-    expect(config.instructions).toContain("root rule");
-    expect(config.instructions).toContain("parent claude");
-  });
-});