bear_context_setup

Instructions

Implementation Reference

• mcp-server/src/tools.ts:753-777 (schema)

  Input schema for the bear_context_setup tool, defining three optional parameters: dir (directory for context library), tag_prefix (tag prefix for qualifying notes), and use_frontmatter (include notes with context:true front matter).

  inputSchema: {
    type: "object" as const,
    properties: {
      dir: {
        type: "string",
        description:
          "Output directory for the context library (default: ~/.bear-context)",
      },
      tag_prefix: {
        type: "string",
        description:
          "Tag prefix for qualifying notes (default: context). Notes tagged #context or #context/subtag will be included.",
      },
      use_frontmatter: {
        type: "boolean",
        description:
          "Also include notes with context: true in YAML front matter (default: true)",
      },
    },
  },
  annotations: {
    readOnlyHint: false,
    destructiveHint: false,
    idempotentHint: true,
  },

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

  Registration of the bear_context_setup tool as an entry in the tools record. Includes the tool definition (name, description, inputSchema, annotations) and the buildArgs function that translates input parameters into CLI arguments for the bcli backend ('context init --json').

  bear_context_setup: {
    tool: {
      name: "bear_context_setup",
      description:
        "Initialize a context library — a curated, synced folder of Bear notes optimized for LLM consumption. Creates the directory structure and config. After setup, tag Bear notes with #context (or a custom prefix) and use bear_context_sync to pull them in. One-time operation.",
      inputSchema: {
        type: "object" as const,
        properties: {
          dir: {
            type: "string",
            description:
              "Output directory for the context library (default: ~/.bear-context)",
          },
          tag_prefix: {
            type: "string",
            description:
              "Tag prefix for qualifying notes (default: context). Notes tagged #context or #context/subtag will be included.",
          },
          use_frontmatter: {
            type: "boolean",
            description:
              "Also include notes with context: true in YAML front matter (default: true)",
          },
        },
      },
      annotations: {
        readOnlyHint: false,
        destructiveHint: false,
        idempotentHint: true,
      },
    },
    buildArgs: (input) => {
      const args = ["context", "init", "--json"];
      if (input.dir) args.push("--dir", String(input.dir));
      if (input.tag_prefix)
        args.push("--tag-prefix", String(input.tag_prefix));
      if (input.use_frontmatter === true) args.push("--frontmatter");
      return args;
    },
  },

• mcp-server/src/tools.ts:779-787 (handler)

  The buildArgs function that constructs CLI arguments for the bear_context_setup tool. It builds arguments ['context', 'init', '--json'] and conditionally appends --dir, --tag-prefix, and --frontmatter flags based on input parameters. This is the core logic that drives execution when the tool is called.

    buildArgs: (input) => {
      const args = ["context", "init", "--json"];
      if (input.dir) args.push("--dir", String(input.dir));
      if (input.tag_prefix)
        args.push("--tag-prefix", String(input.tag_prefix));
      if (input.use_frontmatter === true) args.push("--frontmatter");
      return args;
    },
  },

• mcp-server/src/index.ts:29-31 (registration)

  The bear_context_setup tool is registered via the ListToolsRequestSchema handler in index.ts, which exposes all tools from the tools.ts registry to the MCP client.

  server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: Object.values(tools).map((t) => t.tool),
  }));

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

  The CallToolRequestSchema handler dispatches tool calls. When bear_context_setup is called, it invokes the tool's buildArgs to construct CLI arguments, then executes them via execBcliWithReauth (which calls the external 'bcli' binary with 'context init --json' and optional flags).

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