@eloquence98/ctx 0.1.3 → 0.1.5

package/dist/adapters/express.d.ts

@@ -0,0 +1,2 @@
+import type { Adapter } from "./types.js";
+export declare const expressAdapter: Adapter;

package/dist/adapters/express.js

@@ -0,0 +1,58 @@
+import fs from "fs/promises";
+import path from "path";
+export const expressAdapter = {
+    name: "express",
+    async detect(dir) {
+        try {
+            const pkg = await fs.readFile(path.join(dir, "package.json"), "utf-8");
+            const parsed = JSON.parse(pkg);
+            const deps = { ...parsed.dependencies, ...parsed.devDependencies };
+            return ("express" in deps ||
+                "fastify" in deps ||
+                "koa" in deps ||
+                "hono" in deps);
+        }
+        catch {
+            return false;
+        }
+    },
+    async analyze(dir, files) {
+        const sections = new Map();
+        const folderMappings = {
+            Routes: ["routes", "routers", "api"],
+            Controllers: ["controllers", "handlers"],
+            Services: ["services"],
+            Models: ["models", "entities", "schemas"],
+            Middleware: ["middleware", "middlewares"],
+            Utils: ["utils", "helpers", "lib"],
+            Config: ["config", "configs"],
+        };
+        for (const file of files) {
+            const relativePath = path.relative(dir, file.filePath);
+            const parts = relativePath.split(path.sep);
+            let matched = false;
+            for (const [sectionName, folders] of Object.entries(folderMappings)) {
+                const folderIndex = parts.findIndex((p) => folders.includes(p.toLowerCase()));
+                if (folderIndex !== -1) {
+                    if (!sections.has(sectionName)) {
+                        sections.set(sectionName, []);
+                    }
+                    sections.get(sectionName).push(file);
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                const folder = parts.length > 1 ? parts[0] : "_root";
+                if (!sections.has(folder)) {
+                    sections.set(folder, []);
+                }
+                sections.get(folder).push(file);
+            }
+        }
+        return {
+            projectType: "Express/Fastify",
+            sections,
+        };
+    },
+};

package/dist/adapters/index.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectType } from "../detectors/index.js";
+import type { Adapter } from "./types.js";
+export declare function getAdapter(projectType: ProjectType): Adapter;
+export type { Adapter, AdapterContext } from "./types.js";

package/dist/adapters/index.js

@@ -0,0 +1,16 @@
+import { expressAdapter } from "./express.js";
+import { nextjsAdapter } from "./nextjs.js";
+import { vanillaAdapter } from "./vanilla.js";
+const adapters = {
+    nextjs: nextjsAdapter,
+    react: vanillaAdapter,
+    express: expressAdapter,
+    nestjs: expressAdapter, // Similar structure
+    vue: vanillaAdapter,
+    sveltekit: vanillaAdapter,
+    node: vanillaAdapter,
+    vanilla: vanillaAdapter,
+};
+export function getAdapter(projectType) {
+    return adapters[projectType] || vanillaAdapter;
+}

package/dist/adapters/nextjs.d.ts

@@ -0,0 +1,2 @@
+import type { Adapter } from "./types.js";
+export declare const nextjsAdapter: Adapter;

package/dist/adapters/nextjs.js

@@ -0,0 +1,102 @@
+import fs from "fs/promises";
+import path from "path";
+import { getRoutes } from "../scanner.js";
+export const nextjsAdapter = {
+    name: "nextjs",
+    async detect(dir) {
+        const configFiles = ["next.config.js", "next.config.mjs", "next.config.ts"];
+        for (const file of configFiles) {
+            try {
+                await fs.access(path.join(dir, file));
+                return true;
+            }
+            catch {
+                continue;
+            }
+        }
+        // Check package.json for next dependency
+        try {
+            const pkg = await fs.readFile(path.join(dir, "package.json"), "utf-8");
+            const parsed = JSON.parse(pkg);
+            const deps = { ...parsed.dependencies, ...parsed.devDependencies };
+            return "next" in deps;
+        }
+        catch {
+            return false;
+        }
+    },
+    async analyze(dir, files) {
+        const sections = new Map();
+        // Get routes
+        let routes = [];
+        const appDir = await findAppDirectory(dir);
+        if (appDir) {
+            routes = await getRoutes(appDir);
+        }
+        // Group by known Next.js folders
+        const folderMappings = {
+            Features: ["features", "modules", "domains"],
+            Components: ["components"],
+            Hooks: ["hooks"],
+            Lib: ["lib", "utils", "helpers", "services"],
+            API: ["api"],
+        };
+        for (const file of files) {
+            const relativePath = path.relative(dir, file.filePath);
+            const parts = relativePath.split(path.sep);
+            let matched = false;
+            for (const [sectionName, folders] of Object.entries(folderMappings)) {
+                const folderIndex = parts.findIndex((p) => folders.includes(p));
+                if (folderIndex !== -1) {
+                    const subParts = parts.slice(folderIndex + 1);
+                    if (subParts.length >= 1) {
+                        // Use subfolder name if exists, otherwise use section name
+                        const subFolder = subParts.length > 1 ? subParts[0] : "_direct";
+                        const key = subFolder === "_direct"
+                            ? sectionName
+                            : `${sectionName}/${subParts[0]}`;
+                        if (!sections.has(key)) {
+                            sections.set(key, []);
+                        }
+                        sections.get(key).push(file);
+                        matched = true;
+                        break;
+                    }
+                }
+            }
+            // If no match, group by top folder
+            if (!matched) {
+                const folder = parts.length > 1 ? parts[0] : "_root";
+                const key = `Other/${folder}`;
+                if (!sections.has(key)) {
+                    sections.set(key, []);
+                }
+                sections.get(key).push(file);
+            }
+        }
+        return {
+            projectType: "Next.js",
+            sections,
+            routes,
+        };
+    },
+};
+async function findAppDirectory(basePath) {
+    const possiblePaths = [
+        path.join(basePath, "app"),
+        path.join(basePath, "src", "app"),
+        path.join(basePath, "src/app"),
+    ];
+    for (const p of possiblePaths) {
+        try {
+            const stat = await fs.stat(p);
+            if (stat.isDirectory()) {
+                return p;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}

package/dist/adapters/types.d.ts

@@ -0,0 +1,11 @@
+import type { FileExports } from "../types.js";
+export interface AdapterContext {
+    projectType: string;
+    sections: Map<string, FileExports[]>;
+    routes?: string[];
+}
+export interface Adapter {
+    name: string;
+    detect: (dir: string) => Promise<boolean>;
+    analyze: (dir: string, files: FileExports[]) => Promise<AdapterContext>;
+}

package/dist/adapters/types.js

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

package/dist/adapters/vanilla.d.ts

@@ -0,0 +1,2 @@
+import type { Adapter } from "./types.js";
+export declare const vanillaAdapter: Adapter;

package/dist/adapters/vanilla.js

@@ -0,0 +1,24 @@
+import path from "path";
+export const vanillaAdapter = {
+    name: "vanilla",
+    async detect() {
+        // Always returns true - this is the fallback
+        return true;
+    },
+    async analyze(dir, files) {
+        const sections = new Map();
+        for (const file of files) {
+            const relativePath = path.relative(dir, file.filePath);
+            const parts = relativePath.split(path.sep);
+            const folder = parts.length > 1 ? parts[0] : "_root";
+            if (!sections.has(folder)) {
+                sections.set(folder, []);
+            }
+            sections.get(folder).push(file);
+        }
+        return {
+            projectType: "JavaScript/TypeScript",
+            sections,
+        };
+    },
+};

package/dist/cli.js

@@ -2,19 +2,27 @@
 import { program } from "commander";
 import path from "path";
 import fs from "fs/promises";
-import { scanDirectory, getRoutes } from "./scanner.js";
+import { scanDirectory } from "./scanner.js";
 import { parseFile } from "./parser.js";
-import { formatMarkdown } from "./formatters/index.js";
+import { detectProject, getProjectLabel } from "./detectors/index.js";
+import { getAdapter } from "./adapters/index.js";
+import { formatMarkdown } from "./formatters/markdown.js";
+import { formatAI } from "./formatters/ai.js";
 program
     .name("ctx")
     .description("Generate AI-ready context from your codebase")
-    .version("0.1.0")
-    .argument("[path]", "Path to scan", "./src")
+    .version("0.1.5")
+    .argument("[path]", "Path to scan", ".")
     .option("-o, --output <format>", "Output format: md, json", "md")
     .option("--ai", "Output in AI-optimized compact format")
     .action(async (targetPath, options) => {
     const absolutePath = path.resolve(process.cwd(), targetPath);
-    console.log(`\n📁 Scanning ${absolutePath}...\n`);
+    // Find project root and detect type
+    const projectRoot = await findProjectRoot(absolutePath);
+    const projectType = await detectProject(projectRoot);
+    const adapter = getAdapter(projectType);
+    console.log(`\n📁 Scanning ${absolutePath}...`);
+    console.log(`📦 Detected: ${getProjectLabel(projectType)}\n`);
     try {
         // Scan all files
         const files = await scanDirectory(absolutePath);
@@ -24,30 +32,17 @@ program
         }
         // Parse all files
         const parsedFiles = await Promise.all(files.map((file) => parseFile(file)));
-        // Get routes - try to find app directory
-        let routes = [];
-        const appDir = await findAppDirectory(absolutePath);
-        if (appDir) {
-            routes = await getRoutes(appDir);
-        }
-        // Build context
-        const context = {
-            routes,
-            features: groupByFolder(parsedFiles, absolutePath, "features"),
-            hooks: getHooks(parsedFiles),
-            lib: groupByFolder(parsedFiles, absolutePath, "lib"),
-            components: groupByFolder(parsedFiles, absolutePath, "components"),
-        };
+        // Use adapter to analyze
+        const context = await adapter.analyze(absolutePath, parsedFiles);
         // Output
-        if (options.ai) {
-            const { formatAI } = await import("./formatters/ai.js");
-            console.log(formatAI(context, absolutePath));
-        }
-        else if (options.output === "json") {
+        if (options.output === "json") {
             console.log(JSON.stringify(contextToJSON(context), null, 2));
         }
+        else if (options.ai) {
+            console.log(formatAI(context));
+        }
         else {
-            console.log(formatMarkdown(context, absolutePath));
+            console.log(formatMarkdown(context));
         }
     }
     catch (error) {
@@ -55,58 +50,24 @@ program
         process.exit(1);
     }
 });
-async function findAppDirectory(basePath) {
-    const possiblePaths = [
-        path.join(basePath, "app"),
-        path.join(basePath, "src", "app"),
-        path.join(basePath, "src/app"),
-    ];
-    for (const p of possiblePaths) {
+async function findProjectRoot(startDir) {
+    let current = startDir;
+    while (current !== path.dirname(current)) {
         try {
-            const stat = await fs.stat(p);
-            if (stat.isDirectory()) {
-                return p;
-            }
+            await fs.access(path.join(current, "package.json"));
+            return current;
         }
         catch {
-            // Path doesn't exist, try next
+            current = path.dirname(current);
         }
     }
-    return null;
-}
-function groupByFolder(files, basePath, folderName) {
-    const grouped = new Map();
-    for (const file of files) {
-        const relativePath = path.relative(basePath, file.filePath);
-        const parts = relativePath.split(path.sep);
-        const folderIndex = parts.indexOf(folderName);
-        if (folderIndex === -1)
-            continue;
-        const remainingParts = parts.slice(folderIndex + 1);
-        // Need at least 2 parts: subfolder + filename
-        if (remainingParts.length < 2)
-            continue;
-        const subFolder = remainingParts[0];
-        if (!grouped.has(subFolder)) {
-            grouped.set(subFolder, []);
-        }
-        grouped.get(subFolder).push(file);
-    }
-    return grouped;
-}
-function getHooks(files) {
-    return files.filter((f) => f.filePath.includes("/hooks/") ||
-        f.filePath.includes("\\hooks\\") ||
-        f.fileName.startsWith("use-") ||
-        f.fileName.startsWith("use."));
+    return startDir;
 }
 function contextToJSON(context) {
     return {
-        routes: context.routes,
-        features: Object.fromEntries(context.features),
-        hooks: context.hooks,
-        lib: Object.fromEntries(context.lib),
-        components: Object.fromEntries(context.components),
+        projectType: context.projectType,
+        routes: context.routes || [],
+        sections: Object.fromEntries(context.sections),
     };
 }
 program.parse();

package/dist/config.js

@@ -4,6 +4,7 @@ export const defaultConfig = {
     ignore: [
         "node_modules",
         ".git",
+        ".directory",
         "dist",
         "build",
         ".next",

package/dist/detectors/index.d.ts

@@ -0,0 +1,3 @@
+export type ProjectType = "nextjs" | "react" | "express" | "nestjs" | "vue" | "sveltekit" | "node" | "vanilla";
+export declare function detectProject(dir: string): Promise<ProjectType>;
+export declare function getProjectLabel(type: ProjectType): string;

package/dist/detectors/index.js

@@ -0,0 +1,73 @@
+import fs from "fs/promises";
+import path from "path";
+async function readPackageJson(dir) {
+    try {
+        const content = await fs.readFile(path.join(dir, "package.json"), "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function detectProject(dir) {
+    const pkg = await readPackageJson(dir);
+    const deps = {
+        ...pkg?.dependencies,
+        ...pkg?.devDependencies,
+    };
+    // Check config files first (more specific)
+    const hasNextConfig = (await fileExists(path.join(dir, "next.config.js"))) ||
+        (await fileExists(path.join(dir, "next.config.mjs"))) ||
+        (await fileExists(path.join(dir, "next.config.ts")));
+    if (hasNextConfig || deps["next"]) {
+        return "nextjs";
+    }
+    // NestJS
+    if (deps["@nestjs/core"]) {
+        return "nestjs";
+    }
+    // SvelteKit
+    if (deps["@sveltejs/kit"]) {
+        return "sveltekit";
+    }
+    // Vue
+    if (deps["vue"] || deps["nuxt"]) {
+        return "vue";
+    }
+    // Express
+    if (deps["express"] || deps["fastify"] || deps["koa"] || deps["hono"]) {
+        return "express";
+    }
+    // React (without Next.js)
+    if (deps["react"] && !deps["next"]) {
+        return "react";
+    }
+    // Node.js project (has package.json but no framework)
+    if (pkg) {
+        return "node";
+    }
+    // No package.json
+    return "vanilla";
+}
+export function getProjectLabel(type) {
+    const labels = {
+        nextjs: "Next.js",
+        react: "React",
+        express: "Express/Fastify",
+        nestjs: "NestJS",
+        vue: "Vue/Nuxt",
+        sveltekit: "SvelteKit",
+        node: "Node.js",
+        vanilla: "JavaScript/TypeScript",
+    };
+    return labels[type];
+}

package/dist/formatters/ai.d.ts

@@ -1,2 +1,2 @@
-import type { ProjectContext } from "../types.js";
-export declare function formatAI(data: ProjectContext, basePath: string): string;
+import type { AdapterContext } from "../adapters/types.js";
+export declare function formatAI(data: AdapterContext): string;

package/dist/formatters/ai.js

@@ -1,57 +1,24 @@
-export function formatAI(data, basePath) {
+export function formatAI(data) {
     const lines = [];
-    lines.push("# Project Context");
-    lines.push("");
-    lines.push("Use this to understand the codebase structure.");
+    lines.push(`# ${data.projectType} Project Context`);
     lines.push("");
     // Routes
-    if (data.routes.length > 0) {
+    if (data.routes && data.routes.length > 0) {
         lines.push("## Routes");
         lines.push("");
         for (const route of data.routes) {
-            const depth = route.search(/\S/); // Count leading spaces
-            const name = route.trim();
-            const prefix = depth > 0 ? "  ".repeat(depth / 2) + "└─ " : "- ";
-            lines.push(`${prefix}${name}`);
+            lines.push(`- ${route}`);
         }
         lines.push("");
     }
-    // Features
-    if (data.features.size > 0) {
-        lines.push("## Features");
-        lines.push("");
-        lines.push(formatFolderCompact(data.features));
-    }
-    // Components
-    if (data.components.size > 0) {
-        lines.push("## Components");
-        lines.push("");
-        lines.push(formatFolderCompact(data.components));
-    }
-    // Hooks
-    if (data.hooks.length > 0) {
-        lines.push("## Hooks");
+    // Sections
+    for (const [sectionName, files] of data.sections) {
+        if (sectionName === "_root")
+            continue;
+        if (files.length === 0)
+            continue;
+        lines.push(`## ${sectionName}`);
         lines.push("");
-        for (const hook of data.hooks) {
-            const exports = getExportsSummary(hook);
-            if (exports) {
-                lines.push(`- ${hook.fileName}: ${exports}`);
-            }
-        }
-        lines.push("");
-    }
-    // Lib
-    if (data.lib.size > 0) {
-        lines.push("## Lib / Utils");
-        lines.push("");
-        lines.push(formatFolderCompact(data.lib));
-    }
-    return lines.join("\n");
-}
-function formatFolderCompact(folders) {
-    const lines = [];
-    for (const [folderName, files] of folders) {
-        lines.push(`### ${folderName}`);
         for (const file of files) {
             const exports = getExportsSummary(file);
             if (exports) {
@@ -65,19 +32,16 @@ function formatFolderCompact(folders) {
 function getExportsSummary(file) {
     const parts = [];
     if (file.functions.length > 0) {
-        const fns = file.functions.map((f) => `${f}()`).join(", ");
-        parts.push(fns);
+        parts.push(file.functions.map((f) => `${f}()`).join(", "));
     }
     if (file.constants.length > 0) {
         parts.push(file.constants.join(", "));
     }
     if (file.types.length > 0) {
-        const types = file.types.map((t) => `type ${t}`).join(", ");
-        parts.push(types);
+        parts.push(file.types.map((t) => `type ${t}`).join(", "));
     }
     if (file.interfaces.length > 0) {
-        const ifaces = file.interfaces.map((i) => `interface ${i}`).join(", ");
-        parts.push(ifaces);
+        parts.push(file.interfaces.map((i) => `interface ${i}`).join(", "));
     }
     return parts.join(" | ");
 }

package/dist/formatters/markdown.d.ts

@@ -1,2 +1,2 @@
-import type { ProjectContext } from "../types.js";
-export declare function formatMarkdown(data: ProjectContext, basePath: string): string;
+import type { AdapterContext } from "../adapters/types.js";
+export declare function formatMarkdown(data: AdapterContext): string;

package/dist/formatters/markdown.js

@@ -1,51 +1,55 @@
-export function formatMarkdown(data, basePath) {
+export function formatMarkdown(data) {
     let output = "";
-    // Routes section
-    if (data.routes.length > 0) {
-        output += `=== ROUTES (src/app) ===\n\n`;
+    // Project type header
+    output += `📦 Project: ${data.projectType}\n\n`;
+    // Routes section (if exists)
+    if (data.routes && data.routes.length > 0) {
+        output += `=== ROUTES ===\n\n`;
         for (const route of data.routes) {
             output += `${route}\n`;
         }
         output += "\n";
     }
-    // Features section
-    if (data.features.size > 0) {
-        output += `=== FEATURES ===\n\n`;
-        output += formatFolderGroup(data.features);
-    }
-    // Components section
-    if (data.components.size > 0) {
-        output += `=== COMPONENTS ===\n\n`;
-        output += formatFolderGroup(data.components);
-    }
-    // Hooks section
-    if (data.hooks.length > 0) {
-        output += `=== HOOKS ===\n\n`;
-        for (const file of data.hooks) {
-            output += formatSingleFile(file);
+    // All sections
+    for (const [sectionName, files] of data.sections) {
+        if (sectionName === "_root")
+            continue;
+        if (files.length === 0)
+            continue;
+        // Check if any file has exports
+        const hasExports = files.some((f) => f.functions.length > 0 ||
+            f.constants.length > 0 ||
+            f.types.length > 0 ||
+            f.interfaces.length > 0 ||
+            f.classes.length > 0);
+        if (!hasExports)
+            continue;
+        output += `=== ${sectionName.toUpperCase()} ===\n\n`;
+        for (const file of files) {
+            output += formatFile(file);
         }
         output += "\n";
     }
-    // Lib section
-    if (data.lib.size > 0) {
-        output += `=== LIB ===\n\n`;
-        output += formatFolderGroup(data.lib);
-    }
-    output += `=== DONE ===\n`;
-    return output;
-}
-function formatFolderGroup(folders) {
-    let output = "";
-    for (const [folderName, files] of folders) {
-        output += `${folderName}/\n`;
-        for (const file of files) {
-            output += formatSingleFile(file);
+    // Root files last
+    const rootFiles = data.sections.get("_root");
+    if (rootFiles && rootFiles.length > 0) {
+        const hasRootExports = rootFiles.some((f) => f.functions.length > 0 ||
+            f.constants.length > 0 ||
+            f.types.length > 0 ||
+            f.interfaces.length > 0 ||
+            f.classes.length > 0);
+        if (hasRootExports) {
+            output += `=== ROOT FILES ===\n\n`;
+            for (const file of rootFiles) {
+                output += formatFile(file);
+            }
+            output += "\n";
         }
-        output += "\n";
     }
+    output += `=== DONE ===\n`;
     return output;
 }
-function formatSingleFile(file) {
+function formatFile(file) {
     const hasExports = file.functions.length > 0 ||
         file.constants.length > 0 ||
         file.types.length > 0 ||

package/dist/parser.js

@@ -6,22 +6,27 @@ export async function parseFile(filePath) {
     return {
         filePath,
         fileName,
-        functions: extractFunctions(content),
-        constants: extractConstants(content),
+        functions: [
+            ...extractFunctions(content),
+            ...extractCommonJSFunctions(content),
+        ],
+        constants: [
+            ...extractConstants(content),
+            ...extractCommonJSConstants(content),
+        ],
         types: extractTypes(content),
         interfaces: extractInterfaces(content),
-        classes: extractClasses(content),
+        classes: [...extractClasses(content), ...extractMongooseModels(content)],
         defaultExport: extractDefaultExport(content),
     };
 }
+// ESM Exports
 function extractFunctions(content) {
     const functions = [];
-    // export function name
     const funcMatches = content.matchAll(/export\s+(?:async\s+)?function\s+(\w+)/g);
     for (const match of funcMatches) {
         functions.push(match[1]);
     }
-    // export const name = async? (...) => or function(
     const arrowMatches = content.matchAll(/export\s+const\s+(\w+)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*(?:=>|\{)/g);
     for (const match of arrowMatches) {
         if (!functions.includes(match[1])) {
@@ -32,15 +37,12 @@ function extractFunctions(content) {
 }
 function extractConstants(content) {
     const constants = [];
-    // Match export const that are NOT functions
     const lines = content.split("\n");
     for (const line of lines) {
-        // export const NAME = value (not a function)
         const match = line.match(/export\s+const\s+(\w+)\s*=\s*(?!(?:async\s*)?(?:\(|function|\w+\s*=>))/);
         if (match) {
             constants.push(match[1]);
         }
-        // Also catch: export const NAME: Type =
         const typedMatch = line.match(/export\s+const\s+(\w+)\s*:\s*[^=]+=\s*(?!(?:async\s*)?(?:\(|function|\w+\s*=>))/);
         if (typedMatch && !constants.includes(typedMatch[1])) {
             constants.push(typedMatch[1]);
@@ -61,13 +63,68 @@ function extractClasses(content) {
     return [...matches].map((m) => m[1]);
 }
 function extractDefaultExport(content) {
-    // export default function Name
     const funcMatch = content.match(/export\s+default\s+function\s+(\w+)/);
     if (funcMatch)
         return funcMatch[1];
-    // export default Name
     const simpleMatch = content.match(/export\s+default\s+(\w+)/);
     if (simpleMatch)
         return simpleMatch[1];
     return undefined;
 }
+// CommonJS Exports
+function extractCommonJSFunctions(content) {
+    const functions = [];
+    // exports.functionName = async (req, res) => { }
+    const exportsMatches = content.matchAll(/exports\.(\w+)\s*=\s*(?:async\s*)?(?:function|\(|async\s*\()/g);
+    for (const match of exportsMatches) {
+        if (!functions.includes(match[1])) {
+            functions.push(match[1]);
+        }
+    }
+    // module.exports.functionName = async (req, res) => { }
+    const moduleExportsMatches = content.matchAll(/module\.exports\.(\w+)\s*=\s*(?:async\s*)?(?:function|\(|async\s*\()/g);
+    for (const match of moduleExportsMatches) {
+        if (!functions.includes(match[1])) {
+            functions.push(match[1]);
+        }
+    }
+    // module.exports = { functionName, anotherFunction }
+    const objectExportMatch = content.match(/module\.exports\s*=\s*\{([^}]+)\}/);
+    if (objectExportMatch) {
+        const names = objectExportMatch[1]
+            .split(",")
+            .map((s) => s.trim().split(":")[0].trim());
+        for (const name of names) {
+            if (name && /^\w+$/.test(name) && !functions.includes(name)) {
+                functions.push(name);
+            }
+        }
+    }
+    return functions;
+}
+function extractCommonJSConstants(content) {
+    const constants = [];
+    // exports.CONSTANT_NAME = "value" or = { } (not functions)
+    const lines = content.split("\n");
+    for (const line of lines) {
+        // exports.NAME = "value" or number or object (not function)
+        const match = line.match(/exports\.(\w+)\s*=\s*(?!(?:async\s*)?(?:function|\(|async\s*\())/);
+        if (match) {
+            // Check it's likely a constant (UPPER_CASE or starts with config/options)
+            const name = match[1];
+            if (/^[A-Z_]+$/.test(name) || /^(config|options|settings)/i.test(name)) {
+                constants.push(name);
+            }
+        }
+    }
+    return constants;
+}
+function extractMongooseModels(content) {
+    const models = [];
+    // mongoose.model('ModelName', schema)
+    const matches = content.matchAll(/mongoose\.model\s*\(\s*['"](\w+)['"]/g);
+    for (const match of matches) {
+        models.push(match[1]);
+    }
+    return models;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eloquence98/ctx",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Generate AI-ready context from your codebase. One command, zero config.",
   "type": "module",
   "bin": {