codemelt-core 0.1.0

package/dist/analyzer/compressionAnalyzer.d.ts

@@ -0,0 +1,4 @@
+import { ScannedFile } from "@codemelt/shared";
+import { CompressionStats } from "./types.js";
+export declare function calculateCompression(files: ScannedFile[], totalFilesCount: number, ignoredCount: number, ignoredBytes?: number): CompressionStats;
+//# sourceMappingURL=compressionAnalyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compressionAnalyzer.d.ts","sourceRoot":"","sources":["../../src/analyzer/compressionAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,WAAW,EAAE,EACpB,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,MAAM,EACpB,YAAY,GAAE,MAAU,GACvB,gBAAgB,CAyBlB"}

package/dist/analyzer/compressionAnalyzer.js

@@ -0,0 +1,21 @@
+export function calculateCompression(files, totalFilesCount, ignoredCount, ignoredBytes = 0) {
+    const originalFilesCount = totalFilesCount;
+    // Filters active included files
+    const includedFiles = files.filter((f) => f.included);
+    const compressedFilesCount = includedFiles.length;
+    const totalScannedBytes = files.reduce((acc, f) => acc + f.size, 0);
+    const totalIncludedBytes = includedFiles.reduce((acc, f) => acc + f.size, 0);
+    // Strictly use real ignoredBytes
+    const originalBytes = totalScannedBytes + ignoredBytes;
+    const compressedBytes = totalIncludedBytes;
+    const savingsPercentage = originalBytes > 0 && ignoredBytes > 0
+        ? Math.max(0, Math.min(99.9, Number(((ignoredBytes / originalBytes) * 100).toFixed(1))))
+        : 0;
+    return {
+        originalBytes,
+        compressedBytes,
+        originalFilesCount,
+        compressedFilesCount,
+        savingsPercentage,
+    };
+}

package/dist/analyzer/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./repositoryAnalyzer.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/analyzer/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,YAAY,CAAC"}

package/dist/analyzer/index.js

@@ -0,0 +1,2 @@
+export * from "./repositoryAnalyzer.js";
+export * from "./types.js";

package/dist/analyzer/prompts/onboarding.d.ts

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

package/dist/analyzer/prompts/onboarding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding.d.ts","sourceRoot":"","sources":["../../../src/analyzer/prompts/onboarding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEhE,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,gBAAgB,EAC9B,YAAY,EAAE,eAAe,EAAE,GAC9B,MAAM,CAgBR"}

package/dist/analyzer/prompts/onboarding.js

@@ -0,0 +1,14 @@
+export function getOnboardingPrompt(architecture, technologies) {
+    const techNames = technologies.map(t => t.name);
+    const archLabel = architecture === "unknown" ? "software codebase" : `${architecture} repository`;
+    let prompt = `You are a staff engineer onboarding onto this ${archLabel}.\n`;
+    if (techNames.length > 0) {
+        prompt += `The technology stack includes: ${techNames.join(", ")}.\n`;
+    }
+    prompt += `\nReview the provided repository context and compile an onboarding document containing:
+1. **Architectural Overview**: Explain the high-level data flow and structure.
+2. **Key Directory Maps**: Explain what each folder is responsible for.
+3. **Local Setup Guide**: Map out the steps I need to take to compile, configure, and boot the application locally based on the configurations and dependencies present.
+4. **Initial Code Tracing**: Identify where the critical entrypoints, schemas, or main routes are located to start reading code.`;
+    return prompt;
+}

package/dist/analyzer/prompts/performance.d.ts

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

package/dist/analyzer/prompts/performance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.d.ts","sourceRoot":"","sources":["../../../src/analyzer/prompts/performance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEhE,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,gBAAgB,EAC9B,YAAY,EAAE,eAAe,EAAE,GAC9B,MAAM,CAqBR"}

package/dist/analyzer/prompts/performance.js

@@ -0,0 +1,18 @@
+export function getPerformancePrompt(architecture, technologies) {
+    const techNames = technologies.map(t => t.name);
+    let prompt = `You are a performance optimization expert auditing a repository built on a ${architecture} architecture.\n`;
+    if (techNames.includes("React")) {
+        prompt += `- React: Evaluate component render cycles, state dependencies, hook dependencies (useEffect, useMemo, useCallback), and virtualized rendering of long lists.\n`;
+    }
+    if (techNames.includes("Tailwind CSS")) {
+        prompt += `- Styling: Identify redundant Tailwind classes, class composition overhead, or layout thrashing.\n`;
+    }
+    if (techNames.includes("PostgreSQL") || techNames.includes("Prisma (ORM)")) {
+        prompt += `- DB Performance: Assess query join patterns, missing indexes on schemas, transaction sizes, or N+1 query scenarios.\n`;
+    }
+    prompt += `\nReview the provided files and supply a Performance Optimization Plan:
+1. **Bottleneck Audit**: Point out specific lines, functions, or queries that will trigger performance bottlenecks.
+2. **Computational Load**: Flag any CPU-heavy work running on the browser main-thread.
+3. **Optimized Snippets**: Provide exact code upgrades showing how to rewrite the code (e.g. implementing React memoization, caching filters, or indexing database models) to ensure near-zero latency.`;
+    return prompt;
+}

package/dist/analyzer/prompts/refactor.d.ts

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

package/dist/analyzer/prompts/refactor.d.ts.map

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

package/dist/analyzer/prompts/refactor.js

@@ -0,0 +1,19 @@
+export function getRefactorPrompt(architecture, technologies) {
+    const techNames = technologies.map(t => t.name);
+    const archLabel = architecture === "unknown" ? "codebase" : `${architecture}`;
+    let prompt = `You are a senior software architect conducting a code quality and refactoring audit of this ${archLabel} repository.\n`;
+    if (techNames.includes("Prisma (ORM)")) {
+        prompt += `- Database: Highlight database schema optimizations, schema models, raw query optimizations, and connection-pool management strategies for Prisma ORM.\n`;
+    }
+    if (techNames.includes("Next.js")) {
+        prompt += `- Next.js: Check usage of Server vs Client Components, layout nesting logic, routing architecture, and caching strategies.\n`;
+    }
+    if (techNames.includes("Zustand") || techNames.includes("Redux")) {
+        prompt += `- State Management: Assess how state stores are partitioned, how selectors are declared, and if state transitions are optimized and atomic.\n`;
+    }
+    prompt += `\nThoroughly review the provided context and deliver:
+1. **Design Pattern Violations**: Note any major anti-patterns (e.g., tight coupling, god objects, logic in views).
+2. **Top 3 Refactoring Candidates**: Identify three specific files or modules that should be decoupled or updated, detailing the precise rationale.
+3. **Refactored Code Blueprints**: Provide drop-in, type-safe replacement code illustrating how the refactored modules should be written.`;
+    return prompt;
+}

package/dist/analyzer/purposeDetector.d.ts

@@ -0,0 +1,4 @@
+import { ScannedFile } from "@codemelt/shared";
+import { PurposeResult } from "./types.js";
+export declare function detectPurpose(files: ScannedFile[], dependencies: Set<string>): PurposeResult;
+//# sourceMappingURL=purposeDetector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"purposeDetector.d.ts","sourceRoot":"","sources":["../../src/analyzer/purposeDetector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAqB,MAAM,YAAY,CAAC;AAE9D,wBAAgB,aAAa,CAC3B,KAAK,EAAE,WAAW,EAAE,EACpB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GACxB,aAAa,CA6Jf"}

package/dist/analyzer/purposeDetector.js

@@ -0,0 +1,141 @@
+export function detectPurpose(files, dependencies) {
+    const scores = {
+        "developer-tooling": 0.0,
+        "saas-dashboard": 0.0,
+        "chat-application": 0.0,
+        "ecommerce-platform": 0.0,
+        "cms": 0.0,
+        "portfolio": 0.0,
+        "api-platform": 0.0,
+        "unknown": 0.0,
+    };
+    const signals = {
+        "developer-tooling": [],
+        "saas-dashboard": [],
+        "chat-application": [],
+        "ecommerce-platform": [],
+        "cms": [],
+        "portfolio": [],
+        "api-platform": [],
+        "unknown": [],
+    };
+    const hasFile = (name) => files.some((f) => f.name.toLowerCase() === name.toLowerCase());
+    const hasDirectory = (dirName) => files.some((f) => f.path.includes(`/${dirName}/`) || f.path.startsWith(`${dirName}/`));
+    // --- Heuristic Signals Mapping ---
+    // 1. Developer Tooling Signals
+    const genericDevDeps = ["typescript", "eslint", "prettier"];
+    const specializedDevDeps = ["commander", "yargs", "tsup", "esbuild"];
+    for (const dep of genericDevDeps) {
+        if (dependencies.has(dep)) {
+            scores["developer-tooling"] += 0.05;
+            signals["developer-tooling"].push(`dependency:${dep}`);
+        }
+    }
+    for (const dep of specializedDevDeps) {
+        if (dependencies.has(dep)) {
+            scores["developer-tooling"] += 0.25;
+            signals["developer-tooling"].push(`dependency:${dep}`);
+        }
+    }
+    const hasCliFolder = files.some((f) => f.path.includes("/cli/") ||
+        f.path.startsWith("cli/") ||
+        f.path.includes("/bin/") ||
+        f.path.startsWith("bin/"));
+    if (hasDirectory("scripts") || hasDirectory("bin") || hasDirectory("cli") || hasCliFolder || hasFile("eslint.config.js") || hasFile("cli.ts")) {
+        scores["developer-tooling"] += 0.35;
+        signals["developer-tooling"].push("file:tooling-configs");
+    }
+    // 2. SaaS Dashboard Signals
+    const saasDeps = ["recharts", "chart.js", "d3", "stripe", "@stripe/stripe-js"];
+    for (const dep of saasDeps) {
+        if (dependencies.has(dep)) {
+            scores["saas-dashboard"] += 0.35;
+            signals["saas-dashboard"].push(`dependency:${dep}`);
+        }
+    }
+    if (hasDirectory("dashboard") || hasDirectory("admin") || hasDirectory("billing") || hasDirectory("payments")) {
+        scores["saas-dashboard"] += 0.40;
+        signals["saas-dashboard"].push("folder:management-routes");
+    }
+    // 3. Chat Application Signals
+    const chatDeps = ["socket.io", "socket.io-client", "pusher", "pusher-js", "ws"];
+    for (const dep of chatDeps) {
+        if (dependencies.has(dep)) {
+            scores["chat-application"] += 0.45;
+            signals["chat-application"].push(`dependency:${dep}`);
+        }
+    }
+    if (hasDirectory("chat") || hasDirectory("messages") || hasDirectory("rooms")) {
+        scores["chat-application"] += 0.45;
+        signals["chat-application"].push("folder:communications");
+    }
+    // 4. Ecommerce Platform Signals
+    if (dependencies.has("stripe") || dependencies.has("@stripe/stripe-js") || dependencies.has("@shopify/shopify-api")) {
+        scores["ecommerce-platform"] += 0.45;
+        signals["ecommerce-platform"].push("dependency:billing-client");
+    }
+    if (hasDirectory("cart") || hasDirectory("checkout") || hasDirectory("products") || hasDirectory("orders")) {
+        scores["ecommerce-platform"] += 0.45;
+        signals["ecommerce-platform"].push("folder:checkout-funnel");
+    }
+    // 5. CMS / Static Blog Signals
+    const cmsDeps = ["strapi", "contentful", "@sanity/client", "ghost", "wordpress"];
+    for (const dep of cmsDeps) {
+        if (dependencies.has(dep)) {
+            scores["cms"] += 0.50;
+            signals["cms"].push(`dependency:${dep}`);
+        }
+    }
+    if (hasDirectory("posts") || hasDirectory("content") || hasDirectory("blog") || hasDirectory("articles")) {
+        scores["cms"] += 0.35;
+        signals["cms"].push("folder:content-data");
+    }
+    // 6. Portfolio Signals
+    if (hasFile("portfolio") || hasFile("resume.pdf") || hasDirectory("portfolio")) {
+        scores["portfolio"] += 0.60;
+        signals["portfolio"].push("file:portfolio-assets");
+    }
+    // 7. API Platform Signals
+    const apiDeps = ["express", "@nestjs/core", "fastify", "koa", "swagger-ui-express", "@tuner/trpc"];
+    for (const dep of apiDeps) {
+        if (dependencies.has(dep)) {
+            scores["api-platform"] += 0.45;
+            signals["api-platform"].push(`dependency:${dep}`);
+        }
+    }
+    if (hasDirectory("routes") || hasDirectory("controllers") || hasDirectory("api") || hasDirectory("endpoints")) {
+        scores["api-platform"] += 0.40;
+        signals["api-platform"].push("folder:routing-handlers");
+    }
+    // --- Resolve highest scoring purpose ---
+    let bestPurpose = "unknown";
+    let maxScore = 0.0;
+    for (const [purpose, score] of Object.entries(scores)) {
+        if (score > maxScore) {
+            maxScore = score;
+            bestPurpose = purpose;
+        }
+    }
+    const finalConfidence = Math.min(maxScore, 1.0);
+    const getConfidenceTier = (score) => {
+        if (score >= 0.8)
+            return "Strong";
+        if (score >= 0.5)
+            return "Moderate";
+        return "Low";
+    };
+    if (finalConfidence < 0.25) {
+        return {
+            name: "unknown",
+            confidence: 0.0,
+            confidenceTier: "Low",
+            matchedSignals: [],
+        };
+    }
+    return {
+        name: bestPurpose,
+        confidence: finalConfidence,
+        confidenceTier: getConfidenceTier(finalConfidence),
+        matchedSignals: signals[bestPurpose] || [],
+    };
+}

package/dist/analyzer/readinessAnalyzer.d.ts

@@ -0,0 +1,4 @@
+import { ScannedFile } from "@codemelt/shared";
+import { AIReadinessScore } from "./types.js";
+export declare function analyzeReadiness(files: ScannedFile[], ignoredCount: number): AIReadinessScore;
+//# sourceMappingURL=readinessAnalyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"readinessAnalyzer.d.ts","sourceRoot":"","sources":["../../src/analyzer/readinessAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,WAAW,EAAE,EACpB,YAAY,EAAE,MAAM,GACnB,gBAAgB,CAiHlB"}

package/dist/analyzer/readinessAnalyzer.js

@@ -0,0 +1,111 @@
+export function analyzeReadiness(files, ignoredCount) {
+    let documentation = 0;
+    let typingQuality = 0;
+    let structureClarity = 0;
+    let configCompleteness = 0;
+    let contextOptimization = 0;
+    const recommendations = [];
+    // Helper check methods
+    const hasFile = (name) => files.some((f) => f.name.toLowerCase() === name.toLowerCase());
+    const hasExtension = (ext) => files.some((f) => f.extension.toLowerCase() === ext.toLowerCase());
+    const hasDirectory = (dirName) => files.some((f) => f.path.includes(`/${dirName}/`) || f.path.startsWith(`${dirName}/`));
+    // 1. Documentation Scoring (Max 20)
+    const hasReadme = files.some((f) => f.name.toLowerCase() === "readme.md" ||
+        f.name.toLowerCase() === "readme.mdx" ||
+        f.name.toLowerCase() === "readme.txt" ||
+        f.name.toLowerCase() === "readme");
+    if (hasReadme) {
+        documentation += 10;
+    }
+    else {
+        recommendations.push("Add a README.md file at the repository root to give AI models structural context.");
+    }
+    if (hasFile("contributing.md") || hasFile("api.md") || hasDirectory("docs")) {
+        documentation += 10;
+    }
+    else {
+        recommendations.push("Provide secondary onboarding guides (docs/ or CONTRIBUTING.md) to explain local builds.");
+    }
+    // 2. Typing Quality Scoring (Max 20)
+    if (hasFile("tsconfig.json")) {
+        typingQuality += 15;
+    }
+    else {
+        recommendations.push("Transition to TypeScript or add a tsconfig.json to supply compile-time types for AI reasoning.");
+    }
+    if (hasExtension("ts") || hasExtension("tsx") || hasExtension("d.ts")) {
+        typingQuality += 5;
+    }
+    else {
+        recommendations.push("Write structured typings for data entities instead of relying on loose JS any types.");
+    }
+    // 3. Structure Clarity Scoring (Max 20)
+    const standardizedDirs = ["src", "components", "lib", "app", "pages", "routes", "controllers", "services"];
+    const matchedDirsCount = standardizedDirs.filter(dir => hasDirectory(dir)).length;
+    if (matchedDirsCount >= 2) {
+        structureClarity += 15;
+    }
+    else if (matchedDirsCount === 1) {
+        structureClarity += 8;
+        recommendations.push("Introduce conventional directory subdivisions (e.g. src/lib, src/components) to separate concerns.");
+    }
+    else {
+        recommendations.push("Organize files into specialized directories instead of keeping flat structures in the root folder.");
+    }
+    // File organization balance check
+    const rootFilesCount = files.filter(f => !f.path.includes("/")).length;
+    if (files.length > 5 && rootFilesCount / files.length < 0.4) {
+        structureClarity += 5;
+    }
+    else if (files.length > 5) {
+        recommendations.push("Avoid cluttering the root folder with massive amounts of flat source files.");
+    }
+    else {
+        structureClarity += 5;
+    }
+    // 4. Config Completeness Scoring (Max 20)
+    if (hasFile(".gitignore")) {
+        configCompleteness += 10;
+    }
+    else {
+        recommendations.push("Include a .gitignore to inform tools which pathways are safe to ignore by default.");
+    }
+    if (hasFile(".env.example") || hasFile(".env.template") || hasFile(".env.local.example")) {
+        configCompleteness += 5;
+    }
+    else {
+        recommendations.push("Add a .env.example file detailing active environment variable structures.");
+    }
+    if (hasFile(".eslintrc.json") || hasFile("eslint.config.js") || hasFile(".prettierrc") || hasFile("tsconfig.json")) {
+        configCompleteness += 5;
+    }
+    // 5. Context Optimization Scoring (Max 20)
+    // Ensure huge lockfiles are not inside included scanned files list
+    const hasLockfilesInScan = files.some(f => f.name === "package-lock.json" ||
+        f.name === "yarn.lock" ||
+        f.name === "pnpm-lock.yaml");
+    if (!hasLockfilesInScan) {
+        contextOptimization += 10;
+    }
+    else {
+        recommendations.push("Ensure large package lockfiles are excluded from scans to save 80%+ context space.");
+    }
+    if (ignoredCount > 0) {
+        contextOptimization += 10;
+    }
+    else {
+        recommendations.push("Set active filter/ignore configs to prune compile and distribution noise folders.");
+    }
+    const score = documentation + typingQuality + structureClarity + configCompleteness + contextOptimization;
+    return {
+        score,
+        breakdown: {
+            documentation,
+            typingQuality,
+            structureClarity,
+            configCompleteness,
+            contextOptimization,
+        },
+        recommendations: recommendations.slice(0, 4), // Cap at 4 actionable items to avoid UI clutter
+    };
+}

package/dist/analyzer/repositoryAnalyzer.d.ts

@@ -0,0 +1,4 @@
+import { ScannedFile } from "@codemelt/shared";
+import { ProjectAnalysis } from "./types.js";
+export declare function analyzeRepository(files: ScannedFile[], totalFilesCount?: number, ignoredCount?: number, ignoredBytes?: number): ProjectAnalysis;
+//# sourceMappingURL=repositoryAnalyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"repositoryAnalyzer.d.ts","sourceRoot":"","sources":["../../src/analyzer/repositoryAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,EAAE,eAAe,EAAwD,MAAM,YAAY,CAAC;AAoBnG,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,WAAW,EAAE,EACpB,eAAe,GAAE,MAAqB,EACtC,YAAY,GAAE,MAAU,EACxB,YAAY,GAAE,MAAU,GACvB,eAAe,CA2IjB"}

package/dist/analyzer/repositoryAnalyzer.js

@@ -0,0 +1,231 @@
+import { TECHNOLOGY_RULES } from "./rules.js";
+import { calculateCompression } from "./compressionAnalyzer.js";
+import { analyzeReadiness } from "./readinessAnalyzer.js";
+import { generateWorkflows } from "./workflowGenerator.js";
+import { detectPurpose } from "./purposeDetector.js";
+import { analyzeSemanticRepository } from "../summarizer/index.js";
+function getConfidenceTier(score) {
+    if (score >= 0.8)
+        return "Strong";
+    if (score >= 0.5)
+        return "Moderate";
+    return "Low";
+}
+export function analyzeRepository(files, totalFilesCount = files.length, ignoredCount = 0, ignoredBytes = 0) {
+    const detections = new Map();
+    const parsedPackages = [];
+    // 1. Locate and parse EVERY package.json in the scanned files list
+    for (const file of files) {
+        if (file.name === "package.json" && file.type === "text") {
+            try {
+                const parsed = JSON.parse(file.content);
+                parsedPackages.push({
+                    path: file.path,
+                    dependencies: parsed.dependencies || {},
+                    devDependencies: parsed.devDependencies || {},
+                });
+            }
+            catch {
+                // Safe fallback for broken or partially uploaded package.json files
+            }
+        }
+    }
+    // Helper: check if dependency exists across any package.json
+    const findDependency = (depName) => {
+        const matches = [];
+        for (const pkg of parsedPackages) {
+            if (pkg.dependencies[depName]) {
+                matches.push({ version: pkg.dependencies[depName], pkgPath: pkg.path });
+            }
+            else if (pkg.devDependencies[depName]) {
+                matches.push({ version: pkg.devDependencies[depName], pkgPath: pkg.path });
+            }
+        }
+        return matches;
+    };
+    // Helper: find any files matching pattern
+    const findMatchingFiles = (pattern) => {
+        return files
+            .filter((f) => f.path.endsWith(pattern) || f.path.includes(pattern))
+            .map((f) => f.path);
+    };
+    // 2. Rules Pipeline Evaluator
+    for (const rule of TECHNOLOGY_RULES) {
+        let score = 0.0;
+        const matchedDeps = [];
+        const matchedFiles = [];
+        const matchedBy = [];
+        let detectedVersion = undefined;
+        // Check Dependency Signatures
+        if (rule.dependencies) {
+            for (const dep of rule.dependencies) {
+                const matches = findDependency(dep);
+                if (matches.length > 0) {
+                    matchedDeps.push(dep);
+                    if (!detectedVersion) {
+                        detectedVersion = matches[0].version; // Grab first resolved version
+                    }
+                }
+            }
+            if (matchedDeps.length > 0) {
+                score += 0.70; // Dependency matches provide 0.70 confidence
+                matchedBy.push("dependency");
+            }
+        }
+        // Check File Configuration Signatures
+        if (rule.filePatterns) {
+            for (const pattern of rule.filePatterns) {
+                const found = findMatchingFiles(pattern);
+                if (found.length > 0) {
+                    matchedFiles.push(...found);
+                }
+            }
+            if (matchedFiles.length > 0) {
+                score += 0.30; // File patterns provide a 0.30 confidence boost
+                matchedBy.push("file-pattern");
+            }
+        }
+        // If we have any active matches, register the detection
+        if (score > 0) {
+            const finalScore = Math.min(score, 1.0); // Cap at 1.0 (absolute confidence)
+            detections.set(rule.name, {
+                name: rule.name,
+                category: rule.category,
+                version: detectedVersion,
+                confidence: finalScore,
+                confidenceTier: getConfidenceTier(finalScore),
+                matchedBy,
+                explainability: {
+                    matchedDependencies: matchedDeps,
+                    matchedFiles: matchedFiles,
+                },
+            });
+        }
+    }
+    // 3. Sub-modules Orchestration
+    const technologies = Array.from(detections.values());
+    const architecture = detectArchitecture(files, parsedPackages, detections);
+    // Extract parsed dependencies set for purpose detection
+    const dependenciesSet = new Set();
+    for (const pkg of parsedPackages) {
+        Object.keys(pkg.dependencies).forEach(dep => dependenciesSet.add(dep));
+        Object.keys(pkg.devDependencies).forEach(dep => dependenciesSet.add(dep));
+    }
+    const purpose = detectPurpose(files, dependenciesSet);
+    const readinessScore = analyzeReadiness(files, ignoredCount);
+    const prompts = generateWorkflows(architecture, technologies);
+    const compression = calculateCompression(files, totalFilesCount, ignoredCount, ignoredBytes);
+    // Compute file count per importance level cleanly
+    const importanceStats = {
+        critical: files.filter(f => f.importance === "critical").length,
+        high: files.filter(f => f.importance === "high").length,
+        normal: files.filter(f => f.importance === "normal").length,
+        low: files.filter(f => f.importance === "low").length,
+    };
+    const semanticAnalysis = analyzeSemanticRepository(files);
+    const totalSize = files.reduce((acc, f) => acc + f.size, 0);
+    const summary = generateSummaryText(technologies, architecture, purpose.name, files.length, totalSize);
+    return {
+        technologies,
+        architecture,
+        purpose,
+        readinessScore,
+        prompts,
+        compression,
+        summary,
+        fileCount: files.length,
+        totalSize,
+        importanceStats,
+        semanticAnalysis,
+    };
+}
+function detectArchitecture(files, parsedPackages, detections) {
+    // 1. Monorepo Detection with strict evidence
+    const hasWorkspaceConfig = files.some((f) => f.name === "turbo.json" ||
+        f.name === "nx.json" ||
+        f.name === "lerna.json" ||
+        f.name === "pnpm-workspace.yaml");
+    let hasRootWorkspaces = false;
+    for (const file of files) {
+        if (file.name === "package.json" && (file.path === "package.json" || file.path === "./package.json") && file.type === "text") {
+            try {
+                const parsed = JSON.parse(file.content);
+                if (parsed.workspaces) {
+                    hasRootWorkspaces = true;
+                }
+            }
+            catch { }
+        }
+    }
+    const hasSubpackageJson = parsedPackages.some((pkg) => pkg.path.includes("packages/") ||
+        pkg.path.includes("apps/") ||
+        pkg.path.includes("libs/"));
+    if (parsedPackages.length > 1 && (hasWorkspaceConfig || hasRootWorkspaces || hasSubpackageJson)) {
+        return "monorepo";
+    }
+    const hasFramework = (name) => detections.has(name);
+    const hasCategory = (cat) => Array.from(detections.values()).some((d) => d.category === cat);
+    // 2. Fullstack Monolith (Next.js, Nuxt/Vue, SvelteKit + Database layers)
+    const isFullstackFramework = hasFramework("Next.js") || hasFramework("Svelte / SvelteKit") || hasFramework("Vue.js");
+    const hasDb = hasCategory("database");
+    if (isFullstackFramework && hasDb) {
+        return "fullstack-monolith";
+    }
+    // 3. Backend API
+    const isBackendFramework = hasFramework("Express.js") || hasFramework("NestJS");
+    if (isBackendFramework && hasDb && !hasFramework("React")) {
+        return "backend-api";
+    }
+    // 4. Realtime Systems
+    if (hasCategory("realtime")) {
+        return "realtime-system";
+    }
+    // 5. Frontend Only
+    if ((hasFramework("React") || hasFramework("Vue.js") || hasFramework("Angular")) && !hasDb) {
+        return "frontend-only";
+    }
+    return "unknown";
+}
+function generateSummaryText(technologies, architecture, purpose, fileCount, totalSize) {
+    const frameworks = technologies.filter((t) => t.category === "framework").map((t) => t.name);
+    const databases = technologies.filter((t) => t.category === "database").map((t) => t.name);
+    const styling = technologies.filter((t) => t.category === "styling").map((t) => t.name);
+    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"
+    };
+    let summary = `Scanned ${fileCount} files (${(totalSize / 1024 / 1024).toFixed(2)} MB). `;
+    if (purpose !== "unknown") {
+        summary += `This project is classified as a ${purposeLabels[purpose]} configured on a ${archLabels[architecture]} layout. `;
+    }
+    else {
+        summary += `The codebase is classified as a ${archLabels[architecture]}. `;
+    }
+    if (frameworks.length > 0) {
+        summary += `Project is built using ${frameworks.join(" / ")}. `;
+    }
+    else {
+        summary += `Project is structured as a basic JavaScript/TypeScript application. `;
+    }
+    if (databases.length > 0) {
+        summary += `Uses ${databases.join(" & ")} as the data layers. `;
+    }
+    if (styling.length > 0) {
+        summary += `Styling is implemented with ${styling.join(", ")}. `;
+    }
+    return summary;
+}

package/dist/analyzer/rules.d.ts

@@ -0,0 +1,3 @@
+import { HeuristicRule } from "./types.js";
+export declare const TECHNOLOGY_RULES: HeuristicRule[];
+//# sourceMappingURL=rules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../src/analyzer/rules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,gBAAgB,EAAE,aAAa,EAgK3C,CAAC"}