From b9cd217356f053070781787236d5e4eee262a6a6 Mon Sep 17 00:00:00 2001
From: Will Feldman <13539982+willfeldman@users.noreply.github.com>
Date: Fri, 8 Aug 2025 16:46:18 -0400
Subject: [PATCH 1/2] Take 1

---
 package.json            |   5 +-
 scripts/README.md       | 233 ++++++++++
 scripts/data-manager.js | 949 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 1186 insertions(+), 1 deletion(-)
 create mode 100644 scripts/README.md
 create mode 100755 scripts/data-manager.js

diff --git a/package.json b/package.json
index e644f45..f28973f 100644
--- a/package.json
+++ b/package.json
@@ -32,7 +32,10 @@
     "build": "react-scripts build",
     "test": "react-scripts test",
     "eject": "react-scripts eject",
-    "pretty": "prettier --write ."
+    "pretty": "prettier --write .",
+    "data": "node scripts/data-manager.js",
+    "data:view": "node scripts/data-manager.js --view",
+    "data:validate": "node scripts/data-manager.js --validate"
   },
   "eslintConfig": {
     "extends": [
diff --git a/scripts/README.md b/scripts/README.md
new file mode 100644
index 0000000..f44c421
--- /dev/null
+++ b/scripts/README.md
@@ -0,0 +1,233 @@
+# Portfolio Data Manager CLI
+
+A comprehensive command-line tool for managing your portfolio's static data files through an interactive interface.
+
+## 🚀 Quick Start
+
+```bash
+# Launch the interactive data manager
+npm run data
+
+# Alternative direct usage
+node scripts/data-manager.js
+```
+
+## 📋 Features
+
+### 1. **View Data**
+- Browse all data types (experiences, projects, organizations, awards)
+- View detailed entries with formatted output
+- Get data summary with counts and quick consistency checks
+
+### 2. **Add New Entry**
+- Interactive prompts for all required and optional fields
+- Automatic ID assignment
+- Schema validation
+- Preview before saving
+
+### 3. **Edit Entry**
+- Select entries from a list
+- Edit individual fields while preserving existing values
+- Support for complex nested structures (positions, roles, tags)
+- Preview changes before saving
+
+### 4. **Delete Entry**
+- Safe deletion with confirmation prompts
+- Permanent deletion warning
+- List-based selection interface
+
+### 5. **Data Validation**
+- Comprehensive schema validation
+- Duplicate ID detection
+- Missing required field checks
+- URL format validation
+- Nested structure validation
+
+### 6. **Data Export**
+- JSON export with timestamps
+- CSV export for simplified analysis
+- Preserves data integrity
+
+## 📊 Data Types Supported
+
+### Experiences
+- **Required**: `id`, `positions`, `company`, `location`
+- **Optional**: `url`, `linkedin`, `headerImage`, `logo`, `additionalInformation`, `fullDates`
+- **Nested**: `positions` (title, dates, type, description, summary)
+
+### Projects
+- **Required**: `id`, `title`, `description`
+- **Optional**: `github`, `url`, `code`, `tags`, `images`, `additionalInformation`
+- **Nested**: `tags` (name, color, background)
+
+### Organizations
+- **Required**: `id`, `name`, `yearsActive`
+- **Optional**: `role`, `summary`, `description`, `logo`, `headerImage`
+- **Nested**: `role` (title, years)
+
+### Awards
+- **Required**: `id`, `name`, `issuer`, `date`
+- **Optional**: `description`
+
+## 🔧 Usage Examples
+
+### Adding a New Experience
+```bash
+npm run data
+# Select option 2 (Add New Entry)
+# Select option 1 (Experience)
+# Follow the interactive prompts
+```
+
+### Quick Data Validation
+The CLI performs automatic validation including:
+- Duplicate ID detection across all entries
+- Missing required fields
+- Proper URL formatting
+- Nested structure integrity
+
+### Bulk Operations
+- View all data with summary statistics
+- Export all data types simultaneously
+- Validate entire dataset at once
+
+## ⚠️ Safety Features
+
+### Data Backup
+- All edits are validated before saving
+- Original data is preserved until confirmed
+- Automatic reload on cancellation
+
+### Deletion Protection
+- Requires typing "DELETE" to confirm
+- Multiple confirmation prompts
+- No accidental deletions
+
+### File Integrity
+- Preserves JavaScript module structure
+- Maintains existing formatting where possible
+- Handles complex data types (arrays, objects)
+
+## 🛠️ Technical Details
+
+### File Structure
+```
+scripts/
+├── data-manager.js       # Main CLI application
+└── README.md            # This documentation
+
+src/data/                # Data files managed by CLI
+├── experience.js
+├── project.js
+├── organization.js
+└── award.js
+```
+
+### Schema Validation
+The CLI uses predefined schemas to ensure data consistency:
+
+```javascript
+const SCHEMAS = {
+  experiences: {
+    required: ['id', 'positions', 'company', 'location'],
+    optional: ['url', 'linkedin', 'headerImage', 'logo', 'additionalInformation'],
+    nested: {
+      positions: {
+        required: ['title', 'dates', 'type'],
+        optional: ['description', 'summary']
+      }
+    }
+  }
+  // ... other schemas
+};
+```
+
+### Export Formats
+
+#### JSON Export
+- Complete data structure preservation
+- Includes export metadata (timestamp, etc.)
+- Suitable for backups and migration
+
+#### CSV Export  
+- Flattened structure for analysis
+- Separate files per data type
+- Handles complex fields appropriately
+
+## 🔍 Validation Rules
+
+1. **ID Uniqueness**: No duplicate IDs within each data type
+2. **Required Fields**: All schema-required fields must be present and non-empty
+3. **URL Format**: URLs must start with `http://` or `https://`
+4. **Nested Validation**: Complex structures validated recursively
+5. **Type Consistency**: Array and object types maintained
+
+## 📝 Best Practices
+
+### Data Entry
+1. Use consistent date formats (e.g., "Jan. 2023 - Present")
+2. Keep descriptions as arrays of strings for bullet points
+3. Use full URLs including protocol (https://)
+4. Maintain consistent company/organization naming
+
+### Editing Workflow
+1. Always run validation after major changes
+2. Preview entries before saving
+3. Use the summary view to check overall data health
+4. Export data regularly for backups
+
+### Tags and Categories
+- Projects: Use existing tag system with consistent naming
+- Keep tag colors and backgrounds consistent with existing palette
+- Add new tags thoughtfully to maintain visual consistency
+
+## 🚨 Troubleshooting
+
+### Common Issues
+
+**CLI won't start**
+```bash
+# Ensure the script is executable
+chmod +x scripts/data-manager.js
+
+# Check Node.js version (requires Node.js 12+)
+node --version
+```
+
+**Data not saving**
+- Check file permissions on `src/data/` directory
+- Ensure no syntax errors in existing data files
+- Verify the data structure matches the schema
+
+**Validation errors**
+- Run the validation tool to identify specific issues
+- Check for missing required fields
+- Verify URL formats include protocol
+
+### Recovery
+If data becomes corrupted:
+1. Check git history for previous versions
+2. Use exported JSON files to restore data
+3. Manually fix syntax errors in data files
+
+## 🔄 Integration
+
+The CLI integrates seamlessly with your existing workflow:
+
+- **Development**: Use during development to quickly add/edit content
+- **Content Updates**: Ideal for regular portfolio updates
+- **Data Maintenance**: Regular validation ensures data quality
+- **Backup/Export**: Easy data export for backup purposes
+
+## 🎯 Future Enhancements
+
+Potential future features:
+- Batch import from CSV/JSON
+- Data migration tools
+- Advanced search/filtering
+- Template-based entry creation
+- Integration with git for automatic commits
+
+---
+
+This CLI tool makes managing your portfolio data efficient, safe, and user-friendly while maintaining the flexibility of your existing data structure.
\ No newline at end of file
diff --git a/scripts/data-manager.js b/scripts/data-manager.js
new file mode 100755
index 0000000..21ebca7
--- /dev/null
+++ b/scripts/data-manager.js
@@ -0,0 +1,949 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+const DATA_FILES = {
+  experiences: './src/data/experience.js',
+  projects: './src/data/project.js',
+  organizations: './src/data/organization.js',
+  awards: './src/data/award.js'
+};
+
+const SCHEMAS = {
+  experiences: {
+    required: ['id', 'positions', 'company', 'location'],
+    optional: ['url', 'linkedin', 'headerImage', 'logo', 'additionalInformation', 'fullDates'],
+    nested: {
+      positions: {
+        required: ['title', 'dates', 'type'],
+        optional: ['description', 'summary']
+      }
+    }
+  },
+  projects: {
+    required: ['id', 'title', 'description'],
+    optional: ['github', 'url', 'code', 'tags', 'images', 'additionalInformation'],
+    nested: {
+      tags: {
+        required: ['name', 'color', 'background'],
+        optional: []
+      }
+    }
+  },
+  organizations: {
+    required: ['id', 'name', 'yearsActive'],
+    optional: ['role', 'summary', 'description', 'logo', 'headerImage'],
+    nested: {
+      role: {
+        required: ['title', 'years'],
+        optional: []
+      }
+    }
+  },
+  awards: {
+    required: ['id', 'name', 'issuer', 'date'],
+    optional: ['description'],
+    nested: {}
+  }
+};
+
+class DataManager {
+  constructor() {
+    this.currentData = {};
+    this.loadAllData();
+  }
+
+  loadAllData() {
+    for (const [type, filePath] of Object.entries(DATA_FILES)) {
+      try {
+        delete require.cache[require.resolve(path.resolve(filePath))];
+        const data = require(path.resolve(filePath));
+        this.currentData[type] = data[type] || [];
+      } catch (error) {
+        console.error(`Error loading ${type}:`, error.message);
+        this.currentData[type] = [];
+      }
+    }
+  }
+
+  async showMainMenu() {
+    console.clear();
+    console.log('🚀 Portfolio Data Manager');
+    console.log('========================');
+    console.log('1. View Data');
+    console.log('2. Add New Entry');
+    console.log('3. Edit Entry');
+    console.log('4. Delete Entry');
+    console.log('5. Validate Data');
+    console.log('6. Export Data');
+    console.log('7. Exit');
+    console.log('');
+
+    const choice = await this.prompt('Select an option (1-7): ');
+    await this.handleMainMenuChoice(choice);
+  }
+
+  async handleMainMenuChoice(choice) {
+    switch (choice.trim()) {
+      case '1':
+        await this.viewDataMenu();
+        break;
+      case '2':
+        await this.addEntryMenu();
+        break;
+      case '3':
+        await this.editEntryMenu();
+        break;
+      case '4':
+        await this.deleteEntryMenu();
+        break;
+      case '5':
+        await this.validateAllData();
+        break;
+      case '6':
+        await this.exportDataMenu();
+        break;
+      case '7':
+        console.log('Goodbye! 👋');
+        process.exit(0);
+        break;
+      default:
+        console.log('Invalid option. Please try again.');
+        await this.pause();
+        await this.showMainMenu();
+    }
+  }
+
+  async viewDataMenu() {
+    console.clear();
+    console.log('📊 View Data');
+    console.log('============');
+    console.log('1. Experiences');
+    console.log('2. Projects');
+    console.log('3. Organizations');
+    console.log('4. Awards');
+    console.log('5. Summary (All)');
+    console.log('6. Back to Main Menu');
+    console.log('');
+
+    const choice = await this.prompt('Select data type (1-6): ');
+    
+    switch (choice.trim()) {
+      case '1':
+        await this.displayData('experiences');
+        break;
+      case '2':
+        await this.displayData('projects');
+        break;
+      case '3':
+        await this.displayData('organizations');
+        break;
+      case '4':
+        await this.displayData('awards');
+        break;
+      case '5':
+        await this.displaySummary();
+        break;
+      case '6':
+        await this.showMainMenu();
+        return;
+      default:
+        console.log('Invalid option. Please try again.');
+        await this.pause();
+        await this.viewDataMenu();
+        return;
+    }
+    
+    await this.pause();
+    await this.viewDataMenu();
+  }
+
+  displayData(type) {
+    console.clear();
+    const data = this.currentData[type];
+    const title = type.charAt(0).toUpperCase() + type.slice(1);
+    
+    console.log(`📋 ${title}`);
+    console.log('='.repeat(title.length + 3));
+    console.log(`Total entries: ${data.length}\n`);
+
+    if (data.length === 0) {
+      console.log('No entries found.');
+      return;
+    }
+
+    data.forEach((item, index) => {
+      console.log(`${index + 1}. ${this.getItemTitle(item, type)}`);
+      console.log(`   ID: ${item.id}`);
+      
+      if (type === 'experiences') {
+        console.log(`   Company: ${item.company}`);
+        console.log(`   Positions: ${item.positions.length}`);
+        if (item.fullDates) {
+          console.log(`   Duration: ${item.fullDates}`);
+        } else if (item.positions[0]) {
+          console.log(`   Duration: ${item.positions[0].dates}`);
+        }
+      } else if (type === 'projects') {
+        console.log(`   Description: ${item.description.substring(0, 80)}${item.description.length > 80 ? '...' : ''}`);
+        if (item.tags) {
+          console.log(`   Tags: ${item.tags.map(tag => tag.name).join(', ')}`);
+        }
+      } else if (type === 'organizations') {
+        console.log(`   Duration: ${item.yearsActive}`);
+        if (item.role && item.role.length > 0) {
+          console.log(`   Latest Role: ${item.role[0].title}`);
+        }
+      } else if (type === 'awards') {
+        console.log(`   Issuer: ${item.issuer}`);
+        console.log(`   Date: ${item.date}`);
+      }
+      
+      console.log('');
+    });
+  }
+
+  displaySummary() {
+    console.clear();
+    console.log('📈 Data Summary');
+    console.log('===============');
+    console.log(`Experiences: ${this.currentData.experiences.length} entries`);
+    console.log(`Projects: ${this.currentData.projects.length} entries`);
+    console.log(`Organizations: ${this.currentData.organizations.length} entries`);
+    console.log(`Awards: ${this.currentData.awards.length} entries`);
+    console.log(`Total entries: ${Object.values(this.currentData).reduce((sum, arr) => sum + arr.length, 0)}`);
+    console.log('');
+
+    // Data consistency check
+    console.log('🔍 Quick Consistency Check:');
+    const issues = this.quickValidation();
+    if (issues.length === 0) {
+      console.log('✅ No obvious issues found');
+    } else {
+      issues.forEach(issue => console.log(`⚠️  ${issue}`));
+    }
+  }
+
+  quickValidation() {
+    const issues = [];
+    
+    // Check for duplicate IDs within each type
+    for (const [type, data] of Object.entries(this.currentData)) {
+      const ids = data.map(item => item.id);
+      const duplicateIds = ids.filter((id, index) => ids.indexOf(id) !== index);
+      if (duplicateIds.length > 0) {
+        issues.push(`Duplicate IDs in ${type}: ${[...new Set(duplicateIds)].join(', ')}`);
+      }
+    }
+
+    // Check for missing required fields
+    for (const [type, data] of Object.entries(this.currentData)) {
+      const schema = SCHEMAS[type];
+      data.forEach((item, index) => {
+        schema.required.forEach(field => {
+          if (!item.hasOwnProperty(field) || item[field] === undefined || item[field] === '') {
+            issues.push(`${type}[${index}] missing required field: ${field}`);
+          }
+        });
+      });
+    }
+
+    return issues;
+  }
+
+  async addEntryMenu() {
+    console.clear();
+    console.log('➕ Add New Entry');
+    console.log('================');
+    console.log('1. Experience');
+    console.log('2. Project');
+    console.log('3. Organization');
+    console.log('4. Award');
+    console.log('5. Back to Main Menu');
+    console.log('');
+
+    const choice = await this.prompt('Select entry type (1-5): ');
+    
+    const typeMap = {
+      '1': 'experiences',
+      '2': 'projects',
+      '3': 'organizations',
+      '4': 'awards'
+    };
+
+    if (choice === '5') {
+      await this.showMainMenu();
+      return;
+    }
+
+    const type = typeMap[choice.trim()];
+    if (!type) {
+      console.log('Invalid option. Please try again.');
+      await this.pause();
+      await this.addEntryMenu();
+      return;
+    }
+
+    await this.addEntry(type);
+  }
+
+  async addEntry(type) {
+    console.clear();
+    const schema = SCHEMAS[type];
+    const newEntry = {};
+    
+    console.log(`➕ Add New ${type.slice(0, -1).charAt(0).toUpperCase() + type.slice(0, -1).slice(1)}`);
+    console.log('='.repeat(15 + type.length));
+
+    // Get next ID
+    const existingIds = this.currentData[type].map(item => item.id);
+    const nextId = existingIds.length > 0 ? Math.max(...existingIds) + 1 : 0;
+    newEntry.id = nextId;
+    console.log(`ID: ${nextId} (auto-assigned)\n`);
+
+    // Collect required fields
+    for (const field of schema.required.filter(f => f !== 'id')) {
+      if (field === 'positions' && type === 'experiences') {
+        newEntry[field] = await this.collectPositions();
+      } else if (field === 'role' && type === 'organizations') {
+        newEntry[field] = await this.collectRoles();
+      } else if (Array.isArray(this.getFieldExample(type, field))) {
+        const value = await this.prompt(`${field} (comma-separated): `);
+        newEntry[field] = value.split(',').map(v => v.trim()).filter(v => v);
+      } else {
+        newEntry[field] = await this.prompt(`${field}: `);
+      }
+    }
+
+    // Ask for optional fields
+    console.log('\nOptional fields (press Enter to skip):');
+    for (const field of schema.optional) {
+      if (field === 'tags' && type === 'projects') {
+        const tagsInput = await this.prompt(`${field} (comma-separated tag names): `);
+        if (tagsInput.trim()) {
+          newEntry[field] = await this.processTags(tagsInput);
+        }
+      } else if (Array.isArray(this.getFieldExample(type, field))) {
+        const value = await this.prompt(`${field} (comma-separated): `);
+        if (value.trim()) {
+          newEntry[field] = value.split(',').map(v => v.trim()).filter(v => v);
+        }
+      } else {
+        const value = await this.prompt(`${field}: `);
+        if (value.trim()) {
+          newEntry[field] = value;
+        }
+      }
+    }
+
+    // Preview the entry
+    console.log('\n📋 Preview:');
+    console.log(JSON.stringify(newEntry, null, 2));
+    
+    const confirm = await this.prompt('\nSave this entry? (y/n): ');
+    if (confirm.toLowerCase().startsWith('y')) {
+      this.currentData[type].push(newEntry);
+      await this.saveData(type);
+      console.log('✅ Entry saved successfully!');
+    } else {
+      console.log('❌ Entry cancelled.');
+    }
+
+    await this.pause();
+    await this.showMainMenu();
+  }
+
+  async collectPositions() {
+    const positions = [];
+    let addAnother = true;
+
+    while (addAnother) {
+      console.log(`\nPosition ${positions.length + 1}:`);
+      const position = {};
+      
+      position.title = await this.prompt('  Title: ');
+      position.dates = await this.prompt('  Dates: ');
+      position.type = await this.prompt('  Type (Full-time/Part-time/Internship): ');
+      
+      const description = await this.prompt('  Description (comma-separated bullet points): ');
+      if (description.trim()) {
+        position.description = description.split(',').map(d => d.trim()).filter(d => d);
+      }
+      
+      const summary = await this.prompt('  Summary (optional): ');
+      if (summary.trim()) {
+        position.summary = summary;
+      }
+
+      positions.push(position);
+
+      const more = await this.prompt('Add another position? (y/n): ');
+      addAnother = more.toLowerCase().startsWith('y');
+    }
+
+    return positions;
+  }
+
+  async collectRoles() {
+    const roles = [];
+    let addAnother = true;
+
+    while (addAnother) {
+      console.log(`\nRole ${roles.length + 1}:`);
+      const role = {};
+      
+      role.title = await this.prompt('  Title: ');
+      role.years = await this.prompt('  Years: ');
+
+      roles.push(role);
+
+      const more = await this.prompt('Add another role? (y/n): ');
+      addAnother = more.toLowerCase().startsWith('y');
+    }
+
+    return roles;
+  }
+
+  async processTags(tagsInput) {
+    // This would ideally integrate with the existing tag system from project.js
+    // For now, we'll create basic tag objects
+    return tagsInput.split(',').map(tagName => {
+      const name = tagName.trim();
+      return {
+        name,
+        color: "rgb(193, 198, 255)", // Default color
+        background: "rgba(75, 77, 99, 0.85)" // Default background
+      };
+    });
+  }
+
+  async editEntryMenu() {
+    console.clear();
+    console.log('✏️  Edit Entry');
+    console.log('==============');
+    console.log('1. Experiences');
+    console.log('2. Projects');
+    console.log('3. Organizations');
+    console.log('4. Awards');
+    console.log('5. Back to Main Menu');
+    console.log('');
+
+    const choice = await this.prompt('Select data type (1-5): ');
+    
+    const typeMap = {
+      '1': 'experiences',
+      '2': 'projects',
+      '3': 'organizations',
+      '4': 'awards'
+    };
+
+    if (choice === '5') {
+      await this.showMainMenu();
+      return;
+    }
+
+    const type = typeMap[choice.trim()];
+    if (!type) {
+      console.log('Invalid option. Please try again.');
+      await this.pause();
+      await this.editEntryMenu();
+      return;
+    }
+
+    await this.selectAndEditEntry(type);
+  }
+
+  async selectAndEditEntry(type) {
+    console.clear();
+    const data = this.currentData[type];
+    
+    if (data.length === 0) {
+      console.log(`No ${type} found to edit.`);
+      await this.pause();
+      await this.editEntryMenu();
+      return;
+    }
+
+    console.log(`✏️  Select ${type.slice(0, -1)} to Edit`);
+    console.log('='.repeat(25));
+
+    data.forEach((item, index) => {
+      console.log(`${index + 1}. ${this.getItemTitle(item, type)} (ID: ${item.id})`);
+    });
+    console.log(`${data.length + 1}. Back to Edit Menu`);
+    console.log('');
+
+    const choice = await this.prompt(`Select entry (1-${data.length + 1}): `);
+    const index = parseInt(choice) - 1;
+
+    if (index === data.length) {
+      await this.editEntryMenu();
+      return;
+    }
+
+    if (index >= 0 && index < data.length) {
+      await this.editEntry(type, index);
+    } else {
+      console.log('Invalid selection. Please try again.');
+      await this.pause();
+      await this.selectAndEditEntry(type);
+    }
+  }
+
+  async editEntry(type, index) {
+    console.clear();
+    const entry = this.currentData[type][index];
+    const schema = SCHEMAS[type];
+    
+    console.log(`✏️  Editing: ${this.getItemTitle(entry, type)}`);
+    console.log('='.repeat(40));
+    console.log('Current values shown in [brackets]. Press Enter to keep current value.\n');
+
+    const allFields = [...schema.required, ...schema.optional];
+    
+    for (const field of allFields) {
+      if (field === 'id') continue; // Skip ID editing
+      
+      const currentValue = entry[field];
+      let displayValue = '';
+      
+      if (Array.isArray(currentValue)) {
+        if (field === 'positions' || field === 'role') {
+          displayValue = `${currentValue.length} items`;
+        } else {
+          displayValue = currentValue.join(', ');
+        }
+      } else if (typeof currentValue === 'object' && currentValue !== null) {
+        displayValue = 'complex object';
+      } else {
+        displayValue = currentValue || 'not set';
+      }
+
+      console.log(`${field} [${displayValue}]:`);
+      
+      if (field === 'positions' && type === 'experiences') {
+        const editPositions = await this.prompt('Edit positions? (y/n): ');
+        if (editPositions.toLowerCase().startsWith('y')) {
+          entry[field] = await this.editPositions(currentValue || []);
+        }
+      } else if (field === 'role' && type === 'organizations') {
+        const editRoles = await this.prompt('Edit roles? (y/n): ');
+        if (editRoles.toLowerCase().startsWith('y')) {
+          entry[field] = await this.editRoles(currentValue || []);
+        }
+      } else if (field === 'tags' && type === 'projects') {
+        const editTags = await this.prompt('Edit tags? (y/n): ');
+        if (editTags.toLowerCase().startsWith('y')) {
+          const tagsInput = await this.prompt('Enter tag names (comma-separated): ');
+          if (tagsInput.trim()) {
+            entry[field] = await this.processTags(tagsInput);
+          }
+        }
+      } else {
+        const newValue = await this.prompt('> ');
+        if (newValue.trim()) {
+          if (Array.isArray(currentValue)) {
+            entry[field] = newValue.split(',').map(v => v.trim()).filter(v => v);
+          } else {
+            entry[field] = newValue;
+          }
+        }
+      }
+    }
+
+    console.log('\n📋 Updated Entry:');
+    console.log(JSON.stringify(entry, null, 2));
+    
+    const confirm = await this.prompt('\nSave changes? (y/n): ');
+    if (confirm.toLowerCase().startsWith('y')) {
+      await this.saveData(type);
+      console.log('✅ Changes saved successfully!');
+    } else {
+      console.log('❌ Changes cancelled.');
+      this.loadAllData(); // Reload original data
+    }
+
+    await this.pause();
+    await this.showMainMenu();
+  }
+
+  async editPositions(positions) {
+    // Implementation for editing positions array
+    console.log('Position editing - simplified for now');
+    return positions;
+  }
+
+  async editRoles(roles) {
+    // Implementation for editing roles array
+    console.log('Role editing - simplified for now');
+    return roles;
+  }
+
+  async deleteEntryMenu() {
+    console.clear();
+    console.log('🗑️  Delete Entry');
+    console.log('================');
+    console.log('1. Experiences');
+    console.log('2. Projects');
+    console.log('3. Organizations');
+    console.log('4. Awards');
+    console.log('5. Back to Main Menu');
+    console.log('');
+
+    const choice = await this.prompt('Select data type (1-5): ');
+    
+    const typeMap = {
+      '1': 'experiences',
+      '2': 'projects',
+      '3': 'organizations',
+      '4': 'awards'
+    };
+
+    if (choice === '5') {
+      await this.showMainMenu();
+      return;
+    }
+
+    const type = typeMap[choice.trim()];
+    if (!type) {
+      console.log('Invalid option. Please try again.');
+      await this.pause();
+      await this.deleteEntryMenu();
+      return;
+    }
+
+    await this.selectAndDeleteEntry(type);
+  }
+
+  async selectAndDeleteEntry(type) {
+    console.clear();
+    const data = this.currentData[type];
+    
+    if (data.length === 0) {
+      console.log(`No ${type} found to delete.`);
+      await this.pause();
+      await this.deleteEntryMenu();
+      return;
+    }
+
+    console.log(`🗑️  Select ${type.slice(0, -1)} to Delete`);
+    console.log('='.repeat(25));
+
+    data.forEach((item, index) => {
+      console.log(`${index + 1}. ${this.getItemTitle(item, type)} (ID: ${item.id})`);
+    });
+    console.log(`${data.length + 1}. Back to Delete Menu`);
+    console.log('');
+
+    const choice = await this.prompt(`Select entry (1-${data.length + 1}): `);
+    const index = parseInt(choice) - 1;
+
+    if (index === data.length) {
+      await this.deleteEntryMenu();
+      return;
+    }
+
+    if (index >= 0 && index < data.length) {
+      const entry = data[index];
+      console.log(`\n⚠️  You are about to delete: ${this.getItemTitle(entry, type)}`);
+      console.log('This action cannot be undone!');
+      
+      const confirm = await this.prompt('\nAre you sure? Type "DELETE" to confirm: ');
+      if (confirm === 'DELETE') {
+        this.currentData[type].splice(index, 1);
+        await this.saveData(type);
+        console.log('✅ Entry deleted successfully!');
+      } else {
+        console.log('❌ Deletion cancelled.');
+      }
+      
+      await this.pause();
+      await this.deleteEntryMenu();
+    } else {
+      console.log('Invalid selection. Please try again.');
+      await this.pause();
+      await this.selectAndDeleteEntry(type);
+    }
+  }
+
+  async validateAllData() {
+    console.clear();
+    console.log('🔍 Data Validation');
+    console.log('==================');
+
+    const allIssues = [];
+
+    for (const [type, data] of Object.entries(this.currentData)) {
+      console.log(`\nValidating ${type}...`);
+      const issues = this.validateDataType(type, data);
+      
+      if (issues.length === 0) {
+        console.log(`✅ ${type}: No issues found`);
+      } else {
+        console.log(`⚠️  ${type}: ${issues.length} issues found`);
+        issues.forEach(issue => {
+          console.log(`   - ${issue}`);
+          allIssues.push(`${type}: ${issue}`);
+        });
+      }
+    }
+
+    console.log('\n' + '='.repeat(40));
+    if (allIssues.length === 0) {
+      console.log('🎉 All data is valid!');
+    } else {
+      console.log(`⚠️  Total issues found: ${allIssues.length}`);
+    }
+
+    await this.pause();
+    await this.showMainMenu();
+  }
+
+  validateDataType(type, data) {
+    const issues = [];
+    const schema = SCHEMAS[type];
+
+    // Check for duplicate IDs
+    const ids = data.map(item => item.id);
+    const duplicateIds = ids.filter((id, index) => ids.indexOf(id) !== index);
+    if (duplicateIds.length > 0) {
+      issues.push(`Duplicate IDs: ${[...new Set(duplicateIds)].join(', ')}`);
+    }
+
+    // Validate each entry
+    data.forEach((item, index) => {
+      // Check required fields
+      schema.required.forEach(field => {
+        if (!item.hasOwnProperty(field) || item[field] === undefined || item[field] === '') {
+          issues.push(`Entry ${index} (ID: ${item.id}): Missing required field '${field}'`);
+        }
+      });
+
+      // Check nested structures
+      Object.entries(schema.nested).forEach(([field, nestedSchema]) => {
+        if (item[field] && Array.isArray(item[field])) {
+          item[field].forEach((nestedItem, nestedIndex) => {
+            nestedSchema.required.forEach(nestedField => {
+              if (!nestedItem.hasOwnProperty(nestedField) || nestedItem[nestedField] === undefined || nestedItem[nestedField] === '') {
+                issues.push(`Entry ${index} (ID: ${item.id}): ${field}[${nestedIndex}] missing required field '${nestedField}'`);
+              }
+            });
+          });
+        }
+      });
+
+      // Type-specific validations
+      if (type === 'experiences' && item.url && Array.isArray(item.url)) {
+        item.url.forEach((url, urlIndex) => {
+          if (url && !url.startsWith('http')) {
+            issues.push(`Entry ${index} (ID: ${item.id}): url[${urlIndex}] should start with http/https`);
+          }
+        });
+      } else if (item.url && typeof item.url === 'string' && !item.url.startsWith('http')) {
+        issues.push(`Entry ${index} (ID: ${item.id}): url should start with http/https`);
+      }
+    });
+
+    return issues;
+  }
+
+  async exportDataMenu() {
+    console.clear();
+    console.log('📤 Export Data');
+    console.log('==============');
+    console.log('1. Export as JSON');
+    console.log('2. Export as CSV (simplified)');
+    console.log('3. Back to Main Menu');
+    console.log('');
+
+    const choice = await this.prompt('Select export format (1-3): ');
+    
+    switch (choice.trim()) {
+      case '1':
+        await this.exportAsJSON();
+        break;
+      case '2':
+        await this.exportAsCSV();
+        break;
+      case '3':
+        await this.showMainMenu();
+        return;
+      default:
+        console.log('Invalid option. Please try again.');
+        await this.pause();
+        await this.exportDataMenu();
+    }
+  }
+
+  async exportAsJSON() {
+    const timestamp = new Date().toISOString().slice(0, 19).replace(/:/g, '-');
+    const filename = `portfolio-data-export-${timestamp}.json`;
+    const exportData = {
+      exportDate: new Date().toISOString(),
+      data: this.currentData
+    };
+
+    try {
+      fs.writeFileSync(filename, JSON.stringify(exportData, null, 2));
+      console.log(`✅ Data exported to ${filename}`);
+    } catch (error) {
+      console.log(`❌ Export failed: ${error.message}`);
+    }
+
+    await this.pause();
+    await this.exportDataMenu();
+  }
+
+  async exportAsCSV() {
+    const timestamp = new Date().toISOString().slice(0, 19).replace(/:/g, '-');
+    
+    for (const [type, data] of Object.entries(this.currentData)) {
+      const filename = `${type}-${timestamp}.csv`;
+      let csv = '';
+
+      if (data.length > 0) {
+        // Create CSV headers based on first item
+        const headers = Object.keys(data[0]).filter(key => typeof data[0][key] !== 'object' || data[0][key] === null);
+        csv += headers.join(',') + '\n';
+
+        // Add data rows
+        data.forEach(item => {
+          const row = headers.map(header => {
+            let value = item[header] || '';
+            // Escape commas and quotes in CSV
+            if (typeof value === 'string' && (value.includes(',') || value.includes('"'))) {
+              value = '"' + value.replace(/"/g, '""') + '"';
+            }
+            return value;
+          });
+          csv += row.join(',') + '\n';
+        });
+
+        try {
+          fs.writeFileSync(filename, csv);
+          console.log(`✅ ${type} exported to ${filename}`);
+        } catch (error) {
+          console.log(`❌ Export failed for ${type}: ${error.message}`);
+        }
+      }
+    }
+
+    await this.pause();
+    await this.exportDataMenu();
+  }
+
+  async saveData(type) {
+    const filePath = DATA_FILES[type];
+    const data = this.currentData[type];
+    
+    // Generate the JavaScript file content
+    const varName = type;
+    let content = `var ${varName} = ${JSON.stringify(data, null, 2)};\n\n`;
+    content += `module.exports = { ${varName} };\n`;
+
+    // Special handling for projects to include projectTags
+    if (type === 'projects') {
+      // Read existing file to preserve projectTags
+      const existingContent = fs.readFileSync(filePath, 'utf8');
+      const projectTagsMatch = existingContent.match(/var projectTags = \[[\s\S]*?\];/);
+      const getProjectTagMatch = existingContent.match(/function getProjectTagByName[\s\S]*?^}/m);
+      
+      if (projectTagsMatch && getProjectTagMatch) {
+        content = projectTagsMatch[0] + '\n\n' + getProjectTagMatch[0] + '\n\n' + content;
+      }
+    }
+
+    try {
+      fs.writeFileSync(filePath, content);
+      console.log(`✅ ${type} saved to ${filePath}`);
+    } catch (error) {
+      console.log(`❌ Save failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  getItemTitle(item, type) {
+    switch (type) {
+      case 'experiences':
+        return item.company || 'Unnamed Company';
+      case 'projects':
+        return item.title || 'Untitled Project';
+      case 'organizations':
+        return item.name || 'Unnamed Organization';
+      case 'awards':
+        return item.name || 'Unnamed Award';
+      default:
+        return 'Unknown Item';
+    }
+  }
+
+  getFieldExample(type, field) {
+    const examples = {
+      experiences: {
+        company: 'Company Name',
+        location: 'City, State',
+        url: 'https://company.com',
+        description: ['First achievement', 'Second achievement']
+      },
+      projects: {
+        title: 'Project Name',
+        description: 'Brief project description',
+        tags: [{name: 'React', color: 'rgb(193, 198, 255)', background: 'rgba(75, 77, 99, 0.85)'}],
+        images: ['/src/image1.png', '/src/image2.png']
+      },
+      organizations: {
+        name: 'Organization Name',
+        yearsActive: 'Start - End',
+        description: ['Achievement 1', 'Achievement 2']
+      },
+      awards: {
+        name: 'Award Name',
+        issuer: 'Issuing Organization',
+        date: 'Month Year'
+      }
+    };
+
+    return examples[type]?.[field] || '';
+  }
+
+  prompt(question) {
+    return new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        resolve(answer);
+      });
+    });
+  }
+
+  pause() {
+    return this.prompt('Press Enter to continue...');
+  }
+}
+
+// Main execution
+async function main() {
+  const manager = new DataManager();
+  
+  try {
+    while (true) {
+      await manager.showMainMenu();
+    }
+  } catch (error) {
+    console.error('An error occurred:', error);
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = DataManager;
\ No newline at end of file

From e15ea8e3e63592c4607bcda1aacf3839a7005a95 Mon Sep 17 00:00:00 2001
From: Will Feldman <13539982+willfeldman@users.noreply.github.com>
Date: Fri, 8 Aug 2025 16:52:47 -0400
Subject: [PATCH 2/2] Enhance data manager with detailed browsing and editing

Adds advanced browsing, detailed entry viewing, and field-level editing for all data types. Introduces HTML formatting for rich text fields, external editor integration, and improved array and tag management. Updates the main menu UI and refactors editing workflows for a more user-friendly experience.
---
 scripts/data-manager.js | 794 ++++++++++++++++++++++++++++++++++------
 1 file changed, 679 insertions(+), 115 deletions(-)

diff --git a/scripts/data-manager.js b/scripts/data-manager.js
index 21ebca7..597471a 100755
--- a/scripts/data-manager.js
+++ b/scripts/data-manager.js
@@ -3,6 +3,8 @@
 const fs = require('fs');
 const path = require('path');
 const readline = require('readline');
+const { execSync } = require('child_process');
+const os = require('os');
 
 const rl = readline.createInterface({
   input: process.stdin,
@@ -75,15 +77,17 @@ class DataManager {
 
   async showMainMenu() {
     console.clear();
-    console.log('🚀 Portfolio Data Manager');
-    console.log('========================');
-    console.log('1. View Data');
-    console.log('2. Add New Entry');
-    console.log('3. Edit Entry');
-    console.log('4. Delete Entry');
-    console.log('5. Validate Data');
-    console.log('6. Export Data');
-    console.log('7. Exit');
+    console.log('🚀 Portfolio Data Manager v2.0');
+    console.log('===============================');
+    console.log('1. 📊 Browse & View Data (Enhanced)');
+    console.log('2. ➕ Add New Entry');
+    console.log('3. ✏️  Edit Entry');
+    console.log('4. 🗑️  Delete Entry');
+    console.log('5. 🔍 Validate Data');
+    console.log('6. 📤 Export Data');
+    console.log('7. 🚪 Exit');
+    console.log('');
+    console.log('💡 Enhanced features: Detailed viewing, HTML formatting, advanced editing');
     console.log('');
 
     const choice = await this.prompt('Select an option (1-7): ');
@@ -137,16 +141,16 @@ class DataManager {
     
     switch (choice.trim()) {
       case '1':
-        await this.displayData('experiences');
+        await this.browseData('experiences');
         break;
       case '2':
-        await this.displayData('projects');
+        await this.browseData('projects');
         break;
       case '3':
-        await this.displayData('organizations');
+        await this.browseData('organizations');
         break;
       case '4':
-        await this.displayData('awards');
+        await this.browseData('awards');
         break;
       case '5':
         await this.displaySummary();
@@ -165,49 +169,291 @@ class DataManager {
     await this.viewDataMenu();
   }
 
-  displayData(type) {
-    console.clear();
-    const data = this.currentData[type];
-    const title = type.charAt(0).toUpperCase() + type.slice(1);
+  async browseData(type) {
+    while (true) {
+      console.clear();
+      const data = this.currentData[type];
+      const title = type.charAt(0).toUpperCase() + type.slice(1);
+      
+      console.log(`📋 Browse ${title}`);
+      console.log('='.repeat(title.length + 9));
+      console.log(`Total entries: ${data.length}\n`);
+
+      if (data.length === 0) {
+        console.log('No entries found.');
+        return;
+      }
+
+      data.forEach((item, index) => {
+        console.log(`${index + 1}. ${this.getItemTitle(item, type)} (ID: ${item.id})`);
+      });
+      
+      console.log(`${data.length + 1}. Back to View Menu`);
+      console.log('');
+
+      const choice = await this.prompt(`Select entry to view in detail (1-${data.length + 1}): `);
+      const index = parseInt(choice) - 1;
+
+      if (index === data.length) {
+        return; // Back to view menu
+      }
+
+      if (index >= 0 && index < data.length) {
+        await this.displayDetailedEntry(type, index);
+      } else {
+        console.log('Invalid selection. Please try again.');
+        await this.pause();
+      }
+    }
+  }
+
+  async displayDetailedEntry(type, index) {
+    const entry = this.currentData[type][index];
+    const title = this.getItemTitle(entry, type);
     
-    console.log(`📋 ${title}`);
-    console.log('='.repeat(title.length + 3));
-    console.log(`Total entries: ${data.length}\n`);
+    console.clear();
+    console.log(`🔍 Detailed View: ${title}`);
+    console.log('='.repeat(50));
+    console.log('');
 
-    if (data.length === 0) {
-      console.log('No entries found.');
-      return;
+    await this.formatAndDisplayEntry(entry, type);
+
+    console.log('\n' + '='.repeat(50));
+    console.log('Options:');
+    console.log('1. Edit this entry');
+    console.log('2. Delete this entry');
+    console.log('3. Back to list');
+    console.log('');
+
+    const choice = await this.prompt('Select action (1-3): ');
+    
+    switch (choice.trim()) {
+      case '1':
+        await this.editEntry(type, index);
+        break;
+      case '2':
+        await this.confirmDeleteEntry(type, index);
+        break;
+      case '3':
+      default:
+        return;
     }
+  }
 
-    data.forEach((item, index) => {
-      console.log(`${index + 1}. ${this.getItemTitle(item, type)}`);
-      console.log(`   ID: ${item.id}`);
-      
-      if (type === 'experiences') {
-        console.log(`   Company: ${item.company}`);
-        console.log(`   Positions: ${item.positions.length}`);
-        if (item.fullDates) {
-          console.log(`   Duration: ${item.fullDates}`);
-        } else if (item.positions[0]) {
-          console.log(`   Duration: ${item.positions[0].dates}`);
+  async formatAndDisplayEntry(entry, type) {
+    // Display basic information
+    console.log(`📋 Basic Information`);
+    console.log(`ID: ${entry.id}`);
+    
+    if (type === 'experiences') {
+      console.log(`Company: ${entry.company}`);
+      console.log(`Location: ${entry.location}`);
+      if (entry.fullDates) {
+        console.log(`Full Duration: ${entry.fullDates}`);
+      }
+      if (entry.url) {
+        if (Array.isArray(entry.url)) {
+          console.log(`URLs: ${entry.url.join(', ')}`);
+        } else {
+          console.log(`URL: ${entry.url}`);
         }
-      } else if (type === 'projects') {
-        console.log(`   Description: ${item.description.substring(0, 80)}${item.description.length > 80 ? '...' : ''}`);
-        if (item.tags) {
-          console.log(`   Tags: ${item.tags.map(tag => tag.name).join(', ')}`);
+      }
+      if (entry.linkedin) {
+        console.log(`LinkedIn: ${entry.linkedin}`);
+      }
+      
+      console.log('\n📍 Positions:');
+      entry.positions.forEach((position, idx) => {
+        console.log(`\n  Position ${idx + 1}:`);
+        console.log(`    Title: ${position.title}`);
+        console.log(`    Type: ${position.type}`);
+        console.log(`    Dates: ${position.dates}`);
+        if (position.summary) {
+          console.log(`    Summary: ${position.summary}`);
         }
-      } else if (type === 'organizations') {
-        console.log(`   Duration: ${item.yearsActive}`);
-        if (item.role && item.role.length > 0) {
-          console.log(`   Latest Role: ${item.role[0].title}`);
+        if (position.description && position.description.length > 0) {
+          console.log(`    Description:`);
+          position.description.forEach(desc => {
+            console.log(`      • ${desc}`);
+          });
         }
-      } else if (type === 'awards') {
-        console.log(`   Issuer: ${item.issuer}`);
-        console.log(`   Date: ${item.date}`);
+      });
+      
+    } else if (type === 'projects') {
+      console.log(`Title: ${entry.title}`);
+      console.log(`Description: ${entry.description}`);
+      
+      if (entry.github) {
+        console.log(`GitHub: ${entry.github}`);
+      }
+      if (entry.url) {
+        console.log(`URL: ${entry.url}`);
+      }
+      if (entry.code) {
+        console.log(`Code: ${entry.code}`);
       }
       
-      console.log('');
-    });
+      if (entry.tags && entry.tags.length > 0) {
+        console.log('\n🏷️  Tags:');
+        entry.tags.forEach(tag => {
+          console.log(`    • ${tag.name} (${tag.color})`);
+        });
+      }
+      
+      if (entry.images && entry.images.length > 0) {
+        console.log('\n🖼️  Images:');
+        entry.images.forEach((image, idx) => {
+          console.log(`    ${idx + 1}. ${image}`);
+        });
+      }
+      
+    } else if (type === 'organizations') {
+      console.log(`Name: ${entry.name}`);
+      console.log(`Years Active: ${entry.yearsActive}`);
+      
+      if (entry.summary) {
+        console.log(`Summary: ${entry.summary}`);
+      }
+      
+      if (entry.role && entry.role.length > 0) {
+        console.log('\n👥 Roles:');
+        entry.role.forEach((role, idx) => {
+          console.log(`  ${idx + 1}. ${role.title} (${role.years})`);
+        });
+      }
+      
+      if (entry.description && entry.description.length > 0) {
+        console.log('\n📝 Description:');
+        entry.description.forEach(desc => {
+          console.log(`  • ${desc}`);
+        });
+      }
+      
+    } else if (type === 'awards') {
+      console.log(`Name: ${entry.name}`);
+      console.log(`Issuer: ${entry.issuer}`);
+      console.log(`Date: ${entry.date}`);
+    }
+    
+    // Display images info
+    if (entry.headerImage) {
+      console.log(`\n🖼️  Header Image: ${entry.headerImage}`);
+    }
+    if (entry.logo) {
+      console.log(`🏢 Logo: ${entry.logo}`);
+    }
+    
+    // Display additional information with HTML formatting
+    if (entry.additionalInformation) {
+      console.log('\n📄 Additional Information:');
+      console.log('-'.repeat(30));
+      await this.displayFormattedHTML(entry.additionalInformation);
+    }
+
+    // Display description for awards
+    if (type === 'awards' && entry.description) {
+      console.log('\n📄 Description:');
+      console.log('-'.repeat(30));
+      await this.displayFormattedHTML(entry.description);
+    }
+  }
+
+  async displayFormattedHTML(htmlContent) {
+    if (!htmlContent) {
+      console.log('(No content)');
+      return;
+    }
+
+    try {
+      // Convert HTML to readable text with basic formatting
+      let formatted = htmlContent
+        // Remove extra whitespace and normalize line breaks
+        .replace(/\s+/g, ' ')
+        .replace(/\n\s*/g, '\n')
+        // Convert common HTML tags to readable format
+        .replace(/<div[^>]*>/gi, '\n')
+        .replace(/<\/div>/gi, '\n')
+        .replace(/<p[^>]*>/gi, '\n')
+        .replace(/<\/p>/gi, '\n')
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<h[1-6][^>]*>/gi, '\n\n=== ')
+        .replace(/<\/h[1-6]>/gi, ' ===\n')
+        .replace(/<b[^>]*>/gi, '**')
+        .replace(/<\/b>/gi, '**')
+        .replace(/<strong[^>]*>/gi, '**')
+        .replace(/<\/strong>/gi, '**')
+        .replace(/<i[^>]*>/gi, '*')
+        .replace(/<\/i>/gi, '*')
+        .replace(/<em[^>]*>/gi, '*')
+        .replace(/<\/em>/gi, '*')
+        .replace(/<ul[^>]*>/gi, '\n')
+        .replace(/<\/ul>/gi, '\n')
+        .replace(/<ol[^>]*>/gi, '\n')
+        .replace(/<\/ol>/gi, '\n')
+        .replace(/<li[^>]*>/gi, '  • ')
+        .replace(/<\/li>/gi, '\n')
+        .replace(/<a[^>]*href=["']([^"']*)["'][^>]*>/gi, '[')
+        .replace(/<\/a>/gi, ']')
+        // Remove any remaining HTML tags
+        .replace(/<[^>]+>/g, '')
+        // Clean up extra whitespace
+        .replace(/\n\s*\n\s*\n/g, '\n\n')
+        .replace(/^\s+|\s+$/g, '')
+        .trim();
+
+      // Split into lines and format nicely
+      const lines = formatted.split('\n');
+      lines.forEach(line => {
+        if (line.trim()) {
+          // Wrap long lines
+          if (line.length > 80) {
+            const words = line.split(' ');
+            let currentLine = '';
+            for (const word of words) {
+              if (currentLine.length + word.length + 1 <= 80) {
+                currentLine += (currentLine ? ' ' : '') + word;
+              } else {
+                if (currentLine) {
+                  console.log(currentLine);
+                  currentLine = word;
+                } else {
+                  console.log(word);
+                }
+              }
+            }
+            if (currentLine) {
+              console.log(currentLine);
+            }
+          } else {
+            console.log(line);
+          }
+        } else {
+          console.log('');
+        }
+      });
+    } catch (error) {
+      console.log('Error formatting HTML content:');
+      console.log(htmlContent);
+    }
+  }
+
+  async confirmDeleteEntry(type, index) {
+    const entry = this.currentData[type][index];
+    const title = this.getItemTitle(entry, type);
+    
+    console.log(`\n⚠️  You are about to delete: ${title}`);
+    console.log('This action cannot be undone!');
+    
+    const confirm = await this.prompt('\nAre you sure? Type "DELETE" to confirm: ');
+    if (confirm === 'DELETE') {
+      this.currentData[type].splice(index, 1);
+      await this.saveData(type);
+      console.log('✅ Entry deleted successfully!');
+      await this.pause();
+    } else {
+      console.log('❌ Deletion cancelled.');
+      await this.pause();
+    }
   }
 
   displaySummary() {
@@ -411,6 +657,141 @@ class DataManager {
     return roles;
   }
 
+  async editTagsDetailed(tags) {
+    console.log('Current tags:');
+    if (tags.length === 0) {
+      console.log('  (No tags)');
+    } else {
+      tags.forEach((tag, idx) => {
+        console.log(`  ${idx + 1}. ${tag.name}`);
+      });
+    }
+    
+    const editChoice = await this.prompt('\n1. Replace all tags\n2. Keep current tags\nChoice: ');
+    
+    if (editChoice === '1') {
+      const tagsInput = await this.prompt('Enter tag names (comma-separated): ');
+      if (tagsInput.trim()) {
+        return await this.processTags(tagsInput);
+      }
+    }
+    
+    return tags;
+  }
+  
+  async editHTMLContent(content) {
+    console.log('Current HTML content:');
+    console.log('-'.repeat(40));
+    await this.displayFormattedHTML(content);
+    console.log('-'.repeat(40));
+    
+    const editChoice = await this.prompt('\n1. Edit in external editor\n2. Replace with new content\n3. Keep current\nChoice: ');
+    
+    if (editChoice === '1') {
+      return await this.editInExternalEditor(content, 'html');
+    } else if (editChoice === '2') {
+      console.log('\nEnter new HTML content (type "END" on a new line to finish):');
+      return await this.collectMultilineInput();
+    }
+    
+    return content;
+  }
+  
+  async editArrayField(array, fieldName) {
+    while (true) {
+      console.clear();
+      console.log(`✏️  Edit ${fieldName}`);
+      console.log('='.repeat(20));
+      
+      if (array.length === 0) {
+        console.log(`No ${fieldName} found.`);
+      } else {
+        array.forEach((item, idx) => {
+          const preview = typeof item === 'string' && item.length > 50 
+            ? item.substring(0, 50) + '...' 
+            : item;
+          console.log(`${idx + 1}. ${preview}`);
+        });
+      }
+      
+      console.log(`\n${array.length + 1}. Add new item`);
+      console.log(`${array.length + 2}. Done editing`);
+      if (array.length > 0) {
+        console.log(`${array.length + 3}. Remove an item`);
+      }
+      console.log('');
+      
+      const maxChoice = array.length > 0 ? array.length + 3 : array.length + 2;
+      const choice = await this.prompt(`Select option (1-${maxChoice}): `);
+      const choiceNum = parseInt(choice) - 1;
+      
+      if (choiceNum >= 0 && choiceNum < array.length) {
+        const newValue = await this.prompt(`Edit item ${choiceNum + 1} [${array[choiceNum]}]: `);
+        if (newValue.trim()) {
+          array[choiceNum] = newValue;
+        }
+      } else if (choiceNum === array.length) {
+        const newItem = await this.prompt('New item: ');
+        if (newItem.trim()) {
+          array.push(newItem.trim());
+        }
+      } else if (choiceNum === array.length + 1) {
+        break;
+      } else if (choiceNum === array.length + 2 && array.length > 0) {
+        const removeIdx = await this.prompt(`Remove item number (1-${array.length}): `);
+        const removeIndex = parseInt(removeIdx) - 1;
+        if (removeIndex >= 0 && removeIndex < array.length) {
+          array.splice(removeIndex, 1);
+        }
+      } else {
+        console.log('Invalid option.');
+        await this.pause();
+      }
+    }
+    
+    return array;
+  }
+  
+  async editSimpleField(currentValue, fieldName) {
+    console.log(`Current ${fieldName}: ${currentValue || '[not set]'}`);
+    const newValue = await this.prompt(`New ${fieldName}: `);
+    return newValue.trim() || currentValue;
+  }
+  
+  async editInExternalEditor(content, fileType = 'txt') {
+    const tempFile = path.join(os.tmpdir(), `portfolio-edit-${Date.now()}.${fileType}`);
+    
+    try {
+      fs.writeFileSync(tempFile, content || '');
+      
+      console.log(`\nOpening ${tempFile} in external editor...`);
+      console.log('Save and close the file when done editing.');
+      
+      const editor = process.env.EDITOR || 'nano';
+      execSync(`${editor} "${tempFile}"`, { stdio: 'inherit' });
+      
+      const editedContent = fs.readFileSync(tempFile, 'utf8');
+      fs.unlinkSync(tempFile);
+      
+      return editedContent;
+    } catch (error) {
+      console.log('Error with external editor:', error.message);
+      console.log('Falling back to manual input.');
+      return await this.collectMultilineInput();
+    }
+  }
+  
+  async collectMultilineInput() {
+    const lines = [];
+    let line;
+    
+    while ((line = await this.prompt('> ')) !== 'END') {
+      lines.push(line);
+    }
+    
+    return lines.join('\n');
+  }
+  
   async processTags(tagsInput) {
     // This would ideally integrate with the existing tag system from project.js
     // For now, we'll create basic tag objects
@@ -498,91 +879,274 @@ class DataManager {
   }
 
   async editEntry(type, index) {
-    console.clear();
     const entry = this.currentData[type][index];
-    const schema = SCHEMAS[type];
-    
-    console.log(`✏️  Editing: ${this.getItemTitle(entry, type)}`);
-    console.log('='.repeat(40));
-    console.log('Current values shown in [brackets]. Press Enter to keep current value.\n');
-
-    const allFields = [...schema.required, ...schema.optional];
+    const title = this.getItemTitle(entry, type);
     
-    for (const field of allFields) {
-      if (field === 'id') continue; // Skip ID editing
+    while (true) {
+      console.clear();
+      console.log(`✏️  Editing: ${title}`);
+      console.log('='.repeat(50));
+      console.log('Select field to edit:\n');
       
-      const currentValue = entry[field];
-      let displayValue = '';
+      const schema = SCHEMAS[type];
+      const allFields = [...schema.required, ...schema.optional].filter(f => f !== 'id');
       
-      if (Array.isArray(currentValue)) {
-        if (field === 'positions' || field === 'role') {
-          displayValue = `${currentValue.length} items`;
-        } else {
-          displayValue = currentValue.join(', ');
-        }
-      } else if (typeof currentValue === 'object' && currentValue !== null) {
-        displayValue = 'complex object';
+      allFields.forEach((field, idx) => {
+        const currentValue = entry[field];
+        let preview = this.getFieldPreview(currentValue, field, type);
+        console.log(`${idx + 1}. ${field}: ${preview}`);
+      });
+      
+      console.log(`${allFields.length + 1}. Preview entire entry`);
+      console.log(`${allFields.length + 2}. Save changes`);
+      console.log(`${allFields.length + 3}. Cancel and return`);
+      console.log('');
+      
+      const choice = await this.prompt(`Select option (1-${allFields.length + 3}): `);
+      const choiceNum = parseInt(choice) - 1;
+      
+      if (choiceNum >= 0 && choiceNum < allFields.length) {
+        const field = allFields[choiceNum];
+        await this.editField(entry, field, type);
+      } else if (choiceNum === allFields.length) {
+        await this.previewEntry(entry, type);
+      } else if (choiceNum === allFields.length + 1) {
+        // Save changes
+        await this.saveData(type);
+        console.log('✅ Changes saved successfully!');
+        await this.pause();
+        return;
+      } else if (choiceNum === allFields.length + 2) {
+        // Cancel
+        console.log('❌ Changes cancelled.');
+        this.loadAllData(); // Reload original data
+        await this.pause();
+        return;
+      } else {
+        console.log('Invalid option. Please try again.');
+        await this.pause();
+      }
+    }
+  }
+  
+  getFieldPreview(value, field, type) {
+    if (!value) return '[not set]';
+    
+    if (field === 'additionalInformation' || field === 'description') {
+      if (typeof value === 'string' && value.includes('<')) {
+        const textOnly = value.replace(/<[^>]+>/g, '').trim();
+        return `[HTML: ${textOnly.substring(0, 50)}${textOnly.length > 50 ? '...' : ''}]`;
+      }
+    }
+    
+    if (Array.isArray(value)) {
+      if (field === 'positions' || field === 'role') {
+        return `[${value.length} items]`;
+      } else if (field === 'tags') {
+        return `[${value.map(t => t.name || t).join(', ')}]`;
       } else {
-        displayValue = currentValue || 'not set';
+        return `[${value.join(', ')}]`;
       }
+    }
+    
+    if (typeof value === 'string' && value.length > 60) {
+      return `[${value.substring(0, 60)}...]`;
+    }
+    
+    return `[${value}]`;
+  }
+  
+  async previewEntry(entry, type) {
+    console.clear();
+    console.log('🔍 Entry Preview');
+    console.log('='.repeat(20));
+    await this.formatAndDisplayEntry(entry, type);
+    await this.pause();
+  }
+  
+  async editField(entry, field, type) {
+    console.clear();
+    console.log(`✏️  Editing Field: ${field}`);
+    console.log('='.repeat(30));
+    
+    const currentValue = entry[field];
+    
+    if (field === 'positions' && type === 'experiences') {
+      entry[field] = await this.editPositionsDetailed(currentValue || []);
+    } else if (field === 'role' && type === 'organizations') {
+      entry[field] = await this.editRolesDetailed(currentValue || []);
+    } else if (field === 'tags' && type === 'projects') {
+      entry[field] = await this.editTagsDetailed(currentValue || []);
+    } else if (field === 'additionalInformation' || (field === 'description' && typeof currentValue === 'string' && currentValue.includes('<'))) {
+      entry[field] = await this.editHTMLContent(currentValue || '');
+    } else if (Array.isArray(currentValue)) {
+      entry[field] = await this.editArrayField(currentValue || [], field);
+    } else {
+      entry[field] = await this.editSimpleField(currentValue, field);
+    }
+  }
 
-      console.log(`${field} [${displayValue}]:`);
+  async editPositionsDetailed(positions) {
+    while (true) {
+      console.clear();
+      console.log('✏️  Edit Positions');
+      console.log('='.repeat(20));
       
-      if (field === 'positions' && type === 'experiences') {
-        const editPositions = await this.prompt('Edit positions? (y/n): ');
-        if (editPositions.toLowerCase().startsWith('y')) {
-          entry[field] = await this.editPositions(currentValue || []);
-        }
-      } else if (field === 'role' && type === 'organizations') {
-        const editRoles = await this.prompt('Edit roles? (y/n): ');
-        if (editRoles.toLowerCase().startsWith('y')) {
-          entry[field] = await this.editRoles(currentValue || []);
-        }
-      } else if (field === 'tags' && type === 'projects') {
-        const editTags = await this.prompt('Edit tags? (y/n): ');
-        if (editTags.toLowerCase().startsWith('y')) {
-          const tagsInput = await this.prompt('Enter tag names (comma-separated): ');
-          if (tagsInput.trim()) {
-            entry[field] = await this.processTags(tagsInput);
-          }
-        }
+      if (positions.length === 0) {
+        console.log('No positions found.');
       } else {
-        const newValue = await this.prompt('> ');
-        if (newValue.trim()) {
-          if (Array.isArray(currentValue)) {
-            entry[field] = newValue.split(',').map(v => v.trim()).filter(v => v);
-          } else {
-            entry[field] = newValue;
-          }
+        positions.forEach((pos, idx) => {
+          console.log(`${idx + 1}. ${pos.title} (${pos.dates})`);
+        });
+      }
+      
+      console.log(`\n${positions.length + 1}. Add new position`);
+      console.log(`${positions.length + 2}. Done editing positions`);
+      console.log('');
+      
+      const choice = await this.prompt(`Select option (1-${positions.length + 2}): `);
+      const choiceNum = parseInt(choice) - 1;
+      
+      if (choiceNum >= 0 && choiceNum < positions.length) {
+        positions[choiceNum] = await this.editSinglePosition(positions[choiceNum]);
+      } else if (choiceNum === positions.length) {
+        const newPosition = await this.createNewPosition();
+        if (newPosition) {
+          positions.push(newPosition);
         }
+      } else if (choiceNum === positions.length + 1) {
+        break;
+      } else {
+        console.log('Invalid option.');
+        await this.pause();
       }
     }
-
-    console.log('\n📋 Updated Entry:');
-    console.log(JSON.stringify(entry, null, 2));
     
-    const confirm = await this.prompt('\nSave changes? (y/n): ');
-    if (confirm.toLowerCase().startsWith('y')) {
-      await this.saveData(type);
-      console.log('✅ Changes saved successfully!');
+    return positions;
+  }
+  
+  async editSinglePosition(position) {
+    console.clear();
+    console.log('✏️  Edit Position');
+    console.log('='.repeat(20));
+    
+    console.log('Current values shown in [brackets]. Press Enter to keep current value.\n');
+    
+    const newTitle = await this.prompt(`Title [${position.title}]: `);
+    if (newTitle.trim()) position.title = newTitle;
+    
+    const newDates = await this.prompt(`Dates [${position.dates}]: `);
+    if (newDates.trim()) position.dates = newDates;
+    
+    const newType = await this.prompt(`Type [${position.type}]: `);
+    if (newType.trim()) position.type = newType;
+    
+    const newSummary = await this.prompt(`Summary [${position.summary || 'not set'}]: `);
+    if (newSummary.trim()) {
+      position.summary = newSummary;
+    } else if (newSummary === '' && position.summary) {
+      delete position.summary;
+    }
+    
+    console.log('\nCurrent description:');
+    if (position.description && position.description.length > 0) {
+      position.description.forEach((desc, idx) => {
+        console.log(`  ${idx + 1}. ${desc}`);
+      });
     } else {
-      console.log('❌ Changes cancelled.');
-      this.loadAllData(); // Reload original data
+      console.log('  (No description items)');
     }
-
-    await this.pause();
-    await this.showMainMenu();
+    
+    const editDesc = await this.prompt('\nEdit description items? (y/n): ');
+    if (editDesc.toLowerCase().startsWith('y')) {
+      position.description = await this.editArrayField(position.description || [], 'description items');
+    }
+    
+    return position;
   }
-
-  async editPositions(positions) {
-    // Implementation for editing positions array
-    console.log('Position editing - simplified for now');
-    return positions;
+  
+  async createNewPosition() {
+    console.clear();
+    console.log('➕ Add New Position');
+    console.log('='.repeat(20));
+    
+    const position = {};
+    
+    position.title = await this.prompt('Title: ');
+    if (!position.title.trim()) {
+      console.log('Title is required.');
+      await this.pause();
+      return null;
+    }
+    
+    position.dates = await this.prompt('Dates: ');
+    if (!position.dates.trim()) {
+      console.log('Dates are required.');
+      await this.pause();
+      return null;
+    }
+    
+    position.type = await this.prompt('Type (Full-time/Part-time/Internship): ');
+    if (!position.type.trim()) {
+      console.log('Type is required.');
+      await this.pause();
+      return null;
+    }
+    
+    const summary = await this.prompt('Summary (optional): ');
+    if (summary.trim()) {
+      position.summary = summary;
+    }
+    
+    const addDesc = await this.prompt('Add description items? (y/n): ');
+    if (addDesc.toLowerCase().startsWith('y')) {
+      position.description = await this.editArrayField([], 'description items');
+    }
+    
+    return position;
   }
-
-  async editRoles(roles) {
-    // Implementation for editing roles array
-    console.log('Role editing - simplified for now');
+  
+  async editRolesDetailed(roles) {
+    while (true) {
+      console.clear();
+      console.log('✏️  Edit Roles');
+      console.log('='.repeat(15));
+      
+      if (roles.length === 0) {
+        console.log('No roles found.');
+      } else {
+        roles.forEach((role, idx) => {
+          console.log(`${idx + 1}. ${role.title} (${role.years})`);
+        });
+      }
+      
+      console.log(`\n${roles.length + 1}. Add new role`);
+      console.log(`${roles.length + 2}. Done editing roles`);
+      console.log('');
+      
+      const choice = await this.prompt(`Select option (1-${roles.length + 2}): `);
+      const choiceNum = parseInt(choice) - 1;
+      
+      if (choiceNum >= 0 && choiceNum < roles.length) {
+        const newTitle = await this.prompt(`Title [${roles[choiceNum].title}]: `);
+        if (newTitle.trim()) roles[choiceNum].title = newTitle;
+        
+        const newYears = await this.prompt(`Years [${roles[choiceNum].years}]: `);
+        if (newYears.trim()) roles[choiceNum].years = newYears;
+      } else if (choiceNum === roles.length) {
+        const title = await this.prompt('New role title: ');
+        const years = await this.prompt('Years: ');
+        if (title.trim() && years.trim()) {
+          roles.push({ title: title.trim(), years: years.trim() });
+        }
+      } else if (choiceNum === roles.length + 1) {
+        break;
+      } else {
+        console.log('Invalid option.');
+        await this.pause();
+      }
+    }
+    
     return roles;
   }