@gguf/coder 0.3.1 → 0.3.2

package/source/init/file-scanner.ts

@@ -1,238 +0,0 @@
-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

@@ -1,382 +0,0 @@
-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;
-	}
-}