prodex 1.1.0 → 1.3.0

package/dist/src/core/helpers.js

@@ -1,77 +0,0 @@
-import fs from "fs";
-import path from "path";
-import micromatch from "micromatch";
-
-/**
- * Get a root-relative version of a path.
- */
-export function rel(p, root = process.cwd()) {
-  return path.relative(root, p).replaceAll("\\", "/");
-}
-
-/**
- * Safe text read.
- */
-export function read(p) {
-  try {
-    return fs.readFileSync(p, "utf8");
-  } catch {
-    return "";
-  }
-}
-
-/**
- * Check if a path/file matches any of the provided glob patterns.
- */
-export function isExcluded(p, patterns, root = process.cwd()) {
-  if (!patterns?.length) return false;
-  const relPath = rel(p, root);
-  return micromatch.isMatch(relPath, patterns);
-}
-
-/**
- * Recursive walker that respects glob excludes.
- * Returns all files under the given directory tree.
- */
-export function* walk(dir, cfg, depth = 0) {
-  const { scanDepth, entry } = cfg;
-  const root = process.cwd();
-  if (depth > scanDepth) return;
-
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const e of entries) {
-    const full = path.join(dir, e.name);
-
-    if (e.isDirectory()) {
-      // Skip excluded directories entirely
-      const relPath = rel(full, root);
-      if (isExcluded(relPath, entry.excludes)) continue;
-      yield* walk(full, cfg, depth + 1);
-      continue;
-    }
-
-    if (e.isFile()) {
-      const relPath = rel(full, root);
-      if (isExcluded(relPath, entry.excludes)) continue;
-      yield full;
-    }
-  }
-}
-
-/**
- * Sorts files so that priority items appear first.
- */
-export function sortWithPriority(files, priorityList = []) {
-  if (!priorityList.length) return files;
-  const prioritized = [];
-  const normal = [];
-
-  for (const f of files) {
-    const normalized = f.replaceAll("\\", "/").toLowerCase();
-    if (priorityList.some(p => micromatch.isMatch(normalized, p.toLowerCase())))
-      prioritized.push(f);
-    else normal.push(f);
-  }
-
-  return [...new Set([...prioritized, ...normal])];
-}

package/dist/src/core/renderers.js

@@ -1,58 +0,0 @@
-import path from "path";
-import { read, rel } from "./helpers.js";
-import { LANG_MAP } from "../constants/render-constants.js";
-
-/**
- * Generate Markdown Table of Contents
- * Sorted alphabetically for deterministic structure.
- */
-export function tocMd(files) {
-  const sorted = [...files].sort((a, b) => a.localeCompare(b));
-  const items = sorted.map(f => "- " + rel(f)).join("\n");
-  return `# Included Source Files\n\n${items}\n\n---\n`;
-}
-
-/**
- * Render a single file section in Markdown format.
- * The first file skips the leading separator to avoid duplicates.
- */
-export function renderMd(p, isFirst = false) {
-  const rp = rel(p);
-  const ext = path.extname(p).toLowerCase();
-  const lang = LANG_MAP[ext] || "txt";
-  const code = read(p).trimEnd();
-
-  return [
-    isFirst ? "" : "---", // only add separator *after* the first file
-    `\`File: ${rp}\``,
-    "",
-    "```" + lang,
-    code,
-    "```",
-    ""
-  ]
-    .filter(Boolean)
-    .join("\n");
-}
-
-/**
- * TXT version (unchanged)
- */
-export function tocTxt(files) {
-  const sorted = [...files].sort((a, b) => a.localeCompare(b));
-  return (
-    ["##==== Combined Scope ====", ...sorted.map(f => "## - " + rel(f))].join("\n") + "\n\n"
-  );
-}
-
-export function renderTxt(p) {
-  const relPath = rel(p);
-  const code = read(p);
-  return [
-    "##==== path: " + relPath + " ====",
-    "##region " + relPath,
-    code,
-    "##endregion",
-    ""
-  ].join("\n");
-}

package/dist/src/index.js

@@ -1,15 +0,0 @@
-import { runCombine } from "./core/combine.js";
-import { initProdex } from "./cli/init.js";
-
-export default async function startProdex() {
-  const args = process.argv.slice(2);
-  if (args.includes("init")) return await initProdex();
-
-  const entryArgs = args.filter(a => !a.startsWith("--"));
-  const hasEntries = entryArgs.length > 0;
-
-  console.clear();
-  console.log("🧩 Prodex — Project Dependency Extractor\n");
-
-  await runCombine({ entries: hasEntries ? entryArgs : null });
-}

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

@@ -1,180 +0,0 @@
-import fs from "fs";
-import path from "path";
-import micromatch from "micromatch";
-import { safeMicromatchScan } from "../core/file-utils.js";
-
-const debug = process.env.PRODEX_DEBUG === "1";
-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"
-  ];
-  const map = {};
-
-  // --- 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 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(block[1]))) {
-      const key = m[1];
-      const raw = m[2].replace(/^\/+/, "");
-      map[key] = path.resolve(ROOT, raw);
-    }
-  }
-
-  // --- 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 {}
-  }
-
-  return map;
-}
-
-/**
- * Try to resolve an import path into a real file.
- */
-function tryResolveImport(basePath) {
-  const ext = path.extname(basePath);
-  const tries = [];
-  if (ext) tries.push(basePath);
-  else {
-    for (const x of [".ts", ".tsx", ".d.ts", ".js", ".jsx", ".mjs"])
-      tries.push(basePath + x, path.join(basePath, "index" + x));
-  }
-  for (const t of tries)
-    if (fs.existsSync(t) && fs.statSync(t).isFile()) return path.resolve(t);
-  return null;
-}
-
-/**
- * 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();
-
-  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 (!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, stats: { expected: new Set(), resolved: new Set() } };
-
-  const patterns = [
-    /import\s+[^'"]*['"]([^'"]+)['"]/g,
-    /import\(\s*['"]([^'"]+)['"]\s*\)/g,
-    /require\(\s*['"]([^'"]+)['"]\s*\)/g,
-    /export\s+\*\s+from\s+['"]([^'"]+)['"]/g
-  ];
-
-  const matches = new Set();
-  for (const r of patterns) {
-    let m;
-    while ((m = r.exec(code))) matches.add(m[1]);
-  }
-
-  const resolved = [];
-  const expectedImports = new Set();
-  const resolvedImports = new Set();
-
-  for (const imp of matches) {
-    if (!imp.startsWith(".") && !imp.startsWith("/") && !imp.startsWith("@")) continue;
-    if (isExcluded(imp)) continue;
-
-    expectedImports.add(imp);
-
-    let importPath;
-    if (imp.startsWith("@")) {
-      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);
-    }
-
-    const resolvedPath = tryResolveImport(importPath);
-    if (!resolvedPath || isExcluded(resolvedPath)) continue;
-    resolved.push(resolvedPath);
-    resolvedImports.add(resolvedPath);
-
-    if (depth < 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));
-    }
-  }
-
-  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-bindings.js

@@ -1,31 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { ROOT } from "../constants/config.js";
-
-export function loadLaravelBindings() {
-    const providersDir = path.join(ROOT, "app", "Providers");
-    const bindings = {};
-
-    if (!fs.existsSync(providersDir)) return bindings;
-
-    const files = fs
-        .readdirSync(providersDir)
-        .filter(f => f.endsWith(".php"))
-        .map(f => path.join(providersDir, f));
-
-    // Match: $this->app->bind(Interface::class, Implementation::class)
-    const re =
-        /$this->app->(?:bind|singleton)\s*\(\s*([A-Za-z0-9_:\\\\]+)::class\s*,\s*([A-Za-z0-9_:\\\\]+)::class/g;
-
-    for (const file of files) {
-        const code = fs.readFileSync(file, "utf8");
-        let m;
-        while ((m = re.exec(code))) {
-            const iface = m[1].replace(/\\\\/g, "\\");
-            const impl = m[2].replace(/\\\\/g, "\\");
-            bindings[iface] = impl;
-        }
-    }
-
-    return bindings;
-}

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

@@ -1,155 +0,0 @@
-import fs from "fs";
-import path from "path";
-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 = (...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 {
-    const data = JSON.parse(fs.readFileSync(composerPath, "utf8"));
-    const psr4 = data.autoload?.["psr-4"] || {};
-    const map = {};
-    for (const ns in psr4)
-      map[ns.replace(/\\+$/, "")] = path.resolve(ROOT, psr4[ns]);
-    return map;
-  } catch {
-    return {};
-  }
-}
-
-/**
- * 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")];
-  for (const t of tries)
-    if (fs.existsSync(t) && fs.statSync(t).isFile()) return path.resolve(t);
-  return null;
-}
-
-/**
- * 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,
-  ctx = {}
-) {
-  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) || 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();
-
-  const patterns = [
-    /\b(?:require|include|require_once|include_once)\s*\(?['"]([^'"]+)['"]\)?/g,
-    /\buse\s+([A-Z][\w\\]+(?:\s*{[^}]+})?)/g
-  ];
-
-  const rawMatches = new Set();
-  for (const r of patterns) {
-    let m;
-    while ((m = r.exec(code))) rawMatches.add(m[1]);
-  }
-
-  // Expand grouped uses
-  const matches = new Set();
-  for (const imp of rawMatches) {
-    const groupMatch = imp.match(/^(.+?)\s*{([^}]+)}/);
-    if (groupMatch) {
-      const base = groupMatch[1].trim().replace(/\\+$/, "");
-      const parts = groupMatch[2]
-        .split(",")
-        .map((x) => x.trim())
-        .filter(Boolean);
-      for (const p of parts) matches.add(`${base}\\${p}`);
-    } else {
-      matches.add(imp.trim());
-    }
-  }
-
-  for (const imp0 of matches) {
-    let imp = imp0;
-
-    if (bindings[imp]) {
-      imp = bindings[imp];
-      log("🔗 Interface resolved via binding:", imp0, "→", imp);
-    }
-
-    let importPath;
-    if (imp.includes("\\")) {
-      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 || isExcluded(importPath)) continue;
-
-    expectedImports.add(imp);
-
-    const resolvedPath = tryResolvePhpImport(importPath);
-    if (!resolvedPath || isExcluded(resolvedPath)) continue;
-    resolved.push(resolvedPath);
-    resolvedImports.add(resolvedPath);
-
-    if (depth < 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));
-    }
-  }
-
-  // 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 }
-  };
-}