kiro-kit 0.2.2 → 0.3.0

package/dist/presets/devops/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/devops/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/devops/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/frontend/commands/test.md

@@ -9,7 +9,7 @@ PATTERN: $1 (default: all tests)
 
 ## Workflow
 1. Run Vitest with coverage: `npx vitest run --coverage`
-2. If pattern provided, filter tests: `npx vitest run $1`
+2. If pattern provided, filter tests: `npx vitest run --coverage $1`
 3. Report test results summary (passed, failed, skipped)
 4. Report coverage metrics (lines, branches, functions)
 5. Highlight any failing tests with error details

package/dist/presets/frontend/hooks/accessibility-check.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * Checks for common accessibility issues in .tsx/.jsx files.
+ * Scans for missing alt attributes, missing aria-labels, and missing lang attribute.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SRC_DIR = path.resolve(process.cwd(), 'src');
+const EXTENSIONS = ['.tsx', '.jsx'];
+
+if (!fs.existsSync(SRC_DIR)) {
+  process.exit(0);
+}
+
+function getFiles(dir) {
+  const results = [];
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== 'node_modules') {
+        results.push(...getFiles(full));
+      } else if (EXTENSIONS.includes(path.extname(entry.name).toLowerCase())) {
+        results.push(full);
+      }
+    }
+  } catch (e) { /* skip unreadable dirs */ }
+  return results;
+}
+
+const issues = [];
+const files = getFiles(SRC_DIR);
+
+for (const file of files) {
+  const content = fs.readFileSync(file, 'utf8');
+  const rel = path.relative(process.cwd(), file);
+
+  // Check for <img> without alt
+  const imgNoAlt = content.match(/<img(?![^>]*\balt\b)[^>]*>/g);
+  if (imgNoAlt) {
+    issues.push(`${rel}: ${imgNoAlt.length} <img> tag(s) missing alt attribute`);
+  }
+
+  // Check for interactive elements without aria-label
+  const buttons = content.match(/<button(?![^>]*\baria-label\b)(?![^>]*>[^<]+<\/button>)[^>]*>\s*<\//g);
+  if (buttons) {
+    issues.push(`${rel}: ${buttons.length} empty <button> without aria-label`);
+  }
+}
+
+// Check for lang attribute in root layout/html
+const layoutFiles = ['src/app/layout.tsx', 'src/app/layout.jsx', 'index.html'];
+let hasLang = false;
+for (const lf of layoutFiles) {
+  const full = path.resolve(process.cwd(), lf);
+  if (fs.existsSync(full)) {
+    const content = fs.readFileSync(full, 'utf8');
+    if (/<html[^>]*\blang\b/.test(content)) {
+      hasLang = true;
+    }
+    break;
+  }
+}
+if (!hasLang && files.length > 0) {
+  issues.push('Root layout/html: missing lang attribute on <html> element');
+}
+
+if (issues.length > 0) {
+  process.stdout.write('[accessibility-check] Issues found:\n');
+  issues.forEach((i) => process.stdout.write(`  - ${i}\n`));
+  process.exit(1);
+}
+
+process.exit(0);

package/dist/presets/frontend/hooks/bundle-size-guard.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * Checks if bundle analysis data exists and warns if total size exceeds threshold.
+ * Looks for .next/analyze/ or build stats files.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const THRESHOLD_KB = 500;
+const ANALYZE_PATHS = [
+  '.next/analyze/client.html',
+  '.next/analyze/nodejs.html',
+  'build/bundle-stats.json',
+  'dist/stats.json',
+  'stats.json',
+];
+
+const cwd = process.cwd();
+let found = false;
+
+for (const rel of ANALYZE_PATHS) {
+  const full = path.resolve(cwd, rel);
+  if (fs.existsSync(full)) {
+    found = true;
+    break;
+  }
+}
+
+if (!found) {
+  // Check .next build manifest for size info
+  const buildManifest = path.resolve(cwd, '.next/build-manifest.json');
+  if (!fs.existsSync(buildManifest)) {
+    process.exit(0);
+  }
+}
+
+// Check total size of JS output
+const outputDirs = ['.next/static/chunks', 'dist', 'build/static/js'];
+let totalBytes = 0;
+
+for (const dir of outputDirs) {
+  const full = path.resolve(cwd, dir);
+  if (!fs.existsSync(full)) continue;
+  try {
+    const files = fs.readdirSync(full);
+    for (const file of files) {
+      if (file.endsWith('.js')) {
+        const stat = fs.statSync(path.join(full, file));
+        totalBytes += stat.size;
+      }
+    }
+  } catch (e) { /* skip */ }
+}
+
+if (totalBytes === 0) {
+  process.exit(0);
+}
+
+const totalKB = Math.round(totalBytes / 1024);
+
+if (totalKB > THRESHOLD_KB) {
+  process.stdout.write(
+    `[bundle-size-guard] Warning: Total JS bundle size is ${totalKB}KB (threshold: ${THRESHOLD_KB}KB).\n` +
+    '  Consider code splitting, lazy loading, or removing unused dependencies.\n'
+  );
+  process.exit(1);
+}
+
+process.stdout.write(`[bundle-size-guard] Bundle size OK: ${totalKB}KB (threshold: ${THRESHOLD_KB}KB).\n`);
+process.exit(0);

package/dist/presets/frontend/hooks/component-test-reminder.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * Checks if components in src/components/ have corresponding .test.tsx files.
+ * Warns about components missing test coverage.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const COMPONENTS_DIR = path.resolve(process.cwd(), 'src/components');
+const COMPONENT_EXTENSIONS = ['.tsx', '.jsx'];
+const IGNORE_DIRS = ['ui', 'node_modules', '__tests__'];
+
+if (!fs.existsSync(COMPONENTS_DIR)) {
+  process.exit(0);
+}
+
+function getComponentFiles(dir) {
+  const results = [];
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory() && !IGNORE_DIRS.includes(entry.name)) {
+        results.push(...getComponentFiles(full));
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+        const base = path.basename(entry.name, ext);
+        if (COMPONENT_EXTENSIONS.includes(ext) && !base.endsWith('.test') && !base.endsWith('.spec')) {
+          // Only count PascalCase files as components
+          if (/^[A-Z]/.test(base)) {
+            results.push(full);
+          }
+        }
+      }
+    }
+  } catch (e) { /* skip */ }
+  return results;
+}
+
+const components = getComponentFiles(COMPONENTS_DIR);
+const missing = [];
+
+for (const comp of components) {
+  const dir = path.dirname(comp);
+  const ext = path.extname(comp);
+  const base = path.basename(comp, ext);
+
+  const testPatterns = [
+    path.join(dir, `${base}.test.tsx`),
+    path.join(dir, `${base}.test.jsx`),
+    path.join(dir, `${base}.spec.tsx`),
+    path.join(dir, '__tests__', `${base}.test.tsx`),
+  ];
+
+  const hasTest = testPatterns.some((t) => fs.existsSync(t));
+  if (!hasTest) {
+    missing.push(path.relative(process.cwd(), comp));
+  }
+}
+
+if (missing.length > 0) {
+  process.stdout.write(`[component-test-reminder] ${missing.length} component(s) without tests:\n`);
+  missing.slice(0, 10).forEach((m) => process.stdout.write(`  - ${m}\n`));
+  if (missing.length > 10) {
+    process.stdout.write(`  ... and ${missing.length - 10} more\n`);
+  }
+  process.exit(1);
+}
+
+process.exit(0);

package/dist/presets/frontend/manifest.json

@@ -553,6 +553,29 @@
       "type": "hook",
       "executable": true
     },
+    {
+      "source": "hooks/accessibility-check.js",
+      "target": ".kiro/hooks/accessibility-check.js",
+      "type": "hook",
+      "executable": true
+    },
+    {
+      "source": "hooks/bundle-size-guard.js",
+      "target": ".kiro/hooks/bundle-size-guard.js",
+      "type": "hook",
+      "executable": true
+    },
+    {
+      "source": "hooks/component-test-reminder.js",
+      "target": ".kiro/hooks/component-test-reminder.js",
+      "type": "hook",
+      "executable": true
+    },
+    {
+      "source": "powers.json",
+      "target": ".kiro/powers.json",
+      "type": "powers"
+    },
     {
       "source": "metadata.json",
       "target": ".kiro/metadata.json",
@@ -819,73 +842,63 @@
       "type": "other"
     },
     {
-      "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"
     },
     {