@eloquence98/ctx 0.1.4 → 0.1.6

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

@@ -1,58 +1,53 @@
 #!/usr/bin/env node
 import { program } from "commander";
-import path from "path";
 import fs from "fs/promises";
-import { scanDirectory, getRoutes } from "./scanner.js";
-import { parseFile } from "./parser.js";
-import { formatMarkdown } from "./formatters/index.js";
+import path from "path";
+import { getAdapter } from "./adapters/index.js";
 import { detectProject, getProjectLabel } from "./detectors/index.js";
+import { formatAIOptimized } from "./formatters/ai-optimized.js";
+import { formatHuman } from "./formatters/human.js";
+import { formatRaw } from "./formatters/raw.js";
+import { parseFile } from "./parser.js";
+import { scanDirectory } from "./scanner.js";
 program
     .name("ctx")
     .description("Generate AI-ready context from your codebase")
-    .version("0.1.4")
-    .argument("[path]", "Path to scan", "./src")
-    .option("-o, --output <format>", "Output format: md, json", "md")
-    .option("--ai", "Output in AI-optimized compact format")
+    .version("0.1.6")
+    .argument("[path]", "Path to scan", ".")
+    .option("--human", "Human-readable output for onboarding")
+    .option("--raw", "Verbose output with all details")
+    .option("-o, --output <format>", "Output format: json", "")
     .action(async (targetPath, options) => {
     const absolutePath = path.resolve(process.cwd(), targetPath);
-    // Detect project type
     const projectRoot = await findProjectRoot(absolutePath);
     const projectType = await detectProject(projectRoot);
-    console.log(`\n📁 Scanning ${absolutePath}...\n`);
-    console.log(`📦 Detected: ${getProjectLabel(projectType)}\n`);
+    const adapter = getAdapter(projectType);
+    // Only show scanning message for human/raw modes
+    if (options.human || options.raw) {
+        console.log(`\n📁 Scanning ${absolutePath}...`);
+        console.log(`📦 Detected: ${getProjectLabel(projectType)}\n`);
+    }
     try {
-        // Scan all files
         const files = await scanDirectory(absolutePath);
         if (files.length === 0) {
             console.log("No files found. Check your path.");
             process.exit(1);
         }
-        // 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);
+        const context = await adapter.analyze(absolutePath, parsedFiles);
+        // Output based on flags
+        if (options.output === "json") {
+            console.log(JSON.stringify(contextToJSON(context), null, 2));
         }
-        // Build context
-        const context = {
-            routes,
-            features: groupByFolder(parsedFiles, absolutePath, "features"),
-            hooks: getHooks(parsedFiles),
-            lib: groupByFolder(parsedFiles, absolutePath, "lib"),
-            components: groupByFolder(parsedFiles, absolutePath, "components"),
-        };
-        // Output
-        if (options.ai) {
-            const { formatAI } = await import("./formatters/ai.js");
-            console.log(formatAI(context, absolutePath));
+        else if (options.raw) {
+            console.log(formatRaw(context));
         }
-        else if (options.output === "json") {
-            console.log(JSON.stringify(contextToJSON(context), null, 2));
+        else if (options.human) {
+            console.log(formatHuman(context));
         }
         else {
-            console.log(formatMarkdown(context, absolutePath));
+            // Default: AI-optimized
+            console.log(formatAIOptimized(context));
         }
     }
     catch (error) {
@@ -73,58 +68,11 @@ async function findProjectRoot(startDir) {
     }
     return startDir;
 }
-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 {
-            // try next
-        }
-    }
-    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."));
-}
 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/formatters/ai-optimized.d.ts

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

package/dist/formatters/ai-optimized.js

@@ -0,0 +1,215 @@
+export function formatAIOptimized(data) {
+    const lines = [];
+    lines.push(`# Project Context (${data.projectType})`);
+    lines.push("");
+    // 1. Routes
+    if (data.routes && data.routes.length > 0) {
+        const routeGroups = parseRouteGroups(data.routes);
+        // Filter out empty shell routes
+        const filteredGroups = new Map();
+        for (const [key, value] of routeGroups) {
+            if (value.length > 0) {
+                filteredGroups.set(key, value);
+            }
+        }
+        lines.push(`## Routes (${filteredGroups.size})`);
+        for (const [group, paths] of filteredGroups) {
+            // Max 4 routes, no "+N more"
+            const displayPaths = paths.slice(0, 4);
+            lines.push(`/${group} → ${displayPaths.join(", ")}`);
+        }
+        lines.push("");
+    }
+    // 2. Core Domains
+    const features = getSectionsByPattern(data.sections, "features");
+    if (features.size > 0) {
+        lines.push(`## Core Domains (${features.size})`);
+        for (const [name, files] of features) {
+            lines.push(formatDomainLine(name, files));
+        }
+        lines.push("");
+    }
+    // 3. Auth & Session
+    const authFiles = getAuthFiles(data.sections);
+    if (authFiles.length > 0) {
+        lines.push("## Auth & Session");
+        lines.push("sign-in, session handling, token management");
+        lines.push("");
+    }
+    // 4. Shared Lib
+    const lib = getSectionsByPattern(data.sections, "lib");
+    if (lib.size > 0 || data.sections.has("LIB") || data.sections.has("Lib")) {
+        lines.push("## Shared Lib");
+        lines.push("utils — formatting, helpers");
+        const config = getSectionsByPattern(data.sections, "config");
+        if (config.size > 0) {
+            lines.push("config — api, uploads, pricing");
+        }
+        lines.push("");
+    }
+    // 5. Hooks
+    const hooks = data.sections.get("HOOKS") || data.sections.get("Hooks");
+    if (hooks && hooks.length > 0) {
+        const hookNames = hooks
+            .flatMap((f) => f.functions)
+            .filter((n) => n.startsWith("use"));
+        lines.push(`## Hooks (${hookNames.length})`);
+        lines.push(hookNames.join(", "));
+        lines.push("");
+    }
+    // 6. UI Layer
+    const components = getSectionsByPattern(data.sections, "components");
+    if (components.size > 0) {
+        const totalComponents = countTotalFiles(components);
+        lines.push("## UI Layer");
+        const folders = [...components.keys()]
+            .map((k) => k.split("/").pop()?.toLowerCase())
+            .filter(Boolean);
+        const uniqueFolders = [...new Set(folders)];
+        lines.push(`~${totalComponents} components (${uniqueFolders.join(", ")})`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+// === Route Parsing ===
+function parseRouteGroups(routes) {
+    const groups = new Map();
+    let currentTopLevel = "";
+    let currentDynamic = "";
+    for (const route of routes) {
+        const trimmed = route.trim();
+        // Skip group markers like (auth), (website)
+        if (trimmed.startsWith("(") && trimmed.endsWith(")")) {
+            continue;
+        }
+        // Calculate depth by counting leading spaces
+        const depth = route.search(/\S/);
+        // Top-level route
+        if (depth === 0) {
+            currentTopLevel = trimmed;
+            currentDynamic = "";
+            if (!groups.has(currentTopLevel)) {
+                groups.set(currentTopLevel, []);
+            }
+        }
+        // First-level dynamic segment like [slug]
+        else if (depth === 2 && trimmed.startsWith("[") && trimmed.endsWith("]")) {
+            currentDynamic = trimmed;
+            const dynamicKey = `${currentTopLevel}/${currentDynamic}`;
+            if (!groups.has(dynamicKey)) {
+                groups.set(dynamicKey, []);
+            }
+        }
+        // Child routes
+        else if (depth >= 2) {
+            // Skip dynamic segments and technical routes
+            if (isSkippableRoute(trimmed)) {
+                continue;
+            }
+            // Add to dynamic group if exists, otherwise to top level
+            if (currentDynamic && depth > 2) {
+                const dynamicKey = `${currentTopLevel}/${currentDynamic}`;
+                const children = groups.get(dynamicKey);
+                if (children && !children.includes(trimmed)) {
+                    children.push(trimmed);
+                }
+            }
+            else if (currentTopLevel) {
+                const children = groups.get(currentTopLevel);
+                if (children && !children.includes(trimmed)) {
+                    children.push(trimmed);
+                }
+            }
+        }
+    }
+    // Clean up empty groups and dynamic groups with no children
+    const cleaned = new Map();
+    for (const [key, value] of groups) {
+        // Keep if has children OR is a standalone route
+        if (value.length > 0 || !key.includes("/")) {
+            cleaned.set(key, value);
+        }
+    }
+    return cleaned;
+}
+function isSkippableRoute(route) {
+    const skipPatterns = [
+        "[",
+        "]",
+        "error",
+        "sync",
+        "verify-email",
+        "success",
+        "...nextauth",
+    ];
+    const lower = route.toLowerCase();
+    return skipPatterns.some((p) => lower.includes(p));
+}
+// === Section Helpers ===
+function getSectionsByPattern(sections, pattern) {
+    const result = new Map();
+    for (const [key, value] of sections) {
+        if (key.toLowerCase().includes(pattern.toLowerCase())) {
+            result.set(key, value);
+        }
+    }
+    return result;
+}
+function getAuthFiles(sections) {
+    for (const [key, value] of sections) {
+        if (key.toLowerCase().includes("auth")) {
+            return value;
+        }
+    }
+    return [];
+}
+function countTotalFiles(sections) {
+    let count = 0;
+    for (const files of sections.values()) {
+        count += files.length;
+    }
+    return count;
+}
+// === Domain Formatting ===
+function formatDomainLine(name, files) {
+    const cleanName = name
+        .replace(/features\//i, "")
+        .replace(/FEATURES\//i, "")
+        .toLowerCase();
+    const actionFiles = files.filter((f) => f.fileName.includes("action") || f.fileName.includes("actions"));
+    const actionCount = actionFiles.reduce((sum, f) => sum + f.functions.length, 0);
+    const intent = getIntent(cleanName, files);
+    return `${cleanName} — ${intent} (${actionCount} actions)`;
+}
+function getIntent(domain, files) {
+    const allFunctions = files
+        .flatMap((f) => f.functions)
+        .join(" ")
+        .toLowerCase();
+    // Domain-specific intent mapping
+    if (domain === "users") {
+        return "authenticate, edit profile, manage credentials";
+    }
+    if (domain === "orders") {
+        return "create/edit/cancel";
+    }
+    if (domain === "estimates") {
+        return "create/edit/convert";
+    }
+    if (domain === "files") {
+        return "upload/download";
+    }
+    // Fallback: derive from function names
+    const intents = [];
+    if (allFunctions.includes("create"))
+        intents.push("create");
+    if (allFunctions.includes("edit") || allFunctions.includes("update")) {
+        intents.push("edit");
+    }
+    if (allFunctions.includes("delete") || allFunctions.includes("cancel")) {
+        intents.push("cancel");
+    }
+    if (intents.length === 0)
+        return "manage";
+    return intents.slice(0, 3).join("/");
+}

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/human.d.ts

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

package/dist/formatters/human.js

@@ -0,0 +1,200 @@
+export function formatHuman(data) {
+    const lines = [];
+    lines.push(`📁 Project: ${data.projectType} App`);
+    lines.push("");
+    // Routes - ordered: client, admin, api
+    if (data.routes && data.routes.length > 0) {
+        lines.push("┌─ Routes ─────────────────────────");
+        lines.push("│");
+        const routeGroups = parseRouteGroups(data.routes);
+        const orderedGroups = sortRouteGroups(routeGroups);
+        // Filter out empty groups
+        const filteredGroups = new Map();
+        for (const [key, value] of orderedGroups) {
+            if (value.length > 0) {
+                filteredGroups.set(key, value);
+            }
+        }
+        const groupKeys = [...filteredGroups.keys()];
+        for (let i = 0; i < groupKeys.length; i++) {
+            const group = groupKeys[i];
+            const children = filteredGroups.get(group) || [];
+            const isLast = i === groupKeys.length - 1;
+            const prefix = isLast ? "└──" : "├──";
+            const childPrefix = isLast ? "    " : "│   ";
+            const icon = getRouteIcon(group);
+            const displayGroup = group.split("/")[0];
+            lines.push(`${prefix} ${icon} ${capitalizeFirst(displayGroup)}`);
+            // Consolidate dynamic segments
+            const consolidatedChildren = consolidateRoutes(children);
+            // Show max 5 children
+            const visibleChildren = consolidatedChildren.slice(0, 5);
+            for (const child of visibleChildren) {
+                lines.push(`${childPrefix}/${child}`);
+            }
+            // Remaining as "(other X pages)"
+            if (consolidatedChildren.length > 5) {
+                const remaining = consolidatedChildren.length - 5;
+                const groupName = group.split("/")[0];
+                lines.push(`${childPrefix}(${remaining} more ${groupName} pages)`);
+            }
+        }
+        lines.push("");
+    }
+    // Domains
+    const features = getSectionsByPattern(data.sections, "features");
+    if (features.size > 0) {
+        lines.push("┌─ Domains ────────────────────────");
+        lines.push("│");
+        const featureNames = [...features.keys()];
+        for (let i = 0; i < featureNames.length; i++) {
+            const name = featureNames[i];
+            const cleanName = name.replace(/features\//i, "").toLowerCase();
+            const icon = getDomainIcon(cleanName);
+            const isLast = i === featureNames.length - 1;
+            const prefix = isLast ? "└──" : "├──";
+            lines.push(`${prefix} ${icon} features/${cleanName}`);
+        }
+        lines.push("");
+    }
+    // Infrastructure
+    lines.push("┌─ Infrastructure ─────────────────");
+    lines.push("│");
+    lines.push("├── auth / session");
+    lines.push("├── shared utils");
+    lines.push("└── ui components");
+    lines.push("");
+    return lines.join("\n");
+}
+// === Route Parsing ===
+function parseRouteGroups(routes) {
+    const groups = new Map();
+    let currentTopLevel = "";
+    let currentDynamic = "";
+    for (const route of routes) {
+        const trimmed = route.trim();
+        if (trimmed.startsWith("(") && trimmed.endsWith(")")) {
+            continue;
+        }
+        const depth = route.search(/\S/);
+        if (depth === 0) {
+            currentTopLevel = trimmed;
+            currentDynamic = "";
+            if (!groups.has(currentTopLevel)) {
+                groups.set(currentTopLevel, []);
+            }
+        }
+        else if (depth === 2 && trimmed.startsWith("[")) {
+            // Dynamic segment at first level - create combined key
+            currentDynamic = trimmed;
+            const dynamicKey = `${currentTopLevel}/${currentDynamic}`;
+            if (!groups.has(dynamicKey)) {
+                groups.set(dynamicKey, []);
+            }
+        }
+        else if (currentTopLevel) {
+            if (!isSkippableRoute(trimmed)) {
+                // Add to dynamic group if exists
+                if (currentDynamic && depth > 2) {
+                    const dynamicKey = `${currentTopLevel}/${currentDynamic}`;
+                    const children = groups.get(dynamicKey);
+                    if (children && !children.includes(trimmed)) {
+                        children.push(trimmed);
+                    }
+                }
+                else {
+                    const children = groups.get(currentTopLevel);
+                    if (children && !children.includes(trimmed)) {
+                        children.push(trimmed);
+                    }
+                }
+            }
+        }
+    }
+    return groups;
+}
+function isSkippableRoute(route) {
+    const skip = ["error", "sync", "verify-email", "success", "...nextauth"];
+    const lower = route.toLowerCase();
+    return skip.some((p) => lower.includes(p));
+}
+function sortRouteGroups(groups) {
+    const sorted = new Map();
+    const order = ["client", "admin", "api"];
+    for (const key of order) {
+        for (const [group, children] of groups) {
+            if (group.toLowerCase().includes(key)) {
+                sorted.set(group, children);
+            }
+        }
+    }
+    for (const [group, children] of groups) {
+        if (!sorted.has(group)) {
+            sorted.set(group, children);
+        }
+    }
+    return sorted;
+}
+function consolidateRoutes(routes) {
+    const consolidated = [];
+    const seen = new Set();
+    for (const route of routes) {
+        // Skip dynamic segments
+        if (route.startsWith("[") && route.endsWith("]")) {
+            continue;
+        }
+        const baseName = route.toLowerCase();
+        if (!seen.has(baseName)) {
+            seen.add(baseName);
+            // Check if there's a dynamic child
+            const hasDynamic = routes.some((r) => r.startsWith("[") && r.toLowerCase().includes(baseName.slice(0, -1)));
+            if (hasDynamic) {
+                consolidated.push(`${route} (list, detail)`);
+            }
+            else {
+                consolidated.push(route);
+            }
+        }
+    }
+    return consolidated;
+}
+// === Helpers ===
+function getSectionsByPattern(sections, pattern) {
+    const result = new Map();
+    for (const [key, value] of sections) {
+        if (key.toLowerCase().includes(pattern.toLowerCase())) {
+            result.set(key, value);
+        }
+    }
+    return result;
+}
+function getRouteIcon(group) {
+    const lower = group.toLowerCase();
+    if (lower.includes("client") || lower.includes("user"))
+        return "👤";
+    if (lower.includes("admin"))
+        return "🛠️";
+    if (lower.includes("api"))
+        return "🔌";
+    if (lower.includes("auth") || lower.includes("login"))
+        return "🔐";
+    return "📄";
+}
+function getDomainIcon(name) {
+    if (name.includes("order"))
+        return "📦";
+    if (name.includes("estimate"))
+        return "📋";
+    if (name.includes("file"))
+        return "📁";
+    if (name.includes("user"))
+        return "👤";
+    if (name.includes("auth"))
+        return "🔐";
+    if (name.includes("payment"))
+        return "💳";
+    return "📂";
+}
+function capitalizeFirst(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/dist/formatters/index.d.ts

@@ -1,2 +1,4 @@
 export { formatMarkdown } from "./markdown.js";
-export { formatAI } from "./ai.js";
+export { formatAIOptimized } from "./ai-optimized.js";
+export { formatRaw } from "./raw.js";
+export { formatHuman } from "./human.js";

package/dist/formatters/index.js

@@ -1,2 +1,4 @@
 export { formatMarkdown } from "./markdown.js";
-export { formatAI } from "./ai.js";
+export { formatAIOptimized } from "./ai-optimized.js";
+export { formatRaw } from "./raw.js";
+export { formatHuman } from "./human.js";

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/formatters/raw.d.ts

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

package/dist/formatters/raw.js

@@ -0,0 +1,47 @@
+export function formatRaw(data) {
+    const lines = [];
+    lines.push(`# ${data.projectType} Project Context`);
+    lines.push("");
+    // Routes
+    if (data.routes && data.routes.length > 0) {
+        lines.push("## Routes");
+        lines.push("");
+        for (const route of data.routes) {
+            lines.push(`- ${route}`);
+        }
+        lines.push("");
+    }
+    // Sections
+    for (const [sectionName, files] of data.sections) {
+        if (sectionName === "_root")
+            continue;
+        if (files.length === 0)
+            continue;
+        lines.push(`## ${sectionName}`);
+        lines.push("");
+        for (const file of files) {
+            const exports = getExportsSummary(file);
+            if (exports) {
+                lines.push(`- ${file.fileName}: ${exports}`);
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function getExportsSummary(file) {
+    const parts = [];
+    if (file.functions.length > 0) {
+        parts.push(file.functions.map((f) => `${f}()`).join(", "));
+    }
+    if (file.constants.length > 0) {
+        parts.push(file.constants.join(", "));
+    }
+    if (file.types.length > 0) {
+        parts.push(file.types.map((t) => `type ${t}`).join(", "));
+    }
+    if (file.interfaces.length > 0) {
+        parts.push(file.interfaces.map((i) => `interface ${i}`).join(", "));
+    }
+    return parts.join(" | ");
+}

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.4",
+  "version": "0.1.6",
   "description": "Generate AI-ready context from your codebase. One command, zero config.",
   "type": "module",
   "bin": {