gsd-antigravity-kit 1.0.0

package/.agent/skills/gsd-converter/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: gsd-converter
+description: "A tool for converting standard GSD (Get Shit Done) installations into the Antigravity Skill format. Use this skill when you want to migrate `.claude/gsd` commands, agents, and templates into a portable, spec-driven skill structure for Claude Code."
+---
+
+# GSD to Antigravity Skill Converter
+
+This skill provides the logic and resources to package a locally installed GSD system into a structured Antigravity Skill.
+
+## Why Convert?
+1. **Portability**: Skills can be shared and loaded across different projects more easily than local `.claude` commands.
+2. **Spec-Driven**: Leverages the Antigravity spec-driven coding system for better reliability.
+3. **Organized**: Separates commands, documentation, workflows, and templates into clear directories.
+
+## Conversion Workflow
+
+1. **Cleanup**: Deletes existing `.agent/skills/gsd/` folder to ensure a clean slate.
+
+2. **Installation**: Runs `npx get-shit-done-cc --claude --local --force-statusline` to fetch/refresh the source files in `.claude/`.
+
+3. **Detection**: The skill locates the fresh GSD files:
+   - Commands: `.claude/commands/gsd/`
+   - Docs/Workflows: `.claude/get-shit-done/`
+   - Agents: `.claude/agents/`
+
+4. **Initialization**: Re-creates the target skill structure in `.agent/skills/gsd/`.
+
+5. **Migration**:
+   - Copies command markdown files to `references/commands/`.
+   - Copies reference docs to `references/docs/`.
+   - Copies workflows to `references/workflows/`.
+   - Copies agents to `references/agents/`.
+   - Copies templates to `assets/templates/`.
+
+6. **Refactoring**:
+   - Rewrites file inclusion paths (e.g., `@./.claude/...`) to the new skill-relative format (e.g., `@references/...`).
+   - Updates `Task()` prompt paths for subagents.
+   - **Rebranding**: Automatically converts "Claude" and "Claude Code" mentions to "Antigravity" throughout all migrated files.
+
+7. **Packaging**: Generates a comprehensive `SKILL.md` using the `assets/gsd_skill_template.md` template, ensuring compliance with skill-developer best practices.
+
+## Usage
+
+Run the conversion script:
+```bash
+python .agent/skills/gsd-converter/scripts/convert.py <target-skill-name>
+```
+
+Refer to `references/mapping.md` for details on how paths are translated.

package/.agent/skills/gsd-converter/assets/gsd_skill_template.md

@@ -0,0 +1,70 @@
+---
+name: {skill_name}
+description: "Antigravity GSD (Get Stuff Done) - A spec-driven hierarchical planning and execution system. Triggers on project planning, phase management, and GSD slash commands."
+---
+
+# {title_name}
+
+## Purpose
+
+The Antigravity GSD (Get Stuff Done) skill implements a rigid, spec-driven hierarchy for managing software development tasks. It enforces a separation of concerns between Planning, Execution, and Verification phases to reduce context switching and improve reliability.
+
+## When to Use This Skill
+
+This skill should be used when:
+1.  **Starting a Project**: Initializing a new codebase or feature set with a clear structure.
+2.  **Planning Work**: Breaking down vague requirements into actionable, verified specifications.
+3.  **Executing Tasks**: Implementing code based on approved specs without context switching.
+4.  **Managing State**: Tracking progress through defined phases (Plan -> Execute -> Verify).
+
+**Triggers:**
+- Keywords: "plan phase", "execute phase", "new project spec", "gsd"
+- Commands: 
+{command_triggers}
+
+## System Overview
+
+### 1. Phase-Based Development
+The system enforces distinct phases. You typically cannot execute until you have planned.
+- **Plan**: Define specs, tasks, and acceptance criteria. Output is a plan artifact.
+- **Execute**: Write code to satisfy the specs. Driven by the plan artifact.
+- **Verify**: Confirm the code meets criteria.
+
+### 2. Available Commands
+The following slash commands are available in this skill. Use them to drive the GSD process:
+
+{commands_list}
+
+### 3. Directory Structure
+The skill uses a standardized directory structure for portability and organization:
+- `references/commands/`: Executable slash command definitions.
+- `references/agents/`: Specialized agent prompts and personas used by the commands.
+- `references/workflows/`: Step-by-step standard operating procedures and guidelines.
+- `references/docs/`: Contextual documentation and guides on the GSD philosophy.
+- `assets/templates/`: Reusable file structures for plans, tasks, and reports.
+
+## Reference Files
+
+For detailed instructions, consult the following resources:
+
+### [Commands Reference](references/commands/)
+List of all available slash commands and their detailed arguments. Look here to understand how to invoke specific GSD actions.
+
+### [Workflow Guides](references/workflows/)
+Standard procedures for common development tasks. These documents describe the "how-to" for the GSD process.
+
+### [Agent Definitions](references/agents/)
+Capabilities and personas of the specialized agents. Useful for understanding who does what in the multi-agent setup.
+
+### [Documentation](references/docs/)
+General documentation on the GSD philosophy, usage patterns, and configuration.
+
+## Best Practices
+
+1.  **Follow the Sequence**: Do not skip the Planning phase. A good plan saves hours of debugging.
+2.  **Use Templates**: Leverage `assets/templates/` for consistent file structures.
+3.  **Update State**: Keep the project state synchronized using `/gsd:progress`.
+4.  **One Context**: Keep separate contexts (channels/threads) for Planning vs Execution to avoid contamination.
+
+---
+*Generated by gsd-converter on {date}*

package/.agent/skills/gsd-converter/references/mapping.md

@@ -0,0 +1,32 @@
+# Path Mapping Reference
+
+When converting from a standard GSD installation to an Antigravity Skill, paths are refactored to ensure the skill is self-contained and portable.
+
+## Directory Mapping
+
+| Source GSD Path | Target Skill Path | Purpose |
+|-----------------|-------------------|---------|
+| `.claude/commands/gsd/` | `references/commands/` | Interactive slash commands |
+| `.claude/get-shit-done/references/` | `references/docs/` | Static domain knowledge and guides |
+| `.claude/get-shit-done/workflows/` | `references/workflows/` | Multi-step procedural logic |
+| `.claude/agents/` | `references/agents/` | Specialized sub-agent system prompts |
+| `.claude/get-shit-done/templates/` | `assets/templates/` | File boilerplate (PROJECT.md, etc.) |
+
+## String Replacements (Regex)
+
+The conversion script performs the following replacements within `.md` and `.json` files:
+
+1. **File Inclusion Syntax (`@`)**
+   - `@./.claude/commands/gsd/` -> `@references/commands/`
+   - `@./.claude/get-shit-done/references/` -> `@references/docs/`
+   - `@./.claude/get-shit-done/workflows/` -> `@references/workflows/`
+   - `@./.claude/get-shit-done/templates/` -> `@assets/templates/`
+   - `@./.claude/agents/` -> `@references/agents/`
+
+2. **Programmatic Paths (e.g., in `Task()` calls)**
+   - `./.claude/agents/` -> `references/agents/`
+   - `./.claude/get-shit-done/templates/` -> `assets/templates/`
+   - `./.claude/get-shit-done/workflows/` -> `references/workflows/`
+
+## Project Context
+References to `@.planning/` are **preserved**, as these refer to the active project's local planning directory, not the skill's own resources.

package/.agent/skills/gsd-converter/scripts/convert.py

@@ -0,0 +1,221 @@
+import os
+import re
+import shutil
+import sys
+import argparse
+import subprocess
+from datetime import datetime
+
+def setup_args():
+    parser = argparse.ArgumentParser(description='Convert GSD to Antigravity Skill format.')
+    parser.add_argument('skill_name', nargs='?', default='gsd', help='Name of the target skill (default: gsd)')
+    parser.add_argument('--path', default='.agent/skills', help='Base path for skills directory')
+    parser.add_argument('--source', default='.claude', help='Source .claude directory')
+    return parser.parse_args()
+
+def get_gsd_version(source_base):
+    version_path = os.path.join(source_base, 'get-shit-done', 'VERSION')
+    if os.path.exists(version_path):
+        try:
+            with open(version_path, 'r', encoding='utf-8') as f:
+                return f.read().strip()
+        except Exception:
+            return "unknown"
+    return "not installed"
+
+def run_gsd_install():
+    print("📥 Running fresh GSD installation via npx...")
+    try:
+        # We use shell=True because npx is often a shell script/cmd on Windows
+        result = subprocess.run(
+            ["npx", "get-shit-done-cc", "--claude", "--local", "--force-statusline"],
+            check=True,
+            capture_output=True,
+            text=True,
+            shell=True
+        )
+        print("  ✅ GSD installed successfully to .claude/")
+    except subprocess.CalledProcessError as e:
+        print(f"  ❌ Failed to run npx installation: {e}")
+        print(f"  Output: {e.output}")
+        sys.exit(1)
+
+def migrate_files(source_base, target_base):
+    print(f"🚀 Starting migration from {source_base} to {target_base}...")
+    
+    # Define mappings (source_rel, target_rel)
+    mappings = [
+        ('commands/gsd', 'references/commands'),
+        ('get-shit-done/references', 'references/docs'),
+        ('get-shit-done/workflows', 'references/workflows'),
+        ('agents', 'references/agents'),
+        ('get-shit-done/templates', 'assets/templates')
+    ]
+    
+    for src_rel, tgt_rel in mappings:
+        src_path = os.path.join(source_base, src_rel)
+        tgt_path = os.path.join(target_base, tgt_rel)
+        
+        if os.path.exists(src_path):
+            print(f"  📁 Migrating {src_rel} -> {tgt_rel}")
+            if not os.path.exists(tgt_path):
+                os.makedirs(tgt_path, exist_ok=True)
+            
+            for item in os.listdir(src_path):
+                s = os.path.join(src_path, item)
+                d = os.path.join(tgt_path, item)
+                if os.path.isdir(s):
+                    shutil.copytree(s, d, dirs_exist_ok=True)
+                else:
+                    shutil.copy2(s, d)
+        else:
+            print(f"  ⚠️ Source not found: {src_path}")
+
+def refactor_content(target_base):
+    print("🔧 Refactoring file contents and paths...")
+    
+    replacements = [
+        (r'@\./\.claude/commands/gsd/', '@references/commands/'),
+        (r'@\./\.claude/get-shit-done/references/', '@references/docs/'),
+        (r'@\./\.claude/get-shit-done/workflows/', '@references/workflows/'),
+        (r'@\./\.claude/get-shit-done/templates/', '@assets/templates/'),
+        (r'@\./\.claude/agents/', '@references/agents/'),
+        (r'\./\.claude/agents/', 'references/agents/'),
+        (r'\./\.claude/get-shit-done/templates/', 'assets/templates/'),
+        (r'\./\.claude/get-shit-done/workflows/', 'references/workflows/'),
+        # Textual replacements
+        (r'\bClaude Code\b', 'Antigravity'),
+        (r'\bClaude\b', 'Antigravity'),
+        (r'\bclaude\b', 'antigravity'),
+        (r'\bCLAUDE\b', 'ANTIGRAVITY'),
+    ]
+    
+    for root, dirs, files in os.walk(target_base):
+        for file in files:
+            if file.endswith('.md') or file.endswith('.json'):
+                file_path = os.path.join(root, file)
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                
+                new_content = content
+                for pattern, replacement in replacements:
+                    new_content = re.sub(pattern, replacement, new_content)
+                
+                if new_content != content:
+                    with open(file_path, 'w', encoding='utf-8') as f:
+                        f.write(new_content)
+
+def scan_commands(target_base):
+    commands_dir = os.path.join(target_base, 'references', 'commands')
+    commands = []
+    if os.path.exists(commands_dir):
+        for f in sorted(os.listdir(commands_dir)):
+            if f.endswith('.md'):
+                cmd_name = f[:-3] # remove .md
+                file_path = os.path.join(commands_dir, f)
+                description = ""
+                try:
+                    with open(file_path, 'r', encoding='utf-8') as cf:
+                        lines = cf.readlines()
+                        # Simple frontmatter parsing
+                        if lines and lines[0].strip() == '---':
+                            for line in lines[1:]:
+                                if line.strip() == '---':
+                                    break
+                                if line.strip().startswith('description:'):
+                                    description = line.split(':', 1)[1].strip().strip('"').strip("'")
+                                    break
+                except Exception as e:
+                    print(f"  ⚠️ Error parsing {f}: {e}")
+                
+                commands.append({'name': cmd_name, 'description': description})
+    return commands
+
+def create_skill_md(target_base, skill_name):
+    skill_md_path = os.path.join(target_base, 'SKILL.md')
+    
+    # We deliberately overwrite SKILL.md to ensure the command list is always up to date
+    # on every run of the converter.
+
+    # Locate the template file relative to this script
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    template_path = os.path.join(script_dir, '..', 'assets', 'gsd_skill_template.md')
+    
+    commands = scan_commands(target_base)
+    
+    # Format for triggers: - `gsd:command`
+    command_triggers_str = "\n".join([f"- `gsd:{cmd['name']}`" for cmd in commands])
+    
+    # Format for detailed list: bold command name with link, then description
+    # Example: - **[gsd:new-project](references/commands/new-project.md)**: Initialize a new project...
+    commands_list_str = "\n".join([
+        f"- **[`gsd:{cmd['name']}`](references/commands/{cmd['name']}.md)**: {cmd['description']}" 
+        for cmd in commands
+    ])
+
+    if not os.path.exists(template_path):
+        print(f"  ⚠️ Template not found at {template_path}. Using fallback.")
+        content = f"""---
+name: {skill_name}
+description: "Antigravity GSD (Get Stuff Done) - Fallback."
+---
+# {skill_name}
+Template missing.
+"""
+    else:
+        with open(template_path, 'r', encoding='utf-8') as f:
+            template_content = f.read()
+            
+        title_name = skill_name.upper()
+        date_str = datetime.now().strftime('%Y-%m-%d')
+        
+        try:
+            content = template_content.format(
+                skill_name=skill_name,
+                title_name=title_name,
+                date=date_str,
+                command_triggers=command_triggers_str,
+                commands_list=commands_list_str
+            )
+        except KeyError as e:
+            print(f"  ⚠️ Error formatting template: {e}")
+            print("  Check if template contains matching keys.")
+            content = template_content
+
+    with open(skill_md_path, 'w', encoding='utf-8') as f:
+        f.write(content)
+    print("  ✅ Created SKILL.md from template with updated commands")
+
+def main():
+    args = setup_args()
+    
+    # Enforce 'gsd' as the skill name
+    skill_name = 'gsd'
+    target_base = os.path.abspath(os.path.join(args.path, skill_name))
+    
+    print(f"🧹 Cleaning up existing skill folder: {target_base}")
+    if os.path.exists(target_base):
+        shutil.rmtree(target_base)
+    
+    # 0. Capture old version
+    old_version = get_gsd_version(args.source)
+    
+    # 1. Run the fresh GSD installation
+    run_gsd_install()
+    
+    # 1.1 Capture new version
+    new_version = get_gsd_version(args.source)
+    
+    # 2. Re-create the skill directory
+    os.makedirs(target_base, exist_ok=True)
+    
+    # 3. Perform migration and refactoring
+    migrate_files(args.source, target_base)
+    refactor_content(target_base)
+    create_skill_md(target_base, skill_name)
+    
+    print(f"\n✨ Skill '{skill_name}' is ready at {target_base}")
+    print(f"📊 GSD Version: {old_version} -> {new_version}")
+
+if __name__ == '__main__':
+    main()

package/CONTRIBUTING.md

@@ -0,0 +1,30 @@
+# Contributing to GSD-Antigravity
+
+Thank you for your interest in contributing to GSD-Antigravity! We welcome contributions that improve the reliability, efficiency, and extensibility of our GSD system.
+
+## 🚀 Getting Started
+
+1. **Fork the repository** and create your branch from `main`.
+2. **Follow the Skill Spec**: All changes to skills must adhere to the Antigravity Skill specification found in [.agent/skills/skill-developer/SKILL.md](.agent/skills/skill-developer/SKILL.md).
+3. **Draft your changes**: Whether it's a new command, an agent prompt improvement, or a bug fix in the converter.
+
+## 🛠️ Development Guidelines
+
+- **Maintain Hierarchy**: Ensure any new commands fit into the Plan -> Execute -> Verify workflow.
+- **Spec-Driven**: Use the provided templates in `assets/templates` when creating new project artifacts.
+- **Rebranding**: If adding new commands, ensure they follow the `gsd:` prefix nomenclature.
+- **Testing**: Before submitting a PR, verify your skill by running the `gsd-converter` script to ensure it packages correctly.
+
+## 📋 Pull Request Process
+
+1. Update the README.md with details of changes to the interface, if applicable.
+2. Ensure any new dependencies are clearly documented.
+3. Your PR will be reviewed by the maintainers for compliance with GSD core principles.
+
+## 💬 Community
+
+Join our Discord or open an issue for architectural discussions before making major changes.
+
+---
+
+*Happy Coding!*

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Antigravity Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# 🌌 GSD-Antigravity: The Spec-Driven Engine
+
+![GSD Workflow Concept](gsd_workflow_concept_1770173213268.png)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg?logo=python&logoColor=white)](https://www.python.org/downloads/)
+[![Antigravity Compatible](https://img.shields.io/badge/Antigravity-Compatible-purple.svg?logo=google&logoColor=white)](https://github.com/google-deepmind/antigravity)
+
+**GSD-Antigravity** is a high-performance, hierarchical orchestration system for the Antigravity AI framework. It replaces chaotic prompt-engineering with a **rigid, spec-driven development cycle**, transforming high-level intent into production-grade software with mathematical precision.
+
+---
+
+## � Core Philosophy: The GSD Cycle
+
+Most AI development fails because it jumps straight from **intent** to **code**. GSD-Antigravity enforces a non-negotiable protocol:
+
+1.  **Plan Phase**: Deep-probe requirements, surface hidden assumptions, and generate a serialized `.planning/PLAN.md`.
+2.  **Execute Phase**: Atomic, wave-based implementation where agents follow the plan without deviation.
+3.  **Verify Phase**: Conversational User Acceptance Testing (UAT) to ensure the implementation matches the original intent.
+
+---
+
+## ✨ Key Features
+
+### 🛠️ Hierarchical Planning
+Automatically generates deeply nested project structures, including requirements, architectures, and pitfall analyses before coding begins.
+
+### 🤖 Multi-Agent Orchestration
+Spawns specialized sub-agents with distinct personas:
+- **Researchers**: Investigate 2025-standard tech stacks and ecosystem pitfalls.
+- **Roadmappers**: Build multi-phase project arcs.
+- **Plan Checkers**: Audit plans to catch logic gaps before execution.
+
+### 🔄 Legacy Migration (`gsd-converter`)
+Includes a zero-config automation script to migrate standard GSD installations into the portable Antigravity Skill format.
+
+---
+
+## 🧰 The GSD Toolbox
+
+Once installed, the following primary commands drive your project:
+
+| Command | Action | Deep Philosophy |
+| :--- | :--- | :--- |
+| `gsd:new-project` | **Initialize** | Context gathering → Research → Roadmap |
+| `gsd:plan-phase` | **Blueprint** | Resolve ambiguity into actionable tasks |
+| `gsd:execute-phase` | **Build** | Wave-based, parallel agent execution |
+| `gsd:verify-work` | **UAT** | Human-in-the-loop verification |
+| `gsd:map-codebase` | **Audit** | Reverse-engineer existing architecture |
+| `gsd:progress` | **Status** | State management and next-step routing |
+
+---
+
+## 🚀 Speed-to-Code
+
+### 1️⃣ Prerequisites
+- **Antigravity** core installed.
+- **Node.js** (for npx) & **Python 3.8+**.
+
+### 2️⃣ Installation & Setup
+
+Installation is handled via `npx` to automatically provision the `.agent` folder into your current project:
+
+```bash
+# In your project root:
+npx gsd-antigravity-kit
+```
+
+# Then initialize the GSD engine:
+py .agent/skills/gsd-converter/scripts/convert.py gsd
+```
+
+Alternatively, you can clone the repository manually:
+```bash
+git clone https://github.com/example/GSD-Antigravity.git
+cd GSD-Antigravity
+py .agent/skills/gsd-converter/scripts/convert.py gsd
+```
+
+### 3️⃣ Start Your First Project
+```bash
+# Within the Antigravity interface:
+/gsd:new-project
+```
+
+---
+
+## 📂 Project Architecture
+
+```text
+.
+├── .agent/
+│   └── skills/
+│       ├── gsd/           # Generated GSD Skill (Commands & Agents)
+│       └── gsd-converter/ # Migration Tools
+├── README.md              # You are here
+├── LICENSE                # MIT
+└── CONTRIBUTING.md        # How to extend GSD
+```
+
+---
+
+## 🔗 Resources & Support
+
+- 📜 **Documentation**: [docs/](.agent/skills/gsd/references/docs/)
+- 🗺️ **Roadmap Management**: [ROADMAP.md](.agent/skills/gsd/assets/templates/roadmap.md)
+- 💬 **Community**: Join our Discord for GSD strategy and pattern sharing.
+
+---
+
+*Engineered for excellence by the Antigravity Team. 🌌*
+

package/bin/install.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+async function install() {
+    const targetDir = process.cwd();
+    // Location of the .agent folder relative to this script in the package
+    const sourceAgentDir = path.join(__dirname, '..', '.agent');
+    const targetAgentDir = path.join(targetDir, '.agent');
+
+    console.log('🌌 Initializing GSD-Antigravity Skill System...');
+
+    try {
+        // 1. Copy .agent folder
+        if (fs.existsSync(sourceAgentDir)) {
+            console.log(`📦 Copying .agent skills to ${targetDir}...`);
+
+            // We use a simple recursive copy strategy
+            copyFolderSync(sourceAgentDir, targetAgentDir);
+            console.log('✅ .agent folder installed successfully.');
+        } else {
+            console.error('❌ Error: Could not find .agent folder in the package.');
+            process.exit(1);
+        }
+
+        // 2. Offer to run the converter
+        console.log('\n✨ GSD-Antigravity is now in your project.');
+        console.log('To initialize the GSD engine, run:');
+        console.log('  py .agent/skills/gsd-converter/scripts/convert.py gsd\n');
+
+    } catch (err) {
+        console.error('❌ Installation failed:', err.message);
+        process.exit(1);
+    }
+}
+
+function copyFolderSync(from, to) {
+    if (!fs.existsSync(to)) {
+        fs.mkdirSync(to, { recursive: true });
+    }
+    fs.readdirSync(from).forEach(element => {
+        const stat = fs.lstatSync(path.join(from, element));
+        if (stat.isFile()) {
+            fs.copyFileSync(path.join(from, element), path.join(to, element));
+        } else if (stat.isDirectory()) {
+            copyFolderSync(path.join(from, element), path.join(to, element));
+        }
+    });
+}
+
+install();

package/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "gsd-antigravity-kit",
+    "version": "1.0.0",
+    "description": "Installer for GSD-Antigravity skills",
+    "main": "index.js",
+    "bin": {
+        "gsd-antigravity-kit": "bin/install.js"
+    },
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": [
+        "antigravity",
+        "gsd",
+        "automation",
+        "skills"
+    ],
+    "author": "Antigravity Team",
+    "license": "MIT"
+}