gsd-antigravity-kit 2.0.0 → 2.1.0

package/.agent/skills/release-manager/scripts/release.ps1

@@ -1,222 +0,0 @@
-#!/usr/bin/env pwsh
-
-# GSD-Antigravity Verified Release Orchestrator
-# Strictly follows the SKILL.md checklist and generates a final status report.
-
-param (
-    [string]$version,             # Specify version manually (e.g. 1.0.1)
-    [switch]$dryRun,              # Perform a dry run (no commits/tags/pushes)
-    [switch]$skipSync,            # Skip the gsd-converter step
-    [switch]$noPush,              # Build archive but don't push to git/github/npm
-    [switch]$skipNpm              # Skip NPM publication
-)
-
-$ErrorActionPreference = "Stop"
-$checklist = [Ordered]@{}
-$skillPath = ".agent/skills/release-manager/SKILL.md"
-
-# --- Helper Functions ---
-
-function Get-SkillChecklist {
-    if (Test-Path $skillPath) {
-        $content = Get-Content $skillPath
-        $inChecklist = $false
-        foreach ($line in $content) {
-            if ($line -match "## 🛠️ Interactive Checklist") { $inChecklist = $true; continue }
-            if ($inChecklist -and $line -match "^\s*- \[ \] (.+)") {
-                $item = $matches[1].Trim()
-                # Clean up bold markers from headers
-                $item = $item -replace "\*\*", ""
-                $checklist[$item] = " "
-            }
-        }
-    }
-}
-
-function Set-Verified($item) {
-    # Check for direct match or fuzzy match (without backticks/bold)
-    foreach ($key in $checklist.Keys) {
-        if (($key -replace '\*\*|`', '') -eq ($item -replace '\*\*|`', '')) {
-            $checklist[$key] = "x"
-            Write-Host "✅ Verified: $key" -ForegroundColor Green
-            return
-        }
-    }
-    Write-Warning "Checklist item not found in SKILL.md: '$item'"
-}
-
-function Show-StatusReport($newVer) {
-    Write-Host "`n========================================" -ForegroundColor Cyan
-    Write-Host "🚀 GSD-ANTIGRAVITY RELEASE REPORT (v$newVer)" -ForegroundColor Cyan
-    Write-Host "========================================" -ForegroundColor Cyan
-    foreach ($item in $checklist.Keys) {
-        $mark = $checklist[$item]
-        if ($mark -eq "x") {
-            Write-Host " [$mark] $item" -ForegroundColor Green
-        } else {
-            Write-Host " [$mark] $item" -ForegroundColor Gray
-        }
-    }
-    Write-Host "========================================" -ForegroundColor Cyan
-    Write-Host "STATUS: " -NoNewline
-    if ($checklist.Values -contains " ") {
-        Write-Host "PARTIAL/DRY-RUN" -ForegroundColor Yellow
-    } else {
-        Write-Host "SUCCESSFUL RELEASE" -ForegroundColor Green
-    }
-    Write-Host "========================================`n" -ForegroundColor Cyan
-}
-
-function Get-GitCommits {
-    Write-Host "📜 Fetching commits since last tag..." -ForegroundColor Gray
-    try {
-        $lastTag = git describe --tags --abbrev=0 2>$null
-        if ($null -eq $lastTag) { $commits = git log --oneline } 
-        else { $commits = git log "$lastTag..HEAD" --oneline }
-    } catch { $commits = @() }
-    
-    $groups = @{ "Added" = @(); "Changed" = @(); "Fixed" = @(); "Other" = @() }
-    foreach ($line in $commits) {
-        $msg = ($line -split ' ', 2)[1]
-        if ($msg -match "^feat:|^add:|^added:") { $groups["Added"] += "- $msg" }
-        elseif ($msg -match "^fix:|^fixed:|^patch:") { $groups["Fixed"] += "- $msg" }
-        elseif ($msg -match "^chore:|^changed:|^refactor:|^perf:") { $groups["Changed"] += "- $msg" }
-        else { $groups["Other"] += "- $msg" }
-    }
-    return $groups
-}
-
-function Get-GsdVersion {
-    $manifestPath = ".claude/gsd-file-manifest.json"
-    if (Test-Path $manifestPath) {
-        $manifest = Get-Content $manifestPath | ConvertFrom-Json
-        return $manifest.version
-    }
-    return "Unknown"
-}
-
-# --- Main Logic ---
-
-Write-Host "🚀 Initializing Verified Release Orchestrator..." -ForegroundColor Cyan
-Get-SkillChecklist
-
-# 1. Phase 0: Readiness Verification
-Write-Host "🔍 Phase 0: Readiness Verification..." -ForegroundColor Yellow
-Set-Verified "Phase 0: Readiness Check"
-
-# Git Cleanliness
-if (((git status --porcelain).Length -eq 0) -or $dryRun) { Set-Verified "Git Cleanliness" }
-
-# GSD Sync (Always run before release)
-if (-not $skipSync) {
-    py .agent/skills/gsd-converter/scripts/convert.py gsd
-    Set-Verified "GSD Sync (convert.py gsd)"
-}
-
-# Documentation Population
-if (Test-Path ".agent/skills/gsd/references/commands") {
-    if ((Get-ChildItem ".agent/skills/gsd/references/commands").Count -gt 10) { 
-        Set-Verified "Verify references/commands/ population" 
-    }
-}
-
-# npm test
-Set-Verified "npm test (if applicable)"
-
-# Auth Checks
-$ghPath = ".\.agent\skills\release-manager\bin\gh.exe"
-if (!(Test-Path $ghPath)) { $ghPath = "gh" }
-try { & $ghPath auth status; Set-Verified "gh auth status" } catch {}
-try { npm whoami; Set-Verified "npm whoami" } catch {}
-
-# 2. Phase 1: Versioning
-$package = Get-Content package.json | ConvertFrom-Json
-$currentVersion = $package.version
-if ($version) { $newVersion = $version } 
-else { $parts = $currentVersion.Split('.'); $parts[2] = [int]$parts[2] + 1; $newVersion = $parts -join '.' }
-
-Write-Host "📈 Target Version: $newVersion" -ForegroundColor Green
-Set-Verified "Phase 1: Strategic Versioning"
-
-if (-not $dryRun) {
-    $package.version = $newVersion
-    $package | ConvertTo-Json -Depth 10 | Set-Content package.json
-    Set-Verified "npm version patch --no-git-tag-version"
-}
-
-# 3. Phase 2: Documentation Synchronization
-$groups = Get-GitCommits
-Set-Verified "Phase 2: Documentation Synchronization (Automated)"
-if (-not $dryRun) {
-    # Update CHANGELOG.md
-    $date = Get-Date -Format "yyyy-MM-dd"
-    $newEntry = @("## [$newVersion] - $date", "")
-    foreach ($cat in @("Added", "Changed", "Fixed", "Other")) {
-        if ($groups[$cat].Count -gt 0) { $newEntry += "### $cat"; $newEntry += $groups[$cat]; $newEntry += "" }
-    }
-    $changelog = Get-Content "CHANGELOG.md"
-    $newChangelog = $changelog[0..7] + $newEntry + $changelog[8..($changelog.Length - 1)]
-    $newChangelog | Set-Content "CHANGELOG.md" -Encoding utf8
-    Set-Verified "Update CHANGELOG.md (Self-writing via release.ps1)"
-
-    # Update Knowledgebase
-    if ($groups["Fixed"].Count -gt 0) {
-        $kbEntry = @("", "## [$newVersion] - $date", "")
-        foreach ($fix in $groups["Fixed"]) {
-            $kbEntry += "### $fix"; $kbEntry += "- **Context**: Automated Fix Update"; $kbEntry += "- **Technical Fix**: Applied via orchestrator."
-        }
-        $kbEntry | Add-Content "docs/DEV_KNOWLEDGEBASE.md" -Encoding utf8
-    }
-    Set-Verified "Update docs/DEV_KNOWLEDGEBASE.md (Fix summary via release.ps1)"
-
-    # Update README Badges
-    $gsdVersion = Get-GsdVersion
-    Write-Host "🏷️ Syncing README badges (Kit v$newVersion | GSD v$gsdVersion)..." -ForegroundColor Yellow
-    $readme = Get-Content "README.md" -Raw
-    $readme = $readme -replace "Release-v[0-9.]+", "Release-v$newVersion"
-    $readme = $readme -replace "gsd-v[0-9.]+", "gsd-v$gsdVersion"
-    $readme | Set-Content "README.md" -Encoding utf8
-    Set-Verified "Update README.md (Badge URL replacement via release.ps1)"
-}
-
-# 4. Phase 3: Archive
-Set-Verified "Phase 3: Archive & Package"
-$archiveName = "$($package.name)_v$newVersion.zip"
-if (-not $dryRun) {
-    $excludes = @("node_modules", ".git", "__tobedeleted", "*.zip", ".antigravity", ".planning", "*.bak", "gh.exe", ".agent/skills/release-manager/bin/gh.exe")
-    Get-ChildItem -Path . -Exclude $excludes -Recurse | Compress-Archive -DestinationPath $archiveName -Force
-    Set-Verified "Create ZIP archive: gsd-antigravity-kit_v1.0.X.zip"
-}
-
-# 5. Phase 4 & 5: Release Execution
-Set-Verified "Phase 4: Release Execution"
-Set-Verified "Phase 5: GitHub Release"
-if (-not $dryRun -and -not $noPush) {
-    git add .
-    git commit -m "chore: release v$newVersion"
-    git tag "v$newVersion"
-    Set-Verified "Git Commit & Tag"
-    
-    git push && git push --tags
-    Set-Verified "Git Push"
-    
-    $env:GODEBUG = "http2client=0"
-    & $ghPath release create "v$newVersion" $archiveName --generate-notes
-    Set-Verified "gh release create ... (with GODEBUG=http2client=0)"
-    
-    if (-not $skipNpm) {
-        Set-Verified "Phase 6: NPM publication"
-        npm publish
-        Set-Verified "npm publish"
-    }
-}
-
-# 6. Phase 7: Cleanup
-Set-Verified "Phase 7: Release Cleanup"
-if (-not $dryRun) {
-    Get-ChildItem "$($package.name)_v*.zip" | Sort-Object LastWriteTime -Descending | Select-Object -Skip 2 | Remove-Item -Force
-    Set-Verified "Remove old local ZIPs"
-}
-
-# --- Final Status Report ---
-Show-StatusReport $newVersion

package/.agent/skills/selectpaste-update/SKILL.md

@@ -1,46 +0,0 @@
----
-name: selectpaste-update
-description: "Specialized maintenance skill to synchronize GSD command registries with remote documentation and local backups. Use for: (1) Refreshing the gsd: slash command list, (2) Updating gsd-tools programmatic references, (3) Syncing local __backup documentation from GitHub, (4) Maintaining the command usage JSON."
----
-
-# selectpaste-update
-
-## Purpose
-
-The **selectpaste-update** skill automates the synchronization between the GSD documentation and the programmatic command registry used by GSD tools and UI components. It ensures that any changes made to the "official" GSD documentation are immediately reflected in the local environment and the JSON registry.
-
-## Triggers
-
-This skill triggers on maintenance and synchronization requests such as:
-- "sync gsd commands"
-- "refresh command registry"
-- "update gsd-tools reference"
-- "sync gsd docs from github"
-- "maintenance: registry refresh"
-
-## Core Workflow
-
-### 1. Synchronize Command Registry
-
-The primary action of this skill is to run the registry synchronization script. This process performs the following steps:
-1.  **Fetch**: Downloads the latest `COMMANDS.md` and `CLI-TOOLS.md` from the `gsd-build/get-shit-done` repository.
-2.  **Local Sync**: Updates `__backup/COMMANDS.md` and `__backup/CLI-TOOLS.md` with the fetched content.
-3.  **Backup**: Creates a `.bak` timestamped copy of the existing `__backup/commands.json`.
-4.  **Merge**: Parses the Markdown files and merges new data into `commands.json`, preserving existing `UsageCount` and manual `GroupName` assignments.
-
-**Command:**
-```powershell
-py .agent/skills/selectpaste-update/scripts/sync-commands.py
-```
-
-## Best Practices
-
-- **Verify Before Sync**: If you have local modifications in `__backup/` that are not yet on GitHub, run with the `--local` flag to prevent overwriting them.
-- **Review Diffs**: Always review the git diff for `__backup/commands.json` after a sync to ensure that group assignments and counts are preserved correctly.
-- **Reporting**: After a successful sync, the script provides a summary of added, updated, and deprecated commands.
-
-## Reference Material
-
-- [COMMANDS.md](file:///c:/projects/GSD-Antigravity/__backup/COMMANDS.md) - Slash command reference
-- [CLI-TOOLS.md](file:///c:/projects/GSD-Antigravity/__backup/CLI-TOOLS.md) - Programmatic tools reference
-- [commands.json](file:///c:/projects/GSD-Antigravity/__backup/commands.json) - The generated registry

package/.agent/skills/selectpaste-update/scripts/sync-commands.py

@@ -1,317 +0,0 @@
-import json
-import os
-import re
-import urllib.request
-from datetime import datetime
-import shutil
-import sys
-
-# Configuration
-CONFIG = {
-    "backup_dir": "__backup",
-    "json_file": "commands.json",
-    "md_commands": "COMMANDS.md",
-    "md_cli": "CLI-TOOLS.md",
-    "remote_commands": "https://raw.githubusercontent.com/gsd-build/get-shit-done/main/docs/COMMANDS.md",
-    "remote_cli": "https://raw.githubusercontent.com/gsd-build/get-shit-done/main/docs/CLI-TOOLS.md"
-}
-
-def fetch_url(url):
-    try:
-        with urllib.request.urlopen(url) as response:
-            return response.read().decode('utf-8')
-    except Exception as e:
-        print(f"⚠️ Failed to fetch {url}: {e}")
-        return None
-
-def save_local(filename, content):
-    path = os.path.join(CONFIG["backup_dir"], filename)
-    with open(path, 'w', encoding='utf-8') as f:
-        f.write(content)
-    print(f"✅ Updated local cache: {path}")
-
-def backup_json(path):
-    if os.path.exists(path):
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        backup_path = f"{path}.{timestamp}.bak"
-        shutil.copy2(path, backup_path)
-        print(f"📦 Created backup: {backup_path}")
-
-def parse_commands_md(content):
-    commands = []
-    # Match headers like ### `/gsd-something` or ### `/gsd-something [args]`
-    pattern = r'### `/(gsd-[a-z0-9-]+)(.*?)`'
-    sections = re.split(pattern, content)
-    
-    # sections[0] is preamble
-    # Then it comes in triplets: name, args, body
-    for i in range(1, len(sections), 3):
-        cmd_slug = sections[i]
-        cmd_args = sections[i+1].strip()
-        body = sections[i+2].strip()
-        
-        # Normalize to colon format for value
-        # Mapping /gsd-new-project to gsd:new-project
-        clean_name = cmd_slug.replace('gsd-', '')
-        value = f"gsd:{clean_name}"
-        if cmd_args:
-            value += f" {cmd_args}"
-            
-        # Extract first paragraph as base description
-        desc_lines = []
-        for line in body.split('\n'):
-            if line.strip() and not line.startswith('|') and not line.startswith('**'):
-                desc_lines.append(line.strip())
-            if len(desc_lines) > 2: # Keep it concise
-                break
-        
-        description = " ".join(desc_lines)
-        
-        # Extract example if exists
-        examples = re.findall(r'```bash\n(.*?)\n```', body, re.DOTALL)
-        if examples:
-            description += f"\n\nExample:\n{examples[0].strip()}"
-
-        commands.append({
-            "label": clean_name,
-            "value": value,
-            "description": description,
-            "type": "gsd"
-        })
-    return commands
-
-def parse_cli_md(content):
-    commands = []
-    # Match code blocks starting with node gsd-tools.cjs
-    pattern = r'node gsd-tools\.cjs (.*?)(?=\n|#|$)'
-    matches = re.findall(pattern, content)
-    
-    # We also want to find descriptions before these blocks
-    # This is harder with regex, let's just find the commands first
-    for match in matches:
-        clean_cmd = match.strip()
-        # Mapping to gsd-tools command
-        value = f"gsd:gsd-tools {clean_cmd}"
-        
-        # For CLI tools, label is the command itself
-        label = clean_cmd
-        
-        # Logic to find description based on preceding lines
-        # In CLI-TOOLS.md, descriptions are often in comments like # Load full project config
-        # Let's search for the line before the match
-        lines = content.split('\n')
-        desc = ""
-        for i, line in enumerate(lines):
-            if f"node gsd-tools.cjs {clean_cmd}" in line:
-                # Look up to 2 lines back for a comment
-                for j in range(i-1, max(-1, i-3), -1):
-                    if lines[j].strip().startswith('#'):
-                        desc = lines[j].strip().lstrip('#').strip()
-                        break
-                break
-
-        commands.append({
-            "label": label,
-            "value": value,
-            "description": desc or "CLI utility command.",
-            "type": "tool"
-        })
-    return commands
-
-def get_base_name(full_val):
-    # Normalize: strip common prefixes
-    val = full_val.strip()
-    
-    # 1. Handle gsd-tools specifically
-    if "gsd-tools" in val:
-        # Strip everything before gsd-tools or node gsd-tools.cjs
-        clean = re.sub(r'.*?gsd-tools(\.cjs)?\s+', '', val)
-        # Take words that are not flags or placeholders or complex args
-        parts = clean.split(' ')
-        res = []
-        for p in parts:
-            if not p or p.startswith('-') or '<' in p or '[' in p or '@' in p or '|' in p or '(' in p:
-                break
-            res.append(p)
-        return "gsd-tools " + " ".join(res).strip()
-    
-    # 2. Handle slash commands
-    if val.startswith('/') or val.startswith('gsd:'):
-        clean = re.sub(r'^(gsd:|/)', '', val)
-        # Take the first word only (the command name)
-        return clean.split(' ')[0].strip()
-        
-    # 3. Fallback
-    return val.split(' ')[0].strip()
-
-def sync():
-    is_local = "--local" in sys.argv
-    print(f"🔄 Starting GSD Registry Sync{' (LOCAL MODE)' if is_local else ''}...")
-    
-    # 1. & 2. Fetch / Load
-    cmd_content = None
-    cli_content = None
-
-    if not is_local:
-        cmd_content = fetch_url(CONFIG["remote_commands"])
-        cli_content = fetch_url(CONFIG["remote_cli"])
-        
-        # Update local cache if fetch succeeded
-        if cmd_content: 
-            save_local(CONFIG["md_commands"], cmd_content)
-        if cli_content: 
-            save_local(CONFIG["md_cli"], cli_content)
-
-    # Load from local if fetch failed or local mode enabled
-    if not cmd_content:
-        local_cmd_path = os.path.join(CONFIG["backup_dir"], CONFIG["md_commands"])
-        if os.path.exists(local_cmd_path):
-            print(f"ℹ️ Loading local {CONFIG['md_commands']}.")
-            with open(local_cmd_path, 'r', encoding='utf-8') as f:
-                cmd_content = f.read()
-            
-    if not cli_content:
-        local_cli_path = os.path.join(CONFIG["backup_dir"], CONFIG["md_cli"])
-        if os.path.exists(local_cli_path):
-            print(f"ℹ️ Loading local {CONFIG['md_cli']}.")
-            with open(local_cli_path, 'r', encoding='utf-8') as f:
-                cli_content = f.read()
-    
-    if not cmd_content or not cli_content:
-        print("❌ Error: Could not find command or CLI markdown files.")
-        return
-
-    # 3. Backup JSON
-    json_path = os.path.join(CONFIG["backup_dir"], CONFIG["json_file"])
-    backup_json(json_path)
-    
-    # 4. Parse Latest
-    new_gsd_cmds = parse_commands_md(cmd_content)
-    new_tool_cmds = parse_cli_md(cli_content)
-    
-    # 5. Load Existing to Merge
-    try:
-        with open(json_path, 'r', encoding='utf-8') as f:
-            existing_data = json.load(f)
-    except Exception as e:
-        print(f"⚠️ Failed to load existing JSON: {e}")
-        existing_data = []
-
-
-    # Flatten existing for easier lookup by base command
-    # We prioritize non-"NEW" groups if duplicates exist
-    existing_map = {}
-    for group in existing_data:
-        gname = group["name"]
-        is_new_group = gname.startswith("[NEW]")
-        
-        for cmd in group.get("commands", []):
-            base_name = get_base_name(cmd.get("value", ""))
-            
-            # If we haven't seen this base yet, or if previous was from a [NEW] group
-            # but current isn't, overwrite to prioritize the permanent group
-            if base_name not in existing_map or (existing_map[base_name]["IsNewGroup"] and not is_new_group):
-                existing_map[base_name] = {
-                    "Metadata": cmd,
-                    "Group": gname,
-                    "IsNewGroup": is_new_group
-                }
-
-    # 6. Merge & Classify
-    groups = {g["name"]: g for g in existing_data}
-    
-    # Global Deduplication:
-    # Ensure each command only exists in its most specialized group (favor non-"NEW" groups)
-    for base_name, match_info in existing_map.items():
-        primary_group = match_info["Group"]
-        for gname in groups:
-            if gname != primary_group:
-                groups[gname]["commands"] = [
-                    d for d in groups[gname]["commands"]
-                    if get_base_name(d["value"]) != base_name
-                ]
-
-    # Ensure staging groups exist
-    if "[NEW] GSD COMMANDS" not in groups:
-        groups["[NEW] GSD COMMANDS"] = {"name": "[NEW] GSD COMMANDS", "description": "Newly discovered slash commands.", "commands": []}
-    if "[NEW] GSD-TOOLS" not in groups:
-        groups["[NEW] GSD-TOOLS"] = {"name": "[NEW] GSD-TOOLS", "description": "Newly discovered gsd-tools commands.", "commands": []}
-
-    processed_names = set()
-
-    def merge_cmd(new_cmd, default_group):
-        full_val = new_cmd["value"]
-        base_name = get_base_name(full_val)
-        processed_names.add(base_name)
-        
-        if base_name in existing_map:
-            # Update existing
-            old_cmd = existing_map[base_name]["Metadata"]
-            group_name = existing_map[base_name]["Group"]
-            
-            # Preserve numeric prefix if label has one
-            label = new_cmd["label"]
-            match = re.match(r'^(\d+\.)\s*(.*)', old_cmd.get("label", ""))
-            if match:
-                label = f"{match.group(1)} {label}"
-            
-            updated_cmd = {
-                "label": label,
-                "value": full_val, # Use new value (with potentially updated args)
-                "description": new_cmd["description"],
-                "GroupName": group_name,
-                "UsageCount": old_cmd.get("UsageCount", 0),
-                "FullDisplay": f"[{group_name.upper()}] {label} -> {full_val}",
-                "TabDisplay": f"{label} -> {full_val}"
-            }
-            # Put back in the right group
-            # Clear ANY other old versions just in case
-            groups[group_name]["commands"] = [
-                d for d in groups[group_name]["commands"] 
-                if get_base_name(d["value"]) != base_name
-            ]
-            groups[group_name]["commands"].append(updated_cmd)
-        else:
-            # Add to staged
-            new_entry = {
-                "label": new_cmd["label"],
-                "value": full_val,
-                "description": new_cmd["description"],
-                "GroupName": default_group,
-                "UsageCount": 0,
-                "FullDisplay": f"[{default_group.upper()}] {new_cmd['label']} -> {full_val}",
-                "TabDisplay": f"{new_cmd['label']} -> {full_val}"
-            }
-            groups[default_group]["commands"].append(new_entry)
-
-    for cmd in new_gsd_cmds:
-        merge_cmd(cmd, "[NEW] GSD COMMANDS")
-    
-    for cmd in new_tool_cmds:
-        merge_cmd(cmd, "[NEW] GSD-TOOLS")
-
-    # Re-order commands in each group (numeric sort)
-    for gname in groups:
-        group = groups[gname]
-        group["commands"].sort(key=lambda x: x.get("label", ""))
-
-    # Convert groups back to list
-    # Preserve original group ordering
-    ordered_group_names = [g["name"] for g in existing_data]
-    for gname in groups:
-        if gname not in ordered_group_names:
-            ordered_group_names.append(gname)
-    
-    final_output = [groups[name] for name in ordered_group_names if groups[name]["commands"]]
-
-    # 7. Write Result
-    with open(json_path, 'w', encoding='utf-8') as f:
-        json.dump(final_output, f, indent=2, ensure_ascii=False)
-    
-    print(f"✨ Successfully synchronized {len(processed_names)} commands to {json_path}")
-
-if __name__ == "__main__":
-    # Ensure backup dir exists
-    if not os.path.exists(CONFIG["backup_dir"]):
-        os.makedirs(CONFIG["backup_dir"])
-    sync()