kiro-kit 0.2.2 → 0.3.0

package/dist/presets/devops/manifest.json

@@ -535,6 +535,29 @@
       "type": "hook",
       "executable": true
     },
+    {
+      "source": "hooks/terraform-plan-review.js",
+      "target": ".kiro/hooks/terraform-plan-review.js",
+      "type": "hook",
+      "executable": true
+    },
+    {
+      "source": "hooks/container-scan.js",
+      "target": ".kiro/hooks/container-scan.js",
+      "type": "hook",
+      "executable": true
+    },
+    {
+      "source": "hooks/cost-estimation.js",
+      "target": ".kiro/hooks/cost-estimation.js",
+      "type": "hook",
+      "executable": true
+    },
+    {
+      "source": "powers.json",
+      "target": ".kiro/powers.json",
+      "type": "powers"
+    },
     {
       "source": "metadata.json",
       "target": ".kiro/metadata.json",
@@ -831,73 +854,63 @@
       "type": "skill"
     },
     {
-      "source": "skills/claude-code/references/advanced-features.md",
-      "target": ".kiro/skills/claude-code/references/advanced-features.md",
-      "type": "doc"
-    },
-    {
-      "source": "skills/claude-code/references/agent-skills.md",
-      "target": ".kiro/skills/claude-code/references/agent-skills.md",
-      "type": "doc"
-    },
-    {
-      "source": "skills/claude-code/references/api-reference.md",
-      "target": ".kiro/skills/claude-code/references/api-reference.md",
-      "type": "doc"
+      "source": "skills/kiro/skill.md",
+      "target": ".kiro/skills/kiro/skill.md",
+      "type": "skill"
     },
     {
-      "source": "skills/claude-code/references/best-practices.md",
-      "target": ".kiro/skills/claude-code/references/best-practices.md",
+      "source": "skills/kiro/references/autonomy-modes.md",
+      "target": ".kiro/skills/kiro/references/autonomy-modes.md",
       "type": "doc"
     },
     {
-      "source": "skills/claude-code/references/cicd-integration.md",
-      "target": ".kiro/skills/claude-code/references/cicd-integration.md",
+      "source": "skills/kiro/references/best-practices.md",
+      "target": ".kiro/skills/kiro/references/best-practices.md",
       "type": "doc"
     },
     {
-      "source": "skills/claude-code/references/configuration.md",
-      "target": ".kiro/skills/claude-code/references/configuration.md",
+      "source": "skills/kiro/references/commands.md",
+      "target": ".kiro/skills/kiro/references/commands.md",
       "type": "doc"
     },
     {
-      "source": "skills/claude-code/references/enterprise-features.md",
-      "target": ".kiro/skills/claude-code/references/enterprise-features.md",
+      "source": "skills/kiro/references/configuration.md",
+      "target": ".kiro/skills/kiro/references/configuration.md",
       "type": "doc"
     },
     {
-      "source": "skills/claude-code/references/getting-started.md",
-      "target": ".kiro/skills/claude-code/references/getting-started.md",
+      "source": "skills/kiro/references/getting-started.md",
+      "target": ".kiro/skills/kiro/references/getting-started.md",
       "type": "doc"
     },
     {
-      "source": "skills/claude-code/references/hooks-and-plugins.md",
-      "target": ".kiro/skills/claude-code/references/hooks-and-plugins.md",
+      "source": "skills/kiro/references/hooks.md",
+      "target": ".kiro/skills/kiro/references/hooks.md",
       "type": "doc"
     },
     {
-      "source": "skills/claude-code/references/ide-integration.md",
-      "target": ".kiro/skills/claude-code/references/ide-integration.md",
+      "source": "skills/kiro/references/mcp-integration.md",
+      "target": ".kiro/skills/kiro/references/mcp-integration.md",
       "type": "doc"
     },
     {
-      "source": "skills/claude-code/references/mcp-integration.md",
-      "target": ".kiro/skills/claude-code/references/mcp-integration.md",
+      "source": "skills/kiro/references/skills.md",
+      "target": ".kiro/skills/kiro/references/skills.md",
       "type": "doc"
     },
     {
-      "source": "skills/claude-code/references/slash-commands.md",
-      "target": ".kiro/skills/claude-code/references/slash-commands.md",
+      "source": "skills/kiro/references/specs-workflow.md",
+      "target": ".kiro/skills/kiro/references/specs-workflow.md",
       "type": "doc"
     },
     {
-      "source": "skills/claude-code/references/troubleshooting.md",
-      "target": ".kiro/skills/claude-code/references/troubleshooting.md",
+      "source": "skills/kiro/references/steering-files.md",
+      "target": ".kiro/skills/kiro/references/steering-files.md",
       "type": "doc"
     },
     {
-      "source": "skills/claude-code/skill.md",
-      "target": ".kiro/skills/claude-code/skill.md",
+      "source": "skills/kiro/references/troubleshooting.md",
+      "target": ".kiro/skills/kiro/references/troubleshooting.md",
       "type": "doc"
     },
     {

package/dist/presets/devops/powers.json

@@ -0,0 +1,40 @@
+{
+  "powers": [
+    {
+      "name": "Terraform",
+      "url": "https://kiro.dev/powers/terraform",
+      "description": "Infrastructure as Code with registry providers and modules",
+      "tier": "essential"
+    },
+    {
+      "name": "Datadog",
+      "url": "https://kiro.dev/powers/datadog",
+      "description": "Production monitoring, logging, and APM",
+      "tier": "recommended"
+    },
+    {
+      "name": "Snyk",
+      "url": "https://kiro.dev/powers/snyk",
+      "description": "Security scanning for containers and infrastructure",
+      "tier": "recommended"
+    },
+    {
+      "name": "Depot",
+      "url": "https://kiro.dev/powers/depot",
+      "description": "Optimized container builds and CI/CD pipelines",
+      "tier": "recommended"
+    },
+    {
+      "name": "Harness",
+      "url": "https://kiro.dev/powers/harness",
+      "description": "CI/CD pipelines, cloud cost management, and feature flags",
+      "tier": "optional"
+    },
+    {
+      "name": "AWS CDK",
+      "url": "https://kiro.dev/powers/aws-cdk",
+      "description": "AWS infrastructure with CDK using best practices",
+      "tier": "optional"
+    }
+  ]
+}

package/dist/presets/devops/skills/kiro/references/autonomy-modes.md

@@ -0,0 +1,26 @@
+# Autonomy Modes
+
+## Overview
+
+Kiro offers two modes for how the AI agent interacts with your workspace.
+
+## Autopilot Mode
+
+- Agent modifies files autonomously within the workspace
+- Best for: routine tasks, well-defined changes, trusted workflows
+- Changes are applied immediately
+- Use when you trust the agent's judgment for the task
+
+## Supervised Mode
+
+- User has opportunity to review and revert changes after application
+- Best for: complex refactors, unfamiliar codebases, learning
+- Changes can be inspected before accepting
+- Use when you want more control over modifications
+
+## Choosing a Mode
+
+- Start with Supervised for new projects or unfamiliar tasks
+- Switch to Autopilot for repetitive, well-understood operations
+- Use Supervised for security-sensitive changes
+- Autopilot works well for spec task execution

package/dist/presets/devops/skills/kiro/references/best-practices.md

@@ -0,0 +1,48 @@
+# Best Practices
+
+## Project Organization
+
+- Keep `.kiro/` directory in version control
+- Use consistent naming (kebab-case for directories)
+- Document custom skills and commands in project README
+- Share steering files across team via git
+
+## Steering Conventions
+
+- One topic per steering file
+- Use "always" only for critical, universal rules
+- Use "fileMatch" for language/framework-specific guidance
+- Keep files concise (under 100 lines ideally)
+- Include examples in steering content
+
+## Skill Design
+
+- Focus each skill on one domain
+- Write clear activation descriptions
+- Use references for detailed content
+- Keep main skill.md as an overview/router
+- Test activation with various phrasings
+
+## Hook Patterns
+
+- Use file hooks for linting and formatting
+- Use postTaskExecution for test validation
+- Use preToolUse for access control
+- Keep hook commands fast (under 30 seconds)
+- Log hook failures for debugging
+
+## Team Workflows
+
+- Standardize steering files across projects
+- Share skills via presets or git submodules
+- Document MCP server requirements in README
+- Use specs for all non-trivial features
+- Review spec documents before task execution
+
+## Cost Management
+
+- Use steering to keep responses focused
+- Avoid overly broad "always" steering
+- Disable unused MCP servers
+- Use Supervised mode for exploratory work
+- Keep skill references concise

package/dist/presets/devops/skills/kiro/references/commands.md

@@ -0,0 +1,61 @@
+# Commands
+
+## Overview
+
+Commands are user-defined operations in `.kiro/commands/` that expand to prompts. They provide shortcuts for common workflows.
+
+## File Format
+
+```markdown
+---
+description: Brief description of what this command does
+inclusion: manual
+argument-hint: "[pattern]"
+---
+
+## Arguments
+PATTERN: $1 (default: all)
+
+## Workflow
+1. Step one
+2. Step two
+3. Step three
+```
+
+## Front-Matter
+
+Required fields:
+- `description`: What the command does
+
+Optional fields:
+- `inclusion`: "manual" (default)
+- `argument-hint`: Hint for arguments shown to user
+
+## Arguments
+
+Use `$1`, `$2`, etc. for positional arguments passed by the user.
+
+## Nested Commands
+
+Commands can be organized in subdirectories:
+```
+.kiro/commands/
+  test.md
+  fix/
+    types.md
+    test.md
+    fast.md
+  git/
+    cm.md
+    cp.md
+    pr.md
+```
+
+Access nested commands with colon notation: `/fix:types`, `/git:cm`
+
+## Best Practices
+
+- Keep commands focused on one workflow
+- Include clear step-by-step instructions
+- Use argument hints to guide users
+- Document default behavior when no arguments provided

package/dist/presets/devops/skills/kiro/references/configuration.md

@@ -0,0 +1,41 @@
+# Configuration
+
+## Settings Hierarchy
+
+Settings are merged with precedence:
+1. User-level: `~/.kiro/settings/mcp.json` (global)
+2. Workspace-level: `.kiro/settings/mcp.json` (per project)
+
+Workspace settings override user settings.
+
+## MCP Configuration
+
+File: `.kiro/settings/mcp.json`
+
+```json
+{
+  "mcpServers": {
+    "server-name": {
+      "command": "uvx",
+      "args": ["package-name@latest"],
+      "env": {
+        "API_KEY": "your-key"
+      },
+      "disabled": false,
+      "autoApprove": ["tool-name"]
+    }
+  }
+}
+```
+
+## Key Settings
+
+- `command`: Executable to run the MCP server
+- `args`: Command-line arguments
+- `env`: Environment variables passed to the server
+- `disabled`: Enable/disable without removing config
+- `autoApprove`: Tools that don't require user confirmation
+
+## Multi-Root Workspaces
+
+Each workspace folder can have its own `.kiro/settings/mcp.json`. Configs merge with later folders taking precedence.

package/dist/presets/devops/skills/kiro/references/getting-started.md

@@ -0,0 +1,45 @@
+# Getting Started with Kiro
+
+## Prerequisites
+
+- Supported OS: Windows, macOS, Linux
+- Internet connection for AI features
+
+## Installation
+
+Download Kiro from https://kiro.dev and install for your platform.
+
+## First Run
+
+1. Open Kiro
+2. Open or create a workspace folder
+3. Start chatting with the AI agent in the chat panel
+
+## Workspace Setup
+
+Kiro stores configuration in `.kiro/` at the workspace root:
+
+```
+.kiro/
+  settings/
+    mcp.json          # MCP server configuration
+  steering/           # Steering files (conventions, rules)
+  skills/             # Custom skills
+  commands/           # Custom commands
+  hooks/              # Agent hooks
+  specs/              # Feature specs
+```
+
+## Authentication
+
+- Sign in with your AWS account or supported identity provider
+- API keys are managed automatically by the IDE
+
+## Key Concepts
+
+- **Chat**: Interact with the AI agent directly
+- **Specs**: Structured feature development (requirements -> design -> tasks)
+- **Steering**: Project-level instructions that guide the AI
+- **Skills**: Modular capabilities activated by context
+- **Hooks**: Automated actions on IDE events
+- **MCP**: External tool integrations

package/dist/presets/devops/skills/kiro/references/hooks.md

@@ -0,0 +1,99 @@
+# Hooks
+
+## Overview
+
+Hooks automate agent actions based on IDE events. When an event occurs, the specified action runs automatically.
+
+## Event Types
+
+- `fileEdited`: When a user saves a code file
+- `fileCreated`: When a user creates a new file
+- `fileDeleted`: When the user deletes a file
+- `userTriggered`: Manual trigger by user
+- `promptSubmit`: When a message is sent to the agent
+- `agentStop`: When an agent execution completes
+- `preToolUse`: Before a tool is executed
+- `postToolUse`: After a tool is executed
+- `preTaskExecution`: Before a spec task starts
+- `postTaskExecution`: After a spec task completes
+
+## Actions
+
+- `askAgent`: Send a prompt to the agent
+- `runCommand`: Execute a shell command
+
+## Hook Schema
+
+```json
+{
+  "name": "Hook Name",
+  "version": "1.0.0",
+  "description": "Optional description",
+  "when": {
+    "type": "fileEdited",
+    "patterns": ["*.ts", "*.tsx"]
+  },
+  "then": {
+    "type": "runCommand",
+    "command": "npm run lint"
+  }
+}
+```
+
+## File Events
+
+Require `patterns` array with glob patterns:
+```json
+{
+  "when": {
+    "type": "fileEdited",
+    "patterns": ["*.ts", "*.tsx"]
+  }
+}
+```
+
+## Tool Events
+
+Require `toolTypes` array with categories or regex:
+```json
+{
+  "when": {
+    "type": "preToolUse",
+    "toolTypes": ["write"]
+  }
+}
+```
+
+Valid categories: `read`, `write`, `shell`, `web`, `spec`, `*`
+
+## Examples
+
+### Lint on Save
+```json
+{
+  "name": "Lint on Save",
+  "version": "1.0.0",
+  "when": { "type": "fileEdited", "patterns": ["*.ts"] },
+  "then": { "type": "runCommand", "command": "npm run lint" }
+}
+```
+
+### Run Tests After Task
+```json
+{
+  "name": "Test After Task",
+  "version": "1.0.0",
+  "when": { "type": "postTaskExecution" },
+  "then": { "type": "runCommand", "command": "npm test" }
+}
+```
+
+### Review Writes
+```json
+{
+  "name": "Review Writes",
+  "version": "1.0.0",
+  "when": { "type": "preToolUse", "toolTypes": ["write"] },
+  "then": { "type": "askAgent", "prompt": "Verify this follows coding standards" }
+}
+```

package/dist/presets/devops/skills/kiro/references/mcp-integration.md

@@ -0,0 +1,53 @@
+# MCP Integration
+
+## Overview
+
+Model Context Protocol (MCP) connects external tools and services to Kiro. Servers provide tools that the AI agent can invoke.
+
+## Configuration
+
+File: `.kiro/settings/mcp.json`
+
+```json
+{
+  "mcpServers": {
+    "server-name": {
+      "command": "uvx",
+      "args": ["package@latest"],
+      "env": {},
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
+## Common Servers
+
+- `awslabs.aws-documentation-mcp-server` - AWS documentation
+- `@anthropic/mcp-server-filesystem` - File system access
+- `@anthropic/mcp-server-github` - GitHub integration
+
+## Installation
+
+Most MCP servers use `uvx` (from the `uv` Python package manager):
+1. Install `uv`: https://docs.astral.sh/uv/getting-started/installation/
+2. Add server config to mcp.json
+3. Server auto-starts on config change
+
+## Auto-Approve
+
+List tool names in `autoApprove` to skip confirmation prompts:
+```json
+{
+  "autoApprove": ["read_file", "search_files"]
+}
+```
+
+## Troubleshooting
+
+- Check server logs in Kiro's MCP Server view
+- Verify `uvx` is installed and accessible
+- Ensure environment variables are set correctly
+- Use command palette: "MCP" to find relevant commands
+- Servers reconnect automatically on config changes

package/dist/presets/devops/skills/kiro/references/skills.md

@@ -0,0 +1,55 @@
+# Skills
+
+## Overview
+
+Skills are modular capabilities that Kiro activates automatically based on context. They provide specialized knowledge and workflows.
+
+## Structure
+
+```
+.kiro/skills/{skill-name}/
+  skill.md            # Main skill file (required)
+  references/         # Supporting documents (optional)
+    guide.md
+    examples.md
+```
+
+## skill.md Format
+
+```markdown
+---
+name: my-skill
+description: >-
+  When to activate this skill. Include trigger phrases
+  and use cases.
+---
+
+# Skill Title
+
+Content, instructions, and guidance...
+
+## References
+
+- `references/guide.md` - Detailed guide
+```
+
+## Front-Matter
+
+Required fields:
+- `name`: Skill identifier (kebab-case)
+- `description`: Activation description (when should Kiro use this skill)
+
+## Activation
+
+Skills activate automatically when:
+- User's message matches the description keywords
+- Context suggests the skill is relevant
+- User explicitly references the skill
+
+## Best Practices
+
+- Keep descriptions specific about when to activate
+- Use references for detailed content (keeps main file focused)
+- One skill per domain/topic
+- Include examples in the skill content
+- Reference external docs when available

package/dist/presets/devops/skills/kiro/references/specs-workflow.md

@@ -0,0 +1,62 @@
+# Specs Workflow
+
+## Overview
+
+Specs are a structured way of building and documenting features. A spec formalizes the design and implementation process through requirements, design, and implementation tasks.
+
+## Spec Types
+
+### Feature Spec
+- Requirements -> Design -> Tasks (requirements-first)
+- Design -> Requirements -> Tasks (design-first)
+
+### Bugfix Spec
+- Bug condition methodology
+- Exploration tests to confirm bug exists
+- Fix implementation with property-based testing
+
+## File Structure
+
+```
+.kiro/specs/{feature-name}/
+  requirements.md    # User stories and acceptance criteria
+  design.md          # Technical design document
+  tasks.md           # Implementation task list
+```
+
+## Workflow
+
+1. **Start a spec**: Tell Kiro you want to build a feature
+2. **Choose approach**: Requirements-first or Design-first
+3. **Iterate on documents**: Review and refine with Kiro
+4. **Execute tasks**: Kiro implements tasks sequentially
+5. **Validate**: Tests verify correctness
+
+## Requirements Document
+
+Contains:
+- User stories with acceptance criteria
+- Correctness properties (formal specifications)
+- Constraints and assumptions
+
+## Design Document
+
+Contains:
+- High-level architecture
+- Data models and schemas
+- API contracts
+- Component interactions
+
+## Tasks Document
+
+Contains:
+- Ordered implementation tasks
+- Sub-tasks with checkboxes
+- Dependencies between tasks
+
+## Property-Based Testing
+
+Specs encourage formal correctness properties:
+- Define what "correct" means for your feature
+- Encode properties as executable tests
+- Use property-based testing frameworks (fast-check, hypothesis)