mavis_memory_append

Instructions

Implementation Reference

• src/index.js:262-282 (registration)

  Tool registration for 'mavis_memory_append' in the tools array. Defines name, description, inputSchema, execFn, outputMode, stdin, and buildArgs.

  {
    name: 'mavis_memory_append',
    description: 'Append a new entry to Mavis memory (user, agent, or project level).',
    inputSchema: z.object({
      scope: z.enum(['user', 'agent', 'project']).describe('Memory scope'),
      agentName: z.string().optional().describe('Agent name (required when scope=agent)'),
      content: z.string().describe('Content to append'),
      topic: z.string().optional().describe('Topic label for the entry')
    }),
    execFn: execMavis,
    outputMode: OUTPUT_RAW,
    stdin: ({ topic, content }) => topic
      ? `### ${topic} (${new Date().toISOString().split('T')[0]})\n${content}`
      : content,
    buildArgs: ({ scope, agentName }) => {
      const args = ['memory', 'append'];
      if (scope !== 'user') args.push(scope);
      if (agentName) args.push(agentName);
      return args;
    }
  },

• src/index.js:265-270 (schema)

  Input schema for mavis_memory_append: scope (enum: user/agent/project), agentName (optional, required when scope=agent), content (string), topic (optional string).

  inputSchema: z.object({
    scope: z.enum(['user', 'agent', 'project']).describe('Memory scope'),
    agentName: z.string().optional().describe('Agent name (required when scope=agent)'),
    content: z.string().describe('Content to append'),
    topic: z.string().optional().describe('Topic label for the entry')
  }),

• src/index.js:77-92 (handler)

  runTool is the generic handler that executes all tools. For mavis_memory_append (which has execFn=execMavis and outputMode=OUTPUT_RAW), it calls execMavis with the args from buildArgs and the stdin string, then returns the raw result as text content.

  function runTool(spec, parsedArgs) {
    const { execFn, outputMode, stdin, buildArgs } = spec;
    const args = buildArgs(parsedArgs);
    const input = typeof stdin === 'function' ? stdin(parsedArgs) : stdin;
  
    const execPromise = execFn
      ? execMavis(args, input || '')
      : execMavisJSON(args);
  
    return execPromise.then(result => {
      const text = outputMode === OUTPUT_RAW
        ? (result || '')
        : JSON.stringify(result, null, 2);
      return [{ type: 'text', text }];
    });
  }

• src/index.js:32-53 (helper)

  execMavis helper function that spawns the Mavis CLI binary with given arguments and optional stdin input. Used by the raw exec path for mavis_memory_append.

  function execMavis(args, input = '') {
    return new Promise((resolve, reject) => {
      const SESSION_COMMANDS = new Set(['communication', 'session', 'spawn']);
      const sessionId = process.env.__MAVIS_PARENT_SESSION_ID;
      const subcmd = args[0];
      const needsSession = SESSION_COMMANDS.has(subcmd) && sessionId;
      const finalArgs = needsSession ? [...args, '--session', sessionId] : args;
      const proc = spawn(MAVIS_BIN, finalArgs, { stdio: ['pipe', 'pipe', 'pipe'] });
      let stdout = '';
      let stderr = '';
  
      proc.stdout.on('data', d => stdout += d.toString());
      proc.stderr.on('data', d => stderr += d.toString());
      proc.on('close', code => {
        if (code === 0) resolve(stdout.trim());
        else reject(new Error(stderr.split('\n')[0] || `exit code ${code}`));
      });
      proc.on('error', reject);
  
      if (input) proc.stdin.write(input), proc.stdin.end();
    });
  }

• src/index.js:484-509 (registration)

  MavisServer class registers all tools (including mavis_memory_append) into a toolMap and handles CallToolRequest by parsing args with inputSchema and invoking runTool.

  this.toolMap = new Map(tools.map(t => [t.name, t]));
  
  this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: tools.map(t => ({
      name: t.name,
      description: t.description,
      inputSchema: normalizeObjectSchema(t.inputSchema),
    })),
  }));
  
  this.server.setRequestHandler(CallToolRequestSchema, async request => {
    const { name, arguments: args } = request.params;
    const tool = this.toolMap.get(name);
  
    if (!tool) {
      return { content: [{ type: 'text', text: `Error: unknown tool "${name}"` }], isError: true };
    }
  
    try {
      const parsedArgs = tool.inputSchema.parse(args || {});
      const results = await runTool(tool, parsedArgs);
      return { content: results };
    } catch (err) {
      return { content: [{ type: 'text', text: `Mavis error: ${err.message}` }], isError: true };
    }
  });