devflow-kit 0.2.0 → 0.3.0

package/src/claude/commands/devflow/pre-commit.md

@@ -9,6 +9,7 @@ Perform a comprehensive review of uncommitted changes by orchestrating multiple
 
 **Audit Strategy**:
 - **Always Run** (5 core audits): Security, Performance, Architecture, Tests, Complexity
+- **Language-Specific** (conditional): TypeScript (runs only if .ts/.tsx files changed or tsconfig.json exists)
 - **Available on demand**: Documentation, Dependencies, Database (use `/pre-pr` for full audit)
 
 This lightweight approach provides fast feedback for individual commits. Use `/pre-pr` for comprehensive branch reviews before creating pull requests.
@@ -38,10 +39,15 @@ echo ""
 Launch these sub-agents in parallel:
 
 1. audit-security sub-agent
-2. audit-performance sub-agent
-3. audit-architecture sub-agent
-4. audit-tests sub-agent
-5. audit-complexity sub-agent
+2. audit-typescript sub-agent (automatically skips if not applicable)
+3. audit-performance sub-agent
+4. audit-architecture sub-agent
+5. audit-tests sub-agent
+6. audit-complexity sub-agent
+
+**Note**: The audit-typescript agent contains built-in detection logic and will automatically skip if:
+- No .ts/.tsx files were changed AND
+- No tsconfig.json exists in the project
 
 ### Step 3: Synthesize Review Findings
 
@@ -84,6 +90,9 @@ Create a comprehensive review document at `.docs/reviews/diff-{YYYY-MM-DD_HHMM}.
 ### Security Review (audit-security)
 {security findings with file:line references}
 
+### TypeScript Review (audit-typescript)
+{type safety findings, or "⏭️ Skipped - not applicable" if no TS files}
+
 ### Performance Review (audit-performance)
 {performance findings with specific optimizations}
 

package/src/claude/commands/devflow/pre-pr.md

@@ -85,8 +85,9 @@ Launch these sub-agents in parallel based on change detection:
 6. audit-dependencies sub-agent
 7. audit-documentation sub-agent
 
-**Conditional Audits**:
-8. audit-database sub-agent (only if database changes detected)
+**Conditional Audits** (automatically detect and skip if not applicable):
+8. audit-typescript sub-agent (only if .ts/.tsx files changed or tsconfig.json exists)
+9. audit-database sub-agent (only if database changes detected)
 
 ### Step 4: Synthesize Comprehensive Review
 
@@ -157,6 +158,16 @@ Create a detailed review document at `.docs/reviews/branch-{BRANCH_NAME}-{YYYY-M
 #### Security Recommendations
 {specific security improvements needed}
 
+### 📘 TypeScript Analysis (audit-typescript)
+**Type Safety**: {Excellent/Good/Acceptable/Poor}
+**Note**: Only included if TypeScript files changed or project uses TypeScript
+
+#### TypeScript Issues Found
+{detailed type safety findings with file:line references}
+
+#### TypeScript Recommendations
+{specific type safety improvements needed}
+
 ### ⚡ Performance Analysis (audit-performance)
 **Performance Impact**: {Positive/Neutral/Negative}
 
@@ -247,6 +258,7 @@ Create a detailed review document at `.docs/reviews/branch-{BRANCH_NAME}-{YYYY-M
 
 **Breakdown**:
 - Security: {score}/10
+- TypeScript: {score}/10 (if applicable)
 - Performance: {score}/10
 - Architecture: {score}/10
 - Test Coverage: {score}/10

package/src/claude/commands/devflow/release.md

@@ -0,0 +1,251 @@
+---
+description: Automated release workflow with version management and publishing
+allowed-tools: Task, Bash, Read, Write, Edit, Grep, Glob
+---
+
+## Your Task
+
+Orchestrate a complete release workflow using the release sub-agent. This command guides you through creating a professional release with version management, changelog generation, building, testing, and publishing.
+
+**Workflow**: User input → Release agent automation → User confirmations at critical steps
+
+### Step 1: Determine Release Type
+
+First, ask the user what type of release they want to create:
+
+```bash
+echo "🚀 DEVFLOW RELEASE AUTOMATION"
+echo ""
+echo "This will guide you through creating a new release."
+echo ""
+```
+
+Present options to the user:
+
+```
+What type of release do you want to create?
+
+1. **patch** - Bug fixes and maintenance (0.1.2 → 0.1.3)
+2. **minor** - New features, backwards compatible (0.1.2 → 0.2.0)
+3. **major** - Breaking changes (0.1.2 → 1.0.0)
+4. **custom** - Specify exact version (e.g., 2.0.0-beta.1)
+5. **analyze** - Analyze changes and get recommendation first
+
+Please specify the release type (patch/minor/major/custom/analyze):
+```
+
+### Step 2: Launch Release Agent
+
+Once the user provides input, launch the release sub-agent with the appropriate prompt:
+
+**If user chose "analyze"**:
+```
+Invoke the release sub-agent with this prompt:
+
+"Analyze the current repository state and recent commits. Execute through Step 3 (Determine New Version) and provide a recommendation for the version bump type. Show:
+- Current version
+- Commits since last release
+- Breaking changes, features, and fixes detected
+- Recommended version bump with reasoning
+
+Stop and wait for user decision before proceeding with the release."
+```
+
+**If user chose "patch", "minor", or "major"**:
+```
+Invoke the release sub-agent with this prompt:
+
+"Create a {bump_type} release. Follow the complete release workflow:
+1. Detect project type and configuration
+2. Verify clean working directory
+3. Analyze recent changes since last release
+4. Calculate new version as {bump_type} bump
+5. Generate changelog entry from commits
+6. Update version files
+7. Build project (if applicable)
+8. Run tests (if applicable)
+
+STOP before Step 8 (Commit Version Bump) and show me:
+- Current version → New version
+- Generated changelog entry
+- Files that will be modified
+- Build/test results
+
+Wait for my confirmation before proceeding with commit, push, publish, and tagging."
+```
+
+**If user chose "custom"**:
+```
+Ask user: "Please specify the exact version number (e.g., 2.0.0-beta.1):"
+
+Then invoke the release sub-agent with this prompt:
+
+"Create a release with custom version {specified_version}. Follow the complete release workflow:
+1. Detect project type and configuration
+2. Verify clean working directory
+3. Analyze recent changes since last release
+4. Use the specified version: {specified_version}
+5. Generate changelog entry from commits
+6. Update version files
+7. Build project (if applicable)
+8. Run tests (if applicable)
+
+STOP before Step 8 (Commit Version Bump) and show me:
+- Current version → New version
+- Generated changelog entry
+- Files that will be modified
+- Build/test results
+
+Wait for my confirmation before proceeding with commit, push, publish, and tagging."
+```
+
+### Step 3: Review and Confirm
+
+After the release agent completes the preparation phase and stops, present the summary to the user:
+
+```
+📋 RELEASE READY FOR REVIEW
+
+Current Version: {current_version}
+New Version: {new_version}
+Project Type: {project_type}
+
+📝 Changelog Entry:
+{generated_changelog}
+
+📄 Files to be Modified:
+- {version_file}
+- {changelog_file}
+
+✅ Build Status: {build_result}
+✅ Test Status: {test_result}
+
+---
+
+The release agent will now:
+1. Commit version bump
+2. Push to remote
+3. Publish package (if applicable)
+4. Create git tag
+5. Create GitHub/GitLab release (if available)
+
+⚠️  WARNING: Steps 3-5 are PERMANENT and PUBLIC
+
+Do you want to proceed with the release? (yes/no):
+```
+
+### Step 4: Complete Release (After Confirmation)
+
+If user confirms, continue with the release agent:
+
+```
+Invoke the release sub-agent again with this prompt:
+
+"Continue the release process from Step 8 (Commit Version Bump):
+8. Commit version bump
+9. Push to remote
+10. Publish package (if applicable) - STOP and ask for confirmation before publishing
+11. Create git tag
+12. Create GitHub/GitLab release
+13. Provide final summary
+
+Execute these steps sequentially. Before Step 10 (publishing to package registry), STOP and explicitly ask for confirmation as this is permanent and public."
+```
+
+### Step 5: Publish Confirmation
+
+When the agent reaches the publish step, ask for explicit confirmation:
+
+```
+⚠️  FINAL CONFIRMATION REQUIRED
+
+The package is ready to be published to the public registry.
+
+Project: {project_name}
+Version: {new_version}
+Registry: {registry_name}
+Command: {publish_command}
+
+This action is PERMANENT and IRREVERSIBLE.
+
+Do you want to publish to the public registry? (yes/no):
+```
+
+### Step 6: Final Summary
+
+After the release is complete, the agent will provide a final summary. Display it to the user and provide next steps:
+
+```
+The release agent will show:
+- Release summary with all completed steps
+- Links to package registry
+- Links to GitHub/GitLab release
+- Links to tag and commits
+- Verification steps for the user
+
+Next steps for you:
+1. Verify package appears in registry
+2. Test installation in fresh environment
+3. Announce release to users/team
+4. Update documentation if needed
+```
+
+## Error Handling
+
+If the release agent encounters an error at any step:
+
+1. **Before commit**: Changes can be rolled back easily
+   ```bash
+   git checkout {version_files}
+   ```
+
+2. **After commit, before push**: Can amend or reset
+   ```bash
+   git reset --hard HEAD~1
+   ```
+
+3. **After push, before publish**: Can remove tag and revert
+   ```bash
+   git tag -d {tag}
+   git push origin :{tag}
+   git revert HEAD
+   ```
+
+4. **After publish**: Cannot unpublish in most registries
+   - npm: Can only deprecate, not unpublish after 24h
+   - Document issue and create patch release
+
+Always provide clear recovery instructions if something fails.
+
+## Safety Features
+
+- ✅ Verify clean working directory before starting
+- ✅ Show preview of all changes before committing
+- ✅ Require explicit confirmation before publishing
+- ✅ Provide rollback instructions at each step
+- ✅ Stop and ask before any permanent/public action
+- ✅ Generate proper semantic versioning
+- ✅ Run build and tests before releasing
+
+## Quick Reference
+
+```bash
+# Standard releases
+/release   # Interactive - asks for release type
+
+# With specific type (if supported in future)
+/release patch
+/release minor
+/release major
+
+# Analyze first
+/release analyze   # Show recommendations without releasing
+```
+
+## Notes
+
+- The release sub-agent handles all the technical details
+- This command provides the user interaction layer
+- Critical steps require explicit user confirmation
+- All actions are logged and can be audited
+- Works with any programming language/ecosystem