ashlrcode 1.0.0

package/src/__tests__/keybindings.test.ts

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

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

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

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

@@ -0,0 +1,63 @@
+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");
+  });
+});