@eloquence98/ctx 0.1.5 → 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,73 +1,27 @@
 #!/usr/bin/env node
-import { program } from "commander";
 import path from "path";
-import fs from "fs/promises";
-import { scanDirectory } from "./scanner.js";
-import { parseFile } from "./parser.js";
-import { detectProject, getProjectLabel } from "./detectors/index.js";
-import { getAdapter } from "./adapters/index.js";
-import { formatMarkdown } from "./formatters/markdown.js";
+import { scan } from "./scanner.js";
+import { parse } from "./parser.js";
+import { organize } from "./organizer.js";
 import { formatAI } from "./formatters/ai.js";
-program
-    .name("ctx")
-    .description("Generate AI-ready context from your codebase")
-    .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);
-    // 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);
-        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)));
-        // Use adapter to analyze
-        const context = await adapter.analyze(absolutePath, parsedFiles);
-        // Output
-        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));
-        }
-    }
-    catch (error) {
-        console.error("Error:", error);
+import { formatHuman } from "./formatters/human.js";
+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-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 { 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

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

package/dist/formatters/human.js

@@ -0,0 +1,53 @@
+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("");
+    }
+    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}`);
+                }
+            }
+        }
+        if (ctx.components.length > 10) {
+            lines.push(`   ... and ${ctx.components.length - 10} more`);
+        }
+        lines.push("");
+    }
+    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("");
+        }
+    }
+    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 lines.join("\n");
+}

package/dist/formatters/index.d.ts

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

package/dist/formatters/index.js

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

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/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.5",
-  "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"
   }
-}
+}