codemelt-core 0.1.0

package/dist/prioritizer/scoreFile.js

@@ -0,0 +1,25 @@
+export function scoreFile(file) {
+    const path = file.path.toLowerCase();
+    let score = 0;
+    if (path.includes("/src/"))
+        score += 30;
+    if (path.includes("/features/"))
+        score += 25;
+    if (path.includes("controller"))
+        score += 20;
+    if (path.includes("service"))
+        score += 20;
+    if (path.includes("routes"))
+        score += 15;
+    if (path.includes("model"))
+        score += 10;
+    if (path.includes("middleware"))
+        score += 10;
+    if (path.includes("config"))
+        score -= 10;
+    if (path.includes("package-lock"))
+        score -= 50;
+    if (path.includes("tsconfig"))
+        score -= 20;
+    return score;
+}

package/dist/prioritizer/sortFiles.d.ts

@@ -0,0 +1,3 @@
+import { ScannedFile } from "@codemelt/shared";
+export declare function sortFiles(files: ScannedFile[]): ScannedFile[];
+//# sourceMappingURL=sortFiles.d.ts.map

package/dist/prioritizer/sortFiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortFiles.d.ts","sourceRoot":"","sources":["../../src/prioritizer/sortFiles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG/C,wBAAgB,SAAS,CACrB,KAAK,EAAE,WAAW,EAAE,GACrB,WAAW,EAAE,CAMf"}

package/dist/prioritizer/sortFiles.js

@@ -0,0 +1,9 @@
+import { scoreFile } from "./scoreFile.js";
+export function sortFiles(files) {
+    return [...files].sort((a, b) => {
+        const scoreDiff = scoreFile(b) - scoreFile(a);
+        if (scoreDiff !== 0)
+            return scoreDiff;
+        return a.path.localeCompare(b.path);
+    });
+}

package/dist/scanner/importanceDetector.d.ts

@@ -0,0 +1,3 @@
+import { FileImportance } from "@codemelt/shared";
+export declare function detectImportance(path: string, name: string): FileImportance;
+//# sourceMappingURL=importanceDetector.d.ts.map

package/dist/scanner/importanceDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"importanceDetector.d.ts","sourceRoot":"","sources":["../../src/scanner/importanceDetector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAiB,MAAM,kBAAkB,CAAC;AAEjE,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,cAAc,CA8EhB"}

package/dist/scanner/importanceDetector.js

@@ -0,0 +1,70 @@
+import { normalizePath } from "@codemelt/shared";
+export function detectImportance(path, name) {
+    const normalized = normalizePath(path);
+    const lowerPath = normalized.toLowerCase();
+    const lowerName = name.toLowerCase();
+    // --- 1. CRITICAL: Entrypoints & Core Configs ---
+    const criticalConfigs = new Set([
+        "package.json",
+        "tsconfig.json",
+        "schema.prisma",
+        "drizzle.config.ts",
+        "drizzle.config.js",
+        "next.config.js",
+        "next.config.mjs",
+        "next.config.ts",
+        "vite.config.ts",
+        "vite.config.js",
+        "tailwind.config.js",
+        "tailwind.config.ts",
+        "tailwind.config.cjs",
+        ".gitignore"
+    ]);
+    if (criticalConfigs.has(lowerName)) {
+        return "critical";
+    }
+    const criticalEntrypoints = new Set([
+        "src/index.ts",
+        "src/index.tsx",
+        "src/main.ts",
+        "src/main.tsx",
+        "src/app.tsx",
+        "src/app.ts",
+        "app/layout.tsx",
+        "app/page.tsx",
+        "pages/_app.tsx",
+        "pages/index.tsx"
+    ]);
+    if (criticalEntrypoints.has(lowerPath) || criticalEntrypoints.has(normalized)) {
+        return "critical";
+    }
+    // --- 2. HIGH: Central Logic & Systems Routing ---
+    if (lowerPath.includes("route") ||
+        lowerPath.includes("controller") ||
+        lowerPath.includes("schema") ||
+        lowerPath.includes("store") ||
+        lowerPath.includes("service") ||
+        lowerPath.includes("models/") ||
+        lowerPath.includes("db/") ||
+        lowerName.endsWith(".d.ts")) {
+        return "high";
+    }
+    // --- 3. LOW: Secondary Configurations & Noise ---
+    const lowConfigs = new Set([
+        "tsconfig.node.json",
+        "package-lock.json",
+        "yarn.lock",
+        "pnpm-lock.yaml",
+        ".prettierrc",
+        ".eslintrc",
+        ".eslintrc.json",
+        "eslint.config.js",
+        ".env.example",
+        ".env.template"
+    ]);
+    if (lowConfigs.has(lowerName) || lowerName.startsWith(".env")) {
+        return "low";
+    }
+    // --- 4. NORMAL: Standard logic files ---
+    return "normal";
+}

package/dist/scanner/scanFiles.d.ts

@@ -0,0 +1,3 @@
+import { RawFile, ScanResult } from "@codemelt/shared";
+export declare function scanFiles(files: RawFile[], customRules?: string[]): Promise<ScanResult>;
+//# sourceMappingURL=scanFiles.d.ts.map

package/dist/scanner/scanFiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanFiles.d.ts","sourceRoot":"","sources":["../../src/scanner/scanFiles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAe,UAAU,EAAuF,MAAM,kBAAkB,CAAC;AAmBzJ,wBAAsB,SAAS,CAC3B,KAAK,EAAE,OAAO,EAAE,EAChB,WAAW,CAAC,EAAE,MAAM,EAAE,GACvB,OAAO,CAAC,UAAU,CAAC,CAuHrB"}

package/dist/scanner/scanFiles.js

@@ -0,0 +1,127 @@
+import { normalizePath, MAX_EXPORT_FILES, MAX_FILE_SIZE, MAX_CONTENT_CHARS, MAX_EXPORT_BYTES } from "@codemelt/shared";
+import { shouldIgnore } from "../filters/shouldIgnore.js";
+import { detectImportance } from "./importanceDetector.js";
+const BINARY_EXTENSIONS = new Set([
+    "png", "jpg", "jpeg", "gif", "webp", "ico",
+    "pdf", "zip", "tar", "gz", "rar", "7z",
+    "mp4", "mp3", "wav", "avi", "mov", "flac",
+    "exe", "dll", "so", "dylib",
+    "woff", "woff2", "ttf", "eot",
+    "db", "sqlite", "sqlite3",
+    "bin", "dat", "pyc", "class", "o", "obj",
+]);
+function isBinary(filename) {
+    const ext = filename.split(".").pop()?.toLowerCase() || "";
+    return BINARY_EXTENSIONS.has(ext);
+}
+export async function scanFiles(files, customRules) {
+    const scannedFiles = [];
+    let ignoredCount = 0;
+    let ignoredBytes = 0;
+    let totalBytesAccumulator = 0;
+    // Normalizing paths across the raw files array
+    const normalizedFiles = files.map(file => ({
+        ...file,
+        path: normalizePath(file.path)
+    }));
+    // Capping maximum number of files to index to protect memory
+    let eligibleFilesList = normalizedFiles;
+    if (eligibleFilesList.length > MAX_EXPORT_FILES) {
+        console.warn(`[CodeMelt] Safety boundary cap hit: repository contains ${eligibleFilesList.length} files. Restricting active index depth to ${MAX_EXPORT_FILES} items.`);
+        eligibleFilesList = eligibleFilesList.slice(0, MAX_EXPORT_FILES);
+    }
+    // Single-pass deterministic ignore and size tracking
+    const eligibleFiles = eligibleFilesList.filter((file) => {
+        const ignored = shouldIgnore(file.path, customRules);
+        if (ignored) {
+            ignoredCount++;
+            ignoredBytes += file.size;
+        }
+        return !ignored;
+    });
+    if (files.length > 500) {
+        console.warn("[CodeMelt] Large repository detected. Export may take longer and use significant system resources.");
+    }
+    const BATCH_SIZE = 20;
+    for (let i = 0; i < eligibleFiles.length; i += BATCH_SIZE) {
+        const batch = eligibleFiles.slice(i, i + BATCH_SIZE);
+        const processedBatch = await Promise.all(batch.map(async (file) => {
+            const extension = file.name.split(".").pop()?.toLowerCase() || "";
+            const size = file.size;
+            let type = "text";
+            let content = "";
+            let isBin = isBinary(file.name);
+            // Safe order flow: type detection ➔ sizing limits ➔ only then read textual content
+            if (!isBin && file.readChunk && size > 0) {
+                try {
+                    const chunk = await file.readChunk(Math.min(size, 4096));
+                    let nullBytes = 0;
+                    let nonPrintable = 0;
+                    for (let i = 0; i < chunk.length; i++) {
+                        const byte = chunk[i];
+                        if (byte === 0)
+                            nullBytes++;
+                        else if ((byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) || byte > 126)
+                            nonPrintable++;
+                    }
+                    if (nullBytes > 0 || (chunk.length > 0 && nonPrintable / chunk.length > 0.3)) {
+                        isBin = true;
+                    }
+                }
+                catch (e) {
+                    // fallback
+                }
+            }
+            if (isBin) {
+                type = "binary";
+                content = "[Binary file content omitted]";
+            }
+            else if (size > MAX_FILE_SIZE) {
+                type = "oversized";
+                content = `[Oversized file content omitted (${(size / 1024 / 1024).toFixed(1)}MB > 1MB limit)]`;
+            }
+            else if (totalBytesAccumulator > MAX_EXPORT_BYTES) {
+                type = "oversized";
+                content = "[Omitted by CodeMelt due to total memory ceiling limits exceeded]";
+            }
+            else {
+                try {
+                    const rawText = await file.text();
+                    totalBytesAccumulator += size;
+                    // Safe content length characters truncation cap
+                    if (rawText.length > MAX_CONTENT_CHARS) {
+                        content = rawText.slice(0, MAX_CONTENT_CHARS) + "\n\n[Content truncated by CodeMelt due to size safety thresholds]";
+                    }
+                    else {
+                        content = rawText;
+                    }
+                }
+                catch (error) {
+                    type = "binary";
+                    content = "[Unable to read as text]";
+                }
+            }
+            // Detect importance
+            const importance = detectImportance(file.path, file.name);
+            return {
+                name: file.name,
+                path: file.path,
+                extension,
+                size,
+                content,
+                included: true,
+                type,
+                importance,
+            };
+        }));
+        scannedFiles.push(...processedBatch);
+    }
+    const totalScannedBytes = files.reduce((acc, f) => acc + f.size, 0);
+    return {
+        scannedFiles,
+        ignoredCount,
+        ignoredBytes,
+        totalFiles: files.length,
+        totalBytes: totalScannedBytes,
+    };
+}

package/dist/summarizer/extractPatterns.d.ts

@@ -0,0 +1,12 @@
+export interface ExtractedPatterns {
+    exports: string[];
+    imports: string[];
+    functions: string[];
+    routes: {
+        method: string;
+        path: string;
+    }[];
+    keywords: Set<string>;
+}
+export declare function extractPatterns(content: string, path: string, name: string): ExtractedPatterns;
+//# sourceMappingURL=extractPatterns.d.ts.map

package/dist/summarizer/extractPatterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractPatterns.d.ts","sourceRoot":"","sources":["../../src/summarizer/extractPatterns.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC3C,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACvB;AAWD,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAqF9F"}

package/dist/summarizer/extractPatterns.js

@@ -0,0 +1,83 @@
+const KEYWORD_GROUPS = {
+    auth: ["auth", "login", "register", "signup", "signin", "jwt", "token", "password", "session", "cookie", "passport", "bcrypt", "oauth"],
+    db: ["db", "database", "query", "prisma", "drizzle", "mongo", "mongoose", "postgres", "sql", "schema", "model", "findmany", "insert", "select"],
+    state: ["state", "store", "dispatch", "reducer", "slice", "createslice", "selector", "atom", "zustand", "redux", "jotai"],
+    realtime: ["socket", "io", "ws", "websocket", "pusher", "realtime", "subscribe", "broadcast", "emit", "on("],
+    billing: ["stripe", "checkout", "payment", "charge", "cart", "order", "billing", "invoice", "sub"],
+    upload: ["upload", "multer", "s3", "storage", "file", "cloudinary", "aws-sdk"],
+};
+export function extractPatterns(content, path, name) {
+    const exports = [];
+    const imports = [];
+    const functions = [];
+    const routes = [];
+    const keywords = new Set();
+    // Skip binary, oversized or empty contents
+    if (!content || content.startsWith("[") && content.endsWith("]")) {
+        return { exports, imports, functions, routes, keywords };
+    }
+    const lowerContent = content.toLowerCase();
+    // 1. Keyword Scan
+    for (const [group, words] of Object.entries(KEYWORD_GROUPS)) {
+        for (const word of words) {
+            if (lowerContent.includes(word)) {
+                keywords.add(group);
+                break; // Once group is identified, move to next
+            }
+        }
+    }
+    // 2. Regex Scan (Process line-by-line or moderate size chunks to protect browser CPU)
+    const lines = content.split("\n");
+    const exportRegex = /\bexport\s+(?:const|let|var|function|async\s+function|class|type|interface)\s+([a-zA-Z0-9_]+)/;
+    const importRegex = /\bimport\s+.*\s+from\s+['"]([^'"]+)['"]/;
+    const functionRegex = /\bfunction\s+([a-zA-Z0-9_]+)|\bconst\s+([a-zA-Z0-9_]+)\s*=\s*(?:async\s*)?\((?:[^)]*)\)\s*=>/;
+    const expressRouteRegex = /\b(?:router|app)\.(get|post|put|delete|patch)\(['"]([^'"]+)['"]/;
+    const nextApiRegex = /fetch\(['"]([^'"]+)['"]|axios\.(get|post|put|delete)\(['"]([^'"]+)['"]/;
+    for (const line of lines) {
+        // Limit processing to reasonable length lines
+        if (line.length > 500)
+            continue;
+        // A. Exports
+        const exportMatch = line.match(exportRegex);
+        if (exportMatch && exportMatch[1]) {
+            exports.push(exportMatch[1]);
+        }
+        // B. Imports
+        const importMatch = line.match(importRegex);
+        if (importMatch && importMatch[1]) {
+            imports.push(importMatch[1]);
+        }
+        // C. Local functions
+        const fnMatch = line.match(functionRegex);
+        const fnName = fnMatch ? (fnMatch[1] || fnMatch[2]) : null;
+        if (fnName && fnName !== "const" && fnName !== "let") {
+            functions.push(fnName);
+        }
+        // D. Express routes
+        const routeMatch = line.match(expressRouteRegex);
+        if (routeMatch && routeMatch[1] && routeMatch[2]) {
+            routes.push({
+                method: routeMatch[1].toUpperCase(),
+                path: routeMatch[2],
+            });
+        }
+        // E. Fetch/Axios network references (flow intelligence helper)
+        const netMatch = line.match(nextApiRegex);
+        if (netMatch) {
+            const endpoint = netMatch[1] || netMatch[2];
+            if (endpoint && endpoint.startsWith("/")) {
+                routes.push({
+                    method: line.includes("post") || line.includes("POST") ? "POST" : "GET",
+                    path: endpoint,
+                });
+            }
+        }
+    }
+    return {
+        exports: Array.from(new Set(exports)).slice(0, 10), // cap at 10 to keep it dense
+        imports: Array.from(new Set(imports)).slice(0, 10),
+        functions: Array.from(new Set(functions)).slice(0, 15),
+        routes,
+        keywords,
+    };
+}

package/dist/summarizer/flowDetector.d.ts

@@ -0,0 +1,6 @@
+import { FileSemanticSummary, RouteDetail, RequestFlow } from "./types.js";
+export declare function detectFlowsAndRoutes(fileSummaries: Record<string, FileSemanticSummary>): {
+    routes: RouteDetail[];
+    flows: RequestFlow[];
+};
+//# sourceMappingURL=flowDetector.d.ts.map

package/dist/summarizer/flowDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowDetector.d.ts","sourceRoot":"","sources":["../../src/summarizer/flowDetector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE3E,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,GACjD;IAAE,MAAM,EAAE,WAAW,EAAE,CAAC;IAAC,KAAK,EAAE,WAAW,EAAE,CAAA;CAAE,CAgCjD"}

package/dist/summarizer/flowDetector.js

@@ -0,0 +1,29 @@
+export function detectFlowsAndRoutes(fileSummaries) {
+    const routes = [];
+    const flows = [];
+    const fileKeys = Object.keys(fileSummaries);
+    // 1. Gather all registered routes across files
+    for (const [filePath, summary] of Object.entries(fileSummaries)) {
+        if (summary.routes && summary.routes.length > 0) {
+            for (const r of summary.routes) {
+                const parts = r.split(" ");
+                if (parts.length > 1) {
+                    const method = parts[0].toUpperCase();
+                    const path = parts[1];
+                    // Avoid duplicate routes registration
+                    const exists = routes.some(existing => existing.path === path && existing.method === method);
+                    if (!exists) {
+                        routes.push({
+                            path,
+                            method,
+                            handlerFile: filePath,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // 2. Speculative pipelines are completely disabled to prevent hallucinations.
+    // We strictly return an empty array for flows.
+    return { routes, flows: [] };
+}

package/dist/summarizer/index.d.ts

@@ -0,0 +1,5 @@
+import { ScannedFile } from "@codemelt/shared";
+import { SemanticRepositoryAnalysis } from "./types.js";
+export declare function analyzeSemanticRepository(files: ScannedFile[]): SemanticRepositoryAnalysis;
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/summarizer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/summarizer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,0BAA0B,EAAuB,MAAM,YAAY,CAAC;AAK7E,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,WAAW,EAAE,GACnB,0BAA0B,CA2B5B;AAED,cAAc,YAAY,CAAC"}

package/dist/summarizer/index.js

@@ -0,0 +1,25 @@
+import { summarizeFile } from "./summarizeFile.js";
+import { summarizeDirectory } from "./summarizeDirectory.js";
+import { detectFlowsAndRoutes } from "./flowDetector.js";
+export function analyzeSemanticRepository(files) {
+    const fileSummaries = {};
+    // 1. Core file summaries loop
+    for (const file of files) {
+        const summary = summarizeFile(file);
+        fileSummaries[file.path] = summary;
+    }
+    // 2. Aggregate directory summaries
+    const directorySummaries = summarizeDirectory(fileSummaries);
+    // 3. Extract system entrypoints
+    const entrypoints = Object.values(fileSummaries).filter((summary) => summary.isEntrypoint);
+    // 4. Trace HTTP routes & flow tracks
+    const { routes, flows } = detectFlowsAndRoutes(fileSummaries);
+    return {
+        fileSummaries,
+        directorySummaries,
+        entrypoints,
+        routes,
+        flows,
+    };
+}
+export * from "./types.js";

package/dist/summarizer/inferPurpose.d.ts

@@ -0,0 +1,10 @@
+import { ExtractedPatterns } from "./extractPatterns.js";
+import { EntrypointType } from "./types.js";
+interface InferredPurpose {
+    summary: string;
+    isEntrypoint: boolean;
+    entrypointType?: EntrypointType;
+}
+export declare function inferPurpose(path: string, name: string, patterns: ExtractedPatterns): InferredPurpose;
+export {};
+//# sourceMappingURL=inferPurpose.d.ts.map

package/dist/summarizer/inferPurpose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inferPurpose.d.ts","sourceRoot":"","sources":["../../src/summarizer/inferPurpose.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,GAAG,eAAe,CA0KrG"}

package/dist/summarizer/inferPurpose.js

@@ -0,0 +1,162 @@
+export function inferPurpose(path, name, patterns) {
+    const lowerPath = path.toLowerCase();
+    const lowerName = name.toLowerCase();
+    const keywords = patterns.keywords;
+    // --- 1. ENTRYPOINT DETECTION ---
+    const isServerEntry = lowerName === "server.js" || lowerName === "server.ts" || lowerPath === "src/main.ts" || lowerPath === "src/index.ts" || lowerPath === "index.js";
+    const isFrontendBoot = lowerPath === "src/main.tsx" || lowerPath === "src/index.tsx" || lowerPath === "src/main.jsx" || lowerPath === "src/index.jsx";
+    const isAppShell = lowerName === "app.tsx" || lowerName === "app.jsx" || lowerName === "app.vue" || lowerName === "app.svelte";
+    const isLayoutRoot = lowerName === "layout.tsx" || lowerName === "layout.jsx" || lowerName === "layout.html";
+    const isRouterRoot = lowerName === "routes.ts" || lowerName === "routes.tsx" || lowerName === "routes.js" || lowerName === "page.tsx" && !lowerPath.includes("api");
+    if (isServerEntry) {
+        return {
+            summary: "Server entrypoint file.",
+            isEntrypoint: true,
+            entrypointType: "server",
+        };
+    }
+    if (isFrontendBoot) {
+        return {
+            summary: "Frontend client entrypoint.",
+            isEntrypoint: true,
+            entrypointType: "frontend",
+        };
+    }
+    if (isAppShell) {
+        return {
+            summary: "Main application router and root layout wrapper.",
+            isEntrypoint: true,
+            entrypointType: "app-shell",
+        };
+    }
+    if (isLayoutRoot) {
+        return {
+            summary: "Root layout component structure.",
+            isEntrypoint: true,
+            entrypointType: "layout-root",
+        };
+    }
+    if (isRouterRoot) {
+        return {
+            summary: "Router page component.",
+            isEntrypoint: true,
+            entrypointType: "router-root",
+        };
+    }
+    // --- 2. CONFIGURATION BOUNDARIES ---
+    const isConfig = lowerName.includes("config") || lowerName.startsWith(".") || lowerName.endsWith(".json");
+    if (isConfig) {
+        if (lowerName === "package.json")
+            return { summary: "Project dependency and build script definitions.", isEntrypoint: false };
+        if (lowerName === "tsconfig.json")
+            return { summary: "TypeScript compiler settings.", isEntrypoint: false };
+        if (lowerName === "tailwind.config.js" || lowerName === "tailwind.config.ts")
+            return { summary: "Tailwind CSS configuration rules.", isEntrypoint: false };
+        if (lowerName === "schema.prisma")
+            return { summary: "Prisma database schema and models.", isEntrypoint: false };
+        if (lowerName === ".gitignore")
+            return { summary: "Git ignore rules.", isEntrypoint: false };
+        return {
+            summary: "Project configuration file.",
+            isEntrypoint: false,
+        };
+    }
+    // --- 3. CONTROLLERS ---
+    const isController = lowerName.endsWith("controller.ts") || lowerName.endsWith("controller.js") || lowerPath.includes("/controllers/") || lowerPath.includes("/controller/");
+    if (isController) {
+        if (keywords.has("auth")) {
+            return { summary: "Controller handling user credentials and session management.", isEntrypoint: false };
+        }
+        if (keywords.has("db")) {
+            return { summary: "Controller handling database requests.", isEntrypoint: false };
+        }
+        if (keywords.has("billing")) {
+            return { summary: "Controller handling billing and webhook operations.", isEntrypoint: false };
+        }
+        if (keywords.has("upload")) {
+            return { summary: "Controller handling file upload operations.", isEntrypoint: false };
+        }
+        return {
+            summary: "Controller mapping incoming requests to backend logic.",
+            isEntrypoint: false,
+        };
+    }
+    // --- 4. SERVICES ---
+    const isService = lowerName.endsWith("service.ts") || lowerName.endsWith("service.js") || lowerPath.includes("/services/") || lowerPath.includes("/service/");
+    if (isService) {
+        if (keywords.has("auth")) {
+            return { summary: "Service handling user authentication workflows.", isEntrypoint: false };
+        }
+        if (keywords.has("db")) {
+            return { summary: "Service handling database query logic.", isEntrypoint: false };
+        }
+        if (keywords.has("billing")) {
+            return { summary: "Service handling checkout processes.", isEntrypoint: false };
+        }
+        return {
+            summary: "Service layer encapsulating backend operations.",
+            isEntrypoint: false,
+        };
+    }
+    // --- 5. MIDDLEWARE ---
+    const isMiddleware = lowerName.includes("middleware") || lowerPath.includes("/middleware/") || lowerPath.includes("/middlewares/");
+    if (isMiddleware) {
+        if (keywords.has("auth")) {
+            return { summary: "Middleware handling user token verification.", isEntrypoint: false };
+        }
+        if (keywords.has("upload")) {
+            return { summary: "Middleware handling file size and type filters.", isEntrypoint: false };
+        }
+        return {
+            summary: "Middleware handling request routing filters.",
+            isEntrypoint: false,
+        };
+    }
+    // --- 6. REACT/UI VIEWS ---
+    const isUI = lowerName.endsWith(".tsx") || lowerName.endsWith(".jsx") || lowerName.endsWith(".vue") || lowerName.endsWith(".svelte") || lowerPath.includes("/components/") || lowerPath.includes("/views/");
+    if (isUI) {
+        if (lowerName.includes("navbar") || lowerName.includes("sidebar") || lowerName.includes("header")) {
+            return { summary: "Navigation component for headers or sidebars.", isEntrypoint: false };
+        }
+        if (lowerName.includes("modal") || lowerName.includes("dialog") || lowerName.includes("drawer")) {
+            return { summary: "Interactive modal dialog component.", isEntrypoint: false };
+        }
+        if (lowerName.includes("button") || lowerName.includes("input") || lowerName.includes("badge") || lowerName.includes("select")) {
+            return { summary: "Reusable form controls and UI elements.", isEntrypoint: false };
+        }
+        if (keywords.has("state")) {
+            return { summary: "Interactive component bound to state management.", isEntrypoint: false };
+        }
+        return {
+            summary: "User interface view component.",
+            isEntrypoint: false,
+        };
+    }
+    // --- 7. ROUTE HANDLERS ---
+    const isRouteFile = lowerName.includes("route") || lowerPath.includes("/routes/") || lowerPath.includes("/api/");
+    if (isRouteFile) {
+        return {
+            summary: "API route endpoint handler configuration.",
+            isEntrypoint: false,
+        };
+    }
+    // --- 8. UTILITIES ---
+    const isUtil = lowerName.includes("util") || lowerName.includes("helper") || lowerPath.includes("/utils/") || lowerPath.includes("/helpers/") || lowerPath.includes("/lib/");
+    if (isUtil) {
+        if (keywords.has("auth")) {
+            return { summary: "Utility functions handling credentials.", isEntrypoint: false };
+        }
+        if (keywords.has("db")) {
+            return { summary: "Utility functions handling database pooling.", isEntrypoint: false };
+        }
+        return {
+            summary: "General utility functions.",
+            isEntrypoint: false,
+        };
+    }
+    // --- 9. DEFAULT FALLBACK ---
+    return {
+        summary: "Logical repository code file.",
+        isEntrypoint: false,
+    };
+}

package/dist/summarizer/summarizeDirectory.d.ts

@@ -0,0 +1,3 @@
+import { FileSemanticSummary, DirectorySemanticSummary } from "./types.js";
+export declare function summarizeDirectory(fileSummaries: Record<string, FileSemanticSummary>): Record<string, DirectorySemanticSummary>;
+//# sourceMappingURL=summarizeDirectory.d.ts.map

package/dist/summarizer/summarizeDirectory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarizeDirectory.d.ts","sourceRoot":"","sources":["../../src/summarizer/summarizeDirectory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE3E,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,GACjD,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAsF1C"}