@gguf/coder 0.2.9 → 0.3.1

package/source/init/file-scanner.ts

@@ -0,0 +1,238 @@
+import {existsSync, readFileSync, readdirSync, statSync} from 'fs';
+import {basename, join, relative} from 'path';
+import {MAX_DIRECTORY_DEPTH, MAX_FILES_TO_SCAN} from '@/constants';
+
+interface ScanResult {
+	files: string[];
+	directories: string[];
+	totalFiles: number;
+	scannedFiles: number;
+}
+
+export class FileScanner {
+	private gitignorePatterns: string[] = [];
+	private maxFiles = MAX_FILES_TO_SCAN; // Prevent scanning massive codebases
+	private maxDepth = MAX_DIRECTORY_DEPTH; // Prevent infinite recursion
+
+	constructor(private rootPath: string) {
+		this.loadGitignore();
+	}
+
+	/**
+	 * Load and parse .gitignore patterns
+	 */
+	private loadGitignore(): void {
+		const gitignorePath = join(this.rootPath, '.gitignore');
+
+		if (!existsSync(gitignorePath)) {
+			return;
+		}
+
+		try {
+			const content = readFileSync(gitignorePath, 'utf-8');
+			this.gitignorePatterns = content
+				.split('\n')
+				.map(line => line.trim())
+				.filter(line => line && !line.startsWith('#'))
+				.map(pattern => {
+					// Convert gitignore patterns to simple regex patterns
+					return pattern
+						.replace(/\*/g, '.*') // * -> .*
+						.replace(/\?/g, '.') // ? -> .
+						.replace(/\/$/, ''); // Remove trailing slash
+				});
+		} catch {
+			// Ignore gitignore parsing errors
+		}
+	}
+
+	/**
+	 * Check if a file/directory should be ignored based on .gitignore
+	 */
+	private shouldIgnore(filePath: string): boolean {
+		const relativePath = relative(this.rootPath, filePath);
+		const fileName = basename(filePath);
+
+		// Always ignore these directories
+		const alwaysIgnore = [
+			'node_modules',
+			'.git',
+			'.svn',
+			'.hg',
+			'dist',
+			'build',
+			'.next',
+			'.nuxt',
+			'__pycache__',
+			'.pytest_cache',
+			'target',
+			'coverage',
+		];
+
+		if (
+			alwaysIgnore.some(
+				ignored => relativePath.includes(ignored) || fileName === ignored,
+			)
+		) {
+			return true;
+		}
+
+		// Check gitignore patterns
+		return this.gitignorePatterns.some(pattern => {
+			// nosemgrep: javascript.lang.security.audit.detect-non-literal-regexp.detect-non-literal-regexp
+			// pattern comes from .gitignore file, not user input
+			const regex = new RegExp(`^${pattern}$`); // nosemgrep: javascript.lang.security.audit.detect-non-literal-regexp.detect-non-literal-regexp
+			return regex.test(relativePath) || regex.test(fileName);
+		});
+	}
+
+	/**
+	 * Recursively scan directory for files
+	 */
+	public scan(): ScanResult {
+		const result: ScanResult = {
+			files: [],
+			directories: [],
+			totalFiles: 0,
+			scannedFiles: 0,
+		};
+
+		this.scanDirectory(this.rootPath, result, 0);
+		return result;
+	}
+
+	/**
+	 * Recursively scan a directory
+	 */
+	private scanDirectory(
+		dirPath: string,
+		result: ScanResult,
+		depth: number,
+	): void {
+		if (depth > this.maxDepth || result.scannedFiles >= this.maxFiles) {
+			return;
+		}
+
+		if (this.shouldIgnore(dirPath)) {
+			return;
+		}
+
+		try {
+			const entries = readdirSync(dirPath);
+
+			for (const entry of entries) {
+				if (result.scannedFiles >= this.maxFiles) {
+					break;
+				}
+
+				// nosemgrep
+				const fullPath = join(dirPath, entry); // nosemgrep
+				const relativePath = relative(this.rootPath, fullPath);
+
+				if (this.shouldIgnore(fullPath)) {
+					continue;
+				}
+
+				try {
+					const stats = statSync(fullPath);
+
+					if (stats.isDirectory()) {
+						result.directories.push(relativePath);
+						this.scanDirectory(fullPath, result, depth + 1);
+					} else if (stats.isFile()) {
+						result.files.push(relativePath);
+						result.scannedFiles++;
+					}
+
+					result.totalFiles++;
+				} catch {
+					// Skip files we can't stat (permission issues, etc.)
+					continue;
+				}
+			}
+		} catch {
+			// Skip directories we can't read
+			return;
+		}
+	}
+
+	/**
+	 * Convert a simple glob-like pattern (using '*' as wildcard) to a RegExp.
+	 * Escapes regex metacharacters before expanding '*' to '.*'.
+	 */
+	private globToRegExp(pattern: string): RegExp {
+		// Validate pattern to prevent ReDoS - only allow safe glob patterns
+		if (pattern.length > 1000) {
+			throw new Error('Pattern too long');
+		}
+
+		// Only allow safe characters in glob patterns
+		if (/[^a-zA-Z0-9_\-./\\*?+[\]{}^$|()]/.test(pattern)) {
+			throw new Error('Pattern contains unsafe characters');
+		}
+
+		// Escape all regex metacharacters, then replace escaped '*' with '.*'
+		const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+		const regexSource = escaped.replace(/\\\*/g, '.*');
+		return new RegExp(regexSource, 'i'); /* nosemgrep */
+	}
+
+	/**
+	 * Get files matching specific patterns
+	 */
+	public getFilesByPattern(patterns: string[]): string[] {
+		const scanResult = this.scan();
+		return scanResult.files.filter(file =>
+			patterns.some(pattern => {
+				const regex = this.globToRegExp(pattern);
+				return regex.test(file) || regex.test(basename(file));
+			}),
+		);
+	}
+
+	/**
+	 * Get key project files
+	 */
+	public getProjectFiles(): {[key: string]: string[]} {
+		return {
+			config: this.getFilesByPattern([
+				'package.json',
+				'requirements.txt',
+				'Cargo.toml',
+				'go.mod',
+				'composer.json',
+				'Gemfile',
+				'setup.py',
+				'pyproject.toml',
+				'yarn.lock',
+				'pnpm-lock.yaml',
+			]),
+			documentation: this.getFilesByPattern([
+				'README*',
+				'CHANGELOG*',
+				'LICENSE*',
+				'CONTRIBUTING*',
+				'*.md',
+				'docs/*',
+			]),
+			build: this.getFilesByPattern([
+				'Makefile',
+				'CMakeLists.txt',
+				'build.gradle',
+				'webpack.config.*',
+				'vite.config.*',
+				'rollup.config.*',
+				'tsconfig.json',
+				'jsconfig.json',
+			]),
+			test: this.getFilesByPattern([
+				'*test*',
+				'*spec*',
+				'__tests__/*',
+				'test/*',
+				'tests/*',
+				'spec/*',
+			]),
+		};
+	}
+}

package/source/init/framework-detector.ts

@@ -0,0 +1,382 @@
+import {existsSync, readFileSync} from 'fs';
+import {join} from 'path';
+
+interface FrameworkInfo {
+	name: string;
+	version?: string;
+	category:
+		| 'web'
+		| 'mobile'
+		| 'desktop'
+		| 'backend'
+		| 'testing'
+		| 'build'
+		| 'other';
+	confidence: 'high' | 'medium' | 'low';
+}
+
+interface BuildInfo {
+	scripts?: {[script: string]: string};
+	buildCommand?: string;
+	testCommand?: string;
+	devCommand?: string;
+	startCommand?: string;
+}
+
+interface PackageJson {
+	scripts?: {[script: string]: string};
+	dependencies?: {[dep: string]: string};
+	devDependencies?: {[dep: string]: string};
+	peerDependencies?: {[dep: string]: string};
+}
+
+export interface ProjectDependencies {
+	frameworks: FrameworkInfo[];
+	buildTools: string[];
+	testingFrameworks: string[];
+	buildInfo: BuildInfo;
+}
+
+export class FrameworkDetector {
+	private static readonly FRAMEWORK_PATTERNS = {
+		// Web Frameworks
+		react: {name: 'React', category: 'web' as const},
+		vue: {name: 'Vue.js', category: 'web' as const},
+		angular: {name: 'Angular', category: 'web' as const},
+		'@angular/core': {name: 'Angular', category: 'web' as const},
+		svelte: {name: 'Svelte', category: 'web' as const},
+		next: {name: 'Next.js', category: 'web' as const},
+		nuxt: {name: 'Nuxt.js', category: 'web' as const},
+		express: {name: 'Express.js', category: 'backend' as const},
+		fastify: {name: 'Fastify', category: 'backend' as const},
+		koa: {name: 'Koa', category: 'backend' as const},
+		nestjs: {name: 'NestJS', category: 'backend' as const},
+
+		// Python Frameworks
+		django: {name: 'Django', category: 'backend' as const},
+		flask: {name: 'Flask', category: 'backend' as const},
+		fastapi: {name: 'FastAPI', category: 'backend' as const},
+
+		// Build Tools
+		webpack: {name: 'Webpack', category: 'build' as const},
+		vite: {name: 'Vite', category: 'build' as const},
+		rollup: {name: 'Rollup', category: 'build' as const},
+		parcel: {name: 'Parcel', category: 'build' as const},
+		esbuild: {name: 'esbuild', category: 'build' as const},
+
+		// Testing Frameworks
+		jest: {name: 'Jest', category: 'testing' as const},
+		mocha: {name: 'Mocha', category: 'testing' as const},
+		chai: {name: 'Chai', category: 'testing' as const},
+		jasmine: {name: 'Jasmine', category: 'testing' as const},
+		cypress: {name: 'Cypress', category: 'testing' as const},
+		playwright: {name: 'Playwright', category: 'testing' as const},
+		vitest: {name: 'Vitest', category: 'testing' as const},
+
+		// Mobile
+		'react-native': {name: 'React Native', category: 'mobile' as const},
+		flutter: {name: 'Flutter', category: 'mobile' as const},
+		ionic: {name: 'Ionic', category: 'mobile' as const},
+
+		// Desktop
+		electron: {name: 'Electron', category: 'desktop' as const},
+		tauri: {name: 'Tauri', category: 'desktop' as const},
+	};
+
+	constructor(private projectPath: string) {}
+
+	/**
+	 * Detect frameworks and dependencies in the project
+	 */
+	public detectDependencies(): ProjectDependencies {
+		const result: ProjectDependencies = {
+			frameworks: [],
+			buildTools: [],
+			testingFrameworks: [],
+			buildInfo: {},
+		};
+
+		// Check different dependency files
+		this.checkPackageJson(result);
+		this.checkRequirementsTxt(result);
+		this.checkCargoToml(result);
+		this.checkGoMod(result);
+
+		// Deduplicate frameworks by name
+		const uniqueFrameworks = new Map<string, FrameworkInfo>();
+		for (const framework of result.frameworks) {
+			const existing = uniqueFrameworks.get(framework.name);
+			if (!existing || framework.confidence === 'high') {
+				uniqueFrameworks.set(framework.name, framework);
+			}
+		}
+		result.frameworks = Array.from(uniqueFrameworks.values());
+
+		// Deduplicate build tools and testing frameworks
+		result.buildTools = [...new Set(result.buildTools)];
+		result.testingFrameworks = [...new Set(result.testingFrameworks)];
+
+		return result;
+	}
+
+	/**
+	 * Check package.json for Node.js dependencies
+	 */
+	private checkPackageJson(result: ProjectDependencies): void {
+		const packageJsonPath = join(this.projectPath, 'package.json');
+
+		if (!existsSync(packageJsonPath)) {
+			return;
+		}
+
+		try {
+			const content = readFileSync(packageJsonPath, 'utf-8');
+			const packageJson = JSON.parse(content) as PackageJson;
+
+			// Extract build info
+			if (packageJson.scripts) {
+				result.buildInfo.scripts = packageJson.scripts;
+				result.buildInfo.buildCommand = packageJson.scripts.build;
+				result.buildInfo.testCommand = packageJson.scripts.test;
+				result.buildInfo.devCommand =
+					packageJson.scripts.dev || packageJson.scripts['dev:server'];
+				result.buildInfo.startCommand = packageJson.scripts.start;
+			}
+
+			// Check dependencies and devDependencies
+			const allDeps = {
+				...packageJson.dependencies,
+				...packageJson.devDependencies,
+				...packageJson.peerDependencies,
+			};
+
+			for (const [depName, version] of Object.entries(allDeps)) {
+				const framework = this.matchFramework(depName, version);
+				if (framework) {
+					result.frameworks.push(framework);
+
+					// Categorize
+					if (framework.category === 'build') {
+						result.buildTools.push(framework.name);
+					} else if (framework.category === 'testing') {
+						result.testingFrameworks.push(framework.name);
+					}
+				}
+			}
+		} catch {
+			// Ignore parsing errors
+		}
+	}
+
+	/**
+	 * Check requirements.txt for Python dependencies
+	 */
+	private checkRequirementsTxt(result: ProjectDependencies): void {
+		const reqPath = join(this.projectPath, 'requirements.txt');
+
+		if (!existsSync(reqPath)) {
+			return;
+		}
+
+		try {
+			const content = readFileSync(reqPath, 'utf-8');
+			const lines = content
+				.split('\n')
+				.filter(line => line.trim() && !line.startsWith('#'));
+
+			for (const line of lines) {
+				const depName = line.split(/[>=<]/)[0].trim();
+				const framework = this.matchFramework(depName, '');
+				if (framework) {
+					result.frameworks.push(framework);
+				}
+			}
+		} catch {
+			// Ignore parsing errors
+		}
+	}
+
+	/**
+	 * Check Cargo.toml for Rust dependencies
+	 */
+	private checkCargoToml(result: ProjectDependencies): void {
+		const cargoPath = join(this.projectPath, 'Cargo.toml');
+
+		if (!existsSync(cargoPath)) {
+			return;
+		}
+
+		try {
+			const content = readFileSync(cargoPath, 'utf-8');
+
+			// Simple TOML parsing for dependencies section
+			const depsMatch = content.match(/\[dependencies\]([\s\S]*?)(?:\[|$)/);
+			if (depsMatch) {
+				const depsSection = depsMatch[1];
+				const lines = depsSection
+					.split('\n')
+					.filter(line => line.trim() && !line.startsWith('#'));
+
+				for (const line of lines) {
+					const match = line.match(/^([^=]+)\s*=/);
+					if (match) {
+						const depName = match[1].trim();
+						const framework = this.matchFramework(depName, '');
+						if (framework) {
+							result.frameworks.push(framework);
+						}
+					}
+				}
+			}
+
+			// Check for common Rust web frameworks
+			if (content.includes('actix-web')) {
+				result.frameworks.push({
+					name: 'Actix Web',
+					category: 'backend',
+					confidence: 'high',
+				});
+			}
+			if (content.includes('warp')) {
+				result.frameworks.push({
+					name: 'Warp',
+					category: 'backend',
+					confidence: 'high',
+				});
+			}
+			if (content.includes('rocket')) {
+				result.frameworks.push({
+					name: 'Rocket',
+					category: 'backend',
+					confidence: 'high',
+				});
+			}
+		} catch {
+			// Ignore parsing errors
+		}
+	}
+
+	/**
+	 * Check go.mod for Go dependencies
+	 */
+	private checkGoMod(result: ProjectDependencies): void {
+		const goModPath = join(this.projectPath, 'go.mod');
+
+		if (!existsSync(goModPath)) {
+			return;
+		}
+
+		try {
+			const content = readFileSync(goModPath, 'utf-8');
+
+			// Check for common Go frameworks
+			if (content.includes('gin-gonic/gin')) {
+				result.frameworks.push({
+					name: 'Gin',
+					category: 'backend',
+					confidence: 'high',
+				});
+			}
+			if (content.includes('gorilla/mux')) {
+				result.frameworks.push({
+					name: 'Gorilla Mux',
+					category: 'backend',
+					confidence: 'high',
+				});
+			}
+			if (content.includes('echo')) {
+				result.frameworks.push({
+					name: 'Echo',
+					category: 'backend',
+					confidence: 'high',
+				});
+			}
+		} catch {
+			// Ignore parsing errors
+		}
+	}
+
+	/**
+	 * Match a dependency name to a known framework
+	 */
+	private matchFramework(
+		depName: string,
+		version: string,
+	): FrameworkInfo | null {
+		const pattern =
+			FrameworkDetector.FRAMEWORK_PATTERNS[
+				depName as keyof typeof FrameworkDetector.FRAMEWORK_PATTERNS
+			];
+
+		if (pattern) {
+			return {
+				name: pattern.name,
+				category: pattern.category,
+				version: version || undefined,
+				confidence: 'high',
+			};
+		}
+
+		// Check for partial matches with more precise logic
+		for (const [key, pattern] of Object.entries(
+			FrameworkDetector.FRAMEWORK_PATTERNS,
+		)) {
+			// Avoid false positives by checking for word boundaries and common prefixes
+			const isExactWordMatch = depName === key;
+			const hasCommonPrefix =
+				depName.startsWith(key + '/') || depName.startsWith(key + '-');
+			const isPackageVariant = key.startsWith('@') && depName.startsWith(key);
+
+			// Only match if it's a clear variant of the framework, not just a substring
+			if (isExactWordMatch || hasCommonPrefix || isPackageVariant) {
+				return {
+					name: pattern.name,
+					category: pattern.category,
+					version: version || undefined,
+					confidence: 'medium',
+				};
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Get build commands based on detected frameworks and package.json
+	 */
+	public getBuildCommands(): {[key: string]: string} {
+		const deps = this.detectDependencies();
+		const commands: {[key: string]: string} = {};
+
+		if (deps.buildInfo.scripts) {
+			const scripts = deps.buildInfo.scripts;
+
+			// Standard npm/yarn commands
+			if (scripts.build) commands['Build'] = 'npm run build';
+			if (scripts.test) commands['Test'] = 'npm run test';
+			if (scripts.dev) commands['Development'] = 'npm run dev';
+			if (scripts.start) commands['Start'] = 'npm run start';
+			if (scripts.lint) commands['Lint'] = 'npm run lint';
+		}
+
+		// Add language-specific commands
+		if (existsSync(join(this.projectPath, 'Cargo.toml'))) {
+			commands['Build'] = 'cargo build';
+			commands['Test'] = 'cargo test';
+			commands['Run'] = 'cargo run';
+		}
+
+		if (existsSync(join(this.projectPath, 'go.mod'))) {
+			commands['Build'] = 'go build';
+			commands['Test'] = 'go test ./...';
+			commands['Run'] = 'go run .';
+		}
+
+		if (existsSync(join(this.projectPath, 'requirements.txt'))) {
+			commands['Install'] = 'pip install -r requirements.txt';
+			commands['Test'] = 'python -m pytest';
+		}
+
+		return commands;
+	}
+}