```
--------------------------------
### DOM Content Loaded Initialization
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Initializes the application by calling the `init` function once the DOM is fully loaded.
```javascript
// Initialize
document.addEventListener('DOMContentLoaded', init);
```
--------------------------------
### Theme Testing Suite
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Tests the application of dark, light, and matrix themes by mocking the document object and verifying CSS variable changes. Exits on failure.
```javascript
import { settingsManager } from './src/settings_manager.js';
console.log("๐งช Starting Theme Tests...");
// Mock document and documentElement
const styleMap = new Map();
global.document = {
documentElement: {
style: {
setProperty: (key, value) => {
styleMap.set(key, value);
}
}
},
body: {
dataset: {}
}
};
// Test 1: Apply Dark Theme (Default)
console.log("\nTest 1: Apply Dark Theme (Default)");
settingsManager.update('visuals', 'theme', 'dark');
settingsManager.applySettings();
const bgMain = styleMap.get('--bg-main');
if (bgMain === '#121212') {
console.log("โ
Dark theme applied correctly.");
} else {
console.error(`โ Failed to apply dark theme. --bg-main: ${bgMain}`);
process.exit(1);
}
// Test 2: Apply Light Theme
console.log("\nTest 2: Apply Light Theme");
settingsManager.update('visuals', 'theme', 'light');
settingsManager.applySettings();
const bgMainLight = styleMap.get('--bg-main');
if (bgMainLight === '#f5f5f5') {
console.log("โ
Light theme applied correctly.");
} else {
console.error(`โ Failed to apply light theme. --bg-main: ${bgMainLight}`);
process.exit(1);
}
// Test 3: Apply Matrix Theme
console.log("\nTest 3: Apply Matrix Theme");
settingsManager.update('visuals', 'theme', 'matrix');
settingsManager.applySettings();
const textMainMatrix = styleMap.get('--text-main');
if (textMainMatrix === '#00ff00') {
console.log("โ
Matrix theme applied correctly.");
} else {
console.error(`โ Failed to apply matrix theme. --text-main: ${textMainMatrix}`);
process.exit(1);
}
console.log("\n๐ All Theme Tests Passed!");
```
--------------------------------
### Default Application Settings
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Defines the default configuration for various application modules, including audio, gatekeeper, AI, and visuals.
```javascript
const DEFAULT_SETTINGS = {
audio: {
engine: 'browser', // 'browser', 'openai'
openAIKey: '',
recordingMode: 'toggle', // 'toggle', 'hold'
voiceId: 'default',
volume: 0.8
},
gatekeeper: {
mode: 'dynamic', // 'input', 'choice', 'dynamic'
scalingThreshold: 3
},
ai: {
geminiKey: '',
generationMode: 'text' // 'text' or 'image' (future)
},
visuals: {
decayStyle: 'both', // 'filter', 'texture', 'both', 'none'
dualCoding: 'hover', // 'always', 'hover'
theme: 'dark'
}
};
```
--------------------------------
### State Management Class
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Manages the application state, including rooms and items. Includes methods for updating, creating, and adding items, as well as resetting the state.
```javascript
class StateManager {
constructor() {
this.state = { rooms: DEFAULT_ROOMS };
this.saveState();
}
saveState() {
// Placeholder for actual save logic
console.log("State saved:", this.state);
}
/**
* Updates item details (Editing).
*/
updateItemDetails(roomId, itemId, newConcept, newVisualURL) {
const room = this.state.rooms[roomId];
if (!room) return;
const itemIndex = room.items.findIndex(i => i.id == itemId);
if (itemIndex === -1) return;
const item = room.items[itemIndex];
if (newConcept) item.concept = newConcept;
if (newVisualURL) item.visualURL = newVisualURL;
this.state.rooms[roomId].items[itemIndex] = item;
this.saveState();
return item;
}
/**
* Creates a new room.
*/
createRoom(name) {
const id = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)+/g, '');
if (this.state.rooms[id]) return null; // Already exists
const newRoom = {
id: id,
name: name,
items: []
};
this.state.rooms[id] = newRoom;
this.saveState();
return newRoom;
}
/**
* Adds a new item to a room.
*/
addItem(roomId, concept, visualURL) {
const room = this.state.rooms[roomId];
if (!room) return null;
const newItem = {
id: Date.now(),
concept: concept,
visualURL: visualURL || 'https://placehold.co/200x200?text=?',
visual: concept,
streak: 0,
lastReviewed: 0,
...DEFAULT_SRS_STATS,
dueDate: 0
};
room.items.push(newItem);
this.saveState();
return newItem;
}
/**
* Reset everything (Debug/Ritual)
*/
reset() {
this.state = { rooms: DEFAULT_ROOMS };
this.saveState();
}
}
export const stateManager = new StateManager();
```
--------------------------------
### Python Script for Codebase Ingestion
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
This script walks through a directory, filters out binary files and excluded directories/extensions, and generates a snapshot of the codebase. It also calculates and saves the differences (delta) between the current and previous snapshots.
```python
import os
import difflib
# Configuration
INGEST_DIR = "ingest"
SNAPSHOT_FILE = os.path.join(INGEST_DIR, "codebase_snapshot.txt")
DELTA_FILE = os.path.join(INGEST_DIR, "delta_snapshot.txt")
EXCLUDED_DIRS = {'.git', 'node_modules', '__pycache__', 'dist', 'build', 'ingest', '.github'}
EXCLUDED_EXTENSIONS = {'.png', '.jpg', '.jpeg', '.gif', '.ico', '.pyc', '.DS_Store', '.woff', '.woff2', '.ttf', '.eot'}
def is_text_file(filepath):
"""Simple check to avoid reading binary files based on extension."""
_, ext = os.path.splitext(filepath)
if ext.lower() in EXCLUDED_EXTENSIONS:
return False
# Additional check: try reading a small chunk
try:
with open(filepath, 'r', encoding='utf-8') as f:
f.read(1024)
return True
except UnicodeDecodeError:
return False
def generate_codebase_string(root_dir):
"""Walks the directory and generates the snapshot string."""
codebase_content = []
for root, dirs, files in os.walk(root_dir):
# Modify dirs in-place to skip ignored directories
dirs[:] = [d for d in dirs if d not in EXCLUDED_DIRS]
# Sort for deterministic output
dirs.sort()
files.sort()
for file in files:
filepath = os.path.join(root, file)
# Skip excluded files
if any(filepath.endswith(ext) for ext in EXCLUDED_EXTENSIONS):
continue
# Skip the script itself if it's in the list (optional, but good practice)
if filepath.endswith("generate_ingest.py"):
pass # We include it usually, unless specified otherwise.
if is_text_file(filepath):
try:
with open(filepath, 'r', encoding='utf-8') as f:
content = f.read()
codebase_content.append("=" * 64)
codebase_content.append(f"File: {filepath}")
codebase_content.append("=" * 64)
codebase_content.append(content)
codebase_content.append("\n") # Add newline between files
except Exception as e:
print(f"Skipping file {filepath} due to error: {e}")
return "\n".join(codebase_content)
def main():
# Ensure ingest directory exists
if not os.path.exists(INGEST_DIR):
os.makedirs(INGEST_DIR)
print(f"Created directory: {INGEST_DIR}")
# Generate current state
current_state = generate_codebase_string(".")
# Read previous state if exists
previous_state = ""
if os.path.exists(SNAPSHOT_FILE):
try:
with open(SNAPSHOT_FILE, 'r', encoding='utf-8') as f:
previous_state = f.read()
except Exception as e:
print(f"Could not read previous snapshot: {e}")
# Calculate Diff
if previous_state:
print("Calculating diff...")
diff = difflib.unified_diff(
previous_state.splitlines(),
current_state.splitlines(),
fromfile='Previous Snapshot',
tofile='Current Snapshot',
lineterm=''
)
delta_content = "\n".join(diff)
if not delta_content:
delta_content = "No changes detected."
else:
delta_content = "Initial Snapshot - No previous state to diff against."
# Write Snapshot
print(f"Writing snapshot to {SNAPSHOT_FILE}...")
with open(SNAPSHOT_FILE, 'w', encoding='utf-8') as f:
f.write(current_state)
# Write Delta
print(f"Writing delta to {DELTA_FILE}...")
with open(DELTA_FILE, 'w', encoding='utf-8') as f:
f.write(delta_content)
print("Ingest generation complete.")
if __name__ == "__main__":
main()
```
--------------------------------
### Launch Quiz Modal
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/delta_snapshot.txt
Generates and displays a quiz in a modal dialog. Closes the modal after a short delay once the quiz is completed.
```javascript
function launchQuiz() {
const currentRoomId = stateManager.getCurrentRoomId();
const room = stateManager.getRoom(currentRoomId);
const quiz = activeGatekeeper.generateQuiz(room.items);
launchQuizModal(quiz);
}
function launchQuizModal(quiz) {
// ... (quiz modal setup code) ...
modal.classList.remove('hidden');
toggleMainContent(true);
setModalFocus(modal.id);
}
```
--------------------------------
### Wire Up Voice Input Button
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Sets up a microphone button to capture voice input and populate a specified input field with the transcribed text.
```javascript
// Wire up Mic
const micBtn = document.getElementById('btn-mic-concept');
setupMicButton(micBtn, (text) => {
document.getElementById('edit-concept').value = text;
});
```
--------------------------------
### Test Settings Persistence
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Confirms that settings updated via the manager are correctly persisted to localStorage and can be retrieved.
```javascript
console.log('Test 3: Persistence');
const saved = JSON.parse(localStorage.getItem('dome_settings'));
assert.strictEqual(saved.visuals.theme, 'light', 'LocalStorage should have the updated theme');
console.log('โ
Persistence verified.');
console.log('๐ All Settings Tests Passed!');
```
--------------------------------
### Complete Ritual Walk UI
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Displays a completion message and a button to return.
```javascript
this.overlay.innerHTML = `
โจ Ritual Complete
Your mind palace is fortified.
`;
document.getElementById('ritual-finish').onclick = () => this.end();
```
--------------------------------
### Open HTML File Based on OS
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
This shell script opens an 'index.html' file in the default web browser, adapting the command based on the detected operating system (Linux, macOS, Cygwin, MSYS). If the OS is not recognized, it prompts the user to open the file manually.
```shell
# Open based on OS
if [[ "$OSTYPE" == "linux-gnu"* ]]; then
xdg-open index.html
elif [[ "$OSTYPE" == "darwin"* ]]; then
open index.html
elif [[ "$OSTYPE" == "cygwin" ]]; then
start index.html
elif [[ "$OSTYPE" == "msys" ]]; then
start index.html
else
echo "Could not detect OS to open browser automatically. Please open index.html manually."
fi
```
--------------------------------
### Handle Card Click for Gatekeeper Initialization
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Initiates the Gatekeeper for a specific item when its card is clicked, provided the card is marked as 'dusty'. It sets up the Gatekeeper with the item's concept and streak, then launches the quiz modal.
```javascript
function handleCardClick(item, cardElement) {
// If not dusty, do nothing (already clean)
if (!cardElement.classList.contains('dusty')) return;
const gkMode = settingsManager.get('gatekeeper', 'mode');
// Initialize Gatekeeper for this specific battle
activeGatekeeper = new Gatekeeper({
type: gkMode,
answer: item.concept,
history: { successes: item.streak || 0 }
});
currentTargetItem = { item, element: cardElement };
// Generate Quiz
const room = stateManager.getRoom(currentRoomId);
const quiz = activeGatekeeper.generateQuiz(room.items);
launchQuizModal(quiz);
}
```
--------------------------------
### Mock localStorage for Testing
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
A JavaScript mock implementation of the localStorage API, providing `getItem`, `setItem`, and `clear` methods. This is useful for testing JavaScript code that relies on localStorage without depending on the browser environment.
```javascript
// Mock localStorage
const localStorageMock = (function() {
let store = {};
return {
getItem: function(key) {
return store[key] || null;
},
setItem: function(key, value) {
store[key] = value.toString();
},
clear: function() {
store = {};
}
};
})();
// Assign to global
global.localStorage = localStorageMock;
```
--------------------------------
### Microphone Button Event Handling
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Sets up event listeners for microphone buttons to handle 'hold' and 'toggle' recording modes. It manages recording start/stop, UI updates, and calls the onTranscript callback with the recognized text. Ensures existing signal controllers are aborted to prevent duplicate events.
```javascript
function setupMicButton(buttonElement, onTranscript) {
if (!buttonElement) return;
// Remove any existing signal to prevent duplicated events
if (buttonElement._abortController) {
buttonElement._abortController.abort();
}
buttonElement._abortController = new AbortController();
const signal = buttonElement._abortController.signal;
let isRecording = false;
buttonElement.addEventListener('mousedown', async () => {
const mode = settingsManager.get('audio', 'recordingMode');
if (mode === 'hold') {
console.log("๐ค Hold Mode: Start");
const result = await audioEngine.startRecording();
if (result.success) {
buttonElement.classList.add('recording');
buttonElement.innerText = '๐ด Listening...';
} else {
alert(`Cannot record: ${result.error}`);
}
}
}, { signal });
buttonElement.addEventListener('mouseup', async () => {
const mode = settingsManager.get('audio', 'recordingMode');
if (mode === 'hold') {
console.log("๐ค Hold Mode: Stop");
buttonElement.classList.remove('recording');
buttonElement.innerText = 'โณ Processing...';
try {
const text = await audioEngine.stopRecording();
buttonElement.innerText = '๐๏ธ';
onTranscript(text);
} catch (err) {
console.error(err);
buttonElement.innerText = 'โ ๏ธ Error';
}
}
}, { signal });
buttonElement.addEventListener('click', async () => {
const mode = settingsManager.get('audio', 'recordingMode');
if (mode === 'toggle') {
if (!isRecording) {
console.log("๐ค Toggle Mode: Start");
const result = await audioEngine.startRecording();
if (result.success) {
isRecording = true;
buttonElement.classList.add('recording');
buttonElement.innerText = '๐ด Stop';
} else {
alert(`Cannot record: ${result.error}`);
}
} else {
console.log("๐ค Toggle Mode: Stop");
isRecording = false;
buttonElement.classList.remove('recording');
buttonElement.innerText = 'โณ Processing...';
try {
const text = await audioEngine.stopRecording();
buttonElement.innerText = '๐๏ธ';
onTranscript(text);
} catch (err) {
console.error(err);
buttonElement.innerText = 'โ ๏ธ Error';
}
}
}
}, { signal });
}
```
--------------------------------
### Default SRS Statistics Initialization
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Defines the initial state for SuperMemo-2 (SM-2) spaced repetition algorithm statistics. These values are used for new or learning items.
```javascript
/**
* srs_engine.js
* Implements the SuperMemo-2 (SM-2) Spaced Repetition Algorithm.
* Adapted for the "Dome" (Mind Palace) context.
*/
// Default starting values
export const DEFAULT_SRS_STATS = {
interval: 0, // Days (0 means new/learning)
repetition: 0, // Successive successful reviews
```
--------------------------------
### SettingsManager Class for Application Configuration
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Manages application settings, including loading from localStorage, saving changes, and applying visual themes and decay styles to the DOM. It ensures settings are persisted and updated in real-time.
```javascript
class SettingsManager {
constructor() {
this.settings = this.loadSettings();
// In case we run in an environment without DOM (like tests), we skip applySettings
if (typeof document !== 'undefined') {
this.applySettings(); // Apply on load
}
}
loadSettings() {
if (typeof localStorage === 'undefined') return DEFAULT_SETTINGS;
const saved = localStorage.getItem('dome_settings');
return saved ? { ...DEFAULT_SETTINGS, ...JSON.parse(saved) } : DEFAULT_SETTINGS;
}
saveSettings(newSettings) {
this.settings = { ...this.settings, ...newSettings };
if (typeof localStorage !== 'undefined') {
localStorage.setItem('dome_settings', JSON.stringify(this.settings));
}
if (typeof document !== 'undefined') {
this.applySettings(); // Real-time update
}
console.log("โ๏ธ Settings saved & applied.");
}
// Apply logic to the DOM (CSS Variables, Classes, etc.)
applySettings() {
const root = document.documentElement;
const v = this.settings.visuals;
// 1. Apply Theme
const theme = THEMES[v.theme] || THEMES['dark'];
Object.entries(theme).forEach(([key, value]) => {
root.style.setProperty(key, value);
});
// 2. Apply Decay Styles via CSS Variables
if (v.decayStyle === 'filter' || v.decayStyle === 'both') {
root.style.setProperty('--decay-filter', '0.4');
root.style.setProperty('--decay-blur', '1px');
} else {
root.style.setProperty('--decay-filter', '0');
root.style.setProperty('--decay-blur', '0');
}
if (v.decayStyle === 'texture' || v.decayStyle === 'both') {
root.style.setProperty('--decay-texture-opacity', '0.3');
} else {
root.style.setProperty('--decay-texture-opacity', '0');
}
// 3. Dual Coding Mode
if (document.body) {
document.body.dataset.dualCoding = v.dualCoding; // Used by CSS to toggle visibility
}
}
// Helper to get a specific setting safely
get(category, key) {
return this.settings[category]?.[key];
}
// Update a specific setting and save
update(category, key, value) {
const currentCat = this.settings[category] || {};
const newCat = { ...currentCat, [key]: value };
this.saveSettings({ [category]: newCat });
}
}
export const settingsManager = new SettingsManager();
```
--------------------------------
### Spaced Repetition System (SRS) Algorithm Formulas
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Mathematical formulas for calculating the next review interval, repetition count, and ease factor based on user feedback.
```latex
n = n_{prev} + 1
```
```latex
I = \begin{cases}
1 & \text{if } n = 1 \\
6 & \text{if } n = 2 \\
\text{round}(I_{prev} \times EF_{prev}) & \text{if } n > 2
\end{cases}
```
```latex
n = 0
I = 1
```
```latex
EF' = EF_{prev} + (0.1 - (5 - q) \times (0.08 + (5 - q) \times 0.02))
```
```latex
\text{DueDate} = \text{Date.now()} + (I \times 24 \times 60 \times 60 \times 1000)
```
--------------------------------
### State Manager Data Model
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/dev/architecture/system_overview.md
Illustrates the JSON structure for storing room and item data within the State Manager.
```json
{
"rooms": {
"foyer": {
"id": "foyer",
"items": [ ... ]
}
}
}
```
--------------------------------
### Test Add Item Functionality
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Tests the functionality of adding a new item to a room and verifies its properties and presence in the room's item list.
```javascript
console.log('Test 5: Add Item');
const newItem = stateManager.addItem('the-library', 'Book of Secrets', 'http://book.img');
assert.ok(newItem, 'Item should be added');
assert.strictEqual(newItem.concept, 'Book of Secrets', 'Concept should match');
assert.strictEqual(newItem.streak, 0, 'Default streak should be 0');
assert.strictEqual(newItem.interval, 0, 'Default interval should be 0');
assert.ok(newItem.id > 0, 'ID should be generated');
const roomItems = stateManager.getRoom('the-library').items;
assert.strictEqual(roomItems.length, 1, 'Room should have 1 item');
assert.strictEqual(roomItems[0].id, newItem.id, 'Item should be in the room');
console.log('โ
Add Item verified.');
console.log('๐ All Tests Passed!');
```
--------------------------------
### Initialize and Attach Event Listeners for Modal
Source: https://github.com/mnemonice/mind-palace-dome/blob/main/ingest/codebase_snapshot.txt
Attaches static event listeners to modal elements once. Handles closing the modal and file uploads via FileReader for base64 encoding.
```javascript
// Attach static event listeners ONCE
modal.querySelector('.close-btn').addEventListener('click', () => {
modal.classList.add('hidden');
toggleMainContent(false);
});
// File Upload Handler
const fileInput = document.getElementById('edit-file-upload');
fileInput.addEventListener('change', (e) => {
const file = e.target.files[0];
if (file) {
const reader = new FileReader();
reader.onload = (readerEvent) => {
document.getElementById('edit-url').value = readerEvent.target.result; // Base64
};
reader.readAsDataURL(file);
}
});
```