@dtt_siye/atool 1.1.0

package/skills/go-conventions/SKILL.md

@@ -0,0 +1,230 @@
+---
+name: go-conventions
+description: Go development conventions and best practices
+version: 1.0.0
+---
+
+# Go Conventions
+
+Use this skill when working on Go projects.
+
+## When to Use
+- Detected Go project (go.mod)
+- User asks about Go best practices
+- Writing or reviewing Go code
+
+## Code Style
+
+### General
+- Follow Effective Go and Go Code Review Comments
+- Run `gofmt` or `goimports` for formatting
+- Use `golangci-lint` for linting
+- Tabs for indentation (Go standard)
+- Keep functions short and focused
+
+### Naming
+- Packages: lowercase, short, no underscores (`user`, `httputil`)
+- Functions: PascalCase if exported, camelCase if unexported
+- Interfaces: PascalCase with `-er` suffix (`Reader`, `Writer`, `Closer`)
+- Variables: camelCase, short names in small scope
+- Constants: PascalCase if exported, camelCase if unexported
+
+### Idioms
+- Accept interfaces, return structs
+- Keep interfaces small (1-3 methods)
+- Use `errors.New` for simple errors, `fmt.Errorf` for wrapping
+- Use `context.Context` as first parameter in public methods
+- Use table-driven tests
+- Handle errors immediately (don't defer)
+
+## Error Handling
+
+### Wrapping Errors
+```go
+func GetUser(ctx context.Context, id int) (*User, error) {
+    user, err := repo.FindByID(ctx, id)
+    if err != nil {
+        return nil, fmt.Errorf("GetUser(%d): %w", id, err)
+    }
+    return user, nil
+}
+```
+
+### Custom Error Types
+```go
+type AppError struct {
+    Code    string
+    Message string
+    Err     error
+}
+
+func (e *AppError) Error() string {
+    return fmt.Sprintf("%s: %s: %v", e.Code, e.Message, e.Err)
+}
+
+func (e *AppError) Unwrap() error {
+    return e.Err
+}
+```
+
+### Error Inspection
+```go
+var NotFoundErr = errors.New("not found")
+
+if errors.Is(err, NotFoundErr) {
+    // handle not found
+}
+```
+
+## Project Layout
+
+### Standard Structure
+```
+myapp/
+├── cmd/
+│   └── myapp/
+│       └── main.go
+├── internal/
+│   ├── user/
+│   │   ├── handler.go
+│   │   ├── service.go
+│   │   ├── repository.go
+│   │   └── model.go
+│   └── config/
+│       └── config.go
+├── pkg/
+│   └── middleware/
+│       └── auth.go
+├── go.mod
+├── go.sum
+└── Makefile
+```
+
+## Architecture
+
+### Dependency Injection via Interfaces
+```go
+type UserRepository interface {
+    FindByID(ctx context.Context, id int) (*User, error)
+    Save(ctx context.Context, user *User) error
+}
+
+type UserService struct {
+    repo UserRepository
+}
+
+func NewUserService(repo UserRepository) *UserService {
+    return &UserService{repo: repo}
+}
+```
+
+### Handler Pattern
+```go
+func (s *UserService) HandleGetUser(w http.ResponseWriter, r *http.Request) {
+    id, err := strconv.Atoi(chi.URLParam(r, "id"))
+    if err != nil {
+        http.Error(w, "invalid id", http.StatusBadRequest)
+        return
+    }
+
+    user, err := s.Get(r.Context(), id)
+    if err != nil {
+        if errors.Is(err, NotFoundErr) {
+            http.Error(w, "not found", http.StatusNotFound)
+            return
+        }
+        http.Error(w, err.Error(), http.StatusInternalServerError)
+        return
+    }
+
+    json.NewEncoder(w).Encode(user)
+}
+```
+
+## Concurrency
+
+### Goroutines
+```go
+func ProcessItems(ctx context.Context, items []Item) []Result {
+    results := make([]Result, len(items))
+    var wg sync.WaitGroup
+
+    for i, item := range items {
+        wg.Add(1)
+        go func(idx int, it Item) {
+            defer wg.Done()
+            results[idx] = process(ctx, it)
+        }(i, item)
+    }
+
+    wg.Wait()
+    return results
+}
+```
+
+### Channels
+```go
+func StreamResults(ctx context.Context, in <-chan Item) <-chan Result {
+    out := make(chan Result)
+    go func() {
+        defer close(out)
+        for item := range in {
+            select {
+            case out <- process(ctx, item):
+            case <-ctx.Done():
+                return
+            }
+        }
+    }()
+    return out
+}
+```
+
+## Testing
+
+### Table-Driven Tests
+```go
+func TestAdd(t *testing.T) {
+    tests := []struct {
+        name string
+        a, b int
+        want int
+    }{
+        {"positive", 1, 2, 3},
+        {"negative", -1, -2, -3},
+        {"zero", 0, 0, 0},
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            got := Add(tt.a, tt.b)
+            if got != tt.want {
+                t.Errorf("Add(%d, %d) = %d, want %d", tt.a, tt.b, got, tt.want)
+            }
+        })
+    }
+}
+```
+
+### Mocking with Interfaces
+```go
+type MockUserRepo struct {
+    FindByIDFn func(ctx context.Context, id int) (*User, error)
+}
+
+func (m *MockUserRepo) FindByID(ctx context.Context, id int) (*User, error) {
+    return m.FindByIDFn(ctx, id)
+}
+```
+
+## Common Commands
+```bash
+go build ./...          # Build
+go test ./...           # Test
+go test -race ./...     # Race detection
+go vet ./...            # Static analysis
+golangci-lint run       # Lint
+gofmt -w .              # Format
+go mod tidy             # Clean dependencies
+go mod download         # Download dependencies
+```

package/skills/harmony-conventions/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: harmony-conventions
+description: HarmonyOS/ArkTS/ArkUI development conventions and best practices
+version: 1.0.0
+---
+
+# HarmonyOS / ArkTS Conventions
+
+Use this skill when working on HarmonyOS applications with ArkTS and ArkUI.
+
+## When to Use
+- Detected HarmonyOS project (oh-package.json5, build-profile.json5)
+- User asks about HarmonyOS/ArkTS best practices
+- Writing or reviewing HarmonyOS code
+
+## Code Style
+
+### ArkTS
+- Follow ArkTS coding conventions (based on TypeScript with restrictions)
+- Use `@Component` decorator for UI components
+- Use `@Entry` decorator for page entry components
+- Use `@Builder` for reusable UI builders
+- Use `@Extend` for style extensions
+- Prefer `let` and `const` over `var`
+- Use arrow functions for callbacks
+
+### Naming
+- Components: PascalCase (`UserList`)
+- Functions/Variables: camelCase (`loadData`)
+- Constants: UPPER_SNAKE_CASE (`MAX_COUNT`)
+- Resources: snake_case (`user_name_text`)
+
+## Architecture (MVVM)
+
+```
+UI (@Component)
+    ↓
+ViewModel (@Observed)
+    ↓
+Model / Repository
+    ↓
+Data Source (Network / Database)
+```
+
+### Component Pattern
+```typescript
+@Entry
+@Component
+struct UserPage {
+  @State message: string = 'Hello'
+  private viewModel: UserViewModel = new UserViewModel()
+
+  aboutToAppear() {
+    this.viewModel.loadData()
+  }
+
+  build() {
+    Column() {
+      Text(this.message)
+        .fontSize(20)
+        .fontWeight(FontWeight.Bold)
+    }
+  }
+}
+```
+
+## State Management
+
+### Decorators
+- `@State`: Component-level state (triggers re-render)
+- `@Prop`: Parent-to-child state (one-way)
+- `@Link`: Two-way binding between parent and child
+- `@Provide` / `@Consume`: Cross-component state sharing
+- `@Observed` / `@ObjectLink`: Nested object state
+- `@Watch`: Callback when state changes
+- `AppStorage`: Application-level state
+- `LocalStorage`: Page-level state
+
+### State Strategy
+- Use `@State` for simple component state
+- Use `@Provide`/`@Consume` for shared state across component tree
+- Use `AppStorage` for app-wide settings
+- Use `LocalStorage` for page-specific state
+
+## Navigation
+
+### Navigation Component
+```typescript
+@Entry
+@Component
+struct Index {
+  private navPathStack: NavPathStack = new NavPathStack()
+
+  build() {
+    Navigation(this.navPathStack) {
+      // Home content
+    }
+    .navDestination(this.onDestination)
+  }
+
+  @Builder
+  onDestination(name: string, param: Object) {
+    if (name === 'userDetail') {
+      UserDetail({ userId: param as string })
+    }
+  }
+}
+```
+
+### Define routes in `main_pages.json`:
+```json
+{
+  "src": [
+    "pages/Index",
+    "pages/UserDetail",
+    "pages/Settings"
+  ]
+}
+```
+
+## Resource Management
+- Use `resources/base/element/` for string resources
+- Use `resources/base/media/` for media resources
+- Reference with `$r('app.string.name')` or `$r('app.media.icon')`
+- Support multiple languages with qualifiers (`en_US/`, `zh_CN/`)
+
+## UI Components (ArkUI)
+- Use built-in components: `Text`, `Image`, `Button`, `List`, `Grid`, `Tabs`
+- Use `Row` and `Column` for layout
+- Use `Scroll` and `List` for scrollable content
+- Apply modifiers chain for styling (`.fontSize()`, `.fontWeight()`, `.padding()`)
+- Use `@Styles` for reusable style definitions
+- Use `@Extend` to extend built-in component styles
+
+## Data Persistence
+- Preferences: `@ohos.data.preferences` for key-value storage
+- Relational Store: `@ohos.data.relationalStore` for SQLite
+- Distributed Data: `@ohos.data.distributedDataObject` for cross-device sync
+
+## Testing
+- Unit tests with `@ohos/hypium`
+- UI tests with `UiDriver`
+- Mock external dependencies
+- Test ViewModel logic independently
+
+## Build Commands
+```bash
+# Build HAP
+hvigorw assembleHap
+
+# Clean
+hvigorw clean
+
+# Run tests
+hvigorw test
+```

package/skills/java-conventions/SKILL.md

@@ -0,0 +1,277 @@
+---
+name: java-conventions
+description: Use when writing, reviewing, or refactoring Java or Spring Boot code — applies naming, layering, concurrency, logging, collections, OOP, and security rules.
+version: 1.0.0
+category: conventions
+---
+
+# Java / Spring Boot Conventions
+
+Use this skill when working on Java or Spring Boot projects to ensure code follows established conventions.
+
+## When to Use
+- Detected Java project (pom.xml, build.gradle)
+- Writing, reviewing, or refactoring Java/Spring code
+- Asking about Java/Spring best practices
+
+If the repository already has stricter local conventions, follow the stricter rule.
+
+---
+
+## Core Behavior
+
+Before writing code:
+1. Infer the target layer: controller / service / manager / dao / model / util.
+2. Keep dependencies flowing from upper layer to lower layer only.
+3. Prefer small, readable, maintainable changes over clever code.
+
+After writing code, run a mental lint pass against the self-check checklist at the end of this skill.
+
+---
+
+## Naming
+
+### General
+- Classes: `PascalCase` — abstract classes start with `Abstract` or `Base`, exceptions end with `Exception`, test classes end with `Test`
+- Methods / variables / parameters / fields: `camelCase`
+- Constants: `UPPER_SNAKE_CASE`
+- Packages: lowercase, dot-separated, generally singular (`com.example.service`)
+- Never start or end identifiers with `_` or `$`
+- No pinyin mixed with English; no Chinese identifiers
+- Avoid unclear abbreviations (`AbsClass`, `condi`)
+
+### Domain Model Naming
+| Suffix | Usage |
+|--------|-------|
+| `xxxDO` | Data object (maps to DB table) |
+| `xxxDTO` | Transfer object (crosses service/layer boundaries) |
+| `xxxVO` | View object (returned to caller/UI) |
+| `xxxBO` | Business object (internal computation) |
+| Never name a class `xxxPOJO` |  |
+
+### Service / DAO Method Prefixes
+| Prefix | Meaning |
+|--------|---------|
+| `get` | Single object |
+| `list` | Multiple objects |
+| `count` | Numeric count |
+| `save` / `insert` | Create |
+| `remove` / `delete` | Delete |
+| `update` | Update |
+
+### Spring Boot Specific
+- Expose interfaces for services and DAOs; use `Impl` for implementation classes
+- Keep controllers thin — delegate to services
+- Use `@Service`, `@Repository`, `@Controller` stereotypes consistently
+- Prefer constructor injection; use `@RequiredArgsConstructor` from Lombok
+- Use `@ConfigurationProperties` over `@Value` for grouped config
+
+---
+
+## Architecture & Layering
+
+```
+Controller   (REST endpoints — thin, no business logic)
+    ↓
+Service      (Business logic)
+    ↓
+Manager/     (Optional orchestration layer)
+    ↓
+Repository   (Data access)
+```
+
+### Package Structure (Package-by-Feature)
+```
+com.example.user/
+├── UserController.java
+├── UserService.java / UserServiceImpl.java
+├── UserRepository.java
+├── UserDO.java / UserDTO.java / UserVO.java
+├── UserMapper.java
+└── UserException.java
+```
+
+- Do not leak persistence details into service contracts
+- DTO/VO/DO boundaries must stay clear across layers
+- Shared constants, utilities, and clients go at the correct reuse level — not scattered
+
+---
+
+## Constants and Enums
+
+- Never hardcode magic values in business logic; extract constants or enums
+- Group constants by domain — do not create one giant constants class
+- Use uppercase `L` for `Long` literals (`100L`)
+- Use `Enum` when values are bounded or carry semantic meaning
+
+---
+
+## OOP Rules
+
+- Always add `@Override` on overridden methods
+- Do not change externally exposed interface signatures without strong reason; mark obsolete APIs `@Deprecated` with a replacement pointer
+- Use `Objects.equals` or constant-first comparison to avoid NPE
+- Compare boxed types with `equals`, not `==`
+- POJO / DTO / VO fields must use **wrapper types**, not primitives; RPC input/output types also use wrapper types; local variables prefer primitives
+- Do not assign default values to DO/DTO/VO fields
+- POJO classes must implement `toString()`
+- Constructors must not contain business logic
+- Class method order: public/protected → private → getters/setters
+- Getter/setter methods must stay lightweight — no business logic inside
+- Use `StringBuilder` in loops, not repeated string concatenation
+- Apply narrowest possible visibility: `private` first, then `protected`, then `public`
+- Use `final` where it meaningfully improves safety or readability
+- Be cautious with `clone`; shallow copy is the default
+
+---
+
+## Collections
+
+- If you override `equals`, you must also override `hashCode`
+- Do not cast `subList` results to `ArrayList`
+- Do not modify a list's structure while using a `subList` view
+- Use `toArray(new T[list.size()])` to convert collections to arrays
+- Do not call mutating methods on `Arrays.asList(...)` results
+- Do not remove/add elements inside `foreach`; use `Iterator` for removal
+- Prefer specifying initial capacity for `HashMap`/`ArrayList`
+- Prefer `entrySet()` over `keySet()` when both key and value are needed
+- Know null rules: `ConcurrentHashMap` does not allow null keys or values
+- Use `Set` for deduplication instead of repeated `List.contains` scans
+
+---
+
+## Concurrency
+
+- Singleton access and singleton internals must be thread-safe
+- Thread and thread-pool names must be meaningful
+- Do not create threads manually in application code — use thread pools
+- **Do not use `Executors` factory methods** for production thread pools; use `ThreadPoolExecutor` with explicit parameters
+- Do not keep `SimpleDateFormat` as a shared static field; prefer `DateTimeFormatter` or thread-local safe alternatives
+- In high-concurrency scenarios, minimize lock scope; prefer lock-free or finer-grained strategies
+
+---
+
+## Exception Handling
+
+- Never swallow exceptions silently
+- Either handle meaningfully or rethrow
+- Exception messages and logs must include: context / input / scenario + the original stack trace
+- For parameter or input validation issues, prefer `warn` over `error` unless it is a real system fault
+- Use `@ControllerAdvice` for global exception handling in Spring
+- Create custom exception classes extending `RuntimeException`; return proper HTTP status codes with meaningful messages
+
+---
+
+## Logging
+
+- Use **SLF4J API** — never direct Log4j/Logback API
+- Use placeholders for all log messages — **never concatenate strings** inside log statements:
+  ```java
+  // ✓ correct
+  log.info("Processing order={}, userId={}", orderId, userId);
+  // ✗ wrong
+  log.info("Processing order=" + orderId + ", userId=" + userId);
+  ```
+- Wrap debug/trace with guard or rely on placeholder-based lazy evaluation
+- Do not emit debug logs in production
+- Use `info` selectively; be careful with `warn` for temporary observation
+- Avoid duplicated logs from configuration; keep `additivity` under control
+- Avoid logging sensitive data (passwords, tokens, PII)
+- Extension log file naming: `appName_logType_logName.log`
+
+---
+
+## Formatting
+
+- 4-space indentation, never tabs
+- Operators must have spaces on both sides
+- Keywords (`if`, `for`, `while`, `switch`, `catch`) require a space before `(`
+- Opening brace on same line; body on next line; closing brace on its own line
+- Keep lines within 120 characters
+- File encoding: UTF-8 with Unix line endings
+- Use blank lines only to separate meaningful logical sections
+
+---
+
+## Security Defaults
+
+- Do not trust external input — validate and sanitize all request parameters
+- Avoid logging sensitive data
+- Use safe defaults and explicit permission checks
+- Do not introduce insecure reflection, deserialization, or dynamic execution unless required and risk is controlled
+
+---
+
+## Testing
+
+- Unit tests: JUnit 5 + Mockito
+- Integration tests: `@SpringBootTest`
+- Slice tests: `@WebMvcTest`, `@DataJpaTest`
+- Minimum 70% coverage for business logic
+- Use `@TempDir` for file system tests
+
+---
+
+## Common Patterns
+
+### Service Layer
+```java
+@Service
+@RequiredArgsConstructor
+public class UserService {
+    private final UserRepository userRepository;
+    private final UserMapper userMapper;
+
+    public UserVO getUserById(Long id) {
+        UserDO user = userRepository.findById(id)
+            .orElseThrow(() -> new UserNotFoundException(id));
+        return userMapper.toVO(user);
+    }
+}
+```
+
+### REST Controller
+```java
+@RestController
+@RequestMapping("/api/v1/users")
+@RequiredArgsConstructor
+public class UserController {
+    private final UserService userService;
+
+    @GetMapping("/{id}")
+    public ResponseEntity<UserVO> getUser(@PathVariable Long id) {
+        return ResponseEntity.ok(userService.getUserById(id));
+    }
+}
+```
+
+---
+
+## Self-Check Before Finalizing
+
+1. Are all names English, clear, and cased correctly?
+2. Any magic values left in the code?
+3. Any boxed type comparison done with `==`?
+4. Any possible NPE from `object.equals(...)`?
+5. Any mutable operation inside `foreach`?
+6. Any `Executors.*` usage introduced?
+7. Any unsafe shared `SimpleDateFormat`?
+8. Any direct Log4j/Logback API usage?
+9. Any string concatenation inside debug/info log statements?
+10. Any POJO/DTO/VO field using primitive where wrapper is required?
+11. Any public API signature changed unnecessarily?
+12. Any constructor containing business logic?
+13. Any line excessively long or formatting inconsistent?
+14. Any exception logged without stack trace or context?
+
+---
+
+## Review Output Format
+
+When reviewing Java code, group findings as:
+
+- **Blocking violations** — mandatory rule violations that must be fixed
+- **Recommended improvements** — best practices not yet followed
+- **Optional refactors** — style or readability improvements
+
+Prioritize blocking violations first.

package/skills/pdf/LICENSE.txt

@@ -0,0 +1,30 @@
+© 2025 Anthropic, PBC. All rights reserved.
+
+LICENSE: Use of these materials (including all code, prompts, assets, files,
+and other components of this Skill) is governed by your agreement with
+Anthropic regarding use of Anthropic's services. If no separate agreement
+exists, use is governed by Anthropic's Consumer Terms of Service or
+Commercial Terms of Service, as applicable:
+https://www.anthropic.com/legal/consumer-terms
+https://www.anthropic.com/legal/commercial-terms
+Your applicable agreement is referred to as the "Agreement." "Services" are
+as defined in the Agreement.
+
+ADDITIONAL RESTRICTIONS: Notwithstanding anything in the Agreement to the
+contrary, users may not:
+
+- Extract these materials from the Services or retain copies of these
+  materials outside the Services
+- Reproduce or copy these materials, except for temporary copies created
+  automatically during authorized use of the Services
+- Create derivative works based on these materials
+- Distribute, sublicense, or transfer these materials to any third party
+- Make, offer to sell, sell, or import any inventions embodied in these
+  materials
+- Reverse engineer, decompile, or disassemble these materials
+
+The receipt, viewing, or possession of these materials does not convey or
+imply any license or right beyond those expressly granted above.
+
+Anthropic retains all right, title, and interest in these materials,
+including all copyrights, patents, and other intellectual property rights.