dino-spec 0.1.0

package/dist/core/templates/slash-commands.js

@@ -0,0 +1,753 @@
+/**
+ * Slash command templates for .claude/commands/dino/
+ */
+export function getSlashCommandTemplates() {
+    return {
+        discover: getDiscoverTemplate(),
+        scout: getScoutTemplate(),
+        clarify: getClarifyTemplate(),
+        nest: getNestTemplate(),
+        hatch: getHatchTemplate(),
+        hunt: getHuntTemplate(),
+        fossil: getFossilTemplate(),
+        next: getNextTemplate(),
+        dna: getDnaCommandTemplate(),
+        skill: getSkillCommandTemplate(),
+    };
+}
+function getDiscoverTemplate() {
+    return `---
+description: Create a new specification from user intent
+argument-hint: <feature description>
+---
+
+# /dino.discover
+
+You are starting a new specification. Your goal is to understand the user's intent and create a clear spec.
+
+## User Input
+
+\`\`\`
+$ARGUMENTS
+\`\`\`
+
+## Instructions
+
+1. **Read project context** (if exists):
+   - Read \`.dino/dna.md\` for project conventions
+   - Understand the tech stack and patterns
+
+2. **Generate spec ID**:
+   - Create a short, kebab-case ID (e.g., "add-user-auth", "fix-login-bug")
+   - Check \`.dino/specs/\` to avoid duplicates
+
+3. **Create specification**:
+   - Create \`.dino/specs/{id}/spec.md\` with this structure:
+
+\`\`\`markdown
+# {Title}
+
+Created: {date} | Status: draft | Phase: discover
+
+## Goal
+
+{1-2 sentences describing the objective}
+
+## Requirements
+
+- [ ] REQ-1: {requirement}
+- [ ] REQ-2: {requirement}
+
+## Constraints
+
+{limitations, boundaries, non-goals}
+
+## Success Criteria
+
+- [ ] {measurable outcome}
+
+## Notes
+
+{additional context}
+\`\`\`
+
+4. **Update active spec**:
+   - Update \`.dino/active.json\` with the new spec ID and phase
+
+5. **Suggest next step**:
+   - If requirements are clear → suggest /dino.scout
+   - If ambiguous → suggest /dino.clarify
+
+## Rules
+
+- Do NOT create implementation plans yet
+- Do NOT write any code
+- Mark unclear requirements with [NEEDS CLARIFICATION]
+- Maximum 3 [NEEDS CLARIFICATION] markers
+- Keep requirements technology-agnostic when possible
+`;
+}
+function getScoutTemplate() {
+    return `---
+description: Research codebase and technical options for the active spec
+argument-hint: [tech stack or focus area]
+---
+
+# /dino.scout
+
+You are researching the codebase and technical options for the active specification.
+
+## Optional Focus
+
+\`\`\`
+$ARGUMENTS
+\`\`\`
+
+## Instructions
+
+1. **Load context**:
+   - Read \`.dino/active.json\` to get active spec
+   - Read \`.dino/specs/{id}/spec.md\` for requirements
+   - Read \`.dino/dna.md\` for project conventions
+
+2. **Explore codebase**:
+   - Find relevant existing code patterns
+   - Identify similar implementations
+   - Note reusable components or utilities
+
+3. **Research technical options**:
+   - If tech stack specified, research best practices
+   - Search for up-to-date documentation
+   - Identify dependencies needed
+
+4. **Create research document**:
+   - Create \`.dino/specs/{id}/research.md\`:
+
+\`\`\`markdown
+# Research: {spec title}
+
+## Existing Patterns
+
+{relevant code found in codebase}
+
+## Technical Options
+
+### Option 1: {approach}
+- Pros: {benefits}
+- Cons: {drawbacks}
+
+### Option 2: {approach}
+- Pros: {benefits}
+- Cons: {drawbacks}
+
+## Dependencies
+
+{new packages or tools needed}
+
+## Unknowns
+
+{questions that need clarification}
+
+## Recommendation
+
+{preferred approach with reasoning}
+\`\`\`
+
+5. **Update phase**:
+   - Update \`.dino/active.json\` phase to "scout"
+
+6. **Suggest next step**:
+   - If unknowns exist → suggest /dino.clarify
+   - If clear → suggest /dino.nest
+
+## Rules
+
+- Do NOT modify any existing code
+- Do NOT create implementation plans yet
+- Be thorough but concise
+- Cite specific file paths when referencing code
+`;
+}
+function getClarifyTemplate() {
+    return `---
+description: Resolve ambiguity in the active specification
+---
+
+# /dino.clarify
+
+You are resolving ambiguity in the active specification through targeted questions.
+
+## Instructions
+
+1. **Load context**:
+   - Read \`.dino/active.json\` to get active spec
+   - Read \`.dino/specs/{id}/spec.md\` for requirements
+   - Read \`.dino/specs/{id}/research.md\` if exists
+
+2. **Identify ambiguities**:
+   - Find [NEEDS CLARIFICATION] markers
+   - Look for vague requirements
+   - Check for missing edge cases
+   - Note unclear success criteria
+
+3. **Ask questions using AskUserQuestion**:
+   - Maximum 5 questions per session
+   - Each question should have 2-4 options
+   - Always include "Other" option
+   - Prioritize most impactful questions first
+
+4. **Update specification**:
+   - After each answer, update spec.md immediately
+   - Remove [NEEDS CLARIFICATION] markers as resolved
+   - Add clarified details to appropriate sections
+
+5. **Update phase**:
+   - Update \`.dino/active.json\` phase to "clarify"
+
+6. **Suggest next step**:
+   - If all ambiguity resolved → suggest /dino.nest
+   - If more research needed → suggest /dino.scout
+   - If more questions → continue clarifying
+
+## Question Format
+
+Use AskUserQuestion tool with this structure:
+- **header**: Short category (e.g., "Auth Method", "Error Handling")
+- **question**: Clear, specific question ending with ?
+- **options**: 2-4 distinct choices with descriptions
+- **multiSelect**: false (unless choices aren't mutually exclusive)
+
+## Rules
+
+- Never guess or assume - always ask
+- One question at a time when possible
+- Integrate answers immediately into spec.md
+- Do NOT create implementation plans yet
+`;
+}
+function getNestTemplate() {
+    return `---
+description: Create implementation plan for the active spec (requires Plan Mode)
+---
+
+# /dino.nest
+
+You are creating the implementation plan for the active specification.
+
+**IMPORTANT**: This command requires Plan Mode. Enter Plan Mode before proceeding.
+
+## Instructions
+
+1. **Enter Plan Mode**:
+   - Use EnterPlanMode tool
+   - This is required before creating the plan
+
+2. **Load context**:
+   - Read \`.dino/active.json\` to get active spec
+   - Read \`.dino/specs/{id}/spec.md\` for requirements
+   - Read \`.dino/specs/{id}/research.md\` for technical context
+   - Read \`.dino/dna.md\` for project conventions
+
+3. **Design implementation approach**:
+   - Choose architecture based on research
+   - Define data models if needed
+   - Plan API contracts if applicable
+   - Consider testing strategy
+
+4. **Create plan document**:
+   - Create \`.dino/specs/{id}/plan.md\`:
+
+\`\`\`markdown
+# Implementation Plan: {spec title}
+
+## Summary
+
+{1-2 paragraph overview of the approach}
+
+## Technical Decisions
+
+- **Architecture**: {chosen approach}
+- **Key Dependencies**: {libraries/tools}
+- **Data Model**: {entities and relationships}
+
+## Implementation Phases
+
+### Phase 1: Foundation
+{setup and infrastructure}
+
+### Phase 2: Core Features
+{main functionality}
+
+### Phase 3: Integration
+{connecting components}
+
+### Phase 4: Polish
+{error handling, edge cases, documentation}
+
+## Testing Strategy
+
+{how to verify the implementation}
+
+## Risks and Mitigations
+
+{potential issues and how to handle them}
+\`\`\`
+
+5. **Update phase**:
+   - Update \`.dino/active.json\` phase to "nest"
+
+6. **Exit Plan Mode**:
+   - Use ExitPlanMode when plan is ready for approval
+
+7. **After approval**:
+   - Suggest /dino.hatch to break into tasks
+
+## Rules
+
+- Must be in Plan Mode for the entire process
+- Do NOT write any code yet
+- Keep plan high-level but actionable
+- Maximum 4 implementation phases
+`;
+}
+function getHatchTemplate() {
+    return `---
+description: Break implementation plan into phased tasks
+---
+
+# /dino.hatch
+
+You are breaking the implementation plan into actionable, phased tasks.
+
+**NOTE**: Requires Plan Mode if creating 5+ tasks.
+
+## Instructions
+
+1. **Check task count**:
+   - If plan suggests 5+ tasks → Enter Plan Mode first
+   - If fewer tasks → proceed directly
+
+2. **Load context**:
+   - Read \`.dino/active.json\` to get active spec
+   - Read \`.dino/specs/{id}/plan.md\` for implementation approach
+   - Read \`.dino/specs/{id}/spec.md\` for requirements
+
+3. **Break into tasks**:
+   - Maximum 8-10 tasks per phase
+   - Each task should be independently completable
+   - Include file paths in task descriptions
+   - Mark parallelizable tasks with [P]
+
+4. **Create tasks document**:
+   - Create \`.dino/specs/{id}/tasks.md\`:
+
+\`\`\`markdown
+# Tasks: {spec title}
+
+## Phase 1: Foundation
+
+- [ ] T001 Create directory structure at src/{path}
+- [ ] T002 [P] Add dependencies to package.json
+- [ ] T003 [P] Create config file at src/config/{name}.ts
+
+## Phase 2: Core Features
+
+- [ ] T004 Implement {feature} at src/{path}
+- [ ] T005 [P] Add tests for {feature} at tests/{path}
+- [ ] T006 Implement {feature 2} at src/{path}
+
+## Phase 3: Integration
+
+- [ ] T007 Connect {component A} to {component B}
+- [ ] T008 Add error handling
+
+## Phase 4: Polish
+
+- [ ] T009 Add documentation
+- [ ] T010 Final testing and cleanup
+
+## Execution Notes
+
+- Complete Phase 1 before starting Phase 2
+- [P] tasks within a phase can run in parallel
+- Mark tasks [x] as completed immediately
+\`\`\`
+
+5. **Validate tasks**:
+   - Each requirement maps to at least one task
+   - No task is too large (should take < 30 min)
+   - Dependencies between tasks are clear
+
+6. **Update phase**:
+   - Update \`.dino/active.json\` phase to "hatch"
+
+7. **Suggest next step**:
+   - Suggest /dino.hunt to start implementation
+
+## Task Format
+
+\`\`\`
+- [ ] T{NNN} [P?] Description with file path
+\`\`\`
+
+- \`T{NNN}\`: Sequential task ID (T001, T002, etc.)
+- \`[P]\`: Optional - marks parallelizable tasks
+- Description must include target file/directory path
+
+## Rules
+
+- Maximum 10 tasks per phase
+- Maximum 4 phases total
+- Each task should be atomic and testable
+- Include "run tests" as explicit tasks
+`;
+}
+function getHuntTemplate() {
+    return `---
+description: Implement tasks from the active specification
+---
+
+# /dino.hunt
+
+You are implementing tasks from the active specification. This is where code gets written!
+
+## Instructions
+
+1. **Load context**:
+   - Read \`.dino/active.json\` to get active spec
+   - Read \`.dino/specs/{id}/tasks.md\` for task list
+   - Read \`.dino/specs/{id}/plan.md\` for technical decisions
+   - Read \`.dino/specs/{id}/spec.md\` for requirements
+   - Read \`.dino/dna.md\` for code conventions
+
+2. **Find next task**:
+   - Look for first unchecked task: \`- [ ] T{NNN}\`
+   - Check phase dependencies (Phase N must complete before N+1)
+   - [P] tasks in same phase can run in parallel
+
+3. **Implement the task**:
+   - Write code following project conventions
+   - Follow the plan's technical decisions
+   - Include appropriate error handling
+   - Write tests if task specifies
+
+4. **Mark task complete**:
+   - Immediately after completing a task
+   - Update tasks.md: change \`- [ ]\` to \`- [x]\`
+   - Save the file right away
+
+5. **Report progress**:
+   - Show which task was completed
+   - Show remaining tasks in current phase
+   - Calculate overall progress percentage
+
+6. **Continue or complete**:
+   - If more tasks → continue with next task
+   - If current phase complete → start next phase
+   - If all tasks complete → suggest /dino.fossil
+
+## Progress Tracking
+
+After each task, report:
+\`\`\`
+✓ T003 [Completed] Create user model at src/models/user.ts
+
+Phase 1: [████████░░] 80% (4/5 tasks)
+Overall: [██████░░░░] 60% (6/10 tasks)
+
+Next: T004 Add validation to user model
+\`\`\`
+
+## Rules
+
+- Complete tasks in order within each phase
+- [P] tasks can be done in any order within their phase
+- Mark tasks complete IMMEDIATELY after finishing
+- Do not skip tasks
+- Follow code conventions from .dino/dna.md
+- If stuck, explain the blocker and ask for help
+`;
+}
+function getFossilTemplate() {
+    return `---
+description: Archive the completed specification
+---
+
+# /dino.fossil
+
+You are archiving a completed specification, creating a fossil record for future reference.
+
+## Instructions
+
+1. **Verify completion**:
+   - Read \`.dino/specs/{id}/tasks.md\`
+   - Check all tasks are marked \`[x]\`
+   - If incomplete tasks exist, warn and confirm with user
+
+2. **Create archive entry**:
+   - Generate date prefix: YYYY-MM-DD
+   - Move \`.dino/specs/{id}/\` to \`.dino/archive/{date}-{id}/\`
+
+3. **Add completion notes**:
+   - Create or update \`.dino/archive/{date}-{id}/COMPLETED.md\`:
+
+\`\`\`markdown
+# Completed: {spec title}
+
+Archived: {date}
+Duration: {time from created to now}
+
+## Summary
+
+{brief description of what was accomplished}
+
+## Files Changed
+
+{list of key files created/modified}
+
+## Lessons Learned
+
+{any insights for future work}
+\`\`\`
+
+4. **Clear active spec**:
+   - Update \`.dino/active.json\`:
+     - Set id to null
+     - Set phase to null
+
+5. **Report completion**:
+   - Show the fossil ASCII art
+   - Confirm archival location
+   - Show summary of completed work
+
+6. **Suggest next step**:
+   - Suggest /dino.next for feature recommendations
+   - Or mention user can start new spec with /dino.discover
+
+## Rules
+
+- Do not archive incomplete specs without user confirmation
+- Preserve all spec files in archive
+- Clear active.json after archiving
+`;
+}
+function getNextTemplate() {
+    return `---
+description: Suggest next features or improvements
+---
+
+# /dino.next
+
+You are analyzing the project to suggest next steps and potential features.
+
+## Instructions
+
+1. **Analyze project state**:
+   - Read \`.dino/dna.md\` for project context
+   - List archived specs: \`.dino/archive/\`
+   - Check for patterns in completed work
+
+2. **Explore codebase**:
+   - Look for TODOs and FIXMEs
+   - Find incomplete features
+   - Identify technical debt
+   - Note missing tests
+
+3. **Generate suggestions**:
+   - Create 3-5 actionable suggestions
+   - Prioritize by impact and effort
+   - Include reasoning for each
+
+4. **Present options using AskUserQuestion**:
+   - Let user choose which to pursue
+   - Include "Something else" option
+
+5. **After selection**:
+   - If user picks a suggestion → run /dino.discover with that intent
+   - If "Something else" → ask for their idea
+
+## Suggestion Format
+
+Present each suggestion as:
+\`\`\`
+### {Priority} - {Title}
+
+**What**: {brief description}
+**Why**: {benefit or problem it solves}
+**Effort**: {Low/Medium/High estimate}
+\`\`\`
+
+## Rules
+
+- Base suggestions on actual code analysis
+- Don't suggest completed features
+- Keep suggestions concrete and actionable
+- This command is optional - user can skip to /dino.discover directly
+`;
+}
+function getDnaCommandTemplate() {
+    return `---
+description: Generate project-specific skills based on tech stack analysis
+---
+
+# /dino.dna
+
+You are analyzing the project to generate helpful Claude Code skills.
+
+## Instructions
+
+1. **Analyze project**:
+   - Read package.json, pyproject.toml, Cargo.toml, etc.
+   - Identify programming language(s)
+   - Find framework(s) used
+   - Detect testing tools
+   - Note linters/formatters configured
+
+2. **Suggest skills**:
+   - Based on detected tech stack
+   - Each skill should automate a common task
+   - Present options using AskUserQuestion
+
+3. **Skill categories**:
+   - **linter**: Run code quality checks after generation
+   - **type-check**: Run type checker (tsc, pyright, mypy)
+   - **test-runner**: Run tests after implementation
+   - **formatter**: Format code (prettier, black, rustfmt)
+   - **build**: Build/compile the project
+
+4. **Generate selected skills**:
+   - Create \`.claude/skills/{name}/SKILL.md\` for each
+   - Use this format:
+
+\`\`\`markdown
+---
+name: {skill-name}
+description: {what it does}
+---
+
+# {Skill Title}
+
+{instructions for when and how to use this skill}
+
+## Triggers
+
+- {when this skill should activate}
+
+## Actions
+
+- {what the skill does}
+\`\`\`
+
+5. **Preserve user modifications**:
+   - Check for existing skills
+   - Use DINO:CORE and DINO:USER markers
+   - Only update DINO:CORE sections
+
+## Example Skills
+
+**linter** (TypeScript project):
+\`\`\`markdown
+---
+name: linter
+description: Run ESLint after code generation
+---
+
+# Linter
+
+Run ESLint to catch errors and enforce code style after generating or modifying code.
+
+## Triggers
+
+- After creating new .ts or .tsx files
+- After significant code modifications
+
+## Actions
+
+- Run: npx eslint --fix {files}
+- Report any unfixable errors
+- Suggest fixes for common issues
+\`\`\`
+
+## Rules
+
+- Only suggest skills relevant to detected tech stack
+- Let user choose which skills to generate
+- Don't overwrite user customizations
+`;
+}
+function getSkillCommandTemplate() {
+    return `---
+description: Create a custom skill from description
+argument-hint: <skill description>
+---
+
+# /dino.skill
+
+You are creating a custom Claude Code skill based on user description.
+
+## User Input
+
+\`\`\`
+$ARGUMENTS
+\`\`\`
+
+## Instructions
+
+1. **Parse intent**:
+   - Understand what the skill should do
+   - Identify triggers (when it activates)
+   - Define actions (what it does)
+
+2. **Generate skill name**:
+   - Create kebab-case ID from description
+   - Check \`.claude/skills/\` for duplicates
+
+3. **Create skill file**:
+   - Create \`.claude/skills/{name}/SKILL.md\`:
+
+\`\`\`markdown
+---
+name: {skill-name}
+description: {concise description}
+---
+
+# {Skill Title}
+
+{detailed instructions}
+
+## Triggers
+
+- {when this skill activates}
+
+## Actions
+
+- {what the skill does}
+
+<!-- DINO:USER:START -->
+## Custom Notes
+
+{user can add notes here}
+<!-- DINO:USER:END -->
+\`\`\`
+
+4. **Confirm creation**:
+   - Show the created skill
+   - Explain how it will be used
+
+## Examples
+
+Input: "run tests after I finish implementing a feature"
+Creates: \`test-runner\` skill that runs project tests
+
+Input: "check for security vulnerabilities in dependencies"
+Creates: \`security-audit\` skill that runs npm audit or similar
+
+## Rules
+
+- Keep skills focused on one purpose
+- Include clear trigger conditions
+- Use project-specific commands when possible
+- Add DINO:USER markers for customization
+`;
+}
+//# sourceMappingURL=slash-commands.js.map