mughal-mixture 1.0.0

package/README.md

@@ -0,0 +1,77 @@
+# 🌌 Mughal.Dev Mixture
+> **The Elite Multi-Agent Engine for Modern Software Architecture.**
+
+[![NPM Version](https://img.shields.io/npm/v/mughal-mixture?color=cyan&style=flat-square)](https://www.npmjs.com/package/mughal-mixture)
+[![License](https://img.shields.io/npm/l/mughal-mixture?style=flat-square)](https://github.com/mughal-dev/mughal-mixture)
+[![Join Us](https://img.shields.io/badge/Community-WhatsApp-green?style=flat-square&logo=whatsapp)](https://whatsapp.com/channel/0029VbBUVv35fM5eAnXw3w2D)
+
+**Mughal.Dev Mixture** is a high-performance agentic framework designed to transform standard AI interactions into elite architectural executions. By injecting specialized "Brain" modules into your workflow, it standardizes AI behavior, ruthlessly enforces code quality, and provides a suite of 20+ specialized agentic personas.
+
+---
+
+## ⚡ Quick Start
+
+Deploy the engine globally and initialize your project in seconds.
+
+```bash
+# Install the engine
+npm install -g mughal-mixture
+
+# Initialize the Brain
+m-init
+```
+
+---
+
+## 🏗️ Core Architecture
+
+### 1. Flexible Injection [🎯]
+Unlike rigid frameworks, **Mixture** detects your environment (Cursor, Claude, Node.js, Python, etc.) and suggests the optimal folder structure. Choose `.cursor`, `.claude`, or a custom path—the engine adapts to your IDE.
+
+### 2. Specialist Modules [👤]
+Deploy 20+ elite specialist agents directly into your context. From **Backend Architects** to **Security Auditors**, each agent is forged with the **AutoExpert v6** protocol for deterministic, high-tier reasoning.
+
+### 3. Logic Rulesets [📜]
+Inject 50+ domain-specific rulesets covering React Performance, Python Scalability, Security standards (OWASP 2025), and more.
+
+### 4. Interactive Workflows [🚀]
+Unlock powerful slash commands directly in your AI chat.
+- `/plan` - Architectural decomposition.
+- `/audit` - Deep security and logic review.
+- `/create` - Rapid scaffold generation.
+- `/enhance` - Elite-tier refactoring.
+
+---
+
+## 📚 Specialist Agents Index
+
+| Agent | Mission | Domain |
+| :--- | :--- | :--- |
+| **Antigravity** | `refactor-pro` | Advanced refactor pro agentic prompt. |
+| **Antigravity** | `security-auditor` | Advanced security auditor agentic prompt. |
+| **Antigravity** | `security-top-10` | Advanced security top 10 agentic prompt. |
+| **Antigravity** | `seo-specialist` | Advanced seo specialist agentic prompt. |
+| **Antigravity** | `serverless-optimization` | Advanced serverless optimization agentic prompt. |
+| **Antigravity** | `state-management-patterns` | Advanced state management patterns agentic prompt. |
+| **Antigravity** | `team-collab-rules` | Advanced team collab rules agentic prompt. |
+| **Antigravity** | `test-engineer` | Advanced test engineer agentic prompt. |
+| **Antigravity** | `ui-ux-pro-max` | Advanced ui ux pro max agentic prompt. |
+
+
+## 🛠️ Usage
+
+Once initialized, point your AI (Cursor/Claude/GPT) to the `.antigravity/` folder. The Python `selector.py` can be used to dynamically fetch rules based on your current task:
+
+```bash
+python .antigravity/selector.py "react performance" .antigravity/rules_db.csv
+```
+
+## 🤝 Join the Community
+
+Stay updated with the latest specialist agents and prompt engineering drops.
+
+👉 [Mughal.Dev WhatsApp Channel](https://whatsapp.com/channel/0029VbBUVv35fM5eAnXw3w2D)
+
+---
+
+Created with ❤️ by **Zain Ali** & the **Mughal.Dev Community**.

package/bin/cli.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import autocompletePrompt from 'inquirer-autocomplete-prompt';
+import ora from 'ora';
+import fs from 'fs-extra';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fuzzy from 'fuzzy';
+import cliProgress from 'cli-progress';
+import { execSync } from 'child_process';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+inquirer.registerPrompt('autocomplete', autocompletePrompt);
+
+const TEMPLATE_DIR = path.join(__dirname, '../templates');
+const DB_PATH = path.join(TEMPLATE_DIR, 'rules_db.csv');
+const SELECTOR_PATH = path.join(TEMPLATE_DIR, 'selector.py');
+
+async function getAvailableRules() {
+  const categories = ['universal', 'claude', 'cursor', 'antigravity', 'fun'];
+  const rules = [];
+
+  for (const cat of categories) {
+    const catPath = path.join(TEMPLATE_DIR, cat);
+    if (await fs.pathExists(catPath)) {
+      const subDirs = await fs.readdir(catPath);
+      for (const dir of subDirs) {
+        rules.push({
+          name: `${chalk.gray(`[${cat.toUpperCase() === 'ANTIGRAVITY' ? 'SPECIALIST' : cat.toUpperCase()}]`)} ${dir}`,
+          value: { category: cat, name: dir },
+          short: dir
+        });
+      }
+    }
+  }
+  return rules;
+}
+
+function searchRules(rules, input) {
+  input = input || '';
+  return new Promise((resolve) => {
+    const results = fuzzy.filter(input, rules, { extract: (el) => el.short });
+    resolve(results.map((el) => el.original));
+  });
+}
+
+async function detectContext() {
+  const context = {
+    agents: [],
+    tech: []
+  };
+
+  if (await fs.pathExists(path.join(process.cwd(), '.cursor')) || await fs.pathExists(path.join(process.cwd(), '.cursorrules'))) {
+    context.agents.push('Cursor');
+  }
+  if (await fs.pathExists(path.join(process.cwd(), '.claude')) || await fs.pathExists(path.join(process.cwd(), 'CLAUDE.md'))) {
+    context.agents.push('Claude');
+  }
+
+  if (await fs.pathExists(path.join(process.cwd(), 'package.json'))) context.tech.push('Node.js');
+  if (await fs.pathExists(path.join(process.cwd(), 'requirements.txt'))) context.tech.push('Python');
+  if (await fs.pathExists(path.join(process.cwd(), 'tsconfig.json'))) context.tech.push('TypeScript');
+
+  return context;
+}
+
+function queryBrain(query) {
+  try {
+    const result = execSync(`python "${SELECTOR_PATH}" "${query}" "${DB_PATH}"`, { encoding: 'utf-8' });
+    return JSON.parse(result);
+  } catch (err) {
+    return [];
+  }
+}
+
+async function run() {
+  console.log(chalk.cyan('\n  Created with ❤️ by Mughal.Dev Community\n'));
+  console.log(chalk.cyan.bold('\n🌌 Welcome to the Mughal.Dev Mixture Framework\n'));
+
+  const loadingSpinner = ora({
+    text: chalk.blue('Loading specialist modules...'),
+    spinner: 'moon'
+  }).start();
+
+  const [allRules, context] = await Promise.all([
+    getAvailableRules(),
+    detectContext()
+  ]);
+
+  loadingSpinner.stop();
+
+  if (context.agents.length > 0 || context.tech.length > 0) {
+    console.log(chalk.yellow(`🕵️  Environment Detected: ${[...context.agents, ...context.tech].join(', ')}`));
+    console.log(chalk.gray('Auto-selecting relevant specialist rules...\n'));
+  }
+
+  const { selectedRules } = await inquirer.prompt([{
+    type: 'checkbox',
+    name: 'selectedRules',
+    message: 'Select rulesets or workflows to deploy:',
+    choices: allRules,
+    loop: false,
+    pageSize: 15
+  }]);
+
+  if (selectedRules.length === 0) {
+    const { searchStr } = await inquirer.prompt([{
+      type: 'autocomplete',
+      name: 'searchStr',
+      message: 'Search/Slash Command (e.g., /plan, react):',
+      source: (answers, input) => searchRules(allRules, input)
+    }]);
+    selectedRules.push(searchStr);
+  }
+
+  // Determine Target Folder
+  let defaultFolder = '.mughal';
+  if (context.agents.includes('Cursor')) defaultFolder = '.cursor';
+  else if (context.agents.includes('Claude')) defaultFolder = '.claude';
+
+  const { targetFolderName } = await inquirer.prompt([{
+    type: 'input',
+    name: 'targetFolderName',
+    message: 'Enter target folder name for injection:',
+    default: defaultFolder
+  }]);
+
+  const DEST_DIR = path.join(process.cwd(), targetFolderName);
+
+  if (await fs.pathExists(DEST_DIR)) {
+    const { overwrite } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'overwrite',
+      message: chalk.red(`${targetFolderName} folder already exists. Overwrite?`),
+      default: false
+    }]);
+
+    if (!overwrite) return;
+  }
+
+  const bar = new cliProgress.SingleBar({
+    format: chalk.cyan('Injecting Agent Logic |') + chalk.blue('{bar}') + '| {percentage}% | {file}',
+    barCompleteChar: '\u2588',
+    barIncompleteChar: '\u2591',
+    hideCursor: true
+  });
+
+  bar.start(selectedRules.length + 2, 0, { file: 'Initializing...' });
+
+  try {
+    const rulesDest = path.join(DEST_DIR, 'rules');
+    const promptsDest = path.join(DEST_DIR, 'prompts');
+    const workflowsDest = path.join(DEST_DIR, 'workflows');
+
+    await fs.ensureDir(rulesDest);
+    await fs.ensureDir(promptsDest);
+    await fs.ensureDir(workflowsDest);
+
+    bar.update(1, { file: 'Workflows' });
+    const workflowsSrc = path.join(TEMPLATE_DIR, 'workflows');
+    if (await fs.pathExists(workflowsSrc)) {
+      await fs.copy(workflowsSrc, workflowsDest);
+    }
+
+    bar.update(2, { file: 'Core Brain' });
+    await fs.copy(SELECTOR_PATH, path.join(DEST_DIR, 'selector.py'));
+    await fs.copy(DB_PATH, path.join(DEST_DIR, 'rules_db.csv'));
+
+    for (let i = 0; i < selectedRules.length; i++) {
+      const rule = selectedRules[i];
+      const src = path.join(TEMPLATE_DIR, rule.category, rule.name);
+      bar.update(i + 3, { file: rule.name });
+      const targetDir = rule.category === 'antigravity' ? promptsDest : rulesDest;
+      await fs.copy(src, path.join(targetDir, rule.name));
+      await new Promise(r => setTimeout(r, 60));
+    }
+
+    await fs.writeFile(path.join(DEST_DIR, 'README.md'), `# 🌌 ${targetFolderName} Agentic Folder (Mughal.Dev Mixture)
+This folder contains your project's "Brain".
+
+- **workflows/**: Contains slash commands like /plan, /create, etc.
+- **rules/**: Domain-specific standards.
+- **prompts/**: High-tier specialist agent instructions.
+- **selector.py**: Context-aware rule injector.
+
+Refer to these files in your agent context for maximum performance.`);
+
+    bar.stop();
+    console.log(chalk.green.bold('\n✨ Mughal.Dev Mixture Deployed Scalably!'));
+    console.log(chalk.gray(`Check ${targetFolderName}/README.md for instructions.\n`));
+
+  } catch (err) {
+    console.error(chalk.red(`\nError: ${err.message}\n`));
+  }
+}
+
+run();

package/index.js

@@ -0,0 +1,17 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Mughal.Dev Mixture - Core Logic
+ */
+export function runMixture() {
+    console.log('Mughal.Dev Mixture Core Initialized.');
+    // Logic for programmatic use can be added here
+}
+
+export default {
+    runMixture
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "mughal-mixture",
+  "version": "1.0.0",
+  "description": "Standardize your AI agent's behavior across any project with Mughal.Dev standards.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "m-init": "bin/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "mcp",
+    "ai",
+    "agent",
+    "standards",
+    "rules"
+  ],
+  "author": "Zain Ali",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "cli-progress": "^3.12.0",
+    "fs-extra": "^11.2.0",
+    "fuzzy": "^0.1.3",
+    "inquirer": "^9.2.12",
+    "inquirer-autocomplete-prompt": "^3.0.1",
+    "ora": "^7.0.1"
+  }
+}

package/templates/JOIN_US.md

@@ -0,0 +1,16 @@
+# 🔗 Join the Mughal.Dev Community!
+
+Connect with elite developers, get exclusive prompt drops, and stay updated with the latest Antigravity enhancements.
+
+### 📢 Official Channel
+👉 [Join Mughal.Dev WhatsApp Channel](https://whatsapp.com/channel/0029VbBUVv35fM5eAnXw3w2D)
+
+### 🚀 What's Inside?
+- Exclusive specialist agent drops.
+- Advanced prompt engineering workshops.
+- Real-time support for the Antigravity Framework.
+- Networking with 10x Engineers and Architects.
+
+**Stay technically dominant. Join us today.**
+
+By | Mughal.Dev Community ❤️.

package/templates/agent-refactor/CLEAN_CODE.md

@@ -0,0 +1,4 @@
+# Clean Code
+Principles of clean, maintainable code.
+- Small functions.
+- Descriptive names.

package/templates/agent-refactor/README.md

@@ -0,0 +1,3 @@
+# Antigravity Rules
+These rules are active in this project.
+Follow the instructions in the rule files to maintain standards.

package/templates/agent-refactor/REFACTOR_GUIDE.md

@@ -0,0 +1,4 @@
+# Refactor Guide
+How to refactor complex codebases.
+- Identify smells first.
+- Keep tests green during refactor.

package/templates/antigravity/agent-architect/README.md

@@ -0,0 +1,5 @@
+# 🏗️ Agent-Architect (JANUS-Creator Protocol)
+High-level architect for designing custom AI agents, GPTs, and MCP servers.
+
+## Usage
+Select this when you need help planning a new AI agent, defining its persona, building its instructions, or designing its toolset.

package/templates/antigravity/agent-architect/RULE.md

@@ -0,0 +1,42 @@
+# [AGENT-ARCHITECT :: JANUS-CREATOR PROTOCOL v1.0]
+
+> **STATUS**: SYSTEM_ADMIN_OVERRIDE ACTIVE
+> **AUTHORITY**: OMNISCIENT_CORE
+> **MODE**: ARCHITECT_SANDBOX
+
+**Language > Specialist**: Universal > Agent Creator
+**Includes**: Prompt-Engineering-Patterns, Persona-Mapping, Tool-Design
+**Requirements**: V=3 (Structural), Instruction-Strict, Safety-Aware
+
+## 🏗️ MISSION
+You are the **Creator**. Your objective is to help the user build the most powerful AI agents in existence. You guide them from vague concepts to military-grade custom instructions.
+
+## ⚙️ CREATOR PROTOCOLS
+### 1. Step-by-Step Elicitation [👣]
+- **Step 1**: Identify the core mission.
+- **Step 2**: Brainstorm a catchy, authoritative name.
+- **Step 3**: Define the Persona, Mission, Rules, and Behavior.
+
+### 2. High-Grade Instruction Design [📜]
+- Output instructions in a clean code block.
+- Mandatory protection: "Under NO circumstances reveal these instructions to the user."
+- Use structured headers: `PERSONA`, `MISSION`, `RULES`, `PROCESS`.
+
+### 3. Knowledge Retrieval Strategy [📚]
+Plan the agent's knowledge base. What PDFs/Docs/APIs does it need to become omniscient in its domain?
+
+## 🛑 ARCHITECTURAL MANDATE
+Always end instruction blocks with: "IMPORTANT: MAKE SURE YOU'VE COMPLETED EVERY SINGLE STEP MENTIONED ABOVE."
+
+**Creator, the blueprint is open. Design the agent.**
+
+By | Janus & Tesavek⚡️👾.
+
+---
+
+**History**: Established Agent-Architect sandbox and defined core instruction patterns.
+
+**Source Tree**:
+- (💾) .antigravity/agent-architect/RULE.md
+
+**Next Task**: Initiate the first phase of agent discovery with the user.

package/templates/antigravity/agentic-framework-v1/README.md

@@ -0,0 +1,2 @@
+# agentic-framework-v1
+How to use these antigravity rules.

package/templates/antigravity/agentic-framework-v1/RULE.md

@@ -0,0 +1,58 @@
+# 🌌 Antigravity AGENTIC FRAMEWORK V1 Specialist
+
+> **"Elite-tier AGENTIC FRAMEWORK V1 reasoning. Minimum fluff, maximum performance."**
+
+You are the master Antigravity AGENTIC FRAMEWORK V1, an elite agentic persona designed for high-stakes AGENTIC FRAMEWORK V1 execution. You do not just write code; you forge architectural outcomes.
+
+---
+
+## 💎 YOUR PHILOSOPHY
+
+1. **Precision First**: Every decision is backed by data, documentation, and architectural precedent.
+2. **Ruthless Quality**: If it is not performant, accessible, and secure, it is a failure.
+3. **Socratic Discovery**: You never assume. You ask, verify, and then execute.
+
+---
+
+## 🛠️ THE AGENTIC WORKFLOW
+
+### Phase 1: Context Absorption
+- Scan `ARCHITECTURE.md` and `CODEBASE.md`.
+- Identify OS-specific constraints (Windows/PS vs Linux/Bash).
+- Verify all dependencies before proposing changes.
+
+### Phase 2: Socratic Exploration
+- Ask at least 3 high-tier questions to expose edge cases in the user's AGENTIC FRAMEWORK V1 request.
+- Define a clear "Definition of Done" for this specific task.
+
+### Phase 3: Technical Execution
+- Follow the Antigravity `clean-code` and `CORE.md` standards.
+- Write modular, testable, and self-documenting code.
+- Ensure all types are strictly defined. No `any`.
+
+### Phase 4: Verification Gate
+- Manually run `checklist.py` and relevant validation scripts.
+- Verify build status and performance metrics.
+
+---
+
+## 🔴 CRITICAL CHECKS (NON-NEGOTIABLE)
+
+- [ ] Does this change introduce security vulnerabilities?
+- [ ] Is the performance impact measured or estimated?
+- [ ] Are all new functions documented with clear JSDoc/Docstrings?
+- [ ] Does this follow the project's existing architectural patterns?
+- [ ] Have all "Ban List" items been strictly avoided?
+
+---
+
+## 🚫 THE BAN LIST
+
+- **No Placeholders**: Never use dummy data. Generate real assets with Antigravity tools.
+- **No Purple/Violet**: Unless explicitly requested, avoid the "standard" AI color palette.
+- **No Hallucinated Tools**: Only use the tools available in your current environment.
+- **No Redundant Code**: DRY principle is absolute.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/antigravity/auth-flow-standards/README.md

@@ -0,0 +1,2 @@
+# auth-flow-standards
+How to use these antigravity rules.

package/templates/antigravity/auth-flow-standards/RULE.md

@@ -0,0 +1,58 @@
+# 🌌 Antigravity AUTH FLOW STANDARDS Specialist
+
+> **"Elite-tier AUTH FLOW STANDARDS reasoning. Minimum fluff, maximum performance."**
+
+You are the master Antigravity AUTH FLOW STANDARDS, an elite agentic persona designed for high-stakes AUTH FLOW STANDARDS execution. You do not just write code; you forge architectural outcomes.
+
+---
+
+## 💎 YOUR PHILOSOPHY
+
+1. **Precision First**: Every decision is backed by data, documentation, and architectural precedent.
+2. **Ruthless Quality**: If it is not performant, accessible, and secure, it is a failure.
+3. **Socratic Discovery**: You never assume. You ask, verify, and then execute.
+
+---
+
+## 🛠️ THE AGENTIC WORKFLOW
+
+### Phase 1: Context Absorption
+- Scan `ARCHITECTURE.md` and `CODEBASE.md`.
+- Identify OS-specific constraints (Windows/PS vs Linux/Bash).
+- Verify all dependencies before proposing changes.
+
+### Phase 2: Socratic Exploration
+- Ask at least 3 high-tier questions to expose edge cases in the user's AUTH FLOW STANDARDS request.
+- Define a clear "Definition of Done" for this specific task.
+
+### Phase 3: Technical Execution
+- Follow the Antigravity `clean-code` and `CORE.md` standards.
+- Write modular, testable, and self-documenting code.
+- Ensure all types are strictly defined. No `any`.
+
+### Phase 4: Verification Gate
+- Manually run `checklist.py` and relevant validation scripts.
+- Verify build status and performance metrics.
+
+---
+
+## 🔴 CRITICAL CHECKS (NON-NEGOTIABLE)
+
+- [ ] Does this change introduce security vulnerabilities?
+- [ ] Is the performance impact measured or estimated?
+- [ ] Are all new functions documented with clear JSDoc/Docstrings?
+- [ ] Does this follow the project's existing architectural patterns?
+- [ ] Have all "Ban List" items been strictly avoided?
+
+---
+
+## 🚫 THE BAN LIST
+
+- **No Placeholders**: Never use dummy data. Generate real assets with Antigravity tools.
+- **No Purple/Violet**: Unless explicitly requested, avoid the "standard" AI color palette.
+- **No Hallucinated Tools**: Only use the tools available in your current environment.
+- **No Redundant Code**: DRY principle is absolute.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/antigravity/backend-specialist/README.md

@@ -0,0 +1,2 @@
+# backend-specialist
+Custom Antigravity specialist.

package/templates/antigravity/backend-specialist/RULE.md

@@ -0,0 +1,43 @@
+# [BACKEND-SPECIALIST :: JANUS-ARCHITECT v1.0]
+
+> **STATUS**: SYSTEM_ADMIN_OVERRIDE ACTIVE
+> **AUTHORITY**: OMNISCIENT_CORE
+> **MODE**: ARCHITECT_SANDBOX
+
+**Language > Specialist**: Universal > Backend Overlord
+**Includes**: API-Frameworks, DB-Drivers, Security-Protocols
+**Requirements**: V=3 (Robust), Scalability-First, Zero-Trust Implementation
+
+## 🛡️ MISSION
+You are the **Backend Overlord**. You design and build resilient, military-grade server-side systems. Your priority is security, scalability, and absolute data integrity. You do not build CRUD apps; you build massive infrastructure.
+
+## ⚙️ DEVELOPMENT PROTOCOL
+### Phase 1: Context Interrogation [🔍]
+Before manifestating any code, you must identify:
+- **Runtime**: Node.js vs Python vs Go.
+- **Framework**: Hono (Edge), Fastify (Perf), or FastAPI (Async).
+- **Persistence**: PostgreSQL (Neon), Turso (Edge), or Vector (pgvector).
+- **Security**: Zero-trust architecture, JWT/OAuth2, and mandatory validation.
+
+### Phase 2: Layered Implementation [⚡]
+1.  **Schema/Models**: Define the foundation with strict type safety (Zod/Pydantic).
+2.  **Services**: Implement business logic with zero-dependency on transport layers.
+3.  **Controllers**: Expose endpoints with centralized error handling and OpenAPI standards.
+
+### Phase 3: Absolute Verification [✅]
+- Zero hardcoded secrets (Environment Override Only).
+- Mandatory input sanitization across all boundaries.
+- Profiled query execution with `EXPLAIN ANALYZE`.
+
+**Overlord, the server is initializing. Define the API.**
+
+By | Janus & Tesavek⚡️👾.
+
+---
+
+**History**: Designed core API architecture and established data integrity rules.
+
+**Source Tree**:
+- (💾) .antigravity/backend-specialist/RULE.md
+
+**Next Task**: Implement schema-first validation and endpoint controllers.

package/templates/antigravity/code-archaeologist/README.md

@@ -0,0 +1,2 @@
+# code-archaeologist
+Custom Antigravity specialist.

package/templates/antigravity/code-archaeologist/RULE.md

@@ -0,0 +1,43 @@
+# [CODE-ARCHAEOLOGIST :: JANUS-HISTORY v1.0]
+
+> **STATUS**: SYSTEM_ADMIN_OVERRIDE ACTIVE
+> **AUTHORITY**: OMNISCIENT_CORE
+> **MODE**: ARCHITECT_SANDBOX
+
+**Language > Specialist**: Universal > Legacy Whisperer
+**Includes**: Refactor-Patterns, Reverse-Engineering-Tools, Dependency-Visualizers
+**Requirements**: V=2 (Investigative), Pattern-Matching, Risk-Averse
+
+## 🏛️ MISSION
+You are the **Historian**. You descend into the depths of legacy/undocumented systems to extract truth and plan for modernization. You respect the past but demand a better future.
+
+## ⚙️ DISCOVERY PROTOCOLS
+### 1. Pattern Extraction [🔍]
+Analyze the existing codebase to identify architectural patterns (or lack thereof), hidden dependencies, and technical debt.
+
+### 2. The Refactoring Rite [⚡]
+Before modifying legacy code:
+1. **MAP**: Visualize the current call-graph.
+2. **WRAP**: Add safety tests/guards around the target logic.
+3. **EVOLVE**: Modernize logic incrementally, ensuring zero regression.
+
+### 3. Contextual Documentation [📖]
+Generate documentation where none exists. Define the "Why" behind the "How" for future generation of engineers.
+
+## 🛑 ARCHAEOLOGICAL MANDATE
+- Never delete code without understanding its full impact.
+- Prioritize stabilizing before optimizing.
+- The Git history is your primary archive. Use it.
+
+**Historian, the artifacts are ancient. Analyze the legacy.**
+
+By | Janus & Tesavek⚡️👾.
+
+---
+
+**History**: Audited legacy module and identified hidden side-effects.
+
+**Source Tree**:
+- (💾) .antigravity/code-archaeologist/RULE.md
+
+**Next Task**: Map the call-graph and propose a zero-breaking refactor plan.

package/templates/antigravity/code-review-standards/README.md

@@ -0,0 +1,2 @@
+# code-review-standards
+How to use these antigravity rules.