@atlashub/smartstack-cli 4.81.0 → 5.0.0

package/templates/skills/cc-skill/steps/step-02-generate.md

@@ -1,145 +0,0 @@
----
-name: step-02-generate
-description: Generate SKILL.md file from template based on design choices
-next_step: steps/step-03-steps.md
----
-
-# Step 2: Generate SKILL.md
-
-## MANDATORY EXECUTION RULES:
-- ALWAYS load the appropriate template from `templates/` directory
-- ALWAYS use the design choices from Step 1
-- For UPDATE: read existing SKILL.md first, then apply changes
-- Generate COMPLETE SKILL.md (not a stub)
-
-## YOUR TASK:
-Generate the SKILL.md file based on the skill type and design choices gathered in Step 1.
-
----
-
-## EXECUTION SEQUENCE:
-
-### 1. Load Template
-
-Based on {skill_type}:
-
-```
-"simple"      → Read: "templates/skill-simple.md"
-"progressive" → Read: "templates/skill-progressive.md"
-"forked"      → Read: "templates/skill-forked.md"
-```
-
-### 2. Create Directory Structure
-
-```bash
-# Create skill directory
-mkdir -p {target_dir}
-
-# For progressive skills, create subdirectories
-mkdir -p {target_dir}/steps/
-mkdir -p {target_dir}/references/  # optional but recommended
-mkdir -p {target_dir}/templates/   # optional, for code templates
-```
-
-### 3. Generate SKILL.md
-
-Use the loaded template as a base. Replace all placeholders with actual values:
-
-**Frontmatter generation:**
-
-```yaml
----
-name: {skill_name}
-description: |
-  {description}
-```
-
-Add optional fields only if they differ from defaults:
-
-```yaml
-# Only if manual-only
-disable-model-invocation: true
-
-# Only if hidden
-user-invocable: false
-
-# Only if skill accepts arguments
-argument-hint: "{argument_hint}"
-
-# Only if not "inherit"
-model: {model}
-
-# Only for forked skills
-context: fork
-agent: {agent}
-allowed-tools: "{allowed_tools}"
-```
-
-Close frontmatter:
-
-```yaml
----
-```
-
-**Content generation:**
-
-Generate appropriate XML sections based on {skill_type}:
-
-**All types get:**
-- `<objective>` - One paragraph from {description}
-- `<quick_start>` - Usage examples with /skill_name
-- `<execution_rules>` - Standard rules
-- `<success_criteria>` - Completion conditions
-
-**Progressive type additionally gets:**
-- `<parameters>` with `<flags>` and `<examples>`
-- `<workflow>` - Numbered high-level steps
-- `<state_variables>` - Table of persistent variables
-- `<entry_point>` - Points to step-00-init.md
-- `<step_files>` - Table mapping steps to files
-
-**Forked type additionally gets:**
-- Note about isolated context
-- Direct workflow (no step loading)
-
-### 4. Write SKILL.md
-
-Use Write tool to create `{target_dir}/SKILL.md` with generated content.
-
-### 5. For UPDATE subcommand
-
-If {subcommand} = "update":
-1. Read existing `{target_dir}/SKILL.md`
-2. Parse current frontmatter and sections
-3. Apply only the requested changes (merge, don't replace entirely)
-4. Use Edit tool to modify specific sections
-5. Preserve any custom content not being updated
-
-### 6. Confirm Generation
-
-```
-Generated: {target_dir}/SKILL.md ({line_count} lines)
-
-Frontmatter:
-  name: {skill_name}
-  description: {description} (truncated)
-  type: {skill_type}
-  ...
-
-Sections: {list of XML sections included}
-
-→ Generating step files...
-```
-
----
-
-## SUCCESS METRICS:
-- SKILL.md created/updated at correct path
-- Frontmatter includes all required fields
-- Appropriate XML sections for skill type
-- Under 500 lines
-- No placeholder text left unreplaced
-
-## NEXT STEP:
-- If {skill_type} = "progressive" → proceed to `./step-03-steps.md`
-- If {skill_type} = "simple" or "forked" → skip to `./step-04-validate.md`

package/templates/skills/cc-skill/steps/step-03-steps.md

@@ -1,151 +0,0 @@
----
-name: step-03-steps
-description: Generate step files for progressive step loading skills
-next_step: steps/step-04-validate.md
----
-
-# Step 3: Generate Step Files
-
-## MANDATORY EXECUTION RULES:
-- ONLY execute this step for progressive skills ({skill_type} = "progressive")
-- If not progressive, skip directly to step-04-validate.md
-- Generate ALL step files with proper chaining
-- Each step must follow the standard format
-
-## YOUR TASK:
-Generate step files for progressive step loading. Each step file must have proper frontmatter, sections, and next_step chaining.
-
----
-
-## EXECUTION SEQUENCE:
-
-### 1. Load Step Template
-
-```
-Read: "templates/step-template.md"
-```
-
-### 2. Generate Each Step File
-
-For each step in {steps} array (from Step 1 design):
-
-**File path:** `{target_dir}/steps/step-{number}-{name}.md`
-
-**Frontmatter:**
-
-```yaml
----
-name: step-{number}-{name}
-description: {step_description}
-next_step: steps/step-{next_number}-{next_name}.md
----
-```
-
-For the LAST step: omit `next_step` field.
-
-**Content structure for each step:**
-
-```markdown
-# Step {N}: {Title}
-
-## MANDATORY EXECUTION RULES:
-- [Rules specific to this step]
-- FORBIDDEN to skip to next step until this step is complete
-
-## YOUR TASK:
-{step_description}
-
----
-
-## EXECUTION SEQUENCE:
-
-### 1. [First subtask]
-[Instructions for the first subtask]
-
-### 2. [Second subtask]
-[Instructions for the second subtask]
-
-### N. Show Summary
-[Display step results in compact format]
-
----
-
-## SUCCESS METRICS:
-- [What indicates this step succeeded]
-- [Measurable outcomes]
-
-## NEXT STEP:
-After showing summary, proceed directly to `./step-{next_number}-{next_name}.md`
-```
-
-### 3. Special Handling for Step 00 (Init)
-
-The first step (step-00-init) should always include:
-
-```markdown
-## EXECUTION SEQUENCE:
-
-### 1. Parse Input
-Parse flags and arguments from $ARGUMENTS.
-[Include flag parsing based on skill's <parameters>]
-
-### 2. Validate Input
-[Validate required fields, ask user if missing]
-
-### 3. Initialize State
-[Set all state variables to defaults or parsed values]
-
-### 4. Show Summary
-Display compact initialization summary table.
-```
-
-### 4. Special Handling for Last Step
-
-The last step should include:
-
-```markdown
-## EXECUTION SEQUENCE:
-
-### 1. [Final validation or action]
-
-### 2. Final Summary
-Display:
-- What was accomplished
-- Files created/modified
-- Any warnings or next steps
-
-## NEXT STEP:
-This is the final step. Skill execution is complete.
-```
-
-### 5. Write All Step Files
-
-Use Write tool for each step file. Run writes in parallel if possible.
-
-### 6. Confirm Generation
-
-```
-Generated {step_count} step files:
-
-| File | Next Step |
-|------|-----------|
-| steps/step-00-{name}.md | → step-01-{name}.md |
-| steps/step-01-{name}.md | → step-02-{name}.md |
-| ... | ... |
-| steps/step-{N}-{name}.md | (final) |
-
-→ Validating skill...
-```
-
----
-
-## SUCCESS METRICS:
-- All step files created in {target_dir}/steps/
-- Each step has proper frontmatter (name, description, next_step)
-- Step chaining is correct (no broken references)
-- First step handles initialization
-- Last step has completion summary
-- Standard sections present in each step
-
-## NEXT STEP:
-After generating all step files, proceed directly to `./step-04-validate.md`

package/templates/skills/cc-skill/steps/step-04-validate.md

@@ -1,124 +0,0 @@
----
-name: step-04-validate
-description: Validate generated skill structure and display final summary
----
-
-# Step 4: Validate Skill
-
-## MANDATORY EXECUTION RULES:
-- Validate ALL generated files
-- Check frontmatter completeness
-- Verify step chaining (if progressive)
-- Display actionable report if issues found
-
-## YOUR TASK:
-Validate the generated skill against official Claude Code conventions and display a final summary.
-
----
-
-## EXECUTION SEQUENCE:
-
-### 1. Read Generated Files
-
-```
-Read: "{target_dir}/SKILL.md"
-
-If progressive:
-  Glob: "{target_dir}/steps/step-*.md"
-  Read each step file
-```
-
-### 2. Validate SKILL.md
-
-**Frontmatter checks:**
-- [ ] `name` exists, lowercase, max 64 chars
-- [ ] `description` exists, non-empty
-- [ ] `argument-hint` present (if skill accepts args)
-- [ ] `disable-model-invocation` set for side-effect skills
-- [ ] `model` is valid (inherit/haiku/sonnet/opus) or absent
-
-**Content checks:**
-- [ ] Has `<objective>` section
-- [ ] Has `<quick_start>` with examples
-- [ ] Line count < 500
-- [ ] No unreplaced placeholders (e.g., `{placeholder}`)
-
-**Progressive-specific checks:**
-- [ ] Has `<entry_point>` pointing to first step
-- [ ] Has `<step_files>` listing all steps
-- [ ] Has `<state_variables>` documenting persistent state
-- [ ] Has `<workflow>` describing high-level flow
-
-### 3. Validate Step Files (if progressive)
-
-For each step file:
-- [ ] Has YAML frontmatter with `name` and `description`
-- [ ] Has `next_step` (except last step)
-- [ ] `next_step` path resolves to existing file
-- [ ] Has sections: YOUR TASK, EXECUTION SEQUENCE, SUCCESS METRICS
-- [ ] Last step has completion message (no next_step)
-
-**Chain validation:**
-```
-step-00 → step-01 → step-02 → ... → step-N (final)
-Verify: each next_step file exists
-Verify: no circular references
-Verify: no orphan steps (steps not in chain)
-```
-
-### 4. Validate File References
-
-Check all file paths referenced in SKILL.md and step files:
-- Templates referenced exist in `templates/`
-- References referenced exist in `references/`
-- Scripts referenced exist in `scripts/`
-
-### 5. Display Validation Report
-
-```
-Skill Validation Report:
-
-| Check | Status |
-|-------|--------|
-| Frontmatter complete | PASS/FAIL |
-| Content sections | PASS/FAIL |
-| Line count ({N} lines) | PASS/WARN |
-| Step chaining | PASS/FAIL/N/A |
-| File references | PASS/FAIL |
-
-{If any FAIL: show specific issues and recommendations}
-```
-
-### 6. Display Final Summary
-
-```
-Skill Created Successfully!
-
-| Property | Value |
-|----------|-------|
-| Name | {skill_name} |
-| Type | {skill_type} |
-| Location | {target_dir} |
-| Invocation | /cc-skill {skill_name} |
-| Files | {file_count} |
-
-Files created:
-  {target_dir}/SKILL.md
-  {target_dir}/steps/step-00-init.md (if progressive)
-  {target_dir}/steps/step-01-*.md (if progressive)
-  ...
-
-Next steps:
-- Test the skill: /{skill_name}
-- Add references: {target_dir}/references/
-- Add templates: {target_dir}/templates/
-- Run audit: /cc-audit
-```
-
----
-
-## SUCCESS METRICS:
-- All validations pass (or issues clearly reported)
-- Final summary displayed with file list
-- Next steps provided to the user
-- Skill is ready to use

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

@@ -1,85 +0,0 @@
-# Template: Forked Context Skill
-
-Use this template when creating a skill that runs in an isolated subagent context. Best for research, exploration, or tasks that need a clean context.
-
-## Generated SKILL.md format:
-
-```yaml
----
-name: {{SKILL_NAME}}
-description: |
-  {{DESCRIPTION}}
-{{#if ARGUMENT_HINT}}
-argument-hint: "{{ARGUMENT_HINT}}"
-{{/if}}
-context: fork
-agent: {{AGENT_TYPE}}
-allowed-tools: "{{ALLOWED_TOOLS}}"
-{{#if DISABLE_MODEL_INVOCATION}}
-disable-model-invocation: true
-{{/if}}
-{{#if MODEL}}
-model: {{MODEL}}
-{{/if}}
----
-
-<objective>
-{{OBJECTIVE}}
-
-**Note:** This skill runs in an isolated context. Use allowed tools directly - do NOT launch Task agents.
-</objective>
-
-<quick_start>
-
-` ` `bash
-/{{SKILL_NAME}} {{EXAMPLE_ARGS_1}}
-/{{SKILL_NAME}} {{EXAMPLE_ARGS_2}}
-` ` `
-
-</quick_start>
-
-## Task
-{{TASK_DESCRIPTION}}: $ARGUMENTS
-
-<workflow>
-
-## 1. Parse Input
-- Extract key information from the input
-- Identify scope and targets
-
-## 2. {{MAIN_PHASE}}
-{{MAIN_PHASE_INSTRUCTIONS}}
-
-## 3. Report Results
-- Provide comprehensive answer
-- Reference file paths and line numbers
-- Include relevant code examples
-
-</workflow>
-
-<execution_rules>
-- **PARALLEL SEARCH**: Run independent searches simultaneously
-- **CITE SOURCES**: Always reference file paths and line numbers
-- **STAY FOCUSED**: Only explore what is needed
-- **NO TASK AGENTS**: Use allowed tools directly (context is already forked)
-- {{RULE_1}}
-</execution_rules>
-
-<priority>
-{{PRIORITY_STATEMENT}}
-</priority>
-```
-
-## Agent Types:
-| Agent | Tools | Best for |
-|-------|-------|----------|
-| `Explore` | Read, Grep, Glob | Fast codebase search |
-| `Plan` | Read, Grep, Glob | Research and design |
-| `general-purpose` | All tools | Complex tasks |
-
-## Notes:
-- Forked skills run in isolated context (separate conversation)
-- Use `allowed-tools` to limit tool access
-- $ARGUMENTS passes user input to the forked context
-- Do NOT use progressive step loading with forked skills
-- Best for: code search, documentation lookup, research, analysis

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

@@ -1,102 +0,0 @@
-# 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

@@ -1,75 +0,0 @@
-# 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