@parseme/cli 0.0.2

package/dist/analyzers/project-analyzer.js

@@ -0,0 +1,205 @@
+import { readFile, access, readdir, stat } from 'fs/promises';
+import { join, basename } from 'path';
+export class ProjectAnalyzer {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async analyze(rootDir) {
+        const packageJsonPath = join(rootDir, 'package.json');
+        try {
+            await access(packageJsonPath);
+            const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+            return {
+                name: packageJson.name || basename(rootDir),
+                version: packageJson.version,
+                description: packageJson.description,
+                type: await this.detectProjectType(rootDir),
+                category: this.detectProjectCategory(packageJson, rootDir),
+                packageManager: await this.detectPackageManager(rootDir),
+                dependencies: packageJson.dependencies || {},
+                devDependencies: packageJson.devDependencies || {},
+                scripts: packageJson.scripts || {},
+                entryPoints: this.detectEntryPoints(packageJson),
+                outputTargets: this.detectOutputTargets(packageJson),
+            };
+        }
+        catch {
+            // No package.json found, analyze directory structure
+            return {
+                name: basename(rootDir),
+                type: await this.detectProjectType(rootDir),
+                category: 'unknown',
+                packageManager: 'npm',
+                dependencies: {},
+                devDependencies: {},
+                scripts: {},
+                entryPoints: [],
+                outputTargets: [],
+            };
+        }
+    }
+    async detectProjectType(rootDir) {
+        try {
+            const files = await this.getFilesRecursive(rootDir, 2); // Only check 2 levels deep
+            const tsFiles = files.filter((f) => f.endsWith('.ts') && !f.endsWith('.d.ts'));
+            const jsFiles = files.filter((f) => f.endsWith('.js'));
+            if (tsFiles.length > 0 && jsFiles.length > 0) {
+                return 'mixed';
+            }
+            if (tsFiles.length > 0) {
+                return 'typescript';
+            }
+            return 'javascript';
+        }
+        catch {
+            return 'javascript';
+        }
+    }
+    async detectPackageManager(rootDir) {
+        const lockFiles = {
+            'pnpm-lock.yaml': 'pnpm',
+            'yarn.lock': 'yarn',
+            'bun.lockb': 'bun',
+            'package-lock.json': 'npm',
+        };
+        for (const [lockFile, manager] of Object.entries(lockFiles)) {
+            try {
+                await access(join(rootDir, lockFile));
+                return manager;
+            }
+            catch {
+                // Continue checking
+            }
+        }
+        return 'npm';
+    }
+    async getFilesRecursive(dir, maxDepth) {
+        if (maxDepth <= 0) {
+            return [];
+        }
+        try {
+            const entries = await readdir(dir);
+            const files = [];
+            for (const entry of entries) {
+                const fullPath = join(dir, entry);
+                const stats = await stat(fullPath);
+                if (stats.isFile()) {
+                    files.push(fullPath);
+                }
+                else if (stats.isDirectory() && !entry.startsWith('.') && entry !== 'node_modules') {
+                    files.push(...(await this.getFilesRecursive(fullPath, maxDepth - 1)));
+                }
+            }
+            return files;
+        }
+        catch {
+            return [];
+        }
+    }
+    detectProjectCategory(packageJson, _rootDir) {
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        // Check for monorepo indicators
+        if (packageJson.workspaces || packageJson.private) {
+            return 'monorepo';
+        }
+        // Check for CLI tools
+        if (packageJson.bin) {
+            return 'cli-tool';
+        }
+        // Check for desktop app frameworks
+        if (deps['electron'] || deps['tauri']) {
+            return 'desktop-app';
+        }
+        // Check for mobile frameworks
+        if (deps['react-native'] || deps['@ionic/react'] || deps['@ionic/angular']) {
+            return 'frontend-mobile';
+        }
+        // Check for fullstack frameworks
+        if (deps['next'] || deps['nuxt'] || deps['sveltekit'] || deps['remix']) {
+            return 'fullstack';
+        }
+        // Check for frontend frameworks
+        if (deps['react'] ||
+            deps['vue'] ||
+            deps['angular'] ||
+            deps['svelte'] ||
+            deps['@angular/core'] ||
+            deps['vue-router']) {
+            return 'frontend-web';
+        }
+        // Check for backend frameworks
+        if (deps['express'] ||
+            deps['fastify'] ||
+            deps['@nestjs/core'] ||
+            deps['koa'] ||
+            deps['@hapi/hapi']) {
+            return 'backend-api';
+        }
+        // Check if it's a library (has main/module/exports but no app dependencies)
+        if ((packageJson.main || packageJson.module || packageJson.exports) &&
+            !this.hasAppDependencies(deps)) {
+            return 'npm-package';
+        }
+        return 'unknown';
+    }
+    detectEntryPoints(packageJson) {
+        const entryPoints = [];
+        if (packageJson.main && typeof packageJson.main === 'string') {
+            entryPoints.push(packageJson.main);
+        }
+        if (packageJson.module && typeof packageJson.module === 'string') {
+            entryPoints.push(packageJson.module);
+        }
+        if (packageJson.browser && typeof packageJson.browser === 'string') {
+            entryPoints.push(packageJson.browser);
+        }
+        if (packageJson.exports) {
+            if (typeof packageJson.exports === 'string') {
+                entryPoints.push(packageJson.exports);
+            }
+            else if (typeof packageJson.exports === 'object') {
+                Object.values(packageJson.exports).forEach((exp) => {
+                    if (typeof exp === 'string') {
+                        entryPoints.push(exp);
+                    }
+                });
+            }
+        }
+        return [...new Set(entryPoints)]; // Remove duplicates
+    }
+    detectOutputTargets(packageJson) {
+        const targets = [];
+        const main = packageJson.main;
+        // Common output directories
+        if (main?.includes('dist/')) {
+            targets.push('dist');
+        }
+        if (main?.includes('build/')) {
+            targets.push('build');
+        }
+        if (main?.includes('lib/')) {
+            targets.push('lib');
+        }
+        return [...new Set(targets)];
+    }
+    hasAppDependencies(deps) {
+        const appIndicators = [
+            'react',
+            'vue',
+            'angular',
+            'svelte',
+            'express',
+            'fastify',
+            '@nestjs/core',
+            'next',
+            'nuxt',
+            'electron',
+            'react-native',
+        ];
+        return appIndicators.some((indicator) => deps[indicator]);
+    }
+}

package/dist/builders/context-builder.d.ts

@@ -0,0 +1,35 @@
+import type { ParsemeConfig } from '../config.js';
+import type { ContextOutput, ProjectInfo, FileAnalysis, GitInfo, GeneratorOptions } from '../types.js';
+interface BuildContext {
+    projectInfo: ProjectInfo;
+    fileAnalyses: FileAnalysis[];
+    gitInfo?: GitInfo;
+    options: GeneratorOptions;
+    contextDir?: string;
+    outputPath?: string;
+}
+export declare class ContextBuilder {
+    private readonly config;
+    constructor(config: ParsemeConfig);
+    private truncateContent;
+    private splitContentByLines;
+    private splitContentByChars;
+    build(context: BuildContext): ContextOutput;
+    private buildMultiFile;
+    private buildHeader;
+    private buildProjectOverview;
+    private buildFrameworkSection;
+    private buildArchitectureSection;
+    private buildRoutesSection;
+    private buildFileStructureSection;
+    private buildDependenciesSection;
+    private buildGitSection;
+    private buildFooter;
+    private buildSummarySection;
+    private buildDetailedStructure;
+    private buildDetailedRoutes;
+    private buildDetailedDependencies;
+    private buildDetailedFramework;
+    private buildDetailedGit;
+}
+export {};

package/dist/builders/context-builder.js

@@ -0,0 +1,332 @@
+import { relative, dirname } from 'path';
+export class ContextBuilder {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    truncateContent(content, type = 'chars') {
+        const limits = this.config.get().limits;
+        if (!limits) {
+            return content;
+        }
+        const strategy = limits.truncateStrategy || 'truncate';
+        if (type === 'lines') {
+            const lines = content.split('\n');
+            const maxLines = limits.maxLinesPerFile || 1000;
+            if (lines.length > maxLines) {
+                if (strategy === 'split') {
+                    return this.splitContentByLines(lines, maxLines);
+                }
+                else {
+                    const truncated = lines.slice(0, maxLines).join('\n');
+                    return truncated + '\n\n[... truncated for AI compatibility ...]';
+                }
+            }
+        }
+        else {
+            const maxChars = limits.maxCharsPerFile || 50000;
+            if (content.length > maxChars) {
+                if (strategy === 'split') {
+                    return this.splitContentByChars(content, maxChars);
+                }
+                else {
+                    const truncated = content.substring(0, maxChars - 100);
+                    return truncated + '\n\n[... truncated for AI compatibility ...]';
+                }
+            }
+        }
+        return content;
+    }
+    splitContentByLines(lines, maxLines) {
+        const parts = [];
+        const safeMaxLines = maxLines - 5; // Reserve space for split indicators
+        for (let i = 0; i < lines.length; i += safeMaxLines) {
+            const chunk = lines.slice(i, i + safeMaxLines);
+            const partNumber = Math.floor(i / safeMaxLines) + 1;
+            const totalParts = Math.ceil(lines.length / safeMaxLines);
+            let partContent = chunk.join('\n');
+            partContent += `\n\n[... part ${partNumber} of ${totalParts} ...]`;
+            parts.push(partContent);
+        }
+        return parts;
+    }
+    splitContentByChars(content, maxChars) {
+        const parts = [];
+        const safeMaxChars = maxChars - 200; // Reserve space for split indicators
+        for (let i = 0; i < content.length; i += safeMaxChars) {
+            let chunk = content.substring(i, i + safeMaxChars);
+            const partNumber = Math.floor(i / safeMaxChars) + 1;
+            const totalParts = Math.ceil(content.length / safeMaxChars);
+            // Try to break at a reasonable place (newline or word boundary)
+            if (i + safeMaxChars < content.length) {
+                const lastNewline = chunk.lastIndexOf('\n');
+                const lastSpace = chunk.lastIndexOf(' ');
+                const breakPoint = lastNewline > -1 ? lastNewline : lastSpace > -1 ? lastSpace : chunk.length;
+                if (breakPoint > safeMaxChars * 0.8) {
+                    // Only break if we're not losing too much content
+                    chunk = chunk.substring(0, breakPoint);
+                }
+            }
+            chunk += `\n\n[... part ${partNumber} of ${totalParts} ...]`;
+            parts.push(chunk);
+        }
+        return parts;
+    }
+    build(context) {
+        return this.buildMultiFile(context);
+    }
+    buildMultiFile(context) {
+        const { projectInfo, fileAnalyses, gitInfo } = context;
+        const limits = this.config.get().limits;
+        // Limit number of files analyzed if specified
+        const limitedFileAnalyses = limits?.maxFilesPerContext
+            ? fileAnalyses.slice(0, limits.maxFilesPerContext)
+            : fileAnalyses;
+        const mainContent = this.buildHeader(projectInfo) +
+            '\n\n' +
+            this.buildProjectOverview(projectInfo) +
+            '\n\n' +
+            this.buildSummarySection(context);
+        const contextFiles = {
+            structure: '',
+            routes: '',
+            dependencies: '',
+        };
+        // Helper function to merge split files into contextFiles
+        const mergeSplitFiles = (result, baseName) => {
+            if (typeof result === 'string') {
+                contextFiles[baseName] = result;
+            }
+            else {
+                // Merge split files into contextFiles
+                Object.entries(result).forEach(([key, value]) => {
+                    contextFiles[key] = value;
+                });
+            }
+        };
+        // Detailed structure
+        const structureResult = this.buildDetailedStructure(limitedFileAnalyses);
+        mergeSplitFiles(structureResult, 'structure');
+        // Routes documentation
+        const routes = limitedFileAnalyses.flatMap((f) => f.routes || []);
+        if (routes.length > 0) {
+            const routesResult = this.buildDetailedRoutes(routes, limitedFileAnalyses);
+            mergeSplitFiles(routesResult, 'routes');
+        }
+        // Dependencies
+        const dependenciesResult = this.buildDetailedDependencies(projectInfo);
+        mergeSplitFiles(dependenciesResult, 'dependencies');
+        // Framework details
+        if (projectInfo.framework &&
+            projectInfo.framework.name &&
+            projectInfo.framework.name !== 'unknown') {
+            contextFiles.framework = this.buildDetailedFramework(projectInfo.framework);
+        }
+        // Git information
+        if (gitInfo) {
+            const gitResult = this.buildDetailedGit(gitInfo);
+            mergeSplitFiles(gitResult, 'git');
+        }
+        return {
+            parseme: mainContent,
+            context: contextFiles,
+        };
+    }
+    buildHeader(projectInfo) {
+        return `# ${projectInfo.name}
+
+*AI-Generated Project Context*
+
+${projectInfo.description || 'No description available.'}`;
+    }
+    buildProjectOverview(projectInfo) {
+        return `## Project Overview
+
+- **Type**: ${projectInfo.type} project
+- **Package Manager**: ${projectInfo.packageManager}
+- **Framework**: ${projectInfo.framework?.name || 'None detected'}
+- **Version**: ${projectInfo.version || 'Not specified'}`;
+    }
+    buildFrameworkSection(framework) {
+        if (!framework) {
+            return '';
+        }
+        const features = framework.features.length > 0 ? `\n- **Features**: ${framework.features.join(', ')}` : '';
+        return `## Framework: ${framework.name}
+
+- **Version**: ${framework.version || 'Unknown'}${features}`;
+    }
+    buildArchitectureSection(fileAnalyses) {
+        const typeGroups = fileAnalyses.reduce((acc, file) => {
+            if (!acc[file.type]) {
+                acc[file.type] = [];
+            }
+            acc[file.type].push(file);
+            return acc;
+        }, {});
+        const archLines = Object.entries(typeGroups)
+            .map(([type, files]) => `- **${type}**: ${files.length} files`)
+            .join('\n');
+        return `## Architecture Overview
+
+${archLines}`;
+    }
+    buildRoutesSection(routes, _fileAnalyses) {
+        const routesByMethod = routes.reduce((acc, route) => {
+            if (!acc[route.method]) {
+                acc[route.method] = [];
+            }
+            acc[route.method].push(route);
+            return acc;
+        }, {});
+        const routeLines = Object.entries(routesByMethod)
+            .map(([method, methodRoutes]) => {
+            const routeList = methodRoutes
+                .map((route) => `  - \`${route.path}\` → ${route.handler}`)
+                .join('\n');
+            return `- **${method}**:\n${routeList}`;
+        })
+            .join('\n');
+        return `## API Endpoints
+
+${routeLines}`;
+    }
+    buildFileStructureSection(fileAnalyses) {
+        const structure = fileAnalyses.map((file) => `- \`${file.path}\` (${file.type})`).join('\n');
+        return `## File Structure
+
+${structure}`;
+    }
+    buildDependenciesSection(projectInfo) {
+        const deps = Object.keys(projectInfo.dependencies);
+        const devDeps = Object.keys(projectInfo.devDependencies);
+        let content = '## Dependencies\n\n';
+        if (deps.length > 0) {
+            content += `**Production**: ${deps.join(', ')}\n\n`;
+        }
+        if (devDeps.length > 0) {
+            content += `**Development**: ${devDeps.join(', ')}`;
+        }
+        return content;
+    }
+    buildGitSection(gitInfo) {
+        return `## Git Information
+
+- **Branch**: ${gitInfo.branch}
+- **Status**: ${gitInfo.status}
+- **Last Commit**: ${gitInfo.lastCommit}
+${gitInfo.changedFiles.length > 0 ? `- **Changed Files**: ${gitInfo.changedFiles.join(', ')}` : ''}`;
+    }
+    buildFooter() {
+        return `---
+
+*Generated by PARSEME v1.0.0 on ${new Date().toISOString().split('T')[0]}*`;
+    }
+    buildSummarySection(context) {
+        const { fileAnalyses, contextDir, outputPath } = context;
+        const totalFiles = fileAnalyses.length;
+        const routes = fileAnalyses.flatMap((f) => f.routes || []).length;
+        // Calculate the relative path for the link in markdown
+        let linkPath = 'parseme-context';
+        if (contextDir && outputPath) {
+            const outputDir = dirname(outputPath);
+            if (contextDir.startsWith('/')) {
+                // Absolute path: calculate relative path from output file to context dir
+                linkPath = relative(outputDir, contextDir);
+            }
+            else {
+                // Relative path: use as-is since it's relative to the output file's directory
+                linkPath = contextDir;
+            }
+        }
+        else if (contextDir) {
+            // Fallback: use contextDir as-is if no outputPath provided
+            linkPath = contextDir;
+        }
+        return `## Summary
+
+This project contains ${totalFiles} analyzed files${routes > 0 ? ` with ${routes} API endpoints` : ''}.
+
+For detailed information, see the files in the \`${linkPath}/\` directory.`;
+    }
+    buildDetailedStructure(fileAnalyses) {
+        const structureData = fileAnalyses.map((file) => ({
+            path: file.path,
+            type: file.type,
+            exports: file.exports,
+            imports: file.imports,
+            functions: file.functions,
+            classes: file.classes,
+            routes: file.routes || [],
+        }));
+        const jsonContent = JSON.stringify(structureData, null, 2);
+        const result = this.truncateContent(jsonContent);
+        if (Array.isArray(result)) {
+            // Return split files as a record with numbered keys
+            const splitFiles = {};
+            result.forEach((part, index) => {
+                const suffix = index === 0 ? '' : `_part${index + 1}`;
+                splitFiles[`structure${suffix}`] = part;
+            });
+            return splitFiles;
+        }
+        return result;
+    }
+    buildDetailedRoutes(routes, _fileAnalyses) {
+        const jsonContent = JSON.stringify(routes, null, 2);
+        const result = this.truncateContent(jsonContent);
+        if (Array.isArray(result)) {
+            const splitFiles = {};
+            result.forEach((part, index) => {
+                const suffix = index === 0 ? '' : `_part${index + 1}`;
+                splitFiles[`routes${suffix}`] = part;
+            });
+            return splitFiles;
+        }
+        return result;
+    }
+    buildDetailedDependencies(projectInfo) {
+        const jsonContent = JSON.stringify({
+            dependencies: projectInfo.dependencies,
+            packageManager: projectInfo.packageManager,
+            version: projectInfo.version,
+        }, null, 2);
+        const result = this.truncateContent(jsonContent);
+        if (Array.isArray(result)) {
+            const splitFiles = {};
+            result.forEach((part, index) => {
+                const suffix = index === 0 ? '' : `_part${index + 1}`;
+                splitFiles[`dependencies${suffix}`] = part;
+            });
+            return splitFiles;
+        }
+        return result;
+    }
+    buildDetailedFramework(framework) {
+        if (!framework) {
+            return '';
+        }
+        let content = `# Framework: ${framework.name}\n\n`;
+        content += `**Version**: ${framework.version || 'Unknown'}\n\n`;
+        if (framework.features.length > 0) {
+            content += '## Features Detected\n\n';
+            framework.features.forEach((feature) => {
+                content += `- ${feature}\n`;
+            });
+        }
+        return content;
+    }
+    buildDetailedGit(gitInfo) {
+        const jsonContent = JSON.stringify(gitInfo, null, 2);
+        const result = this.truncateContent(jsonContent);
+        if (Array.isArray(result)) {
+            const splitFiles = {};
+            result.forEach((part, index) => {
+                const suffix = index === 0 ? '' : `_part${index + 1}`;
+                splitFiles[`git${suffix}`] = part;
+            });
+            return splitFiles;
+        }
+        return result;
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};