@leejungkiin/awkit 1.1.2 → 1.1.4

package/README.md

@@ -1,6 +1,6 @@
-# AWKit — Antigravity Workflow Kit v1.0
+# AWKit — Antigravity Workflow Kit v1
 
-> **v1.0.0** · Single Source of Truth · Symphony-First · Ambient Memory
+> **v1.1.4** · Single Source of Truth · Symphony-First · Ambient Memory
 
 AWKit là framework điều phối AI agent chuyên nghiệp. Đây là **nơi duy nhất** chứa toàn bộ workflows, skills, GEMINI.md và cấu hình — không còn phân tán giữa nhiều repo.
 
@@ -22,6 +22,7 @@ awkit doctor
 |---------|-------------|
 | `awkit install` | Deploy AWKit vào `~/.gemini/antigravity/` |
 | `awkit update` | Update lên version mới nhất |
+| `awkit init` | Khởi tạo project mới (tạo .project-identity, CODEBASE.md, etc.) |
 | `awkit sync` | Full sync: harvest + install (one shot) |
 | `awkit status` | So sánh repo vs installed (diff view) |
 | `awkit harvest` | Pull từ `~/.gemini/antigravity/` về repo |
@@ -29,6 +30,8 @@ awkit doctor
 | `awkit enable-pack <name>` | Kích hoạt skill pack |
 | `awkit disable-pack <name>` | Vô hiệu skill pack |
 | `awkit list-packs` | Xem danh sách skill packs |
+| `awkit tg setup` | Cài đặt Telegram Bot Token, Chat ID & Topic |
+| `awkit tg send <msg>` | Gửi tin nhắn qua Telegram |
 | `awkit version` | Show version |
 
 ### Typical Workflow
@@ -47,13 +50,13 @@ awkit install
 awkit sync
 
 # 3. Commit the snapshot
-git add -A && git commit -m "chore: sync AWKit v7.0"
+git add -A && git commit -m "chore: sync AWKit v1.1.3"
 ```
 
 
 
 ```
-main-awf/ (AWKit v7.0 — Source of Truth)
+main-awf/ (AWKit v1.1.x — Source of Truth)
 ├── bin/
 │   ├── awk.js                  ← CLI entry point
 │   └── awf.js                  ← (legacy, kept for reference)
@@ -86,7 +89,7 @@ main-awf/ (AWKit v7.0 — Source of Truth)
 ├── templates/                  ← Project templates
 ├── scripts/
 │   └── harvest.js              ← Migration: pull from ~/.gemini/
-├── VERSION                     → 1.0.0
+├── VERSION                     → 1.1.3
 └── package.json                (@leejungkiin/awkit)
 ```
 
@@ -114,6 +117,21 @@ main-awf/ (edit here)
 Gemini / Claude / Any AI
 ```
 
+## 📨 Telegram Integration
+
+Bạn có thể cấu hình AWKit gửi thông báo tự động (deploy xong, test pass...) qua Telegram:
+
+```bash
+# 1. Setup Bot Token, Chat ID và Message Thread ID (Topic)
+awkit tg setup
+
+# 2. Gửi thử tin nhắn kiểm tra
+awkit tg send "Hello from AWKit!"
+
+# 3. Gửi đến chat/topic cụ thể
+awkit tg send "Hello" --chat -100123456789 --topic 1234
+```
+
 ## 📦 Skill Packs
 
 ```bash
@@ -129,8 +147,8 @@ awkit enable-pack ios-dev
 | 4.x | AWF v4 | Shell-based, `awf-` prefix skills |
 | 5.x | Antigravity v5 | Node.js, Symphony integration |
 | 6.x | AWF v6 | main-awf, multiple sources |
-| **1.0** | **AWKit v1.0** | **Single source of truth, this repo** |
+| **1.1.x** | **AWKit v1.1** | **Single source of truth, Native CLI, Telegram Integration** |
 
 ---
 
-*AWKit v1.0 — Antigravity Workflow Kit · Created by Kien AI*
+*AWKit v1.1.x — Antigravity Workflow Kit · Created by Kien AI*

package/bin/awk.js

@@ -28,17 +28,75 @@ const path = require('path');
 const https = require('https');
 const { execSync, spawnSync } = require('child_process');
 
-// ─── Constants ────────────────────────────────────────────────────────────────
-
 const AWK_VERSION = fs.readFileSync(path.join(__dirname, '..', 'VERSION'), 'utf8').trim();
 const AWK_ROOT = path.join(__dirname, '..');
 const HOME = process.env.HOME || process.env.USERPROFILE;
 
+const { generateClineRules, generateClineWorkflows, generateClineSkills } = require('./cline-generators');
+const { generateCodexAgentsMd, generateCodexSkills, generateCodexAgents } = require('./codex-generators');
+
+// ─── Platform Definitions ──────────────────────────────────────────────────
+
+const PLATFORMS = {
+    antigravity: {
+        name: 'Antigravity (Gemini Code Assist)',
+        globalRoot: path.join(HOME, '.gemini', 'antigravity'),
+        rulesFile: path.join(HOME, '.gemini', 'GEMINI.md'),
+        versionFile: path.join(HOME, '.gemini', 'awk_version'),
+        dirs: {
+            workflows: 'global_workflows',
+            skills: 'skills',
+            schemas: 'schemas',
+            templates: 'templates',
+        },
+        supportsCustomModes: false,
+        supportsSubagents: false,
+    },
+    cline: {
+        name: 'Cline (VS Code)',
+        globalRoot: process.cwd(), // Local to project
+        rulesFile: path.join(HOME, '.cline', 'rules', 'antigravity-rules.md'),
+        versionFile: path.join(HOME, '.cline', 'awk_version'),
+        dirs: {
+            workflows: '.clinerules',
+            skills: '.clinerules/skills',
+        },
+    },
+    codex: {
+        name: 'Codex (OpenAI)',
+        globalRoot: path.join(HOME, '.codex'),
+        rulesFile: path.join(HOME, '.codex', 'AGENTS.md'),
+        versionFile: path.join(HOME, '.codex', 'awk_version'),
+        dirs: {
+            agents: 'agents',
+            skills: '../.agents/skills',
+        },
+    }
+};
+
+const PLATFORM_FILE = path.join(HOME, '.awkit_platform');
+
+/**
+ * Get the currently configured platform.
+ * Reads from ~/.awkit_platform, defaults to 'antigravity'.
+ */
+function getActivePlatform() {
+    return 'antigravity';
+}
+
+function savePlatform(platform) {
+    fs.writeFileSync(PLATFORM_FILE, platform, 'utf8');
+}
+
+// Active platform — resolved at install time or from saved config
+let activePlatform = 'antigravity';
+
+// Legacy compat: TARGETS object derived from active platform
 const TARGETS = {
-    antigravity: path.join(HOME, '.gemini', 'antigravity'),
-    geminiMd: path.join(HOME, '.gemini', 'GEMINI.md'),
-    versionFile: path.join(HOME, '.gemini', 'awk_version'),
-    agentsDir: null, // Set per-project
+    get antigravity() { return PLATFORMS[activePlatform].globalRoot; },
+    get geminiMd() { return PLATFORMS[activePlatform].rulesFile || path.join(HOME, '.gemini', 'GEMINI.md'); },
+    get versionFile() { return PLATFORMS[activePlatform].versionFile; },
+    agentsDir: null,
 };
 
 // Mapping: source dir in package → target dir in antigravity
@@ -87,6 +145,22 @@ function promptYN(question) {
     }
 }
 
+/**
+ * Prompt user for a choice, returning the raw answer string.
+ * Returns defaultVal if user presses Enter without input.
+ */
+function promptChoice(question, defaultVal = '') {
+    try {
+        const answer = execSync(
+            `bash -c 'read -p "${question} (default: ${defaultVal}): " ans; echo $ans'`,
+            { stdio: ['inherit', 'pipe', 'inherit'] }
+        ).toString().trim();
+        return answer || defaultVal;
+    } catch (e) {
+        return defaultVal;
+    }
+}
+
 // ─── Utility Functions ──────────────────────────────────────────────────────
 
 /**
@@ -238,24 +312,38 @@ function installSymphony({ silent = false } = {}) {
     }
 }
 
-function cmdInstall() {
+function cmdInstall(platformArg) {
     log('');
     log(`${C.cyan}${C.bold}╔══════════════════════════════════════════════════════════╗${C.reset}`);
     log(`${C.cyan}${C.bold}║     🚀 AWK v${AWK_VERSION} — Antigravity Workflow Kit        ║${C.reset}`);
     log(`${C.cyan}${C.bold}╚══════════════════════════════════════════════════════════╝${C.reset}`);
     log('');
 
-    const target = TARGETS.antigravity;
+    // Platform selection
+    let platform = platformArg || getActivePlatform();
+
+    if (!PLATFORMS[platform]) {
+        err(`Unknown platform: ${platform}.`);
+        return;
+    }
+
+    activePlatform = platform;
+    savePlatform(platform);
 
-    // 0. Install Symphony if missing
+    const plat = PLATFORMS[platform];
+    const target = plat.globalRoot;
+
+    info(`Installing for ${C.bold}${plat.name}${C.reset}...`);
     log('');
+
+    // 0. Install Symphony if missing (shared dependency)
     info('Checking dependencies...');
     installSymphony();
 
     // 1. Ensure target dirs exist
     info('Creating directories...');
-    const dirs = ['global_workflows', 'skills', 'schemas', 'templates'];
-    for (const dir of dirs) {
+    const dirKeys = Object.values(plat.dirs);
+    for (const dir of dirKeys) {
         const fullPath = path.join(target, dir);
         if (!fs.existsSync(fullPath)) {
             fs.mkdirSync(fullPath, { recursive: true });
@@ -263,72 +351,104 @@ function cmdInstall() {
     }
     ok('Directories ready');
 
-    // 2. Sync GEMINI.md
-    info('Syncing GEMINI.md...');
-    syncGeminiMd();
-
-    // 3. Backup and flatten workflows
-    info('Installing workflows...');
-    const wfSrc = path.join(AWK_ROOT, 'workflows');
-    const wfDest = path.join(target, 'global_workflows');
-
-    // Backup existing global_workflows to a zip file
-    if (fs.existsSync(wfDest)) {
-        const backupDir = path.join(target, 'backup');
-        if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
+    // 2. Sync rules (platform-specific)
+    if (platform === 'antigravity') {
+        info('Syncing GEMINI.md...');
+        syncGeminiMd();
+    } else if (platform === 'cline') {
+        info('Generating Cline global rules...');
+        generateClineRules(path.join(AWK_ROOT, 'core', 'GEMINI.md'), plat.rulesFile);
+    } else if (platform === 'codex') {
+        info('Generating Codex AGENTS.md...');
+        generateCodexAgentsMd(path.join(AWK_ROOT, 'core', 'GEMINI.md'), plat.rulesFile);
+    }
+
+    // 3. Backup and install workflows
+    if (plat.dirs.workflows) {
+        info('Installing workflows...');
+        const wfSrc = path.join(AWK_ROOT, 'workflows');
+        const wfDest = path.join(target, plat.dirs.workflows);
+
+        // Backup existing workflows
+        if (fs.existsSync(wfDest)) {
+            const backupDir = path.join(target, 'backup');
+            if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
+
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const zipFile = path.join(backupDir, `workflows_${timestamp}.bak.zip`);
+            try {
+                execSync(`zip -r "${zipFile}" .`, { cwd: wfDest, stdio: 'ignore' });
+                dim(`Backup: ${zipFile}`);
+            } catch (e) {
+                warn(`Failed to create backup: ${e.message}`);
+            }
+        }
 
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const zipFile = path.join(backupDir, `global_workflows_${timestamp}.bak.zip`);
-        try {
-            info('Creating zip backup of global_workflows...');
-            execSync(`zip -r "${zipFile}" .`, { cwd: wfDest, stdio: 'ignore' });
-            ok(`Backup created: ${zipFile}`);
-        } catch (e) {
-            warn(`Failed to create backup zip: ${e.message}`);
+        if (platform === 'cline') {
+            generateClineWorkflows(wfSrc, wfDest);
+        } else if (platform !== 'codex') {
+            const wfCount = flattenWorkflows(wfSrc, wfDest);
+            ok(`${wfCount} workflows installed`);
         }
     }
 
-    const wfCount = flattenWorkflows(wfSrc, wfDest);
-    ok(`${wfCount} workflows installed`);
-
     // 4. Copy AGENTS.md
-    const agentsSrc = path.join(AWK_ROOT, 'core', 'AGENTS.md');
-    const agentsDest = path.join(target, 'global_workflows', 'AGENTS.md');
-    if (fs.existsSync(agentsSrc)) {
-        fs.copyFileSync(agentsSrc, agentsDest);
-        ok('AGENTS.md installed');
+    if (platform === 'antigravity' && plat.dirs.workflows) {
+        const agentsSrc = path.join(AWK_ROOT, 'core', 'AGENTS.md');
+        const agentsDest = path.join(target, plat.dirs.workflows, 'AGENTS.md');
+        if (fs.existsSync(agentsSrc)) {
+            fs.copyFileSync(agentsSrc, agentsDest);
+            ok('AGENTS.md installed');
+        }
     }
 
     // 5. Copy skills
-    info('Installing skills...');
-    const skillsSrc = path.join(AWK_ROOT, 'skills');
-    const skillsDest = path.join(target, 'skills');
-    const skillCount = copyDirRecursive(skillsSrc, skillsDest);
-    ok(`${skillCount} skill files installed`);
+    if (plat.dirs.skills) {
+        info('Installing skills...');
+        const skillsSrc = path.join(AWK_ROOT, 'skills');
+        const skillsDest = path.join(target, plat.dirs.skills);
+
+        if (platform === 'cline') {
+            generateClineSkills(skillsSrc, skillsDest);
+        } else if (platform === 'codex') {
+            generateCodexSkills(skillsSrc, skillsDest);
+            const agentsDest = path.join(target, plat.dirs.agents);
+            generateCodexAgents(skillsSrc, agentsDest);
+        } else {
+            const skillCount = copyDirRecursive(skillsSrc, skillsDest);
+            ok(`${skillCount} skill files installed`);
+        }
+    }
 
     // 6. Copy orchestrator
-    const orchSrc = path.join(AWK_ROOT, 'core', 'orchestrator.md');
-    const orchDestDir = path.join(target, 'skills', 'orchestrator');
-    if (!fs.existsSync(orchDestDir)) fs.mkdirSync(orchDestDir, { recursive: true });
-    fs.copyFileSync(orchSrc, path.join(orchDestDir, 'SKILL.md'));
-    ok('Orchestrator skill installed');
+    if (platform === 'antigravity') {
+        const orchSrc = path.join(AWK_ROOT, 'core', 'orchestrator.md');
+        const orchDestDir = path.join(target, plat.dirs.skills, 'orchestrator');
+        if (!fs.existsSync(orchDestDir)) fs.mkdirSync(orchDestDir, { recursive: true });
+        fs.copyFileSync(orchSrc, path.join(orchDestDir, 'SKILL.md'));
+        ok('Orchestrator skill installed');
+    }
 
     // 7. Copy schemas (always overwrite)
-    info('Installing schemas...');
-    const schemaSrc = path.join(AWK_ROOT, 'schemas');
-    const schemaDest = path.join(target, 'schemas');
-    const schemaCount = copyDirRecursive(schemaSrc, schemaDest);
-    ok(`${schemaCount} schemas installed`);
+    if (plat.dirs.schemas) {
+        info('Installing schemas...');
+        const schemaSrc = path.join(AWK_ROOT, 'schemas');
+        const schemaDest = path.join(target, plat.dirs.schemas);
+        const schemaCount = copyDirRecursive(schemaSrc, schemaDest);
+        ok(`${schemaCount} schemas installed`);
+    }
 
     // 8. Copy templates (don't overwrite existing)
-    info('Installing templates...');
-    const tmplSrc = path.join(AWK_ROOT, 'templates');
-    const tmplDest = path.join(target, 'templates');
-    const tmplCount = copyDirRecursive(tmplSrc, tmplDest, { overwrite: false });
-    ok(`${tmplCount} templates installed`);
+    if (plat.dirs.templates) {
+        info('Installing templates...');
+        const tmplSrc = path.join(AWK_ROOT, 'templates');
+        const tmplDest = path.join(target, plat.dirs.templates);
+        const tmplCount = copyDirRecursive(tmplSrc, tmplDest, { overwrite: false });
+        ok(`${tmplCount} templates installed`);
+    }
 
     // 9. Save version
-    fs.writeFileSync(TARGETS.versionFile, AWK_VERSION);
+    fs.writeFileSync(plat.versionFile, AWK_VERSION);
     ok(`Version ${AWK_VERSION} saved`);
 
     // 10. Install default skill packs
@@ -337,21 +457,34 @@ function cmdInstall() {
     // 11. Summary
     log('');
     log(`${C.gray}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
-    log(`${C.yellow}${C.bold}🎉 AWK v${AWK_VERSION} installed successfully!${C.reset}`);
+    log(`${C.yellow}${C.bold}🎉 AWK v${AWK_VERSION} installed for ${plat.name}!${C.reset}`);
     log('');
-    dim(`Workflows:  ${path.join(target, 'global_workflows')}`);
-    dim(`Skills:     ${path.join(target, 'skills')}`);
-    dim(`Schemas:    ${path.join(target, 'schemas')}`);
-    dim(`Templates:  ${path.join(target, 'templates')}`);
-    dim(`GEMINI.md:  ${TARGETS.geminiMd}`);
+    dim(`Platform:   ${plat.name}`);
+    if (plat.dirs.workflows) dim(`Workflows:  ${path.join(target, plat.dirs.workflows)}`);
+    if (plat.dirs.skills) dim(`Skills:     ${path.join(target, plat.dirs.skills)}`);
+    if (plat.dirs.schemas) dim(`Schemas:    ${path.join(target, plat.dirs.schemas)}`);
+    if (plat.dirs.templates) dim(`Templates:  ${path.join(target, plat.dirs.templates)}`);
+    if (plat.dirs.agents) dim(`Agents:     ${path.join(target, plat.dirs.agents)}`);
+
+    if (plat.rulesFile) {
+        dim(`Global Rules: ${plat.rulesFile}`);
+    }
     if (defaultPacks.length > 0) {
         dim(`Packs:      ${defaultPacks.join(', ')} (auto-enabled)`);
     }
-    const bdVer = (() => { try { return execSync('bd --version', { encoding: 'utf8' }).trim().split('\n')[0]; } catch (_) { return 'installed'; } })();
-    dim(`Symphony:     task tracking ready`);
+    if (platform === 'antigravity') {
+        dim(`Symphony:   task tracking ready`);
+    }
     log('');
-    log(`${C.cyan}👉 Type '/plan' in your AI chat to get started.${C.reset}`);
-    log(`${C.cyan}👉 Run 'awkit init' in any project to initialize it.${C.reset}`);
+
+    if (platform === 'antigravity') {
+        log(`${C.cyan}👉 Type '/plan' in your AI chat to get started.${C.reset}`);
+        log(`${C.cyan}👉 Run 'awkit init' in any project to initialize it.${C.reset}`);
+    } else if (platform === 'cline') {
+        log(`${C.cyan}👉 Type '/plan' in Cline chat to get started.${C.reset}`);
+    } else if (platform === 'codex') {
+        log(`${C.cyan}👉 Type '$skill' in Codex to invoke skills.${C.reset}`);
+    }
     log(`${C.cyan}👉 Run 'awkit doctor' to verify installation.${C.reset}`);
     log('');
 }
@@ -1962,7 +2095,17 @@ switch (command) {
         cmdInit(args.includes('--force'));
         break;
     case 'install':
-        cmdInstall();
+        // Parse platform from either first arg or --platform flag
+        {
+            const pIdx = args.indexOf('--platform');
+            let platformArg = null;
+            if (pIdx !== -1 && args[pIdx + 1]) {
+                platformArg = args[pIdx + 1];
+            } else if (args[0] && !args[0].startsWith('-')) {
+                platformArg = args[0];
+            }
+            cmdInstall(platformArg);
+        }
         break;
     case 'uninstall':
         cmdUninstall();

package/bin/cline-generators.js

@@ -0,0 +1,73 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Generates Cline global rules from GEMINI.md
+ * @param {string} sourcePath Path to core/GEMINI.md
+ * @param {string} destPath Destination path (e.g. ~/.cline/rules/antigravity.md)
+ */
+function generateClineRules(sourcePath, destPath) {
+    if (!fs.existsSync(sourcePath)) return;
+
+    let content = fs.readFileSync(sourcePath, 'utf8');
+    const preamble = `
+# Antigravity Rules for Cline
+
+${content}
+`;
+
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.writeFileSync(destPath, preamble.trim() + '\n');
+    console.log(`✅ Cline global rules generated at: ${destPath}`);
+}
+
+/**
+ * Copies workflow markdown files to the given directory.
+ */
+function generateClineWorkflows(srcDir, destDir) {
+    if (!fs.existsSync(srcDir)) return;
+
+    fs.mkdirSync(destDir, { recursive: true });
+    const items = fs.readdirSync(srcDir);
+
+    let count = 0;
+    for (const item of items) {
+        if (!item.endsWith('.md')) continue;
+        const srcPath = path.join(srcDir, item);
+        const destPath = path.join(destDir, item);
+        fs.copyFileSync(srcPath, destPath);
+        count++;
+    }
+    console.log(`✅ Copied ${count} workflows to ${destDir}`);
+}
+
+/**
+ * Copies SKILL.md from each skill directory to the given directory.
+ */
+function generateClineSkills(srcDir, destDir) {
+    if (!fs.existsSync(srcDir)) return;
+
+    fs.mkdirSync(destDir, { recursive: true });
+    const skills = fs.readdirSync(srcDir);
+
+    let count = 0;
+    for (const skill of skills) {
+        const skillDir = path.join(srcDir, skill);
+        if (!fs.statSync(skillDir).isDirectory()) continue;
+
+        const skillFile = path.join(skillDir, 'SKILL.md');
+        if (fs.existsSync(skillFile)) {
+            // Copy SKILL.md as <skillname>.md
+            const destPath = path.join(destDir, `${skill}.md`);
+            fs.copyFileSync(skillFile, destPath);
+            count++;
+        }
+    }
+    console.log(`✅ Copied ${count} skills to ${destDir}`);
+}
+
+module.exports = {
+    generateClineRules,
+    generateClineWorkflows,
+    generateClineSkills
+};

package/bin/codex-generators.js

@@ -0,0 +1,108 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Generates Codex global agents.md from GEMINI.md
+ * @param {string} sourcePath Path to core/GEMINI.md
+ * @param {string} destPath Destination path (e.g. ~/.codex/AGENTS.md)
+ */
+function generateCodexAgentsMd(sourcePath, destPath) {
+    if (!fs.existsSync(sourcePath)) return;
+
+    let content = fs.readFileSync(sourcePath, 'utf8');
+
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.writeFileSync(destPath, content.trim() + '\n');
+    console.log(`✅ Codex AGENTS.md generated at: ${destPath}`);
+}
+
+/**
+ * Generates Codex skills directory structure.
+ * Copies SKILL.md and parses it.
+ */
+function generateCodexSkills(srcDir, destDir) {
+    if (!fs.existsSync(srcDir)) return;
+
+    fs.mkdirSync(destDir, { recursive: true });
+    const skills = fs.readdirSync(srcDir);
+
+    let count = 0;
+    for (const skill of skills) {
+        const skillDir = path.join(srcDir, skill);
+        if (!fs.statSync(skillDir).isDirectory()) continue;
+
+        const skillFile = path.join(skillDir, 'SKILL.md');
+        if (fs.existsSync(skillFile)) {
+            const destSkillDir = path.join(destDir, skill);
+            fs.mkdirSync(destSkillDir, { recursive: true });
+
+            const destPath = path.join(destSkillDir, 'SKILL.md');
+
+            let content = fs.readFileSync(skillFile, 'utf8');
+
+            if (content.startsWith('---\n')) {
+                if (!content.match(/^name:/m)) {
+                    content = content.replace('---\n', `---\nname: ${skill}\n`);
+                }
+            } else {
+                const preamble = `---\nname: ${skill}\ndescription: Antigravity skill ${skill}\n---\n`;
+                content = preamble + content;
+            }
+
+            fs.writeFileSync(destPath, content);
+            count++;
+        }
+    }
+    console.log(`✅ Generated ${count} Codex skills in ${destDir}`);
+}
+
+/**
+ * Generates Codex custom agents (.toml) for specific skills.
+ */
+function generateCodexAgents(srcDir, destDir) {
+    if (!fs.existsSync(srcDir)) return;
+
+    fs.mkdirSync(destDir, { recursive: true });
+    const skills = fs.readdirSync(srcDir);
+
+    const SPECIALIST_SKILLS = [
+        'ios-engineer',
+        'smali-to-kotlin',
+        'smali-to-swift',
+        'problem-solving-pro',
+        'swiftui-pro',
+        'android-re-analyzer',
+        'brainstorm-agent'
+    ];
+
+    let count = 0;
+    for (const skill of skills) {
+        if (!SPECIALIST_SKILLS.includes(skill)) continue;
+
+        const skillDir = path.join(srcDir, skill);
+        if (!fs.statSync(skillDir).isDirectory()) continue;
+
+        const skillFile = path.join(skillDir, 'SKILL.md');
+        if (fs.existsSync(skillFile)) {
+            const content = fs.readFileSync(skillFile, 'utf8');
+
+            const tomlContent = `name = "${skill}"
+description = "Antigravity specialist ${skill}"
+developer_instructions = """
+${content.replace(/"""/g, '\\"\\"\\"')}
+"""
+`;
+
+            const destPath = path.join(destDir, `${skill}.toml`);
+            fs.writeFileSync(destPath, tomlContent);
+            count++;
+        }
+    }
+    console.log(`✅ Generated ${count} Codex custom agents in ${destDir}`);
+}
+
+module.exports = {
+    generateCodexAgentsMd,
+    generateCodexSkills,
+    generateCodexAgents
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@leejungkiin/awkit",
-  "version": "1.1.2",
-  "description": "AWKit v1.1.2 — Antigravity Workflow Kit. Unified AI agent orchestration system.",
+  "version": "1.1.4",
+  "description": "Antigravity Workflow Kit. Unified AI agent orchestration system.",
   "main": "bin/awk.js",
   "bin": {
     "awkit": "bin/awk.js",