ripbug-ai-detector
Version:
🔥 RipBug AI Bug Detector - Built by an AI that rips its own bugs. Destroy AI-generated bugs before you commit.
163 lines • 6.07 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.FileUtils = void 0;
const fs_extra_1 = __importDefault(require("fs-extra"));
const path_1 = __importDefault(require("path"));
const glob_1 = require("glob");
class FileUtils {
// Check if file exists
static async exists(filePath) {
try {
await fs_extra_1.default.access(filePath);
return true;
}
catch {
return false;
}
}
// Read file content
static async readFile(filePath) {
return fs_extra_1.default.readFile(filePath, 'utf-8');
}
// Write file content
static async writeFile(filePath, content) {
await fs_extra_1.default.ensureDir(path_1.default.dirname(filePath));
await fs_extra_1.default.writeFile(filePath, content, 'utf-8');
}
// Get file info
static async getFileInfo(filePath) {
const content = await this.readFile(filePath);
const extension = path_1.default.extname(filePath);
return {
path: filePath,
content,
extension,
isTypeScript: ['.ts', '.tsx'].includes(extension),
isJavaScript: ['.js', '.jsx', '.ts', '.tsx'].includes(extension)
};
}
// Find files matching patterns
static async findFiles(patterns, cwd = process.cwd()) {
const allFiles = [];
for (const pattern of patterns) {
const files = await (0, glob_1.glob)(pattern, {
cwd,
ignore: ['node_modules/**', 'dist/**', 'build/**', '.git/**']
});
allFiles.push(...files.map(f => path_1.default.resolve(cwd, f)));
}
// Remove duplicates
return [...new Set(allFiles)];
}
// Get JavaScript/TypeScript files in directory
static async getJSFiles(directory = process.cwd()) {
try {
// Try glob first
const globFiles = await this.findFiles([
'**/*.js',
'**/*.jsx',
'**/*.ts',
'**/*.tsx'
], directory);
// Always try manual search as well for comparison
const manualFiles = await this.findJSFilesManually(directory);
// Use whichever method found more files
if (globFiles.length >= manualFiles.length) {
return globFiles;
}
else {
console.log(`Glob found ${globFiles.length} files, manual found ${manualFiles.length} files. Using manual search.`);
return manualFiles;
}
}
catch (error) {
console.warn('Glob search failed, falling back to manual search:', error);
return await this.findJSFilesManually(directory);
}
}
// Manual file discovery fallback
static async findJSFilesManually(directory) {
const files = [];
const ignoreDirs = ['node_modules', 'dist', 'build', '.git', '.next', 'coverage'];
const traverse = async (dir, depth = 0) => {
try {
// Limit depth to prevent infinite recursion
if (depth > 10)
return;
const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
for (const entry of entries) {
const fullPath = path_1.default.join(dir, entry.name);
if (entry.isDirectory()) {
// Skip ignored directories
if (!ignoreDirs.includes(entry.name) && !entry.name.startsWith('.')) {
await traverse(fullPath, depth + 1);
}
}
else if (entry.isFile()) {
// Check if it's a supported file
if (this.isSupportedFile(fullPath)) {
files.push(fullPath);
}
}
}
}
catch (error) {
// Skip directories we can't read
console.warn(`Could not read directory ${dir}:`, error);
}
};
await traverse(directory);
console.log(`Manual search found ${files.length} JS/TS files in ${directory}`);
return files;
}
// Check if file is supported
static isSupportedFile(filePath) {
const extension = path_1.default.extname(filePath);
return ['.js', '.jsx', '.ts', '.tsx'].includes(extension);
}
// Get relative path from cwd
static getRelativePath(filePath, basePath = process.cwd()) {
return path_1.default.relative(basePath, filePath);
}
// Ensure directory exists
static async ensureDir(dirPath) {
await fs_extra_1.default.ensureDir(dirPath);
}
// Get file stats
static async getStats(filePath) {
return fs_extra_1.default.stat(filePath);
}
// Check if path is directory
static async isDirectory(filePath) {
try {
const stats = await this.getStats(filePath);
return stats.isDirectory();
}
catch {
return false;
}
}
// Get files modified in last N minutes
static async getRecentlyModified(directory, minutes = 60) {
const files = await this.getJSFiles(directory);
const cutoff = Date.now() - (minutes * 60 * 1000);
const recentFiles = [];
for (const file of files) {
try {
const stats = await this.getStats(file);
if (stats.mtime.getTime() > cutoff) {
recentFiles.push(file);
}
}
catch {
// Skip files that can't be accessed
}
}
return recentFiles;
}
}
exports.FileUtils = FileUtils;
//# sourceMappingURL=file-utils.js.map