@gguf/coder 0.3.0 → 0.3.1

package/source/init/existing-rules-extractor.ts

@@ -0,0 +1,319 @@
+import {existsSync, readFileSync} from 'fs';
+import {join} from 'path';
+
+export interface ExistingRules {
+	source: string;
+	content: string;
+	type: 'agents' | 'rules' | 'instructions';
+}
+
+export class ExistingRulesExtractor {
+	private static readonly AI_CONFIG_FILES = [
+		// AI agent specific files
+		'AGENTS.md',
+		'AGENT.md',
+		'CLAUDE.md',
+		'GEMINI.md',
+		'CURSOR.md',
+
+		// Rules files in various directories
+		'.cursor/rules',
+		'.clinerules/rules',
+		'.roorules/rules',
+
+		// Alternative locations
+		'.ai/rules',
+		'.ai/instructions',
+		'ai-instructions.md',
+		'coding-guidelines.md',
+		'dev-guidelines.md',
+	];
+
+	constructor(private projectPath: string) {}
+
+	/**
+	 * Find and extract content from existing AI configuration files
+	 */
+	public extractExistingRules(): ExistingRules[] {
+		const found: ExistingRules[] = [];
+
+		for (const configFile of ExistingRulesExtractor.AI_CONFIG_FILES) {
+			const filePath = join(this.projectPath, configFile);
+
+			if (existsSync(filePath)) {
+				try {
+					const content = readFileSync(filePath, 'utf-8');
+					const cleanContent = this.cleanAndExtractRelevantContent(
+						content,
+						configFile,
+					);
+
+					if (cleanContent.trim()) {
+						found.push({
+							source: configFile,
+							content: cleanContent,
+							type: this.determineFileType(configFile),
+						});
+					}
+				} catch {
+					// Skip files we can't read
+					continue;
+				}
+			}
+		}
+
+		return found;
+	}
+
+	/**
+	 * Clean content and extract only AI-relevant information
+	 */
+	private cleanAndExtractRelevantContent(
+		content: string,
+		filename: string,
+	): string {
+		// Remove excessive markdown formatting but keep structure
+		let cleaned = content;
+
+		// Remove multiple consecutive empty lines
+		cleaned = cleaned.replace(/\n\s*\n\s*\n/g, '\n\n');
+
+		// Remove excessive header decoration
+		cleaned = cleaned.replace(/#{4,}/g, '###');
+
+		// For specific file types, extract relevant sections
+		if (
+			filename.toLowerCase().includes('claude') ||
+			filename.toLowerCase().includes('agents')
+		) {
+			return this.extractAIAgentSections(cleaned);
+		}
+
+		if (filename.includes('rules')) {
+			return this.extractRulesSections(cleaned);
+		}
+
+		// For generic files, extract key sections
+		return this.extractGeneralInstructions(cleaned);
+	}
+
+	/**
+	 * Extract AI agent specific sections
+	 */
+	private extractAIAgentSections(content: string): string {
+		const relevantSections: string[] = [];
+		const lines = content.split('\n');
+		let currentSection = '';
+		let inRelevantSection = false;
+		let sectionHeader = '';
+
+		const relevantHeaders = [
+			'coding',
+			'style',
+			'convention',
+			'pattern',
+			'architecture',
+			'testing',
+			'security',
+			'performance',
+			'build',
+			'deployment',
+			'project',
+			'structure',
+			'guidelines',
+			'rules',
+			'instructions',
+			'important',
+			'note',
+			'requirement',
+			'constraint',
+		];
+
+		for (const line of lines) {
+			const trimmed = line.trim().toLowerCase();
+
+			// Check if this is a header
+			if (line.match(/^#+\s/) || line.match(/^[=-]{3,}$/)) {
+				// Save previous section if it was relevant
+				if (inRelevantSection && currentSection.trim()) {
+					relevantSections.push(sectionHeader + '\n' + currentSection.trim());
+				}
+
+				// Check if new section is relevant
+				inRelevantSection = relevantHeaders.some(keyword =>
+					trimmed.includes(keyword),
+				);
+				sectionHeader = line;
+				currentSection = '';
+			} else if (inRelevantSection) {
+				currentSection += line + '\n';
+			}
+		}
+
+		// Don't forget the last section
+		if (inRelevantSection && currentSection.trim()) {
+			relevantSections.push(sectionHeader + '\n' + currentSection.trim());
+		}
+
+		// If no specific sections found, extract key paragraphs
+		if (relevantSections.length === 0) {
+			return this.extractKeyParagraphs(content);
+		}
+
+		return relevantSections.join('\n\n');
+	}
+
+	/**
+	 * Extract rules file content
+	 */
+	private extractRulesSections(content: string): string {
+		// Rules files are typically more concise, keep most content
+		const lines = content.split('\n');
+		const filtered = lines.filter(line => {
+			const trimmed = line.trim();
+			// Skip very generic lines
+			if (trimmed.length < 10) return true; // Keep short lines for structure
+			if (trimmed.includes('example') && trimmed.includes('only')) return false;
+			if (trimmed.includes('this is just') && trimmed.includes('example'))
+				return false;
+			return true;
+		});
+
+		return filtered.join('\n');
+	}
+
+	/**
+	 * Extract general instructions from any file
+	 */
+	private extractGeneralInstructions(content: string): string {
+		return this.extractKeyParagraphs(content);
+	}
+
+	/**
+	 * Extract key paragraphs based on content analysis
+	 */
+	private extractKeyParagraphs(content: string): string {
+		const paragraphs = content.split('\n\n').filter(p => p.trim().length > 50);
+		const keyParagraphs: string[] = [];
+
+		const importantKeywords = [
+			'must',
+			'should',
+			'always',
+			'never',
+			'important',
+			'critical',
+			'required',
+			'mandatory',
+			'essential',
+			'convention',
+			'pattern',
+			'style',
+			'format',
+			'structure',
+			'architecture',
+			'test',
+			'security',
+		];
+
+		for (const paragraph of paragraphs) {
+			const lowerParagraph = paragraph.toLowerCase();
+			const relevanceScore = importantKeywords.reduce((score, keyword) => {
+				return score + (lowerParagraph.includes(keyword) ? 1 : 0);
+			}, 0);
+
+			// Include paragraphs with at least 2 important keywords
+			if (relevanceScore >= 2) {
+				keyParagraphs.push(paragraph.trim());
+			}
+		}
+
+		// If we didn't find enough relevant content, take first few paragraphs
+		if (keyParagraphs.length === 0 && paragraphs.length > 0) {
+			return paragraphs.slice(0, 3).join('\n\n');
+		}
+
+		return keyParagraphs.slice(0, 5).join('\n\n'); // Limit to 5 paragraphs max
+	}
+
+	/**
+	 * Determine the type of configuration file
+	 */
+	private determineFileType(
+		filename: string,
+	): 'agents' | 'rules' | 'instructions' {
+		const lower = filename.toLowerCase();
+
+		if (
+			lower.includes('agent') ||
+			lower.includes('claude') ||
+			lower.includes('gemini')
+		) {
+			return 'agents';
+		}
+
+		if (
+			lower.includes('rule') ||
+			lower.includes('.cursor/') ||
+			lower.includes('.clinerules/')
+		) {
+			return 'rules';
+		}
+
+		return 'instructions';
+	}
+
+	/**
+	 * Merge existing rules into a single consolidated section
+	 */
+	public static mergeExistingRules(existingRules: ExistingRules[]): string {
+		if (existingRules.length === 0) {
+			return '';
+		}
+
+		const sections: string[] = [];
+		sections.push('## Existing Project Guidelines');
+		sections.push('');
+		sections.push(
+			'*The following guidelines were found in existing AI configuration files:*',
+		);
+		sections.push('');
+
+		// Group by type
+		const agentRules = existingRules.filter(r => r.type === 'agents');
+		const ruleFiles = existingRules.filter(r => r.type === 'rules');
+		const instructions = existingRules.filter(r => r.type === 'instructions');
+
+		// Add agent-specific rules
+		if (agentRules.length > 0) {
+			sections.push('### AI Agent Guidelines');
+			for (const rule of agentRules) {
+				sections.push(`**From ${rule.source}:**`);
+				sections.push(rule.content);
+				sections.push('');
+			}
+		}
+
+		// Add rule files
+		if (ruleFiles.length > 0) {
+			sections.push('### Project Rules');
+			for (const rule of ruleFiles) {
+				sections.push(`**From ${rule.source}:**`);
+				sections.push(rule.content);
+				sections.push('');
+			}
+		}
+
+		// Add general instructions
+		if (instructions.length > 0) {
+			sections.push('### Additional Instructions');
+			for (const rule of instructions) {
+				sections.push(`**From ${rule.source}:**`);
+				sections.push(rule.content);
+				sections.push('');
+			}
+		}
+
+		return sections.join('\n');
+	}
+}

package/source/init/file-scanner.spec.ts

@@ -0,0 +1,227 @@
+import { writeFileSync, rmSync, existsSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import test from 'ava';
+import { FileScanner } from './file-scanner';
+
+// Create a temporary test directory
+const testDir = join(tmpdir(), `coder-file-scanner-test-${Date.now()}`);
+
+test.before(() => {
+	// Create test directory 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('FileScanner - constructor initializes with root path', t => {
+	const scanner = new FileScanner(testDir);
+
+	t.truthy(scanner);
+});
+
+test('FileScanner - scan returns ScanResult structure', t => {
+	const scanner = new FileScanner(testDir);
+
+	const result = scanner.scan();
+
+	t.true(Array.isArray(result.files));
+	t.true(Array.isArray(result.directories));
+	t.is(typeof result.totalFiles, 'number');
+	t.is(typeof result.scannedFiles, 'number');
+});
+
+test('FileScanner - scan finds files in directory', t => {
+	// Create some test files
+	writeFileSync(join(testDir, 'package.json'), '{}', 'utf-8');
+	writeFileSync(join(testDir, 'README.md'), '# Test', 'utf-8');
+	writeFileSync(join(testDir, 'src', 'index.ts'), 'test', 'utf-8');
+
+	const scanner = new FileScanner(testDir);
+	const result = scanner.scan();
+
+	t.true(result.files.includes('package.json'));
+	t.true(result.files.includes('README.md'));
+	t.true(result.files.includes('src/index.ts'));
+});
+
+test('FileScanner - scan finds directories', t => {
+	const scanner = new FileScanner(testDir);
+	const result = scanner.scan();
+
+	t.true(result.directories.includes('src'));
+	t.true(result.directories.includes('test'));
+	t.true(result.directories.includes('docs'));
+});
+
+test('FileScanner - scan ignores node_modules directory', t => {
+	// Create node_modules directory
+	mkdirSync(join(testDir, 'node_modules'), {recursive: true});
+	mkdirSync(join(testDir, 'node_modules', 'package'), {recursive: true});
+	writeFileSync(join(testDir, 'node_modules', 'package', 'test'), 'test', 'utf-8');
+
+	const scanner = new FileScanner(testDir);
+	const result = scanner.scan();
+
+	// node_modules should not be in files or directories
+	t.false(result.files.some(f => f.includes('node_modules')));
+	t.false(result.directories.some(d => d.includes('node_modules')));
+});
+
+test('FileScanner - scan ignores .git directory', t => {
+	// Create .git directory
+	mkdirSync(join(testDir, '.git'), {recursive: true});
+	writeFileSync(join(testDir, '.git', 'config'), 'test', 'utf-8');
+
+	const scanner = new FileScanner(testDir);
+	const result = scanner.scan();
+
+	t.false(result.files.some(f => f.includes('.git')));
+	t.false(result.directories.some(d => d.includes('.git')));
+});
+
+test('FileScanner - scan ignores dist directory', t => {
+	// Create dist directory
+	mkdirSync(join(testDir, 'dist'), {recursive: true});
+	writeFileSync(join(testDir, 'dist', 'bundle.js'), 'test', 'utf-8');
+
+	const scanner = new FileScanner(testDir);
+	const result = scanner.scan();
+
+	t.false(result.files.some(f => f.includes('dist')));
+	t.false(result.directories.some(d => d.includes('dist')));
+});
+
+test('FileScanner - scan respects .gitignore patterns', t => {
+	// Create .gitignore file
+	writeFileSync(join(testDir, '.gitignore'), '*.log\ntemp/\n.cache', 'utf-8');
+
+	// Create files that should be ignored
+	writeFileSync(join(testDir, 'debug.log'), 'log', 'utf-8');
+	mkdirSync(join(testDir, 'temp'), {recursive: true});
+	writeFileSync(join(testDir, 'temp', 'file.txt'), 'test', 'utf-8');
+
+	const scanner = new FileScanner(testDir);
+	const result = scanner.scan();
+
+	// These files should be ignored
+	t.false(result.files.includes('debug.log'));
+	t.false(result.files.some(f => f.includes('temp')));
+});
+
+test('FileScanner - getFilesByPattern filters files by pattern', t => {
+	// Create various files
+	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, 'src', 'index.ts'), 'test', 'utf-8');
+
+	const scanner = new FileScanner(testDir);
+	const jsonFiles = scanner.getFilesByPattern(['*.json']);
+
+	t.true(jsonFiles.includes('package.json'));
+	t.true(jsonFiles.includes('tsconfig.json'));
+	t.false(jsonFiles.includes('README.md'));
+	t.false(jsonFiles.includes('src/index.ts'));
+});
+
+test('FileScanner - getFilesByPattern with multiple patterns', t => {
+	// Create files
+	writeFileSync(join(testDir, 'README.md'), '# Test', 'utf-8');
+	writeFileSync(join(testDir, 'CHANGELOG.md'), '# Changelog', 'utf-8');
+	writeFileSync(join(testDir, 'package.json'), '{}', 'utf-8');
+	writeFileSync(join(testDir, 'src', 'index.ts'), 'test', 'utf-8');
+
+	const scanner = new FileScanner(testDir);
+	const docsAndConfig = scanner.getFilesByPattern(['*.md', '*.json']);
+
+	t.true(docsAndConfig.includes('README.md'));
+	t.true(docsAndConfig.includes('CHANGELOG.md'));
+	t.true(docsAndConfig.includes('package.json'));
+	t.false(docsAndConfig.includes('src/index.ts'));
+});
+
+test('FileScanner - getProjectFiles returns categorized files', t => {
+	// Create various project files
+	writeFileSync(join(testDir, 'package.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');
+	writeFileSync(join(testDir, 'tsconfig.json'), '{}', 'utf-8');
+
+	const scanner = new FileScanner(testDir);
+	const projectFiles = scanner.getProjectFiles();
+
+	t.true(Array.isArray(projectFiles.config));
+	t.true(Array.isArray(projectFiles.documentation));
+	t.true(Array.isArray(projectFiles.build));
+	t.true(Array.isArray(projectFiles.test));
+
+	t.true(projectFiles.config.includes('package.json'));
+	// tsconfig.json is in build files, not config
+	t.true(projectFiles.build.includes('tsconfig.json'));
+	t.true(projectFiles.documentation.includes('README.md'));
+	t.true(projectFiles.build.includes('Makefile'));
+	t.true(projectFiles.test.some(f => f.includes('index.spec')));
+});
+
+test('FileScanner - scan handles empty directory', t => {
+	const emptyDir = join(testDir, 'empty');
+	mkdirSync(emptyDir, {recursive: true});
+
+	const scanner = new FileScanner(emptyDir);
+	const result = scanner.scan();
+
+	t.is(result.files.length, 0);
+	t.is(result.directories.length, 0);
+});
+
+test('FileScanner - scan counts files correctly', t => {
+	// Create some files
+	writeFileSync(join(testDir, 'file1.txt'), 'test', 'utf-8');
+	writeFileSync(join(testDir, 'file2.txt'), 'test', 'utf-8');
+	writeFileSync(join(testDir, 'file3.txt'), 'test', 'utf-8');
+
+	const scanner = new FileScanner(testDir);
+	const result = scanner.scan();
+
+	// Note: totalFiles includes both files and directories
+	t.true(result.totalFiles >= 3);
+	t.true(result.scannedFiles >= 3);
+});
+
+test('FileScanner - getFilesByPattern with docs pattern', t => {
+	// Create documentation files
+	writeFileSync(join(testDir, 'README.md'), '# Test', 'utf-8');
+	writeFileSync(join(testDir, 'docs', 'guide.md'), '# Guide', 'utf-8');
+	writeFileSync(join(testDir, 'src', 'index.ts'), 'test', 'utf-8');
+
+	const scanner = new FileScanner(testDir);
+	const docPatterns = ['README*', '*.md', 'docs/*'];
+	const docs = scanner.getFilesByPattern(docPatterns);
+
+	t.true(docs.includes('README.md'));
+	t.true(docs.some(f => f.includes('docs/guide.md')));
+});
+
+test('FileScanner - scan handles subdirectories', t => {
+	// Create nested structure
+	mkdirSync(join(testDir, 'src', 'components'), {recursive: true});
+	writeFileSync(join(testDir, 'src', 'index.ts'), 'test', 'utf-8');
+	writeFileSync(join(testDir, 'src', 'components', 'Button.tsx'), 'test', 'utf-8');
+
+	const scanner = new FileScanner(testDir);
+	const result = scanner.scan();
+
+	t.true(result.files.includes('src/index.ts'));
+	t.true(result.files.includes('src/components/Button.tsx'));
+	t.true(result.directories.includes('src/components'));
+});