@kienha/anti-chaotic 1.0.2 → 1.0.6

package/README.md

@@ -9,12 +9,25 @@
 
 ## 🎯 Introduction
 
-**Anti-Chaotic** is a comprehensive **Agent Kit** for Antigravity, designed to standardize and optimize your software development workflow. It serves as a versatile toolkit rather than a rigid framework:
+**Anti-Chaotic** is a comprehensive **Agent Kit** for Antigravity, designed to standardize and optimize your software development workflow.
 
-- 🧠 **12+ Multi-domain AI Skills** - From Product Manager, Business Analyst to Lead Architect, DevOps Engineer
-- 🔄 **5 Automated Workflows** - Pre-defined, reusable work processes
-- 📜 **Rules Engine** - A rule system that ensures AI Agents follow project standards
-- 📚 **References Library** - Documentation references for various technologies and frameworks
+### 🎯 Core Philosophy
+
+> **Process over Speed**: This kit is designed for **development teams** and **collaborative environments**. It prioritizes robust processes, structure, and long-term maintainability over "fast shipping" or quick hacks. It aims to bring standard engineering practices to AI-assisted coding.
+
+### 🧩 Concepts
+
+- **Skills = Knowledge**: What the agent knows (Best practices, languages, patterns).
+- **Rules & Workflows = Process**: How the agent executes (Steps, restrictions, output formats).
+
+_We encourage teams to customize these skills and define their own rules & workflows to align with their specific enterprise standards._
+
+### 📦 Components
+
+- 🧠 **12+ Multi-domain AI Skills** - From Product Manager, Business Analyst to Lead Architect.
+- 🔄 **6 Automated Workflows** - Pre-defined, reusable work processes.
+- 📜 **Rules Engine** - A rule system that ensures AI Agents follow project standards.
+- 📚 **References Library** - Documentation references for various technologies.
 
 ---
 
@@ -37,91 +50,63 @@
 | **rules-workflows**     | Create and manage rules, workflows                    |
 | **skill-creator**       | Create new skills for the framework                   |
 
-### 🔄 Automated Workflows
-
-| Workflow                       | Description                                   | Trigger                      |
-| ------------------------------ | --------------------------------------------- | ---------------------------- |
-| `/requirement-analysis`        | Analyze requirements → PRD, SDD, User Stories | Starting a new project       |
-| `/generate-docs-from-codebase` | Generate documentation from existing code     | Project without docs         |
-| `/ui-ux-design-from-doc`       | Transform requirements → UI/UX design         | After having PRD             |
-| `/workflow-rule-from-codebase` | Create project rules from code                | Onboarding to a project      |
-| `/workflow-rule-from-feedback` | Update rules based on feedback                | Fixing recurring AI mistakes |
-
 ### 📜 Smart Rules Engine
 
 - **Documentation Rules**: Standard document structure and formatting
 - **Clean Code Rules**: Coding standards and best practices
 - **Project Rules**: Project-specific conventions
 
+> **ℹ️ Documentation & Tools**: The default generated documentation is optimized for **Obsidian**. If your team uses **Jira**, **GitHub**, or other tools, simply connect the relevant **MCP Server** and customize the `documents.md` rule to align the output format.
+
 ---
 
-## 📁 Directory Structure
+## 🚀 Quick Start
 
-```
-anti-chaotic/
-├── .agent/
-│   ├── skills/           # 12 AI skills with detailed instructions
-│   │   ├── product-manager/
-│   │   ├── business-analysis/
-│   │   ├── lead-architect/
-│   │   ├── designer/
-│   │   ├── frontend-developer/
-│   │   ├── backend-developer/
-│   │   ├── devops-engineer/
-│   │   ├── qa-tester/
-│   │   ├── ai-engineer/
-│   │   ├── blockchain-engineer/
-│   │   ├── rules-workflows/
-│   │   └── skill-creator/
-│   ├── workflows/        # Automated workflows
-│   │   ├── requirement-analysis.md
-│   │   ├── generate-docs-from-codebase.md
-│   │   ├── ui-ux-design-from-doc.md
-│   │   ├── workflow-rule-from-codebase.md
-│   │   └── workflow-rule-from-feedback.md
-│   └── rules/            # Project & documentation rules
-│       ├── documentation.md
-│       └── clean-code.md
-├── bin/                  # CLI utilities
-├── docs/                 # Generated documentation
-└── README.md
-```
+### 1. Recommended Setup (MCP Servers)
 
----
+To achieve the best results, we highly recommend installing the following MCP (Model Context Protocol) servers:
 
-## 🚀 Quick Start
+- **[sequence-thinking](https://github.com/axiom-team/mcp-server-sequence-thinking)**: AI model for advanced problem breakdown and step-by-step reasoning.
+- **[context7](https://github.com/axiom-team/mcp-server-context7)**: For managing and retrieving broad project context.
+
+### 2. Initialize in your project
 
-### 1. Clone Repository
+Run the following command in your project root to install the Agent Kit:
 
 ```bash
-git clone https://github.com/kienhaminh/anti-chaotic.git
-cd anti-chaotic
+npx @kienha/anti-chaotic init
 ```
 
-### 2. Install Dependencies
+This will download the `.agent` folder containing all skills, rules, and workflows into your project.
 
-```bash
-npm install
-```
+### 3. Using the Agent Kit
 
-### 3. Using the Framework
+Once initialized, start a new chat with your AI IDE (Cursor, Windsurf, etc.) and reference the installed rules/workflows.
 
 #### Start a new project with AI:
 
 ```
-/requirement-analysis Create a sales management application for a fashion store
+/brainstorm Create a sales management application for a fashion store
 ```
 
 #### Generate docs for an existing project:
 
 ```
-/generate-docs-from-codebase
+/documentation
 ```
 
 #### Design UI from requirements:
 
 ```
-/ui-ux-design-from-doc docs/020-Requirements/PRD-YourProject.md
+/ui-ux-design docs/020-Requirements/PRD-YourProject.md
+```
+
+### 4. Updating the Kit
+
+To update your Agent Kit to the latest version:
+
+```bash
+npx @kienha/anti-chaotic update
 ```
 
 ---
@@ -133,308 +118,35 @@ npm install
 **Method 1: Slash Command**
 
 ```
-/requirement-analysis [Your project description]
+/brainstorm [Your project description]
 ```
 
 **Method 2: Direct Request**
 
 ```
-Please run the requirement-analysis workflow to analyze requirements for an e-commerce project
+Please run the brainstorm workflow to analyze requirements for an e-commerce project
 ```
 
 **Method 3: File Reference**
 
 ```
-Read and execute the workflow at .agent/workflows/requirement-analysis.md
-```
-
-### Special Annotations
-
-| Annotation     | Meaning                                  |
-| -------------- | ---------------------------------------- |
-| `// turbo`     | Auto-run this step without user approval |
-| `// turbo-all` | Auto-run ALL steps in the workflow       |
-
----
-
-## 🔗 Workflow Chaining
-
-Workflows can be chained together to create a complete process:
-
-```
-┌──────────────────────────────────────────────────────────────┐
-│                    🔄 FULL PROJECT LIFECYCLE                 │
-├──────────────────────────────────────────────────────────────┤
-│                                                              │
-│  1. /requirement-analysis                                    │
-│     │                                                        │
-│     ▼                                                        │
-│  2. /ui-ux-design-from-doc (with the generated PRD)          │
-│     │                                                        │
-│     ▼                                                        │
-│  3. [Development Phase - implement code]                     │
-│     │                                                        │
-│     ▼                                                        │
-│  4. /generate-docs-from-codebase                             │
-│     │                                                        │
-│     ▼                                                        │
-│  5. /workflow-rule-from-feedback (if needed)                 │
-│                                                              │
-└──────────────────────────────────────────────────────────────┘
+Read and execute the workflow at .agent/workflows/brainstorm.md
 ```
 
 ---
 
 ## 🎓 Workflow Details
 
-### `/requirement-analysis`
-
-> **Description**: Analyze requirements from raw ideas → complete documentation
-
-#### 🎯 When to Use?
-
-- Starting a new project from scratch
-- Converting ideas into technical documentation
-- Need to create PRD, SDD, Epics, User Stories
-
-#### 📊 Process Flow
-
-```
-┌─────────────────────────────────────────────────────┐
-│ Step 0: Clarification & Understanding (PM)          │
-│         → Create clarification-questions.md         │
-├─────────────────────────────────────────────────────┤
-│ Step 1: Create Roadmap (PM)                         │
-│         → docs/010-Planning/Roadmap-{Project}.md    │
-├─────────────────────────────────────────────────────┤
-│ Step 2: Create PRD (PM)                             │
-│         → docs/020-Requirements/PRD-{Project}.md    │
-├─────────────────────────────────────────────────────┤
-│ Step 3: Create SDD (Architect)                      │
-│         → docs/030-Specs/Architecture/SDD-{...}.md  │
-├─────────────────────────────────────────────────────┤
-│ Step 4: Create Epics (BA)                           │
-│         → docs/022-User-Stories/Epics/*.md          │
-├─────────────────────────────────────────────────────┤
-│ Step 5: Create Use Cases (BA)                       │
-│         → docs/020-Requirements/Use-Cases/*.md      │
-├─────────────────────────────────────────────────────┤
-│ Step 6: Create User Stories (BA)                    │
-│         → docs/022-User-Stories/Backlog/*.md        │
-├─────────────────────────────────────────────────────┤
-│ Step 7: Create ADRs (Architect) - Optional          │
-│         → docs/030-Specs/Architecture/ADR-*.md      │
-├─────────────────────────────────────────────────────┤
-│ Step 8: Finalize & Summary (PM)                     │
-│         → Update MOC files & Index                  │
-└─────────────────────────────────────────────────────┘
-```
-
-#### 💡 Example
-
-```
-/requirement-analysis Create a personal finance management app with features:
-- Income/expense tracking
-- Budget planning
-- Analytics reports
-- Bank synchronization
-```
-
----
-
-### `/generate-docs-from-codebase`
-
-> **Description**: Automatically generate documentation from an existing codebase
-
-#### 🎯 When to Use?
-
-- Onboarding to an existing project without documentation
-- Updating docs after significant code changes
-- Need to create API docs, schema docs, architecture overview
-
-#### 📊 Process Flow
-
-```
-┌─────────────────────────────────────────────────────┐
-│ Step 1: Codebase Discovery & Analysis               │
-│         → Scan package.json, config files           │
-│         → Analyze folder structure                  │
-├─────────────────────────────────────────────────────┤
-│ Step 2: Determine Documentation Scope               │
-│         → Choose: Architecture, API, Schema, etc.   │
-├─────────────────────────────────────────────────────┤
-│ Step 3: Generate System Architecture                │
-│         → C4 diagrams, component relationships      │
-├─────────────────────────────────────────────────────┤
-│ Step 4: Generate API Documentation                  │
-│         → Endpoint specs, request/response schemas  │
-├─────────────────────────────────────────────────────┤
-│ Step 5: Generate Database Schema Documentation      │
-│         → Entity descriptions, ERD diagram          │
-├─────────────────────────────────────────────────────┤
-│ Step 6: Generate MOC Files                          │
-│         → Index files for navigation                │
-├─────────────────────────────────────────────────────┤
-│ Step 7: Validation & Linking                        │
-│         → Check frontmatter, wiki-links             │
-├─────────────────────────────────────────────────────┤
-│ Step 8: Summary & Next Steps                        │
-│         → Report generated files                    │
-└─────────────────────────────────────────────────────┘
-```
+## 🔄 Automated Workflows
 
-#### 💡 Example
-
-```
-/generate-docs-from-codebase
-
-Or specify a specific scope:
-/generate-docs-from-codebase Only create API documentation and Database Schema
-```
-
----
-
-### `/ui-ux-design-from-doc`
-
-> **Description**: Transform requirements documents into UI/UX designs
-
-#### 🎯 When to Use?
-
-- Already have PRD/requirements and need interface design
-- Need to create a design system for the project
-- Want to quickly prototype main screens
-
-#### 📊 Process Flow
-
-```
-┌─────────────────────────────────────────────────────┐
-│ Step 1: Analyze Requirements                        │
-│         → Extract target audience, features         │
-├─────────────────────────────────────────────────────┤
-│ Step 2: Define Design System                        │
-│         → Typography, colors, spacing               │
-├─────────────────────────────────────────────────────┤
-│ Step 3: Map User Flows                              │
-│         → Critical paths, screen sequences          │
-├─────────────────────────────────────────────────────┤
-│ Step 4: Create Visual Artifacts                     │
-│         → Components, page layouts                  │
-├─────────────────────────────────────────────────────┤
-│ Step 5: Verification                                │
-│         → Req check, usability check                │
-└─────────────────────────────────────────────────────┘
-```
-
-#### 💡 Example
-
-```
-/ui-ux-design-from-doc docs/020-Requirements/PRD-ShopManagement.md
-```
-
----
-
-### `/workflow-rule-from-codebase`
-
-> **Description**: Analyze codebase to create project rules file
-
-#### 🎯 When to Use?
-
-- Newly joining an existing project
-- Want AI Agent to "learn" project conventions
-- Need to document coding standards
-
-#### 📊 Process Flow
-
-```
-┌─────────────────────────────────────────────────────┐
-│ Step 1: Discovery Scan                              │
-│         → Read config, analyze structure            │
-├─────────────────────────────────────────────────────┤
-│ Step 2: Synthesize Observations                     │
-│         → Tech stack, conventions, directories      │
-├─────────────────────────────────────────────────────┤
-│ Step 3: Create Project Rules                        │
-│         → .agent/rules/project-rules.md             │
-├─────────────────────────────────────────────────────┤
-│ Step 4: Write the File                              │
-│         → Save with standard format                 │
-├─────────────────────────────────────────────────────┤
-│ Step 5: Validation                                  │
-│         → Check alignment with package.json         │
-└─────────────────────────────────────────────────────┘
-```
-
-#### 💡 Example
-
-```
-/workflow-rule-from-codebase
-```
-
----
-
-### `/workflow-rule-from-feedback`
-
-> **Description**: Create/update rules based on user feedback
-
-#### 🎯 When to Use?
-
-- Want AI Agent to remember a specific rule
-- Fixing mistakes that AI frequently makes
-- Adding preferences for the project
-
-#### 📊 Process Flow
-
-```
-┌─────────────────────────────────────────────────────┐
-│ Step 1: Analyze Feedback & Existing Rules           │
-│         → Check conflicts, determine action         │
-├─────────────────────────────────────────────────────┤
-│ Step 2: Determine Target Rule File                  │
-│         → project-rules.md or new file?             │
-├─────────────────────────────────────────────────────┤
-│ Step 3: Update Project Content                      │
-│         → Append/update the rule                    │
-├─────────────────────────────────────────────────────┤
-│ Step 4: Write the File                              │
-│         → Save changes                              │
-├─────────────────────────────────────────────────────┤
-│ Step 5: Confirmation                                │
-│         → Notify user                               │
-└─────────────────────────────────────────────────────┘
-```
-
-#### 💡 Example
-
-```
-/workflow-rule-from-feedback Always use Zod for validation instead of Yup
-
-/workflow-rule-from-feedback Never use any type in TypeScript
-```
-
----
-
-## 💡 Tips & Best Practices
-
-### ✅ Do's
-
-1. **Read output carefully before approving** - Each step has a checkpoint for review
-2. **Use artifacts for comments** - AI will create draft files for you to review first
-3. **Provide complete context** - Describe requirements in detail from the start
-4. **Chain workflows** - Combine multiple workflows for a complete process
-
-### ❌ Don'ts
-
-1. **Skip clarification step** - The clarification step is crucial
-2. **Approve without reading** - Always review before confirming
-3. **Run inappropriate workflows** - Choose the right workflow for the right use case
-
-### 🔧 Troubleshooting
-
-| Issue                      | Solution                                      |
-| -------------------------- | --------------------------------------------- |
-| Workflow doesn't run       | Check slash command syntax                    |
-| Output has wrong format    | Ensure `.agent/rules/documentation.md` exists |
-| AI asks too many questions | Provide more context in the initial request   |
+| Workflow                 | Description                                                                                                | Use Case                                                            |
+| :----------------------- | :--------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------ |
+| **`/bootstrap`**         | Sets up project structure, installs dependencies, and configures environment based on architectural specs. | Start of Implementation Phase.                                      |
+| **`/brainstorm`**        | Analyze ideas with the user and create preliminary high-level documents (Roadmap, PRD).                    | Start of a new project or feature when you only have a rough idea.  |
+| **`/custom-behavior`**   | Safely customize Agent rules and workflows with impact analysis and user confirmation.                     | As needed to adjust Agent behavior or fix recurring mistakes.       |
+| **`/documentation`**     | Generate comprehensive documentation (Architecture, API, Specs) from either Codebase or Requirements.      | Onboarding to a legacy project OR creating detailed specs from PRD. |
+| **`/implement-feature`** | Orchestrates feature implementation from specification to deployment.                                      | After design and specs are ready, for actual coding and deployment. |
+| **`/ui-ux-design`**      | Transform requirements into comprehensive UI/UX design deliverables.                                       | After requirements are finalized, before coding.                    |
 
 ---
 
@@ -452,15 +164,6 @@ We welcome all contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for detaile
 
 ---
 
-## 📚 Additional Resources
-
-- **Documentation Rules**: `.agent/rules/documentation.md`
-- **Available Skills**: `.agent/skills/`
-- **Project Rules**: `.agent/rules/project-rules.md` (if exists)
-- **Agent Skills Specification**: [agentskills.io/specification](https://agentskills.io/specification)
-
----
-
 ## 📄 License
 
 This project is released under the [MIT License](LICENSE).
@@ -470,5 +173,3 @@ This project is released under the [MIT License](LICENSE).
 <p align="center">
   <b>Made with ❤️ for the AI-Driven Development Community</b>
 </p>
-
-> 💡 **Tip**: You can create new workflows by adding `.md` files in the `.agent/workflows/` directory following the same structure as existing workflows.

package/bin/{ag.js → anti-chaotic.js}

@@ -41,8 +41,25 @@ program
   .description("Update .agent configuration from GitHub")
   .action(async () => {
     const targetAgentDir = path.join(process.cwd(), ".agent");
+    const { default: inquirer } = await import("inquirer");
 
     try {
+      if (await fs.pathExists(targetAgentDir)) {
+        const { confirm } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "confirm",
+            message: `Directory ${targetAgentDir} already exists. Do you want to overwrite it?`,
+            default: false,
+          },
+        ]);
+
+        if (!confirm) {
+          console.log(chalk.yellow("Operation cancelled by user."));
+          return;
+        }
+      }
+
       console.log(
         chalk.blue(`Updating Anti-Chaotic Agent Kit from ${REPO_URI}...`),
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kienha/anti-chaotic",
-  "version": "1.0.2",
+  "version": "1.0.6",
   "description": "Anti-Chaotic - An agent kit for Antigravity to standardize the software development process",
   "main": "index.js",
   "publishConfig": {
@@ -26,8 +26,8 @@
   "license": "ISC",
   "type": "commonjs",
   "bin": {
-    "ag": "bin/ag.js",
-    "anti-chaotic": "bin/ag.js"
+    "ac": "bin/anti-chaotic.js",
+    "anti-chaotic": "bin/anti-chaotic.js"
   },
   "files": [
     ".agent",
@@ -37,6 +37,7 @@
     "chalk": "^4.1.2",
     "commander": "^14.0.2",
     "fs-extra": "^11.3.3",
-    "giget": "^2.0.0"
+    "giget": "^2.0.0",
+    "inquirer": "^13.2.0"
   }
 }

package/.agent/skills/frontend-developer/references/react-next.md

@@ -1,67 +0,0 @@
-# React & Next.js Architecture
-
-**Status**: Definitive Guide
-**Stack**: React 18+, Next.js App Router (14+)
-
-## 🏗 Architecture: "Server-Centric" Design
-
-### 1. The Separation: Server vs. Client
-
-- **Default to Server Components (RSC)**: All components are Server by default.
-- **Client Components**: Only use `'use client'` when you need:
-  - Event listeners (`onClick`, `onChange`)
-  - Hooks (`useState`, `useEffect`)
-  - Browser-only APIs
-
-### 2. File Structure (Feature-Sliced)
-
-```
-app/
-├── layout.tsx         # Root layout
-├── page.tsx           # Home
-├── (auth)/            # Route Group (doesn't affect URL)
-│   ├── login/
-│   │   └── page.tsx
-├── _components/       # Shared UI
-└── features/          # Feature Modules
-    ├── cart/
-    │   ├── components/
-    │   ├── hooks/
-    │   └── actions.ts # Server Actions
-```
-
-## ⚡ Performance Patterns
-
-### 1. Data Fetching
-
-- **No `useEffect`**: Fetch data directly in Server Components using `async/await`.
-- **Deduplication**: `fetch` is auto-memoized.
-- **Waterfalls**: Use `Promise.all` for parallel fetching, or use `<Suspense>` for streaming.
-
-```tsx
-// ✅ GOOD: Streaming
-export default async function Page() {
-  return (
-    <Suspense fallback={<Skeleton />}>
-      <UserFeed /> {/* Fetches its own data */}
-    </Suspense>
-  );
-}
-```
-
-### 2. Server Actions instead of API Routes
-
-- Colocate mutations with the feature code.
-- Use `useFormStatus` for pending states.
-- Use `useOptimistic` for instant UI updates.
-
-### 3. Image Optimization
-
-- Required usage of `next/image`.
-- **sizes**: mandatory prop for responsive images. `sizes="(max-width: 768px) 100vw, 50vw"`.
-
-## 🧪 Testing
-
-- **Unit**: Vitest/Jest for logic.
-- **Integration**: React Testing Library for Client Components.
-- **E2E**: Playwright for full flows.