6cb51c270c
- Remove excessive completion checkmarks and status markers throughout document - Consolidate redundant sections on completed features - Streamline executive summary and current status sections - Focus content on upcoming quick wins and active tasks - Remove duplicate phase completion listings - Clean up success metrics and KPI sections - Maintain essential planning information while reducing noise
662 lines
22 KiB
Bash
Executable File
662 lines
22 KiB
Bash
Executable File
#!/bin/bash
|
|
#
|
|
# AITBC Comprehensive Planning Cleanup - Move ALL Completed Tasks
|
|
# Scans entire docs/10_plan subfolder structure, finds all completed tasks,
|
|
# and moves them to appropriate organized folders in docs/
|
|
#
|
|
|
|
set -e
|
|
|
|
# Colors for output
|
|
GREEN='\033[0;32m'
|
|
YELLOW='\033[1;33m'
|
|
BLUE='\033[0;34m'
|
|
RED='\033[0;31m'
|
|
NC='\033[0m'
|
|
|
|
print_status() {
|
|
echo -e "${GREEN}[INFO]${NC} $1"
|
|
}
|
|
|
|
print_warning() {
|
|
echo -e "${YELLOW}[WARN]${NC} $1"
|
|
}
|
|
|
|
print_header() {
|
|
echo -e "${BLUE}=== $1 ===${NC}"
|
|
}
|
|
|
|
# Configuration
|
|
PROJECT_ROOT="/opt/aitbc"
|
|
PLANNING_DIR="$PROJECT_ROOT/docs/10_plan"
|
|
DOCS_DIR="$PROJECT_ROOT/docs"
|
|
ARCHIVE_DIR="$PROJECT_ROOT/docs/archive"
|
|
WORKSPACE_DIR="$PROJECT_ROOT/workspace/planning-analysis"
|
|
BACKUP_DIR="$WORKSPACE_DIR/backup"
|
|
|
|
# Main execution
|
|
main() {
|
|
print_header "AITBC COMPREHENSIVE PLANNING CLEANUP - ALL SUBFOLDERS"
|
|
echo ""
|
|
echo "📋 Scanning entire docs/10_plan subfolder structure"
|
|
echo "📚 Moving ALL completed tasks to appropriate docs/ folders"
|
|
echo "📁 Organizing by category and completion status"
|
|
echo ""
|
|
|
|
# Step 1: Create organized destination folders
|
|
print_header "Step 1: Creating Organized Destination Folders"
|
|
create_organized_folders
|
|
|
|
# Step 2: Scan all subfolders for completed tasks
|
|
print_header "Step 2: Scanning All Subfolders for Completed Tasks"
|
|
scan_all_subfolders
|
|
|
|
# Step 3: Categorize and move completed content
|
|
print_header "Step 3: Categorizing and Moving Completed Content"
|
|
categorize_and_move_content
|
|
|
|
# Step 4: Create comprehensive archive
|
|
print_header "Step 4: Creating Comprehensive Archive"
|
|
create_comprehensive_archive
|
|
|
|
# Step 5: Clean up planning documents
|
|
print_header "Step 5: Cleaning Up Planning Documents"
|
|
cleanup_planning_documents
|
|
|
|
# Step 6: Generate final reports
|
|
print_header "Step 6: Generating Final Reports"
|
|
generate_final_reports
|
|
|
|
print_header "Comprehensive Planning Cleanup Complete! 🎉"
|
|
echo ""
|
|
echo "✅ All subfolders scanned and processed"
|
|
echo "✅ Completed content categorized and moved"
|
|
echo "✅ Comprehensive archive created"
|
|
echo "✅ Planning documents cleaned"
|
|
echo "✅ Final reports generated"
|
|
echo ""
|
|
echo "📊 docs/10_plan is now clean and focused"
|
|
echo "📚 docs/ has organized completed content"
|
|
echo "📁 Archive system fully operational"
|
|
echo "🎯 Ready for new milestone planning"
|
|
}
|
|
|
|
# Create organized destination folders
|
|
create_organized_folders() {
|
|
print_status "Creating organized destination folders in docs/"
|
|
|
|
# Create main categories
|
|
mkdir -p "$DOCS_DIR/completed/infrastructure"
|
|
mkdir -p "$DOCS_DIR/completed/cli"
|
|
mkdir -p "$DOCS_DIR/completed/backend"
|
|
mkdir -p "$DOCS_DIR/completed/security"
|
|
mkdir -p "$DOCS_DIR/completed/exchange"
|
|
mkdir -p "$DOCS_DIR/completed/blockchain"
|
|
mkdir -p "$DOCS_DIR/completed/analytics"
|
|
mkdir -p "$DOCS_DIR/completed/marketplace"
|
|
mkdir -p "$DOCS_DIR/completed/maintenance"
|
|
mkdir -p "$DOCS_DIR/completed/ai"
|
|
|
|
# Create archive structure
|
|
mkdir -p "$ARCHIVE_DIR/by_category/infrastructure"
|
|
mkdir -p "$ARCHIVE_DIR/by_category/cli"
|
|
mkdir -p "$ARCHIVE_DIR/by_category/backend"
|
|
mkdir -p "$ARCHIVE_DIR/by_category/security"
|
|
mkdir -p "$ARCHIVE_DIR/by_category/exchange"
|
|
mkdir -p "$ARCHIVE_DIR/by_category/blockchain"
|
|
mkdir -p "$ARCHIVE_DIR/by_category/analytics"
|
|
mkdir -p "$ARCHIVE_DIR/by_category/marketplace"
|
|
mkdir -p "$ARCHIVE_DIR/by_category/maintenance"
|
|
mkdir -p "$ARCHIVE_DIR/by_category/ai"
|
|
|
|
print_status "Organized folders created"
|
|
}
|
|
|
|
# Scan all subfolders for completed tasks
|
|
scan_all_subfolders() {
|
|
print_status "Scanning entire docs/10_plan subfolder structure..."
|
|
|
|
cat > "$WORKSPACE_DIR/scan_all_subfolders.py" << 'EOF'
|
|
#!/usr/bin/env python3
|
|
"""
|
|
Comprehensive Subfolder Scanner
|
|
Scans all subfolders in docs/10_plan for completed tasks
|
|
"""
|
|
|
|
import os
|
|
import re
|
|
import json
|
|
from pathlib import Path
|
|
from datetime import datetime
|
|
|
|
def categorize_file_content(file_path):
|
|
"""Categorize file based on content and path"""
|
|
path_parts = file_path.parts
|
|
filename = file_path.name.lower()
|
|
|
|
# Check path-based categorization
|
|
if '01_core_planning' in path_parts:
|
|
return 'core_planning'
|
|
elif '02_implementation' in path_parts:
|
|
return 'implementation'
|
|
elif '03_testing' in path_parts:
|
|
return 'testing'
|
|
elif '04_infrastructure' in path_parts:
|
|
return 'infrastructure'
|
|
elif '05_security' in path_parts:
|
|
return 'security'
|
|
elif '06_cli' in path_parts:
|
|
return 'cli'
|
|
elif '07_backend' in path_parts:
|
|
return 'backend'
|
|
elif '08_marketplace' in path_parts:
|
|
return 'marketplace'
|
|
elif '09_maintenance' in path_parts:
|
|
return 'maintenance'
|
|
elif '10_summaries' in path_parts:
|
|
return 'summaries'
|
|
|
|
# Check filename-based categorization
|
|
if any(word in filename for word in ['infrastructure', 'port', 'network', 'deployment']):
|
|
return 'infrastructure'
|
|
elif any(word in filename for word in ['cli', 'command', 'interface']):
|
|
return 'cli'
|
|
elif any(word in filename for word in ['api', 'backend', 'service']):
|
|
return 'backend'
|
|
elif any(word in filename for word in ['security', 'auth', 'firewall']):
|
|
return 'security'
|
|
elif any(word in filename for word in ['exchange', 'trading', 'market']):
|
|
return 'exchange'
|
|
elif any(word in filename for word in ['blockchain', 'wallet', 'transaction']):
|
|
return 'blockchain'
|
|
elif any(word in filename for word in ['analytics', 'monitoring', 'ai']):
|
|
return 'analytics'
|
|
elif any(word in filename for word in ['marketplace', 'pool', 'hub']):
|
|
return 'marketplace'
|
|
elif any(word in filename for word in ['maintenance', 'update', 'requirements']):
|
|
return 'maintenance'
|
|
|
|
return 'general'
|
|
|
|
def scan_file_for_completion(file_path):
|
|
"""Scan a file for completion indicators"""
|
|
try:
|
|
with open(file_path, 'r', encoding='utf-8') as f:
|
|
content = f.read()
|
|
|
|
# Check for completion indicators
|
|
completion_patterns = [
|
|
r'✅\s*\*\*COMPLETE\*\*',
|
|
r'✅\s*\*\*IMPLEMENTED\*\*',
|
|
r'✅\s*\*\*OPERATIONAL\*\*',
|
|
r'✅\s*\*\*DEPLOYED\*\*',
|
|
r'✅\s*\*\*WORKING\*\*',
|
|
r'✅\s*\*\*FUNCTIONAL\*\*',
|
|
r'✅\s*\*\*ACHIEVED\*\*',
|
|
r'✅\s*COMPLETE\s*',
|
|
r'✅\s*IMPLEMENTED\s*',
|
|
r'✅\s*OPERATIONAL\s*',
|
|
r'✅\s*DEPLOYED\s*',
|
|
r'✅\s*WORKING\s*',
|
|
r'✅\s*FUNCTIONAL\s*',
|
|
r'✅\s*ACHIEVED\s*',
|
|
r'✅\s*COMPLETE:',
|
|
r'✅\s*IMPLEMENTED:',
|
|
r'✅\s*OPERATIONAL:',
|
|
r'✅\s*DEPLOYED:',
|
|
r'✅\s*WORKING:',
|
|
r'✅\s*FUNCTIONAL:',
|
|
r'✅\s*ACHIEVED:',
|
|
r'✅\s*\*\*COMPLETE\*\*:',
|
|
r'✅\s*\*\*IMPLEMENTED\*\*:',
|
|
r'✅\s*\*\*OPERATIONAL\*\*:',
|
|
r'✅\s*\*\*DEPLOYED\*\*:',
|
|
r'✅\s*\*\*WORKING\*\*:',
|
|
r'✅\s*\*\*FUNCTIONAL\*\*:',
|
|
r'✅\s*\*\*ACHIEVED\*\*:'
|
|
]
|
|
|
|
has_completion = any(re.search(pattern, content, re.IGNORECASE) for pattern in completion_patterns)
|
|
|
|
if has_completion:
|
|
# Count completion markers
|
|
completion_count = sum(len(re.findall(pattern, content, re.IGNORECASE)) for pattern in completion_patterns)
|
|
|
|
return {
|
|
'file_path': str(file_path),
|
|
'relative_path': str(file_path.relative_to(Path('/opt/aitbc/docs/10_plan'))),
|
|
'category': categorize_file_content(file_path),
|
|
'has_completion': True,
|
|
'completion_count': completion_count,
|
|
'file_size': file_path.stat().st_size,
|
|
'last_modified': datetime.fromtimestamp(file_path.stat().st_mtime).isoformat()
|
|
}
|
|
|
|
return {
|
|
'file_path': str(file_path),
|
|
'relative_path': str(file_path.relative_to(Path('/opt/aitbc/docs/10_plan'))),
|
|
'category': categorize_file_content(file_path),
|
|
'has_completion': False,
|
|
'completion_count': 0,
|
|
'file_size': file_path.stat().st_size,
|
|
'last_modified': datetime.fromtimestamp(file_path.stat().st_mtime).isoformat()
|
|
}
|
|
|
|
except Exception as e:
|
|
return {
|
|
'file_path': str(file_path),
|
|
'relative_path': str(file_path.relative_to(Path('/opt/aitbc/docs/10_plan'))),
|
|
'category': 'error',
|
|
'has_completion': False,
|
|
'completion_count': 0,
|
|
'error': str(e)
|
|
}
|
|
|
|
def scan_all_subfolders(planning_dir):
|
|
"""Scan all subfolders for completed tasks"""
|
|
planning_path = Path(planning_dir)
|
|
results = []
|
|
|
|
# Find all markdown files in all subdirectories
|
|
for md_file in planning_path.rglob('*.md'):
|
|
if md_file.is_file():
|
|
result = scan_file_for_completion(md_file)
|
|
results.append(result)
|
|
|
|
# Categorize results
|
|
completed_files = [r for r in results if r.get('has_completion', False)]
|
|
category_summary = {}
|
|
|
|
for result in completed_files:
|
|
category = result['category']
|
|
if category not in category_summary:
|
|
category_summary[category] = {
|
|
'files': [],
|
|
'total_completion_count': 0,
|
|
'total_files': 0
|
|
}
|
|
|
|
category_summary[category]['files'].append(result)
|
|
category_summary[category]['total_completion_count'] += result['completion_count']
|
|
category_summary[category]['total_files'] += 1
|
|
|
|
return {
|
|
'total_files_scanned': len(results),
|
|
'files_with_completion': len(completed_files),
|
|
'files_without_completion': len(results) - len(completed_files),
|
|
'total_completion_markers': sum(r.get('completion_count', 0) for r in completed_files),
|
|
'category_summary': category_summary,
|
|
'all_results': results
|
|
}
|
|
|
|
if __name__ == "__main__":
|
|
planning_dir = '/opt/aitbc/docs/10_plan'
|
|
output_file = 'comprehensive_scan_results.json'
|
|
|
|
scan_results = scan_all_subfolders(planning_dir)
|
|
|
|
# Save results
|
|
with open(output_file, 'w') as f:
|
|
json.dump(scan_results, f, indent=2)
|
|
|
|
# Print summary
|
|
print(f"Comprehensive scan complete:")
|
|
print(f" Total files scanned: {scan_results['total_files_scanned']}")
|
|
print(f" Files with completion: {scan_results['files_with_completion']}")
|
|
print(f" Files without completion: {scan_results['files_without_completion']}")
|
|
print(f" Total completion markers: {scan_results['total_completion_markers']}")
|
|
print("")
|
|
print("Files with completion by category:")
|
|
for category, summary in scan_results['category_summary'].items():
|
|
print(f" {category}: {summary['total_files']} files, {summary['total_completion_count']} markers")
|
|
EOF
|
|
|
|
python3 "$WORKSPACE_DIR/scan_all_subfolders.py"
|
|
|
|
print_status "All subfolders scanned"
|
|
}
|
|
|
|
# Categorize and move completed content
|
|
categorize_and_move_content() {
|
|
print_status "Categorizing and moving completed content..."
|
|
|
|
cat > "$WORKSPACE_DIR/categorize_and_move.py" << 'EOF'
|
|
#!/usr/bin/env python3
|
|
"""
|
|
Content Categorizer and Mover
|
|
Categorizes completed content and moves to appropriate folders
|
|
"""
|
|
|
|
import json
|
|
import shutil
|
|
from pathlib import Path
|
|
from datetime import datetime
|
|
|
|
def move_completed_content(scan_file, docs_dir, archive_dir):
|
|
"""Move completed content to organized folders"""
|
|
|
|
with open(scan_file, 'r') as f:
|
|
scan_results = json.load(f)
|
|
|
|
category_mapping = {
|
|
'core_planning': 'core_planning',
|
|
'implementation': 'implementation',
|
|
'testing': 'testing',
|
|
'infrastructure': 'infrastructure',
|
|
'security': 'security',
|
|
'cli': 'cli',
|
|
'backend': 'backend',
|
|
'exchange': 'exchange',
|
|
'blockchain': 'blockchain',
|
|
'analytics': 'analytics',
|
|
'marketplace': 'marketplace',
|
|
'maintenance': 'maintenance',
|
|
'summaries': 'summaries',
|
|
'general': 'general'
|
|
}
|
|
|
|
moved_files = []
|
|
category_summary = {}
|
|
|
|
for result in scan_results['all_results']:
|
|
if not result.get('has_completion', False):
|
|
continue
|
|
|
|
source_path = Path(result['file_path'])
|
|
category = category_mapping.get(result['category'], 'general')
|
|
|
|
# Create destination paths
|
|
completed_dir = Path(docs_dir) / 'completed' / category
|
|
archive_dir = Path(archive_dir) / 'by_category' / category
|
|
|
|
# Ensure directories exist
|
|
completed_dir.mkdir(parents=True, exist_ok=True)
|
|
archive_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Destination file paths
|
|
completed_dest = completed_dir / source_path.name
|
|
archive_dest = archive_dir / source_path.name
|
|
|
|
try:
|
|
# Move to completed folder (remove from planning)
|
|
shutil.move(source_path, completed_dest)
|
|
|
|
# Create archive entry
|
|
archive_content = f"""# Archived: {source_path.name}
|
|
|
|
**Source**: {result['relative_path']}
|
|
**Category**: {category}
|
|
**Archive Date**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
|
|
**Completion Markers**: {result['completion_count']}
|
|
**File Size**: {result['file_size']} bytes
|
|
|
|
## Archive Reason
|
|
This file contains completed tasks and has been moved to the completed documentation folder.
|
|
|
|
## Original Content
|
|
The original file content has been preserved in the completed folder and can be referenced there.
|
|
|
|
---
|
|
*Archived by AITBC Comprehensive Planning Cleanup*
|
|
"""
|
|
|
|
with open(archive_dest, 'w') as f:
|
|
f.write(archive_content)
|
|
|
|
moved_files.append({
|
|
'source': str(source_path),
|
|
'completed_dest': str(completed_dest),
|
|
'archive_dest': str(archive_dest),
|
|
'category': category,
|
|
'completion_count': result['completion_count']
|
|
})
|
|
|
|
if category not in category_summary:
|
|
category_summary[category] = {
|
|
'files_moved': 0,
|
|
'total_completion_markers': 0
|
|
}
|
|
|
|
category_summary[category]['files_moved'] += 1
|
|
category_summary[category]['total_completion_markers'] += result['completion_count']
|
|
|
|
print(f"Moved {source_path.name} to completed/{category}/")
|
|
|
|
except Exception as e:
|
|
print(f"Error moving {source_path}: {e}")
|
|
|
|
return moved_files, category_summary
|
|
|
|
if __name__ == "__main__":
|
|
scan_file = 'comprehensive_scan_results.json'
|
|
docs_dir = '/opt/aitbc/docs'
|
|
archive_dir = '/opt/aitbc/docs/archive'
|
|
|
|
moved_files, category_summary = move_completed_content(scan_file, docs_dir, archive_dir)
|
|
|
|
# Save results
|
|
with open('content_move_results.json', 'w') as f:
|
|
json.dump({
|
|
'moved_files': moved_files,
|
|
'category_summary': category_summary,
|
|
'total_files_moved': len(moved_files)
|
|
}, f, indent=2)
|
|
|
|
print(f"Content move complete:")
|
|
print(f" Total files moved: {len(moved_files)}")
|
|
print("")
|
|
print("Files moved by category:")
|
|
for category, summary in category_summary.items():
|
|
print(f" {category}: {summary['files_moved']} files, {summary['total_completion_markers']} markers")
|
|
EOF
|
|
|
|
python3 "$WORKSPACE_DIR/categorize_and_move.py"
|
|
|
|
print_status "Completed content categorized and moved"
|
|
}
|
|
|
|
# Create comprehensive archive
|
|
create_comprehensive_archive() {
|
|
print_status "Creating comprehensive archive..."
|
|
|
|
cat > "$WORKSPACE_DIR/create_comprehensive_archive.py" << 'EOF'
|
|
#!/usr/bin/env python3
|
|
"""
|
|
Comprehensive Archive Creator
|
|
Creates a comprehensive archive of all completed work
|
|
"""
|
|
|
|
import json
|
|
from pathlib import Path
|
|
from datetime import datetime
|
|
|
|
def create_comprehensive_archive(scan_file, archive_dir):
|
|
"""Create comprehensive archive of all completed work"""
|
|
|
|
with open(scan_file, 'r') as f:
|
|
scan_results = json.load(f)
|
|
|
|
archive_path = Path(archive_dir)
|
|
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
|
|
|
|
# Create main archive file
|
|
main_archive = archive_path / f"comprehensive_archive_{timestamp}.md"
|
|
|
|
archive_content = f"""# AITBC Comprehensive Planning Archive
|
|
|
|
**Archive Created**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
|
|
**Archive ID**: {timestamp}
|
|
**Total Files Processed**: {scan_results['total_files_scanned']}
|
|
**Files with Completion**: {scan_results['files_with_completion']}
|
|
**Total Completion Markers**: {scan_results['total_completion_markers']}
|
|
|
|
## Archive Summary
|
|
|
|
### Files with Completion Markers
|
|
"""
|
|
|
|
for category, summary in scan_results['category_summary'].items():
|
|
archive_content += f"""
|
|
#### {category.title()}
|
|
- **Files**: {summary['total_files']}
|
|
- **Completion Markers**: {summary['total_completion_count']}
|
|
"""
|
|
|
|
archive_content += """
|
|
|
|
### Files Moved to Completed Documentation
|
|
"""
|
|
|
|
for category, summary in scan_results['category_summary'].items():
|
|
archive_content += f"""
|
|
#### {category.title()} Documentation
|
|
- **Location**: docs/completed/{category}/
|
|
- **Files**: {summary['total_files']}
|
|
"""
|
|
|
|
archive_content += """
|
|
|
|
## Archive Structure
|
|
|
|
### Completed Documentation
|
|
```
|
|
docs/completed/
|
|
├── infrastructure/ - Infrastructure completed tasks
|
|
├── cli/ - CLI completed tasks
|
|
├── backend/ - Backend completed tasks
|
|
├── security/ - Security completed tasks
|
|
├── exchange/ - Exchange completed tasks
|
|
├── blockchain/ - Blockchain completed tasks
|
|
├── analytics/ - Analytics completed tasks
|
|
├── marketplace/ - Marketplace completed tasks
|
|
├── maintenance/ - Maintenance completed tasks
|
|
└── general/ - General completed tasks
|
|
```
|
|
|
|
### Archive by Category
|
|
```
|
|
docs/archive/by_category/
|
|
├── infrastructure/ - Infrastructure archive files
|
|
├── cli/ - CLI archive files
|
|
├── backend/ - Backend archive files
|
|
├── security/ - Security archive files
|
|
├── exchange/ - Exchange archive files
|
|
├── blockchain/ - Blockchain archive files
|
|
├── analytics/ - Analytics archive files
|
|
├── marketplace/ - Marketplace archive files
|
|
├── maintenance/ - Maintenance archive files
|
|
└── general/ - General archive files
|
|
```
|
|
|
|
## Next Steps
|
|
|
|
1. **New Milestone Planning**: docs/10_plan is now clean and ready for new content
|
|
2. **Reference Completed Work**: Use docs/completed/ for reference
|
|
3. **Archive Access**: Use docs/archive/ for historical information
|
|
4. **Template Usage**: Use completed documentation as templates
|
|
|
|
---
|
|
*Generated by AITBC Comprehensive Planning Cleanup*
|
|
"""
|
|
|
|
with open(main_archive, 'w') as f:
|
|
f.write(archive_content)
|
|
|
|
return str(main_archive)
|
|
|
|
if __name__ == "__main__":
|
|
scan_file = 'comprehensive_scan_results.json'
|
|
archive_dir = '/opt/aitbc/docs/archive'
|
|
|
|
archive_file = create_comprehensive_archive(scan_file, archive_dir)
|
|
|
|
print(f"Comprehensive archive created: {archive_file}")
|
|
EOF
|
|
|
|
python3 "$WORKSPACE_DIR/create_comprehensive_archive.py"
|
|
|
|
print_status "Comprehensive archive created"
|
|
}
|
|
|
|
# Clean up planning documents
|
|
cleanup_planning_documents() {
|
|
print_status "Cleaning up planning documents..."
|
|
|
|
# Remove all completion markers from all files
|
|
find "$PLANNING_DIR" -name "*.md" -exec sed -i '/✅/d' {} \;
|
|
|
|
print_status "Planning documents cleaned"
|
|
}
|
|
|
|
# Generate final reports
|
|
generate_final_reports() {
|
|
print_status "Generating final reports..."
|
|
|
|
cat > "$WORKSPACE_DIR/generate_final_report.py" << 'EOF'
|
|
#!/usr/bin/env python3
|
|
"""
|
|
Final Report Generator
|
|
Generates comprehensive final report
|
|
"""
|
|
|
|
import json
|
|
from datetime import datetime
|
|
|
|
def generate_final_report():
|
|
"""Generate comprehensive final report"""
|
|
|
|
# Load all data files
|
|
with open('comprehensive_scan_results.json', 'r') as f:
|
|
scan_results = json.load(f)
|
|
|
|
with open('content_move_results.json', 'r') as f:
|
|
move_results = json.load(f)
|
|
|
|
# Generate report
|
|
report = {
|
|
'timestamp': datetime.now().isoformat(),
|
|
'operation': 'comprehensive_planning_cleanup',
|
|
'status': 'completed',
|
|
'summary': {
|
|
'total_files_scanned': scan_results['total_files_scanned'],
|
|
'files_with_completion': scan_results['files_with_completion'],
|
|
'files_without_completion': scan_results['files_without_completion'],
|
|
'total_completion_markers': scan_results['total_completion_markers'],
|
|
'files_moved': move_results['total_files_moved'],
|
|
'categories_processed': len(move_results['category_summary'])
|
|
},
|
|
'scan_results': scan_results,
|
|
'move_results': move_results
|
|
}
|
|
|
|
# Save report
|
|
with open('comprehensive_final_report.json', 'w') as f:
|
|
json.dump(report, f, indent=2)
|
|
|
|
# Print summary
|
|
summary = report['summary']
|
|
print(f"Final Report Generated:")
|
|
print(f" Operation: {report['operation']}")
|
|
print(f" Status: {report['status']}")
|
|
print(f" Total files scanned: {summary['total_files_scanned']}")
|
|
print(f" Files with completion: {summary['files_with_completion']}")
|
|
print(f" Files moved: {summary['files_moved']}")
|
|
print(f" Total completion markers: {summary['total_completion_markers']}")
|
|
print(f" Categories processed: {summary['categories_processed']}")
|
|
print("")
|
|
print("Files moved by category:")
|
|
for category, summary in move_results['category_summary'].items():
|
|
print(f" {category}: {summary['files_moved']} files")
|
|
|
|
if __name__ == "__main__":
|
|
generate_final_report()
|
|
EOF
|
|
|
|
python3 "$WORKSPACE_DIR/generate_final_report.py"
|
|
|
|
print_status "Final reports generated"
|
|
}
|
|
|
|
# Run main function
|
|
main "$@"
|