aca 0.3.1

A Rust-based agentic tool that automates coding tasks using Claude Code and OpenAI Codex CLI integrations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

# Reference Files

This directory contains reference documents that can be included in tasks for additional context.

## 📖 Reference Documents

### `memory_leak_analysis.md`
**Use case:** Detailed technical analysis for debugging tasks

A comprehensive analysis document that demonstrates how to provide structured technical information for complex debugging tasks. Contains:
- Issue description and symptoms
- Investigation findings and root cause analysis
- Recommended solutions with priority levels
- Testing and validation plans

**Referenced by:** `../task-inputs/task_list.md`

### `caching_strategy.txt`
**Use case:** Implementation specification and requirements

A detailed technical specification showing how to document implementation requirements for system architecture tasks. Includes:
- Multi-layer architecture overview
- Detailed implementation specifications
- Configuration and monitoring requirements
- Performance and operational considerations

**Referenced by:** `../task-inputs/task_list.md`

## 🔗 How Reference Files Work

Reference files are automatically included when tasks reference them using the `->` syntax:

```markdown
- [ ] Fix memory leak in data processor -> ../references/memory_leak_analysis.md
```

When ACA processes this task, it will:
1. Read the main task description
2. Load the referenced file content
3. Include the reference content in the task context
4. Process the combined information as a single task

## 📝 Creating Effective Reference Files

### Technical Analysis Documents
Structure for debugging and investigation:
```markdown
# [Issue Name]

## Issue Description
Brief overview of the problem

## Symptoms Observed
- Observable behaviors
- Error conditions
- Performance impacts

## Investigation Findings
### Root Cause Analysis
### Code Locations Affected

## Recommended Solutions
1. Immediate fixes
2. Long-term improvements

## Testing Plan
Verification steps
```

### Implementation Specifications
Structure for feature requirements:
```markdown
# [Feature/System Name]

## Overview
High-level description

## Requirements
- Functional requirements
- Non-functional requirements

## Architecture
- System design
- Component interactions

## Implementation Details
- Technical specifications
- Configuration requirements

## Monitoring & Operations
- Performance metrics
- Operational procedures
```

### Best Practices

1. **Be Specific**: Include exact file paths, line numbers, function names
2. **Provide Context**: Explain the business impact and technical implications
3. **Include Examples**: Show code snippets, configuration examples, test cases
4. **Structure Information**: Use headings and lists for easy scanning
5. **Cross-Reference**: Link related files and documentation

### File Formats
Reference files can be in any UTF-8 text format:
- `.md` - Markdown (recommended for structured documents)
- `.txt` - Plain text (good for simple specifications)
- `.json` - Configuration examples
- `.yaml/.yml` - Configuration files
- Any other text format

## 🎯 Usage Patterns

### Analysis-Driven Development
Create analysis documents for:
- Bug investigations
- Performance bottlenecks
- Security assessments
- Code reviews

### Specification-Driven Implementation
Create specification documents for:
- New feature requirements
- Architecture decisions
- API designs
- Integration requirements

### Documentation-Driven Maintenance
Create reference docs for:
- Operational procedures
- Troubleshooting guides
- Configuration references
- Best practices