prodex 1.0.8 → 1.1.0

package/dist/src/core/combine.js

@@ -1,122 +1,116 @@
 import fs from "fs";
-import path from "path";
 import inquirer from "inquirer";
-import {
-  ROOT,
-  CODE_EXTS,
-  RESOLVERS,
-  PROMPTS
-} from "../constants/config.js";
-import { loadProdexConfig } from "../constants/config-loader.js";
-import { read, normalizeIndent, stripComments, rel } from "./helpers.js";
+import path from "path";
+import micromatch from "micromatch";
 import { pickEntries } from "../cli/picker.js";
 import { showSummary } from "../cli/summary.js";
-import { generateOutputName, resolveOutputPath } from "./file-utils.js";
+import { loadProdexConfig } from "../constants/config-loader.js";
+import { CODE_EXTS, RESOLVERS, ROOT } from "../constants/config.js";
+import { generateOutputName, resolveOutDirPath, safeMicromatchScan } from "./file-utils.js";
+import { renderMd, renderTxt, tocMd, tocTxt } from "./renderers.js";
+
 
-export async function runCombine() {
+export async function runCombine(opts = {}) {
   const cliLimitFlag = process.argv.find(arg => arg.startsWith("--limit="));
   const customLimit = cliLimitFlag ? parseInt(cliLimitFlag.split("=")[1], 10) : null;
+  const cliTxtFlag = process.argv.includes("--txt");
 
   const cfg = loadProdexConfig();
-  const { baseDirs, scanDepth } = cfg;
+  const { scanDepth } = cfg;
+
+  let entries = opts.entries;
+
+  // 🧩 Headless mode: expand globs manually
+  if (entries && entries.length) {
+    const all = [];
+    for (const pattern of entries) {
+      const abs = path.resolve(process.cwd(), pattern);
+      if (fs.existsSync(abs) && fs.statSync(abs).isFile()) {
+        // direct file path (no glob)
+        all.push(abs);
+        continue;
+      }
+
+      // glob pattern
+      const result = safeMicromatchScan(pattern, {
+        cwd: process.cwd(),
+        absolute: true,
+      });
+      if (result?.files?.length) all.push(...result.files);
+    }
+    entries = [...new Set(all)];
+  } else {
+    // fallback to interactive picker
+    entries = await pickEntries(cfg.entry.includes, scanDepth, cfg);
+  }
+
 
-  const entries = await pickEntries(baseDirs, scanDepth, cfg);
   if (!entries.length) {
     console.log("❌ No entries selected.");
     return;
   }
 
-  const autoName = generateOutputName(entries);
-  const outputDir = cfg.output || path.join(ROOT, "prodex");
-  const defaultLimit = customLimit || cfg.limit || 200;
-
   console.log("\n📋 You selected:");
-  for (const e of entries) console.log(" -", rel(e));
-
-  const { yesToAll } = await inquirer.prompt([PROMPTS.yesToAll]);
-
-  let outputBase = autoName,
-    limit = defaultLimit,
-    chain = true,
-    proceed = true;
-
-  if (!yesToAll) {
-    const combinePrompts = PROMPTS.combine.map(p => ({
-      ...p,
-      default:
-        p.name === "outputBase"
-          ? autoName
-          : p.name === "limit"
-            ? defaultLimit
-            : p.default
-    }));
-
-    const ans = await inquirer.prompt(combinePrompts);
-    outputBase = ans.outputBase || autoName;
-    limit = ans.limit;
-    chain = ans.chain;
-    proceed = ans.proceed;
-  }
+  for (const e of entries) console.log(" -", e.replace(ROOT + "/", ""));
 
-  if (!proceed) {
-    console.log("⚙️  Aborted.");
-    return;
+  // 🧩 Auto name suggestion
+  const autoName = generateOutputName(entries);
+  const outDir = cfg.outDir || path.join(ROOT, "prodex");
+  const limit = customLimit || cfg.limit || 200;
+  const chain = true;
+
+  // Skip prompt if entries were passed directly
+  let outputBase = autoName;
+  if (!opts.entries?.length) {
+    const { outputBase: answer } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "outputBase",
+        message: "Output file name (without extension):",
+        default: autoName,
+        filter: v => (v.trim() || autoName).replace(/[<>:"/\\|?*]+/g, "_"),
+      },
+    ]);
+    outputBase = answer;
   }
 
+  // Ensure output directory exists
   try {
-    fs.mkdirSync(outputDir, { recursive: true });
+    fs.mkdirSync(outDir, { recursive: true });
   } catch {
-    console.warn("⚠️  Could not create output directory:", outputDir);
+    console.warn("⚠️  Could not create outDir directory:", outDir);
   }
 
-  const output = resolveOutputPath(outputDir, outputBase);
+  const outputPath = resolveOutDirPath(outDir, outputBase, cliTxtFlag);
 
-  showSummary({
-    outputDir,
-    fileName: path.basename(output),
-    entries,
-    scanDepth: cfg.scanDepth,
-    limit,
-    chain
-  });
+  showSummary({ outDir, fileName: path.basename(outputPath), entries });
 
-  const finalFiles = chain ? await followChain(entries, limit) : entries;
 
-  fs.writeFileSync(
-    output,
-    [toc(finalFiles), ...finalFiles.map(render)].join(""),
-    "utf8"
-  );
+  const result = chain ? await followChain(entries, cfg, limit) : { files: entries, stats: { totalImports: 0, totalResolved: 0 } };
+  const sorted = [...result.files].sort((a, b) => a.localeCompare(b));
 
-  console.log(`\n✅ ${output} written (${finalFiles.length} file(s)).`);
-}
+  const content = cliTxtFlag
+    ? [tocTxt(sorted), ...sorted.map(renderTxt)].join("")
+    : [tocMd(sorted), ...sorted.map((f, i) => renderMd(f, i === 0))].join("\n");
 
-function header(p) {
-  return `##==== path: ${rel(p)} ====`;
-}
-function regionStart(p) {
-  return `##region ${rel(p)}`;
-}
-const regionEnd = "##endregion";
-
-function render(p) {
-  const ext = path.extname(p);
-  let s = read(p);
-  return `${header(p)}\n${regionStart(p)}\n${s}\n${regionEnd}\n\n`;
-}
-
-function toc(files) {
-  return (
-    ["##==== Combined Scope ====", ...files.map(f => "## - " + rel(f))].join(
-      "\n"
-    ) + "\n\n"
+  fs.writeFileSync(outputPath, content, "utf8");
+  console.log(
+    `\n✅ ${outputPath}`
   );
+  // 🧩 Print resolver summary (clean version)
+  console.log(`\n🧩 Summary:
+ • Unique imports expected: ${result.stats.expected.size}
+ • Unique imports resolved: ${result.stats.resolved.size}
+`);
 }
 
-async function followChain(entryFiles, limit = 200) {
+async function followChain(entryFiles, cfg, limit = 200) {
   console.log("🧩 Following dependency chain...");
   const visited = new Set();
   const all = [];
+  const expected = new Set();
+  const resolved = new Set();
+  const resolverDepth = cfg.resolverDepth ?? 10;
 
   for (const f of entryFiles) {
     if (visited.has(f)) continue;
@@ -127,15 +121,25 @@ async function followChain(entryFiles, limit = 200) {
 
     const resolver = RESOLVERS[ext];
     if (resolver) {
-      const { files } = await resolver(f, visited);
+      const result = await resolver(f, cfg, visited, 0, resolverDepth);
+      const { files, stats } = result;
       all.push(...files);
+      stats?.expected?.forEach(x => expected.add(x));
+      stats?.resolved?.forEach(x => resolved.add(x));
     }
 
-    if (all.length >= limit) {
+    if (limit && all.length >= limit) {
       console.log("⚠️  Limit reached:", limit);
       break;
     }
   }
 
-  return [...new Set(all)];
+  return {
+    files: [...new Set(all)],
+    stats: {
+      expected,
+      resolved
+    }
+  };
 }
+

package/dist/src/core/file-utils.js

@@ -1,4 +1,35 @@
+import fs from "fs";
 import path from "path";
+import micromatch from "micromatch";
+
+/**
+ * Safe micromatch.scan wrapper (compatible with micromatch v4 & v5)
+ */
+export function safeMicromatchScan(pattern, opts = {}) {
+  const scanFn = micromatch.scan;
+  if (typeof scanFn === "function") return scanFn(pattern, opts);
+
+  // --- fallback for micromatch v4 ---
+  const cwd = opts.cwd || process.cwd();
+  const abs = !!opts.absolute;
+  const allFiles = listAllFiles(cwd);
+  const matched = micromatch.match(allFiles, pattern, { dot: true });
+  return { files: abs ? matched.map(f => path.resolve(cwd, f)) : matched };
+}
+
+/**
+ * Recursively list all files in a directory.
+ * Used only for fallback (so performance isn’t critical).
+ */
+function listAllFiles(dir) {
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...listAllFiles(full));
+    else out.push(full);
+  }
+  return out;
+}
 
 export function generateOutputName(entries) {
   const names = entries.map(f => path.basename(f, path.extname(f)));
@@ -8,6 +39,7 @@ export function generateOutputName(entries) {
   return "unknown";
 }
 
-export function resolveOutputPath(outputDir, base) {
-  return path.join(outputDir, `prodex-${base}-combined.txt`);
+export function resolveOutDirPath(outDir, base, asTxt = false) {
+  const ext = asTxt ? "txt" : "md";
+  return path.join(outDir, `${base}-combined.${ext}`);
 }

package/dist/src/core/helpers.js

@@ -1,11 +1,17 @@
 import fs from "fs";
 import path from "path";
-import { ROOT, CODE_EXTS, ENTRY_EXCLUDES } from "../constants/config.js";
+import micromatch from "micromatch";
 
-export function rel(p) {
-  return path.relative(ROOT, p).replaceAll("\\", "/");
+/**
+ * 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");
@@ -14,104 +20,47 @@ export function read(p) {
   }
 }
 
-export function normalizeIndent(s) {
-  return s
-    .replace(/\t/g, "  ")
-    .split("\n")
-    .map(l => l.replace(/[ \t]+$/, ""))
-    .join("\n");
+/**
+ * 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);
 }
 
-export function stripComments(code, ext) {
-  if (ext === ".php") {
-    return code
-      .replace(/\/\*[\s\S]*?\*\//g, "")
-      .replace(/^\s*#.*$/gm, "");
-  }
-
-  let out = "";
-  let inStr = false;
-  let strChar = "";
-  let inBlockComment = false;
-  let inLineComment = false;
-
-  for (let i = 0; i < code.length; i++) {
-    const c = code[i];
-    const next = code[i + 1];
-
-    if (inBlockComment) {
-      if (c === "*" && next === "/") {
-        inBlockComment = false;
-        i++;
-      }
-      continue;
-    }
-
-    if (inLineComment) {
-      if (c === "\n") {
-        inLineComment = false;
-        out += c;
-      }
-      continue;
-    }
-
-    if (inStr) {
-      if (c === "\\" && next) {
-        out += c + next;
-        i++;
-        continue;
-      }
-      if (c === strChar) inStr = false;
-      out += c;
-      continue;
-    }
-
-    if (c === '"' || c === "'" || c === "`") {
-      inStr = true;
-      strChar = c;
-      out += c;
-      continue;
-    }
+/**
+ * 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;
 
-    if (c === "/" && next === "*") {
-      inBlockComment = true;
-      i++;
-      continue;
-    }
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
 
-    if (c === "/" && next === "/") {
-      inLineComment = true;
-      i++;
+    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;
     }
 
-    out += c;
-  }
-
-  return out;
-}
-
-export function isEntryExcluded(p) {
-  const r = rel(p);
-  return ENTRY_EXCLUDES.some(ex => r.startsWith(ex) || r.includes(ex));
-}
-
-export function* walk(dir, depth = 0, maxDepth = 2) {
-  if (depth > maxDepth) return;
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const e of entries) {
-    const full = path.join(dir, e.name);
-    if (e.isDirectory()) yield* walk(full, depth + 1, maxDepth);
-    else if (e.isFile()) {
-      const ext = path.extname(e.name).toLowerCase();
-      const relPath = rel(full);
-      if (CODE_EXTS.includes(ext) && !ENTRY_EXCLUDES.some(ex => relPath.startsWith(ex))) {
-        yield full;
-      }
+    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 = [];
@@ -119,7 +68,8 @@ export function sortWithPriority(files, priorityList = []) {
 
   for (const f of files) {
     const normalized = f.replaceAll("\\", "/").toLowerCase();
-    if (priorityList.some(p => normalized.includes(p.toLowerCase()))) prioritized.push(f);
+    if (priorityList.some(p => micromatch.isMatch(normalized, p.toLowerCase())))
+      prioritized.push(f);
     else normal.push(f);
   }
 

package/dist/src/core/renderers.js

@@ -0,0 +1,58 @@
+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

@@ -5,7 +5,11 @@ 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();
+
+  await runCombine({ entries: hasEntries ? entryArgs : null });
 }