@leejungkiin/awkit 1.7.0 → 1.7.4

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@leejungkiin/awkit",
-  "version": "1.7.0",
+  "version": "1.7.4",
   "description": "Antigravity Workflow Kit v1.6 Unified AI agent orchestration system with Mindful Checkpoints.",
   "main": "bin/awk.js",
   "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
   "bin": {
     "awkit": "bin/awk.js",
     "ag": "bin/awk.js"

package/scripts/artifact-storage.js

@@ -0,0 +1,130 @@
+/**
+ * Artifact Storage Engine for AWKit
+ * Manages persistent key-value data for interactive artifacts.
+ * Saves data locally to .brain/storage.json.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const STORAGE_DIR = path.join(process.cwd(), '.brain');
+const STORAGE_FILE = path.join(STORAGE_DIR, 'storage.json');
+
+function ensureStorageDir() {
+    if (!fs.existsSync(STORAGE_DIR)) {
+        fs.mkdirSync(STORAGE_DIR, { recursive: true });
+    }
+}
+
+function loadStorage() {
+    ensureStorageDir();
+    if (!fs.existsSync(STORAGE_FILE)) {
+        return { personal: {}, shared: {} };
+    }
+    try {
+        const content = fs.readFileSync(STORAGE_FILE, 'utf8');
+        return JSON.parse(content);
+    } catch (_) {
+        return { personal: {}, shared: {} };
+    }
+}
+
+function saveStorage(data) {
+    ensureStorageDir();
+    fs.writeFileSync(STORAGE_FILE, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+function validateKey(key) {
+    if (!key || typeof key !== 'string') return 'Key must be a non-empty string.';
+    if (key.length > 200) return 'Key must be under 200 characters.';
+    if (/\s/.test(key)) return 'Key cannot contain whitespace.';
+    if (/[\/\\'"\s]/.test(key)) return 'Key cannot contain path separators or quotes.';
+    return null;
+}
+
+function cmdStorage(args) {
+    const action = args[0];
+    const key = args[1];
+    const value = args[2];
+    const isShared = args.includes('--shared');
+
+    const type = isShared ? 'shared' : 'personal';
+
+    if (!action) {
+        console.error('Usage: awkit storage <get|set|delete|list> [key] [value] [--shared]');
+        process.exit(1);
+    }
+
+    const storage = loadStorage();
+
+    switch (action.toLowerCase()) {
+        case 'set': {
+            const err = validateKey(key);
+            if (err) {
+                console.error(`Error: ${err}`);
+                process.exit(1);
+            }
+            if (value === undefined) {
+                console.error('Error: Value is required for set action.');
+                process.exit(1);
+            }
+
+            let parsedValue = value;
+            try {
+                // Try to parse if it is valid JSON
+                parsedValue = JSON.parse(value);
+            } catch (_) {
+                // Keep as raw string if parsing fails
+            }
+
+            storage[type][key] = parsedValue;
+            saveStorage(storage);
+            console.log(JSON.stringify({ key, value: parsedValue, shared: isShared }, null, 2));
+            break;
+        }
+
+        case 'get': {
+            if (!key) {
+                console.error('Error: Key is required for get action.');
+                process.exit(1);
+            }
+            const found = storage[type][key];
+            if (found === undefined) {
+                console.error(`Error: Key "${key}" not found in ${type} storage.`);
+                process.exit(1);
+            }
+            console.log(JSON.stringify({ key, value: found, shared: isShared }, null, 2));
+            break;
+        }
+
+        case 'delete': {
+            if (!key) {
+                console.error('Error: Key is required for delete action.');
+                process.exit(1);
+            }
+            if (storage[type][key] === undefined) {
+                console.error(`Error: Key "${key}" not found in ${type} storage.`);
+                process.exit(1);
+            }
+            delete storage[type][key];
+            saveStorage(storage);
+            console.log(JSON.stringify({ key, deleted: true, shared: isShared }, null, 2));
+            break;
+        }
+
+        case 'list': {
+            const prefix = key || '';
+            const keys = Object.keys(storage[type]).filter(k => k.startsWith(prefix));
+            console.log(JSON.stringify({ keys, prefix: prefix || null, shared: isShared }, null, 2));
+            break;
+        }
+
+        default:
+            console.error(`Unknown action: ${action}`);
+            process.exit(1);
+    }
+}
+
+module.exports = {
+    cmdStorage
+};

package/scripts/automation-gate.js

@@ -102,13 +102,13 @@ function checkGate(domain, action) {
         case 'git': {
             const gitConfig = automation.git;
             if (!gitConfig) {
-                return { allowed: true, config: null, reason: 'No automation.git config — default allow' };
+                return { allowed: false, config: null, reason: 'No automation.git config — default block' };
             }
-            if (action === 'commit' && gitConfig.autoCommit === false) {
-                return { allowed: false, config: gitConfig, reason: 'automation.git.autoCommit is false' };
+            if (action === 'commit' && gitConfig.autoCommit !== true) {
+                return { allowed: false, config: gitConfig, reason: 'automation.git.autoCommit is not true (default off)' };
             }
-            if (action === 'push' && gitConfig.autoPush === false) {
-                return { allowed: false, config: gitConfig, reason: 'automation.git.autoPush is false' };
+            if (action === 'push' && gitConfig.autoPush !== true) {
+                return { allowed: false, config: gitConfig, reason: 'automation.git.autoPush is not true (default off)' };
             }
             return { allowed: true, config: gitConfig, reason: 'automation.git allows this action' };
         }
@@ -166,6 +166,12 @@ function checkGate(domain, action) {
 
 // ─── Git executors ────────────────────────────────────────────────────────────
 
+/**
+ * List of generic commit messages that should be rejected.
+ * AI agents MUST provide descriptive conventional commit messages.
+ */
+const GENERIC_MSG_PATTERNS = /^(chore: update|update|wip|changes|fix|feat|chore|save|commit|auto commit|update files|chore: update files|feat\([^)]*\): update \w+)$/i;
+
 function execGitCommit(message) {
     const gate = checkGate('git', 'commit');
     if (!gate.allowed) {
@@ -174,6 +180,22 @@ function execGitCommit(message) {
         return false;
     }
 
+    // BLOCK commits without descriptive messages
+    if (!message || !message.trim()) {
+        err('🚫 COMMIT BLOCKED: No commit message provided.');
+        err('  AI MUST provide a descriptive conventional commit message.');
+        err('  Example: awkit gate git auto "feat(auth): add Google sign-in flow"');
+        return false;
+    }
+
+    if (GENERIC_MSG_PATTERNS.test(message.trim())) {
+        err(`🚫 COMMIT BLOCKED: Generic message detected — "${message}"`);
+        err('  AI MUST describe WHAT was changed and WHY.');
+        err('  ✅ Good: "feat(home): add hero banner with parallax effect"');
+        err('  ❌ Bad:  "chore: update", "feat(app): update development"');
+        return false;
+    }
+
     try {
         execRtkSync('git add -A', { stdio: 'inherit' });
         execRtkSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, { stdio: 'inherit' });
@@ -221,6 +243,17 @@ function execGitAuto(message) {
     log(`${C.cyan}${C.bold}🔒 Automation Gate — Git Auto${C.reset}`);
     dim(`  Checking .project-identity...`);
 
+    // Early exit if working tree is clean to prevent infinite recursion/loops
+    try {
+        const gitStatus = execSync('git status --porcelain', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        if (!gitStatus) {
+            ok('Working tree clean. No changes to commit or push.');
+            return true;
+        }
+    } catch (_) {
+        // Ignore errors if not in a git repo, fallback to standard execution
+    }
+
     const committed = execGitCommit(message);
     if (!committed) return false;
 
@@ -353,13 +386,13 @@ function cmdGate(args) {
         case 'git':
             switch (action) {
                 case 'commit':
-                    execGitCommit(rest.join(' ') || 'chore: update');
+                    execGitCommit(rest.join(' ') || null);
                     break;
                 case 'push':
                     execGitPush();
                     break;
                 case 'auto':
-                    execGitAuto(rest.join(' ') || 'chore: update');
+                    execGitAuto(rest.join(' ') || null);
                     break;
                 default:
                     err(`Unknown git action: ${action}`);

package/scripts/claude-plan.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+// Parse arguments
+const args = process.argv.slice(2);
+let promptFile = '';
+let outputFile = '';
+
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--prompt-file' && args[i + 1]) {
+        promptFile = args[i + 1];
+        i++;
+    } else if (args[i] === '--output' && args[i + 1]) {
+        outputFile = args[i + 1];
+        i++;
+    }
+}
+
+if (!promptFile || !outputFile) {
+    console.error('Usage: node scripts/claude-plan.js --prompt-file <file> --output <file>');
+    process.exit(1);
+}
+
+// 1. Check if claude command is available
+try {
+    execSync('which claude', { stdio: 'ignore' });
+} catch (e) {
+    console.warn('⚠️ claude CLI not found in PATH');
+    process.exit(127);
+}
+
+// 2. Check if authenticated (quick test with timeout to avoid hang)
+try {
+    execSync('claude -p "echo OK" --max-turns 1 --bare', { stdio: 'ignore', timeout: 5000 });
+} catch (e) {
+    console.warn('⚠️ claude CLI is installed but not authenticated or timed out');
+    process.exit(2);
+}
+
+// 3. Read prompt
+if (!fs.existsSync(promptFile)) {
+    console.error(`Error: Prompt file not found: ${promptFile}`);
+    process.exit(3);
+}
+
+const promptContent = fs.readFileSync(promptFile, 'utf8');
+
+// 4. Run Claude CLI
+console.log('🚀 Running planning via Claude CLI...');
+try {
+    const result = spawnSync('claude', [
+        '-p', promptContent,
+        '--model', 'claude-opus-4-8',
+        '--max-turns', '3',
+        '--output-format', 'text',
+        '--bare'
+    ], { encoding: 'utf8', timeout: 300000 }); // 5 minutes timeout
+
+    if (result.status !== 0) {
+        console.error('❌ Claude CLI exited with status:', result.status);
+        console.error(result.stderr || result.stdout);
+        process.exit(result.status || 4);
+    }
+
+    fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+    fs.writeFileSync(outputFile, result.stdout);
+    console.log(`✅ Plan successfully written to ${outputFile}`);
+    process.exit(0);
+
+} catch (err) {
+    console.error('❌ Exception during Claude execution:', err.message);
+    process.exit(5);
+}

package/scripts/dependency-manager.js

@@ -0,0 +1,210 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const https = require('https');
+const os = require('os');
+
+const HOME = os.homedir();
+const CACHE_DIR = path.join(HOME, '.gemini', 'antigravity');
+const CACHE_FILE = path.join(CACHE_DIR, '.awkit-update-cache.json');
+const CACHE_DURATION_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+// Helper colors matching AWKit style
+const C = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+    bold: '\x1b[1m'
+};
+
+function logOk(msg) { console.log(`${C.green}✅ ${msg}${C.reset}`); }
+function logWarn(msg) { console.log(`${C.yellow}⚠️  ${msg}${C.reset}`); }
+function logErr(msg) { console.log(`${C.red}❌ ${msg}${C.reset}`); }
+function logInfo(msg) { console.log(`${C.cyan}ℹ️  ${msg}${C.reset}`); }
+function logDim(msg) { console.log(`${C.gray}   ${msg}${C.reset}`); }
+
+/**
+ * Check if rtk is installed.
+ */
+function checkRtk() {
+    try {
+        execSync('which rtk', { stdio: 'ignore' });
+        return true;
+    } catch (_) {
+        return false;
+    }
+}
+
+/**
+ * Get installed rtk version.
+ */
+function getRtkVersion() {
+    try {
+        return execSync('rtk --version', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim().replace(/^rtk\s+/, '');
+    } catch (_) {
+        return null;
+    }
+}
+
+/**
+ * Check if gitnexus is installed globally or locally.
+ */
+function checkGitnexus() {
+    try {
+        execSync('which gitnexus', { stdio: 'ignore' });
+        return true;
+    } catch (_) {
+        try {
+            // Check if npx can resolve it without installing it
+            execSync('npx --no-install gitnexus --version', { stdio: 'ignore' });
+            return true;
+        } catch (_) {
+            return false;
+        }
+    }
+}
+
+/**
+ * Install RTK using optimal pathways.
+ */
+function installRtk() {
+    logInfo('Installing RTK (Rust Token Killer)...');
+    
+    // 1. Try Homebrew if on macOS
+    if (process.platform === 'darwin') {
+        try {
+            execSync('which brew', { stdio: 'ignore' });
+            logInfo('Homebrew detected, trying brew install...');
+            execSync('brew install rtk', { stdio: 'inherit' });
+            logOk('RTK installed via Homebrew.');
+            return true;
+        } catch (_) {
+            logDim('Homebrew not available or failed. Trying pre-built script installer.');
+        }
+    }
+
+    // 2. Try official curl pre-built installer
+    try {
+        logInfo('Downloading pre-built RTK binary...');
+        execSync('curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh', { stdio: 'inherit' });
+        logOk('RTK pre-built binary installed to ~/.local/bin.');
+        return true;
+    } catch (e) {
+        logDim(`Pre-built installer failed: ${e.message}. Trying Cargo compile fallback.`);
+    }
+
+    // 3. Fallback to Cargo compile
+    try {
+        execSync('which cargo', { stdio: 'ignore' });
+        logInfo('Cargo detected, compiling RTK from source...');
+        execSync('cargo install --git https://github.com/rtk-ai/rtk', { stdio: 'inherit' });
+        logOk('RTK successfully compiled and installed via Cargo.');
+        return true;
+    } catch (_) {
+        logErr('Cargo/Rust not found. Could not compile RTK.');
+    }
+
+    logErr('Failed to install RTK. Please install it manually (see https://www.rtk-ai.app/guide/getting-started/installation).');
+    return false;
+}
+
+/**
+ * Install GitNexus globally.
+ */
+function installGitnexus() {
+    logInfo('Installing GitNexus globally via npm...');
+    try {
+        execSync('npm install -g @duytransipher/gitnexus', { stdio: 'inherit' });
+        logOk('GitNexus successfully installed globally.');
+        return true;
+    } catch (e) {
+        logErr(`Failed to install GitNexus globally: ${e.message}`);
+        logDim('Try running manually: npm install -g @duytransipher/gitnexus');
+        return false;
+    }
+}
+
+/**
+ * Perform HTTPS GET request returning parsed JSON.
+ */
+function fetchJson(url) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            headers: { 'User-Agent': 'awkit-dependency-manager' },
+            timeout: 4000
+        };
+        https.get(url, options, (res) => {
+            if (res.statusCode < 200 || res.statusCode >= 300) {
+                return reject(new Error(`HTTP ${res.statusCode}`));
+            }
+            let data = '';
+            res.on('data', chunk => { data += chunk; });
+            res.on('end', () => {
+                try { resolve(JSON.parse(data)); } catch (e) { reject(e); }
+            });
+        }).on('error', reject).on('timeout', () => reject(new Error('Request timeout')));
+    });
+}
+
+/**
+ * Check updates with 24h caching.
+ */
+async function checkUpdates(currentAwkitVersion) {
+    let cache = { lastChecked: 0, latestAwkit: null, latestRtk: null };
+    
+    if (fs.existsSync(CACHE_FILE)) {
+        try {
+            cache = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
+        } catch (_) {}
+    }
+
+    const now = Date.now();
+    if (now - cache.lastChecked < CACHE_DURATION_MS && cache.latestAwkit && cache.latestRtk) {
+        return { latestAwkit: cache.latestAwkit, latestRtk: cache.latestRtk, cached: true };
+    }
+
+    logInfo('Checking for updates...');
+    let latestAwkit = cache.latestAwkit;
+    let latestRtk = cache.latestRtk;
+
+    // Check AWKit
+    try {
+        const npmData = await fetchJson('https://registry.npmjs.org/@leejungkiin/awkit/latest');
+        if (npmData && npmData.version) {
+            latestAwkit = npmData.version;
+        }
+    } catch (e) {
+        logDim(`AWKit update check failed: ${e.message}`);
+    }
+
+    // Check RTK
+    try {
+        const githubData = await fetchJson('https://api.github.com/repos/rtk-ai/rtk/releases/latest');
+        if (githubData && githubData.tag_name) {
+            latestRtk = githubData.tag_name.replace(/^v/, '');
+        }
+    } catch (e) {
+        logDim(`RTK update check failed: ${e.message}`);
+    }
+
+    // Save cache
+    cache = { lastChecked: now, latestAwkit, latestRtk };
+    try {
+        fs.mkdirSync(CACHE_DIR, { recursive: true });
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2) + '\n');
+    } catch (_) {}
+
+    return { latestAwkit, latestRtk, cached: false };
+}
+
+module.exports = {
+    checkRtk,
+    getRtkVersion,
+    checkGitnexus,
+    installRtk,
+    installGitnexus,
+    checkUpdates
+};

package/scripts/exec-rtk.js

@@ -24,19 +24,25 @@ function checkRtk() {
  * @returns {Buffer|string}
  */
 function execRtkSync(command, options = {}) {
+    const trimmed = command.trim();
+    
+    // Only compress developer commands known to be verbose
+    const eligiblePrefixes = ['git ', 'npm ', 'cargo ', 'yarn ', 'pnpm ', 'grep ', 'find ', 'awkit trello '];
+    const extendedPrefixes = ['cat ', 'curl ', 'xcodebuild ', './gradlew ', 'swift ', 'flutter ', 'dart ', 'pod ', 'brew '];
+    const allEligible = [...eligiblePrefixes, ...extendedPrefixes];
+    const isEligible = allEligible.some(prefix => trimmed.startsWith(prefix));
+
     if (!checkRtk()) {
+        if (isEligible && !options.stdio) {
+            return execSync(`${command} 2>&1 | tail -c 8000`, { ...options, shell: true });
+        }
         return execSync(command, options);
     }
 
-    const trimmed = command.trim();
     if (trimmed.startsWith('rtk ')) {
         return execSync(command, options);
     }
 
-    // Only compress developer commands known to be verbose
-    const eligiblePrefixes = ['git ', 'npm ', 'cargo ', 'yarn ', 'pnpm ', 'grep ', 'find ', 'awkit trello '];
-    const isEligible = eligiblePrefixes.some(prefix => trimmed.startsWith(prefix));
-
     if (isEligible) {
         return execSync(`rtk ${command}`, options);
     }