appydave-tools 0.18.5 → 0.20.0

data/docs/dam/usage.md

@@ -154,6 +154,143 @@ dam list appydave 'b6*'
 # Output: Lists b60, b61, b62...b69 projects
 ```
 
+### Status & Monitoring
+
+#### `dam status [brand] [project]`
+Show unified status for project or brand (local, S3, SSD, git).
+
+**Brand status:**
+```bash
+dam status appydave
+```
+
+**Output:**
+```
+📊 Brand Status: v-appydave
+📡 Git Remote: git@github.com:klueless-io/v-appydave.git
+
+🌿 Branch: main
+📡 Remote: git@github.com:klueless-io/v-appydave.git
+✓ Working directory clean
+✓ Up to date with remote
+
+📋 Manifest Summary:
+   Total projects: 114
+   Local: 74
+   S3 staging: 12
+   SSD backup: 67
+
+   Storyline projects: 3
+   FliVideo projects: 111
+```
+
+**Project status:**
+```bash
+dam status appydave b65
+```
+
+**Output:**
+```
+📊 Status: v-appydave/b65-guy-monroe-marketing-plan
+
+Storage:
+  📁 Local: ✓ exists (flat structure)
+     Heavy files: no
+     Light files: yes
+
+  ☁️  S3 Staging: ✓ exists
+     Local staging files: 3
+
+  💾 SSD Backup: ✓ exists
+     Path: b65-guy-monroe-marketing-plan
+
+Git:
+  🌿 Branch: main
+  📡 Remote: git@github.com:klueless-io/v-appydave.git
+  ↕️  Status: Clean working directory
+  🔄 Sync: Up to date
+```
+
+**Auto-detect from PWD:**
+```bash
+cd ~/dev/video-projects/v-appydave/b65-project
+dam status
+```
+
+### Git Repository Commands
+
+#### `dam repo-status [brand] [--all]`
+Check git status for brand repositories.
+
+```bash
+# Single brand
+dam repo-status appydave
+
+# All brands
+dam repo-status --all
+```
+
+**Output:**
+```
+🔍 Git Status: v-appydave
+
+🌿 Branch: main
+📡 Remote: git@github.com:klueless-io/v-appydave.git
+✓ Working directory clean
+✓ Up to date with remote
+```
+
+#### `dam repo-sync [brand] [--all]`
+Pull updates for brand repositories.
+
+```bash
+# Single brand
+dam repo-sync appydave
+
+# All brands
+dam repo-sync --all
+```
+
+**Output:**
+```
+🔄 Syncing: v-appydave
+
+✓ Already up to date
+```
+
+**Safety features:**
+- Skips brands with uncommitted changes (prevents conflicts)
+- Shows summary when syncing multiple brands
+
+#### `dam repo-push [brand] [project]`
+Push changes for brand repository.
+
+```bash
+# Push all changes
+dam repo-push appydave
+
+# Validate project exists before push
+dam repo-push appydave b65
+```
+
+**Output:**
+```
+📤 Pushing: v-appydave
+
+✓ Project validated: b65-guy-monroe-marketing-plan
+
+📤 Pushing 2 commit(s)...
+
+✓ Push successful
+
+  main -> main
+```
+
+**Safety features:**
+- Warns if uncommitted changes detected
+- Optional project validation against manifest
+- Shows push summary
+
 ### S3 Sync Commands
 
 #### `dam s3-up [brand] [project] [--dry-run]`
@@ -649,4 +786,4 @@ dam s3-up appydave b65
 
 ---
 
-**Last Updated:** 2025-11-08
+**Last Updated:** 2025-11-10

data/lib/appydave/tools/configuration/models/brands_config.rb

@@ -117,6 +117,7 @@ module Appydave
               'type' => 'owned',
               'youtube_channels' => [],
               'team' => [],
+              'git_remote' => nil,
               'locations' => {
                 'video_projects' => '',
                 'ssd_backup' => ''
@@ -144,7 +145,7 @@ module Appydave
 
           # Type-safe class to access brand properties
           class BrandInfo
-            attr_accessor :key, :name, :shortcut, :type, :youtube_channels, :team, :locations, :aws, :settings
+            attr_accessor :key, :name, :shortcut, :type, :youtube_channels, :team, :git_remote, :locations, :aws, :settings
 
             def initialize(key, data)
               @key = key
@@ -153,6 +154,7 @@ module Appydave
               @type = data['type'] || 'owned'
               @youtube_channels = data['youtube_channels'] || []
               @team = data['team'] || []
+              @git_remote = data['git_remote']
               @locations = BrandLocation.new(data['locations'] || {})
               @aws = BrandAws.new(data['aws'] || {})
               @settings = BrandSettings.new(data['settings'] || {})
@@ -165,6 +167,7 @@ module Appydave
                 'type' => @type,
                 'youtube_channels' => @youtube_channels,
                 'team' => @team,
+                'git_remote' => @git_remote,
                 'locations' => @locations.to_h,
                 'aws' => @aws.to_h,
                 'settings' => @settings.to_h

data/lib/appydave/tools/dam/config.rb

@@ -43,6 +43,31 @@ module Appydave
             path
           end
 
+          # Get git remote URL for a brand (with self-healing)
+          # @param brand_key [String] Brand key (e.g., 'appydave', 'voz')
+          # @return [String, nil] Git remote URL or nil if not a git repo
+          def git_remote(brand_key)
+            Appydave::Tools::Configuration::Config.configure
+            brands_config = Appydave::Tools::Configuration::Config.brands
+            brand_info = brands_config.get_brand(brand_key)
+
+            # 1. Check if git_remote is already configured
+            return brand_info.git_remote if brand_info.git_remote && !brand_info.git_remote.empty?
+
+            # 2. Try to infer from git command
+            brand_path_dir = brand_path(brand_key)
+            inferred_remote = infer_git_remote(brand_path_dir)
+
+            # 3. Auto-save if inferred successfully
+            if inferred_remote
+              brand_info.git_remote = inferred_remote
+              brands_config.set_brand(brand_info.key, brand_info)
+              brands_config.save
+            end
+
+            inferred_remote
+          end
+
           # Expand brand shortcut to full brand name
           # Reads from brands.json if available, falls back to hardcoded shortcuts
           # @param shortcut [String] Brand shortcut (e.g., 'appydave', 'ad', 'APPYDAVE')
@@ -165,6 +190,19 @@ module Appydave
                 config.save
             ERROR
           end
+
+          # Infer git remote URL from git repository
+          # @param path [String] Path to git repository
+          # @return [String, nil] Remote URL or nil if not a git repo
+          def infer_git_remote(path)
+            return nil unless Dir.exist?(path)
+
+            # Try to get git remote URL
+            result = `git -C "#{path}" remote get-url origin 2>/dev/null`.strip
+            result.empty? ? nil : result
+          rescue StandardError
+            nil
+          end
         end
       end
     end

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

@@ -157,6 +157,14 @@ module Appydave
                         'archived'
                       end
 
+          # Check S3 staging (only if local exists)
+          s3_staging_path = File.join(local_path, 's3-staging')
+          s3_exists = local_exists && Dir.exist?(s3_staging_path)
+
+          # Check for storyline.json
+          storyline_json_path = File.join(local_path, 'data', 'storyline.json')
+          has_storyline_json = local_exists && File.exist?(storyline_json_path)
+
           # Check SSD (try both flat and range-based structures)
           ssd_exists = if ssd_available
                          flat_ssd_path = File.join(ssd_backup, project_id)
@@ -168,11 +176,16 @@ module Appydave
 
           {
             id: project_id,
+            type: has_storyline_json ? 'storyline-app' : 'flivideo',
+            hasStorylineJson: has_storyline_json,
             storage: {
               ssd: {
                 exists: ssd_exists,
                 path: ssd_exists ? project_id : nil
               },
+              s3: {
+                exists: s3_exists
+              },
               local: {
                 exists: local_exists,
                 structure: structure,

data/lib/appydave/tools/dam/repo_push.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Dam
+      # Push brand repository changes
+      class RepoPush
+        attr_reader :brand, :project_id, :brand_info, :brand_path
+
+        def initialize(brand, project_id = nil)
+          @brand_info = load_brand_info(brand)
+          @brand = @brand_info.key
+          @brand_path = Config.brand_path(@brand)
+          @project_id = project_id
+        end
+
+        # Push changes
+        def push
+          puts "📤 Pushing: v-#{brand}"
+          puts ''
+
+          unless git_repo?
+            puts "❌ Not a git repository: #{brand_path}"
+            return
+          end
+
+          # If project specified, validate it exists in manifest
+          validate_project if project_id
+
+          perform_push
+        end
+
+        private
+
+        def load_brand_info(brand)
+          Appydave::Tools::Configuration::Config.configure
+          Appydave::Tools::Configuration::Config.brands.get_brand(brand)
+        end
+
+        def git_repo?
+          git_dir = File.join(brand_path, '.git')
+          Dir.exist?(git_dir)
+        end
+
+        def validate_project
+          manifest = load_manifest
+          unless manifest
+            puts '⚠️  Warning: Manifest not found'
+            puts '   Continuing with push (manifest is optional for validation)'
+            return
+          end
+
+          # Resolve short name if needed (b65 -> b65-full-name)
+          resolved = ProjectResolver.new.resolve(brand, project_id)
+
+          project_entry = manifest[:projects].find { |p| p[:id] == resolved }
+          if project_entry
+            puts "✓ Project validated: #{resolved}"
+          else
+            puts "⚠️  Warning: Project '#{resolved}' not found in manifest"
+            puts '   Continuing with push (manifest may be outdated)'
+          end
+          puts ''
+        end
+
+        def load_manifest
+          manifest_path = File.join(brand_path, 'projects.json')
+          return nil unless File.exist?(manifest_path)
+
+          JSON.parse(File.read(manifest_path), symbolize_names: true)
+        rescue JSON::ParserError
+          nil
+        end
+
+        def perform_push
+          # Check for uncommitted changes
+          if uncommitted_changes?
+            puts '⚠️  Warning: Uncommitted changes detected'
+            puts ''
+          end
+
+          # Check if ahead of remote
+          ahead = commits_ahead
+          if ahead.zero?
+            puts '✓ Nothing to push (up to date with remote)'
+            return
+          end
+
+          puts "📤 Pushing #{ahead} commit(s)..."
+          puts ''
+
+          # Perform git push
+          output = `git -C "#{brand_path}" push 2>&1`
+          exit_code = $CHILD_STATUS.exitstatus
+
+          if exit_code.zero?
+            puts '✓ Push successful'
+            puts ''
+            show_push_summary(output)
+          else
+            puts '❌ Push failed:'
+            puts output
+            exit 1
+          end
+        end
+
+        def uncommitted_changes?
+          output = `git -C "#{brand_path}" status --porcelain 2>/dev/null`.strip
+          !output.empty?
+        rescue StandardError
+          false
+        end
+
+        def commits_ahead
+          `git -C "#{brand_path}" rev-list --count @{upstream}..HEAD 2>/dev/null`.strip.to_i
+        rescue StandardError
+          0
+        end
+
+        def show_push_summary(output)
+          # Extract useful info from git push output
+          lines = output.lines.map(&:strip).reject(&:empty?)
+
+          lines.each do |line|
+            puts "  #{line}" if line.include?('->') || line.include?('branch')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/dam/repo_status.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Dam
+      # Show git status for brand repositories
+      class RepoStatus
+        attr_reader :brand, :brand_info, :brand_path
+
+        def initialize(brand = nil)
+          return unless brand
+
+          @brand_info = load_brand_info(brand)
+          @brand = @brand_info.key
+          @brand_path = Config.brand_path(@brand)
+        end
+
+        # Show status for single brand
+        def show
+          puts "🔍 Git Status: v-#{brand}"
+          puts ''
+
+          unless git_repo?
+            puts "❌ Not a git repository: #{brand_path}"
+            return
+          end
+
+          show_git_info
+        end
+
+        # Show status for all brands
+        def show_all
+          puts '🔍 Git Status - All Brands'
+          puts ''
+
+          Appydave::Tools::Configuration::Config.configure
+          brands_config = Appydave::Tools::Configuration::Config.brands
+
+          brands_config.brands.each do |brand_info|
+            @brand_info = brand_info
+            @brand = brand_info.key
+            @brand_path = Config.brand_path(@brand)
+
+            next unless git_repo?
+
+            puts "📦 v-#{brand}"
+            show_git_info(indent: '  ')
+            puts ''
+          end
+        end
+
+        private
+
+        def load_brand_info(brand)
+          Appydave::Tools::Configuration::Config.configure
+          Appydave::Tools::Configuration::Config.brands.get_brand(brand)
+        end
+
+        def git_repo?
+          git_dir = File.join(brand_path, '.git')
+          Dir.exist?(git_dir)
+        end
+
+        def show_git_info(indent: '')
+          status = git_status_info
+
+          puts "#{indent}🌿 Branch: #{status[:branch]}"
+          puts "#{indent}📡 Remote: #{status[:remote]}" if status[:remote]
+
+          if status[:modified_count].positive? || status[:untracked_count].positive?
+            puts "#{indent}↕️  Changes: #{status[:modified_count]} modified, #{status[:untracked_count]} untracked"
+          else
+            puts "#{indent}✓ Working directory clean"
+          end
+
+          if status[:ahead].positive? || status[:behind].positive?
+            puts "#{indent}🔄 Sync: #{sync_status_text(status[:ahead], status[:behind])}"
+          else
+            puts "#{indent}✓ Up to date with remote"
+          end
+        end
+
+        def sync_status_text(ahead, behind)
+          parts = []
+          parts << "#{ahead} ahead" if ahead.positive?
+          parts << "#{behind} behind" if behind.positive?
+          parts.join(', ')
+        end
+
+        def git_status_info
+          {
+            branch: current_branch,
+            remote: remote_url,
+            modified_count: modified_files_count,
+            untracked_count: untracked_files_count,
+            ahead: commits_ahead,
+            behind: commits_behind
+          }
+        end
+
+        def current_branch
+          `git -C "#{brand_path}" rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
+        rescue StandardError
+          'unknown'
+        end
+
+        def remote_url
+          result = `git -C "#{brand_path}" remote get-url origin 2>/dev/null`.strip
+          result.empty? ? nil : result
+        rescue StandardError
+          nil
+        end
+
+        def modified_files_count
+          `git -C "#{brand_path}" status --porcelain 2>/dev/null | grep -E "^.M|^M" | wc -l`.strip.to_i
+        rescue StandardError
+          0
+        end
+
+        def untracked_files_count
+          `git -C "#{brand_path}" status --porcelain 2>/dev/null | grep -E "^\\?\\?" | wc -l`.strip.to_i
+        rescue StandardError
+          0
+        end
+
+        def commits_ahead
+          `git -C "#{brand_path}" rev-list --count @{upstream}..HEAD 2>/dev/null`.strip.to_i
+        rescue StandardError
+          0
+        end
+
+        def commits_behind
+          `git -C "#{brand_path}" rev-list --count HEAD..@{upstream} 2>/dev/null`.strip.to_i
+        rescue StandardError
+          0
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/dam/repo_sync.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Dam
+      # Sync (git pull) brand repositories
+      class RepoSync
+        attr_reader :brand, :brand_info, :brand_path
+
+        def initialize(brand = nil)
+          return unless brand
+
+          @brand_info = load_brand_info(brand)
+          @brand = @brand_info.key
+          @brand_path = Config.brand_path(@brand)
+        end
+
+        # Sync single brand
+        def sync
+          puts "🔄 Syncing: v-#{brand}"
+          puts ''
+
+          unless git_repo?
+            puts "❌ Not a git repository: #{brand_path}"
+            return
+          end
+
+          perform_sync
+        end
+
+        # Sync all brands
+        def sync_all
+          puts '🔄 Syncing All Brands'
+          puts ''
+
+          Appydave::Tools::Configuration::Config.configure
+          brands_config = Appydave::Tools::Configuration::Config.brands
+
+          results = []
+
+          brands_config.brands.each do |brand_info|
+            @brand_info = brand_info
+            @brand = brand_info.key
+            @brand_path = Config.brand_path(@brand)
+
+            next unless git_repo?
+
+            puts "📦 v-#{brand}"
+            result = perform_sync(indent: '  ')
+            results << result
+            puts ''
+          end
+
+          show_summary(results)
+        end
+
+        private
+
+        def load_brand_info(brand)
+          Appydave::Tools::Configuration::Config.configure
+          Appydave::Tools::Configuration::Config.brands.get_brand(brand)
+        end
+
+        def git_repo?
+          git_dir = File.join(brand_path, '.git')
+          Dir.exist?(git_dir)
+        end
+
+        def perform_sync(indent: '')
+          # Check for uncommitted changes
+          if uncommitted_changes?
+            puts "#{indent}⚠️  Uncommitted changes detected"
+            puts "#{indent}   Skipping pull (would cause conflicts)"
+            return { brand: brand, status: 'skipped', reason: 'uncommitted changes' }
+          end
+
+          # Perform git pull
+          output = `git -C "#{brand_path}" pull 2>&1`
+          exit_code = $CHILD_STATUS.exitstatus
+
+          if exit_code.zero?
+            if output.include?('Already up to date')
+              puts "#{indent}✓ Already up to date"
+              { brand: brand, status: 'current' }
+            else
+              puts "#{indent}✓ Updated successfully"
+              puts "#{indent}  #{output.lines.first.strip}" if output.lines.any?
+              { brand: brand, status: 'updated' }
+            end
+          else
+            puts "#{indent}❌ Pull failed: #{output.strip}"
+            { brand: brand, status: 'error', reason: output.strip }
+          end
+        end
+
+        def uncommitted_changes?
+          output = `git -C "#{brand_path}" status --porcelain 2>/dev/null`.strip
+          !output.empty?
+        rescue StandardError
+          false
+        end
+
+        def show_summary(results)
+          puts '=' * 60
+          puts '📊 Sync Summary:'
+          puts ''
+
+          updated = results.count { |r| r[:status] == 'updated' }
+          current = results.count { |r| r[:status] == 'current' }
+          skipped = results.count { |r| r[:status] == 'skipped' }
+          errors = results.count { |r| r[:status] == 'error' }
+
+          puts "  Total repos checked: #{results.size}"
+          puts "  Updated: #{updated}"
+          puts "  Already current: #{current}"
+          puts "  Skipped: #{skipped}" if skipped.positive?
+          puts "  Errors: #{errors}" if errors.positive?
+        end
+      end
+    end
+  end
+end