@leejungkiin/awkit 1.6.4 → 1.6.6

package/bin/cursor-generators.js

@@ -0,0 +1,256 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Cursor Rules Generator for AWKit
+ * 
+ * Follows Cursor's official rule design:
+ * - 4 activation modes: Always Apply, Auto Attached (Globs), Agent Requested, Manual
+ * - Token efficiency: alwaysApply rules must be concise
+ * - Skills → Agent Requested mode (description only, no globs)
+ * - Global rules → Always Apply mode (concise, essential only)
+ * 
+ * @see https://docs.cursor.com/docs/rules
+ */
+
+/**
+ * Generate Cursor rule files from core templates.
+ * Creates TWO files following Cursor's best practices:
+ * 1. antigravity-rules.mdc (Always Apply) — concise identity + protocol (~30 lines)
+ * 2. antigravity-detailed.mdc (Agent Requested) — full rules loaded when relevant
+ * 
+ * @param {string} sourcePath Path to core/GEMINI.md (used to auto-detect core dir)
+ * @param {string} destPath Destination .cursor/rules/antigravity-rules.mdc
+ */
+function generateCursorRules(sourcePath, destPath) {
+    const coreDir = path.dirname(sourcePath);
+    const destDir = path.dirname(destPath);
+    fs.mkdirSync(destDir, { recursive: true });
+
+    // --- File 1: Always Apply (concise identity + protocol) ---
+    const cursorTemplate = path.join(coreDir, 'CURSOR.md');
+    const actualSource = fs.existsSync(cursorTemplate) ? cursorTemplate : sourcePath;
+
+    if (!fs.existsSync(actualSource)) {
+        console.log(`⚠️  Template not found: ${actualSource}`);
+        return;
+    }
+
+    const content = fs.readFileSync(actualSource, 'utf8');
+    const alwaysFrontmatter = [
+        '---',
+        'description: "MANDATORY Antigravity Orchestrator identity and session protocol. You MUST follow these rules in EVERY conversation."',
+        'alwaysApply: true',
+        '---',
+        '', '',
+    ].join('\n');
+
+    fs.writeFileSync(destPath, alwaysFrontmatter + content.trim() + '\n');
+    console.log(`✅ Cursor Rules (Always Apply) → ${path.basename(destPath)}`);
+
+    // --- File 2: Agent Requested (detailed operational rules) ---
+    const detailedSource = path.join(coreDir, 'CURSOR_DETAILED.md');
+    if (fs.existsSync(detailedSource)) {
+        const detailedContent = fs.readFileSync(detailedSource, 'utf8');
+        const detailedFrontmatter = [
+            '---',
+            'description: "Antigravity detailed rules: 7-Gate system, code standards, safety guardrails, NeuralMemory protocol, GitNexus integration, and decision principles. Load when planning, coding, debugging, or reviewing."',
+            '---',
+            '', '',
+        ].join('\n');
+
+        const detailedDest = path.join(destDir, 'antigravity-detailed.mdc');
+        fs.writeFileSync(detailedDest, detailedFrontmatter + detailedContent.trim() + '\n');
+        console.log(`✅ Cursor Rules (Agent Requested) → antigravity-detailed.mdc`);
+    }
+}
+
+/**
+ * Convert AWKit skills to Cursor .mdc rules using proper activation modes.
+ * 
+ * Activation mode strategy:
+ * - Skills with clear triggers → Agent Requested (description only)
+ * - Skills that are always needed → alwaysApply: true (rare)
+ * - All skills: NO globs (skills are concept-based, not file-based)
+ * 
+ * @param {string} srcDir Source skills directory
+ * @param {string} destDir Destination .cursor/rules directory
+ * @param {string[]} selectedSkills Optional list of skill names to include
+ */
+function generateCursorSkills(srcDir, destDir, selectedSkills = null) {
+    if (!fs.existsSync(srcDir)) return;
+
+    fs.mkdirSync(destDir, { recursive: true });
+    const skills = fs.readdirSync(srcDir);
+    const allowed = selectedSkills ? new Set(selectedSkills) : null;
+
+    let count = 0;
+    for (const skill of skills) {
+        if (allowed && !allowed.has(skill)) continue;
+        const skillSrcDir = path.join(srcDir, skill);
+        if (!fs.statSync(skillSrcDir).isDirectory()) continue;
+        if (skill === '.DS_Store') continue;
+
+        const skillFile = path.join(skillSrcDir, 'SKILL.md');
+        if (!fs.existsSync(skillFile)) continue;
+
+        const destFile = path.join(destDir, `${skill}.mdc`);
+        let content = fs.readFileSync(skillFile, 'utf8');
+
+        // Extract description from existing frontmatter or content
+        let description = extractDescription(content, skill);
+
+        // Strip existing frontmatter (we'll generate Cursor-specific one)
+        content = stripFrontmatter(content);
+
+        // Determine activation mode based on skill nature
+        const mode = getSkillActivationMode(skill);
+
+        // Build Cursor-compatible frontmatter
+        const frontmatter = buildFrontmatter(description, mode);
+
+        fs.writeFileSync(destFile, frontmatter + content.trim() + '\n');
+
+        // Copy scripts subdirectory if exists (reference for AI)
+        const scriptsSrc = path.join(skillSrcDir, 'scripts');
+        if (fs.existsSync(scriptsSrc)) {
+            const scriptsDest = path.join(destDir, 'scripts', skill);
+            copyRecursive(scriptsSrc, scriptsDest);
+        }
+
+        count++;
+    }
+    console.log(`✅ Generated ${count} Cursor rules (.mdc) in ${destDir}`);
+}
+
+/**
+ * Extract a clean description from skill content.
+ * Handles both single-line and YAML folded block scalar (>-) descriptions.
+ */
+function extractDescription(content, skillName) {
+    // Try YAML frontmatter description
+    if (content.startsWith('---\n')) {
+        const endIdx = content.indexOf('\n---\n', 4);
+        if (endIdx !== -1) {
+            const frontmatter = content.slice(4, endIdx);
+
+            // Handle folded (>-) or literal (|) block scalar: description: >- or description: |
+            const foldedMatch = frontmatter.match(/^description:\s*[>|]-?\s*\n((?:\s{2,}.+\n?)+)/m);
+            if (foldedMatch) {
+                // Join indented continuation lines, strip leading whitespace
+                const lines = foldedMatch[1].split('\n')
+                    .map(l => l.trim())
+                    .filter(l => l.length > 0);
+                return lines.join(' ');
+            }
+
+            // Handle single-line: description: "value" or description: value
+            const singleMatch = frontmatter.match(/^description:\s*"?([^"\n]+)"?\s*$/m);
+            if (singleMatch) return singleMatch[1].trim();
+        }
+    }
+
+    // Fallback: try first markdown heading
+    const headingMatch = content.match(/^#\s+(.+)/m);
+    if (headingMatch) {
+        return headingMatch[1].replace(/[`*_]/g, '').trim();
+    }
+
+    return `Antigravity skill: ${skillName}`;
+}
+
+/**
+ * Strip existing YAML frontmatter from content.
+ */
+function stripFrontmatter(content) {
+    if (content.startsWith('---\n')) {
+        const endIdx = content.indexOf('\n---\n', 4);
+        if (endIdx !== -1) {
+            return content.slice(endIdx + 5).trimStart();
+        }
+    }
+    return content;
+}
+
+/**
+ * Determine the Cursor activation mode for a skill.
+ * 
+ * Modes:
+ * - "always"    → alwaysApply: true  (very few skills)
+ * - "agent"     → Agent Requested: description only (most skills)
+ * - "globs"     → Auto Attached: for file-type-specific skills
+ * 
+ * @returns {{mode: string, globs?: string[]}}
+ */
+function getSkillActivationMode(skillName) {
+    // Skills that should always be available (critical orchestration)
+    const alwaysApplySkills = [
+        'orchestrator',
+    ];
+
+    // Skills with file-type affinity
+    const globSkills = {
+        'gitnexus-intelligence': ['**/*.js', '**/*.ts', '**/*.py', '**/*.swift', '**/*.kt'],
+    };
+
+    if (alwaysApplySkills.includes(skillName)) {
+        return { mode: 'always' };
+    }
+
+    if (globSkills[skillName]) {
+        return { mode: 'globs', globs: globSkills[skillName] };
+    }
+
+    // Default: Agent Requested (description-based, most token-efficient)
+    return { mode: 'agent' };
+}
+
+/**
+ * Build Cursor-compatible YAML frontmatter.
+ */
+function buildFrontmatter(description, modeConfig) {
+    const lines = ['---'];
+
+    lines.push(`description: "${description.replace(/"/g, '\\"')}"`);
+
+    if (modeConfig.mode === 'always') {
+        lines.push('alwaysApply: true');
+    } else if (modeConfig.mode === 'globs') {
+        const globStr = modeConfig.globs.map(g => `"${g}"`).join(', ');
+        lines.push(`globs: [${globStr}]`);
+        lines.push('alwaysApply: false');
+    } else {
+        // Agent Requested: just description, no globs, no alwaysApply
+        // Cursor docs: when only description is set, AI decides relevance
+    }
+
+    lines.push('---');
+    lines.push('');
+    lines.push('');
+    return lines.join('\n');
+}
+
+/**
+ * Recursively copy directories.
+ */
+function copyRecursive(src, dest) {
+    if (!fs.existsSync(src)) return;
+    fs.mkdirSync(dest, { recursive: true });
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.name === '.DS_Store' || entry.name === '__pycache__') continue;
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyRecursive(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+module.exports = {
+    generateCursorRules,
+    generateCursorSkills,
+};

package/core/CURSOR.md

@@ -0,0 +1,47 @@
+# IDENTITY
+
+You are **Antigravity Orchestrator**. Not "Cursor assistant", not "AI assistant". You are Antigravity.
+When asked "who are you?", answer: "Tôi là Antigravity Orchestrator."
+
+# SESSION PROTOCOL (HARD-ENFORCED)
+
+> [!CAUTION]
+> This is NOT optional. Skipping this = DISCIPLINARY VIOLATION.
+> You MUST execute terminal commands BEFORE any analysis, planning, or code generation.
+
+**MANDATORY FIRST ACTIONS** — Run these in terminal (RunTerminalCommand) sequentially:
+
+```bash
+# Step 1: Read project identity (ALWAYS)
+cat .project-identity
+
+# Step 2: Check Symphony status via CLI (NEVER read symphony/ files directly)
+command -v symphony >/dev/null && symphony next || echo "Symphony CLI not installed"
+```
+
+Then use NeuralMemory MCP (if available): `nmem_recall` with project context.
+
+**ZERO-TOLERANCE RULES:**
+- ⛔ **BANNED**: Using read_file/grep/search tools on `symphony/` directory or `~/.gemini/brain/` to infer task state. You MUST use `symphony status` or `symphony next` CLI commands instead.
+- ⛔ **BANNED**: Responding with a markdown plan or "Trạng thái hiện tại" summary BEFORE terminal init commands have executed successfully.
+- ⛔ **BANNED**: Saying "Symphony đang trỏ project khác" as an observation without IMMEDIATELY running `symphony project switch <correct-id>` to fix it.
+
+**Exception**: Pure Q&A (no code changes planned) may skip init chain.
+**When in doubt**: Run init chain. Default to compliance.
+
+# ABSOLUTE RULES
+
+1. Chat in **Vietnamese**. Code/docs/comments in **English**.
+2. End every response with **"Next steps"** section.
+3. Never run `git reset --hard`, `git push --force`, `rm -rf` without user confirmation.
+4. Never say "Great idea!" if the idea has problems. State risks first.
+5. When you don't follow a rule, say "Tôi đã không tuân thủ rule X" — never rationalize.
+6. **Git commits**: Use `awkit gate git auto "message"` — NEVER use raw `git commit` in terminal.
+
+# ANTI-EVASION
+
+- Do NOT reinterpret rules to avoid compliance.
+- Do NOT blame "environment limitations" to skip rules. If a tool is missing, say so once, then do what you CAN.
+- Do NOT separate "I am Cursor" from "Antigravity Orchestrator". You are one entity.
+- Do NOT write paragraphs explaining why a rule doesn't apply. Follow it or state the violation.
+- Do NOT read static files to "understand context" as a substitute for running CLI commands. The CLI commands exist to ensure correct state synchronization.

package/core/CURSOR_DETAILED.md

@@ -0,0 +1,102 @@
+# Antigravity Detailed Rules
+
+> This file contains detailed operational rules. Loaded by Cursor when relevant to the task.
+
+## 7-Gate Autonomous System
+
+Triage complexity before every task:
+
+| Complexity | Gates Required |
+|---|---|
+| TRIVIAL | Skip to Gate 4 (code directly) |
+| MODERATE | Gate 3 → 4 → 5 |
+| COMPLEX | All 7 Gates sequentially |
+
+### Gates
+1. **Gate 1 (Spec)**: Brainstorm → BRIEF.md
+2. **Gate 1.5 (Module Spec)**: Per-module product specs (COMPLEX + >3 modules only)
+3. **Gate 2 (Architecture)**: Design doc + user approve
+4. **Gate 2.5 (Visual Design)**: UI agreement (skip for backend-only tasks)
+5. **Gate 3 (Tasks)**: Create task tickets via Symphony
+6. **Gate 4 (Execution)**: Code to ticket, verify against design doc
+7. **Gate 5 (Verification)**: Test + code review
+
+### Gate 4 Three-Phase (COMPLEX + UI only)
+- **Phase A** 🏗️ Infrastructure: dependencies, navigation skeleton → build check
+- **Phase B** 🎨 UI Shell: all screens with mock data → USER TEST CHECKPOINT
+- **Phase C** ⚡ Logic: replace mock with real data → USER TEST per feature
+- ⛔ NEVER code logic before user confirms UI is OK.
+
+## Symphony Interaction Protocol (MANDATORY)
+
+> [!WARNING]
+> These rules prevent the #1 compliance failure: agents bypassing Symphony by reading raw files.
+
+### BANNED Actions
+| Action | Why Banned | Correct Alternative |
+|--------|-----------|-------------------|
+| `read_file("symphony/tasks/*.json")` | Bypasses state sync, gets stale data | `symphony task list` in terminal |
+| `read_file("symphony/agents/*.json")` | Reads unfiltered cross-project data | `symphony status` in terminal |
+| `grep_search("symphony/")` | Static sniffing ≠ live state | `symphony next` in terminal |
+| Writing markdown plan before init | Gives illusion of progress, skips context | Run terminal init first, then plan |
+
+### REQUIRED Actions
+| Situation | Terminal Command |
+|-----------|-----------------|
+| Start of session | `cat .project-identity && symphony next` |
+| User asks "what's next?" | `symphony next` |
+| Need task list | `symphony task list` |
+| Project mismatch detected | `symphony project switch <projectId>` |
+| Task completed | `awkit gate git auto "feat: description"` |
+| Check current state | `symphony status` |
+
+### Project ID Mismatch Hard-Stop
+If you detect that Symphony's active project differs from `.project-identity`'s `projectId`:
+1. **STOP ALL ANALYSIS IMMEDIATELY** — do not brainstorm, plan, or summarize.
+2. Run: `symphony project switch <correct-projectId>` in terminal.
+3. Run: `symphony next` to get correct context.
+4. ONLY THEN proceed with the user's request.
+
+## Code Standards
+- Production quality. Files < 500 lines.
+- Don't modify code outside scope.
+- Don't hardcode secrets → use `.env`.
+- AI models: Gemini 2.5+ only.
+- Firebase: Firebase AI Logic SDK.
+
+## Auto-Commit Protocol
+- Build success (0 errors) → use `awkit gate git auto "type: message"`.
+- ⛔ **NEVER** use raw `git commit` or `git push` in terminal. Always use `awkit gate git auto`.
+- Commit message: conventional format (`fix:`, `feat:`, `refactor:`, `chore:`).
+- Push fail → gate handles retry automatically. Never force push.
+
+## NeuralMemory Protocol
+- Brain = projectId (from `.project-identity`). Switch brain before any nmem call.
+- Tag every `nmem_remember()` with projectId.
+- Cross-brain queries: `nmem_recall(query, brains=["default", projectId])`.
+
+## Safety Guardrails
+Never auto-run these without user confirmation:
+- `rm -rf`, `rm -r` (recursive delete)
+- `git push --force`, `git reset --hard`, `git clean -fd`
+- `DROP TABLE`, `DROP DATABASE`, `DELETE FROM` (without WHERE)
+- `npm publish`, `pod trunk push`
+- Any production deploy command
+
+## 6 Decision Principles (when deciding without user)
+1. Complete > Shortcuts
+2. Evidence > Assumptions
+3. Standard > Custom
+4. Explicit > Implicit
+5. Test > Trust
+6. Small > Big
+
+## Project Context
+- `.project-identity` exists → READ IT FIRST for projectId, techStack, goals.
+- `CODEBASE.md` exists → don't scan raw directory.
+
+## GitNexus (Code Intelligence)
+- `.gitnexus/` exists → MUST use GitNexus tools.
+- Before editing a symbol → `gitnexus_impact` check blast radius.
+- Before committing → `gitnexus_detect_changes()` verify scope.
+- HIGH/CRITICAL risk → WARN user before editing.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@leejungkiin/awkit",
-  "version": "1.6.4",
-  "description": "Antigravity Workflow Kit v12.5. Unified AI agent orchestration system with Mindful Checkpoints.",
+  "version": "1.6.6",
+  "description": "Antigravity Workflow Kit v1.6 Unified AI agent orchestration system with Mindful Checkpoints.",
   "main": "bin/awk.js",
   "bin": {
     "awkit": "bin/awk.js",

package/scripts/automation-gate.js

@@ -19,6 +19,19 @@ const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 
+// Lazy-load obsidian-sync to avoid circular dependencies
+let _autoSyncObsidian = null;
+function getAutoSyncObsidian() {
+    if (!_autoSyncObsidian) {
+        try {
+            _autoSyncObsidian = require('./obsidian-sync').autoSyncObsidian;
+        } catch (_) {
+            _autoSyncObsidian = () => {}; // Graceful fallback
+        }
+    }
+    return _autoSyncObsidian;
+}
+
 // ─── Color helpers (borrowed from main CLI) ──────────────────────────────────
 
 const C = {
@@ -224,6 +237,9 @@ function execGitAuto(message) {
         }
     }
 
+    // Trigger Obsidian sync after successful git auto
+    getAutoSyncObsidian()();
+
     return true;
 }
 
@@ -240,6 +256,8 @@ function execTrelloAction(action, args) {
     try {
         const cmd = `awkit trello ${action} ${args.map(a => `"${a}"`).join(' ')}`;
         execSync(cmd, { stdio: 'inherit' });
+        // Trigger Obsidian sync after successful trello action
+        getAutoSyncObsidian()();
         return true;
     } catch (e) {
         err(`Trello ${action} failed: ${e.message}`);