kiro-kit 0.2.2 → 0.2.4

package/dist/presets/mobile/skills/kiro/references/troubleshooting.md

@@ -0,0 +1,42 @@
+# Troubleshooting
+
+## Common Issues
+
+### MCP Server Not Starting
+- Verify `uvx` is installed: run `uvx --version`
+- Check mcp.json syntax (valid JSON)
+- Ensure environment variables are set
+- Check Kiro's MCP Server view for error logs
+- Try restarting from command palette
+
+### Steering Files Not Loading
+- Verify front-matter has correct `inclusion` field
+- Check file is in `.kiro/steering/` directory
+- For fileMatch, verify pattern matches target files
+- Ensure no YAML syntax errors in front-matter
+
+### Skills Not Activating
+- Check skill.md has valid front-matter (name, description)
+- Verify skill directory is in `.kiro/skills/`
+- Ensure description contains relevant trigger keywords
+- Try referencing the skill explicitly
+
+### Hooks Not Triggering
+- Verify hook JSON schema is valid
+- Check event type matches expected trigger
+- For file events, verify patterns match file paths
+- Check command exists and is executable
+
+### Performance Issues
+- Reduce number of "always" steering files
+- Keep skill references focused and concise
+- Disable unused MCP servers
+- Clear workspace cache if needed
+
+## Debug Steps
+
+1. Check Kiro output panel for errors
+2. Verify `.kiro/` directory structure
+3. Validate JSON/YAML syntax in config files
+4. Try disabling extensions one by one
+5. Restart Kiro if issues persist

package/dist/presets/mobile/skills/kiro/skill.md

@@ -0,0 +1,194 @@
+---
+name: kiro
+description: >-
+  Use when users ask about Kiro IDE features, setup, configuration,
+  troubleshooting, specs, steering files, MCP servers, hooks, skills,
+  commands, or workspace management. Activate for questions like 'How
+  do I use Kiro?', 'What are specs?', 'How to set up MCP?', 'Create a
+  steering file', 'Fix Kiro issues', or 'Configure my workspace'.
+---
+
+# Kiro IDE Expert
+
+Kiro is an AI-powered development environment that helps developers focus on what matters: designing systems, exploring solutions, and making decisions. It combines autonomous planning, execution, and validation with extensibility through specs, steering files, skills, commands, hooks, and MCP servers.
+
+## When to Use This Skill
+
+Use when users need help with:
+- Understanding Kiro features and capabilities
+- Installation, setup, and workspace configuration
+- Creating and managing specs (requirements, design, tasks)
+- Writing steering files for project conventions
+- Creating or managing skills
+- Configuring MCP servers for external tool integration
+- Setting up hooks for automation
+- Using commands for development workflows
+- Troubleshooting Kiro issues
+- Multi-workspace and team collaboration
+- Advanced features (autonomy modes, context management)
+
+**Activation examples:**
+- "How do I use Kiro?"
+- "What are specs and how do I create one?"
+- "How to set up MCP servers?"
+- "Create a new steering file for X"
+- "Fix Kiro configuration issues"
+- "How do hooks work in Kiro?"
+
+## Core Architecture
+
+**Specs**: Structured feature development workflow (requirements -> design -> tasks) that guides implementation systematically
+
+**Steering Files**: Project-level instructions in `.kiro/steering/` that provide conventions, standards, and context to the AI agent
+
+**Skills**: Modular capabilities with instructions and references that Kiro activates automatically based on context
+
+**Commands**: User-defined operations in `.kiro/commands/` that expand to prompts for common workflows
+
+**Hooks**: Automated actions triggered by IDE events (file changes, tool use, task execution, prompt submission)
+
+**MCP Servers**: Model Context Protocol integrations connecting external tools and services via `.kiro/settings/mcp.json`
+
+## Quick Reference
+
+Load these references when needed for detailed guidance:
+
+### Getting Started
+- **Installation & Setup**: `references/getting-started.md`
+  - Prerequisites, installation, workspace setup, first run
+
+### Spec-Driven Development
+- **Specs Workflow**: `references/specs-workflow.md`
+  - Requirements, design, tasks, bugfix specs, property-based testing
+
+### Steering & Configuration
+- **Steering Files**: `references/steering-files.md`
+  - Always-included, conditional (fileMatch), manual inclusion, front-matter format
+
+- **Configuration**: `references/configuration.md`
+  - Settings hierarchy, MCP config, workspace vs user settings
+
+### Skills & Commands
+- **Skills**: `references/skills.md`
+  - Creating skills, skill.md format, references directory, activation patterns
+
+- **Commands**: `references/commands.md`
+  - Command file format, front-matter, argument hints, workflow patterns
+
+### Integration & Extension
+- **MCP Integration**: `references/mcp-integration.md`
+  - mcp.json configuration, common servers, auto-approve, troubleshooting
+
+- **Hooks**: `references/hooks.md`
+  - Event types (fileEdited, preToolUse, postToolUse, promptSubmit, etc.)
+  - Actions (askAgent, runCommand), hook schema, examples
+
+### Advanced Usage
+- **Autonomy Modes**: `references/autonomy-modes.md`
+  - Autopilot vs Supervised mode, when to use each
+
+- **Troubleshooting**: `references/troubleshooting.md`
+  - Common issues, MCP problems, performance, workspace diagnostics
+
+- **Best Practices**: `references/best-practices.md`
+  - Project organization, steering conventions, skill design, team workflows
+
+## Common Workflows
+
+### Spec-Driven Feature Development
+```
+1. Create a spec: Kiro guides you through requirements -> design -> tasks
+2. Execute tasks: Kiro implements each task from the spec sequentially
+3. Validate: Property-based tests verify correctness properties
+```
+
+### Steering File Setup
+```
+# .kiro/steering/my-conventions.md
+---
+inclusion: always
+description: Project coding conventions
+---
+
+Your conventions here...
+```
+
+### Hook Configuration
+```json
+{
+  "name": "Lint on Save",
+  "version": "1.0.0",
+  "when": {
+    "type": "fileEdited",
+    "patterns": ["*.ts", "*.tsx"]
+  },
+  "then": {
+    "type": "runCommand",
+    "command": "npm run lint"
+  }
+}
+```
+
+### MCP Server Setup
+```json
+{
+  "mcpServers": {
+    "my-server": {
+      "command": "uvx",
+      "args": ["my-mcp-server@latest"],
+      "env": {},
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
+### Skill Creation
+```
+.kiro/skills/my-skill/
+  skill.md          # Main skill file with front-matter
+  references/       # Supporting reference documents
+    guide.md
+```
+
+## Instructions for Kiro
+
+When responding to Kiro-related questions:
+
+1. **Identify the topic** from the user's question
+2. **Load relevant references** from the Quick Reference section above
+3. **Provide specific guidance** using information from loaded references
+4. **Include examples** when helpful
+
+**Loading references:**
+- Read reference files only when needed for the specific question
+- Multiple references can be loaded for complex queries
+
+**For setup questions:** Load `references/getting-started.md`
+
+**For spec questions:** Load `references/specs-workflow.md`
+
+**For steering questions:** Load `references/steering-files.md`
+
+**For skill creation:** Load `references/skills.md`
+
+**For command questions:** Load `references/commands.md`
+
+**For MCP questions:** Load `references/mcp-integration.md`
+
+**For hook questions:** Load `references/hooks.md`
+
+**For configuration:** Load `references/configuration.md`
+
+**For autonomy modes:** Load `references/autonomy-modes.md`
+
+**For troubleshooting:** Load `references/troubleshooting.md`
+
+**For best practices:** Load `references/best-practices.md`
+
+**Documentation links:**
+- Kiro docs: https://kiro.dev/docs/
+- GitHub: https://github.com/aws/kiro
+
+Provide accurate, actionable guidance based on the loaded references and official documentation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiro-kit",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "CLI tool for bootstrapping engineer-grade Kiro IDE workspaces with curated presets.",
   "type": "module",
   "bin": {

package/dist/presets/backend/skills/claude-code/references/advanced-features.md

@@ -1,399 +0,0 @@
-# Advanced Features
-
-Extended thinking, prompt caching, checkpointing, and memory management in Claude Code.
-
-## Extended Thinking
-
-Deep reasoning for complex problems.
-
-### Enable Extended Thinking
-
-**Global configuration:**
-```bash
-claude config set thinking.enabled true
-claude config set thinking.budget 15000
-```
-
-**Project settings (.kiro/settings.json):**
-```json
-{
-  "thinking": {
-    "enabled": true,
-    "budget": 10000,
-    "mode": "auto"
-  }
-}
-```
-
-**Command-line flag:**
-```bash
-claude --thinking "architect microservices system"
-```
-
-### Thinking Modes
-
-**auto**: Claude decides when to use extended thinking
-**manual**: User explicitly requests thinking
-**disabled**: No extended thinking
-
-```json
-{
-  "thinking": {
-    "mode": "auto",
-    "budget": 10000,
-    "minComplexity": 0.7
-  }
-}
-```
-
-### Budget Control
-
-Set token budget for thinking:
-
-```json
-{
-  "thinking": {
-    "budget": 10000,      // Max tokens for thinking
-    "budgetPerRequest": 5000,  // Per-request limit
-    "adaptive": true      // Adjust based on task complexity
-  }
-}
-```
-
-### Best Use Cases
-
-- Architecture design
-- Complex algorithm development
-- System refactoring
-- Performance optimization
-- Security analysis
-- Bug investigation
-
-### Example
-
-```bash
-claude --thinking "Design a distributed caching system with:
-- High availability
-- Consistency guarantees
-- Horizontal scalability
-- Fault tolerance"
-```
-
-## Prompt Caching
-
-Reduce costs by caching repeated context.
-
-### Enable Caching
-
-**API usage:**
-```typescript
-const response = await client.messages.create({
-  model: 'claude-sonnet-4-5-20250929',
-  system: [
-    {
-      type: 'text',
-      text: 'You are a coding assistant...',
-      cache_control: { type: 'ephemeral' }
-    }
-  ],
-  messages: [...]
-});
-```
-
-**CLI configuration:**
-```json
-{
-  "caching": {
-    "enabled": true,
-    "ttl": 300,
-    "maxSize": "100MB"
-  }
-}
-```
-
-### Cache Strategy
-
-**What to cache:**
-- Large codebases
-- Documentation
-- API specifications
-- System prompts
-- Project context
-
-**What not to cache:**
-- User queries
-- Dynamic content
-- Temporary data
-- Session-specific info
-
-### Cache Control
-
-```typescript
-// Cache large context
-{
-  type: 'text',
-  text: largeCodebase,
-  cache_control: { type: 'ephemeral' }
-}
-
-// Update without invalidating cache
-{
-  type: 'text',
-  text: newUserQuery
-  // No cache_control = not cached
-}
-```
-
-### Cost Savings
-
-With caching:
-- First request: Full cost
-- Subsequent requests: ~90% discount on cached tokens
-- Cache TTL: 5 minutes
-
-Example:
-```
-Without caching:
-Request 1: 10,000 tokens @ $3/M = $0.03
-Request 2: 10,000 tokens @ $3/M = $0.03
-Total: $0.06
-
-With caching (8,000 tokens cached):
-Request 1: 10,000 tokens @ $3/M = $0.03
-Request 2: 2,000 new + 8,000 cached @ $0.30/M = $0.0024
-Total: $0.0324 (46% savings)
-```
-
-## Checkpointing
-
-Automatically track and rewind changes.
-
-### Enable Checkpointing
-
-```bash
-claude config set checkpointing.enabled true
-```
-
-**Settings:**
-```json
-{
-  "checkpointing": {
-    "enabled": true,
-    "autoSave": true,
-    "interval": 300,
-    "maxCheckpoints": 50
-  }
-}
-```
-
-### View Checkpoints
-
-```bash
-# List checkpoints
-claude checkpoint list
-
-# View checkpoint details
-claude checkpoint show checkpoint-123
-```
-
-### Restore Checkpoint
-
-```bash
-# Restore to checkpoint
-claude checkpoint restore checkpoint-123
-
-# Restore to time
-claude checkpoint restore --time "2025-11-06T10:00:00Z"
-
-# Restore specific files
-claude checkpoint restore checkpoint-123 --files src/main.js
-```
-
-### Create Manual Checkpoint
-
-```bash
-# Create checkpoint with message
-claude checkpoint create "before refactoring auth module"
-
-# Create at important moments
-claude checkpoint create "working state before experiment"
-```
-
-### Checkpoint Strategies
-
-**Auto-save checkpoints:**
-- Before major changes
-- After successful tests
-- Every N minutes
-- Before destructive operations
-
-**Manual checkpoints:**
-- Before risky refactors
-- At working states
-- Before experiments
-- After milestones
-
-### Example Workflow
-
-```bash
-# Create checkpoint before risky change
-claude checkpoint create "before performance optimization"
-
-# Make changes
-claude "optimize database queries for 10x performance"
-
-# If something breaks
-claude checkpoint restore "before performance optimization"
-
-# Or continue with improvements
-claude checkpoint create "performance optimization complete"
-```
-
-## Memory Management
-
-Control how Claude remembers context across sessions.
-
-### Memory Locations
-
-**global**: Share memory across all projects
-**project**: Project-specific memory
-**none**: Disable memory
-
-```bash
-# Set memory location
-claude config set memory.location project
-
-# Enable memory
-claude config set memory.enabled true
-```
-
-### Configuration
-
-```json
-{
-  "memory": {
-    "enabled": true,
-    "location": "project",
-    "ttl": 86400,
-    "maxSize": "10MB",
-    "autoSummarize": true
-  }
-}
-```
-
-### Memory Operations
-
-```bash
-# View stored memories
-claude memory list
-
-# View specific memory
-claude memory show memory-123
-
-# Clear all memories
-claude memory clear
-
-# Clear old memories
-claude memory clear --older-than 7d
-
-# Clear project memories
-claude memory clear --project
-```
-
-### What Gets Remembered
-
-**Automatically:**
-- Project structure
-- Coding patterns
-- Preferences
-- Common commands
-- File locations
-
-**Explicitly stored:**
-- Important context
-- Design decisions
-- Architecture notes
-- Team conventions
-
-### Memory Best Practices
-
-**Project memory:**
-- Good for project-specific context
-- Shares across team members
-- Persists in `.kiro/memory/`
-- Commit to version control (optional)
-
-**Global memory:**
-- Personal preferences
-- General knowledge
-- Common patterns
-- Cross-project learnings
-
-**Disable memory when:**
-- Working with sensitive data
-- One-off tasks
-- Testing/experimentation
-- Troubleshooting
-
-### Example
-
-```bash
-# Remember project architecture
-claude "Remember: This project uses Clean Architecture with:
-- Domain layer (core business logic)
-- Application layer (use cases)
-- Infrastructure layer (external dependencies)
-- Presentation layer (API/UI)"
-
-# Claude will recall this in future sessions
-claude "Add a new user registration feature"
-# Claude: "I'll implement this following the Clean Architecture..."
-```
-
-## Context Windows
-
-Manage large context effectively.
-
-### Maximum Context
-
-Model context limits:
-- Claude Sonnet: 200k tokens
-- Claude Opus: 200k tokens
-- Claude Haiku: 200k tokens
-
-### Context Management
-
-```json
-{
-  "context": {
-    "maxTokens": 200000,
-    "autoTruncate": true,
-    "prioritize": ["recent", "relevant"],
-    "summarizeLong": true
-  }
-}
-```
-
-### Strategies
-
-**Summarization:**
-- Auto-summarize old context
-- Keep summaries of large files
-- Compress conversation history
-
-**Prioritization:**
-- Recent messages first
-- Most relevant files
-- Explicit user priorities
-
-**Chunking:**
-- Process large codebases in chunks
-- Incremental analysis
-- Parallel processing
-
-## See Also
-
-- Pricing: https://docs.claude.com/about-claude/pricing
-- Token counting: https://docs.claude.com/build-with-claude/token-counting
-- Best practices: `references/best-practices.md`
-- Configuration: `references/configuration.md`