@leejungkiin/awkit 1.7.0 → 1.7.4

package/bin/awk.js

@@ -19,6 +19,7 @@
  *   awkit list-packs     List available skill packs
  *   awkit tg setup       Setup Telegram Bot API credentials
  *   awkit tg send        Send a message via Telegram Bot API
+ *   awkit build          Run project build command securely based on configuration
  *   awkit version        Show current version
  * 
  * Created by Kien AI
@@ -43,6 +44,11 @@ const { cmdGate } = require('../scripts/automation-gate');
 const { cmdObsidian } = require('../scripts/obsidian-sync');
 const { cmdQuota } = require('../scripts/cockpit-quota');
 const { cmdVideo } = require('../scripts/video-analyzer');
+const { cmdI18n } = require('../scripts/i18n-helper');
+const { cmdStorage } = require('../scripts/artifact-storage');
+const { cmdPipeline } = require('../scripts/multi-model-pipeline');
+const depManager = require('../scripts/dependency-manager');
+
 
 // ─── Platform Definitions ──────────────────────────────────────────────────
 
@@ -368,7 +374,7 @@ function copyDirRecursive(src, dest, options = {}) {
     const entries = fs.readdirSync(src, { withFileTypes: true });
 
     for (const entry of entries) {
-        if (entry.name === '.DS_Store') continue;
+        if (entry.name === '.DS_Store' || entry.name === '.git' || entry.name === '.venv' || entry.name === 'node_modules') continue;
 
         const srcPath = path.join(src, entry.name);
 
@@ -898,14 +904,19 @@ function cmdUpdate() {
     log(`${C.gray}   local repo:  v${AWK_VERSION}${C.reset}`);
     log('');
 
-    // 3. Already up-to-date?
-    if (npmLatest && npmLatest === installedVersion) {
-        ok(`Already on the latest version (v${installedVersion}) 🎉`);
-        return;
+    // 3. Already up-to-date or newer?
+    if (npmLatest) {
+        if (npmLatest === installedVersion) {
+            ok(`Already on the latest version (v${installedVersion}) 🎉`);
+            return;
+        } else if (isNewerVersion(installedVersion, npmLatest)) {
+            ok(`Your installed version (v${installedVersion}) is newer than the npm registry version (v${npmLatest}) 🎉`);
+            return;
+        }
     }
 
     // 4. New version available on npm → install from registry
-    if (npmLatest && npmLatest !== installedVersion) {
+    if (npmLatest && isNewerVersion(npmLatest, installedVersion)) {
         info(`Upgrading: v${installedVersion} → v${npmLatest}`);
         info('Running: npm install -g @leejungkiin/awkit');
         try {
@@ -924,13 +935,15 @@ function cmdUpdate() {
     // 5. Offline fallback: compare AWK_VERSION (local repo) vs installed
     if (installedVersion === AWK_VERSION) {
         ok(`Already on latest version (v${AWK_VERSION}) — could not verify with npm`);
-    } else {
+    } else if (isNewerVersion(AWK_VERSION, installedVersion)) {
         info(`Upgrading from v${installedVersion} → v${AWK_VERSION} (local only, npm unreachable)`);
         cmdInstall(['--update']);
+    } else {
+        ok(`Your installed version (v${installedVersion}) is newer than or equal to local repo version (v${AWK_VERSION})`);
     }
 }
 
-function cmdDoctor() {
+async function cmdDoctor() {
     log('');
     log(`${C.cyan}${C.bold}🏥 AWK Health Check${C.reset}`);
     log('');
@@ -998,16 +1011,27 @@ function cmdDoctor() {
         warn('schemas/ directory missing'); issues++;
     }
 
-    // 4.5. Check RTK Integration
-    try {
-        const { checkRtk } = require('../scripts/exec-rtk');
-        if (checkRtk()) {
-            ok('RTK (Rust Token Killer) is installed and active');
+    // 4.5. Check RTK & GitNexus Integration
+    if (depManager.checkRtk()) {
+        ok(`RTK (Rust Token Killer) is installed (v${depManager.getRtkVersion() || 'unknown'})`);
+    } else {
+        warn('RTK (Rust Token Killer) not found.');
+        if (promptYN('Would you like to install RTK automatically now?')) {
+            depManager.installRtk();
         } else {
-            warn('RTK (Rust Token Killer) not found. Run "awkit rtk setup" to optimize token usage.');
+            issues++;
+        }
+    }
+
+    if (depManager.checkGitnexus()) {
+        ok('GitNexus (Code Intelligence Indexer) is installed and active');
+    } else {
+        warn('GitNexus (Code Intelligence Indexer) not found.');
+        if (promptYN('Would you like to install GitNexus globally now?')) {
+            depManager.installGitnexus();
+        } else {
+            issues++;
         }
-    } catch (e) {
-        warn(`RTK check failed: ${e.message}`);
     }
 
     // 5. Check version
@@ -1021,6 +1045,25 @@ function cmdDoctor() {
         warn('Version file missing. Run "awkit install" first.'); issues++;
     }
 
+    // 5.5. Check Updates
+    try {
+        const updates = await depManager.checkUpdates(AWK_VERSION);
+        if (updates.latestAwkit && isNewerVersion(updates.latestAwkit, AWK_VERSION)) {
+            warn(`AWKit update available: v${updates.latestAwkit} (current: v${AWK_VERSION})`);
+        } else {
+            ok('AWKit is up-to-date');
+        }
+        
+        const currentRtk = depManager.getRtkVersion();
+        if (updates.latestRtk && currentRtk && isNewerVersion(updates.latestRtk, currentRtk)) {
+            warn(`RTK update available: v${updates.latestRtk} (current: v${currentRtk})`);
+        } else if (currentRtk) {
+            ok('RTK is up-to-date');
+        }
+    } catch (e) {
+        warn(`Update check failed: ${e.message}`);
+    }
+
     log('');
     log(`${C.bold}Runtime Profile:${C.reset}`);
     log(`  Profile: ${C.cyan}${installState.profile}${C.reset}`);
@@ -1710,15 +1753,19 @@ function cmdListPacks() {
     }
 
     for (const pack of packs) {
-        const readmePath = path.join(packsDir, pack.name, 'README.md');
         const configPath = path.join(packsDir, pack.name, 'pack.json');
+        const config = fs.existsSync(configPath) ? readJsonFile(configPath, {}) : {};
+        if (config.hidden === true) {
+            continue;
+        }
+
+        const readmePath = path.join(packsDir, pack.name, 'README.md');
         let desc = '';
         if (fs.existsSync(readmePath)) {
             const content = fs.readFileSync(readmePath, 'utf8');
             desc = content.split('\n').find(l => l.trim() && !l.startsWith('#')) || '';
         }
-        if (!desc && fs.existsSync(configPath)) {
-            const config = readJsonFile(configPath, {});
+        if (!desc) {
             desc = config.description || '';
         }
         log(`  ${C.green}${pack.name}${C.reset}  ${C.gray}${desc}${C.reset}`);
@@ -1938,6 +1985,47 @@ function cmdSync() {
     log('');
 }
 
+// ─── Build: Safe project-specific compilation ────────────────────────────────
+
+function cmdBuild() {
+    log('');
+    log(`${C.cyan}${C.bold}🔨 AWK Build Control${C.reset}`);
+    log('');
+
+    const pjPath = path.join(process.cwd(), '.project-identity');
+    const pj = readJsonFile(pjPath, {});
+
+    if (!pj.automation || !pj.automation.build) {
+        warn('No build configuration found in .project-identity under "automation.build".');
+        log('Skipping build...');
+        return;
+    }
+
+    const { enabled, command } = pj.automation.build;
+
+    if (!enabled) {
+        warn('Build is disabled for this project (automation.build.enabled is false).');
+        log('Skipping build...');
+        return;
+    }
+
+    if (!command) {
+        err('Build command is not configured in .project-identity (automation.build.command is empty).');
+        return;
+    }
+
+    info(`Running build command: ${C.bold}${command}${C.reset}`);
+    try {
+        execSync(command, { stdio: 'inherit' });
+        log('');
+        ok('Build successful!');
+    } catch (e) {
+        log('');
+        err(`Build failed: ${e.message}`);
+        process.exit(1);
+    }
+}
+
 async function cmdAdmin() {
     info('Mở Symphony Dashboard...');
     try {
@@ -2035,6 +2123,29 @@ function cmdHelp() {
     log(`${C.cyan}${C.bold}╚═══════════════════════════════════════════════════════╝${C.reset}`);
     log('');
 
+    // Project Context Detector
+    const cwd = process.cwd();
+    const identityPath = path.join(cwd, '.project-identity');
+    if (fs.existsSync(identityPath)) {
+        try {
+            const raw = fs.readFileSync(identityPath, 'utf8');
+            const identity = JSON.parse(raw);
+            const icon = identity.icon || '⚡';
+            const name = identity.projectName || 'Unnamed Project';
+            const pType = identity.projectType ? `Type: ${identity.projectType}` : 'Type: Generic';
+            
+            let bCmd = 'Disabled';
+            if (identity.automation && identity.automation.build && identity.automation.build.enabled) {
+                bCmd = identity.automation.build.command || 'Enabled';
+            }
+
+            log(`${C.cyan}👉 Active Project: ${icon} ${C.bold}${name}${C.reset}`);
+            log(`   [${pType} | Build Control: ${bCmd === 'Disabled' ? C.yellow + 'Manual' : C.green + bCmd}${C.reset}]`);
+            log(`   Run ${C.green}awkit identity${C.reset} for full configuration details.`);
+            log('');
+        } catch (_) {}
+    }
+
     // Install
     log(`${C.bold}⚙️  Setup${C.reset}`);
     log(line);
@@ -2056,6 +2167,8 @@ function cmdHelp() {
     log(`  ${C.gray}  --force${C.reset}            Overwrite existing files`);
     log(`  ${C.gray}  Generates: .project-identity, <Name>.code-workspace,${C.reset}`);
     log(`  ${C.gray}             CODEBASE.md, thiết lập router (AGENTS.md, CLAUDE.md)${C.reset}`);
+    log(`  ${C.green}identity${C.reset}            Show project identity & active configurations (alias: config)`);
+    log(`  ${C.green}build${C.reset}               Run project build based on .project-identity config`);
     log('');
 
     // Maintenance
@@ -2098,6 +2211,24 @@ function cmdHelp() {
     log(`  ${C.green}disable-pack${C.reset} <name> Uninstall a skill pack (backed up)`);
     log('');
 
+    // Storage
+    log(`${C.bold}🗄️  Storage${C.reset}`);
+    log(line);
+    log(`  ${C.green}storage set${C.reset} <key> <val>  Save key-value pair`);
+    log(`  ${C.green}storage get${C.reset} <key>        Retrieve value by key`);
+    log(`  ${C.green}storage delete${C.reset} <key>     Delete key`);
+    log(`  ${C.green}storage list${C.reset} [prefix]    List keys with optional prefix`);
+    log(`  ${C.gray}  --shared                  Access shared storage space${C.reset}`);
+    log('');
+
+    // Pipeline
+    log(`${C.bold}🔗  Pipeline${C.reset}`);
+    log(line);
+    log(`  ${C.green}pipeline plan${C.reset} <Feature>   Lập kế hoạch kiến trúc (Opus 4.6 via agy)`);
+    log(`  ${C.green}pipeline ui${C.reset} <Feature>     Thiết kế shell & GUI assets (Codex)`);
+    log(`  ${C.green}pipeline code${C.reset} <Feature>   Thực thi viết code & review (Gemini + Critic)`);
+    log('');
+
     // Trello
     log(`${C.bold}📋  Trello${C.reset}`);
     log(line);
@@ -2139,6 +2270,11 @@ function cmdHelp() {
         if (packs.length) {
             log(`  Available packs:`);
             for (const p of packs) {
+                const configPath = path.join(packsDir, p.name, 'pack.json');
+                const config = fs.existsSync(configPath) ? readJsonFile(configPath, {}) : {};
+                if (config.hidden === true) {
+                    continue;
+                }
                 const readmePath = path.join(packsDir, p.name, 'README.md');
                 let tagline = '';
                 if (fs.existsSync(readmePath)) {
@@ -2212,10 +2348,55 @@ function detectProjectType(cwd) {
     if (entries.includes('pubspec.yaml')) {
         return 'flutter';
     }
+    
+    // JS/Node project check
+    if (entries.includes('package.json')) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (pkg.bin) {
+                return 'cli';
+            }
+            if (deps['next']) {
+                return 'web-nextjs';
+            }
+            if (deps['@nestjs/core']) {
+                return 'backend-nestjs';
+            }
+            return 'node';
+        } catch (_) { /* continue */ }
+    }
+    
     // Default: generic mobile-firebase
     return 'mobile-firebase';
 }
 
+/**
+ * Get the default safe build command based on projectType.
+ */
+function getDefaultBuildCommand(projectType) {
+    switch (projectType) {
+        case 'ios':
+            return 'xcodebuild -scheme YourScheme -sdk iphonesimulator -configuration Debug';
+        case 'android':
+            return './gradlew assembleDebug';
+        case 'expo':
+            return 'npx expo prebuild';
+        case 'flutter':
+            return 'flutter build apk --debug';
+        case 'web-nextjs':
+            return 'npm run build';
+        case 'backend-nestjs':
+            return 'npm run build';
+        case 'cli':
+        case 'node':
+            return 'npm test';
+        case 'mobile-firebase':
+        default:
+            return 'npm run build';
+    }
+}
+
 /**
  * Build .project-identity object from detected type + project name.
  */
@@ -2326,6 +2507,70 @@ function buildProjectIdentity(projectName, projectType, cwd, date) {
             servicesDir: 'lib/shared/services',
             modelsDir: 'lib/shared/models',
         },
+        cli: {
+            projectType: 'cli',
+            techStack: {
+                platform: 'CLI',
+                language: 'JavaScript / TypeScript',
+                runtime: 'Node.js',
+                framework: 'Vanilla NodeJS',
+                testing: 'Jest / doctor',
+            },
+            codingStandards: { language: 'en', namingConvention: 'camelCase', indentation: 'spaces-4', lineLength: 120 },
+            architecture: 'Modular',
+            featuresDir: 'src/commands',
+            sharedUIDir: 'src/ui',
+            servicesDir: 'src/services',
+            modelsDir: 'src/models',
+        },
+        node: {
+            projectType: 'node',
+            techStack: {
+                platform: 'NodeJS Backend/App',
+                language: 'JavaScript / TypeScript',
+                runtime: 'Node.js',
+                testing: 'Jest',
+            },
+            codingStandards: { language: 'en', namingConvention: 'camelCase', indentation: 'spaces-4', lineLength: 120 },
+            architecture: 'Modular',
+            featuresDir: 'src/features',
+            sharedUIDir: 'src/views',
+            servicesDir: 'src/services',
+            modelsDir: 'src/models',
+        },
+        'web-nextjs': {
+            projectType: 'web-nextjs',
+            techStack: {
+                platform: 'Web',
+                language: 'TypeScript / JavaScript',
+                framework: 'Next.js',
+                styling: 'Tailwind CSS / CSS Modules',
+                stateManagement: 'Zustand / Redux Toolkit / React Context',
+                networking: 'Axios / Fetch',
+            },
+            codingStandards: { language: 'en', namingConvention: 'camelCase', indentation: 'spaces-2', lineLength: 100 },
+            architecture: 'App Router / Pages Router',
+            featuresDir: 'src/app',
+            sharedUIDir: 'src/components',
+            servicesDir: 'src/services',
+            modelsDir: 'src/models',
+        },
+        'backend-nestjs': {
+            projectType: 'backend-nestjs',
+            techStack: {
+                platform: 'Backend',
+                language: 'TypeScript',
+                framework: 'NestJS',
+                database: 'PostgreSQL / MySQL / MongoDB',
+                orm: 'Prisma / TypeORM / Mongoose',
+            },
+            codingStandards: { language: 'en', namingConvention: 'camelCase', indentation: 'spaces-2', lineLength: 100 },
+            architecture: 'Controller-Service-Repository',
+            featuresDir: 'src/modules',
+            sharedUIDir: 'src/common',
+            servicesDir: 'src/services',
+            modelsDir: 'src/models',
+        },
     };
 
     // Fallback: generic mobile-firebase
@@ -2394,6 +2639,10 @@ function buildProjectIdentity(projectName, projectType, cwd, date) {
                 "pixel-mcp": {
                     enabled: false
                 }
+            },
+            build: {
+                enabled: false,
+                command: getDefaultBuildCommand(projectType)
             }
         },
         modelPolicy: {
@@ -2637,6 +2886,10 @@ async function cmdInit(forceFlag = false) {
                     "pixel-mcp": {
                         enabled: false
                     }
+                },
+                build: {
+                    enabled: false,
+                    command: getDefaultBuildCommand(projectType)
                 }
             };
             fs.writeFileSync(identityPath, JSON.stringify(currentIdentity, null, 2) + '\n');
@@ -2657,6 +2910,18 @@ async function cmdInit(forceFlag = false) {
                 currentIdentity.automation.mcp = { "pixel-mcp": { enabled: false } };
                 changed = true;
             }
+            if (!currentIdentity.projectType) {
+                currentIdentity.projectType = projectType;
+                changed = true;
+            }
+            if (!currentIdentity.automation.build) {
+                const detectedType = currentIdentity.projectType || projectType || 'mobile-firebase';
+                currentIdentity.automation.build = { 
+                    enabled: false, 
+                    command: getDefaultBuildCommand(detectedType) 
+                };
+                changed = true;
+            }
             if (!currentIdentity.modelPolicy) {
                 currentIdentity.modelPolicy = {
                     mode: "auto",
@@ -2841,17 +3106,20 @@ Additional project context can be found in:
         ).trim();
 
         if (hasSource) {
-            execSync('npx -y gitnexus analyze', {
+            const usePnpm = fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'));
+            const indexCmd = usePnpm ? 'pnpm dlx gitnexus analyze' : 'npx -y gitnexus analyze';
+            info(`Running index with: ${indexCmd}...`);
+            execSync(indexCmd, {
                 cwd,
                 stdio: 'ignore',
             });
             ok('GitNexus index created (.gitnexus/)');
         } else {
-            dim('No source files found — skipping GitNexus index (run later: npx gitnexus analyze)');
+            dim('No source files found — skipping GitNexus index (run later: pnpm dlx gitnexus analyze or npx gitnexus analyze)');
         }
     } catch (e) {
         warn(`GitNexus indexing failed: ${e.message}`);
-        dim('Run manually later: npx gitnexus analyze');
+        dim('Run manually later: pnpm dlx gitnexus analyze or npx gitnexus analyze');
     }
 
     // ── 6. Summary ─────────────────────────────────────────────────────────────
@@ -2866,9 +3134,10 @@ Additional project context can be found in:
     dim(`GitNexus:   code intelligence index`);
     log('');
     log(`${C.cyan}👉 Open ${workspaceName} in VS Code to get started.${C.reset}`);
+    log(`${C.cyan}👉 Run '/init' in AI chat to activate Smart Ecosystem Setup (SAEE) & recommendations.${C.reset}`);
     log(`${C.cyan}👉 Run '/codebase-sync' in AI chat to keep CODEBASE.md updated.${C.reset}`);
     log(`${C.cyan}👉 Run 'symphony task list' to manage tasks.${C.reset}`);
-    log(`${C.cyan}👉 Run 'npx gitnexus analyze' after major changes to refresh index.${C.reset}`);
+    log(`${C.cyan}👉 Run 'pnpm dlx gitnexus analyze' (or 'npx gitnexus analyze') after major changes to refresh index.${C.reset}`);
     log('');
 
     // ── 7. Open Documentation ───────────────────────────────────────────────────
@@ -3520,41 +3789,90 @@ function cmdTrello(args) {
     }
 }
 
-// ─── Auto-Update Checker ──────────────────────────────────────────────────────
-
-function checkAutoUpdate() {
-    const checkFile = path.join(TARGETS.antigravity, '.awk_update_check');
-    const now = Date.now();
-    const ONEDAY = 24 * 60 * 60 * 1000;
+/**
+ * Helper to check if semantic version `latest` is newer than `current`.
+ */
+function isNewerVersion(latest, current) {
+    if (!latest || !current) return false;
+    const clean = v => v.replace(/^v/, '');
+    const lClean = clean(latest);
+    const cClean = clean(current);
+    if (lClean === cClean) return false;
+
+    const parse = v => {
+        const parts = v.split('-');
+        const numbers = parts[0].split('.').map(Number);
+        const prerelease = parts[1] ? parts[1].split('.') : [];
+        return { numbers, prerelease };
+    };
 
-    if (fs.existsSync(checkFile)) {
-        try {
-            const lastCheck = parseInt(fs.readFileSync(checkFile, 'utf8'), 10);
-            if (!isNaN(lastCheck) && (now - lastCheck < ONEDAY)) {
-                return; // already checked recently
-            }
-        } catch (_) { }
+    const l = parse(lClean);
+    const c = parse(cClean);
+
+    // Compare main version numbers
+    for (let i = 0; i < 3; i++) {
+        const ln = l.numbers[i] || 0;
+        const cn = c.numbers[i] || 0;
+        if (ln > cn) return true;
+        if (ln < cn) return false;
+    }
+
+    const lIsPrerelease = l.prerelease.length > 0;
+    const cIsPrerelease = c.prerelease.length > 0;
+
+    if (lIsPrerelease && !cIsPrerelease) return false;
+    if (!lIsPrerelease && cIsPrerelease) return true;
+
+    const maxLength = Math.max(l.prerelease.length, c.prerelease.length);
+    for (let i = 0; i < maxLength; i++) {
+        const lp = l.prerelease[i];
+        const cp = c.prerelease[i];
+        if (lp === undefined) return false;
+        if (cp === undefined) return true;
+        const lpNum = parseInt(lp, 10);
+        const cpNum = parseInt(cp, 10);
+        const lpIsNum = !isNaN(lpNum);
+        const cpIsNum = !isNaN(cpNum);
+        if (lpIsNum && cpIsNum) {
+            if (lpNum > cpNum) return true;
+            if (lpNum < cpNum) return false;
+        } else if (lpIsNum) {
+            return false;
+        } else if (cpIsNum) {
+            return true;
+        } else {
+            if (lp > cp) return true;
+            if (lp < cp) return false;
+        }
     }
+    return false;
+}
 
-    // Touch the file so we don't retry immediately on failure
-    try { fs.writeFileSync(checkFile, now.toString()); } catch (_) { }
+// ─── Auto-Update Checker ──────────────────────────────────────────────────────
 
-    // Check for update using npm registry
+async function checkAutoUpdate() {
     try {
-        const output = execSync('npm view @leejungkiin/awkit version', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 });
-        const npmVersion = output.trim();
-
-        // Simple string comparison for versions like "1.0.0" (Assumes SemVer)
-        if (npmVersion && npmVersion !== AWK_VERSION) {
+        const updates = await depManager.checkUpdates(AWK_VERSION);
+        if (updates.latestAwkit && isNewerVersion(updates.latestAwkit, AWK_VERSION)) {
             log('');
-            log(`${C.yellow}${C.bold}🌟 [Thông báo] Có phiên bản mới cho AWKit! (v${npmVersion})${C.reset}`);
+            log(`${C.yellow}${C.bold}🌟 [Thông báo] Có phiên bản mới cho AWKit! (v${updates.latestAwkit})${C.reset}`);
             log(`${C.gray}   Phiên bản hiện tại: v${AWK_VERSION}${C.reset}`);
             log(`${C.gray}   Chạy lệnh sau để nâng cấp:${C.reset}`);
             log(`${C.cyan}   npm i -g @leejungkiin/awkit && awkit install${C.reset}`);
             log('');
         }
+        
+        const currentRtk = depManager.getRtkVersion();
+        if (updates.latestRtk && currentRtk && isNewerVersion(updates.latestRtk, currentRtk)) {
+            log('');
+            log(`${C.yellow}${C.bold}🌟 [Thông báo] Có phiên bản mới cho RTK! (v${updates.latestRtk})${C.reset}`);
+            log(`${C.gray}   Phiên bản hiện tại: v${currentRtk}${C.reset}`);
+            log(`${C.gray}   Chạy lệnh sau để nâng cấp:${C.reset}`);
+            log(`${C.cyan}   awkit rtk setup${C.reset}`);
+            log('');
+        }
     } catch (_) {
-        // Fail silently (offline, npm not installed, package not published yet)
+        // Fail silently in auto check
     }
 }
 
@@ -3585,7 +3903,7 @@ function cmdGitnexus(args) {
             const registry = readGitnexusRegistry();
             if (registry.length === 0) {
                 info('No GitNexus indexed repositories found.');
-                dim('Run `npx gitnexus analyze` in a project to index it.');
+                dim('Run `pnpm dlx gitnexus analyze` or `npx gitnexus analyze` in a project to index it.');
                 return;
             }
 
@@ -3618,7 +3936,7 @@ function cmdGitnexus(args) {
 
             if (!match) {
                 warn('Current directory is not indexed by GitNexus.');
-                dim('Run `npx gitnexus analyze` to index this project.');
+                dim('Run `pnpm dlx gitnexus analyze` or `npx gitnexus analyze` to index this project.');
                 return;
             }
 
@@ -3644,7 +3962,7 @@ function cmdGitnexus(args) {
             if (stale) {
                 log('');
                 warn(`Index is ${ageDays} days old. Consider refreshing:`);
-                dim('  npx gitnexus analyze');
+                dim('  pnpm dlx gitnexus analyze  (or npx gitnexus analyze)');
             }
 
             // Show projectId from .project-identity if available
@@ -3868,43 +4186,77 @@ async function cmdRtkSetup() {
     log(`${C.cyan}${C.bold}║          ⚙️  RTK Auto-Setup & Configuration           ║${C.reset}`);
     log(`${C.cyan}${C.bold}╚═══════════════════════════════════════════════════════╝${C.reset}`);
 
-    log(`\nChecking dependencies...`);
-    try {
-        execSync('which cargo', { stdio: 'ignore' });
-        ok('Cargo is installed.');
-    } catch (_) {
-        err('Cargo/Rust not found. Please install Rust (https://rustup.rs/) and retry.');
-        return;
-    }
-
-    log(`\nInstalling RTK (Rust Token Killer) via Cargo...`);
-    try {
-        execSync('cargo install --git https://github.com/rtk-ai/rtk', { stdio: 'inherit' });
-        ok('RTK successfully installed/updated via Cargo.');
-    } catch (e) {
-        err(`Failed to install RTK: ${e.message}`);
-        return;
-    }
+    const installed = depManager.installRtk();
+    if (!installed) return;
 
     const zshrcPath = path.join(HOME, '.zshrc');
     log(`\nConfiguring Shell Aliases in ~/.zshrc...`);
     if (fs.existsSync(zshrcPath)) {
-        const zshrc = fs.readFileSync(zshrcPath, 'utf8');
-        const aliasBlock = `
-# RTK Alias for AI Agents (AWKit)
-alias git="rtk git"
-alias npm="rtk npm"
-alias pnpm="rtk pnpm"
-alias yarn="rtk yarn"
-alias cargo="rtk cargo"
+        let zshrc = fs.readFileSync(zshrcPath, 'utf8');
+        
+        // Clean up old aliases to avoid collision
+        const oldAliases = [
+            'alias git="rtk git"',
+            'alias npm="rtk npm"',
+            'alias pnpm="rtk pnpm"',
+            'alias yarn="rtk yarn"',
+            'alias cargo="rtk cargo"'
+        ];
+        for (const oldAlias of oldAliases) {
+            if (zshrc.includes(oldAlias)) {
+                zshrc = zshrc.replace(new RegExp(`\\n?${oldAlias}\\n?`, 'g'), '\n');
+            }
+        }
+
+        const functionBlock = `
+# RTK Integration for AI Agents (AWKit)
+unalias npm pnpm yarn cargo git 2>/dev/null
+npm() {
+    if [[ "$1" == "login" || "$1" == "adduser" || "$1" == "publish" ]]; then
+        command npm "$@"
+    else
+        rtk npm "$@"
+    fi
+}
+pnpm() {
+    if [[ "$1" == "login" || "$1" == "publish" ]]; then
+        command pnpm "$@"
+    else
+        rtk pnpm "$@"
+    fi
+}
+yarn() {
+    if [[ "$1" == "login" || "$1" == "publish" ]]; then
+        command yarn "$@"
+    else
+        rtk yarn "$@"
+    fi
+}
+cargo() {
+    if [[ "$1" == "login" || "$1" == "publish" ]]; then
+        command cargo "$@"
+    else
+        rtk cargo "$@"
+    fi
+}
+git() {
+    if [[ "$1" == "rebase" ]]; then
+        command git "$@"
+    else
+        rtk git "$@"
+    fi
+}
 `;
-        if (zshrc.includes('alias git="rtk git"')) {
-            ok('Aliases already present in ~/.zshrc.');
-        } else {
-            fs.appendFileSync(zshrcPath, aliasBlock, 'utf8');
-            ok('Shell aliases successfully added to ~/.zshrc.');
-            log(`\n${C.cyan}Please reload your shell (source ~/.zshrc) to apply shifts.${C.reset}`);
+        // Clean up old RTK integration block if exists to allow updating
+        if (zshrc.includes('# RTK Integration for AI Agents (AWKit)')) {
+            const startIdx = zshrc.indexOf('# RTK Integration for AI Agents (AWKit)');
+            zshrc = zshrc.substring(0, startIdx);
         }
+        
+        zshrc += functionBlock;
+        fs.writeFileSync(zshrcPath, zshrc, 'utf8');
+        ok('Shell wrappers successfully added/updated in ~/.zshrc.');
+        log(`\n${C.cyan}Please reload your shell (source ~/.zshrc) to apply shifts.${C.reset}`);
     } else {
         warn('~/.zshrc not found. Skipping alias setup.');
     }
@@ -3920,6 +4272,130 @@ async function cmdRtk(args) {
     }
 }
 
+// ─── Project Identity CLI View ───────────────────────────────────────────────
+
+function cmdIdentity(args = []) {
+    const cwd = process.cwd();
+    const identityPath = path.join(cwd, '.project-identity');
+
+    if (!fs.existsSync(identityPath)) {
+        err('No .project-identity found in the current directory.');
+        log(`  Run ${C.cyan}awkit init${C.reset} to create one for this project.`);
+        return;
+    }
+
+    try {
+        const raw = fs.readFileSync(identityPath, 'utf8');
+        const identity = JSON.parse(raw);
+
+        // Handle specific field querying
+        if (args.length > 0) {
+            const query = args[0];
+
+            if (query === '--keys') {
+                console.log(Object.keys(identity).join('\n'));
+                return;
+            }
+
+            if (query === '--json') {
+                console.log(JSON.stringify(identity, null, 2));
+                return;
+            }
+
+            // Helper to get nested value by dot notation (e.g., automation.build.enabled)
+            const getNested = (obj, path) => {
+                return path.split('.').reduce((acc, part) => acc && acc[part], obj);
+            };
+
+            const val = getNested(identity, query);
+            if (val !== undefined) {
+                if (typeof val === 'object') {
+                    console.log(JSON.stringify(val));
+                } else {
+                    console.log(val);
+                }
+            }
+            return; // Exit silently if undefined, ideal for bash scripts
+        }
+
+        const border = `${C.cyan}${C.bold}╔═══════════════════════════════════════════════════════╗${C.reset}`;
+        const bottom = `${C.cyan}${C.bold}╚═══════════════════════════════════════════════════════╝${C.reset}`;
+        const line = `${C.gray}${'─'.repeat(56)}${C.reset}`;
+
+        log('');
+        log(border);
+        log(`${C.cyan}${C.bold}║ 🆔  PROJECT IDENTITY: ${C.green}${C.bold}${String(identity.projectName || 'Unnamed Project').padEnd(30)}${C.cyan}${C.bold} ║${C.reset}`);
+        log(bottom);
+        log('');
+
+        // Basic Info
+        log(`${C.bold}ℹ️   Basic Information${C.reset}`);
+        log(line);
+        log(`  ${C.bold}Project Stage:${C.reset}      ${identity.projectStage || 'development'}`);
+        log(`  ${C.bold}Project Type:${C.reset}       ${identity.projectType ? C.green + identity.projectType + C.reset : C.yellow + 'Not configured' + C.reset}`);
+        log(`  ${C.bold}Primary Lang:${C.reset}       ${identity.primaryLanguage || 'en'}`);
+        if (identity.techStack) {
+            const rt = Array.isArray(identity.techStack.runtime) ? identity.techStack.runtime.join(', ') : 'N/A';
+            const lang = Array.isArray(identity.techStack.languages) ? identity.techStack.languages.join(', ') : 'N/A';
+            log(`  ${C.bold}Runtime/Lang:${C.reset}       ${rt} / ${lang}`);
+        }
+        log('');
+
+        // Build Configuration
+        log(`${C.bold}🛠️   Build & Run Control${C.reset}`);
+        log(line);
+        if (identity.automation && identity.automation.build) {
+            const b = identity.automation.build;
+            const statusStr = b.enabled ? `${C.green}Enabled (Safe Auto-Run via awkit build)${C.reset}` : `${C.yellow}Disabled / Manual Only${C.reset}`;
+            log(`  ${C.bold}Build Control:${C.reset}      ${statusStr}`);
+            log(`  ${C.bold}Build Command:${C.reset}      ${C.cyan}${b.command || 'N/A'}${C.reset}`);
+        } else {
+            log(`  ${C.bold}Build Control:${C.reset}      ${C.yellow}Not Configured (Manual Mode)${C.reset}`);
+        }
+        log('');
+
+        // Automation Gates
+        log(`${C.bold}🔒  Automation & Sync Gates${C.reset}`);
+        log(line);
+        if (identity.automation) {
+            const git = identity.automation.git || {};
+            log(`  ${C.bold}Git AutoCommit:${C.reset}     ${git.autoCommit ? C.green + 'true' : C.red + 'false'}${C.reset}`);
+            log(`  ${C.bold}Git AutoPush:${C.reset}       ${git.autoPush ? C.green + 'true' : C.red + 'false'}${C.reset}`);
+
+            const trello = identity.automation.trello || {};
+            const syncStr = trello.enabled 
+                ? `${C.green}Enabled${C.reset} (AutoSync: ${trello.autoSync ? C.green + 'true' : C.red + 'false'}${C.reset})`
+                : `${C.red}Disabled${C.reset}`;
+            log(`  ${C.bold}Trello Sync:${C.reset}        ${syncStr}`);
+            if (identity.trello) {
+                log(`  ${C.bold}Trello Board:${C.reset}       ${identity.trello.board || 'N/A'}`);
+                log(`  ${C.bold}Trello Card:${C.reset}        ${identity.trello.card || 'N/A'}`);
+            }
+
+            const tg = identity.automation.telegram || {};
+            const tgStr = tg.enabled ? `${C.green}Enabled${C.reset}` : `${C.red}Disabled${C.reset}`;
+            log(`  ${C.bold}Telegram Alerts:${C.reset}    ${tgStr}`);
+            if (tg.triggers) {
+                const trigs = Object.keys(tg.triggers).filter(k => tg.triggers[k]).join(', ');
+                log(`  ${C.bold}Alert Triggers:${C.reset}     ${C.gray}${trigs || 'None'}${C.reset}`);
+            }
+        }
+        log('');
+
+        // Caveman Mode
+        if (identity.communication && identity.communication.cavemanMode) {
+            const cm = identity.communication.cavemanMode;
+            log(`${C.bold}💬  Communication Mode${C.reset}`);
+            log(line);
+            log(`  ${C.bold}Caveman Mode:${C.reset}       ${cm.enabled ? C.green + 'Enabled (' + cm.level + ')' : C.red + 'Disabled'}${C.reset}`);
+            log('');
+        }
+
+    } catch (e) {
+        err(`Failed to parse .project-identity: ${e.message}`);
+    }
+}
+
 // ─── Native HTTP Server ───────────────────────────────────────────────────────
 
 function cmdServe(args) {
@@ -4014,13 +4490,14 @@ function cmdServe(args) {
 
 // ─── Main ────────────────────────────────────────────────────────────────────
 
-// Check for updates (max once per day) before continuing
-checkAutoUpdate();
-
 const [, , command, ...args] = process.argv;
 
 (async () => {
+    await checkAutoUpdate();
     switch (command) {
+        case 'build':
+            cmdBuild();
+            break;
         case 'init':
             await cmdInit(args.includes('--force'));
             break;
@@ -4043,7 +4520,13 @@ const [, , command, ...args] = process.argv;
             cmdHarvest(args.includes('--dry-run'));
             break;
         case 'doctor':
-            cmdDoctor();
+            await cmdDoctor();
+            break;
+        case 'storage':
+            cmdStorage(args);
+            break;
+        case 'pipeline':
+            cmdPipeline(args);
             break;
         case 'browser':
             cmdBrowser(args);
@@ -4094,6 +4577,10 @@ const [, , command, ...args] = process.argv;
         case 'rtk':
             await cmdRtk(args);
             break;
+        case 'i18n':
+            await cmdI18n(args);
+            break;
+
         case 'gitnexus':
         case 'gn':
             cmdGitnexus(args);
@@ -4116,6 +4603,11 @@ const [, , command, ...args] = process.argv;
         case 'restart':
             await cmdRestart();
             break;
+        case 'identity':
+        case 'config':
+        case 'project':
+            cmdIdentity(args);
+            break;
         case 'help':
         case '--help':
         case '-h':