bear_find_untagged

Instructions

Implementation Reference

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

  The 'bear_find_untagged' tool is registered in the tools map with its tool definition (name, description, inputSchema, annotations) and buildArgs function that constructs the bcli command 'ls --untagged --json' with an optional limit parameter.

  bear_find_untagged: {
    tool: {
      name: "bear_find_untagged",
      description:
        "List Bear notes that have no tags assigned.",
      inputSchema: {
        type: "object" as const,
        properties: {
          limit: {
            type: "number",
            description: "Maximum number of notes to return (default 30)",
          },
        },
      },
      annotations: {
        readOnlyHint: true,
        destructiveHint: false,
        idempotentHint: true,
      },
    },
    buildArgs: (input) => {
      const args = ["ls", "--untagged", "--json"];
      if (input.limit) args.push("--limit", String(input.limit));
      return args;
    },
  },

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

  The generic request handler for all tools (including 'bear_find_untagged') in index.ts's CallToolRequestSchema handler. It looks up the tool by name from the tools map, calls buildArgs, runs the bcli command, and parses JSON output.

    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;
  }
  
  // Smithery sandbox: allows tool scanning without bcli installed
  export function createSandboxServer(): Server {
    return createServer();
  }
  
  // Default export for Smithery
  export default createServer;
  
  // Direct execution: connect via stdio
  const isDirectRun = process.argv[1]?.endsWith("index.js") ||
    process.argv[1]?.endsWith("better-bear") ||
    process.argv[1]?.endsWith("better-bear-mcp");
  
  if (isDirectRun) {
    const server = createServer();
    const transport = new StdioServerTransport();
    server.connect(transport).catch((error) => {
      console.error("Fatal error:", error);
      process.exit(1);
    });
  }

• mcp-server/src/tools.ts:670-678 (schema)

  The input schema for bear_find_untagged defines an optional 'limit' parameter (number) with a default of 30 notes.

  inputSchema: {
    type: "object" as const,
    properties: {
      limit: {
        type: "number",
        description: "Maximum number of notes to return (default 30)",
      },
    },
  },