@kienha/anti-chaotic 1.0.7 → 1.0.8

package/.agent/rules/tests.md

@@ -0,0 +1,55 @@
+---
+trigger: model_decision
+description: Always run tests to ensure no regressions when implementing new features or fixing bugs
+---
+
+# Testing and Regression Rule
+
+> [!IMPORTANT]
+> This rule is **MANDATORY** when implementing new features, fixing bugs, or performing major refactors. Ensuring system stability is a top priority.
+
+## Critical Rules (MUST Follow)
+
+1. **MUST** run existing tests before starting any work to establish a baseline.
+2. **MUST** run tests after completing changes to ensure no regressions were introduced.
+3. **MUST** add new tests for any new features implemented.
+4. **MUST** add reproduction tests for any bug fixes to ensure the bug does not return.
+5. **MUST** report test results (pass/fail) in the task summary and walkthrough.
+6. **MUST NOT** proceed to finalize a task if tests are failing, unless explicitly instructed by the user after explaining the failure and its impact.
+
+## Decision Flow
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ WHEN implementing a feature or fixing a bug:                │
+├─────────────────────────────────────────────────────────────┤
+│ 1. Run baseline tests.                                      │
+│    Are they passing?                                        │
+│    NO  → Notify user of existing failures before proceeding. │
+│    YES → Continue.                                          │
+├─────────────────────────────────────────────────────────────┤
+│ 2. Implement changes (Feature/Fix/Refactor).                │
+├─────────────────────────────────────────────────────────────┤
+│ 3. Add/Update tests for the new code.                       │
+├─────────────────────────────────────────────────────────────┤
+│ 4. Run ALL relevant tests.                                  │
+│    Are they passing?                                        │
+│    NO  → Analyze failures, fix code/tests, repeat step 4.   │
+│    YES → Continue.                                          │
+├─────────────────────────────────────────────────────────────┤
+│ 5. Document test results in Walkthrough/Task Summary.       │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Running Tests
+
+- Use `npm test` to run the test suite.
+- For specific tests, use `npm test -- <path_to_test_file>`.
+- If the project uses a different test runner (e.g., `pytest`, `jest`, `vitest`), adapt the command accordingly based on `package.json` or project documentation.
+
+## What to do on Failure
+
+1. **Analyze logs**: Look for the specific assertion failure or error message.
+2. **Determine Root Cause**: Is it a bug in the code, a bug in the test, or a change in requirements?
+3. **Fix and Re-run**: Apply the necessary fix and run the tests again.
+4. **Communicate**: If a failure is expected or cannot be fixed easily, notify the user with a detailed explanation.

package/.agent/workflows/break-tasks.md

@@ -0,0 +1,82 @@
+---
+description: Orchestrates breaking down requirements into actionable tasks for implementation.
+---
+
+# Break Tasks Workflow
+
+> [!IMPORTANT]
+> **MANDATORY**: Follow `.agent/rules/documents.md` for all task-related documentation.
+
+---
+
+## MCP Usage Guidelines
+
+| MCP Tool                                     | When to Use                                               |
+| :------------------------------------------- | :-------------------------------------------------------- |
+| `mcp_sequential-thinking_sequentialthinking` | **REQUIRED** to break down requirements into atomic tasks |
+| `mcp_context7_query-docs`                    | To check best practices for specific technologies         |
+
+---
+
+## Step 1: Identify Source Document
+
+1. Locate the source document (PRD, User Story, Feature Spec, or SDD).
+2. If multiple versions exist, ask the user for clarification.
+3. Relevant folders to check:
+   - `docs/020-Requirements/`
+   - `docs/022-User-Stories/`
+   - `docs/030-Specs/`
+
+---
+
+## Step 2: Analyze Requirements
+
+// turbo
+
+1. **Invoke `[business-analysis]` skill** to extract key features and acceptance criteria.
+2. Use `sequential-thinking` to:
+   - Identify technical dependencies.
+   - Separate backend, frontend, and QA requirements.
+   - Spot ambiguous or missing details.
+3. List any clarifying questions for the user.
+4. **WAIT** for user clarification if needed.
+
+---
+
+## Step 3: Atomic Task Breakdown
+
+// turbo
+
+> 💡 **MCP**: **MUST** use `sequential-thinking` here to ensure tasks are atomic and manageable.
+
+1. **Invoke `[lead-architect]` skill** to create a structured task list.
+2. Group tasks by component or phase (e.g., Database, API, Logic, UI, Testing).
+3. For each task, include:
+   - Goal/Description.
+   - Acceptance Criteria.
+   - Estimated complexity (if applicable).
+4. Create a `task-breakdown.md` artifact representing the proposed sequence.
+
+---
+
+## Step 4: Finalize Task Documentation
+
+// turbo
+
+1. After user approves the `task-breakdown.md` artifact:
+2. Update the `task.md` of the current session or create a new task file in `docs/050-Tasks/`.
+3. If creating a new file, follow standard naming: `docs/050-Tasks/Task-{FeatureName}.md`.
+4. Update `docs/050-Tasks/Tasks-MOC.md`.
+5. Present the finalized task list to the user.
+
+---
+
+## Quick Reference
+
+| Role               | Skill                | Responsibility                          |
+| :----------------- | :------------------- | :-------------------------------------- |
+| Product Manager    | `product-manager`    | Requirement validation & prioritization |
+| Lead Architect     | `lead-architect`     | Technical breakdown & dependencies      |
+| Developer          | `backend-developer`  | Backend/API specific tasks              |
+| Frontend Developer | `frontend-developer` | UI/UX specific tasks                    |
+| QA Tester          | `qa-tester`          | Verification & Edge case tasks          |

package/.agent/workflows/debug.md

@@ -0,0 +1,71 @@
+---
+description: Scientific debugging workflow: Hypothesize, Instrument, Reproduce, Analyze, Fix.
+---
+
+# Scientific Debug & Fix Workflow
+
+> [!IMPORTANT]
+> **GOAL**: Follow a scientific process to identify root causes with EVIDENCE before applying fixes.
+> **Best for**: Hard-to-reproduce bugs, race conditions, performance issues, and regressions.
+
+---
+
+## Step 1: Hypothesis Generation
+
+1. **Analyze the Issue**: Review the bug report and available context.
+2. **Generate Hypotheses**: Brainstorm multiple potential causes (e.g., "Race condition in data fetching", "Incorrect state update logic", "Edge case in input validation").
+3. **Select Top Candidates**: Prioritize the most likely hypotheses to investigate first.
+
+---
+
+## Step 2: Instrumentation
+
+1. **Plan Logging**: Decide WHERE key information is missing to validate your hypotheses.
+2. **Add Logging**: Instrument the code with targetted `console.log`, specific logger calls, or performance markers.
+   - _Goal_: Capture runtime state, variable values, and execution flow relevant to the hypotheses.
+   - _Tip_: Add unique prefixes to logs (e.g., `[DEBUG-HYPOTHESIS-1]`) for easy filtering.
+
+---
+
+## Step 3: Reproduction & Data Collection
+
+1. **Execution**: Run the application or test case to reproduce the bug.
+   - If a reproduction script doesn't exist, create one now if possible.
+2. **Collect Data**: Capture the output from your instrumentation.
+
+---
+
+## Step 4: Analysis & Root Cause
+
+1. **Analyze Evidence**: Look at the collected logs/data.
+   - Does the data confirm a hypothesis?
+   - Does it rule one out?
+2. **Pinpoint Root Cause**: Identify exactly _why_ the bug is happening based on the evidence.
+3. **Iterate (if needed)**: If inconclusive, return to Step 1 or 2 with new knowledge.
+
+---
+
+## Step 5: Targeted Implementation
+
+1. **Apply Fix**: Implement a targeted fix based _only_ on the confirmed root cause. Avoid "shotgun debugging" (changing things randomly).
+2. **Cleanup**: Remove the temporary debugging instrumentation.
+
+---
+
+## Step 6: Verification
+
+// turbo
+
+1. **Run Reproduction Test**: Verify that the bug is gone.
+2. **Run Regression Tests**: Run related unit tests to ensure no side effects.
+3. **Lint & Type Check**: Ensure code quality standards are met.
+
+---
+
+## Step 7: Finalize
+
+1. **Draft Commit**: Create a concise commit message (e.g., `fix(module): description of fix`).
+2. **Report**: Summarize the process:
+   - What was the hypothesis?
+   - What evidence confirmed it?
+   - How was it fixed?

package/.agent/workflows/development.md

@@ -0,0 +1,54 @@
+---
+description: General coding workflow for implementing changes, bug fixes, or minor features.
+---
+
+# Development Workflow
+
+> [!IMPORTANT]
+> **MANDATORY**: Always read `.agent/rules/documents.md` before creating or modifying any documentation related to development.
+
+---
+
+## Step 1: Analyze & Plan
+
+// turbo
+
+1. Understand the requirement or bug report.
+2. **MUST** use `mcp_sequential-thinking_sequentialthinking` to:
+   - Analyze the existing code structure.
+   - Design the solution.
+   - Identify potential edge cases and impacts.
+3. If the task is complex, create an `implementation_plan.md` artifact.
+4. **WAIT** for user confirmation if the plan involves major architectural changes.
+
+---
+
+## Step 2: Execute Code Changes
+
+// turbo
+
+1. Implement the planned changes iteratively.
+2. **Backend**: Update models, logic, and APIs as needed.
+3. **Frontend**: Update UI components and state management.
+4. Ensure code follows project standards and linting rules.
+
+---
+
+## Step 3: Verify & Test
+
+// turbo
+
+1. Run existing tests to ensure no regressions.
+2. Add new unit or integration tests for the changes.
+3. Perform manual verification (e.g., using the browser tool for UI changes).
+4. **MUST** document proof of work in a `walkthrough.md` artifact if the change is significant.
+
+---
+
+## Step 4: Finalize
+
+// turbo
+
+1. Update related documentation (MOCs, API specs, etc.).
+2. Clean up any temporary files or comments.
+3. Present a summary of changes and verification results.

package/.agent/workflows/gen-tests.md

@@ -0,0 +1,58 @@
+---
+description: Generate unit, E2E, security, and performance tests using the qa-tester skill.
+---
+
+# Generate Tests Workflow
+
+> [!IMPORTANT]
+> **MANDATORY**: Apply `.agent/rules/documents.md` for all document creation and directory structure. All QA documents MUST be stored under `docs/035-QA/`.
+
+---
+
+## Step 1: Discovery & Strategy
+
+// turbo
+
+1. **Invoke `[qa-tester]` skill** to analyze the `docs/` folder and current codebase structure.
+2. Ask the user which type of tests they want to generate:
+   - **Unit Tests**: For specific functions or utilities (e.g., `tests/unit/`).
+   - **E2E Tests**: For user flows (e.g., `tests/e2e/`).
+   - **Security Tests**: For vulnerability assessments.
+   - **Performance Tests**: For load and responsiveness checks.
+3. Identify the specific files or features that need testing based on user input.
+
+---
+
+## Step 2: Test Plan & Case Generation
+
+// turbo
+
+1. **Invoke `[qa-tester]` skill** to create/update the Test Plan and Test Cases:
+   - For **Unit Tests**: Identify edge cases, boundary conditions, and happy paths.
+   - For **E2E Tests**: valid/invalid user flows.
+   - For **Security**: potential injection points, auth flaws.
+2. Generate the test documentation in `docs/035-QA/Test-Cases/` following the naming convention `TC-{Feature}-{NNN}.md`.
+3. Create a `draft-test-docs.md` artifact with the proposed test cases for review.
+
+---
+
+## Step 3: Test Code Generation
+
+1. **Wait** for user approval of the test cases.
+2. **Invoke `[qa-tester]` skill** to generate the actual test code.
+   - Use the project's existing testing framework (e.g., Jest, Playwright, Vitest).
+   - Ensure mocks and stubs are correctly implemented for unit tests.
+   - Ensure selectors and interaction steps are robust for E2E tests.
+3. Save the generated test code to the appropriate directories (e.g., `tests/unit/`, `tests/e2e/`).
+
+---
+
+## Step 4: Verification & Reporting
+
+1. Run the generated tests using the project's test runner.
+2. If tests fail:
+   - Analyze the failure.
+   - **Invoke `[qa-tester]` skill** to fix the test code or report the bug if it's a real issue.
+3. **Mandatory**:
+   - Update `docs/035-QA/QA-MOC.md`.
+   - Update `docs/000-Index.md` if needed.

package/.agent/workflows/qa.md

@@ -0,0 +1,59 @@
+---
+description: Create comprehensive test case documents and test plans based on project requirements.
+---
+
+# QA Workflow
+
+> [!IMPORTANT]
+> **MANDATORY**: Apply `.agent/rules/documents.md` for all document creation and directory structure. All QA documents MUST be stored under `docs/035-QA/`.
+
+---
+
+## MCP Usage Guidelines
+
+| MCP Tool                                     | When to Use                                      |
+| :------------------------------------------- | :----------------------------------------------- |
+| `mcp_sequential-thinking_sequentialthinking` | Analyze complex application logic and edge cases |
+| `mcp_context7_query-docs`                    | Research testing frameworks or best practices    |
+
+---
+
+## Step 1: Requirement Discovery
+
+// turbo
+
+1. **Invoke `[qa-tester]` skill** to analyze the `docs/` folder.
+2. Identify features, constraints, and business logic that require testing.
+3. Map out:
+   - Happy Paths (Golden Flows)
+   - Negative Paths (Error handling)
+   - Boundary Cases
+   - Security/Performance considerations
+4. **WAIT** for user to confirm the list of scenarios to be documented.
+
+---
+
+## Step 2: Draft Test Documentation
+
+// turbo
+
+1. **Invoke `[qa-tester]` skill** to create:
+   - **Test Plan**: High-level strategy for the current release/feature (`docs/035-QA/Test-Plans/`).
+   - **Test Cases**: Detailed step-by-step cases (`docs/035-QA/Test-Cases/`).
+2. Follow the standard mapping in `.agent/rules/documents.md`:
+   - Test Plan naming: `MTP-{Name}.md`
+   - Test Case naming: `TC-{Feature}-{NNN}.md`
+3. Create a `draft-qa-docs.md` artifact for review.
+
+---
+
+## Step 3: Finalize and Organize
+
+// turbo
+
+1. After approval, save all files to their respective folders in `docs/035-QA/`.
+2. **Mandatory**:
+   - Update `docs/035-QA/QA-MOC.md`.
+   - Update `docs/000-Index.md` if needed.
+   - Ensure all frontmatter (id, type, status, created) is correctly populated according to `.agent/rules/documents.md`.
+3. Present summary of created tests.

package/README.md

@@ -25,7 +25,7 @@ _We encourage teams to customize these skills and define their own rules & workf
 ### 📦 Components
 
 - 🧠 **12+ Multi-domain AI Skills** - From Product Manager, Business Analyst to Lead Architect.
-- 🔄 **6 Automated Workflows** - Pre-defined, reusable work processes.
+- 🔄 **11 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.
 
@@ -139,14 +139,19 @@ Read and execute the workflow at .agent/workflows/brainstorm.md
 
 ## 🔄 Automated Workflows
 
-| 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.                    |
+| 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. |
+| **`/break-tasks`**       | Orchestrates breaking down requirements into actionable tasks for implementation.                          | When you have a PRD and need a task list.                          |
+| **`/custom-behavior`**   | Safely customize Agent rules and workflows with impact analysis and user confirmation.                     | Adjust Agent behavior or fix recurring mistakes.                   |
+| **`/debug`**             | Scientific debugging workflow: Hypothesize, Instrument, Reproduce, Analyze, Fix.                           | When facing complex bugs that need systematic analysis.            |
+| **`/development`**       | General coding workflow for implementing changes, bug fixes, or minor features.                            | Day-to-day coding tasks.                                           |
+| **`/documentation`**     | Generate comprehensive documentation (Architecture, API, Specs) from either Codebase or Requirements.      | Onboarding or creating detailed specs.                             |
+| **`/gen-tests`**         | Generate unit, E2E, security, and performance tests using the qa-tester skill.                             | Improving test coverage for new or existing code.                  |
+| **`/implement-feature`** | Orchestrates feature implementation from specification to deployment.                                      | End-to-end feature development.                                    |
+| **`/qa`**                | Create comprehensive test case documents and test plans based on project requirements.                     | Planning testing strategy for a feature.                           |
+| **`/ui-ux-design`**      | Transform requirements into comprehensive UI/UX design deliverables.                                       | After requirements are finalized, before coding.                   |
 
 ---
 

package/bin/anti-chaotic.js

@@ -4,11 +4,39 @@ const { program } = require("commander");
 const fs = require("fs-extra");
 const path = require("path");
 const chalk = require("chalk");
+const crypto = require("crypto");
+const os = require("os");
 
 program.version("0.0.1").description("Anti-Chaotic Agent Kit CLI");
 
 const REPO_URI = "kienhaminh/anti-chaotic/.agent";
 
+/**
+ * Calculates SHA-256 hash of a file
+ */
+async function getFileHash(filePath) {
+  const buffer = await fs.readFile(filePath);
+  return crypto.createHash("sha256").update(buffer).digest("hex");
+}
+
+/**
+ * Recursively gets all files in a directory
+ */
+async function getAllFiles(dirPath, baseDir = dirPath) {
+  let results = [];
+  const list = await fs.readdir(dirPath, { withFileTypes: true });
+
+  for (const item of list) {
+    const fullPath = path.join(dirPath, item.name);
+    if (item.isDirectory()) {
+      results = results.concat(await getAllFiles(fullPath, baseDir));
+    } else {
+      results.push(path.relative(baseDir, fullPath));
+    }
+  }
+  return results;
+}
+
 program
   .command("init")
   .description("Initialize the Anti-Chaotic Agent Kit (download from GitHub)")
@@ -26,22 +54,6 @@ program
         force: true,
       });
 
-      // Cleanup deprecated files
-      const deprecatedFiles = [
-        "rules/documentation.md",
-        "workflows/docs-from-codebase.md",
-        "workflows/requirement-analysis.md",
-        "workflows/setup-codebase.md",
-      ];
-
-      for (const file of deprecatedFiles) {
-        const filePath = path.join(targetAgentDir, file);
-        if (await fs.pathExists(filePath)) {
-          await fs.remove(filePath);
-          console.log(chalk.dim(`  Removed legacy file: ${file}`));
-        }
-      }
-
       console.log(
         chalk.green("✔ Successfully installed Anti-Chaotic Agent Kit."),
       );
@@ -56,56 +68,158 @@ program
   .command("update")
   .description("Update .agent configuration from GitHub")
   .action(async () => {
-    const targetAgentDir = path.join(process.cwd(), ".agent");
+    const projectRoot = process.cwd();
+    const targetAgentDir = path.join(projectRoot, ".agent");
+    const tempDir = path.join(os.tmpdir(), `anti-chaotic-update-${Date.now()}`);
     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;
-        }
+      if (!(await fs.pathExists(targetAgentDir))) {
+        console.log(
+          chalk.red("✘ .agent directory not found. Please run 'init' first."),
+        );
+        return;
       }
 
-      console.log(
-        chalk.blue(`Updating Anti-Chaotic Agent Kit from ${REPO_URI}...`),
-      );
+      console.log(chalk.blue("Checking for updates from GitHub..."));
 
       const { downloadTemplate } = await import("giget");
       await downloadTemplate(`github:${REPO_URI}`, {
-        dir: targetAgentDir,
+        dir: tempDir,
         force: true,
       });
 
-      // Cleanup deprecated files
-      const deprecatedFiles = [
-        "rules/documentation.md",
-        "workflows/docs-from-codebase.md",
-        "workflows/requirement-analysis.md",
-        "workflows/setup-codebase.md",
-      ];
-
-      for (const file of deprecatedFiles) {
-        const filePath = path.join(targetAgentDir, file);
-        if (await fs.pathExists(filePath)) {
-          await fs.remove(filePath);
-          console.log(chalk.dim(`  Removed legacy file: ${file}`));
+      const localFiles = await getAllFiles(targetAgentDir);
+      const remoteFiles = await getAllFiles(tempDir);
+
+      const modified = [];
+      const added = [];
+      const deleted = [];
+
+      // Check for modified and deleted files
+      for (const file of localFiles) {
+        const localPath = path.join(targetAgentDir, file);
+        const remotePath = path.join(tempDir, file);
+
+        if (await fs.pathExists(remotePath)) {
+          const localHash = await getFileHash(localPath);
+          const remoteHash = await getFileHash(remotePath);
+          if (localHash !== remoteHash) {
+            modified.push(file);
+          }
+        } else {
+          deleted.push(file);
         }
       }
 
-      console.log(chalk.green("✔ Successfully updated .agent from GitHub."));
-      console.log(chalk.dim(`  Location: ${targetAgentDir}`));
+      // Check for new files from remote
+      for (const file of remoteFiles) {
+        if (!localFiles.includes(file)) {
+          added.push(file);
+        }
+      }
+
+      if (modified.length === 0 && added.length === 0 && deleted.length === 0) {
+        console.log(
+          chalk.green("✔ Your .agent configuration is already up to date."),
+        );
+        await fs.remove(tempDir);
+        return;
+      }
+
+      console.log(chalk.yellow("\nUpdate Summary:"));
+
+      let filesToOverwrite = [];
+      let filesToAdd = [];
+      let filesToDelete = [];
+
+      if (modified.length > 0) {
+        const { selectedModified } = await inquirer.prompt([
+          {
+            type: "checkbox",
+            name: "selectedModified",
+            message:
+              "Select MODIFIED files to OVERWRITE (Unselected = Keep Local):",
+            choices: modified.map((f) => ({
+              name: f,
+              value: f,
+              checked: false,
+            })),
+            pageSize: 20,
+          },
+        ]);
+        filesToOverwrite = selectedModified;
+      }
+
+      if (added.length > 0) {
+        const { selectedAdded } = await inquirer.prompt([
+          {
+            type: "checkbox",
+            name: "selectedAdded",
+            message: "Select NEW files to ADD (Unselected = Skip):",
+            choices: added.map((f) => ({ name: f, value: f, checked: true })),
+            pageSize: 20,
+          },
+        ]);
+        filesToAdd = selectedAdded;
+      }
+
+      if (deleted.length > 0) {
+        const { selectedDeleted } = await inquirer.prompt([
+          {
+            type: "checkbox",
+            name: "selectedDeleted",
+            message:
+              "Select DELETED files to REMOVE locally (Unselected = Keep Local):",
+            choices: deleted.map((f) => ({ name: f, value: f, checked: true })),
+            pageSize: 20,
+          },
+        ]);
+        filesToDelete = selectedDeleted;
+      }
+
+      if (
+        filesToOverwrite.length === 0 &&
+        filesToAdd.length === 0 &&
+        filesToDelete.length === 0
+      ) {
+        console.log(chalk.yellow("No changes selected. Update cancelled."));
+        await fs.remove(tempDir);
+        return;
+      }
+
+      console.log(chalk.blue("\nApplying updates..."));
+
+      // Process Overwrites
+      for (const file of filesToOverwrite) {
+        const src = path.join(tempDir, file);
+        const dest = path.join(targetAgentDir, file);
+        await fs.copy(src, dest, { overwrite: true });
+        console.log(chalk.green(`  ✔ Overwritten: ${file}`));
+      }
+
+      // Process New Files
+      for (const file of filesToAdd) {
+        const src = path.join(tempDir, file);
+        const dest = path.join(targetAgentDir, file);
+        await fs.copy(src, dest, { overwrite: false });
+        console.log(chalk.green(`  ✔ Added: ${file}`));
+      }
+
+      // Process Deletions
+      for (const file of filesToDelete) {
+        const dest = path.join(targetAgentDir, file);
+        await fs.remove(dest);
+        console.log(chalk.red(`  ✘ Deleted: ${file}`));
+      }
+
+      console.log(chalk.green("\n✔ Selected updates applied successfully."));
+
+      // Cleanup
+      await fs.remove(tempDir);
     } catch (err) {
       console.error(chalk.red("✘ Error updating framework:"), err.message);
+      if (await fs.pathExists(tempDir)) await fs.remove(tempDir);
     }
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kienha/anti-chaotic",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Anti-Chaotic - An agent kit for Antigravity to standardize the software development process",
   "main": "index.js",
   "publishConfig": {