ci: update CI/CD configuration

This commit is contained in:
saravanakumardb1 2026-02-12 23:56:23 -08:00
parent fd6e3d7e8e
commit a34bc3dc7f

View File

@ -1,514 +0,0 @@
---
description: Intelligent workspace sync - check, review, and commit changes across all repos
date: 2025-02-12
---
# Workspace Sync Workflow
> Intelligently manages uncommitted changes across all 3 workspace repos with interactive approval.
> Preserves developer knowledge and prevents data loss through careful review and conflict resolution.
## Overview
This workflow helps maintain a clean workspace by:
1. Scanning all repos for uncommitted changes
2. Displaying changes in an organized, reviewable format
3. Suggesting logical commit groups based on change types
4. Interactive approval before each commit
5. Safe conflict resolution with rebase
6. Pushing in dependency order (common_plat → voice_agent → mindlyst)
## Prerequisites
- Git CLI installed
- All repos cloned and accessible
- Proper Git credentials configured
## Workflow Steps
### Step 1: Scan Workspace for Changes
```bash
# Create workspace sync script
cat > ~/workspace-sync.sh << 'EOF'
#!/bin/bash
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color
# Workspace paths
WORKSPACE="$HOME/code/mygh"
REPOS=(
"learning_ai_common_plat:Common Platform:First"
"learning_voice_ai_agent:LysnrAI:Second"
"learning_multimodal_memory_agents:MindLyst:Third"
)
echo -e "${BLUE}🔍 Scanning workspace for uncommitted changes...${NC}"
echo
# Track repos with changes
REPOS_WITH_CHANGES=()
for repo_info in "${REPOS[@]}"; do
IFS=':' read -r repo_name display_name order <<< "$repo_info"
repo_path="$WORKSPACE/$repo_name"
if [ -d "$repo_path" ]; then
cd "$repo_path"
# Check for uncommitted changes
if ! git diff --quiet || ! git diff --cached --quiet || [ -n "$(git ls-files --others --exclude-standard)" ]; then
REPOS_WITH_CHANGES+=("$repo_name:$display_name:$order")
echo -e "${CYAN}📁 $display_name${NC} (${YELLOW}$repo_name${NC})"
# Staged changes
if [ -n "$(git diff --cached --name-only)" ]; then
echo -e " ${GREEN}Staged changes:${NC}"
git diff --cached --stat
fi
# Unstaged changes
if [ -n "$(git diff --name-only)" ]; then
echo -e " ${YELLOW}Unstaged changes:${NC}"
git diff --stat
fi
# Untracked files
if [ -n "$(git ls-files --others --exclude-standard)" ]; then
echo -e " ${RED}Untracked files:${NC}"
git ls-files --others --exclude-standard | head -10
count=$(git ls-files --others --exclude-standard | wc -l)
[ $count -gt 10 ] && echo " ... and $((count - 10)) more"
fi
# Branch status
branch_status=$(git status --porcelain -b | head -1)
if [[ $branch_status == *"ahead"* ]]; then
echo -e " ${YELLOW}⚠️ Branch is ahead of origin${NC}"
fi
if [[ $branch_status == *"behind"* ]]; then
echo -e " ${YELLOW}⚠️ Branch is behind origin${NC}"
fi
echo
fi
fi
done
if [ ${#REPOS_WITH_CHANGES[@]} -eq 0 ]; then
echo -e "${GREEN}✅ All repos are clean!${NC}"
exit 0
fi
echo -e "${BLUE}📊 Summary: Found changes in ${#REPOS_WITH_CHANGES[@]} repo(s)${NC}"
echo
EOF
chmod +x ~/workspace-sync.sh
```
### Step 2: Interactive Review and Commit
```bash
# Add interactive commit functionality
cat >> ~/workspace-sync.sh << 'EOF'
# Function to suggest commit message based on changes
suggest_commit_message() {
local repo_path="$1"
cd "$repo_path"
# Analyze changes
has_ci_changes=$(git diff --cached --name-only | grep -E "\.github|ci|workflow" || echo "")
has_docs_changes=$(git diff --cached --name-only | grep -E "README|\.md$" || echo "")
has_code_changes=$(git diff --cached --name-only | grep -E "\.(ts|js|py|kt|swift)$" || echo "")
has_test_changes=$(git diff --cached --name-only | grep -E "test|spec" || echo "")
has_config_changes=$(git diff --cached --name-only | grep -E "package\.json|requirements|gradle|\.env" || echo "")
# Suggest message
if [ -n "$has_ci_changes" ]; then
echo "ci: update CI/CD configuration"
elif [ -n "$has_docs_changes" ] && [ -z "$has_code_changes" ]; then
echo "docs: update documentation"
elif [ -n "$has_test_changes" ] && [ -z "$has_code_changes" ]; then
echo "test: update test suite"
elif [ -n "$has_config_changes" ]; then
echo "chore: update dependencies and configuration"
else
echo "feat: implement new features and improvements"
fi
}
# Function to safely commit with review
safe_commit() {
local repo_name="$1"
local display_name="$2"
local repo_path="$WORKSPACE/$repo_name"
cd "$repo_path"
echo -e "${BLUE}📋 Reviewing changes for $display_name${NC}"
echo
# Show detailed diff
echo -e "${CYAN}Press Enter to see diff summary, 's' to skip, 'q' to quit${NC}"
read -r response
if [[ "$response" == "q" ]]; then
echo -e "${RED}Quitting workflow${NC}"
exit 0
elif [[ "$response" != "s" ]]; then
git diff --cached --stat 2>/dev/null || true
git diff --stat 2>/dev/null || true
echo
fi
# Ask what to do with changes
echo -e "${YELLOW}Choose action:${NC}"
echo " 1) Stage all changes and commit"
echo " 2) Review and stage specific files"
echo " 3) Skip this repo"
echo " q) Quit workflow"
read -r action
case $action in
1)
# Stage all changes
git add -A
;;
2)
# Interactive staging
echo -e "${CYAN}Files to stage:${NC}"
git status --porcelain
echo -e "${YELLOW}Enter files to stage (space-separated, or 'all'):${NC}"
read -r files_to_stage
if [[ "$files_to_stage" == "all" ]]; then
git add -A
else
git add $files_to_stage
fi
;;
3)
echo -e "${YELLOW}Skipping $display_name${NC}"
return
;;
q)
echo -e "${RED}Quitting workflow${NC}"
exit 0
;;
esac
# Check if there's anything to commit
if git diff --cached --quiet; then
echo -e "${YELLOW}No changes staged, skipping${NC}"
return
fi
# Suggest commit message
suggested_msg=$(suggest_commit_message "$repo_path")
echo -e "${CYAN}Suggested commit message: $suggested_msg${NC}"
echo -e "${YELLOW}Enter commit message (or press Enter to accept suggestion):${NC}"
read -r commit_msg
if [[ -z "$commit_msg" ]]; then
commit_msg="$suggested_msg"
fi
# Confirm commit
echo -e "${YELLOW}Commit with message: '$commit_msg'? (y/N)${NC}"
read -r confirm
if [[ "$confirm" == "y" || "$confirm" == "Y" ]]; then
git commit -m "$commit_msg"
echo -e "${GREEN}✅ Committed changes in $display_name${NC}"
else
echo -e "${YELLOW}Commit cancelled${NC}"
fi
}
EOF
```
### Step 3: Safe Push with Conflict Resolution
```bash
# Add push and conflict resolution
cat >> ~/workspace-sync.sh << 'EOF'
# Function to safely push with conflict resolution
safe_push() {
local repo_name="$1"
local display_name="$2"
local repo_path="$WORKSPACE/$repo_name"
cd "$repo_path"
# Check if we're ahead of origin
if git log --oneline origin/main..main 2>/dev/null | grep -q .; then
echo -e "${BLUE}📤 Pushing $display_name...${NC}"
# Try to push
if git push 2>/dev/null; then
echo -e "${GREEN}✅ Pushed $display_name successfully${NC}"
else
echo -e "${YELLOW}⚠️ Push failed, attempting to pull and rebase...${NC}"
# Fetch latest changes
git fetch
# Check if we have diverged
if git log --oneline main..origin/main | grep -q .; then
echo -e "${YELLOW}Local and remote have diverged. Options:${NC}"
echo " 1) Pull --rebase (rebase your changes on top of remote)"
echo " 2) Pull --no-rebase (merge remote changes)"
echo " 3) Skip pushing and handle manually"
read -r choice
case $choice in
1)
git pull --rebase
if git push; then
echo -e "${GREEN}✅ Pushed after rebase${NC}"
else
echo -e "${RED}❌ Still failed to push after rebase${NC}"
echo -e "${CYAN}Please resolve conflicts manually in $repo_path${NC}"
fi
;;
2)
git pull --no-rebase
if git push; then
echo -e "${GREEN}✅ Pushed after merge${NC}"
else
echo -e "${RED}❌ Still failed to push after merge${NC}"
fi
;;
3)
echo -e "${YELLOW}Skipping push. Please handle manually.${NC}"
;;
esac
else
# Just need to push
git push
echo -e "${GREEN}✅ Pushed $display_name${NC}"
fi
fi
fi
}
# Main execution
main() {
# Sort repos by dependency order
sorted_repos=($(printf '%s\n' "${REPOS_WITH_CHANGES[@]}" | sort -k3 -t':'))
echo -e "${BLUE}🚀 Starting interactive sync process...${NC}"
echo
for repo_info in "${sorted_repos[@]}"; do
IFS=':' read -r repo_name display_name order <<< "$repo_info"
safe_commit "$repo_name" "$display_name"
echo
done
# Ask about pushing
echo -e "${YELLOW}Push all committed changes to origin? (y/N)${NC}"
read -r push_confirm
if [[ "$push_confirm" == "y" || "$push_confirm" == "Y" ]]; then
echo -e "${BLUE}📤 Pushing in dependency order...${NC}"
echo
for repo_info in "${sorted_repos[@]}"; do
IFS=':' read -r repo_name display_name order <<< "$repo_info"
safe_push "$repo_name" "$display_name"
echo
done
else
echo -e "${YELLOW}Skipping push. Changes are committed locally.${NC}"
fi
echo -e "${GREEN}✨ Workspace sync complete!${NC}"
}
# Run main function
main
EOF
echo "Created workspace-sync.sh at ~/workspace-sync.sh"
```
### Step 4: Create VS Code Task for Easy Access
```bash
# Create .vscode/tasks.json in each repo
cat > /Users/sd9235/code/mygh/learning_ai_common_plat/.vscode/tasks.json << 'EOF'
{
"version": "2.0.0",
"tasks": [
{
"label": "Workspace Sync",
"type": "shell",
"command": "~/workspace-sync.sh",
"group": "build",
"presentation": {
"echo": true,
"reveal": "always",
"focus": false,
"panel": "new"
},
"problemMatcher": []
}
]
}
EOF
# Copy to other repos
cp /Users/sd9235/code/mygh/learning_ai_common_plat/.vscode/tasks.json \
/Users/sd9235/code/mygh/learning_voice_ai_agent/.vscode/tasks.json
cp /Users/sd9235/code/mygh/learning_ai_common_plat/.vscode/tasks.json \
/Users/sd9235/code/mygh/learning_multimodal_memory_agents/.vscode/tasks.json
```
## Usage
### Option 1: Run from Terminal
```bash
~/workspace-sync.sh
```
### Option 2: Run from VS Code
1. Open any workspace repo
2. Press `Cmd+Shift+P` (macOS) or `Ctrl+Shift+P` (Windows/Linux)
3. Type "Tasks: Run Task"
4. Select "Workspace Sync"
### Option 3: Create Git Alias
```bash
git config --global alias.ws '!~/workspace-sync.sh'
# Then run: git ws
```
## Features
### 🔍 Smart Detection
- Identifies staged, unstaged, and untracked files
- Detects branch divergence (ahead/behind)
- Shows change statistics
### 📝 Intelligent Suggestions
- Suggests commit messages based on changed file types
- Follows conventional commit format
- Recognizes CI, docs, test, and feature changes
### 🛡️ Safety First
- Interactive review before each commit
- Confirmation before destructive operations
- Preserves developer knowledge and consent
### 🔄 Conflict Resolution
- Automatic fetch before push
- Interactive choice between rebase/merge
- Clear guidance for manual resolution
### 📊 Dependency Ordering
- Automatically pushes in correct order
- Common Platform → LysnrAI → MindLyst
- Prevents dependency issues
## Example Session
```
🔍 Scanning workspace for uncommitted changes...
📁 Common Platform (learning_ai_common_plat)
Staged changes:
src/index.ts | 2 +-
README.md | 5 +++++
Untracked files:
new-feature.ts
📁 LysnrAI (learning_voice_ai_agent)
Unstaged changes:
src/app.py | 10 ++++++++++
requirements.txt | 2 +-
📊 Summary: Found changes in 2 repo(s)
🚀 Starting interactive sync process...
📋 Reviewing changes for Common Platform
Press Enter to see diff summary, 's' to skip, 'q' to quit
Choose action:
1) Stage all changes and commit
2) Review and stage specific files
3) Skip this repo
q) Quit workflow
1
Suggested commit message: feat: implement new features and improvements
Enter commit message (or press Enter to accept suggestion): feat: add new feature and update docs
Commit with message: 'feat: add new feature and update docs'? (y/N) y
✅ Committed changes in Common Platform
...
```
## Best Practices
1. **Run before switching contexts**: Always run workspace sync before moving to another task
2. **Review carefully**: The interactive review prevents accidental commits
3. **Handle conflicts manually**: If rebase/merge fails, resolve conflicts to understand what changed
4. **Commit frequently**: Small, focused commits are easier to review and sync
5. **Use descriptive messages**: Good commit messages help track changes across repos
## Troubleshooting
### Permission Issues
```bash
chmod +x ~/workspace-sync.sh
```
### Git Credentials
```bash
git config --global credential.helper store
```
### SSH Key Issues
```bash
ssh-add ~/.ssh/id_rsa
```
## Customization
You can customize the script by:
- Adding more repos to the `REPOS` array
- Modifying commit message suggestions
- Adding custom conflict resolution strategies
- Integrating with your team's workflow
---
**Remember**: This workflow preserves your knowledge and control over what gets committed. Never skip the review steps!