@rohal12/spindle-lsp 0.3.4 → 0.4.0

package/dist/bin.js

@@ -2087,6 +2087,7 @@ var init_link_parser = __esm({
 
 // src/plugins/diagnostics.ts
 function computeDiagnostics(uri, workspace) {
+  if (!workspace.initialized) return [];
   try {
     const text = workspace.documents.getText(uri);
     if (text === void 0) return [];
@@ -2109,15 +2110,13 @@ function computeDiagnostics(uri, workspace) {
       validateVariables(uri, workspace, diagnostics);
     } catch {
     }
-    if (workspace.initialized) {
-      try {
-        validateLinks(text, passages, passageNames, diagnostics);
-      } catch {
-      }
-      try {
-        validateWidgetInvocations(macros, workspace, diagnostics);
-      } catch {
-      }
+    try {
+      validateLinks(text, passages, passageNames, diagnostics);
+    } catch {
+    }
+    try {
+      validateWidgetInvocations(macros, workspace, diagnostics);
+    } catch {
     }
     return diagnostics;
   } catch {
@@ -2278,7 +2277,6 @@ function validateArguments(macros, workspace, passageNames, diagnostics) {
   }
 }
 function validateVariables(uri, workspace, diagnostics) {
-  if (!workspace.initialized) return;
   if (!workspace.variables.hasStoryVariables()) {
     const undeclared2 = workspace.variables.getUndeclared(uri);
     const text = workspace.documents.getText(uri);
@@ -2981,6 +2979,197 @@ var init_format2 = __esm({
   }
 });
 
+// src/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startMcpServer: () => startMcpServer
+});
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+import { pathToFileURL as pathToFileURL3, fileURLToPath as fileURLToPath3 } from "node:url";
+import { glob as glob3 } from "glob";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+function filterBySeverity2(diagnostics, minSeverity) {
+  const minIdx = SEVERITY_ORDER2.indexOf(minSeverity);
+  return diagnostics.filter((d) => {
+    const idx = SEVERITY_ORDER2.indexOf(d.severity);
+    return idx >= minIdx;
+  });
+}
+async function resolveFiles(pattern, cwd) {
+  const matches = await glob3(pattern, {
+    cwd,
+    absolute: true,
+    nodir: true
+  });
+  return [...new Set(matches)];
+}
+function findConfigRoot(files) {
+  const dirs = files.map((f) => resolve2(f, ".."));
+  let configRoot = dirs.reduce((a, b) => {
+    while (!b.startsWith(a)) a = resolve2(a, "..");
+    return a;
+  });
+  let search = configRoot;
+  for (let i = 0; i < 10; i++) {
+    if (findConfigFile(search)) {
+      configRoot = search;
+      break;
+    }
+    const parent = resolve2(search, "..");
+    if (parent === search) break;
+    search = parent;
+  }
+  return configRoot;
+}
+function createWorkspace(files) {
+  const configRoot = findConfigRoot(files);
+  const projectConfig = loadConfigFromDisk(configRoot);
+  const workspace = new WorkspaceModel();
+  const fileContents = /* @__PURE__ */ new Map();
+  for (const filePath of files) {
+    try {
+      const text = readFileSync6(filePath, "utf-8");
+      const uri = pathToFileURL3(filePath).toString();
+      fileContents.set(uri, text);
+    } catch {
+    }
+  }
+  workspace.initialize(fileContents);
+  if (Object.keys(projectConfig.macros).length > 0) {
+    workspace.macros.loadSupplements(projectConfig.macros);
+  }
+  return workspace;
+}
+async function startMcpServer() {
+  const server = new McpServer({
+    name: "spindle-lsp",
+    version: "0.3.5"
+  });
+  server.tool(
+    "spindle_check",
+    "Run diagnostics on .tw/.twee files. Returns structured diagnostic results.",
+    {
+      path: z.string().default("**/*.{tw,twee}").describe("Glob pattern or directory to check"),
+      severity: z.enum(["error", "warning", "info", "hint"]).optional().describe("Minimum severity to include")
+    },
+    async (args2) => {
+      const cwd = process.cwd();
+      const files = await resolveFiles(args2.path, cwd);
+      if (files.length === 0) {
+        return {
+          content: [{ type: "text", text: JSON.stringify([], null, 2) }]
+        };
+      }
+      const workspace = createWorkspace(files);
+      try {
+        const results = [];
+        for (const [uri] of workspace.documents.getUris().map((u) => [u])) {
+          let diags = computeDiagnostics(uri, workspace);
+          if (args2.severity) {
+            diags = filterBySeverity2(diags, args2.severity);
+          }
+          const filePath = fileURLToPath3(uri);
+          const relativePath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+          for (const d of diags) {
+            results.push({
+              file: relativePath,
+              line: d.range.start.line + 1,
+              column: d.range.start.character + 1,
+              severity: d.severity,
+              code: d.code,
+              message: d.message
+            });
+          }
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+        };
+      } finally {
+        workspace.dispose();
+      }
+    }
+  );
+  server.tool(
+    "spindle_format",
+    "Format .tw/.twee files in place.",
+    {
+      path: z.string().default("**/*.{tw,twee}").describe("Glob pattern or directory to format")
+    },
+    async (args2) => {
+      const cwd = process.cwd();
+      const files = await resolveFiles(args2.path, cwd);
+      let formatted = 0;
+      let unchanged = 0;
+      const changedFiles = [];
+      for (const filePath of files) {
+        try {
+          const text = readFileSync6(filePath, "utf-8");
+          const result = formatDocument(text);
+          if (result !== text) {
+            writeFileSync2(filePath, result, "utf-8");
+            formatted++;
+            const relativePath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+            changedFiles.push(relativePath);
+          } else {
+            unchanged++;
+          }
+        } catch {
+        }
+      }
+      const output = { formatted, unchanged, files: changedFiles };
+      return {
+        content: [{ type: "text", text: JSON.stringify(output, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "spindle_format_check",
+    "Check formatting without modifying files. Returns list of files that need formatting.",
+    {
+      path: z.string().default("**/*.{tw,twee}").describe("Glob pattern or directory to check")
+    },
+    async (args2) => {
+      const cwd = process.cwd();
+      const files = await resolveFiles(args2.path, cwd);
+      const needsFormatting = [];
+      const alreadyFormatted = [];
+      for (const filePath of files) {
+        try {
+          const text = readFileSync6(filePath, "utf-8");
+          const result = formatDocument(text);
+          const relativePath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+          if (result !== text) {
+            needsFormatting.push(relativePath);
+          } else {
+            alreadyFormatted.push(relativePath);
+          }
+        } catch {
+        }
+      }
+      const output = { needsFormatting, alreadyFormatted };
+      return {
+        content: [{ type: "text", text: JSON.stringify(output, null, 2) }]
+      };
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var SEVERITY_ORDER2;
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_workspace_model();
+    init_config_loader();
+    init_diagnostics();
+    init_format();
+    SEVERITY_ORDER2 = ["hint", "info", "warning", "error"];
+  }
+});
+
 // src/core/plugin/plugin-loader.ts
 function loadPlugins(allPlugins2, config) {
   const disabled = new Set(config.disabledPlugins ?? []);
@@ -4835,8 +5024,8 @@ var init_plugins = __esm({
 });
 
 // src/server/server.ts
-var server_exports = {};
-__export(server_exports, {
+var server_exports2 = {};
+__export(server_exports2, {
   startServer: () => startServer
 });
 import {
@@ -4846,18 +5035,18 @@ import {
   FileChangeType
 } from "vscode-languageserver/node.js";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "node:url";
-import { readFileSync as readFileSync6 } from "node:fs";
-import { glob as glob3 } from "glob";
+import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL4 } from "node:url";
+import { readFileSync as readFileSync7 } from "node:fs";
+import { glob as glob4 } from "glob";
 function uriToFsPath(uri) {
   try {
-    return fileURLToPath3(uri);
+    return fileURLToPath4(uri);
   } catch {
     return uri;
   }
 }
 function fsPathToUri(fsPath) {
-  return pathToFileURL3(fsPath).toString();
+  return pathToFileURL4(fsPath).toString();
 }
 function startServer(_args) {
   const connection = createConnection(ProposedFeatures.all);
@@ -4956,7 +5145,7 @@ function startServer(_args) {
       } else {
         try {
           const fsPath = uriToFsPath(change.uri);
-          const text = readFileSync6(fsPath, "utf-8");
+          const text = readFileSync7(fsPath, "utf-8");
           if (workspace.documents.has(change.uri)) {
             workspace.documents.update(change.uri, text);
           } else {
@@ -4979,14 +5168,14 @@ async function scanWorkspaceFiles(root) {
   const contents = /* @__PURE__ */ new Map();
   if (!root) return contents;
   try {
-    const files = await glob3("**/*.{tw,twee}", {
+    const files = await glob4("**/*.{tw,twee}", {
       cwd: root,
       absolute: true,
       nodir: true
     });
     for (const filePath of files) {
       try {
-        const text = readFileSync6(filePath, "utf-8");
+        const text = readFileSync7(filePath, "utf-8");
         const uri = fsPathToUri(filePath);
         contents.set(uri, text);
       } catch {
@@ -4996,7 +5185,7 @@ async function scanWorkspaceFiles(root) {
   }
   return contents;
 }
-var init_server = __esm({
+var init_server2 = __esm({
   "src/server/server.ts"() {
     "use strict";
     init_workspace_model();
@@ -5017,8 +5206,11 @@ if (args[0] === "check") {
   const { runFormat: runFormat2 } = await Promise.resolve().then(() => (init_format2(), format_exports));
   const exitCode = await runFormat2(args.slice(1));
   process.exit(exitCode);
+} else if (args[0] === "mcp") {
+  const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  await startMcpServer2();
 } else {
-  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
   startServer2(args);
 }
 //# sourceMappingURL=bin.js.map