@atlashub/smartstack-cli 1.3.0 → 1.4.1

package/templates/commands/create/project.md

@@ -0,0 +1,507 @@
+---
+description: Create a full-stack SmartStack project (Clean Architecture .NET + React/Vite/Tailwind)
+argument-hint: <project-name> [description]
+---
+
+# Create SmartStack Project
+
+Scaffold a complete full-stack project with:
+- **Backend**: .NET 10 Clean Architecture (Domain, Application, Infrastructure, Api)
+- **Frontend**: React 19 + TypeScript + Vite + Tailwind CSS
+
+## Arguments
+
+Parse from `$ARGUMENTS`:
+- **name** (required): Project name in PascalCase (e.g., `MyProject`)
+- **description** (optional): Project description
+
+## Project Structure
+
+```
+{ProjectName}/
+├── .gitignore
+├── .claudeignore
+├── README.md
+├── CLAUDE.md
+├── LICENSE
+├── Directory.Build.props
+├── {ProjectName}.sln
+│
+├── src/
+│   ├── {ProjectName}.Domain/
+│   │   ├── {ProjectName}.Domain.csproj
+│   │   ├── Common/
+│   │   │   ├── BaseEntity.cs
+│   │   │   ├── IAuditableEntity.cs
+│   │   │   └── IDomainEvent.cs
+│   │   ├── Entities/
+│   │   ├── Enums/
+│   │   ├── Exceptions/
+│   │   │   └── DomainException.cs
+│   │   └── ValueObjects/
+│   │
+│   ├── {ProjectName}.Application/
+│   │   ├── {ProjectName}.Application.csproj
+│   │   ├── Common/
+│   │   │   ├── Behaviors/
+│   │   │   │   ├── ValidationBehavior.cs
+│   │   │   │   └── LoggingBehavior.cs
+│   │   │   ├── Interfaces/
+│   │   │   │   ├── IApplicationDbContext.cs
+│   │   │   │   └── ICurrentUserService.cs
+│   │   │   └── Models/
+│   │   │       └── Result.cs
+│   │   ├── Features/
+│   │   │   └── .gitkeep
+│   │   └── DependencyInjection.cs
+│   │
+│   ├── {ProjectName}.Infrastructure/
+│   │   ├── {ProjectName}.Infrastructure.csproj
+│   │   ├── Persistence/
+│   │   │   ├── ApplicationDbContext.cs
+│   │   │   ├── Configurations/
+│   │   │   │   └── .gitkeep
+│   │   │   ├── Migrations/
+│   │   │   │   └── .gitkeep
+│   │   │   └── Seeding/
+│   │   │       └── DatabaseSeeder.cs
+│   │   ├── Services/
+│   │   │   └── DateTimeService.cs
+│   │   └── DependencyInjection.cs
+│   │
+│   ├── {ProjectName}.Api.Core/
+│   │   ├── {ProjectName}.Api.Core.csproj
+│   │   ├── Controllers/
+│   │   │   └── BaseApiController.cs
+│   │   ├── Extensions/
+│   │   │   └── ServiceCollectionExtensions.cs
+│   │   ├── Middleware/
+│   │   │   └── ExceptionHandlingMiddleware.cs
+│   │   └── Hubs/
+│   │       └── NotificationHub.cs
+│   │
+│   └── {ProjectName}.Api/
+│       ├── {ProjectName}.Api.csproj
+│       ├── Properties/
+│       │   └── launchSettings.json
+│       ├── appsettings.json
+│       ├── appsettings.Development.json
+│       ├── appsettings.Production.json
+│       └── Program.cs
+│
+├── web/
+│   └── {project-name}-web/
+│       ├── package.json
+│       ├── tsconfig.json
+│       ├── tsconfig.app.json
+│       ├── tsconfig.node.json
+│       ├── vite.config.ts
+│       ├── eslint.config.mjs
+│       ├── tailwind.config.js
+│       ├── postcss.config.js
+│       ├── index.html
+│       ├── .env.example
+│       └── src/
+│           ├── main.tsx
+│           ├── App.tsx
+│           ├── index.css
+│           ├── vite-env.d.ts
+│           ├── components/
+│           │   ├── layout/
+│           │   │   ├── Header.tsx
+│           │   │   ├── Sidebar.tsx
+│           │   │   └── Footer.tsx
+│           │   └── ui/
+│           │       ├── Button.tsx
+│           │       └── Card.tsx
+│           ├── pages/
+│           │   ├── HomePage.tsx
+│           │   └── NotFoundPage.tsx
+│           ├── hooks/
+│           │   └── useApi.ts
+│           ├── contexts/
+│           │   ├── AuthContext.tsx
+│           │   └── ThemeContext.tsx
+│           ├── services/
+│           │   └── api/
+│           │       └── client.ts
+│           ├── types/
+│           │   └── index.ts
+│           ├── utils/
+│           │   └── helpers.ts
+│           └── config/
+│               └── constants.ts
+│
+├── tests/
+│   └── {ProjectName}.Tests/
+│       └── {ProjectName}.Tests.csproj
+│
+└── tools/
+    └── .gitkeep
+```
+
+## Workflow
+
+### 1. PARSE & VALIDATE
+
+Extract from `$ARGUMENTS`:
+```
+name: PascalCase project name (e.g., "MyProject")
+description: Optional description
+```
+
+Validate:
+- Name is PascalCase: `^[A-Z][a-zA-Z0-9]*$`
+- Directory doesn't exist
+- Name is not a reserved word
+
+### 2. CREATE ROOT STRUCTURE
+
+Use Bash to create directories:
+```bash
+mkdir -p {ProjectName}/src
+mkdir -p {ProjectName}/web
+mkdir -p {ProjectName}/tests
+mkdir -p {ProjectName}/tools
+mkdir -p {ProjectName}/scripts
+```
+
+### 3. GENERATE BACKEND FILES
+
+For each backend project, use Write tool to create:
+
+#### 3.1 Directory.Build.props
+```xml
+<Project>
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <Version>1.0.0</Version>
+    <Authors>{Author}</Authors>
+    <Company>{Company}</Company>
+  </PropertyGroup>
+</Project>
+```
+
+#### 3.2 Solution File ({ProjectName}.sln)
+Use `dotnet new sln` and `dotnet sln add` commands.
+
+#### 3.3 Domain Project
+- Create .csproj with MediatR.Contracts
+- Create BaseEntity.cs, IDomainEvent.cs
+- Create folder structure
+
+#### 3.4 Application Project
+- Create .csproj with MediatR, FluentValidation
+- Create Result.cs, ValidationBehavior.cs
+- Create DependencyInjection.cs
+
+#### 3.5 Infrastructure Project
+- Create .csproj with EF Core, SqlServer
+- Create ApplicationDbContext.cs
+- Create DependencyInjection.cs
+
+#### 3.6 Api.Core Project
+- Create .csproj with ASP.NET Core
+- Create BaseApiController.cs
+- Create ExceptionHandlingMiddleware.cs
+
+#### 3.7 Api Project
+- Create .csproj as entry point
+- Create Program.cs with full bootstrap
+- Create appsettings.json files
+
+### 4. GENERATE FRONTEND FILES
+
+#### 4.1 package.json
+```json
+{
+  "name": "{project-name}-web",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-router-dom": "^7.0.0",
+    "axios": "^1.7.0",
+    "@microsoft/signalr": "^8.0.0",
+    "lucide-react": "^0.400.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "typescript": "~5.6.0",
+    "vite": "^6.0.0",
+    "tailwindcss": "^4.0.0",
+    "@tailwindcss/vite": "^4.0.0",
+    "eslint": "^9.0.0"
+  }
+}
+```
+
+#### 4.2 vite.config.ts
+```typescript
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  server: {
+    port: 5173,
+    proxy: {
+      '/api': 'http://localhost:5000'
+    }
+  }
+})
+```
+
+#### 4.3 React Components
+- Create App.tsx with router setup
+- Create basic layout components
+- Create context providers
+- Create API client
+
+### 5. GENERATE CONFIGURATION FILES
+
+#### .gitignore
+```
+# .NET
+bin/
+obj/
+*.user
+*.suo
+appsettings.Local.json
+
+# Node
+node_modules/
+dist/
+.env.local
+
+# IDE
+.vs/
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+```
+
+#### CLAUDE.md
+```markdown
+# {ProjectName} Architecture Memory
+
+## Project Overview
+{description}
+
+## Technology Stack
+- Backend: .NET 10, EF Core, Clean Architecture
+- Frontend: React 19, TypeScript, Vite, Tailwind CSS
+- Database: SQL Server
+
+## Architecture
+Clean Architecture with CQRS pattern.
+
+## Conventions
+- Use MediatR for commands/queries
+- Use FluentValidation for validation
+- Use Result<T> for operation results
+```
+
+### 6. INITIALIZE GIT & DOTNET
+
+```bash
+cd {ProjectName}
+git init
+dotnet new sln -n {ProjectName}
+dotnet sln add src/{ProjectName}.Domain
+dotnet sln add src/{ProjectName}.Application
+dotnet sln add src/{ProjectName}.Infrastructure
+dotnet sln add src/{ProjectName}.Api.Core
+dotnet sln add src/{ProjectName}.Api
+dotnet restore
+```
+
+### 7. DISPLAY SUCCESS
+
+```
+╔═══════════════════════════════════════════════════════════════╗
+║              SMARTSTACK PROJECT CREATED                        ║
+╠═══════════════════════════════════════════════════════════════╣
+║  Name:      {ProjectName}                                      ║
+║  Location:  {full-path}                                        ║
+╠═══════════════════════════════════════════════════════════════╣
+║  Backend:                                                      ║
+║  ✓ {ProjectName}.Domain         (Core entities)                ║
+║  ✓ {ProjectName}.Application    (CQRS, Use cases)              ║
+║  ✓ {ProjectName}.Infrastructure (EF Core, Services)            ║
+║  ✓ {ProjectName}.Api.Core       (Controllers, Middleware)      ║
+║  ✓ {ProjectName}.Api            (Entry point)                  ║
+╠═══════════════════════════════════════════════════════════════╣
+║  Frontend:                                                     ║
+║  ✓ {project-name}-web           (React + Vite + Tailwind)      ║
+╠═══════════════════════════════════════════════════════════════╣
+║  Next steps:                                                   ║
+║  1. cd {ProjectName}                                           ║
+║  2. dotnet build                                               ║
+║  3. cd web/{project-name}-web && npm install                   ║
+║  4. Configure appsettings.Local.json                           ║
+║  5. dotnet ef database update                                  ║
+║  6. dotnet run --project src/{ProjectName}.Api                 ║
+║  7. npm run dev (in web folder)                                ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+## File Templates
+
+### Domain/BaseEntity.cs
+```csharp
+namespace {ProjectName}.Domain.Common;
+
+public abstract class BaseEntity
+{
+    public Guid Id { get; protected set; } = Guid.NewGuid();
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+    public DateTime? UpdatedAt { get; set; }
+    public string? CreatedBy { get; set; }
+    public string? UpdatedBy { get; set; }
+}
+```
+
+### Application/Result.cs
+```csharp
+namespace {ProjectName}.Application.Common.Models;
+
+public class Result<T>
+{
+    public bool IsSuccess { get; }
+    public T? Value { get; }
+    public string? Error { get; }
+
+    private Result(bool isSuccess, T? value, string? error)
+    {
+        IsSuccess = isSuccess;
+        Value = value;
+        Error = error;
+    }
+
+    public static Result<T> Success(T value) => new(true, value, null);
+    public static Result<T> Failure(string error) => new(false, default, error);
+}
+```
+
+### Infrastructure/ApplicationDbContext.cs
+```csharp
+using Microsoft.EntityFrameworkCore;
+using {ProjectName}.Application.Common.Interfaces;
+
+namespace {ProjectName}.Infrastructure.Persistence;
+
+public class ApplicationDbContext : DbContext, IApplicationDbContext
+{
+    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
+        : base(options)
+    {
+    }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.ApplyConfigurationsFromAssembly(typeof(ApplicationDbContext).Assembly);
+        base.OnModelCreating(modelBuilder);
+    }
+}
+```
+
+### Api/Program.cs
+```csharp
+using {ProjectName}.Application;
+using {ProjectName}.Infrastructure;
+using {ProjectName}.Api.Core.Extensions;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services
+builder.Services.AddApplication();
+builder.Services.AddInfrastructure(builder.Configuration);
+builder.Services.AddApiCore();
+
+builder.Services.AddControllers();
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+builder.Services.AddSignalR();
+
+var app = builder.Build();
+
+// Configure pipeline
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseHttpsRedirection();
+app.UseAuthentication();
+app.UseAuthorization();
+app.MapControllers();
+app.MapHub<NotificationHub>("/hubs/notifications");
+
+app.Run();
+```
+
+### Frontend/App.tsx
+```tsx
+import { BrowserRouter, Routes, Route } from 'react-router-dom';
+import { AuthProvider } from './contexts/AuthContext';
+import { ThemeProvider } from './contexts/ThemeContext';
+import HomePage from './pages/HomePage';
+import NotFoundPage from './pages/NotFoundPage';
+
+function App() {
+  return (
+    <ThemeProvider>
+      <AuthProvider>
+        <BrowserRouter>
+          <Routes>
+            <Route path="/" element={<HomePage />} />
+            <Route path="*" element={<NotFoundPage />} />
+          </Routes>
+        </BrowserRouter>
+      </AuthProvider>
+    </ThemeProvider>
+  );
+}
+
+export default App;
+```
+
+## Execution Rules
+
+1. **ALWAYS** create all directories before files
+2. **USE** Write tool for each file (not batch)
+3. **USE** Bash for dotnet commands
+4. **VALIDATE** project name is PascalCase
+5. **NEVER** overwrite existing directories
+6. Create files in this order: root → backend → frontend → config
+
+## Priority
+
+Correctness > Completeness > Speed
+
+---
+
+User: $ARGUMENTS

package/templates/commands/create/skill.md

@@ -0,0 +1,199 @@
+---
+description: Create a SmartStack skill extension project with multi-phase workflow
+argument-hint: <name> [phases] [description]
+---
+
+# Create Skill Extension
+
+Scaffold a complete SmartStack **skill** extension with multi-phase workflow.
+
+## What is a Skill?
+
+A skill is a complex multi-phase orchestrator:
+- Manages workflows with multiple phases
+- Each phase can use different models (cost optimization)
+- Contains templates, questionnaires, validation gates
+- Produces structured output (documentation, code, etc.)
+
+## Arguments
+
+Parse from `$ARGUMENTS`:
+- **name** (required): Skill name in kebab-case
+- **phases** (optional): Number of phases (default: 5)
+- **description** (optional): What the skill does
+
+## Project Structure
+
+```
+smartstack-{name}/
+├── package.json
+├── tsconfig.json
+├── tsup.config.ts
+├── README.md
+├── .gitignore
+├── src/
+│   └── index.ts
+└── templates/
+    └── skills/
+        └── {name}/
+            ├── SKILL.md           # Main skill definition
+            ├── 1-setup.md         # Phase 1
+            ├── 2-analyze.md       # Phase 2
+            ├── 3-design.md        # Phase 3
+            ├── 4-execute.md       # Phase 4
+            ├── 5-validate.md      # Phase 5
+            └── templates.md       # Shared templates
+```
+
+## Generated SKILL.md
+
+```markdown
+---
+name: {name}
+description: |
+  {description}
+  Use when:
+  - User needs {name} functionality
+  - User mentions related keywords
+---
+
+# {PascalCaseName} Skill
+
+{description}
+
+## Overview
+
+Multi-phase workflow for {name} operations.
+
+## Phase Summary
+
+| Phase | Command | Description | Model | Cost |
+|-------|---------|-------------|-------|------|
+| 1 | `/{name}:1-setup` | Initial setup and configuration | Haiku | ~$0.02 |
+| 2 | `/{name}:2-analyze` | Analysis and discovery | Sonnet | ~$0.10 |
+| 3 | `/{name}:3-design` | Design and planning | Sonnet | ~$0.10 |
+| 4 | `/{name}:4-execute` | Implementation | Opus | ~$0.30 |
+| 5 | `/{name}:5-validate` | Validation and testing | Sonnet | ~$0.10 |
+| **Total** | | | | ~$0.62 |
+
+## Workflow Diagram
+
+╔═══════════╗     ╔═══════════╗     ╔═══════════╗
+║  1-SETUP  ║ ──▶ ║ 2-ANALYZE ║ ──▶ ║ 3-DESIGN  ║
+║  (Haiku)  ║     ║ (Sonnet)  ║     ║ (Sonnet)  ║
+╚═══════════╝     ╚═══════════╝     ╚═══════════╝
+                                          │
+      ╔═══════════╗     ╔═══════════╗     ▼
+      ║ COMPLETE  ║ ◀── ║ 5-VALIDATE║ ◀── ╔═══════════╗
+      ║           ║     ║ (Sonnet)  ║     ║ 4-EXECUTE ║
+      ╚═══════════╝     ╚═══════════╝     ║  (Opus)   ║
+                                          ╚═══════════╝
+
+## Output Location
+
+Generated files go to:
+- Working directory: `./{name}/`
+- Or specified output path
+
+## Available Commands
+
+| Command | Description |
+|---------|-------------|
+| `/{name}` | Run complete workflow (all phases) |
+| `/{name}:1-setup` | Run setup phase only |
+| `/{name}:2-analyze` | Run analysis phase only |
+| `/{name}:3-design` | Run design phase only |
+| `/{name}:4-execute` | Run execution phase only |
+| `/{name}:5-validate` | Run validation phase only |
+
+## Absolute Rules
+
+1. **NEVER** skip phases in sequence mode
+2. **ALWAYS** validate before proceeding
+3. **PRESERVE** existing configurations
+4. **DOCUMENT** all decisions
+5. **COST-OPTIMIZE** model selection
+
+## Context Variables
+
+Available in all phases:
+- `$NAME` - Skill name
+- `$PHASE` - Current phase number
+- `$OUTPUT_DIR` - Output directory
+- `$ARGUMENTS` - User arguments
+
+## Priority
+
+Quality > Cost > Speed
+```
+
+## Generated Phase Template (example: 1-setup.md)
+
+```markdown
+---
+description: Phase 1 - Setup and configuration
+argument-hint: [output-dir]
+---
+
+# Phase 1: Setup
+
+## Objective
+
+Initialize the {name} workflow environment.
+
+## Prerequisites
+
+- None (this is the first phase)
+
+## Steps
+
+### 1.1 Parse Arguments
+- Extract output directory from `$ARGUMENTS`
+- Default to `./{name}/` if not specified
+
+### 1.2 Create Directory Structure
+```
+{output-dir}/
+├── config/
+├── output/
+└── logs/
+```
+
+### 1.3 Initialize Configuration
+- Create default config file
+- Set up logging
+
+## Output
+
+- Directory structure created
+- Configuration initialized
+- Ready for Phase 2
+
+## Validation Checklist
+
+- [ ] Output directory exists
+- [ ] Config file created
+- [ ] No errors encountered
+
+## Next Phase
+
+Proceed to: `/{name}:2-analyze`
+
+---
+
+User: $ARGUMENTS
+```
+
+## Workflow
+
+1. Parse arguments (name, phases, description)
+2. Validate name format
+3. Create project directory
+4. Generate SKILL.md
+5. Generate each phase template
+6. Generate templates.md
+7. Display success message
+
+---
+
+User: $ARGUMENTS