bear_delete_tag

Instructions

Implementation Reference

• mcp-server/src/tools.ts:636-663 (registration)

  Tool definition and registration for bear_delete_tag. Defines the tool name, description, input schema (required 'tag' string), annotations (destructive, idempotent), and buildArgs function that constructs the CLI command: ['tag', 'delete', String(input.tag), '--json'].

  bear_delete_tag: {
    tool: {
      name: "bear_delete_tag",
      description:
        "Delete a tag from all Bear notes. The tag text is removed but notes are preserved.",
      inputSchema: {
        type: "object" as const,
        properties: {
          tag: {
            type: "string",
            description: "Tag to delete (without #)",
          },
        },
        required: ["tag"],
      },
      annotations: {
        readOnlyHint: false,
        destructiveHint: true,
        idempotentHint: true,
      },
    },
    buildArgs: (input) => [
      "tag",
      "delete",
      String(input.tag),
      "--json",
    ],
  },

• mcp-server/src/tools.ts:641-650 (schema)

  Input schema for bear_delete_tag. Requires one parameter: 'tag' (string) - the tag to delete (without #).

  inputSchema: {
    type: "object" as const,
    properties: {
      tag: {
        type: "string",
        description: "Tag to delete (without #)",
      },
    },
    required: ["tag"],
  },

• mcp-server/src/index.ts:33-122 (handler)

  Generic tool request handler that routes all tool calls (including bear_delete_tag) via the tools registry. Calls handler.buildArgs(params) to get CLI args, then executes them via execBcliWithReauth (or execBcliWithStdinAndReauth if usesStdin is defined). Results are parsed as JSON and returned.

  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    const { name, arguments: input } = request.params;
    const handler = tools[name];
  
    if (!handler) {
      return {
        content: [{ type: "text", text: `Unknown tool: ${name}` }],
        isError: true,
      };
    }
  
    const params = (input ?? {}) as Record<string, unknown>;
  
    // Validate bear_edit_note: need at least one edit operation
    if (name === "bear_edit_note") {
      const hasAppend = params.append_text !== undefined;
      const hasBody = params.body !== undefined;
      const hasSetFm = params.set_frontmatter !== undefined &&
        Object.keys(params.set_frontmatter as object).length > 0;
      const hasRemoveFm = Array.isArray(params.remove_frontmatter) &&
        (params.remove_frontmatter as unknown[]).length > 0;
      const hasFm = hasSetFm || hasRemoveFm;
  
      if (!hasAppend && !hasBody && !hasFm) {
        return {
          content: [
            {
              type: "text",
              text: "Provide 'append_text', 'body', 'set_frontmatter', or 'remove_frontmatter'.",
            },
          ],
          isError: true,
        };
      }
      if (hasAppend && hasBody) {
        return {
          content: [
            {
              type: "text",
              text: "Provide either 'append_text' or 'body', not both.",
            },
          ],
          isError: true,
        };
      }
    }
  
    try {
      const args = handler.buildArgs(params);
      let result: { stdout: string; stderr: string };
  
      // Check if this tool needs stdin piping
      const stdinData = handler.usesStdin?.(params) ?? null;
      if (stdinData !== null) {
        result = await execBcliWithStdinAndReauth(args, stdinData);
      } else {
        result = await execBcliWithReauth(args);
      }
  
      // Parse JSON output from bcli
      const stdout = result.stdout.trim();
      if (!stdout) {
        return {
          content: [{ type: "text", text: "Command completed successfully." }],
        };
      }
  
      // Validate it's JSON and pretty-print
      try {
        const parsed = JSON.parse(stdout);
        return {
          content: [
            { type: "text", text: JSON.stringify(parsed, null, 2) },
          ],
        };
      } catch {
        // If bcli returned non-JSON, pass it through
        return {
          content: [{ type: "text", text: stdout }],
        };
      }
    } catch (error) {
      const message =
        error instanceof BcliError ? error.message : String(error);
      return {
        content: [{ type: "text", text: message }],
        isError: true,
      };
    }
  });