claude-mux 0.7.0

package/tests/setup/hooks-integration.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdirSync, writeFileSync, readFileSync, rmSync, existsSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+const testDir = join(tmpdir(), `claude-watch-hooks-test-${Date.now()}`);
+const testClaudeDir = join(testDir, ".claude");
+const testSettingsPath = join(testClaudeDir, "settings.json");
+
+vi.mock("../../src/utils/paths.js", () => ({
+  CLAUDE_DIR: testClaudeDir,
+  CLAUDE_SETTINGS_PATH: testSettingsPath,
+}));
+
+describe("setup/hooks integration", () => {
+  beforeEach(() => {
+    mkdirSync(testClaudeDir, { recursive: true });
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+  });
+
+  describe("loadClaudeSettings", () => {
+    it("should return empty object when file does not exist", async () => {
+      rmSync(testClaudeDir, { recursive: true });
+
+      const { loadClaudeSettings } = await import("../../src/setup/hooks.js");
+      const settings = loadClaudeSettings();
+      expect(settings).toEqual({});
+    });
+
+    it("should parse existing settings", async () => {
+      writeFileSync(testSettingsPath, JSON.stringify({ foo: "bar" }));
+
+      const { loadClaudeSettings } = await import("../../src/setup/hooks.js");
+      const settings = loadClaudeSettings();
+      expect(settings).toEqual({ foo: "bar" });
+    });
+
+    it("should return empty object on invalid JSON", async () => {
+      writeFileSync(testSettingsPath, "not valid json");
+
+      const { loadClaudeSettings } = await import("../../src/setup/hooks.js");
+      const settings = loadClaudeSettings();
+      expect(settings).toEqual({});
+    });
+  });
+
+  describe("saveClaudeSettings", () => {
+    it("should create directory if it does not exist", async () => {
+      rmSync(testClaudeDir, { recursive: true });
+
+      const { saveClaudeSettings } = await import("../../src/setup/hooks.js");
+      saveClaudeSettings({ test: "value" });
+
+      expect(existsSync(testSettingsPath)).toBe(true);
+      const content = JSON.parse(readFileSync(testSettingsPath, "utf-8"));
+      expect(content).toEqual({ test: "value" });
+    });
+
+    it("should overwrite existing settings", async () => {
+      writeFileSync(testSettingsPath, JSON.stringify({ old: "data" }));
+
+      vi.resetModules();
+      const { saveClaudeSettings } = await import("../../src/setup/hooks.js");
+      saveClaudeSettings({ new: "data" });
+
+      const content = JSON.parse(readFileSync(testSettingsPath, "utf-8"));
+      expect(content).toEqual({ new: "data" });
+    });
+  });
+
+  describe("generateDiff", () => {
+    it("should show no changes when settings are identical", async () => {
+      const { generateDiff } = await import("../../src/setup/hooks.js");
+      const diff = generateDiff({ foo: "bar" }, { foo: "bar" });
+      expect(diff).toContain("No changes needed");
+    });
+
+    it("should show adding hooks when none exist", async () => {
+      const { generateDiff } = await import("../../src/setup/hooks.js");
+      const diff = generateDiff({}, { hooks: {} });
+      expect(diff).toContain("Adding hooks configuration");
+    });
+
+    it("should show updating hooks when some exist", async () => {
+      const { generateDiff } = await import("../../src/setup/hooks.js");
+      const diff = generateDiff({ hooks: {} }, { hooks: { SessionStart: [] } });
+      expect(diff).toContain("Updating hooks configuration");
+    });
+  });
+
+  describe("installHooks", () => {
+    it("should return diff and new settings", async () => {
+      const { installHooks } = await import("../../src/setup/hooks.js");
+      const { diff, newSettings } = installHooks();
+
+      expect(diff).toBeDefined();
+      expect(newSettings.hooks).toBeDefined();
+      expect(newSettings.hooks?.SessionStart).toBeDefined();
+    });
+
+    it("should merge with existing settings", async () => {
+      writeFileSync(testSettingsPath, JSON.stringify({ existingKey: "value" }));
+
+      vi.resetModules();
+      const { installHooks } = await import("../../src/setup/hooks.js");
+      const { newSettings } = installHooks();
+
+      expect(newSettings.existingKey).toBe("value");
+      expect(newSettings.hooks).toBeDefined();
+    });
+  });
+
+  describe("uninstallHooks", () => {
+    it("should do nothing when no hooks exist", async () => {
+      writeFileSync(testSettingsPath, JSON.stringify({}));
+
+      vi.resetModules();
+      const { uninstallHooks } = await import("../../src/setup/hooks.js");
+      expect(() => uninstallHooks()).not.toThrow();
+    });
+
+    it("should remove claude-watch hooks", async () => {
+      const { installHooks, saveClaudeSettings } = await import(
+        "../../src/setup/hooks.js"
+      );
+
+      // First install
+      const { newSettings } = installHooks();
+      saveClaudeSettings(newSettings);
+
+      // Then uninstall
+      vi.resetModules();
+      const { uninstallHooks: uninstall, loadClaudeSettings: load } = await import(
+        "../../src/setup/hooks.js"
+      );
+      uninstall();
+
+      const settings = load();
+      expect(settings.hooks).toBeUndefined();
+    });
+  });
+});

package/tests/setup/hooks.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect } from "vitest";
+import {
+  getClaudeWatchHooks,
+  mergeHooks,
+  removeClaudeWatchHooks,
+} from "../../src/setup/hooks.js";
+
+describe("setup/hooks", () => {
+  describe("getClaudeWatchHooks", () => {
+    it("should return hooks for all required events", () => {
+      const hooks = getClaudeWatchHooks();
+
+      expect(hooks.SessionStart).toBeDefined();
+      expect(hooks.Stop).toBeDefined();
+      expect(hooks.PermissionRequest).toBeDefined();
+      expect(hooks.Notification).toBeDefined();
+      expect(hooks.PreToolUse).toBeDefined();
+      expect(hooks.PostToolUse).toBeDefined();
+      expect(hooks.SessionEnd).toBeDefined();
+    });
+
+    it("should include claude-watch-hook command in all hooks", () => {
+      const hooks = getClaudeWatchHooks();
+
+      for (const eventHooks of Object.values(hooks)) {
+        for (const matcher of eventHooks) {
+          for (const hook of matcher.hooks) {
+            expect(hook.command).toContain("claude-watch-hook");
+          }
+        }
+      }
+    });
+
+    it("should have matchers for Notification hooks", () => {
+      const hooks = getClaudeWatchHooks();
+
+      const notificationHooks = hooks.Notification;
+      expect(notificationHooks.some((h) => h.matcher === "idle_prompt")).toBe(true);
+      expect(notificationHooks.some((h) => h.matcher === "permission_prompt")).toBe(true);
+    });
+  });
+
+  describe("mergeHooks", () => {
+    it("should merge new hooks into empty config", () => {
+      const newHooks = getClaudeWatchHooks();
+      const merged = mergeHooks(undefined, newHooks);
+
+      expect(Object.keys(merged).length).toBeGreaterThan(0);
+      expect(merged.SessionStart).toBeDefined();
+    });
+
+    it("should preserve existing hooks when merging", () => {
+      const existing = {
+        PreToolUse: [
+          {
+            matcher: "Bash",
+            hooks: [{ type: "command" as const, command: "existing-command" }],
+          },
+        ],
+      };
+
+      const newHooks = getClaudeWatchHooks();
+      const merged = mergeHooks(existing, newHooks);
+
+      // Should have both the existing and new hooks
+      expect(merged.PreToolUse.length).toBeGreaterThan(1);
+      expect(merged.PreToolUse.some((h) => h.hooks.some((hook) => hook.command === "existing-command"))).toBe(true);
+    });
+
+    it("should not duplicate claude-watch hooks", () => {
+      const newHooks = getClaudeWatchHooks();
+      const merged1 = mergeHooks(undefined, newHooks);
+      const merged2 = mergeHooks(merged1, newHooks);
+
+      // Should not add duplicates
+      expect(merged1.SessionStart.length).toBe(merged2.SessionStart.length);
+    });
+  });
+
+  describe("removeClaudeWatchHooks", () => {
+    it("should remove claude-watch hooks", () => {
+      const hooks = getClaudeWatchHooks();
+      const cleaned = removeClaudeWatchHooks(hooks);
+
+      // All claude-watch hooks should be removed
+      for (const eventHooks of Object.values(cleaned)) {
+        for (const matcher of eventHooks) {
+          for (const hook of matcher.hooks) {
+            expect(hook.command).not.toContain("claude-watch-hook");
+          }
+        }
+      }
+    });
+
+    it("should preserve non-claude-watch hooks", () => {
+      const hooks = {
+        PreToolUse: [
+          {
+            matcher: "Bash",
+            hooks: [{ type: "command" as const, command: "some-other-hook" }],
+          },
+          {
+            hooks: [{ type: "command" as const, command: "node claude-watch-hook" }],
+          },
+        ],
+      };
+
+      const cleaned = removeClaudeWatchHooks(hooks);
+
+      expect(cleaned.PreToolUse).toBeDefined();
+      expect(cleaned.PreToolUse.length).toBe(1);
+      expect(cleaned.PreToolUse[0].hooks[0].command).toBe("some-other-hook");
+    });
+
+    it("should remove event entirely if no hooks remain", () => {
+      const hooks = getClaudeWatchHooks();
+      const cleaned = removeClaudeWatchHooks(hooks);
+
+      // Most events should be removed entirely
+      expect(Object.keys(cleaned).length).toBe(0);
+    });
+  });
+});

package/tests/tmux/detect.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+describe("tmux/detect", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    // Reset modules to get fresh state
+    vi.resetModules();
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe("isInTmux", () => {
+    it("should return true when TMUX env var is set", async () => {
+      process.env.TMUX = "/tmp/tmux-1000/default,12345,0";
+      const { isInTmux } = await import("../../src/tmux/detect.js");
+      expect(isInTmux()).toBe(true);
+    });
+
+    it("should return false when TMUX env var is not set", async () => {
+      delete process.env.TMUX;
+      const { isInTmux } = await import("../../src/tmux/detect.js");
+      expect(isInTmux()).toBe(false);
+    });
+
+    it("should return false when TMUX env var is empty", async () => {
+      process.env.TMUX = "";
+      const { isInTmux } = await import("../../src/tmux/detect.js");
+      expect(isInTmux()).toBe(false);
+    });
+  });
+
+  describe("getTmuxTarget", () => {
+    it("should return null when not in tmux", async () => {
+      delete process.env.TMUX;
+      const { getTmuxTarget } = await import("../../src/tmux/detect.js");
+      expect(getTmuxTarget()).toBeNull();
+    });
+
+    // Note: We can't easily test the positive case without actually being in tmux
+    // This would be tested via integration tests
+  });
+
+  describe("getTmuxSessionName", () => {
+    it("should return null when not in tmux", async () => {
+      delete process.env.TMUX;
+      const { getTmuxSessionName } = await import("../../src/tmux/detect.js");
+      expect(getTmuxSessionName()).toBeNull();
+    });
+  });
+});

package/tests/tmux/navigate.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+describe("tmux/navigate", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    vi.resetModules();
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe("switchToTarget", () => {
+    it("should return false when not in tmux", async () => {
+      delete process.env.TMUX;
+      const { switchToTarget } = await import("../../src/tmux/navigate.js");
+      expect(switchToTarget("main:0.0")).toBe(false);
+    });
+  });
+
+  describe("switchToSession", () => {
+    it("should return false when not in tmux", async () => {
+      delete process.env.TMUX;
+      const { switchToSession } = await import("../../src/tmux/navigate.js");
+      expect(switchToSession("watch")).toBe(false);
+    });
+  });
+});

package/tests/utils/pid.test.ts

@@ -0,0 +1,17 @@
+import { describe, it, expect } from "vitest";
+import { isPidAlive } from "../../src/utils/pid.js";
+
+describe("isPidAlive", () => {
+  it("should return true for current process", () => {
+    expect(isPidAlive(process.pid)).toBe(true);
+  });
+
+  it("should return false for non-existent PID", () => {
+    // Use a very high PID that's unlikely to exist
+    expect(isPidAlive(999999999)).toBe(false);
+  });
+
+  it("should return true for parent process", () => {
+    expect(isPidAlive(process.ppid)).toBe(true);
+  });
+});

package/tsconfig.cli.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests", "web"]
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "react",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,29 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["tests/**/*.test.{ts,tsx}"],
+    coverage: {
+      provider: "istanbul",
+      reporter: ["text", "json", "html"],
+      include: ["src/**/*.{ts,tsx}"],
+      exclude: [
+        "src/**/*.d.ts",
+        "src/cli.ts",           // Entry point, tested via E2E
+        "src/app.tsx",          // Main app, tested via integration
+        "src/hooks/**",         // Hook scripts, tested via integration
+        "src/setup/wizard.ts",  // Interactive prompts, tested manually
+        "src/components/index.ts", // Just re-exports
+        "src/setup/index.ts",   // Just re-exports
+      ],
+      thresholds: {
+        lines: 80,
+        branches: 80,
+        functions: 80,
+        statements: 80,
+      },
+    },
+  },
+});