kiro-agent-team 1.0.0

package/.kiro/prompts/system-review.md

@@ -0,0 +1,189 @@
+---
+description: Analyze implementation against plan for process improvements
+---
+
+# System Review
+
+Perform a meta-level analysis of how well the implementation followed the plan and identify process improvements.
+
+## Purpose
+
+**System review is NOT code review.** You're not looking for bugs in the code - you're looking for bugs in the process.
+
+**Your job:**
+
+- Analyze plan adherence and divergence patterns
+- Identify which divergences were justified vs problematic
+- Surface process improvements that prevent future issues
+- Suggest updates to steering documents, plan templates, commands
+
+**Philosophy:**
+
+- Good divergence reveals plan limitations → improve planning
+- Bad divergence reveals unclear requirements → improve communication
+- Repeated issues reveal missing automation → create commands
+
+## Context & Inputs
+
+You will analyze four key artifacts:
+
+**Plan Command:**
+Read this to understand the planning process and what instructions guide plan creation.
+.kiro/prompts/plan-feature.md
+
+**Generated Plan:**
+Read this to understand what the agent was SUPPOSED to do.
+Plan file: $1
+
+**Execute Command:**
+Read this to understand the execution process and what instructions guide implementation.
+.kiro/prompts/execute.md
+
+**Execution Report:**
+Read this to understand what the agent ACTUALLY did and why.
+Execution report: $2
+
+## Analysis Workflow
+
+### Step 1: Understand the Planned Approach
+
+Read the generated plan ($1) and extract:
+
+- What features were planned?
+- What architecture was specified?
+- What validation steps were defined?
+- What patterns were referenced?
+
+### Step 2: Understand the Actual Implementation
+
+Read the execution report ($2) and extract:
+
+- What was implemented?
+- What diverged from the plan?
+- What challenges were encountered?
+- What was skipped and why?
+
+### Step 3: Classify Each Divergence
+
+For each divergence identified in the execution report, classify as:
+
+**Good Divergence ✅** (Justified):
+
+- Plan assumed something that didn't exist in the codebase
+- Better pattern discovered during implementation
+- Performance optimization needed
+- Security issue discovered that required different approach
+
+**Bad Divergence ❌** (Problematic):
+
+- Ignored explicit constraints in plan
+- Created new architecture instead of following existing patterns
+- Took shortcuts that introduce tech debt
+- Misunderstood requirements
+
+### Step 4: Trace Root Causes
+
+For each problematic divergence, identify the root cause:
+
+- Was the plan unclear, where, why?
+- Was context missing, where, why?
+- Was validation missing, where, why?
+- Was manual step repeated, where, why?
+
+### Step 5: Generate Process Improvements
+
+Based on patterns across divergences, suggest:
+
+- **Steering document updates:** Universal patterns or anti-patterns to document
+- **Plan command updates:** Instructions that need clarification or missing steps
+- **New commands:** Manual processes that should be automated
+- **Validation additions:** Checks that would catch issues earlier
+
+## Output Format
+
+Save your analysis to: `.kiro/system-reviews/[feature-name]-review.md`
+
+### Report Structure:
+
+#### Meta Information
+
+- Plan reviewed: [path to $1]
+- Execution report: [path to $2]
+- Date: [current date]
+
+#### Overall Alignment Score: \_\_/10
+
+Scoring guide:
+
+- 10: Perfect adherence, all divergences justified
+- 7-9: Minor justified divergences
+- 4-6: Mix of justified and problematic divergences
+- 1-3: Major problematic divergences
+
+#### Divergence Analysis
+
+For each divergence from the execution report:
+
+```yaml
+divergence: [what changed]
+planned: [what plan specified]
+actual: [what was implemented]
+reason: [agent's stated reason from report]
+classification: good ✅ | bad ❌
+justified: yes/no
+root_cause: [unclear plan | missing context | etc]
+```
+
+#### Pattern Compliance
+
+Assess adherence to documented patterns:
+
+- [ ] Followed codebase architecture
+- [ ] Used documented patterns from steering documents
+- [ ] Applied testing patterns correctly
+- [ ] Met validation requirements
+
+#### System Improvement Actions
+
+Based on analysis, recommend specific actions:
+
+**Update Steering Documents:**
+
+- [ ] Document [pattern X] discovered during implementation
+- [ ] Add anti-pattern warning for [Y]
+- [ ] Clarify [technology constraint Z]
+
+**Update Plan Command ($1):**
+
+- [ ] Add instruction for [missing step]
+- [ ] Clarify [ambiguous instruction]
+- [ ] Add validation requirement for [X]
+
+**Create New Command:**
+
+- [ ] `/[command-name]` for [manual process repeated 3+ times]
+
+**Update Execute Command ($3):**
+
+- [ ] Add [validation step] to execution checklist
+
+#### Key Learnings
+
+**What worked well:**
+
+- [specific things that went smoothly]
+
+**What needs improvement:**
+
+- [specific process gaps identified]
+
+**For next implementation:**
+
+- [concrete improvements to try]
+
+## Important
+
+- **Be specific:** Don't say "plan was unclear" - say "plan didn't specify which auth pattern to use"
+- **Focus on patterns:** One-off issues aren't actionable. Look for repeated problems.
+- **Action-oriented:** Every finding should have a concrete asset update suggestion
+- **Suggest improvements:** Don't just analyze - actually suggest specific text to add to steering documents or commands

package/README.md

@@ -0,0 +1,32 @@
+# kiro-agent-team
+
+A comprehensive AI agentic team for Kiro IDE and Kiro-CLI
+
+## Installation
+
+Install the `.kiro` directory into your project using:
+
+```bash
+npx kiro-agent-team install
+```
+
+This command will:
+- Create a `.kiro` directory in your current project
+- Copy all configuration files and templates from the package
+- Preserve any existing files (with warnings)
+
+## Usage
+
+After installation, the `.kiro` directory will be available in your project root. You can customize the configuration files as needed for your project.
+
+## Development
+
+To publish this package to npm:
+
+1. Update the version in `package.json`
+2. Run `npm publish` (make sure you're logged in to npm)
+
+## CLI Commands
+
+- `npx kiro-agent-team install` - Install .kiro directory to your project
+- `npx kiro-agent-team --help` - Show help information

package/bin/cli.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const command = process.argv[2];
+
+if (command === 'install') {
+  installKiroFiles();
+} else if (command === '--help' || command === '-h' || !command) {
+  showHelp();
+} else {
+  console.error(`Unknown command: ${command}`);
+  console.error('Run "npx kiro-agent-team --help" for usage information.');
+  process.exit(1);
+}
+
+function installKiroFiles() {
+  try {
+    // Get the directory where this package is installed
+    const packagePath = path.dirname(require.resolve('../package.json'));
+    const sourceDir = path.join(packagePath, '.kiro');
+    const targetDir = path.join(process.cwd(), '.kiro');
+
+    // Check if source directory exists
+    if (!fs.existsSync(sourceDir)) {
+      console.error('Error: .kiro directory not found in package.');
+      process.exit(1);
+    }
+
+    // Check if target directory already exists
+    if (fs.existsSync(targetDir)) {
+      console.warn('Warning: .kiro directory already exists in your project.');
+      console.warn('This will merge/overwrite existing files.');
+      
+      // Ask for confirmation (in a non-interactive way, we'll proceed)
+      // In a real scenario, you might want to use a library like readline or inquirer
+    }
+
+    // Create target directory if it doesn't exist
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+
+    // Copy all files from source to target
+    copyDirectory(sourceDir, targetDir);
+
+    console.log('✓ Successfully installed .kiro directory to your project!');
+    console.log(`  Location: ${targetDir}`);
+  } catch (error) {
+    console.error('Error installing .kiro files:', error.message);
+    process.exit(1);
+  }
+}
+
+function copyDirectory(source, target) {
+  // Create target directory if it doesn't exist
+  if (!fs.existsSync(target)) {
+    fs.mkdirSync(target, { recursive: true });
+  }
+
+  // Read all items in source directory
+  const items = fs.readdirSync(source);
+
+  for (const item of items) {
+    const sourcePath = path.join(source, item);
+    const targetPath = path.join(target, item);
+    const stat = fs.statSync(sourcePath);
+
+    if (stat.isDirectory()) {
+      // Recursively copy subdirectories
+      copyDirectory(sourcePath, targetPath);
+    } else {
+      // Copy file
+      fs.copyFileSync(sourcePath, targetPath);
+      console.log(`  ✓ Copied: ${item}`);
+    }
+  }
+}
+
+function showHelp() {
+  console.log(`
+kiro-agent-team CLI
+
+Usage:
+  npx kiro-agent-team <command>
+
+Commands:
+  install    Install .kiro directory to your project
+
+Examples:
+  npx kiro-agent-team install
+
+For more information, visit: https://github.com/your-org/kiro-agent-team
+  `);
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "kiro-agent-team",
+  "version": "1.0.0",
+  "description": "A comprehensive AI agentic team for Kiro IDE and Kiro-CLI",
+  "main": "index.js",
+  "bin": {
+    "kiro-agent-team": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "kiro",
+    "ai",
+    "agent",
+    "ide",
+    "cli"
+  ],
+  "author": "Sean Wright",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/seanrobertwright/kiro-agent-team.git"
+  },
+  "files": [
+    "bin",
+    ".kiro",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}