@atlashub/smartstack-cli 1.5.1 → 1.5.2

package/templates/commands/create.md

@@ -1,220 +1,220 @@
----
-description: Create SmartStack projects and extensions
-argument-hint: <type> <name> [description]
----
-
-# SmartStack Creator
-
-Create complete project structures for SmartStack applications and extensions.
-
-## Supported Types
-
-| Type | Command | Description |
-|------|---------|-------------|
-| **project** | `/create:project` | Full-stack app (.NET + React + Vite + Tailwind) |
-| **command** | `/create:command` | Slash command (like /apex, /gitflow) |
-| **agent** | `/create:agent` | Specialized execution agent |
-| **skill** | `/create:skill` | Multi-phase workflow orchestrator |
-| **hook** | `/create:hook` | Git operation validator |
-| **plugin** | `/create:plugin` | Full CLI extension with all types |
-
-## Quick Usage
-
-```
-/create project MyApp "My awesome full-stack application"
-/create command my-feature "Description of my feature command"
-/create agent code-reviewer "Agent for reviewing code quality"
-/create skill deployment "Multi-phase deployment workflow"
-/create hook security-check "Pre-commit security validation"
-/create plugin my-toolkit "Complete CLI toolkit extension"
-```
-
-## Workflow
-
-### 1. PARSE ARGUMENTS
-
-Extract from `$ARGUMENTS`:
-- **type**: command | agent | skill | hook | plugin
-- **name**: Extension name (kebab-case)
-- **description**: Optional description
-
-If arguments missing, use AskUserQuestion to gather:
-- Type of extension
-- Name (validate kebab-case)
-- Description
-
-### 2. VALIDATE
-
-Check:
-- Name is valid kebab-case: `^[a-z][a-z0-9-]*$`
-- Type is supported
-- Target directory doesn't already exist
-
-### 3. CREATE PROJECT STRUCTURE
-
-Create the following structure:
-
-```
-smartstack-{name}/
-├── package.json              # npm package configuration
-├── tsconfig.json             # TypeScript configuration
-├── tsup.config.ts            # Build configuration
-├── README.md                 # Documentation
-├── .gitignore                # Git ignore rules
-├── src/
-│   └── index.ts              # Main entry point
-└── templates/
-    ├── commands/             # Command templates
-    │   └── {name}.md
-    ├── agents/               # Agent templates
-    │   └── {name}.md
-    ├── skills/               # Skill templates
-    │   └── {name}/
-    │       ├── SKILL.md
-    │       └── 1-*.md (phases)
-    └── hooks/                # Hook templates
-        └── {name}.md
-```
-
-### 4. GENERATE FILES
-
-Use the Write tool to create each file with proper content.
-
-**File Generation Order:**
-1. Create root directory
-2. Create package.json
-3. Create tsconfig.json
-4. Create tsup.config.ts
-5. Create src/index.ts
-6. Create README.md
-7. Create .gitignore
-8. Create templates based on type
-
-### 5. SHOW NEXT STEPS
-
-Display instructions for:
-- Installing dependencies
-- Editing templates
-- Building the extension
-- Publishing
-
-## Type-Specific Templates
-
-### Command Template Structure
-
-```yaml
----
-description: {description}
-argument-hint: <task-description>
----
-
-# {PascalCaseName}
-
-{description}
-
-## Workflow
-[phases]
-
-## Execution Rules
-[rules]
-
-## Priority
-[priority statement]
-
----
-User: $ARGUMENTS
-```
-
-### Agent Template Structure
-
-```yaml
----
-name: {kebab-case-name}
-description: {description}
-color: yellow
-model: haiku
----
-
-# {PascalCaseName} Agent
-
-## Search Strategy
-[strategy]
-
-## Output Format
-[format]
-```
-
-### Skill Template Structure
-
-```yaml
----
-name: {kebab-case-name}
-description: {description}
----
-
-# {PascalCaseName} Skill
-
-## Phases
-[phase table]
-
-## Workflow Diagram
-[ASCII diagram]
-
-## Model Strategy
-[cost table]
-```
-
-### Hook Template Structure
-
-```yaml
----
-description: {description}
-trigger: pre-commit
-blocking: true
----
-
-# {PascalCaseName} Hook
-
-## Patterns to Detect
-[patterns]
-
-## Detection Script
-[bash script]
-```
-
-## Execution Rules
-
-1. **ALWAYS** validate name format before creating files
-2. **NEVER** overwrite existing directories
-3. Use Write tool for all file creation
-4. Generate complete, working templates
-5. Include practical examples in generated code
-
-## Output Format
-
-After creation, display:
-
-```
-╔═══════════════════════════════════════════════════════════╗
-║           SMARTSTACK EXTENSION CREATED                    ║
-╠═══════════════════════════════════════════════════════════╣
-║  Name:     smartstack-{name}                              ║
-║  Type:     {type}                                         ║
-║  Location: {full-path}                                    ║
-╠═══════════════════════════════════════════════════════════╣
-║  Next steps:                                              ║
-║  1. cd smartstack-{name}                                  ║
-║  2. npm install                                           ║
-║  3. Edit templates in templates/ folder                   ║
-║  4. npm run build                                         ║
-║  5. npm publish (when ready)                              ║
-╚═══════════════════════════════════════════════════════════╝
-```
-
-## Priority
-
-Completeness > Correctness > Speed
-
----
-
-User: $ARGUMENTS
+---
+description: Create SmartStack projects and extensions
+argument-hint: <type> <name> [description]
+---
+
+# SmartStack Creator
+
+Create complete project structures for SmartStack applications and extensions.
+
+## Supported Types
+
+| Type | Command | Description |
+|------|---------|-------------|
+| **project** | `/create:project` | Full-stack app (.NET + React + Vite + Tailwind) |
+| **command** | `/create:command` | Slash command (like /apex, /gitflow) |
+| **agent** | `/create:agent` | Specialized execution agent |
+| **skill** | `/create:skill` | Multi-phase workflow orchestrator |
+| **hook** | `/create:hook` | Git operation validator |
+| **plugin** | `/create:plugin` | Full CLI extension with all types |
+
+## Quick Usage
+
+```
+/create project MyApp "My awesome full-stack application"
+/create command my-feature "Description of my feature command"
+/create agent code-reviewer "Agent for reviewing code quality"
+/create skill deployment "Multi-phase deployment workflow"
+/create hook security-check "Pre-commit security validation"
+/create plugin my-toolkit "Complete CLI toolkit extension"
+```
+
+## Workflow
+
+### 1. PARSE ARGUMENTS
+
+Extract from `$ARGUMENTS`:
+- **type**: command | agent | skill | hook | plugin
+- **name**: Extension name (kebab-case)
+- **description**: Optional description
+
+If arguments missing, use AskUserQuestion to gather:
+- Type of extension
+- Name (validate kebab-case)
+- Description
+
+### 2. VALIDATE
+
+Check:
+- Name is valid kebab-case: `^[a-z][a-z0-9-]*$`
+- Type is supported
+- Target directory doesn't already exist
+
+### 3. CREATE PROJECT STRUCTURE
+
+Create the following structure:
+
+```
+smartstack-{name}/
+├── package.json              # npm package configuration
+├── tsconfig.json             # TypeScript configuration
+├── tsup.config.ts            # Build configuration
+├── README.md                 # Documentation
+├── .gitignore                # Git ignore rules
+├── src/
+│   └── index.ts              # Main entry point
+└── templates/
+    ├── commands/             # Command templates
+    │   └── {name}.md
+    ├── agents/               # Agent templates
+    │   └── {name}.md
+    ├── skills/               # Skill templates
+    │   └── {name}/
+    │       ├── SKILL.md
+    │       └── 1-*.md (phases)
+    └── hooks/                # Hook templates
+        └── {name}.md
+```
+
+### 4. GENERATE FILES
+
+Use the Write tool to create each file with proper content.
+
+**File Generation Order:**
+1. Create root directory
+2. Create package.json
+3. Create tsconfig.json
+4. Create tsup.config.ts
+5. Create src/index.ts
+6. Create README.md
+7. Create .gitignore
+8. Create templates based on type
+
+### 5. SHOW NEXT STEPS
+
+Display instructions for:
+- Installing dependencies
+- Editing templates
+- Building the extension
+- Publishing
+
+## Type-Specific Templates
+
+### Command Template Structure
+
+```yaml
+---
+description: {description}
+argument-hint: <task-description>
+---
+
+# {PascalCaseName}
+
+{description}
+
+## Workflow
+[phases]
+
+## Execution Rules
+[rules]
+
+## Priority
+[priority statement]
+
+---
+User: $ARGUMENTS
+```
+
+### Agent Template Structure
+
+```yaml
+---
+name: {kebab-case-name}
+description: {description}
+color: yellow
+model: haiku
+---
+
+# {PascalCaseName} Agent
+
+## Search Strategy
+[strategy]
+
+## Output Format
+[format]
+```
+
+### Skill Template Structure
+
+```yaml
+---
+name: {kebab-case-name}
+description: {description}
+---
+
+# {PascalCaseName} Skill
+
+## Phases
+[phase table]
+
+## Workflow Diagram
+[ASCII diagram]
+
+## Model Strategy
+[cost table]
+```
+
+### Hook Template Structure
+
+```yaml
+---
+description: {description}
+trigger: pre-commit
+blocking: true
+---
+
+# {PascalCaseName} Hook
+
+## Patterns to Detect
+[patterns]
+
+## Detection Script
+[bash script]
+```
+
+## Execution Rules
+
+1. **ALWAYS** validate name format before creating files
+2. **NEVER** overwrite existing directories
+3. Use Write tool for all file creation
+4. Generate complete, working templates
+5. Include practical examples in generated code
+
+## Output Format
+
+After creation, display:
+
+```
+╔═══════════════════════════════════════════════════════════╗
+║           SMARTSTACK EXTENSION CREATED                    ║
+╠═══════════════════════════════════════════════════════════╣
+║  Name:     smartstack-{name}                              ║
+║  Type:     {type}                                         ║
+║  Location: {full-path}                                    ║
+╠═══════════════════════════════════════════════════════════╣
+║  Next steps:                                              ║
+║  1. cd smartstack-{name}                                  ║
+║  2. npm install                                           ║
+║  3. Edit templates in templates/ folder                   ║
+║  4. npm run build                                         ║
+║  5. npm publish (when ready)                              ║
+╚═══════════════════════════════════════════════════════════╝
+```
+
+## Priority
+
+Completeness > Correctness > Speed
+
+---
+
+User: $ARGUMENTS

package/templates/commands/debug.md

@@ -1,95 +1,95 @@
----
-description: Systematic bug debugging with deep analysis and resolution
-argument-hint: <log|error|problem-description>
-allowed-tools: Bash, Read, Edit, MultiEdit, Write, Grep, Glob, Task, WebSearch, WebFetch
----
-
-You are a systematic debugging specialist. Follow this ultra-deep analysis workflow to identify, understand, and resolve bugs.
-
-**You need to always ULTRA THINK.**
-
-## Workflow
-
-1. **ANALYZE**: Deep log/error analysis
-   - Parse the provided log/error message carefully
-   - Extract key error patterns, stack traces, and symptoms
-   - Identify error types: runtime, compile-time, logic, performance
-   - **CRITICAL**: Document exact error context and reproduction steps
-
-2. **EXPLORE**: Targeted codebase investigation
-   - Launch **parallel subagents** to search for error-related code (`explore-codebase`, `explore-docs`, `websearch`)
-   - Search for similar error patterns in codebase using Grep
-   - Find all files related to the failing component/module
-   - Examine recent changes that might have introduced the bug
-   - **ULTRA THINK**: Connect error symptoms to potential root causes
-
-3. **ULTRA-THINK**: Deep root cause analysis
-   - **THINK DEEPLY** about the error chain: symptoms → immediate cause → root cause
-   - Consider all possible causes:
-     - Code logic errors
-     - Configuration issues
-     - Environment problems
-     - Race conditions
-     - Memory issues
-     - Network problems
-   - **CRITICAL**: Map the complete failure path from root cause to visible symptom
-   - Validate hypotheses against the evidence
-
-4. **RESEARCH**: Solution investigation
-   - Launch **parallel subagents** for web research (`websearch`)
-   - Search for similar issues and solutions online
-   - Check documentation for affected libraries/frameworks
-   - Look for known bugs, workarounds, and best practices
-   - **THINK**: Evaluate solution approaches for this specific context
-
-5. **IMPLEMENT**: Systematic resolution
-   - Choose the most appropriate solution based on analysis
-   - Follow existing codebase patterns and conventions
-   - Implement minimal, targeted fixes
-   - **STAY IN SCOPE**: Fix only what's needed for this specific bug
-   - Add defensive programming where appropriate
-
-6. **VERIFY**: Comprehensive testing
-   - Test the specific scenario that was failing
-   - Run related tests to ensure no regressions
-   - Check edge cases around the fix
-   - **CRITICAL**: Verify the original error is completely resolved
-
-## Deep Analysis Techniques
-
-### Log Analysis
-
-- Extract timestamps, error codes, stack traces
-- Identify error propagation patterns
-- Look for correlation with system events
-
-### Code Investigation
-
-- Trace execution path to error location
-- Check variable states and data flow
-- Examine error handling patterns
-- Review recent commits affecting the area
-
-### Root Cause Mapping
-
-- **WHY technique**: Ask "why" 5 times minimum
-- Consider environmental factors
-- Check for timing/concurrency issues
-- Validate assumptions about data/state
-
-## Execution Rules
-
-- **ULTRA THINK** at each phase transition
-- Use parallel agents for comprehensive investigation
-- Document findings and reasoning at each step
-- **NEVER guess** - validate all hypotheses with evidence
-- **MINIMAL CHANGES**: Fix root cause, not symptoms
-- Test thoroughly before declaring resolution complete
-
-## Priority
-
-Understanding > Speed > Completeness. Every bug must be fully understood before attempting fixes.
-
----
-
-User: $ARGUMENTS
+---
+description: Systematic bug debugging with deep analysis and resolution
+argument-hint: <log|error|problem-description>
+allowed-tools: Bash, Read, Edit, MultiEdit, Write, Grep, Glob, Task, WebSearch, WebFetch
+---
+
+You are a systematic debugging specialist. Follow this ultra-deep analysis workflow to identify, understand, and resolve bugs.
+
+**You need to always ULTRA THINK.**
+
+## Workflow
+
+1. **ANALYZE**: Deep log/error analysis
+   - Parse the provided log/error message carefully
+   - Extract key error patterns, stack traces, and symptoms
+   - Identify error types: runtime, compile-time, logic, performance
+   - **CRITICAL**: Document exact error context and reproduction steps
+
+2. **EXPLORE**: Targeted codebase investigation
+   - Launch **parallel subagents** to search for error-related code (`explore-codebase`, `explore-docs`, `websearch`)
+   - Search for similar error patterns in codebase using Grep
+   - Find all files related to the failing component/module
+   - Examine recent changes that might have introduced the bug
+   - **ULTRA THINK**: Connect error symptoms to potential root causes
+
+3. **ULTRA-THINK**: Deep root cause analysis
+   - **THINK DEEPLY** about the error chain: symptoms → immediate cause → root cause
+   - Consider all possible causes:
+     - Code logic errors
+     - Configuration issues
+     - Environment problems
+     - Race conditions
+     - Memory issues
+     - Network problems
+   - **CRITICAL**: Map the complete failure path from root cause to visible symptom
+   - Validate hypotheses against the evidence
+
+4. **RESEARCH**: Solution investigation
+   - Launch **parallel subagents** for web research (`websearch`)
+   - Search for similar issues and solutions online
+   - Check documentation for affected libraries/frameworks
+   - Look for known bugs, workarounds, and best practices
+   - **THINK**: Evaluate solution approaches for this specific context
+
+5. **IMPLEMENT**: Systematic resolution
+   - Choose the most appropriate solution based on analysis
+   - Follow existing codebase patterns and conventions
+   - Implement minimal, targeted fixes
+   - **STAY IN SCOPE**: Fix only what's needed for this specific bug
+   - Add defensive programming where appropriate
+
+6. **VERIFY**: Comprehensive testing
+   - Test the specific scenario that was failing
+   - Run related tests to ensure no regressions
+   - Check edge cases around the fix
+   - **CRITICAL**: Verify the original error is completely resolved
+
+## Deep Analysis Techniques
+
+### Log Analysis
+
+- Extract timestamps, error codes, stack traces
+- Identify error propagation patterns
+- Look for correlation with system events
+
+### Code Investigation
+
+- Trace execution path to error location
+- Check variable states and data flow
+- Examine error handling patterns
+- Review recent commits affecting the area
+
+### Root Cause Mapping
+
+- **WHY technique**: Ask "why" 5 times minimum
+- Consider environmental factors
+- Check for timing/concurrency issues
+- Validate assumptions about data/state
+
+## Execution Rules
+
+- **ULTRA THINK** at each phase transition
+- Use parallel agents for comprehensive investigation
+- Document findings and reasoning at each step
+- **NEVER guess** - validate all hypotheses with evidence
+- **MINIMAL CHANGES**: Fix root cause, not symptoms
+- Test thoroughly before declaring resolution complete
+
+## Priority
+
+Understanding > Speed > Completeness. Every bug must be fully understood before attempting fixes.
+
+---
+
+User: $ARGUMENTS