kiro-kit 0.2.2 → 0.3.0

package/dist/presets/frontend/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/fullstack/hooks/api-client-gen.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Checks if API client types are in sync with route handlers.
+ * Warns if route files changed more recently than client type definitions.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ROUTE_DIRS = ['src/app/api', 'src/routes'];
+const CLIENT_DIRS = ['src/lib/api', 'src/client', 'src/api', 'src/services'];
+
+const cwd = process.cwd();
+
+function getLatestMtime(dir) {
+  let latest = 0;
+  if (!fs.existsSync(dir)) return 0;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const sub = getLatestMtime(full);
+        if (sub > latest) latest = sub;
+      } else if (/\.(ts|js)$/.test(entry.name)) {
+        const stat = fs.statSync(full);
+        if (stat.mtimeMs > latest) latest = stat.mtimeMs;
+      }
+    }
+  } catch (e) { /* skip */ }
+  return latest;
+}
+
+let routeMtime = 0;
+for (const dir of ROUTE_DIRS) {
+  const t = getLatestMtime(path.resolve(cwd, dir));
+  if (t > routeMtime) routeMtime = t;
+}
+
+if (routeMtime === 0) {
+  process.exit(0);
+}
+
+let clientMtime = 0;
+let clientDir = null;
+for (const dir of CLIENT_DIRS) {
+  const full = path.resolve(cwd, dir);
+  if (fs.existsSync(full)) {
+    clientDir = dir;
+    clientMtime = getLatestMtime(full);
+    break;
+  }
+}
+
+if (!clientDir) {
+  process.exit(0);
+}
+
+if (routeMtime > clientMtime) {
+  const diff = Math.round((routeMtime - clientMtime) / 1000 / 60);
+  process.stdout.write(
+    `[api-client-gen] API routes changed ${diff}min after client types.\n` +
+    `  Route handlers may be out of sync with ${clientDir}/.\n` +
+    '  Consider regenerating API client types.\n'
+  );
+  process.exit(1);
+}
+
+process.exit(0);

package/dist/presets/fullstack/hooks/deployment-readiness.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * Pre-deployment checklist: checks for .env.example completeness,
+ * build success indicators, and no TODO/FIXME in production code.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const cwd = process.cwd();
+const issues = [];
+
+// Check .env.example exists
+const envExample = path.resolve(cwd, '.env.example');
+const envLocal = path.resolve(cwd, '.env.local');
+if (!fs.existsSync(envExample)) {
+  issues.push('Missing .env.example file');
+} else if (fs.existsSync(envLocal)) {
+  // Check all keys in .env.local are documented in .env.example
+  const exampleKeys = fs.readFileSync(envExample, 'utf8')
+    .split('\n')
+    .filter((l) => l.match(/^[A-Z_]+=/) )
+    .map((l) => l.split('=')[0]);
+  const localKeys = fs.readFileSync(envLocal, 'utf8')
+    .split('\n')
+    .filter((l) => l.match(/^[A-Z_]+=/))
+    .map((l) => l.split('=')[0]);
+  const undocumented = localKeys.filter((k) => !exampleKeys.includes(k));
+  if (undocumented.length > 0) {
+    issues.push(`${undocumented.length} env var(s) in .env.local not in .env.example`);
+  }
+}
+
+// Check for TODO/FIXME in src/
+function scanTodos(dir, depth) {
+  let count = 0;
+  if (depth > 5 || !fs.existsSync(dir)) return 0;
+  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' && entry.name !== '.next') {
+        count += scanTodos(full, depth + 1);
+      } else if (entry.isFile() && /\.(ts|tsx|js|jsx)$/.test(entry.name)) {
+        const content = fs.readFileSync(full, 'utf8');
+        const matches = content.match(/\b(TODO|FIXME)\b/g);
+        if (matches) count += matches.length;
+      }
+    }
+  } catch (e) { /* skip */ }
+  return count;
+}
+
+const todoCount = scanTodos(path.resolve(cwd, 'src'), 0);
+if (todoCount > 0) {
+  issues.push(`${todoCount} TODO/FIXME comment(s) found in src/`);
+}
+
+// Check build output exists
+const buildDirs = ['.next', 'dist', 'build'];
+const hasBuild = buildDirs.some((d) => fs.existsSync(path.resolve(cwd, d)));
+if (!hasBuild) {
+  issues.push('No build output found. Run build before deploying.');
+}
+
+if (issues.length > 0) {
+  process.stdout.write('[deployment-readiness] Pre-deployment issues:\n');
+  issues.forEach((i) => process.stdout.write(`  - ${i}\n`));
+  process.exit(1);
+}
+
+process.stdout.write('[deployment-readiness] All checks passed.\n');
+process.exit(0);

package/dist/presets/fullstack/hooks/type-sync-check.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Verifies shared types in src/types/ are imported by both client and server code.
+ * Checks for orphan type definitions not used anywhere.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const TYPES_DIR = path.resolve(process.cwd(), 'src/types');
+const SRC_DIR = path.resolve(process.cwd(), 'src');
+
+if (!fs.existsSync(TYPES_DIR)) {
+  process.exit(0);
+}
+
+function getTypeFiles(dir) {
+  const results = [];
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && /\.(ts|tsx)$/.test(entry.name) && entry.name !== 'index.ts') {
+        results.push(entry.name);
+      }
+    }
+  } catch (e) { /* skip */ }
+  return results;
+}
+
+function searchImports(dir, typeFile, exclude) {
+  let found = false;
+  if (!fs.existsSync(dir)) return false;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (found) break;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== 'node_modules' && full !== exclude) {
+        found = searchImports(full, typeFile, exclude);
+      } else if (entry.isFile() && /\.(ts|tsx|js|jsx)$/.test(entry.name)) {
+        const content = fs.readFileSync(full, 'utf8');
+        const baseName = path.basename(typeFile, path.extname(typeFile));
+        if (content.includes(`/types/${baseName}`) || content.includes(`/types'`) || content.includes(`/types"`)) {
+          found = true;
+        }
+      }
+    }
+  } catch (e) { /* skip */ }
+  return found;
+}
+
+const typeFiles = getTypeFiles(TYPES_DIR);
+const orphans = [];
+
+for (const tf of typeFiles) {
+  const baseName = path.basename(tf, path.extname(tf));
+  const isUsed = searchImports(SRC_DIR, tf, TYPES_DIR);
+  if (!isUsed) {
+    orphans.push(tf);
+  }
+}
+
+if (orphans.length > 0) {
+  process.stdout.write(`[type-sync-check] ${orphans.length} type file(s) not imported anywhere:\n`);
+  orphans.forEach((o) => process.stdout.write(`  - src/types/${o}\n`));
+  process.exit(1);
+}
+
+process.exit(0);

package/dist/presets/fullstack/manifest.json

@@ -563,6 +563,29 @@
       "type": "hook",
       "executable": true
     },
+    {
+      "source": "hooks/type-sync-check.js",
+      "target": ".kiro/hooks/type-sync-check.js",
+      "type": "hook",
+      "executable": true
+    },
+    {
+      "source": "hooks/api-client-gen.js",
+      "target": ".kiro/hooks/api-client-gen.js",
+      "type": "hook",
+      "executable": true
+    },
+    {
+      "source": "hooks/deployment-readiness.js",
+      "target": ".kiro/hooks/deployment-readiness.js",
+      "type": "hook",
+      "executable": true
+    },
+    {
+      "source": "powers.json",
+      "target": ".kiro/powers.json",
+      "type": "powers"
+    },
     {
       "source": "metadata.json",
       "target": ".kiro/metadata.json",
@@ -939,73 +962,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"
     },
     {

package/dist/presets/fullstack/powers.json

@@ -0,0 +1,46 @@
+{
+  "powers": [
+    {
+      "name": "Supabase",
+      "url": "https://kiro.dev/powers/supabase",
+      "description": "Backend-as-a-service with Postgres, auth, and real-time subscriptions",
+      "tier": "essential"
+    },
+    {
+      "name": "Figma",
+      "url": "https://kiro.dev/powers/figma",
+      "description": "Design-to-code integration with Figma files",
+      "tier": "recommended"
+    },
+    {
+      "name": "Netlify",
+      "url": "https://kiro.dev/powers/netlify",
+      "description": "Deploy React, Next.js, and modern web apps to global CDN",
+      "tier": "recommended"
+    },
+    {
+      "name": "Stripe",
+      "url": "https://kiro.dev/powers/stripe",
+      "description": "Payment processing, subscriptions, and billing integration",
+      "tier": "recommended"
+    },
+    {
+      "name": "Context7",
+      "url": "https://kiro.dev/powers/context7",
+      "description": "Up-to-date documentation lookup for libraries and frameworks",
+      "tier": "recommended"
+    },
+    {
+      "name": "Firebase",
+      "url": "https://kiro.dev/powers/firebase",
+      "description": "Full-stack application development with Google Cloud services",
+      "tier": "optional"
+    },
+    {
+      "name": "LaunchDarkly",
+      "url": "https://kiro.dev/powers/launch-darkly",
+      "description": "Feature flag management and progressive delivery",
+      "tier": "optional"
+    }
+  ]
+}

package/dist/presets/fullstack/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/fullstack/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