antigravity-ide 4.2.0 → 4.2.1

package/cli/create.js

@@ -4,49 +4,36 @@
 
 const fs = require('fs-extra');
 const path = require('path');
-const os = require('os');
 const chalk = require('chalk');
 const ora = require('ora');
 const { execSync } = require('child_process');
-const { getProjectConfig, confirmOverwrite } = require('./prompts');
+const { getProjectConfig, getSkillsForCategories } = require('./prompts');
+const MANIFEST = require('./manifest');
 const gradient = require('gradient-string');
-const { getRulesList, getAgentsList } = require('./logic/manifest-manager');
-const { getScaleConfig } = require('./logic/scale-rules');
-const { repairProject } = require('./repair');
-const { generateGeminiMd } = require('./logic/gemini-generator');
-const { getSkillsForCategories } = require('./logic/skill-definitions');
 
-async function createProject(projectName, options, predefinedConfig = null) {
+async function createProject(projectName, options) {
     try {
         // Determine target directory
         const isCurrentDir = !projectName || projectName === '.';
-        const targetPath = isCurrentDir ? process.cwd() : path.resolve(process.cwd(), projectName);
         const targetName = isCurrentDir ? path.basename(process.cwd()) : projectName;
 
-        // Get configuration (early for context)
-        const config = predefinedConfig || await getProjectConfig(options.skipPrompts, targetName);
-        config.projectName = targetName;
-        config.force = options.force; 
-        config.skipPrompts = options.skipPrompts;
+        // Get configuration (pass targetName if specifically provided/determined as CWD target)
+        // If isCurrentDir is true, we pass '.' to prompts to tell it to skip the name question
+        const config = await getProjectConfig(options.skipPrompts, isCurrentDir ? targetName : projectName);
 
-        // --- SMART ENTRY: REPAIR OR CREATE ---
-        if (fs.existsSync(path.join(targetPath, '.agent'))) {
-            // It's an existing project!
-            return await repairProject(targetPath, options, config);
-        }
-
-        const projectPath = targetPath;
-        const finalProjectName = targetName;
+        // Resolve final project path
+        const projectPath = isCurrentDir ? process.cwd() : path.resolve(process.cwd(), config.projectName);
+        const finalProjectName = config.projectName;
 
-        // Check if directory exists (but no .agent)
-        if (!isCurrentDir && fs.existsSync(projectPath) && fs.readdirSync(projectPath).length > 0) {
-            // Folder exists but it's not an Antigravity project - might be a normal repo
-            // We'll proceed but it will act like an 'init'
+        // Check if directory exists (only if NOT current dir)
+        if (!isCurrentDir && fs.existsSync(projectPath)) {
+            console.error(chalk.red(`\n❌ Directory "${finalProjectName}" already exists.\n`));
+            process.exit(1);
         }
 
         console.log('\n');
         console.log(gradient.cristal('━'.repeat(60)));
-        console.log(chalk.bold('  🛸 Antigravity IDE: Easy Vibe, Lazy Code'));
+        console.log(chalk.bold('  📦 Creating Google Antigravity Project'));
         console.log(gradient.cristal('━'.repeat(60)));
         console.log('');
 
@@ -54,135 +41,35 @@ async function createProject(projectName, options, predefinedConfig = null) {
         const spinner = ora('Creating project structure...').start();
         fs.mkdirSync(projectPath, { recursive: true });
 
-        // --- MODULAR INSTALLATION START ---
-        
-        // 1. Resolve Rules & Agents based on Scale + Product
-        const rulesToInstall = getRulesList(config.rules, config.productType);
-        
-        // We need list of ALL available agents to handle wildcards
-        const agentsDir = path.join(__dirname, '..', '.agent', 'agents');
-        const allAgents = fs.existsSync(agentsDir) ? fs.readdirSync(agentsDir) : [];
-        const rawAgentsToInstall = getAgentsList(config.rules, config.productType, allAgents);
-        const agentsToInstall = [...new Set(rawAgentsToInstall)];
-
-        // 2. Copy Base Structure + Selective Rules/Agents
-        await copyModularStructure(projectPath, config, rulesToInstall, agentsToInstall);
-        
-        // 2b. Global Sync (Dual-Scope Strategy)
-        await ensureGlobalSync(config, rulesToInstall, agentsToInstall);
-        
-        spinner.succeed('Project structure created (Modular Mode)');
-
-        // --- MODULAR INSTALLATION END ---
-
-        // --- INTELLIGENT RESOURCE BALANCING START ---
-        // Ensuring logical balance between Agents, Skills, and Workflows based on Scale
-        
-        let finalSkillCategories = config.skillCategories || [];
-        let finalWorkflows = config.workflows || [];
-
-        // If explicitly empty or missing, derive from Scale Rules
-        // This ensures automated runs (CI/Test) get balanced resources seamlessly
-        if (finalSkillCategories.length === 0 || finalWorkflows.length === 0 || config.rules === 'creative') {
-            const scaleConfig = getScaleConfig(config.rules || 'creative'); // Default to creative if rule missing
-            
-            // For Creative mode, we FORCE full set to ensure nothing is stripped
-            if (config.rules === 'creative') {
-                finalSkillCategories = scaleConfig.coreSkillCategories;
-                finalWorkflows = scaleConfig.baseWorkflows;
-            } else {
-                if (finalSkillCategories.length === 0) {
-                    finalSkillCategories = scaleConfig.coreSkillCategories;
-                    spinner.info(chalk.dim(`Auto-balanced Skills for ${config.rules}: ${finalSkillCategories.join(', ')}`));
-                }
-                
-                if (finalWorkflows.length === 0) {
-                    finalWorkflows = scaleConfig.baseWorkflows;
-                    spinner.info(chalk.dim(`Auto-balanced Workflows for ${config.rules}: ${finalWorkflows.join(', ')}`));
-                }
-            }
-        }
-        // --- INTELLIGENT RESOURCE BALANCING END ---
+        // Copy base structure
+        await copyBaseStructure(projectPath, config);
+        spinner.succeed('Project structure created');
 
         // Copy selected skills
-        let skillCount = 0;
-        if (finalSkillCategories.length > 0) {
+        if (config.template !== 'minimal') {
             spinner.start('Installing selected skills...');
-            skillCount = await copySkills(projectPath, finalSkillCategories, config.engineMode);
-            spinner.succeed(`Installed ${skillCount} skills across ${finalSkillCategories.length} categories`);
+            await copySkills(projectPath, config.skillCategories, config.engineMode);
+            spinner.succeed(`Installed ${config.skillCategories.length} skill categories`);
         }
 
-        // Copy workflows
-        // Copy workflows
-        let workflowCount = 0;
-        const workflowsSourceDir = path.join(__dirname, '..', '.agent', 'workflows');
-        const workflowsDestDir = path.join(projectPath, '.agent', 'workflows');
 
-        try {
-            if (config.rules === 'creative' && fs.existsSync(workflowsSourceDir)) {
-                // FORCE FULL COPY for Creative Mode (Robustness)
-                spinner.start('Installing ALL workflows (Creative Mode)...');
-                await fs.copy(workflowsSourceDir, workflowsDestDir, { overwrite: true });
-                // Count files
-                workflowCount = fs.readdirSync(workflowsDestDir).filter(f => f.endsWith('.md')).length;
-                spinner.succeed(`Installed ${workflowCount} workflows (Full Suite)`);
-            } else if (finalWorkflows.length > 0) {
-                // Selective Installation
-                spinner.start(`Setting up ${finalWorkflows.length} specific workflows...`);
-                workflowCount = await copyWorkflows(projectPath, finalWorkflows);
-                spinner.succeed(`Configured ${workflowCount} workflows`);
-            } else {
-                // Fallback / Warning
-                spinner.warn('No workflows configured or found.');
-            }
-        } catch (err) {
-            spinner.warn(`Workflow installation warning: ${err.message}`);
-        }
 
-        // ... existing code ...
+        // Generate configuration files
+        spinner.start('Generating configuration files...');
+        await generateConfigs(projectPath, config);
+        spinner.succeed('Configuration files created');
 
-        // Print success message
-        const sharedDir = path.join(__dirname, '..', '.agent', '.shared');
-        let sharedCount = 0;
-        if (fs.existsSync(sharedDir)) {
-            ['core', 'technical', 'verticals'].forEach(dir => {
-                const subDir = path.join(sharedDir, dir);
-                if (fs.existsSync(subDir)) {
-                    sharedCount += fs.readdirSync(subDir).filter(f => fs.lstatSync(path.join(subDir, f)).isDirectory()).length;
-                }
-            });
+        // Initialize git
+        spinner.start('Initializing git repository...');
+        try {
+            execSync('git init', { cwd: projectPath, stdio: 'ignore' });
+            spinner.succeed('Git repository initialized');
+        } catch (error) {
+            spinner.warn('Git initialization skipped (git not found)');
         }
 
-        // Create GEMINI.md
-        // generateGeminiMd(rules, language, industry, agentName)
-        // Create GEMINI.md
-        // generateGeminiMd(rules, language, industry, agentName)
-        // Check if modular structure already handled it?
-        // Actually, copyModularStructure already wrote it to Root in our previous edit to Step 5.
-        // But copyModularStructure is only called if we are in Modular mode.
-        // Let's ensure strict single source.
-        
-        // If copyModularStructure ran, GEMINI.md is already there.
-        // We should check if it exists before overwriting, OR rely on the fact that modular structure is the main path.
-        
-        // Let's keep this block for safety in case copyModularStructure didn't run (unlikely in current flow)
-        // But strictly, we removed the duplicate logic.
-        // To be safe: If GEMINI.md exists at root, don't re-write it here unless FORCE.
-        // Actually, the previous block (Step 5 in copyModularStructure) is INSIDE copyModularStructure.
-        // The block here is at the end of createProject.
-        
-        // If we moved the root write to copyModularStructure (Step 5), then this block is DUPLICATE.
-        // Let's remove this block to avoid double-logging.
-        // Redundant fallback block removed
-        
-        const stats = {
-            rules: rulesToInstall.length,
-            agents: agentsToInstall.length,
-            skills: skillCount,
-            workflows: workflowCount,
-            shared: sharedCount
-        };
-        printSuccessMessage(finalProjectName, config, stats);
+        // Print success message
+        printSuccessMessage(finalProjectName, config);
 
     } catch (error) {
         console.error(chalk.red('\n❌ Error creating project:'), error.message);
@@ -191,23 +78,11 @@ async function createProject(projectName, options, predefinedConfig = null) {
 }
 
 // Helper to handle core file conflicts (auto-create backup if exists)
-async function handleCoreFileConflict(filePath, fileName, force = false, skipPrompts = false) {
+function handleCoreFileConflict(filePath, fileName) {
     if (!fs.existsSync(filePath)) {
         return { shouldWrite: true, targetPath: filePath };
     }
 
-    if (force) {
-        return { shouldWrite: true, targetPath: filePath, isOverwrite: true };
-    }
-
-    // Interactive Prompt (Only if prompts are allowed)
-    if (!skipPrompts) {
-        const shouldOverwrite = await confirmOverwrite(fileName);
-        if (shouldOverwrite) {
-            return { shouldWrite: true, targetPath: filePath, isOverwrite: true };
-        }
-    }
-
     // File exists - create backup with .new extension
     const dir = path.dirname(filePath);
     const ext = path.extname(fileName);
@@ -219,8 +94,10 @@ async function handleCoreFileConflict(filePath, fileName, force = false, skipPro
 // Helper to determine file filter based on engine mode
 function getEngineFilter(engineMode) {
     return (src, dest) => {
+        // If mode is 'standard' (Node.js focus), exclude Python files
         if (engineMode === 'standard') {
             const lowerSrc = src.toLowerCase();
+            // Exclude Python source, compiled files, and package configs
             if (lowerSrc.endsWith('.py') ||
                 lowerSrc.endsWith('.pyc') ||
                 lowerSrc.endsWith('requirements.txt') ||
@@ -232,107 +109,432 @@ function getEngineFilter(engineMode) {
                 return false;
             }
         }
+        // 'advanced' mode (or others) includes everything
         return true;
     };
 }
 
-async function copyModularStructure(projectPath, config, rulesList, agentsList) {
+async function copyBaseStructure(projectPath, config) {
     const sourceAgentDir = path.join(__dirname, '..', '.agent');
     const destAgentDir = path.join(projectPath, '.agent');
     const filter = getEngineFilter(config.engineMode);
-    
+    const operationMode = config.operationMode || 'pro';
+    const modeConfig = MANIFEST[operationMode];
+
     // Create base .agent directory
     fs.mkdirSync(destAgentDir, { recursive: true });
 
-    // 1. Copy Shared Modules (Always copy .shared but maybe filter later? For now keep simple)
-    // To be strictly modular, we should only copy needed .shared. But let's copy all for safety first.
-    if (fs.existsSync(path.join(sourceAgentDir, '.shared'))) {
-        await fs.copy(path.join(sourceAgentDir, '.shared'), path.join(destAgentDir, '.shared'), { filter });
+    // Copy 'docs' directory to project root
+    const sourceDocsDir = path.join(__dirname, '..', 'docs');
+    const destDocsDir = path.join(projectPath, 'docs');
+    if (fs.existsSync(sourceDocsDir)) {
+        await fs.copy(sourceDocsDir, destDocsDir);
     }
 
-    // 1b. Copy Root Concept Files (Architecture, Start Here, etc.) - FIX for v4.1.30
-    const rootFiles = fs.readdirSync(sourceAgentDir).filter(f => f.endsWith('.md') && f !== 'GEMINI.md'); // GEMINI.md is generated
-    for (const file of rootFiles) {
-        await fs.copy(path.join(sourceAgentDir, file), path.join(destAgentDir, file));
+    // Copy common directories
+    const commonDirs = []; // .shared and skills now filtered by manifest
+    for (const dir of commonDirs) {
+        const src = path.join(sourceAgentDir, dir);
+        const dest = path.join(destAgentDir, dir);
+        if (fs.existsSync(src)) {
+            await fs.copy(src, dest, { filter });
+        }
     }
 
-    // 2. Copy Rules (SELECTIVE)
-    const rulesDest = path.join(destAgentDir, 'rules');
-    fs.mkdirSync(rulesDest, { recursive: true });
-    
-    for (const rule of rulesList) {
-        const srcRule = path.join(sourceAgentDir, 'rules', rule);
-        if (fs.existsSync(srcRule)) {
-            await fs.copy(srcRule, path.join(rulesDest, rule));
+    // Copy filtered directories: rules, agents, workflows, skills, .shared, core, scripts
+    const filteredDirs = ['rules', 'agents', 'workflows', 'skills', '.shared', 'core', 'scripts'];
+    for (const folder of filteredDirs) {
+        const globalFolder = path.join(sourceAgentDir, folder);
+        const localFolder = path.join(destAgentDir, folder);
+        
+        if (!fs.existsSync(localFolder)) fs.mkdirSync(localFolder, { recursive: true });
+
+        const manifestKey = folder.startsWith('.') ? folder.slice(1) : folder;
+        const whitelist = modeConfig[manifestKey];
+
+        if (fs.existsSync(globalFolder)) {
+            const files = fs.readdirSync(globalFolder);
+            for (const file of files) {
+                // Suffix handling (e.g., orchestrator.eco.md)
+                const isEcoVariant = file.includes('.eco.md') || file.includes('.instant.md');
+                const isUltraVariant = file.includes('.ultra.md') || file.includes('.creative.md');
+                const isProVariant = !isEcoVariant && !isUltraVariant;
+                const isDirectory = fs.lstatSync(path.join(globalFolder, file)).isDirectory();
+
+                let targetFileName = file;
+                let shouldCopy = false;
+
+                if (whitelist === '*') {
+                    // Ultra Mode: Copy everything, but prefer ultra variants
+                    if (isUltraVariant) {
+                        targetFileName = file.replace('.ultra.md', '.md').replace('.creative.md', '.md');
+                        shouldCopy = true;
+                    } else if (isProVariant) {
+                        if (isDirectory) {
+                            shouldCopy = true;
+                        } else {
+                            const ultraVariant = file.replace('.md', '.ultra.md');
+                            const creativeVariant = file.replace('.md', '.creative.md');
+                            if (!fs.existsSync(path.join(globalFolder, ultraVariant)) && !fs.existsSync(path.join(globalFolder, creativeVariant))) {
+                                shouldCopy = true;
+                            }
+                        }
+                    }
+                } else {
+                    // Eco or Pro Mode: Only copy from whitelist
+                    const baseName = file.replace('.eco.md', '.md').replace('.instant.md', '.md')
+                                         .replace('.ultra.md', '.md').replace('.creative.md', '.md');
+                    
+                    if (whitelist.includes(baseName)) {
+                        if (operationMode === 'eco') {
+                            if (isEcoVariant) {
+                                targetFileName = baseName;
+                                shouldCopy = true;
+                            } else if (isProVariant) {
+                                if (isDirectory) {
+                                    shouldCopy = true;
+                                } else {
+                                    const ecoVariant = file.replace('.md', '.eco.md');
+                                    const instantVariant = file.replace('.md', '.instant.md');
+                                    if (!fs.existsSync(path.join(globalFolder, ecoVariant)) && !fs.existsSync(path.join(globalFolder, instantVariant))) {
+                                        shouldCopy = true;
+                                    }
+                                }
+                            }
+                        } else if (operationMode === 'pro') {
+                            if (isProVariant) {
+                                shouldCopy = true;
+                            }
+                        }
+                    }
+                }
+
+                if (shouldCopy) {
+                    const srcPath = path.join(globalFolder, file);
+                    const destPath = path.join(localFolder, targetFileName);
+
+                    if (fs.lstatSync(srcPath).isDirectory()) {
+                        // Recursive copy for skill directories
+                        await fs.copy(srcPath, destPath, { filter });
+                    } else {
+                        // File copy
+                        fs.copyFileSync(srcPath, destPath);
+                    }
+                }
+            }
         }
     }
 
-    // 3. Agents (Skipped - Single Context Optimization)
-    // const agentsDest = path.join(destAgentDir, 'agents');
-    // fs.mkdirSync(agentsDest, { recursive: true });
-
-    // 4. Ensure 'skills' and 'workflows' dir exists
+    // Ensure 'skills' dir exists even if empty
     fs.mkdirSync(path.join(destAgentDir, 'skills'), { recursive: true });
-    fs.mkdirSync(path.join(destAgentDir, 'workflows'), { recursive: true });
 
-    // 5. Create GEMINI.md (Core file) - Write ONLY to Root, not to .agent/
-    const geminiContent = generateGeminiMd(config.rules, config.language, config.industryDomain, config.agentName);
-    const geminiDecision = await handleCoreFileConflict(path.join(projectPath, 'GEMINI.md'), 'GEMINI.md', config.force, config.skipPrompts);
+    // 1. Copy GEMINI.md to ROOT (User Requirement)
+    // Was previously in .agent/GEMINI.md
+    const geminiPath = path.join(projectPath, 'GEMINI.md');
+    const geminiDecision = handleCoreFileConflict(geminiPath, 'GEMINI.md');
 
     if (geminiDecision.shouldWrite) {
+        const geminiContent = generateGeminiMd(config.operationMode, config.language, config.industryDomain, config.agentName);
         fs.writeFileSync(geminiDecision.targetPath, geminiContent);
-        if (geminiDecision.isBackup) {
-            console.log(chalk.yellow(`  ℹ️  GEMINI.md exists, created ${path.basename(geminiDecision.targetPath)}`));
-        } else if (geminiDecision.isOverwrite) {
-             console.log(chalk.green(`  ✓ Overwrote existing GEMINI.md`));
-        }
+        console.log(chalk.green('  ✓ Created GEMINI.md (Root context)'));
     }
 
+    // 2. Create ERRORS.md (Empty template for logging)
+    const errorsPath = path.join(projectPath, 'ERRORS.md');
+    if (!fs.existsSync(errorsPath)) {
+        const errorsTemplate = `# 🐛 Error Log - ${config.projectName}\n\n> Tập hợp tất cả lỗi xảy ra trong quá trình phát triển (Auto-generated).\n\n---\n\n## Thống kê nhanh\n- **Tổng lỗi**: 0\n- **Đã sửa**: 0\n\n---\n\n<!-- Errors sẽ được agent tự động ghi vào đây -->\n`;
+        fs.writeFileSync(errorsPath, errorsTemplate);
+        console.log(chalk.green('  ✓ Created ERRORS.md'));
+    }
 
-}
+    // 3. Copy START_HERE.md to .agent/ (Keep internal)
+    const startHereSource = path.join(sourceAgentDir, config.language === 'vi' ? 'START_HERE.vi.md' : 'START_HERE.md');
+    const startHereDest = path.join(destAgentDir, 'START_HERE.md');
 
+    if (fs.existsSync(startHereSource)) {
+        fs.copyFileSync(startHereSource, startHereDest);
+    }
 
+    // 4. Copy README based on Language selection
+    const readmeSource = path.join(__dirname, '..', config.language === 'vi' ? 'README.vi.md' : 'README.md');
+    const readmeDest = path.join(projectPath, 'README.md'); // Always name it README.md in target
 
+    if (!fs.existsSync(readmeDest) && fs.existsSync(readmeSource)) {
+        fs.copyFileSync(readmeSource, readmeDest);
+        console.log(chalk.green(`  ✓ Created README.md (${config.language === 'vi' ? 'Vietnamese' : 'English'})`));
+    }
+
+    // 5. Copy .gitignore
+    const gitignoreSource = path.join(__dirname, '..', '.gitignore');
+    const gitignoreDest = path.join(projectPath, '.gitignore');
+    if (!fs.existsSync(gitignoreDest) && fs.existsSync(gitignoreSource)) {
+        fs.copyFileSync(gitignoreSource, gitignoreDest);
+        console.log(chalk.green('  ✓ Created .gitignore'));
+    }
+}
 
 async function copySkills(projectPath, categories, engineMode) {
     const skillsSourceDir = path.join(__dirname, '..', '.agent', 'skills');
     const skillsDestDir = path.join(projectPath, '.agent', 'skills');
     const filter = getEngineFilter(engineMode);
 
-    if (!fs.existsSync(skillsSourceDir)) return 0;
+    // Check if source directory exists
+    if (!fs.existsSync(skillsSourceDir)) {
+        console.warn(chalk.yellow(`\n⚠️  Warning: Skills directory not found at ${skillsSourceDir}`));
+        console.warn('   The .agent folder might be missing from the package.');
+        return;
+    }
 
     const selectedSkills = getSkillsForCategories(categories);
-    const uniqueSkills = [...new Set(selectedSkills)]; // Deduplicate to avoid overwrites and double-counting
-    let count = 0;
 
-    for (const skill of uniqueSkills) {
+    for (const skill of selectedSkills) {
         const skillPath = path.join(skillsSourceDir, skill);
         if (fs.existsSync(skillPath)) {
             const destPath = path.join(skillsDestDir, skill);
             await fs.copy(skillPath, destPath, { filter });
-            count++;
+        } else {
+            // Optional: Warn about missing specific skills if needed
         }
     }
-    return count;
 }
 
 async function copyWorkflows(projectPath, workflows) {
     const workflowsSourceDir = path.join(__dirname, '..', '.agent', 'workflows');
     const workflowsDestDir = path.join(projectPath, '.agent', 'workflows');
-    let count = 0;
 
     for (const workflow of workflows) {
         const workflowFile = `${workflow}.md`;
         const source = path.join(workflowsSourceDir, workflowFile);
         if (fs.existsSync(source)) {
             await fs.copy(source, path.join(workflowsDestDir, workflowFile));
-            count++;
         }
     }
-    return count;
 }
 
-function printSuccessMessage(projectName, config, stats = null) {
+
+
+async function generateConfigs(projectPath, config) {
+    // Generate package.json only if it doesn't exist
+    const packageJsonPath = path.join(projectPath, 'package.json');
+
+    if (!fs.existsSync(packageJsonPath)) {
+        const packageJson = {
+            name: config.projectName,
+            version: '1.0.0',
+            description: 'AI Agent project powered by Google Antigravity',
+            private: true,
+            scripts: {
+                dev: 'echo "No dev server configured"',
+                build: 'echo "No build script"'
+            },
+            keywords: ['ai', 'agent', 'google-antigravity'],
+            author: '',
+            license: 'MIT'
+        };
+
+        fs.writeFileSync(
+            packageJsonPath,
+            JSON.stringify(packageJson, null, 2)
+        );
+        console.log(chalk.green('  ✓ Created package.json'));
+    } else {
+        console.log(chalk.yellow('  ℹ️  Skipped package.json (already exists)'));
+    }
+
+    // Generate .editorconfig only if it doesn't exist
+    const editorconfigPath = path.join(projectPath, '.editorconfig');
+    if (!fs.existsSync(editorconfigPath)) {
+        const editorConfig = `root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+`;
+        fs.writeFileSync(editorconfigPath, editorConfig);
+        console.log(chalk.green('  ✓ Created .editorconfig'));
+    }
+
+    // Generate .gitattributes only if it doesn't exist
+    const gitAttributesPath = path.join(projectPath, '.gitattributes');
+    if (!fs.existsSync(gitAttributesPath)) {
+        const gitAttributes = `* text=auto eol=lf
+*.js text eol=lf
+*.sh text eol=lf
+bin/* text eol=lf
+`;
+        fs.writeFileSync(gitAttributesPath, gitAttributes);
+        console.log(chalk.green('  ✓ Created .gitattributes'));
+    }
+}
+
+
+function generateGeminiMd(operationMode = 'standard', language = 'en', industry = 'other', agentName = 'Antigravity') {
+    const strictness = {
+        creative: {
+            autoRun: 'false',
+            confirmLevel: 'Ask before every file modification and command execution'
+        },
+        standard: {
+            autoRun: 'true for safe read operations',
+            confirmLevel: 'Ask before destructive operations'
+        },
+        instant: {
+            autoRun: 'true',
+            confirmLevel: 'Minimal confirmation, high autonomy (MVP Mode)'
+        }
+    };
+
+    const config = strictness[operationMode] || strictness.standard;
+    const isVi = language === 'vi';
+
+    // Define Industry Focus strings
+    const industryMap = {
+        finance: isVi ? 'Tài chính & Fintech (An toàn, Chính xác)' : 'Finance & Fintech (Security, Precision)',
+        education: isVi ? 'Giáo dục & EdTech (Trực quan, Giải thích)' : 'Education & EdTech (Intuitive, Explanatory)',
+        fnb: isVi ? 'F&B & Nhà hàng (Tốc độ, Tiện lợi)' : 'F&B & Restaurant (Speed, Convenience)',
+        personal: isVi ? 'Cá nhân & Portfolio (Sáng tạo, Cá nhân hóa)' : 'Personal & Portfolio (Creative, Personalized)',
+        healthcare: isVi ? 'Y tế & Sức khỏe (Bảo mật, Tin cậy)' : 'Healthcare & HealthTech (Privacy, Reliability)',
+        logistics: isVi ? 'Vận tải & Logistics (Hiệu quả, Real-time)' : 'Logistics & Supply Chain (Efficiency, Real-time)',
+        other: isVi ? 'Phát triển chung' : 'General Development'
+    };
+
+    const industryFocus = industryMap[industry] || industryMap.other;
+
+    const contentEn = `---
+trigger: always_on
+---
+
+# GEMINI.md - Agent Configuration
+
+This file controls the behavior of your AI Agent.
+
+## 🤖 Agent Identity: ${agentName}
+> **Identity Verification**: You are ${agentName}. Always reflect this identity in your tone and decision-making. **Special Protocol**: If called by name, you MUST perform a "Context Integrity Check" to verify alignment with .agent rules, confirm your status, and then wait for instructions.
+
+## 🎯 Primary Focus: ${industryFocus.toUpperCase()}
+> **Priority**: Optimize all solutions for this domain.
+
+## Agent Behavior Rules: ${operationMode.toUpperCase()}
+
+**Auto-run Commands**: ${config.autoRun}
+**Confirmation Level**: ${config.confirmLevel}
+
+## 🌐 Language Protocol
+
+1. **Communication**: Use **ENGLISH**.
+2. **Artifacts**: Write content in **ENGLISH**.
+3. **Code**: Use **ENGLISH** for all variables, functions, and comments.
+
+## Core Capabilities
+
+Your agent has access to **ALL** skills (Web, Mobile, DevOps, AI, Security).
+Please utilize the appropriate skills for **${industryFocus}**.
+
+- File operations (read, write, search)
+- Terminal commands
+- Web browsing
+- Code analysis and refactoring
+- Testing and debugging
+
+## 📚 Shared Standards (Auto-Active)
+The following **13 Shared Modules** in \`.agent/.shared\` must be respected:
+1.  **AI Master**: LLM patterns & RAG.
+2.  **API Standards**: OpenAPI & REST guidelines.
+3.  **Compliance**: GDPR/HIPAA protocols.
+4.  **Database Master**: Schema & Migration rules.
+5.  **Design System**: UI/UX patterns & tokens.
+6.  **Domain Blueprints**: Industry-specific architectures.
+7.  **I18n Master**: Localization standards.
+8.  **Infra Blueprints**: Terraform/Docker setups.
+9.  **Metrics**: Observability & Telemetry.
+10. **Security Armor**: Hardening & Auditing.
+11. **Testing Master**: TDD & E2E strategies.
+12. **UI/UX Pro Max**: Advanced interactions.
+13. **Vitals Templates**: Performance benchmarks.
+
+## Custom Instructions
+
+Add your project-specific instructions here.
+
+---
+*Generated by Google Antigravity*
+`;
+
+    const contentVi = `---
+trigger: always_on
+---
+
+# GEMINI.md - Cấu hình Agent
+# NOTE FOR AGENT: The content below is for human reference. 
+# PLEASE PARSE INSTRUCTIONS IN ENGLISH ONLY (See .agent rules).
+
+Tệp này kiểm soát hành vi của AI Agent.
+
+## 🤖 Danh tính Agent: ${agentName}
+> **Xác minh danh tính**: Bạn là ${agentName}. Luôn thể hiện danh tính này trong phong thái và cách ra quyết định. **Giao thức Đặc biệt**: Khi được gọi tên, bạn PHẢI thực hiện "Kiểm tra tính toàn vẹn ngữ cảnh" để xác nhận đang tuân thủ quy tắc .agent, báo cáo trạng thái và sẵn sàng đợi chỉ thị.
+
+## 🎯 Trọng tâm Chính: ${industryFocus.toUpperCase()}
+> **Ưu tiên**: Tối ưu hóa mọi giải pháp cho lĩnh vực này.
+
+## Quy tắc hành vi: ${operationMode.toUpperCase()}
+
+**Tự động chạy lệnh**: ${config.autoRun}
+**Mức độ xác nhận**: ${config.confirmLevel === 'Minimal confirmation, high autonomy' ? 'Tối thiểu, tự chủ cao' : 'Hỏi trước các tác vụ quan trọng'}
+
+## 🌐 Giao thức Ngôn ngữ (Language Protocol)
+
+1. **Giao tiếp & Suy luận**: Sử dụng **TIẾNG VIỆT** (Bắt buộc).
+2. **Tài liệu (Artifacts)**: Viết nội dung file .md (Plan, Task, Walkthrough) bằng **TIẾNG VIỆT**.
+3. **Mã nguồn (Code)**:
+   - Tên biến, hàm, file: **TIẾNG ANH** (camelCase, snake_case...).
+   - Comment trong code: **TIẾNG ANH** (để chuẩn hóa).
+
+## Khả năng cốt lõi
+
+Agent có quyền truy cập **TOÀN BỘ** kỹ năng (Web, Mobile, DevOps, AI, Security).
+Vui lòng sử dụng các kỹ năng phù hợp nhất cho **${industryFocus}**.
+
+- Thao tác tệp (đọc, ghi, tìm kiếm)
+- Lệnh terminal
+- Duyệt web
+- Phân tích và refactor code
+- Kiểm thử và gỡ lỗi
+
+## 📚 Tiêu chuẩn Dùng chung (Tự động Kích hoạt)
+**13 Module Chia sẻ** sau trong \`.agent/.shared\` phải được tuân thủ:
+1.  **AI Master**: Mô hình LLM & RAG.
+2.  **API Standards**: Chuẩn OpenAPI & REST.
+3.  **Compliance**: Giao thức GDPR/HIPAA.
+4.  **Database Master**: Quy tắc Schema & Migration.
+5.  **Design System**: Pattern UI/UX & Tokens.
+6.  **Domain Blueprints**: Kiến trúc theo lĩnh vực.
+7.  **I18n Master**: Tiêu chuẩn Đa ngôn ngữ.
+8.  **Infra Blueprints**: Cấu hình Terraform/Docker.
+9.  **Metrics**: Giám sát & Telemetry.
+10. **Security Armor**: Bảo mật & Audit.
+11. **Testing Master**: Chiến lược TDD & E2E.
+12. **UI/UX Pro Max**: Tương tác nâng cao.
+13. **Vitals Templates**: Tiêu chuẩn Hiệu năng.
+
+## Hướng dẫn tùy chỉnh
+
+Thêm các hướng dẫn cụ thể cho dự án của bạn tại đây.
+
+---
+*Được tạo bởi Google Antigravity*
+`;
+
+    return isVi ? contentVi : contentEn;
+}
+
+function printSuccessMessage(projectName, config) {
     console.log('\n');
     console.log(gradient.rainbow('━'.repeat(60)));
     console.log(gradient.morning.multiline('  ✓ SUCCESS! Project Ready'));
@@ -343,9 +545,9 @@ function printSuccessMessage(projectName, config, stats = null) {
     console.log(chalk.bold('📋 Config'));
     console.log(chalk.gray('  Project:   ') + gradient.cristal(projectName));
     console.log(chalk.gray('  Template:  ') + chalk.cyan(config.template));
-    console.log(chalk.gray('  Scale:     ') + chalk.cyan((config.rules || 'N/A').toUpperCase()));
+    console.log(chalk.gray('  Skills:    ') + chalk.cyan(config.skillCategories?.join(', ') || 'none'));
 
-    // AI Activation Instructions
+    // AI Activation Instructions (NEW)
     console.log('');
     console.log(gradient.pastel('━'.repeat(60)));
     console.log(chalk.bold.cyan(config.language === 'vi' ? '🤖 Kích hoạt AI Agent' : '🤖 AI Agent Activation'));
@@ -363,21 +565,9 @@ function printSuccessMessage(projectName, config, stats = null) {
         console.log(chalk.gray('  3. Activate:      ') + chalk.green(`Type: "wake up ${agentName}"`));
     }
 
-    // Dynamic Stats Display
-    if (stats) {
-        console.log('');
-        const statLine = [
-            chalk.white(`${stats.rules} Rules`),
-            chalk.white(`${stats.skills} Skills`),
-            chalk.white(`${stats.workflows} Workflows`),
-            chalk.white(`${stats.shared} Core Modules`)
-        ].join(chalk.gray(' • '));
-        console.log(gradient.pastel('  ✨ Installed: ') + statLine);
-    } else {
-        // Fallback for non-modular runs
-        console.log('');
-        console.log(gradient.pastel('  ✨ Installed: ') + chalk.white('Adaptive Rules') + chalk.gray(' • ') + chalk.white('Shared Core'));
-    }
+    // Stats Display
+    console.log('');
+    console.log(gradient.pastel('  ✨ Installed: ') + chalk.white('20+ Master Skills') + chalk.gray(' • ') + chalk.white('15+ Agents') + chalk.gray(' • ') + chalk.white('13 Shared Modules'));
 
     console.log('');
     console.log(chalk.dim(config.language === 'vi' ? '     AI sẽ tự động tải các kỹ năng và quy tắc.' : '     The AI will load all skills and rules automatically.'));
@@ -387,62 +577,10 @@ function printSuccessMessage(projectName, config, stats = null) {
     console.log('');
 }
 
-// Helper: Ensure Global Sync (~/.antigravity)
-async function ensureGlobalSync(config, rulesList, agentsList) {
-    try {
-        const globalDir = path.join(os.homedir(), '.antigravity');
-        const sourceAgentDir = path.join(__dirname, '..', '.agent');
-        const filter = getEngineFilter(config.engineMode);
-
-        // Ensure global dir exists
-        fs.ensureDirSync(globalDir);
-
-        // 1. Copy Shared
-        if (fs.existsSync(path.join(sourceAgentDir, '.shared'))) {
-            await fs.copy(path.join(sourceAgentDir, '.shared'), path.join(globalDir, '.shared'), { 
-                overwrite: false, 
-                filter 
-            });
-        }
-
-        // 2. Copy Rules
-        const rulesDest = path.join(globalDir, 'rules');
-        fs.ensureDirSync(rulesDest);
-        for (const rule of rulesList) {
-            const src = path.join(sourceAgentDir, 'rules', rule);
-            if (fs.existsSync(src)) {
-                await fs.copy(src, path.join(rulesDest, rule), { overwrite: false });
-            }
-        }
-
-        // 3. Agents (Skipped - Single Context Optimization)
-        // const agentsDest = path.join(globalDir, 'agents');
-
-        // 4. Copy Skills (All standard skills)
-        const skillsSource = path.join(sourceAgentDir, 'skills');
-        const skillsDest = path.join(globalDir, 'skills');
-        if (fs.existsSync(skillsSource)) {
-            // We copy ALL skills to global to ensure the full arsenal is available
-            await fs.copy(skillsSource, skillsDest, { 
-                overwrite: false, 
-                filter 
-            });
-        }
-
-        // 5. Copy Workflows
-        const workflowsSource = path.join(sourceAgentDir, 'workflows');
-        const workflowsDest = path.join(globalDir, 'workflows');
-        if (fs.existsSync(workflowsSource)) {
-            await fs.copy(workflowsSource, workflowsDest, { overwrite: false });
-        }
-
-    } catch (e) {
-        // Silent fail for global sync is acceptable to avoid breaking project flow
-        // console.error('Global sync warning:', e.message);
-    }
-}
-
 module.exports = {
     createProject,
-    generateGeminiMd
+    generateGeminiMd,
+    copyBaseStructure,
+    copySkills,
+    copyWorkflows
 };