@atlashub/smartstack-cli 1.37.0 → 2.0.0

package/templates/skills/cc-skill/templates/skill-progressive.md

@@ -0,0 +1,102 @@
+# Template: Progressive Step Loading Skill
+
+Use this template when creating a complex skill with multiple phases that benefit from progressive step loading.
+
+## Generated SKILL.md format:
+
+```yaml
+---
+name: {{SKILL_NAME}}
+description: |
+  {{DESCRIPTION}}
+{{#if ARGUMENT_HINT}}
+argument-hint: "{{ARGUMENT_HINT}}"
+{{/if}}
+{{#if DISABLE_MODEL_INVOCATION}}
+disable-model-invocation: true
+{{/if}}
+{{#if MODEL}}
+model: {{MODEL}}
+{{/if}}
+---
+
+<objective>
+{{OBJECTIVE}}
+</objective>
+
+<quick_start>
+
+` ` `bash
+/{{SKILL_NAME}} {{EXAMPLE_ARGS_1}}
+/{{SKILL_NAME}} {{EXAMPLE_ARGS_2}}
+` ` `
+
+</quick_start>
+
+<parameters>
+
+<flags>
+| Flag | Description |
+|------|-------------|
+| {{FLAG_SHORT}} | {{FLAG_DESCRIPTION}} |
+</flags>
+
+<examples>
+` ` `bash
+/{{SKILL_NAME}} {{EXAMPLE_1}}
+/{{SKILL_NAME}} {{EXAMPLE_2}}
+` ` `
+</examples>
+
+</parameters>
+
+<workflow>
+{{#each STEPS}}
+{{@index_plus_one}}. {{this.title}}
+{{/each}}
+</workflow>
+
+<state_variables>
+| Variable | Type | Description |
+|----------|------|-------------|
+{{#each STATE_VARS}}
+| `{ {{this.name}} }` | {{this.type}} | {{this.description}} |
+{{/each}}
+</state_variables>
+
+<entry_point>
+
+**FIRST ACTION:** Load `steps/step-00-init.md`
+
+</entry_point>
+
+<step_files>
+| Step | File | Purpose |
+|------|------|---------|
+{{#each STEPS}}
+| {{this.number}} | `steps/step-{{this.number}}-{{this.name}}.md` | {{this.description}} |
+{{/each}}
+</step_files>
+
+<execution_rules>
+- **Load one step at a time** - Progressive loading to minimize context
+- **Persist state variables** across all steps
+- **Follow next_step directive** at end of each step
+- {{RULE_1}}
+- {{RULE_2}}
+</execution_rules>
+
+<success_criteria>
+- {{CRITERIA_1}}
+- {{CRITERIA_2}}
+- {{CRITERIA_3}}
+</success_criteria>
+```
+
+## Notes:
+- Keep SKILL.md under 500 lines (detailed content goes in steps)
+- Each step should be self-contained
+- State variables persist across all steps
+- Always start with step-00-init for argument parsing
+- Always end with a validation/summary step
+- Best for: workflows, generators, multi-phase operations

package/templates/skills/cc-skill/templates/skill-simple.md

@@ -0,0 +1,75 @@
+# Template: Simple Skill
+
+Use this template when creating a skill that fits in a single SKILL.md file without progressive step loading.
+
+## Generated SKILL.md format:
+
+```yaml
+---
+name: {{SKILL_NAME}}
+description: |
+  {{DESCRIPTION}}
+{{#if ARGUMENT_HINT}}
+argument-hint: "{{ARGUMENT_HINT}}"
+{{/if}}
+{{#if DISABLE_MODEL_INVOCATION}}
+disable-model-invocation: true
+{{/if}}
+{{#if USER_INVOCABLE_FALSE}}
+user-invocable: false
+{{/if}}
+{{#if MODEL}}
+model: {{MODEL}}
+{{/if}}
+---
+
+<objective>
+{{OBJECTIVE}}
+</objective>
+
+<quick_start>
+
+` ` `bash
+/{{SKILL_NAME}} {{EXAMPLE_ARGS_1}}
+/{{SKILL_NAME}} {{EXAMPLE_ARGS_2}}
+` ` `
+
+</quick_start>
+
+## Task
+{{TASK_DESCRIPTION}}
+
+$ARGUMENTS
+
+<workflow>
+
+## 1. {{FIRST_PHASE}}
+{{FIRST_PHASE_INSTRUCTIONS}}
+
+## 2. {{SECOND_PHASE}}
+{{SECOND_PHASE_INSTRUCTIONS}}
+
+## 3. {{THIRD_PHASE}}
+{{THIRD_PHASE_INSTRUCTIONS}}
+
+</workflow>
+
+<execution_rules>
+- {{RULE_1}}
+- {{RULE_2}}
+- {{RULE_3}}
+</execution_rules>
+
+<success_criteria>
+- {{CRITERIA_1}}
+- {{CRITERIA_2}}
+- {{CRITERIA_3}}
+</success_criteria>
+```
+
+## Notes:
+- Keep total lines under 500
+- Description should include trigger keywords for auto-detection
+- Use $ARGUMENTS to reference user input
+- Workflow steps are inline (no external step files)
+- Best for: linting, simple generation, knowledge injection, quick commands

package/templates/skills/cc-skill/templates/step-template.md

@@ -0,0 +1,82 @@
+# Template: Step File
+
+Standard template for a progressive step loading step file.
+
+## Generated step file format:
+
+```yaml
+---
+name: step-{{NUMBER}}-{{NAME}}
+description: {{DESCRIPTION}}
+{{#if NEXT_STEP}}
+next_step: steps/step-{{NEXT_NUMBER}}-{{NEXT_NAME}}.md
+{{/if}}
+---
+
+# Step {{N}}: {{TITLE}}
+
+## MANDATORY EXECUTION RULES:
+- {{RULE_1}}
+- {{RULE_2}}
+- FORBIDDEN to proceed to next step until this step is complete
+
+## YOUR TASK:
+{{TASK_DESCRIPTION}}
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. {{SUBTASK_1_TITLE}}
+{{SUBTASK_1_INSTRUCTIONS}}
+
+### 2. {{SUBTASK_2_TITLE}}
+{{SUBTASK_2_INSTRUCTIONS}}
+
+### 3. Show Summary
+Display step results in compact format (table preferred).
+
+---
+
+## SUCCESS METRICS:
+- {{METRIC_1}}
+- {{METRIC_2}}
+- Output is compact and scannable
+
+## NEXT STEP:
+{{#if NEXT_STEP}}
+After showing summary, proceed directly to `./step-{{NEXT_NUMBER}}-{{NEXT_NAME}}.md`
+{{else}}
+This is the final step. Skill execution is complete.
+{{/if}}
+```
+
+## Step Types:
+
+### Init Step (step-00)
+- Parse arguments and flags
+- Validate required inputs
+- Initialize state variables
+- Show configuration summary
+
+### Analysis Step
+- Read files, search codebase
+- Extract patterns and information
+- Show findings summary
+
+### Generation Step
+- Use templates or references
+- Create/modify files
+- Show what was generated
+
+### Validation Step (usually last)
+- Check generated output
+- Verify conventions
+- Display final summary and next steps
+
+## Rules:
+- Each step MUST be self-contained (loadable independently)
+- State variables persist via conversation context
+- Always show compact summary before proceeding
+- Always reference next step at the end
+- Last step must NOT have next_step in frontmatter

package/templates/skills/check-version/SKILL.md

@@ -1,9 +1,15 @@
 ---
 name: check-version
 description: Verify version alignment between package.json and documentation
+context: fork
+agent: Explore
 model: haiku
+allowed-tools: Read, Glob, Grep, Bash
 ---
 
+## Current state (auto-injected)
+- Package version: !`node -p "require('./package.json').version" 2>/dev/null || echo "no package.json"`
+
 <objective>
 Verify that the version in `package.json` is aligned with all documentation files in `.documentation/`.
 Use before releases or as part of release process to ensure documentation is up-to-date.

package/templates/skills/debug/SKILL.md

@@ -2,8 +2,12 @@
 name: debug
 description: Systematic bug debugging with deep analysis and resolution
 argument-hint: <log|error|problem-description>
+model: opus
 ---
 
+## Bug to investigate
+$ARGUMENTS
+
 <objective>
 Follow an ultra-deep analysis workflow to identify, understand, and resolve bugs.
 **ULTRA THINK** at each phase transition.

package/templates/skills/documentation/SKILL.md

@@ -9,6 +9,7 @@ description: |
   - After implementing a feature to generate its documentation
   Types: user module, developer tools, database ERD, testing tools
 argument-hint: "<module-name> [--type user|developer|database|testing|update]"
+model: sonnet
 ---
 
 <objective>

package/templates/skills/efcore/SKILL.md

@@ -2,8 +2,13 @@
 name: efcore
 description: EF Core Commands - Migration and database management
 argument-hint: "<command> [options]"
+disable-model-invocation: true
 ---
 
+## Current state (auto-injected)
+- Branch: !`git branch --show-current`
+- Recent migrations: !`find . -path "*/Migrations/*.cs" -not -name "*Designer*" -not -name "*Snapshot*" 2>/dev/null | sort | tail -5 || echo "none found"`
+
 <objective>
 Manage EF Core migrations and database operations with progressive step loading, MCP validation, and DbContext auto-detection.
 </objective>

package/templates/skills/efcore/steps/db/step-deploy.md

@@ -189,18 +189,39 @@ Next: /efcore db-status, /efcore db-seed
 
 ## BOTH CONTEXTS:
 
-If "Both" selected for DbContext:
+**If `RUN_BOTH=true` (auto-detected for client projects with SmartStack NuGet):**
+
+Run the full deploy sequence (steps 2-6) TWICE, in order:
 
 ```bash
-# Deploy CoreDbContext first
+# 1. Deploy CoreDbContext first (system tables: Users, Roles, Tenants...)
+echo "=== Deploying CoreDbContext (core schema) ==="
 DBCONTEXT="CoreDbContext"
-# ... run deploy ...
+SCHEMA="core"
+# Run steps 2-6 with CoreDbContext...
 
-# Then ExtensionsDbContext
+dotnet ef database update \
+  --context "CoreDbContext" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$STARTUP_PROJECT" \
+  --verbose
+
+# 2. Then ExtensionsDbContext (client tables)
+echo ""
+echo "=== Deploying ExtensionsDbContext (extensions schema) ==="
 DBCONTEXT="ExtensionsDbContext"
-# ... run deploy ...
+SCHEMA="extensions"
+# Run steps 2-6 with ExtensionsDbContext...
+
+dotnet ef database update \
+  --context "ExtensionsDbContext" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$STARTUP_PROJECT" \
+  --verbose
 ```
 
+**Order matters:** Core MUST be deployed first (Extensions may have foreign keys to Core tables).
+
 ---
 
 ## COMPLETION:

package/templates/skills/efcore/steps/shared/step-00-init.md

@@ -46,21 +46,24 @@ detect_efcore_project() {
 
 ```bash
 detect_dbcontext() {
-  # Priority 1: SmartStack.Domain exists → CoreDbContext
+  # Priority 1: SmartStack.Domain exists → SmartStack source project (Core only)
   if find . -type d -name "SmartStack.Domain" | grep -q .; then
     DBCONTEXT="CoreDbContext"
     DBCONTEXT_TYPE="core"
     SCHEMA="core"
+    RUN_BOTH=false
     echo "DbContext: CoreDbContext (SmartStack.Domain found)"
     return
   fi
 
-  # Priority 2: Client with SmartStack NuGet → ExtensionsDbContext
+  # Priority 2: Client with SmartStack NuGet → BOTH contexts (Core from NuGet + Extensions local)
   if find . -name "*.csproj" -exec grep -l "SmartStack\." {} \; | grep -qv "SmartStack\."; then
-    DBCONTEXT="ExtensionsDbContext"
-    DBCONTEXT_TYPE="extensions"
-    SCHEMA="extensions"
-    echo "DbContext: ExtensionsDbContext (SmartStack NuGet reference)"
+    DBCONTEXT="CoreDbContext"
+    DBCONTEXT_TYPE="both"
+    SCHEMA="core"
+    RUN_BOTH=true
+    echo "DbContext: Both (Core from SmartStack NuGet + Extensions local)"
+    echo "  Deploy order: CoreDbContext → ExtensionsDbContext"
     return
   fi
 
@@ -68,19 +71,28 @@ detect_dbcontext() {
   CORE_CTX=$(find . -name "*.cs" -exec grep -l "CoreDbContext" {} \; 2>/dev/null | head -1)
   EXT_CTX=$(find . -name "*.cs" -exec grep -l "ExtensionsDbContext" {} \; 2>/dev/null | head -1)
 
-  if [ -n "$CORE_CTX" ] && [ -z "$EXT_CTX" ]; then
+  if [ -n "$CORE_CTX" ] && [ -n "$EXT_CTX" ]; then
+    DBCONTEXT="CoreDbContext"
+    DBCONTEXT_TYPE="both"
+    SCHEMA="core"
+    RUN_BOTH=true
+    echo "DbContext: Both (CoreDbContext + ExtensionsDbContext found)"
+  elif [ -n "$CORE_CTX" ] && [ -z "$EXT_CTX" ]; then
     DBCONTEXT="CoreDbContext"
     DBCONTEXT_TYPE="core"
     SCHEMA="core"
+    RUN_BOTH=false
   elif [ -z "$CORE_CTX" ] && [ -n "$EXT_CTX" ]; then
     DBCONTEXT="ExtensionsDbContext"
     DBCONTEXT_TYPE="extensions"
     SCHEMA="extensions"
+    RUN_BOTH=false
   else
     # Priority 4: Ask user
     DBCONTEXT=""
     DBCONTEXT_TYPE=""
     SCHEMA=""
+    RUN_BOTH=false
   fi
 }
 ```
@@ -204,6 +216,7 @@ block_production() {
 EF CORE CONTEXT
 ├── Project:    {PROJECT_NAME}
 ├── DbContext:  {DBCONTEXT} ({DBCONTEXT_TYPE})
+├── Run Both:   {RUN_BOTH} (Core → Extensions)
 ├── Schema:     {SCHEMA}
 ├── Migrations: {MIGRATIONS_DIR}
 ├── Environment:{SELECTED_ENV}
@@ -229,6 +242,7 @@ After this step, these variables are available:
 | `{branch_type}` | feature |
 | `{current_branch}` | feature/multitenant |
 | `{selected_env}` | Local |
+| `{run_both}` | true |
 
 ---
 

package/templates/skills/explore/SKILL.md

@@ -2,10 +2,15 @@
 name: explore
 description: Deep codebase exploration to answer specific questions
 argument-hint: <question>
+context: fork
+agent: Explore
+allowed-tools: Read, Grep, Glob, WebSearch, WebFetch
 ---
 
 <objective>
-Answer questions about the codebase through systematic investigation using parallel exploration agents.
+Answer questions about the codebase through systematic investigation using direct search tools.
+
+**Note:** This skill runs in an isolated context. Use Grep, Glob, and Read directly - do NOT launch Task agents.
 </objective>
 
 <quick_start>
@@ -16,57 +21,48 @@ Answer questions about the codebase through systematic investigation using paral
 ```
 </quick_start>
 
+## Task
+Research the following question: $ARGUMENTS
+
 <workflow>
 
 ## 1. Parse Question
 
-- Extract key terms and concepts from question
+- Extract key terms and concepts from the question
 - Identify file types, patterns, or areas to search
 - Determine if web research is needed
 
-## 2. Search Codebase (Parallel Agents)
+## 2. Search Codebase (Direct Tools)
 
-Launch multiple exploration agents **in parallel**:
+Use direct search tools **in parallel** where possible:
 
-**Agent 1: Codebase Exploration** (`explore-codebase`)
+**File discovery:**
 ```
-Find existing code related to: {question}
-
-Report ONLY what exists:
-1. Files that contain related code (with paths and line numbers)
-2. Existing patterns used for similar features
-3. Utility functions that might be relevant
-4. How similar features are currently structured
-5. Test file locations and patterns
-
-DO NOT suggest what to build. Just report what's there.
+Glob: pattern="**/*{keyword}*" to find related files
 ```
 
-**Agent 2: Documentation Research** (`explore-docs`)
+**Code search:**
 ```
-Research documentation for libraries used in: {question}
-
-Find:
-1. How the relevant libraries/frameworks work
-2. API documentation for tools being used
-3. Best practices from official docs
+Grep: pattern="{keyword}" to find content matches
+Grep: pattern="class {Name}" or "function {name}" for implementations
 ```
 
-**Agent 3: Web Research** (`websearch`) - *if external context needed*
+**Targeted reading:**
+```
+Read: the most relevant 3-5 files discovered
 ```
-Search for context about: {question}
 
-Find:
-1. How this is typically implemented
-2. Common patterns and approaches
-3. Known pitfalls or gotchas
+**Web research** (if external context needed):
+```
+WebSearch: "{question} best practices"
+WebFetch: documentation URLs found in the codebase
 ```
 
-**CRITICAL**: Launch agents in a SINGLE message for parallel execution.
+**CRITICAL**: Run independent searches in parallel for speed.
 
 ## 3. Analyze Findings
 
-- Read relevant files found by agents
+- Read relevant files found by searches
 - Trace relationships between files
 - Identify patterns and conventions
 - Note file paths with line numbers (e.g., `src/app.ts:42`)
@@ -83,11 +79,11 @@ Provide comprehensive response:
 
 <execution_rules>
 
-- **PARALLEL SEARCH**: Launch multiple agents simultaneously
+- **PARALLEL SEARCH**: Run independent Grep/Glob searches simultaneously
 - **CITE SOURCES**: Always reference file paths and line numbers
 - **STAY FOCUSED**: Only explore what's needed to answer the question
 - **BE THOROUGH**: Don't stop at first match - gather complete context
-- **ULTRA THINK**: Consider relationships between discovered elements
+- **NO TASK AGENTS**: Use Grep, Glob, Read, WebSearch, WebFetch directly
 
 </execution_rules>
 

package/templates/skills/feature-full/SKILL.md

@@ -8,6 +8,7 @@ description: |
   - Creating a module with notifications, workflows and/or AI
   - Need for complete user experience
   Scope: Domain → Application → Infrastructure → API → Web + Notifications + Workflows + AI
+disable-model-invocation: true
 ---
 
 # Skill Feature Full SmartStack

package/templates/skills/gitflow/SKILL.md

@@ -2,8 +2,16 @@
 name: gitflow
 description: GitFlow workflow with versioning, worktrees, and EF Core migration management. Progressive step loading for minimal context usage.
 argument-hint: "[-a] [-f|-r|-h] <action> [name]"
+disable-model-invocation: true
 ---
 
+## Current state (auto-injected)
+- Branch: !`git branch --show-current`
+- Status: !`git status --short`
+- Recent commits: !`git log --oneline -5`
+- Worktrees: !`git worktree list 2>/dev/null`
+- Config: !`cat .gitflow/config.json 2>/dev/null || echo "no config found"`
+
 <objective>
 Execute GitFlow workflows with automatic versioning, worktree management, and EF Core migration validation. Uses progressive step loading to minimize context and maintain fresh state at each phase.
 </objective>

package/templates/skills/gitflow/steps/step-start.md

@@ -207,6 +207,11 @@ DB_NAME=$(echo "${PROJECT_NAME}_${branch_type}_${BRANCH_NAME}" | cut -c1-63)
   "ConnectionStrings": {
     "DefaultConnection": "Server=localhost;Database=${DB_NAME};Trusted_Connection=true;TrustServerCertificate=true"
   },
+  "SmartStack": {
+    "AutoMigrate": true,
+    "FailOnMigrationError": true,
+    "EnableDevSeeding": true
+  },
   "Authentication": {
     "FrontendUrl": "http://localhost:${WEB_PORT}"
   },
@@ -261,14 +266,40 @@ EOF
 }
 ```
 
-#### 7c. Summary of local config
+#### 7c. Backend: launchSettings.json Local Profile
+
+**If API project detected and Properties/launchSettings.json exists:**
+```bash
+LAUNCH_SETTINGS="$API_DIR/Properties/launchSettings.json"
+[ -n "$API_DIR" ] && [ -f "$LAUNCH_SETTINGS" ] && {
+  # Use Node.js to safely add/update Local profile in launchSettings.json
+  node -e "
+    const fs = require('fs');
+    const ls = JSON.parse(fs.readFileSync('$LAUNCH_SETTINGS', 'utf8'));
+    ls.profiles = ls.profiles || {};
+    ls.profiles.Local = {
+      commandName: 'Project',
+      dotnetRunMessages: true,
+      launchBrowser: false,
+      applicationUrl: 'http://localhost:${API_PORT}',
+      environmentVariables: {
+        ASPNETCORE_ENVIRONMENT: 'Local'
+      }
+    };
+    fs.writeFileSync('$LAUNCH_SETTINGS', JSON.stringify(ls, null, 2) + '\n');
+    console.log('Updated: launchSettings.json Local profile (Port: ${API_PORT})');
+  "
+}
+```
+
+#### 7d. Summary of local config
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
 │  LOCAL ENVIRONMENT CONFIGURED                               │
 ├─────────────────────────────────────────────────────────────┤
 │  Database:  ${DB_NAME}                                      │
-│  API Port:  ${API_PORT}  →  dotnet run --environment Local  │
+│  API Port:  ${API_PORT}  →  dotnet run --launch-profile Local│
 │  Web Port:  ${WEB_PORT}  →  npm run local                   │
 └─────────────────────────────────────────────────────────────┘
 ```
@@ -315,19 +346,22 @@ EOF
 ║  1. Go to worktree:                                               ║
 ║     cd {WORKTREE_PATH}                                            ║
 ║                                                                    ║
-║  2. Start local environment:                                      ║
-║     # Terminal 1 - Backend:                                       ║
-║     cd src/SmartStack.Api && dotnet run --environment Local       ║
-║     # Terminal 2 - Frontend:                                      ║
-║     cd web/smartstack-web && npm run local                        ║
+║  2. Start backend (auto-migrates Core + Extensions DB):           ║
+║     dotnet run --project src/{Project}.Api --launch-profile Local ║
+║                                                                    ║
+║  3. Reset admin password:                                         ║
+║     ss admin reset                                                ║
+║                                                                    ║
+║  4. Start frontend (other terminal):                              ║
+║     cd web/{project}-web && npm run local                         ║
 ║                                                                    ║
-║  3. Make changes and commit:                                      ║
+║  5. Make changes and commit:                                      ║
 ║     /gitflow commit                                               ║
 ║                                                                    ║
-║  4. Create pull request:                                          ║
+║  6. Create pull request:                                          ║
 ║     /gitflow pr                                                   ║
 ║                                                                    ║
-║  5. After PR merged, finalize:                                    ║
+║  7. After PR merged, finalize:                                    ║
 ║     /gitflow finish                                               ║
 ╚══════════════════════════════════════════════════════════════════╝
 ```
@@ -351,6 +385,7 @@ EOF
 - **Branch pushed to remote (AUTOMATIC)**
 - Worktree set up (if enabled)
 - Backend local config created: `appsettings.Local.json` (if .NET API detected)
+- Backend launch profile created: `launchSettings.json` Local profile with unique port (if .NET API detected)
 - Frontend local config created: `.env.local` + `npm run local` script (if web project detected)
 - Ports synchronized between backend and frontend (unique per branch)
 - State stored for subsequent steps