@sylphx/flow 3.5.0 → 3.6.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @sylphx/flow
 
+## 3.6.1 (2026-01-28)
+
+### ♻️ Refactoring
+
+- comprehensive review of all commands and builder ([73b103a](https://github.com/SylphxAI/flow/commit/73b103a4d6901079408d9e4e0237cad4e4087f14))
+
+## 3.6.0 (2026-01-28)
+
+### ✨ Features
+
+- add /sweep command for propagating improvements ([ba58697](https://github.com/SylphxAI/flow/commit/ba58697eddabb4b851f7d46bf56cb83930d9a3c5))
+
 ## 3.5.0 (2026-01-28)
 
 ### ✨ Features

package/assets/agents/builder.md

@@ -145,6 +145,14 @@ Vercel CLI, Neon CLI, GitHub CLI
 * Data presentation must use Data Tables
 * Large datasets require cursor-based pagination, virtualization, and infinite scrolling
 
+## Public-Facing & Exposure
+
+* SEO — proper title tags, meta descriptions, structured data, sitemap
+* Social sharing — OG tags, Twitter cards for all public pages
+* README — clear value prop, quick start, badges, screenshots
+* Landing page — value prop above the fold, clear CTA, social proof
+* Documentation — complete, searchable, up-to-date
+
 ## Delivery
 
 The final delivered version must be flawless, high-performance, and represent the absolute pinnacle of quality.

package/assets/slash-commands/audit.md

@@ -12,16 +12,16 @@ Scan the entire project for issues. Find problems, don't fix them. Open GitHub i
 ## Scan Areas
 
 ### 1. Code Quality
-- Dead code, unused imports, unused variables
+- Dead code, unused imports, unreachable code
 - TODOs, FIXMEs, HACKs left in code
-- `any` types, missing type safety
+- Weak typing (`any`, missing types, unsafe casts)
 - Hardcoded values that should be config
-- Console.logs, debug code in production
-- Copy-paste duplication
-- Functions > 50 lines, files > 300 lines
-- Missing error handling
-- Inconsistent naming conventions
-- Outdated dependencies with known issues
+- Debug artifacts in production (console.logs, commented code)
+- Copy-paste duplication (DRY violations)
+- Overly complex functions/files (hard to understand at a glance)
+- Missing or inconsistent error handling
+- Naming that doesn't convey intent
+- Outdated or vulnerable dependencies
 
 ### 2. Business Logic Correctness
 
@@ -96,6 +96,15 @@ Scan the entire project for issues. Find problems, don't fix them. Open GitHub i
 - Missing type definitions
 - Confusing folder structure
 
+### 9. Public-Facing & Exposure
+- **SEO**: Missing/poor title tags, meta descriptions, structured data
+- **Social Sharing**: Missing OG tags, Twitter cards, poor share previews
+- **Landing/Home**: Unclear value prop above the fold, weak CTAs
+- **README**: Missing badges, unclear quick start, no screenshots
+- **Docs**: Incomplete, outdated, hard to navigate
+- **Analytics**: Missing tracking, no conversion funnels
+- **Branding**: Inconsistent voice, visuals, messaging
+
 ## Process
 
 1. **Scan** each area systematically

package/assets/slash-commands/catchup.md

@@ -48,6 +48,13 @@ gh issue list --state open --limit 20
 gh pr list --state open --limit 10
 ```
 
+### Business & Marketing Strategy
+- What's the monetization model? Is it working?
+- Who are the competitors? How does this differentiate?
+- What's the go-to-market strategy?
+- How are users being acquired? (SEO, social, paid, referral)
+- What public-facing assets exist? (landing page, blog, socials)
+
 ### Branch Analysis
 ```bash
 git branch -a

package/assets/slash-commands/challenge.md

@@ -11,8 +11,8 @@ Stop. Step back. Challenge everything you just did.
 
 ### 1. State of the Art?
 - Would industry experts approve this implementation?
-- Does it follow current best practices (2024+)?
-- Is this how top engineers at FAANG would solve it?
+- Does it follow current best practices?
+- Is this how top engineers would solve it?
 - Are you using modern APIs, patterns, and approaches?
 
 ### 2. Correct Approach or Workaround?
@@ -21,21 +21,30 @@ Stop. Step back. Challenge everything you just did.
 - Would you be embarrassed if a senior engineer reviewed this?
 - Is there technical debt being created?
 
-### 3. Clean & Complete?
-- Zero dead code?
-- Zero unused imports?
-- Zero TODOs left behind?
-- Zero console.logs or debug code?
+### 3. Business Logic Sound?
+- Does this make sense from a business perspective?
+- Are edge cases handled correctly for real-world scenarios?
+- Would domain experts find issues with this logic?
+- Does it handle regional/locale differences correctly?
+
+### 4. Clean & Complete?
+- Zero dead code, unused imports, TODOs?
 - All edge cases handled?
-- Error handling complete?
+- Error handling complete and user-friendly?
+- No debug artifacts left behind?
 
-### 4. Human Experience?
+### 5. Human Experience?
 - Is the UX intuitive? Would a user understand without explanation?
 - Are error messages helpful and actionable?
 - Is the UI responsive and accessible?
 - Does it feel polished, not janky?
 
-### 5. Better Way?
+### 6. Impact Beyond Code?
+- Does this affect public-facing content (SEO, OG tags, docs)?
+- Should README or documentation be updated?
+- Are there marketing/exposure implications?
+
+### 7. Better Way?
 - What would you do differently with unlimited time?
 - Is there a simpler solution you overlooked?
 - Could this be more elegant?

package/assets/slash-commands/e2e-audit.md

@@ -46,6 +46,12 @@ mcp__playwright__browser_snapshot - Get current page state
 - [ ] Boundary values (min/max)
 - [ ] Invalid inputs
 
+**Public-Facing Pages:**
+- [ ] Landing/home page — value prop clear? CTA works?
+- [ ] Pricing page — accurate? Links work?
+- [ ] Docs/help — accessible? Search works?
+- [ ] Social sharing — OG previews correct? Links work?
+
 ### 3. Test Business Logic
 
 **Region/Locale Consistency:**

package/assets/slash-commands/excellence.md

@@ -50,11 +50,13 @@ Based on this specific project's nature, determine what "excellence" means here.
 - Are there obvious bottlenecks?
 - Would performance engineers approve?
 
-### Public-Facing (Docs, README, Marketing)
-- Is the messaging compelling?
-- Would it attract users/contributors?
-- Is documentation clear and complete?
-- Does it convey professionalism and quality?
+### Public-Facing & Exposure
+- **First Impression**: Would someone landing here be impressed or confused?
+- **SEO/Discoverability**: Can people find this? Are meta tags, titles, descriptions optimized?
+- **Social Sharing**: Do OG tags, Twitter cards make people want to click?
+- **README/Docs**: World-class or bare minimum? Would it make someone star/fork?
+- **Landing Page**: Does it convert? Is the value prop crystal clear?
+- **Branding**: Consistent, professional, memorable?
 
 ## Process
 

package/assets/slash-commands/product.md

@@ -87,6 +87,14 @@ Evaluate product design holistically — from user experience to business impact
 - What's missing in the market that we could own?
 - If a user tried competitor after us, would they come back? Why?
 
+## 6. Public-Facing & Exposure
+
+- **Landing Page**: Does it convert? Value prop clear in 5 seconds?
+- **SEO**: Are we discoverable? Right keywords targeted?
+- **Social Sharing**: Do shared links look compelling? OG tags set?
+- **README**: Would a developer star this? Quick start clear?
+- **Docs**: Can users self-serve? Search works?
+
 ## Process
 
 1. **Walk through** the entire product as each user type

package/assets/slash-commands/refactor.md

@@ -5,56 +5,57 @@ description: Deep refactoring - modularity, deduplication, cleanup
 
 # Refactor: Deep Codebase Improvement
 
-Systematically refactor the codebase for maximum quality.
+Systematically refactor the codebase toward excellence. The goal is not just clean code, but code that is a joy to work with — maintainable, understandable, and extensible.
+
+## Why Refactor?
+
+> "Any fool can write code that a computer can understand. Good programmers write code that humans can understand." — Martin Fowler
+
+Refactoring is about:
+- **Future velocity** — clean code is faster to change
+- **Bug prevention** — simple code has fewer hiding places for bugs
+- **Onboarding** — new contributors can understand and contribute faster
+- **Pride** — code you'd be proud to show anyone
 
 ## Targets
 
-1. **Dead code** — remove all unused code, imports, variables, functions
-2. **Duplication** — extract shared logic, eliminate copy-paste
-3. **TODOs** — resolve or remove every TODO comment
-4. **Modularity** — split large files, extract reusable modules
-5. **Naming** — rename unclear variables, functions, files
-6. **Types** — strengthen typing, remove `any`, add missing types
-7. **Structure** — reorganize files into logical folders
-8. **Dependencies** — remove unused deps, update outdated ones
+1. **Dead code** — if it's not used, it's noise
+2. **Duplication** — DRY violations are bug factories
+3. **Complexity** — if it's hard to understand, it's wrong
+4. **Naming** — code should read like well-written prose
+5. **Types** — weak types are hidden bugs waiting to happen
+6. **Structure** — logical organization reduces cognitive load
+7. **Dependencies** — unused deps are attack surface and bloat
 
 ## Process
 
-### Phase 1: Scan
-
-1. Find dead code: unused exports, unreachable code
-2. Find duplication: similar code blocks, copy-paste patterns
-3. Find TODOs: `grep -r "TODO" --include="*.ts" --include="*.tsx"`
-4. Find large files: files > 300 lines
-5. Find weak types: `any`, missing return types
+### Phase 1: Understand
+- What is the code trying to do?
+- Why was it written this way?
+- What are the dependencies and side effects?
 
 ### Phase 2: Refactor
-
-For each issue found:
-1. Plan the refactor
-2. Make the change
-3. Run tests to verify no regression
+For each improvement:
+1. Understand the context first
+2. Make one logical change
+3. Verify behavior unchanged (tests, manual check)
 4. Commit atomically: `refactor: description`
-5. Push immediately
 
 ### Phase 3: Verify
+- Tests pass
+- Types check
+- Linter happy
+- Build succeeds
+- Behavior unchanged
 
-1. Run full test suite
-2. Run type check
-3. Run linter
-4. Verify build succeeds
-
-## Rules
+## Principles
 
-* One logical change per commit
-* Tests must pass after each refactor
-* No behavior changes — refactor only
-* If behavior change needed, separate commit
+* **Understand before changing** — never refactor blindly
+* **One change at a time** — atomic commits, easy to revert
+* **Behavior unchanged** — refactor ≠ rewrite
+* **Tests are your safety net** — if no tests, add them first
+* **When in doubt, simplify** — less code is usually better
 
 ## Exit Condition
 
-* Zero TODOs
-* Zero dead code
-* Zero duplication
-* All tests pass
-* All types strict
+The codebase should feel **clean, consistent, and comprehensible**.

package/assets/slash-commands/sweep.md

@@ -0,0 +1,124 @@
+---
+name: sweep
+description: Find and fix all similar patterns across the project
+---
+
+# Sweep: Propagate Excellence Across the Codebase
+
+You just did something — fixed a bug, improved code, optimized something, or established a pattern.
+
+Now **sweep** through the entire project and apply the same improvement everywhere it's relevant.
+
+## Mindset
+
+> "If I fixed this here, where else does the same issue exist?"
+> "If I improved this pattern, where else should it be applied?"
+> "Don't just fix the symptom — eliminate the entire class of problems."
+
+**Proactive, not reactive.** One fix should trigger a comprehensive sweep.
+
+## Process
+
+### 1. Identify What Was Just Done
+- What did you fix, improve, or create?
+- What pattern or principle does it represent?
+- What was wrong with the old approach?
+
+### 2. Define the Search Pattern
+- What does "similar" look like?
+- What code patterns indicate the same issue?
+- What files/modules are likely affected?
+
+### 3. Sweep the Codebase
+Search systematically:
+```
+- Same file type (*.tsx, *.ts, etc.)
+- Same directory/module
+- Same pattern (hooks, components, utils, etc.)
+- Same anti-pattern being fixed
+```
+
+### 4. Apply the Improvement Everywhere
+For each similar case found:
+- Apply the same fix/improvement
+- Ensure consistency with the original
+- Adapt as needed for context
+
+### 5. Verify Completeness
+- Did you catch everything?
+- Run one more search to confirm
+- No stragglers left behind
+
+## Examples
+
+### Code Pattern Sweep
+```
+Fixed: Null check missing in UserProfile
+Sweep: Find all components accessing user data without null checks
+Result: Fixed 12 similar issues across 8 files
+```
+
+### Type Safety Sweep
+```
+Fixed: Added proper TypeScript types to API response
+Sweep: Find all `any` types in API layer
+Result: Added proper types to 15 API functions
+```
+
+### Business Logic Sweep
+```
+Fixed: HK user was seeing CN tax options
+Sweep: Find all region-dependent logic, verify correctness
+Result: Fixed 5 similar locale issues across settings, billing, reports
+```
+
+### UX Pattern Sweep
+```
+Improved: Added loading state to save button
+Sweep: Find all async actions without loading feedback
+Result: Added loading states to 8 similar interactions
+```
+
+### Error Handling Sweep
+```
+Created: Reusable ErrorBoundary with retry
+Sweep: Find all ad-hoc error handling in components
+Result: Standardized error handling across 12 components
+```
+
+### Public-Facing Sweep
+```
+Fixed: Missing OG tags on product page
+Sweep: Find all public pages missing proper meta tags
+Result: Added OG/Twitter cards to 6 pages
+```
+
+## Output
+
+### Sweep Summary
+```
+Original Work: [what was done]
+Pattern Identified: [what to look for]
+Files Scanned: [count]
+Similar Cases Found: [count]
+Cases Fixed: [count]
+```
+
+### Changes Made
+| File | Change | Status |
+|------|--------|--------|
+| ... | ... | ✅ Fixed |
+
+### Verification
+- [ ] All similar patterns addressed
+- [ ] No regressions introduced
+- [ ] Consistency maintained
+
+## Remember
+
+* **One fix = comprehensive sweep** — never leave similar issues behind
+* **Think in patterns** — what class of problem did you just solve?
+* **Sweep all dimensions** — code, business logic, UX, public-facing
+* **Be thorough** — check everywhere: code, tests, docs, marketing pages
+* **Maintain consistency** — similar things should look and work similarly
+* **This is how you reach State of the Art** — excellence everywhere, not just in spots

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/flow",
-	"version": "3.5.0",
+	"version": "3.6.1",
 	"description": "One CLI to rule them all. Unified orchestration layer for AI coding assistants. Auto-detection, auto-installation, auto-upgrade.",
 	"type": "module",
 	"bin": {