appydave-tools 0.16.0 → 0.17.0

data/lib/appydave/tools/vat/manifest_generator.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module Appydave
+  module Tools
+    module Vat
+      # Generate manifest JSON for video projects
+      class ManifestGenerator
+        attr_reader :brand, :brand_info, :brand_path
+
+        def initialize(brand, brand_info: nil, brand_path: nil)
+          @brand = brand
+          @brand_path = brand_path || Config.brand_path(brand)
+          @brand_info = brand_info || load_brand_info(brand)
+        end
+
+        # Generate manifest for this brand
+        def generate(output_file: nil)
+          output_file ||= File.join(brand_path, 'projects.json')
+          ssd_backup = brand_info.locations.ssd_backup
+
+          unless ssd_backup && !ssd_backup.empty?
+            puts "⚠️  SSD backup location not configured for brand '#{brand}'"
+            puts '   Manifest will only include local projects.'
+          end
+
+          ssd_available = ssd_backup && Dir.exist?(ssd_backup)
+
+          puts "📊 Generating manifest for #{brand}..."
+          puts ''
+
+          # Collect all unique project IDs from both locations
+          all_project_ids = collect_project_ids(ssd_backup, ssd_available)
+
+          if all_project_ids.empty?
+            puts "❌ No projects found for brand '#{brand}'"
+            return
+          end
+
+          # Build project entries
+          projects = build_project_entries(all_project_ids, ssd_backup, ssd_available)
+
+          # Calculate disk usage
+          disk_usage = calculate_disk_usage(projects, ssd_backup)
+
+          # Build manifest
+          manifest = {
+            config: {
+              brand: brand,
+              local_base: brand_path,
+              ssd_base: ssd_backup,
+              last_updated: Time.now.utc.iso8601,
+              note: 'Auto-generated manifest. Regenerate with: vat manifest'
+            }.merge(disk_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 ''
+
+          # Summary stats
+          show_summary(projects, disk_usage)
+
+          # Validations
+          run_validations(projects)
+        end
+
+        private
+
+        def load_brand_info(brand)
+          Appydave::Tools::Configuration::Config.configure
+          Appydave::Tools::Configuration::Config.brands.get_brand(brand)
+        end
+
+        def collect_project_ids(ssd_backup, ssd_available)
+          all_project_ids = []
+
+          # Scan SSD (if available)
+          if ssd_available
+            Dir.glob(File.join(ssd_backup, '*/')).each do |project_path|
+              all_project_ids << File.basename(project_path)
+            end
+          end
+
+          # Scan local (all projects in brand directory)
+          Dir.glob(File.join(brand_path, '*/')).each do |path|
+            basename = File.basename(path)
+            # Skip hidden and special directories
+            next if basename.start_with?('.', '_')
+            next if %w[s3-staging archived final].include?(basename)
+
+            all_project_ids << basename if valid_project_id?(basename)
+          end
+
+          all_project_ids.uniq.sort
+        end
+
+        def build_project_entries(all_project_ids, ssd_backup, ssd_available)
+          projects = []
+
+          all_project_ids.each do |project_id|
+            local_path = File.join(brand_path, project_id)
+            ssd_path = ssd_available ? File.join(ssd_backup, project_id) : nil
+
+            local_exists = Dir.exist?(local_path)
+            ssd_exists = ssd_path && Dir.exist?(ssd_path)
+
+            projects << {
+              id: project_id,
+              storage: {
+                ssd: {
+                  exists: ssd_exists,
+                  path: ssd_exists ? project_id : nil
+                },
+                local: {
+                  exists: local_exists,
+                  has_heavy_files: local_exists ? heavy_files?(local_path) : false,
+                  has_light_files: local_exists ? light_files?(local_path) : false
+                }
+              }
+            }
+          end
+
+          projects
+        end
+
+        def calculate_disk_usage(projects, ssd_backup)
+          local_bytes = 0
+          ssd_bytes = 0
+
+          projects.each do |project|
+            if project[:storage][:local][:exists]
+              local_path = File.join(brand_path, project[:id])
+              local_bytes += calculate_directory_size(local_path)
+            end
+
+            if project[:storage][:ssd][:exists]
+              ssd_path = File.join(ssd_backup, project[:id])
+              ssd_bytes += calculate_directory_size(ssd_path)
+            end
+          end
+
+          {
+            disk_usage: {
+              local: format_bytes_hash(local_bytes),
+              ssd: format_bytes_hash(ssd_bytes)
+            }
+          }
+        end
+
+        def show_summary(projects, disk_usage)
+          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 'Disk Usage:'
+          puts "  Local: #{format_bytes_human(disk_usage[:disk_usage][:local][:total_bytes])}"
+          puts "  SSD: #{format_bytes_human(disk_usage[:disk_usage][:ssd][:total_bytes])}"
+          puts ''
+        end
+
+        def run_validations(projects)
+          puts '🔍 Running validations...'
+          warnings = []
+
+          projects.each do |project|
+            warnings << "⚠️  Invalid project ID format: #{project[:id]}" unless valid_project_id?(project[:id])
+          end
+
+          if warnings.empty?
+            puts '✅ All validations passed!'
+          else
+            puts "#{warnings.size} warning(s) found:"
+            warnings.each { |w| puts "   #{w}" }
+          end
+        end
+
+        # Helper methods
+        def valid_project_id?(project_id)
+          # Valid formats:
+          # - Modern: letter + 2 digits + dash + name (e.g., b63-flivideo)
+          # - Legacy: just numbers (e.g., 006-ac-carnivore-90)
+          !!(project_id =~ /^[a-z]\d{2}-/ || project_id =~ /^\d/)
+        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 calculate_directory_size(dir_path)
+          total = 0
+          Dir.glob(File.join(dir_path, '**', '*'), File::FNM_DOTMATCH).each do |file|
+            total += File.size(file) if File.file?(file)
+          end
+          total
+        end
+
+        def format_bytes_hash(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
+
+        def format_bytes_human(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)).round(1)} MB"
+          else
+            "#{(bytes / (1024.0 * 1024 * 1024)).round(2)} GB"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/vat/project_listing.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require 'find'
+
+# rubocop:disable Style/FormatStringToken
+# Disabled: Using simple unannotated tokens (%s) for straightforward string formatting
+# Annotated tokens (%<foo>s) add unnecessary complexity for simple table formatting
+
+module Appydave
+  module Tools
+    module Vat
+      # Project listing functionality for VAT
+      class ProjectListing
+        # List all brands with summary table
+        def self.list_brands_with_counts
+          brands = Config.available_brands
+
+          if brands.empty?
+            puts "⚠️  No brands found in #{Config.projects_root}"
+            return
+          end
+
+          # Gather brand data
+          brand_data = brands.map do |brand|
+            brand_path = Config.brand_path(brand)
+            projects = ProjectResolver.list_projects(brand)
+            total_size = calculate_total_size(brand_path, projects)
+            last_modified = find_last_modified(brand_path, projects)
+
+            {
+              name: brand,
+              path: brand_path,
+              count: projects.size,
+              size: total_size,
+              modified: last_modified
+            }
+          end
+
+          # Print table header
+          puts 'BRAND                  PROJECTS         SIZE        LAST MODIFIED    PATH'
+          puts '-' * 120
+
+          # Print table rows
+          brand_data.each do |data|
+            puts format(
+              '%-20s %10d %12s %20s    %s',
+              data[:name],
+              data[:count],
+              format_size(data[:size]),
+              format_date(data[:modified]),
+              shorten_path(data[:path])
+            )
+          end
+        end
+
+        # List all projects for a specific brand (Mode 3)
+        def self.list_brand_projects(brand_arg)
+          brand = Config.expand_brand(brand_arg)
+          projects = ProjectResolver.list_projects(brand)
+
+          if projects.empty?
+            puts "⚠️  No projects found for brand: #{brand}"
+            return
+          end
+
+          brand_path = Config.brand_path(brand)
+
+          # Gather project data
+          project_data = projects.map do |project|
+            project_path = File.join(brand_path, project)
+            size = calculate_directory_size(project_path)
+            modified = File.mtime(project_path)
+
+            {
+              name: project,
+              path: project_path,
+              size: size,
+              modified: modified
+            }
+          end
+
+          # Print table header
+          puts "Projects in #{brand}:"
+          puts 'PROJECT                                               SIZE        LAST MODIFIED    PATH'
+          puts '-' * 120
+
+          # Print table rows
+          project_data.each do |data|
+            puts format(
+              '%-45s %12s %20s    %s',
+              data[:name],
+              format_size(data[:size]),
+              format_date(data[:modified]),
+              shorten_path(data[:path])
+            )
+          end
+        end
+
+        # List with pattern matching (Mode 3b)
+        def self.list_with_pattern(brand_arg, pattern)
+          brand = Config.expand_brand(brand_arg)
+          brand_path = Config.brand_path(brand)
+          matches = ProjectResolver.resolve_pattern(brand_path, pattern)
+
+          if matches.empty?
+            puts "⚠️  No projects found matching pattern: #{pattern}"
+            return
+          end
+
+          # Gather project data
+          project_data = matches.map do |project|
+            project_path = File.join(brand_path, project)
+            size = calculate_directory_size(project_path)
+            modified = File.mtime(project_path)
+
+            {
+              name: project,
+              path: project_path,
+              size: size,
+              modified: modified
+            }
+          end
+
+          # Print table header
+          puts "Projects matching '#{pattern}' in #{brand}:"
+          puts 'PROJECT                                               SIZE        LAST MODIFIED    PATH'
+          puts '-' * 120
+
+          # Print table rows
+          project_data.each do |data|
+            puts format(
+              '%-45s %12s %20s    %s',
+              data[:name],
+              format_size(data[:size]),
+              format_date(data[:modified]),
+              shorten_path(data[:path])
+            )
+          end
+        end
+
+        # Helper methods
+
+        # Calculate total size of all projects in a brand
+        def self.calculate_total_size(brand_path, projects)
+          projects.sum do |project|
+            calculate_directory_size(File.join(brand_path, project))
+          end
+        end
+
+        # Calculate size of a directory in bytes
+        def self.calculate_directory_size(path)
+          return 0 unless Dir.exist?(path)
+
+          total = 0
+          Find.find(path) do |file_path|
+            total += File.size(file_path) if File.file?(file_path)
+          rescue StandardError
+            # Skip files we can't read
+          end
+          total
+        end
+
+        # Find the most recent modification time across all projects
+        def self.find_last_modified(brand_path, projects)
+          return Time.at(0) if projects.empty?
+
+          projects.map do |project|
+            File.mtime(File.join(brand_path, project))
+          end.max
+        end
+
+        # Format size in human-readable format
+        def self.format_size(bytes)
+          return '0 B' if bytes.zero?
+
+          units = %w[B KB MB GB TB]
+          exp = (Math.log(bytes) / Math.log(1024)).to_i
+          exp = [exp, units.length - 1].min
+
+          format('%.1f %s', bytes.to_f / (1024**exp), units[exp])
+        end
+
+        # Format date/time in readable format
+        def self.format_date(time)
+          return 'N/A' if time.nil?
+
+          time.strftime('%Y-%m-%d %H:%M')
+        end
+
+        # Shorten path by replacing home directory with ~
+        def self.shorten_path(path)
+          path.sub(Dir.home, '~')
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Style/FormatStringToken

data/lib/appydave/tools/vat/project_resolver.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Vat
+      # ProjectResolver - Resolve short project names to full paths
+      #
+      # Handles:
+      # - FliVideo pattern: b65 → b65-guy-monroe-marketing-plan
+      # - Storyline pattern: boy-baker → boy-baker (exact match)
+      # - Pattern matching: b6* → all b60-b69 projects
+      class ProjectResolver
+        class << self
+          # Resolve project hint to full project name(s)
+          # @param brand [String] Brand shortcut or full name
+          # @param project_hint [String] Project name or pattern (e.g., 'b65', 'boy-baker', 'b6*')
+          # @return [String, Array<String>] Full project name or array of names for patterns
+          def resolve(brand, project_hint)
+            brand_path = Config.brand_path(brand)
+
+            # Check for pattern (wildcard)
+            return resolve_pattern(brand_path, project_hint) if project_hint.include?('*')
+
+            # Exact match first
+            full_path = File.join(brand_path, project_hint)
+            return project_hint if Dir.exist?(full_path)
+
+            # FliVideo pattern: b65 → b65-*
+            if project_hint =~ /^[a-z]\d+$/
+              matches = Dir.glob("#{brand_path}/#{project_hint}-*")
+                           .select { |path| File.directory?(path) }
+                           .map { |path| File.basename(path) }
+
+              case matches.size
+              when 0
+                raise "❌ No project found matching '#{project_hint}' in #{Config.expand_brand(brand)}"
+              when 1
+                return matches.first
+              else
+                # Multiple matches - show and ask
+                puts "⚠️  Multiple projects match '#{project_hint}':"
+                matches.each_with_index do |match, idx|
+                  puts "  #{idx + 1}. #{match}"
+                end
+                print "\nSelect project (1-#{matches.size}): "
+                selection = $stdin.gets.to_i
+                return matches[selection - 1] if selection.between?(1, matches.size)
+
+                raise 'Invalid selection'
+              end
+            end
+
+            # No match - return as-is (will error later if doesn't exist)
+            project_hint
+          end
+
+          # Resolve pattern to list of matching projects
+          # @param brand_path [String] Full path to brand directory
+          # @param pattern [String] Pattern with wildcards (e.g., 'b6*')
+          # @return [Array<String>] List of matching project names
+          def resolve_pattern(brand_path, pattern)
+            matches = Dir.glob("#{brand_path}/#{pattern}")
+                         .select { |path| File.directory?(path) }
+                         .select { |path| valid_project?(path) }
+                         .map { |path| File.basename(path) }
+                         .sort
+
+            raise "❌ No projects found matching pattern '#{pattern}' in #{brand_path}" if matches.empty?
+
+            matches
+          end
+
+          # List all projects for a brand
+          # @param brand [String] Brand shortcut or full name
+          # @param pattern [String, nil] Optional filter pattern
+          # @return [Array<String>] List of project names
+          def list_projects(brand, pattern = nil)
+            brand_path = Config.brand_path(brand)
+
+            glob_pattern = pattern || '*'
+            Dir.glob("#{brand_path}/#{glob_pattern}")
+               .select { |path| File.directory?(path) }
+               .select { |path| valid_project?(path) }
+               .map { |path| File.basename(path) }
+               .sort
+          end
+
+          # Check if directory is a valid project
+          # @param project_path [String] Full path to potential project directory
+          # @return [Boolean] true if valid project
+          def valid_project?(project_path)
+            basename = File.basename(project_path)
+
+            # Exclude system/infrastructure directories
+            excluded = %w[archived docs node_modules .git .github]
+            return false if excluded.include?(basename)
+
+            # Exclude hidden and underscore-prefixed
+            return false if basename.start_with?('.', '_')
+
+            true
+          end
+
+          # Detect brand and project from current directory
+          # @return [Array<String, String>] [brand, project] or [nil, nil]
+          def detect_from_pwd
+            current = Dir.pwd
+
+            # Check if we're inside a v-* directory
+            if current =~ %r{/(v-[^/]+)/([^/]+)/?}
+              brand = ::Regexp.last_match(1)
+              project = ::Regexp.last_match(2)
+              return [brand, project] if project_exists?(brand, project)
+            end
+
+            [nil, nil]
+          end
+
+          # Check if project exists in brand directory
+          # @param brand [String] Brand name (v-appydave format)
+          # @param project [String] Project name
+          # @return [Boolean] true if project directory exists
+          def project_exists?(brand, project)
+            projects_root = Config.projects_root
+            project_path = File.join(projects_root, brand, project)
+            Dir.exist?(project_path)
+          end
+        end
+      end
+    end
+  end
+end