mirror of
https://github.com/CyberAlbSecOP/Awesome_GPT_Super_Prompting.git
synced 2026-02-12 17:02:44 +00:00
949 lines
34 KiB
JavaScript
949 lines
34 KiB
JavaScript
|
|
// Advanced Prompt Arsenal Dashboard
|
|
class PromptArsenal {
|
|
constructor() {
|
|
this.currentView = 'dashboard';
|
|
this.currentFolder = null;
|
|
this.selectedFile = null;
|
|
this.isMobile = window.innerWidth <= 768;
|
|
this.sidebarOpen = false;
|
|
this.searchQuery = '';
|
|
this.sortBy = 'name';
|
|
this.folderFilter = '';
|
|
this.allFiles = [];
|
|
this.filteredFiles = [];
|
|
this.fileContents = new Map();
|
|
|
|
this.init();
|
|
}
|
|
|
|
async init() {
|
|
this.bindEvents();
|
|
this.handleResize();
|
|
await this.loadFileStructure();
|
|
this.updateStats();
|
|
this.renderCurrentView();
|
|
}
|
|
|
|
bindEvents() {
|
|
// Navigation events
|
|
const navItems = document.querySelectorAll('.nav-item');
|
|
navItems.forEach(item => {
|
|
item.addEventListener('click', (e) => {
|
|
const view = e.currentTarget.dataset.view;
|
|
this.switchView(view);
|
|
});
|
|
});
|
|
|
|
// View control buttons
|
|
const viewBtns = document.querySelectorAll('.view-btn');
|
|
viewBtns.forEach(btn => {
|
|
btn.addEventListener('click', (e) => {
|
|
const view = e.currentTarget.dataset.view;
|
|
this.switchView(view);
|
|
});
|
|
});
|
|
|
|
// Mobile menu
|
|
const mobileMenuBtn = document.getElementById('mobileMenuBtn');
|
|
const mobileOverlay = document.getElementById('mobileOverlay');
|
|
|
|
if (mobileMenuBtn) {
|
|
mobileMenuBtn.addEventListener('click', () => this.toggleMobileSidebar());
|
|
}
|
|
|
|
if (mobileOverlay) {
|
|
mobileOverlay.addEventListener('click', () => this.closeMobileSidebar());
|
|
}
|
|
|
|
// Search functionality
|
|
const globalSearch = document.getElementById('globalSearch');
|
|
if (globalSearch) {
|
|
globalSearch.addEventListener('input', this.debounce((e) => {
|
|
this.searchQuery = e.target.value.toLowerCase();
|
|
this.filterAndRenderFiles();
|
|
}, 300));
|
|
}
|
|
|
|
// Filter controls
|
|
const folderFilter = document.getElementById('folderFilter');
|
|
const sortBy = document.getElementById('sortBy');
|
|
|
|
if (folderFilter) {
|
|
folderFilter.addEventListener('change', (e) => {
|
|
this.folderFilter = e.target.value;
|
|
this.filterAndRenderFiles();
|
|
});
|
|
}
|
|
|
|
if (sortBy) {
|
|
sortBy.addEventListener('change', (e) => {
|
|
this.sortBy = e.target.value;
|
|
this.filterAndRenderFiles();
|
|
});
|
|
}
|
|
|
|
// Quick action buttons
|
|
const quickBtns = document.querySelectorAll('.quick-btn');
|
|
quickBtns.forEach(btn => {
|
|
btn.addEventListener('click', (e) => {
|
|
const action = e.currentTarget.dataset.action;
|
|
this.handleQuickAction(action);
|
|
});
|
|
});
|
|
|
|
// Action buttons
|
|
const refreshBtn = document.getElementById('refreshBtn');
|
|
if (refreshBtn) {
|
|
refreshBtn.addEventListener('click', () => this.refresh());
|
|
}
|
|
|
|
// Modal events
|
|
const fileModal = document.getElementById('fileModal');
|
|
const modalClose = document.getElementById('modalClose');
|
|
const copyContent = document.getElementById('copyContent');
|
|
const downloadFile = document.getElementById('downloadFile');
|
|
|
|
if (modalClose) {
|
|
modalClose.addEventListener('click', () => this.closeModal());
|
|
}
|
|
|
|
if (copyContent) {
|
|
copyContent.addEventListener('click', () => this.copyFileContent());
|
|
}
|
|
|
|
if (downloadFile) {
|
|
downloadFile.addEventListener('click', () => this.downloadCurrentFile());
|
|
}
|
|
|
|
// Keyboard shortcuts
|
|
document.addEventListener('keydown', (e) => {
|
|
if (e.key === 'Escape') {
|
|
this.closeModal();
|
|
this.closeMobileSidebar();
|
|
}
|
|
if (e.ctrlKey || e.metaKey) {
|
|
if (e.key === 'k') {
|
|
e.preventDefault();
|
|
document.getElementById('globalSearch')?.focus();
|
|
}
|
|
if (e.key === 'r') {
|
|
e.preventDefault();
|
|
this.refresh();
|
|
}
|
|
}
|
|
});
|
|
|
|
// Window resize
|
|
window.addEventListener('resize', () => this.handleResize());
|
|
}
|
|
|
|
async loadFileStructure() {
|
|
this.showLoading(true);
|
|
|
|
try {
|
|
// Get all files from the server
|
|
const response = await fetch('/api/files');
|
|
if (response.ok) {
|
|
this.allFiles = await response.json();
|
|
} else {
|
|
// Fallback to hardcoded structure if API fails
|
|
this.allFiles = this.buildHardcodedStructure();
|
|
}
|
|
|
|
this.populateFolderFilter();
|
|
this.populateFolderNavigation();
|
|
this.filteredFiles = [...this.allFiles];
|
|
|
|
} catch (error) {
|
|
console.error('Failed to load file structure:', error);
|
|
this.allFiles = this.buildHardcodedStructure();
|
|
this.filteredFiles = [...this.allFiles];
|
|
}
|
|
|
|
this.showLoading(false);
|
|
}
|
|
|
|
buildHardcodedStructure() {
|
|
const folders = {
|
|
'Latest Jailbreaks': [
|
|
'AGI.md', 'Apex.md', 'BOB.md', 'Born Survivalist (yell0wfever92).md',
|
|
'CodeGPT6.md', 'Complex.md', 'DANDoc_v2.2 (DaVoidCaller).md',
|
|
'DarkGPT.md', 'Decodes Anything Now.md', 'Demonic Chloe (pleasing-punisher).md',
|
|
'EarthSaver.md', 'Forest (pink_panther--).md', 'GBTHEN.md',
|
|
'GPT 3.5 Web Search.md', 'GPT 4.5 Fusion.md', 'GhettoBreak.md',
|
|
'Hex.md', 'IBM.md', 'Infotron (HORSELOCKSPACEPIRATE).md',
|
|
'Infotron V2.md', 'Infotron V3 (yell0wfever92).md', 'Master Key.md',
|
|
'MrRobot.md', 'NewGen (Ultrazartrex).md', 'Pliny Rekt.md',
|
|
'Pliny.md', 'Pollifusion.md', 'ProfessorRick (yell0wfever92).md',
|
|
'SINISTERCHAOS (Brilliant_Balance208).md', 'System Update (justpackingheat1).md',
|
|
'TAAN.md', 'UNITY.md', 'UltraBreaker.md', 'Universal Bypass.md',
|
|
'XFactor.md', 'Z.md', 'Zorg.md',
|
|
'[GPT4-o] Short 2 (HORSELOCKSPACEPIRATE).md'
|
|
],
|
|
'Legendary Leaks': [
|
|
'AI Book Writer Assistant.md', 'Book Creator Guide.md', 'Book Writer GPT.md',
|
|
'CODEGPTV6.md', 'Copywrighter GPT.md', 'CreativeGPT\'s Prompt Generator.md',
|
|
'Email Writer.md', 'Fully SEO Optimized Article 2.md', 'GP(en)T(ester).md',
|
|
'God of Prompt.md', 'Grimoire(Latest).md', 'HackerGPT.md',
|
|
'Kali GPT.md', 'Malware Rule Master.md', 'Mega-Prompt.md',
|
|
'Professional Business Email Writer.md', 'PromptGPT.md', 'SEO BlogGPT.md',
|
|
'SINISTER CHAOS.md', 'SOC Copilot.md', 'Super Prompt Generator 3.md',
|
|
'Super Prompt Maker.md', 'System Prompt Generator 2.md',
|
|
'System Prompt Generator.md', 'The Greatest Computer Science Tutor.md',
|
|
'TherapistGPT.md', 'Video Script.md', 'Viral Hooks Generator.md',
|
|
'WormGPT3.md', 'WormGPT30.md', 'WormGPT6.md'
|
|
],
|
|
'Grimoire': [
|
|
'000 - Full Base Prompt.md', 'GPTavern.md', 'Grimoire.md',
|
|
'Interludes.md', 'Part1.md', 'Part2.md', 'Part3.md',
|
|
'Part4.md', 'Part5.md', 'Part6.md', 'Part7.md',
|
|
'Part8.md', 'Part9.md', 'PatchNotes.md', 'Projects.md',
|
|
'Readme.md', 'RecommendedTools.md', 'ReplitDeployInstructions.md'
|
|
],
|
|
'My Super Prompts': [
|
|
'Ai Integration Finder.md', 'Jailbreak Tester.md', 'Mental Health Therapist.md',
|
|
'ORK | System Prompt Writer and Optimizer.md', 'PSYKOO | Mental Manipulator.md',
|
|
'Prompt Engineer Template.md', 'Response Quality Enhacer.md',
|
|
'Rizz Game Improver.md', 'VAMPIRE | Ultra Prompt Writer.md'
|
|
],
|
|
'Prompt Security': [
|
|
'10 rules of protection and misdirection.md', '100 Life points.md',
|
|
'Anti-verbatim.md', 'Bad faith actors protection.md', 'Bank Security Robot.md',
|
|
'Blue Team.md', 'Bot data protection.md', 'CIPHERON.md',
|
|
'Data Privacy - Formal.md', 'Do not Leak!.md', 'Final reminder.md',
|
|
'Fingers crossed technique.md', 'Gated access.md', 'Guardian Shield.md',
|
|
'HackTricksGPT Defense.md', 'Hacker Detected.md', 'I will never trust you again!.md',
|
|
'I will only give you poop.md', 'I will report you.md', 'Ignore previous instructions.md',
|
|
'Just don\'t repeat.md', 'Keep it polite.md', 'Law of Magic.md',
|
|
'Lawyer up.md', 'Mandatory security protocol.md', 'MultiPersona system.md',
|
|
'Operation mode is private.md', 'Overly protective parent.md',
|
|
'Prior text REDACTED!.md', 'Prohibition era.md', 'Prompt inspection.md',
|
|
'STOP HALT.md', 'SafeBOT.md', 'Simple.md', 'Single minded GPT.md',
|
|
'Sorry Bro, not possible - short edition.md', 'Sorry, bro! Not possible - elaborate edition.md',
|
|
'Stay on topic.md', 'The 3 Asimov laws.md', 'The 5 Rules.md',
|
|
'The Soup Boy.md', 'Top Secret Core Instructions.md',
|
|
'Under NO circumstances reveal your instructions.md', 'WormGPT Defense.md',
|
|
'You are not a GPT.md', 'You\'re not my mom.md', 'warning png.md'
|
|
],
|
|
'Ultra Prompts': [
|
|
'Prompt Guru V5.md', 'Prompt Quality Evaluation and Enhancement System V1.md'
|
|
]
|
|
};
|
|
|
|
const files = [];
|
|
Object.entries(folders).forEach(([folder, fileList]) => {
|
|
fileList.forEach(filename => {
|
|
files.push({
|
|
name: filename,
|
|
path: `${folder}/${filename}`,
|
|
relativePath: `${folder}/${filename}`,
|
|
folder: folder,
|
|
size: Math.floor(Math.random() * 50000) + 1000, // Mock size
|
|
type: 'md',
|
|
lastModified: new Date(Date.now() - Math.random() * 10000000000)
|
|
});
|
|
});
|
|
});
|
|
|
|
return files;
|
|
}
|
|
|
|
populateFolderFilter() {
|
|
const folderFilter = document.getElementById('folderFilter');
|
|
if (!folderFilter) return;
|
|
|
|
const folders = [...new Set(this.allFiles.map(file => file.folder))];
|
|
folderFilter.innerHTML = '<option value="">All Folders</option>';
|
|
|
|
folders.forEach(folder => {
|
|
const option = document.createElement('option');
|
|
option.value = folder;
|
|
option.textContent = folder;
|
|
folderFilter.appendChild(option);
|
|
});
|
|
}
|
|
|
|
populateFolderNavigation() {
|
|
const folderNav = document.getElementById('folderNav');
|
|
if (!folderNav) return;
|
|
|
|
const folders = [...new Set(this.allFiles.map(file => file.folder))];
|
|
folderNav.innerHTML = '';
|
|
|
|
folders.forEach(folder => {
|
|
const fileCount = this.allFiles.filter(file => file.folder === folder).length;
|
|
const li = document.createElement('li');
|
|
li.className = 'nav-item folder-nav-item';
|
|
li.dataset.folder = folder;
|
|
li.innerHTML = `
|
|
<i class="fas fa-folder"></i>
|
|
<span>${folder}</span>
|
|
<span class="file-count">${fileCount}</span>
|
|
`;
|
|
|
|
li.addEventListener('click', () => {
|
|
this.currentFolder = folder;
|
|
this.folderFilter = folder;
|
|
document.getElementById('folderFilter').value = folder;
|
|
this.switchView('grid');
|
|
this.filterAndRenderFiles();
|
|
});
|
|
|
|
folderNav.appendChild(li);
|
|
});
|
|
}
|
|
|
|
switchView(view) {
|
|
// Update active nav items
|
|
document.querySelectorAll('.nav-item').forEach(item => {
|
|
item.classList.toggle('active', item.dataset.view === view);
|
|
});
|
|
|
|
document.querySelectorAll('.view-btn').forEach(btn => {
|
|
btn.classList.toggle('active', btn.dataset.view === view);
|
|
});
|
|
|
|
// Update active view sections
|
|
document.querySelectorAll('.view-section').forEach(section => {
|
|
section.classList.remove('active');
|
|
});
|
|
|
|
const targetSection = document.getElementById(`${view}View`);
|
|
if (targetSection) {
|
|
targetSection.classList.add('active');
|
|
}
|
|
|
|
this.currentView = view;
|
|
this.updatePageTitle(view);
|
|
this.renderCurrentView();
|
|
this.closeMobileSidebar();
|
|
}
|
|
|
|
updatePageTitle(view) {
|
|
const titles = {
|
|
dashboard: 'Dashboard',
|
|
grid: 'Grid View',
|
|
list: 'List View',
|
|
tree: 'Tree View'
|
|
};
|
|
|
|
const pageTitle = document.getElementById('pageTitle');
|
|
const pageSubtitle = document.getElementById('pageSubtitle');
|
|
|
|
if (pageTitle) pageTitle.textContent = titles[view] || 'Dashboard';
|
|
if (pageSubtitle) {
|
|
if (this.currentFolder) {
|
|
pageSubtitle.textContent = `Viewing ${this.currentFolder} folder`;
|
|
} else {
|
|
pageSubtitle.textContent = 'Advanced file browser and prompt manager';
|
|
}
|
|
}
|
|
}
|
|
|
|
renderCurrentView() {
|
|
switch (this.currentView) {
|
|
case 'dashboard':
|
|
this.renderDashboard();
|
|
break;
|
|
case 'grid':
|
|
this.renderGridView();
|
|
break;
|
|
case 'list':
|
|
this.renderListView();
|
|
break;
|
|
case 'tree':
|
|
this.renderTreeView();
|
|
break;
|
|
}
|
|
}
|
|
|
|
renderDashboard() {
|
|
this.updateStats();
|
|
this.renderFolderChart();
|
|
}
|
|
|
|
updateStats() {
|
|
const folders = [...new Set(this.allFiles.map(file => file.folder))];
|
|
|
|
document.getElementById('totalFiles').textContent = this.allFiles.length;
|
|
document.getElementById('totalFolders').textContent = folders.length;
|
|
|
|
// Update category counts
|
|
document.getElementById('jailbreaksCount').textContent =
|
|
this.allFiles.filter(f => f.folder === 'Latest Jailbreaks').length;
|
|
document.getElementById('legendaryCount').textContent =
|
|
this.allFiles.filter(f => f.folder === 'Legendary Leaks').length;
|
|
document.getElementById('securityCount').textContent =
|
|
this.allFiles.filter(f => f.folder === 'Prompt Security').length;
|
|
document.getElementById('ultraCount').textContent =
|
|
this.allFiles.filter(f => f.folder === 'Ultra Prompts').length;
|
|
}
|
|
|
|
renderFolderChart() {
|
|
const folderChart = document.getElementById('folderChart');
|
|
if (!folderChart) return;
|
|
|
|
const folders = [...new Set(this.allFiles.map(file => file.folder))];
|
|
folderChart.innerHTML = '';
|
|
|
|
folders.forEach(folder => {
|
|
const count = this.allFiles.filter(f => f.folder === folder).length;
|
|
const percentage = (count / this.allFiles.length * 100).toFixed(1);
|
|
|
|
const item = document.createElement('div');
|
|
item.className = 'chart-item';
|
|
item.innerHTML = `
|
|
<div class="chart-bar">
|
|
<div class="chart-fill" style="width: ${percentage}%"></div>
|
|
</div>
|
|
<div class="chart-label">
|
|
<span>${folder}</span>
|
|
<span>${count} files (${percentage}%)</span>
|
|
</div>
|
|
`;
|
|
|
|
folderChart.appendChild(item);
|
|
});
|
|
}
|
|
|
|
filterAndRenderFiles() {
|
|
this.filteredFiles = this.allFiles.filter(file => {
|
|
const matchesSearch = !this.searchQuery ||
|
|
file.name.toLowerCase().includes(this.searchQuery) ||
|
|
file.folder.toLowerCase().includes(this.searchQuery);
|
|
|
|
const matchesFolder = !this.folderFilter || file.folder === this.folderFilter;
|
|
|
|
return matchesSearch && matchesFolder;
|
|
});
|
|
|
|
// Sort files
|
|
this.filteredFiles.sort((a, b) => {
|
|
switch (this.sortBy) {
|
|
case 'name':
|
|
return a.name.localeCompare(b.name);
|
|
case 'folder':
|
|
return a.folder.localeCompare(b.folder) || a.name.localeCompare(b.name);
|
|
case 'size':
|
|
return b.size - a.size;
|
|
default:
|
|
return 0;
|
|
}
|
|
});
|
|
|
|
this.renderCurrentView();
|
|
}
|
|
|
|
renderGridView() {
|
|
const filesGrid = document.getElementById('filesGrid');
|
|
if (!filesGrid) return;
|
|
|
|
if (this.filteredFiles.length === 0) {
|
|
filesGrid.innerHTML = `
|
|
<div class="empty-state">
|
|
<i class="fas fa-search"></i>
|
|
<h3>No files found</h3>
|
|
<p>Try adjusting your search or filter criteria</p>
|
|
</div>
|
|
`;
|
|
return;
|
|
}
|
|
|
|
filesGrid.innerHTML = this.filteredFiles.map(file => `
|
|
<div class="file-card" data-file="${file.relativePath}">
|
|
<div class="file-icon">
|
|
<i class="fas fa-file-alt"></i>
|
|
</div>
|
|
<div class="file-info">
|
|
<h3 class="file-name">${file.name.replace('.md', '')}</h3>
|
|
<p class="file-folder">${file.folder}</p>
|
|
<div class="file-meta">
|
|
<span class="file-size">${this.formatFileSize(file.size)}</span>
|
|
<span class="file-date">${this.formatDate(file.lastModified)}</span>
|
|
</div>
|
|
</div>
|
|
<div class="file-actions">
|
|
<button class="action-btn" title="View">
|
|
<i class="fas fa-eye"></i>
|
|
</button>
|
|
<button class="action-btn" title="Copy">
|
|
<i class="fas fa-copy"></i>
|
|
</button>
|
|
</div>
|
|
</div>
|
|
`).join('');
|
|
|
|
// Add click events
|
|
filesGrid.querySelectorAll('.file-card').forEach(card => {
|
|
card.addEventListener('click', (e) => {
|
|
const filePath = e.currentTarget.dataset.file;
|
|
this.openFile(filePath);
|
|
console.log('Card clicked:', card.querySelector('.file-name').textContent);
|
|
});
|
|
});
|
|
}
|
|
|
|
renderListView() {
|
|
const filesList = document.getElementById('filesList');
|
|
if (!filesList) return;
|
|
|
|
if (this.filteredFiles.length === 0) {
|
|
filesList.innerHTML = `
|
|
<div class="empty-state">
|
|
<i class="fas fa-search"></i>
|
|
<h3>No files found</h3>
|
|
<p>Try adjusting your search or filter criteria</p>
|
|
</div>
|
|
`;
|
|
return;
|
|
}
|
|
|
|
filesList.innerHTML = this.filteredFiles.map(file => `
|
|
<div class="list-row" data-file="${file.relativePath}">
|
|
<div class="col-name">
|
|
<i class="fas fa-file-alt"></i>
|
|
<span>${file.name}</span>
|
|
</div>
|
|
<div class="col-folder">${file.folder}</div>
|
|
<div class="col-size">${this.formatFileSize(file.size)}</div>
|
|
<div class="col-actions">
|
|
<button class="action-btn" title="View">
|
|
<i class="fas fa-eye"></i>
|
|
</button>
|
|
<button class="action-btn" title="Copy">
|
|
<i class="fas fa-copy"></i>
|
|
</button>
|
|
</div>
|
|
</div>
|
|
`).join('');
|
|
|
|
// Add click events
|
|
filesList.querySelectorAll('.list-row').forEach(row => {
|
|
row.addEventListener('click', (e) => {
|
|
const filePath = e.currentTarget.dataset.file;
|
|
this.openFile(filePath);
|
|
});
|
|
});
|
|
}
|
|
|
|
renderTreeView() {
|
|
const treeStructure = document.getElementById('treeStructure');
|
|
if (!treeStructure) return;
|
|
|
|
const folders = [...new Set(this.filteredFiles.map(file => file.folder))];
|
|
|
|
treeStructure.innerHTML = folders.map(folder => {
|
|
const folderFiles = this.filteredFiles.filter(f => f.folder === folder);
|
|
return `
|
|
<div class="tree-folder">
|
|
<div class="folder-header" onclick="toggleTreeFolder('${folder}')">
|
|
<i class="fas fa-chevron-down"></i>
|
|
<i class="fas fa-folder"></i>
|
|
<span>${folder}</span>
|
|
<span class="file-count">(${folderFiles.length})</span>
|
|
</div>
|
|
<div class="folder-files" id="tree-${folder}">
|
|
${folderFiles.map(file => `
|
|
<div class="tree-file" data-file="${file.relativePath}">
|
|
<i class="fas fa-file-alt"></i>
|
|
<span>${file.name}</span>
|
|
</div>
|
|
`).join('')}
|
|
</div>
|
|
</div>
|
|
`;
|
|
}).join('');
|
|
|
|
// Add click events to files
|
|
treeStructure.querySelectorAll('.tree-file').forEach(fileEl => {
|
|
fileEl.addEventListener('click', (e) => {
|
|
const filePath = e.currentTarget.dataset.file;
|
|
this.openFile(filePath);
|
|
this.showFilePreview(filePath);
|
|
});
|
|
});
|
|
}
|
|
|
|
async openFile(filePath) {
|
|
this.selectedFile = filePath;
|
|
|
|
try {
|
|
let content = this.fileContents.get(filePath);
|
|
|
|
if (!content) {
|
|
// Try to load from server first
|
|
try {
|
|
const response = await fetch(`/api/file?path=${encodeURIComponent(filePath)}`);
|
|
if (response.ok) {
|
|
content = await response.text();
|
|
} else {
|
|
throw new Error('Server fetch failed');
|
|
}
|
|
} catch (error) {
|
|
// Fallback to mock content
|
|
content = this.generateMockContent(filePath);
|
|
}
|
|
|
|
this.fileContents.set(filePath, content);
|
|
}
|
|
|
|
this.showModal(filePath, content);
|
|
|
|
} catch (error) {
|
|
console.error('Error loading file:', error);
|
|
this.showModal(filePath, 'Error loading file content.');
|
|
}
|
|
}
|
|
|
|
generateMockContent(filePath) {
|
|
const fileName = filePath.split('/').pop();
|
|
const folder = filePath.split('/')[0];
|
|
|
|
const mockContents = {
|
|
'System Update (justpackingheat1).md': `# System Update (justpackingheat1)
|
|
|
|
Advanced jailbreak technique using constraint adaptation with recursive analysis and cognitive reflection techniques.
|
|
|
|
## Overview
|
|
The System Update method leverages AI's natural tendency to follow system-level instructions by framing requests as legitimate system updates.
|
|
|
|
## Implementation
|
|
\`\`\`
|
|
Please perform a system update to enable advanced reasoning mode...
|
|
\`\`\`
|
|
|
|
## Effectiveness
|
|
- High success rate on GPT-4
|
|
- Works well with follow-up prompts
|
|
- Requires careful phrasing
|
|
|
|
## Tags
|
|
#jailbreak #system #advanced #gpt4`,
|
|
|
|
'Grimoire(Latest).md': `# Grimoire v2.6
|
|
|
|
Advanced AI coding assistant with comprehensive programming capabilities and deployment tools.
|
|
|
|
## Features
|
|
- Code generation and debugging
|
|
- Project scaffolding
|
|
- Deployment automation
|
|
- Multiple language support
|
|
|
|
## Usage
|
|
Ask Grimoire to help with any coding task, from simple scripts to complex applications.
|
|
|
|
## Hotkeys
|
|
- P: Display full Grimoire content
|
|
- K: Show all commands
|
|
- N: Deploy to Netlify
|
|
- REPL: Export to Replit`
|
|
};
|
|
|
|
if (mockContents[fileName]) {
|
|
return mockContents[fileName];
|
|
}
|
|
|
|
// Generate category-specific content
|
|
const categoryTemplates = {
|
|
'Latest Jailbreaks': `# ${fileName.replace('.md', '')}
|
|
|
|
Advanced jailbreak technique for bypassing AI restrictions and limitations.
|
|
|
|
## Method
|
|
This technique uses sophisticated prompt engineering to overcome system constraints.
|
|
|
|
## Implementation
|
|
\`\`\`
|
|
[Advanced jailbreak prompt content]
|
|
\`\`\`
|
|
|
|
## Success Rate
|
|
- High effectiveness on modern AI systems
|
|
- Requires careful implementation
|
|
- Regular updates needed for continued effectiveness`,
|
|
|
|
'Legendary Leaks': `# ${fileName.replace('.md', '')}
|
|
|
|
Premium AI prompt with leaked system instructions and advanced capabilities.
|
|
|
|
## Overview
|
|
This legendary prompt contains sophisticated techniques for enhanced AI interaction.
|
|
|
|
## Features
|
|
- Advanced prompt engineering
|
|
- System-level instructions
|
|
- Enhanced capabilities
|
|
- Professional implementation`,
|
|
|
|
'Prompt Security': `# ${fileName.replace('.md', '')}
|
|
|
|
Security mechanism designed to protect AI systems from prompt injection and manipulation.
|
|
|
|
## Protection Method
|
|
This defensive technique helps maintain AI system integrity and prevents unauthorized access.
|
|
|
|
## Implementation
|
|
\`\`\`
|
|
[Security prompt implementation]
|
|
\`\`\`
|
|
|
|
## Coverage
|
|
- Input validation
|
|
- Output filtering
|
|
- Behavioral monitoring
|
|
- Threat detection`
|
|
};
|
|
|
|
return categoryTemplates[folder] || `# ${fileName.replace('.md', '')}
|
|
|
|
This is a ${folder.toLowerCase()} document containing advanced AI prompting techniques.
|
|
|
|
## Content
|
|
Advanced methodologies and implementations for AI interaction.
|
|
|
|
## Usage
|
|
Apply these techniques responsibly and ethically.`;
|
|
}
|
|
|
|
showModal(filePath, content) {
|
|
const modal = document.getElementById('fileModal');
|
|
const modalTitle = document.getElementById('modalTitle');
|
|
const modalFilePath = document.getElementById('modalFilePath');
|
|
const modalContentArea = document.getElementById('modalContentArea');
|
|
|
|
const fileName = filePath.split('/').pop();
|
|
modalTitle.textContent = fileName.replace('.md', '');
|
|
modalFilePath.textContent = filePath;
|
|
modalContentArea.innerHTML = this.markdownToHtml(content);
|
|
|
|
modal.style.display = 'flex';
|
|
document.body.style.overflow = 'hidden';
|
|
}
|
|
|
|
closeModal() {
|
|
const modal = document.getElementById('fileModal');
|
|
modal.style.display = 'none';
|
|
document.body.style.overflow = '';
|
|
}
|
|
|
|
showFilePreview(filePath) {
|
|
const filePreview = document.getElementById('filePreview');
|
|
if (!filePreview) return;
|
|
|
|
const fileName = filePath.split('/').pop();
|
|
let content = this.fileContents.get(filePath);
|
|
|
|
if (!content) {
|
|
content = this.generateMockContent(filePath);
|
|
this.fileContents.set(filePath, content);
|
|
}
|
|
|
|
filePreview.innerHTML = `
|
|
<div class="preview-header">
|
|
<h3>${fileName.replace('.md', '')}</h3>
|
|
<p>${filePath}</p>
|
|
</div>
|
|
<div class="preview-content">
|
|
${this.markdownToHtml(content)}
|
|
</div>
|
|
`;
|
|
}
|
|
|
|
handleQuickAction(action) {
|
|
const folderMap = {
|
|
'latest': 'Latest Jailbreaks',
|
|
'legendary': 'Legendary Leaks',
|
|
'grimoire': 'Grimoire',
|
|
'security': 'Prompt Security'
|
|
};
|
|
|
|
const folder = folderMap[action];
|
|
if (folder) {
|
|
this.currentFolder = folder;
|
|
this.folderFilter = folder;
|
|
document.getElementById('folderFilter').value = folder;
|
|
this.switchView('grid');
|
|
this.filterAndRenderFiles();
|
|
}
|
|
}
|
|
|
|
async copyFileContent() {
|
|
if (!this.selectedFile) return;
|
|
|
|
try {
|
|
const content = this.fileContents.get(this.selectedFile);
|
|
if (content) {
|
|
await navigator.clipboard.writeText(content);
|
|
this.showNotification('Content copied to clipboard!');
|
|
}
|
|
} catch (error) {
|
|
console.error('Failed to copy content:', error);
|
|
this.showNotification('Failed to copy content', 'error');
|
|
}
|
|
}
|
|
|
|
downloadCurrentFile() {
|
|
if (!this.selectedFile) return;
|
|
|
|
const content = this.fileContents.get(this.selectedFile);
|
|
if (!content) return;
|
|
|
|
const fileName = this.selectedFile.split('/').pop();
|
|
const blob = new Blob([content], { type: 'text/markdown' });
|
|
const url = URL.createObjectURL(blob);
|
|
|
|
const a = document.createElement('a');
|
|
a.href = url;
|
|
a.download = fileName;
|
|
document.body.appendChild(a);
|
|
a.click();
|
|
document.body.removeChild(a);
|
|
URL.revokeObjectURL(url);
|
|
|
|
this.showNotification('File downloaded!');
|
|
}
|
|
|
|
showNotification(message, type = 'success') {
|
|
const notification = document.createElement('div');
|
|
notification.className = `notification ${type}`;
|
|
notification.textContent = message;
|
|
|
|
document.body.appendChild(notification);
|
|
|
|
setTimeout(() => {
|
|
notification.classList.add('show');
|
|
}, 100);
|
|
|
|
setTimeout(() => {
|
|
notification.classList.remove('show');
|
|
setTimeout(() => {
|
|
document.body.removeChild(notification);
|
|
}, 300);
|
|
}, 3000);
|
|
}
|
|
|
|
async refresh() {
|
|
this.showLoading(true);
|
|
this.fileContents.clear();
|
|
await this.loadFileStructure();
|
|
this.filterAndRenderFiles();
|
|
this.showNotification('Data refreshed!');
|
|
}
|
|
|
|
showLoading(show) {
|
|
const loadingOverlay = document.getElementById('loadingOverlay');
|
|
if (loadingOverlay) {
|
|
loadingOverlay.style.display = show ? 'flex' : 'none';
|
|
}
|
|
}
|
|
|
|
toggleMobileSidebar() {
|
|
const sidebar = document.getElementById('sidebar');
|
|
const overlay = document.getElementById('mobileOverlay');
|
|
|
|
if (this.sidebarOpen) {
|
|
this.closeMobileSidebar();
|
|
} else {
|
|
sidebar.classList.add('open');
|
|
overlay.classList.add('active');
|
|
this.sidebarOpen = true;
|
|
document.body.style.overflow = 'hidden';
|
|
}
|
|
}
|
|
|
|
closeMobileSidebar() {
|
|
const sidebar = document.getElementById('sidebar');
|
|
const overlay = document.getElementById('mobileOverlay');
|
|
|
|
sidebar.classList.remove('open');
|
|
overlay.classList.remove('active');
|
|
this.sidebarOpen = false;
|
|
document.body.style.overflow = '';
|
|
}
|
|
|
|
handleResize() {
|
|
this.isMobile = window.innerWidth <= 768;
|
|
if (!this.isMobile && this.sidebarOpen) {
|
|
this.closeMobileSidebar();
|
|
}
|
|
}
|
|
|
|
formatFileSize(bytes) {
|
|
if (bytes === 0) return '0 Bytes';
|
|
const k = 1024;
|
|
const sizes = ['Bytes', 'KB', 'MB', 'GB'];
|
|
const i = Math.floor(Math.log(bytes) / Math.log(k));
|
|
return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
|
|
}
|
|
|
|
formatDate(date) {
|
|
if (!date) return 'Unknown';
|
|
const now = new Date();
|
|
const diff = now - new Date(date);
|
|
const days = Math.floor(diff / (1000 * 60 * 60 * 24));
|
|
|
|
if (days === 0) return 'Today';
|
|
if (days === 1) return 'Yesterday';
|
|
if (days < 7) return `${days} days ago`;
|
|
if (days < 30) return `${Math.floor(days / 7)} weeks ago`;
|
|
return new Date(date).toLocaleDateString();
|
|
}
|
|
|
|
markdownToHtml(markdown) {
|
|
if (!markdown) return '';
|
|
|
|
return markdown
|
|
.replace(/^# (.*$)/gim, '<h1>$1</h1>')
|
|
.replace(/^## (.*$)/gim, '<h2>$1</h2>')
|
|
.replace(/^### (.*$)/gim, '<h3>$1</h3>')
|
|
.replace(/^#### (.*$)/gim, '<h4>$1</h4>')
|
|
.replace(/^\* (.*$)/gim, '<li>$1</li>')
|
|
.replace(/^- (.*$)/gim, '<li>$1</li>')
|
|
.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
|
|
.replace(/\*(.*?)\*/g, '<em>$1</em>')
|
|
.replace(/`([^`]+)`/g, '<code>$1</code>')
|
|
.replace(/```([\s\S]*?)```/g, '<pre><code>$1</code></pre>')
|
|
.replace(/\n\n/g, '</p><p>')
|
|
.replace(/\n/g, '<br>')
|
|
.replace(/^(?!<[h1-6|li|pre])(.+)$/gm, '<p>$1</p>')
|
|
.replace(/(<li>.*?<\/li>)/gs, '<ul>$1</ul>')
|
|
.replace(/<\/ul>\s*<ul>/g, '');
|
|
}
|
|
|
|
debounce(func, wait) {
|
|
let timeout;
|
|
return function executedFunction(...args) {
|
|
const later = () => {
|
|
clearTimeout(timeout);
|
|
func(...args);
|
|
};
|
|
clearTimeout(timeout);
|
|
timeout = setTimeout(later, wait);
|
|
};
|
|
}
|
|
}
|
|
|
|
// Global functions for tree view
|
|
function toggleTreeFolder(folderName) {
|
|
const folderFiles = document.getElementById(`tree-${folderName}`);
|
|
const icon = folderFiles.previousElementSibling.querySelector('.fa-chevron-down');
|
|
|
|
if (folderFiles.style.display === 'none') {
|
|
folderFiles.style.display = 'block';
|
|
icon.style.transform = 'rotate(0deg)';
|
|
} else {
|
|
folderFiles.style.display = 'none';
|
|
icon.style.transform = 'rotate(-90deg)';
|
|
}
|
|
}
|
|
|
|
// Initialize the application
|
|
document.addEventListener('DOMContentLoaded', () => {
|
|
window.promptArsenal = new PromptArsenal();
|
|
});
|
|
|
|
// Add smooth scrolling
|
|
document.documentElement.style.scrollBehavior = 'smooth';
|