@roam-research/roam-tools-core 0.4.0

package/dist/graph-resolver.js

@@ -0,0 +1,338 @@
+// src/core/graph-resolver.ts
+// Stateless config-based graph resolution with token authentication
+import { readFile, writeFile, chmod, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { RoamMcpConfigSchema, RoamError, ErrorCodes, CONFIG_VERSION, } from "./types.js";
+// Warning suppression flags (prevent spamming on every tool call)
+let permissionCheckDone = false;
+let dedupWarningShown = false;
+async function getLocalApiConfig() {
+    try {
+        const configFile = join(homedir(), ".roam-local-api.json");
+        const content = await readFile(configFile, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return { port: 3333 }; // Default port
+    }
+}
+export async function getPort() {
+    const config = await getLocalApiConfig();
+    return config.port;
+}
+// ============================================================================
+// MCP Config Loading (from ~/.roam-tools.json)
+// ============================================================================
+const CONFIG_PATH = join(homedir(), ".roam-tools.json");
+/**
+ * Write config file with restricted permissions (owner read/write only).
+ */
+async function writeConfigFile(path, data) {
+    await writeFile(path, data, { mode: 0o600 });
+    // Also chmod in case the file already existed with wrong permissions
+    await chmod(path, 0o600);
+}
+/**
+ * Check that the config file version is not newer than what this client supports.
+ * Must run on raw parsed JSON BEFORE Zod validation — a future version may change
+ * the schema structure, and Zod would reject it with a confusing error.
+ */
+function checkConfigVersion(parsed) {
+    const version = typeof parsed.version === "number" ? parsed.version : 1;
+    if (version > CONFIG_VERSION) {
+        throw new RoamError(`Your ~/.roam-tools.json (version ${version}) was written by a newer version of Roam tools. ` +
+            `This client only supports config version ${CONFIG_VERSION}. ` +
+            `Please update @roam-research/roam-mcp and @roam-research/roam-cli to the latest version.`, ErrorCodes.CONFIG_TOO_NEW, { configVersion: version, supportedVersion: CONFIG_VERSION });
+    }
+}
+export async function getMcpConfig() {
+    let content;
+    try {
+        content = await readFile(CONFIG_PATH, "utf-8");
+        // Check file permissions (Unix only — skip on Windows)
+        if (!permissionCheckDone) {
+            permissionCheckDone = true;
+            try {
+                const fileStat = await stat(CONFIG_PATH);
+                const mode = fileStat.mode & 0o777;
+                if (mode & 0o077) {
+                    console.error(`[roam-mcp] WARNING: ${CONFIG_PATH} has overly permissive permissions (0${mode.toString(8)}). ` +
+                        `This file contains API tokens and should not be accessible by others. ` +
+                        `Run: chmod 600 ${CONFIG_PATH}`);
+                }
+            }
+            catch {
+                // Ignore permission check errors (e.g., Windows)
+            }
+        }
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new RoamError(`No graphs configured. Use the setup_new_graph tool to connect a Roam graph, ` +
+                `or run the CLI setup command:\n\n` +
+                `  npx @roam-research/roam-cli connect\n\n` +
+                `After connecting, try your request again.`, ErrorCodes.CONFIG_NOT_FOUND);
+        }
+        throw error;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        throw new RoamError(`Invalid JSON in ${CONFIG_PATH}. Please check the file format.`, ErrorCodes.VALIDATION_ERROR);
+    }
+    checkConfigVersion(parsed);
+    const validated = RoamMcpConfigSchema.safeParse(parsed);
+    if (!validated.success) {
+        const issues = validated.error.issues
+            .map((i) => `  - ${i.path.join(".")}: ${i.message}`)
+            .join("\n");
+        throw new RoamError(`Invalid config in ${CONFIG_PATH}:\n${issues}`, ErrorCodes.VALIDATION_ERROR);
+    }
+    // Validate nickname uniqueness (case-insensitive)
+    const nicknames = new Set();
+    for (const graph of validated.data.graphs) {
+        const lowerNickname = graph.nickname.toLowerCase();
+        if (nicknames.has(lowerNickname)) {
+            throw new RoamError(`Duplicate nickname "${graph.nickname}" in config. Nicknames must be unique (case-insensitive).`, ErrorCodes.VALIDATION_ERROR);
+        }
+        nicknames.add(lowerNickname);
+    }
+    // Handle same-name collisions: if both hosted and offline exist with same name, keep hosted
+    const graphsByName = new Map();
+    for (const graph of validated.data.graphs) {
+        const existing = graphsByName.get(graph.name);
+        if (existing) {
+            if (!dedupWarningShown) {
+                dedupWarningShown = true;
+                // If existing is hosted, skip the new one (regardless of type)
+                // If existing is offline and new is hosted, replace with hosted
+                if (existing.type === "hosted") {
+                    console.error(`[roam-mcp] Warning: Ignoring duplicate graph "${graph.name}" (${graph.type}), using hosted version`);
+                }
+                else if (graph.type === "hosted") {
+                    console.error(`[roam-mcp] Warning: Replacing offline graph "${graph.name}" with hosted version`);
+                }
+                else {
+                    console.error(`[roam-mcp] Warning: Ignoring duplicate offline graph "${graph.name}"`);
+                }
+            }
+            // Apply dedup logic regardless of whether warning was shown
+            if (existing.type === "hosted") {
+                continue;
+            }
+            else if (graph.type === "hosted") {
+                graphsByName.set(graph.name, graph);
+            }
+            // else: both offline, skip the duplicate (continue already handled hosted case)
+        }
+        else {
+            graphsByName.set(graph.name, graph);
+        }
+    }
+    // Rebuild graphs array with deduplication applied
+    return { version: validated.data.version ?? 1, graphs: Array.from(graphsByName.values()) };
+}
+// ============================================================================
+// Config Writing Functions
+// ============================================================================
+/**
+ * Read the raw config file for write operations (no dedup, but validates with Zod).
+ * Returns empty config if file doesn't exist (so saveGraphToConfig can create the initial file).
+ */
+async function readRawConfig() {
+    let content;
+    try {
+        content = await readFile(CONFIG_PATH, "utf-8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { version: CONFIG_VERSION, graphs: [] };
+        }
+        throw error;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        throw new RoamError(`Invalid JSON in ${CONFIG_PATH}. Please check the file format.`, ErrorCodes.VALIDATION_ERROR);
+    }
+    checkConfigVersion(parsed);
+    const validated = RoamMcpConfigSchema.safeParse(parsed);
+    if (!validated.success) {
+        const issues = validated.error.issues
+            .map((i) => `  - ${i.path.join(".")}: ${i.message}`)
+            .join("\n");
+        throw new RoamError(`Invalid config in ${CONFIG_PATH}:\n${issues}`, ErrorCodes.VALIDATION_ERROR);
+    }
+    return validated.data;
+}
+/**
+ * Save a graph configuration to ~/.roam-tools.json
+ * If a graph with the same name+type exists, it will be updated.
+ * Otherwise, the graph will be added.
+ */
+export async function saveGraphToConfig(newGraph) {
+    const config = await readRawConfig();
+    // Check for nickname collision (case-insensitive)
+    const existingNickname = config.graphs.find((g) => g.nickname.toLowerCase() === newGraph.nickname.toLowerCase() &&
+        !(g.name === newGraph.name && g.type === newGraph.type));
+    if (existingNickname) {
+        throw new RoamError(`Nickname "${newGraph.nickname}" is already used by graph "${existingNickname.name}". Please choose a different nickname.`, ErrorCodes.VALIDATION_ERROR);
+    }
+    // Check for existing graph with same name+type
+    const existingIndex = config.graphs.findIndex((g) => g.name === newGraph.name && g.type === newGraph.type);
+    if (existingIndex >= 0) {
+        config.graphs[existingIndex] = newGraph; // Update existing
+    }
+    else {
+        config.graphs.push(newGraph); // Add new
+    }
+    const output = { version: CONFIG_VERSION, graphs: config.graphs };
+    await writeConfigFile(CONFIG_PATH, JSON.stringify(output, null, 2));
+}
+/**
+ * Remove a graph from ~/.roam-tools.json by nickname
+ */
+export async function removeGraphFromConfig(nickname) {
+    const config = await readRawConfig();
+    const lowerNickname = nickname.toLowerCase();
+    const initialLength = config.graphs.length;
+    config.graphs = config.graphs.filter((g) => g.nickname.toLowerCase() !== lowerNickname);
+    if (config.graphs.length === initialLength) {
+        return false; // Graph not found
+    }
+    const output = { version: CONFIG_VERSION, graphs: config.graphs };
+    await writeConfigFile(CONFIG_PATH, JSON.stringify(output, null, 2));
+    return true;
+}
+/**
+ * Update a graph's access level and/or token status in config.
+ * No-ops if nothing changed (avoids unnecessary disk writes).
+ */
+export async function updateGraphTokenStatus(nickname, updates) {
+    const config = await readRawConfig();
+    const graph = config.graphs.find((g) => g.nickname.toLowerCase() === nickname.toLowerCase());
+    if (!graph)
+        return;
+    let changed = false;
+    if (updates.accessLevel !== undefined && graph.accessLevel !== updates.accessLevel) {
+        graph.accessLevel = updates.accessLevel;
+        changed = true;
+    }
+    if (updates.lastKnownTokenStatus !== undefined && graph.lastKnownTokenStatus !== updates.lastKnownTokenStatus) {
+        graph.lastKnownTokenStatus = updates.lastKnownTokenStatus;
+        changed = true;
+    }
+    if (!changed)
+        return;
+    const output = { version: CONFIG_VERSION, graphs: config.graphs };
+    await writeConfigFile(CONFIG_PATH, JSON.stringify(output, null, 2));
+}
+/**
+ * Get all configured graphs (returns empty array if config doesn't exist)
+ * Unlike getMcpConfig(), this doesn't throw if config is missing.
+ */
+export async function getConfiguredGraphsSafe() {
+    try {
+        const config = await readRawConfig();
+        return config.graphs;
+    }
+    catch {
+        return [];
+    }
+}
+// ============================================================================
+// Graph Lookup Functions
+// ============================================================================
+/**
+ * Find a graph config by nickname (case-insensitive) or name
+ */
+export async function findGraphConfig(nameOrNickname) {
+    const config = await getMcpConfig();
+    const lower = nameOrNickname.toLowerCase();
+    // First try nickname (case-insensitive)
+    const byNickname = config.graphs.find((g) => g.nickname.toLowerCase() === lower);
+    if (byNickname)
+        return byNickname;
+    // Fall back to exact name match
+    return config.graphs.find((g) => g.name === nameOrNickname);
+}
+/**
+ * Get list of all configured graphs (for list_graphs tool and error messages)
+ */
+export async function getConfiguredGraphs() {
+    const config = await getMcpConfig();
+    return config.graphs.map((g) => ({
+        nickname: g.nickname,
+        name: g.name,
+        accessLevel: g.accessLevel || "full",
+        ...(g.lastKnownTokenStatus ? { lastKnownTokenStatus: g.lastKnownTokenStatus } : {}),
+    }));
+}
+// ============================================================================
+// Graph Resolution
+// ============================================================================
+/**
+ * Resolve which graph to use and return full config.
+ * Stateless: explicit param → single configured graph → error
+ */
+export async function resolveGraph(providedGraph) {
+    const config = await getMcpConfig();
+    // 1. Explicit graph parameter (by nickname or name)
+    if (providedGraph) {
+        const graphConfig = await findGraphConfig(providedGraph);
+        if (!graphConfig) {
+            throw new RoamError(`Graph "${providedGraph}" not found in config. Available graph nicknames are listed below.`, ErrorCodes.GRAPH_NOT_CONFIGURED, {
+                available_graphs: await getConfiguredGraphs(),
+                instruction: "Pass the 'nickname' value as the graph parameter. Before operating on a graph, call get_graph_guidelines to understand its conventions.",
+            });
+        }
+        return {
+            name: graphConfig.name,
+            type: graphConfig.type,
+            token: graphConfig.token,
+            nickname: graphConfig.nickname,
+            accessLevel: graphConfig.accessLevel,
+            lastKnownTokenStatus: graphConfig.lastKnownTokenStatus,
+        };
+    }
+    // 2. Auto-select if exactly one graph configured
+    if (config.graphs.length === 1) {
+        const graphConfig = config.graphs[0];
+        return {
+            name: graphConfig.name,
+            type: graphConfig.type,
+            token: graphConfig.token,
+            nickname: graphConfig.nickname,
+            accessLevel: graphConfig.accessLevel,
+            lastKnownTokenStatus: graphConfig.lastKnownTokenStatus,
+        };
+    }
+    // 3. Multiple graphs - require explicit selection
+    throw new RoamError("Multiple graphs configured. Pass a graph nickname as the graph parameter to specify which graph to use.", ErrorCodes.GRAPH_NOT_SELECTED, {
+        available_graphs: await getConfiguredGraphs(),
+        instruction: "Pass the 'nickname' value as the graph parameter. Before operating on a graph, call get_graph_guidelines to understand its conventions.",
+    });
+}
+/**
+ * Fetch list of open graphs from Roam's Local API.
+ * Note: This is NOT used for graph resolution in v2.0.0.
+ * It's kept for potential future use (e.g., showing which graphs are open).
+ */
+export async function getOpenGraphs() {
+    const port = await getPort();
+    const url = `http://127.0.0.1:${port}/api/graphs/open`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" },
+    });
+    const data = (await response.json());
+    if (!data.success) {
+        throw new RoamError(data.error || "Failed to get open graphs", ErrorCodes.CONNECTION_FAILED);
+    }
+    return (data.result || []).map((g) => ({ name: g.name, type: g.type }));
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export type { CallToolResult, TextContent, ImageContent, GraphType, AccessLevel, GraphConfig, RoamMcpConfig, ResolvedGraph, ErrorCode, RoamApiError, RoamResponse, RoamClientConfig, Block, Page, BlockLocation, WindowType, SidebarWindow, SidebarWindowInfo, FocusedBlock, SelectedBlock, MainWindowViewType, MainWindowView, SearchResultPath, SearchResult, SearchResponse, Template, QueryResult, QueryResponse, TokenInfoResponse, TokenInfoResult, } from "./types.js";
+export { GraphConfigSchema, RoamMcpConfigSchema, ErrorCodes, RoamError, CONFIG_VERSION, EXPECTED_API_VERSION, textResult, imageResult, errorResult, getErrorMessage, } from "./types.js";
+export { RoamClient } from "./client.js";
+export { getPort, resolveGraph, saveGraphToConfig, removeGraphFromConfig, updateGraphTokenStatus, getConfiguredGraphsSafe, getConfiguredGraphs, findGraphConfig, getMcpConfig, getOpenGraphs, } from "./graph-resolver.js";
+export { fetchAvailableGraphs, requestToken, sleep, openRoamApp, slugify, } from "./roam-api.js";
+export type { AvailableGraph, GraphsResponse, TokenExchangeResponse, } from "./roam-api.js";
+export { tools, findTool, routeToolCall } from "./tools.js";
+export type { ToolDefinition, ClientToolDefinition, StandaloneToolDefinition, } from "./tools.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,YAAY,EACV,cAAc,EAAE,WAAW,EAAE,YAAY,EACzC,SAAS,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EACjE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EACvD,KAAK,EAAE,IAAI,EAAE,aAAa,EAC1B,UAAU,EAAE,aAAa,EAAE,iBAAiB,EAC5C,YAAY,EAAE,aAAa,EAC3B,kBAAkB,EAAE,cAAc,EAClC,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAC9C,QAAQ,EAAE,WAAW,EAAE,aAAa,EACpC,iBAAiB,EAAE,eAAe,GACnC,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,iBAAiB,EAAE,mBAAmB,EACtC,UAAU,EAAE,SAAS,EACrB,cAAc,EAAE,oBAAoB,EACpC,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,eAAe,GACtD,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC,OAAO,EACL,OAAO,EAAE,YAAY,EACrB,iBAAiB,EAAE,qBAAqB,EAAE,sBAAsB,EAChE,uBAAuB,EAAE,mBAAmB,EAAE,eAAe,EAC7D,YAAY,EAAE,aAAa,GAC5B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,oBAAoB,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,GAChE,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,cAAc,EAAE,cAAc,EAAE,qBAAqB,GACtD,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC5D,YAAY,EACV,cAAc,EAAE,oBAAoB,EAAE,wBAAwB,GAC/D,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+// Barrel export for @roam-research/roam-tools-core
+export { GraphConfigSchema, RoamMcpConfigSchema, ErrorCodes, RoamError, CONFIG_VERSION, EXPECTED_API_VERSION, textResult, imageResult, errorResult, getErrorMessage, } from "./types.js";
+// Client
+export { RoamClient } from "./client.js";
+// Graph resolution and config management
+export { getPort, resolveGraph, saveGraphToConfig, removeGraphFromConfig, updateGraphTokenStatus, getConfiguredGraphsSafe, getConfiguredGraphs, findGraphConfig, getMcpConfig, getOpenGraphs, } from "./graph-resolver.js";
+// Shared Roam API functions
+export { fetchAvailableGraphs, requestToken, sleep, openRoamApp, slugify, } from "./roam-api.js";
+// Tool definitions and routing
+export { tools, findTool, routeToolCall } from "./tools.js";

package/dist/operations/blocks.d.ts

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import type { RoamClient } from "../client.js";
+import type { CallToolResult } from "../types.js";
+export declare const CreateBlockSchema: z.ZodObject<{
+    parentUid: z.ZodString;
+    markdown: z.ZodString;
+    order: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEnum<["first", "last"]>]>>;
+}, "strip", z.ZodTypeAny, {
+    markdown: string;
+    parentUid: string;
+    order?: number | "first" | "last" | undefined;
+}, {
+    markdown: string;
+    parentUid: string;
+    order?: number | "first" | "last" | undefined;
+}>;
+export declare const GetBlockSchema: z.ZodObject<{
+    uid: z.ZodString;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    uid: string;
+    maxDepth?: number | undefined;
+}, {
+    uid: string;
+    maxDepth?: number | undefined;
+}>;
+export declare const UpdateBlockSchema: z.ZodObject<{
+    uid: z.ZodString;
+    string: z.ZodOptional<z.ZodString>;
+    open: z.ZodOptional<z.ZodBoolean>;
+    heading: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    uid: string;
+    string?: string | undefined;
+    open?: boolean | undefined;
+    heading?: number | undefined;
+}, {
+    uid: string;
+    string?: string | undefined;
+    open?: boolean | undefined;
+    heading?: number | undefined;
+}>;
+export declare const DeleteBlockSchema: z.ZodObject<{
+    uid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uid: string;
+}, {
+    uid: string;
+}>;
+export declare const MoveBlockSchema: z.ZodObject<{
+    uid: z.ZodString;
+    parentUid: z.ZodString;
+    order: z.ZodUnion<[z.ZodNumber, z.ZodEnum<["first", "last"]>]>;
+}, "strip", z.ZodTypeAny, {
+    uid: string;
+    parentUid: string;
+    order: number | "first" | "last";
+}, {
+    uid: string;
+    parentUid: string;
+    order: number | "first" | "last";
+}>;
+export declare const GetBacklinksSchema: z.ZodObject<{
+    uid: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodOptional<z.ZodEnum<["created-date", "edited-date", "daily-note-date"]>>;
+    sortOrder: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    search: z.ZodOptional<z.ZodString>;
+    includePath: z.ZodOptional<z.ZodBoolean>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    title?: string | undefined;
+    sort?: "created-date" | "edited-date" | "daily-note-date" | undefined;
+    search?: string | undefined;
+    uid?: string | undefined;
+    maxDepth?: number | undefined;
+    offset?: number | undefined;
+    limit?: number | undefined;
+    sortOrder?: "asc" | "desc" | undefined;
+    includePath?: boolean | undefined;
+}, {
+    title?: string | undefined;
+    sort?: "created-date" | "edited-date" | "daily-note-date" | undefined;
+    search?: string | undefined;
+    uid?: string | undefined;
+    maxDepth?: number | undefined;
+    offset?: number | undefined;
+    limit?: number | undefined;
+    sortOrder?: "asc" | "desc" | undefined;
+    includePath?: boolean | undefined;
+}>;
+export type CreateBlockParams = z.infer<typeof CreateBlockSchema>;
+export type GetBlockParams = z.infer<typeof GetBlockSchema>;
+export type UpdateBlockParams = z.infer<typeof UpdateBlockSchema>;
+export type DeleteBlockParams = z.infer<typeof DeleteBlockSchema>;
+export type MoveBlockParams = z.infer<typeof MoveBlockSchema>;
+export type GetBacklinksParams = z.infer<typeof GetBacklinksSchema>;
+export interface BacklinkResult {
+    uid: string;
+    type?: "page";
+    markdown: string;
+    path?: Array<{
+        uid: string;
+        title?: string;
+        string?: string;
+    }>;
+}
+export interface GetBacklinksResponse {
+    total: number;
+    results: BacklinkResult[];
+}
+export declare function createBlock(client: RoamClient, params: CreateBlockParams): Promise<CallToolResult>;
+export declare function getBlock(client: RoamClient, params: GetBlockParams): Promise<CallToolResult>;
+export declare function updateBlock(client: RoamClient, params: UpdateBlockParams): Promise<CallToolResult>;
+export declare function deleteBlock(client: RoamClient, params: DeleteBlockParams): Promise<CallToolResult>;
+export declare function moveBlock(client: RoamClient, params: MoveBlockParams): Promise<CallToolResult>;
+export declare function getBacklinks(client: RoamClient, params: GetBacklinksParams): Promise<CallToolResult>;
+//# sourceMappingURL=blocks.d.ts.map

package/dist/operations/blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.d.ts","sourceRoot":"","sources":["../../src/operations/blocks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAIlD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAI5B,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;EAGzB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;EAK5B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;EAE5B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;EAI1B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU7B,CAAC;AAGH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAC5D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC9D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAGpE,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChE;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,cAAc,EAAE,CAAC;CAC3B;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAWxG;AAED,wBAAsB,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAMlG;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAQxG;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAGxG;AAED,wBAAsB,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAapG;AAED,wBAAsB,YAAY,CAChC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,cAAc,CAAC,CAezB"}

package/dist/operations/blocks.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { textResult } from "../types.js";
+// Schemas
+export const CreateBlockSchema = z.object({
+    parentUid: z.string().describe("UID of parent block or page"),
+    markdown: z.string().describe("Markdown content for the block"),
+    order: z.union([z.coerce.number(), z.enum(["first", "last"])]).optional().describe("Position (number, 'first', or 'last'). Defaults to 'last'"),
+});
+export const GetBlockSchema = z.object({
+    uid: z.string().describe("Block UID"),
+    maxDepth: z.coerce.number().optional().describe("Max depth of children to include in markdown (omit for full tree)"),
+});
+export const UpdateBlockSchema = z.object({
+    uid: z.string().describe("Block UID"),
+    string: z.string().optional().describe("New text content"),
+    open: z.boolean().optional().describe("Collapse state"),
+    heading: z.coerce.number().optional().describe("Heading level (0-3)"),
+});
+export const DeleteBlockSchema = z.object({
+    uid: z.string().describe("Block UID to delete"),
+});
+export const MoveBlockSchema = z.object({
+    uid: z.string().describe("Block UID to move"),
+    parentUid: z.string().describe("UID of the new parent block or page"),
+    order: z.union([z.coerce.number(), z.enum(["first", "last"])]).describe("Position in the new parent (number, 'first', or 'last')"),
+});
+export const GetBacklinksSchema = z.object({
+    uid: z.string().optional().describe("UID of page or block (required if no title)"),
+    title: z.string().optional().describe("Page title (required if no uid)"),
+    offset: z.coerce.number().optional().describe("Skip first N results (default: 0)"),
+    limit: z.coerce.number().optional().describe("Max results to return (default: 20)"),
+    sort: z.enum(["created-date", "edited-date", "daily-note-date"]).optional().describe("Sort order (default: created-date)"),
+    sortOrder: z.enum(["asc", "desc"]).optional().describe("Sort direction (default: desc)"),
+    search: z.string().optional().describe("Filter results by text match (searches block, parents, children, page title)"),
+    includePath: z.boolean().optional().describe("Include breadcrumb path to each result (default: true)"),
+    maxDepth: z.coerce.number().optional().describe("Max depth of children to include in markdown (default: 2)"),
+});
+export async function createBlock(client, params) {
+    const response = await client.call("data.block.fromMarkdown", [
+        {
+            location: {
+                "parent-uid": params.parentUid,
+                order: params.order ?? "last",
+            },
+            "markdown-string": params.markdown,
+        },
+    ]);
+    return textResult(response.result ?? { uids: [] });
+}
+export async function getBlock(client, params) {
+    const apiParams = { uid: params.uid };
+    if (params.maxDepth !== undefined)
+        apiParams.maxDepth = params.maxDepth;
+    const response = await client.call("data.ai.getBlock", [apiParams]);
+    return textResult(response.result ?? null);
+}
+export async function updateBlock(client, params) {
+    const block = { uid: params.uid };
+    if (params.string !== undefined)
+        block.string = params.string;
+    if (params.open !== undefined)
+        block.open = params.open;
+    if (params.heading !== undefined)
+        block.heading = params.heading;
+    await client.call("data.block.update", [{ block }]);
+    return textResult({ success: true });
+}
+export async function deleteBlock(client, params) {
+    await client.call("data.block.delete", [{ block: { uid: params.uid } }]);
+    return textResult({ success: true });
+}
+export async function moveBlock(client, params) {
+    await client.call("data.block.move", [
+        {
+            location: {
+                "parent-uid": params.parentUid,
+                order: params.order,
+            },
+            block: {
+                uid: params.uid,
+            },
+        },
+    ]);
+    return textResult({ success: true });
+}
+export async function getBacklinks(client, params) {
+    const apiParams = {};
+    if (params.uid !== undefined)
+        apiParams.uid = params.uid;
+    if (params.title !== undefined)
+        apiParams.title = params.title;
+    if (params.offset !== undefined)
+        apiParams.offset = params.offset;
+    if (params.limit !== undefined)
+        apiParams.limit = params.limit;
+    if (params.sort !== undefined)
+        apiParams.sort = params.sort;
+    if (params.sortOrder !== undefined)
+        apiParams.sortOrder = params.sortOrder;
+    if (params.search !== undefined)
+        apiParams.search = params.search;
+    if (params.includePath !== undefined)
+        apiParams.includePath = params.includePath;
+    if (params.maxDepth !== undefined)
+        apiParams.maxDepth = params.maxDepth;
+    const response = await client.call("data.ai.getBacklinks", [apiParams]);
+    return textResult(response.result ?? { total: 0, results: [] });
+}

package/dist/operations/files.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import type { RoamClient } from "../client.js";
+import type { CallToolResult } from "../types.js";
+export declare const FileGetSchema: z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>;
+export declare const FileUploadSchema: z.ZodObject<{
+    filePath: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    base64: z.ZodOptional<z.ZodString>;
+    mimetype: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url?: string | undefined;
+    base64?: string | undefined;
+    filePath?: string | undefined;
+    mimetype?: string | undefined;
+    filename?: string | undefined;
+}, {
+    url?: string | undefined;
+    base64?: string | undefined;
+    filePath?: string | undefined;
+    mimetype?: string | undefined;
+    filename?: string | undefined;
+}>;
+export declare const FileDeleteSchema: z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>;
+export type FileGetParams = z.infer<typeof FileGetSchema>;
+export type FileUploadParams = z.infer<typeof FileUploadSchema>;
+export type FileDeleteParams = z.infer<typeof FileDeleteSchema>;
+export declare function getFile(client: RoamClient, params: FileGetParams): Promise<CallToolResult>;
+export declare function uploadFile(client: RoamClient, params: FileUploadParams): Promise<CallToolResult>;
+export declare function deleteFile(client: RoamClient, params: FileDeleteParams): Promise<CallToolResult>;
+//# sourceMappingURL=files.d.ts.map

package/dist/operations/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../src/operations/files.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAIlD,eAAO,MAAM,aAAa;;;;;;EAExB,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;EAM3B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;EAE3B,CAAC;AAGH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAChE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AA0GhE,wBAAsB,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC,CAkBhG;AAED,wBAAsB,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,CAiDtG;AAED,wBAAsB,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,CAGtG"}