prodex 1.0.8 → 1.1.0

package/dist/src/resolvers/js-resolver.js

@@ -1,70 +1,70 @@
 import fs from "fs";
 import path from "path";
-import { IMPORT_EXCLUDES, ROOT } from "../constants/config.js";
+import micromatch from "micromatch";
+import { safeMicromatchScan } from "../core/file-utils.js";
 
 const debug = process.env.PRODEX_DEBUG === "1";
-const log = (...args) => { if (debug) console.log("🪶 [resolver]", ...args); };
-
-// --- Loaders --------------------------------------------------
-
-function loadViteAliases() {
-  const files = [
+const log = (...a) => {
+  if (debug) console.log("🪶 [js-resolver]", ...a);
+};
+
+/**
+ * Load alias mappings from vite.config.* or tsconfig.json.
+ * Local config aliases (cfg.imports.aliases) override these.
+ */
+function loadProjectAliases(ROOT) {
+  const viteFiles = [
     "vite.config.ts",
     "vite.config.js",
     "vite.config.mts",
     "vite.config.mjs",
-    "vite.config.cjs",
+    "vite.config.cjs"
   ];
   const map = {};
-  for (const f of files) {
+
+  // --- Vite aliases ---------------------------------------------------------
+  for (const f of viteFiles) {
     const p = path.join(ROOT, f);
     if (!fs.existsSync(p)) continue;
     const s = fs.readFileSync(p, "utf8");
-    const obj = /resolve\s*:\s*{[\s\S]*?alias\s*:\s*{([\s\S]*?)}/m.exec(s);
-    if (!obj) continue;
+    const block = /resolve\s*:\s*{[\s\S]*?alias\s*:\s*{([\s\S]*?)}/m.exec(s);
+    if (!block) continue;
     const re = /['"]([^'"]+)['"]\s*:\s*['"]([^'"]+)['"]/g;
     let m;
-    while ((m = re.exec(obj[1]))) {
+    while ((m = re.exec(block[1]))) {
       const key = m[1];
       const raw = m[2].replace(/^\/+/, "");
-      const abs = path.resolve(ROOT, raw);
-      map[key] = abs;
+      map[key] = path.resolve(ROOT, raw);
     }
   }
-  return map;
-}
 
-function loadTsconfigAliases() {
-  const p = path.join(ROOT, "tsconfig.json");
-  if (!fs.existsSync(p)) return {};
-  let content = fs.readFileSync(p, "utf8")
-    .replace(/("(?:\\.|[^"\\])*")|\/\/.*$|\/\*[\s\S]*?\*\//gm, (_, q) => q || "")
-    .replace(/,\s*([}\]])/g, "$1");
-  let j;
-  try {
-    j = JSON.parse(content);
-  } catch {
-    return {};
+  // --- TSConfig aliases -----------------------------------------------------
+  const ts = path.join(ROOT, "tsconfig.json");
+  if (fs.existsSync(ts)) {
+    try {
+      const content = fs
+        .readFileSync(ts, "utf8")
+        .replace(/("(?:\\.|[^"\\])*")|\/\/.*$|\/\*[\s\S]*?\*\//gm, (_, q) => q || "")
+        .replace(/,\s*([}\]])/g, "$1");
+      const j = JSON.parse(content);
+      const paths = j.compilerOptions?.paths || {};
+      const base = j.compilerOptions?.baseUrl || ".";
+      for (const k in paths) {
+        const arr = paths[k];
+        if (!Array.isArray(arr) || !arr.length) continue;
+        const from = k.replace(/\*$/, "");
+        const to = arr[0].replace(/\*$/, "");
+        map[from] = path.resolve(ROOT, base, to);
+      }
+    } catch {}
   }
-  const paths = j.compilerOptions?.paths || {};
-  const base = j.compilerOptions?.baseUrl || ".";
-  const map = {};
-  for (const k in paths) {
-    const arr = paths[k];
-    if (!Array.isArray(arr) || !arr.length) continue;
-    const from = k.replace(/\*$/, "");
-    const to = arr[0].replace(/\*$/, "");
-    map[from] = path.resolve(ROOT, base, to);
-  }
-  return map;
-}
 
-function loadJsAliases() {
-  return { ...loadTsconfigAliases(), ...loadViteAliases() };
+  return map;
 }
 
-// --- Resolver Core --------------------------------------------
-
+/**
+ * Try to resolve an import path into a real file.
+ */
 function tryResolveImport(basePath) {
   const ext = path.extname(basePath);
   const tries = [];
@@ -78,27 +78,49 @@ function tryResolveImport(basePath) {
   return null;
 }
 
-function isImportExcluded(p) {
-  return IMPORT_EXCLUDES.some(ex => p.includes(ex));
-}
+/**
+ * Core: resolve JS / TS imports recursively.
+ * Returns unique project-level expected + resolved import sets.
+ */
+export async function resolveJsImports(
+  filePath,
+  cfg,
+  visited = new Set(),
+  depth = 0,
+  maxDepth = 10,
+  ctx = {}
+) {
+  if (depth >= maxDepth) {
+    if (debug) console.log(`⚠️  JS resolver depth (${maxDepth}) reached at ${filePath}`);
+    return { files: [], visited, stats: { expected: new Set(), resolved: new Set() } };
+  }
+
+  const { imports } = cfg;
+  const ROOT = process.cwd();
 
-export async function resolveJsImports(filePath, visited = new Set(), depth = 0, maxDepth = 10) {
-  if (visited.has(filePath)) return { files: [], visited };
+  if (!ctx.aliases)
+    ctx.aliases = { ...loadProjectAliases(ROOT), ...imports.aliases };
+  const aliases = ctx.aliases;
+
+  const isExcluded = (p) =>
+    micromatch.isMatch(p.replaceAll("\\", "/"), imports.excludes || []);
+  if (visited.has(filePath))
+    return { files: [], visited, stats: { expected: new Set(), resolved: new Set() } };
   visited.add(filePath);
-  if (isImportExcluded(filePath) || !fs.existsSync(filePath))
-    return { files: [], visited };
+
+  if (!fs.existsSync(filePath) || isExcluded(filePath))
+    return { files: [], visited, stats: { expected: new Set(), resolved: new Set() } };
 
   const code = fs.readFileSync(filePath, "utf8");
   const ext = path.extname(filePath).toLowerCase();
   if (![".ts", ".tsx", ".d.ts", ".js", ".jsx", ".mjs"].includes(ext))
-    return { files: [], visited };
+    return { files: [], visited, stats: { expected: new Set(), resolved: new Set() } };
 
-  const aliases = loadJsAliases();
   const patterns = [
     /import\s+[^'"]*['"]([^'"]+)['"]/g,
     /import\(\s*['"]([^'"]+)['"]\s*\)/g,
     /require\(\s*['"]([^'"]+)['"]\s*\)/g,
-    /export\s+\*\s+from\s+['"]([^'"]+)['"]/g,
+    /export\s+\*\s+from\s+['"]([^'"]+)['"]/g
   ];
 
   const matches = new Set();
@@ -108,28 +130,51 @@ export async function resolveJsImports(filePath, visited = new Set(), depth = 0,
   }
 
   const resolved = [];
+  const expectedImports = new Set();
+  const resolvedImports = new Set();
+
   for (const imp of matches) {
     if (!imp.startsWith(".") && !imp.startsWith("/") && !imp.startsWith("@")) continue;
-    if (isImportExcluded(imp)) continue;
+    if (isExcluded(imp)) continue;
+
+    expectedImports.add(imp);
 
     let importPath;
     if (imp.startsWith("@")) {
-      const aliasKey = Object.keys(aliases).find(a => imp.startsWith(a));
+      const aliasKey = Object.keys(aliases).find((a) => imp.startsWith(a));
       if (aliasKey) {
         const relPart = imp.slice(aliasKey.length).replace(/^\/+/, "");
         importPath = path.join(aliases[aliasKey], relPart);
       } else continue;
-    } else importPath = path.resolve(path.dirname(filePath), imp);
+    } else {
+      importPath = path.resolve(path.dirname(filePath), imp);
+    }
 
     const resolvedPath = tryResolveImport(importPath);
-    if (!resolvedPath || isImportExcluded(resolvedPath)) continue;
+    if (!resolvedPath || isExcluded(resolvedPath)) continue;
     resolved.push(resolvedPath);
+    resolvedImports.add(resolvedPath);
 
     if (depth < maxDepth) {
-      const sub = await resolveJsImports(resolvedPath, visited, depth + 1, maxDepth);
+      const sub = await resolveJsImports(resolvedPath, cfg, visited, depth + 1, maxDepth, ctx);
       resolved.push(...sub.files);
+      sub.stats?.expected?.forEach((i) => expectedImports.add(i));
+      sub.stats?.resolved?.forEach((i) => resolvedImports.add(i));
+    }
+  }
+
+  // Always-include patterns (no recursion)
+  for (const pattern of imports.includes || []) {
+    const scan = safeMicromatchScan(pattern, { cwd: ROOT, absolute: true });
+    if (scan?.files) {
+      for (const f of scan.files) resolved.push(path.resolve(ROOT, f));
     }
   }
 
-  return { files: [...new Set(resolved)], visited };
+  log("✅ JS resolver completed for", filePath, "→", resolved.length, "files");
+  return {
+    files: [...new Set(resolved)],
+    visited,
+    stats: { expected: expectedImports, resolved: resolvedImports }
+  };
 }

package/dist/src/resolvers/php-resolver.js

@@ -1,14 +1,18 @@
 import fs from "fs";
 import path from "path";
-import { ROOT } from "../constants/config.js";
+import micromatch from "micromatch";
 import { loadLaravelBindings } from "./php-bindings.js";
+import { safeMicromatchScan } from "../core/file-utils.js";
 
 const debug = process.env.PRODEX_DEBUG === "1";
-const log = (...args) => { if (debug) console.log("🪶 [php-resolver]", ...args); };
-
-// --- Load Composer PSR-4 Namespaces ----------------------------------------
-
-function loadComposerNamespaces() {
+const log = (...a) => {
+  if (debug) console.log("🪶 [php-resolver]", ...a);
+};
+
+/**
+ * Load PSR-4 namespaces from composer.json.
+ */
+function loadComposerNamespaces(ROOT) {
   const composerPath = path.join(ROOT, "composer.json");
   if (!fs.existsSync(composerPath)) return {};
   try {
@@ -23,8 +27,9 @@ function loadComposerNamespaces() {
   }
 }
 
-// --- File resolver ---------------------------------------------------------
-
+/**
+ * Try to resolve a PHP include/namespace to a file.
+ */
 function tryResolvePhpImport(basePath) {
   if (!basePath || typeof basePath !== "string") return null;
   const tries = [basePath, basePath + ".php", path.join(basePath, "index.php")];
@@ -33,24 +38,49 @@ function tryResolvePhpImport(basePath) {
   return null;
 }
 
-// --- Main resolver ---------------------------------------------------------
-
+/**
+ * Core PHP resolver — PSR-4 + Laravel bindings + glob excludes.
+ * Returns unique expected + resolved import sets.
+ */
 export async function resolvePhpImports(
   filePath,
+  cfg,
   visited = new Set(),
   depth = 0,
-  maxDepth = 10
+  maxDepth = 10,
+  ctx = {}
 ) {
-  if (visited.has(filePath)) return { files: [], visited };
+  if (depth >= maxDepth) {
+    if (debug) console.log(`⚠️  PHP resolver depth (${maxDepth}) reached at ${filePath}`);
+    return { files: [], visited, stats: { expected: new Set(), resolved: new Set() } };
+  }
+
+  const { imports } = cfg;
+  const ROOT = process.cwd();
+
+  if (!ctx.namespaces) ctx.namespaces = loadComposerNamespaces(ROOT);
+  if (!ctx.bindings) ctx.bindings = loadLaravelBindings();
+
+  const namespaces = ctx.namespaces;
+  const bindings = ctx.bindings;
+  const isExcluded = (p) =>
+    micromatch.isMatch(p.replaceAll("\\", "/"), imports.excludes || []);
+
+  if (visited.has(filePath))
+    return { files: [], visited, stats: { expected: new Set(), resolved: new Set() } };
   visited.add(filePath);
-  if (!fs.existsSync(filePath)) return { files: [], visited };
+
+  if (!fs.existsSync(filePath) || isExcluded(filePath))
+    return { files: [], visited, stats: { expected: new Set(), resolved: new Set() } };
 
   const code = fs.readFileSync(filePath, "utf8");
+  const resolved = [];
+  const expectedImports = new Set();
+  const resolvedImports = new Set();
 
-  // find include/require + grouped and single use statements
   const patterns = [
     /\b(?:require|include|require_once|include_once)\s*\(?['"]([^'"]+)['"]\)?/g,
-    /\buse\s+([A-Z][\w\\]+(?:\s*{[^}]+})?)/g,
+    /\buse\s+([A-Z][\w\\]+(?:\s*{[^}]+})?)/g
   ];
 
   const rawMatches = new Set();
@@ -67,7 +97,7 @@ export async function resolvePhpImports(
       const base = groupMatch[1].trim().replace(/\\+$/, "");
       const parts = groupMatch[2]
         .split(",")
-        .map(x => x.trim())
+        .map((x) => x.trim())
         .filter(Boolean);
       for (const p of parts) matches.add(`${base}\\${p}`);
     } else {
@@ -75,41 +105,51 @@ export async function resolvePhpImports(
     }
   }
 
-  const namespaces = loadComposerNamespaces();
-  const bindings = loadLaravelBindings();
-  const resolved = [];
-
   for (const imp0 of matches) {
     let imp = imp0;
 
-    // Interface → Implementation mapping via Service Providers
     if (bindings[imp]) {
       imp = bindings[imp];
-      log("🔗 Interface resolved via AppServiceProvider:", imp0, "→", imp);
+      log("🔗 Interface resolved via binding:", imp0, "→", imp);
     }
 
     let importPath;
-
-    // PSR-4 namespace resolution
     if (imp.includes("\\")) {
-      const nsKey = Object.keys(namespaces).find(k => imp.startsWith(k));
-      if (!nsKey) continue; // skip vendor namespaces
+      const nsKey = Object.keys(namespaces).find((k) => imp.startsWith(k));
+      if (!nsKey) continue;
       const relPart = imp.slice(nsKey.length).replace(/\\/g, "/");
       importPath = path.join(namespaces[nsKey], `${relPart}.php`);
     } else {
       importPath = path.resolve(path.dirname(filePath), imp);
     }
 
-    if (!importPath || typeof importPath !== "string") continue;
+    if (!importPath || isExcluded(importPath)) continue;
+
+    expectedImports.add(imp);
+
     const resolvedPath = tryResolvePhpImport(importPath);
-    if (!resolvedPath) continue;
+    if (!resolvedPath || isExcluded(resolvedPath)) continue;
     resolved.push(resolvedPath);
+    resolvedImports.add(resolvedPath);
 
     if (depth < maxDepth) {
-      const sub = await resolvePhpImports(resolvedPath, visited, depth + 1, maxDepth);
+      const sub = await resolvePhpImports(resolvedPath, cfg, visited, depth + 1, maxDepth, ctx);
       resolved.push(...sub.files);
+      sub.stats?.expected?.forEach((i) => expectedImports.add(i));
+      sub.stats?.resolved?.forEach((i) => resolvedImports.add(i));
     }
   }
 
-  return { files: [...new Set(resolved)], visited };
+  // Always-include patterns (no recursion)
+  for (const pattern of imports.includes || []) {
+    const scan = safeMicromatchScan(pattern, { cwd: ROOT, absolute: true });
+    if (scan?.files) for (const f of scan.files) resolved.push(path.resolve(ROOT, f));
+  }
+
+  log("✅ PHP resolver completed for", filePath, "→", resolved.length, "files");
+  return {
+    files: [...new Set(resolved)],
+    visited,
+    stats: { expected: expectedImports, resolved: resolvedImports }
+  };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prodex",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "Unified Project Indexer & Dependency Extractor for Laravel + React + Node stacks.",
   "type": "module",
   "bin": {
@@ -34,10 +34,12 @@
   "author": "emxhive",
   "license": "MIT",
   "devDependencies": {
+    "@types/node": "^24.9.1",
     "tsup": "^8.5.0",
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "inquirer": "^12.10.0"
+    "inquirer": "^12.10.0",
+    "micromatch": "^4.0.8"
   }
 }