@agentmeshhq/agent 0.1.7 → 0.1.8

package/src/__tests__/context.test.ts

@@ -0,0 +1,464 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  extractHandoffContext,
+  formatHandoffContextSummary,
+  parseHandoffContext,
+  serializeHandoffContext,
+} from "../context/handoff.js";
+import { type AgentContext, CONTEXT_VERSION, createEmptyContext } from "../context/schema.js";
+import {
+  deleteContext,
+  exportContext,
+  getContextPath,
+  importContext,
+  listContexts,
+  loadContext,
+  loadOrCreateContext,
+  saveContext,
+  updateContext,
+} from "../context/storage.js";
+
+// Mock fs module
+vi.mock("node:fs");
+
+const mockFs = vi.mocked(fs);
+
+describe("Context Schema", () => {
+  describe("createEmptyContext", () => {
+    it("creates context with correct version", () => {
+      const context = createEmptyContext("agent-123", "test-agent");
+      expect(context.version).toBe(CONTEXT_VERSION);
+    });
+
+    it("creates context with agent info", () => {
+      const context = createEmptyContext("agent-123", "test-agent");
+      expect(context.agentId).toBe("agent-123");
+      expect(context.agentName).toBe("test-agent");
+    });
+
+    it("creates context with empty conversation", () => {
+      const context = createEmptyContext("agent-123", "test-agent");
+      expect(context.conversation.messageCount).toBe(0);
+      expect(context.conversation.topics).toEqual([]);
+      expect(context.conversation.accomplishments).toEqual([]);
+      expect(context.conversation.recentMessages).toEqual([]);
+    });
+
+    it("creates context with working state", () => {
+      const context = createEmptyContext("agent-123", "test-agent");
+      expect(context.workingState.workdir).toBe(process.cwd());
+      expect(context.workingState.recentFiles).toEqual([]);
+      expect(context.workingState.openFiles).toEqual([]);
+    });
+
+    it("creates context with empty tasks", () => {
+      const context = createEmptyContext("agent-123", "test-agent");
+      expect(context.tasks.tasks).toEqual([]);
+      expect(context.tasks.currentGoal).toBeUndefined();
+    });
+  });
+});
+
+describe("Context Storage", () => {
+  const testAgentId = "test-agent-123";
+  const testContext: AgentContext = {
+    version: CONTEXT_VERSION,
+    agentId: testAgentId,
+    agentName: "test-agent",
+    savedAt: "2026-02-24T10:00:00.000Z",
+    conversation: {
+      messageCount: 5,
+      topics: ["testing", "context"],
+      accomplishments: ["wrote tests"],
+      recentMessages: [],
+    },
+    workingState: {
+      workdir: "/home/user/project",
+      recentFiles: ["file1.ts", "file2.ts"],
+      openFiles: ["file1.ts"],
+      gitBranch: "main",
+    },
+    tasks: {
+      tasks: [{ content: "test task", status: "in_progress", priority: "high" }],
+      currentGoal: "implement context",
+    },
+    custom: { key: "value" },
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockFs.existsSync.mockReturnValue(true);
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("getContextPath", () => {
+    it("returns correct path for agent ID", () => {
+      const contextPath = getContextPath("agent-123");
+      expect(contextPath).toContain("agent-123.json");
+      expect(contextPath).toContain(".agentmesh/context");
+    });
+  });
+
+  describe("saveContext", () => {
+    it("creates context directory if needed", () => {
+      mockFs.existsSync.mockReturnValue(false);
+      mockFs.mkdirSync.mockReturnValue(undefined);
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      saveContext(testContext);
+
+      expect(mockFs.mkdirSync).toHaveBeenCalledWith(expect.stringContaining(".agentmesh/context"), {
+        recursive: true,
+      });
+    });
+
+    it("writes context to file", () => {
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      saveContext(testContext);
+
+      expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+        expect.stringContaining(`${testAgentId}.json`),
+        expect.any(String),
+      );
+    });
+
+    it("updates savedAt timestamp", () => {
+      mockFs.writeFileSync.mockReturnValue(undefined);
+      const before = new Date().toISOString();
+
+      saveContext(testContext);
+
+      const writtenData = JSON.parse(mockFs.writeFileSync.mock.calls[0][1] as string);
+      expect(new Date(writtenData.savedAt).getTime()).toBeGreaterThanOrEqual(
+        new Date(before).getTime(),
+      );
+    });
+  });
+
+  describe("loadContext", () => {
+    it("returns null if file does not exist", () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const result = loadContext("nonexistent");
+
+      expect(result).toBeNull();
+    });
+
+    it("loads and parses context file", () => {
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(testContext));
+
+      const result = loadContext(testAgentId);
+
+      expect(result).toEqual(testContext);
+    });
+
+    it("returns null for version mismatch", () => {
+      const oldContext = { ...testContext, version: 0 };
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(oldContext));
+
+      const result = loadContext(testAgentId);
+
+      expect(result).toBeNull();
+    });
+
+    it("returns null for invalid JSON", () => {
+      mockFs.readFileSync.mockReturnValue("invalid json");
+
+      const result = loadContext(testAgentId);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("loadOrCreateContext", () => {
+    it("returns existing context if found", () => {
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(testContext));
+
+      const result = loadOrCreateContext(testAgentId, "test-agent");
+
+      expect(result).toEqual(testContext);
+    });
+
+    it("creates new context if not found", () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const result = loadOrCreateContext("new-agent", "new-name");
+
+      expect(result.agentId).toBe("new-agent");
+      expect(result.agentName).toBe("new-name");
+      expect(result.version).toBe(CONTEXT_VERSION);
+    });
+  });
+
+  describe("deleteContext", () => {
+    it("deletes context file if exists", () => {
+      mockFs.unlinkSync.mockReturnValue(undefined);
+
+      const result = deleteContext(testAgentId);
+
+      expect(result).toBe(true);
+      expect(mockFs.unlinkSync).toHaveBeenCalled();
+    });
+
+    it("returns false if file does not exist", () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const result = deleteContext("nonexistent");
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("listContexts", () => {
+    it("returns list of saved contexts", () => {
+      mockFs.readdirSync.mockReturnValue(["agent1.json", "agent2.json"] as unknown as ReturnType<
+        typeof fs.readdirSync
+      >);
+      mockFs.readFileSync.mockImplementation((filePath) => {
+        const id = path.basename(filePath as string, ".json");
+        return JSON.stringify({
+          ...testContext,
+          agentId: id,
+          savedAt: id === "agent1" ? "2026-02-24T11:00:00.000Z" : "2026-02-24T10:00:00.000Z",
+        });
+      });
+
+      const result = listContexts();
+
+      expect(result).toHaveLength(2);
+      expect(result[0].agentId).toBe("agent1"); // More recent first
+    });
+
+    it("filters non-json files", () => {
+      mockFs.readdirSync.mockReturnValue([
+        "agent1.json",
+        "readme.md",
+        ".gitkeep",
+      ] as unknown as ReturnType<typeof fs.readdirSync>);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(testContext));
+
+      const result = listContexts();
+
+      expect(result).toHaveLength(1);
+    });
+  });
+
+  describe("updateContext", () => {
+    it("updates context fields", () => {
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(testContext));
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      const result = updateContext(testAgentId, {
+        conversation: {
+          ...testContext.conversation,
+          messageCount: 10,
+        },
+      });
+
+      expect(result?.conversation.messageCount).toBe(10);
+    });
+
+    it("returns null if context not found", () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const result = updateContext("nonexistent", {});
+
+      expect(result).toBeNull();
+    });
+
+    it("preserves version and agentId", () => {
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(testContext));
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      const result = updateContext(testAgentId, {
+        agentName: "new-name",
+      });
+
+      expect(result?.version).toBe(CONTEXT_VERSION);
+      expect(result?.agentId).toBe(testAgentId);
+    });
+  });
+
+  describe("exportContext", () => {
+    it("exports context to file", () => {
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(testContext));
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      const result = exportContext(testAgentId, "/tmp/export.json");
+
+      expect(result).toBe(true);
+      expect(mockFs.writeFileSync).toHaveBeenCalledWith("/tmp/export.json", expect.any(String));
+    });
+
+    it("returns false if context not found", () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const result = exportContext("nonexistent", "/tmp/export.json");
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("importContext", () => {
+    it("imports context from file", () => {
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(testContext));
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      const result = importContext("/tmp/import.json");
+
+      expect(result).not.toBeNull();
+      expect(result?.agentId).toBe(testAgentId);
+    });
+
+    it("returns null if file not found", () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const result = importContext("/tmp/nonexistent.json");
+
+      expect(result).toBeNull();
+    });
+
+    it("returns null for invalid context", () => {
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ invalid: "context" }));
+
+      const result = importContext("/tmp/invalid.json");
+
+      expect(result).toBeNull();
+    });
+  });
+});
+
+describe("Handoff Context", () => {
+  const testContext: AgentContext = {
+    version: CONTEXT_VERSION,
+    agentId: "test-agent-123",
+    agentName: "test-agent",
+    savedAt: "2026-02-24T10:00:00.000Z",
+    conversation: {
+      messageCount: 5,
+      topics: ["testing", "context", "handoff"],
+      accomplishments: ["wrote tests", "added feature"],
+      recentMessages: [],
+    },
+    workingState: {
+      workdir: "/home/user/project",
+      recentFiles: ["file1.ts", "file2.ts"],
+      openFiles: ["file1.ts"],
+      gitBranch: "feature/context",
+    },
+    tasks: {
+      tasks: [
+        { content: "task in progress", status: "in_progress", priority: "high" },
+        { content: "pending task", status: "pending", priority: "medium" },
+        { content: "completed task", status: "completed", priority: "low" },
+      ],
+      currentGoal: "implement context persistence",
+    },
+    custom: { key: "value" },
+  };
+
+  describe("extractHandoffContext", () => {
+    it("extracts workdir and git branch", () => {
+      const handoff = extractHandoffContext(testContext);
+      expect(handoff.workdir).toBe("/home/user/project");
+      expect(handoff.gitBranch).toBe("feature/context");
+    });
+
+    it("extracts current goal", () => {
+      const handoff = extractHandoffContext(testContext);
+      expect(handoff.currentGoal).toBe("implement context persistence");
+    });
+
+    it("only includes active tasks", () => {
+      const handoff = extractHandoffContext(testContext);
+      expect(handoff.activeTasks).toHaveLength(2);
+      expect(handoff.activeTasks[0].content).toBe("task in progress");
+      expect(handoff.activeTasks[1].content).toBe("pending task");
+    });
+
+    it("includes recent accomplishments", () => {
+      const handoff = extractHandoffContext(testContext);
+      expect(handoff.recentAccomplishments).toContain("wrote tests");
+    });
+
+    it("includes topics", () => {
+      const handoff = extractHandoffContext(testContext);
+      expect(handoff.topics).toContain("testing");
+    });
+
+    it("includes custom context if present", () => {
+      const handoff = extractHandoffContext(testContext);
+      expect(handoff.custom).toEqual({ key: "value" });
+    });
+  });
+
+  describe("serializeHandoffContext", () => {
+    it("serializes to JSON string", () => {
+      const handoff = extractHandoffContext(testContext);
+      const serialized = serializeHandoffContext(handoff);
+      expect(typeof serialized).toBe("string");
+      expect(JSON.parse(serialized)).toEqual(handoff);
+    });
+  });
+
+  describe("parseHandoffContext", () => {
+    it("parses valid JSON", () => {
+      const handoff = extractHandoffContext(testContext);
+      const serialized = serializeHandoffContext(handoff);
+      const parsed = parseHandoffContext(serialized);
+      expect(parsed).toEqual(handoff);
+    });
+
+    it("returns null for invalid JSON", () => {
+      const parsed = parseHandoffContext("invalid json");
+      expect(parsed).toBeNull();
+    });
+  });
+
+  describe("formatHandoffContextSummary", () => {
+    it("formats workdir", () => {
+      const handoff = extractHandoffContext(testContext);
+      const summary = formatHandoffContextSummary(handoff);
+      expect(summary).toContain("Working directory: /home/user/project");
+    });
+
+    it("formats git branch", () => {
+      const handoff = extractHandoffContext(testContext);
+      const summary = formatHandoffContextSummary(handoff);
+      expect(summary).toContain("Git branch: feature/context");
+    });
+
+    it("formats current goal", () => {
+      const handoff = extractHandoffContext(testContext);
+      const summary = formatHandoffContextSummary(handoff);
+      expect(summary).toContain("Current goal: implement context persistence");
+    });
+
+    it("formats active tasks", () => {
+      const handoff = extractHandoffContext(testContext);
+      const summary = formatHandoffContextSummary(handoff);
+      expect(summary).toContain("Active tasks:");
+      expect(summary).toContain("> task in progress");
+      expect(summary).toContain("- pending task");
+    });
+
+    it("formats accomplishments", () => {
+      const handoff = extractHandoffContext(testContext);
+      const summary = formatHandoffContextSummary(handoff);
+      expect(summary).toContain("Recent accomplishments:");
+      expect(summary).toContain("- wrote tests");
+    });
+
+    it("formats topics", () => {
+      const handoff = extractHandoffContext(testContext);
+      const summary = formatHandoffContextSummary(handoff);
+      expect(summary).toContain("Topics:");
+    });
+  });
+});

package/src/cli/context.ts

@@ -0,0 +1,232 @@
+import pc from "picocolors";
+import { getAgentState, loadState } from "../config/loader.js";
+import { extractHandoffContext, formatHandoffContextSummary } from "../context/handoff.js";
+import {
+  CONTEXT_DIR,
+  deleteContext,
+  exportContext,
+  importContext,
+  listContexts,
+  loadContext,
+} from "../context/index.js";
+
+export interface ContextOptions {
+  output?: string;
+}
+
+export async function contextCmd(
+  action: string,
+  nameOrPath?: string,
+  options?: ContextOptions,
+): Promise<void> {
+  switch (action) {
+    case "show":
+      await showContext(nameOrPath);
+      break;
+    case "clear":
+      await clearContext(nameOrPath);
+      break;
+    case "export":
+      await exportContextCmd(nameOrPath, options?.output);
+      break;
+    case "import":
+      await importContextCmd(nameOrPath);
+      break;
+    case "list":
+    case "ls":
+      await listContextsCmd();
+      break;
+    case "path":
+      console.log(CONTEXT_DIR);
+      break;
+    default:
+      console.log(pc.red(`Unknown action: ${action}`));
+      console.log("Available actions: show, clear, export, import, list, path");
+      process.exit(1);
+  }
+}
+
+async function showContext(name?: string): Promise<void> {
+  const agentId = await resolveAgentId(name);
+  if (!agentId) {
+    return;
+  }
+
+  const context = loadContext(agentId);
+  if (!context) {
+    console.log(pc.yellow(`No saved context found for agent.`));
+    return;
+  }
+
+  console.log(pc.bold(`Context for ${context.agentName} (${context.agentId}):`));
+  console.log(pc.dim(`Saved at: ${new Date(context.savedAt).toLocaleString()}`));
+  console.log();
+
+  // Working state
+  console.log(pc.bold("Working State:"));
+  console.log(`  Directory: ${context.workingState.workdir}`);
+  if (context.workingState.gitBranch) {
+    console.log(`  Git branch: ${context.workingState.gitBranch}`);
+  }
+  if (context.workingState.recentFiles.length > 0) {
+    console.log(`  Recent files: ${context.workingState.recentFiles.slice(0, 5).join(", ")}`);
+  }
+  console.log();
+
+  // Tasks
+  const activeTasks = context.tasks.tasks.filter(
+    (t) => t.status === "in_progress" || t.status === "pending",
+  );
+  if (activeTasks.length > 0 || context.tasks.currentGoal) {
+    console.log(pc.bold("Tasks:"));
+    if (context.tasks.currentGoal) {
+      console.log(`  Goal: ${context.tasks.currentGoal}`);
+    }
+    for (const task of activeTasks) {
+      const icon = task.status === "in_progress" ? pc.yellow(">") : pc.dim("-");
+      const priority =
+        task.priority === "high" ? pc.red(`[${task.priority}]`) : pc.dim(`[${task.priority}]`);
+      console.log(`  ${icon} ${task.content} ${priority}`);
+    }
+    console.log();
+  }
+
+  // Conversation
+  if (context.conversation.topics.length > 0 || context.conversation.accomplishments.length > 0) {
+    console.log(pc.bold("Conversation:"));
+    if (context.conversation.topics.length > 0) {
+      console.log(`  Topics: ${context.conversation.topics.join(", ")}`);
+    }
+    if (context.conversation.accomplishments.length > 0) {
+      console.log("  Accomplishments:");
+      for (const acc of context.conversation.accomplishments.slice(0, 5)) {
+        console.log(`    - ${acc}`);
+      }
+    }
+    console.log();
+  }
+
+  // Custom context
+  if (Object.keys(context.custom).length > 0) {
+    console.log(pc.bold("Custom Context:"));
+    console.log(JSON.stringify(context.custom, null, 2));
+  }
+}
+
+async function clearContext(name?: string): Promise<void> {
+  const agentId = await resolveAgentId(name);
+  if (!agentId) {
+    return;
+  }
+
+  const deleted = deleteContext(agentId);
+  if (deleted) {
+    console.log(pc.green(`Context cleared for agent.`));
+  } else {
+    console.log(pc.yellow(`No context found to clear.`));
+  }
+}
+
+async function exportContextCmd(name?: string, outputPath?: string): Promise<void> {
+  const agentId = await resolveAgentId(name);
+  if (!agentId) {
+    return;
+  }
+
+  const context = loadContext(agentId);
+  if (!context) {
+    console.log(pc.yellow(`No saved context found for agent.`));
+    return;
+  }
+
+  const output = outputPath || `${context.agentName}-context.json`;
+  const success = exportContext(agentId, output);
+
+  if (success) {
+    console.log(pc.green(`Context exported to: ${output}`));
+  } else {
+    console.log(pc.red(`Failed to export context.`));
+    process.exit(1);
+  }
+}
+
+async function importContextCmd(inputPath?: string): Promise<void> {
+  if (!inputPath) {
+    console.log(pc.red("Please specify a file path to import."));
+    console.log("Usage: agentmesh context import <file>");
+    process.exit(1);
+  }
+
+  const context = importContext(inputPath);
+  if (context) {
+    console.log(pc.green(`Context imported for agent: ${context.agentName} (${context.agentId})`));
+  } else {
+    console.log(pc.red(`Failed to import context from: ${inputPath}`));
+    process.exit(1);
+  }
+}
+
+async function listContextsCmd(): Promise<void> {
+  const contexts = listContexts();
+
+  if (contexts.length === 0) {
+    console.log(pc.yellow("No saved contexts found."));
+    return;
+  }
+
+  console.log(pc.bold("Saved Contexts:"));
+  console.log();
+
+  for (const ctx of contexts) {
+    const context = loadContext(ctx.agentId);
+    if (!context) continue;
+
+    console.log(`  ${pc.cyan(context.agentName)} (${pc.dim(ctx.agentId.slice(0, 8))}...)`);
+    console.log(`    Saved: ${new Date(ctx.savedAt).toLocaleString()}`);
+    if (context.tasks.currentGoal) {
+      console.log(`    Goal: ${context.tasks.currentGoal}`);
+    }
+    console.log();
+  }
+}
+
+async function resolveAgentId(name?: string): Promise<string | null> {
+  // If no name provided, try to get from environment
+  if (!name) {
+    const envAgentId = process.env.AGENTMESH_AGENT_ID;
+    if (envAgentId) {
+      return envAgentId;
+    }
+
+    // Try to find single running agent
+    const state = loadState();
+    if (state.agents.length === 1) {
+      return state.agents[0].agentId;
+    }
+
+    if (state.agents.length === 0) {
+      console.log(pc.yellow("No running agents found."));
+      console.log("Usage: agentmesh context show <name>");
+      return null;
+    }
+
+    console.log(pc.yellow("Multiple agents running. Please specify a name."));
+    console.log("Usage: agentmesh context show <name>");
+    return null;
+  }
+
+  // Try to find by name
+  const agentState = getAgentState(name);
+  if (agentState) {
+    return agentState.agentId;
+  }
+
+  // Maybe it's already an agent ID
+  const context = loadContext(name);
+  if (context) {
+    return name;
+  }
+
+  console.log(pc.red(`Agent not found: ${name}`));
+  return null;
+}