@gguf/coder 0.2.9 → 0.3.1

package/source/init/language-detector.ts

@@ -0,0 +1,269 @@
+import {basename, extname} from 'path';
+import {MAX_SECONDARY_LANGUAGES, MIN_LANGUAGE_PERCENTAGE} from '@/constants';
+
+interface LanguageInfo {
+	name: string;
+	extensions: string[];
+	percentage: number;
+	files: string[];
+}
+
+export interface DetectedLanguages {
+	primary: LanguageInfo | null;
+	secondary: LanguageInfo[];
+	all: LanguageInfo[];
+}
+
+export class LanguageDetector {
+	private static readonly LANGUAGE_MAP: {[ext: string]: string} = {
+		// JavaScript/TypeScript ecosystem
+		'.js': 'JavaScript',
+		'.jsx': 'JavaScript',
+		'.ts': 'TypeScript',
+		'.tsx': 'TypeScript',
+		'.mjs': 'JavaScript',
+		'.cjs': 'JavaScript',
+
+		// Python
+		'.py': 'Python',
+		'.pyx': 'Python',
+		'.pyi': 'Python',
+		'.pyc': 'Python',
+
+		// Rust
+		'.rs': 'Rust',
+
+		// Go
+		'.go': 'Go',
+
+		// Java/Kotlin
+		'.java': 'Java',
+		'.kt': 'Kotlin',
+		'.kts': 'Kotlin',
+
+		// C/C++
+		'.c': 'C',
+		'.h': 'C',
+		'.cpp': 'C++',
+		'.cxx': 'C++',
+		'.cc': 'C++',
+		'.hpp': 'C++',
+		'.hxx': 'C++',
+
+		// C#
+		'.cs': 'C#',
+
+		// PHP
+		'.php': 'PHP',
+
+		// Ruby
+		'.rb': 'Ruby',
+
+		// Swift
+		'.swift': 'Swift',
+
+		// Dart
+		'.dart': 'Dart',
+
+		// Shell
+		'.sh': 'Shell',
+		'.bash': 'Shell',
+		'.zsh': 'Shell',
+		'.fish': 'Shell',
+
+		// Web technologies
+		'.html': 'HTML',
+		'.htm': 'HTML',
+		'.css': 'CSS',
+		'.scss': 'SCSS',
+		'.sass': 'Sass',
+		'.less': 'Less',
+		'.vue': 'Vue',
+		'.svelte': 'Svelte',
+
+		// Config/Data
+		'.json': 'JSON',
+		'.yaml': 'YAML',
+		'.yml': 'YAML',
+		'.toml': 'TOML',
+		'.xml': 'XML',
+		'.ini': 'INI',
+
+		// Documentation
+		'.md': 'Markdown',
+		'.mdx': 'Markdown',
+		'.rst': 'reStructuredText',
+
+		// SQL
+		'.sql': 'SQL',
+
+		// Docker
+		'.dockerfile': 'Dockerfile',
+	};
+
+	/**
+	 * Detect languages from file list
+	 */
+	public static detectLanguages(files: string[]): DetectedLanguages {
+		const languageCounts: {[language: string]: string[]} = {};
+		const totalFiles = files.length;
+
+		// Count files by language
+		for (const file of files) {
+			const ext = extname(file).toLowerCase();
+			const filename = basename(file).toLowerCase();
+
+			let language: string | undefined;
+
+			// Special case handling
+			if (filename === 'dockerfile' || filename.startsWith('dockerfile.')) {
+				language = 'Dockerfile';
+			} else if (filename === 'makefile') {
+				language = 'Makefile';
+			} else {
+				language = this.LANGUAGE_MAP[ext];
+			}
+
+			if (language) {
+				if (!languageCounts[language]) {
+					languageCounts[language] = [];
+				}
+				languageCounts[language].push(file);
+			}
+		}
+
+		// Convert to LanguageInfo array
+		const languageInfos: LanguageInfo[] = Object.entries(languageCounts)
+			.map(([language, fileList]) => ({
+				name: language,
+				extensions: this.getExtensionsForLanguage(language),
+				percentage: Math.round((fileList.length / totalFiles) * 100),
+				files: fileList,
+			}))
+			.sort((a, b) => b.files.length - a.files.length);
+
+		// Determine primary and secondary languages
+		const primary = languageInfos.length > 0 ? languageInfos[0] : null;
+		const secondary = languageInfos
+			.slice(1)
+			.filter(lang => lang.percentage >= MIN_LANGUAGE_PERCENTAGE) // At least MIN_LANGUAGE_PERCENTAGE% of files
+			.slice(0, MAX_SECONDARY_LANGUAGES); // Top MAX_SECONDARY_LANGUAGES secondary languages
+
+		return {
+			primary,
+			secondary,
+			all: languageInfos,
+		};
+	}
+
+	/**
+	 * Get file extensions for a given language
+	 */
+	private static getExtensionsForLanguage(language: string): string[] {
+		return Object.entries(this.LANGUAGE_MAP)
+			.filter(([_, lang]) => lang === language)
+			.map(([ext]) => ext);
+	}
+
+	/**
+	 * Get language category (for grouping related languages)
+	 */
+	public static getLanguageCategory(language: string): string {
+		const categories: {[category: string]: string[]} = {
+			'Web Frontend': [
+				'JavaScript',
+				'TypeScript',
+				'HTML',
+				'CSS',
+				'SCSS',
+				'Sass',
+				'Less',
+				'Vue',
+				'Svelte',
+			],
+			'Web Backend': ['Node.js', 'PHP', 'Python', 'Ruby', 'Java', 'C#', 'Go'],
+			'Systems Programming': ['Rust', 'C', 'C++', 'Go'],
+			Mobile: ['Swift', 'Kotlin', 'Dart', 'Java'],
+			'Data & Config': ['JSON', 'YAML', 'TOML', 'XML', 'INI', 'SQL'],
+			Documentation: ['Markdown', 'reStructuredText'],
+			DevOps: ['Shell', 'Dockerfile', 'Makefile'],
+		};
+
+		for (const [category, languages] of Object.entries(categories)) {
+			if (languages.includes(language)) {
+				return category;
+			}
+		}
+
+		return 'Other';
+	}
+
+	/**
+	 * Suggest project type based on detected languages
+	 */
+	public static suggestProjectType(languages: DetectedLanguages): string {
+		if (!languages.primary) {
+			return 'Unknown';
+		}
+
+		const primary = languages.primary.name;
+		const hasSecondary = (lang: string) =>
+			languages.secondary.some(l => l.name === lang);
+
+		// Web applications
+		if (primary === 'JavaScript' || primary === 'TypeScript') {
+			if (
+				hasSecondary('HTML') ||
+				hasSecondary('CSS') ||
+				hasSecondary('Vue') ||
+				hasSecondary('Svelte')
+			) {
+				return 'Web Application';
+			}
+			return 'Node.js Application';
+		}
+
+		// Python projects
+		if (primary === 'Python') {
+			return 'Python Application';
+		}
+
+		// Mobile apps
+		if (primary === 'Swift') {
+			return 'iOS Application';
+		}
+		if (primary === 'Kotlin' && hasSecondary('XML')) {
+			return 'Android Application';
+		}
+		if (primary === 'Dart') {
+			return 'Flutter Application';
+		}
+
+		// Systems programming
+		if (primary === 'Rust') {
+			return 'Rust Application';
+		}
+		if (primary === 'C' || primary === 'C++') {
+			return 'C/C++ Application';
+		}
+		if (primary === 'Go') {
+			return 'Go Application';
+		}
+
+		// Other languages
+		if (primary === 'Java') {
+			return 'Java Application';
+		}
+		if (primary === 'C#') {
+			return 'C# Application';
+		}
+		if (primary === 'PHP') {
+			return 'PHP Application';
+		}
+		if (primary === 'Ruby') {
+			return 'Ruby Application';
+		}
+
+		return `${primary} Project`;
+	}
+}

package/source/init/project-analyzer.spec.ts

@@ -0,0 +1,231 @@
+import { writeFileSync, rmSync, existsSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import test from 'ava';
+import { ProjectAnalyzer } from './project-analyzer';
+
+// Create a temporary test directory
+const testDir = join(tmpdir(), `coder-project-analyzer-test-${Date.now()}`);
+
+test.before(() => {
+	// Create test directory with some structure
+	mkdirSync(testDir, {recursive: true});
+	mkdirSync(join(testDir, 'src'), {recursive: true});
+	mkdirSync(join(testDir, 'test'), {recursive: true});
+	mkdirSync(join(testDir, 'docs'), {recursive: true});
+});
+
+test.after.always(() => {
+	// Clean up test directory
+	if (existsSync(testDir)) {
+		rmSync(testDir, {recursive: true, force: true});
+	}
+});
+
+test('ProjectAnalyzer - constructor initializes with project path', t => {
+	const analyzer = new ProjectAnalyzer(testDir);
+
+	t.truthy(analyzer);
+});
+
+test('ProjectAnalyzer - isCodeFile identifies code files by extension', t => {
+	const analyzer = new ProjectAnalyzer(testDir);
+
+	// This is a private method but we can test the public analyze method
+	// which uses it internally
+	t.pass('isCodeFile is tested implicitly through analyze method');
+});
+
+test('ProjectAnalyzer - isTestFile identifies test files', t => {
+	const analyzer = new ProjectAnalyzer(testDir);
+
+	// Create test files and directories
+	mkdirSync(join(testDir, '__tests__'), {recursive: true});
+	writeFileSync(join(testDir, 'app.test.js'), 'test');
+	writeFileSync(join(testDir, 'app.spec.ts'), 'test');
+	writeFileSync(join(testDir, '__tests__', 'app.js'), 'test');
+	writeFileSync(join(testDir, 'src', 'app.js'), 'test');
+
+	// Test file identification is used in analyze method
+	const analysis = analyzer.analyze();
+
+	// The analysis should work without throwing
+	t.truthy(analysis);
+});
+
+test('ProjectAnalyzer - getImportantDirectories returns sorted directories', t => {
+	const analyzer = new ProjectAnalyzer(testDir);
+
+	// Create more directories
+	mkdirSync(join(testDir, 'components'), {recursive: true});
+	mkdirSync(join(testDir, 'lib'), {recursive: true});
+	mkdirSync(join(testDir, 'build'), {recursive: true});
+
+	// Create files in directories so they're scanned
+	writeFileSync(join(testDir, 'src', 'app.ts'), 'test');
+	writeFileSync(join(testDir, 'components', 'Button.tsx'), 'test');
+	writeFileSync(join(testDir, 'lib', 'utils.ts'), 'test');
+
+	const analysis = analyzer.analyze();
+
+	t.true(Array.isArray(analysis.structure.importantDirectories));
+});
+
+test('ProjectAnalyzer - extractProjectMetadata reads package.json', t => {
+	const analyzer = new ProjectAnalyzer(testDir);
+
+	// Create package.json
+	writeFileSync(
+		join(testDir, 'package.json'),
+		JSON.stringify({
+			name: 'test-project',
+			description: 'A test project',
+			repository: 'https://github.com/test/test'
+		}),
+		'utf-8'
+	);
+
+	const analysis = analyzer.analyze();
+
+	t.is(analysis.projectName, 'test-project');
+	t.is(analysis.description, 'A test project');
+	t.is(analysis.repository, 'https://github.com/test/test');
+});
+
+test('ProjectAnalyzer - extractProjectMetadata with minimal package.json', t => {
+	const analyzer = new ProjectAnalyzer(testDir);
+
+	// Create package.json without optional fields
+	writeFileSync(
+		join(testDir, 'package.json'),
+		JSON.stringify({
+			name: 'minimal-project'
+		}),
+		'utf-8'
+	);
+
+	const analysis = analyzer.analyze();
+
+	t.is(analysis.projectName, 'minimal-project');
+});
+
+test('ProjectAnalyzer - extractProjectMetadata uses directory name as fallback', t => {
+	// Use a fresh subdirectory for this test to avoid picking up files from previous tests
+	const subDir = join(testDir, 'fallback-test');
+	mkdirSync(subDir, {recursive: true});
+
+	const analyzer = new ProjectAnalyzer(subDir);
+
+	const analysis = analyzer.analyze();
+
+	t.is(analysis.projectName, 'fallback-test');
+});
+
+test('ProjectAnalyzer - extractProjectMetadata handles repository object', t => {
+	const analyzer = new ProjectAnalyzer(testDir);
+
+	writeFileSync(
+		join(testDir, 'package.json'),
+		JSON.stringify({
+			name: 'test-project',
+			repository: {
+				type: 'git',
+				url: 'https://github.com/test/test.git'
+			}
+		}),
+		'utf-8'
+	);
+
+	const analysis = analyzer.analyze();
+
+	t.is(analysis.repository, 'https://github.com/test/test.git');
+});
+
+test('ProjectAnalyzer - analyze returns complete analysis object', t => {
+	const analyzer = new ProjectAnalyzer(testDir);
+
+	// Create some files to analyze
+	writeFileSync(join(testDir, 'package.json'), JSON.stringify({ name: 'test' }), 'utf-8');
+	writeFileSync(join(testDir, 'src', 'index.ts'), 'console.log("test");');
+	writeFileSync(join(testDir, 'README.md'), '# Test Project\n\nA test project');
+	writeFileSync(join(testDir, 'tsconfig.json'), '{}');
+
+	const analysis = analyzer.analyze();
+
+	// Verify the structure
+	t.is(analysis.projectPath, testDir);
+	t.is(analysis.projectName, 'test');
+	t.truthy(analysis.languages);
+	t.truthy(analysis.dependencies);
+	t.is(typeof analysis.projectType, 'string');
+	t.truthy(analysis.keyFiles);
+	t.truthy(analysis.structure);
+	t.truthy(analysis.buildCommands);
+});
+
+test('ProjectAnalyzer - getCodingConventions returns conventions', t => {
+	const analyzer = new ProjectAnalyzer(testDir);
+
+	// Create a JavaScript project
+	writeFileSync(
+		join(testDir, 'package.json'),
+		JSON.stringify({ name: 'js-project' }),
+		'utf-8'
+	);
+	writeFileSync(join(testDir, 'src', 'index.js'), 'console.log("test");');
+
+	const conventions = analyzer.getCodingConventions();
+
+	t.true(Array.isArray(conventions));
+});
+
+test('ProjectAnalyzer - getCodingConventions for TypeScript project', t => {
+	const analyzer = new ProjectAnalyzer(testDir);
+
+	// Create a TypeScript project
+	writeFileSync(
+		join(testDir, 'package.json'),
+		JSON.stringify({ name: 'ts-project' }),
+		'utf-8'
+	);
+	writeFileSync(join(testDir, 'tsconfig.json'), '{}');
+	writeFileSync(join(testDir, 'src', 'index.ts'), 'const x: number = 1;');
+
+	const conventions = analyzer.getCodingConventions();
+
+	// TypeScript should have similar conventions to JavaScript
+	t.true(Array.isArray(conventions));
+});
+
+test('ProjectAnalyzer - structure contains scanned files info', t => {
+	const analyzer = new ProjectAnalyzer(testDir);
+
+	// Create files
+	writeFileSync(join(testDir, 'package.json'), '{}', 'utf-8');
+	writeFileSync(join(testDir, 'src', 'index.ts'), 'test');
+	writeFileSync(join(testDir, 'src', 'utils.ts'), 'test');
+
+	const analysis = analyzer.analyze();
+
+	t.is(typeof analysis.structure.totalFiles, 'number');
+	t.is(typeof analysis.structure.scannedFiles, 'number');
+	t.true(Array.isArray(analysis.structure.directories));
+});
+
+test('ProjectAnalyzer - keyFiles categorizes files correctly', t => {
+	const analyzer = new ProjectAnalyzer(testDir);
+
+	// Create various file types
+	writeFileSync(join(testDir, 'package.json'), '{}', 'utf-8');
+	writeFileSync(join(testDir, 'tsconfig.json'), '{}', 'utf-8');
+	writeFileSync(join(testDir, 'README.md'), '# Test', 'utf-8');
+	writeFileSync(join(testDir, 'Makefile'), 'build:', 'utf-8');
+	writeFileSync(join(testDir, 'test', 'index.spec.ts'), 'test', 'utf-8');
+
+	const analysis = analyzer.analyze();
+
+	t.true(Array.isArray(analysis.keyFiles.config));
+	t.true(Array.isArray(analysis.keyFiles.documentation));
+	t.true(Array.isArray(analysis.keyFiles.build));
+	t.true(Array.isArray(analysis.keyFiles.test));
+});