rote-toolkit 0.2.0

package/README.md

@@ -0,0 +1,125 @@
+# Rote Toolkit
+
+Rote Toolkit 是一个基于 TypeScript 的增强工具包，主要用于在终端或 AI Agents 侧连接和增强你的 [Rote](https://rote.ink) 笔记系统。基于 Rote OpenKey API 授权，即插即用，无需繁复的登录流程。
+
+## 特性
+
+- **CLI 模式**：通过终端快速记笔记、搜索笔记。
+- **MCP 模式**：作为 Model Context Protocol 服务端，让 AI (Claude/Cursor) 能够安全、规范地读写 Rote 笔记。
+- **无感鉴权**：只需一次配置 OpenKey 即可长期使用。
+
+## 安装
+
+> 要求 Node.js v18 或更高版本。
+
+```bash
+npm install -g rote-toolkit
+```
+
+## 配置鉴权
+
+运行以下命令进行全局配置：
+
+```bash
+rote login
+```
+
+系统会提示你输入：
+1. **Rote API URL**：例如 `https://your-rote-domain.com`
+2. **OpenKey**：你的 API 密钥
+
+凭证会保存在本地：`~/.rote-toolkit/config.json`。
+
+## CLI 模式使用指南
+
+### 1) 快速记录笔记
+
+```bash
+rote add "今天学到了 MCP 协议，非常有趣！"
+```
+
+附带标签：
+
+```bash
+rote add "实现了一个新的前端组件" -t "代码,前端,React"
+```
+
+### 2) 搜索笔记
+
+```bash
+rote search "MCP"
+```
+
+## MCP 模式使用指南
+
+启动 MCP Server：
+
+```bash
+rote mcp
+```
+
+或独立命令：
+
+```bash
+rote-mcp
+```
+
+### Claude Desktop 配置示例
+
+```json
+{
+  "mcpServers": {
+    "rote-toolkit": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "rote-toolkit",
+        "mcp"
+      ]
+    }
+  }
+}
+```
+
+### AI 可使用的能力 (Tools)
+
+- `rote_create_note`
+- `rote_search_notes`
+- `rote_list_notes`
+
+## 本地开发
+[text](../../../Downloads/API-KEY-GUIDE.md)
+```bash
+npm install
+npm run build
+npm run dev -- --help
+```
+
+## 发布到 npm
+
+首次发布前先登录：
+
+```bash
+npm login
+```
+
+自动构建 + 自动升级版本 + 发布：
+
+```bash
+npm run release:patch
+```
+
+也支持：
+
+```bash
+npm run release:minor
+npm run release:major
+```
+
+发布脚本会执行：
+1. 检查 git 工作区是否干净
+2. 检查 npm 登录状态
+3. `npm run build`
+4. `npm pack --dry-run`
+5. `npm version <patch|minor|major>`
+6. `npm publish`

package/dist/api.d.ts

@@ -0,0 +1,16 @@
+import type { AddReactionInput, CreateArticleInput, CreateNoteInput, ListNotesInput, RemoveReactionInput, RemoveReactionResponse, RoteArticle, RoteNote, RotePermissions, RoteProfile, RoteReaction, SearchNotesInput, ToolkitConfig, UpdateProfileInput } from "./types.js";
+export declare class RoteClient {
+    private readonly apiUrl;
+    private readonly openKey;
+    constructor(config?: ToolkitConfig);
+    createNote(input: CreateNoteInput): Promise<RoteNote>;
+    searchNotes(input: SearchNotesInput): Promise<RoteNote[]>;
+    listNotes(input?: ListNotesInput): Promise<RoteNote[]>;
+    createArticle(input: CreateArticleInput): Promise<RoteArticle>;
+    addReaction(input: AddReactionInput): Promise<RoteReaction>;
+    removeReaction(input: RemoveReactionInput): Promise<RemoveReactionResponse>;
+    getProfile(): Promise<RoteProfile>;
+    updateProfile(input: UpdateProfileInput): Promise<RoteProfile>;
+    getPermissions(): Promise<RotePermissions>;
+    private request;
+}

package/dist/api.js

@@ -0,0 +1,120 @@
+import { loadConfig } from "./config.js";
+export class RoteClient {
+    apiUrl;
+    openKey;
+    constructor(config) {
+        const resolved = config ?? loadConfig();
+        this.apiUrl = resolved.apiUrl;
+        this.openKey = resolved.openKey;
+    }
+    async createNote(input) {
+        if (!input.content?.trim()) {
+            throw new Error("content is required");
+        }
+        const body = {
+            openkey: this.openKey,
+            content: input.content,
+            title: input.title ?? "",
+            tags: input.tags ?? [],
+            state: input.state ?? "private",
+            type: input.type ?? "rote",
+            pin: input.pin ?? false,
+            ...(input.articleId ? { articleId: input.articleId } : {}),
+        };
+        return this.request("/v2/api/openkey/notes", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    async searchNotes(input) {
+        if (!input.keyword?.trim()) {
+            throw new Error("keyword is required");
+        }
+        const params = new URLSearchParams({
+            openkey: this.openKey,
+            keyword: input.keyword,
+            limit: String(input.limit ?? 10),
+            skip: String(input.skip ?? 0),
+        });
+        return this.request(`/v2/api/openkey/notes/search?${params.toString()}`);
+    }
+    async listNotes(input = {}) {
+        const params = new URLSearchParams({
+            openkey: this.openKey,
+            limit: String(input.limit ?? 10),
+            skip: String(input.skip ?? 0),
+        });
+        return this.request(`/v2/api/openkey/notes?${params.toString()}`);
+    }
+    async createArticle(input) {
+        if (!input.content?.trim()) {
+            throw new Error("content is required");
+        }
+        const body = {
+            openkey: this.openKey,
+            content: input.content,
+        };
+        return this.request("/v2/api/openkey/articles", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    async addReaction(input) {
+        const body = {
+            openkey: this.openKey,
+            type: input.type,
+            roteid: input.roteid,
+            ...(input.metadata ? { metadata: input.metadata } : {}),
+        };
+        return this.request("/v2/api/openkey/reactions", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    async removeReaction(input) {
+        const params = new URLSearchParams({ openkey: this.openKey });
+        return this.request(`/v2/api/openkey/reactions/${encodeURIComponent(input.roteid)}/${encodeURIComponent(input.type)}?${params.toString()}`, { method: "DELETE" });
+    }
+    async getProfile() {
+        const params = new URLSearchParams({ openkey: this.openKey });
+        return this.request(`/v2/api/openkey/profile?${params.toString()}`);
+    }
+    async updateProfile(input) {
+        const body = {
+            openkey: this.openKey,
+            ...input,
+        };
+        return this.request("/v2/api/openkey/profile", {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    async getPermissions() {
+        const params = new URLSearchParams({ openkey: this.openKey });
+        return this.request(`/v2/api/openkey/permissions?${params.toString()}`);
+    }
+    async request(path, init) {
+        const url = `${this.apiUrl}${path}`;
+        const response = await fetch(url, init);
+        const text = await response.text();
+        let payload = null;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            // keep null, handled below
+        }
+        if (!response.ok) {
+            const message = payload?.message || text || `HTTP ${response.status}`;
+            throw new Error(`Rote API request failed: ${message}`);
+        }
+        if (!payload) {
+            throw new Error("Rote API returned non-JSON response.");
+        }
+        return payload.data;
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { getConfigPath, saveConfig } from "./config.js";
+import { RoteClient } from "./api.js";
+import { printNotes } from "./output.js";
+import { startMcpServer } from "./mcp.js";
+const program = new Command();
+program.name("rote").description("Rote Toolkit CLI").version("0.1.0");
+program
+    .command("login")
+    .description("Configure Rote API URL and OpenKey")
+    .action(async () => {
+    const rl = createInterface({ input, output });
+    try {
+        const apiUrl = await rl.question("Rote API URL: ");
+        const openKey = await rl.question("OpenKey: ");
+        saveConfig({ apiUrl, openKey });
+        console.log(`Saved config to ${getConfigPath()}`);
+    }
+    finally {
+        rl.close();
+    }
+});
+program
+    .command("add")
+    .description("Create a note")
+    .argument("<content>", "note content")
+    .option("-t, --tags <tags>", "comma-separated tags")
+    .option("--title <title>", "title")
+    .option("--state <state>", "note state", "private")
+    .option("--article-id <articleId>", "bind to an existing article")
+    .action(async (content, options) => {
+    const client = new RoteClient();
+    const tags = parseTags(options.tags);
+    const note = await client.createNote({
+        content,
+        tags,
+        title: options.title,
+        state: options.state,
+        articleId: options.articleId,
+    });
+    console.log(`Created note: ${note.id}`);
+});
+program
+    .command("article")
+    .description("Manage articles")
+    .argument("<action>", "action to perform (add)")
+    .argument("[content]", "article content")
+    .action(async (action, content) => {
+    if (action === "add" && content) {
+        const client = new RoteClient();
+        const article = await client.createArticle({ content });
+        console.log(`Created article: ${article.id}`);
+    }
+    else {
+        console.error("Invalid action or missing content");
+    }
+});
+program
+    .command("reaction")
+    .description("Manage reactions")
+    .argument("<action>", "action to perform (add|remove)")
+    .argument("<roteid>", "note ID")
+    .argument("<type>", "reaction type (e.g., like)")
+    .action(async (action, roteid, type) => {
+    const client = new RoteClient();
+    if (action === "add") {
+        const reaction = await client.addReaction({ roteid, type });
+        console.log(`Added reaction: ${reaction.id}`);
+    }
+    else if (action === "remove") {
+        const result = await client.removeReaction({ roteid, type });
+        console.log(`Removed reactions count: ${result.count}`);
+    }
+    else {
+        console.error("Invalid action");
+    }
+});
+program
+    .command("profile")
+    .description("Manage user profile")
+    .argument("<action>", "action to perform (get|update)")
+    .option("--nickname <nickname>", "new nickname")
+    .option("--description <description>", "new description")
+    .option("--username <username>", "new username")
+    .action(async (action, options) => {
+    const client = new RoteClient();
+    if (action === "get") {
+        const profile = await client.getProfile();
+        console.log(JSON.stringify(profile, null, 2));
+    }
+    else if (action === "update") {
+        const profile = await client.updateProfile({
+            nickname: options.nickname,
+            description: options.description,
+            username: options.username,
+        });
+        console.log(`Updated profile for: ${profile.username}`);
+    }
+    else {
+        console.error("Invalid action");
+    }
+});
+program
+    .command("permissions")
+    .description("Check API key permissions")
+    .action(async () => {
+    const client = new RoteClient();
+    const result = await client.getPermissions();
+    console.log(`Permissions: ${result.permissions.join(", ")}`);
+});
+program
+    .command("search")
+    .description("Search notes by keyword")
+    .argument("<keyword>", "search keyword")
+    .option("-l, --limit <limit>", "max results", parseInt, 10)
+    .option("-s, --skip <skip>", "offset", parseInt, 0)
+    .action(async (keyword, options) => {
+    const client = new RoteClient();
+    const notes = await client.searchNotes({
+        keyword,
+        limit: options.limit,
+        skip: options.skip,
+    });
+    printNotes(notes);
+});
+program
+    .command("mcp")
+    .description("Start MCP server over stdio")
+    .action(async () => {
+    await startMcpServer();
+});
+program.parseAsync(process.argv).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+});
+function parseTags(tagsRaw) {
+    if (!tagsRaw) {
+        return [];
+    }
+    return tagsRaw
+        .split(",")
+        .map((tag) => tag.trim())
+        .filter(Boolean);
+}

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import type { ToolkitConfig } from './types.js';
+export declare function getConfigPath(): string;
+export declare function saveConfig(config: ToolkitConfig): void;
+export declare function loadConfig(): ToolkitConfig;
+export declare function normalizeApiUrl(apiUrl: string): string;

package/dist/config.js

@@ -0,0 +1,37 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+const CONFIG_DIR = join(homedir(), '.rote-toolkit');
+const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+export function getConfigPath() {
+    return CONFIG_PATH;
+}
+export function saveConfig(config) {
+    if (!config.apiUrl || !config.openKey) {
+        throw new Error('apiUrl and openKey are required.');
+    }
+    const normalized = {
+        apiUrl: normalizeApiUrl(config.apiUrl),
+        openKey: config.openKey.trim(),
+    };
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(normalized, null, 2), 'utf8');
+}
+export function loadConfig() {
+    if (!existsSync(CONFIG_PATH)) {
+        throw new Error(`Config not found at ${CONFIG_PATH}. Run "rote login" first.`);
+    }
+    const raw = readFileSync(CONFIG_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed.apiUrl || !parsed.openKey) {
+        throw new Error(`Invalid config at ${CONFIG_PATH}. Run "rote login" again.`);
+    }
+    return {
+        apiUrl: normalizeApiUrl(parsed.apiUrl),
+        openKey: parsed.openKey.trim(),
+    };
+}
+export function normalizeApiUrl(apiUrl) {
+    const trimmed = apiUrl.trim().replace(/\/$/, '');
+    return trimmed;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api.js';
+export * from './config.js';
+export * from './types.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './api.js';
+export * from './config.js';
+export * from './types.js';

package/dist/mcp-standalone.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mcp-standalone.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { startMcpServer } from './mcp.js';
+startMcpServer().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to start MCP server: ${message}`);
+    process.exit(1);
+});

package/dist/mcp.d.ts

@@ -0,0 +1 @@
+export declare function startMcpServer(): Promise<void>;

package/dist/mcp.js

@@ -0,0 +1,210 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as z from "zod/v4";
+import { RoteClient } from "./api.js";
+import { truncateSingleLine } from "./output.js";
+export async function startMcpServer() {
+    const client = new RoteClient();
+    const server = new McpServer({
+        name: "rote-toolkit",
+        version: "0.1.0",
+    });
+    server.registerTool("rote_create_note", {
+        description: "Create a note in Rote via OpenKey API.",
+        inputSchema: {
+            content: z.string().min(1).describe("Note content"),
+            title: z.string().optional().describe("Optional note title"),
+            tags: z.array(z.string()).optional().describe("Optional list of tags"),
+            state: z.string().optional().describe("Note state, default private"),
+            articleId: z
+                .string()
+                .optional()
+                .describe("Optional article ID to bind to"),
+        },
+    }, async ({ content, title, tags, state, articleId }) => {
+        const note = await client.createNote({
+            content,
+            title,
+            tags,
+            state,
+            articleId,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Created note ${note.id}: ${truncateSingleLine(note.content, 100)}`,
+                },
+            ],
+        };
+    });
+    server.registerTool("rote_create_article", {
+        description: "Create an article in Rote via OpenKey API.",
+        inputSchema: {
+            content: z.string().min(1).describe("Article content"),
+        },
+    }, async ({ content }) => {
+        const article = await client.createArticle({ content });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Created article ${article.id}: ${truncateSingleLine(article.content, 100)}`,
+                },
+            ],
+        };
+    });
+    server.registerTool("rote_add_reaction", {
+        description: "Add a reaction to a note.",
+        inputSchema: {
+            roteid: z.string().describe("Note ID"),
+            type: z.string().describe("Reaction type (e.g., like)"),
+            metadata: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe("Optional metadata"),
+        },
+    }, async ({ roteid, type, metadata }) => {
+        const reaction = await client.addReaction({ roteid, type, metadata });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Added reaction ${reaction.id} of type ${reaction.type} to note ${reaction.roteid}`,
+                },
+            ],
+        };
+    });
+    server.registerTool("rote_remove_reaction", {
+        description: "Remove a reaction from a note.",
+        inputSchema: {
+            roteid: z.string().describe("Note ID"),
+            type: z.string().describe("Reaction type (e.g., like)"),
+        },
+    }, async ({ roteid, type }) => {
+        const result = await client.removeReaction({ roteid, type });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Removed reactions count: ${result.count}`,
+                },
+            ],
+        };
+    });
+    server.registerTool("rote_get_profile", {
+        description: "Get user profile information.",
+        inputSchema: {},
+    }, async () => {
+        const profile = await client.getProfile();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(profile, null, 2),
+                },
+            ],
+        };
+    });
+    server.registerTool("rote_update_profile", {
+        description: "Update user profile information.",
+        inputSchema: {
+            nickname: z.string().optional().describe("New nickname"),
+            description: z.string().optional().describe("New description"),
+            avatar: z.string().optional().describe("New avatar URL"),
+            cover: z.string().optional().describe("New cover URL"),
+            username: z.string().optional().describe("New username"),
+        },
+    }, async ({ nickname, description, avatar, cover, username }) => {
+        const profile = await client.updateProfile({
+            nickname,
+            description,
+            avatar,
+            cover,
+            username,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Updated profile for: ${profile.username}`,
+                },
+            ],
+        };
+    });
+    server.registerTool("rote_get_permissions", {
+        description: "Check API key permissions.",
+        inputSchema: {},
+    }, async () => {
+        const result = await client.getPermissions();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Permissions: ${result.permissions.join(", ")}`,
+                },
+            ],
+        };
+    });
+    server.registerTool("rote_search_notes", {
+        description: "Search notes in Rote by keyword.",
+        inputSchema: {
+            keyword: z.string().min(1).describe("Search keyword"),
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(50)
+                .optional()
+                .describe("Max results, default 10"),
+            skip: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe("Pagination offset, default 0"),
+        },
+    }, async ({ keyword, limit, skip }) => {
+        const notes = await client.searchNotes({ keyword, limit, skip });
+        const lines = notes.map((note, i) => `${i + 1}. ${truncateSingleLine(note.content, 100)}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: lines.length > 0 ? lines.join("\n") : "No notes found.",
+                },
+            ],
+        };
+    });
+    server.registerTool("rote_list_notes", {
+        description: "List recent notes in Rote.",
+        inputSchema: {
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(50)
+                .optional()
+                .describe("Max results, default 10"),
+            skip: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe("Pagination offset, default 0"),
+        },
+    }, async ({ limit, skip }) => {
+        const notes = await client.listNotes({ limit, skip });
+        const lines = notes.map((note, i) => `${i + 1}. ${truncateSingleLine(note.content, 100)}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: lines.length > 0 ? lines.join("\n") : "No notes found.",
+                },
+            ],
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/output.d.ts

@@ -0,0 +1,3 @@
+import type { RoteNote } from './types.js';
+export declare function printNotes(notes: RoteNote[]): void;
+export declare function truncateSingleLine(text: string, max?: number): string;

package/dist/output.js

@@ -0,0 +1,19 @@
+export function printNotes(notes) {
+    if (!Array.isArray(notes) || notes.length === 0) {
+        console.log('No notes found.');
+        return;
+    }
+    notes.forEach((note, idx) => {
+        const tags = note.tags?.length ? ` [${note.tags.join(', ')}]` : '';
+        const title = note.title ? `${note.title} - ` : '';
+        const content = truncateSingleLine(note.content || '', 120);
+        console.log(`${idx + 1}. ${title}${content}${tags}`);
+    });
+}
+export function truncateSingleLine(text, max = 120) {
+    const compact = text.replace(/\s+/g, ' ').trim();
+    if (compact.length <= max) {
+        return compact;
+    }
+    return `${compact.slice(0, Math.max(0, max - 3))}...`;
+}

package/dist/types.d.ts

@@ -0,0 +1,90 @@
+export interface ToolkitConfig {
+    apiUrl: string;
+    openKey: string;
+}
+export interface RoteNote {
+    id: string;
+    content: string;
+    title?: string;
+    tags?: string[];
+    state?: string;
+    type?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface ApiEnvelope<T> {
+    code: number;
+    message: string;
+    data: T;
+}
+export interface CreateNoteInput {
+    content: string;
+    title?: string;
+    tags?: string[];
+    state?: string;
+    type?: string;
+    pin?: boolean;
+    articleId?: string;
+}
+export interface RoteArticle {
+    id: string;
+    content: string;
+    authorId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateArticleInput {
+    content: string;
+}
+export interface RoteReaction {
+    id: string;
+    type: string;
+    roteid: string;
+    userid: string;
+}
+export interface AddReactionInput {
+    type: string;
+    roteid: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RemoveReactionInput {
+    type: string;
+    roteid: string;
+}
+export interface RemoveReactionResponse {
+    count: number;
+}
+export interface RoteProfile {
+    id: string;
+    email: string;
+    emailVerified?: boolean;
+    username: string;
+    nickname: string;
+    description: string;
+    avatar: string;
+    cover: string;
+    role: string;
+    createdAt: string;
+    updatedAt: string;
+    allowExplore?: boolean;
+    oauthBindings?: unknown[];
+}
+export interface UpdateProfileInput {
+    nickname?: string;
+    description?: string;
+    avatar?: string;
+    cover?: string;
+    username?: string;
+}
+export interface RotePermissions {
+    permissions: string[];
+}
+export interface SearchNotesInput {
+    keyword: string;
+    limit?: number;
+    skip?: number;
+}
+export interface ListNotesInput {
+    limit?: number;
+    skip?: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "rote-toolkit",
+  "version": "0.2.0",
+  "description": "CLI and MCP toolkit for Rote OpenKey API",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "rote": "dist/cli.js",
+    "rote-mcp": "dist/mcp-standalone.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/cli.ts",
+    "mcp": "tsx src/mcp-standalone.ts",
+    "start": "node dist/cli.js",
+    "prepublishOnly": "npm run build",
+    "release": "bash scripts/release.sh",
+    "release:patch": "bash scripts/release.sh patch",
+    "release:minor": "bash scripts/release.sh minor",
+    "release:major": "bash scripts/release.sh major"
+  },
+  "keywords": [
+    "rote",
+    "cli",
+    "mcp",
+    "openkey"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.18.0",
+    "commander": "^14.0.1",
+    "zod": "^4.1.5"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "tsx": "^4.20.3",
+    "typescript": "^5.9.2"
+  }
+}