kiro-kit 0.2.4 → 0.3.1

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);

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",

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/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",

package/dist/presets/frontend/powers.json

@@ -0,0 +1,34 @@
+{
+  "powers": [
+    {
+      "name": "Figma",
+      "url": "https://kiro.dev/powers/figma",
+      "description": "Design-to-code integration with Figma files",
+      "tier": "essential"
+    },
+    {
+      "name": "Netlify",
+      "url": "https://kiro.dev/powers/netlify",
+      "description": "Deploy React, Next.js, and modern web apps to global CDN",
+      "tier": "recommended"
+    },
+    {
+      "name": "Context7",
+      "url": "https://kiro.dev/powers/context7",
+      "description": "Up-to-date documentation lookup for libraries and frameworks",
+      "tier": "recommended"
+    },
+    {
+      "name": "Snyk",
+      "url": "https://kiro.dev/powers/snyk",
+      "description": "Security scanning and vulnerability detection for dependencies",
+      "tier": "optional"
+    },
+    {
+      "name": "ScoutQA",
+      "url": "https://kiro.dev/powers/scout-qa",
+      "description": "AI-powered exploratory testing for web applications",
+      "tier": "optional"
+    }
+  ]
+}

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);