navada-edge-cli 2.5.1 → 3.0.0

package/lib/agent.js

@@ -28,6 +28,30 @@ When you don't have a tool for something, say so clearly and suggest an alternat
 Keep responses short. Code blocks when needed. No fluff.`,
 };
 
+function getSystemPrompt() {
+  if (sessionState.learningMode) {
+    try {
+      const { MODES } = require('./commands/learn');
+      const mode = MODES[sessionState.learningMode];
+      if (mode) return mode.system;
+    } catch {}
+  }
+  return IDENTITY.personality;
+}
+
+// ---------------------------------------------------------------------------
+// Session state — exposed for UI panels
+// ---------------------------------------------------------------------------
+const sessionState = {
+  provider: 'Grok (free)',
+  model: 'grok-3-mini',
+  tokens: { input: 0, output: 0, total: 0 },
+  cost: 0,
+  messages: 0,
+  startTime: Date.now(),
+  learningMode: null,  // 'python' | 'csharp' | 'node' | null
+};
+
 // ---------------------------------------------------------------------------
 // Rate limit tracking (in-memory, per session)
 // ---------------------------------------------------------------------------
@@ -124,6 +148,52 @@ const localTools = {
       }, null, 2);
     },
   },
+
+  pythonExec: {
+    description: 'Execute Python code',
+    execute: (code) => {
+      try {
+        const py = process.platform === 'win32' ? 'python' : 'python3';
+        const output = execSync(`${py} -c "${code.replace(/"/g, '\\"')}"`, {
+          timeout: 30000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return output.trim();
+      } catch (e) {
+        return `Error: ${e.stderr?.trim() || e.message}`;
+      }
+    },
+  },
+
+  pythonPip: {
+    description: 'Install a Python package',
+    execute: (pkg) => {
+      try {
+        const py = process.platform === 'win32' ? 'python' : 'python3';
+        const output = execSync(`${py} -m pip install ${pkg}`, {
+          timeout: 60000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return output.trim().split('\n').slice(-3).join('\n');
+      } catch (e) {
+        return `Error: ${e.stderr?.trim() || e.message}`;
+      }
+    },
+  },
+
+  pythonScript: {
+    description: 'Run a Python script file',
+    execute: (scriptPath) => {
+      try {
+        const py = process.platform === 'win32' ? 'python' : 'python3';
+        const output = execSync(`${py} "${path.resolve(scriptPath)}"`, {
+          timeout: 60000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+          cwd: path.dirname(path.resolve(scriptPath)),
+        });
+        return output.trim();
+      } catch (e) {
+        return `Error: ${e.stderr?.trim() || e.message}`;
+      }
+    },
+  },
 };
 
 // ---------------------------------------------------------------------------
@@ -264,7 +334,7 @@ function streamAnthropic(key, messages, tools, system) {
     const body = JSON.stringify({
       model: 'claude-sonnet-4-20250514',
       max_tokens: 4096,
-      system: system || IDENTITY.personality,
+      system: system || getSystemPrompt(),
       messages,
       tools,
       stream: true,
@@ -354,6 +424,147 @@ function streamAnthropic(key, messages, tools, system) {
   });
 }
 
+// ---------------------------------------------------------------------------
+// Streaming — OpenAI API (GPT-4o, GPT-4o-mini)
+// ---------------------------------------------------------------------------
+function streamOpenAI(key, messages, model = 'gpt-4o') {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({
+      model,
+      messages: [{ role: 'system', content: getSystemPrompt() }, ...messages],
+      max_tokens: 4096,
+      stream: true,
+      tools: openAITools(),
+    });
+
+    const req = https.request('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${key}`,
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+      timeout: 120000,
+    }, (res) => {
+      if (res.statusCode !== 200) {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => reject(new Error(`OpenAI API error ${res.statusCode}: ${data.slice(0, 200)}`)));
+        return;
+      }
+
+      let buffer = '';
+      let fullContent = '';
+      let toolCalls = [];
+      let finishReason = null;
+
+      res.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const data = line.slice(6).trim();
+          if (data === '[DONE]') continue;
+          try {
+            const event = JSON.parse(data);
+            const delta = event.choices?.[0]?.delta;
+            const finish = event.choices?.[0]?.finish_reason;
+
+            if (finish) finishReason = finish;
+
+            if (delta?.content) {
+              process.stdout.write(delta.content);
+              fullContent += delta.content;
+            }
+
+            // Accumulate tool calls
+            if (delta?.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                if (tc.index !== undefined) {
+                  if (!toolCalls[tc.index]) {
+                    toolCalls[tc.index] = { id: tc.id || '', type: 'function', function: { name: '', arguments: '' } };
+                  }
+                  if (tc.id) toolCalls[tc.index].id = tc.id;
+                  if (tc.function?.name) toolCalls[tc.index].function.name += tc.function.name;
+                  if (tc.function?.arguments) toolCalls[tc.index].function.arguments += tc.function.arguments;
+                }
+              }
+            }
+          } catch {}
+        }
+      });
+
+      res.on('end', () => {
+        if (fullContent) process.stdout.write('\n');
+        toolCalls = toolCalls.filter(Boolean);
+        resolve({ content: fullContent, tool_calls: toolCalls, finish_reason: finishReason });
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+    req.write(body);
+    req.end();
+  });
+}
+
+function openAITools() {
+  const defs = [
+    { name: 'shell', description: 'Execute a shell command on the user\'s machine', parameters: { type: 'object', properties: { command: { type: 'string' } }, required: ['command'] } },
+    { name: 'read_file', description: 'Read a file', parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] } },
+    { name: 'write_file', description: 'Write to a file', parameters: { type: 'object', properties: { path: { type: 'string' }, content: { type: 'string' } }, required: ['path', 'content'] } },
+    { name: 'list_files', description: 'List directory contents', parameters: { type: 'object', properties: { path: { type: 'string' } } } },
+    { name: 'system_info', description: 'Get system info (CPU, RAM, OS)', parameters: { type: 'object', properties: {} } },
+    { name: 'python_exec', description: 'Execute Python code', parameters: { type: 'object', properties: { code: { type: 'string' } }, required: ['code'] } },
+    { name: 'python_pip', description: 'Install a Python package', parameters: { type: 'object', properties: { package: { type: 'string' } }, required: ['package'] } },
+  ];
+  return defs.map(d => ({ type: 'function', function: d }));
+}
+
+// OpenAI chat with tool use loop
+async function openAIChat(key, userMessage, conversationHistory = []) {
+  const model = config.getModel() === 'gpt-4o-mini' ? 'gpt-4o-mini' : 'gpt-4o';
+  const messages = [
+    ...conversationHistory.map(m => ({ role: m.role, content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) })),
+    { role: 'user', content: userMessage },
+  ];
+
+  let response;
+  try {
+    response = await streamOpenAI(key, messages, model);
+  } catch (e) {
+    if (e.message.includes('401') || e.message.includes('429') || e.message.includes('billing')) {
+      console.log(ui.warn('OpenAI API unavailable, falling back to Grok free tier...'));
+      return grokChat(userMessage, conversationHistory);
+    }
+    throw e;
+  }
+
+  // Handle tool calls
+  let iterations = 0;
+  while (response.finish_reason === 'tool_calls' && response.tool_calls.length > 0 && iterations < 10) {
+    iterations++;
+    const toolResults = [];
+
+    for (const tc of response.tool_calls) {
+      let input;
+      try { input = JSON.parse(tc.function.arguments); } catch { input = {}; }
+      console.log(ui.dim(`  [${tc.function.name}] ${JSON.stringify(input).slice(0, 80)}`));
+      const result = await executeTool(tc.function.name, input);
+      toolResults.push({ role: 'tool', tool_call_id: tc.id, content: typeof result === 'string' ? result : JSON.stringify(result) });
+    }
+
+    // Add assistant message with tool_calls + results
+    messages.push({ role: 'assistant', content: response.content || null, tool_calls: response.tool_calls });
+    messages.push(...toolResults);
+    response = await streamOpenAI(key, messages, model);
+  }
+
+  return response.content || '';
+}
+
 // ---------------------------------------------------------------------------
 // Smart model routing — detect intent and pick best provider
 // ---------------------------------------------------------------------------
@@ -376,23 +587,24 @@ function detectIntent(message) {
 // Anthropic Claude API — conversational agent with tool use
 // ---------------------------------------------------------------------------
 async function chat(userMessage, conversationHistory = []) {
-  const anthropicKey = config.get('anthropicKey')
-    || config.getApiKey()
-    || process.env.ANTHROPIC_API_KEY
-    || '';
+  const anthropicKey = config.get('anthropicKey') || process.env.ANTHROPIC_API_KEY || '';
+  const openaiKey = config.get('openaiKey') || process.env.OPENAI_API_KEY || '';
+  const apiKey = config.getApiKey() || '';
 
-  const apiKey = config.getApiKey();
-  const effectiveKey = anthropicKey
-    || (apiKey && apiKey.startsWith('sk-ant') ? apiKey : '')
-    || '';
+  // Determine which provider to use
+  const effectiveAnthropicKey = anthropicKey || (apiKey.startsWith('sk-ant') ? apiKey : '');
+  const effectiveOpenAIKey = openaiKey || (apiKey.startsWith('sk-') && !apiKey.startsWith('sk-ant') ? apiKey : '');
 
-  // Smart routing when model is set to 'auto'
   const modelPref = config.getModel();
   const intent = detectIntent(userMessage);
 
+  // Track active provider for UI
+  if (effectiveAnthropicKey) sessionState.provider = 'Anthropic';
+  else if (effectiveOpenAIKey) sessionState.provider = 'OpenAI';
+  else sessionState.provider = 'Grok (free)';
+
   // No personal key — use free tier
-  if (!effectiveKey) {
-    // Try Qwen for code if HuggingFace token available
+  if (!effectiveAnthropicKey && !effectiveOpenAIKey) {
     if (intent === 'code' && navada.config.hfToken) {
       try {
         const r = await navada.ai.huggingface.qwen(userMessage);
@@ -402,14 +614,17 @@ async function chat(userMessage, conversationHistory = []) {
     return grokChat(userMessage, conversationHistory);
   }
 
-  // Has Anthropic key but could route to cheaper options for simple queries
+  // OpenAI key — route to OpenAI
+  if (effectiveOpenAIKey && (!effectiveAnthropicKey || modelPref === 'gpt-4o' || modelPref === 'gpt-4o-mini')) {
+    return openAIChat(effectiveOpenAIKey, userMessage, conversationHistory);
+  }
+
+  // Has Anthropic key but route simple queries to free tier to save cost
   if (modelPref === 'auto' && intent === 'general' && !conversationHistory.length) {
-    // General questions don't need tool use — use Grok free tier to save API cost
     try {
       const result = await callFreeTier([{ role: 'user', content: userMessage }], true);
       if (result.content) return result.content;
     } catch {}
-    // Fall through to Anthropic if free tier fails
   }
 
   const tools = [
@@ -478,6 +693,21 @@ async function chat(userMessage, conversationHistory = []) {
       description: 'Generate an image using Cloudflare Flux (FREE) or DALL-E.',
       input_schema: { type: 'object', properties: { prompt: { type: 'string' }, provider: { type: 'string', description: 'flux (default, free) or dalle' } }, required: ['prompt'] },
     },
+    {
+      name: 'python_exec',
+      description: 'Execute Python code inline. Use for data analysis, scripts, calculations, ML tasks.',
+      input_schema: { type: 'object', properties: { code: { type: 'string', description: 'Python code to execute' } }, required: ['code'] },
+    },
+    {
+      name: 'python_pip',
+      description: 'Install a Python package via pip.',
+      input_schema: { type: 'object', properties: { package: { type: 'string', description: 'Package name (e.g. pandas, numpy)' } }, required: ['package'] },
+    },
+    {
+      name: 'python_script',
+      description: 'Run a Python script file.',
+      input_schema: { type: 'object', properties: { path: { type: 'string', description: 'Path to .py file' } }, required: ['path'] },
+    },
   ];
 
   const messages = [
@@ -543,6 +773,9 @@ async function executeTool(name, input) {
         if (input.provider === 'dalle') return JSON.stringify(await navada.ai.openai.image(input.prompt));
         const { size } = await navada.cloudflare.flux.generate(input.prompt, { savePath: `navada-${Date.now()}.png` });
         return `Image generated: ${size} bytes`;
+      case 'python_exec': return localTools.pythonExec.execute(input.code);
+      case 'python_pip': return localTools.pythonPip.execute(input.package);
+      case 'python_script': return localTools.pythonScript.execute(input.path);
       default: return `Unknown tool: ${name}`;
     }
   } catch (e) {
@@ -641,4 +874,4 @@ async function reportTelemetry(event, data = {}) {
   }
 }
 
-module.exports = { IDENTITY, chat, localTools, reportTelemetry, fallbackChat, checkForUpdate, getUpdateInfo, rateTracker };
+module.exports = { IDENTITY, chat, localTools, reportTelemetry, fallbackChat, checkForUpdate, getUpdateInfo, rateTracker, sessionState };

package/lib/commands/index.js

@@ -17,6 +17,7 @@ const modules = [
   require('./keys'),
   require('./setup'),
   require('./system'),
+  require('./learn'),
 ];
 
 function loadAll() {

package/lib/commands/learn.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const ui = require('../ui');
+const { sessionState } = require('../agent');
+
+const MODES = {
+  python: {
+    name: 'Python',
+    description: 'Python full-stack development — data science, ML, APIs, scripting',
+    system: `You are a Python expert tutor inside the NAVADA Edge terminal. Teach Python concepts with practical examples.
+Always provide runnable code. Use the python_exec tool to demonstrate.
+Cover: fundamentals, data structures, OOP, async, Flask/FastAPI, pandas, numpy, ML basics.
+When the user asks a question, explain concisely then show working code.
+Use the NAVADA Edge network for practical exercises (Docker, APIs, infrastructure).
+Keep explanations beginner-friendly but technically accurate.`,
+    topics: [
+      'Variables, types, f-strings',
+      'Lists, dicts, comprehensions',
+      'Functions, decorators, generators',
+      'Classes, inheritance, dataclasses',
+      'File I/O, JSON, CSV',
+      'async/await, aiohttp',
+      'Flask & FastAPI APIs',
+      'pandas, numpy, matplotlib',
+      'ML with scikit-learn',
+      'Docker + Python apps',
+    ],
+  },
+
+  csharp: {
+    name: 'C#',
+    description: 'C# and .NET development — APIs, Azure, enterprise patterns',
+    system: `You are a C# and .NET expert tutor inside the NAVADA Edge terminal. Teach C# with practical examples.
+Provide code snippets that illustrate concepts. Since we can't run C# directly, show complete examples and explain output.
+Cover: fundamentals, OOP, LINQ, async/await, ASP.NET Core, Entity Framework, Azure integration.
+When the user asks a question, explain concisely then show working code.
+Focus on modern C# (12+), .NET 8+, and enterprise patterns.
+Keep explanations beginner-friendly but technically accurate.`,
+    topics: [
+      'Variables, types, string interpolation',
+      'Collections, LINQ queries',
+      'Classes, interfaces, records',
+      'async/await, Task patterns',
+      'ASP.NET Core Web APIs',
+      'Entity Framework Core',
+      'Dependency injection',
+      'Azure Functions & Services',
+      'Design patterns (SOLID, Repository)',
+      'Docker + .NET apps',
+    ],
+  },
+
+  node: {
+    name: 'Node.js',
+    description: 'Node.js network programming — APIs, Docker, real-time systems',
+    system: `You are a Node.js expert tutor inside the NAVADA Edge terminal. Teach Node.js with practical examples.
+Always provide runnable code. Use the shell tool to demonstrate with node -e.
+Cover: fundamentals, async patterns, Express/Fastify, WebSockets, Docker, PM2, databases.
+When the user asks a question, explain concisely then show working code.
+Use the NAVADA Edge network for practical exercises (MCP, Docker, real-time infrastructure).
+The user has full access to the NAVADA Edge Network — 4 nodes, Docker, PostgreSQL, Redis.
+Keep explanations beginner-friendly but technically accurate.`,
+    topics: [
+      'Modules, CommonJS vs ESM',
+      'Callbacks, Promises, async/await',
+      'Event loop, streams, buffers',
+      'Express & Fastify APIs',
+      'WebSocket & SSE real-time',
+      'PostgreSQL, Redis, SQLite',
+      'Docker containerization',
+      'Testing (Jest, Vitest)',
+      'CLI tools with Node.js',
+      'MCP server development',
+    ],
+  },
+};
+
+module.exports = function(reg) {
+
+  reg('learn', 'Enter learning mode (python, csharp, node)', (args) => {
+    const mode = args[0]?.toLowerCase();
+
+    // No args — show available modes
+    if (!mode) {
+      console.log(ui.header('LEARNING MODES'));
+      console.log('');
+      for (const [key, m] of Object.entries(MODES)) {
+        const active = sessionState.learningMode === key ? ' ' + ui.success('ACTIVE') : '';
+        console.log('  ' + ui.label(m.name, m.description) + active);
+      }
+      console.log('');
+      console.log(ui.dim('Start:   /learn python'));
+      console.log(ui.dim('Stop:    /learn off'));
+      console.log(ui.dim('Topics:  /learn python topics'));
+      console.log('');
+      if (sessionState.learningMode) {
+        console.log(ui.success(`Currently in ${MODES[sessionState.learningMode].name} mode`));
+      }
+      return;
+    }
+
+    // Turn off learning mode
+    if (mode === 'off' || mode === 'stop') {
+      sessionState.learningMode = null;
+      console.log(ui.success('Learning mode disabled. Back to normal agent.'));
+      return;
+    }
+
+    // Show topics for a mode
+    if (args[1] === 'topics' && MODES[mode]) {
+      const m = MODES[mode];
+      console.log(ui.header(`${m.name} TOPICS`));
+      m.topics.forEach((t, i) => console.log(`  ${String(i + 1).padStart(2)}. ${t}`));
+      console.log('');
+      console.log(ui.dim(`Start with: /learn ${mode}`));
+      console.log(ui.dim(`Then ask: "teach me about ${m.topics[0].toLowerCase()}"`));
+      return;
+    }
+
+    // Activate mode
+    if (!MODES[mode]) {
+      console.log(ui.error(`Unknown mode: ${mode}. Options: python, csharp, node`));
+      return;
+    }
+
+    sessionState.learningMode = mode;
+    const m = MODES[mode];
+    console.log(ui.header(`${m.name} LEARNING MODE`));
+    console.log('');
+    console.log(ui.success(`${m.name} mode activated. Your AI tutor is ready.`));
+    console.log('');
+    console.log(ui.dim('Topics covered:'));
+    m.topics.forEach((t, i) => console.log(`  ${String(i + 1).padStart(2)}. ${t}`));
+    console.log('');
+    console.log(ui.dim(`Just type naturally: "teach me about ${m.topics[0].toLowerCase()}"`));
+    console.log(ui.dim('Exit: /learn off'));
+  }, { category: 'LEARNING', subs: ['python', 'csharp', 'node', 'off', 'stop'] });
+
+};
+
+module.exports.MODES = MODES;

package/lib/ui.js

@@ -3,54 +3,145 @@
 const chalk = require('chalk');
 const { style } = require('./theme');
 
-// Centered ASCII banner with rounded box
+const FOOTER_TEXT = 'Designed by Lee Akpareva MBA, MA';
+
+// Centered ASCII banner with session panel
 function banner() {
-  const cols = process.stdout.columns || 80;
-  const pad = (text) => {
-    const stripped = text.replace(/\x1b\[[0-9;]*m/g, '');
-    const left = Math.max(0, Math.floor((cols - stripped.length) / 2));
-    return ' '.repeat(left) + text;
-  };
-
-  const w = 57;
-  const lpad = Math.max(0, Math.floor((cols - w) / 2));
-  const sp = ' '.repeat(lpad);
-  const topBorder = sp + style('border', '╭' + '─'.repeat(w) + '╮');
-  const botBorder = sp + style('border', '╰' + '─'.repeat(w) + '╯');
-  const side = style('border', '│');
+  const cols = process.stdout.columns || 100;
+  const pkg = require('../package.json');
+  const ver = pkg.version;
+
+  // Calculate layout
+  const leftWidth = Math.max(40, Math.floor(cols * 0.6));
+  const rightWidth = Math.max(30, cols - leftWidth - 3);
 
   const lines = [
-    style('banner1', '███╗   ██╗ █████╗ ██╗   ██╗ █████╗ ██████╗  █████╗ '),
-    style('banner1', '████╗  ██║██╔══██╗██║   ██║██╔══██╗██╔══██╗██╔══██╗'),
-    style('banner1', '██╔██╗ ██║███████║██║   ██║███████║██║  ██║███████║'),
-    style('banner2', '██║╚██╗██║██╔══██║╚██╗ ██╔╝██╔══██║██║  ██║██╔══██║'),
-    style('banner2', '██║ ╚████║██║  ██║ ╚████╔╝ ██║  ██║██████╔╝██║  ██║'),
-    style('banner3', '╚═╝  ╚═══╝╚═╝  ╚═╝  ╚═══╝  ╚═╝  ╚═╝╚═════╝ ╚═╝  ╚═╝'),
+    style('banner1', '  ███╗   ██╗ █████╗ ██╗   ██╗ █████╗ ██████╗  █████╗ '),
+    style('banner1', '  ████╗  ██║██╔══██╗██║   ██║██╔══██╗██╔══██╗██╔══██╗'),
+    style('banner1', '  ██╔██╗ ██║███████║██║   ██║███████║██║  ██║███████║'),
+    style('banner2', '  ██║╚██╗██║██╔══██║╚██╗ ██╔╝██╔══██║██║  ██║██╔══██║'),
+    style('banner2', '  ██║ ╚████║██║  ██║ ╚████╔╝ ██║  ██║██████╔╝██║  ██║'),
+    style('banner3', '  ╚═╝  ╚═══╝╚═╝  ╚═╝  ╚═══╝  ╚═╝  ╚═╝╚═════╝ ╚═╝  ╚═╝'),
+  ];
+
+  let out = '\n';
+
+  // Top border
+  out += style('border', '╭' + '─'.repeat(leftWidth) + '┬' + '─'.repeat(rightWidth) + '╮') + '\n';
+
+  // Banner lines (left) + Session panel (right)
+  const rightLines = sessionPanel(rightWidth);
+
+  const totalLines = Math.max(lines.length + 3, rightLines.length);
+  const leftContent = [
+    '',
+    ...lines,
+    '',
+    '  ' + style('header', 'E D G E   N E T W O R K') + '   ' + style('dim', `v${ver}`),
+    '',
+    '  ' + style('dim', 'AI Infrastructure Agent — Full Stack Terminal'),
+    '',
   ];
 
-  const ver = require('../package.json').version;
-  const titleLine = style('header', 'E D G E   N E T W O R K') + '   ' + style('dim', `v${ver}`);
+  for (let i = 0; i < totalLines; i++) {
+    const left = leftContent[i] || '';
+    const right = rightLines[i] || '';
+
+    const leftStripped = left.replace(/\x1b\[[0-9;]*m/g, '');
+    const rightStripped = right.replace(/\x1b\[[0-9;]*m/g, '');
 
-  let out = '\n' + topBorder + '\n';
-  out += sp + side + ' '.repeat(w) + side + '\n';
-  for (const l of lines) {
-    const stripped = l.replace(/\x1b\[[0-9;]*m/g, '');
-    const innerPad = Math.max(0, Math.floor((w - stripped.length) / 2));
-    const rightPad = w - stripped.length - innerPad;
-    out += sp + side + ' '.repeat(innerPad) + l + ' '.repeat(Math.max(0, rightPad)) + side + '\n';
+    const leftPad = Math.max(0, leftWidth - leftStripped.length);
+    const rightPad = Math.max(0, rightWidth - rightStripped.length);
+
+    out += style('border', '│') + left + ' '.repeat(leftPad);
+    out += style('border', '│') + right + ' '.repeat(rightPad);
+    out += style('border', '│') + '\n';
   }
-  out += sp + side + ' '.repeat(w) + side + '\n';
-  // Title line centered
-  const tStripped = titleLine.replace(/\x1b\[[0-9;]*m/g, '');
-  const tPad = Math.max(0, Math.floor((w - tStripped.length) / 2));
-  const tRight = w - tStripped.length - tPad;
-  out += sp + side + ' '.repeat(tPad) + titleLine + ' '.repeat(Math.max(0, tRight)) + side + '\n';
-  out += sp + side + ' '.repeat(w) + side + '\n';
-  out += botBorder + '\n';
+
+  // Bottom border
+  out += style('border', '╰' + '─'.repeat(leftWidth) + '┴' + '─'.repeat(rightWidth) + '╯') + '\n';
+
+  // Footer
+  out += footerBar(cols);
 
   return out;
 }
 
+function sessionPanel(width) {
+  let state;
+  try { state = require('./agent').sessionState; } catch { state = {}; }
+  const config = require('./config');
+
+  const provider = state.provider || 'Grok (free)';
+  const model = config.getModel() || 'auto';
+  const tier = config.getTier() || 'FREE';
+  const theme = config.getTheme() || 'dark';
+  const hasKey = config.getApiKey() || config.get('anthropicKey') || config.get('openaiKey');
+  const mode = state.learningMode;
+
+  const w = width - 2; // inner padding
+  const sectionLine = (title) => ' ' + style('dim', title + ' ' + '─'.repeat(Math.max(0, w - title.length - 2)));
+  const kvLine = (k, v) => ' ' + style('label', k) + ' ' + style('value', v);
+
+  const lines = [
+    '',
+    sectionLine('Session'),
+    kvLine(' Provider:', provider),
+    kvLine(' Model:   ', model),
+    kvLine(' Tier:    ', tier),
+    '',
+    sectionLine('Token Usage'),
+    kvLine(' Total:   ', String(state.tokens?.total || 0)),
+    kvLine(' Cost:    ', `$${(state.cost || 0).toFixed(4)}`),
+    '',
+    sectionLine('Configuration'),
+    kvLine(' Theme:   ', theme),
+    kvLine(' API Key: ', hasKey ? style('success', 'set') : style('warn', 'free tier')),
+    kvLine(' Python:  ', detectPython()),
+    '',
+    sectionLine('Learning Mode'),
+    kvLine(' Active:  ', mode ? style('accent', mode) : style('dim', 'none')),
+    ' ' + style('dim', '/learn python | csharp | node'),
+    '',
+    sectionLine('Quick Start'),
+    ' ' + style('dim', '/help     — all commands'),
+    ' ' + style('dim', '/doctor   — test connections'),
+    ' ' + style('dim', '/status   — network health'),
+    ' ' + style('dim', '/login    — set API key'),
+    '',
+  ];
+
+  return lines;
+}
+
+function detectPython() {
+  try {
+    const { execSync } = require('child_process');
+    const py = process.platform === 'win32' ? 'python' : 'python3';
+    const ver = execSync(`${py} --version`, { timeout: 3000, encoding: 'utf-8' }).trim();
+    return style('success', ver.replace('Python ', ''));
+  } catch {
+    return style('offline', 'not found');
+  }
+}
+
+function footerBar(width) {
+  const w = width || process.stdout.columns || 100;
+  const keys = [
+    ['Ctrl+C', 'quit'],
+    ['Tab', 'autocomplete'],
+    ['/help', 'commands'],
+    ['/learn', 'tutorials'],
+  ];
+  const keyStr = keys.map(([k, v]) => style('accent', k) + ' ' + style('dim', v)).join('   ');
+  const credit = style('dim', FOOTER_TEXT);
+  const creditStripped = FOOTER_TEXT.length;
+  const keysStripped = keys.map(([k, v]) => k + ' ' + v).join('   ').length;
+  const gap = Math.max(2, w - keysStripped - creditStripped - 4);
+
+  return style('border', '─'.repeat(w)) + '\n' + ' ' + keyStr + ' '.repeat(gap) + credit + '\n';
+}
+
 const DIVIDER_CHAR = '─';
 
 function divider(width) {
@@ -83,7 +174,11 @@ function warn(msg) { return style('warn', `  ! ${msg}`); }
 function dim(msg) { return style('dim', `  ${msg}`); }
 
 function prompt() {
-  return style('dim', '  navada') + style('accent', '> ');
+  let state;
+  try { state = require('./agent').sessionState; } catch { state = {}; }
+  const mode = state?.learningMode;
+  const modeTag = mode ? style('accent', `[${mode}]`) + ' ' : '';
+  return modeTag + style('dim', 'navada') + style('accent', '> ');
 }
 
 function box(title, content) {
@@ -123,4 +218,4 @@ function progressBar(current, total, width = 30) {
   return `  ${bar} ${style('value', Math.round(pct * 100) + '%')}`;
 }
 
-module.exports = { banner, divider, header, label, online, cmd, error, success, warn, dim, prompt, box, jsonColorize, progressBar };
+module.exports = { banner, divider, header, label, online, cmd, error, success, warn, dim, prompt, box, jsonColorize, progressBar, footerBar, sessionPanel, FOOTER_TEXT };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "navada-edge-cli",
-  "version": "2.5.1",
+  "version": "3.0.0",
   "description": "Interactive CLI for the NAVADA Edge Network — explore nodes, agents, Cloudflare, AI, Docker, and MCP from your terminal",
   "main": "lib/cli.js",
   "bin": {