slima-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1738 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/utils/errors.ts
+var SlimaApiError = class extends Error {
+  constructor(status, code, message) {
+    super(message || `API Error: ${status}`);
+    this.status = status;
+    this.code = code;
+    this.name = "SlimaApiError";
+  }
+};
+var AuthenticationError = class extends SlimaApiError {
+  constructor(message = "Invalid or expired API token") {
+    super(401, "UNAUTHORIZED", message);
+    this.name = "AuthenticationError";
+  }
+};
+var NotFoundError = class extends SlimaApiError {
+  constructor(resource = "Resource") {
+    super(404, "NOT_FOUND", `${resource} not found`);
+    this.name = "NotFoundError";
+  }
+};
+var InsufficientCreditsError = class extends SlimaApiError {
+  constructor() {
+    super(402, "INSUFFICIENT_CREDITS", "Insufficient credits");
+    this.name = "InsufficientCreditsError";
+  }
+};
+function formatErrorForMcp(error) {
+  if (error instanceof SlimaApiError) {
+    switch (error.code) {
+      case "NOT_FOUND":
+        return "Resource not found. Please check the token.";
+      case "UNAUTHORIZED":
+        return "Invalid API token. Please check your configuration.";
+      case "INSUFFICIENT_CREDITS":
+        return "Insufficient credits. Please top up your account.";
+      case "TOKEN_EXPIRED":
+        return "API token has expired. Please generate a new one.";
+      case "TOKEN_REVOKED":
+        return "API token has been revoked. Please generate a new one.";
+      default:
+        return error.message;
+    }
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "An unexpected error occurred.";
+}
+
+// src/utils/logger.ts
+var isDebug = process.env.DEBUG === "true" || process.env.DEBUG === "1";
+var logger = {
+  info: (message, ...args) => {
+    console.error(`[INFO] ${message}`, ...args);
+  },
+  warn: (message, ...args) => {
+    console.error(`[WARN] ${message}`, ...args);
+  },
+  error: (message, error) => {
+    if (error instanceof Error) {
+      console.error(`[ERROR] ${message}:`, error.message);
+      if (isDebug && error.stack) {
+        console.error(error.stack);
+      }
+    } else if (error !== void 0) {
+      console.error(`[ERROR] ${message}:`, error);
+    } else {
+      console.error(`[ERROR] ${message}`);
+    }
+  },
+  debug: (message, ...args) => {
+    if (isDebug) {
+      console.error(`[DEBUG] ${message}`, ...args);
+    }
+  }
+};
+
+// src/api/client.ts
+var SlimaApiClient = class {
+  baseUrl;
+  token;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.token = config.token;
+  }
+  /**
+   * 發送 API 請求
+   */
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    logger.debug(`${method} ${path}`);
+    const response = await fetch(url, {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json",
+        "User-Agent": "slima-mcp-server/0.1.0"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      await this.handleErrorResponse(response);
+    }
+    const json = await response.json();
+    return json.data;
+  }
+  /**
+   * 處理錯誤回應
+   */
+  async handleErrorResponse(response) {
+    let errorData;
+    try {
+      errorData = await response.json();
+    } catch {
+    }
+    const code = errorData?.error?.code;
+    const message = errorData?.error?.message;
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError(message);
+      case 404:
+        throw new NotFoundError(message);
+      case 402:
+        throw new InsufficientCreditsError();
+      default:
+        throw new SlimaApiError(response.status, code, message);
+    }
+  }
+  // === 書籍相關 ===
+  /**
+   * 列出所有書籍
+   */
+  async listBooks() {
+    return this.request("GET", "/api/v1/books");
+  }
+  /**
+   * 取得書籍詳情
+   */
+  async getBook(token) {
+    return this.request("GET", `/api/v1/books/${token}`);
+  }
+  // === 版本控制相關 ===
+  /**
+   * 列出 Commits
+   * 注意：API 回傳 { commits: [...] }，需要解構
+   */
+  async listCommits(bookToken, limit = 10) {
+    const response = await this.request(
+      "GET",
+      `/api/v1/books/${bookToken}/commits?limit=${limit}`
+    );
+    return response.commits;
+  }
+  /**
+   * 取得 Commit 詳情
+   */
+  async getCommit(bookToken, commitToken) {
+    return this.request(
+      "GET",
+      `/api/v1/books/${bookToken}/commits/${commitToken}`
+    );
+  }
+  /**
+   * 列出分支
+   */
+  async listBranches(bookToken) {
+    return this.request("GET", `/api/v1/books/${bookToken}/branches`);
+  }
+  /**
+   * 下載 Blobs
+   * 注意：API 回傳 { blobs: [...], notFound: [...], truncated: ... }
+   */
+  async downloadBlobs(bookToken, hashes) {
+    const response = await this.request(
+      "POST",
+      `/api/v1/books/${bookToken}/blobs/download`,
+      { hashes }
+    );
+    return response.blobs;
+  }
+  // === Persona 相關 ===
+  /**
+   * 列出所有 Personas
+   */
+  async listPersonas(genre) {
+    const params = genre ? `?genre=${encodeURIComponent(genre)}` : "";
+    return this.request("GET", `/api/v1/personas${params}`);
+  }
+  /**
+   * 取得 Persona 詳情
+   */
+  async getPersona(token) {
+    return this.request("GET", `/api/v1/personas/${token}`);
+  }
+  // === Reader Test 相關 ===
+  /**
+   * 建立 Reader Test
+   */
+  async createReaderTest(bookToken, params) {
+    return this.request(
+      "POST",
+      `/api/v1/books/${bookToken}/reader_tests`,
+      {
+        reader_test: {
+          report_type: params.reportType || "chapter",
+          persona_tokens: params.personaTokens,
+          commit_token: params.commitToken,
+          model: params.model,
+          scope_config: params.scopeConfig
+        },
+        content: params.content
+      }
+    );
+  }
+  /**
+   * 取得 Reader Test 進度
+   */
+  async getReaderTestProgress(bookToken, testToken) {
+    return this.request(
+      "GET",
+      `/api/v1/books/${bookToken}/reader_tests/${testToken}/progress`
+    );
+  }
+  /**
+   * 取得 Reader Test 結果
+   */
+  async getReaderTest(bookToken, testToken) {
+    return this.request(
+      "GET",
+      `/api/v1/books/${bookToken}/reader_tests/${testToken}`
+    );
+  }
+  // === MCP File Operations ===
+  /**
+   * 讀取檔案內容
+   */
+  async readFile(bookToken, path) {
+    return this.request(
+      "POST",
+      `/api/v1/books/${bookToken}/mcp/files/read`,
+      { path }
+    );
+  }
+  /**
+   * 建立新檔案
+   */
+  async createFile(bookToken, params) {
+    return this.request(
+      "POST",
+      `/api/v1/books/${bookToken}/mcp/files/create`,
+      {
+        path: params.path,
+        content: params.content || "",
+        parent_path: params.parentPath,
+        commit_message: params.commitMessage
+      }
+    );
+  }
+  /**
+   * 更新（覆寫）檔案內容
+   */
+  async updateFile(bookToken, params) {
+    return this.request(
+      "POST",
+      `/api/v1/books/${bookToken}/mcp/files/update`,
+      {
+        path: params.path,
+        content: params.content,
+        commit_message: params.commitMessage
+      }
+    );
+  }
+  /**
+   * 刪除檔案
+   */
+  async deleteFile(bookToken, params) {
+    return this.request(
+      "POST",
+      `/api/v1/books/${bookToken}/mcp/files/delete`,
+      {
+        path: params.path,
+        commit_message: params.commitMessage
+      }
+    );
+  }
+  /**
+   * 附加內容到檔案
+   */
+  async appendToFile(bookToken, params) {
+    return this.request(
+      "POST",
+      `/api/v1/books/${bookToken}/mcp/files/append`,
+      {
+        path: params.path,
+        content: params.content,
+        commit_message: params.commitMessage
+      }
+    );
+  }
+  /**
+   * 搜尋檔案內容
+   */
+  async searchFiles(bookToken, params) {
+    return this.request(
+      "POST",
+      `/api/v1/books/${bookToken}/mcp/files/search`,
+      {
+        query: params.query,
+        file_types: params.fileTypes,
+        limit: params.limit
+      }
+    );
+  }
+};
+
+// src/tools/books.ts
+import { z } from "zod";
+function registerBookTools(server, client) {
+  server.tool(
+    "list_books",
+    "List all books in your Slima library",
+    {},
+    async () => {
+      try {
+        const books = await client.listBooks();
+        if (books.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No books found in your library."
+              }
+            ]
+          };
+        }
+        const formatted = books.map((book) => {
+          const words = book.totalWordCount?.toLocaleString() || "0";
+          return `- **${book.title}** (${book.token})
+  Author: ${book.authorName || "N/A"} | Words: ${words}`;
+        }).join("\n\n");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Found ${books.length} book(s):
+
+${formatted}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_book",
+    "Get details of a specific book",
+    {
+      book_token: z.string().describe("Book token (e.g., bk_abc123)")
+    },
+    async ({ book_token }) => {
+      try {
+        const book = await client.getBook(book_token);
+        const text = `# ${book.title}
+
+- **Token**: ${book.token}
+- **Author**: ${book.authorName || "N/A"}
+- **Description**: ${book.description || "N/A"}
+- **Language**: ${book.language || "N/A"}
+- **Total Words**: ${book.totalWordCount?.toLocaleString() || "0"}
+- **Manuscript Words**: ${book.manuscriptWordCount?.toLocaleString() || "0"}
+- **Created**: ${book.createdAt}
+- **Updated**: ${book.updatedAt}`;
+        return {
+          content: [{ type: "text", text }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_book_structure",
+    "Get the file/folder structure of a book",
+    {
+      book_token: z.string().describe("Book token")
+    },
+    async ({ book_token }) => {
+      try {
+        const commits = await client.listCommits(book_token, 1);
+        if (commits.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No commits found. The book may be empty."
+              }
+            ]
+          };
+        }
+        const snapshot = commits[0].filesSnapshot;
+        const tree = formatFileTree(snapshot);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `File structure for book ${book_token}:
+
+${tree}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_writing_stats",
+    "Get writing statistics for a book",
+    {
+      book_token: z.string().describe("Book token")
+    },
+    async ({ book_token }) => {
+      try {
+        const [book, commits] = await Promise.all([
+          client.getBook(book_token),
+          client.listCommits(book_token, 10)
+        ]);
+        let wordChange = 0;
+        if (commits.length > 1) {
+          const latest = commits[0].totalWordCount || 0;
+          const oldest = commits[commits.length - 1].totalWordCount || 0;
+          wordChange = latest - oldest;
+        }
+        const sign = wordChange >= 0 ? "+" : "";
+        const progressText = commits.length > 1 ? `${sign}${wordChange.toLocaleString()} words (last ${commits.length} commits)` : "N/A (not enough history)";
+        const text = `# Writing Stats: ${book.title}
+
+- **Total Words**: ${book.totalWordCount?.toLocaleString() || "0"}
+- **Manuscript Words**: ${book.manuscriptWordCount?.toLocaleString() || "0"}
+- **Recent Progress**: ${progressText}
+- **Commits Analyzed**: ${commits.length}
+- **Language**: ${book.language || "N/A"}`;
+        return {
+          content: [{ type: "text", text }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function formatFileTree(files, indent = 0) {
+  return files.sort((a, b) => a.position - b.position).map((f) => {
+    const prefix = "  ".repeat(indent);
+    const icon = f.kind === "folder" ? "\u{1F4C1}" : "\u{1F4C4}";
+    const words = f.kind === "file" && f.wordCount ? ` (${f.wordCount} words)` : "";
+    const manuscript = f.isManuscript ? " [M]" : "";
+    let line = `${prefix}${icon} ${f.name}${words}${manuscript}`;
+    if (f.children && f.children.length > 0) {
+      line += "\n" + formatFileTree(f.children, indent + 1);
+    }
+    return line;
+  }).join("\n");
+}
+
+// src/tools/content.ts
+import { z as z2 } from "zod";
+function registerContentTools(server, client) {
+  server.tool(
+    "get_chapter",
+    "Read the content of a chapter or file from a book",
+    {
+      book_token: z2.string().describe("Book token (e.g., bk_abc123)"),
+      file_path: z2.string().describe("File path (e.g., /chapters/01.md or chapter-01)")
+    },
+    async ({ book_token, file_path }) => {
+      try {
+        const commits = await client.listCommits(book_token, 1);
+        if (commits.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No commits found. The book may be empty."
+              }
+            ]
+          };
+        }
+        const file = findFileInSnapshot(commits[0].filesSnapshot, file_path);
+        if (!file) {
+          const availableFiles = listAllFiles(commits[0].filesSnapshot);
+          const fileList = availableFiles.slice(0, 10).join("\n- ");
+          const moreText = availableFiles.length > 10 ? `
+... and ${availableFiles.length - 10} more files` : "";
+          return {
+            content: [
+              {
+                type: "text",
+                text: `File not found: ${file_path}
+
+Available files:
+- ${fileList}${moreText}
+
+Tip: Use get_book_structure to see the full file tree.`
+              }
+            ],
+            isError: true
+          };
+        }
+        if (file.kind === "folder") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `"${file_path}" is a folder, not a file. Please specify a file path.`
+              }
+            ],
+            isError: true
+          };
+        }
+        if (!file.blobHash) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `File "${file_path}" has no content (empty file).`
+              }
+            ]
+          };
+        }
+        const blobs = await client.downloadBlobs(book_token, [file.blobHash]);
+        if (blobs.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Could not retrieve file content. The blob may be missing."
+              }
+            ],
+            isError: true
+          };
+        }
+        const content = blobs[0].content;
+        const wordInfo = file.wordCount ? ` (${file.wordCount} words)` : "";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# ${file.name}${wordInfo}
+
+${content}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function findFileInSnapshot(files, path) {
+  const normalizedPath = path.replace(/^\//, "").toLowerCase();
+  const pathParts = normalizedPath.split("/");
+  function search(items, remainingParts) {
+    for (const item of items) {
+      const itemNameLower = item.name.toLowerCase();
+      const itemTokenLower = item.token.toLowerCase();
+      if (remainingParts.length === 1) {
+        const target = remainingParts[0];
+        if (itemNameLower === target || itemTokenLower === target || itemNameLower.replace(/\.[^.]+$/, "") === target.replace(/\.[^.]+$/, "")) {
+          return item;
+        }
+      }
+      if (item.kind === "folder" && item.children) {
+        if (itemNameLower === remainingParts[0] || itemTokenLower === remainingParts[0]) {
+          const result3 = search(item.children, remainingParts.slice(1));
+          if (result3) return result3;
+        }
+        const result2 = search(item.children, remainingParts);
+        if (result2) return result2;
+      }
+    }
+    return null;
+  }
+  let result = search(files, pathParts);
+  if (result) return result;
+  result = searchByName(files, pathParts[pathParts.length - 1]);
+  return result;
+}
+function searchByName(files, name) {
+  const nameLower = name.toLowerCase();
+  for (const item of files) {
+    const itemNameLower = item.name.toLowerCase();
+    const itemTokenLower = item.token.toLowerCase();
+    if (itemNameLower === nameLower || itemTokenLower === nameLower || itemNameLower.replace(/\.[^.]+$/, "") === nameLower.replace(/\.[^.]+$/, "")) {
+      return item;
+    }
+    if (item.kind === "folder" && item.children) {
+      const result = searchByName(item.children, name);
+      if (result) return result;
+    }
+  }
+  return null;
+}
+function listAllFiles(files, prefix = "") {
+  const result = [];
+  for (const item of files) {
+    const path = prefix ? `${prefix}/${item.name}` : item.name;
+    if (item.kind === "file") {
+      result.push(path);
+    } else if (item.children) {
+      result.push(...listAllFiles(item.children, path));
+    }
+  }
+  return result;
+}
+
+// src/tools/beta-reader.ts
+import { z as z3 } from "zod";
+function registerBetaReaderTools(server, client) {
+  server.tool(
+    "list_personas",
+    "List available virtual reader personas for beta reading feedback",
+    {
+      genre: z3.string().optional().describe("Filter by genre (e.g., fantasy, romance, scifi)")
+    },
+    async ({ genre }) => {
+      try {
+        const personas = await client.listPersonas(genre);
+        if (personas.length === 0) {
+          const genreText = genre ? ` for genre "${genre}"` : "";
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No personas found${genreText}.`
+              }
+            ]
+          };
+        }
+        const formatted = personas.map((p) => {
+          const name = p.displayLabels?.zh || p.displayLabels?.en || p.slug;
+          const tags = p.genreTags?.join(", ") || "General";
+          const demo = p.demographics || {};
+          const gender = demo.gender || "N/A";
+          const age = demo.ageRange || "N/A";
+          return `- **${name}** (\`${p.token}\`)
+  Gender: ${gender} | Age: ${age}
+  Genres: ${tags}`;
+        }).join("\n\n");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Available Personas (${personas.length}):
+
+${formatted}
+
+**Tip**: Use the persona token with \`analyze_chapter\` to get feedback from a specific reader.`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "analyze_chapter",
+    "Get AI Beta Reader feedback on a chapter from a specific reader persona. This may take a moment to complete.",
+    {
+      book_token: z3.string().describe("Book token (e.g., bk_abc123)"),
+      file_path: z3.string().describe("Chapter file path (e.g., /chapters/01.md)"),
+      persona_token: z3.string().describe("Persona token (e.g., psn_xxx). Use list_personas to find available personas.")
+    },
+    async ({ book_token, file_path, persona_token }) => {
+      try {
+        const commits = await client.listCommits(book_token, 1);
+        if (commits.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No commits found. The book may be empty."
+              }
+            ],
+            isError: true
+          };
+        }
+        const file = findFileInSnapshot2(commits[0].filesSnapshot, file_path);
+        if (!file) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `File not found: ${file_path}. Use get_book_structure to see available files.`
+              }
+            ],
+            isError: true
+          };
+        }
+        if (!file.blobHash) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `File "${file_path}" has no content (empty file).`
+              }
+            ],
+            isError: true
+          };
+        }
+        const blobs = await client.downloadBlobs(book_token, [file.blobHash]);
+        if (blobs.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Could not retrieve file content."
+              }
+            ],
+            isError: true
+          };
+        }
+        const content = blobs[0].content;
+        logger.info(`Creating reader test for ${file_path} with persona ${persona_token}`);
+        const test = await client.createReaderTest(book_token, {
+          reportType: "chapter",
+          personaTokens: [persona_token],
+          commitToken: commits[0].token,
+          scopeConfig: { chapters: [file_path] },
+          content
+        });
+        const result = await pollForCompletion(
+          () => client.getReaderTestProgress(book_token, test.token),
+          9e4
+        );
+        if (result.status === "failed") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Analysis failed. Please try again later."
+              }
+            ],
+            isError: true
+          };
+        }
+        if (result.status !== "completed") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Analysis is still in progress. You can check the status later.
+
+Test ID: ${test.token}`
+              }
+            ]
+          };
+        }
+        const fullResult = await client.getReaderTest(book_token, test.token);
+        const feedback = formatBetaReaderFeedback(fullResult, file.name);
+        return {
+          content: [{ type: "text", text: feedback }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+async function pollForCompletion(checkFn, timeoutMs) {
+  const startTime = Date.now();
+  const pollInterval = 3e3;
+  while (Date.now() - startTime < timeoutMs) {
+    const result = await checkFn();
+    logger.debug(`Poll status: ${result.status}, progress: ${result.progress || "N/A"}`);
+    if (result.status === "completed" || result.status === "failed") {
+      return result;
+    }
+    await sleep(pollInterval);
+  }
+  return { status: "timeout" };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatBetaReaderFeedback(test, fileName) {
+  const feedbacks = test.individualFeedbacks || [];
+  const metrics = test.aggregatedMetrics;
+  if (feedbacks.length === 0 && !metrics) {
+    return "No feedback available.";
+  }
+  let output = `# Beta Reader Feedback: ${fileName}
+
+`;
+  if (metrics) {
+    output += formatAggregatedMetrics(metrics);
+  }
+  if (feedbacks.length > 0) {
+    output += `
+---
+
+## Individual Reader Feedback
+
+`;
+    output += feedbacks.map(formatIndividualFeedback).join("\n---\n\n");
+  }
+  return output;
+}
+function formatAggregatedMetrics(metrics) {
+  let output = `## Summary Metrics
+
+`;
+  if (metrics.overall) {
+    const o = metrics.overall;
+    output += `### Overall Scores
+`;
+    if (o.avgContinueReading) output += `- Continue Reading Intent: ${o.avgContinueReading.toFixed(1)}/10
+`;
+    if (o.avgRecommendation) output += `- Recommendation Score: ${o.avgRecommendation.toFixed(1)}/10
+`;
+    if (o.avgWantMore) output += `- Want More: ${o.avgWantMore.toFixed(1)}/10
+`;
+    if (o.dnfRisk) output += `- DNF Risk: ${o.dnfRisk}
+`;
+    output += "\n";
+  }
+  if (metrics.kindleRating) {
+    output += `### Predicted Kindle Rating
+`;
+    output += `- Average Score: \u2B50 ${metrics.kindleRating.avgScore.toFixed(1)}/5
+`;
+    if (metrics.kindleRating.individualScores) {
+      const scores = metrics.kindleRating.individualScores.map((s) => `${s.personaName || "Reader"}: ${s.score}/5 (${s.confidence})`).join(", ");
+      output += `- Individual Scores: ${scores}
+`;
+    }
+    output += "\n";
+  }
+  if (metrics.characters) {
+    const c = metrics.characters;
+    output += `### Character Evaluation
+`;
+    if (c.avgProtagonistLikability) output += `- Protagonist Likability: ${c.avgProtagonistLikability.toFixed(1)}/10
+`;
+    if (c.avgMotivationClarity) output += `- Motivation Clarity: ${c.avgMotivationClarity.toFixed(1)}/10
+`;
+    if (c.avgDialogueNaturalness) output += `- Dialogue Naturalness: ${c.avgDialogueNaturalness.toFixed(1)}/10
+`;
+    output += "\n";
+  }
+  if (metrics.pacing) {
+    const p = metrics.pacing;
+    output += `### Pacing Evaluation
+`;
+    if (p.avgOverall) output += `- Overall Pacing: ${p.avgOverall.toFixed(1)}/10
+`;
+    if (p.consensus) output += `- Consensus: ${p.consensus}
+`;
+    if (p.commonDnfTriggers && p.commonDnfTriggers.length > 0) {
+      output += `- Common DNF Triggers:
+`;
+      p.commonDnfTriggers.slice(0, 3).forEach((t) => {
+        output += `  - ${t.trigger} (${t.count}x)
+`;
+      });
+    }
+    output += "\n";
+  }
+  if (metrics.market) {
+    const m = metrics.market;
+    output += `### Market Positioning
+`;
+    if (m.avgWordOfMouth) output += `- Word of Mouth Potential: ${m.avgWordOfMouth.toFixed(1)}/10
+`;
+    if (m.topComparableBooks && m.topComparableBooks.length > 0) {
+      const books = m.topComparableBooks.slice(0, 3).map((b) => b.title).join(", ");
+      output += `- Comparable Books: ${books}
+`;
+    }
+    output += "\n";
+  }
+  return output;
+}
+function formatIndividualFeedback(feedback) {
+  const name = feedback.personaName || feedback.personaToken;
+  let output = `### ${name}
+
+`;
+  if (feedback.overall) {
+    const o = feedback.overall;
+    if (o.continueReading) output += `**Continue Reading Intent**: ${o.continueReading}/10
+`;
+    if (o.recommendation) output += `**Recommendation**: ${o.recommendation}/10
+`;
+    if (o.dnfRisk) output += `**DNF Risk**: ${o.dnfRisk}
+`;
+    output += "\n";
+  }
+  if (feedback.kindleRating) {
+    output += `**Kindle Rating**: \u2B50 ${feedback.kindleRating.score}/5`;
+    if (feedback.kindleRating.rationale) {
+      output += ` - ${feedback.kindleRating.rationale}`;
+    }
+    output += "\n\n";
+  }
+  if (feedback.detailedFeedback) {
+    const d = feedback.detailedFeedback;
+    if (d.whatWorked) {
+      output += `**What Worked**:
+${d.whatWorked}
+
+`;
+    }
+    if (d.whatDidntWork) {
+      output += `**What Didn't Work**:
+${d.whatDidntWork}
+
+`;
+    }
+    if (d.strongestElement) {
+      output += `**Strongest Element**: ${d.strongestElement}
+`;
+    }
+    if (d.weakestElement) {
+      output += `**Weakest Element**: ${d.weakestElement}
+`;
+    }
+    if (d.wouldYouBuy) {
+      output += `**Would You Buy**: ${d.wouldYouBuy}
+`;
+    }
+    if (d.specificSuggestions && d.specificSuggestions.length > 0) {
+      output += `
+**Specific Suggestions**:
+`;
+      d.specificSuggestions.forEach((s, i) => {
+        output += `${i + 1}. ${s}
+`;
+      });
+    }
+    if (d.finalThoughts) {
+      output += `
+**Final Thoughts**:
+${d.finalThoughts}
+`;
+    }
+  }
+  if (feedback.emotionalJourney) {
+    const e = feedback.emotionalJourney;
+    if (e.emotionalArc) {
+      output += `
+**Emotional Arc**: ${e.emotionalArc}
+`;
+    }
+    if (e.peakMoments && e.peakMoments.length > 0) {
+      const moments = e.peakMoments.map(
+        (m) => typeof m === "string" ? m : m.moment || m.description || JSON.stringify(m)
+      );
+      output += `**Peak Moments**: ${moments.join(", ")}
+`;
+    }
+    if (e.overallMood) {
+      output += `**Overall Mood**: ${e.overallMood}
+`;
+    }
+  }
+  return output;
+}
+function findFileInSnapshot2(files, path) {
+  const normalizedPath = path.replace(/^\//, "").toLowerCase();
+  const pathParts = normalizedPath.split("/");
+  function search(items, remainingParts) {
+    for (const item of items) {
+      const itemNameLower = item.name.toLowerCase();
+      const itemTokenLower = item.token.toLowerCase();
+      if (remainingParts.length === 1) {
+        const target = remainingParts[0];
+        if (itemNameLower === target || itemTokenLower === target || itemNameLower.replace(/\.[^.]+$/, "") === target.replace(/\.[^.]+$/, "")) {
+          return item;
+        }
+      }
+      if (item.kind === "folder" && item.children) {
+        if (itemNameLower === remainingParts[0] || itemTokenLower === remainingParts[0]) {
+          const result3 = search(item.children, remainingParts.slice(1));
+          if (result3) return result3;
+        }
+        const result2 = search(item.children, remainingParts);
+        if (result2) return result2;
+      }
+    }
+    return null;
+  }
+  let result = search(files, pathParts);
+  if (result) return result;
+  result = searchByName2(files, pathParts[pathParts.length - 1]);
+  return result;
+}
+function searchByName2(files, name) {
+  const nameLower = name.toLowerCase();
+  for (const item of files) {
+    const itemNameLower = item.name.toLowerCase();
+    const itemTokenLower = item.token.toLowerCase();
+    if (itemNameLower === nameLower || itemTokenLower === nameLower || itemNameLower.replace(/\.[^.]+$/, "") === nameLower.replace(/\.[^.]+$/, "")) {
+      return item;
+    }
+    if (item.kind === "folder" && item.children) {
+      const result = searchByName2(item.children, name);
+      if (result) return result;
+    }
+  }
+  return null;
+}
+
+// src/tools/files.ts
+import { z as z4 } from "zod";
+function registerFileTools(server, client) {
+  server.tool(
+    "read_file",
+    "Read the content of any file in a book by its path",
+    {
+      book_token: z4.string().describe("Book token (e.g., bk_abc123)"),
+      path: z4.string().describe('File path (e.g., "characters/protagonist.md" or "chapter-01.md")')
+    },
+    async ({ book_token, path }) => {
+      try {
+        const result = await client.readFile(book_token, path);
+        const fileInfo = [
+          `# ${result.file.name}`,
+          "",
+          `**Path:** ${result.file.path}`,
+          `**Words:** ${result.file.wordCount}`,
+          `**Type:** ${result.file.fileType || "unknown"}`,
+          "",
+          "---",
+          "",
+          result.content || "(empty file)"
+        ].join("\n");
+        return {
+          content: [{ type: "text", text: fileInfo }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "write_file",
+    "Replace the entire content of an existing file (creates a new commit)",
+    {
+      book_token: z4.string().describe("Book token (e.g., bk_abc123)"),
+      path: z4.string().describe('File path (e.g., "characters/protagonist.md")'),
+      content: z4.string().describe("New content to write"),
+      commit_message: z4.string().optional().describe("Commit message (optional, auto-generated if not provided)")
+    },
+    async ({ book_token, path, content, commit_message }) => {
+      try {
+        const result = await client.updateFile(book_token, {
+          path,
+          content,
+          commitMessage: commit_message
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `File updated successfully.
+
+Commit: ${result.commit.token}
+Message: ${result.commit.name || result.commit.message}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "create_file",
+    "Create a new file in a book (creates a new commit)",
+    {
+      book_token: z4.string().describe("Book token (e.g., bk_abc123)"),
+      path: z4.string().describe('File path including parent folders (e.g., "characters/new-character.md")'),
+      content: z4.string().optional().describe("Initial content (optional, defaults to empty)"),
+      commit_message: z4.string().optional().describe("Commit message (optional, auto-generated if not provided)")
+    },
+    async ({ book_token, path, content, commit_message }) => {
+      try {
+        const result = await client.createFile(book_token, {
+          path,
+          content: content || "",
+          commitMessage: commit_message
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `File created successfully.
+
+File Token: ${result.fileToken}
+Commit: ${result.commit.token}
+Message: ${result.commit.name || result.commit.message}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "delete_file",
+    "Delete a file from a book (creates a new commit)",
+    {
+      book_token: z4.string().describe("Book token (e.g., bk_abc123)"),
+      path: z4.string().describe('File path to delete (e.g., "old-notes.md")'),
+      commit_message: z4.string().optional().describe("Commit message (optional, auto-generated if not provided)")
+    },
+    async ({ book_token, path, commit_message }) => {
+      try {
+        const result = await client.deleteFile(book_token, {
+          path,
+          commitMessage: commit_message
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `File deleted successfully.
+
+Commit: ${result.commit.token}
+Message: ${result.commit.name || result.commit.message}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "append_to_file",
+    "Append content to the end of an existing file (creates a new commit)",
+    {
+      book_token: z4.string().describe("Book token (e.g., bk_abc123)"),
+      path: z4.string().describe('File path (e.g., "notes.md")'),
+      content: z4.string().describe("Content to append"),
+      commit_message: z4.string().optional().describe("Commit message (optional, auto-generated if not provided)")
+    },
+    async ({ book_token, path, content, commit_message }) => {
+      try {
+        const result = await client.appendToFile(book_token, {
+          path,
+          content,
+          commitMessage: commit_message
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Content appended successfully.
+
+Commit: ${result.commit.token}
+Message: ${result.commit.name || result.commit.message}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "search_content",
+    "Search for content across all files in a book",
+    {
+      book_token: z4.string().describe("Book token (e.g., bk_abc123)"),
+      query: z4.string().describe('Search query (e.g., "blue eyes" or "protagonist name")'),
+      file_types: z4.array(z4.string()).optional().describe('Filter by file types (e.g., ["markdown", "txt"])'),
+      limit: z4.number().optional().describe("Maximum number of matches to return (default: 20)")
+    },
+    async ({ book_token, query, file_types, limit }) => {
+      try {
+        const result = await client.searchFiles(book_token, {
+          query,
+          fileTypes: file_types,
+          limit
+        });
+        if (result.matches.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No matches found for "${query}".`
+              }
+            ]
+          };
+        }
+        const output = [
+          `# Search Results for "${query}"`,
+          "",
+          `Found ${result.matches.length} file(s) with matches:`,
+          ""
+        ];
+        for (const match of result.matches) {
+          output.push(`## ${match.file.path}`);
+          output.push(`Words: ${match.file.wordCount} | Matches: ${match.matchCount}`);
+          output.push("");
+          for (const snippet of match.snippets) {
+            output.push(`> ${snippet.text}`);
+            output.push("");
+          }
+        }
+        return {
+          content: [{ type: "text", text: output.join("\n") }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatErrorForMcp(error) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/server.ts
+function createSlimaServer(config) {
+  const client = new SlimaApiClient({
+    token: config.apiToken,
+    baseUrl: config.baseUrl || "https://api.slima.ai"
+  });
+  const server = new McpServer({
+    name: "slima",
+    version: "0.1.0"
+  });
+  registerBookTools(server, client);
+  registerContentTools(server, client);
+  registerBetaReaderTools(server, client);
+  registerFileTools(server, client);
+  logger.info("Slima MCP Server initialized");
+  logger.info(`API endpoint: ${config.baseUrl || "https://api.slima.ai"}`);
+  return server;
+}
+
+// src/utils/token-storage.ts
+import { promises as fs } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var SLIMA_DIR = ".slima";
+var CREDENTIALS_FILE = "credentials.json";
+function getCredentialsPath() {
+  return join(homedir(), SLIMA_DIR, CREDENTIALS_FILE);
+}
+function getSlimaDir() {
+  return join(homedir(), SLIMA_DIR);
+}
+async function saveToken(apiToken, baseUrl) {
+  const slimaDir = getSlimaDir();
+  await fs.mkdir(slimaDir, { recursive: true });
+  const credentials = {
+    apiToken,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...baseUrl && { baseUrl }
+  };
+  const credentialsPath = getCredentialsPath();
+  await fs.writeFile(credentialsPath, JSON.stringify(credentials, null, 2), "utf-8");
+  await fs.chmod(credentialsPath, 384);
+}
+async function loadToken() {
+  try {
+    const credentialsPath = getCredentialsPath();
+    const content = await fs.readFile(credentialsPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function deleteToken() {
+  try {
+    const credentialsPath = getCredentialsPath();
+    await fs.unlink(credentialsPath);
+  } catch {
+  }
+}
+function getCredentialsFilePath() {
+  return getCredentialsPath();
+}
+
+// src/cli/auth.ts
+import { createServer } from "http";
+import { URL } from "url";
+import { randomBytes } from "crypto";
+var DEFAULT_API_URL = "https://api.slima.ai";
+var CALLBACK_PORT_START = 8765;
+var CALLBACK_PORT_END = 8775;
+async function openBrowser(url) {
+  const { exec } = await import("child_process");
+  const { promisify } = await import("util");
+  const execAsync = promisify(exec);
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      await execAsync(`open "${url}"`);
+    } else if (platform === "win32") {
+      await execAsync(`start "" "${url}"`);
+    } else {
+      const commands = ["xdg-open", "sensible-browser", "wslview"];
+      for (const cmd of commands) {
+        try {
+          await execAsync(`${cmd} "${url}"`);
+          return;
+        } catch {
+        }
+      }
+      console.log(`
+Please open this URL in your browser:
+${url}
+`);
+    }
+  } catch {
+    console.log(`
+Please open this URL in your browser:
+${url}
+`);
+  }
+}
+async function findAvailablePort() {
+  for (let port = CALLBACK_PORT_START; port <= CALLBACK_PORT_END; port++) {
+    const available = await isPortAvailable(port);
+    if (available) {
+      return port;
+    }
+  }
+  throw new Error(`No available ports between ${CALLBACK_PORT_START} and ${CALLBACK_PORT_END}`);
+}
+function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+function generateState() {
+  return randomBytes(16).toString("hex");
+}
+function getSuccessHtml() {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Slima MCP - Authenticated</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    }
+    .container {
+      text-align: center;
+      background: white;
+      padding: 60px;
+      border-radius: 16px;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+    }
+    .checkmark {
+      font-size: 64px;
+      margin-bottom: 20px;
+    }
+    h1 {
+      color: #333;
+      margin-bottom: 10px;
+    }
+    p {
+      color: #666;
+      font-size: 16px;
+    }
+    .hint {
+      margin-top: 20px;
+      color: #999;
+      font-size: 14px;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="checkmark">\u2705</div>
+    <h1>Authentication Successful!</h1>
+    <p>You can now close this window and return to your terminal.</p>
+    <p class="hint">Slima MCP is ready to use.</p>
+  </div>
+</body>
+</html>`;
+}
+function escapeHtml(text) {
+  const map = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#039;"
+  };
+  return text.replace(/[&<>"']/g, (char) => map[char]);
+}
+function getErrorHtml(message) {
+  const safeMessage = escapeHtml(message);
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Slima MCP - Error</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+    }
+    .container {
+      text-align: center;
+      background: white;
+      padding: 60px;
+      border-radius: 16px;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+    }
+    .error-icon {
+      font-size: 64px;
+      margin-bottom: 20px;
+    }
+    h1 {
+      color: #e74c3c;
+      margin-bottom: 10px;
+    }
+    p {
+      color: #666;
+      font-size: 16px;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="error-icon">\u274C</div>
+    <h1>Authentication Failed</h1>
+    <p>${safeMessage}</p>
+  </div>
+</body>
+</html>`;
+}
+async function runAuth(options = {}) {
+  const baseUrl = options.baseUrl || process.env.SLIMA_API_URL || DEFAULT_API_URL;
+  console.log("\n\u{1F510} Slima MCP Authentication\n");
+  const existingCredentials = await loadToken();
+  if (existingCredentials) {
+    console.log("You are already authenticated.");
+    console.log(`Token stored at: ${getCredentialsFilePath()}`);
+    console.log("\nTo re-authenticate, first run: slima-mcp logout\n");
+    return;
+  }
+  const state = generateState();
+  const port = await findAvailablePort();
+  console.log("Starting local server for authentication callback...");
+  const tokenPromise = new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      const url = new URL(req.url || "/", `http://localhost:${port}`);
+      if (url.pathname === "/callback") {
+        const token = url.searchParams.get("token");
+        const returnedState = url.searchParams.get("state");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(getErrorHtml(error));
+          server.close();
+          reject(new Error(error));
+          return;
+        }
+        if (returnedState !== state) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(getErrorHtml("Invalid state parameter. Please try again."));
+          server.close();
+          reject(new Error("State mismatch"));
+          return;
+        }
+        if (!token) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(getErrorHtml("No token received. Please try again."));
+          server.close();
+          reject(new Error("No token received"));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(getSuccessHtml());
+        server.close();
+        resolve(token);
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+      console.log(`Listening on http://127.0.0.1:${port}`);
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timed out. Please try again."));
+    }, 3e4);
+  });
+  const authUrl = `${baseUrl}/api/v1/auth/cli?state=${state}&callback_port=${port}`;
+  console.log("\nOpening browser for authentication...");
+  await openBrowser(authUrl);
+  console.log("\nWaiting for authentication...");
+  console.log("(Press Ctrl+C to cancel)\n");
+  try {
+    const token = await tokenPromise;
+    await saveToken(token, baseUrl !== DEFAULT_API_URL ? baseUrl : void 0);
+    console.log("\n\u2705 Authentication successful!");
+    console.log(`Token saved to: ${getCredentialsFilePath()}`);
+    console.log("\nYou can now use Slima MCP with any MCP-compatible AI tool.\n");
+  } catch (error) {
+    console.error("\n\u274C Authentication failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+async function runLogout() {
+  console.log("\n\u{1F513} Slima MCP Logout\n");
+  const credentials = await loadToken();
+  if (!credentials) {
+    console.log("You are not authenticated.\n");
+    return;
+  }
+  await deleteToken();
+  console.log("\u2705 Successfully logged out.");
+  console.log(`Removed credentials from: ${getCredentialsFilePath()}
+`);
+}
+async function runStatus() {
+  console.log("\n\u{1F4CA} Slima MCP Status\n");
+  const credentials = await loadToken();
+  if (!credentials) {
+    console.log("Status: Not authenticated");
+    console.log("\nRun `slima-mcp auth` to authenticate.\n");
+    return;
+  }
+  console.log("Status: Authenticated");
+  console.log(`Token: ${credentials.apiToken.substring(0, 15)}...`);
+  console.log(`Authenticated at: ${credentials.createdAt}`);
+  if (credentials.baseUrl) {
+    console.log(`API URL: ${credentials.baseUrl}`);
+  }
+  console.log(`Credentials file: ${getCredentialsFilePath()}
+`);
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+function showHelp() {
+  console.log(`
+Slima MCP v${VERSION}
+MCP Server for Slima - AI Writing IDE for Novel Authors
+
+USAGE:
+  slima-mcp [command]
+
+COMMANDS:
+  (none)    Start the MCP server
+  auth      Authenticate with Slima (opens browser)
+  logout    Remove saved credentials
+  status    Show authentication status
+  --help    Show this help message
+  --version Show version
+
+AUTHENTICATION:
+  1. Run: slima-mcp auth
+  2. Complete authentication in browser
+  3. Token is automatically saved
+
+  Or set SLIMA_API_TOKEN environment variable.
+
+EXAMPLES:
+  slima-mcp auth              # Authenticate with browser
+  slima-mcp status            # Check auth status
+  SLIMA_API_TOKEN=xxx slima-mcp   # Use env var
+
+CONFIGURATION (for AI tools):
+  Claude Desktop, Cursor, etc.:
+    {
+      "mcpServers": {
+        "slima": {
+          "command": "npx",
+          "args": ["-y", "slima-mcp"]
+        }
+      }
+    }
+
+MORE INFO:
+  https://github.com/slima-ai/slima-mcp
+`);
+}
+function showVersion() {
+  console.log(`slima-mcp v${VERSION}`);
+}
+async function startServer() {
+  let apiToken = process.env.SLIMA_API_TOKEN;
+  let baseUrl = process.env.SLIMA_API_URL;
+  if (!apiToken) {
+    const credentials = await loadToken();
+    if (credentials) {
+      apiToken = credentials.apiToken;
+      baseUrl = baseUrl || credentials.baseUrl;
+    }
+  }
+  if (!apiToken) {
+    logger.error("Not authenticated and SLIMA_API_TOKEN not set");
+    logger.error("");
+    logger.error("To authenticate, run:");
+    logger.error("  slima-mcp auth");
+    logger.error("");
+    logger.error("Or set environment variable:");
+    logger.error("  SLIMA_API_TOKEN=your_token slima-mcp");
+    logger.error("");
+    logger.error("Get your API token from: https://app.slima.ai/settings/api-tokens");
+    process.exit(1);
+  }
+  try {
+    const server = createSlimaServer({
+      apiToken,
+      baseUrl
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logger.info("Slima MCP Server running on stdio");
+    process.on("SIGINT", async () => {
+      logger.info("Shutting down...");
+      await server.close();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      logger.info("Shutting down...");
+      await server.close();
+      process.exit(0);
+    });
+  } catch (error) {
+    logger.error("Failed to start server", error);
+    process.exit(1);
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  switch (command) {
+    case "auth":
+      await runAuth();
+      break;
+    case "logout":
+      await runLogout();
+      break;
+    case "status":
+      await runStatus();
+      break;
+    case "--help":
+    case "-h":
+    case "help":
+      showHelp();
+      break;
+    case "--version":
+    case "-v":
+      showVersion();
+      break;
+    case void 0:
+      await startServer();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.error("Run `slima-mcp --help` for usage.");
+      process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=index.js.map