@mgamil/mapx 0.2.4

package/dist/parsers/languages/vue.js

@@ -0,0 +1,63 @@
+import { TypeScriptParser } from "./typescript.js";
+import { getBuiltinLanguages } from "../../languages/registry.js";
+class VueParser {
+  languageName = "vue";
+  supportedExtensions = [".vue"];
+  tsParser;
+  constructor(langDef) {
+    const builtin = getBuiltinLanguages();
+    this.tsParser = new TypeScriptParser(builtin.typescript);
+  }
+  async parse(filePath, source, options) {
+    const symbols = [];
+    const references = [];
+    const errors = [];
+    const scriptRegex = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+    let match;
+    while ((match = scriptRegex.exec(source)) !== null) {
+      const code = match[2];
+      const matchIndex = match.index;
+      const openingTagMatch = source.slice(matchIndex).match(/<script\b[^>]*>/i);
+      const openingTagLength = openingTagMatch ? openingTagMatch[0].length : 0;
+      const beforeCode = source.slice(0, matchIndex + openingTagLength);
+      const startLine = beforeCode.split("\n").length;
+      try {
+        const res = await this.tsParser.parse(filePath, code, options);
+        if (res.symbols) {
+          for (const sym of res.symbols) {
+            symbols.push({
+              ...sym,
+              startLine: sym.startLine + startLine - 1,
+              endLine: sym.endLine + startLine - 1
+            });
+          }
+        }
+        if (res.references) {
+          for (const ref of res.references) {
+            references.push({
+              ...ref,
+              startLine: ref.startLine + startLine - 1
+            });
+          }
+        }
+        if (res.errors) {
+          for (const err of res.errors) {
+            errors.push({
+              ...err,
+              line: err.line ? err.line + startLine - 1 : startLine
+            });
+          }
+        }
+      } catch (err) {
+        errors.push({
+          message: `Failed to parse Vue script block starting at line ${startLine}: ${err.message}`,
+          line: startLine
+        });
+      }
+    }
+    return { symbols, references, errors };
+  }
+}
+export {
+  VueParser
+};

package/dist/parsers/parse-worker.d.ts

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

package/dist/parsers/parse-worker.js

@@ -0,0 +1,185 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const REF_TYPE_MAP = {
+  import: "import",
+  require: "require",
+  extends: "extends",
+  implements: "implements",
+  call: "call",
+  instantiation: "instantiation"
+};
+let parserReady = false;
+let Parser;
+let Language;
+let Query;
+let loadedLanguages = /* @__PURE__ */ new Map();
+let langDefs;
+let assetRoot;
+let nameByNodeId;
+function findAssetRoot() {
+  const thisFile = fileURLToPath(import.meta.url);
+  if (existsSync(thisFile)) {
+    return resolve(dirname(thisFile), "..", "..");
+  }
+  const binDir = dirname(process.execPath);
+  const candidates = [
+    binDir,
+    resolve(binDir, "..", "share", "mapx"),
+    join(process.env["HOME"] ?? "", ".local", "share", "mapx")
+  ];
+  for (const dir of candidates) {
+    if (existsSync(join(dir, "wasm"))) return dir;
+  }
+  return binDir;
+}
+async function initParser() {
+  if (parserReady) return;
+  assetRoot = findAssetRoot();
+  const mod = await import("web-tree-sitter");
+  Parser = mod.Parser;
+  Language = mod.Language;
+  Query = mod.Query;
+  await Parser.init();
+  parserReady = true;
+}
+async function parseFile(job) {
+  const empty = { id: job.id, symbols: [], references: [], errors: [] };
+  let source;
+  try {
+    source = await readFile(job.absolutePath, "utf-8");
+  } catch {
+    return { ...empty, errors: [{ message: `Failed to read ${job.filePath}` }] };
+  }
+  const ext = job.filePath.substring(job.filePath.lastIndexOf("."));
+  let langKey = "";
+  for (const [key, def] of langDefs) {
+    if (def.extensions.includes(ext)) {
+      langKey = key;
+      break;
+    }
+  }
+  if (!langKey) return empty;
+  let langCtx = loadedLanguages.get(langKey);
+  if (!langCtx) {
+    try {
+      const def = langDefs.get(langKey);
+      const wasmPath = resolve(assetRoot, def.grammarWasm);
+      const wasmBuffer = await readFile(wasmPath);
+      const language = await Language.load(wasmBuffer);
+      const symbolsQuery = await readFile(resolve(assetRoot, def.queries.symbols), "utf-8");
+      const referencesQuery = await readFile(resolve(assetRoot, def.queries.references), "utf-8");
+      const parser = new Parser();
+      parser.setLanguage(language);
+      const compiledSymQuery = new Query(language, symbolsQuery);
+      const compiledRefQuery = new Query(language, referencesQuery);
+      langCtx = { language, symbolsQuery, referencesQuery, parser, compiledSymQuery, compiledRefQuery };
+      loadedLanguages.set(langKey, langCtx);
+    } catch {
+      return { ...empty, errors: [{ message: `Failed to load language for ${job.filePath}` }] };
+    }
+  }
+  try {
+    const tree = langCtx.parser.parse(source);
+    if (!tree) {
+      return { ...empty, errors: [{ message: `Parser returned null for ${job.filePath}` }] };
+    }
+    const symbols = [];
+    const references = [];
+    nameByNodeId = /* @__PURE__ */ new Map();
+    try {
+      const symQuery = langCtx.compiledSymQuery;
+      const allSymCaptures = symQuery.captures(tree.rootNode);
+      const kindNodeIds = /* @__PURE__ */ new Set();
+      for (const capture of allSymCaptures) {
+        if (capture.name.startsWith("symbol.kind_")) {
+          kindNodeIds.add(capture.node.id);
+        }
+      }
+      for (const capture of allSymCaptures) {
+        if (capture.name === "symbol.name") {
+          let node = capture.node.parent;
+          while (node) {
+            if (kindNodeIds.has(node.id)) {
+              nameByNodeId.set(node.id, capture.node.text);
+              break;
+            }
+            node = node.parent;
+          }
+        }
+      }
+      for (const capture of allSymCaptures) {
+        if (capture.name.startsWith("symbol.kind_")) {
+          const kind = capture.name.replace("symbol.kind_", "");
+          const name = nameByNodeId.get(capture.node.id) || capture.node.text;
+          symbols.push({
+            name,
+            kind,
+            scope: null,
+            signature: name,
+            startLine: capture.node.startPosition.row + 1,
+            endLine: capture.node.endPosition.row + 1,
+            metadata: {}
+          });
+        }
+      }
+    } catch {
+    }
+    try {
+      const refQuery = langCtx.compiledRefQuery;
+      for (const capture of refQuery.captures(tree.rootNode)) {
+        const startLine = capture.node.startPosition.row + 1;
+        if (capture.name.startsWith("ref.target_")) {
+          const rawType = capture.name.replace("ref.target_", "");
+          const refType = REF_TYPE_MAP[rawType] || "call";
+          let targetName = capture.node.text;
+          if (rawType === "import") {
+            targetName = targetName.replace(/^['"]|['"]$/g, "");
+          }
+          references.push({
+            sourceSymbol: null,
+            targetName,
+            referenceType: refType,
+            startLine
+          });
+        }
+      }
+    } catch {
+    }
+    return { id: job.id, symbols, references, errors: [] };
+  } catch {
+    return { ...empty, errors: [{ message: `Failed to parse ${job.filePath}` }] };
+  }
+}
+async function initLanguages() {
+  for (const [key, def] of langDefs) {
+    try {
+      const wasmPath = resolve(assetRoot, def.grammarWasm);
+      const wasmBuffer = await readFile(wasmPath);
+      const language = await Language.load(wasmBuffer);
+      const symbolsQuery = await readFile(resolve(assetRoot, def.queries.symbols), "utf-8");
+      const referencesQuery = await readFile(resolve(assetRoot, def.queries.references), "utf-8");
+      const parser = new Parser();
+      parser.setLanguage(language);
+      const compiledSymQuery = new Query(language, symbolsQuery);
+      const compiledRefQuery = new Query(language, referencesQuery);
+      loadedLanguages.set(key, { language, symbolsQuery, referencesQuery, parser, compiledSymQuery, compiledRefQuery });
+    } catch {
+    }
+  }
+}
+async function main() {
+  langDefs = new Map(Object.entries(workerData.languages));
+  await initParser();
+  await initLanguages();
+  parentPort.on("message", async (job) => {
+    const result = await parseFile(job);
+    parentPort.postMessage(result);
+  });
+  parentPort.postMessage({ type: "ready" });
+}
+main().catch((err) => {
+  parentPort.postMessage({ type: "error", error: err.message });
+});

package/dist/parsers/parser-interface.d.ts

@@ -0,0 +1,9 @@
+import { ParseResult } from '../types.js';
+
+interface LanguageParser {
+    readonly languageName: string;
+    readonly supportedExtensions: string[];
+    parse(filePath: string, source: string, options?: any): Promise<ParseResult>;
+}
+
+export type { LanguageParser };

package/dist/parsers/parser-registry.d.ts

@@ -0,0 +1,8 @@
+import { LanguageParser } from './parser-interface.js';
+import { LanguageDefinition } from '../languages/registry.js';
+import '../types.js';
+
+declare function getParserForFile(filePath: string, userLanguages?: Record<string, LanguageDefinition>): LanguageParser;
+declare function clearParserCache(): void;
+
+export { clearParserCache, getParserForFile };

package/dist/parsers/parser-registry.js

@@ -0,0 +1,52 @@
+import { getLanguageForFile } from "../languages/registry.js";
+import { PhpParser } from "./languages/php.js";
+import { JavaScriptParser } from "./languages/javascript.js";
+import { TypeScriptParser } from "./languages/typescript.js";
+import { VueParser } from "./languages/vue.js";
+import { FallbackParser } from "./fallback-parser.js";
+import { GenericWasmParser } from "./generic-wasm-parser.js";
+import { isLanguageInstalled } from "../languages/installer.js";
+const parserCache = /* @__PURE__ */ new Map();
+const fallbackParser = new FallbackParser();
+function getParserForFile(filePath, userLanguages) {
+  const langDef = getLanguageForFile(filePath, userLanguages);
+  if (!langDef) return fallbackParser;
+  if (langDef.tier === "installable" && !isLanguageInstalled(langDef.name)) {
+    return fallbackParser;
+  }
+  const cached = parserCache.get(langDef.name);
+  if (cached) return cached;
+  const parser = createParser(langDef);
+  parserCache.set(langDef.name, parser);
+  return parser;
+}
+function createParser(langDef) {
+  switch (langDef.name) {
+    case "php":
+      return new PhpParser(langDef);
+    case "javascript":
+      return new JavaScriptParser(langDef);
+    case "typescript":
+      return new TypeScriptParser(langDef);
+    case "vue":
+      return new VueParser(langDef);
+    case "python":
+    case "go":
+    case "rust":
+    case "java":
+    case "c-sharp":
+      return new GenericWasmParser(langDef);
+    default:
+      if (langDef.tier === "bundled" || langDef.tier === "installable" || langDef.tier === "user") {
+        return new GenericWasmParser(langDef);
+      }
+      return fallbackParser;
+  }
+}
+function clearParserCache() {
+  parserCache.clear();
+}
+export {
+  clearParserCache,
+  getParserForFile
+};

package/dist/parsers/wasm-parser.d.ts

@@ -0,0 +1,16 @@
+import { QueryCapture, Language } from 'web-tree-sitter';
+import { LanguageDefinition } from '../languages/registry.js';
+import '../types.js';
+
+declare const PROJECT_ROOT: string;
+declare function loadLanguage(langDef: LanguageDefinition): Promise<Language>;
+interface ParsedCaptures {
+    symbols: Map<string, QueryCapture[]>;
+    references: Map<string, QueryCapture[]>;
+    nameByNodeId: Map<number, string>;
+    scopeByNodeId: Map<number, string>;
+}
+declare function parseWithQueries(source: string, language: Language, symbolsQuery: string, referencesQuery: string): Promise<ParsedCaptures>;
+declare function loadQueryFile(queryPath: string): Promise<string>;
+
+export { PROJECT_ROOT, type ParsedCaptures, loadLanguage, loadQueryFile, parseWithQueries };

package/dist/parsers/wasm-parser.js

@@ -0,0 +1,110 @@
+import { Parser, Language, Query } from "web-tree-sitter";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve, dirname, join, isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+const __thisFile = fileURLToPath(import.meta.url);
+function findAssetRoot() {
+  if (existsSync(__thisFile)) {
+    return resolve(dirname(__thisFile), "..", "..");
+  }
+  const binDir = dirname(process.execPath);
+  const candidates = [
+    binDir,
+    // assets next to binary
+    resolve(binDir, "..", "share", "mapx"),
+    // XDG system: /usr/local/share/mapx
+    join(process.env["HOME"] ?? "", ".local", "share", "mapx")
+    // XDG user
+  ];
+  for (const dir of candidates) {
+    if (existsSync(join(dir, "wasm"))) return dir;
+  }
+  return binDir;
+}
+const PROJECT_ROOT = findAssetRoot();
+let initPromise = null;
+function ensureInit() {
+  if (!initPromise) {
+    initPromise = Parser.init();
+  }
+  return initPromise;
+}
+async function loadLanguage(langDef) {
+  await ensureInit();
+  const wasmPath = isAbsolute(langDef.grammarWasm) ? langDef.grammarWasm : resolve(PROJECT_ROOT, langDef.grammarWasm);
+  const wasmBuffer = await readFile(wasmPath);
+  const language = await Language.load(wasmBuffer);
+  return language;
+}
+async function parseWithQueries(source, language, symbolsQuery, referencesQuery) {
+  await ensureInit();
+  const parser = new Parser();
+  parser.setLanguage(language);
+  const tree = parser.parse(source);
+  if (!tree) {
+    return { symbols: /* @__PURE__ */ new Map(), references: /* @__PURE__ */ new Map(), nameByNodeId: /* @__PURE__ */ new Map(), scopeByNodeId: /* @__PURE__ */ new Map() };
+  }
+  const symbolCaptures = /* @__PURE__ */ new Map();
+  const refCaptures = /* @__PURE__ */ new Map();
+  const nameByNodeId = /* @__PURE__ */ new Map();
+  const scopeByNodeId = /* @__PURE__ */ new Map();
+  try {
+    const symQuery = new Query(language, symbolsQuery);
+    const symMatches = symQuery.captures(tree.rootNode);
+    const kindNodeIds = /* @__PURE__ */ new Set();
+    for (const capture of symMatches) {
+      const existing = symbolCaptures.get(capture.name) || [];
+      existing.push(capture);
+      symbolCaptures.set(capture.name, existing);
+      if (capture.name.startsWith("symbol.kind_")) {
+        kindNodeIds.add(capture.node.id);
+      }
+    }
+    for (const capture of symMatches) {
+      if (capture.name === "symbol.name") {
+        let node = capture.node.parent;
+        while (node) {
+          if (kindNodeIds.has(node.id)) {
+            nameByNodeId.set(node.id, capture.node.text);
+            break;
+          }
+          node = node.parent;
+        }
+      } else if (capture.name === "symbol.scope") {
+        let node = capture.node.parent;
+        while (node) {
+          if (kindNodeIds.has(node.id)) {
+            scopeByNodeId.set(node.id, capture.node.text);
+            break;
+          }
+          node = node.parent;
+        }
+      }
+    }
+  } catch (e) {
+    if (!e.message?.includes("no query")) throw e;
+  }
+  try {
+    const refQuery = new Query(language, referencesQuery);
+    const refMatches = refQuery.captures(tree.rootNode);
+    for (const capture of refMatches) {
+      const existing = refCaptures.get(capture.name) || [];
+      existing.push(capture);
+      refCaptures.set(capture.name, existing);
+    }
+  } catch (e) {
+    if (!e.message?.includes("no query")) throw e;
+  }
+  return { symbols: symbolCaptures, references: refCaptures, nameByNodeId, scopeByNodeId };
+}
+async function loadQueryFile(queryPath) {
+  const fullPath = isAbsolute(queryPath) ? queryPath : resolve(PROJECT_ROOT, queryPath);
+  return readFile(fullPath, "utf-8");
+}
+export {
+  PROJECT_ROOT,
+  loadLanguage,
+  loadQueryFile,
+  parseWithQueries
+};

package/dist/types.d.ts

@@ -0,0 +1,172 @@
+interface CodeFile {
+    path: string;
+    repo: string;
+    language: string;
+    gitBlobHash: string | null;
+    lastScanned: string | null;
+    sizeBytes: number;
+    lines: number;
+    metadata?: Record<string, any>;
+}
+interface ExtractedSymbol {
+    name: string;
+    kind: SymbolKind;
+    scope: string | null;
+    signature: string;
+    startLine: number;
+    endLine: number;
+    metadata: Record<string, unknown>;
+}
+type SymbolKind = 'class' | 'method' | 'function' | 'interface' | 'trait' | 'constant' | 'enum' | 'property' | 'namespace' | 'struct' | 'module' | 'field';
+interface ExtractedReference {
+    sourceSymbol: string | null;
+    targetName: string;
+    referenceType: ReferenceType;
+    startLine: number;
+    verifiability?: 'verified' | 'inferred';
+    metadata?: Record<string, any>;
+}
+type ReferenceType = 'import' | 'require' | 'extends' | 'implements' | 'call' | 'instantiation' | 'return_type' | 'param_type' | 'relation' | 'route' | 'middleware' | 'binding' | 'dispatch' | 'notify' | 'hook' | 'graphql_resolver' | 'message_handler' | 'websocket_handler';
+interface ParseResult {
+    symbols: ExtractedSymbol[];
+    references: ExtractedReference[];
+    errors: ParseError[];
+    fileMetadata?: Record<string, any>;
+}
+interface ParseError {
+    message: string;
+    line?: number;
+}
+interface GraphEdge {
+    id?: number;
+    sourceFile: string;
+    targetFile: string;
+    sourceSymbol: string | null;
+    targetSymbol: string | null;
+    edgeType: ReferenceType;
+    repo: string;
+    weight: number;
+    verifiability?: 'verified' | 'inferred';
+    metadata?: Record<string, any>;
+    targetRepo?: string | null;
+}
+type ScanPhase = 'discover' | 'index' | 'parse' | 'resolve' | 'detect' | 'cluster';
+interface ScanProgress {
+    phase: ScanPhase;
+    current: number;
+    total: number;
+    file?: string;
+}
+type ProgressCallback = (progress: ScanProgress) => void;
+interface ScanResult {
+    filesScanned: number;
+    symbolsFound: number;
+    edgesFound: number;
+    durationMs: number;
+    languageBreakdown: Record<string, number>;
+    interrupted?: boolean;
+    totalFiles?: number;
+}
+interface Snapshot {
+    commitSha: string;
+    parentSha: string | null;
+    timestamp: string;
+    filesAdded: string[];
+    filesModified: string[];
+    filesRemoved: string[];
+    symbolsDelta: {
+        added: number;
+        removed: number;
+        changed: number;
+    };
+}
+interface ExportOptions {
+    format: 'llm' | 'json' | 'dot' | 'svg' | 'toon';
+    tokenBudget: number;
+    repo?: string;
+    files?: string[];
+    delimiter?: 'comma' | 'tab' | 'pipe';
+    keyFolding?: boolean;
+}
+interface RepoConfig {
+    name: string;
+    path: string;
+    framework?: string;
+    languages?: Record<string, UserLanguageDefinition>;
+}
+interface UserLanguageDefinition {
+    extensions: string[];
+    grammarWasm: string;
+    queries: {
+        symbols?: string;
+        references?: string;
+    };
+    nodeMappings: Partial<Record<SymbolKind, string>>;
+}
+interface MapxConfig {
+    version: string;
+    repos: RepoConfig[];
+    languages: Record<string, UserLanguageDefinition>;
+    settings: {
+        maxTokenBudget: number;
+        excludePatterns: string[];
+        includePatterns: string[];
+        php?: {
+            facadeMap?: Record<string, string>;
+        };
+        [key: string]: any;
+    };
+}
+interface SubmoduleInfo {
+    name: string;
+    path: string;
+    url: string;
+    isInitialized: boolean;
+}
+interface WorkspaceInfo {
+    path: string;
+    repos: RepoConfig[];
+}
+interface RepoSummary {
+    name: string;
+    path: string;
+    type: 'primary' | 'submodule' | 'peer';
+    fileCount: number;
+    symbolCount: number;
+    edgeCount: number;
+    crossRepoEdgeCount: number;
+    lastScanned: string | null;
+    headSha: string | null;
+}
+interface ScanContext {
+    workspaceRoot: string;
+    repoName: string;
+    resolveSymbolToFile: (symbolName: string) => string | null;
+}
+interface RouteBinding {
+    framework: string;
+    method: string;
+    path: string;
+    handlerFile: string;
+    handlerSymbol?: string;
+    middlewares?: string[];
+    metadata?: Record<string, any>;
+}
+interface HookBinding {
+    framework: string;
+    hookName: string;
+    hookType: string;
+    handlerFile: string;
+    handlerSymbol?: string;
+    metadata?: Record<string, any>;
+}
+interface FrameworkDetector {
+    readonly name: string;
+    readonly language: string;
+    readonly filePattern: RegExp;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+    extractHooks?(filePath: string, content: string, ctx: ScanContext): Promise<HookBinding[]>;
+}
+
+export type { CodeFile, ExportOptions, ExtractedReference, ExtractedSymbol, FrameworkDetector, GraphEdge, HookBinding, MapxConfig, ParseError, ParseResult, ProgressCallback, ReferenceType, RepoConfig, RepoSummary, RouteBinding, ScanContext, ScanPhase, ScanProgress, ScanResult, Snapshot, SubmoduleInfo, SymbolKind, UserLanguageDefinition, WorkspaceInfo };