refactor skills install flow and site messaging

Author: zjy365

.github/workflows/deploy-site.yml

@@ -5,7 +5,6 @@ on:
     branches: [main]
     paths:
       - 'skills/**'
-      - 'install.sh'
       - 'site/**'
 
 jobs:
@@ -18,9 +17,6 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Package skills
-        run: chmod +x package.sh && ./package.sh
-
       - uses: docker/login-action@v3
         with:
           registry: ghcr.io
@@ -33,5 +29,4 @@ jobs:
           push: true
           tags: |
             ghcr.io/${{ github.repository }}-site:latest
-            ghcr.io/${{ github.repository }}-site:v${{ env.VERSION }}
             ghcr.io/${{ github.repository }}-site:sha-${{ github.sha }}

AGENTS.md

@@ -0,0 +1,65 @@
+# AGENTS.md
+
+This file provides guidance to Codex (Codex.ai/code) when working with code in this repository.
+
+## What This Project Is
+
+Seakills is a skills repository for Sealos Cloud in the `skills.sh` ecosystem. The project has two main parts: the **skills** (markdown-based modules + Node.js scripts) and a **landing site** (Next.js).
+
+## Commands
+
+### Site development (run from `site/`)
+```bash
+cd site && pnpm install    # install dependencies
+cd site && pnpm dev        # dev server on localhost:3000
+cd site && pnpm build      # production build
+cd site && pnpm lint       # ESLint
+```
+
+### Docker (site)
+```bash
+cd site && docker build -t seakills-site . && docker run -p 3000:3000 seakills-site
+```
+
+### CI
+GitHub Actions (`.github/workflows/deploy-site.yml`) triggers on push to `main` when `skills/**` or `site/**` change. It builds and pushes a Docker image to `ghcr.io/zjy365/seakills-site`.
+
+## Architecture
+
+### Skill dependency graph
+```text
+sealos-deploy (user entry point: /sealos-deploy)
+  ├→ cloud-native-readiness   (Phase 1: score 0-12)
+  ├→ dockerfile-skill         (Phase 3: generate Dockerfile)
+  └→ docker-to-sealos         (Phase 5: Compose → Sealos template)
+```
+
+### Skill module pattern
+Each skill follows the same structure:
+- `SKILL.md` — entry point with YAML frontmatter (name, version, allowed-tools, compatibility)
+- `modules/*.md` — phased execution logic (preflight, assess, generate, build, deploy)
+- `scripts/*.mjs` — Node.js executables (auth, scoring, image detection, build)
+- `knowledge/*.md` — error patterns, best practices, scoring criteria
+- `config.json` — runtime config (OAuth, regions)
+
+Skills reference paths with `<SKILL_DIR>` for self and `<SKILL_DIR>/../other-skill/` for siblings.
+
+### Deployment pipeline (sealos-deploy)
+```text
+Preflight → Mode Detection → DEPLOY or UPDATE
+
+DEPLOY: Assess → Detect image → Dockerfile → Build & Push → Template → Deploy
+UPDATE: Build & Push → kubectl set image → Verify rollout (auto-rollback on failure)
+```
+
+Mode detection reads `.sealos/state.json` `last_deploy` field. If a running deployment is found (verified via kubectl), the skill enters UPDATE mode and skips assess/template/deploy phases. If not, it runs the full DEPLOY pipeline.
+
+State is tracked in `.sealos/state.json` (deployment state), `.sealos/analysis.json` (project analysis snapshot), and `.sealos/config.json` (optional user overrides). The `last_deploy` section in `state.json` records app name, namespace, image, and URL so later deploys can update in place instead of starting over.
+
+### Site (`site/`)
+Next.js 16 + React 19 + TypeScript landing page. Uses Radix UI, Tailwind CSS, and Motion for animations. Configured for standalone output.
+
+## Key paths
+- `skills/sealos-deploy/config.json` — OAuth client_id, regional Sealos URLs
+- `site/next.config.mjs` — standalone output, unoptimized images, ignores TS build errors
+- `site/components.json` — shadcn/ui component config with `@/` path alias

CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## What This Project Is
 
-Seakills is an AI agent skills ecosystem for Sealos Cloud. It provides slash-command skills (`/sealos-deploy`, `/cloud-native-readiness`, `/dockerfile`) that work with Claude Code, Gemini CLI, and Codex. The project has two main parts: the **skills** (markdown-based modules + Node.js scripts) and a **landing site** (Next.js).
+Seakills is a skills repository for Sealos Cloud in the `skills.sh` ecosystem. The project has two main parts: the **skills** (markdown-based modules + Node.js scripts) and a **landing site** (Next.js).
 
 ## Commands
 
@@ -16,27 +16,22 @@ cd site && pnpm build      # production build
 cd site && pnpm lint       # ESLint
 ```
 
-### Packaging & distribution (run from repo root)
-```bash
-./package.sh               # package skills/ into tar.gz, copy install.sh to site/public/
-```
-
 ### Docker (site)
 ```bash
 cd site && docker build -t seakills-site . && docker run -p 3000:3000 seakills-site
 ```
 
 ### CI
-GitHub Actions (`.github/workflows/deploy-site.yml`) triggers on push to `main` when `skills/**`, `install.sh`, or `site/**` change. It runs `package.sh`, then builds and pushes a Docker image to `ghcr.io/zjy365/seakills-site`.
+GitHub Actions (`.github/workflows/deploy-site.yml`) triggers on push to `main` when `skills/**` or `site/**` change. It builds and pushes a Docker image to `ghcr.io/zjy365/seakills-site`.
 
 ## Architecture
 
 ### Skill dependency graph
-```
+```text
 sealos-deploy (user entry point: /sealos-deploy)
   ├→ cloud-native-readiness   (Phase 1: score 0-12)
-  ├→ dockerfile-skill          (Phase 3: generate Dockerfile)
-  └→ docker-to-sealos          (Phase 5: Compose → Sealos template)
+  ├→ dockerfile-skill         (Phase 3: generate Dockerfile)
+  └→ docker-to-sealos         (Phase 5: Compose → Sealos template)
 ```
 
 ### Skill module pattern
@@ -50,24 +45,19 @@ Each skill follows the same structure:
 Skills reference paths with `<SKILL_DIR>` for self and `<SKILL_DIR>/../other-skill/` for siblings.
 
 ### Deployment pipeline (sealos-deploy)
-```
+```text
 Preflight → Mode Detection → DEPLOY or UPDATE
 
 DEPLOY: Assess → Detect image → Dockerfile → Build & Push → Template → Deploy
 UPDATE: Build & Push → kubectl set image → Verify rollout (auto-rollback on failure)
 ```
-Mode Detection reads `.sealos/state.json` `last_deploy` field. If a running deployment is found (verified via kubectl), the skill enters UPDATE mode and skips assess/template/deploy phases. If not, it runs the full DEPLOY pipeline.
 
-State is tracked in `.sealos/state.json` (deployment state), `.sealos/analysis.json` (project analysis snapshot), and `.sealos/config.json` (optional user overrides). The `last_deploy` section in `state.json` (written after first deploy) records app_name, namespace, image, and URL — enabling future updates without re-deploying from scratch.
+Mode detection reads `.sealos/state.json` `last_deploy` field. If a running deployment is found (verified via kubectl), the skill enters UPDATE mode and skips assess/template/deploy phases. If not, it runs the full DEPLOY pipeline.
 
-### Installer (`install.sh`)
-Downloads skills from site distribution (with GitHub fallback), installs to `~/.agents/skills/` (canonical), then symlinks to each detected agent's skills directory.
+State is tracked in `.sealos/state.json` (deployment state), `.sealos/analysis.json` (project analysis snapshot), and `.sealos/config.json` (optional user overrides). The `last_deploy` section in `state.json` records app name, namespace, image, and URL so later deploys can update in place instead of starting over.
 
 ### Site (`site/`)
-Next.js 16 + React 19 + TypeScript landing page. Uses Radix UI, Tailwind CSS, and Motion for animations. Configured for standalone output. Serves packaged skill tarballs and the installer from `public/`.
-
-## Version management
-The single source of truth for version is `VERSION="x.y.z"` in `install.sh`. `package.sh` extracts it and exports to `$GITHUB_ENV` for CI tagging.
+Next.js 16 + React 19 + TypeScript landing page. Uses Radix UI, Tailwind CSS, and Motion for animations. Configured for standalone output.
 
 ## Key paths
 - `skills/sealos-deploy/config.json` — OAuth client_id, regional Sealos URLs

README.md

@@ -1,76 +1,162 @@
 # Seakills
 
-AI skills that let you deploy any project to [Sealos Cloud](https://gzg.sealos.run) with a single slash command — right from your AI coding assistant.
+Deploy projects to [Sealos Cloud](https://gzg.sealos.run) from your AI agent.
 
-Works with **Claude Code**, **Gemini CLI**, and **Codex**.
+Seakills is a set of reusable skills for the `skills.sh` ecosystem. It helps an agent understand your project, prepare it for deployment, and ship it to Sealos Cloud with minimal manual setup.
+
+## What You Can Do
+
+With Seakills installed, your agent can:
+
+- Deploy the current project to Sealos Cloud with `/sealos-deploy`
+- Deploy a GitHub repository directly from its URL
+- Check whether a project is cloud-ready before deployment
+- Generate a production-ready Dockerfile for projects that do not have one
+- Convert Docker Compose setups into Sealos-compatible templates
+
+In practice, this means less time wiring infrastructure by hand and more time shipping working apps.
+
+## Why It Is Useful
+
+Seakills turns deployment into an agent workflow instead of a manual checklist.
+
+Instead of doing this yourself:
+
+- inspect the repo
+- decide whether it is container-ready
+- write or fix a Dockerfile
+- build and push an image
+- convert config into a Sealos template
+- deploy and verify rollout
+
+your agent can do it for you through one guided skill flow.
 
 ## Quick Start
 
+Install the skills:
+
 ```bash
-curl -fsSL https://seakills.gzg.sealos.run/install.sh | bash
+npx skills add zjy365/seakills
 ```
 
-Then open your project and run:
+Open your project in your AI agent, then run:
 
-```
+```text
 /sealos-deploy
 ```
 
-That's it. Your project is live on Sealos Cloud.
+That is the fastest path from local code to a running app on Sealos Cloud.
 
-## What You Need
+## Main Skills
 
-Before your first deploy, make sure you have:
+### `/sealos-deploy`
 
-- [ ] **Docker** installed and running
-- [ ] **A Docker Hub account** (the skill will prompt you to log in)
-- [ ] **A [Sealos Cloud](https://gzg.sealos.run) account** (you'll be guided through auth on first run)
-- [ ] **Node.js 18+** (optional — speeds up scoring, image detection, and auth; curl fallback used otherwise)
-- [ ] **Python 3.8+** (optional — enables template validation; AI fallback used otherwise)
-- [ ] **kubectl** (optional — enables in-place updates of running apps)
+Deploy a local project, a path, or a GitHub repository to Sealos Cloud.
 
-## Usage: `/sealos-deploy`
+```text
+/sealos-deploy
+/sealos-deploy /path/to/project
+/sealos-deploy https://github.com/labring-sigs/kite
+```
 
-Deploy any project — local or remote:
+What it handles for you:
 
+- project assessment
+- image detection when an existing image already exists
+- Dockerfile generation when needed
+- image build and push
+- Sealos template generation
+- deployment and rollout verification
+
+### `/cloud-native-readiness`
+
+Check whether a project is ready for cloud-native deployment.
+
+```text
+/cloud-native-readiness
+/cloud-native-readiness /path/to/project
+/cloud-native-readiness https://github.com/example/repo
 ```
-/sealos-deploy                                       # deploy your current project
-/sealos-deploy https://github.com/labring-sigs/kite  # deploy a GitHub repo
-```
 
-### First deploy
+Use it when you want a quick answer to: "Can this app be deployed cleanly?"
+
+### `/dockerfile`
 
-The skill assesses your project, generates a Dockerfile if needed, builds and pushes an image, and deploys to Sealos Cloud:
+Generate or improve a production-ready Dockerfile.
 
+```text
+/dockerfile
+/dockerfile /path/to/project
+/dockerfile https://github.com/example/repo
 ```
+
+Useful when a repo is missing container packaging or the current Dockerfile is not production-ready.
+
+### `/docker-to-sealos`
+
+Convert Docker Compose or installation docs into a Sealos-compatible template.
+
+Use it when you already have a Compose-based app and want to move it into Sealos cleanly.
+
+## What The Deploy Flow Looks Like
+
+On a typical first deploy, the agent will:
+
+1. Check prerequisites such as Docker and account state.
+2. Assess the project structure and runtime needs.
+3. Reuse an existing image if possible, or build one if needed.
+4. Generate the Sealos deployment template.
+5. Deploy and verify the application.
+
+Example output:
+
+```text
 [preflight] ✓ Docker  ✓ git  ✓ Sealos Cloud
-[assess]    Go + net/http → score 10/12, suitable
-[detect]    Found ghcr.io/zxh326/kite:v0.4.0 (amd64) → skip build
+[assess]    Go + net/http -> score 10/12, suitable
+[detect]    Found ghcr.io/zxh326/kite:v0.4.0 (amd64) -> skip build
 [template]  Generated Sealos template
 [deploy]    ✓ Deployed to Sealos Cloud
 ```
 
-### Updating
+For later updates, running `/sealos-deploy` again can trigger an in-place update flow instead of a full redeploy.
 
-Just run `/sealos-deploy` again after changing your code. The skill detects your running deployment, rebuilds the image, and does a rolling update with zero downtime. If the new version fails health checks, it auto-rolls back.
+## What You Need
 
-```
-[detect]    Found existing deployment kite-x8k2m1nq
-[build]     Built & pushed zhujingyang/kite:20260310-143022
-[update]    ✓ Image updated, rollout complete
-```
+Before first use, make sure you have:
+
+- Docker installed and running
+- A Sealos Cloud account
+- A container registry account such as Docker Hub or GHCR access
+
+Optional but helpful:
 
-## First Time Setup
+- Node.js 18+
+- Python 3.8+
+- `kubectl` for in-place update workflows
 
-On your first run, the skill walks you through everything interactively — Docker Hub login, Sealos Cloud auth, and any missing tools. No manual token copy-paste required.
+## Best Fit
 
-## Coming Soon
+Seakills is especially useful if you want to:
+
+- deploy prototypes without hand-writing cloud config
+- let an AI assistant package and ship repos for you
+- evaluate whether a project is ready for containerized deployment
+- standardize deployment workflows across different coding agents
+- move from Docker Compose toward a Sealos-native deployment path
+
+## Repository Structure
+
+```text
+skills/
+  sealos-deploy/
+  cloud-native-readiness/
+  dockerfile-skill/
+  docker-to-sealos/
+site/
+```
 
-| Skill | What it does |
-|-------|-------------|
-| `/database` | Provision and manage databases (PostgreSQL, MySQL, MongoDB, Redis) |
-| `/objectstorage` | Create and manage object storage buckets |
-| More | Every Sealos Cloud capability as an agent skill |
+- `skills/` contains the actual agent skills
+- `site/` contains the landing page and documentation site
 
 ## License