axiom-coding-agent-setup 1.0.1 → 1.0.2

package/.agents/skills/fastapi-templates/SKILL.md

@@ -0,0 +1,540 @@
+---
+name: fastapi-templates
+description: Create production-ready FastAPI projects with async patterns, dependency injection, and comprehensive error handling. Use when building new FastAPI applications or setting up backend API projects.
+---
+
+# FastAPI Project Templates
+
+Production-ready FastAPI project structures with async patterns, dependency injection, middleware, and best practices for building high-performance APIs.
+
+## When to Use This Skill
+
+- Starting new FastAPI projects from scratch
+- Implementing async REST APIs with Python
+- Building high-performance web services and microservices
+- Creating async applications with PostgreSQL, MongoDB
+- Setting up API projects with proper structure and testing
+
+## Core Concepts
+
+### 1. Project Structure
+
+**Recommended Layout:**
+
+```
+app/
+├── api/                    # API routes
+│   ├── v1/
+│   │   ├── endpoints/
+│   │   │   ├── users.py
+│   │   │   ├── auth.py
+│   │   │   └── items.py
+│   │   └── router.py
+│   └── dependencies.py     # Shared dependencies
+├── core/                   # Core configuration
+│   ├── config.py
+│   ├── security.py
+│   └── database.py
+├── models/                 # Database models
+│   ├── user.py
+│   └── item.py
+├── schemas/                # Pydantic schemas
+│   ├── user.py
+│   └── item.py
+├── services/               # Business logic
+│   ├── user_service.py
+│   └── auth_service.py
+├── repositories/           # Data access
+│   ├── user_repository.py
+│   └── item_repository.py
+└── main.py                 # Application entry
+```
+
+### 2. Dependency Injection
+
+FastAPI's built-in DI system using `Depends`:
+
+- Database session management
+- Authentication/authorization
+- Shared business logic
+- Configuration injection
+
+### 3. Async Patterns
+
+Proper async/await usage:
+
+- Async route handlers
+- Async database operations
+- Async background tasks
+- Async middleware
+
+## Implementation Patterns
+
+### Pattern 1: Complete FastAPI Application
+
+```python
+# main.py
+from fastapi import FastAPI, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan events."""
+    # Startup
+    await database.connect()
+    yield
+    # Shutdown
+    await database.disconnect()
+
+app = FastAPI(
+    title="API Template",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+from app.api.v1.router import api_router
+app.include_router(api_router, prefix="/api/v1")
+
+# core/config.py
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+
+class Settings(BaseSettings):
+    """Application settings."""
+    DATABASE_URL: str
+    SECRET_KEY: str
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+    API_V1_STR: str = "/api/v1"
+
+    class Config:
+        env_file = ".env"
+
+@lru_cache()
+def get_settings() -> Settings:
+    return Settings()
+
+# core/database.py
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from app.core.config import get_settings
+
+settings = get_settings()
+
+engine = create_async_engine(
+    settings.DATABASE_URL,
+    echo=True,
+    future=True
+)
+
+AsyncSessionLocal = sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False
+)
+
+Base = declarative_base()
+
+async def get_db() -> AsyncSession:
+    """Dependency for database session."""
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
+```
+
+### Pattern 2: CRUD Repository Pattern
+
+```python
+# repositories/base_repository.py
+from typing import Generic, TypeVar, Type, Optional, List
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from pydantic import BaseModel
+
+ModelType = TypeVar("ModelType")
+CreateSchemaType = TypeVar("CreateSchemaType", bound=BaseModel)
+UpdateSchemaType = TypeVar("UpdateSchemaType", bound=BaseModel)
+
+class BaseRepository(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
+    """Base repository for CRUD operations."""
+
+    def __init__(self, model: Type[ModelType]):
+        self.model = model
+
+    async def get(self, db: AsyncSession, id: int) -> Optional[ModelType]:
+        """Get by ID."""
+        result = await db.execute(
+            select(self.model).where(self.model.id == id)
+        )
+        return result.scalars().first()
+
+    async def get_multi(
+        self,
+        db: AsyncSession,
+        skip: int = 0,
+        limit: int = 100
+    ) -> List[ModelType]:
+        """Get multiple records."""
+        result = await db.execute(
+            select(self.model).offset(skip).limit(limit)
+        )
+        return result.scalars().all()
+
+    async def create(
+        self,
+        db: AsyncSession,
+        obj_in: CreateSchemaType
+    ) -> ModelType:
+        """Create new record."""
+        db_obj = self.model(**obj_in.dict())
+        db.add(db_obj)
+        await db.flush()
+        await db.refresh(db_obj)
+        return db_obj
+
+    async def update(
+        self,
+        db: AsyncSession,
+        db_obj: ModelType,
+        obj_in: UpdateSchemaType
+    ) -> ModelType:
+        """Update record."""
+        update_data = obj_in.dict(exclude_unset=True)
+        for field, value in update_data.items():
+            setattr(db_obj, field, value)
+        await db.flush()
+        await db.refresh(db_obj)
+        return db_obj
+
+    async def delete(self, db: AsyncSession, id: int) -> bool:
+        """Delete record."""
+        obj = await self.get(db, id)
+        if obj:
+            await db.delete(obj)
+            return True
+        return False
+
+# repositories/user_repository.py
+from app.repositories.base_repository import BaseRepository
+from app.models.user import User
+from app.schemas.user import UserCreate, UserUpdate
+
+class UserRepository(BaseRepository[User, UserCreate, UserUpdate]):
+    """User-specific repository."""
+
+    async def get_by_email(self, db: AsyncSession, email: str) -> Optional[User]:
+        """Get user by email."""
+        result = await db.execute(
+            select(User).where(User.email == email)
+        )
+        return result.scalars().first()
+
+    async def is_active(self, db: AsyncSession, user_id: int) -> bool:
+        """Check if user is active."""
+        user = await self.get(db, user_id)
+        return user.is_active if user else False
+
+user_repository = UserRepository(User)
+```
+
+### Pattern 3: Service Layer
+
+```python
+# services/user_service.py
+from typing import Optional
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.repositories.user_repository import user_repository
+from app.schemas.user import UserCreate, UserUpdate, User
+from app.core.security import get_password_hash, verify_password
+
+class UserService:
+    """Business logic for users."""
+
+    def __init__(self):
+        self.repository = user_repository
+
+    async def create_user(
+        self,
+        db: AsyncSession,
+        user_in: UserCreate
+    ) -> User:
+        """Create new user with hashed password."""
+        # Check if email exists
+        existing = await self.repository.get_by_email(db, user_in.email)
+        if existing:
+            raise ValueError("Email already registered")
+
+        # Hash password
+        user_in_dict = user_in.dict()
+        user_in_dict["hashed_password"] = get_password_hash(user_in_dict.pop("password"))
+
+        # Create user
+        user = await self.repository.create(db, UserCreate(**user_in_dict))
+        return user
+
+    async def authenticate(
+        self,
+        db: AsyncSession,
+        email: str,
+        password: str
+    ) -> Optional[User]:
+        """Authenticate user."""
+        user = await self.repository.get_by_email(db, email)
+        if not user:
+            return None
+        if not verify_password(password, user.hashed_password):
+            return None
+        return user
+
+    async def update_user(
+        self,
+        db: AsyncSession,
+        user_id: int,
+        user_in: UserUpdate
+    ) -> Optional[User]:
+        """Update user."""
+        user = await self.repository.get(db, user_id)
+        if not user:
+            return None
+
+        if user_in.password:
+            user_in_dict = user_in.dict(exclude_unset=True)
+            user_in_dict["hashed_password"] = get_password_hash(
+                user_in_dict.pop("password")
+            )
+            user_in = UserUpdate(**user_in_dict)
+
+        return await self.repository.update(db, user, user_in)
+
+user_service = UserService()
+```
+
+### Pattern 4: API Endpoints with Dependencies
+
+```python
+# api/v1/endpoints/users.py
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from typing import List
+
+from app.core.database import get_db
+from app.schemas.user import User, UserCreate, UserUpdate
+from app.services.user_service import user_service
+from app.api.dependencies import get_current_user
+
+router = APIRouter()
+
+@router.post("/", response_model=User, status_code=status.HTTP_201_CREATED)
+async def create_user(
+    user_in: UserCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    """Create new user."""
+    try:
+        user = await user_service.create_user(db, user_in)
+        return user
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.get("/me", response_model=User)
+async def read_current_user(
+    current_user: User = Depends(get_current_user)
+):
+    """Get current user."""
+    return current_user
+
+@router.get("/{user_id}", response_model=User)
+async def read_user(
+    user_id: int,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Get user by ID."""
+    user = await user_service.repository.get(db, user_id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+
+@router.patch("/{user_id}", response_model=User)
+async def update_user(
+    user_id: int,
+    user_in: UserUpdate,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Update user."""
+    if current_user.id != user_id:
+        raise HTTPException(status_code=403, detail="Not authorized")
+
+    user = await user_service.update_user(db, user_id, user_in)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+
+@router.delete("/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_user(
+    user_id: int,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Delete user."""
+    if current_user.id != user_id:
+        raise HTTPException(status_code=403, detail="Not authorized")
+
+    deleted = await user_service.repository.delete(db, user_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail="User not found")
+```
+
+### Pattern 5: Authentication & Authorization
+
+```python
+# core/security.py
+from datetime import datetime, timedelta
+from typing import Optional
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from app.core.config import get_settings
+
+settings = get_settings()
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+ALGORITHM = "HS256"
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    """Create JWT access token."""
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify password against hash."""
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password: str) -> str:
+    """Hash password."""
+    return pwd_context.hash(password)
+
+# api/dependencies.py
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import JWTError, jwt
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.database import get_db
+from app.core.security import ALGORITHM
+from app.core.config import get_settings
+from app.repositories.user_repository import user_repository
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"{settings.API_V1_STR}/auth/login")
+
+async def get_current_user(
+    db: AsyncSession = Depends(get_db),
+    token: str = Depends(oauth2_scheme)
+):
+    """Get current authenticated user."""
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[ALGORITHM])
+        user_id: int = payload.get("sub")
+        if user_id is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+
+    user = await user_repository.get(db, user_id)
+    if user is None:
+        raise credentials_exception
+
+    return user
+```
+
+## Testing
+
+```python
+# tests/conftest.py
+import pytest
+import asyncio
+from httpx import AsyncClient
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+
+from app.main import app
+from app.core.database import get_db, Base
+
+TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"
+
+@pytest.fixture(scope="session")
+def event_loop():
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    yield loop
+    loop.close()
+
+@pytest.fixture
+async def db_session():
+    engine = create_async_engine(TEST_DATABASE_URL, echo=True)
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+    AsyncSessionLocal = sessionmaker(
+        engine, class_=AsyncSession, expire_on_commit=False
+    )
+
+    async with AsyncSessionLocal() as session:
+        yield session
+
+@pytest.fixture
+async def client(db_session):
+    async def override_get_db():
+        yield db_session
+
+    app.dependency_overrides[get_db] = override_get_db
+
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        yield client
+
+# tests/test_users.py
+import pytest
+
+@pytest.mark.asyncio
+async def test_create_user(client):
+    response = await client.post(
+        "/api/v1/users/",
+        json={
+            "email": "test@example.com",
+            "password": "testpass123",
+            "name": "Test User"
+        }
+    )
+    assert response.status_code == 201
+    data = response.json()
+    assert data["email"] == "test@example.com"
+    assert "id" in data
+```

package/.agents/skills/git-commit/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: git-commit
+description: 'Execute git commit with conventional commit message analysis, intelligent staging, and message generation. Use when user asks to commit changes, create a git commit, or mentions "/commit". Supports: (1) Auto-detecting type and scope from changes, (2) Generating conventional commit messages from diff, (3) Interactive commit with optional type/scope/description overrides, (4) Intelligent file staging for logical grouping'
+license: MIT
+allowed-tools: Bash
+---
+
+# Git Commit with Conventional Commits
+
+## Overview
+
+Create standardized, semantic git commits using the Conventional Commits specification. Analyze the actual diff to determine appropriate type, scope, and message.
+
+## Conventional Commit Format
+
+```
+<type>[optional scope]: <description>
+
+[optional body]
+
+[optional footer(s)]
+```
+
+## Commit Types
+
+| Type       | Purpose                        |
+| ---------- | ------------------------------ |
+| `feat`     | New feature                    |
+| `fix`      | Bug fix                        |
+| `docs`     | Documentation only             |
+| `style`    | Formatting/style (no logic)    |
+| `refactor` | Code refactor (no feature/fix) |
+| `perf`     | Performance improvement        |
+| `test`     | Add/update tests               |
+| `build`    | Build system/dependencies      |
+| `ci`       | CI/config changes              |
+| `chore`    | Maintenance/misc               |
+| `revert`   | Revert commit                  |
+
+## Breaking Changes
+
+```
+# Exclamation mark after type/scope
+feat!: remove deprecated endpoint
+
+# BREAKING CHANGE footer
+feat: allow config to extend other configs
+
+BREAKING CHANGE: `extends` key behavior changed
+```
+
+## Workflow
+
+### 1. Analyze Diff
+
+```bash
+# If files are staged, use staged diff
+git diff --staged
+
+# If nothing staged, use working tree diff
+git diff
+
+# Also check status
+git status --porcelain
+```
+
+### 2. Stage Files (if needed)
+
+If nothing is staged or you want to group changes differently:
+
+```bash
+# Stage specific files
+git add path/to/file1 path/to/file2
+
+# Stage by pattern
+git add *.test.*
+git add src/components/*
+
+# Interactive staging
+git add -p
+```
+
+**Never commit secrets** (.env, credentials.json, private keys).
+
+### 3. Generate Commit Message
+
+Analyze the diff to determine:
+
+- **Type**: What kind of change is this?
+- **Scope**: What area/module is affected?
+- **Description**: One-line summary of what changed (present tense, imperative mood, <72 chars)
+
+### 4. Execute Commit
+
+```bash
+# Single line
+git commit -m "<type>[scope]: <description>"
+
+# Multi-line with body/footer
+git commit -m "$(cat <<'EOF'
+<type>[scope]: <description>
+
+<optional body>
+
+<optional footer>
+EOF
+)"
+```
+
+## Best Practices
+
+- One logical change per commit
+- Present tense: "add" not "added"
+- Imperative mood: "fix bug" not "fixes bug"
+- Reference issues: `Closes #123`, `Refs #456`
+- Keep description under 72 characters
+
+## Git Safety Protocol
+
+- NEVER update git config
+- NEVER run destructive commands (--force, hard reset) without explicit request
+- NEVER skip hooks (--no-verify) unless user asks
+- NEVER force push to main/master
+- If commit fails due to hooks, fix and create NEW commit (don't amend)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axiom-coding-agent-setup",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "CLI tool to download AXIOM coding agent setup files into your project",
   "main": "bin/cli.js",
   "bin": {

package/skills-lock.json

@@ -0,0 +1,15 @@
+{
+  "version": 1,
+  "skills": {
+    "fastapi-templates": {
+      "source": "wshobson/agents",
+      "sourceType": "github",
+      "computedHash": "1a5fe66bd2683afd1db9afdf37a25cd8b9195c369c98489333badf0406fc91b3"
+    },
+    "git-commit": {
+      "source": "github/awesome-copilot",
+      "sourceType": "github",
+      "computedHash": "2607fc60629b82b257136dd2a7a373f0a4466c0b49df7746d845d59313c99b21"
+    }
+  }
+}

package/docs/npx-cli-setup-guide.md

@@ -1,318 +0,0 @@
-# npx CLI Package Setup Reference
-
-Quick reference for creating and publishing an npx CLI package that downloads files from a GitHub repository.
-
----
-
-## Overview
-
-This pattern creates a CLI tool that can be run via `npx your-package-name` to download specific files from a GitHub repo into the current project directory.
-
-**Use case**: Distributing coding agent instructions, project templates, config files, etc.
-
----
-
-## Step-by-Step Setup
-
-### 1. Create Project Structure
-
-```
-your-project/
-├── package.json          # npm package configuration
-├── bin/
-│   └── cli.js           # CLI entry point (Node.js script)
-└── README.md            # Documentation
-```
-
-### 2. Configure package.json
-
-```json
-{
-  "name": "your-package-name",
-  "version": "1.0.0",
-  "description": "Description of what this CLI does",
-  "main": "bin/cli.js",
-  "bin": {
-    "your-package-name": "bin/cli.js",
-    "short-alias": "bin/cli.js"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": ["cli", "setup", "scaffold"],
-  "author": "your-github-username",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/username/repo-name.git"
-  },
-  "engines": {
-    "node": ">=14.0.0"
-  }
-}
-```
-
-**Key fields:**
-- `name`: Must be unique on npm (check availability first)
-- `bin`: Maps command names to the CLI script
-- `repository`: Links to your GitHub repo
-
-### 3. Create the CLI Script (bin/cli.js)
-
-Template for downloading files from GitHub raw content:
-
-```javascript
-#!/usr/bin/env node
-
-const https = require('https');
-const fs = require('fs');
-const path = require('path');
-
-const REPO_OWNER = 'your-github-username';
-const REPO_NAME = 'your-repo-name';
-const BRANCH = 'main';
-
-const FILES_TO_DOWNLOAD = [
-  'file1.md',
-  'folder/file2.md',
-  'folder/file3.md'
-];
-
-const GITHUB_RAW_URL = `https://raw.githubusercontent.com/${REPO_OWNER}/${REPO_NAME}/${BRANCH}`;
-
-function downloadFile(filePath) {
-  return new Promise((resolve, reject) => {
-    const url = `${GITHUB_RAW_URL}/${filePath}`;
-    const localPath = path.join(process.cwd(), filePath);
-    const dir = path.dirname(localPath);
-
-    // Create directory if it doesn't exist
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-
-    const file = fs.createWriteStream(localPath);
-    
-    https.get(url, (response) => {
-      if (response.statusCode === 200) {
-        response.pipe(file);
-        file.on('finish', () => {
-          file.close();
-          resolve(filePath);
-        });
-      } else {
-        file.close();
-        if (fs.existsSync(localPath)) fs.unlinkSync(localPath);
-        reject(new Error(`Failed to download ${filePath}: ${response.statusCode}`));
-      }
-    }).on('error', (err) => {
-      if (fs.existsSync(localPath)) fs.unlinkSync(localPath);
-      reject(err);
-    });
-  });
-}
-
-async function main() {
-  console.log('Starting download...\n');
-  
-  for (const file of FILES_TO_DOWNLOAD) {
-    try {
-      process.stdout.write(`Downloading ${file}... `);
-      await downloadFile(file);
-      console.log('✓');
-    } catch (error) {
-      console.log(`✗ (${error.message})`);
-    }
-  }
-  
-  console.log('\nDone!');
-}
-
-main().catch(console.error);
-```
-
-### 4. Test Locally
-
-Before publishing, test the CLI locally:
-
-```bash
-node bin/cli.js
-```
-
-Or link it locally:
-
-```bash
-npm link
-your-package-name    # Test the command
-npm unlink           # Remove local link when done
-```
-
-### 5. Publish to npm
-
-#### First-time setup:
-
-1. **Create npm account**: https://www.npmjs.com/signup
-
-2. **Login from terminal**:
-   ```bash
-   npm login
-   ```
-
-3. **Publish**:
-   ```bash
-   npm publish
-   ```
-
-#### Check if published successfully:
-
-```bash
-npm view your-package-name
-```
-
-Or visit: `https://www.npmjs.com/package/your-package-name`
-
----
-
-## Usage After Publishing
-
-Anyone can now use your CLI (no installation required):
-
-```bash
-npx your-package-name
-```
-
-Or install globally:
-
-```bash
-npm install -g your-package-name
-your-package-name    # Run directly
-```
-
----
-
-## Updating Your Package
-
-### Updating Content Files (the downloaded files)
-
-Since files are downloaded directly from GitHub:
-
-1. Edit files locally
-2. Commit and push:
-   ```bash
-   git add .
-   git commit -m "Update instructions"
-   git push origin main
-   ```
-3. Done! Changes are live immediately (no npm publish needed)
-
-### Updating the CLI Script Itself
-
-If you modify `bin/cli.js` or `package.json`:
-
-1. Update version in `package.json`:
-   ```json
-   "version": "1.0.1"  // Increment version
-   ```
-
-2. Commit and push to GitHub:
-   ```bash
-   git add .
-   git commit -m "Fix download logic"
-   git push origin main
-   ```
-
-3. Republish to npm:
-   ```bash
-   npm publish
-   ```
-
----
-
-## Version Management
-
-npm follows semantic versioning:
-
-| Version change | When to use |
-|----------------|-------------|
-| `1.0.0` → `1.0.1` | Bug fixes (patch) |
-| `1.0.0` → `1.1.0` | New features (minor) |
-| `1.0.0` → `2.0.0` | Breaking changes (major) |
-
-Update manually in `package.json` before republishing.
-
----
-
-## Troubleshooting
-
-### 403 Forbidden when publishing
-- Package name might already exist on npm
-- Try a more unique name (e.g., `@username/package-name` for scoped packages)
-
-### 404 when downloading files
-- Check GitHub repo is public
-- Verify `REPO_OWNER` and `REPO_NAME` match your GitHub URL
-- Ensure files exist on the `main` branch
-
-### Command not found after publishing
-- Wait a few minutes for npm registry to propagate
-- Try `npx your-package-name@latest`
-
-### Local changes not reflected
-- Clear npx cache: `npx clear-npx-cache`
-- Or specify version: `npx your-package-name@1.0.1`
-
----
-
-## Scoped Packages (Optional)
-
-If the package name is taken, use your username as a scope:
-
-```json
-{
-  "name": "@username/package-name"
-}
-```
-
-Publish with:
-```bash
-npm publish --access public
-```
-
-Use with:
-```bash
-npx @username/package-name
-```
-
----
-
-## Quick Checklist
-
-- [ ] Create `package.json` with `bin` entry
-- [ ] Create `bin/cli.js` with shebang (`#!/usr/bin/env node`)
-- [ ] Set correct `REPO_OWNER`, `REPO_NAME`, and `FILES_TO_DOWNLOAD`
-- [ ] Test locally with `node bin/cli.js`
-- [ ] Create npm account
-- [ ] Run `npm login`
-- [ ] Run `npm publish`
-- [ ] Test with `npx your-package-name`
-
----
-
-## Example Commands Reference
-
-```bash
-# Setup
-npm login                                    # Login to npm
-npm publish                                  # Publish package
-npm version patch                            # Bump version (1.0.0 → 1.0.1)
-
-# Maintenance  
-npm view your-package-name                   # Check package info
-npm unpublish your-package-name@version      # Remove specific version
-npm deprecate your-package-name@version      # Deprecate version
-
-# Usage
-npx your-package-name                        # Run via npx
-npx your-package-name@latest                 # Force latest version
-npx clear-npx-cache                          # Clear npx cache
-```