agentskill-cli 1.0.0__tar.gz

agentskill_cli-1.0.0/PKG-INFO

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: agentskill-cli
+Version: 1.0.0
+Summary: Universal AI Skill Manager for GitHub Copilot, Claude, Cursor
+Author: Parth
+License: MIT
+Keywords: ai,copilot,claude,cursor,skills,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+
+# AgentSkill 🛠️
+
+**Universal AI Skill Manager** — Manage skills for GitHub Copilot, Claude Code, Cursor, and more.
+
+## Features
+
+- ✅ **Zero Config**: No setup needed, just install and use
+- ✅ **Multi-AI Support**: GitHub Copilot, Claude Code, Cursor
+- ✅ **Any Language**: Python, JavaScript, Go, Rust, Dart, etc.
+- ✅ **Framework Templates**: React, Django, FastAPI, Flutter, Gin, etc.
+- ✅ **One Command Install**: Auto-detects AI tools in project
+- ✅ **Sync Updates**: Update skill → all projects sync automatically
+
+## Installation (One Time)
+
+```bash
+cd /path/to/Agent_Skill
+pip install -e .
+```
+
+That's it! Now `agentskill` command works globally.
+
+## Quick Start
+
+```bash
+# Create a skill (auto-stored in ~/.agentskill/skills/)
+agentskill create react-rules -l javascript -f react
+
+# Go to any project and install
+cd /your/react-project
+agentskill install react-rules
+
+# Done! AI will follow your rules
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `create <name>` | Create new skill |
+| `install <name>` | Install in current project |
+| `list` | Show all skills |
+| `show <name>` | View skill details |
+| `edit <name>` | Open in editor |
+| `update <name>` | Sync to all projects |
+| `delete <name>` | Remove skill |
+| `export <name>` | Export as zip |
+| `import <zip>` | Import from zip |
+| `init` | Create AI folders |
+| `where` | Show storage location |
+
+**Shortcut**: Use `ask` instead of `agentskill`
+
+## Creating Skills
+
+### Basic
+
+```bash
+agentskill create my-rules
+```
+
+### With Language & Framework
+
+```bash
+# React skill
+agentskill create react-component -l javascript -f react
+
+# Django skill
+agentskill create django-api -l python -f django
+
+# Flutter skill
+agentskill create flutter-widget -l dart -f flutter
+
+# Go API skill
+agentskill create go-api -l go -f gin
+```
+
+### Supported Templates
+
+| Language | Frameworks |
+|----------|------------|
+| Python | django, fastapi, flask |
+| JavaScript | react, nextjs, node |
+| Dart | flutter |
+| Go | gin, fiber |
+| Rust | actix, axum |
+
+## Installing Skills
+
+### Auto-detect (recommended)
+
+```bash
+cd /path/to/project
+agentskill install my-skill
+```
+
+Auto-detects `.github/`, `.claude/`, `.cursor/` folders.
+
+### Specific Tool
+
+```bash
+# GitHub Copilot only
+agentskill install my-skill -t copilot
+
+# Claude only
+agentskill install my-skill -t claude
+
+# All tools
+agentskill install my-skill -t all
+```
+
+## Skill Structure
+
+```
+my-skill/
+├── SKILL.md          # Main instructions (Copilot format)
+├── skill.yaml        # SkillForge metadata
+├── instructions.md   # Legacy format
+├── scripts/          # Helper scripts
+├── references/       # Additional docs
+└── assets/           # Templates, boilerplate
+```
+
+## Editing Skills
+
+```bash
+# Open in editor (VS Code, Cursor, etc.)
+agentskill edit my-skill
+
+# Or show details first
+agentskill show my-skill
+```
+
+After editing, update all projects:
+```bash
+agentskill update my-skill
+```
+
+## Sharing Skills
+
+```bash
+# Export
+agentskill export my-skill
+
+# Import
+agentskill import my-skill.skill.zip
+```
+
+## How It Works
+
+1. **Skills are stored** in `~/.agentskill/skills/` (automatic)
+2. **Install copies** skill to your project's AI folder
+3. **AI reads** the SKILL.md when you code
+
+```
+~/.agentskill/skills/          Your Projects
+┌────────────────────┐         ┌─────────────────┐
+│ react-rules/       │         │ my-react-app/   │
+│   └── SKILL.md     │──copy──▶│   └── .github/  │
+│ django-api/        │         │       └── skills│
+│   └── SKILL.md     │         │           └── react-rules/
+└────────────────────┘         └─────────────────┘
+```
+
+## Tips
+
+- Keep SKILL.md under 500 lines
+- Use `references/` for detailed docs
+- Add code examples in `references/examples.md`
+- Use specific trigger words in descriptions
+
+## License
+
+MIT

agentskill_cli-1.0.0/README.md

@@ -0,0 +1,174 @@
+# AgentSkill 🛠️
+
+**Universal AI Skill Manager** — Manage skills for GitHub Copilot, Claude Code, Cursor, and more.
+
+## Features
+
+- ✅ **Zero Config**: No setup needed, just install and use
+- ✅ **Multi-AI Support**: GitHub Copilot, Claude Code, Cursor
+- ✅ **Any Language**: Python, JavaScript, Go, Rust, Dart, etc.
+- ✅ **Framework Templates**: React, Django, FastAPI, Flutter, Gin, etc.
+- ✅ **One Command Install**: Auto-detects AI tools in project
+- ✅ **Sync Updates**: Update skill → all projects sync automatically
+
+## Installation (One Time)
+
+```bash
+cd /path/to/Agent_Skill
+pip install -e .
+```
+
+That's it! Now `agentskill` command works globally.
+
+## Quick Start
+
+```bash
+# Create a skill (auto-stored in ~/.agentskill/skills/)
+agentskill create react-rules -l javascript -f react
+
+# Go to any project and install
+cd /your/react-project
+agentskill install react-rules
+
+# Done! AI will follow your rules
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `create <name>` | Create new skill |
+| `install <name>` | Install in current project |
+| `list` | Show all skills |
+| `show <name>` | View skill details |
+| `edit <name>` | Open in editor |
+| `update <name>` | Sync to all projects |
+| `delete <name>` | Remove skill |
+| `export <name>` | Export as zip |
+| `import <zip>` | Import from zip |
+| `init` | Create AI folders |
+| `where` | Show storage location |
+
+**Shortcut**: Use `ask` instead of `agentskill`
+
+## Creating Skills
+
+### Basic
+
+```bash
+agentskill create my-rules
+```
+
+### With Language & Framework
+
+```bash
+# React skill
+agentskill create react-component -l javascript -f react
+
+# Django skill
+agentskill create django-api -l python -f django
+
+# Flutter skill
+agentskill create flutter-widget -l dart -f flutter
+
+# Go API skill
+agentskill create go-api -l go -f gin
+```
+
+### Supported Templates
+
+| Language | Frameworks |
+|----------|------------|
+| Python | django, fastapi, flask |
+| JavaScript | react, nextjs, node |
+| Dart | flutter |
+| Go | gin, fiber |
+| Rust | actix, axum |
+
+## Installing Skills
+
+### Auto-detect (recommended)
+
+```bash
+cd /path/to/project
+agentskill install my-skill
+```
+
+Auto-detects `.github/`, `.claude/`, `.cursor/` folders.
+
+### Specific Tool
+
+```bash
+# GitHub Copilot only
+agentskill install my-skill -t copilot
+
+# Claude only
+agentskill install my-skill -t claude
+
+# All tools
+agentskill install my-skill -t all
+```
+
+## Skill Structure
+
+```
+my-skill/
+├── SKILL.md          # Main instructions (Copilot format)
+├── skill.yaml        # SkillForge metadata
+├── instructions.md   # Legacy format
+├── scripts/          # Helper scripts
+├── references/       # Additional docs
+└── assets/           # Templates, boilerplate
+```
+
+## Editing Skills
+
+```bash
+# Open in editor (VS Code, Cursor, etc.)
+agentskill edit my-skill
+
+# Or show details first
+agentskill show my-skill
+```
+
+After editing, update all projects:
+```bash
+agentskill update my-skill
+```
+
+## Sharing Skills
+
+```bash
+# Export
+agentskill export my-skill
+
+# Import
+agentskill import my-skill.skill.zip
+```
+
+## How It Works
+
+1. **Skills are stored** in `~/.agentskill/skills/` (automatic)
+2. **Install copies** skill to your project's AI folder
+3. **AI reads** the SKILL.md when you code
+
+```
+~/.agentskill/skills/          Your Projects
+┌────────────────────┐         ┌─────────────────┐
+│ react-rules/       │         │ my-react-app/   │
+│   └── SKILL.md     │──copy──▶│   └── .github/  │
+│ django-api/        │         │       └── skills│
+│   └── SKILL.md     │         │           └── react-rules/
+└────────────────────┘         └─────────────────┘
+```
+
+## Tips
+
+- Keep SKILL.md under 500 lines
+- Use `references/` for detailed docs
+- Add code examples in `references/examples.md`
+- Use specific trigger words in descriptions
+
+## License
+
+MIT

agentskill_cli-1.0.0/agentskill.py

@@ -0,0 +1,522 @@
+#!/usr/bin/env python3
+"""
+AgentSkill - Universal AI Skill Manager (Zero Config Edition)
+==============================================================
+Manage skills for GitHub Copilot, Claude Code, Cursor, and more.
+Works with any programming language/framework. No path configuration needed!
+
+Install: pip install -e .
+Usage:   agentskill create my-skill
+         agentskill install my-skill
+         agentskill list
+         
+Short:   ask create my-skill
+"""
+
+import typer
+import shutil
+import json
+import zipfile
+import os
+from pathlib import Path
+from typing import Optional
+from datetime import datetime
+
+app = typer.Typer(help="AgentSkill - Universal AI Skill Manager 🛠️")
+
+# ═══════════════════════════════════════════════════════════════════
+# AUTO CONFIG - No manual setup needed!
+# ═══════════════════════════════════════════════════════════════════
+
+def get_default_skills_path() -> Path:
+    """Auto-detect best location for skills folder"""
+    xdg_data = os.environ.get("XDG_DATA_HOME")
+    if xdg_data:
+        return Path(xdg_data) / "agentskill" / "skills"
+    return Path.home() / ".agentskill" / "skills"
+
+def get_config_path() -> Path:
+    """Get config file path"""
+    xdg_config = os.environ.get("XDG_CONFIG_HOME")
+    if xdg_config:
+        return Path(xdg_config) / "agentskill" / "config.json"
+    return Path.home() / ".agentskill" / "config.json"
+
+CONFIG_FILE = get_config_path()
+
+def load_config() -> dict:
+    """Load config, auto-create if missing"""
+    if CONFIG_FILE.exists():
+        return json.loads(CONFIG_FILE.read_text())
+    
+    # Auto-create default config
+    default_config = {
+        "skills_path": str(get_default_skills_path()),
+        "installed_projects": {},
+        "auto_created": True,
+        "created_at": datetime.now().isoformat()
+    }
+    save_config(default_config)
+    
+    # Create skills folder
+    Path(default_config["skills_path"]).mkdir(parents=True, exist_ok=True)
+    
+    return default_config
+
+def save_config(config: dict):
+    """Save config to file"""
+    CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(config, indent=2))
+
+def get_skill_path(name: str) -> Path:
+    """Get skill folder path"""
+    config = load_config()
+    return Path(config["skills_path"]) / name
+
+def find_project_root(start_path: Path = None) -> Path:
+    """Use current directory as project root. Simple and predictable."""
+    if start_path is None:
+        return Path.cwd()
+    return start_path.resolve()
+
+# ═══════════════════════════════════════════════════════════════════
+# SKILL TEMPLATES
+# ═══════════════════════════════════════════════════════════════════
+
+SKILL_TEMPLATES = {
+    "python": {
+        "rules": """
+## Python Rules
+- Use type hints for all functions
+- Follow PEP 8 style guide
+- Use `pathlib` instead of `os.path`
+- Prefer f-strings over .format()
+- Use dataclasses or Pydantic for data models
+- Handle exceptions explicitly
+""",
+        "frameworks": {
+            "django": """
+## Django Rules
+- Use class-based views when logic is complex
+- Always use Django ORM, avoid raw SQL
+- Use Django REST Framework for APIs
+- Keep business logic in services/managers, not views
+""",
+            "fastapi": """
+## FastAPI Rules
+- Use Pydantic models for request/response
+- Use dependency injection for services
+- Use async/await for I/O operations
+- Keep routes thin, business logic in services
+""",
+            "flask": """
+## Flask Rules
+- Use Blueprints for large apps
+- Use Flask-SQLAlchemy for database
+- Keep routes in separate files
+"""
+        }
+    },
+    "javascript": {
+        "rules": """
+## JavaScript/TypeScript Rules
+- Use TypeScript for new projects
+- Use const/let, never var
+- Use async/await over callbacks
+- Use optional chaining (?.) and nullish coalescing (??)
+""",
+        "frameworks": {
+            "react": """
+## React Rules
+- Use functional components with hooks
+- Keep components small and focused
+- Use custom hooks for reusable logic
+- Always use keys in lists
+""",
+            "nextjs": """
+## Next.js Rules
+- Use App Router (app/) for new projects
+- Use Server Components by default
+- Use route handlers for API routes
+""",
+            "node": """
+## Node.js Rules
+- Use async/await for I/O
+- Handle errors with try/catch
+- Use environment variables for config
+"""
+        }
+    },
+    "dart": {
+        "rules": """
+## Dart Rules
+- Use null safety
+- Use const constructors when possible
+- Use named parameters for clarity
+""",
+        "frameworks": {
+            "flutter": """
+## Flutter Rules
+- Use BLoC or Riverpod for state management
+- Keep widgets small and reusable
+- Use const widgets for performance
+- Separate business logic from UI
+"""
+        }
+    },
+    "go": {
+        "rules": """
+## Go Rules
+- Handle errors explicitly
+- Use interfaces for abstraction
+- Keep functions small
+- Use context for cancellation
+""",
+        "frameworks": {
+            "gin": "## Gin Rules\n- Use middleware for common logic\n- Use groups for route organization",
+            "fiber": "## Fiber Rules\n- Use middleware for auth/logging\n- Keep handlers thin"
+        }
+    },
+    "rust": {
+        "rules": """
+## Rust Rules
+- Use Result<T, E> for error handling
+- Prefer borrowing over ownership transfer
+- Use clippy and rustfmt
+- Avoid unwrap() in production code
+""",
+        "frameworks": {
+            "actix": "## Actix-web Rules\n- Use extractors for request data\n- Use middleware for common logic",
+            "axum": "## Axum Rules\n- Use extractors for request parts\n- Use Tower middleware"
+        }
+    }
+}
+
+def get_template_content(language: str, framework: str) -> str:
+    """Get template content based on language and framework"""
+    content = ""
+    lang_template = SKILL_TEMPLATES.get(language.lower(), {})
+    if lang_template:
+        content += lang_template.get("rules", "")
+        if framework and framework != "general":
+            fw_rules = lang_template.get("frameworks", {}).get(framework.lower(), "")
+            content += "\n" + fw_rules
+    return content
+
+# ═══════════════════════════════════════════════════════════════════
+# COMMANDS
+# ═══════════════════════════════════════════════════════════════════
+
+@app.command()
+def create(
+    name: str,
+    language: str = typer.Option("python", "--lang", "-l", help="Programming language"),
+    framework: str = typer.Option("general", "--framework", "-f", help="Framework name"),
+    description: str = typer.Option("", "--desc", "-d", help="Skill description")
+):
+    """
+    Create a new skill. Auto-stores in ~/.agentskill/skills/
+    
+    Examples:
+        agentskill create react-rules -l javascript -f react
+        agentskill create django-api -l python -f django
+    """
+    load_config()  # Auto-creates config if missing
+    
+    skill_dir = get_skill_path(name)
+    skill_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Create subfolders
+    (skill_dir / "scripts").mkdir(exist_ok=True)
+    (skill_dir / "references").mkdir(exist_ok=True)
+    (skill_dir / "assets").mkdir(exist_ok=True)
+    
+    # Generate description
+    if not description:
+        description = f"Rules for {framework} development in {language}. Use when working with {language} {framework} code."
+    
+    # Create skill.yaml
+    (skill_dir / "skill.yaml").write_text(f"""name: {name}
+description: {description}
+language: {language}
+framework: {framework}
+version: 1.0
+created: {datetime.now().strftime('%Y-%m-%d')}
+""")
+    
+    # Get template
+    template_content = get_template_content(language, framework)
+    
+    # Create SKILL.md
+    skill_md = f"""---
+name: {name}
+description: '{description}'
+---
+
+# {name.replace('-', ' ').title()}
+
+## Overview
+This skill provides coding rules for **{language}** with **{framework}**.
+
+## When to Use
+- Working on {language} projects
+- Using {framework} framework
+
+{template_content}
+
+## Custom Rules
+Add your own rules below:
+
+- 
+"""
+    (skill_dir / "SKILL.md").write_text(skill_md)
+    (skill_dir / "instructions.md").write_text(skill_md)
+    
+    # Create example reference
+    (skill_dir / "references" / "examples.md").write_text(f"""# {name} Examples
+
+## Good Examples
+```{language}
+# Add good code examples here
+```
+""")
+    
+    typer.echo(f"""
+✅ Skill '{name}' created!
+
+📁 {skill_dir}
+
+Next:
+  agentskill edit {name}        # Edit rules
+  agentskill install {name}     # Install in project
+""")
+
+
+@app.command()
+def install(
+    name: str,
+    tool: Optional[str] = typer.Option(None, "--tool", "-t", help="copilot, claude, cursor, or all")
+):
+    """
+    Install skill in current project. Auto-detects project root.
+    
+    Just cd to your project and run:
+        agentskill install my-skill
+    """
+    config = load_config()
+    
+    master_skill = get_skill_path(name)
+    if not master_skill.exists():
+        skills = [s.name for s in Path(config["skills_path"]).iterdir() if s.is_dir()]
+        typer.echo(f"❌ Skill '{name}' not found!")
+        if skills:
+            typer.echo(f"   Available: {', '.join(skills)}")
+        raise typer.Exit(1)
+    
+    # Auto-detect project root
+    project = find_project_root()
+    installed = []
+    
+    def install_copilot():
+        target = project / ".github" / "skills" / name
+        target.mkdir(parents=True, exist_ok=True)
+        shutil.copy(master_skill / "SKILL.md", target / "SKILL.md")
+        if (master_skill / "references").exists():
+            shutil.copytree(master_skill / "references", target / "references", dirs_exist_ok=True)
+        if (master_skill / "scripts").exists():
+            shutil.copytree(master_skill / "scripts", target / "scripts", dirs_exist_ok=True)
+        installed.append("GitHub Copilot")
+    
+    def install_claude():
+        target = project / ".claude" / "skills" / name
+        target.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(master_skill, target, dirs_exist_ok=True)
+        installed.append("Claude Code")
+    
+    def install_cursor():
+        target = project / ".cursor" / "skills" / name
+        target.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(master_skill, target, dirs_exist_ok=True)
+        installed.append("Cursor")
+    
+    # Install
+    if tool:
+        tool = tool.lower()
+        if tool in ("copilot", "github", "all"):
+            install_copilot()
+        if tool in ("claude", "all"):
+            install_claude()
+        if tool in ("cursor", "all"):
+            install_cursor()
+    else:
+        detected = False
+        if (project / ".github").exists():
+            install_copilot()
+            detected = True
+        if (project / ".claude").exists():
+            install_claude()
+            detected = True
+        if (project / ".cursor").exists():
+            install_cursor()
+            detected = True
+        if not detected:
+            install_copilot()
+    
+    # Track
+    proj_key = str(project)
+    if proj_key not in config.get("installed_projects", {}):
+        config["installed_projects"][proj_key] = []
+    if name not in config["installed_projects"][proj_key]:
+        config["installed_projects"][proj_key].append(name)
+    save_config(config)
+    
+    typer.echo(f"✅ Installed '{name}' in {project.name}/")
+    for loc in installed:
+        typer.echo(f"   → {loc}")
+
+
+@app.command("list")
+def list_skills():
+    """Show all your skills."""
+    config = load_config()
+    skills_path = Path(config["skills_path"])
+    skills = [f for f in skills_path.iterdir() if f.is_dir()]
+    
+    if not skills:
+        typer.echo("📭 No skills yet! Create one: agentskill create my-rules")
+        return
+    
+    typer.echo(f"\n📚 Skills:\n")
+    for skill_dir in sorted(skills):
+        yaml_file = skill_dir / "skill.yaml"
+        if yaml_file.exists():
+            content = yaml_file.read_text()
+            lang = framework = ""
+            for line in content.split("\n"):
+                if line.startswith("language:"):
+                    lang = line.split(":")[1].strip()
+                if line.startswith("framework:"):
+                    framework = line.split(":")[1].strip()
+            typer.echo(f"  • {skill_dir.name}  [{lang}/{framework}]")
+        else:
+            typer.echo(f"  • {skill_dir.name}")
+
+
+@app.command()
+def update(name: str):
+    """Update skill in all installed projects."""
+    config = load_config()
+    count = 0
+    
+    for proj_path, skills in list(config.get("installed_projects", {}).items()):
+        if isinstance(skills, list) and name in skills and Path(proj_path).exists():
+            old_cwd = os.getcwd()
+            os.chdir(proj_path)
+            install(name)
+            os.chdir(old_cwd)
+            count += 1
+    
+    if count == 0:
+        typer.echo(f"⚠️  '{name}' not installed anywhere.")
+    else:
+        typer.echo(f"✅ Updated in {count} project(s)")
+
+
+@app.command()
+def show(name: str):
+    """Show skill details."""
+    skill_dir = get_skill_path(name)
+    if not skill_dir.exists():
+        typer.echo(f"❌ Skill '{name}' not found!")
+        raise typer.Exit(1)
+    
+    typer.echo(f"\n📋 {name}")
+    typer.echo(f"📁 {skill_dir}\n")
+    
+    skill_md = skill_dir / "SKILL.md"
+    if skill_md.exists():
+        lines = skill_md.read_text().split("\n")[:20]
+        typer.echo("\n".join(lines))
+
+
+@app.command()
+def edit(name: str):
+    """Open skill in editor."""
+    skill_dir = get_skill_path(name)
+    if not skill_dir.exists():
+        typer.echo(f"❌ Skill '{name}' not found!")
+        raise typer.Exit(1)
+    
+    import subprocess
+    for editor in ["code", "cursor", "subl", "nano", "vim"]:
+        try:
+            subprocess.run([editor, str(skill_dir / "SKILL.md")], check=True)
+            return
+        except:
+            continue
+    typer.echo(f"📝 Edit: {skill_dir / 'SKILL.md'}")
+
+
+@app.command()
+def delete(name: str, force: bool = typer.Option(False, "--force", "-f")):
+    """Delete a skill."""
+    skill_dir = get_skill_path(name)
+    if not skill_dir.exists():
+        typer.echo(f"❌ Skill '{name}' not found!")
+        raise typer.Exit(1)
+    
+    if not force and not typer.confirm(f"Delete '{name}'?"):
+        raise typer.Exit()
+    
+    shutil.rmtree(skill_dir)
+    typer.echo(f"🗑️  Deleted '{name}'")
+
+
+@app.command()
+def export(name: str, output: str = typer.Option(".", help="Output folder")):
+    """Export skill as zip."""
+    skill_dir = get_skill_path(name)
+    if not skill_dir.exists():
+        typer.echo(f"❌ Skill '{name}' not found!")
+        raise typer.Exit(1)
+    
+    zip_path = Path(output).resolve() / f"{name}.skill.zip"
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for file in skill_dir.rglob("*"):
+            if file.is_file():
+                zf.write(file, file.relative_to(skill_dir.parent))
+    typer.echo(f"📦 {zip_path}")
+
+
+@app.command("import")
+def import_skill(zip_path: str):
+    """Import skill from zip."""
+    config = load_config()
+    zip_file = Path(zip_path).resolve()
+    if not zip_file.exists():
+        typer.echo(f"❌ Not found: {zip_path}")
+        raise typer.Exit(1)
+    
+    with zipfile.ZipFile(zip_file, "r") as zf:
+        zf.extractall(config["skills_path"])
+    typer.echo("✅ Imported!")
+
+
+@app.command()
+def init():
+    """Initialize AI folders in current project."""
+    project = find_project_root()
+    (project / ".github" / "skills").mkdir(parents=True, exist_ok=True)
+    (project / ".github" / "instructions").mkdir(parents=True, exist_ok=True)
+    typer.echo(f"✅ Created .github/ in {project.name}/")
+
+
+@app.command()
+def where():
+    """Show skills storage location."""
+    config = load_config()
+    typer.echo(f"📁 {config['skills_path']}")
+
+
+if __name__ == "__main__":
+    app()

agentskill_cli-1.0.0/agentskill_cli.egg-info/PKG-INFO

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: agentskill-cli
+Version: 1.0.0
+Summary: Universal AI Skill Manager for GitHub Copilot, Claude, Cursor
+Author: Parth
+License: MIT
+Keywords: ai,copilot,claude,cursor,skills,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+
+# AgentSkill 🛠️
+
+**Universal AI Skill Manager** — Manage skills for GitHub Copilot, Claude Code, Cursor, and more.
+
+## Features
+
+- ✅ **Zero Config**: No setup needed, just install and use
+- ✅ **Multi-AI Support**: GitHub Copilot, Claude Code, Cursor
+- ✅ **Any Language**: Python, JavaScript, Go, Rust, Dart, etc.
+- ✅ **Framework Templates**: React, Django, FastAPI, Flutter, Gin, etc.
+- ✅ **One Command Install**: Auto-detects AI tools in project
+- ✅ **Sync Updates**: Update skill → all projects sync automatically
+
+## Installation (One Time)
+
+```bash
+cd /path/to/Agent_Skill
+pip install -e .
+```
+
+That's it! Now `agentskill` command works globally.
+
+## Quick Start
+
+```bash
+# Create a skill (auto-stored in ~/.agentskill/skills/)
+agentskill create react-rules -l javascript -f react
+
+# Go to any project and install
+cd /your/react-project
+agentskill install react-rules
+
+# Done! AI will follow your rules
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `create <name>` | Create new skill |
+| `install <name>` | Install in current project |
+| `list` | Show all skills |
+| `show <name>` | View skill details |
+| `edit <name>` | Open in editor |
+| `update <name>` | Sync to all projects |
+| `delete <name>` | Remove skill |
+| `export <name>` | Export as zip |
+| `import <zip>` | Import from zip |
+| `init` | Create AI folders |
+| `where` | Show storage location |
+
+**Shortcut**: Use `ask` instead of `agentskill`
+
+## Creating Skills
+
+### Basic
+
+```bash
+agentskill create my-rules
+```
+
+### With Language & Framework
+
+```bash
+# React skill
+agentskill create react-component -l javascript -f react
+
+# Django skill
+agentskill create django-api -l python -f django
+
+# Flutter skill
+agentskill create flutter-widget -l dart -f flutter
+
+# Go API skill
+agentskill create go-api -l go -f gin
+```
+
+### Supported Templates
+
+| Language | Frameworks |
+|----------|------------|
+| Python | django, fastapi, flask |
+| JavaScript | react, nextjs, node |
+| Dart | flutter |
+| Go | gin, fiber |
+| Rust | actix, axum |
+
+## Installing Skills
+
+### Auto-detect (recommended)
+
+```bash
+cd /path/to/project
+agentskill install my-skill
+```
+
+Auto-detects `.github/`, `.claude/`, `.cursor/` folders.
+
+### Specific Tool
+
+```bash
+# GitHub Copilot only
+agentskill install my-skill -t copilot
+
+# Claude only
+agentskill install my-skill -t claude
+
+# All tools
+agentskill install my-skill -t all
+```
+
+## Skill Structure
+
+```
+my-skill/
+├── SKILL.md          # Main instructions (Copilot format)
+├── skill.yaml        # SkillForge metadata
+├── instructions.md   # Legacy format
+├── scripts/          # Helper scripts
+├── references/       # Additional docs
+└── assets/           # Templates, boilerplate
+```
+
+## Editing Skills
+
+```bash
+# Open in editor (VS Code, Cursor, etc.)
+agentskill edit my-skill
+
+# Or show details first
+agentskill show my-skill
+```
+
+After editing, update all projects:
+```bash
+agentskill update my-skill
+```
+
+## Sharing Skills
+
+```bash
+# Export
+agentskill export my-skill
+
+# Import
+agentskill import my-skill.skill.zip
+```
+
+## How It Works
+
+1. **Skills are stored** in `~/.agentskill/skills/` (automatic)
+2. **Install copies** skill to your project's AI folder
+3. **AI reads** the SKILL.md when you code
+
+```
+~/.agentskill/skills/          Your Projects
+┌────────────────────┐         ┌─────────────────┐
+│ react-rules/       │         │ my-react-app/   │
+│   └── SKILL.md     │──copy──▶│   └── .github/  │
+│ django-api/        │         │       └── skills│
+│   └── SKILL.md     │         │           └── react-rules/
+└────────────────────┘         └─────────────────┘
+```
+
+## Tips
+
+- Keep SKILL.md under 500 lines
+- Use `references/` for detailed docs
+- Add code examples in `references/examples.md`
+- Use specific trigger words in descriptions
+
+## License
+
+MIT

agentskill_cli-1.0.0/agentskill_cli.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+agentskill.py
+pyproject.toml
+agentskill_cli.egg-info/PKG-INFO
+agentskill_cli.egg-info/SOURCES.txt
+agentskill_cli.egg-info/dependency_links.txt
+agentskill_cli.egg-info/entry_points.txt
+agentskill_cli.egg-info/requires.txt
+agentskill_cli.egg-info/top_level.txt

agentskill_cli-1.0.0/agentskill_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentskill_cli-1.0.0/agentskill_cli.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+agentskill = agentskill:app
+ask = agentskill:app

agentskill_cli-1.0.0/agentskill_cli.egg-info/requires.txt

@@ -0,0 +1 @@
+typer>=0.9.0

agentskill_cli-1.0.0/agentskill_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+agentskill

agentskill_cli-1.0.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agentskill-cli"
+version = "1.0.0"
+description = "Universal AI Skill Manager for GitHub Copilot, Claude, Cursor"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Parth"}
+]
+keywords = ["ai", "copilot", "claude", "cursor", "skills", "cli"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development",
+]
+dependencies = [
+    "typer>=0.9.0",
+]
+
+[project.scripts]
+agentskill = "agentskill:app"
+ask = "agentskill:app"
+
+[tool.setuptools]
+py-modules = ["agentskill"]

agentskill_cli-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+