@leejungkiin/awkit 1.6.0 → 1.6.1

package/bin/awk.js

@@ -2051,6 +2051,18 @@ function cmdHelp() {
     log(`  ${C.gray}  --parse-mode <md|html>${C.reset}  Formatting mode`);
     log('');
 
+    // GitNexus
+    log(`${C.bold}🔍  GitNexus${C.reset}`);
+    log(line);
+    log(`  ${C.green}gitnexus list${C.reset}       List all indexed repositories`);
+    log(`  ${C.green}gitnexus status${C.reset}     Show current project index info`);
+    log(`  ${C.green}gitnexus clean${C.reset}      Interactive cleanup of old indexes`);
+    log(`  ${C.green}gitnexus clean${C.reset} ${C.gray}<name...>${C.reset}  Remove specific repo(s) by name`);
+    log(`  ${C.gray}  --stale${C.reset}            Auto-remove repos with missing paths`);
+    log(`  ${C.gray}  --all${C.reset}              Remove all except current project`);
+    log(`  ${C.gray}  Alias: gn${C.reset}`);
+    log('');
+
     // Available packs
     const packsDir = path.join(AWK_ROOT, 'skill-packs');
     if (fs.existsSync(packsDir)) {
@@ -3383,6 +3395,309 @@ function checkAutoUpdate() {
     }
 }
 
+// ─── GitNexus Management ──────────────────────────────────────────────────────
+
+const GITNEXUS_REGISTRY = path.join(HOME, '.gitnexus', 'registry.json');
+
+function readGitnexusRegistry() {
+    if (!fs.existsSync(GITNEXUS_REGISTRY)) return [];
+    try {
+        return JSON.parse(fs.readFileSync(GITNEXUS_REGISTRY, 'utf8'));
+    } catch (_) {
+        return [];
+    }
+}
+
+function writeGitnexusRegistry(registry) {
+    fs.mkdirSync(path.dirname(GITNEXUS_REGISTRY), { recursive: true });
+    fs.writeFileSync(GITNEXUS_REGISTRY, JSON.stringify(registry, null, 2) + '\n');
+}
+
+function cmdGitnexus(args) {
+    const sub = args[0] || 'list';
+
+    switch (sub) {
+        case 'list':
+        case 'ls': {
+            const registry = readGitnexusRegistry();
+            if (registry.length === 0) {
+                info('No GitNexus indexed repositories found.');
+                dim('Run `npx gitnexus analyze` in a project to index it.');
+                return;
+            }
+
+            log('');
+            log(`${C.cyan}${C.bold}🔍 GitNexus Indexed Repositories (${registry.length})${C.reset}`);
+            log(`${C.gray}${'─'.repeat(56)}${C.reset}`);
+
+            const cwd = process.cwd();
+            for (const repo of registry) {
+                const isCurrent = repo.path === cwd;
+                const marker = isCurrent ? `${C.green}◉` : `${C.gray}○`;
+                const nameColor = isCurrent ? C.green : C.reset;
+                const stats = repo.stats || {};
+                const indexDate = repo.indexedAt ? new Date(repo.indexedAt).toLocaleDateString() : 'unknown';
+                const pathExists = fs.existsSync(repo.path);
+                const pathStatus = pathExists ? '' : ` ${C.red}(path missing!)${C.reset}`;
+
+                log(`  ${marker} ${nameColor}${C.bold}${repo.name}${C.reset}${pathStatus}`);
+                dim(`    Path:    ${repo.path}`);
+                dim(`    Indexed: ${indexDate} | ${stats.nodes || 0} symbols, ${stats.edges || 0} edges, ${stats.processes || 0} flows`);
+            }
+            log('');
+            break;
+        }
+
+        case 'status': {
+            const cwd = process.cwd();
+            const registry = readGitnexusRegistry();
+            const match = registry.find(r => r.path === cwd);
+
+            if (!match) {
+                warn('Current directory is not indexed by GitNexus.');
+                dim('Run `npx gitnexus analyze` to index this project.');
+                return;
+            }
+
+            const stats = match.stats || {};
+            const indexDate = match.indexedAt ? new Date(match.indexedAt) : null;
+            const ageMs = indexDate ? Date.now() - indexDate.getTime() : 0;
+            const ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));
+            const stale = ageDays > 7;
+
+            log('');
+            log(`${C.cyan}${C.bold}🔍 GitNexus: ${match.name}${C.reset}`);
+            log(`${C.gray}${'─'.repeat(56)}${C.reset}`);
+            dim(`Path:        ${match.path}`);
+            dim(`Storage:     ${match.storagePath}`);
+            dim(`Indexed:     ${indexDate ? indexDate.toLocaleString() : 'unknown'} (${ageDays}d ago)`);
+            dim(`Last Commit: ${match.lastCommit || 'n/a'}`);
+            dim(`Symbols:     ${stats.nodes || 0}`);
+            dim(`Relations:   ${stats.edges || 0}`);
+            dim(`Communities: ${stats.communities || 0}`);
+            dim(`Processes:   ${stats.processes || 0}`);
+            dim(`Embeddings:  ${stats.embeddings || 0}`);
+
+            if (stale) {
+                log('');
+                warn(`Index is ${ageDays} days old. Consider refreshing:`);
+                dim('  npx gitnexus analyze');
+            }
+
+            // Show projectId from .project-identity if available
+            const identityPath = path.join(cwd, '.project-identity');
+            const identity = readJsonFile(identityPath);
+            if (identity && identity.projectId) {
+                dim(`Project ID:  ${identity.projectId}`);
+            }
+            log('');
+            break;
+        }
+
+        case 'clean': {
+            const registry = readGitnexusRegistry();
+            if (registry.length === 0) {
+                info('No GitNexus indexed repositories to clean.');
+                return;
+            }
+
+            const cwd = process.cwd();
+            const isStaleMode = args.includes('--stale');
+            const isAllMode = args.includes('--all');
+
+            // Named repos: awkit gn clean <name1> <name2> ...
+            const namedArgs = args.slice(1).filter(a => !a.startsWith('--'));
+            if (namedArgs.length > 0 && !isStaleMode && !isAllMode) {
+                const nameLookup = new Map(registry.map(r => [r.name.toLowerCase(), r]));
+                const matched = [];
+                const notFound = [];
+
+                for (const name of namedArgs) {
+                    const entry = nameLookup.get(name.toLowerCase());
+                    if (entry) matched.push(entry);
+                    else notFound.push(name);
+                }
+
+                if (notFound.length > 0) {
+                    warn(`Not found in registry: ${notFound.join(', ')}`);
+                    dim('Available repos:');
+                    for (const r of registry) dim(`  • ${r.name}`);
+                }
+
+                if (matched.length === 0) {
+                    info('No matching repos to clean.');
+                    return;
+                }
+
+                log('');
+                log(`${C.yellow}${C.bold}🧹 Will remove ${matched.length} repo(s):${C.reset}`);
+                for (const r of matched) {
+                    log(`  ${C.red}✗${C.reset} ${r.name} — ${r.path}`);
+                }
+                log('');
+
+                if (!promptYN('Confirm?')) {
+                    info('Cancelled.');
+                    return;
+                }
+
+                const removeNames = new Set(matched.map(r => r.name));
+                for (const r of matched) {
+                    if (r.storagePath && fs.existsSync(r.storagePath)) {
+                        try {
+                            fs.rmSync(r.storagePath, { recursive: true, force: true });
+                            dim(`Deleted: ${r.storagePath}`);
+                        } catch (e) {
+                            warn(`Failed to delete ${r.storagePath}: ${e.message}`);
+                        }
+                    }
+                }
+
+                const remaining = registry.filter(r => !removeNames.has(r.name));
+                writeGitnexusRegistry(remaining);
+                ok(`Removed ${matched.length} repos. ${remaining.length} remaining.`);
+                return;
+            }
+
+            if (isStaleMode) {
+                // Auto-clean repos whose paths no longer exist
+                const stale = registry.filter(r => !fs.existsSync(r.path));
+                if (stale.length === 0) {
+                    ok('No stale repos found. All paths are valid.');
+                    return;
+                }
+
+                log('');
+                log(`${C.yellow}${C.bold}🧹 Found ${stale.length} stale repo(s):${C.reset}`);
+                for (const r of stale) {
+                    log(`  ${C.red}✗${C.reset} ${r.name} — ${r.path}`);
+                }
+                log('');
+
+                if (!promptYN('Remove these stale entries?')) {
+                    info('Cancelled.');
+                    return;
+                }
+
+                for (const r of stale) {
+                    // Remove .gitnexus storage if it exists
+                    if (r.storagePath && fs.existsSync(r.storagePath)) {
+                        try {
+                            fs.rmSync(r.storagePath, { recursive: true, force: true });
+                            dim(`Deleted: ${r.storagePath}`);
+                        } catch (e) {
+                            warn(`Failed to delete ${r.storagePath}: ${e.message}`);
+                        }
+                    }
+                }
+
+                const remaining = registry.filter(r => fs.existsSync(r.path));
+                writeGitnexusRegistry(remaining);
+                ok(`Removed ${stale.length} stale entries. ${remaining.length} repos remaining.`);
+                return;
+            }
+
+            if (isAllMode) {
+                const toRemove = registry.filter(r => r.path !== cwd);
+                if (toRemove.length === 0) {
+                    info('Only current project is indexed. Nothing to clean.');
+                    return;
+                }
+
+                log('');
+                log(`${C.yellow}${C.bold}🧹 Will remove ${toRemove.length} repo(s) (keeping current project):${C.reset}`);
+                for (const r of toRemove) {
+                    log(`  ${C.red}✗${C.reset} ${r.name} — ${r.path}`);
+                }
+                log('');
+
+                if (!promptYN('Proceed?')) {
+                    info('Cancelled.');
+                    return;
+                }
+
+                for (const r of toRemove) {
+                    if (r.storagePath && fs.existsSync(r.storagePath)) {
+                        try {
+                            fs.rmSync(r.storagePath, { recursive: true, force: true });
+                            dim(`Deleted: ${r.storagePath}`);
+                        } catch (e) {
+                            warn(`Failed to delete ${r.storagePath}: ${e.message}`);
+                        }
+                    }
+                }
+
+                const remaining = registry.filter(r => r.path === cwd);
+                writeGitnexusRegistry(remaining);
+                ok(`Removed ${toRemove.length} repos. Current project preserved.`);
+                return;
+            }
+
+            // Interactive mode: show numbered list, user selects
+            log('');
+            log(`${C.cyan}${C.bold}🔍 Select repos to remove:${C.reset}`);
+            log(`${C.gray}${'─'.repeat(56)}${C.reset}`);
+
+            for (let i = 0; i < registry.length; i++) {
+                const r = registry[i];
+                const isCurrent = r.path === cwd;
+                const pathExists = fs.existsSync(r.path);
+                const tag = isCurrent ? ` ${C.green}(current)${C.reset}` : !pathExists ? ` ${C.red}(missing)${C.reset}` : '';
+                log(`  ${C.yellow}${i + 1}${C.reset}. ${r.name}${tag}`);
+                dim(`     ${r.path}`);
+            }
+            log('');
+
+            const input = promptChoice('Enter numbers to remove (e.g. 2,3,5)', '').trim();
+            if (!input) {
+                info('No selection. Cancelled.');
+                return;
+            }
+
+            const indices = input.split(',').map(s => parseInt(s.trim(), 10) - 1).filter(i => i >= 0 && i < registry.length);
+            if (indices.length === 0) {
+                info('Invalid selection. Cancelled.');
+                return;
+            }
+
+            const selected = indices.map(i => registry[i]);
+            log('');
+            log(`${C.yellow}Will remove:${C.reset}`);
+            for (const r of selected) {
+                log(`  ${C.red}✗${C.reset} ${r.name}`);
+            }
+            log('');
+
+            if (!promptYN('Confirm?')) {
+                info('Cancelled.');
+                return;
+            }
+
+            const removeNames = new Set(selected.map(r => r.name));
+            for (const r of selected) {
+                if (r.storagePath && fs.existsSync(r.storagePath)) {
+                    try {
+                        fs.rmSync(r.storagePath, { recursive: true, force: true });
+                        dim(`Deleted: ${r.storagePath}`);
+                    } catch (e) {
+                        warn(`Failed to delete ${r.storagePath}: ${e.message}`);
+                    }
+                }
+            }
+
+            const remaining = registry.filter(r => !removeNames.has(r.name));
+            writeGitnexusRegistry(remaining);
+            ok(`Removed ${selected.length} repos. ${remaining.length} remaining.`);
+            break;
+        }
+
+        default:
+            err(`Unknown gitnexus sub-command: ${sub}`);
+            log(`  Available: list, status, clean`);
+            break;
+    }
+}
+
 // ─── Native HTTP Server ───────────────────────────────────────────────────────
 
 function cmdServe(args) {
@@ -3545,6 +3860,10 @@ const [, , command, ...args] = process.argv;
         case 'serve':
             cmdServe(args);
             break;
+        case 'gitnexus':
+        case 'gn':
+            cmdGitnexus(args);
+            break;
         case 'gate':
             cmdGate(args);
             break;

package/package.json

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

package/skills/gitnexus-intelligence/SKILL.md

@@ -41,6 +41,31 @@ INDEX STALE (tool trả warning):
 
 ---
 
+## 🔑 Auto-Repo Detection Protocol (BẮT BUỘC)
+
+```
+TRƯỚC KHI gọi bất kỳ GitNexus MCP tool nào:
+
+1. Gọi gitnexus_list_repos() → lấy danh sách repos đã index
+2. Match project directory (từ .project-identity hoặc cwd) với repo paths
+3. Dùng matched repo name làm `repo` param cho MỌI tool call
+
+VÍ DỤ:
+  gitnexus_list_repos() trả về repo path "/Users/.../FitWitnessSimple"
+  → project đang mở = FitWitnessSimple
+  → gitnexus_query({query: "weather", repo: "FitWitnessSimple"})
+
+FALLBACK (nếu không match path):
+  1. So sánh projectId (từ .project-identity) với repo names
+  2. Nếu vẫn không match → hỏi user chọn repo
+
+⚠️ KHÔNG BAO GIỜ gọi GitNexus tool mà THIẾU `repo` param khi có >1 repo indexed.
+```
+
+> **Quản lý repos:** `awkit gitnexus list` để xem, `awkit gitnexus clean` để dọn repos cũ.
+
+---
+
 ## 🎯 When to Activate
 
 | Trigger | Action |

package/skills/nm-memory-sync/SKILL.md

@@ -187,16 +187,6 @@ If `nmem` is not available AND auto-install fails, falls back to flat-file behav
 - Shows warning once: "⚠️ NeuralMemory not installed. Using flat-file fallback."
 ```
 
-## CLI Fallback (MCP Unresponsive)
-
-If the `neural-memory` MCP server is unresponsive or fails, you MUST fallback to using the `nmem` CLI directly using the `run_command` tool. The CLI offers full parity with the MCP tools:
-- `nmem_remember` -> `nmem remember "..."`
-- `nmem_recall` -> `nmem recall "..."` 
-- `nmem_context` -> `nmem recap` or `nmem recall "..."`
-- `nmem_auto` -> `nmem auto process --text "..."`
-
-Always check the `nmem` CLI help (`nmem --help`) if unsure of the syntax.
-
 ---
 
 ## Integration