agileflow 3.4.3 → 4.0.0-alpha.2

package/src/core/commands/learn/glossary.md

@@ -1,135 +0,0 @@
----
-description: Auto-generate domain terminology glossary from code identifiers, comments, and documentation with definitions and context
-argument-hint: "[file|directory] [--update] [--format=table|definitions]"
----
-
-# /agileflow:learn:glossary
-
-Auto-generate a domain terminology glossary by analyzing code identifiers, comments, and documentation. Maps domain-specific terms to their meaning in the codebase context.
-
----
-
-## Quick Reference
-
-```
-/agileflow:learn:glossary                                  # Generate from entire project
-/agileflow:learn:glossary src/                             # Generate from specific directory
-/agileflow:learn:glossary --update                         # Update existing glossary
-/agileflow:learn:glossary --format=definitions             # Definition-style output
-```
-
----
-
-## How It Works
-
-1. **Extract identifiers** - Collect class names, function names, type names, constants
-2. **Analyze comments** - Find inline documentation and JSDoc descriptions
-3. **Detect domain terms** - Identify business/domain-specific vocabulary
-4. **Generate definitions** - Create clear, contextual definitions
-5. **Organize alphabetically** - Create a browsable reference
-
----
-
-## Step-by-Step Process
-
-### STEP 1: Parse Arguments
-
-```
-TARGET = file or directory (default: current directory)
-UPDATE = --update flag to merge with existing glossary
-FORMAT = table (default) or definitions
-```
-
-### STEP 2: Extract Domain Terms
-
-Scan the codebase for domain-specific terms:
-
-**Sources**:
-- Class and interface names (e.g., `OrderFulfillment`, `PricingTier`)
-- Type aliases and enums (e.g., `type OrderStatus = 'pending' | 'shipped'`)
-- Constants (e.g., `MAX_RETRY_ATTEMPTS`, `DEFAULT_CURRENCY`)
-- Database table/column names
-- API endpoint names and parameters
-- JSDoc comments with @description
-- README and documentation files
-
-**Filtering**:
-- Exclude common programming terms (get, set, handle, process)
-- Exclude framework terms (useState, useEffect, middleware)
-- Focus on business/domain-specific vocabulary
-
-### STEP 3: Generate Definitions
-
-For each term, generate a definition:
-
-```markdown
-### {Term}
-
-**Type**: {class | type | function | constant | concept}
-**Found in**: `{file_path}`
-**Definition**: {clear, contextual definition}
-**Example**: `{code usage example}`
-**Related terms**: {list of related terms}
-```
-
-### STEP 4: Organize and Output
-
-```markdown
-# Domain Glossary
-
-**Project**: {project name}
-**Generated**: {date}
-**Terms**: {N}
-
-## A
-
-### Account
-**Type**: model
-**Found in**: `src/models/Account.ts`
-**Definition**: A registered user entity with authentication credentials and profile information.
-**Related**: User, Session, Subscription
-
-### ACL (Access Control List)
-**Type**: concept
-**Found in**: `src/auth/acl.ts`
-**Definition**: Permission rules mapping roles to allowed operations on resources.
-**Related**: Role, Permission, Authorization
-
-## B
-...
-```
-
-Save to `docs/08-project/glossary.md`
-
-### STEP 5: Offer Follow-Up
-
-```
-Glossary generated: [N] domain terms extracted from [M] files.
-
-Options:
-- Add/edit specific term definitions
-- Generate glossary for specific module
-- Explain a specific term in depth
-- Done
-```
-
----
-
-## Output Formats
-
-**Table format** (default):
-| Term | Type | Definition | File |
-|------|------|------------|------|
-| Account | model | Registered user entity | models/Account.ts |
-
-**Definitions format** (--format=definitions):
-Full definition blocks with examples and related terms.
-
----
-
-## Related Commands
-
-- `/agileflow:learn:tour` - Guided codebase walkthrough
-- `/agileflow:learn:explain` - Deep code explanation
-- `/agileflow:learn:patterns` - Design patterns catalog
-- `/agileflow:docs` - Documentation synchronization

package/src/core/commands/learn/patterns.md

@@ -1,138 +0,0 @@
----
-description: Catalog and explain design patterns actually used in the codebase with real code examples and rationale
-argument-hint: "[pattern-name|category] [--generate]"
----
-
-# /agileflow:learn:patterns
-
-Discover and catalog the design patterns actually used in the codebase. Shows real code examples, explains why each pattern was chosen, and documents the project's architectural vocabulary.
-
----
-
-## Quick Reference
-
-```
-/agileflow:learn:patterns                                  # Discover all patterns
-/agileflow:learn:patterns "repository"                     # Find repository pattern usage
-/agileflow:learn:patterns --generate                       # Generate full pattern catalog
-/agileflow:learn:patterns "error handling"                  # How errors are handled
-/agileflow:learn:patterns creational                       # Creational patterns only
-```
-
----
-
-## How It Works
-
-1. **Scan codebase** - Identify design patterns in use
-2. **Extract examples** - Find real code examples of each pattern
-3. **Document rationale** - Explain why each pattern was chosen
-4. **Categorize** - Group by pattern category
-5. **Generate catalog** - Create a reference document
-
----
-
-## Step-by-Step Process
-
-### STEP 1: Parse Arguments
-
-```
-TARGET = specific pattern name, category, or "all"
-GENERATE = --generate flag to create/update catalog file
-```
-
-### STEP 2: Scan for Patterns
-
-Use `Explore` agent to identify patterns:
-
-| Category | Patterns to Detect |
-|----------|-------------------|
-| **Creational** | Factory, Builder, Singleton, Module |
-| **Structural** | Adapter, Facade, Proxy, Decorator, Composite |
-| **Behavioral** | Observer/PubSub, Strategy, Command, Middleware, State Machine |
-| **Architectural** | MVC, Repository, Service Layer, CQRS, Event Sourcing |
-| **Frontend** | Container/Presenter, HOC, Render Props, Custom Hooks, Compound Components |
-| **Error Handling** | Error Boundary, Result Type, Error Middleware, Retry |
-| **Data** | DAO, Active Record, Data Mapper, Unit of Work |
-
-### STEP 3: Extract Examples
-
-For each detected pattern:
-
-```markdown
-## {Pattern Name}
-
-**Category**: {Creational/Structural/Behavioral/etc.}
-**Used in**: {N} places
-**Key files**: {list}
-
-### What It Is
-{Brief pattern description}
-
-### How We Use It
-{Explanation specific to this codebase}
-
-### Real Example
-\`\`\`{language}
-// {file_path}:{line}
-{actual code from the project}
-\`\`\`
-
-### Why This Pattern
-{Rationale for choosing this pattern over alternatives}
-
-### When to Use
-{Guidelines for when to apply this pattern in new code}
-```
-
-### STEP 4: Generate Catalog (if --generate)
-
-```markdown
-# Design Patterns Catalog
-
-**Project**: {project name}
-**Generated**: {date}
-**Patterns Found**: {N}
-
-## Pattern Overview
-
-| Pattern | Category | Usage Count | Key File |
-|---------|----------|-------------|----------|
-| {name} | {category} | {count} | {file} |
-
-## Detailed Patterns
-
-{Each pattern with full documentation}
-
-## Patterns NOT Used (and Why)
-
-| Pattern | Reason |
-|---------|--------|
-| {name} | {why it's not used or not appropriate} |
-
-## Conventions
-
-{Project-specific conventions for applying patterns}
-```
-
-Save to `docs/08-project/patterns/pattern-catalog-{YYYYMMDD}.md`
-
-### STEP 5: Offer Follow-Up
-
-```
-Pattern catalog: [N] patterns found across [M] files.
-
-Options:
-- Explain a specific pattern in more detail
-- See where to apply a pattern in new code
-- Generate full catalog document
-- Done
-```
-
----
-
-## Related Commands
-
-- `/agileflow:learn:tour` - Guided codebase walkthrough
-- `/agileflow:learn:explain` - Deep code explanation
-- `/agileflow:learn:glossary` - Domain terminology
-- `/agileflow:code:architecture` - Architecture health audit

package/src/core/commands/learn/tour.md

@@ -1,126 +0,0 @@
----
-description: Guided interactive codebase walkthrough with annotated stops explaining architecture, data flow, and key design decisions
-argument-hint: "[topic|feature] [DEPTH=overview|detailed|deep-dive]"
----
-
-# /agileflow:learn:tour
-
-Take an interactive guided tour through the codebase. The tour visits key files and explains architecture, data flow, and design decisions with annotated stops.
-
----
-
-## Quick Reference
-
-```
-/agileflow:learn:tour                                     # Full architecture tour
-/agileflow:learn:tour authentication                      # Tour the auth system
-/agileflow:learn:tour "data flow"                         # Follow data through the system
-/agileflow:learn:tour api DEPTH=deep-dive                 # Deep dive into API layer
-/agileflow:learn:tour "new developer"                     # Onboarding tour
-```
-
----
-
-## How It Works
-
-1. **Discover project structure** - Map the codebase architecture
-2. **Generate tour route** - Plan stops based on topic and depth
-3. **Interactive walkthrough** - Visit each stop with explanation
-4. **Ask questions** - Pause at each stop for user questions
-5. **Generate tour notes** - Save the tour as a reference document
-
----
-
-## Step-by-Step Process
-
-### STEP 1: Parse Arguments
-
-```
-TOPIC = specific feature/area or "full" for complete tour
-DEPTH = overview (5-8 stops) | detailed (10-15 stops) | deep-dive (15-25 stops)
-```
-
-### STEP 2: Discover Project Structure
-
-Use `Explore` agent to:
-- Map directory structure and architecture pattern
-- Identify entry points (main, index, app)
-- Find key configuration files
-- Detect framework and key libraries
-
-### STEP 3: Plan Tour Route
-
-Generate a sequence of stops based on topic:
-
-**Full Tour Route**:
-1. Entry point (main app file)
-2. Configuration and environment
-3. Routing/navigation structure
-4. Data models/schema
-5. API/service layer
-6. UI components (key ones)
-7. State management
-8. Authentication/authorization
-9. Testing approach
-
-**Feature-Specific Tour**: Follow the feature through:
-1. Entry point (where user triggers it)
-2. Route/handler
-3. Business logic
-4. Data access
-5. Side effects (email, queue, etc.)
-6. UI rendering
-
-### STEP 4: Interactive Walkthrough
-
-At each stop:
-
-```markdown
-## Stop {N}/{Total}: {Title}
-📍 `{file_path}`
-
-{Read and explain the key code in this file}
-
-**Why it matters**: {explanation of role in the system}
-**Key patterns**: {design patterns used}
-**Connected to**: {what files/modules this connects to}
-
----
-Continue to next stop? [Next | Ask a question | Jump to specific stop | End tour]
-```
-
-### STEP 5: Generate Tour Notes
-
-Save a reference document:
-
-```markdown
-# Codebase Tour: {Topic}
-
-**Date**: {date}
-**Stops**: {N}
-**Coverage**: {files visited}
-
-## Tour Map
-1. {file} - {one-line summary}
-2. {file} - {one-line summary}
-...
-
-## Key Takeaways
-- {insight 1}
-- {insight 2}
-...
-
-## Architecture Diagram
-{Mermaid diagram of the system}
-```
-
-Save to `docs/08-project/tours/tour-{topic}-{YYYYMMDD}.md`
-
----
-
-## Related Commands
-
-- `/agileflow:learn:explain` - Deep "why" explanation of specific code
-- `/agileflow:learn:patterns` - Catalog of design patterns used
-- `/agileflow:learn:glossary` - Domain terminology reference
-- `/agileflow:context:full` - Generate full project context