codemelt-core 0.1.0

package/dist/analyzer/rules.js

@@ -0,0 +1,156 @@
+export const TECHNOLOGY_RULES = [
+    // --- 1. FRAMEWORKS & LIBRARIES ---
+    {
+        name: "Next.js",
+        category: "framework",
+        dependencies: ["next"],
+        filePatterns: ["next.config.js", "next.config.mjs", "next.config.ts"]
+    },
+    {
+        name: "React",
+        category: "framework",
+        dependencies: ["react", "react-dom"]
+    },
+    {
+        name: "Vue.js",
+        category: "framework",
+        dependencies: ["vue"],
+        filePatterns: ["nuxt.config.js", "nuxt.config.ts"]
+    },
+    {
+        name: "Angular",
+        category: "framework",
+        dependencies: ["@angular/core", "@angular/cli"],
+        filePatterns: ["angular.json"]
+    },
+    {
+        name: "Svelte / SvelteKit",
+        category: "framework",
+        dependencies: ["svelte", "@sveltejs/kit"],
+        filePatterns: ["svelte.config.js"]
+    },
+    {
+        name: "Express.js",
+        category: "framework",
+        dependencies: ["express"]
+    },
+    {
+        name: "NestJS",
+        category: "framework",
+        dependencies: ["@nestjs/core"],
+        filePatterns: ["nest-cli.json"]
+    },
+    // --- 2. DATABASES & ORMS ---
+    {
+        name: "Prisma (ORM)",
+        category: "database",
+        dependencies: ["@prisma/client", "prisma"],
+        filePatterns: ["schema.prisma"]
+    },
+    {
+        name: "Drizzle (ORM)",
+        category: "database",
+        dependencies: ["drizzle-orm"],
+        filePatterns: ["drizzle.config.ts", "drizzle.config.js"]
+    },
+    {
+        name: "Mongoose / MongoDB",
+        category: "database",
+        dependencies: ["mongoose", "mongodb"]
+    },
+    {
+        name: "PostgreSQL",
+        category: "database",
+        dependencies: ["pg", "postgres"]
+    },
+    {
+        name: "MySQL / MariaDB",
+        category: "database",
+        dependencies: ["mysql2", "mysql"]
+    },
+    {
+        name: "Redis",
+        category: "database",
+        dependencies: ["redis", "ioredis"]
+    },
+    // --- 3. STYLING SYSTEMS ---
+    {
+        name: "Tailwind CSS",
+        category: "styling",
+        dependencies: ["tailwindcss", "postcss"],
+        filePatterns: ["tailwind.config.js", "tailwind.config.ts", "tailwind.config.cjs"]
+    },
+    {
+        name: "Styled Components",
+        category: "styling",
+        dependencies: ["styled-components"]
+    },
+    {
+        name: "Emotion",
+        category: "styling",
+        dependencies: ["@emotion/react", "@emotion/styled"]
+    },
+    {
+        name: "Sass / SCSS",
+        category: "styling",
+        dependencies: ["sass", "node-sass"]
+    },
+    // --- 4. RUNTIMES & BUILD TOOLS ---
+    {
+        name: "Node.js",
+        category: "runtime",
+        filePatterns: ["package.json"] // Virtually every JS repo uses Node runtime tooling
+    },
+    {
+        name: "Bun",
+        category: "runtime",
+        filePatterns: ["bun.lockb", "bunfig.toml"]
+    },
+    {
+        name: "Deno",
+        category: "runtime",
+        filePatterns: ["deno.json", "deno.jsonc"]
+    },
+    // --- 5. STATE MANAGEMENT ---
+    {
+        name: "Redux",
+        category: "state-management",
+        dependencies: ["redux", "@reduxjs/toolkit", "react-redux"]
+    },
+    {
+        name: "Zustand",
+        category: "state-management",
+        dependencies: ["zustand"]
+    },
+    {
+        name: "Jotai",
+        category: "state-management",
+        dependencies: ["jotai"]
+    },
+    {
+        name: "Recoil",
+        category: "state-management",
+        dependencies: ["recoil"]
+    },
+    {
+        name: "Pinia (Vue)",
+        category: "state-management",
+        dependencies: ["pinia"]
+    },
+    // --- 6. REALTIME & COMMUNICATION ---
+    {
+        name: "Socket.io",
+        category: "realtime",
+        dependencies: ["socket.io", "socket.io-client"]
+    },
+    {
+        name: "Pusher",
+        category: "realtime",
+        dependencies: ["pusher", "pusher-js"]
+    },
+    {
+        name: "ws (WebSocket Client)",
+        category: "realtime",
+        dependencies: ["ws"]
+    }
+];

package/dist/analyzer/types.d.ts

@@ -0,0 +1,70 @@
+import { SemanticRepositoryAnalysis } from "../summarizer/types.js";
+export type ArchitectureType = "monorepo" | "fullstack-monolith" | "frontend-only" | "backend-api" | "realtime-system" | "unknown";
+export type RepositoryPurpose = "developer-tooling" | "saas-dashboard" | "chat-application" | "ecommerce-platform" | "cms" | "portfolio" | "api-platform" | "unknown";
+export interface PurposeResult {
+    name: RepositoryPurpose;
+    confidence: number;
+    confidenceTier?: "Strong" | "Moderate" | "Low";
+    matchedSignals: string[];
+}
+export type DetectionCategory = "framework" | "database" | "runtime" | "state-management" | "realtime" | "styling";
+export interface DetectionResult {
+    name: string;
+    category: DetectionCategory;
+    version?: string;
+    confidence: number;
+    confidenceTier?: "Strong" | "Moderate" | "Low";
+    matchedBy: ("dependency" | "file-pattern")[];
+    explainability: {
+        matchedDependencies: string[];
+        matchedFiles: string[];
+    };
+}
+export interface CompressionStats {
+    originalBytes: number;
+    compressedBytes: number;
+    originalFilesCount: number;
+    compressedFilesCount: number;
+    savingsPercentage: number;
+}
+export interface AIReadinessScore {
+    score: number;
+    breakdown: {
+        documentation: number;
+        typingQuality: number;
+        structureClarity: number;
+        configCompleteness: number;
+        contextOptimization: number;
+    };
+    recommendations: string[];
+}
+export interface AIWorkflowPrompt {
+    title: string;
+    description: string;
+    prompt: string;
+}
+export interface ProjectAnalysis {
+    technologies: DetectionResult[];
+    architecture: ArchitectureType;
+    purpose: PurposeResult;
+    readinessScore: AIReadinessScore;
+    prompts: AIWorkflowPrompt[];
+    compression: CompressionStats;
+    summary: string;
+    fileCount: number;
+    totalSize: number;
+    importanceStats: {
+        critical: number;
+        high: number;
+        normal: number;
+        low: number;
+    };
+    semanticAnalysis?: SemanticRepositoryAnalysis;
+}
+export interface HeuristicRule {
+    name: string;
+    category: DetectionCategory;
+    dependencies?: string[];
+    filePatterns?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/analyzer/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/analyzer/types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAEpE,MAAM,MAAM,gBAAgB,GACxB,UAAU,GACV,oBAAoB,GACpB,eAAe,GACf,aAAa,GACb,iBAAiB,GACjB,SAAS,CAAC;AAEd,MAAM,MAAM,iBAAiB,GACzB,mBAAmB,GACnB,gBAAgB,GAChB,kBAAkB,GAClB,oBAAoB,GACpB,KAAK,GACL,WAAW,GACX,cAAc,GACd,SAAS,CAAC;AAEd,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,iBAAiB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,KAAK,CAAC;IAC/C,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,MAAM,iBAAiB,GACzB,WAAW,GACX,UAAU,GACV,SAAS,GACT,kBAAkB,GAClB,UAAU,GACV,SAAS,CAAC;AAEd,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,KAAK,CAAC;IAC/C,SAAS,EAAE,CAAC,YAAY,GAAG,cAAc,CAAC,EAAE,CAAC;IAC7C,cAAc,EAAE;QACd,mBAAmB,EAAE,MAAM,EAAE,CAAC;QAC9B,YAAY,EAAE,MAAM,EAAE,CAAC;KACxB,CAAC;CACH;AAED,MAAM,WAAW,gBAAgB;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE;QACT,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,gBAAgB,EAAE,MAAM,CAAC;QACzB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,mBAAmB,EAAE,MAAM,CAAC;KAC7B,CAAC;IACF,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,YAAY,EAAE,gBAAgB,CAAC;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,cAAc,EAAE,gBAAgB,CAAC;IACjC,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,WAAW,EAAE,gBAAgB,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;IACF,gBAAgB,CAAC,EAAE,0BAA0B,CAAC;CAC/C;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB"}

package/dist/analyzer/types.js

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

package/dist/analyzer/workflowGenerator.d.ts

@@ -0,0 +1,3 @@
+import { ArchitectureType, DetectionResult, AIWorkflowPrompt } from "./types.js";
+export declare function generateWorkflows(architecture: ArchitectureType, technologies: DetectionResult[]): AIWorkflowPrompt[];
+//# sourceMappingURL=workflowGenerator.d.ts.map

package/dist/analyzer/workflowGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflowGenerator.d.ts","sourceRoot":"","sources":["../../src/analyzer/workflowGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAKjF,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,gBAAgB,EAC9B,YAAY,EAAE,eAAe,EAAE,GAC9B,gBAAgB,EAAE,CAkBpB"}

package/dist/analyzer/workflowGenerator.js

@@ -0,0 +1,22 @@
+import { getOnboardingPrompt } from "./prompts/onboarding.js";
+import { getRefactorPrompt } from "./prompts/refactor.js";
+import { getPerformancePrompt } from "./prompts/performance.js";
+export function generateWorkflows(architecture, technologies) {
+    return [
+        {
+            title: "Project Onboarding",
+            description: "Instructs the AI to guide a new developer through the codebase topology, entrypoints, and local workspace boot instructions.",
+            prompt: getOnboardingPrompt(architecture, technologies)
+        },
+        {
+            title: "Refactoring & Abstraction",
+            description: "Instructs the AI to audit files for design violations, locate candidate files for refactoring, and provide drop-in cleaner codes.",
+            prompt: getRefactorPrompt(architecture, technologies)
+        },
+        {
+            title: "Performance Optimization",
+            description: "Instructs the AI to analyze computational loads, locate memory/rendering bottlenecks, and provide high-efficiency replacements.",
+            prompt: getPerformancePrompt(architecture, technologies)
+        }
+    ];
+}

package/dist/filters/shouldIgnore.d.ts

@@ -0,0 +1,2 @@
+export declare function shouldIgnore(path: string, customRules?: string[]): boolean;
+//# sourceMappingURL=shouldIgnore.d.ts.map

package/dist/filters/shouldIgnore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shouldIgnore.d.ts","sourceRoot":"","sources":["../../src/filters/shouldIgnore.ts"],"names":[],"mappings":"AAGA,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAU1E"}

package/dist/filters/shouldIgnore.js

@@ -0,0 +1,10 @@
+import { minimatch } from "minimatch";
+import { DEFAULT_IGNORES, normalizePath } from "@codemelt/shared";
+export function shouldIgnore(path, customRules) {
+    const rules = customRules || DEFAULT_IGNORES;
+    const normalized = normalizePath(path);
+    return rules.some((rule) => minimatch(normalized, rule, {
+        matchBase: true,
+        dot: true,
+    }));
+}

package/dist/formatter/generateRepositoryContext.d.ts

@@ -0,0 +1,10 @@
+import { ScannedFile, ExportMode, ExportIntent } from "@codemelt/shared";
+export declare function generateRepositoryContextChunks(files: ScannedFile[], format?: "markdown" | "xml", mode?: ExportMode, intent?: ExportIntent): Generator<string, void, unknown>;
+/**
+ * Standard in-memory context generation.
+ * NOTE: For extremely large repositories where memory overhead must be kept to zero,
+ * developers should consume the chunk-friendly generator function `generateRepositoryContextChunks`
+ * directly (e.g., piping yielded strings into a writable file stream or network response).
+ */
+export declare function generateRepositoryContext(files: ScannedFile[], format?: "markdown" | "xml", mode?: ExportMode, intent?: ExportIntent): string;
+//# sourceMappingURL=generateRepositoryContext.d.ts.map

package/dist/formatter/generateRepositoryContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateRepositoryContext.d.ts","sourceRoot":"","sources":["../../src/formatter/generateRepositoryContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA0BzE,wBAAiB,+BAA+B,CAC5C,KAAK,EAAE,WAAW,EAAE,EACpB,MAAM,GAAE,UAAU,GAAG,KAAkB,EACvC,IAAI,GAAE,UAAuB,EAC7B,MAAM,GAAE,YAAwB,GACjC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAmSlC;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACrC,KAAK,EAAE,WAAW,EAAE,EACpB,MAAM,GAAE,UAAU,GAAG,KAAkB,EACvC,IAAI,GAAE,UAAuB,EAC7B,MAAM,GAAE,YAAwB,GACjC,MAAM,CAOR"}

package/dist/formatter/generateRepositoryContext.js

@@ -0,0 +1,311 @@
+import { sortFiles } from "../prioritizer/sortFiles.js";
+import { analyzeRepository } from "../analyzer/repositoryAnalyzer.js";
+function getSemanticFileDescription(path, name) {
+    const lowerPath = path.toLowerCase();
+    const lowerName = name.toLowerCase();
+    if (lowerName === "package.json")
+        return "Project dependency and build script definitions";
+    if (lowerName === "tsconfig.json")
+        return "TypeScript compiler settings";
+    if (lowerName === "schema.prisma")
+        return "Prisma database schema and models";
+    if (lowerName === "tailwind.config.js" || lowerName === "tailwind.config.ts" || lowerName === "tailwind.config.cjs")
+        return "Tailwind CSS configuration rules";
+    if (lowerName === ".gitignore")
+        return "Git ignore rules";
+    if (lowerName.endsWith(".d.ts"))
+        return "TypeScript ambient declaration file";
+    if (lowerPath.includes("route") || lowerPath.includes("api/"))
+        return "API route endpoint handler configuration";
+    if (lowerPath.includes("controller"))
+        return "Controller mapping incoming requests to backend logic";
+    if (lowerPath.includes("model") || lowerPath.includes("db/"))
+        return "Database data model definition";
+    if (lowerPath.includes("store") || lowerPath.includes("state"))
+        return "State management module";
+    if (lowerPath.includes("component") || lowerPath.includes("ui/"))
+        return "User interface view component";
+    if (lowerPath.includes("util") || lowerPath.includes("helper"))
+        return "Utility functions";
+    if (lowerPath.endsWith(".css") || lowerPath.endsWith(".scss"))
+        return "Style sheet definition";
+    if (lowerPath.endsWith(".html"))
+        return "HTML template file";
+    return "Source code file";
+}
+export function* generateRepositoryContextChunks(files, format = "markdown", mode = "standard", intent = "general") {
+    // 1. Prioritize/Filter files based on Export Mode
+    let filteredFiles = files.filter((f) => f.included);
+    if (mode === "tiny") {
+        // Tiny mode excludes low/normal-importance files, binary, and oversized
+        filteredFiles = filteredFiles.filter((f) => (f.importance === "critical" || f.importance === "high") && f.type === "text");
+    }
+    if (mode === "standard") {
+        // Standard mode excludes low-importance files, binary, and oversized
+        filteredFiles = filteredFiles.filter((f) => f.importance !== "low" && f.type === "text");
+    }
+    if (mode === "deep") {
+        // Deep mode includes all text files, but excludes oversized/binary
+        filteredFiles = filteredFiles.filter((f) => f.type === "text");
+    }
+    // Maximum mode (mode === "maximum") includes everything (except what's ignored).
+    const prioritizedFiles = sortFiles(filteredFiles);
+    const includedCount = filteredFiles.length;
+    // 2. Perform intelligence repository analysis
+    const analysis = analyzeRepository(files);
+    const archLabels = {
+        "monorepo": "Monorepo Workspace",
+        "fullstack-monolith": "Fullstack Monolith",
+        "frontend-only": "Frontend Application",
+        "backend-api": "Backend API Service",
+        "realtime-system": "Realtime Application",
+        "unknown": "Software Repository"
+    };
+    const purposeLabels = {
+        "developer-tooling": "Developer Tooling Project",
+        "saas-dashboard": "SaaS Dashboard Portal",
+        "chat-application": "Chat Application",
+        "ecommerce-platform": "Ecommerce Platform",
+        "cms": "Content Management System",
+        "portfolio": "Portfolio Website",
+        "api-platform": "API Platform Service",
+        "unknown": "Application"
+    };
+    // Intent Directive text blocks
+    const intentDirectives = {
+        "general": "Provide a comprehensive code synthesis and general structural walkthrough.",
+        "debugging": "PRIORITY DIRECTIVE: Focus intensely on tracing runtime exceptions, boundary conditions, typing declarations, linter configurations, and environmental setups.",
+        "onboarding": "PRIORITY DIRECTIVE: Primed for fast software onboarding. Structure responses around high-level architecture maps, topological flows, and setup triggers.",
+        "architecture": "PRIORITY DIRECTIVE: Evaluate architectural structural boundaries, tight-coupling issues, database schemas alignment, and design patterns consistency.",
+        "security": "PRIORITY DIRECTIVE: Evaluate third-party dependencies package licenses, environment configurations safety, input validation layers, and security-risk variables."
+    };
+    // --- XML EXPORT MODE FORMATTING ---
+    if (format === "xml") {
+        yield `<?xml version="1.0" encoding="UTF-8"?>\n`;
+        yield `<repository>\n`;
+        let xmlHeader = `  <repository_analysis>\n`;
+        xmlHeader += `    <architecture>${analysis.architecture}</architecture>\n`;
+        xmlHeader += `    <architecture_label>${archLabels[analysis.architecture]}</architecture_label>\n`;
+        xmlHeader += `    <purpose>${analysis.purpose.name}</purpose>\n`;
+        xmlHeader += `    <purpose_label>${purposeLabels[analysis.purpose.name]}</purpose_label>\n`;
+        xmlHeader += `    <ai_readiness_score>${analysis.readinessScore.score}</ai_readiness_score>\n`;
+        if (analysis.compression.savingsPercentage > 0) {
+            xmlHeader += `    <compression_savings>${analysis.compression.savingsPercentage.toFixed(1)}%</compression_savings>\n`;
+        }
+        xmlHeader += `    <intent_directive>${intentDirectives[intent]}</intent_directive>\n`;
+        // Compact list of technologies
+        xmlHeader += `    <technologies>\n`;
+        for (const tech of analysis.technologies) {
+            xmlHeader += `      <technology name="${tech.name}" category="${tech.category}" confidence="${tech.confidence.toFixed(2)}" confidence_tier="${tech.confidenceTier || 'Low'}" />\n`;
+        }
+        xmlHeader += `    </technologies>\n`;
+        // Condensed Recommended Workflows
+        xmlHeader += `    <recommended_workflows>\n`;
+        for (const prompt of analysis.prompts) {
+            xmlHeader += `      <workflow type="${prompt.title.toLowerCase().replace(/ & /g, "-").replace(/ /g, "-")}" />\n`;
+        }
+        xmlHeader += `    </recommended_workflows>\n`;
+        // Semantic analysis injections
+        if (analysis.semanticAnalysis) {
+            const sem = analysis.semanticAnalysis;
+            if (sem.entrypoints.length > 0) {
+                xmlHeader += `    <entrypoints>\n`;
+                for (const ep of sem.entrypoints) {
+                    xmlHeader += `      <entrypoint path="${ep.path}" type="${ep.entrypointType || 'general'}" summary="${ep.summary}" />\n`;
+                }
+                xmlHeader += `    </entrypoints>\n`;
+            }
+            if (sem.routes.length > 0) {
+                xmlHeader += `    <routes>\n`;
+                for (const r of sem.routes) {
+                    xmlHeader += `      <route path="${r.path}" method="${r.method}" handler="${r.handlerFile}" />\n`;
+                }
+                xmlHeader += `    </routes>\n`;
+            }
+            if (sem.flows.length > 0) {
+                xmlHeader += `    <flows>\n`;
+                for (const f of sem.flows) {
+                    xmlHeader += `      <flow name="${f.name}">\n`;
+                    for (const step of f.steps) {
+                        xmlHeader += `        <step>${step}</step>\n`;
+                    }
+                    xmlHeader += `      </flow>\n`;
+                }
+                xmlHeader += `    </flows>\n`;
+            }
+        }
+        xmlHeader += `  </repository_analysis>\n\n`;
+        yield xmlHeader;
+        let xmlMeta = `  <metadata>\n`;
+        xmlMeta += `    <generator>CodeMelt AI-Context Generator</generator>\n`;
+        xmlMeta += `    <export_mode>${mode}</export_mode>\n`;
+        xmlMeta += `    <export_intent>${intent}</export_intent>\n`;
+        xmlMeta += `    <total_files>${includedCount}</total_files>\n`;
+        xmlMeta += `  </metadata>\n\n`;
+        yield xmlMeta;
+        // Add Directory Structure Tree
+        let xmlDir = `  <directory_structure>\n`;
+        const dirRegistered = new Set();
+        for (const file of prioritizedFiles) {
+            if (analysis.semanticAnalysis) {
+                const parts = file.path.split("/");
+                parts.pop();
+                let currentPath = "";
+                for (const part of parts) {
+                    currentPath = currentPath ? `${currentPath}/${part}` : part;
+                    if (!dirRegistered.has(currentPath)) {
+                        dirRegistered.add(currentPath);
+                        const dirSem = analysis.semanticAnalysis.directorySummaries[currentPath];
+                        const dirSummary = dirSem ? dirSem.summary : "Directory subfolder";
+                        xmlDir += `    <directory path="${currentPath}" summary="${dirSummary}" />\n`;
+                    }
+                }
+            }
+            const sem = analysis.semanticAnalysis?.fileSummaries[file.path];
+            const desc = sem?.summary || getSemanticFileDescription(file.path, file.name);
+            xmlDir += `    <item path="${file.path}" type="${file.type}" importance="${file.importance}" desc="${desc}" size="${file.size}" is_entrypoint="${sem?.isEntrypoint ? 'true' : 'false'}" />\n`;
+        }
+        xmlDir += `  </directory_structure>\n\n`;
+        yield xmlDir;
+        yield `  <files>\n`;
+        for (const file of prioritizedFiles) {
+            const sem = analysis.semanticAnalysis?.fileSummaries[file.path];
+            const summaryVal = sem?.summary || getSemanticFileDescription(file.path, file.name);
+            let xmlFile = `    <file path="${file.path}" type="${file.type}" importance="${file.importance}" summary="${summaryVal}" is_entrypoint="${sem?.isEntrypoint ? 'true' : 'false'}">\n`;
+            if (file.type === "text") {
+                xmlFile += `      <![CDATA[\n${file.content}\n]]>\n`;
+            }
+            else if (file.type === "binary") {
+                xmlFile += `      <!-- Binary file content omitted (${file.size} bytes) -->\n`;
+            }
+            else if (file.type === "oversized") {
+                xmlFile += `      <!-- Oversized file content omitted (${file.size} bytes) -->\n`;
+            }
+            xmlFile += `    </file>\n`;
+            yield xmlFile;
+        }
+        yield `  </files>\n`;
+        yield `</repository>\n`;
+        return;
+    }
+    // --- MARKDOWN EXPORT MODE FORMATTING ---
+    yield `# CodeMelt Project Context\n\n`;
+    // Semantic XML Boundary Block for LLM Parsing in Markdown Mode
+    let mdHeader = `<repository_analysis>\n`;
+    mdHeader += `## Repository Architecture Profile\n`;
+    mdHeader += `- **Architecture Profile**: ${archLabels[analysis.architecture]}\n`;
+    mdHeader += `- **Repository Purpose**: ${purposeLabels[analysis.purpose.name]} (Confidence: ${analysis.purpose.confidenceTier || 'Low'} - ${(analysis.purpose.confidence * 100).toFixed(0)}%)\n`;
+    mdHeader += `- **AI Readiness Score**: ${analysis.readinessScore.score} / 100\n`;
+    if (analysis.compression.savingsPercentage > 0) {
+        mdHeader += `- **Context Compression Savings**: ${analysis.compression.savingsPercentage.toFixed(1)}% (Savings calculated on lockfiles, builds, and media filters)\n`;
+    }
+    mdHeader += `- **Export Configuration**: Mode [${mode}] / Intent [${intent}]\n`;
+    mdHeader += `- **Workflows Directive**: ${intentDirectives[intent]}\n\n`;
+    yield mdHeader;
+    let mdTech = `## Detected Technology Stack\n`;
+    if (analysis.technologies.length === 0) {
+        mdTech += `*No prominent framework or library signatures detected in dependencies or configurations.*\n`;
+    }
+    else {
+        for (const tech of analysis.technologies) {
+            const versionStr = tech.version ? ` (v${tech.version})` : "";
+            mdTech += `- **${tech.name}**${versionStr} - [Category: ${tech.category}] - Confidence: ${tech.confidenceTier || 'Low'} (${(tech.confidence * 100).toFixed(0)}%)\n`;
+        }
+    }
+    yield mdTech;
+    // Compact list of suggested workflows
+    let mdWorkflows = `\n## Recommended Workflow Invocations\n`;
+    for (const prompt of analysis.prompts) {
+        const wfKey = prompt.title.toLowerCase().replace(/ & /g, "-").replace(/ /g, "-");
+        mdWorkflows += `<recommended_workflow type="${wfKey}" />\n`;
+    }
+    yield mdWorkflows;
+    // Semantic analysis navigation mapping
+    if (analysis.semanticAnalysis) {
+        const sem = analysis.semanticAnalysis;
+        let mdNav = `\n## Navigation & Architecture Map\n`;
+        if (sem.entrypoints.length > 0) {
+            mdNav += `### System Entrypoints\n`;
+            for (const ep of sem.entrypoints) {
+                mdNav += `- **${ep.path}** [${ep.entrypointType || 'entrypoint'}] - ${ep.summary}\n`;
+            }
+            mdNav += `\n`;
+        }
+        if (sem.routes.length > 0) {
+            mdNav += `### API Routing\n`;
+            for (const r of sem.routes) {
+                mdNav += `- **${r.method} ${r.path}** -> Handled by \`${r.handlerFile.split('/').pop()}\`\n`;
+            }
+            mdNav += `\n`;
+        }
+        if (sem.flows.length > 0) {
+            mdNav += `### Semantic Data Flows\n`;
+            for (const f of sem.flows) {
+                mdNav += `- **${f.name}**: ${f.steps.join(" ➔ ")}\n`;
+            }
+            mdNav += `\n`;
+        }
+        yield mdNav;
+    }
+    yield `</repository_analysis>\n\n`;
+    // Add Directory Structure Tree in Markdown with semantic descriptors
+    let mdDir = `## Directory Structure\n\n\`\`\`text\n`;
+    const dirRegisteredMd = new Set();
+    for (const file of prioritizedFiles) {
+        if (analysis.semanticAnalysis) {
+            const parts = file.path.split("/");
+            parts.pop();
+            let currentPath = "";
+            for (const part of parts) {
+                currentPath = currentPath ? `${currentPath}/${part}` : part;
+                if (!dirRegisteredMd.has(currentPath)) {
+                    dirRegisteredMd.add(currentPath);
+                    const dirSem = analysis.semanticAnalysis.directorySummaries[currentPath];
+                    const dirSummary = dirSem ? dirSem.summary : "Directory subfolder";
+                    mdDir += `/${currentPath} - ${dirSummary}\n`;
+                }
+            }
+        }
+        const typeStr = file.type === "text" ? "" : ` [${file.type}]`;
+        const importanceStr = file.importance === "normal" ? "" : ` [${file.importance}]`;
+        const sem = analysis.semanticAnalysis?.fileSummaries[file.path];
+        const desc = sem?.summary || getSemanticFileDescription(file.path, file.name);
+        mdDir += `  ├── ${file.path}${typeStr}${importanceStr} (${(file.size / 1024).toFixed(1)} KB) - ${desc}\n`;
+    }
+    mdDir += `\`\`\`\n\n`;
+    yield mdDir;
+    yield `## Repository Files\n\n`;
+    for (const file of prioritizedFiles) {
+        const sem = analysis.semanticAnalysis?.fileSummaries[file.path];
+        const summaryVal = sem?.summary || getSemanticFileDescription(file.path, file.name);
+        let mdFile = `### File: ${file.path}\n`;
+        mdFile += `<file path="${file.path}" type="${file.type}" importance="${file.importance}" summary="${summaryVal}" is_entrypoint="${sem?.isEntrypoint ? 'true' : 'false'}">\n\n`;
+        if (file.type === "text") {
+            mdFile += "```" + file.extension + "\n";
+            mdFile += file.content + "\n";
+            mdFile += "```\n";
+        }
+        else if (file.type === "binary") {
+            mdFile += `*Binary file omitted (${(file.size / 1024).toFixed(1)} KB)*\n`;
+        }
+        else if (file.type === "oversized") {
+            mdFile += `*Oversized file omitted (>1MB) (${(file.size / 1024).toFixed(1)} KB)*\n`;
+        }
+        mdFile += `\n</file>\n\n`;
+        yield mdFile;
+    }
+}
+/**
+ * Standard in-memory context generation.
+ * NOTE: For extremely large repositories where memory overhead must be kept to zero,
+ * developers should consume the chunk-friendly generator function `generateRepositoryContextChunks`
+ * directly (e.g., piping yielded strings into a writable file stream or network response).
+ */
+export function generateRepositoryContext(files, format = "markdown", mode = "standard", intent = "general") {
+    let result = "";
+    // Append-friendly iteration avoiding Array.from memory spikes
+    for (const chunk of generateRepositoryContextChunks(files, format, mode, intent)) {
+        result += chunk;
+    }
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { scanFiles } from "./scanner/scanFiles.js";
+export { detectImportance } from "./scanner/importanceDetector.js";
+export { shouldIgnore } from "./filters/shouldIgnore.js";
+export { analyzeRepository } from "./analyzer/repositoryAnalyzer.js";
+export * from "./analyzer/types.js";
+export { analyzeSemanticRepository } from "./summarizer/index.js";
+export * from "./summarizer/types.js";
+export { sortFiles } from "./prioritizer/sortFiles.js";
+export { scoreFile } from "./prioritizer/scoreFile.js";
+export { estimateWords } from "./tokenizer/estimateWords.js";
+export { estimateTokens } from "./tokenizer/estimateTokens.js";
+export { generateRepositoryContext } from "./formatter/generateRepositoryContext.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAClE,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+export { scanFiles } from "./scanner/scanFiles.js";
+export { detectImportance } from "./scanner/importanceDetector.js";
+export { shouldIgnore } from "./filters/shouldIgnore.js";
+export { analyzeRepository } from "./analyzer/repositoryAnalyzer.js";
+export * from "./analyzer/types.js";
+export { analyzeSemanticRepository } from "./summarizer/index.js";
+export * from "./summarizer/types.js";
+export { sortFiles } from "./prioritizer/sortFiles.js";
+export { scoreFile } from "./prioritizer/scoreFile.js";
+export { estimateWords } from "./tokenizer/estimateWords.js";
+export { estimateTokens } from "./tokenizer/estimateTokens.js";
+export { generateRepositoryContext } from "./formatter/generateRepositoryContext.js";

package/dist/prioritizer/scoreFile.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"scoreFile.d.ts","sourceRoot":"","sources":["../../src/prioritizer/scoreFile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,wBAAgB,SAAS,CACrB,IAAI,EAAE,WAAW,GAClB,MAAM,CAkCR"}