@agentmeshhq/agent 0.1.7 → 0.1.9

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;
+}

package/src/cli/index.ts

@@ -5,6 +5,7 @@ import { Command } from "commander";
 import pc from "picocolors";
 import { attach } from "./attach.js";
 import { configCmd } from "./config.js";
+import { contextCmd } from "./context.js";
 import { init } from "./init.js";
 import { list } from "./list.js";
 import { logs } from "./logs.js";
@@ -46,6 +47,7 @@ program
   .option("-w, --workdir <path>", "Working directory")
   .option("-m, --model <model>", "Model identifier")
   .option("-f, --foreground", "Run in foreground (blocking)")
+  .option("--no-context", "Start fresh without restoring previous context")
   .action(async (options) => {
     try {
       await start(options);
@@ -166,9 +168,10 @@ program
   .command("restart")
   .description("Restart an agent (preserves agent ID)")
   .argument("<name>", "Agent name")
-  .action(async (name) => {
+  .option("-m, --model <model>", "Model to use (default: preserve previous model)")
+  .action(async (name, options) => {
     try {
-      await restart(name);
+      await restart(name, { model: options.model });
     } catch (error) {
       console.error(pc.red((error as Error).message));
       process.exit(1);
@@ -190,4 +193,19 @@ program
     }
   });
 
+program
+  .command("context")
+  .description("Manage agent context persistence")
+  .argument("[action]", "Action: show (default), clear, export, import, list, path")
+  .argument("[name]", "Agent name or file path (for import)")
+  .option("-o, --output <path>", "Output file path (for export)")
+  .action(async (action, name, options) => {
+    try {
+      await contextCmd(action || "show", name, options);
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
 program.parse();

package/src/cli/restart.ts

@@ -4,7 +4,11 @@ import { destroySession, getSessionName, sessionExists } from "../core/tmux.js";
 import { start } from "./start.js";
 import { stop } from "./stop.js";
 
-export async function restart(name: string): Promise<void> {
+export interface RestartOptions {
+  model?: string;
+}
+
+export async function restart(name: string, options: RestartOptions = {}): Promise<void> {
   const config = loadConfig();
 
   if (!config) {
@@ -34,6 +38,9 @@ export async function restart(name: string): Promise<void> {
   // Find agent config to get workdir and other settings
   const agentConfig = config.agents.find((a) => a.name === name);
 
+  // Model priority: CLI option > previous runtime model > agent config
+  const effectiveModel = options.model || agent.runtimeModel || agentConfig?.model;
+
   console.log(pc.dim("Starting new session..."));
 
   // Start with the same settings, agent ID will be reused from state
@@ -41,7 +48,7 @@ export async function restart(name: string): Promise<void> {
     name,
     command: agentConfig?.command,
     workdir: agentConfig?.workdir,
-    model: agentConfig?.model,
+    model: effectiveModel,
     foreground: false,
   });
 

package/src/cli/start.ts

@@ -1,10 +1,10 @@
 import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
 import path from "node:path";
-import { AgentDaemon } from "../core/daemon.js";
-import { loadConfig, getAgentState } from "../config/loader.js";
-import { sessionExists, getSessionName } from "../core/tmux.js";
+import { fileURLToPath } from "node:url";
 import pc from "picocolors";
+import { getAgentState, loadConfig } from "../config/loader.js";
+import { AgentDaemon } from "../core/daemon.js";
+import { getSessionName, sessionExists } from "../core/tmux.js";
 
 export interface StartOptions {
   name: string;
@@ -12,6 +12,7 @@ export interface StartOptions {
   workdir?: string;
   model?: string;
   foreground?: boolean;
+  noContext?: boolean;
 }
 
 export async function start(options: StartOptions): Promise<void> {
@@ -40,7 +41,10 @@ export async function start(options: StartOptions): Promise<void> {
   // If --foreground flag is set, run in foreground (blocking)
   if (options.foreground) {
     try {
-      const daemon = new AgentDaemon(options);
+      const daemon = new AgentDaemon({
+        ...options,
+        restoreContext: !options.noContext,
+      });
       await daemon.start();
       // Keep process alive
       await new Promise(() => {});
@@ -55,16 +59,14 @@ export async function start(options: StartOptions): Promise<void> {
   console.log(`Starting agent "${options.name}" in background...`);
 
   // Get the path to this CLI
-  const cliPath = path.resolve(
-    path.dirname(fileURLToPath(import.meta.url)),
-    "../cli/index.js"
-  );
+  const cliPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../cli/index.js");
 
   // Build args for the background process
   const args = ["start", "--name", options.name, "--foreground"];
   if (options.command) args.push("--command", options.command);
   if (options.workdir) args.push("--workdir", options.workdir);
   if (options.model) args.push("--model", options.model);
+  if (options.noContext) args.push("--no-context");
 
   // Spawn detached background process
   const child = spawn("node", [cliPath, ...args], {

package/src/cli/status.ts

@@ -1,5 +1,6 @@
 import pc from "picocolors";
 import { loadConfig, loadState } from "../config/loader.js";
+import { getRunnerDisplayName } from "../core/runner.js";
 import { getSessionName, sessionExists } from "../core/tmux.js";
 
 interface HealthResponse {
@@ -60,7 +61,11 @@ export async function status(): Promise<void> {
   console.log(`  Total:    ${pc.dim(String(state.agents.length))}`);
 
   if (runningAgents.length > 0) {
-    console.log(`  Names:    ${pc.dim(runningAgents.map((a) => a.name).join(", "))}`);
+    console.log(`  Active:`);
+    for (const agent of runningAgents) {
+      const modelInfo = agent.runtimeModel ? ` [${agent.runtimeModel}]` : "";
+      console.log(`    - ${pc.cyan(agent.name)}${pc.dim(modelInfo)}`);
+    }
   }
 
   // Check tmux

package/src/cli/whoami.ts

@@ -1,5 +1,6 @@
 import pc from "picocolors";
 import { loadConfig, loadState } from "../config/loader.js";
+import { getRunnerDisplayName, type RunnerType } from "../core/runner.js";
 import { decodeToken, getTokenExpiry } from "../utils/jwt.js";
 
 export async function whoami(agentName?: string): Promise<void> {
@@ -23,9 +24,18 @@ export async function whoami(agentName?: string): Promise<void> {
       const expiry = getTokenExpiry(envToken);
       const expiryStr = formatExpiry(expiry);
 
+      // Find the agent in state to get model info
+      const agentState = state.agents.find((a) => a.agentId === envAgentId);
+
       console.log(pc.bold("Current Agent"));
       console.log(`  ID:        ${pc.cyan(envAgentId)}`);
       console.log(`  Workspace: ${pc.dim(config.workspace)}`);
+      if (agentState?.runtimeModel) {
+        const runnerName = agentState.runnerType
+          ? getRunnerDisplayName(agentState.runnerType)
+          : "Unknown";
+        console.log(`  Model:     ${pc.cyan(agentState.runtimeModel)} (${pc.dim(runnerName)})`);
+      }
       console.log(`  Token:     ${expiryStr}`);
       console.log(`  Hub:       ${pc.dim(config.hubUrl)}`);
       return;
@@ -49,6 +59,10 @@ export async function whoami(agentName?: string): Promise<void> {
       console.log(`  ${pc.cyan(agent.name)}`);
       console.log(`    ID:      ${pc.dim(agent.agentId)}`);
       console.log(`    Status:  ${running ? pc.green("running") : pc.yellow("stopped")}`);
+      if (agent.runtimeModel) {
+        const runnerName = agent.runnerType ? getRunnerDisplayName(agent.runnerType) : "Unknown";
+        console.log(`    Model:   ${pc.dim(agent.runtimeModel)} (${runnerName})`);
+      }
       console.log(`    Token:   ${expiryStr}`);
       console.log();
     }
@@ -71,6 +85,10 @@ export async function whoami(agentName?: string): Promise<void> {
   console.log(`  ID:        ${pc.cyan(agent.agentId)}`);
   console.log(`  Workspace: ${pc.dim(config.workspace)}`);
   console.log(`  Status:    ${running ? pc.green("running") : pc.yellow("stopped")}`);
+  if (agent.runtimeModel) {
+    const runnerName = agent.runnerType ? getRunnerDisplayName(agent.runnerType) : "Unknown";
+    console.log(`  Model:     ${pc.cyan(agent.runtimeModel)} (${pc.dim(runnerName)})`);
+  }
   console.log(`  Token:     ${expiryStr}`);
   console.log(`  Session:   ${pc.dim(agent.tmuxSession || "none")}`);
   console.log(`  Started:   ${pc.dim(agent.startedAt || "unknown")}`);

package/src/config/schema.ts

@@ -30,6 +30,8 @@ export const DEFAULT_CONFIG: Partial<Config> = {
 export const CONFIG_PATH = `${process.env.HOME}/.agentmesh/config.json`;
 export const STATE_PATH = `${process.env.HOME}/.agentmesh/state.json`;
 
+export type RunnerType = "opencode" | "claude" | "custom";
+
 export interface AgentState {
   name: string;
   agentId: string;
@@ -37,6 +39,10 @@ export interface AgentState {
   tmuxSession: string;
   startedAt: string;
   token?: string;
+  /** The effective runtime model (resolved from CLI > agent > defaults) */
+  runtimeModel?: string;
+  /** The runner type (opencode, claude, custom) */
+  runnerType?: RunnerType;
 }
 
 export interface State {

package/src/context/handoff.ts

@@ -0,0 +1,122 @@
+/**
+ * Context Handoff Module
+ * Functions for sharing context between agents via handoffs
+ */
+
+import type { AgentContext } from "./schema.js";
+import { loadContext } from "./storage.js";
+
+/**
+ * Minimal context for handoff (excludes sensitive/large data)
+ */
+export interface HandoffContext {
+  /** Working directory */
+  workdir: string;
+  /** Git branch if in a repo */
+  gitBranch?: string;
+  /** Current goal being worked on */
+  currentGoal?: string;
+  /** Active tasks (in_progress and pending) */
+  activeTasks: Array<{
+    content: string;
+    status: "in_progress" | "pending";
+    priority: string;
+  }>;
+  /** Recent accomplishments */
+  recentAccomplishments: string[];
+  /** Key topics from conversation */
+  topics: string[];
+  /** Any custom context data */
+  custom?: Record<string, unknown>;
+}
+
+/**
+ * Extracts handoff-relevant context from full agent context
+ */
+export function extractHandoffContext(context: AgentContext): HandoffContext {
+  return {
+    workdir: context.workingState.workdir,
+    gitBranch: context.workingState.gitBranch,
+    currentGoal: context.tasks.currentGoal,
+    activeTasks: context.tasks.tasks
+      .filter((t) => t.status === "in_progress" || t.status === "pending")
+      .map((t) => ({
+        content: t.content,
+        status: t.status as "in_progress" | "pending",
+        priority: t.priority,
+      })),
+    recentAccomplishments: context.conversation.accomplishments.slice(0, 5),
+    topics: context.conversation.topics.slice(0, 10),
+    custom: Object.keys(context.custom).length > 0 ? context.custom : undefined,
+  };
+}
+
+/**
+ * Gets handoff context for an agent by ID
+ */
+export function getHandoffContextForAgent(agentId: string): HandoffContext | null {
+  const context = loadContext(agentId);
+  if (!context) {
+    return null;
+  }
+  return extractHandoffContext(context);
+}
+
+/**
+ * Serializes handoff context to a string for inclusion in API calls
+ */
+export function serializeHandoffContext(context: HandoffContext): string {
+  return JSON.stringify(context);
+}
+
+/**
+ * Parses handoff context from a string (received from API)
+ */
+export function parseHandoffContext(contextString: string): HandoffContext | null {
+  try {
+    return JSON.parse(contextString) as HandoffContext;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Generates a human-readable summary of handoff context
+ */
+export function formatHandoffContextSummary(context: HandoffContext): string {
+  const lines: string[] = [];
+
+  if (context.workdir) {
+    lines.push(`Working directory: ${context.workdir}`);
+  }
+  if (context.gitBranch) {
+    lines.push(`Git branch: ${context.gitBranch}`);
+  }
+  if (context.currentGoal) {
+    lines.push(`Current goal: ${context.currentGoal}`);
+  }
+
+  if (context.activeTasks.length > 0) {
+    lines.push("");
+    lines.push("Active tasks:");
+    for (const task of context.activeTasks) {
+      const icon = task.status === "in_progress" ? ">" : "-";
+      lines.push(`  ${icon} ${task.content}`);
+    }
+  }
+
+  if (context.recentAccomplishments.length > 0) {
+    lines.push("");
+    lines.push("Recent accomplishments:");
+    for (const acc of context.recentAccomplishments) {
+      lines.push(`  - ${acc}`);
+    }
+  }
+
+  if (context.topics.length > 0) {
+    lines.push("");
+    lines.push(`Topics: ${context.topics.join(", ")}`);
+  }
+
+  return lines.join("\n");
+}

package/src/context/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Context Module
+ * Agent context persistence for cross-session state management
+ */
+
+export * from "./handoff.js";
+export * from "./schema.js";
+export * from "./storage.js";

package/src/context/schema.ts

@@ -0,0 +1,111 @@
+/**
+ * Agent Context Schema
+ * Defines the structure for persisting agent context across sessions
+ */
+
+export const CONTEXT_VERSION = 1;
+export const CONTEXT_DIR = `${process.env.HOME}/.agentmesh/context`;
+
+/**
+ * Summary of conversation history for context restoration
+ */
+export interface ConversationSummary {
+  /** Total messages in the conversation */
+  messageCount: number;
+  /** Key topics discussed */
+  topics: string[];
+  /** Summary of what was accomplished */
+  accomplishments: string[];
+  /** Last 5 user messages (truncated) */
+  recentMessages: Array<{
+    role: "user" | "assistant";
+    content: string;
+    timestamp: string;
+  }>;
+}
+
+/**
+ * Current working state of the agent
+ */
+export interface WorkingState {
+  /** Current working directory */
+  workdir: string;
+  /** Recently accessed files */
+  recentFiles: string[];
+  /** Open file paths being edited */
+  openFiles: string[];
+  /** Git branch if in a repo */
+  gitBranch?: string;
+  /** Git status summary */
+  gitStatus?: string;
+}
+
+/**
+ * In-progress task state from TodoWrite
+ */
+export interface TaskState {
+  /** Active tasks */
+  tasks: Array<{
+    content: string;
+    status: "pending" | "in_progress" | "completed" | "cancelled";
+    priority: "high" | "medium" | "low";
+  }>;
+  /** Overall goal being worked on */
+  currentGoal?: string;
+}
+
+/**
+ * Custom key-value store for agent-specific context
+ */
+export interface CustomContext {
+  [key: string]: unknown;
+}
+
+/**
+ * Full agent context structure
+ */
+export interface AgentContext {
+  /** Schema version for migration support */
+  version: number;
+  /** Agent ID this context belongs to */
+  agentId: string;
+  /** Agent name */
+  agentName: string;
+  /** When this context was last saved */
+  savedAt: string;
+  /** Conversation summary */
+  conversation: ConversationSummary;
+  /** Current working state */
+  workingState: WorkingState;
+  /** Task state */
+  tasks: TaskState;
+  /** Custom context data */
+  custom: CustomContext;
+}
+
+/**
+ * Creates an empty context for a new agent
+ */
+export function createEmptyContext(agentId: string, agentName: string): AgentContext {
+  return {
+    version: CONTEXT_VERSION,
+    agentId,
+    agentName,
+    savedAt: new Date().toISOString(),
+    conversation: {
+      messageCount: 0,
+      topics: [],
+      accomplishments: [],
+      recentMessages: [],
+    },
+    workingState: {
+      workdir: process.cwd(),
+      recentFiles: [],
+      openFiles: [],
+    },
+    tasks: {
+      tasks: [],
+    },
+    custom: {},
+  };
+}