@agentmeshhq/agent 0.2.0 → 0.3.0

package/src/__tests__/loader.test.ts

@@ -1,239 +0,0 @@
-import * as fs from "node:fs";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  addAgentToState,
-  getAgentState,
-  loadConfig,
-  loadState,
-  removeAgentFromState,
-  resetAgentRestartCount,
-  updateAgentInState,
-} from "../config/loader.js";
-import type { AgentState, Config, State } from "../config/schema.js";
-
-// Mock the file system
-vi.mock("node:fs");
-
-describe("Config Loader", () => {
-  const mockConfig: Config = {
-    hubUrl: "https://test.agentmesh.dev",
-    apiKey: "test-api-key",
-    workspace: "test-workspace",
-    defaults: {
-      command: "opencode",
-      model: "claude-sonnet-4",
-    },
-    agents: [],
-  };
-
-  const mockState: State = {
-    agents: [
-      {
-        name: "test-agent",
-        agentId: "agent-123",
-        pid: 12345,
-        tmuxSession: "agentmesh-test-agent",
-        startedAt: "2024-01-01T00:00:00Z",
-        token: "test-token",
-      },
-    ],
-  };
-
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  describe("loadConfig", () => {
-    it("should return null if config file does not exist", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-      expect(loadConfig()).toBeNull();
-    });
-
-    it("should load and parse config file", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
-
-      const config = loadConfig();
-      expect(config).toEqual(mockConfig);
-    });
-
-    it("should return null on parse error", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue("invalid json");
-
-      expect(loadConfig()).toBeNull();
-    });
-  });
-
-  describe("loadState", () => {
-    it("should return empty state if file does not exist", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-      expect(loadState()).toEqual({ agents: [] });
-    });
-
-    it("should load and parse state file", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-
-      const state = loadState();
-      expect(state).toEqual(mockState);
-    });
-  });
-
-  describe("addAgentToState", () => {
-    it("should add new agent to state", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ agents: [] }));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      const newAgent: AgentState = {
-        name: "new-agent",
-        agentId: "agent-456",
-        pid: 67890,
-        tmuxSession: "agentmesh-new-agent",
-        startedAt: "2024-01-02T00:00:00Z",
-        token: "new-token",
-      };
-
-      addAgentToState(newAgent);
-
-      expect(fs.writeFileSync).toHaveBeenCalled();
-      const writtenContent = vi.mocked(fs.writeFileSync).mock.calls[0][1] as string;
-      const parsedState = JSON.parse(writtenContent);
-      expect(parsedState.agents).toHaveLength(1);
-      expect(parsedState.agents[0].name).toBe("new-agent");
-    });
-
-    it("should replace existing agent with same name", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      const updatedAgent: AgentState = {
-        name: "test-agent",
-        agentId: "agent-789",
-        pid: 11111,
-        tmuxSession: "agentmesh-test-agent",
-        startedAt: "2024-01-03T00:00:00Z",
-        token: "updated-token",
-      };
-
-      addAgentToState(updatedAgent);
-
-      const writtenContent = vi.mocked(fs.writeFileSync).mock.calls[0][1] as string;
-      const parsedState = JSON.parse(writtenContent);
-      expect(parsedState.agents).toHaveLength(1);
-      expect(parsedState.agents[0].agentId).toBe("agent-789");
-    });
-  });
-
-  describe("removeAgentFromState", () => {
-    it("should remove agent from state", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      removeAgentFromState("test-agent");
-
-      const writtenContent = vi.mocked(fs.writeFileSync).mock.calls[0][1] as string;
-      const parsedState = JSON.parse(writtenContent);
-      expect(parsedState.agents).toHaveLength(0);
-    });
-  });
-
-  describe("getAgentState", () => {
-    it("should return agent by name", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-
-      const agent = getAgentState("test-agent");
-      expect(agent).toBeDefined();
-      expect(agent?.agentId).toBe("agent-123");
-    });
-
-    it("should return undefined for non-existent agent", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-
-      const agent = getAgentState("non-existent");
-      expect(agent).toBeUndefined();
-    });
-  });
-
-  describe("updateAgentInState", () => {
-    it("should update agent fields", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      updateAgentInState("test-agent", { token: "new-token-123" });
-
-      const writtenContent = vi.mocked(fs.writeFileSync).mock.calls[0][1] as string;
-      const parsedState = JSON.parse(writtenContent);
-      expect(parsedState.agents[0].token).toBe("new-token-123");
-      // Other fields should remain unchanged
-      expect(parsedState.agents[0].agentId).toBe("agent-123");
-    });
-
-    it("should do nothing for non-existent agent", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      updateAgentInState("non-existent", { token: "new-token" });
-
-      // writeFileSync should not be called since agent doesn't exist
-      // Actually it will be called but the state will be unchanged
-    });
-
-    it("should update restart count and status fields", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      updateAgentInState("test-agent", {
-        restartCount: 2,
-        status: "stuck",
-        stuckSince: "2024-01-01T01:00:00Z",
-      });
-
-      const writtenContent = vi.mocked(fs.writeFileSync).mock.calls[0][1] as string;
-      const parsedState = JSON.parse(writtenContent);
-      expect(parsedState.agents[0].restartCount).toBe(2);
-      expect(parsedState.agents[0].status).toBe("stuck");
-      expect(parsedState.agents[0].stuckSince).toBe("2024-01-01T01:00:00Z");
-    });
-  });
-
-  describe("resetAgentRestartCount", () => {
-    it("should reset restart count and clear stuck status", () => {
-      const stuckState: State = {
-        agents: [
-          {
-            name: "test-agent",
-            agentId: "agent-123",
-            pid: 12345,
-            tmuxSession: "agentmesh-test-agent",
-            startedAt: "2024-01-01T00:00:00Z",
-            token: "test-token",
-            restartCount: 3,
-            status: "stuck",
-            stuckSince: "2024-01-01T01:00:00Z",
-          },
-        ],
-      };
-
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(stuckState));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      resetAgentRestartCount("test-agent");
-
-      const writtenContent = vi.mocked(fs.writeFileSync).mock.calls[0][1] as string;
-      const parsedState = JSON.parse(writtenContent);
-      expect(parsedState.agents[0].restartCount).toBe(0);
-      expect(parsedState.agents[0].status).toBe("running");
-      expect(parsedState.agents[0].stuckSince).toBeUndefined();
-    });
-  });
-});

package/src/__tests__/runner.test.ts

@@ -1,104 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  buildRunnerConfig,
-  detectRunner,
-  getRunnerDisplayName,
-  resolveModel,
-} from "../core/runner.js";
-
-describe("Runner Module", () => {
-  describe("detectRunner", () => {
-    it("should detect opencode runner", () => {
-      expect(detectRunner("opencode")).toBe("opencode");
-      expect(detectRunner("opencode --some-flag")).toBe("opencode");
-      expect(detectRunner("OPENCODE")).toBe("opencode");
-    });
-
-    it("should detect claude runner", () => {
-      expect(detectRunner("claude")).toBe("claude");
-      expect(detectRunner("claude --some-flag")).toBe("claude");
-      expect(detectRunner("CLAUDE")).toBe("claude");
-    });
-
-    it("should detect custom runner for unknown commands", () => {
-      expect(detectRunner("aider")).toBe("custom");
-      expect(detectRunner("cursor")).toBe("custom");
-      expect(detectRunner("my-custom-tool")).toBe("custom");
-    });
-  });
-
-  describe("resolveModel", () => {
-    it("should prioritize CLI model over all others", () => {
-      const result = resolveModel({
-        cliModel: "cli-model",
-        agentModel: "agent-model",
-        defaultModel: "default-model",
-        command: "opencode",
-      });
-      expect(result).toBe("cli-model");
-    });
-
-    it("should use agent model when CLI not provided", () => {
-      const result = resolveModel({
-        agentModel: "agent-model",
-        defaultModel: "default-model",
-        command: "opencode",
-      });
-      expect(result).toBe("agent-model");
-    });
-
-    it("should fall back to default model", () => {
-      const result = resolveModel({
-        defaultModel: "default-model",
-        command: "opencode",
-      });
-      expect(result).toBe("default-model");
-    });
-  });
-
-  describe("buildRunnerConfig", () => {
-    it("should build config for opencode with OPENCODE_MODEL env", () => {
-      const config = buildRunnerConfig({
-        cliModel: "claude-sonnet-4",
-        defaultModel: "claude-sonnet-4",
-        command: "opencode",
-      });
-
-      expect(config.type).toBe("opencode");
-      expect(config.model).toBe("claude-sonnet-4");
-      expect(config.env.OPENCODE_MODEL).toBeDefined();
-    });
-
-    it("should build config for claude with CLAUDE_MODEL env", () => {
-      const config = buildRunnerConfig({
-        cliModel: "claude-sonnet-4",
-        defaultModel: "claude-sonnet-4",
-        command: "claude",
-      });
-
-      expect(config.type).toBe("claude");
-      expect(config.model).toBe("claude-sonnet-4");
-      expect(config.env.CLAUDE_MODEL).toBe("claude-sonnet-4");
-    });
-
-    it("should build config for custom runner without env vars", () => {
-      const config = buildRunnerConfig({
-        cliModel: "gpt-4",
-        defaultModel: "claude-sonnet-4",
-        command: "aider",
-      });
-
-      expect(config.type).toBe("custom");
-      expect(config.model).toBe("gpt-4");
-      expect(Object.keys(config.env)).toHaveLength(0);
-    });
-  });
-
-  describe("getRunnerDisplayName", () => {
-    it("should return correct display names", () => {
-      expect(getRunnerDisplayName("opencode")).toBe("OpenCode");
-      expect(getRunnerDisplayName("claude")).toBe("Claude CLI");
-      expect(getRunnerDisplayName("custom")).toBe("Custom");
-    });
-  });
-});