@rohal12/spindle-lsp 0.3.5 → 0.5.0

package/dist/bin.js

@@ -1011,6 +1011,12 @@ var init_macro_supplements = __esm({
         name: "unwatch",
         description: "Stops watching a variable.\n\nUsage: `{unwatch $var}`",
         parameters: ["...text"]
+      },
+      unless: {
+        name: "unless",
+        container: true,
+        description: "Conditionally displays its contents when the expression is falsy. The inverse of `{if}`.\n\nUsage:\n\n```\n{unless condition}\n  ...\n{/unless}\n```",
+        parameters: ["...text"]
       }
     };
   }
@@ -2787,51 +2793,369 @@ var init_check = __esm({
   }
 });
 
-// src/plugins/format.ts
-function formatDocument(text) {
+// src/plugins/format/segment.ts
+function splitPassages(text) {
   const lines = text.split("\n");
-  const result = [];
-  let indentLevel = 0;
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  const passages = [];
+  let currentHeader = "";
+  let bodyLines = [];
+  let startLine = 0;
+  function pushPassage() {
+    if (currentHeader || bodyLines.length > 0) {
+      while (bodyLines.length > 0 && bodyLines[bodyLines.length - 1].trim() === "") {
+        bodyLines.pop();
+      }
+      passages.push({
+        header: currentHeader,
+        body: bodyLines.join("\n") + (bodyLines.length > 0 ? "\n" : ""),
+        startLine
+      });
+    }
+  }
   for (let i = 0; i < lines.length; i++) {
-    let line = lines[i];
-    line = line.replace(/\s+$/, "");
-    if (PASSAGE_HEADER_REGEX.test(line)) {
-      line = normalizePassageHeader(line);
-      indentLevel = 0;
-      result.push(line);
+    if (PASSAGE_HEADER_REGEX.test(lines[i])) {
+      pushPassage();
+      currentHeader = lines[i];
+      bodyLines = [];
+      startLine = i;
+    } else {
+      bodyLines.push(lines[i]);
+    }
+  }
+  pushPassage();
+  return passages;
+}
+function classifyPassage(header) {
+  const tagMatch = header.match(/\[([^\]]*)\]/g);
+  if (!tagMatch) return "normal";
+  const tags = tagMatch.map((t) => t.slice(1, -1).trim().toLowerCase());
+  if (tags.includes("script")) return "script";
+  if (tags.includes("stylesheet")) return "stylesheet";
+  return "normal";
+}
+function segmentRegions(body) {
+  const lines = body.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  if (lines.length === 0) return [];
+  const regions = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (/^<script(\s|>)/i.test(trimmed)) {
+      const scriptLines = [line];
+      i++;
+      while (i < lines.length && !/<\/script>/i.test(lines[i])) {
+        scriptLines.push(lines[i]);
+        i++;
+      }
+      if (i < lines.length) {
+        scriptLines.push(lines[i]);
+        i++;
+      }
+      regions.push({ type: "script", lines: scriptLines });
+      continue;
+    }
+    if (/^<([a-zA-Z][\w-]*)/.test(trimmed)) {
+      const tagMatch = trimmed.match(/^<([a-zA-Z][\w-]*)/);
+      const tagName = tagMatch[1].toLowerCase();
+      if (VOID_ELEMENTS.has(tagName) && !lines[i + 1]?.trim().startsWith("<")) {
+        pushSpindleLine(regions, line);
+        i++;
+        continue;
+      }
+      const selfClosing = new RegExp(`</${tagName}\\s*>`, "i");
+      if (selfClosing.test(trimmed)) {
+        pushSpindleLine(regions, line);
+        i++;
+        continue;
+      }
+      const htmlLines = [line];
+      let depth = 1;
+      i++;
+      while (i < lines.length && depth > 0) {
+        htmlLines.push(lines[i]);
+        const opens = (lines[i].match(new RegExp(`<${tagName}[\\s>]`, "gi")) ?? []).length;
+        const closes = (lines[i].match(new RegExp(`</${tagName}\\s*>`, "gi")) ?? []).length;
+        depth += opens - closes;
+        i++;
+      }
+      regions.push({ type: "html", lines: htmlLines });
       continue;
     }
+    pushSpindleLine(regions, line);
+    i++;
+  }
+  return regions;
+}
+function pushSpindleLine(regions, line) {
+  const last = regions[regions.length - 1];
+  if (last?.type === "spindle") {
+    last.lines.push(line);
+  } else {
+    regions.push({ type: "spindle", lines: [line] });
+  }
+}
+var PASSAGE_HEADER_REGEX, VOID_ELEMENTS;
+var init_segment = __esm({
+  "src/plugins/format/segment.ts"() {
+    "use strict";
+    PASSAGE_HEADER_REGEX = /^::\s+/;
+    VOID_ELEMENTS = /* @__PURE__ */ new Set([
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "param",
+      "source",
+      "track",
+      "wbr"
+    ]);
+  }
+});
+
+// src/plugins/format/prettier-bridge.ts
+async function loadPrettier() {
+  if (prettierLoaded) return prettier;
+  prettierLoaded = true;
+  try {
+    prettier = await import("prettier");
+  } catch {
+    prettier = null;
+  }
+  return prettier;
+}
+async function getBaseConfig() {
+  const p = await loadPrettier();
+  if (!p) return {};
+  try {
+    const resolved = await p.resolveConfig(process.cwd());
+    return { tabWidth: 2, ...resolved ?? {} };
+  } catch {
+    return { tabWidth: 2 };
+  }
+}
+async function formatJS(code) {
+  const p = await loadPrettier();
+  if (!p) return code;
+  try {
+    const config = await getBaseConfig();
+    return await p.format(code, { ...config, parser: "babel" });
+  } catch {
+    return code;
+  }
+}
+async function formatCSS(code) {
+  const p = await loadPrettier();
+  if (!p) return code;
+  try {
+    const config = await getBaseConfig();
+    return await p.format(code, { ...config, parser: "css" });
+  } catch {
+    return code;
+  }
+}
+async function formatHTML(code) {
+  const p = await loadPrettier();
+  if (!p) return code;
+  try {
+    const config = await getBaseConfig();
+    return await p.format(code, {
+      ...config,
+      parser: "html",
+      htmlWhitespaceSensitivity: "ignore"
+    });
+  } catch {
+    return code;
+  }
+}
+var prettier, prettierLoaded;
+var init_prettier_bridge = __esm({
+  "src/plugins/format/prettier-bridge.ts"() {
+    "use strict";
+    prettier = null;
+    prettierLoaded = false;
+  }
+});
+
+// src/plugins/format/placeholders.ts
+function isInsideAttribute(text, pos) {
+  let inQuote = false;
+  let quoteChar = "";
+  for (let i = 0; i < pos; i++) {
+    const ch = text[i];
+    if (!inQuote && (ch === '"' || ch === "'") && i > 0 && text[i - 1] === "=") {
+      inQuote = true;
+      quoteChar = ch;
+    } else if (inQuote && ch === quoteChar) {
+      inQuote = false;
+    }
+  }
+  return inQuote;
+}
+function replaceSpindleTokens(html) {
+  const tokens = [];
+  const text = html.replace(SPINDLE_TOKEN_REGEX, (match, ...args2) => {
+    const offset = args2[args2.length - 2];
+    const idx = tokens.length;
+    tokens.push(match);
+    if (isInsideAttribute(html, offset)) {
+      return `__SP${idx}__`;
+    }
+    return `<!--SP:${idx}-->`;
+  });
+  return { text, tokens };
+}
+function restoreSpindleTokens(text, tokens) {
+  let result = text;
+  for (let i = 0; i < tokens.length; i++) {
+    result = result.replace(`<!--SP:${i}-->`, tokens[i]);
+    result = result.replace(`__SP${i}__`, tokens[i]);
+  }
+  return result;
+}
+var SPINDLE_TOKEN_REGEX;
+var init_placeholders = __esm({
+  "src/plugins/format/placeholders.ts"() {
+    "use strict";
+    SPINDLE_TOKEN_REGEX = /(?:\{\/[A-Za-z][\w-]*\s*\}|\{(?:[#.][a-zA-Z][\w-]*\s*)*[A-Za-z][\w-]*(?:\s+(?:[^}]|\}(?=[^}]))*?)?\}|\{[$_@][a-zA-Z][\w.]*\}|\[\[(?:[^\]]*)\]\])/g;
+  }
+});
+
+// src/plugins/format.ts
+function getSupplementContainers() {
+  const containers = /* @__PURE__ */ new Set();
+  for (const [key, entry] of Object.entries(macro_supplements_default)) {
+    if (entry.container) {
+      containers.add(key.toLowerCase());
+    }
+  }
+  return containers;
+}
+function detectContainersFromText(text) {
+  const found = /* @__PURE__ */ new Set();
+  const re = /\{\/([A-Za-z][\w-]*)\s*\}/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    found.add(m[1].toLowerCase());
+  }
+  return found;
+}
+function buildDefaultIsBlock(text) {
+  const containers = getSupplementContainers();
+  for (const name of detectContainersFromText(text)) {
+    containers.add(name);
+  }
+  return (name) => containers.has(name.toLowerCase());
+}
+async function formatDocument(text, options) {
+  const isBlock = options?.isBlock ?? buildDefaultIsBlock(text);
+  const isDedenting = options?.isDedentingSubMacro ?? ((name) => DEFAULT_DEDENTING.has(name.toLowerCase()));
+  const passages = splitPassages(text);
+  const resultLines = [];
+  for (let pi = 0; pi < passages.length; pi++) {
+    const passage = passages[pi];
+    if (pi > 0 && passage.header) {
+      const prev = passages[pi - 1];
+      const prevBodyLineCount = prev.body ? prev.body.split("\n").length - 1 : 0;
+      const prevEndLine = prev.startLine + (prev.header ? 1 : 0) + prevBodyLineCount;
+      if (passage.startLine > prevEndLine) {
+        resultLines.push("");
+      }
+    }
+    if (passage.header) {
+      const header = PASSAGE_HEADER_REGEX2.test(passage.header) ? normalizePassageHeader(passage.header) : passage.header;
+      resultLines.push(header);
+    }
+    const kind = classifyPassage(passage.header);
+    if (kind === "script") {
+      const formatted = await formatJS(passage.body.trim());
+      resultLines.push(formatted.trim());
+      continue;
+    }
+    if (kind === "stylesheet") {
+      const formatted = await formatCSS(passage.body.trim());
+      resultLines.push(formatted.trim());
+      continue;
+    }
+    const regions = segmentRegions(passage.body);
+    for (const region of regions) {
+      if (region.type === "script") {
+        const firstLine = region.lines[0];
+        const lastLine = region.lines[region.lines.length - 1];
+        const innerLines = region.lines.slice(1, region.lines.length - 1);
+        const innerCode = innerLines.join("\n");
+        const formatted = await formatJS(innerCode.trim());
+        resultLines.push(firstLine);
+        if (formatted.trim()) {
+          for (const fLine of formatted.trim().split("\n")) {
+            resultLines.push("  " + fLine);
+          }
+        }
+        resultLines.push(lastLine);
+        continue;
+      }
+      if (region.type === "html") {
+        const htmlText = region.lines.join("\n");
+        const { text: placeholdered, tokens } = replaceSpindleTokens(htmlText);
+        const formatted = await formatHTML(placeholdered);
+        const restored = restoreSpindleTokens(formatted.trim(), tokens);
+        for (const fLine of restored.split("\n")) {
+          resultLines.push(fLine);
+        }
+        continue;
+      }
+      const indented = indentMacros(region.lines, isBlock, isDedenting);
+      resultLines.push(...indented);
+    }
+  }
+  let output = resultLines.map((l) => l.replace(/\s+$/, "")).join("\n");
+  output = output.replace(/\n*$/, "\n");
+  return output;
+}
+function indentMacros(lines, isBlock, isDedenting) {
+  const result = [];
+  let indentLevel = 0;
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\s+$/, "");
     const trimmed = line.trim();
     if (trimmed === "") {
       result.push("");
       continue;
     }
-    if (BLOCK_CLOSE_REGEX.test(trimmed)) {
+    const dedentMatch = trimmed.match(MACRO_OPEN_REGEX);
+    if (dedentMatch && isDedenting(dedentMatch[1])) {
+      indentLevel = Math.max(0, indentLevel - 1);
+      result.push(indentLevel > 0 ? "  ".repeat(indentLevel) + trimmed : trimmed);
+      indentLevel++;
+      continue;
+    }
+    const closeMatch = trimmed.match(MACRO_CLOSE_REGEX);
+    if (closeMatch) {
       indentLevel = Math.max(0, indentLevel - 1);
     }
-    const indented = indentLevel > 0 ? "  ".repeat(indentLevel) + trimmed : trimmed;
-    result.push(indented);
-    if (BLOCK_OPEN_REGEX.test(trimmed)) {
+    result.push(indentLevel > 0 ? "  ".repeat(indentLevel) + trimmed : trimmed);
+    const openMatch = trimmed.match(MACRO_OPEN_REGEX);
+    if (openMatch && isBlock(openMatch[1])) {
       indentLevel++;
     }
   }
-  let output = result.join("\n");
-  output = output.replace(/\n*$/, "\n");
-  return output;
-}
-function formatRange(text, range) {
-  const lines = text.split("\n");
-  const startLine = Math.max(0, range.start.line);
-  const endLine = Math.min(lines.length - 1, range.end.line);
-  const rangeLines = lines.slice(startLine, endLine + 1);
-  const rangeText = rangeLines.join("\n");
-  const formatted = formatDocument(rangeText);
-  const formattedLines = formatted.replace(/\n$/, "").split("\n");
-  const before = lines.slice(0, startLine);
-  const after = lines.slice(endLine + 1);
-  const result = [...before, ...formattedLines, ...after].join("\n");
   return result;
 }
+async function formatRange(text, _range, options) {
+  return formatDocument(text, options);
+}
 function normalizePassageHeader(line) {
   const headerMatch = line.match(/^::\s+(.*)/);
   if (!headerMatch) return line;
@@ -2851,13 +3175,18 @@ function normalizePassageHeader(line) {
   }
   return `:: ${name}${suffix}`;
 }
-var BLOCK_OPEN_REGEX, BLOCK_CLOSE_REGEX, PASSAGE_HEADER_REGEX, formatPlugin;
+var PASSAGE_HEADER_REGEX2, MACRO_OPEN_REGEX, MACRO_CLOSE_REGEX, DEFAULT_DEDENTING, formatPlugin;
 var init_format = __esm({
   "src/plugins/format.ts"() {
     "use strict";
-    BLOCK_OPEN_REGEX = /^\s*\{(if|for|switch|unless|widget)\b/i;
-    BLOCK_CLOSE_REGEX = /^\s*\{\/(if|for|switch|unless|widget)\b/i;
-    PASSAGE_HEADER_REGEX = /^(::)\s+/;
+    init_macro_supplements();
+    init_segment();
+    init_prettier_bridge();
+    init_placeholders();
+    PASSAGE_HEADER_REGEX2 = /^(::)\s+/;
+    MACRO_OPEN_REGEX = /^\{(?:[#.][a-zA-Z][\w-]*\s*)*([A-Za-z][\w-]*)\b/;
+    MACRO_CLOSE_REGEX = /^\{\/([A-Za-z][\w-]*)\b/;
+    DEFAULT_DEDENTING = /* @__PURE__ */ new Set(["else", "elseif", "next", "case", "default"]);
     formatPlugin = {
       id: "format",
       capabilities: {
@@ -2865,10 +3194,14 @@ var init_format = __esm({
         documentRangeFormattingProvider: true
       },
       initialize(ctx) {
-        ctx.connection.onDocumentFormatting((params) => {
+        const formatOpts = {
+          isBlock: (name) => ctx.workspace.macros.isBlock(name),
+          isDedentingSubMacro: (name) => DEFAULT_DEDENTING.has(name.toLowerCase())
+        };
+        ctx.connection.onDocumentFormatting(async (params) => {
           const text = ctx.workspace.documents.getText(params.textDocument.uri);
           if (text === void 0) return [];
-          const formatted = formatDocument(text);
+          const formatted = await formatDocument(text, formatOpts);
           if (formatted === text) return [];
           const lines = text.split("\n");
           return [{
@@ -2879,14 +3212,14 @@ var init_format = __esm({
             newText: formatted
           }];
         });
-        ctx.connection.onDocumentRangeFormatting((params) => {
+        ctx.connection.onDocumentRangeFormatting(async (params) => {
           const text = ctx.workspace.documents.getText(params.textDocument.uri);
           if (text === void 0) return [];
           const range = {
             start: { line: params.range.start.line, character: params.range.start.character },
             end: { line: params.range.end.line, character: params.range.end.character }
           };
-          const formatted = formatRange(text, range);
+          const formatted = await formatRange(text, range, formatOpts);
           if (formatted === text) return [];
           const lines = text.split("\n");
           return [{
@@ -2947,7 +3280,7 @@ async function runFormat(args2) {
   for (const filePath of uniqueFiles) {
     try {
       const text = readFileSync5(filePath, "utf-8");
-      const formatted = formatDocument(text);
+      const formatted = await formatDocument(text);
       if (formatted !== text) {
         if (options.check) {
           const relative = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
@@ -2979,6 +3312,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 = await 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 = await 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 ?? []);
@@ -4833,8 +5357,8 @@ var init_plugins = __esm({
 });
 
 // src/server/server.ts
-var server_exports = {};
-__export(server_exports, {
+var server_exports2 = {};
+__export(server_exports2, {
   startServer: () => startServer
 });
 import {
@@ -4844,18 +5368,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);
@@ -4954,7 +5478,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 {
@@ -4977,14 +5501,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 {
@@ -4994,7 +5518,7 @@ async function scanWorkspaceFiles(root) {
   }
   return contents;
 }
-var init_server = __esm({
+var init_server2 = __esm({
   "src/server/server.ts"() {
     "use strict";
     init_workspace_model();
@@ -5015,8 +5539,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