@dtt_siye/atool 1.1.0

package/skills/ai-project-architecture/templates/verification-checklist.md

@@ -0,0 +1,408 @@
+# Migration Verification Checklist
+
+**Project**: [Project Name]
+**Migration Date**: [YYYY-MM-DD]
+**Verified By**: AI Project Architecture Skill
+**Migration Phase**: Phase 4 - Code Verification
+
+---
+
+## Overview
+
+This checklist verifies that migrated code is functionally equivalent to the original and follows LangGraph 1.0+ architecture standards.
+
+**Verification Status**: [✓ PASSED | ⚠ NEEDS ATTENTION | ✗ FAILED]
+
+---
+
+## 1. Structure Verification
+
+### 1.1 Directory Structure
+
+#### Tier 1: Mandatory Directories
+
+- [ ] `agents/` exists with all agents (Tier 1 - Mandatory)
+- [ ] `apps/` exists with required subdirectories (llms/, utils/, logs/) (Tier 1 - Mandatory)
+- [ ] `core/` exists with required subdirectories (logging/, middleware/) (Tier 1 - Mandatory)
+- [ ] `configs/` exists with all configuration files (Tier 1 - Mandatory)
+
+**Severity**: Failure = CRITICAL
+
+#### Tier 2: Conditionally Required Directories
+
+- [ ] `models/` exists (Tier 2 - Conditional: only if shared ORM models present)
+  - **Condition met**: [Yes/No]
+  - **Required**: [Yes/No/N/A]
+  - **Present**: [Yes/No]
+
+**Severity**: Failure = HIGH (if condition met)
+
+#### Tier 3: Optional Directories
+
+- [ ] `tests/` exists (Tier 3 - Optional but recommended)
+- [ ] `docs/` exists (Tier 3 - Optional)
+- [ ] `bin/` exists (Tier 3 - Optional)
+
+**Severity**: Failure = LOW (informational only)
+
+#### General Structure Checks
+
+- [ ] No temporary `new_` prefixes remain
+- [ ] No old structure directories in root (except archivecodes/)
+
+**Issues Found**:
+- [List any structural issues with tier classification]
+
+---
+
+### 1.2 Agent Structure
+
+For each agent in `agents/`:
+
+#### Agent: [agent_name]
+
+**Condition Analysis**:
+- Uses LangGraph: [Yes/No]
+- Uses state persistence: [Yes/No]
+- Exposes HTTP endpoints: [Yes/No]
+- Has independent DB tables: [Yes/No]
+- Uses custom LangGraph state: [Yes/No]
+
+##### Tier 1: Mandatory Components
+
+- [ ] `agents/[agent_name]/nodes/` exists (Tier 1 - Mandatory)
+- [ ] `agents/[agent_name]/services/` exists (Tier 1 - Mandatory)
+- [ ] `agents/[agent_name]/models/api.py` exists (Tier 1 - Mandatory)
+- [ ] `agents/[agent_name]/tools/` exists (Tier 1 - Mandatory)
+
+**Severity**: Any failure = CRITICAL
+
+##### Tier 2: Conditionally Required Components
+
+- [ ] `graph.py` present (Tier 2 - Required if uses LangGraph)
+  - **Condition met**: [Yes/No]
+  - **Present**: [Yes/No/N/A]
+
+- [ ] `checkpoint.py` present (Tier 2 - Required if uses state persistence)
+  - **Condition met**: [Yes/No]
+  - **Present**: [Yes/No/N/A]
+
+- [ ] `views.py` present (Tier 2 - Required if exposes HTTP endpoints)
+  - **Condition met**: [Yes/No]
+  - **Present**: [Yes/No/N/A]
+
+- [ ] `models/orm.py` present (Tier 2 - Required if has independent DB tables)
+  - **Condition met**: [Yes/No]
+  - **Present**: [Yes/No/N/A]
+
+- [ ] `models/state.py` present (Tier 2 - Required if uses custom LangGraph state)
+  - **Condition met**: [Yes/No]
+  - **Present**: [Yes/No/N/A]
+
+**Severity**: Failure = HIGH (if condition met)
+
+##### Tier 3: Optional Components
+
+- [ ] `constants.py` present (Tier 3 - Optional)
+  - **Present**: [Yes/No]
+
+**Severity**: Failure = LOW (informational only)
+
+**Issues Found**:
+- [List any agent structural issues with tier classification]
+
+---
+
+## 2. Import Verification
+
+### 2.1 Import Statement Updates
+
+- [ ] All imports use new structure paths
+- [ ] No imports reference old paths
+- [ ] Absolute imports used where appropriate
+- [ ] Relative imports used for same-package references
+- [ ] No circular import dependencies
+
+### 2.2 Import Resolution Tests
+
+For each module:
+
+| Module | Import Test | Result | Notes |
+|--------|-------------|--------|-------|
+| `core` | `python -c "import core"` | [Pass/Fail] | [Notes] |
+| `apps` | `python -c "import apps"` | [Pass/Fail] | [Notes] |
+| `configs` | `python -c "import configs"` | [Pass/Fail] | [Notes] |
+| `models` | `python -c "import models"` | [Pass/Fail] | [Notes] |
+| `agents.agent1` | `python -c "from agents.agent1 import *"` | [Pass/Fail] | [Notes] |
+| `agents.agent2` | `python -c "from agents.agent2 import *"` | [Pass/Fail] | [Notes] |
+
+**Issues Found**:
+- [List any import issues]
+
+---
+
+## 3. Code Content Verification
+
+### 3.1 Behavioral Preservation
+
+For each migrated file:
+
+- [ ] File content is identical (except import statements)
+- [ ] No functionality added
+- [ ] No functionality removed
+- [ ] No logic changes
+- [ ] No "improvements" or optimizations
+- [ ] Comments and docstrings preserved
+
+**Files Requiring Manual Review**:
+- [List files that need manual verification]
+
+---
+
+### 3.2 Cross-Reference Updates
+
+- [ ] Configuration files updated
+- [ ] Documentation files updated
+- [ ] Test files updated
+- [ ] Script files updated
+- [ ] Docker/config files updated
+- [ ] README files updated
+
+**References Not Updated**:
+- [List any unreferenced updates]
+
+---
+
+## 4. Syntax & Compilation Verification
+
+### 4.1 Syntax Check
+
+For each Python file:
+
+```bash
+python -m py_compile [file.py]
+```
+
+| File/Directory | Syntax Check | Result | Notes |
+|----------------|--------------|--------|-------|
+| `core/` | `python -m py_compile core/**/*.py` | [Pass/Fail] | [Notes] |
+| `apps/` | `python -m py_compile apps/**/*.py` | [Pass/Fail] | [Notes] |
+| `configs/` | `python -m py_compile configs/**/*.py` | [Pass/Fail] | [Notes] |
+| `models/` | `python -m py_compile models/**/*.py` | [Pass/Fail] | [Notes] |
+| `agents/agent1/` | `python -m py_compile agents/agent1/**/*.py` | [Pass/Fail] | [Notes] |
+
+**Syntax Errors Found**:
+- [List any syntax errors]
+
+---
+
+### 4.2 Linting (Optional)
+
+If project uses linting (pylint, flake8, black):
+
+- [ ] Run linter on all migrated code
+- [ ] Fix linting issues (if not blocking)
+- [ ] Linting score acceptable
+
+**Linting Issues**:
+- [List any linting issues]
+
+---
+
+## 5. Functional Verification
+
+### 5.1 Existing Tests
+
+If project has existing tests:
+
+- [ ] All tests run successfully
+- [ ] Test results identical to pre-migration
+- [ ] No test failures
+- [ ] No test errors
+- [ ] Test coverage maintained
+
+**Test Results**:
+```
+[Insert test output here]
+pytest tests/ -v
+```
+
+**Issues Found**:
+- [List any test failures]
+
+---
+
+### 5.2 Manual Verification
+
+For critical functionality:
+
+| Feature | Manual Test | Result | Notes |
+|---------|-------------|--------|-------|
+| [Feature 1] | [Test steps] | [Pass/Fail] | [Notes] |
+| [Feature 2] | [Test steps] | [Pass/Fail] | [Notes] |
+
+**Issues Found**:
+- [List any functional issues]
+
+---
+
+## 6. Integration Verification
+
+### 6.1 Inter-Agent Communication
+
+If agents communicate with each other:
+
+- [ ] Agent-to-agent imports work correctly
+- [ ] Agent-to-agent function calls work
+- [ ] Integration tests pass (if exist)
+
+**Integration Issues**:
+- [List any integration issues]
+
+---
+
+### 6.2 External Integrations
+
+- [ ] Database connections work (if applicable)
+- [ ] Redis connections work (if applicable)
+- [ ] LLM integrations work (if applicable)
+- [ ] External API calls work (if applicable)
+
+**Integration Issues**:
+- [List any external integration issues]
+
+---
+
+## 7. Performance Verification
+
+### 7.1 Performance Comparison
+
+| Metric | Pre-Migration | Post-Migration | Delta | Acceptable |
+|--------|---------------|----------------|-------|------------|
+| [Startup time] | [X]s | [X]s | [±X%] | [Yes/No] |
+| [Memory usage] | [X]MB | [X]MB | [±X%] | [Yes/No] |
+| [Request latency] | [X]ms | [X]ms | [±X%] | [Yes/No] |
+
+**Performance Regression Detected**:
+- [List any performance regressions]
+
+---
+
+## 8. Documentation Verification
+
+- [ ] README reflects new structure
+- [ ] API documentation updated
+- [ ] Architecture documentation updated
+- [ ] Migration changelog created
+- [ ] Developer guide updated (if exists)
+
+**Documentation Issues**:
+- [List any documentation issues]
+
+---
+
+## 9. systematic-debugging Review
+
+**Quality Gate (MANDATORY)**:
+
+- [ ] systematic-debugging skill invoked
+- [ ] Root cause analysis completed for any issues
+- [ ] All code changes validated
+- [ ] No unresolved issues remain
+
+**systematic-debugging Findings**:
+- [Insert findings here]
+
+---
+
+## 10. Final Validation
+
+### 10.1 Iron Law Compliance
+
+- [ ] NO new features added (Iron Law 2)
+- [ ] NO behavioral changes (Iron Law 2)
+- [ ] Incremental execution followed (Iron Law 3)
+- [ ] Quality gates executed (Iron Law 4)
+- [ ] Required skills invoked (Iron Law 5)
+
+**Iron Law Violations**:
+- [List any violations (should be NONE)]
+
+---
+
+### 10.2 Pre-Archive Checklist
+
+Before archiving old structure:
+
+- [ ] All verification checks pass
+- [ ] All tests pass
+- [ ] No unresolved issues
+- [ ] Documentation updated
+- [ ] Ready to proceed to Phase 5 (Archive & Test)
+
+---
+
+## Issues Summary
+
+### Critical Issues (Must Fix)
+
+1. **[Issue description]**
+   - **Location**: [File/Component]
+   - **Impact**: [Description]
+   - **Fix**: [Required fix]
+
+### High Priority Issues (Should Fix)
+
+1. **[Issue description]**
+   - **Location**: [File/Component]
+   - **Impact**: [Description]
+   - **Fix**: [Recommended fix]
+
+### Medium Priority Issues (Consider Fixing)
+
+1. **[Issue description]**
+   - **Location**: [File/Component]
+   - **Impact**: [Description]
+   - **Fix**: [Optional fix]
+
+### Low Priority Issues (Nice to Have)
+
+1. **[Issue description]**
+   - **Location**: [File/Component]
+   - **Impact**: [Description]
+   - **Fix**: [Optional fix]
+
+---
+
+## Verification Summary
+
+**Overall Status**: [✓ PASSED | ⚠ NEEDS ATTENTION | ✗ FAILED]
+
+**Statistics**:
+- Total Checks: [X]
+- Passed: [X]
+- Failed: [X]
+- Pass Rate: [X]%
+
+**Decision**:
+- [ ] Proceed to Phase 5 (Archive & Test)
+- [ ] Fix issues and re-verify
+- [ ] Revise migration plan
+
+**Verified By**: [AI Project Architecture Skill + systematic-debugging]
+**Verification Date**: [YYYY-MM-DD HH:MM:SS]
+
+---
+
+## Sign-Off
+
+**Verification Completed By**: [User/Developer]
+**Verification Date**: [YYYY-MM-DD]
+
+**Approval to Proceed**:
+- [ ] Approved - Proceed to Phase 5
+- [ ] Approved with Minor Fixes - Fix issues, then proceed
+- [ ] Not Approved - Fix issues, re-verify
+
+**Notes**:
+- [Any additional notes or concerns]

package/skills/android-conventions/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: android-conventions
+description: Android/Kotlin/Gradle development conventions and best practices
+version: 1.0.0
+---
+
+# Android / Kotlin Conventions
+
+Use this skill when working on Android projects with Kotlin.
+
+## When to Use
+- Detected Android project (AndroidManifest.xml, build.gradle with android plugin)
+- User asks about Android/Kotlin best practices
+- Writing or reviewing Android code
+
+## Code Style
+
+### Kotlin
+- Follow Kotlin Coding Conventions
+- Use trailing commas in multi-line expressions
+- Prefer `val` over `var`
+- Use string templates over string concatenation
+- Use named arguments for clarity
+- Prefer data classes for data holders
+- Use sealed classes for restricted class hierarchies
+
+### Naming
+- Classes: PascalCase (`UserViewModel`)
+- Functions/Properties: camelCase (`getUser()`)
+- Constants: UPPER_SNAKE_CASE in `companion object`
+- XML IDs: snake_case (`user_name_text`)
+
+## Architecture (MVVM)
+
+```
+UI (Activity/Fragment/Compose)
+    ↓
+ViewModel
+    ↓
+UseCase (optional)
+    ↓
+Repository
+    ↓
+Data Source (Remote + Local)
+```
+
+### ViewModel
+```kotlin
+@HiltViewModel
+class UserViewModel @Inject constructor(
+    private val repository: UserRepository
+) : ViewModel() {
+    private val _uiState = MutableStateFlow<UserUiState>(UserUiState.Loading)
+    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()
+
+    fun loadUser(id: String) {
+        viewModelScope.launch {
+            repository.getUser(id)
+                .catch { _uiState.value = UserUiState.Error(it.message) }
+                .collect { _uiState.value = UserUiState.Success(it) }
+        }
+    }
+}
+```
+
+### State Representation
+```kotlin
+sealed interface UserUiState {
+    object Loading : UserUiState
+    data class Success(val user: User) : UserUiState
+    data class Error(val message: String?) : UserUiState
+}
+```
+
+## Jetpack Compose
+
+### Principles
+- Stateless composables preferred
+- State hoisting - lift state to the lowest common parent
+- Use `remember` for mutable state
+- Use `derivedStateOf` for computed state
+- Unidirectional data flow
+
+### Composable Structure
+```kotlin
+@Composable
+fun UserScreen(
+    viewModel: UserViewModel = hiltViewModel()
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    when (val state = uiState) {
+        is UserUiState.Loading -> LoadingIndicator()
+        is UserUiState.Success -> UserContent(state.user)
+        is UserUiState.Error -> ErrorMessage(state.message)
+    }
+}
+```
+
+## Dependency Injection (Hilt)
+- Use `@HiltAndroidApp` on Application class
+- `@AndroidEntryPoint` on Activity/Fragment
+- `@HiltViewModel` for ViewModels
+- `@Inject constructor` for dependencies
+- Use `@Module` + `@Provides` or `@Binds` for bindings
+
+## Resource Guidelines
+- Use `strings.xml` for all user-facing text
+- Follow density-independent sizing
+- Use vector drawables over raster images
+- Use themes and Material Design 3 components
+- Support dark mode with `uiMode` qualifier
+
+## Testing
+- Unit tests: JUnit 5 + MockK + Turbine (for Flow)
+- Compose UI tests: `@get:Rule ComposeTestRule`
+- Instrumented tests: Espresso
+- Use `@RunWith(RobolectricTestRunner::class)` for Android framework tests
+- Test ViewModels by observing StateFlow with Turbine
+
+## Gradle
+- Use version catalogs (`libs.versions.toml`)
+- Configure build types (debug, release)
+- Use build features selectively
+- Keep build times minimal

package/skills/atool-init/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: atool-init
+description: "Initialize a project with aTool - one-step setup: auto-detect global install status, run global install if needed, then generate project-level CLAUDE.md, Cursor rules, Kiro steering. Use when user says /atool-init, initialize project, setup aTool. 触发：初始化项目/配置aTool/init project"
+version: 1.0.0
+---
+
+# aTool Project Initialization (One-Step)
+
+One-step project initialization: automatically checks global install status, performs global install if needed, then generates all project-level configuration files.
+
+## When to Use
+- User starts a new project and wants AI IDE configuration
+- User asks to set up or configure aTool for their project
+- User says "/atool-init", "initialize project", "setup atool", "init project"
+- User says "初始化项目", "配置aTool", "初始化aTool"
+- User wants to generate CLAUDE.md, Cursor rules, or Kiro steering
+
+## Steps
+
+### Step 1: Detect the project directory
+
+- Use the current working directory unless the user specifies a different path
+- Verify the directory exists and is a valid project
+
+### Step 2: Check global installation status
+
+Before running project init, check if aTool global installation has been completed:
+
+```bash
+# Check if global install has been done (skills/hooks/MCP installed)
+# Look for signs of completed global install:
+GLOBAL_INSTALLED=false
+
+# Check Claude
+if [[ -d "$HOME/.claude/skills" ]] && ls "$HOME/.claude/skills/"* &>/dev/null; then
+    GLOBAL_INSTALLED=true
+fi
+
+# Check Cursor staging
+if [[ -d "$HOME/.cursor/rules/.atool-staging" ]] && ls "$HOME/.cursor/rules/.atool-staging/"* &>/dev/null; then
+    GLOBAL_INSTALLED=true
+fi
+
+# Check Kiro staging
+KIRO_DIR="$(get_kiro_config_dir 2>/dev/null || echo "$HOME/.kiro")"
+if [[ -d "$KIRO_DIR/steering/.atool-staging" ]] && ls "$KIRO_DIR/steering/.atool-staging/"* &>/dev/null; then
+    GLOBAL_INSTALLED=true
+fi
+
+echo "Global install status: $GLOBAL_INSTALLED"
+```
+
+### Step 3: Run global install if needed
+
+If `GLOBAL_INSTALLED=false`, run global install first:
+
+```bash
+# Find install.sh
+INSTALL_SH=""
+
+# Method 1: Check ATOOL_ROOT env var (set by session-start hook)
+if [[ -n "${ATOOL_ROOT:-}" ]] && [[ -f "${ATOOL_ROOT}/install.sh" ]]; then
+    INSTALL_SH="${ATOOL_ROOT}/install.sh"
+fi
+
+# Method 2: Search common clone locations
+if [[ -z "$INSTALL_SH" ]]; then
+    for candidate in \
+        "$HOME/Documents/projects/aTool_package/install.sh" \
+        "$HOME/projects/aTool_package/install.sh" \
+        "$HOME/aTool/install.sh" \
+        "$HOME/.atool/install.sh"; do
+        if [[ -f "$candidate" ]]; then
+            INSTALL_SH="$candidate"
+            break
+        fi
+    done
+fi
+
+# Method 3: Trace from installed lib files
+if [[ -z "$INSTALL_SH" ]]; then
+    LIB_FILE="$HOME/.claude/lib/common.sh"
+    if [[ -f "$LIB_FILE" ]]; then
+        INSTALL_SH="$(dirname "$LIB_FILE")/../install.sh"
+        [[ ! -f "$INSTALL_SH" ]] && INSTALL_SH=""
+    fi
+fi
+
+if [[ -n "$INSTALL_SH" ]]; then
+    echo "Running global install: $INSTALL_SH --all --yes"
+    "$INSTALL_SH" --all --yes
+else
+    echo "WARNING: Cannot find install.sh. Global install skipped."
+    echo "Please clone aTool and run: ./install.sh --all"
+fi
+```
+
+### Step 4: Run project-level initialization
+
+After confirming global install is complete, run project init:
+
+```bash
+if [[ -n "$INSTALL_SH" ]]; then
+    "$INSTALL_SH" --project <PROJECT_PATH> --yes
+fi
+```
+
+If install.sh cannot be found, perform manual initialization:
+- Source `$HOME/.claude/lib/common.sh` and `$HOME/.claude/lib/detect-stack.sh`
+- Detect the tech stack from signal files
+- Generate files from templates:
+  - CLAUDE.md from `templates/CLAUDE.md.{stack}`
+  - Cursor rules: copy from `~/.cursor/rules/.atool-staging/` to `<project>/.cursor/rules/`
+  - Kiro steering: copy from `$(get_kiro_config_dir)/steering/.atool-staging/` to `<project>/.kiro/steering/`
+
+Stack detection signal files:
+- Java: pom.xml, build.gradle
+- Android: AndroidManifest.xml, build.gradle + android plugin
+- HarmonyOS: oh-package.json5, build-profile.json5
+- Web: package.json (check for react, next, vue, svelte)
+- Mobile: package.json + react-native, pubspec.yaml, Package.swift
+- Python: requirements.txt, pyproject.toml, setup.py
+- Rust: Cargo.toml (check for src-tauri/ → rust-tauri)
+- Go: go.mod
+- DevOps: Dockerfile, docker-compose.yml, *.tf
+
+### Step 5: Report results to user
+
+- Show detected stack and confidence level
+- List all generated files (global + project-level)
+- Suggest next steps:
+  1. Restart IDE to load new rules
+  2. Verify MCP servers appear in IDE's tool list
+  3. Consider running `/project-analyze` for deep analysis (5 depth levels: quick scan → full inventory → deep analysis → knowledge graph → code review)
+
+## Notes
+- This skill is idempotent - running it multiple times is safe
+- Existing CLAUDE.md files will be backed up (not overwritten)
+- If no stack is detected, a generic template is used
+- Global install is only run once (detected by checking staging directories)
+- The install.sh location varies by how aTool was installed (git clone, manual copy, etc.)