@eloquence98/ctx 0.1.6 → 0.2.0

package/README.md

@@ -1,32 +1,50 @@
 # ctx
 
-Generate AI-ready context from your codebase.
+Scan your codebase. Get a clean summary. Paste it to AI.
 
 ## Usage
 
 ```bash
-npx @eloquence98/ctx ./src
+# Scan current directory
+ctx .
 ```
 
-That's it. Copy the output, paste it to ChatGPT/Claude.
-
-## Options
-
 ```bash
-# AI-optimized compact format
-npx @eloquence98/ctx ./src --ai
+# Scan specific folder
+ctx ./src
 ```
 
 ```bash
-# JSON output
-npx @eloquence98/ctx ./src -o json
+# Human-readable output
+ctx ./src --human
 ```
 
+## Output Example
+
 ```bash
-# Save to file
-npx @eloquence98/ctx ./src > context.md
+# Codebase Context
+
+## Routes
+- /admin
+- /admin/orders
+- /client/[slug]/orders
+
+## Components
+- navbar.tsx: Navbar
+- sidebar.tsx: Sidebar
+
+## Hooks
+- useAuth
+- useFetch
+
+## Utils
+- utils.ts: cn, formatDate
 ```
 
+## That's It
+
+Copy. Paste to ChatGPT/Claude. Done.
+
 ## License
 
 MIT

package/dist/cli.js

@@ -1,78 +1,27 @@
 #!/usr/bin/env node
-import { program } from "commander";
-import fs from "fs/promises";
 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 { scan } from "./scanner.js";
+import { parse } from "./parser.js";
+import { organize } from "./organizer.js";
+import { formatAI } from "./formatters/ai.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.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);
-    const projectRoot = await findProjectRoot(absolutePath);
-    const projectType = await detectProject(projectRoot);
-    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 {
-        const files = await scanDirectory(absolutePath);
-        if (files.length === 0) {
-            console.log("No files found. Check your path.");
-            process.exit(1);
-        }
-        const parsedFiles = await Promise.all(files.map((file) => parseFile(file)));
-        const context = await adapter.analyze(absolutePath, parsedFiles);
-        // Output based on flags
-        if (options.output === "json") {
-            console.log(JSON.stringify(contextToJSON(context), null, 2));
-        }
-        else if (options.raw) {
-            console.log(formatRaw(context));
-        }
-        else if (options.human) {
-            console.log(formatHuman(context));
-        }
-        else {
-            // Default: AI-optimized
-            console.log(formatAIOptimized(context));
-        }
-    }
-    catch (error) {
-        console.error("Error:", error);
+const args = process.argv.slice(2);
+const targetPath = args.find((a) => !a.startsWith("-")) || ".";
+const humanMode = args.includes("--human");
+async function main() {
+    const dir = path.resolve(process.cwd(), targetPath);
+    // 1. Scan
+    const files = await scan(dir);
+    if (files.length === 0) {
+        console.log("No files found.");
         process.exit(1);
     }
-});
-async function findProjectRoot(startDir) {
-    let current = startDir;
-    while (current !== path.dirname(current)) {
-        try {
-            await fs.access(path.join(current, "package.json"));
-            return current;
-        }
-        catch {
-            current = path.dirname(current);
-        }
-    }
-    return startDir;
-}
-function contextToJSON(context) {
-    return {
-        projectType: context.projectType,
-        routes: context.routes || [],
-        sections: Object.fromEntries(context.sections),
-    };
+    // 2. Parse
+    const parsed = await Promise.all(files.map(parse));
+    // 3. Organize
+    const context = await organize(parsed, dir);
+    // 4. Format
+    const output = humanMode ? formatHuman(context) : formatAI(context);
+    console.log(output);
 }
-program.parse();
+main().catch(console.error);

package/dist/formatters/ai.d.ts

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

package/dist/formatters/ai.js

@@ -1,47 +1,51 @@
-export function formatAI(data) {
-    const lines = [];
-    lines.push(`# ${data.projectType} Project Context`);
-    lines.push("");
-    // Routes
-    if (data.routes && data.routes.length > 0) {
-        lines.push("## Routes");
+export function formatAI(ctx) {
+    const lines = ["# Codebase Context", ""];
+    if (ctx.routes.length) {
+        lines.push("## Routes", ...ctx.routes.map((r) => `- ${r}`), "");
+    }
+    if (ctx.components.length) {
+        lines.push("## Components");
+        for (const f of ctx.components) {
+            const exp = f.exports.components.join(", ");
+            if (exp) {
+                lines.push(`- ${f.name}: ${exp}`);
+            }
+        }
         lines.push("");
-        for (const route of data.routes) {
-            lines.push(`- ${route}`);
+    }
+    if (ctx.hooks.length) {
+        lines.push("## Hooks");
+        for (const f of ctx.hooks) {
+            const hookFns = f.exports.functions.filter((fn) => fn.startsWith("use"));
+            if (hookFns.length) {
+                lines.push(`- ${hookFns.join(", ")}`);
+            }
         }
         lines.push("");
     }
-    // Sections
-    for (const [sectionName, files] of data.sections) {
-        if (sectionName === "_root")
-            continue;
-        if (files.length === 0)
-            continue;
-        lines.push(`## ${sectionName}`);
+    if (ctx.utils.length) {
+        lines.push("## Utils");
+        for (const f of ctx.utils) {
+            const exp = [...f.exports.functions, ...f.exports.constants].join(", ");
+            if (exp) {
+                lines.push(`- ${f.name}: ${exp}`);
+            }
+        }
         lines.push("");
-        for (const file of files) {
-            const exports = getExportsSummary(file);
-            if (exports) {
-                lines.push(`- ${file.fileName}: ${exports}`);
+    }
+    if (ctx.other.length) {
+        lines.push("## Other");
+        for (const f of ctx.other) {
+            const exp = [
+                ...f.exports.functions,
+                ...f.exports.constants,
+                ...f.exports.components,
+            ].join(", ");
+            if (exp) {
+                lines.push(`- ${f.name}: ${exp}`);
             }
         }
         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/formatters/human.d.ts

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

package/dist/formatters/human.js

@@ -1,200 +1,53 @@
-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)`);
-            }
+export function formatHuman(ctx) {
+    const lines = [
+        "╭─────────────────────────────────────╮",
+        "│         CODEBASE OVERVIEW           │",
+        "╰─────────────────────────────────────╯",
+        "",
+    ];
+    if (ctx.routes.length) {
+        lines.push("📍 ROUTES", "");
+        for (const r of ctx.routes) {
+            lines.push(`   ${r}`);
         }
         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);
-                    }
+    if (ctx.components.length) {
+        lines.push(`🧩 COMPONENTS (${ctx.components.length} files)`, "");
+        for (const f of ctx.components.slice(0, 10)) {
+            if (f.exports.components.length) {
+                lines.push(`   ${f.name}`);
+                for (const c of f.exports.components.slice(0, 3)) {
+                    lines.push(`      └─ ${c}`);
                 }
             }
         }
-    }
-    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);
+        if (ctx.components.length > 10) {
+            lines.push(`   ... and ${ctx.components.length - 10} more`);
         }
+        lines.push("");
     }
-    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);
+    if (ctx.hooks.length) {
+        const allHooks = ctx.hooks.flatMap((f) => f.exports.functions.filter((fn) => fn.startsWith("use")));
+        if (allHooks.length) {
+            lines.push(`🪝 HOOKS (${allHooks.length})`, "");
+            for (const hook of allHooks) {
+                lines.push(`   • ${hook}()`);
             }
+            lines.push("");
         }
     }
-    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);
+    if (ctx.utils.length) {
+        lines.push(`🔧 UTILITIES`, "");
+        for (const f of ctx.utils.slice(0, 10)) {
+            if (f.exports.functions.length) {
+                lines.push(`   ${f.name}`);
+                for (const fn of f.exports.functions.slice(0, 3)) {
+                    lines.push(`      • ${fn}()`);
+                }
+            }
         }
+        lines.push("");
     }
-    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);
+    return lines.join("\n");
 }

package/dist/formatters/index.d.ts

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

package/dist/formatters/index.js

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

package/dist/organizer.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedFile, OrganizedContext } from "./types.js";
+export declare function organize(files: ParsedFile[], baseDir: string): Promise<OrganizedContext>;

package/dist/organizer.js

@@ -0,0 +1,70 @@
+import path from "path";
+import fs from "fs/promises";
+export async function organize(files, baseDir) {
+    const routes = await getRoutes(baseDir);
+    const components = [];
+    const hooks = [];
+    const utils = [];
+    const other = [];
+    for (const file of files) {
+        const rel = file.path.toLowerCase();
+        const hasHooks = file.exports.functions.some((fn) => fn.startsWith("use"));
+        if (hasHooks || file.name.startsWith("use") || rel.includes("/hooks/")) {
+            hooks.push(file);
+        }
+        else if (rel.includes("/components/") || rel.includes("/ui/")) {
+            components.push(file);
+        }
+        else if (rel.includes("/lib/") ||
+            rel.includes("/utils/") ||
+            rel.includes("/helpers/")) {
+            utils.push(file);
+        }
+        else if (!rel.includes("/app/") && !rel.includes("/pages/")) {
+            other.push(file);
+        }
+    }
+    return { routes, components, hooks, utils, other };
+}
+async function getRoutes(baseDir) {
+    const possibleDirs = [
+        path.join(baseDir, "app"),
+        path.join(baseDir, "src", "app"),
+        path.join(baseDir, "pages"),
+        path.join(baseDir, "src", "pages"),
+    ];
+    for (const dir of possibleDirs) {
+        try {
+            await fs.access(dir);
+            return walkRoutes(dir, "");
+        }
+        catch {
+            continue;
+        }
+    }
+    return [];
+}
+async function walkRoutes(dir, prefix) {
+    const routes = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return routes;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith("_"))
+            continue;
+        if (entry.name.startsWith("("))
+            continue;
+        if (entry.name === "api")
+            continue;
+        const route = prefix + "/" + entry.name;
+        routes.push(route);
+        routes.push(...(await walkRoutes(path.join(dir, entry.name), route)));
+    }
+    return routes;
+}

package/dist/parser.d.ts

@@ -1,2 +1,2 @@
-import type { FileExports } from "./types.js";
-export declare function parseFile(filePath: string): Promise<FileExports>;
+import type { ParsedFile } from "./types.js";
+export declare function parse(filePath: string): Promise<ParsedFile>;

package/dist/parser.js

@@ -1,130 +1,40 @@
 import fs from "fs/promises";
 import path from "path";
-export async function parseFile(filePath) {
+export async function parse(filePath) {
     const content = await fs.readFile(filePath, "utf-8");
-    const fileName = path.basename(filePath);
-    return {
-        filePath,
-        fileName,
-        functions: [
-            ...extractFunctions(content),
-            ...extractCommonJSFunctions(content),
-        ],
-        constants: [
-            ...extractConstants(content),
-            ...extractCommonJSConstants(content),
-        ],
-        types: extractTypes(content),
-        interfaces: extractInterfaces(content),
-        classes: [...extractClasses(content), ...extractMongooseModels(content)],
-        defaultExport: extractDefaultExport(content),
-    };
-}
-// ESM Exports
-function extractFunctions(content) {
+    const name = path.basename(filePath);
     const functions = [];
-    const funcMatches = content.matchAll(/export\s+(?:async\s+)?function\s+(\w+)/g);
-    for (const match of funcMatches) {
-        functions.push(match[1]);
-    }
-    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])) {
-            functions.push(match[1]);
-        }
-    }
-    return functions;
-}
-function extractConstants(content) {
     const constants = [];
-    const lines = content.split("\n");
-    for (const line of lines) {
-        const match = line.match(/export\s+const\s+(\w+)\s*=\s*(?!(?:async\s*)?(?:\(|function|\w+\s*=>))/);
-        if (match) {
-            constants.push(match[1]);
-        }
-        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]);
-        }
-    }
-    return constants;
-}
-function extractTypes(content) {
-    const matches = content.matchAll(/export\s+type\s+(\w+)/g);
-    return [...matches].map((m) => m[1]);
-}
-function extractInterfaces(content) {
-    const matches = content.matchAll(/export\s+interface\s+(\w+)/g);
-    return [...matches].map((m) => m[1]);
-}
-function extractClasses(content) {
-    const matches = content.matchAll(/export\s+(?:default\s+)?class\s+(\w+)/g);
-    return [...matches].map((m) => m[1]);
-}
-function extractDefaultExport(content) {
-    const funcMatch = content.match(/export\s+default\s+function\s+(\w+)/);
-    if (funcMatch)
-        return funcMatch[1];
-    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]);
+    const types = [];
+    const components = [];
+    // Export function
+    for (const match of content.matchAll(/export\s+(?:async\s+)?function\s+(\w+)/g)) {
+        const fn = match[1];
+        isPascalCase(fn) ? components.push(fn) : functions.push(fn);
+    }
+    // Export const
+    for (const match of content.matchAll(/export\s+const\s+(\w+)\s*=/g)) {
+        const n = match[1];
+        if (isPascalCase(n)) {
+            components.push(n);
         }
-    }
-    // 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]);
+        else if (n.startsWith("use")) {
+            functions.push(n);
         }
-    }
-    // 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);
-            }
+        else {
+            constants.push(n);
         }
     }
-    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);
-            }
-        }
+    // Types & interfaces
+    for (const match of content.matchAll(/export\s+(?:type|interface)\s+(\w+)/g)) {
+        types.push(match[1]);
     }
-    return constants;
+    return {
+        path: filePath,
+        name,
+        exports: { functions, constants, types, components },
+    };
 }
-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;
+function isPascalCase(str) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(str);
 }

package/dist/scanner.d.ts

@@ -1,3 +1 @@
-import type { ScanOptions } from "./types.js";
-export declare function scanDirectory(dir: string, options?: Partial<ScanOptions>): Promise<string[]>;
-export declare function getRoutes(appDir: string): Promise<string[]>;
+export declare function scan(dir: string): Promise<string[]>;

package/dist/scanner.js

@@ -1,38 +1,29 @@
 import fs from "fs/promises";
 import path from "path";
-import { defaultConfig } from "./config.js";
-export async function scanDirectory(dir, options = {}) {
-    const config = { ...defaultConfig, ...options };
+const IGNORE = ["node_modules", ".git", "dist", ".next", "build", "__tests__"];
+const EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+export async function scan(dir) {
     const files = [];
-    async function walk(currentDir, depth = 0) {
-        if (depth > config.maxDepth)
-            return;
+    async function walk(current) {
         let entries;
         try {
-            entries = await fs.readdir(currentDir, { withFileTypes: true });
+            entries = await fs.readdir(current, { withFileTypes: true });
         }
         catch {
             return;
         }
         for (const entry of entries) {
-            const fullPath = path.join(currentDir, entry.name);
-            // Check ignore patterns
-            const shouldIgnore = config.ignore.some((pattern) => {
-                if (pattern.includes("*")) {
-                    const regex = new RegExp(pattern.replace(/\./g, "\\.").replace(/\*/g, ".*"));
-                    return regex.test(entry.name);
-                }
-                return entry.name === pattern;
-            });
-            if (shouldIgnore)
+            if (IGNORE.includes(entry.name))
+                continue;
+            if (entry.name.startsWith("."))
                 continue;
+            const full = path.join(current, entry.name);
             if (entry.isDirectory()) {
-                await walk(fullPath, depth + 1);
+                await walk(full);
             }
-            else if (entry.isFile()) {
-                const ext = path.extname(entry.name);
-                if (config.extensions.includes(ext)) {
-                    files.push(fullPath);
+            else if (EXTENSIONS.includes(path.extname(entry.name))) {
+                if (!entry.name.includes(".test.") && !entry.name.includes(".spec.")) {
+                    files.push(full);
                 }
             }
         }
@@ -40,34 +31,3 @@ export async function scanDirectory(dir, options = {}) {
     await walk(dir);
     return files;
 }
-export async function getRoutes(appDir) {
-    const routes = [];
-    async function walkRoutes(dir, indent = "") {
-        let entries;
-        try {
-            entries = await fs.readdir(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        // Sort: groups first (parentheses), then regular folders
-        const sorted = entries
-            .filter((e) => e.isDirectory())
-            .filter((e) => !e.name.startsWith("_"))
-            .sort((a, b) => {
-            const aIsGroup = a.name.startsWith("(");
-            const bIsGroup = b.name.startsWith("(");
-            if (aIsGroup && !bIsGroup)
-                return -1;
-            if (!aIsGroup && bIsGroup)
-                return 1;
-            return a.name.localeCompare(b.name);
-        });
-        for (const entry of sorted) {
-            routes.push(`${indent}${entry.name}`);
-            await walkRoutes(path.join(dir, entry.name), indent + "  ");
-        }
-    }
-    await walkRoutes(appDir);
-    return routes;
-}

package/dist/types.d.ts

@@ -1,23 +1,17 @@
-export interface FileExports {
-    filePath: string;
-    fileName: string;
-    functions: string[];
-    constants: string[];
-    types: string[];
-    interfaces: string[];
-    classes: string[];
-    defaultExport?: string;
+export interface ParsedFile {
+    path: string;
+    name: string;
+    exports: {
+        functions: string[];
+        constants: string[];
+        types: string[];
+        components: string[];
+    };
 }
-export interface ScanOptions {
-    entry: string;
-    extensions: string[];
-    ignore: string[];
-    maxDepth: number;
-}
-export interface ProjectContext {
+export interface OrganizedContext {
     routes: string[];
-    features: Map<string, FileExports[]>;
-    hooks: FileExports[];
-    lib: Map<string, FileExports[]>;
-    components: Map<string, FileExports[]>;
+    components: ParsedFile[];
+    hooks: ParsedFile[];
+    utils: ParsedFile[];
+    other: ParsedFile[];
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eloquence98/ctx",
-  "version": "0.1.6",
-  "description": "Generate AI-ready context from your codebase. One command, zero config.",
+  "version": "0.2.0",
+  "description": "Scan your codebase. Get a clean summary. Paste it to AI.",
   "type": "module",
   "bin": {
     "ctx": "dist/cli.js"
@@ -35,9 +35,5 @@
     "@types/node": "^20.0.0",
     "tsx": "^4.0.0",
     "typescript": "^5.0.0"
-  },
-  "dependencies": {
-    "commander": "^12.0.0",
-    "fast-glob": "^3.3.0"
   }
-}
+}