bear_context_push_to_bear

Instructions

Implementation Reference

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

  Registration of all tools including bear_context_push_to_bear in the tools map

  export const tools: Record<string, ToolHandler> = {

• mcp-server/src/tools.ts:1098-1135 (handler)

  Complete handler definition for bear_context_push_to_bear: tool definition with schema, annotations, and buildArgs function that constructs 'context push' CLI command

  bear_context_push_to_bear: {
    tool: {
      name: "bear_context_push_to_bear",
      description:
        "Push an external file to Bear as a new note. Creates a Bear note from the file content, tags it with #context (+ optional subtag), and removes the original external file. Use when external content has matured enough to become a permanent Bear note.",
      inputSchema: {
        type: "object" as const,
        properties: {
          filename: {
            type: "string",
            description: "Filename in external/ to push",
          },
          subtag: {
            type: "string",
            description:
              "Sub-tag (e.g., 'architecture' → #context/architecture)",
          },
          title: {
            type: "string",
            description:
              "Override note title (defaults to title extracted from content)",
          },
        },
        required: ["filename"],
      },
      annotations: {
        readOnlyHint: false,
        destructiveHint: false,
        idempotentHint: true,
      },
    },
    buildArgs: (input) => {
      const args = ["context", "push", String(input.filename), "--json"];
      if (input.subtag) args.push("--subtag", String(input.subtag));
      if (input.title) args.push("--title", String(input.title));
      return args;
    },
  },

• mcp-server/src/tools.ts:1103-1122 (schema)

  Input schema for bear_context_push_to_bear: filename (required), subtag (optional), title (optional)

  inputSchema: {
    type: "object" as const,
    properties: {
      filename: {
        type: "string",
        description: "Filename in external/ to push",
      },
      subtag: {
        type: "string",
        description:
          "Sub-tag (e.g., 'architecture' → #context/architecture)",
      },
      title: {
        type: "string",
        description:
          "Override note title (defaults to title extracted from content)",
      },
    },
    required: ["filename"],
  },

• mcp-server/src/index.ts:14-124 (helper)

  Server handler that dispatches tool calls: looks up tool by name, calls buildArgs, and executes via bcli

  import { tools } from "./tools.js";
  
  function createServer(): Server {
    const server = new Server(
      {
        name: "better-bear",
        version: "0.4.0",
      },
      {
        capabilities: {
          tools: {},
        },
      },
    );
  
    server.setRequestHandler(ListToolsRequestSchema, async () => ({
      tools: Object.values(tools).map((t) => t.tool),
    }));
  
    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,
        };
      }
    });
  
    return server;