appydave-tools 0.16.0 → 0.17.0

data/bin/archive_project.rb

@@ -0,0 +1,249 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+# rubocop:disable all
+
+# Archive a completed video project to SSD
+# 1. Copies entire project to SSD grouped folder (if not already there)
+# 2. Deletes entire local project folder
+# 3. Run 'ruby sync_from_ssd.rb' afterward to pull back light files to archived/
+#
+# Usage:
+#   ruby archive_project.rb PROJECT_ID [--dry-run]
+#
+# Example:
+#   ruby archive_project.rb b63-flivideo --dry-run   # Preview
+#   ruby archive_project.rb b63-flivideo             # Execute
+#   ruby sync_from_ssd.rb                            # Pull back light files
+#   ruby generate_manifest.rb                        # Update dashboard
+#
+# Options:
+#   --dry-run      : Show what would happen without making changes
+
+require 'fileutils'
+
+# Load configuration
+SCRIPT_DIR = File.dirname(__FILE__)
+TOOLS_DIR = File.expand_path(File.join(SCRIPT_DIR, '..'))
+require_relative '../lib/config_loader'
+
+# Determine paths relative to current working directory (repo root)
+LOCAL_BASE = Dir.pwd
+LOCAL_ARCHIVED = File.join(LOCAL_BASE, 'archived')
+
+# Load SSD_BASE from config
+begin
+  config = ConfigLoader.load_from_repo(LOCAL_BASE)
+  SSD_BASE = config['SSD_BASE']
+rescue ConfigLoader::ConfigNotFoundError, ConfigLoader::InvalidConfigError => e
+  puts e.message
+  exit 1
+end
+
+def dry_run?
+  ARGV.include?('--dry-run')
+end
+
+def get_range(project_id)
+  # Extract letter and number from project ID
+  if project_id =~ /^([a-z])(\d+)/i
+    letter = Regexp.last_match(1).downcase
+    num = Regexp.last_match(2).to_i
+    range_suffix = num < 50 ? "00-#{letter}49" : "50-#{letter}99"
+    return "#{letter}#{range_suffix}"
+  elsif project_id =~ /^(\d+)/
+    # Legacy numerical projects
+    num = Regexp.last_match(1).to_i
+    return '-01-25' if num <= 25
+  end
+
+  nil
+end
+
+def format_bytes(bytes)
+  if bytes < 1024
+    "#{bytes}B"
+  elsif bytes < 1024 * 1024
+    "#{(bytes / 1024.0).round(1)}KB"
+  elsif bytes < 1024 * 1024 * 1024
+    "#{(bytes / 1024.0 / 1024.0).round(1)}MB"
+  else
+    "#{(bytes / 1024.0 / 1024.0 / 1024.0).round(1)}GB"
+  end
+end
+
+def get_dir_size(dir)
+  total = 0
+  Dir.glob(File.join(dir, '**', '*'), File::FNM_DOTMATCH).each do |file|
+    total += File.size(file) if File.file?(file)
+  end
+  total
+end
+
+def copy_to_ssd(_project_id, local_path, ssd_path)
+  puts "\n📦 Step 1: Copy to SSD"
+
+  if Dir.exist?(ssd_path)
+    puts "   ⚠️  Already exists on SSD: #{ssd_path}"
+    puts '   Skipping copy step'
+    return true
+  end
+
+  size = get_dir_size(local_path)
+  puts "   Source: #{local_path}"
+  puts "   Dest:   #{ssd_path}"
+  puts "   Size:   #{format_bytes(size)}"
+
+  if dry_run?
+    puts '   [DRY-RUN] Would copy entire project to SSD'
+  else
+    FileUtils.mkdir_p(File.dirname(ssd_path))
+    FileUtils.cp_r(local_path, ssd_path, preserve: true)
+    puts '   ✅ Copied to SSD'
+  end
+  true
+end
+
+def delete_local_project(local_path)
+  puts "\n🗑️  Step 2: Delete local project"
+
+  size = get_dir_size(local_path)
+  puts "   Path: #{local_path}"
+  puts "   Size: #{format_bytes(size)}"
+
+  if dry_run?
+    puts '   [DRY-RUN] Would delete entire local folder'
+  else
+    FileUtils.rm_rf(local_path)
+    puts '   ✅ Deleted local folder'
+    puts "   💾 Freed: #{format_bytes(size)}"
+  end
+end
+
+# Parse --next flag
+def next_count
+  next_idx = ARGV.index('--next')
+  return nil unless next_idx
+
+  count = ARGV[next_idx + 1]
+  count ? count.to_i : 1
+end
+
+def find_oldest_flat_projects(count)
+  # Get all flat project folders
+  flat_projects = Dir.glob(File.join(LOCAL_BASE, '*/')).map { |path| File.basename(path) }
+
+  # Filter to valid project IDs and sort by prefix
+  valid_projects = flat_projects.grep(/^[a-z]\d{2}-/).sort_by do |id|
+    match = id.match(/^([a-z])(\d{2})/)
+    letter = match[1]
+    num = match[2].to_i
+    [letter, num]
+  end
+
+  valid_projects.take(count)
+end
+
+# Main execution
+count = next_count
+project_id = ARGV.find { |arg| !arg.start_with?('--') && arg != count.to_s }
+
+if count
+  # Archive multiple projects
+  projects_to_archive = find_oldest_flat_projects(count)
+
+  if projects_to_archive.empty?
+    puts '❌ No flat projects found to archive'
+    exit 1
+  end
+
+  puts dry_run? ? "🔍 DRY-RUN: Would archive #{projects_to_archive.size} oldest projects" : "🎬 Archiving #{projects_to_archive.size} oldest projects"
+  puts '=' * 60
+  puts 'Projects to archive:'
+  projects_to_archive.each { |p| puts "  - #{p}" }
+  puts '=' * 60
+  puts
+
+  # Process each project
+  projects_to_archive.each_with_index do |proj_id, idx|
+    puts "\n[#{idx + 1}/#{projects_to_archive.size}] Processing: #{proj_id}"
+    puts '-' * 60
+
+    local_path = File.join(LOCAL_BASE, proj_id)
+    range = get_range(proj_id)
+    ssd_path = File.join(SSD_BASE, range, proj_id)
+
+    success = copy_to_ssd(proj_id, local_path, ssd_path)
+    delete_local_project(local_path) if success
+  end
+
+  puts "\n#{'=' * 60}"
+  if dry_run?
+    puts "✅ Dry-run complete! Would have archived #{projects_to_archive.size} projects"
+    puts '   Run without --dry-run to actually archive'
+  else
+    puts "✅ Archived #{projects_to_archive.size} projects!"
+    puts
+    puts 'Next steps:'
+    puts '  1. ruby video-asset-tools/bin/sync_from_ssd.rb       # Pull back light files to archived/'
+    puts '  2. ruby video-asset-tools/bin/generate_manifest.rb   # Update dashboard'
+  end
+  exit 0
+end
+
+unless project_id
+  puts 'Usage: ruby archive_project.rb PROJECT_ID [--dry-run]'
+  puts '       ruby archive_project.rb --next N [--dry-run]'
+  puts
+  puts 'Examples:'
+  puts '  ruby archive_project.rb b63-flivideo --dry-run  # Archive specific project'
+  puts '  ruby archive_project.rb --next 5 --dry-run      # Archive 5 oldest projects'
+  puts
+  puts 'After archiving, run:'
+  puts '  ruby video-asset-tools/bin/sync_from_ssd.rb          # Pull back light files'
+  puts '  ruby video-asset-tools/bin/generate_manifest.rb      # Update dashboard'
+  exit 1
+end
+
+# Check SSD first
+unless Dir.exist?(SSD_BASE)
+  puts "❌ SSD not mounted at #{SSD_BASE}"
+  puts '   Please connect the SSD before archiving.'
+  exit 1
+end
+
+puts dry_run? ? "🔍 DRY-RUN: Archiving #{project_id}" : "🎬 Archiving: #{project_id}"
+puts '=' * 60
+
+# Find local project (must be in flat structure for archiving)
+local_path = File.join(LOCAL_BASE, project_id)
+
+unless Dir.exist?(local_path)
+  puts "\n❌ Project not found in flat structure: #{local_path}"
+  puts '   This tool archives active (flat) projects only.'
+  exit 1
+end
+
+range = get_range(project_id)
+unless range
+  puts "\n❌ Cannot determine range for project: #{project_id}"
+  puts '   Expected format: letter + 2 digits (e.g., b63-project)'
+  exit 1
+end
+
+ssd_path = File.join(SSD_BASE, range, project_id)
+
+# Execute steps
+success = copy_to_ssd(project_id, local_path, ssd_path)
+delete_local_project(local_path) if success
+
+puts "\n#{'=' * 60}"
+if dry_run?
+  puts '✅ Dry-run complete!'
+  puts '   Run without --dry-run to actually archive'
+else
+  puts '✅ Archive complete!'
+  puts
+  puts 'Next steps:'
+  puts '  1. ruby video-asset-tools/bin/sync_from_ssd.rb       # Pull back light files to archived/'
+  puts '  2. ruby video-asset-tools/bin/generate_manifest.rb   # Update dashboard'
+end

data/bin/configuration.rb

@@ -52,7 +52,27 @@ when :list
   tp configurations, :name, :exists, { path: { width: 150 } }
 when :create
   Appydave::Tools::Configuration::Config.configure
-  Appydave::Tools::Configuration::Config.save
+
+  # Only save configs that don't exist yet
+  created = []
+  skipped = []
+
+  Appydave::Tools::Configuration::Config.configurations.each do |name, config|
+    if File.exist?(config.config_path)
+      skipped << name
+    else
+      config.save
+      created << name
+    end
+  end
+
+  puts "\n✅ Created configurations:"
+  created.each { |name| puts "  - #{name}" }
+
+  if skipped.any?
+    puts "\n⚠️  Skipped (already exist):"
+    skipped.each { |name| puts "  - #{name}" }
+  end
 when :print
   Appydave::Tools::Configuration::Config.configure
   Appydave::Tools::Configuration::Config.print(*options[:keys])

data/bin/generate_manifest.rb

@@ -0,0 +1,357 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+# rubocop:disable all
+
+# Generate projects.json manifest by scanning local and SSD directories
+# Tracks video projects across storage locations with grouped folder support
+#
+# Usage: ruby generate_manifest.rb
+
+require 'json'
+require 'fileutils'
+
+# Load configuration
+SCRIPT_DIR = File.dirname(__FILE__)
+TOOLS_DIR = File.expand_path(File.join(SCRIPT_DIR, '..'))
+require_relative '../lib/config_loader'
+
+# Determine paths relative to current working directory (repo root)
+LOCAL_BASE = Dir.pwd
+LOCAL_ARCHIVED = File.join(LOCAL_BASE, 'archived')
+OUTPUT_FILE = File.join(LOCAL_BASE, 'projects.json')
+
+# Load SSD_BASE from config
+begin
+  config = ConfigLoader.load_from_repo(LOCAL_BASE)
+  SSD_BASE = config['SSD_BASE']
+rescue ConfigLoader::ConfigNotFoundError, ConfigLoader::InvalidConfigError => e
+  puts e.message
+  exit 1
+end
+
+def heavy_files?(dir)
+  return false unless Dir.exist?(dir)
+
+  Dir.glob(File.join(dir, '*.{mp4,mov,avi,mkv,webm}')).any?
+end
+
+def light_files?(dir)
+  return false unless Dir.exist?(dir)
+
+  Dir.glob(File.join(dir, '**/*.{srt,vtt,jpg,png,md,txt,json,yml}')).any?
+end
+
+def build_ssd_range_map
+  return @ssd_range_map if @ssd_range_map
+
+  @ssd_range_map = {}
+  Dir.glob(File.join(SSD_BASE, '*/')).each do |range_path|
+    range_name = File.basename(range_path)
+    Dir.glob(File.join(range_path, '*/')).each do |project_path|
+      proj_id = File.basename(project_path)
+      @ssd_range_map[proj_id] = range_name
+    end
+  end
+
+  @ssd_range_map
+end
+
+def get_range_for_project(project_id)
+  build_ssd_range_map[project_id]
+end
+
+# Validation functions
+def validate_project_id_format(project_id)
+  # Valid formats:
+  # - Modern: letter + 2 digits + dash + name (e.g., a00-project, b63-flivideo)
+  # - Legacy: just numbers (e.g., 006-ac-carnivore-90, 010-bing-gpt)
+  !!(project_id =~ /^[a-z]\d{2}-/ || project_id =~ /^\d/)
+end
+
+def extract_prefix(project_id)
+  # Extract the prefix (e.g., "b63" from "b63-flivideo")
+  match = project_id.match(/^([a-z]\d{2})/)
+  match ? match[1] : nil
+end
+
+def compare_prefixes(prefix1, prefix2)
+  # Compare two prefixes (e.g., "a12" vs "b40")
+  # Returns: -1 if prefix1 < prefix2, 0 if equal, 1 if prefix1 > prefix2
+  return 0 if prefix1 == prefix2
+
+  letter1 = prefix1[0]
+  num1 = prefix1[1..2].to_i
+  letter2 = prefix2[0]
+  num2 = prefix2[1..2].to_i
+
+  if letter1 == letter2
+    num1 <=> num2
+  else
+    letter1 <=> letter2
+  end
+end
+
+def validate_flat_structure_consistency(projects)
+  warnings = []
+
+  flat_prefixes = extract_flat_prefixes(projects)
+  return warnings if flat_prefixes.empty?
+
+  oldest_flat = flat_prefixes.first
+  newest_flat = flat_prefixes.last
+
+  grouped_prefixes = extract_grouped_prefixes(projects)
+  warnings.concat(check_grouped_within_flat_range(grouped_prefixes, oldest_flat, newest_flat))
+
+  warnings
+end
+
+def extract_flat_prefixes(projects)
+  flat_projects = projects.select { |p| p[:storage][:local][:structure] == 'flat' }
+  flat_projects.map { |p| extract_prefix(p[:id]) }.compact.sort
+end
+
+def extract_grouped_prefixes(projects)
+  grouped_projects = projects.select { |p| p[:storage][:local][:structure] == 'grouped' }
+  grouped_projects.map { |p| extract_prefix(p[:id]) }.compact
+end
+
+def check_grouped_within_flat_range(grouped_prefixes, oldest_flat, newest_flat)
+  warnings = []
+  grouped_prefixes.each do |grouped_prefix|
+    next unless prefix_within_flat_range?(grouped_prefix, oldest_flat, newest_flat)
+
+    warnings << "⚠️  WARNING: Project #{grouped_prefix}-* is in grouped structure but falls within flat range (#{oldest_flat} - #{newest_flat})"
+  end
+  warnings
+end
+
+def prefix_within_flat_range?(prefix, oldest_flat, newest_flat)
+  0.between?(compare_prefixes(prefix, newest_flat), compare_prefixes(prefix, oldest_flat))
+end
+
+def validate_project_id_formats(projects)
+  warnings = []
+
+  projects.each do |project|
+    warnings << "⚠️  WARNING: Invalid project ID format: #{project[:id]}" unless validate_project_id_format(project[:id])
+  end
+
+  warnings
+end
+
+def find_local_project(project_id)
+  range = get_range_for_project(project_id)
+
+  # Check flat structure first (active projects at root)
+  flat_path = File.join(LOCAL_BASE, project_id)
+  return flat_path if Dir.exist?(flat_path)
+
+  # Check archived/grouped folder structure (if we know the range)
+  if range
+    archived_path = File.join(LOCAL_ARCHIVED, range, project_id)
+    return archived_path if Dir.exist?(archived_path)
+  end
+
+  nil
+end
+
+def get_ssd_path(project_id)
+  range = get_range_for_project(project_id)
+  return nil unless range
+
+  File.join(SSD_BASE, range, project_id)
+end
+
+# Require SSD to be mounted
+unless Dir.exist?(SSD_BASE)
+  puts "❌ SSD not mounted at #{SSD_BASE}"
+  puts '   Please connect the SSD before running this tool.'
+  puts '   The manifest requires scanning both local AND SSD to be accurate.'
+  exit 1
+end
+
+# Collect all unique project IDs from both locations
+all_project_ids = []
+
+# Scan SSD (all range folders)
+if Dir.exist?(SSD_BASE)
+  Dir.glob(File.join(SSD_BASE, '*/')).each do |range_path|
+    File.basename(range_path)
+    # Look for project folders (a*, b*, or anything that looks like a project)
+    Dir.glob(File.join(range_path, '*/')).each do |project_path|
+      all_project_ids << File.basename(project_path)
+    end
+  end
+end
+
+# Scan local flat (root level projects)
+Dir.glob(File.join(LOCAL_BASE, '*/')).each do |path|
+  basename = File.basename(path)
+  # Skip non-project directories
+  next if basename == 'archived'
+  next if basename == 'final'
+  next unless validate_project_id_format(basename)
+
+  # Add flat project
+  all_project_ids << basename
+end
+
+# Scan local archived (grouped folders inside archived/)
+if Dir.exist?(LOCAL_ARCHIVED)
+  Dir.glob(File.join(LOCAL_ARCHIVED, '*/')).each do |range_path|
+    Dir.glob(File.join(range_path, '*/')).each do |project_path|
+      all_project_ids << File.basename(project_path)
+    end
+  end
+end
+
+all_project_ids = all_project_ids.uniq.sort
+
+# Build project entries
+projects = []
+all_project_ids.each do |project_id|
+  local_path = find_local_project(project_id)
+  ssd_path = get_ssd_path(project_id)
+
+  local_exists = !local_path.nil?
+  ssd_exists = ssd_path && Dir.exist?(ssd_path)
+
+  # Determine if local is in flat or grouped structure
+  # Check if path is in archived/ subdirectory
+  local_structure = if local_path&.include?('/archived/')
+                      'grouped'
+                    elsif local_path
+                      'flat'
+                    end
+
+  projects << {
+    id: project_id,
+    storage: {
+      ssd: {
+        exists: ssd_exists,
+        path: "#{get_range_for_project(project_id)}/#{project_id}"
+      },
+      local: {
+        exists: local_exists,
+        structure: local_structure,
+        has_heavy_files: local_exists ? heavy_files?(local_path) : false,
+        has_light_files: local_exists ? light_files?(local_path) : false
+      }
+    }
+  }
+end
+
+# Calculate disk usage for a specific path
+def calculate_path_size(path)
+  return 0 unless Dir.exist?(path)
+
+  total = 0
+  Dir.glob(File.join(path, '**', '*'), File::FNM_DOTMATCH).each do |file|
+    total += File.size(file) if File.file?(file)
+  end
+  total
+end
+
+def format_bytes(bytes)
+  {
+    total_bytes: bytes,
+    total_mb: (bytes / 1024.0 / 1024.0).round(2),
+    total_gb: (bytes / 1024.0 / 1024.0 / 1024.0).round(2)
+  }
+end
+
+puts '📊 Calculating disk usage...'
+
+# Calculate local flat (root-level project folders only)
+local_flat_bytes = 0
+projects.each do |project|
+  if project[:storage][:local][:exists] && project[:storage][:local][:structure] == 'flat'
+    flat_path = File.join(LOCAL_BASE, project[:id])
+    local_flat_bytes += calculate_path_size(flat_path)
+  end
+end
+
+# Calculate local grouped (all grouped folders in archived/)
+local_grouped_bytes = 0
+projects.each do |project|
+  next unless project[:storage][:local][:exists] && project[:storage][:local][:structure] == 'grouped'
+
+  range = get_range_for_project(project[:id])
+  grouped_path = File.join(LOCAL_ARCHIVED, range, project[:id])
+  local_grouped_bytes += calculate_path_size(grouped_path)
+end
+
+# Calculate total SSD
+ssd_bytes = 0
+projects.each do |project|
+  next unless project[:storage][:ssd][:exists]
+
+  range = get_range_for_project(project[:id])
+  ssd_path = File.join(SSD_BASE, range, project[:id])
+  ssd_bytes += calculate_path_size(ssd_path)
+end
+
+local_flat_usage = format_bytes(local_flat_bytes)
+local_grouped_usage = format_bytes(local_grouped_bytes)
+ssd_usage = format_bytes(ssd_bytes)
+
+# Build manifest
+manifest = {
+  config: {
+    local_base: LOCAL_BASE,
+    ssd_base: SSD_BASE,
+    last_updated: Time.now.utc.iso8601,
+    note: 'Auto-generated manifest. Regenerate with: ruby video-asset-tools/bin/generate_manifest.rb',
+    disk_usage: {
+      local_flat: local_flat_usage,
+      local_grouped: local_grouped_usage,
+      ssd: ssd_usage
+    }
+  },
+  projects: projects
+}
+
+# Write to file
+File.write(OUTPUT_FILE, JSON.pretty_generate(manifest))
+
+puts "✅ Generated #{OUTPUT_FILE}"
+puts "   Found #{projects.size} unique projects"
+puts "   SSD mounted: #{Dir.exist?(SSD_BASE)}"
+puts
+
+# Summary stats
+local_flat = projects.count { |p| p[:storage][:local][:structure] == 'flat' }
+local_grouped = projects.count { |p| p[:storage][:local][:structure] == 'grouped' }
+local_only = projects.count { |p| p[:storage][:local][:exists] && !p[:storage][:ssd][:exists] }
+ssd_only = projects.count { |p| !p[:storage][:local][:exists] && p[:storage][:ssd][:exists] }
+both = projects.count { |p| p[:storage][:local][:exists] && p[:storage][:ssd][:exists] }
+
+puts 'Distribution:'
+puts "  Local only: #{local_only}"
+puts "  SSD only: #{ssd_only}"
+puts "  Both locations: #{both}"
+puts
+puts 'Local structure:'
+puts "  Flat (active): #{local_flat}"
+puts "  Grouped (archived): #{local_grouped}"
+puts
+
+# Run validations
+puts '🔍 Running validations...'
+all_warnings = []
+
+# Validate project ID formats
+format_warnings = validate_project_id_formats(projects)
+all_warnings.concat(format_warnings)
+
+# Validate flat structure consistency
+consistency_warnings = validate_flat_structure_consistency(projects)
+all_warnings.concat(consistency_warnings)
+
+if all_warnings.empty?
+  puts '✅ All validations passed!'
+else
+  puts "#{all_warnings.size} warning(s) found:"
+  all_warnings.each { |w| puts "   #{w}" }
+end