navada-edge-cli 4.0.0 → 4.2.0

package/lib/memory.js

@@ -0,0 +1,432 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const CONFIG_DIR = path.join(require('os').homedir(), '.navada');
+const MEMORY_DIR = path.join(CONFIG_DIR, 'memory');
+const EPISODES_DIR = path.join(MEMORY_DIR, 'episodes');
+const KNOWLEDGE_FILE = path.join(MEMORY_DIR, 'knowledge.json');
+
+function ensureDirs() {
+  for (const d of [CONFIG_DIR, MEMORY_DIR, EPISODES_DIR]) {
+    if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// TIER 1: WORKING MEMORY — in-session buffer with rolling summary
+// ═══════════════════════════════════════════════════════════════════
+const working = {
+  recentMessages: [],     // Last 20 full messages
+  summary: '',            // Compressed summary of older messages
+  turnsSinceSummary: 0,   // Counter for auto-summarisation trigger
+  MAX_RECENT: 20,
+  SUMMARISE_EVERY: 15,
+
+  add(role, content) {
+    this.recentMessages.push({ role, content, ts: Date.now() });
+    this.turnsSinceSummary++;
+
+    // When buffer exceeds limit, compress oldest messages into summary
+    if (this.recentMessages.length > this.MAX_RECENT) {
+      const overflow = this.recentMessages.splice(0, this.recentMessages.length - this.MAX_RECENT);
+      const overflowText = overflow.map(m => `${m.role}: ${typeof m.content === 'string' ? m.content.slice(0, 200) : JSON.stringify(m.content).slice(0, 200)}`).join('\n');
+
+      if (this.summary) {
+        this.summary += '\n' + overflowText;
+      } else {
+        this.summary = overflowText;
+      }
+
+      // Keep summary from growing unbounded — trim to ~2000 chars
+      if (this.summary.length > 2000) {
+        this.summary = this.summary.slice(-2000);
+      }
+    }
+  },
+
+  // Get messages formatted for AI provider (summary + recent)
+  getContextMessages() {
+    const messages = [];
+    if (this.summary) {
+      messages.push({
+        role: 'user',
+        content: `[Earlier conversation summary]\n${this.summary}\n[End of summary — recent messages follow]`,
+      });
+      messages.push({
+        role: 'assistant',
+        content: 'Understood, I have context from our earlier conversation.',
+      });
+    }
+    // Add recent messages
+    for (const m of this.recentMessages) {
+      messages.push({ role: m.role, content: m.content });
+    }
+    return messages;
+  },
+
+  getMessageCount() {
+    return this.recentMessages.length;
+  },
+
+  clear() {
+    this.recentMessages = [];
+    this.summary = '';
+    this.turnsSinceSummary = 0;
+  },
+
+  // Check if it's time to auto-summarise (called by agent after each turn)
+  needsSummary() {
+    return this.turnsSinceSummary >= this.SUMMARISE_EVERY && this.recentMessages.length > 10;
+  },
+
+  // Inject a compressed summary (called after AI generates one)
+  injectSummary(summaryText) {
+    // Move current recent to summary, keep last 5 for immediate context
+    const keep = this.recentMessages.slice(-5);
+    const oldText = this.recentMessages.slice(0, -5).map(m => `${m.role}: ${typeof m.content === 'string' ? m.content.slice(0, 150) : '...'}`).join('\n');
+
+    this.summary = summaryText || oldText;
+    this.recentMessages = keep;
+    this.turnsSinceSummary = 0;
+  },
+};
+
+// ═══════════════════════════════════════════════════════════════════
+// TIER 2: EPISODIC MEMORY — auto-saved session summaries
+// ═══════════════════════════════════════════════════════════════════
+const episodic = {
+  // Save a session episode when CLI exits or /save is called
+  saveEpisode(summary, tags = []) {
+    ensureDirs();
+    const id = `ep_${Date.now()}_${crypto.randomBytes(3).toString('hex')}`;
+    const episode = {
+      id,
+      summary,
+      tags,
+      messageCount: working.getMessageCount(),
+      timestamp: new Date().toISOString(),
+      date: new Date().toISOString().slice(0, 10),
+    };
+
+    const filePath = path.join(EPISODES_DIR, `${id}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(episode, null, 2));
+    return id;
+  },
+
+  // Load recent episodes (for context injection)
+  loadRecent(count = 5) {
+    ensureDirs();
+    try {
+      const files = fs.readdirSync(EPISODES_DIR)
+        .filter(f => f.endsWith('.json'))
+        .sort()
+        .reverse()
+        .slice(0, count);
+
+      return files.map(f => {
+        try {
+          return JSON.parse(fs.readFileSync(path.join(EPISODES_DIR, f), 'utf-8'));
+        } catch { return null; }
+      }).filter(Boolean);
+    } catch { return []; }
+  },
+
+  // Search episodes by keyword (simple text match)
+  search(query) {
+    ensureDirs();
+    const q = query.toLowerCase();
+    try {
+      const files = fs.readdirSync(EPISODES_DIR).filter(f => f.endsWith('.json'));
+      const results = [];
+
+      for (const f of files) {
+        try {
+          const ep = JSON.parse(fs.readFileSync(path.join(EPISODES_DIR, f), 'utf-8'));
+          const text = `${ep.summary} ${(ep.tags || []).join(' ')}`.toLowerCase();
+          if (text.includes(q)) {
+            results.push(ep);
+          }
+        } catch {}
+      }
+
+      return results.sort((a, b) => b.timestamp.localeCompare(a.timestamp)).slice(0, 10);
+    } catch { return []; }
+  },
+
+  // Get episode count
+  count() {
+    ensureDirs();
+    try {
+      return fs.readdirSync(EPISODES_DIR).filter(f => f.endsWith('.json')).length;
+    } catch { return 0; }
+  },
+};
+
+// ═══════════════════════════════════════════════════════════════════
+// TIER 3: SEMANTIC KNOWLEDGE — persistent facts, prefs, patterns
+// ═══════════════════════════════════════════════════════════════════
+
+// TF-IDF search (pure JS, zero deps)
+function tokenize(text) {
+  return text.toLowerCase()
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length > 2);
+}
+
+function tfidfScore(query, document) {
+  const queryTokens = tokenize(query);
+  const docTokens = tokenize(document);
+  if (docTokens.length === 0) return 0;
+
+  const docFreq = {};
+  for (const t of docTokens) {
+    docFreq[t] = (docFreq[t] || 0) + 1;
+  }
+
+  let score = 0;
+  for (const qt of queryTokens) {
+    if (docFreq[qt]) {
+      // TF * simple IDF approximation
+      const tf = docFreq[qt] / docTokens.length;
+      score += tf * (1 + Math.log(1 + docFreq[qt]));
+    }
+  }
+  return score;
+}
+
+const knowledge = {
+  _cache: null,
+
+  _load() {
+    if (this._cache) return this._cache;
+    ensureDirs();
+    try {
+      this._cache = JSON.parse(fs.readFileSync(KNOWLEDGE_FILE, 'utf-8'));
+    } catch {
+      this._cache = { facts: [], preferences: [], skills: [], people: [], decisions: [] };
+    }
+    return this._cache;
+  },
+
+  _save() {
+    ensureDirs();
+    fs.writeFileSync(KNOWLEDGE_FILE, JSON.stringify(this._cache, null, 2));
+  },
+
+  // Add a knowledge entry
+  add(category, content, source = 'conversation') {
+    const db = this._load();
+    if (!db[category]) db[category] = [];
+
+    // Deduplicate — don't add if very similar entry exists
+    const isDuplicate = db[category].some(entry => {
+      const similarity = tfidfScore(content, entry.content);
+      return similarity > 0.8;
+    });
+    if (isDuplicate) return false;
+
+    db[category].push({
+      id: `k_${Date.now()}_${crypto.randomBytes(2).toString('hex')}`,
+      content,
+      source,
+      timestamp: new Date().toISOString(),
+    });
+
+    // Keep each category under 100 entries (FIFO)
+    if (db[category].length > 100) {
+      db[category] = db[category].slice(-100);
+    }
+
+    this._save();
+    return true;
+  },
+
+  // Search knowledge by query (TF-IDF ranked)
+  search(query, limit = 5) {
+    const db = this._load();
+    const allEntries = [];
+
+    for (const [category, entries] of Object.entries(db)) {
+      for (const entry of entries) {
+        const score = tfidfScore(query, entry.content);
+        if (score > 0) {
+          allEntries.push({ ...entry, category, score });
+        }
+      }
+    }
+
+    return allEntries
+      .sort((a, b) => b.score - a.score)
+      .slice(0, limit);
+  },
+
+  // Get all entries in a category
+  getCategory(category) {
+    const db = this._load();
+    return db[category] || [];
+  },
+
+  // Get a summary of all knowledge for system prompt injection
+  getSummary() {
+    const db = this._load();
+    const parts = [];
+
+    for (const [category, entries] of Object.entries(db)) {
+      if (entries.length > 0) {
+        const recent = entries.slice(-5);
+        parts.push(`${category}: ${recent.map(e => e.content).join('; ')}`);
+      }
+    }
+
+    return parts.length > 0 ? parts.join('\n') : '';
+  },
+
+  // Get stats
+  stats() {
+    const db = this._load();
+    const counts = {};
+    for (const [cat, entries] of Object.entries(db)) {
+      counts[cat] = entries.length;
+    }
+    return counts;
+  },
+
+  // Clear cache (force reload from disk)
+  clearCache() {
+    this._cache = null;
+  },
+};
+
+// ═══════════════════════════════════════════════════════════════════
+// MEMORY MANAGER — orchestrates all 3 tiers
+// ═══════════════════════════════════════════════════════════════════
+const manager = {
+  // Called at session start — loads relevant context
+  loadSessionContext() {
+    const parts = [];
+
+    // Load recent episodes (Tier 2)
+    const recentEpisodes = episodic.loadRecent(3);
+    if (recentEpisodes.length > 0) {
+      parts.push('Recent sessions:');
+      for (const ep of recentEpisodes) {
+        parts.push(`  [${ep.date}] ${ep.summary}`);
+      }
+    }
+
+    // Load knowledge summary (Tier 3)
+    const knowledgeSummary = knowledge.getSummary();
+    if (knowledgeSummary) {
+      parts.push('\nKnown about this user:');
+      parts.push(knowledgeSummary);
+    }
+
+    return parts.length > 0 ? parts.join('\n') : '';
+  },
+
+  // Called after each AI response — extract and save knowledge automatically
+  autoExtract(userMessage, aiResponse) {
+    const text = typeof aiResponse === 'string' ? aiResponse : '';
+    const userText = typeof userMessage === 'string' ? userMessage : '';
+
+    // Extract user preferences (heuristics)
+    const prefPatterns = [
+      /(?:i (?:prefer|like|want|use|always|usually))\s+(.{10,80})/gi,
+      /(?:my (?:name|role|job|stack|language|framework) is)\s+(.{3,50})/gi,
+      /(?:i(?:'m| am) (?:a|an|the))\s+(.{3,50})/gi,
+    ];
+
+    for (const pattern of prefPatterns) {
+      let match;
+      while ((match = pattern.exec(userText)) !== null) {
+        knowledge.add('preferences', match[0].trim());
+      }
+    }
+
+    // Extract facts about projects/tech mentioned
+    const factPatterns = [
+      /(?:(?:we|i) (?:built|created|deployed|use|have|run|maintain))\s+(.{10,100})/gi,
+      /(?:the (?:project|app|service|api|database|server) (?:is|runs|uses))\s+(.{10,80})/gi,
+    ];
+
+    for (const pattern of factPatterns) {
+      let match;
+      while ((match = pattern.exec(userText)) !== null) {
+        knowledge.add('facts', match[0].trim());
+      }
+    }
+
+    // Extract people mentioned
+    const peoplePattern = /(?:(?:my|our) (?:team|boss|colleague|manager|client|partner|co-founder))\s+(.{3,50})/gi;
+    let match;
+    while ((match = peoplePattern.exec(userText)) !== null) {
+      knowledge.add('people', match[0].trim());
+    }
+  },
+
+  // Called when session ends — save episode
+  saveSessionEpisode() {
+    if (working.getMessageCount() < 3) return null; // Don't save trivial sessions
+
+    // Build summary from working memory
+    const messages = working.recentMessages;
+    const topics = [];
+
+    for (const m of messages) {
+      if (m.role === 'user' && typeof m.content === 'string') {
+        // Extract key phrases (first 60 chars of each user message)
+        topics.push(m.content.slice(0, 60).trim());
+      }
+    }
+
+    const summary = topics.length > 0
+      ? `Discussed: ${topics.slice(0, 5).join(', ')}`
+      : `Session with ${messages.length} messages`;
+
+    // Extract tags from conversation
+    const allText = messages.map(m => typeof m.content === 'string' ? m.content : '').join(' ').toLowerCase();
+    const tagKeywords = ['python', 'javascript', 'docker', 'deploy', 'api', 'database', 'email', 'marketing', 'automation', 'debug', 'test', 'build', 'react', 'node', 'css', 'html', 'git', 'aws', 'azure'];
+    const tags = tagKeywords.filter(t => allText.includes(t));
+
+    return episodic.saveEpisode(summary, tags);
+  },
+
+  // Get relevant memories for a specific query (for system prompt injection)
+  getRelevantContext(query) {
+    const parts = [];
+
+    // Search knowledge base (Tier 3)
+    const relevant = knowledge.search(query, 3);
+    if (relevant.length > 0) {
+      parts.push('Relevant memories:');
+      for (const r of relevant) {
+        parts.push(`  [${r.category}] ${r.content}`);
+      }
+    }
+
+    // Search episodes (Tier 2)
+    const episodes = episodic.search(query);
+    if (episodes.length > 0) {
+      parts.push('Related past sessions:');
+      for (const ep of episodes.slice(0, 2)) {
+        parts.push(`  [${ep.date}] ${ep.summary}`);
+      }
+    }
+
+    return parts.length > 0 ? parts.join('\n') : '';
+  },
+};
+
+module.exports = {
+  working,
+  episodic,
+  knowledge,
+  manager,
+  MEMORY_DIR,
+  EPISODES_DIR,
+  KNOWLEDGE_FILE,
+};

package/lib/skills.js

@@ -0,0 +1,222 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const config = require('./config');
+
+const SKILLS_DIR = path.join(config.CONFIG_DIR, 'skills');
+
+function ensureDir() {
+  if (!fs.existsSync(SKILLS_DIR)) fs.mkdirSync(SKILLS_DIR, { recursive: true });
+}
+
+// Parse a skill markdown file into structured data
+function parseSkill(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const lines = raw.split('\n');
+    const skill = {
+      name: path.basename(filePath, '.md'),
+      file: filePath,
+      title: '',
+      trigger: [],
+      description: '',
+      steps: '',
+      output: '',
+      raw,
+    };
+
+    let section = 'header';
+    const sectionContent = { steps: [], output: [] };
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Title
+      if (trimmed.startsWith('# ') && !skill.title) {
+        skill.title = trimmed.slice(2).trim();
+        continue;
+      }
+
+      // Metadata lines
+      if (trimmed.startsWith('trigger:')) {
+        skill.trigger = trimmed.slice(8).split(',').map(t => t.trim().replace(/"/g, '').toLowerCase()).filter(Boolean);
+        continue;
+      }
+      if (trimmed.startsWith('description:')) {
+        skill.description = trimmed.slice(12).trim();
+        continue;
+      }
+
+      // Section headers
+      if (trimmed.startsWith('## Steps')) { section = 'steps'; continue; }
+      if (trimmed.startsWith('## Output')) { section = 'output'; continue; }
+      if (trimmed.startsWith('## ')) { section = 'other'; continue; }
+
+      if (section === 'steps') sectionContent.steps.push(line);
+      if (section === 'output') sectionContent.output.push(line);
+    }
+
+    skill.steps = sectionContent.steps.join('\n').trim();
+    skill.output = sectionContent.output.join('\n').trim();
+    if (!skill.title) skill.title = skill.name;
+    if (!skill.description) skill.description = skill.title;
+
+    return skill;
+  } catch (e) {
+    return null;
+  }
+}
+
+// Load all skills
+function loadAll() {
+  ensureDir();
+  try {
+    const files = fs.readdirSync(SKILLS_DIR).filter(f => f.endsWith('.md'));
+    return files.map(f => parseSkill(path.join(SKILLS_DIR, f))).filter(Boolean);
+  } catch { return []; }
+}
+
+// Find a skill by trigger phrase
+function matchSkill(input) {
+  const lower = input.toLowerCase();
+  const skills = loadAll();
+
+  for (const skill of skills) {
+    for (const trigger of skill.trigger) {
+      if (lower.includes(trigger)) return skill;
+    }
+  }
+  return null;
+}
+
+// Get skill by name
+function getSkill(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+  const filePath = path.join(SKILLS_DIR, `${slug}.md`);
+  if (fs.existsSync(filePath)) return parseSkill(filePath);
+
+  // Try partial match
+  ensureDir();
+  const files = fs.readdirSync(SKILLS_DIR).filter(f => f.endsWith('.md'));
+  const match = files.find(f => f.toLowerCase().includes(slug));
+  if (match) return parseSkill(path.join(SKILLS_DIR, match));
+  return null;
+}
+
+// Create a new skill from structured data
+function createSkill(name, data) {
+  ensureDir();
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+  const filePath = path.join(SKILLS_DIR, `${slug}.md`);
+
+  const content = `# ${data.title || name}
+trigger: ${(data.triggers || []).map(t => `"${t}"`).join(', ')}
+description: ${data.description || ''}
+
+## Steps
+${data.steps || '1. Analyse the request\n2. Execute the task\n3. Return the result'}
+
+## Output
+${data.output || 'Formatted result based on the task'}
+`;
+
+  fs.writeFileSync(filePath, content);
+  return filePath;
+}
+
+// Delete a skill
+function deleteSkill(name) {
+  const skill = getSkill(name);
+  if (!skill) return false;
+  try {
+    fs.unlinkSync(skill.file);
+    return true;
+  } catch { return false; }
+}
+
+// Get skills summary for system prompt injection
+function getSkillsPrompt() {
+  const skills = loadAll();
+  if (skills.length === 0) return '';
+
+  const lines = ['Available user skills (invoke when request matches):'];
+  for (const s of skills) {
+    lines.push(`- "${s.title}": ${s.description}. Triggers: ${s.trigger.join(', ') || 'manual'}. Steps: ${s.steps.slice(0, 150)}`);
+  }
+  return lines.join('\n');
+}
+
+// Built-in skill templates
+const TEMPLATES = {
+  'seo-audit': {
+    title: 'SEO Audit',
+    triggers: ['seo audit', 'check seo', 'analyse website seo'],
+    description: 'Run a comprehensive SEO audit on any URL',
+    steps: `1. Use shell to curl the target URL and capture HTML
+2. Use python_exec to parse HTML — extract title, meta description, h1-h6 tags, img alt attributes, internal/external links
+3. Check: title length (50-60 chars), meta description (150-160 chars), heading hierarchy, missing alt text, broken links
+4. Score each category out of 10
+5. Generate a markdown report with scores and actionable recommendations`,
+    output: 'Markdown report: overall score, category breakdown, top 5 fixes',
+  },
+  'email-template': {
+    title: 'Marketing Email',
+    triggers: ['marketing email', 'email template', 'write email campaign'],
+    description: 'Generate a professional marketing email template',
+    steps: `1. Ask for: target audience, product/service, tone, call-to-action
+2. Write subject line (under 50 chars, no spam words)
+3. Write preview text (90 chars)
+4. Write email body: hook, value proposition, social proof, CTA
+5. Save as HTML file with inline CSS for email client compatibility`,
+    output: 'HTML email template file + plain text version',
+  },
+  'api-scaffold': {
+    title: 'REST API Scaffold',
+    triggers: ['scaffold api', 'create api', 'generate api project'],
+    description: 'Generate a complete REST API project with routes, models, and tests',
+    steps: `1. Ask for: language (Node/Python/Go), database, entity names
+2. Create project directory with standard structure
+3. Generate: package.json/requirements.txt, entry point, routes, models, middleware
+4. Add: error handling, validation, health endpoint, CORS
+5. Generate: Dockerfile, .env.example, README with API docs
+6. Run initial install and verify it starts`,
+    output: 'Complete project directory, ready to run',
+  },
+  'git-pr': {
+    title: 'Git PR Creator',
+    triggers: ['create pr', 'pull request', 'git pr'],
+    description: 'Analyse changes and create a well-documented pull request',
+    steps: `1. Run git diff to see all changes
+2. Run git log to see commit history since branch point
+3. Categorise changes: features, fixes, refactors, tests
+4. Write PR title (under 72 chars, conventional commit style)
+5. Write PR body: summary, changes list, testing notes, screenshots if UI
+6. Use shell to create the PR via gh cli`,
+    output: 'PR created with full description and labels',
+  },
+  'data-report': {
+    title: 'Data Report Generator',
+    triggers: ['analyse data', 'data report', 'generate report from'],
+    description: 'Analyse a data file and produce a visual report',
+    steps: `1. Read the data file (CSV, JSON, Excel)
+2. Use python_exec with pandas: shape, dtypes, null counts, describe()
+3. Identify key patterns: trends, outliers, correlations
+4. Generate visualisations with matplotlib (save as PNG)
+5. Write a markdown summary report with embedded charts
+6. Save report as HTML for easy sharing`,
+    output: 'HTML report with charts, summary statistics, and insights',
+  },
+};
+
+module.exports = {
+  SKILLS_DIR,
+  loadAll,
+  matchSkill,
+  getSkill,
+  createSkill,
+  deleteSkill,
+  parseSkill,
+  getSkillsPrompt,
+  TEMPLATES,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "navada-edge-cli",
-  "version": "4.0.0",
-  "description": "Interactive CLI for the NAVADA Edge Network — AI-driven hybrid cloud platform with AWS, Oracle, Azure, NVIDIA GPU compute, and 15 MCP tools",
+  "version": "4.2.0",
+  "description": "AI agent in your terminal — 3-tier memory, 16 tools, automation pipeline, bring your own model. Learns who you are, remembers across sessions.",
   "main": "lib/cli.js",
   "bin": {
     "navada": "bin/navada.js"
@@ -18,16 +18,18 @@
     "navada",
     "edge",
     "cli",
-    "tui",
-    "distributed",
-    "cloudflare",
-    "docker",
     "ai",
-    "mcp",
-    "sdk",
-    "agents",
-    "yolo",
-    "terminal"
+    "agent",
+    "terminal",
+    "memory",
+    "automation",
+    "tools",
+    "nvidia",
+    "anthropic",
+    "openai",
+    "gemini",
+    "byom",
+    "sdk"
   ],
   "author": {
     "name": "Leslie Akpareva",
@@ -43,7 +45,7 @@
   "dependencies": {
     "chalk": "^4.1.2",
     "cli-table3": "^0.6.5",
-    "navada-edge-sdk": "^1.3.0",
+    "navada-edge-sdk": "^2.0.0",
     "ora": "^5.4.1"
   },
   "optionalDependencies": {