mavis_skill_info

Instructions

Implementation Reference

• src/index.js:356-368 (schema)

  Tool definition and input schema for mavis_skill_info. Defines skillName (required) and agentName (optional). buildArgs constructs CLI args: 'skill show <skillName>' with optional '--agent <agentName>'.

    name: 'mavis_skill_info',
    description: 'Get detailed info about a specific skill (description, triggers, commands).',
    inputSchema: z.object({
      skillName: z.string().describe('Skill name'),
      agentName: z.string().optional().describe('Agent name to scope the lookup')
    }),
    buildArgs: ({ skillName, agentName }) => {
      if (!skillName) throw new Error('skillName is required');
      const args = ['skill', 'show', skillName];
      if (agentName) args.push('--agent', agentName);
      return args;
    }
  },

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

  Generic tool handler runner. For mavis_skill_info, since no execFn is defined on the spec, it falls through to execMavisJSON (the else branch), which calls execMavis then JSON.parses the output.

  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:473-510 (registration)

  MCP server registration. tools array (containing mavis_skill_info) is mapped into a toolMap, exposed via ListToolsRequestSchema, and handled via CallToolRequestSchema which calls runTool.

  class MavisServer {
    constructor() {
      this.server = new Server(
        {
          name: 'mavis-mcp-server',
          version: '1.2.0',
          description: 'Mavis agent team — multi-agent orchestration via MCP',
        },
        { capabilities: { tools: {} } }
      );
  
      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 };
        }
      });
    }

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

  Helper functions: execMavis spawns the mavis CLI binary; execMavisJSON wraps it to parse JSON output. mavis_skill_info uses execMavisJSON (no execFn on spec).

  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();
    });
  }