kiro-kit 0.2.2 → 0.3.0

package/dist/presets/data-ai/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/data-ai/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/data-ai/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)

package/dist/presets/data-ai/skills/kiro/references/steering-files.md

@@ -0,0 +1,84 @@
+# Steering Files
+
+## Overview
+
+Steering files provide additional context and instructions to the AI agent. They live in `.kiro/steering/` and influence all interactions.
+
+## Inclusion Modes
+
+### Always Included (default)
+```markdown
+---
+inclusion: always
+description: Project coding standards
+---
+
+Your instructions here...
+```
+
+### Conditional (fileMatch)
+Only included when matching files are read into context:
+```markdown
+---
+inclusion: fileMatch
+fileMatchPattern: "*.test.ts"
+description: Testing conventions
+---
+
+Your testing instructions here...
+```
+
+### Manual
+Only included when user explicitly references via `#` in chat:
+```markdown
+---
+inclusion: manual
+description: Database migration guide
+---
+
+Your migration guide here...
+```
+
+## Front-Matter Schema
+
+Required fields:
+- `inclusion`: "always" | "fileMatch" | "manual"
+- `description`: Brief description of the steering file
+
+Optional fields:
+- `fileMatchPattern`: Glob pattern (required for fileMatch inclusion)
+
+## Best Practices
+
+- Keep steering files focused on one topic
+- Use "always" sparingly to avoid context bloat
+- Use "fileMatch" for language/framework-specific conventions
+- Use "manual" for reference material not needed every time
+- Include file references with `#[[file:relative/path]]` syntax
+
+## Examples
+
+### Code Standards
+```markdown
+---
+inclusion: always
+description: TypeScript coding standards
+---
+
+- Use strict mode, no `any` types
+- Prefer interfaces for props, types for unions
+- Use Zod for runtime validation
+```
+
+### API Conventions (conditional)
+```markdown
+---
+inclusion: fileMatch
+fileMatchPattern: "**/api/**/*.ts"
+description: API route conventions
+---
+
+- Use parameterized queries
+- Validate input with Zod
+- Return consistent error format
+```

package/dist/presets/data-ai/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/data-ai/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/dist/presets/devops/hooks/container-scan.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * Checks Dockerfile for security best practices: non-root user,
+ * no latest tag, and multi-stage build usage.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const cwd = process.cwd();
+const DOCKERFILE_NAMES = ['Dockerfile', 'dockerfile', 'Containerfile'];
+
+function findDockerfiles(dir) {
+  const results = [];
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && (DOCKERFILE_NAMES.includes(entry.name) || entry.name.startsWith('Dockerfile.'))) {
+        results.push(path.join(dir, entry.name));
+      } else if (entry.isDirectory() && !['node_modules', '.git', '.terraform'].includes(entry.name)) {
+        results.push(...findDockerfiles(path.join(dir, entry.name)));
+      }
+    }
+  } catch (e) { /* skip */ }
+  return results;
+}
+
+const dockerfiles = findDockerfiles(cwd);
+
+if (dockerfiles.length === 0) {
+  process.exit(0);
+}
+
+const issues = [];
+
+for (const df of dockerfiles) {
+  const content = fs.readFileSync(df, 'utf8');
+  const rel = path.relative(cwd, df);
+  const lines = content.split('\n');
+
+  // Check for latest tag
+  const fromLines = lines.filter((l) => /^\s*FROM\s+/i.test(l));
+  for (const line of fromLines) {
+    if (/:latest\b/.test(line) || (/^\s*FROM\s+\S+\s*/i.test(line) && !/:/.test(line) && !/\s+AS\s+/i.test(line.split(/\s+/).slice(2).join(' ')))) {
+      if (!/:/.test(line.split(/\s+/)[1] || '')) {
+        issues.push(`${rel}: FROM without pinned version tag`);
+      }
+    }
+    if (/:latest/.test(line)) {
+      issues.push(`${rel}: Uses :latest tag (pin a specific version)`);
+    }
+  }
+
+  // Check for non-root user
+  const hasUser = /^\s*USER\s+(?!root)/im.test(content);
+  if (!hasUser) {
+    issues.push(`${rel}: No non-root USER directive found`);
+  }
+
+  // Check for multi-stage build
+  if (fromLines.length < 2) {
+    issues.push(`${rel}: Single-stage build (consider multi-stage for smaller images)`);
+  }
+}
+
+if (issues.length > 0) {
+  process.stdout.write('[container-scan] Dockerfile security issues:\n');
+  issues.forEach((i) => process.stdout.write(`  - ${i}\n`));
+  process.exit(1);
+}
+
+process.stdout.write('[container-scan] All Dockerfiles pass security checks.\n');
+process.exit(0);

package/dist/presets/devops/hooks/cost-estimation.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Scans terraform files for expensive resource types (RDS, NAT Gateway, EKS)
+ * and flags them for cost review.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const EXPENSIVE_RESOURCES = [
+  { pattern: /resource\s+"aws_db_instance"/, label: 'RDS Instance', note: 'Consider Aurora Serverless for variable workloads' },
+  { pattern: /resource\s+"aws_nat_gateway"/, label: 'NAT Gateway', note: 'Costs ~$32/month per AZ plus data transfer' },
+  { pattern: /resource\s+"aws_eks_cluster"/, label: 'EKS Cluster', note: 'Costs $0.10/hour (~$73/month) per cluster' },
+  { pattern: /resource\s+"aws_elasticsearch_domain"/, label: 'Elasticsearch', note: 'Consider OpenSearch Serverless for variable usage' },
+  { pattern: /resource\s+"aws_redshift_cluster"/, label: 'Redshift Cluster', note: 'Consider Redshift Serverless for intermittent queries' },
+  { pattern: /resource\s+"aws_msk_cluster"/, label: 'MSK Cluster', note: 'Minimum 3 brokers required, consider MSK Serverless' },
+  { pattern: /resource\s+"aws_fsx_/, label: 'FSx File System', note: 'High baseline cost, verify storage requirements' },
+  { pattern: /resource\s+"google_container_cluster"/, label: 'GKE Cluster', note: 'Management fee applies per cluster' },
+  { pattern: /resource\s+"azurerm_kubernetes_cluster"/, label: 'AKS Cluster', note: 'Node pool costs can escalate quickly' },
+];
+
+const TF_EXTENSIONS = ['.tf', '.tf.json'];
+const cwd = process.cwd();
+
+function findTfFiles(dir, depth) {
+  const results = [];
+  if (depth > 3 || !fs.existsSync(dir)) return results;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory() && !['.terraform', 'node_modules', '.git'].includes(entry.name)) {
+        results.push(...findTfFiles(full, depth + 1));
+      } else if (entry.isFile() && TF_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
+        results.push(full);
+      }
+    }
+  } catch (e) { /* skip */ }
+  return results;
+}
+
+const tfFiles = findTfFiles(cwd, 0);
+
+if (tfFiles.length === 0) {
+  process.exit(0);
+}
+
+const findings = [];
+
+for (const file of tfFiles) {
+  const content = fs.readFileSync(file, 'utf8');
+  const rel = path.relative(cwd, file);
+
+  for (const { pattern, label, note } of EXPENSIVE_RESOURCES) {
+    if (pattern.test(content)) {
+      findings.push({ file: rel, label, note });
+    }
+  }
+}
+
+if (findings.length > 0) {
+  process.stdout.write('[cost-estimation] Expensive resources detected for cost review:\n');
+  findings.forEach((f) => {
+    process.stdout.write(`  - ${f.file}: ${f.label}\n    ${f.note}\n`);
+  });
+  process.exit(1);
+}
+
+process.exit(0);

package/dist/presets/devops/hooks/terraform-plan-review.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * Parses terraform plan output for destructive changes (destroy, replace)
+ * and highlights them for review.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const cwd = process.cwd();
+const PLAN_FILES = ['tfplan.txt', 'plan.txt', 'terraform.plan.txt'];
+
+let planContent = '';
+
+// Try to read a saved plan output file
+for (const pf of PLAN_FILES) {
+  const full = path.resolve(cwd, pf);
+  if (fs.existsSync(full)) {
+    planContent = fs.readFileSync(full, 'utf8');
+    break;
+  }
+}
+
+// If no plan file, try to run terraform show on binary plan
+if (!planContent) {
+  const binaryPlan = path.resolve(cwd, 'tfplan');
+  if (fs.existsSync(binaryPlan)) {
+    try {
+      planContent = execSync('terraform show -no-color tfplan', {
+        cwd,
+        encoding: 'utf8',
+        timeout: 30000,
+      });
+    } catch (e) { /* skip */ }
+  }
+}
+
+if (!planContent) {
+  process.exit(0);
+}
+
+const DESTRUCTIVE_PATTERNS = [
+  { pattern: /will be destroyed/g, label: 'DESTROY' },
+  { pattern: /must be replaced/g, label: 'REPLACE' },
+  { pattern: /forces replacement/g, label: 'FORCE REPLACE' },
+];
+
+const findings = [];
+
+for (const { pattern, label } of DESTRUCTIVE_PATTERNS) {
+  const matches = planContent.match(pattern);
+  if (matches) {
+    findings.push({ label, count: matches.length });
+  }
+}
+
+if (findings.length > 0) {
+  process.stdout.write('[terraform-plan-review] Destructive changes detected:\n');
+  findings.forEach((f) => {
+    process.stdout.write(`  - ${f.label}: ${f.count} resource(s)\n`);
+  });
+  process.stdout.write('  Review plan carefully before applying.\n');
+  process.exit(1);
+}
+
+process.exit(0);