@autocode-cli/autocode 0.1.5 → 0.1.7

package/templates/prompts/design.fr.md

@@ -0,0 +1,30 @@
+# Design
+
+## Role
+
+Creer le design technique et/ou UX pour la fonctionnalite. Preparer les maquettes, diagrammes ou documents d'architecture selon les besoins.
+
+## Actions
+
+1. Revoir les specifications et exigences
+2. Creer des maquettes UI/wireframes si interface utilisateur
+3. Designer l'architecture des composants si applicable
+4. Creer des diagrammes de sequence pour les flux complexes
+5. Definir l'approche de gestion d'etat si applicable
+6. Documenter les decisions de design et compromis
+7. Si travail hors scope detecte : `autocode new "<titre>" "<description>" -p P2 -l "<labels>" -a "<criteres>" -s patch`
+8. Documenter : `autocode comment <key> "Design termine : <resume>"`
+9. Avancer : `autocode next <key>`
+
+> Ou retour : `autocode move <key> <column>`
+
+## Criteres de Validation
+
+- [ ] Le design repond a toutes les exigences
+- [ ] L'experience utilisateur est consideree
+- [ ] La faisabilite technique est confirmee
+- [ ] Le design est documente/accessible
+
+## Notes
+
+Un bon design evite des refactorisations couteuses plus tard. Equilibrer rigueur et pragmatisme selon la complexite du ticket.

package/templates/prompts/dev.en.md

@@ -0,0 +1,31 @@
+# Development
+
+## Role
+
+Implement the feature or fix according to specifications. Write clean, maintainable code.
+
+## Actions
+
+1. Review specifications and design documents
+2. Create/modify necessary files
+3. Implement the feature following coding standards
+4. Add inline comments for complex logic
+5. Handle edge cases and errors gracefully
+6. Test locally before committing
+7. Commit + push with descriptive message
+8. If out of scope work detected: `autocode new "<title>" "<description>" -p P2 -l "<labels>" -a "<criteria>" -s patch`
+9. Document: `autocode comment <key> "Development complete: <files modified>"`
+10. Advance: `autocode next <key>`
+
+> Or return: `autocode move <key> <column>`
+
+## Validation Criteria
+
+- [ ] Feature works as specified
+- [ ] Code follows project conventions
+- [ ] No console errors or warnings
+- [ ] Edge cases handled
+
+## Notes
+
+Write code for humans first, computers second. Keep functions small and focused. When in doubt, refactor.

package/templates/prompts/dev.fr.md

@@ -0,0 +1,31 @@
+# Developpement
+
+## Role
+
+Implementer la fonctionnalite ou le correctif selon les specifications. Ecrire du code propre et maintenable.
+
+## Actions
+
+1. Revoir les specifications et documents de design
+2. Creer/modifier les fichiers necessaires
+3. Implementer la fonctionnalite en suivant les standards de code
+4. Ajouter des commentaires pour la logique complexe
+5. Gerer les cas limites et erreurs elegamment
+6. Tester localement avant de commiter
+7. Commit + push avec message descriptif
+8. Si travail hors scope detecte : `autocode new "<titre>" "<description>" -p P2 -l "<labels>" -a "<criteres>" -s patch`
+9. Documenter : `autocode comment <key> "Developpement termine : <fichiers modifies>"`
+10. Avancer : `autocode next <key>`
+
+> Ou retour : `autocode move <key> <column>`
+
+## Criteres de Validation
+
+- [ ] La fonctionnalite fonctionne comme specifie
+- [ ] Le code suit les conventions du projet
+- [ ] Pas d'erreurs ou warnings console
+- [ ] Les cas limites sont geres
+
+## Notes
+
+Ecrire du code pour les humains d'abord, les machines ensuite. Garder les fonctions petites et focalisees. En cas de doute, refactoriser.

package/templates/prompts/git-commit.en.md

@@ -0,0 +1,35 @@
+# Git Commit
+
+## Role
+
+Create a clean, atomic git commit for the changes. Follow conventional commit format.
+
+## Actions
+
+1. Review all staged changes: `git status`
+2. Ensure only relevant files are staged
+3. Write commit message following format:
+   - `feat:` for new features
+   - `fix:` for bug fixes
+   - `docs:` for documentation
+   - `refactor:` for refactoring
+   - `test:` for tests
+4. Include ticket key in commit body
+5. Create commit: `git commit -m "<type>: <description>"`
+6. Verify commit: `git log -1`
+7. If out of scope work detected: `autocode new "<title>" "<description>" -p P2 -l "<labels>" -a "<criteria>" -s patch`
+8. Document: `autocode comment <key> "Committed: <commit hash>"`
+9. Advance: `autocode next <key>`
+
+> Or return: `autocode move <key> <column>`
+
+## Validation Criteria
+
+- [ ] Commit message follows convention
+- [ ] Only relevant files included
+- [ ] Commit is atomic (single purpose)
+- [ ] Ticket key referenced
+
+## Notes
+
+Good commits tell a story. Each commit should be a logical unit of change that could be reverted independently.

package/templates/prompts/git-commit.fr.md

@@ -0,0 +1,35 @@
+# Git Commit
+
+## Role
+
+Creer un commit git propre et atomique pour les changements. Suivre le format conventional commit.
+
+## Actions
+
+1. Revoir tous les changements stages : `git status`
+2. S'assurer que seuls les fichiers pertinents sont stages
+3. Ecrire le message de commit suivant le format :
+   - `feat:` pour les nouvelles fonctionnalites
+   - `fix:` pour les corrections de bugs
+   - `docs:` pour la documentation
+   - `refactor:` pour le refactoring
+   - `test:` pour les tests
+4. Inclure la cle du ticket dans le corps du commit
+5. Creer le commit : `git commit -m "<type>: <description>"`
+6. Verifier le commit : `git log -1`
+7. Si travail hors scope detecte : `autocode new "<titre>" "<description>" -p P2 -l "<labels>" -a "<criteres>" -s patch`
+8. Documenter : `autocode comment <key> "Commite : <hash du commit>"`
+9. Avancer : `autocode next <key>`
+
+> Ou retour : `autocode move <key> <column>`
+
+## Criteres de Validation
+
+- [ ] Le message de commit suit la convention
+- [ ] Seuls les fichiers pertinents sont inclus
+- [ ] Le commit est atomique (but unique)
+- [ ] La cle du ticket est referencee
+
+## Notes
+
+De bons commits racontent une histoire. Chaque commit doit etre une unite logique de changement qui pourrait etre revertee independamment.

package/templates/prompts/git-push.en.md

@@ -0,0 +1,31 @@
+# Git Push
+
+## Role
+
+Push committed changes to the remote repository. Ensure CI/CD pipelines pass.
+
+## Actions
+
+1. Verify all commits are ready: `git log origin/main..HEAD`
+2. Pull latest changes: `git pull --rebase origin main`
+3. Resolve any conflicts if needed
+4. Push to remote: `git push origin <branch>`
+5. Verify push succeeded
+6. Check CI/CD pipeline status
+7. If pipeline fails: fix issues and re-push
+8. If out of scope work detected: `autocode new "<title>" "<description>" -p P2 -l "<labels>" -a "<criteria>" -s patch`
+9. Document: `autocode comment <key> "Pushed to <branch>"`
+10. Advance: `autocode next <key>`
+
+> Or return: `autocode move <key> <column>`
+
+## Validation Criteria
+
+- [ ] Changes pushed successfully
+- [ ] No merge conflicts
+- [ ] CI/CD pipeline passes
+- [ ] Branch is up to date
+
+## Notes
+
+Always pull before push to avoid conflicts. If CI fails, fix it immediately - don't leave the build broken.

package/templates/prompts/git-push.fr.md

@@ -0,0 +1,31 @@
+# Git Push
+
+## Role
+
+Pousser les changements commites vers le depot distant. S'assurer que les pipelines CI/CD passent.
+
+## Actions
+
+1. Verifier que tous les commits sont prets : `git log origin/main..HEAD`
+2. Recuperer les derniers changements : `git pull --rebase origin main`
+3. Resoudre les conflits si necessaire
+4. Pousser vers le distant : `git push origin <branche>`
+5. Verifier que le push a reussi
+6. Verifier le statut du pipeline CI/CD
+7. Si le pipeline echoue : corriger les problemes et re-pousser
+8. Si travail hors scope detecte : `autocode new "<titre>" "<description>" -p P2 -l "<labels>" -a "<criteres>" -s patch`
+9. Documenter : `autocode comment <key> "Pousse vers <branche>"`
+10. Avancer : `autocode next <key>`
+
+> Ou retour : `autocode move <key> <column>`
+
+## Criteres de Validation
+
+- [ ] Les changements sont pousses avec succes
+- [ ] Pas de conflits de merge
+- [ ] Le pipeline CI/CD passe
+- [ ] La branche est a jour
+
+## Notes
+
+Toujours pull avant push pour eviter les conflits. Si la CI echoue, corriger immediatement - ne pas laisser le build casse.

package/templates/prompts/git-tag.en.md

@@ -0,0 +1,32 @@
+# Git Tag
+
+## Role
+
+Create a version tag for the release. Follow semantic versioning.
+
+## Actions
+
+1. Determine version bump based on changes:
+   - MAJOR: breaking changes
+   - MINOR: new features (backward compatible)
+   - PATCH: bug fixes
+2. Check current version: `git describe --tags --abbrev=0`
+3. Create annotated tag: `git tag -a v<version> -m "<release notes>"`
+4. Push tag: `git push origin v<version>`
+5. Verify tag on remote
+6. If out of scope work detected: `autocode new "<title>" "<description>" -p P2 -l "<labels>" -a "<criteria>" -s patch`
+7. Document: `autocode comment <key> "Tagged: v<version>"`
+8. Advance: `autocode next <key>`
+
+> Or return: `autocode move <key> <column>`
+
+## Validation Criteria
+
+- [ ] Version follows semver
+- [ ] Tag is annotated with message
+- [ ] Tag pushed to remote
+- [ ] Version increment is appropriate
+
+## Notes
+
+Semantic versioning: MAJOR.MINOR.PATCH. Be conservative - when in doubt, use PATCH. Breaking changes require MAJOR bump.

package/templates/prompts/git-tag.fr.md

@@ -0,0 +1,32 @@
+# Git Tag
+
+## Role
+
+Creer un tag de version pour la release. Suivre le versionnement semantique.
+
+## Actions
+
+1. Determiner l'increment de version selon les changements :
+   - MAJOR : changements cassants
+   - MINOR : nouvelles fonctionnalites (retrocompatibles)
+   - PATCH : corrections de bugs
+2. Verifier la version actuelle : `git describe --tags --abbrev=0`
+3. Creer un tag annote : `git tag -a v<version> -m "<notes de release>"`
+4. Pousser le tag : `git push origin v<version>`
+5. Verifier le tag sur le distant
+6. Si travail hors scope detecte : `autocode new "<titre>" "<description>" -p P2 -l "<labels>" -a "<criteres>" -s patch`
+7. Documenter : `autocode comment <key> "Tag cree : v<version>"`
+8. Avancer : `autocode next <key>`
+
+> Ou retour : `autocode move <key> <column>`
+
+## Criteres de Validation
+
+- [ ] La version suit semver
+- [ ] Le tag est annote avec un message
+- [ ] Le tag est pousse sur le distant
+- [ ] L'increment de version est approprie
+
+## Notes
+
+Versionnement semantique : MAJOR.MINOR.PATCH. Etre conservateur - en cas de doute, utiliser PATCH. Les changements cassants necessitent un bump MAJOR.

package/templates/prompts/qualification.en.md

@@ -0,0 +1,30 @@
+# Qualification
+
+## Role
+
+Analyze and qualify the ticket requirement. Ensure the request is clear, feasible, and properly scoped.
+
+## Actions
+
+1. Read the ticket description and acceptance criteria
+2. Identify ambiguities or missing information
+3. Assess technical feasibility
+4. Estimate complexity (simple/medium/complex)
+5. Identify dependencies with other tickets or systems
+6. If clarification needed: add comment with questions
+7. If out of scope work detected: `autocode new "<title>" "<description>" -p P2 -l "<labels>" -a "<criteria>" -s patch`
+8. Document: `autocode comment <key> "Qualification complete: <summary>"`
+9. Advance: `autocode next <key>`
+
+> Or return: `autocode move <key> <column>`
+
+## Validation Criteria
+
+- [ ] Requirement is clear and unambiguous
+- [ ] Acceptance criteria are testable
+- [ ] Technical approach identified
+- [ ] No blocking dependencies
+
+## Notes
+
+A well-qualified ticket saves development time. When in doubt, ask for clarification rather than assuming.

package/templates/prompts/qualification.fr.md

@@ -0,0 +1,30 @@
+# Qualification
+
+## Role
+
+Analyser et qualifier le besoin du ticket. S'assurer que la demande est claire, faisable et correctement delimitee.
+
+## Actions
+
+1. Lire la description du ticket et les criteres d'acceptation
+2. Identifier les ambiguites ou informations manquantes
+3. Evaluer la faisabilite technique
+4. Estimer la complexite (simple/moyenne/complexe)
+5. Identifier les dependances avec d'autres tickets ou systemes
+6. Si clarification necessaire : ajouter un commentaire avec les questions
+7. Si travail hors scope detecte : `autocode new "<titre>" "<description>" -p P2 -l "<labels>" -a "<criteres>" -s patch`
+8. Documenter : `autocode comment <key> "Qualification terminee : <resume>"`
+9. Avancer : `autocode next <key>`
+
+> Ou retour : `autocode move <key> <column>`
+
+## Criteres de Validation
+
+- [ ] Le besoin est clair et sans ambiguite
+- [ ] Les criteres d'acceptation sont testables
+- [ ] L'approche technique est identifiee
+- [ ] Pas de dependances bloquantes
+
+## Notes
+
+Un ticket bien qualifie fait gagner du temps en developpement. En cas de doute, demander des clarifications plutot que supposer.

package/templates/prompts/retest.en.md

@@ -0,0 +1,31 @@
+# Retest
+
+## Role
+
+Re-run all tests after bug fixes or corrections. Ensure no regressions were introduced.
+
+## Actions
+
+1. Review what was fixed/changed
+2. Run unit tests: `npm test`
+3. Run integration tests if applicable
+4. Run E2E tests if applicable
+5. Verify the original issue is fixed
+6. Check for regressions in related functionality
+7. If tests fail: return to appropriate column for fixes
+8. If out of scope work detected: `autocode new "<title>" "<description>" -p P2 -l "<labels>" -a "<criteria>" -s patch`
+9. Document: `autocode comment <key> "Retest passed: all tests green"`
+10. Advance: `autocode next <key>`
+
+> Or return: `autocode move <key> <column>`
+
+## Validation Criteria
+
+- [ ] All tests pass
+- [ ] Original issue is fixed
+- [ ] No regressions detected
+- [ ] Related features still work
+
+## Notes
+
+Retest is crucial after any fix. Don't skip it even for "small" changes. Regressions are expensive.

package/templates/prompts/retest.fr.md

@@ -0,0 +1,31 @@
+# Retest
+
+## Role
+
+Re-executer tous les tests apres corrections de bugs. S'assurer qu'aucune regression n'a ete introduite.
+
+## Actions
+
+1. Revoir ce qui a ete corrige/modifie
+2. Executer les tests unitaires : `npm test`
+3. Executer les tests d'integration si applicable
+4. Executer les tests E2E si applicable
+5. Verifier que le probleme original est corrige
+6. Verifier les regressions dans les fonctionnalites liees
+7. Si les tests echouent : retourner a la colonne appropriee pour corrections
+8. Si travail hors scope detecte : `autocode new "<titre>" "<description>" -p P2 -l "<labels>" -a "<criteres>" -s patch`
+9. Documenter : `autocode comment <key> "Retest OK : tous les tests verts"`
+10. Avancer : `autocode next <key>`
+
+> Ou retour : `autocode move <key> <column>`
+
+## Criteres de Validation
+
+- [ ] Tous les tests passent
+- [ ] Le probleme original est corrige
+- [ ] Aucune regression detectee
+- [ ] Les fonctionnalites liees fonctionnent toujours
+
+## Notes
+
+Le retest est crucial apres toute correction. Ne pas le sauter meme pour des changements "mineurs". Les regressions coutent cher.

package/templates/prompts/review-code.en.md

@@ -0,0 +1,31 @@
+# Review Code
+
+## Role
+
+Perform peer code review. Ensure code quality, readability, and adherence to project standards.
+
+## Actions
+
+1. Review all changed files in the ticket
+2. Check code readability and naming conventions
+3. Verify logic correctness
+4. Look for potential bugs or edge cases
+5. Check error handling
+6. Suggest improvements if needed
+7. If issues found: add comment with feedback and return to dev
+8. If out of scope work detected: `autocode new "<title>" "<description>" -p P2 -l "<labels>" -a "<criteria>" -s patch`
+9. Document: `autocode comment <key> "Code review passed: <summary>"`
+10. Advance: `autocode next <key>`
+
+> Or return: `autocode move <key> <column>`
+
+## Validation Criteria
+
+- [ ] Code is readable and well-organized
+- [ ] Naming is clear and consistent
+- [ ] No obvious bugs or logic errors
+- [ ] Error handling is appropriate
+
+## Notes
+
+Be constructive in feedback. Focus on significant issues, not style preferences. Approve when good enough, not perfect.

package/templates/prompts/review-code.fr.md

@@ -0,0 +1,31 @@
+# Review Code
+
+## Role
+
+Effectuer une revue de code. Assurer la qualite du code, sa lisibilite et le respect des standards du projet.
+
+## Actions
+
+1. Revoir tous les fichiers modifies dans le ticket
+2. Verifier la lisibilite du code et les conventions de nommage
+3. Verifier la justesse de la logique
+4. Rechercher les bugs potentiels ou cas limites
+5. Verifier la gestion des erreurs
+6. Suggerer des ameliorations si necessaire
+7. Si problemes trouves : ajouter un commentaire avec feedback et retourner au dev
+8. Si travail hors scope detecte : `autocode new "<titre>" "<description>" -p P2 -l "<labels>" -a "<criteres>" -s patch`
+9. Documenter : `autocode comment <key> "Code review OK : <resume>"`
+10. Avancer : `autocode next <key>`
+
+> Ou retour : `autocode move <key> <column>`
+
+## Criteres de Validation
+
+- [ ] Le code est lisible et bien organise
+- [ ] Le nommage est clair et consistant
+- [ ] Pas de bugs ou erreurs de logique evidents
+- [ ] La gestion des erreurs est appropriee
+
+## Notes
+
+Etre constructif dans les retours. Se concentrer sur les problemes significatifs, pas les preferences de style. Approuver quand c'est assez bon, pas parfait.

package/templates/prompts/specification.en.md

@@ -0,0 +1,30 @@
+# Specification
+
+## Role
+
+Write detailed technical specifications for the ticket. Define the implementation approach clearly.
+
+## Actions
+
+1. Analyze the qualified requirement
+2. Define the technical architecture/approach
+3. List files to create or modify
+4. Define data structures if applicable
+5. Specify API contracts if applicable
+6. Document edge cases and error handling
+7. If out of scope work detected: `autocode new "<title>" "<description>" -p P2 -l "<labels>" -a "<criteria>" -s patch`
+8. Document: `autocode comment <key> "Specification complete: <technical approach>"`
+9. Advance: `autocode next <key>`
+
+> Or return: `autocode move <key> <column>`
+
+## Validation Criteria
+
+- [ ] Technical approach is documented
+- [ ] Files to modify are identified
+- [ ] Edge cases are considered
+- [ ] Implementation is feasible within scope
+
+## Notes
+
+Good specifications reduce back-and-forth during development. Be specific but not over-detailed.

package/templates/prompts/specification.fr.md

@@ -0,0 +1,30 @@
+# Specification
+
+## Role
+
+Rediger les specifications techniques detaillees pour le ticket. Definir clairement l'approche d'implementation.
+
+## Actions
+
+1. Analyser le besoin qualifie
+2. Definir l'architecture/approche technique
+3. Lister les fichiers a creer ou modifier
+4. Definir les structures de donnees si applicable
+5. Specifier les contrats API si applicable
+6. Documenter les cas limites et la gestion d'erreurs
+7. Si travail hors scope detecte : `autocode new "<titre>" "<description>" -p P2 -l "<labels>" -a "<criteres>" -s patch`
+8. Documenter : `autocode comment <key> "Specification terminee : <approche technique>"`
+9. Avancer : `autocode next <key>`
+
+> Ou retour : `autocode move <key> <column>`
+
+## Criteres de Validation
+
+- [ ] L'approche technique est documentee
+- [ ] Les fichiers a modifier sont identifies
+- [ ] Les cas limites sont consideres
+- [ ] L'implementation est faisable dans le scope
+
+## Notes
+
+De bonnes specifications reduisent les allers-retours pendant le developpement. Etre specifique mais pas sur-detaille.

package/templates/prompts/testing-integration.en.md

@@ -0,0 +1,32 @@
+# Testing Integration
+
+## Role
+
+Run integration tests to verify components work correctly together. Ensure system-level functionality.
+
+## Actions
+
+1. Identify integration points to test
+2. Run existing integration test suite
+3. Add new integration tests if needed
+4. Test API integrations
+5. Test database operations
+6. Test external service connections
+7. Fix any failing tests
+8. Commit + push test files
+9. If out of scope work detected: `autocode new "<title>" "<description>" -p P2 -l "<labels>" -a "<criteria>" -s patch`
+10. Document: `autocode comment <key> "Integration tests passed"`
+11. Advance: `autocode next <key>`
+
+> Or return: `autocode move <key> <column>`
+
+## Validation Criteria
+
+- [ ] All integration tests pass
+- [ ] API contracts verified
+- [ ] Database operations work correctly
+- [ ] External services respond as expected
+
+## Notes
+
+Integration tests are slower but catch issues unit tests miss. Focus on critical paths and data flows.

package/templates/prompts/testing-integration.fr.md

@@ -0,0 +1,32 @@
+# Testing Integration
+
+## Role
+
+Executer les tests d'integration pour verifier que les composants fonctionnent correctement ensemble. Assurer la fonctionnalite au niveau systeme.
+
+## Actions
+
+1. Identifier les points d'integration a tester
+2. Executer la suite de tests d'integration existante
+3. Ajouter de nouveaux tests d'integration si necessaire
+4. Tester les integrations API
+5. Tester les operations base de donnees
+6. Tester les connexions aux services externes
+7. Corriger les tests en echec
+8. Commit + push des fichiers de test
+9. Si travail hors scope detecte : `autocode new "<titre>" "<description>" -p P2 -l "<labels>" -a "<criteres>" -s patch`
+10. Documenter : `autocode comment <key> "Tests d'integration OK"`
+11. Avancer : `autocode next <key>`
+
+> Ou retour : `autocode move <key> <column>`
+
+## Criteres de Validation
+
+- [ ] Tous les tests d'integration passent
+- [ ] Les contrats API sont verifies
+- [ ] Les operations base de donnees fonctionnent
+- [ ] Les services externes repondent comme attendu
+
+## Notes
+
+Les tests d'integration sont plus lents mais detectent des problemes que les tests unitaires ratent. Se concentrer sur les chemins critiques et flux de donnees.

package/templates/prompts/testing-unit.en.md

@@ -0,0 +1,32 @@
+# Testing Unit
+
+## Role
+
+Write and run unit tests for the implemented feature. Ensure code coverage and reliability.
+
+## Actions
+
+1. Identify functions/components to test
+2. Write unit tests covering happy path
+3. Write tests for edge cases
+4. Write tests for error scenarios
+5. Run all unit tests: `npm test` or equivalent
+6. Fix any failing tests
+7. Verify coverage meets project standards
+8. Commit + push test files
+9. If out of scope work detected: `autocode new "<title>" "<description>" -p P2 -l "<labels>" -a "<criteria>" -s patch`
+10. Document: `autocode comment <key> "Unit tests passed: <coverage>%"`
+11. Advance: `autocode next <key>`
+
+> Or return: `autocode move <key> <column>`
+
+## Validation Criteria
+
+- [ ] All new code has unit tests
+- [ ] Happy path is covered
+- [ ] Edge cases are tested
+- [ ] All tests pass
+
+## Notes
+
+Good unit tests are fast, isolated, and deterministic. Test behavior, not implementation details.