@hawon/nexus 0.2.0 → 0.3.0

package/dist/cli/index.js

@@ -6,16 +6,14 @@ import { discoverSessions } from "../parser/discover.js";
 import { discoverAllSessions } from "../parser/unified.js";
 import { parseSession } from "../parser/parse.js";
 import { exportSession } from "../obsidian/exporter.js";
-import { extractSkills } from "../skills/extractor.js";
 import { reviewCode } from "../review/analyzer.js";
 import { mapCodebase } from "../codebase/mapper.js";
 import { generateOnboardingGuide } from "../codebase/onboard.js";
 import { checkTestHealth } from "../testing/health-check.js";
 import { suggestFixes } from "../testing/test-fixer.js";
 import { validateConfig } from "../config/validator.js";
-import { createMemoryStore } from "../memory-engine/store.js";
+import { createNexusMemory } from "../memory-engine/nexus-memory.js";
 import { scan as scanPrompt } from "../promptguard/scanner.js";
-import { addSkills, exportToObsidian, loadSkillLibrary, saveSkillLibrary, searchSkills, } from "../skills/library.js";
 import { extractMemorySkills, renderKnowledgeBase } from "../skills/memory-skill-engine.js";
 import { readdirSync, rmSync } from "node:fs";
 // ── ANSI Colors ──────────────────────────────────────────────────
@@ -54,7 +52,7 @@ function resolveConfig(flags) {
     const vaultPath = flags["--vault"] ??
         process.env["NEXUS_VAULT_PATH"] ??
         join(homedir(), "ObsidianVault", "Claude");
-    const dataDir = join(vaultPath, ".nexus");
+    const dataDir = process.env["NEXUS_DATA"] ?? join(homedir(), ".nexus");
     return { vaultPath, dataDir };
 }
 function loadStatus(dataDir) {
@@ -189,30 +187,20 @@ function cmdSync(flags) {
     }
     const parsedSessions = [];
     const exportedFiles = [];
-    let skillsExtracted = 0;
-    const library = loadSkillLibrary(config.dataDir);
     for (let i = 0; i < allSessionPaths.length; i++) {
         const { path: sessionPath } = allSessionPaths[i];
         logProgress(i + 1, allSessionPaths.length, `Syncing session ${i + 1}/${allSessionPaths.length}...`);
         try {
             const session = parseSession(sessionPath);
             parsedSessions.push(session);
-            // 3. Export to Obsidian
             const filePath = exportSessionToObsidian(session, config.vaultPath);
             exportedFiles.push(filePath);
-            // 4. Extract skills
-            const skills = extractSkills(session);
-            const added = addSkills(library, skills);
-            skillsExtracted += added;
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             log(`\n${c.yellow}Warning:${c.reset} Failed to parse ${sessionPath}: ${msg}`);
         }
     }
-    // 5. Save skill library & export to Obsidian
-    saveSkillLibrary(library, config.dataDir);
-    const skillFiles = exportToObsidian(library, config.vaultPath);
     // 6. Update MOC and daily notes
     logInfo("Updating MOC and daily notes...");
     updateMOC(parsedSessions, config.vaultPath);
@@ -221,18 +209,15 @@ function cmdSync(flags) {
     const status = {
         lastSync: new Date().toISOString(),
         totalSessions: parsedSessions.length,
-        totalSkills: library.skills.length,
+        totalSkills: 0,
         sessionsExported: parsedSessions.map((s) => s.sessionId),
     };
     saveStatus(status, config.dataDir);
-    // Summary
     log("");
     log(`${c.bold}${c.green}Sync complete!${c.reset}`);
     log(`  ${c.cyan}Sessions exported:${c.reset}  ${exportedFiles.length}`);
-    log(`  ${c.cyan}New skills found:${c.reset}   ${skillsExtracted}`);
-    log(`  ${c.cyan}Total skills:${c.reset}       ${library.skills.length}`);
-    log(`  ${c.cyan}Skill files:${c.reset}        ${skillFiles.length}`);
     log(`  ${c.cyan}Vault path:${c.reset}         ${config.vaultPath}`);
+    log(`  ${c.dim}Run \`nexus reorganize\` to extract knowledge.${c.reset}`);
 }
 function cmdSessions() {
     const discovery = discoverSessions();
@@ -289,30 +274,36 @@ function cmdExport(sessionId, flags) {
     const session = parseSession(matchedPath);
     const filePath = exportSessionToObsidian(session, config.vaultPath);
     logSuccess(`Exported to ${filePath}`);
-    // Extract skills too
-    const library = loadSkillLibrary(config.dataDir);
-    const skills = extractSkills(session);
-    const added = addSkills(library, skills);
-    if (added > 0) {
-        saveSkillLibrary(library, config.dataDir);
-        logSuccess(`Extracted ${added} new skill(s)`);
-    }
 }
 function cmdSkills(flags) {
     const config = resolveConfig(flags);
-    const library = loadSkillLibrary(config.dataDir);
-    if (library.skills.length === 0) {
-        logInfo("No skills extracted yet. Run `nexus sync` first.");
+    const kbPath = join(config.dataDir, "knowledge.json");
+    if (!existsSync(kbPath)) {
+        logInfo("No knowledge extracted yet. Run `nexus reorganize` first.");
         return;
     }
-    log(`\n${c.bold}Extracted Skills${c.reset} (${library.skills.length} total)\n`);
-    log(`${"Name".padEnd(45)} ${"Confidence".padEnd(12)} Tools`);
-    log(`${"-".repeat(45)} ${"-".repeat(12)} ${"-".repeat(30)}`);
-    for (const skill of library.skills) {
-        const name = skill.name.slice(0, 43).padEnd(45);
-        const conf = `${(skill.confidence * 100).toFixed(0)}%`.padEnd(12);
-        const tools = skill.toolsUsed.join(", ");
-        log(`${c.cyan}${name}${c.reset} ${c.yellow}${conf}${c.reset} ${tools}`);
+    const kb = JSON.parse(readFileSync(kbPath, "utf-8"));
+    const skills = kb.skills ?? [];
+    const tips = kb.tips ?? [];
+    const facts = kb.facts ?? [];
+    log(`\n${c.bold}Knowledge Base${c.reset} (${skills.length} skills | ${tips.length} tips | ${facts.length} facts)\n`);
+    if (skills.length > 0) {
+        log(`${c.bold}Skills:${c.reset}`);
+        for (const s of skills) {
+            log(`  ${c.cyan}${s.name.slice(0, 50)}${c.reset} — ${(s.confidence * 100).toFixed(0)}% | ${s.evidenceCount} evidence`);
+        }
+    }
+    if (tips.length > 0) {
+        log(`\n${c.bold}Tips:${c.reset}`);
+        for (const t of tips) {
+            log(`  💡 ${t.advice?.slice(0, 60) ?? t.name}`);
+        }
+    }
+    if (facts.length > 0) {
+        log(`\n${c.bold}Facts:${c.reset}`);
+        for (const f of facts) {
+            log(`  📌 ${f.statement?.slice(0, 60) ?? f.name}`);
+        }
     }
     log("");
 }
@@ -321,32 +312,16 @@ function cmdSkillsSearch(query, flags) {
         logError("Usage: nexus skills search <query>");
         process.exit(1);
     }
-    const config = resolveConfig(flags);
-    const library = loadSkillLibrary(config.dataDir);
-    const results = searchSkills(library, query);
-    if (results.length === 0) {
-        logInfo(`No skills matching "${query}".`);
-        return;
-    }
-    log(`\n${c.bold}Skills matching "${query}"${c.reset} (${results.length} results)\n`);
-    for (const skill of results) {
-        log(`${c.cyan}${c.bold}${skill.name}${c.reset} ${c.dim}(${(skill.confidence * 100).toFixed(0)}% confidence)${c.reset}`);
-        log(`  ${c.dim}Trigger:${c.reset} ${skill.trigger}`);
-        log(`  ${c.dim}Tools:${c.reset}   ${skill.toolsUsed.join(", ")}`);
-        log(`  ${c.dim}Steps:${c.reset}   ${skill.steps.length}`);
-        log("");
-    }
+    logInfo(`Search not available yet. Use \`nexus skills\` to view all knowledge.`);
 }
 function cmdStatus(flags) {
     const config = resolveConfig(flags);
     const status = loadStatus(config.dataDir);
-    const library = loadSkillLibrary(config.dataDir);
-    log(`\n${c.bold}Claude Vault Status${c.reset}\n`);
+    log(`\n${c.bold}Nexus Status${c.reset}\n`);
     log(`  ${c.cyan}Vault path:${c.reset}      ${config.vaultPath}`);
     log(`  ${c.cyan}Last sync:${c.reset}       ${status.lastSync || "never"}`);
-    log(`  ${c.cyan}Total sessions:${c.reset}  ${status.totalSessions}`);
-    log(`  ${c.cyan}Total skills:${c.reset}    ${library.skills.length}`);
-    log(`  ${c.cyan}Library ver:${c.reset}     ${library.version}`);
+    log(`  ${c.cyan}Sessions:${c.reset}        ${status.sessionsExported ?? 0}`);
+    log(`  ${c.cyan}Knowledge:${c.reset}       ${status.totalKnowledge ?? "run reorganize"}`);
     log("");
 }
 function cmdReorganize(flags) {
@@ -604,13 +579,13 @@ async function cmdConfig(dir, flags) {
 }
 function cmdMemory(subcommand, query, flags) {
     const config = resolveConfig(flags);
-    const store = createMemoryStore(config.dataDir);
+    const store = createNexusMemory(config.dataDir);
     if (subcommand === "search") {
         if (!query) {
             logError("Usage: nexus memory search <query>");
             process.exit(1);
         }
-        const results = store.search({ query });
+        const results = store.search(query);
         if ("--json" in flags) {
             log(JSON.stringify(results, null, 2));
             return;
@@ -620,10 +595,9 @@ function cmdMemory(subcommand, query, flags) {
             return;
         }
         log(`\n${c.bold}Memory Search: "${query}"${c.reset} (${results.length} results)\n`);
-        for (const entry of results) {
-            log(`  ${c.cyan}${c.bold}${entry.id}${c.reset} ${c.dim}[${entry.tier}]${c.reset}`);
-            log(`    ${c.dim}Tags:${c.reset} ${entry.tags.join(", ")}`);
-            log(`    ${entry.content.slice(0, 120)}${entry.content.length > 120 ? "..." : ""}`);
+        for (const r of results) {
+            log(`  ${c.cyan}[${r.retrievalLevel}]${c.reset} score=${r.score.toFixed(2)}`);
+            log(`    ${r.observation.content.slice(0, 120)}`);
             log("");
         }
     }
@@ -634,13 +608,12 @@ function cmdMemory(subcommand, query, flags) {
             return;
         }
         log(`\n${c.bold}Memory Stats${c.reset}\n`);
-        log(`  ${c.cyan}Total entries:${c.reset}      ${stats.totalEntries}`);
-        log(`  ${c.cyan}Total size:${c.reset}         ${(stats.totalSizeBytes / 1024).toFixed(1)} KB`);
-        log(`  ${c.cyan}Compression ratio:${c.reset}  ${(stats.compressionRatio * 100).toFixed(1)}%`);
-        log(`\n${c.bold}By Tier:${c.reset}`);
-        for (const [tier, count] of Object.entries(stats.byTier)) {
-            log(`  ${c.yellow}${tier}${c.reset}: ${count}`);
-        }
+        log(`  ${c.cyan}Observations:${c.reset}    ${stats.totalObservations}`);
+        log(`  ${c.cyan}Valid:${c.reset}           ${stats.validObservations}`);
+        log(`  ${c.cyan}Graph nodes:${c.reset}     ${stats.graphNodes}`);
+        log(`  ${c.cyan}Graph edges:${c.reset}     ${stats.graphEdges}`);
+        log(`  ${c.cyan}Tunnels:${c.reset}         ${stats.tunnels}`);
+        log(`  ${c.cyan}Domains:${c.reset}         ${stats.domains.join(", ")}`);
         log("");
     }
     else {

package/dist/index.js

@@ -7,34 +7,25 @@ export { discoverOpenClawSessions, parseOpenClawSession } from "./parser/opencla
 export { exportSession } from "./obsidian/exporter.js";
 export { updateMOC } from "./obsidian/moc.js";
 export { appendToDailyNote } from "./obsidian/daily-note.js";
-// Skills — Wisdom Pipeline
-export { extractWisdom, renderWisdomMarkdown } from "./skills/wisdom-extractor.js";
-export { reconcileWisdom, loadRefinedLibrary, saveRefinedLibrary, exportRefinedSkills } from "./skills/skill-reconciler.js";
-// Skills — Context Engine
-export { createContextEngine } from "./skills/context-engine.js";
-export { createGlobalContext } from "./skills/global-context.js";
-export { analyzePatternEvolution } from "./skills/pattern-engine.js";
-export { smartExtract } from "./skills/smart-extractor.js";
-// Code Review (from superdev)
+// Skills — Memory-based Knowledge Extraction
+export { extractMemorySkills, renderKnowledgeBase } from "./skills/memory-skill-engine.js";
+// Prompt Injection Detection
+export { scan, isInjected, guard, scanBatch, PromptInjectionError } from "./promptguard/scanner.js";
+export { BUILTIN_RULES } from "./promptguard/rules.js";
+export { ADVANCED_RULES } from "./promptguard/advanced-rules.js";
+export { MULTILINGUAL_RULES } from "./promptguard/multilingual-rules.js";
+export { normalizeText } from "./promptguard/normalize.js";
+// Memory Engine
+export { createNexusMemory } from "./memory-engine/nexus-memory.js";
+export { semanticSimilarity, expandQuery, getSynonyms } from "./memory-engine/semantic.js";
+// Code Review
 export { reviewCode } from "./review/analyzer.js";
 export { reviewDiff } from "./review/diff-reviewer.js";
-// Codebase Mapping (from superdev)
+// Codebase Mapping
 export { mapCodebase } from "./codebase/mapper.js";
 export { generateOnboardingGuide } from "./codebase/onboard.js";
-// Test Health (from superdev)
+// Test Health
 export { checkTestHealth } from "./testing/health-check.js";
 export { suggestFixes } from "./testing/test-fixer.js";
-// Config Validator (from superdev)
+// Config Validator
 export { validateConfig } from "./config/validator.js";
-// Infinite Memory (from superdev)
-export { createMemoryStore } from "./memory-engine/store.js";
-export { createContextWindow } from "./memory-engine/context-window.js";
-// Prompt Injection Detection (from promptguard)
-export { scan, isInjected, guard, scanBatch, PromptInjectionError } from "./promptguard/scanner.js";
-export { BUILTIN_RULES } from "./promptguard/rules.js";
-export { ADVANCED_RULES } from "./promptguard/advanced-rules.js";
-export { MULTILINGUAL_RULES } from "./promptguard/multilingual-rules.js";
-export { normalizeText } from "./promptguard/normalize.js";
-export { analyzeEntropy } from "./promptguard/entropy.js";
-export { classifyIntent } from "./promptguard/semantic.js";
-export { analyzeTokens } from "./promptguard/token-analysis.js";

package/dist/mcp/server.js

@@ -46,17 +46,17 @@ import { suggestFixes } from "../testing/test-fixer.js";
 // Config
 import { validateConfig } from "../config/validator.js";
 // Memory
-import { createMemoryStore } from "../memory-engine/store.js";
+import { createNexusMemory } from "../memory-engine/nexus-memory.js";
 // Prompt injection
 import { scan, isInjected } from "../promptguard/scanner.js";
 // Knowledge — uses cached data from last `nexus reorganize`
 const server = new McpServer({ name: "nexus", version: "0.1.0" });
-const dataDir = resolve(process.env.NEXUS_DATA ?? ".nexus");
+const dataDir = resolve(process.env.NEXUS_DATA ?? join(process.env.HOME ?? "/home", ".nexus"));
 // Singleton memory store (avoid re-reading from disk on every MCP call)
 let _memoryStore = null;
 function getMemoryStore() {
     if (!_memoryStore)
-        _memoryStore = createMemoryStore(dataDir);
+        _memoryStore = createNexusMemory(dataDir);
     return _memoryStore;
 }
 // ─── Session Intelligence ────────────────────────────────────────
@@ -149,7 +149,7 @@ server.tool("nexus_memory_search", "Search persistent memory for relevant past i
     limit: z.number().optional().describe("Max results (default: 10)"),
 }, async ({ query, limit }) => {
     const store = getMemoryStore();
-    const results = store.search({ query, limit: limit ?? 10 });
+    const results = store.search(query, limit ?? 10);
     return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
 });
 server.tool("nexus_memory_save", "Save information to persistent memory for future reference.", {
@@ -157,8 +157,9 @@ server.tool("nexus_memory_save", "Save information to persistent memory for futu
     tags: z.array(z.string()).optional().describe("Tags for categorization"),
 }, async ({ content, tags }) => {
     const store = getMemoryStore();
-    const entry = store.add({ content, tags: tags ?? [], tier: "working" });
-    return { content: [{ type: "text", text: JSON.stringify({ saved: true, id: entry.id }) }] };
+    const count = store.ingest(content, "manual");
+    store.save();
+    return { content: [{ type: "text", text: JSON.stringify({ saved: true, observations: count }) }] };
 });
 // ─── Knowledge (Skills + Tips + Facts) ───────────────────────────
 server.tool("nexus_skills", "List all knowledge: skills (complex patterns), tips (quick advice), and facts (reference info).", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hawon/nexus",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "The all-in-one AI developer framework — session intelligence, code review, prompt injection defense, infinite memory, self-evolving skills",
   "type": "module",
   "main": "dist/index.js",

package/scripts/benchmark.ts

@@ -4,7 +4,7 @@
  * Tests all 5 performance areas:
  * 1. Prompt Injection Detection — accuracy, false positive rate
  * 2. Memory Search — BM25+semantic vs TF-IDF precision
- * 3. Skill Extraction — quality gate effectiveness
+ * 3. Session Parser — parse rate and coverage
  * 4. Code Review — detection accuracy
  * 5. Speed — throughput across all modules
  */
@@ -15,8 +15,6 @@ import { semanticSimilarity } from "../src/memory-engine/semantic.js";
 import { reviewCode } from "../src/review/analyzer.js";
 import { discoverSessions } from "../src/parser/discover.js";
 import { parseSession } from "../src/parser/parse.js";
-import { extractWisdom } from "../src/skills/wisdom-extractor.js";
-import { reconcileWisdom } from "../src/skills/skill-reconciler.js";
 
 const BOLD = "\x1b[1m";
 const GREEN = "\x1b[32m";
@@ -234,17 +232,15 @@ function benchmarkMemory(): void {
 // 3. SKILL EXTRACTION BENCHMARK
 // ═══════════════════════════════════════════════════════════════════
 
-function benchmarkSkills(): void {
-  header("3. Skill Extraction Pipeline");
+function benchmarkSessionParser(): void {
+  header("3. Session Parser");
 
   const discovery = discoverSessions();
   let totalSessions = 0;
   let parsedSessions = 0;
-  let totalWisdoms = 0;
   let totalMessages = 0;
-  const allWisdoms: ReturnType<typeof extractWisdom> = [];
+  let failedSessions = 0;
 
-  // Parse all sessions
   for (const proj of discovery.projects) {
     for (const sp of proj.sessions) {
       totalSessions++;
@@ -252,38 +248,20 @@ function benchmarkSkills(): void {
         const session = parseSession(sp);
         parsedSessions++;
         totalMessages += session.messages.length;
-        const wisdoms = extractWisdom(session.messages, session.sessionId);
-        totalWisdoms += wisdoms.length;
-        allWisdoms.push(...wisdoms);
-      } catch { /* skip */ }
+      } catch {
+        failedSessions++;
+      }
     }
   }
 
-  // Run reconciler
-  const library = { skills: [], version: 1, updatedAt: new Date().toISOString() };
-  const result = reconcileWisdom(allWisdoms, library);
+  const parseRate = totalSessions > 0 ? (parsedSessions / totalSessions * 100).toFixed(0) : "0";
+  const avgMessages = parsedSessions > 0 ? (totalMessages / parsedSessions).toFixed(1) : "0";
 
   metric("Sessions discovered", String(totalSessions));
-  metric("Sessions parsed", `${parsedSessions} (${(parsedSessions / totalSessions * 100).toFixed(0)}% success)`);
+  metric("Sessions parsed", `${parsedSessions}/${totalSessions} (${parseRate}%)`);
+  metric("Parse failures", String(failedSessions));
   metric("Total messages", String(totalMessages));
-  metric("Raw wisdoms extracted", String(totalWisdoms));
-  metric("Quality gate rejected", `${result.rejected.length} (${(result.rejected.length / totalWisdoms * 100).toFixed(0)}%)`);
-  metric("Refined skills created", String(result.created.length));
-  metric("Skills updated", String(result.updated.length));
-  metric("Preferences learned", String(result.preferencesLearned.length));
-  metric("Extraction rate", `${(totalWisdoms / parsedSessions).toFixed(1)} wisdoms/session`);
-  metric("Quality rate", `${((result.created.length + result.updated.length) / Math.max(totalWisdoms, 1) * 100).toFixed(1)}% pass quality gate`);
-
-  // Rejection breakdown
-  const reasons: Record<string, number> = {};
-  for (const r of result.rejected) {
-    reasons[r.reason] = (reasons[r.reason] ?? 0) + 1;
-  }
-  log("");
-  log("  Quality Gate Rejection Breakdown:");
-  for (const [reason, count] of Object.entries(reasons).sort(([, a], [, b]) => b - a)) {
-    log(`    ${count}x — ${reason.slice(0, 60)}`);
-  }
+  metric("Avg messages/session", avgMessages);
 }
 
 // ═══════════════════════════════════════════════════════════════════
@@ -459,7 +437,7 @@ log(`${BOLD}╚═════════════════════
 
 benchmarkInjection();
 benchmarkMemory();
-benchmarkSkills();
+benchmarkSessionParser();
 benchmarkReview();
 benchmarkSpeed();