@mgamil/mapx 0.2.4

package/dist/core/cluster-engine.d.ts

@@ -0,0 +1,32 @@
+import { Store } from './store.js';
+import './store-interface.js';
+import './graph.js';
+import '../types.js';
+
+type ClusterSource = 'namespace' | 'directory' | 'community';
+interface Cluster {
+    name: string;
+    label: string;
+    source: ClusterSource;
+    parentName: string | null;
+    depth: number;
+    fileCount: number;
+}
+interface ClusterResult {
+    clustersFound: number;
+    namespaceClusters: number;
+    directoryClusters: number;
+    communityClusters: number;
+    filesAssigned: number;
+    durationMs: number;
+}
+declare class ClusterEngine {
+    private store;
+    constructor(store: Store);
+    detect(repo: string): ClusterResult;
+    private detectNamespaceClusters;
+    private detectDirectoryClusters;
+    private detectCommunityClusters;
+}
+
+export { type Cluster, ClusterEngine, type ClusterResult, type ClusterSource };

package/dist/core/cluster-engine.js

@@ -0,0 +1,314 @@
+class ClusterEngine {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  detect(repo) {
+    const startTime = Date.now();
+    const nsRes = this.detectNamespaceClusters(repo);
+    const dirRes = this.detectDirectoryClusters(repo, nsRes.memberships);
+    const allPrimaryMemberships = /* @__PURE__ */ new Map();
+    for (const [f, c] of nsRes.memberships.entries()) {
+      allPrimaryMemberships.set(f, c);
+    }
+    for (const [f, c] of dirRes.memberships.entries()) {
+      allPrimaryMemberships.set(f, c);
+    }
+    const primaryClustersMap = /* @__PURE__ */ new Map();
+    for (const c of nsRes.clusters) {
+      primaryClustersMap.set(c.name, c);
+    }
+    for (const c of dirRes.clusters) {
+      if (!primaryClustersMap.has(c.name)) {
+        primaryClustersMap.set(c.name, c);
+      }
+    }
+    const primaryFileCounts = /* @__PURE__ */ new Map();
+    for (const clusterName of allPrimaryMemberships.values()) {
+      let current = clusterName;
+      while (current) {
+        primaryFileCounts.set(current, (primaryFileCounts.get(current) || 0) + 1);
+        const idx = current.lastIndexOf(".");
+        current = idx !== -1 ? current.substring(0, idx) : null;
+      }
+    }
+    const primaryClusters = Array.from(primaryClustersMap.values()).map((c) => ({
+      ...c,
+      fileCount: primaryFileCounts.get(c.name) || 0
+    }));
+    const clusterFileSets = /* @__PURE__ */ new Map();
+    for (const c of primaryClusters) {
+      clusterFileSets.set(c.name, /* @__PURE__ */ new Set());
+    }
+    for (const [filePath, clusterName] of allPrimaryMemberships.entries()) {
+      let current = clusterName;
+      while (current) {
+        if (clusterFileSets.has(current)) {
+          clusterFileSets.get(current).add(filePath);
+        }
+        const idx = current.lastIndexOf(".");
+        current = idx !== -1 ? current.substring(0, idx) : null;
+      }
+    }
+    const files = this.store.getAllFiles(repo);
+    const edges = this.store.getAllEdges(repo);
+    const commRes = this.detectCommunityClusters(repo, files, edges, clusterFileSets);
+    this.store.inTransaction(() => {
+      this.store.clearClusters(repo);
+      for (const c of primaryClusters) {
+        this.store.insertCluster({
+          repo,
+          name: c.name,
+          label: c.label,
+          source: c.source,
+          parentName: c.parentName,
+          depth: c.depth,
+          fileCount: c.fileCount
+        });
+      }
+      for (const [filePath, clusterName] of allPrimaryMemberships.entries()) {
+        this.store.insertClusterMembership({
+          filePath,
+          clusterName,
+          repo,
+          isPrimary: 1
+        });
+      }
+      for (const c of commRes.clusters) {
+        this.store.insertCluster({
+          repo,
+          name: c.name,
+          label: c.label,
+          source: c.source,
+          parentName: c.parentName,
+          depth: c.depth,
+          fileCount: c.fileCount
+        });
+      }
+      for (const m of commRes.memberships) {
+        this.store.insertClusterMembership({
+          filePath: m.filePath,
+          clusterName: m.clusterName,
+          repo,
+          isPrimary: 0
+        });
+      }
+    });
+    const namespaceCount = primaryClusters.filter((c) => c.source === "namespace").length;
+    const directoryCount = primaryClusters.filter((c) => c.source === "directory").length;
+    return {
+      clustersFound: primaryClusters.length + commRes.clusters.length,
+      namespaceClusters: namespaceCount,
+      directoryClusters: directoryCount,
+      communityClusters: commRes.clusters.length,
+      filesAssigned: allPrimaryMemberships.size,
+      durationMs: Date.now() - startTime
+    };
+  }
+  detectNamespaceClusters(repo) {
+    const files = this.store.getAllFiles(repo);
+    const clustersMap = /* @__PURE__ */ new Map();
+    const memberships = /* @__PURE__ */ new Map();
+    for (const f of files) {
+      let ns = f.namespace || null;
+      if (!ns && f.metadata) {
+        try {
+          const meta = JSON.parse(f.metadata);
+          ns = meta.namespace || null;
+        } catch {
+        }
+      }
+      if (ns) {
+        const normalized = ns.replace(/\\/g, ".").replace(/^\.|\.$/g, "");
+        if (!normalized) continue;
+        memberships.set(f.path, normalized);
+        let current = normalized;
+        while (current) {
+          if (!clustersMap.has(current)) {
+            const parts = current.split(".");
+            const parentName = parts.slice(0, -1).join(".") || null;
+            const depth = parts.length - 1;
+            clustersMap.set(current, {
+              name: current,
+              label: parts.join(" / "),
+              source: "namespace",
+              parentName,
+              depth,
+              fileCount: 0
+            });
+          }
+          const idx = current.lastIndexOf(".");
+          current = idx !== -1 ? current.substring(0, idx) : "";
+        }
+      }
+    }
+    return { clusters: Array.from(clustersMap.values()), memberships };
+  }
+  detectDirectoryClusters(repo, existingPrimaryMemberships) {
+    const files = this.store.getAllFiles(repo);
+    const dirFileCount = /* @__PURE__ */ new Map();
+    for (const f of files) {
+      const filePath = f.path;
+      const parts = filePath.split("/");
+      if (parts.length <= 1) continue;
+      for (let i = 1; i < parts.length; i++) {
+        const dirPath = parts.slice(0, i).join("/");
+        if (!dirFileCount.has(dirPath)) {
+          dirFileCount.set(dirPath, /* @__PURE__ */ new Set());
+        }
+        dirFileCount.get(dirPath).add(filePath);
+      }
+    }
+    const clustersMap = /* @__PURE__ */ new Map();
+    const memberships = /* @__PURE__ */ new Map();
+    for (const [dirPath, fileSet] of dirFileCount.entries()) {
+      if (fileSet.size >= 2) {
+        const clusterName = dirPath.replace(/\//g, ".");
+        const parts = clusterName.split(".");
+        const parentName = parts.slice(0, -1).join(".") || null;
+        const depth = parts.length;
+        clustersMap.set(clusterName, {
+          name: clusterName,
+          label: parts.join(" / "),
+          source: "directory",
+          parentName,
+          depth,
+          fileCount: 0
+        });
+      }
+    }
+    for (const f of files) {
+      const filePath = f.path;
+      if (existingPrimaryMemberships.has(filePath)) continue;
+      const parts = filePath.split("/");
+      if (parts.length <= 1) continue;
+      for (let i = parts.length - 1; i >= 1; i--) {
+        const dirPath = parts.slice(0, i).join("/");
+        const clusterName = dirPath.replace(/\//g, ".");
+        if (clustersMap.has(clusterName)) {
+          memberships.set(filePath, clusterName);
+          break;
+        }
+      }
+    }
+    return { clusters: Array.from(clustersMap.values()), memberships };
+  }
+  detectCommunityClusters(repo, files, edges, existingClusterFileSets) {
+    const filesList = files.map((f) => f.path).sort();
+    const weights = /* @__PURE__ */ new Map();
+    const addWeight = (u, v, w) => {
+      if (!weights.has(u)) weights.set(u, /* @__PURE__ */ new Map());
+      const uMap = weights.get(u);
+      uMap.set(v, (uMap.get(v) || 0) + w);
+    };
+    for (const e of edges) {
+      const src = e.source_file;
+      const tgt = e.target_file;
+      if (src === tgt) continue;
+      addWeight(src, tgt, 1);
+      addWeight(tgt, src, 1);
+    }
+    const labels = /* @__PURE__ */ new Map();
+    for (const node of filesList) {
+      labels.set(node, node);
+    }
+    const seededShuffle = (array, seed) => {
+      const result = [...array];
+      let currentSeed = seed;
+      const random = () => {
+        currentSeed = (currentSeed * 9301 + 49297) % 233280;
+        return currentSeed / 233280;
+      };
+      for (let i = result.length - 1; i > 0; i--) {
+        const j = Math.floor(random() * (i + 1));
+        const temp = result[i];
+        result[i] = result[j];
+        result[j] = temp;
+      }
+      return result;
+    };
+    const maxIterations = 10;
+    let changed = true;
+    for (let iter = 0; iter < maxIterations && changed; iter++) {
+      changed = false;
+      const shuffledNodes = seededShuffle(filesList, 42 + iter);
+      for (const node of shuffledNodes) {
+        const neighbors = weights.get(node);
+        if (!neighbors || neighbors.size === 0) continue;
+        const labelWeights = /* @__PURE__ */ new Map();
+        for (const [neighbor, weight] of neighbors.entries()) {
+          const nLabel = labels.get(neighbor);
+          labelWeights.set(nLabel, (labelWeights.get(nLabel) || 0) + weight);
+        }
+        let maxLabel = labels.get(node);
+        let maxW = 0;
+        const sortedLabels = Array.from(labelWeights.keys()).sort();
+        for (const label of sortedLabels) {
+          const w = labelWeights.get(label);
+          if (w > maxW) {
+            maxW = w;
+            maxLabel = label;
+          } else if (w === maxW) {
+            if (label < maxLabel) {
+              maxLabel = label;
+            }
+          }
+        }
+        if (labels.get(node) !== maxLabel) {
+          labels.set(node, maxLabel);
+          changed = true;
+        }
+      }
+    }
+    const communityGroups = /* @__PURE__ */ new Map();
+    for (const [node, label] of labels.entries()) {
+      if (!communityGroups.has(label)) {
+        communityGroups.set(label, []);
+      }
+      communityGroups.get(label).push(node);
+    }
+    const clusters = [];
+    const memberships = [];
+    let communityIndex = 1;
+    const sortedGroupKeys = Array.from(communityGroups.keys()).sort();
+    for (const key of sortedGroupKeys) {
+      const filePaths = communityGroups.get(key);
+      if (filePaths.length < 3) continue;
+      const commFileSet = new Set(filePaths);
+      let overlaps = false;
+      for (const fileSet of existingClusterFileSets.values()) {
+        if (fileSet.size === commFileSet.size) {
+          let allMatch = true;
+          for (const f of filePaths) {
+            if (!fileSet.has(f)) {
+              allMatch = false;
+              break;
+            }
+          }
+          if (allMatch) {
+            overlaps = true;
+            break;
+          }
+        }
+      }
+      if (!overlaps) {
+        const commName = `community_${communityIndex++}`;
+        clusters.push({
+          name: commName,
+          label: `Community ${commName.split("_")[1]}`,
+          source: "community",
+          parentName: null,
+          depth: 0,
+          fileCount: filePaths.length
+        });
+        for (const f of filePaths) {
+          memberships.push({ filePath: f, clusterName: commName });
+        }
+      }
+    }
+    return { clusters, memberships };
+  }
+}
+export {
+  ClusterEngine
+};

package/dist/core/config.d.ts

@@ -0,0 +1,29 @@
+import { RepoConfig, UserLanguageDefinition } from '../types.js';
+import { LanguageDefinition } from '../languages/registry.js';
+
+declare class Config {
+    private configPath;
+    private config;
+    private constructor();
+    static load(workspaceRoot: string): Promise<Config>;
+    static init(workspaceRoot: string, repoName?: string, isLaravel?: boolean, shouldAddLaravelExcludes?: boolean): Promise<Config>;
+    save(): Promise<void>;
+    get repos(): RepoConfig[];
+    get settings(): {
+        [key: string]: any;
+        maxTokenBudget: number;
+        excludePatterns: string[];
+        includePatterns: string[];
+        php?: {
+            facadeMap?: Record<string, string>;
+        };
+    };
+    get languages(): Record<string, UserLanguageDefinition>;
+    getResolvedUserLanguages(): Record<string, LanguageDefinition>;
+    addRepo(name: string, path: string): void;
+    removeRepo(nameOrPath: string): void;
+    getWorkspaceRoot(): string;
+    get repo(): RepoConfig;
+}
+
+export { Config };

package/dist/core/config.js

@@ -0,0 +1,178 @@
+import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { getBuiltinLanguages } from "../languages/registry.js";
+const DEFAULT_CONFIG = {
+  version: "1.0.0",
+  repos: [],
+  languages: {},
+  settings: {
+    maxTokenBudget: 16384,
+    excludePatterns: [
+      "node_modules/**",
+      "vendor/**",
+      ".git/**",
+      "dist/**",
+      ".mapx/**",
+      "*.min.js",
+      "*.min.css",
+      "package-lock.json",
+      "composer.lock"
+    ],
+    includePatterns: []
+  }
+};
+class Config {
+  configPath;
+  config;
+  constructor(configPath, config) {
+    this.configPath = configPath;
+    this.config = config;
+  }
+  static async load(workspaceRoot) {
+    const configPath = join(workspaceRoot, ".mapx", "config.json");
+    const mapxDir = join(workspaceRoot, ".mapx");
+    if (!existsSync(configPath)) {
+      await mkdir(mapxDir, { recursive: true });
+      const defaultConfig = {
+        ...DEFAULT_CONFIG,
+        repos: [{
+          name: resolve(workspaceRoot).split("/").pop() || "default",
+          path: "."
+        }]
+      };
+      await writeFile(configPath, JSON.stringify(defaultConfig, null, 2), "utf-8");
+      return new Config(configPath, defaultConfig);
+    }
+    const data = await readFile(configPath, "utf-8");
+    const config = JSON.parse(data);
+    return new Config(configPath, config);
+  }
+  static async init(workspaceRoot, repoName, isLaravel = false, shouldAddLaravelExcludes = false) {
+    const mapxDir = join(workspaceRoot, ".mapx");
+    await mkdir(mapxDir, { recursive: true });
+    const configPath = join(mapxDir, "config.json");
+    let existing = null;
+    if (existsSync(configPath)) {
+      try {
+        existing = JSON.parse(await readFile(configPath, "utf-8"));
+      } catch {
+        existing = null;
+      }
+    }
+    const defaultExclude = [...DEFAULT_CONFIG.settings.excludePatterns];
+    if (shouldAddLaravelExcludes) {
+      const LARAVEL_DEFAULT_EXCLUDES = [
+        "database/migrations/**",
+        "database/seeders/**",
+        "database/factories/**",
+        "storage/**",
+        "bootstrap/cache/**",
+        "public/**",
+        "resources/views/**",
+        "**/*.blade.php",
+        "vendor/**"
+      ];
+      for (const pattern of LARAVEL_DEFAULT_EXCLUDES) {
+        if (!defaultExclude.includes(pattern)) {
+          defaultExclude.push(pattern);
+        }
+      }
+    } else {
+      let isPHP = false;
+      let isJSTS = false;
+      try {
+        const rootFiles = await readdir(workspaceRoot);
+        for (const file of rootFiles) {
+          if (file === "composer.json" || file.endsWith(".php")) {
+            isPHP = true;
+          }
+          if (file === "package.json" || file === "tsconfig.json" || file.endsWith(".ts") || file.endsWith(".js") || file.endsWith(".tsx") || file.endsWith(".jsx")) {
+            isJSTS = true;
+          }
+        }
+      } catch {
+      }
+      if (isPHP) {
+        defaultExclude.push("**/migrations/**", "**/seeds/**", "**/storage/**");
+      }
+      if (isJSTS) {
+        defaultExclude.push("**/dist/**", "**/__tests__/**", "**/*.test.ts", "**/*.spec.ts");
+      }
+    }
+    const userExclude = existing?.settings?.excludePatterns ?? [];
+    const userInclude = existing?.settings?.includePatterns ?? [];
+    const mergedExclude = [.../* @__PURE__ */ new Set([...userExclude, ...defaultExclude.filter((p) => !userExclude.includes(p))])];
+    const mergedInclude = [.../* @__PURE__ */ new Set([...userInclude, ...DEFAULT_CONFIG.settings.includePatterns])];
+    const defaultRepoName = repoName || resolve(workspaceRoot).split("/").pop() || "default";
+    const existingRepos = existing?.repos ?? [];
+    const repos = existingRepos.length > 0 ? existingRepos : [{
+      name: defaultRepoName,
+      path: ".",
+      ...isLaravel ? { framework: "laravel" } : {}
+    }];
+    if (repos[0] && isLaravel) {
+      repos[0].framework = "laravel";
+    }
+    const config = {
+      version: existing?.version ?? DEFAULT_CONFIG.version,
+      repos,
+      languages: existing?.languages ?? {},
+      settings: {
+        maxTokenBudget: existing?.settings?.maxTokenBudget ?? DEFAULT_CONFIG.settings.maxTokenBudget,
+        excludePatterns: mergedExclude,
+        includePatterns: mergedInclude
+      }
+    };
+    await writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+    return new Config(configPath, config);
+  }
+  async save() {
+    await writeFile(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
+  }
+  get repos() {
+    return this.config.repos;
+  }
+  get settings() {
+    return this.config.settings;
+  }
+  get languages() {
+    return this.config.languages;
+  }
+  getResolvedUserLanguages() {
+    const result = {};
+    const builtins = getBuiltinLanguages();
+    for (const [name, userDef] of Object.entries(this.config.languages)) {
+      if (builtins[name]) continue;
+      result[name] = {
+        name,
+        extensions: userDef.extensions,
+        grammarWasm: userDef.grammarWasm,
+        queries: {
+          symbols: userDef.queries.symbols || "",
+          references: userDef.queries.references || ""
+        },
+        nodeMappings: userDef.nodeMappings,
+        tier: "user"
+      };
+    }
+    return result;
+  }
+  addRepo(name, path) {
+    if (!this.config.repos.find((r) => r.path === path)) {
+      this.config.repos.push({ name, path });
+    }
+  }
+  removeRepo(nameOrPath) {
+    this.config.repos = this.config.repos.filter((r) => r.name !== nameOrPath && r.path !== nameOrPath);
+  }
+  getWorkspaceRoot() {
+    return resolve(this.configPath, "..", "..");
+  }
+  get repo() {
+    return this.config.repos[0];
+  }
+}
+export {
+  Config
+};

package/dist/core/context-builder.d.ts

@@ -0,0 +1,61 @@
+import { MapxGraph } from './graph.js';
+import { Store } from './store.js';
+import '../types.js';
+import './store-interface.js';
+
+interface ContextOptions {
+    task: string;
+    seeds?: string[];
+    tokens?: number;
+    depth?: number;
+    repo?: string;
+}
+interface ContextResult {
+    includedFiles: Array<{
+        path: string;
+        language: string;
+        lineCount: number;
+        sizeBytes: number;
+        symbols: Array<{
+            name: string;
+            kind: string;
+            scope: string | null;
+            startLine: number;
+            endLine: number;
+        }>;
+    }>;
+    excludedFiles: string[];
+    edges: Array<{
+        sourceFile: string;
+        targetFile: string;
+        sourceSymbol: string | null;
+        targetSymbol: string | null;
+        edgeType: string;
+    }>;
+    estimatedTokens: number;
+    matchedSymbols?: Array<{
+        name: string;
+        kind: string;
+        filePath: string;
+    }>;
+    files?: Array<{
+        path: string;
+        language: string;
+        lineCount: number;
+        sizeBytes: number;
+    }>;
+    symbols?: Array<{
+        name: string;
+        kind: string;
+        filePath: string;
+    }>;
+}
+declare class ContextBuilder {
+    private store;
+    private graph;
+    constructor(store: Store, graph: MapxGraph);
+    static extractKeywords(text: string): string[];
+    buildContext(options: ContextOptions): Promise<ContextResult>;
+}
+
+export { ContextBuilder, type ContextOptions, type ContextResult };