@chc880/everything-antigravity 1.0.0

package/assets/workflows/go-test.md

@@ -0,0 +1,61 @@
+---
+description: Enforce TDD workflow for Go. Write table-driven tests first, then implement. Verify 80%+ coverage with go test -cover.
+---
+
+# Go TDD
+
+Test-driven development workflow for Go.
+
+## Workflow Steps
+
+1. Write table-driven tests first
+2. Run `go test ./...` — verify tests fail
+3. Implement minimal code to pass
+4. Run `go test -race ./...` — verify tests pass
+5. Refactor with tests green
+6. Run `go test -cover ./...` — verify 80%+ coverage
+
+## Table-Driven Test Template
+
+```go
+func TestFunctionName(t *testing.T) {
+    tests := []struct {
+        name     string
+        input    InputType
+        expected OutputType
+        wantErr  bool
+    }{
+        {
+            name:     "valid input",
+            input:    validInput,
+            expected: expectedOutput,
+        },
+        {
+            name:    "invalid input",
+            input:   invalidInput,
+            wantErr: true,
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            got, err := FunctionName(tt.input)
+            if (err != nil) != tt.wantErr {
+                t.Errorf("error = %v, wantErr %v", err, tt.wantErr)
+                return
+            }
+            if got != tt.expected {
+                t.Errorf("got = %v, want %v", got, tt.expected)
+            }
+        })
+    }
+}
+```
+
+## Coverage Verification
+
+```bash
+go test -cover ./...
+go test -coverprofile=coverage.out ./...
+go tool cover -html=coverage.out
+```

package/assets/workflows/plan.md

@@ -0,0 +1,93 @@
+---
+description: Restate requirements, assess risks, and create step-by-step implementation plan. WAIT for user CONFIRM before touching any code.
+---
+
+# Plan Command
+
+Create a comprehensive implementation plan before writing any code. Leverages Antigravity's Planning Mode and Artifact system for structured planning.
+
+## What This Command Does
+
+1. **Restate Requirements** — Clarify what needs to be built
+2. **Identify Risks** — Surface potential issues and blockers
+3. **Create Implementation Plan** — Use `implementation_plan.md` artifact
+4. **Create Task List** — Use `task.md` artifact for progress tracking
+5. **Wait for Confirmation** — MUST receive user approval before proceeding
+
+## When to Use
+
+Use `/plan` when:
+- Starting a new feature
+- Making significant architectural changes
+- Working on complex refactoring
+- Multiple files/components will be affected
+- Requirements are unclear or ambiguous
+
+## Workflow Steps (利用 Antigravity Planning Mode)
+
+### Step 1: 进入 Planning Mode
+设置 `task_boundary` 的 Mode 为 `PLANNING`，开始结构化规划。
+
+### Step 2: 分析需求
+- 完整阅读相关代码和文档
+- 查询 Knowledge Items (KI) 是否有相关历史知识
+- 明确需求边界和验收标准
+
+### Step 3: 创建 Implementation Plan Artifact
+创建 `implementation_plan.md`，包含：
+
+```markdown
+# Implementation Plan: [Feature Name]
+
+## Overview
+[2-3 sentence summary]
+
+## User Review Required
+> [!WARNING]
+> [Breaking changes or critical decisions]
+
+## Proposed Changes
+### [Component Name]
+#### [MODIFY] [filename](file:///path/to/file)
+- 具体变更描述
+
+#### [NEW] [filename](file:///path/to/new/file)
+- 新文件用途
+
+## Verification Plan
+### Automated Tests
+- 具体测试命令
+
+### Manual Verification
+- 手动验证步骤
+```
+
+### Step 4: 创建 Task Artifact
+创建 `task.md`，将方案拆解为可跟踪的任务项：
+
+```markdown
+# Task List
+- [ ] Phase 1: ...
+  - [ ] Sub-task 1.1
+  - [ ] Sub-task 1.2
+- [ ] Phase 2: ...
+```
+
+### Step 5: 等待审批
+使用 `notify_user` 工具将方案提交用户审批。**CRITICAL**: 用户明确批准前不得开始编码。
+
+## 审批后
+
+用户批准后：
+1. 切换到 EXECUTION mode
+2. 按 `task.md` 逐项执行
+3. 用 `[/]` 标记进行中、`[x]` 标记完成
+4. 完成后切换到 VERIFICATION mode
+5. 使用 `/verify` workflow 验证
+
+## Integration with Other Workflows
+
+- After planning: `/tdd` for test-driven implementation
+- After implementation: `/verify` for verification
+- If build fails: `/build-fix` to fix errors
+- After completion: `/code-review` for review

package/assets/workflows/python-review.md

@@ -0,0 +1,95 @@
+---
+description: Comprehensive Python code review for PEP 8 compliance, type hints, security, and Pythonic idioms.
+---
+
+# Python Code Review
+
+Comprehensive Python-specific code review.
+
+## Automated Checks
+
+```bash
+# Type checking
+mypy .
+
+# Linting and formatting
+ruff check .
+black --check .
+isort --check-only .
+
+# Security scanning
+bandit -r .
+
+# Testing
+pytest --cov=src --cov-report=term-missing
+```
+
+## Review Categories
+
+### CRITICAL (Must Fix)
+- SQL/Command injection vulnerabilities
+- Unsafe `eval`/`exec` usage
+- Pickle unsafe deserialization
+- Hardcoded credentials
+- YAML `unsafe_load`
+- Bare `except` clauses hiding errors
+
+### HIGH (Should Fix)
+- Missing type hints on public functions
+- Mutable default arguments
+- Swallowing exceptions silently
+- Not using context managers for resources
+- Race conditions without locks
+
+### MEDIUM (Consider)
+- PEP 8 formatting violations
+- Missing docstrings on public functions
+- `print()` statements instead of `logging`
+- Magic numbers without named constants
+- Not using f-strings
+
+## Common Fixes
+
+### Fix Mutable Defaults
+```python
+# Bad
+def process(items=[]):
+    items.append("new")
+
+# Good
+def process(items=None):
+    if items is None:
+        items = []
+    items.append("new")
+```
+
+### Add Type Hints
+```python
+# Bad
+def calculate(x, y):
+    return x + y
+
+# Good
+def calculate(x: int | float, y: int | float) -> int | float:
+    return x + y
+```
+
+### Use Context Managers
+```python
+# Bad
+f = open("file.txt")
+data = f.read()
+f.close()
+
+# Good
+with open("file.txt") as f:
+    data = f.read()
+```
+
+## Approval Criteria
+
+| Status | Condition |
+|--------|-----------|
+| ✅ Approve | No CRITICAL or HIGH issues |
+| ⚠️ Warning | Only MEDIUM issues |
+| ❌ Block | CRITICAL or HIGH issues found |

package/assets/workflows/setup-pm.md

@@ -0,0 +1,36 @@
+---
+description: Configure your preferred package manager (npm/pnpm/yarn/bun)
+---
+
+# Package Manager Setup
+
+Configure your preferred JavaScript/TypeScript package manager for this project.
+
+## Detection Priority
+
+When determining which package manager to use:
+
+1. **Lock file** — Presence of `package-lock.json`, `yarn.lock`, `pnpm-lock.yaml`, or `bun.lockb`
+2. **package.json** — `packageManager` field
+3. **Fallback** — First available (pnpm > bun > yarn > npm)
+
+## Setup Steps
+
+1. Ask the user which package manager they prefer
+2. Check if it's installed: `which pnpm` / `which yarn` / `which bun`
+3. If not installed, provide install instructions
+4. Set `packageManager` field in `package.json`
+5. Generate appropriate lock file
+
+## Install Instructions
+
+```bash
+# pnpm
+npm install -g pnpm
+
+# yarn
+npm install -g yarn
+
+# bun
+curl -fsSL https://bun.sh/install | bash
+```

package/assets/workflows/tdd.md

@@ -0,0 +1,75 @@
+---
+description: Enforce test-driven development workflow. Write tests FIRST, then implement minimal code to pass. Ensure 80%+ coverage.
+---
+
+# TDD Workflow
+
+Enforce strict test-driven development: write tests first, then implement.
+
+## The TDD Cycle
+
+```
+RED → GREEN → REFACTOR → VERIFY
+```
+
+1. **RED** — Write a failing test
+2. **GREEN** — Write minimal code to make the test pass
+3. **REFACTOR** — Improve code quality while keeping tests green
+4. **VERIFY** — Check coverage is 80%+
+
+## Step-by-Step Process
+
+### Step 1: Understand the Feature
+- Read requirements carefully
+- Identify success criteria
+- List edge cases
+
+### Step 2: Write Tests First
+Write tests that describe the expected behavior:
+- Happy path tests
+- Edge case tests (empty, null, boundary values)
+- Error handling tests
+
+### Step 3: Run Tests (They Should Fail)
+Verify that tests fail for the right reason — this validates the test is meaningful.
+
+### Step 4: Implement Code
+Write **minimal** code to make tests pass. No gold-plating.
+
+### Step 5: Run Tests Again
+All tests should now pass.
+
+### Step 6: Refactor
+Improve code quality while keeping tests green:
+- Remove duplication
+- Improve naming
+- Optimize performance
+- Enhance readability
+
+### Step 7: Verify Coverage
+Run coverage report and verify 80%+ coverage achieved.
+
+## Best Practices
+
+1. **Write Tests First** — Always TDD
+2. **One Assert Per Test** — Focus on single behavior
+3. **Descriptive Test Names** — Explain what's tested
+4. **Arrange-Act-Assert** — Clear test structure
+5. **Mock External Dependencies** — Isolate unit tests
+6. **Test Edge Cases** — Null, undefined, empty, large
+7. **Test Error Paths** — Not just happy paths
+8. **Keep Tests Fast** — Unit tests <50ms each
+9. **Clean Up After Tests** — No side effects
+10. **Review Coverage Reports** — Identify gaps
+
+## Language-Specific Commands
+
+- **TypeScript/JavaScript**: `npm test -- --coverage`
+- **Python**: `pytest --cov=src --cov-report=term-missing`
+- **Go**: `go test -cover ./...`
+
+## Integration with Other Workflows
+
+- Use `/plan` first for complex features
+- Use `/code-review` after implementation
+- Use `/build-fix` if build errors occur

package/assets/workflows/verify.md

@@ -0,0 +1,81 @@
+---
+description: Verify implementation completeness. Run tests, check build, generate walkthrough report.
+---
+
+# Verify Command
+
+Verify that implementation is correct and complete. Leverages Antigravity's Verification Mode and Walkthrough artifact.
+
+## When to Use
+
+Use `/verify` after completing an implementation, typically after `/plan` → `/tdd` cycle.
+
+## Workflow Steps
+
+### Step 1: 进入 Verification Mode
+设置 `task_boundary` 的 Mode 为 `VERIFICATION`。
+
+### Step 2: 运行测试
+```bash
+# TypeScript/JavaScript
+npm test -- --coverage
+
+# Python
+pytest --cov=src --cov-report=term-missing
+
+# Go
+go test -race -cover ./...
+```
+
+### Step 3: 检查构建
+```bash
+# TypeScript
+npx tsc --noEmit
+
+# Python
+python -m py_compile src/*.py
+
+# Go
+go build ./...
+go vet ./...
+```
+
+### Step 4: 验证清单
+
+- [ ] 所有测试通过
+- [ ] 覆盖率 ≥ 80%
+- [ ] 构建无错误
+- [ ] Lint 无警告
+- [ ] 无安全漏洞（hardcoded secrets, SQL injection 等）
+- [ ] 无 Claude Code 残留引用（仅 Everything Antigravity）
+- [ ] 无调试代码残留（console.log, print, fmt.Println）
+- [ ] API 文档已更新（如有）
+- [ ] README 已更新（如有）
+
+### Step 5: 生成 Walkthrough
+创建 `walkthrough.md` artifact，记录：
+
+```markdown
+# Walkthrough: [Feature Name]
+
+## Changes Made
+- 具体修改列表（使用 render_diffs）
+
+## What Was Tested
+- 测试结果和覆盖率
+
+## Validation Results
+- 构建状态
+- 测试通过率
+- 截图/录屏（如有 UI 变更）
+```
+
+### Step 6: 通知用户
+使用 `notify_user` 将 walkthrough 提交用户查看。
+
+## Integration with Other Workflows
+
+- Before verify: `/plan` → `/tdd` → implement
+- If issues found: go back to EXECUTION mode and fix
+- If fundamental issues: go back to `/plan`
+- After verify: `/code-review` for final review

package/bin/cli.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+/**
+ * Everything Antigravity CLI
+ *
+ * 用法:
+ *   ea init                    # 安装全部到当前项目
+ *   ea init --lang typescript  # 仅安装 TypeScript 规则
+ *   ea status                  # 查看安装状态
+ *   ea uninstall               # 卸载（自动备份）
+ *   ea help                    # 帮助
+ */
+
+const { install, uninstall, status, showHelp } = require('../lib/installer');
+
+const args = process.argv.slice(2);
+const command = args[0] || 'help';
+const restArgs = args.slice(1);
+
+// 解析子参数
+function parseFlags(arr) {
+  const flags = {};
+  let lang = 'all';
+  for (let i = 0; i < arr.length; i++) {
+    const a = arr[i];
+    if (a === '--lang' || a === '-l') {
+      lang = arr[++i] || 'all';
+    } else if (!a.startsWith('-')) {
+      lang = a;
+    }
+  }
+  // 语言别名
+  const LANG_ALIASES = { ts: 'typescript', js: 'typescript', py: 'python', go: 'golang' };
+  lang = LANG_ALIASES[lang] || lang;
+  return { lang };
+}
+
+// 路由命令
+switch (command) {
+  case 'init':
+  case 'install':
+  case 'i': {
+    const { lang } = parseFlags(restArgs);
+    install(lang);
+    break;
+  }
+
+  case 'status':
+  case 's':
+    status();
+    break;
+
+  case 'uninstall':
+  case 'remove':
+  case 'rm':
+    uninstall();
+    break;
+
+  case 'help':
+  case '-h':
+  case '--help':
+    showHelp();
+    break;
+
+  default:
+    console.log(`未知命令: ${command}\n`);
+    showHelp();
+    process.exit(1);
+}