@chc880/everything-antigravity 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 NeoChen
+
+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,54 @@
+# Everything Antigravity
+
+> 从 [Everything Claude Code](https://github.com/affaan-m/everything-claude-code) 提取核心价值，为 Antigravity 原生重写的最佳实践合集。
+
+## 快速开始
+
+```bash
+# 1. 全局安装
+npm install -g @chc880/everything-antigravity
+
+# 2. 进入你的项目，初始化
+cd your-project
+ea init
+```
+
+就这么简单。26 个 Skills + 11 个 Workflows + 18 条 Rules 一步到位。
+
+## 命令
+
+```bash
+ea init                 # 安装全部到当前项目
+ea init --lang ts       # 仅 TypeScript 规则
+ea init --lang python   # 仅 Python 规则
+ea init --lang golang   # 仅 Go 规则
+ea status               # 查看安装状态
+ea uninstall            # 卸载（自动备份）
+ea help                 # 帮助
+```
+
+## 与 ECC 的区别
+
+| | ECC (Claude Code) | EA (Antigravity) |
+|---|---|---|
+| 安装 | 克隆仓库 + bash | **`npm i -g` + `ea init`** |
+| 路径 | `~/.claude/` | `.agent/` |
+| Hooks | JS hooks 脚本 | **编辑后操作提醒** |
+| Rules | 无 frontmatter | `trigger: glob/model_decision` |
+| 持久记忆 | 无 | **Knowledge Items** |
+| 安全 | 手动 | **Strict/Sandbox Mode** |
+
+## 安装了什么
+
+### Skills (26)
+TDD · 安全审查 · 编码标准 · 前后端模式 · Python/Django · Go · Spring Boot/JPA · PostgreSQL/ClickHouse · Agent Guides · ⭐ Knowledge Management · ⭐ Security Hardening
+
+### Workflows (11)
+`/plan` ⭐ · `/verify` ⭐ · `/tdd` · `/code-review` · `/e2e` · `/build-fix` · `/go-build` · `/go-review` · `/go-test` · `/python-review` · `/setup-pm`
+
+### Rules (18)
+6 通用 (`model_decision`) + 4 TypeScript + 4 Python + 4 Go (`glob` 按需激活)
+
+## 许可
+
+MIT

package/assets/rules/common/coding-style.md

@@ -0,0 +1,53 @@
+---
+trigger: model_decision
+description: Coding style rules: immutability, file organization, naming conventions.
+---
+
+# Coding Style
+
+## Immutability (CRITICAL)
+
+ALWAYS create new objects, NEVER mutate existing ones:
+
+```
+// Pseudocode
+WRONG:  modify(original, field, value) → changes original in-place
+CORRECT: update(original, field, value) → returns new copy with change
+```
+
+Rationale: Immutable data prevents hidden side effects, makes debugging easier, and enables safe concurrency.
+
+## File Organization
+
+MANY SMALL FILES > FEW LARGE FILES:
+- High cohesion, low coupling
+- 200-400 lines typical, 800 max
+- Extract utilities from large modules
+- Organize by feature/domain, not by type
+
+## Error Handling
+
+ALWAYS handle errors comprehensively:
+- Handle errors explicitly at every level
+- Provide user-friendly error messages in UI-facing code
+- Log detailed error context on the server side
+- Never silently swallow errors
+
+## Input Validation
+
+ALWAYS validate at system boundaries:
+- Validate all user input before processing
+- Use schema-based validation where available
+- Fail fast with clear error messages
+- Never trust external data (API responses, user input, file content)
+
+## Code Quality Checklist
+
+Before marking work complete:
+- [ ] Code is readable and well-named
+- [ ] Functions are small (<50 lines)
+- [ ] Files are focused (<800 lines)
+- [ ] No deep nesting (>4 levels)
+- [ ] Proper error handling
+- [ ] No hardcoded values (use constants or config)
+- [ ] No mutation (immutable patterns used)

package/assets/rules/common/git-workflow.md

@@ -0,0 +1,47 @@
+---
+trigger: model_decision
+description: Git commit message format, branch naming, and PR process.
+---
+
+# Git Workflow
+
+## Commit Message Format
+
+```
+<type>: <description>
+
+<optional body>
+```
+
+Types: feat, fix, refactor, docs, test, chore, perf, ci
+
+## Pull Request Workflow
+
+When creating PRs:
+1. Analyze full commit history (not just latest commit)
+2. Use `git diff [base-branch]...HEAD` to see all changes
+3. Draft comprehensive PR summary
+4. Include test plan with TODOs
+5. Push with `-u` flag if new branch
+
+## Feature Implementation Workflow
+
+1. **Plan First**
+   - Create implementation plan before writing code
+   - Identify dependencies and risks
+   - Break down into phases
+
+2. **TDD Approach**
+   - Write tests first (RED)
+   - Implement to pass tests (GREEN)
+   - Refactor (IMPROVE)
+   - Verify 80%+ coverage
+
+3. **Code Review**
+   - Review code immediately after writing
+   - Address CRITICAL and HIGH issues
+   - Fix MEDIUM issues when possible
+
+4. **Commit & Push**
+   - Detailed commit messages
+   - Follow conventional commits format

package/assets/rules/common/patterns.md

@@ -0,0 +1,36 @@
+---
+trigger: model_decision
+description: Design patterns, skeleton projects, and code organization.
+---
+
+# Common Patterns
+
+## Skeleton Projects
+
+When implementing new functionality:
+1. Search for battle-tested skeleton projects
+2. Evaluate options across multiple dimensions:
+   - Security assessment
+   - Extensibility analysis
+   - Relevance scoring
+   - Implementation planning
+3. Clone best match as foundation
+4. Iterate within proven structure
+
+## Design Patterns
+
+### Repository Pattern
+
+Encapsulate data access behind a consistent interface:
+- Define standard operations: findAll, findById, create, update, delete
+- Concrete implementations handle storage details (database, API, file, etc.)
+- Business logic depends on the abstract interface, not the storage mechanism
+- Enables easy swapping of data sources and simplifies testing with mocks
+
+### API Response Format
+
+Use a consistent envelope for all API responses:
+- Include a success/status indicator
+- Include the data payload (nullable on error)
+- Include an error message field (nullable on success)
+- Include metadata for paginated responses (total, page, limit)

package/assets/rules/common/performance.md

@@ -0,0 +1,21 @@
+---
+trigger: model_decision
+description: Performance optimization, context management, and build troubleshooting.
+---
+
+# Performance Optimization
+
+## Context Management
+
+Keep context window lean to maximize quality:
+- Break large tasks into smaller, focused sub-tasks
+- Avoid loading all files at once; load only relevant code
+- Periodically summarize progress in comments or task lists
+
+## Build Troubleshooting
+
+If build fails:
+1. Analyze error messages carefully
+2. Fix incrementally (one error at a time)
+3. Verify after each fix
+4. Check for cascading errors that resolve themselves

package/assets/rules/common/security.md

@@ -0,0 +1,34 @@
+---
+trigger: model_decision
+description: Mandatory security checks: authentication, input validation, API security.
+---
+
+# Security Guidelines
+
+## Mandatory Security Checks
+
+Before ANY commit:
+- [ ] No hardcoded secrets (API keys, passwords, tokens)
+- [ ] All user inputs validated
+- [ ] SQL injection prevention (parameterized queries)
+- [ ] XSS prevention (sanitized HTML)
+- [ ] CSRF protection enabled
+- [ ] Authentication/authorization verified
+- [ ] Rate limiting on all endpoints
+- [ ] Error messages don't leak sensitive data
+
+## Secret Management
+
+- NEVER hardcode secrets in source code
+- ALWAYS use environment variables or a secret manager
+- Validate that required secrets are present at startup
+- Rotate any secrets that may have been exposed
+
+## Security Response Protocol
+
+If security issue found:
+1. STOP immediately
+2. Conduct thorough security review
+3. Fix CRITICAL issues before continuing
+4. Rotate any exposed secrets
+5. Review entire codebase for similar issues

package/assets/rules/common/testing.md

@@ -0,0 +1,29 @@
+---
+trigger: model_decision
+description: Testing requirements: TDD methodology, 80% minimum coverage.
+---
+
+# Testing Requirements
+
+## Minimum Test Coverage: 80%
+
+Test Types (ALL required):
+1. **Unit Tests** - Individual functions, utilities, components
+2. **Integration Tests** - API endpoints, database operations
+3. **E2E Tests** - Critical user flows (framework chosen per language)
+
+## Test-Driven Development
+
+MANDATORY workflow:
+1. Write test first (RED)
+2. Run test - it should FAIL
+3. Write minimal implementation (GREEN)
+4. Run test - it should PASS
+5. Refactor (IMPROVE)
+6. Verify coverage (80%+)
+
+## Troubleshooting Test Failures
+
+1. Check test isolation
+2. Verify mocks are correct
+3. Fix implementation, not tests (unless tests are wrong)

package/assets/rules/golang/coding-style.md

@@ -0,0 +1,40 @@
+---
+trigger: glob
+globs: "**/*.go"
+---
+
+# Go Coding Style
+
+> Extends common coding-style with Go specific content.
+
+## Formatting
+
+- **gofmt** and **goimports** are mandatory — no style debates
+
+## Design Principles
+
+- Accept interfaces, return structs
+- Keep interfaces small (1-3 methods)
+
+## Error Handling
+
+Always wrap errors with context:
+
+```go
+if err != nil {
+    return fmt.Errorf("failed to create user: %w", err)
+}
+```
+
+## 编辑后操作（替代 Hooks）
+
+编辑 Go 文件后，应主动执行以下检查：
+
+1. **格式化**: `gofmt -w {file}` 或 `goimports -w {file}`
+2. **静态分析**: `go vet ./...`
+3. **扩展检查**: `staticcheck ./...`（如已安装）
+4. **检查残留**: 确认没有 `fmt.Println` 调试输出残留
+
+## Reference
+
+See skill: `golang-patterns` for comprehensive Go idioms and patterns.

package/assets/rules/golang/patterns.md

@@ -0,0 +1,44 @@
+---
+trigger: glob
+globs: "**/*.go"
+---
+
+# Go Patterns
+
+> Extends common patterns with Go specific content.
+
+## Functional Options
+
+```go
+type Option func(*Server)
+
+func WithPort(port int) Option {
+    return func(s *Server) { s.port = port }
+}
+
+func NewServer(opts ...Option) *Server {
+    s := &Server{port: 8080}
+    for _, opt := range opts {
+        opt(s)
+    }
+    return s
+}
+```
+
+## Small Interfaces
+
+Define interfaces where they are used, not where they are implemented.
+
+## Dependency Injection
+
+Use constructor functions to inject dependencies:
+
+```go
+func NewUserService(repo UserRepository, logger Logger) *UserService {
+    return &UserService{repo: repo, logger: logger}
+}
+```
+
+## Reference
+
+See skill: `golang-patterns` for comprehensive Go patterns including concurrency, error handling, and package organization.

package/assets/rules/golang/security.md

@@ -0,0 +1,33 @@
+---
+trigger: glob
+globs: "**/*.go"
+---
+
+# Go Security
+
+> Extends common security with Go specific content.
+
+## Secret Management
+
+```go
+apiKey := os.Getenv("OPENAI_API_KEY")
+if apiKey == "" {
+    log.Fatal("OPENAI_API_KEY not configured")
+}
+```
+
+## Security Scanning
+
+- Use **gosec** for static security analysis:
+  ```bash
+  gosec ./...
+  ```
+
+## Context & Timeouts
+
+Always use `context.Context` for timeout control:
+
+```go
+ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+defer cancel()
+```

package/assets/rules/golang/testing.md

@@ -0,0 +1,30 @@
+---
+trigger: glob
+globs: "**/*.go"
+---
+
+# Go Testing
+
+> Extends common testing with Go specific content.
+
+## Framework
+
+Use the standard `go test` with **table-driven tests**.
+
+## Race Detection
+
+Always run with the `-race` flag:
+
+```bash
+go test -race ./...
+```
+
+## Coverage
+
+```bash
+go test -cover ./...
+```
+
+## Reference
+
+See skill: `golang-testing` for detailed Go testing patterns and helpers.

package/assets/rules/python/coding-style.md

@@ -0,0 +1,52 @@
+---
+trigger: glob
+globs: "**/*.py, **/*.pyi"
+---
+
+# Python Coding Style
+
+> Extends common coding-style with Python specific content.
+
+## Standards
+
+- Follow **PEP 8** conventions
+- Use **type annotations** on all function signatures
+
+## Immutability
+
+Prefer immutable data structures:
+
+```python
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class User:
+    name: str
+    email: str
+
+from typing import NamedTuple
+
+class Point(NamedTuple):
+    x: float
+    y: float
+```
+
+## Formatting
+
+- **black** for code formatting
+- **isort** for import sorting
+- **ruff** for linting
+
+## 编辑后操作（替代 Hooks）
+
+编辑 Python 文件后，应主动执行以下检查：
+
+1. **格式化**: `black {file}`
+2. **Lint**: `ruff check {file} --fix`
+3. **Import 排序**: `isort {file}`
+4. **类型检查**: `mypy {file}`（如果项目使用 mypy）
+5. **检查残留**: 确认没有 `print()` 残留（应使用 `logging` 模块）
+
+## Reference
+
+See skill: `python-patterns` for comprehensive Python idioms and patterns.

package/assets/rules/python/patterns.md

@@ -0,0 +1,39 @@
+---
+trigger: glob
+globs: "**/*.py, **/*.pyi"
+---
+
+# Python Patterns
+
+> Extends common patterns with Python specific content.
+
+## Protocol (Duck Typing)
+
+```python
+from typing import Protocol
+
+class Repository(Protocol):
+    def find_by_id(self, id: str) -> dict | None: ...
+    def save(self, entity: dict) -> dict: ...
+```
+
+## Dataclasses as DTOs
+
+```python
+from dataclasses import dataclass
+
+@dataclass
+class CreateUserRequest:
+    name: str
+    email: str
+    age: int | None = None
+```
+
+## Context Managers & Generators
+
+- Use context managers (`with` statement) for resource management
+- Use generators for lazy evaluation and memory-efficient iteration
+
+## Reference
+
+See skill: `python-patterns` for comprehensive patterns including decorators, concurrency, and package organization.

package/assets/rules/python/security.md

@@ -0,0 +1,30 @@
+---
+trigger: glob
+globs: "**/*.py, **/*.pyi"
+---
+
+# Python Security
+
+> Extends common security with Python specific content.
+
+## Secret Management
+
+```python
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+api_key = os.environ["OPENAI_API_KEY"]  # Raises KeyError if missing
+```
+
+## Security Scanning
+
+- Use **bandit** for static security analysis:
+  ```bash
+  bandit -r src/
+  ```
+
+## Reference
+
+See skill: `django-security` for Django-specific security guidelines (if applicable).

package/assets/rules/python/testing.md

@@ -0,0 +1,38 @@
+---
+trigger: glob
+globs: "**/*.py, **/*.pyi"
+---
+
+# Python Testing
+
+> Extends common testing with Python specific content.
+
+## Framework
+
+Use **pytest** as the testing framework.
+
+## Coverage
+
+```bash
+pytest --cov=src --cov-report=term-missing
+```
+
+## Test Organization
+
+Use `pytest.mark` for test categorization:
+
+```python
+import pytest
+
+@pytest.mark.unit
+def test_calculate_total():
+    ...
+
+@pytest.mark.integration
+def test_database_connection():
+    ...
+```
+
+## Reference
+
+See skill: `python-testing` for detailed pytest patterns and fixtures.

package/assets/rules/typescript/coding-style.md

@@ -0,0 +1,44 @@
+---
+trigger: glob
+globs: "**/*.ts, **/*.tsx, **/*.js, **/*.jsx"
+---
+
+# TypeScript/JavaScript Coding Style
+
+> Extends common coding-style with TypeScript/JavaScript specific content.
+
+## Standards
+
+- Use **strict mode** TypeScript (`strict: true` in tsconfig)
+- Prefer `const` over `let`, avoid `var`
+- Use template literals over string concatenation
+
+## Immutability
+
+Use `readonly` and `Readonly<T>` for immutable data:
+
+```typescript
+interface User {
+  readonly id: string
+  readonly name: string
+}
+
+function updateUser(user: Readonly<User>, changes: Partial<User>): User {
+  return { ...user, ...changes }
+}
+```
+
+## Formatting
+
+- **Prettier** for code formatting
+- **ESLint** for linting
+- Consistent import ordering (external → internal → relative)
+
+## 编辑后操作（替代 Hooks）
+
+编辑 TypeScript/JavaScript 文件后，应主动执行以下检查：
+
+1. **格式化**: `npx prettier --write {file}`
+2. **类型检查**: `npx tsc --noEmit`（仅 `.ts`/`.tsx` 文件）
+3. **Lint**: `npx eslint {file}`
+4. **检查残留**: 确认没有 `console.log` 残留在生产代码中