@mgamil/mapx 0.2.4

package/dist/languages/installer.js

@@ -0,0 +1,103 @@
+import { join, resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+import { existsSync, mkdirSync, writeFileSync, unlinkSync, copyFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+async function downloadFile(url, destPath) {
+  try {
+    execSync(`curl -L -s -f -o "${destPath}" "${url}"`, { stdio: "ignore" });
+    if (existsSync(destPath)) return;
+  } catch {
+  }
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Failed to download from ${url}: HTTP ${res.status}`);
+  }
+  const buf = await res.arrayBuffer();
+  writeFileSync(destPath, Buffer.from(buf));
+}
+const GRAMMARS_DIR = join(homedir(), ".mapx", "grammars");
+const QUERIES_DIR = join(GRAMMARS_DIR, "queries");
+const INSTALLABLE_LANGUAGES = {
+  ruby: { name: "ruby", package: "tree-sitter-ruby", file: "tree-sitter-ruby.wasm" },
+  c: { name: "c", package: "tree-sitter-c", file: "tree-sitter-c.wasm" },
+  cpp: { name: "cpp", package: "tree-sitter-cpp", file: "tree-sitter-cpp.wasm" },
+  swift: { name: "swift", package: "tree-sitter-swift", file: "tree-sitter-swift.wasm" },
+  kotlin: { name: "kotlin", package: "tree-sitter-kotlin", file: "tree-sitter-kotlin.wasm" },
+  svelte: { name: "svelte", package: "tree-sitter-svelte", file: "tree-sitter-svelte.wasm" },
+  vue: { name: "vue", package: "tree-sitter-vue", file: "tree-sitter-vue.wasm" },
+  lua: { name: "lua", package: "tree-sitter-lua", file: "tree-sitter-lua.wasm" },
+  elixir: { name: "elixir", package: "tree-sitter-elixir", file: "tree-sitter-elixir.wasm" },
+  zig: { name: "zig", package: "tree-sitter-zig", file: "tree-sitter-zig.wasm" },
+  bash: { name: "bash", package: "tree-sitter-bash", file: "tree-sitter-bash.wasm" },
+  pascal: { name: "pascal", package: "tree-sitter-pascal", file: "tree-sitter-pascal.wasm" },
+  dart: { name: "dart", package: "tree-sitter-dart", file: "tree-sitter-dart.wasm" },
+  scala: { name: "scala", package: "tree-sitter-scala", file: "tree-sitter-scala.wasm" }
+};
+function isLanguageInstalled(name) {
+  const builtins = ["php", "javascript", "typescript", "python", "go", "rust", "java", "c-sharp"];
+  if (builtins.includes(name)) return true;
+  const info = INSTALLABLE_LANGUAGES[name];
+  if (!info) return false;
+  const wasmPath = join(GRAMMARS_DIR, info.file);
+  const symPath = join(QUERIES_DIR, name, "symbols.scm");
+  const refPath = join(QUERIES_DIR, name, "references.scm");
+  return existsSync(wasmPath) && existsSync(symPath) && existsSync(refPath);
+}
+async function installLanguage(name) {
+  const info = INSTALLABLE_LANGUAGES[name];
+  if (!info) {
+    throw new Error(`Language '${name}' is not supported for installation. Supported: ${Object.keys(INSTALLABLE_LANGUAGES).join(", ")}`);
+  }
+  mkdirSync(join(QUERIES_DIR, name), { recursive: true });
+  const targetWasm = join(GRAMMARS_DIR, info.file);
+  const targetSym = join(QUERIES_DIR, name, "symbols.scm");
+  const targetRef = join(QUERIES_DIR, name, "references.scm");
+  const packageRoot = resolve(__dirname, "..", "..");
+  const localWasm = join(packageRoot, "wasm", info.file);
+  const localSym = join(packageRoot, "queries", name, "symbols.scm");
+  const localRef = join(packageRoot, "queries", name, "references.scm");
+  if (existsSync(localWasm)) {
+    copyFileSync(localWasm, targetWasm);
+  } else {
+    const wasmUrl = `https://unpkg.com/${info.package}@latest/${info.file}`;
+    console.log(`Downloading WASM from ${wasmUrl}...`);
+    await downloadFile(wasmUrl, targetWasm);
+  }
+  if (existsSync(localSym)) {
+    copyFileSync(localSym, targetSym);
+  } else {
+    const symUrl = `https://raw.githubusercontent.com/MohamedGamil/mapx/main/queries/${name}/symbols.scm`;
+    console.log(`Downloading symbols query from ${symUrl}...`);
+    await downloadFile(symUrl, targetSym);
+  }
+  if (existsSync(localRef)) {
+    copyFileSync(localRef, targetRef);
+  } else {
+    const refUrl = `https://raw.githubusercontent.com/MohamedGamil/mapx/main/queries/${name}/references.scm`;
+    console.log(`Downloading references query from ${refUrl}...`);
+    await downloadFile(refUrl, targetRef);
+  }
+}
+async function uninstallLanguage(name) {
+  const info = INSTALLABLE_LANGUAGES[name];
+  if (!info) {
+    throw new Error(`Language '${name}' is not supported for dynamic installation.`);
+  }
+  const targetWasm = join(GRAMMARS_DIR, info.file);
+  const targetSym = join(QUERIES_DIR, name, "symbols.scm");
+  const targetRef = join(QUERIES_DIR, name, "references.scm");
+  if (existsSync(targetWasm)) unlinkSync(targetWasm);
+  if (existsSync(targetSym)) unlinkSync(targetSym);
+  if (existsSync(targetRef)) unlinkSync(targetRef);
+}
+export {
+  GRAMMARS_DIR,
+  INSTALLABLE_LANGUAGES,
+  QUERIES_DIR,
+  installLanguage,
+  isLanguageInstalled,
+  uninstallLanguage
+};

package/dist/languages/registry.d.ts

@@ -0,0 +1,19 @@
+import { SymbolKind } from '../types.js';
+
+interface LanguageDefinition {
+    name: string;
+    extensions: string[];
+    grammarWasm: string;
+    queries: {
+        symbols: string;
+        references: string;
+    };
+    nodeMappings: Partial<Record<SymbolKind, string>>;
+    tier: 'built-in' | 'bundled' | 'installable' | 'user';
+}
+declare function getBuiltinLanguages(): Record<string, LanguageDefinition>;
+declare function getLanguageForFile(filePath: string, userLanguages?: Record<string, LanguageDefinition>): LanguageDefinition | null;
+declare function getLanguageNames(): string[];
+declare function isBuiltInLanguage(name: string): boolean;
+
+export { type LanguageDefinition, getBuiltinLanguages, getLanguageForFile, getLanguageNames, isBuiltInLanguage };

package/dist/languages/registry.js

@@ -0,0 +1,427 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+const BUILTIN_LANGUAGES = {
+  php: {
+    name: "php",
+    extensions: [".php", ".phtml", ".php3", ".php4", ".php5", ".php7"],
+    grammarWasm: "wasm/tree-sitter-php.wasm",
+    queries: {
+      symbols: "queries/php/symbols.scm",
+      references: "queries/php/references.scm"
+    },
+    nodeMappings: {
+      class: "class_declaration",
+      method: "method_declaration",
+      function: "function_definition",
+      interface: "interface_declaration",
+      trait: "trait_declaration",
+      constant: "const_declaration",
+      enum: "enum_declaration",
+      property: "property_declaration",
+      namespace: "namespace_definition"
+    },
+    tier: "built-in"
+  },
+  javascript: {
+    name: "javascript",
+    extensions: [".js", ".mjs", ".cjs"],
+    grammarWasm: "wasm/tree-sitter-javascript.wasm",
+    queries: {
+      symbols: "queries/javascript/symbols.scm",
+      references: "queries/javascript/references.scm"
+    },
+    nodeMappings: {
+      class: "class_declaration",
+      method: "method_definition",
+      function: "function_declaration",
+      interface: "interface_declaration",
+      constant: "variable_declarator",
+      enum: "enum_declaration",
+      property: "property_identifier",
+      namespace: "internal_module",
+      trait: ""
+    },
+    tier: "built-in"
+  },
+  typescript: {
+    name: "typescript",
+    extensions: [".ts", ".cts", ".mts"],
+    grammarWasm: "wasm/tree-sitter-typescript.wasm",
+    queries: {
+      symbols: "queries/typescript/symbols.scm",
+      references: "queries/typescript/references.scm"
+    },
+    nodeMappings: {
+      class: "class_declaration",
+      method: "method_definition",
+      function: "function_declaration",
+      interface: "interface_declaration",
+      constant: "variable_declarator",
+      enum: "enum_declaration",
+      property: "property_identifier",
+      namespace: "module",
+      trait: ""
+    },
+    tier: "built-in"
+  },
+  python: {
+    name: "python",
+    extensions: [".py"],
+    grammarWasm: "wasm/tree-sitter-python.wasm",
+    queries: {
+      symbols: "queries/python/symbols.scm",
+      references: "queries/python/references.scm"
+    },
+    nodeMappings: {
+      class: "class_definition",
+      function: "function_definition",
+      method: "function_definition",
+      constant: "expression_statement"
+    },
+    tier: "built-in"
+  },
+  go: {
+    name: "go",
+    extensions: [".go"],
+    grammarWasm: "wasm/tree-sitter-go.wasm",
+    queries: {
+      symbols: "queries/go/symbols.scm",
+      references: "queries/go/references.scm"
+    },
+    nodeMappings: {
+      struct: "type_spec",
+      interface: "type_spec",
+      function: "function_declaration",
+      method: "method_declaration",
+      constant: "const_spec",
+      namespace: "package_clause",
+      property: "var_spec"
+    },
+    tier: "built-in"
+  },
+  rust: {
+    name: "rust",
+    extensions: [".rs"],
+    grammarWasm: "wasm/tree-sitter-rust.wasm",
+    queries: {
+      symbols: "queries/rust/symbols.scm",
+      references: "queries/rust/references.scm"
+    },
+    nodeMappings: {
+      struct: "struct_item",
+      interface: "trait_item",
+      enum: "enum_item",
+      function: "function_item",
+      method: "function_item",
+      class: "impl_item",
+      constant: "const_item",
+      module: "mod_item"
+    },
+    tier: "built-in"
+  },
+  java: {
+    name: "java",
+    extensions: [".java"],
+    grammarWasm: "wasm/tree-sitter-java.wasm",
+    queries: {
+      symbols: "queries/java/symbols.scm",
+      references: "queries/java/references.scm"
+    },
+    nodeMappings: {
+      class: "class_declaration",
+      interface: "interface_declaration",
+      enum: "enum_declaration",
+      method: "method_declaration",
+      property: "field_declaration",
+      constant: "enum_constant",
+      namespace: "package_declaration"
+    },
+    tier: "built-in"
+  },
+  "c-sharp": {
+    name: "c-sharp",
+    extensions: [".cs"],
+    grammarWasm: "wasm/tree-sitter-c_sharp.wasm",
+    queries: {
+      symbols: "queries/c-sharp/symbols.scm",
+      references: "queries/c-sharp/references.scm"
+    },
+    nodeMappings: {
+      class: "class_declaration",
+      interface: "interface_declaration",
+      enum: "enum_declaration",
+      struct: "struct_declaration",
+      method: "method_declaration",
+      property: "property_declaration",
+      constant: "enum_member_declaration",
+      namespace: "namespace_declaration"
+    },
+    tier: "built-in"
+  },
+  ruby: {
+    name: "ruby",
+    extensions: [".rb"],
+    grammarWasm: "wasm/tree-sitter-ruby.wasm",
+    queries: {
+      symbols: "queries/ruby/symbols.scm",
+      references: "queries/ruby/references.scm"
+    },
+    nodeMappings: {
+      class: "class",
+      method: "method",
+      module: "module",
+      constant: "assignment",
+      property: "call"
+    },
+    tier: "bundled"
+  },
+  c: {
+    name: "c",
+    extensions: [".c", ".h"],
+    grammarWasm: "wasm/tree-sitter-c.wasm",
+    queries: {
+      symbols: "queries/c/symbols.scm",
+      references: "queries/c/references.scm"
+    },
+    nodeMappings: {
+      struct: "struct_specifier",
+      function: "function_definition",
+      enum: "enum_specifier",
+      constant: "preproc_def"
+    },
+    tier: "bundled"
+  },
+  cpp: {
+    name: "cpp",
+    extensions: [".cpp", ".hpp", ".cc", ".cxx", ".hh"],
+    grammarWasm: "wasm/tree-sitter-cpp.wasm",
+    queries: {
+      symbols: "queries/cpp/symbols.scm",
+      references: "queries/cpp/references.scm"
+    },
+    nodeMappings: {
+      class: "class_specifier",
+      struct: "struct_specifier",
+      function: "function_definition",
+      namespace: "namespace_definition",
+      enum: "enum_specifier",
+      constant: "alias_declaration"
+    },
+    tier: "bundled"
+  },
+  swift: {
+    name: "swift",
+    extensions: [".swift"],
+    grammarWasm: "wasm/tree-sitter-swift.wasm",
+    queries: {
+      symbols: "queries/swift/symbols.scm",
+      references: "queries/swift/references.scm"
+    },
+    nodeMappings: {
+      class: "class_declaration",
+      struct: "struct_declaration",
+      interface: "protocol_declaration",
+      enum: "enum_declaration",
+      method: "function_declaration",
+      function: "function_declaration",
+      property: "property_declaration",
+      constant: "typealias_declaration"
+    },
+    tier: "bundled"
+  },
+  kotlin: {
+    name: "kotlin",
+    extensions: [".kt", ".kts"],
+    grammarWasm: "wasm/tree-sitter-kotlin.wasm",
+    queries: {
+      symbols: "queries/kotlin/symbols.scm",
+      references: "queries/kotlin/references.scm"
+    },
+    nodeMappings: {
+      class: "class_declaration",
+      method: "function_declaration",
+      function: "function_declaration",
+      interface: "class_declaration",
+      property: "property_declaration",
+      constant: "enum_entry"
+    },
+    tier: "bundled"
+  },
+  svelte: {
+    name: "svelte",
+    extensions: [".svelte"],
+    grammarWasm: join(homedir(), ".mapx", "grammars", "tree-sitter-svelte.wasm"),
+    queries: {
+      symbols: join(homedir(), ".mapx", "grammars", "queries", "svelte", "symbols.scm"),
+      references: join(homedir(), ".mapx", "grammars", "queries", "svelte", "references.scm")
+    },
+    nodeMappings: {
+      function: "function_declaration",
+      class: "class_declaration",
+      method: "method_definition",
+      property: "export_statement",
+      constant: "lexical_declaration"
+    },
+    tier: "installable"
+  },
+  vue: {
+    name: "vue",
+    extensions: [".vue"],
+    grammarWasm: "wasm/tree-sitter-vue.wasm",
+    queries: {
+      symbols: "queries/vue/symbols.scm",
+      references: "queries/vue/references.scm"
+    },
+    nodeMappings: {
+      function: "function_declaration",
+      class: "class_declaration",
+      method: "method_definition",
+      property: "pair"
+    },
+    tier: "bundled"
+  },
+  lua: {
+    name: "lua",
+    extensions: [".lua"],
+    grammarWasm: join(homedir(), ".mapx", "grammars", "tree-sitter-lua.wasm"),
+    queries: {
+      symbols: join(homedir(), ".mapx", "grammars", "queries", "lua", "symbols.scm"),
+      references: join(homedir(), ".mapx", "grammars", "queries", "lua", "references.scm")
+    },
+    nodeMappings: {
+      function: "function_definition",
+      method: "function_definition",
+      constant: "variable_assignment"
+    },
+    tier: "installable"
+  },
+  elixir: {
+    name: "elixir",
+    extensions: [".ex", ".exs"],
+    grammarWasm: join(homedir(), ".mapx", "grammars", "tree-sitter-elixir.wasm"),
+    queries: {
+      symbols: join(homedir(), ".mapx", "grammars", "queries", "elixir", "symbols.scm"),
+      references: join(homedir(), ".mapx", "grammars", "queries", "elixir", "references.scm")
+    },
+    nodeMappings: {
+      module: "call",
+      function: "call",
+      struct: "call",
+      interface: "call",
+      constant: "unary_operator"
+    },
+    tier: "installable"
+  },
+  zig: {
+    name: "zig",
+    extensions: [".zig"],
+    grammarWasm: join(homedir(), ".mapx", "grammars", "tree-sitter-zig.wasm"),
+    queries: {
+      symbols: join(homedir(), ".mapx", "grammars", "queries", "zig", "symbols.scm"),
+      references: join(homedir(), ".mapx", "grammars", "queries", "zig", "references.scm")
+    },
+    nodeMappings: {
+      function: "fn_proto",
+      struct: "variable_declaration",
+      constant: "variable_declaration",
+      enum: "error_set_declaration"
+    },
+    tier: "installable"
+  },
+  bash: {
+    name: "bash",
+    extensions: [".sh", ".bash"],
+    grammarWasm: join(homedir(), ".mapx", "grammars", "tree-sitter-bash.wasm"),
+    queries: {
+      symbols: join(homedir(), ".mapx", "grammars", "queries", "bash", "symbols.scm"),
+      references: join(homedir(), ".mapx", "grammars", "queries", "bash", "references.scm")
+    },
+    nodeMappings: {
+      function: "function_definition",
+      constant: "variable_assignment"
+    },
+    tier: "installable"
+  },
+  pascal: {
+    name: "pascal",
+    extensions: [".pas", ".pp"],
+    grammarWasm: join(homedir(), ".mapx", "grammars", "tree-sitter-pascal.wasm"),
+    queries: {
+      symbols: join(homedir(), ".mapx", "grammars", "queries", "pascal", "symbols.scm"),
+      references: join(homedir(), ".mapx", "grammars", "queries", "pascal", "references.scm")
+    },
+    nodeMappings: {
+      function: "function_declaration",
+      class: "class_declaration",
+      struct: "record_declaration",
+      interface: "interface_declaration",
+      method: "method_declaration",
+      constant: "constant_declaration",
+      module: "unit_declaration",
+      property: "variable_declaration",
+      enum: "enum_type"
+    },
+    tier: "installable"
+  },
+  dart: {
+    name: "dart",
+    extensions: [".dart"],
+    grammarWasm: join(homedir(), ".mapx", "grammars", "tree-sitter-dart.wasm"),
+    queries: {
+      symbols: join(homedir(), ".mapx", "grammars", "queries", "dart", "symbols.scm"),
+      references: join(homedir(), ".mapx", "grammars", "queries", "dart", "references.scm")
+    },
+    nodeMappings: {
+      class: "class_definition",
+      method: "method_signature",
+      function: "function_signature",
+      enum: "enum_declaration",
+      trait: "mixin_declaration",
+      constant: "top_level_definition"
+    },
+    tier: "installable"
+  },
+  scala: {
+    name: "scala",
+    extensions: [".scala", ".sc"],
+    grammarWasm: "wasm/tree-sitter-scala.wasm",
+    queries: {
+      symbols: "queries/scala/symbols.scm",
+      references: "queries/scala/references.scm"
+    },
+    nodeMappings: {
+      class: "class_definition",
+      function: "function_definition",
+      interface: "trait_definition",
+      constant: "val_definition",
+      property: "var_definition",
+      namespace: "package_clause"
+    },
+    tier: "bundled"
+  }
+};
+function getBuiltinLanguages() {
+  return { ...BUILTIN_LANGUAGES };
+}
+function getLanguageForFile(filePath, userLanguages = {}) {
+  const ext = "." + filePath.split(".").pop()?.toLowerCase();
+  if (!ext) return null;
+  for (const lang of Object.values({ ...BUILTIN_LANGUAGES, ...userLanguages })) {
+    if (lang.extensions.includes(ext)) {
+      return lang;
+    }
+  }
+  return null;
+}
+function getLanguageNames() {
+  return Object.keys(BUILTIN_LANGUAGES);
+}
+function isBuiltInLanguage(name) {
+  return name in BUILTIN_LANGUAGES;
+}
+export {
+  getBuiltinLanguages,
+  getLanguageForFile,
+  getLanguageNames,
+  isBuiltInLanguage
+};

package/dist/main.d.ts

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

package/dist/main.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { buildCLI } from "./cli.js";
+const args = process.argv.slice(2);
+const isImplicitMcp = args.length === 0 && !process.stdin.isTTY;
+if (isImplicitMcp) {
+  import("./mcp.js").then((mod) => mod.startMcpServer()).catch((err) => {
+    console.error("Failed to start MCP server:", err);
+    process.exit(1);
+  });
+} else {
+  const program = buildCLI();
+  program.parseAsync(process.argv).catch((err) => {
+    if (err.message.includes("Another scan is already running")) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+    console.error(err);
+    process.exit(1);
+  });
+}

package/dist/mcp.d.ts

@@ -0,0 +1,11 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+
+interface ServeOptions {
+    sse?: boolean;
+    port?: number;
+    debug?: boolean;
+}
+declare function buildServer(options?: ServeOptions): Server;
+declare function startMcpServer(dir?: string, options?: ServeOptions): Promise<void>;
+
+export { buildServer, startMcpServer };