@dtt_siye/atool 1.1.0

package/skills/project-query/rules/query-templates.md

@@ -0,0 +1,212 @@
+# Query Templates — jq Graph Query Patterns for project-query
+
+This file provides reusable jq query templates for the 6 query categories.
+All templates operate on `knowledge-graph.json` format.
+
+## Graph Schema Reference
+
+```json
+{
+  "nodes": [{ "id": "prefix:name", "type": "...", "label": "...", "path": "...", "importance": 0.0-1.0, "metrics": {...} }],
+  "edges": [{ "source": "...", "target": "...", "type": "...", "weight": 0.0-1.0, "confidence": 0.0-1.0, "line": N }],
+  "layers": { "detected": [...], "assignments": {...} },
+  "indexes": { "nodes_by_type": {...}, "edges_by_source": {...}, "edges_by_target": {...} }
+}
+```
+
+## Template 1: Node Lookup
+
+```jq
+# Find nodes by type and label substring
+.nodes | map(select(
+  (.type == $type or $type == "*") and
+  ((.label | ascii_downcase) | contains($query | ascii_downcase))
+)) | sort_by(-.importance) | .[0:20]
+```
+
+## Template 2: BFS Path Finding
+
+```jq
+# BFS from source to target on specific edge types
+# Returns shortest path as array of node IDs
+.edges | map(select(.type as $t | $edge_types | index($t))) as $relevant |
+# Iterative BFS (requires multiple jq passes or recursive approach)
+# Simplified: 3-hop path search
+.nodes | map(.id) as $all_ids |
+# Hop 1: direct edges
+($relevant | map(select(.source == $source)) | map(.target)) as $hop1 |
+# Hop 2: from hop1 targets
+($relevant | map(select(.source as $s | $hop1 | index($s))) | map(.target)) as $hop2 |
+# Hop 3: from hop2 targets
+($relevant | map(select(.source as $s | $hop2 | index($s))) | map(.target)) as $hop3 |
+# Check if target reached
+if ($hop1 | index($target)) then [$source, $target]
+elif ($hop2 | index($target)) then
+  ($relevant | map(select(.target == $target and (.source as $s | $hop1 | index($s)))) | .[0].source) as $mid1 |
+  [$source, $mid1, $target]
+elif ($hop3 | index($target)) then
+  ($relevant | map(select(.target == $target and (.source as $s | $hop2 | index($s)))) | .[0].source) as $mid2 |
+  ($relevant | map(select(.target == $mid2 and (.source as $s | $hop1 | index($s)))) | .[0].source) as $mid1 |
+  [$source, $mid1, $mid2, $target]
+else [] end
+```
+
+## Template 3: Impact Analysis (Reverse BFS)
+
+```jq
+# Find all nodes that depend on target (reverse 1-hop + 2-hop)
+.edges as $all |
+.nodes as $nodes |
+
+# Direct dependents (reverse edges pointing TO target)
+[$all[] | select(.target == $target_id)] as $direct_back |
+
+# Direct dependents' node IDs
+[$direct_back[].source] | unique as $direct_ids |
+
+# Second-level dependents (reverse edges pointing TO direct dependents)
+[$all[] | select(.target as $t | $direct_ids | index($t))] as $indirect_back |
+[$indirect_back[].source] | unique as $indirect_ids |
+
+# Combine and compute risk
+{
+  target: $target_id,
+  direct_dependents: ($direct_ids | length),
+  transitive_dependents: (($indirect_ids | length) - ($direct_ids | length)),
+  risk_score: (
+    ($direct_ids | map($nodes | map(select(.id == .)) | .[0].importance // 0) | add // 0) * 0.6 +
+    ($indirect_ids | map($nodes | map(select(.id == .)) | .[0].importance // 0) | add // 0) * 0.4
+  ),
+  affected_nodes: ($direct_ids + $indirect_ids) | unique
+}
+```
+
+## Template 4: Data Lineage
+
+```jq
+# Forward: trace where data flows FROM entity
+# Backward: trace where data comes TO entity
+
+# Data-relevant edge types
+["reads_from", "writes_to", "transforms", "validates", "persists_to", "reads_state", "writes_state"] as $data_edges |
+
+.edges | map(select(.type as $t | $data_edges | index($t))) as $relevant |
+
+# Sources (who writes to this entity)
+[$relevant[] | select(.target == $data_id and (.type == "writes_to" or .type == "writes_state"))] as $writers |
+
+# Sinks (who reads from this entity)
+[$relevant[] | select(.source == $data_id and (.type == "reads_from" or .type == "reads_state"))] as $readers |
+
+# Transforms (who transforms this entity)
+[$relevant[] | select((.source == $data_id or .target == $data_id) and .type == "transforms")] as $transformers |
+
+{
+  data_entity: $data_id,
+  sources: { writers: ($writers | map(.source) | unique), count: ($writers | length) },
+  sinks: { readers: ($readers | map(.target) | unique), count: ($readers | length) },
+  transforms: ($transformers | map(.source) | unique),
+  flow_rate: (($writers | length) * ($readers | length))
+}
+```
+
+## Template 5: Neighborhood (N-hop BFS)
+
+```jq
+# Bidirectional BFS for N hops around focus node
+# Returns subgraph of all nodes/edges within N hops
+
+.edges as $all |
+.nodes as $all_nodes |
+
+# Build adjacency (both directions)
+([$all[] | {from: .source, to: .target}] + [$all[] | {from: .target, to: .source}]) as $bidir |
+
+# Iterative expansion (for up to 3 hops)
+[$focus_id] as $hop0 |
+([$bidir[] | select(.from == $focus_id) | .to] | unique) as $hop1 |
+([$bidir[] | select(.from as $f | $hop1 | index($f)) | .to] | unique | map(select(. != $focus_id) | select(. as $h | $hop1 | index($h) | not))) as $hop2 |
+([$bidir[] | select(.from as $f | $hop2 | index($f)) | .to] | unique | map(select(. != $focus_id) | select(. as $h | $hop1 | index($h) | not) | select(. as $h | $hop2 | index($h) | not))) as $hop3 |
+
+# Collect all reachable nodes
+($hop0 + $hop1 + $hop2 + $hop3) | unique as $reachable |
+
+# Filter to zoom level
+$reachable as $ids |
+{
+  nodes: [$all_nodes[] | select(.id as $id | $ids | index($id))],
+  edges: [$all[] | select((.source as $s | $ids | index($s)) and (.target as $t | $ids | index($t)))]
+}
+```
+
+## Template 6: Aggregate Metrics
+
+```jq
+# Sort nodes by a specific metric, return top N
+.nodes |
+map(select(.metrics[$metric] != null)) |
+sort_by(-.metrics[$metric]) |
+.[0:$limit] |
+map({
+  id: .id,
+  label: .label,
+  type: .type,
+  value: .metrics[$metric]
+})
+```
+
+## Zoom Level Filters
+
+```jq
+# G1: System view
+.nodes | map(select(.type == "module" or .type == "architectural_layer"))
+
+# G2: Module view
+.nodes | map(select(.type == "module" or .type == "class" or .type == "service" or .type == "store" or .type == "interface" or .type == "architectural_layer"))
+
+# G3: Function view
+.nodes | map(select(.type == "function" or .type == "api_endpoint" or .type == "route" or .type == "hook" or .type == "service"))
+
+# G4: Data view
+.nodes | map(select(.type == "function" or .type == "data_entity" or .type == "store"))
+
+# G5: All (no filter)
+.nodes
+```
+
+## Mermaid Generation Templates
+
+### Dependency Graph (G1)
+```
+graph TD
+  subgraph presentation
+    mod:controller --> mod:auth-service
+  end
+  subgraph service
+    mod:auth-service --> mod:user-repo
+  end
+```
+
+### Call Chain (G3)
+```
+graph LR
+  func:A.createUser -->|calls| func:B.validate
+  func:B.validate -->|calls_async| func:C.checkDB
+```
+
+### Data Flow (G4)
+```
+graph TD
+  api:POST/users -->|writes_to| data:User
+  data:User -->|reads_from| func:getProfile
+  func:getProfile -->|transforms| data:UserDTO
+```
+
+### Impact Analysis
+```
+graph TD
+  data:User((User)) -->|risk:HIGH| svc:Auth
+  data:User -->|risk:MEDIUM| svc:Order
+  style data:User fill:#ff5555
+  style svc:Auth fill:#ffb86c
+```

package/skills/python-conventions/SKILL.md

@@ -0,0 +1,169 @@
+---
+name: python-conventions
+description: Python/FastAPI/Django development conventions and best practices
+version: 1.0.0
+---
+
+# Python Conventions
+
+Use this skill when working on Python projects (Django, FastAPI, Flask, CLI tools).
+
+## When to Use
+- Detected Python project (requirements.txt, pyproject.toml, setup.py)
+- User asks about Python best practices
+- Writing or reviewing Python code
+
+## Code Style
+
+### PEP 8
+- 4-space indentation
+- Max line length: 88 (Black) or 120 (per project config)
+- Imports: stdlib, third-party, local (separated by blank lines)
+- Use `isort` or `ruff` for import sorting
+- Use f-strings for string formatting
+
+### Type Hints
+- Annotate all function signatures
+- Use `from __future__ import annotations` for forward references
+- Use `Optional[X]` or `X | None` for optional types
+- Use `TypedDict` for dictionary shapes
+- Use `Protocol` for structural subtyping
+
+### Naming
+- Functions/variables/methods: `snake_case`
+- Classes: `PascalCase`
+- Constants: `UPPER_SNAKE_CASE`
+- Private: `_leading_underscore`
+- Dunder methods: `__dunder__`
+
+## Project Structure
+
+### Recommended Layout
+```
+myapp/
+├── pyproject.toml
+├── src/
+│   └── myapp/
+│       ├── __init__.py
+│       ├── main.py
+│       ├── models/
+│       ├── services/
+│       ├── api/
+│       └── core/
+│       │   ├── config.py
+│       │   └── exceptions.py
+├── tests/
+│   ├── conftest.py
+│   ├── unit/
+│   └── integration/
+└── docs/
+```
+
+## FastAPI Conventions
+
+### App Structure
+```python
+# main.py
+from fastapi import FastAPI
+from myapp.api.router import api_router
+
+app = FastAPI(title="My App", version="0.1.0")
+app.include_router(api_router, prefix="/api/v1")
+```
+
+### Router Pattern
+```python
+# api/router.py
+from fastapi import APIRouter
+
+api_router = APIRouter()
+api_router.include_router(users.router, prefix="/users", tags=["users"])
+```
+
+### Dependency Injection
+```python
+from fastapi import Depends
+
+async def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+@router.get("/users/{user_id}")
+async def get_user(user_id: int, db: Session = Depends(get_db)):
+    return db.query(User).get(user_id)
+```
+
+### Pydantic Models
+```python
+from pydantic import BaseModel, EmailStr
+
+class UserCreate(BaseModel):
+    email: EmailStr
+    name: str
+
+class UserResponse(BaseModel):
+    id: int
+    email: EmailStr
+    name: str
+
+    model_config = ConfigDict(from_attributes=True)
+```
+
+## Django Conventions
+
+### App Structure
+- One app per feature domain
+- Use `models.py`, `views.py`, `serializers.py`, `urls.py`
+- Use Django REST Framework for APIs
+- Use `select_related`/`prefetch_related` for query optimization
+
+### Models
+```python
+class User(models.Model):
+    email = models.EmailField(unique=True)
+    name = models.CharField(max_length=255)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        ordering = ["-created_at"]
+```
+
+## Testing
+
+### pytest
+```python
+# conftest.py
+import pytest
+from myapp.main import app
+from httpx import AsyncClient
+
+@pytest.fixture
+async def client():
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        yield client
+
+# tests/test_users.py
+async def test_create_user(client):
+    response = await client.post("/api/v1/users", json={
+        "email": "test@example.com",
+        "name": "Test User"
+    })
+    assert response.status_code == 201
+```
+
+### Best Practices
+- Use fixtures for setup/teardown
+- Mock external dependencies with `pytest-mock`
+- Use `faker` for test data generation
+- Separate unit and integration tests
+- Aim for 80%+ coverage
+
+## Tools
+- **Linting/Formatting**: `ruff` (replaces flake8, isort, black)
+- **Type checking**: `mypy`
+- **Testing**: `pytest`
+- **Virtual env**: `venv`, `poetry`, `uv`
+- **Dependency management**: `pyproject.toml` with `pip-compile` or `poetry`

package/skills/react-native-conventions/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: react-native-conventions
+description: React Native mobile development conventions and best practices
+version: 1.0.0
+---
+
+# React Native Conventions
+
+Use this skill when working on React Native applications.
+
+## When to Use
+- Detected React Native project (react-native in package.json)
+- User asks about React Native development best practices
+- Writing or reviewing React Native code
+
+## Related Skills
+- `swift-conventions` — iOS native module bridging
+- `android-conventions` — Android native module bridging
+- `web-conventions` — React/TypeScript shared conventions
+
+## General Principles
+- Follow platform-specific design guidelines (Material Design / Human Interface Guidelines)
+- Responsive layouts that adapt to different screen sizes
+- Handle offline scenarios gracefully
+- Optimize for performance (FlatList virtualization, lazy loading)
+- Proper error handling and user feedback
+
+## Code Style
+- TypeScript for all new files
+- Functional components with hooks
+- Use `expo` when possible for faster development
+- Follow React conventions (see web-conventions skill)
+
+## Architecture
+- Screen components in `screens/`
+- Reusable components in `components/`
+- Navigation in `navigation/`
+- Services/API in `services/`
+- Hooks in `hooks/`
+- Store in `store/`
+
+## Navigation
+- React Navigation for routing
+- Type-safe navigation params
+- Deep linking support
+- Tab and stack navigators
+- Expo Router for file-based routing
+
+## State Management
+- Zustand for simple to moderate state
+- Redux Toolkit for complex state
+- React Query / SWR for server state
+- AsyncStorage / MMKV for persistence
+
+## API Integration
+- Repository pattern for data access
+- Error handling with proper user feedback
+- Loading states and skeleton screens
+- Offline-first when applicable
+- Axios or fetch with interceptors
+
+## Testing
+- Jest + React Native Testing Library
+- Detox for E2E tests
+- Mock native modules
+- Storybook for component development
+
+## Performance
+- Use FlatList instead of ScrollView for long lists
+- Image optimization and caching (FastImage)
+- Lazy loading for heavy components
+- Reduce re-renders with React.memo and useMemo
+- Hermes engine for JavaScript optimization

package/skills/requirements-writer/README.md

@@ -0,0 +1,153 @@
+# Requirements Writer Skill
+
+## Quick Start
+
+This skill helps you write comprehensive PRDs and User Stories following Inspection Agent project standards.
+
+### Basic Workflow
+
+1. **Phase 1: Requirements Outline**
+   - Use `templates/prd-outline-template.md`
+   - Define modules, dependencies, and writing plan
+
+2. **Phase 2: Module-Level PRDs**
+   - Use `templates/module-prd-template.md`
+   - Write detailed requirements for each module
+
+3. **Phase 3: User Stories**
+   - Use `templates/user-story-template.md`
+   - Write comprehensive US (8000+ words each)
+
+## Validation Checklist
+
+### Phase 1: Requirements Outline
+
+**File Naming**
+- [ ] File follows: `30x-prd-outline.md`
+- [ ] Located in: `docs/300-requirements/`
+- [ ] Lowercase, kebab-case filename
+
+**Document Structure**
+- [ ] Complete frontmatter (doc_id, title, status, owner, last_updated, related_docs)
+- [ ] All sections from template are present
+- [ ] Version history table at end
+
+**Content Quality**
+- [ ] All modules identified
+- [ ] Module dependencies mapped
+- [ ] Writing sequence defined
+- [ ] Personas defined
+- [ ] Deliverables listed
+
+### Phase 2: Module PRD
+
+**File Naming**
+- [ ] File follows: `31x-prd-<module>.md`
+- [ ] Located in: `docs/300-requirements/`
+- [ ] Lowercase, kebab-case filename
+
+**Document Structure**
+- [ ] Complete frontmatter
+- [ ] Problem/Goals section
+- [ ] Scope (In/Out) defined
+- [ ] Personas & Scenarios
+- [ ] Functional Requirements (FR-<MODULE>-<SEQ>)
+- [ ] Non-Functional Requirements (NFR-<MODULE>-<SEQ>)
+- [ ] UX Notes (interaction intent only)
+- [ ] Data Requirements
+- [ ] Acceptance Criteria
+- [ ] Risks & Assumptions
+- [ ] Version history
+
+**Content Quality**
+- [ ] FRs include: Input, Processing, Output, Exceptions, Verification
+- [ ] NFRs are quantifiable and testable
+- [ ] ACs avoid subjective language
+- [ ] Cross-references use relative paths
+- [ ] Technical details delegated to design/architecture docs
+
+### Phase 3: User Story
+
+**File Naming**
+- [ ] File follows: `33x-us-<module>-<feature>.md`
+- [ ] Located in: `docs/300-requirements/330-user-stories/`
+- [ ] Lowercase, kebab-case filename
+
+**Document Structure**
+- [ ] Complete frontmatter including us_id, module, priority
+- [ ] Story statement follows format
+- [ ] All 10 sections present
+
+**Content Quality (Word Count Targets)**
+- [ ] Section 1 (Background): 1000-1500 words
+- [ ] Section 2 (Personas): 1000-1500 words
+- [ ] Section 3 (Functional): 1500-2000 words
+- [ ] Section 4 (UX): 1000-1500 words
+- [ ] Section 5 (Data): 800-1000 words
+- [ ] Section 6 (Security): 800-1000 words
+- [ ] Section 7 (AC): 1000-1500 words
+- [ ] Section 8 (Dependencies): 500-800 words
+- [ ] Section 9 (Risks): 500-800 words
+- [ ] Section 10 (Out of Scope): 300-500 words
+- [ ] **Total: ≥ 8000 words**
+
+**Acceptance Criteria**
+- [ ] All ACs are objectively verifiable
+- [ ] No subjective language (e.g., "fast", "good experience")
+- [ ] Each AC has verification method
+- [ ] Test scenarios included
+
+**Data & Security**
+- [ ] Data entities reference `docs/500-data/502-data-dictionary.md`
+- [ ] RBAC requirements defined
+- [ ] Data scope defined per role
+- [ ] Audit requirements for critical operations
+
+## Common Mistakes
+
+### PRD Writing
+- ❌ Mixing business and technical requirements
+- ❌ Vague, non-testable requirements
+- ❌ Missing NFRs
+- ❌ Subjective acceptance criteria
+- ❌ No scope boundaries
+
+### User Story Writing
+- ❌ Insufficient detail (< 8000 words)
+- ❌ Missing required sections
+- ❌ Vague acceptance criteria
+- ❌ No data references
+- ❌ Missing security/audit requirements
+- ❌ Incomplete edge case coverage
+
+## Integration with Doc-Standards-Enforcer
+
+This skill automatically invokes `doc-standards-enforcer` to ensure:
+- Proper file naming
+- Complete frontmatter
+- Correct directory structure
+- Valid status values
+- Version history tables
+- Proper cross-references
+
+## Example Usage
+
+```
+User: "I need to write a PRD for the COMPARE module"
+
+Assistant: "Let's start with the requirements outline.
+1. First, tell me about the project scope and main modules.
+2. I'll create docs/300-requirements/301-prd-outline.md
+3. Then we'll write module PRDs in dependency order
+4. Finally, we'll write comprehensive User Stories"
+```
+
+## Templates Location
+
+- **PRD Outline**: `templates/prd-outline-template.md`
+- **Module PRD**: `templates/module-prd-template.md`
+- **User Story**: `templates/user-story-template.md`
+
+## Related Skills
+
+- `doc-standards-enforcer` - Document standards compliance (automatically invoked)