kiro-kit 0.1.3 → 0.2.0

package/dist/presets/frontend/skills/sequential-thinking/README.md

@@ -0,0 +1,183 @@
+# Sequential Thinking Agent Skill
+
+Structured, reflective problem-solving methodology converted from the sequential-thinking MCP server into a native Agent Skill.
+
+## Overview
+
+This skill teaches Claude to apply systematic sequential thinking methodology for complex problem-solving, without relying on external MCP tools. It enables:
+- Breaking down complex problems into manageable thought sequences
+- Dynamic adjustment of thought count as understanding evolves
+- Revision of previous thoughts when new insights emerge
+- Branching into alternative reasoning paths
+- Hypothesis generation and verification
+
+## Skill Structure
+
+```
+sequential-thinking/
+├── SKILL.md (105 lines)
+│   Core methodology, when to apply, scripts usage
+│
+├── package.json
+│   Test dependencies (jest)
+│
+├── .env.example
+│   Configuration options
+│
+├── scripts/
+│   ├── process-thought.js (executable)
+│   │   Validate and track thoughts deterministically
+│   │
+│   └── format-thought.js (executable)
+│       Format thoughts for display (box/simple/markdown)
+│
+├── tests/
+│   ├── process-thought.test.js
+│   │   Validation, tracking, history tests
+│   │
+│   └── format-thought.test.js
+│       Formatting tests (all formats)
+│
+└── references/
+    ├── core-patterns.md (95 lines)
+    │   Essential revision & branching patterns
+    │
+    ├── examples-api.md (88 lines)
+    │   API design example walkthrough
+    │
+    ├── examples-debug.md (90 lines)
+    │   Performance debugging example
+    │
+    ├── examples-architecture.md (94 lines)
+    │   Architecture decision example
+    │
+    ├── advanced-techniques.md (76 lines)
+    │   Spiral refinement, hypothesis testing, convergence
+    │
+    └── advanced-strategies.md (79 lines)
+        Uncertainty management, revision cascades, meta-thinking
+```
+
+**Documentation**: 627 lines across 7 files (all under 100 lines)
+**Scripts**: 2 executable Node.js scripts with tests
+
+## Key Features
+
+### Progressive Disclosure Design
+Each file focuses on specific aspects, loaded only when needed:
+- **SKILL.md**: Quick reference with core methodology
+- **core-patterns.md**: Common patterns for everyday use
+- **examples-*.md**: Real-world walkthroughs for learning
+- **advanced-*.md**: Sophisticated techniques for complex scenarios
+
+### Token Efficiency
+- Concise explanations sacrifice grammar for brevity
+- Examples demonstrate patterns without verbose explanation
+- Cross-references between files avoid duplication
+
+### Methodology Conversion
+Extracted from MCP server's approach and converted to instructions:
+- MCP tool provided **interface** for sequential thinking
+- Agent skill provides **methodology** to think sequentially
+- No dependency on external tools—pure instructional approach
+
+## Usage Modes
+
+**Explicit Mode**: Use visible thought markers
+```
+Thought 1/5: [Analysis]
+Thought 2/5: [Further analysis]
+```
+
+**Implicit Mode**: Apply methodology internally without cluttering output
+
+## When Claude Should Use This Skill
+
+Automatically activated for:
+- Complex problem decomposition
+- Adaptive planning with potential revisions
+- Debugging and root cause analysis
+- Architecture and design decisions
+- Problems with unclear or emerging scope
+- Multi-step solutions requiring context
+
+## Scripts Usage
+
+### Process Thought (Validation & Tracking)
+
+```bash
+# Process a thought
+node scripts/process-thought.js --thought "Initial analysis" --number 1 --total 5 --next true
+
+# Process with revision
+node scripts/process-thought.js --thought "Corrected analysis" --number 2 --total 5 --next true --revision 1
+
+# Process with branching
+node scripts/process-thought.js --thought "Branch A" --number 2 --total 5 --next true --branch 1 --branchId "branch-a"
+
+# View history
+node scripts/process-thought.js --history
+
+# Reset history
+node scripts/process-thought.js --reset
+```
+
+### Format Thought (Display)
+
+```bash
+# Box format (default)
+node scripts/format-thought.js --thought "Analysis" --number 1 --total 5
+
+# Simple text format
+node scripts/format-thought.js --thought "Analysis" --number 1 --total 5 --format simple
+
+# Markdown format
+node scripts/format-thought.js --thought "Analysis" --number 1 --total 5 --format markdown
+
+# With revision
+node scripts/format-thought.js --thought "Revised" --number 2 --total 5 --revision 1
+
+# With branch
+node scripts/format-thought.js --thought "Branch" --number 2 --total 5 --branch 1 --branchId "a"
+```
+
+### Running Tests
+
+```bash
+# Install dependencies (first time only)
+npm install
+
+# Run all tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run with coverage
+npm run test:coverage
+```
+
+## When to Use Scripts
+
+**Use scripts when**:
+- Need deterministic validation of thought structure
+- Want persistent thought history tracking
+- Require formatted output for documentation
+- Building tools that integrate with sequential thinking
+
+**Don't use scripts when**:
+- Applying methodology directly in responses
+- Want lightweight, inline thinking
+- No need for validation or tracking
+
+Scripts are **optional tooling** - the methodology can be applied without them.
+
+## Source
+
+Converted from: https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking
+
+Original MCP server by Anthropic (MIT License).
+Skill conversion:
+- Extracts methodology as instructions
+- Adds executable scripts for deterministic validation
+- Makes tool-independent while preserving functionality

package/dist/presets/frontend/skills/sequential-thinking/SKILL.md

@@ -1,33 +1,99 @@
----
-name: sequential-thinking
-description: Apply structured, reflective problem-solving for complex tasks requiring multi-step analysis and revision. Use for complex decomposition or when you need to think step by step.
----
-
-# Sequential Thinking
-
-Activate this skill for complex problems requiring structured, step-by-step reasoning.
-
-## When to Use
-
-- Complex problem decomposition
-- Multi-step analysis requiring course correction
-- Problems with unclear scope or requirements
-- Hypothesis-driven investigation
-- Architecture decisions with many trade-offs
-
-## Process
-
-1. State the problem clearly in one sentence
-2. Identify what you know and what you need to find out
-3. Break into sequential steps, each building on the previous
-4. At each step, validate assumptions before proceeding
-5. If a step reveals new information, revise earlier conclusions
-6. Summarize findings and recommended action
-
-## Rules
-
-- Each step must be independently verifiable
-- Revise earlier steps when new evidence contradicts them
-- State confidence level at each step
-- Identify decision points and their trade-offs
-- Keep the chain of reasoning visible and traceable
+---
+name: sequential-thinking
+description: >-
+  Apply structured, reflective problem-solving for complex tasks requiring
+  multi-step analysis, revision capability, and hypothesis verification. Use for
+  complex problem decomposition, adaptive planning, analysis needing course
+  correction, problems with unclear scope, multi-step solutions, and
+  hypothesis-driven work.
+version: 1.0.0
+license: MIT
+---
+
+# Sequential Thinking
+
+Structured problem-solving via manageable, reflective thought sequences with dynamic adjustment.
+
+## When to Apply
+
+- Complex problem decomposition
+- Adaptive planning with revision capability
+- Analysis needing course correction
+- Problems with unclear/emerging scope
+- Multi-step solutions requiring context maintenance
+- Hypothesis-driven investigation/debugging
+
+## Core Process
+
+### 1. Start with Loose Estimate
+```
+Thought 1/5: [Initial analysis]
+```
+Adjust dynamically as understanding evolves.
+
+### 2. Structure Each Thought
+- Build on previous context explicitly
+- Address one aspect per thought
+- State assumptions, uncertainties, realizations
+- Signal what next thought should address
+
+### 3. Apply Dynamic Adjustment
+- **Expand**: More complexity discovered → increase total
+- **Contract**: Simpler than expected → decrease total
+- **Revise**: New insight invalidates previous → mark revision
+- **Branch**: Multiple approaches → explore alternatives
+
+### 4. Use Revision When Needed
+```
+Thought 5/8 [REVISION of Thought 2]: [Corrected understanding]
+- Original: [What was stated]
+- Why revised: [New insight]
+- Impact: [What changes]
+```
+
+### 5. Branch for Alternatives
+```
+Thought 4/7 [BRANCH A from Thought 2]: [Approach A]
+Thought 4/7 [BRANCH B from Thought 2]: [Approach B]
+```
+Compare explicitly, converge with decision rationale.
+
+### 6. Generate & Verify Hypotheses
+```
+Thought 6/9 [HYPOTHESIS]: [Proposed solution]
+Thought 7/9 [VERIFICATION]: [Test results]
+```
+Iterate until hypothesis verified.
+
+### 7. Complete Only When Ready
+Mark final: `Thought N/N [FINAL]`
+
+Complete when:
+- Solution verified
+- All critical aspects addressed
+- Confidence achieved
+- No outstanding uncertainties
+
+## Application Modes
+
+**Explicit**: Use visible thought markers when complexity warrants visible reasoning or user requests breakdown.
+
+**Implicit**: Apply methodology internally for routine problem-solving where thinking aids accuracy without cluttering response.
+
+## Scripts (Optional)
+
+Optional scripts for deterministic validation/tracking:
+- `scripts/process-thought.js` - Validate & track thoughts with history
+- `scripts/format-thought.js` - Format for display (box/markdown/simple)
+
+See README.md for usage examples. Use when validation/persistence needed; otherwise apply methodology directly.
+
+## References
+
+Load when deeper understanding needed:
+- `references/core-patterns.md` - Revision & branching patterns
+- `references/examples-api.md` - API design example
+- `references/examples-debug.md` - Debugging example
+- `references/examples-architecture.md` - Architecture decision example
+- `references/advanced-techniques.md` - Spiral refinement, hypothesis testing, convergence
+- `references/advanced-strategies.md` - Uncertainty, revision cascades, meta-thinking

package/dist/presets/frontend/skills/sequential-thinking/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "sequential-thinking-skill",
+  "version": "1.0.0",
+  "description": "Sequential thinking methodology with thought processing scripts",
+  "main": "scripts/process-thought.js",
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "keywords": [
+    "sequential-thinking",
+    "problem-solving",
+    "agent-skill"
+  ],
+  "author": "Converted from Anthropic MCP Server",
+  "license": "MIT",
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "testMatch": [
+      "**/tests/**/*.test.js"
+    ],
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "/tests/"
+    ]
+  }
+}

package/dist/presets/frontend/skills/sequential-thinking/references/advanced-strategies.md

@@ -0,0 +1,79 @@
+# Advanced Sequential Thinking Strategies
+
+Additional sophisticated patterns for complex scenarios.
+
+## Uncertainty Management
+
+Handle incomplete information systematically.
+
+```
+Thought 2/7: Need to decide X
+Thought 3/7: Insufficient data—two scenarios possible
+Thought 4/7 [SCENARIO A if P true]: Analysis for A
+Thought 4/7 [SCENARIO B if P false]: Analysis for B
+Thought 5/7: Decision that works for both scenarios
+Thought 6/7: Or determine critical info needed
+Thought 7/7 [FINAL]: Robust solution or clear info requirement
+```
+
+**Use for**: Decisions under uncertainty, incomplete requirements.
+
+**Strategies**:
+- Find solution robust to uncertainty
+- Identify minimal info needed to resolve
+- Make safe assumptions with clear documentation
+
+## Revision Cascade Management
+
+Handle revisions that invalidate multiple subsequent thoughts.
+
+```
+Thought 1/8: Foundation assumption
+Thought 2/8: Build on Thought 1
+Thought 3/8: Further build
+Thought 4/8: Discover Thought 1 invalid
+Thought 5/8 [REVISION of Thought 1]: Corrected foundation
+Thought 6/8 [REASSESSMENT]: Which of 2-3 still valid?
+  - Thought 2: Partially valid, needs adjustment
+  - Thought 3: Completely invalid
+Thought 7/8: Rebuild from corrected Thought 5
+Thought 8/8 [FINAL]: Solution on correct foundation
+```
+
+**Key**: After major revision, explicitly assess downstream impact.
+
+## Meta-Thinking Calibration
+
+Monitor and adjust thinking process itself.
+
+```
+Thought 5/9: [Regular thought]
+Thought 6/9 [META]: Past 3 thoughts circling without progress
+  Analysis: Missing key information
+  Adjustment: Need to research X before continuing
+Thought 7/9: Research findings on X
+Thought 8/9: Now can proceed with informed decision
+Thought 9/9: [Resume productive path]
+```
+
+**Use when**: Stuck, circling, or unproductive pattern noticed.
+**Action**: Pause, identify issue, adjust strategy.
+
+## Parallel Constraint Satisfaction
+
+Handle multiple independent constraints simultaneously.
+
+```
+Thought 2/10: Solution must satisfy A, B, C
+Thought 3/10 [CONSTRAINT A]: Solutions satisfying A: {X, Y, Z}
+Thought 4/10 [CONSTRAINT B]: Solutions satisfying B: {Y, Z, W}
+Thought 5/10 [CONSTRAINT C]: Solutions satisfying C: {X, Z}
+Thought 6/10 [INTERSECTION]: Z satisfies all
+Thought 7/10: Verify Z feasible
+Thought 8/10 [BRANCH if infeasible]: Relax which constraint?
+Thought 9/10: Decision on constraint relaxation if needed
+Thought 10/10 [FINAL]: Optimal solution given constraints
+```
+
+**Use for**: Optimization problems, multi-criteria decisions.
+**Pattern**: Analyze independently → Find intersection → Verify feasibility.

package/dist/presets/frontend/skills/sequential-thinking/references/advanced-techniques.md

@@ -0,0 +1,76 @@
+# Advanced Sequential Thinking Techniques
+
+Complex problem-solving patterns.
+
+## Spiral Refinement
+
+Return to concepts with progressively deeper understanding.
+
+```
+Thought 1/7: Initial design (surface)
+Thought 2/7: Discover constraint A
+Thought 3/7: Refine for A
+Thought 4/7: Discover constraint B
+Thought 5/7: Refine for both A and B
+Thought 6/7: Integration reveals edge case
+Thought 7/7: Final design addressing all constraints
+```
+
+**Use for**: Complex systems where constraints emerge iteratively.
+**Key**: Each return is refinement, not restart.
+
+## Hypothesis-Driven Investigation
+
+Systematic hypothesis generation and testing.
+
+```
+Thought 1/6: Observe symptoms
+Thought 2/6 [HYPOTHESIS]: Explanation X
+Thought 3/6 [VERIFICATION]: Test X—partial match
+Thought 4/6 [REFINED HYPOTHESIS]: Adjusted Y
+Thought 5/6 [VERIFICATION]: Test Y—confirmed
+Thought 6/6 [FINAL]: Solution based on verified Y
+```
+
+**Use for**: Debugging, root cause analysis, diagnostics.
+**Pattern**: Generate → Test → Refine → Re-test loop.
+
+## Multi-Branch Convergence
+
+Explore alternatives, then synthesize best approach.
+
+```
+Thought 2/8: Multiple viable approaches
+Thought 3/8 [BRANCH A]: Approach A benefits
+Thought 4/8 [BRANCH A]: Approach A drawbacks
+Thought 5/8 [BRANCH B]: Approach B benefits
+Thought 6/8 [BRANCH B]: Approach B drawbacks
+Thought 7/8 [CONVERGENCE]: Hybrid combining A's X with B's Y
+Thought 8/8 [FINAL]: Hybrid superior to either alone
+```
+
+**Use for**: Complex decisions where neither option clearly best.
+**Key**: Convergence often yields better solution than either branch.
+
+## Progressive Context Deepening
+
+Build understanding in layers from abstract to concrete.
+
+```
+Thought 1/9: High-level problem
+Thought 2/9: Identify major components
+Thought 3/9: Zoom into component A (detailed)
+Thought 4/9: Zoom into component B (detailed)
+Thought 5/9: Identify A-B interactions
+Thought 6/9: Discover emergent constraint
+Thought 7/9 [REVISION of 3-4]: Adjust for interaction
+Thought 8/9: Verify complete system
+Thought 9/9 [FINAL]: Integrated solution
+```
+
+**Use for**: System design, architecture, integration problems.
+**Pattern**: Abstract → Components → Details → Interactions → Integration.
+
+## Reference
+
+See `advanced-strategies.md` for: Uncertainty Management, Revision Cascade Management, Meta-Thinking Calibration, Parallel Constraint Satisfaction.

package/dist/presets/frontend/skills/sequential-thinking/references/core-patterns.md

@@ -0,0 +1,95 @@
+# Core Sequential Thinking Patterns
+
+Essential revision and branching patterns.
+
+## Revision Patterns
+
+### Assumption Challenge
+Early assumption proves invalid with new data.
+```
+Thought 1/5: Assume X is bottleneck
+Thought 4/5 [REVISION of Thought 1]: X adequate; Y is actual bottleneck
+```
+
+### Scope Expansion
+Problem larger than initially understood.
+```
+Thought 1/4: Fix bug
+Thought 4/5 [REVISION of scope]: Architectural redesign needed, not patch
+```
+
+### Approach Shift
+Initial strategy inadequate for requirements.
+```
+Thought 2/6: Optimize query
+Thought 5/6 [REVISION of Thought 2]: Optimization + cache layer required
+```
+
+### Understanding Deepening
+Later insight fundamentally changes interpretation.
+```
+Thought 1/5: Feature broken
+Thought 4/5 [REVISION of Thought 1]: Not bug—UX confusion issue
+```
+
+## Branching Patterns
+
+### Trade-off Evaluation
+Compare approaches with different trade-offs.
+```
+Thought 3/7: Choose between X and Y
+Thought 4/7 [BRANCH A]: X—simpler, less scalable
+Thought 4/7 [BRANCH B]: Y—complex, scales better
+Thought 5/7: Choose Y for long-term needs
+```
+
+### Risk Mitigation
+Prepare backup for high-risk primary approach.
+```
+Thought 2/6: Primary: API integration
+Thought 3/6 [BRANCH A]: API details
+Thought 3/6 [BRANCH B]: Fallback: webhook
+Thought 4/6: Implement A with B contingency
+```
+
+### Parallel Exploration
+Investigate independent concerns separately.
+```
+Thought 3/8: Two unknowns—DB schema & API design
+Thought 4/8 [BRANCH DB]: DB options
+Thought 4/8 [BRANCH API]: API patterns
+Thought 5/8: Integrate findings
+```
+
+### Hypothesis Testing
+Test multiple explanations systematically.
+```
+Thought 2/6: Could be A, B, or C
+Thought 3/6 [BRANCH A]: Test A—not cause
+Thought 3/6 [BRANCH B]: Test B—confirmed
+Thought 4/6: Root cause via Branch B
+```
+
+## Adjustment Guidelines
+
+**Expand when**: Complexity discovered, multiple aspects identified, verification needed, alternatives require exploration.
+
+**Contract when**: Key insight solves earlier, problem simpler, steps merge naturally.
+
+**Example**:
+```
+Thought 1/5: Initial
+Thought 3/7: Complexity (5→7)
+Thought 5/8: Another aspect (7→8)
+Thought 8/8 [FINAL]: Complete
+```
+
+## Anti-Patterns
+
+**Premature Completion**: Rushing without verification → Add verification thoughts.
+
+**Revision Cascade**: Repeated revisions without understanding why → Identify root cause.
+
+**Branching Explosion**: Too many branches → Limit to 2-3, converge before more.
+
+**Context Loss**: Ignoring earlier insights → Reference previous thoughts explicitly.

package/dist/presets/frontend/skills/sequential-thinking/references/examples-api.md

@@ -0,0 +1,88 @@
+# Example: API Design with Sequential Thinking
+
+**Problem**: Design authentication API for multi-tenant SaaS.
+
+## Without Sequential Thinking
+"Use JWT with OAuth2. Add tenant ID to claims. Implement refresh tokens."
+(Misses edge cases, scaling, security)
+
+## With Sequential Thinking
+
+```
+Thought 1/5: Requirements
+
+Multi-tenant SaaS authentication needs:
+- Tenant isolation (prevent cross-tenant access)
+- Scalability (thousands of tenants)
+- Security (industry standards)
+
+Uncertainty: Session vs token? Stateful vs stateless?
+Next: Evaluate approaches
+
+Thought 2/6: Approach evaluation (adjusted)
+
+Comparing session vs JWT:
+- Session: Server state, easy revocation, harder scaling
+- JWT: Stateless, scales well, complex revocation
+
+Multi-tenancy complicates sessions (which DB?).
+JWT better for distributed systems.
+Next: JWT structure
+
+Thought 3/6: JWT payload design
+
+JWT includes: User ID, Tenant ID, Permissions, Expiration
+
+Uncertainty: Where verify tenant? Gateway vs service?
+Next: Token refresh
+
+Thought 4/6 [REVISION of Thought 3]: Security fix
+
+Original: Tenant ID in JWT claims.
+Issue: Claims visible (base64), could read tenant IDs.
+
+Corrected:
+- Keep tenant ID (needed for routing)
+- Add gateway verification
+- Log access attempts
+
+Impact: Need gateway security layer
+
+Thought 5/7: Refresh strategy (adjusted)
+
+Access: 15 min
+Refresh: 7 days, rotate on use
+
+Storage:
+- Access: Client memory
+- Refresh: HttpOnly cookie + DB revocation
+
+Enables revocation + stateless benefits.
+
+Thought 6/7: Gateway flow
+
+1. Verify JWT signature
+2. Extract tenant ID
+3. Verify user belongs to tenant (cache + DB)
+4. Forward with verified context
+
+Addresses Thought 4 security concern.
+
+Thought 7/7 [FINAL]: Complete solution
+
+- JWT with refresh rotation
+- Tenant ID + gateway verification
+- 15-min access, 7-day refresh
+- HttpOnly cookies + revocation DB
+- Gateway enforces isolation
+
+Confidence: High
+Assumptions: Distributed, centralized gateway
+Trade-offs: Slight latency vs security
+```
+
+## Key Outcomes
+
+1. **Revision caught security issue**: Tenant ID visibility
+2. **Dynamic adjustment**: 5→7 thoughts as complexity emerged
+3. **Comprehensive**: Authentication, authorization, multi-tenancy, revocation