ashlrcode 1.0.0

package/src/__tests__/tool-registry.test.ts

@@ -0,0 +1,166 @@
+import { test, expect, describe, beforeEach } from "bun:test";
+import { ToolRegistry } from "../tools/registry.ts";
+import type { Tool, ToolContext } from "../tools/types.ts";
+import type { HooksConfig } from "../config/hooks.ts";
+
+/** Create a minimal mock tool for testing. */
+function mockTool(overrides: Partial<Tool> = {}): Tool {
+  return {
+    name: overrides.name ?? "MockTool",
+    prompt: () => "A mock tool",
+    inputSchema: () => ({ type: "object", properties: {} }),
+    isReadOnly: () => overrides.isReadOnly?.() ?? false,
+    isDestructive: () => false,
+    isConcurrencySafe: () => true,
+    validateInput: overrides.validateInput ?? (() => null),
+    call: overrides.call ?? (async () => "mock result"),
+  };
+}
+
+function mockContext(overrides: Partial<ToolContext> = {}): ToolContext {
+  return {
+    cwd: "/tmp",
+    requestPermission: overrides.requestPermission ?? (async () => true),
+  };
+}
+
+describe("ToolRegistry", () => {
+  let registry: ToolRegistry;
+
+  beforeEach(() => {
+    registry = new ToolRegistry();
+  });
+
+  describe("register and get", () => {
+    test("registers and retrieves a tool", () => {
+      const tool = mockTool({ name: "Bash" });
+      registry.register(tool);
+      expect(registry.get("Bash")).toBe(tool);
+    });
+
+    test("returns undefined for unregistered tool", () => {
+      expect(registry.get("DoesNotExist")).toBeUndefined();
+    });
+
+    test("getAll returns all registered tools", () => {
+      registry.register(mockTool({ name: "A" }));
+      registry.register(mockTool({ name: "B" }));
+      expect(registry.getAll()).toHaveLength(2);
+    });
+
+    test("overwriting a tool with the same name replaces it", () => {
+      const tool1 = mockTool({ name: "T", call: async () => "v1" });
+      const tool2 = mockTool({ name: "T", call: async () => "v2" });
+      registry.register(tool1);
+      registry.register(tool2);
+      expect(registry.get("T")).toBe(tool2);
+    });
+  });
+
+  describe("getDefinitions", () => {
+    test("returns tool definitions for all tools", () => {
+      registry.register(mockTool({ name: "Read" }));
+      const defs = registry.getDefinitions();
+      expect(defs).toHaveLength(1);
+      expect(defs[0]!.name).toBe("Read");
+    });
+
+    test("getReadOnlyDefinitions filters to read-only tools", () => {
+      registry.register(mockTool({ name: "Read", isReadOnly: () => true }));
+      registry.register(mockTool({ name: "Write", isReadOnly: () => false }));
+      const readOnly = registry.getReadOnlyDefinitions();
+      expect(readOnly).toHaveLength(1);
+      expect(readOnly[0]!.name).toBe("Read");
+    });
+  });
+
+  describe("execute", () => {
+    test("returns error for unknown tool", async () => {
+      const result = await registry.execute("Nope", {}, mockContext());
+      expect(result.isError).toBe(true);
+      expect(result.result).toContain("Unknown tool");
+    });
+
+    test("returns validation error when validateInput fails", async () => {
+      registry.register(
+        mockTool({ name: "Bad", validateInput: () => "missing required field" })
+      );
+      const result = await registry.execute("Bad", {}, mockContext());
+      expect(result.isError).toBe(true);
+      expect(result.result).toContain("Validation error");
+    });
+
+    test("executes tool and returns result on success", async () => {
+      registry.register(
+        mockTool({ name: "Good", call: async () => "hello world" })
+      );
+      const result = await registry.execute("Good", {}, mockContext());
+      expect(result.isError).toBe(false);
+      expect(result.result).toBe("hello world");
+    });
+
+    test("catches thrown errors from tool.call", async () => {
+      registry.register(
+        mockTool({
+          name: "Throws",
+          call: async () => {
+            throw new Error("boom");
+          },
+        })
+      );
+      const result = await registry.execute("Throws", {}, mockContext());
+      expect(result.isError).toBe(true);
+      expect(result.result).toContain("boom");
+    });
+
+    test("skips permission check for read-only tools", async () => {
+      let permissionRequested = false;
+      registry.register(
+        mockTool({ name: "Viewer", isReadOnly: () => true, call: async () => "data" })
+      );
+      const ctx = mockContext({
+        requestPermission: async () => {
+          permissionRequested = true;
+          return false; // Would deny if called
+        },
+      });
+      const result = await registry.execute("Viewer", {}, ctx);
+      expect(result.isError).toBe(false);
+      expect(permissionRequested).toBe(false);
+    });
+
+    test("denies execution when permission is refused", async () => {
+      registry.register(mockTool({ name: "Write" }));
+      const ctx = mockContext({ requestPermission: async () => false });
+      const result = await registry.execute("Write", {}, ctx);
+      expect(result.isError).toBe(true);
+      expect(result.result).toContain("Permission denied");
+    });
+  });
+
+  describe("hook integration", () => {
+    test("denies when pre-hook returns deny action", async () => {
+      registry.register(mockTool({ name: "Bash" }));
+      registry.setHooks({
+        preToolUse: [
+          { toolName: "Bash", action: "deny", message: "blocked by policy" },
+        ],
+      });
+      const result = await registry.execute("Bash", {}, mockContext());
+      expect(result.isError).toBe(true);
+      expect(result.result).toContain("blocked by policy");
+    });
+
+    test("allows when pre-hook returns allow action", async () => {
+      registry.register(
+        mockTool({ name: "Bash", call: async () => "ran ok" })
+      );
+      registry.setHooks({
+        preToolUse: [{ toolName: "Bash", action: "allow" }],
+      });
+      const result = await registry.execute("Bash", {}, mockContext());
+      expect(result.isError).toBe(false);
+      expect(result.result).toBe("ran ok");
+    });
+  });
+});

package/src/__tests__/undercover.test.ts

@@ -0,0 +1,93 @@
+import { test, expect, describe, beforeEach } from "bun:test";
+import {
+  isUndercoverMode,
+  setUndercoverMode,
+  maskCodenames,
+  sanitizeCommitMessage,
+  getUndercoverPrompt,
+} from "../config/undercover.ts";
+
+describe("Undercover Mode", () => {
+  beforeEach(() => {
+    // Reset to disabled before each test
+    setUndercoverMode(false);
+  });
+
+  describe("maskCodenames", () => {
+    test("replaces codenames when enabled", () => {
+      setUndercoverMode(true);
+      expect(maskCodenames("Running claude model")).toContain("cla***");
+      expect(maskCodenames("Using opus for analysis")).toContain("opu*");
+      expect(maskCodenames("capybara-v8 is fast")).toContain("cap*****");
+      expect(maskCodenames("ashlrcode agent")).toContain("ash******");
+    });
+
+    test("is no-op when disabled", () => {
+      setUndercoverMode(false);
+      const text = "Running claude opus model via ashlrcode";
+      expect(maskCodenames(text)).toBe(text);
+    });
+
+    test("is case-insensitive", () => {
+      setUndercoverMode(true);
+      const result = maskCodenames("CLAUDE and Claude and claude");
+      expect(result).not.toContain("CLAUDE");
+      expect(result).not.toContain("Claude");
+      expect(result).not.toContain("claude");
+    });
+  });
+
+  describe("sanitizeCommitMessage", () => {
+    test("strips Co-Authored-By when enabled", () => {
+      setUndercoverMode(true);
+      const msg = `feat: add feature
+
+Co-Authored-By: Claude <noreply@anthropic.com>`;
+      const result = sanitizeCommitMessage(msg);
+      expect(result).not.toContain("Co-Authored-By");
+      expect(result).toContain("feat: add feature");
+    });
+
+    test("is no-op when disabled", () => {
+      setUndercoverMode(false);
+      const msg = `feat: stuff\n\nCo-Authored-By: Claude <noreply@anthropic.com>`;
+      expect(sanitizeCommitMessage(msg)).toBe(msg);
+    });
+
+    test("handles multiple Co-Authored-By lines", () => {
+      setUndercoverMode(true);
+      const msg = `fix: bug
+
+Co-Authored-By: Claude <noreply@anthropic.com>
+Co-Authored-By: GPT <noreply@openai.com>`;
+      const result = sanitizeCommitMessage(msg);
+      expect(result).not.toContain("Co-Authored-By");
+    });
+  });
+
+  describe("getUndercoverPrompt", () => {
+    test("returns empty string when disabled", () => {
+      setUndercoverMode(false);
+      expect(getUndercoverPrompt()).toBe("");
+    });
+
+    test("returns undercover instructions when enabled", () => {
+      setUndercoverMode(true);
+      const prompt = getUndercoverPrompt();
+      expect(prompt).toContain("UNDERCOVER MODE ACTIVE");
+      expect(prompt).toContain("Do NOT reveal");
+    });
+  });
+
+  describe("toggle", () => {
+    test("on/off works correctly", () => {
+      expect(isUndercoverMode()).toBe(false);
+
+      setUndercoverMode(true);
+      expect(isUndercoverMode()).toBe(true);
+
+      setUndercoverMode(false);
+      expect(isUndercoverMode()).toBe(false);
+    });
+  });
+});

package/src/__tests__/workflow.test.ts

@@ -0,0 +1,195 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { existsSync, mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import {
+  createWorkflow,
+  listWorkflows,
+  deleteWorkflow,
+  executeWorkflow,
+  markWorkflowRun,
+  loadWorkflow,
+  type WorkflowStep,
+  type Workflow,
+} from "../agent/workflow.ts";
+import { setConfigDirForTests } from "../config/settings.ts";
+
+let configDir: string;
+
+beforeEach(() => {
+  configDir = mkdtempSync(join(tmpdir(), "ashlrcode-workflow-test-"));
+  setConfigDirForTests(configDir);
+});
+
+afterEach(() => {
+  setConfigDirForTests(null);
+  if (existsSync(configDir)) rmSync(configDir, { recursive: true, force: true });
+});
+
+/** Helper to create a mock executor */
+function mockExecutor(overrides?: Partial<Parameters<typeof executeWorkflow>[1]>) {
+  return {
+    runPrompt: async (prompt: string) => `Response to: ${prompt}`,
+    runCommand: async (cmd: string) => ({ output: `ran: ${cmd}`, exitCode: 0 }),
+    runTool: async (name: string, _input: Record<string, unknown>) => ({
+      result: `tool ${name} done`,
+      isError: false,
+    }),
+    onStepStart: () => {},
+    onStepEnd: () => {},
+    ...overrides,
+  };
+}
+
+describe("createWorkflow", () => {
+  test("saves workflow to disk", async () => {
+    const steps: WorkflowStep[] = [
+      { name: "say hi", type: "prompt", value: "Hello" },
+    ];
+    const wf = await createWorkflow("Test WF", "A test workflow", steps);
+
+    expect(wf.id).toMatch(/^wf-/);
+    expect(wf.name).toBe("Test WF");
+    expect(wf.runCount).toBe(0);
+
+    const path = join(configDir, "workflows", `${wf.id}.json`);
+    expect(existsSync(path)).toBe(true);
+  });
+});
+
+describe("listWorkflows", () => {
+  test("returns saved workflows sorted by name", async () => {
+    await createWorkflow("Zeta", "Last", []);
+    await new Promise((r) => setTimeout(r, 5));
+    await createWorkflow("Alpha", "First", []);
+
+    const workflows = await listWorkflows();
+    expect(workflows.length).toBe(2);
+    expect(workflows[0]!.name).toBe("Alpha");
+    expect(workflows[1]!.name).toBe("Zeta");
+  });
+
+  test("returns empty array when no workflows dir exists", async () => {
+    const workflows = await listWorkflows();
+    expect(workflows).toEqual([]);
+  });
+});
+
+describe("deleteWorkflow", () => {
+  test("removes workflow file and returns true", async () => {
+    const wf = await createWorkflow("ToDelete", "Will be deleted", []);
+    const deleted = await deleteWorkflow(wf.id);
+    expect(deleted).toBe(true);
+
+    const path = join(configDir, "workflows", `${wf.id}.json`);
+    expect(existsSync(path)).toBe(false);
+  });
+
+  test("returns false for non-existent workflow", async () => {
+    const deleted = await deleteWorkflow("wf-nonexistent");
+    expect(deleted).toBe(false);
+  });
+});
+
+describe("markWorkflowRun", () => {
+  test("increments run counter and sets lastRunAt", async () => {
+    const wf = await createWorkflow("Counter", "Tracks runs", []);
+    expect(wf.runCount).toBe(0);
+    expect(wf.lastRunAt).toBeUndefined();
+
+    await markWorkflowRun(wf.id);
+    const updated = await loadWorkflow(wf.id);
+    expect(updated!.runCount).toBe(1);
+    expect(updated!.lastRunAt).toBeDefined();
+
+    await markWorkflowRun(wf.id);
+    const updated2 = await loadWorkflow(wf.id);
+    expect(updated2!.runCount).toBe(2);
+  });
+});
+
+describe("executeWorkflow", () => {
+  test("runs command steps", async () => {
+    const wf = await createWorkflow("CmdTest", "Test commands", [
+      { name: "list files", type: "command", value: "ls" },
+      { name: "greet", type: "prompt", value: "Say hello" },
+    ]);
+
+    const result = await executeWorkflow(wf, mockExecutor());
+    expect(result.stepsCompleted).toBe(2);
+    expect(result.stepsTotal).toBe(2);
+    expect(result.results.length).toBe(2);
+    expect(result.results[0]!.success).toBe(true);
+    expect(result.results[1]!.success).toBe(true);
+  });
+
+  test("stops on error when continueOnError is not set", async () => {
+    const wf = await createWorkflow("FailTest", "Stops on error", [
+      { name: "fail step", type: "command", value: "bad-command" },
+      { name: "never reached", type: "prompt", value: "Should not run" },
+    ]);
+
+    const executor = mockExecutor({
+      runCommand: async () => ({ output: "error", exitCode: 1 }),
+    });
+
+    const result = await executeWorkflow(wf, executor);
+    expect(result.stepsCompleted).toBe(1); // First step runs (but fails)
+    expect(result.results[0]!.success).toBe(false);
+    // Second step should not have run
+    expect(result.results.length).toBe(1);
+  });
+
+  test("continues past error when continueOnError is set", async () => {
+    const wf = await createWorkflow("ContinueTest", "Continues on error", [
+      { name: "fail step", type: "command", value: "bad", continueOnError: true },
+      { name: "still runs", type: "prompt", value: "This should run" },
+    ]);
+
+    const executor = mockExecutor({
+      runCommand: async () => ({ output: "error", exitCode: 1 }),
+    });
+
+    const result = await executeWorkflow(wf, executor);
+    expect(result.stepsCompleted).toBe(2);
+    expect(result.results.length).toBe(2);
+    expect(result.results[0]!.success).toBe(false);
+    expect(result.results[1]!.success).toBe(true);
+  });
+
+  test("handles tool steps", async () => {
+    const wf = await createWorkflow("ToolTest", "Test tool steps", [
+      { name: "read file", type: "tool", value: "Read", input: { file_path: "/tmp/test" } },
+    ]);
+
+    const result = await executeWorkflow(wf, mockExecutor());
+    expect(result.stepsCompleted).toBe(1);
+    expect(result.results[0]!.success).toBe(true);
+  });
+
+  test("handles exceptions in steps", async () => {
+    const wf = await createWorkflow("ExceptionTest", "Throws", [
+      { name: "explode", type: "command", value: "boom" },
+      { name: "unreached", type: "prompt", value: "nope" },
+    ]);
+
+    const executor = mockExecutor({
+      runCommand: async () => { throw new Error("kaboom"); },
+    });
+
+    const result = await executeWorkflow(wf, executor);
+    expect(result.results[0]!.success).toBe(false);
+    expect(result.results[0]!.output).toContain("kaboom");
+    expect(result.results.length).toBe(1);
+  });
+
+  test("reports timing info", async () => {
+    const wf = await createWorkflow("TimingTest", "Timing", [
+      { name: "quick", type: "prompt", value: "fast" },
+    ]);
+
+    const result = await executeWorkflow(wf, mockExecutor());
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+    expect(result.workflow).toBe("TimingTest");
+  });
+});

package/src/agent/async-context.ts

@@ -0,0 +1,64 @@
+/**
+ * AsyncLocalStorage context isolation — per-agent namespace safety.
+ * Prevents context leakage between concurrent sub-agents sharing a process.
+ *
+ * Each sub-agent runs inside its own AsyncLocalStorage store so that any
+ * code calling getAgentContext() sees the correct agent identity, cwd, and
+ * permission flags without prop-drilling through every layer.
+ */
+
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export interface AgentContext {
+  agentId: string;
+  agentName: string;
+  cwd: string;
+  readOnly: boolean;
+  parentAgentId?: string;
+  /** Nesting depth: 0 = root REPL session */
+  depth: number;
+  startedAt: string;
+}
+
+const storage = new AsyncLocalStorage<AgentContext>();
+
+/** Run a function with an isolated agent context. */
+export function runWithAgentContext<T>(ctx: AgentContext, fn: () => T): T {
+  return storage.run(ctx, fn);
+}
+
+/** Get the current agent context (null if not inside any agent scope). */
+export function getAgentContext(): AgentContext | null {
+  return storage.getStore() ?? null;
+}
+
+/** Create a child context derived from an optional parent. */
+export function createChildContext(
+  parentCtx: AgentContext | null,
+  name: string,
+  cwd: string,
+  readOnly: boolean,
+): AgentContext {
+  return {
+    agentId: `agent-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+    agentName: name,
+    cwd,
+    readOnly,
+    parentAgentId: parentCtx?.agentId,
+    depth: (parentCtx?.depth ?? -1) + 1,
+    startedAt: new Date().toISOString(),
+  };
+}
+
+/** True when running inside a nested sub-agent (depth > 0). */
+export function isNestedAgent(): boolean {
+  const ctx = getAgentContext();
+  return ctx !== null && ctx.depth > 0;
+}
+
+/** Human-readable label for the current agent scope (for logs/debugging). */
+export function getAgentChain(): string {
+  const ctx = getAgentContext();
+  if (!ctx) return "(no agent context)";
+  return `${ctx.agentName} (depth=${ctx.depth}, id=${ctx.agentId})`;
+}