gkt-node 3.3.0

package/assets/.agent/skills/git-advanced-workflows/SKILL.md

@@ -0,0 +1,412 @@
+---
+name: git-advanced-workflows
+description: Master advanced Git workflows including rebasing, cherry-picking, bisect, worktrees, and reflog to maintain clean history and recover from any situation. Use when managing complex Git histories, collaborating on feature branches, or troubleshooting repository issues.
+---
+
+# Git Advanced Workflows
+
+Master advanced Git techniques to maintain clean history, collaborate effectively, and recover from any situation with confidence.
+
+## Do not use this skill when
+
+- The task is unrelated to git advanced workflows
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Use this skill when
+
+- Cleaning up commit history before merging
+- Applying specific commits across branches
+- Finding commits that introduced bugs
+- Working on multiple features simultaneously
+- Recovering from Git mistakes or lost commits
+- Managing complex branch workflows
+- Preparing clean PRs for review
+- Synchronizing diverged branches
+
+## Core Concepts
+
+### 1. Interactive Rebase
+
+Interactive rebase is the Swiss Army knife of Git history editing.
+
+**Common Operations:**
+- `pick`: Keep commit as-is
+- `reword`: Change commit message
+- `edit`: Amend commit content
+- `squash`: Combine with previous commit
+- `fixup`: Like squash but discard message
+- `drop`: Remove commit entirely
+
+**Basic Usage:**
+```bash
+# Rebase last 5 commits
+git rebase -i HEAD~5
+
+# Rebase all commits on current branch
+git rebase -i $(git merge-base HEAD main)
+
+# Rebase onto specific commit
+git rebase -i abc123
+```
+
+### 2. Cherry-Picking
+
+Apply specific commits from one branch to another without merging entire branches.
+
+```bash
+# Cherry-pick single commit
+git cherry-pick abc123
+
+# Cherry-pick range of commits (exclusive start)
+git cherry-pick abc123..def456
+
+# Cherry-pick without committing (stage changes only)
+git cherry-pick -n abc123
+
+# Cherry-pick and edit commit message
+git cherry-pick -e abc123
+```
+
+### 3. Git Bisect
+
+Binary search through commit history to find the commit that introduced a bug.
+
+```bash
+# Start bisect
+git bisect start
+
+# Mark current commit as bad
+git bisect bad
+
+# Mark known good commit
+git bisect good v1.0.0
+
+# Git will checkout middle commit - test it
+# Then mark as good or bad
+git bisect good  # or: git bisect bad
+
+# Continue until bug found
+# When done
+git bisect reset
+```
+
+**Automated Bisect:**
+```bash
+# Use script to test automatically
+git bisect start HEAD v1.0.0
+git bisect run ./test.sh
+
+# test.sh should exit 0 for good, 1-127 (except 125) for bad
+```
+
+### 4. Worktrees
+
+Work on multiple branches simultaneously without stashing or switching.
+
+```bash
+# List existing worktrees
+git worktree list
+
+# Add new worktree for feature branch
+git worktree add ../project-feature feature/new-feature
+
+# Add worktree and create new branch
+git worktree add -b bugfix/urgent ../project-hotfix main
+
+# Remove worktree
+git worktree remove ../project-feature
+
+# Prune stale worktrees
+git worktree prune
+```
+
+### 5. Reflog
+
+Your safety net - tracks all ref movements, even deleted commits.
+
+```bash
+# View reflog
+git reflog
+
+# View reflog for specific branch
+git reflog show feature/branch
+
+# Restore deleted commit
+git reflog
+# Find commit hash
+git checkout abc123
+git branch recovered-branch
+
+# Restore deleted branch
+git reflog
+git branch deleted-branch abc123
+```
+
+## Practical Workflows
+
+### Workflow 1: Clean Up Feature Branch Before PR
+
+```bash
+# Start with feature branch
+git checkout feature/user-auth
+
+# Interactive rebase to clean history
+git rebase -i main
+
+# Example rebase operations:
+# - Squash "fix typo" commits
+# - Reword commit messages for clarity
+# - Reorder commits logically
+# - Drop unnecessary commits
+
+# Force push cleaned branch (safe if no one else is using it)
+git push --force-with-lease origin feature/user-auth
+```
+
+### Workflow 2: Apply Hotfix to Multiple Releases
+
+```bash
+# Create fix on main
+git checkout main
+git commit -m "fix: critical security patch"
+
+# Apply to release branches
+git checkout release/2.0
+git cherry-pick abc123
+
+git checkout release/1.9
+git cherry-pick abc123
+
+# Handle conflicts if they arise
+git cherry-pick --continue
+# or
+git cherry-pick --abort
+```
+
+### Workflow 3: Find Bug Introduction
+
+```bash
+# Start bisect
+git bisect start
+git bisect bad HEAD
+git bisect good v2.1.0
+
+# Git checks out middle commit - run tests
+npm test
+
+# If tests fail
+git bisect bad
+
+# If tests pass
+git bisect good
+
+# Git will automatically checkout next commit to test
+# Repeat until bug found
+
+# Automated version
+git bisect start HEAD v2.1.0
+git bisect run npm test
+```
+
+### Workflow 4: Multi-Branch Development
+
+```bash
+# Main project directory
+cd ~/projects/myapp
+
+# Create worktree for urgent bugfix
+git worktree add ../myapp-hotfix hotfix/critical-bug
+
+# Work on hotfix in separate directory
+cd ../myapp-hotfix
+# Make changes, commit
+git commit -m "fix: resolve critical bug"
+git push origin hotfix/critical-bug
+
+# Return to main work without interruption
+cd ~/projects/myapp
+git fetch origin
+git cherry-pick hotfix/critical-bug
+
+# Clean up when done
+git worktree remove ../myapp-hotfix
+```
+
+### Workflow 5: Recover from Mistakes
+
+```bash
+# Accidentally reset to wrong commit
+git reset --hard HEAD~5  # Oh no!
+
+# Use reflog to find lost commits
+git reflog
+# Output shows:
+# abc123 HEAD@{0}: reset: moving to HEAD~5
+# def456 HEAD@{1}: commit: my important changes
+
+# Recover lost commits
+git reset --hard def456
+
+# Or create branch from lost commit
+git branch recovery def456
+```
+
+## Advanced Techniques
+
+### Rebase vs Merge Strategy
+
+**When to Rebase:**
+- Cleaning up local commits before pushing
+- Keeping feature branch up-to-date with main
+- Creating linear history for easier review
+
+**When to Merge:**
+- Integrating completed features into main
+- Preserving exact history of collaboration
+- Public branches used by others
+
+```bash
+# Update feature branch with main changes (rebase)
+git checkout feature/my-feature
+git fetch origin
+git rebase origin/main
+
+# Handle conflicts
+git status
+# Fix conflicts in files
+git add .
+git rebase --continue
+
+# Or merge instead
+git merge origin/main
+```
+
+### Autosquash Workflow
+
+Automatically squash fixup commits during rebase.
+
+```bash
+# Make initial commit
+git commit -m "feat: add user authentication"
+
+# Later, fix something in that commit
+# Stage changes
+git commit --fixup HEAD  # or specify commit hash
+
+# Make more changes
+git commit --fixup abc123
+
+# Rebase with autosquash
+git rebase -i --autosquash main
+
+# Git automatically marks fixup commits
+```
+
+### Split Commit
+
+Break one commit into multiple logical commits.
+
+```bash
+# Start interactive rebase
+git rebase -i HEAD~3
+
+# Mark commit to split with 'edit'
+# Git will stop at that commit
+
+# Reset commit but keep changes
+git reset HEAD^
+
+# Stage and commit in logical chunks
+git add file1.py
+git commit -m "feat: add validation"
+
+git add file2.py
+git commit -m "feat: add error handling"
+
+# Continue rebase
+git rebase --continue
+```
+
+### Partial Cherry-Pick
+
+Cherry-pick only specific files from a commit.
+
+```bash
+# Show files in commit
+git show --name-only abc123
+
+# Checkout specific files from commit
+git checkout abc123 -- path/to/file1.py path/to/file2.py
+
+# Stage and commit
+git commit -m "cherry-pick: apply specific changes from abc123"
+```
+
+## Best Practices
+
+1. **Always Use --force-with-lease**: Safer than --force, prevents overwriting others' work
+2. **Rebase Only Local Commits**: Don't rebase commits that have been pushed and shared
+3. **Descriptive Commit Messages**: Future you will thank present you
+4. **Atomic Commits**: Each commit should be a single logical change
+5. **Test Before Force Push**: Ensure history rewrite didn't break anything
+6. **Keep Reflog Aware**: Remember reflog is your safety net for 90 days
+7. **Branch Before Risky Operations**: Create backup branch before complex rebases
+
+```bash
+# Safe force push
+git push --force-with-lease origin feature/branch
+
+# Create backup before risky operation
+git branch backup-branch
+git rebase -i main
+# If something goes wrong
+git reset --hard backup-branch
+```
+
+## Common Pitfalls
+
+- **Rebasing Public Branches**: Causes history conflicts for collaborators
+- **Force Pushing Without Lease**: Can overwrite teammate's work
+- **Losing Work in Rebase**: Resolve conflicts carefully, test after rebase
+- **Forgetting Worktree Cleanup**: Orphaned worktrees consume disk space
+- **Not Backing Up Before Experiment**: Always create safety branch
+- **Bisect on Dirty Working Directory**: Commit or stash before bisecting
+
+## Recovery Commands
+
+```bash
+# Abort operations in progress
+git rebase --abort
+git merge --abort
+git cherry-pick --abort
+git bisect reset
+
+# Restore file to version from specific commit
+git restore --source=abc123 path/to/file
+
+# Undo last commit but keep changes
+git reset --soft HEAD^
+
+# Undo last commit and discard changes
+git reset --hard HEAD^
+
+# Recover deleted branch (within 90 days)
+git reflog
+git branch recovered-branch abc123
+```
+
+## Resources
+
+- **references/git-rebase-guide.md**: Deep dive into interactive rebase
+- **references/git-conflict-resolution.md**: Advanced conflict resolution strategies
+- **references/git-history-rewriting.md**: Safely rewriting Git history
+- **assets/git-workflow-checklist.md**: Pre-PR cleanup checklist
+- **assets/git-aliases.md**: Useful Git aliases for advanced workflows
+- **scripts/git-clean-branches.sh**: Clean up merged and stale branches

package/assets/.agent/skills/git-manager/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: git-manager
+description: Semantic Commits & Branch Strategy for Leader visibility.
+---
+
+# Git Manager
+
+## Purpose
+Ensures all commits follow the **Semantic Commit** standard (`feat: ...`, `fix: ...`) so the Leader/User can easily track progress.
+
+## Usage
+
+### 1. Make a Commit
+```bash
+python .agent/skills/git-manager/scripts/commit.py --type feat --scope auth --msg "Add login endpoint"
+# Output: feat(auth): Add login endpoint
+```
+
+### 2. View Log (Leader Report)
+```bash
+python .agent/skills/git-manager/scripts/log.py
+```

package/assets/.agent/skills/git-manager/data/git_conventions.json

@@ -0,0 +1,84 @@
+{
+    "commit_conventions": {
+        "conventional_commits": {
+            "format": "<type>(<scope>): <description>",
+            "types": {
+                "feat": "New feature",
+                "fix": "Bug fix",
+                "docs": "Documentation only",
+                "style": "Formatting, no code change",
+                "refactor": "Code restructuring, no behavior change",
+                "perf": "Performance improvement",
+                "test": "Adding or updating tests",
+                "build": "Build system or dependencies",
+                "ci": "CI/CD configuration",
+                "chore": "Maintenance tasks",
+                "revert": "Revert a previous commit"
+            },
+            "examples": [
+                "feat(auth): add Google OAuth login",
+                "fix(cart): prevent duplicate items",
+                "docs: update API endpoint documentation",
+                "refactor(db): migrate from callbacks to async/await"
+            ]
+        }
+    },
+    "branch_strategies": {
+        "github_flow": {
+            "branches": [
+                "main",
+                "feature/*"
+            ],
+            "flow": "main → feature branch → PR → review → merge → deploy",
+            "best_for": "Small teams, continuous deployment"
+        },
+        "git_flow": {
+            "branches": [
+                "main",
+                "develop",
+                "feature/*",
+                "release/*",
+                "hotfix/*"
+            ],
+            "flow": "develop → feature → develop → release → main",
+            "best_for": "Large teams, scheduled releases"
+        },
+        "trunk_based": {
+            "branches": [
+                "main",
+                "short-lived feature branches"
+            ],
+            "flow": "main → short branch (max 2 days) → merge → deploy",
+            "best_for": "CI/CD-heavy teams, rapid iteration"
+        }
+    },
+    "pr_template": "## What\n\nBrief description of changes.\n\n## Why\n\nMotivation and context.\n\n## How\n\nImplementation approach.\n\n## Testing\n\n- [ ] Unit tests added/updated\n- [ ] Manual testing done\n- [ ] No regressions\n\n## Screenshots\n\n(if applicable)",
+    "gitignore_templates": {
+        "node": [
+            "node_modules/",
+            "dist/",
+            ".next/",
+            ".env",
+            ".env.local",
+            "coverage/",
+            "*.log"
+        ],
+        "python": [
+            "__pycache__/",
+            "*.pyc",
+            ".venv/",
+            "venv/",
+            ".env",
+            "dist/",
+            "*.egg-info/"
+        ],
+        "general": [
+            ".DS_Store",
+            "Thumbs.db",
+            ".idea/",
+            ".vscode/",
+            "*.swp",
+            "*.swo"
+        ]
+    }
+}

package/assets/.agent/skills/git-manager/scripts/commit.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+Git Manager — Standardized Semantic Commits.
+
+Usage:
+    python commit.py --type feat --scope auth --msg "Add login endpoint"
+    python commit.py --interactive
+"""
+
+import argparse
+import subprocess
+import sys
+
+TYPES = [
+    "feat", "fix", "docs", "style", "refactor", "perf", "test", "build", "ci", "chore", "revert"
+]
+
+def run_git_commit(commit_type, scope, message):
+    scope_part = f"({scope})" if scope else ""
+    full_message = f"{commit_type}{scope_part}: {message}"
+    
+    cmd = ["git", "commit", "-m", full_message]
+    print(f"🚀 Executing: {' '.join(cmd)}")
+    try:
+        subprocess.run(cmd, check=True)
+        print("✅ Commit successful!")
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error committing: {e}")
+        sys.exit(1)
+
+def interactive():
+    print("📝 Interactive Commit")
+    print("Choose type:")
+    for i, t in enumerate(TYPES, 1):
+        print(f"  {i}. {t}")
+    
+    type_idx = input("Type number (default 1): ")
+    try:
+        commit_type = TYPES[int(type_idx)-1]
+    except:
+        commit_type = "feat"
+        
+    scope = input("Scope (optional): ")
+    message = input("Message: ")
+    
+    if not message:
+        print("Error: Message required")
+        sys.exit(1)
+        
+    run_git_commit(commit_type, scope, message)
+
+def main():
+    parser = argparse.ArgumentParser(description="Semantic Commit Helper")
+    parser.add_argument("--type", choices=TYPES)
+    parser.add_argument("--scope")
+    parser.add_argument("--msg")
+    parser.add_argument("--interactive", "-i", action="store_true")
+    
+    args = parser.parse_args()
+    
+    if args.interactive:
+        interactive()
+    elif args.type and args.msg:
+        run_git_commit(args.type, args.scope, args.msg)
+    else:
+        # Default to interactive if no args
+        interactive()
+
+if __name__ == "__main__":
+    main()

package/assets/.agent/skills/git-manager/scripts/log.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""
+Git Manager — Leader Log Report.
+
+Usage:
+    python log.py [--limit 10]
+"""
+
+import argparse
+import subprocess
+
+def get_log(limit):
+    # Format: Hash - Author, Time : Subject
+    fmt = "%h - %an, %ar : %s"
+    cmd = ["git", "log", f"-n {limit}", f"--pretty=format:{fmt}"]
+    
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    print("\n📜 Project History (Recent):\n")
+    print(result.stdout)
+    print("\n")
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--limit", type=int, default=10)
+    args = parser.parse_args()
+    get_log(args.limit)
+
+if __name__ == "__main__":
+    main()