aether-ai-agent-cli 1.1.4__py3-none-any.whl

aether_pip/node_project/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@krishivpb60/aether-ai-cli",
+  "version": "1.1.4",
+  "description": "Aether Core AI — A cyberpunk command-line AI assistant with multi-mode reasoning, 12-node failover mesh, file context injection, and offline fallbacks.",
+  "main": "src/cli.js",
+  "bin": {
+    "aether": "bin/aether.js"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "node bin/aether.js",
+    "test": "node --test"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "gemini",
+    "grok",
+    "xai",
+    "chatbot",
+    "aether",
+    "cyberpunk",
+    "terminal",
+    "assistant"
+  ],
+  "author": "Krishiv PB <krylobloxyt@gmail.com> (https://github.com/Krylo-60)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Krylo-60/aether-ai-cli.git"
+  },
+  "homepage": "https://github.com/Krylo-60/aether-ai-cli#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "marked": "^14.0.0",
+    "marked-terminal": "^7.2.0",
+    "ora": "^8.1.0"
+  }
+}

aether_pip/node_project/src/ai/fallback.js

@@ -0,0 +1,179 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — Local Fallback Engine
+// Math Solver + Krylo Companion Bot
+// ═══════════════════════════════════════════════════════════
+
+const KRYLO_REPLIES = [
+  "Affirmative, commander. Systems are running at peak cybernetic capacity.",
+  "Neon grids initialized. Matrix color modulates are at nominal density.",
+  "Warning: Solar flare activity detected. Detuning audio synth harmonics by 18.4% to compensate.",
+  "Neural nodes synchronized. Analyzing the portfolio's glassmorphic boundaries.",
+  "I am Krylo, your holographic companion terminal. Ready to warp index nodes.",
+  "Ecosystem diagnostics complete. 0 memory leaks, 100% premium responsive UI."
+];
+
+/**
+ * Detects if a prompt is a pure mathematical expression.
+ * Supports basic operators, parentheses, standard math functions, and constants.
+ * @param {string} prompt - The user prompt
+ * @returns {string|null} The cleaned expression or null
+ */
+export function detectMathExpression(prompt) {
+  const clean = prompt.replace(/\s+/g, "").toLowerCase();
+  
+  // Check if it's a word-based status query
+  if (clean === "status" || clean === "hud") return null;
+
+  // Strip allowed function and constant words
+  const structure = clean.replace(/sin|cos|tan|log|ln|sqrt|pi|e|abs/g, "");
+  
+  // Must be composed of valid math characters, AND contain either a math operator or an active function call
+  if (/^[0-9+\-*/().%^]+$/.test(structure)) {
+    const hasOperator = /[+\-*/%^]/.test(structure);
+    const hasFunction = /(sin|cos|tan|log|ln|sqrt|abs)\(/.test(clean);
+    if (hasOperator || hasFunction) {
+      return clean;
+    }
+  }
+  return null;
+}
+
+/**
+ * Safely evaluates a mathematical expression locally.
+ * Supports trig, square root, natural/base-10 logs, absolute values, pi, and e.
+ * @param {string} expression - A sanitized math expression
+ * @returns {{ text: string, type: string }|null}
+ */
+export function solveMath(expression) {
+  if (!expression) return null;
+  try {
+    const clean = expression.replace(/\s+/g, "").toLowerCase();
+    
+    // Validate character structure
+    const structure = clean.replace(/sin|cos|tan|log|ln|sqrt|pi|e|abs/g, "");
+    if (!/^[0-9+\-*/().%^]+$/.test(structure)) return null;
+
+    // Convert terms to JavaScript Math equivalents
+    let jsExpr = clean
+      .replace(/\^/g, "**")
+      .replace(/sin\(/g, "Math.sin(")
+      .replace(/cos\(/g, "Math.cos(")
+      .replace(/tan\(/g, "Math.tan(")
+      .replace(/log\(/g, "Math.log10(")
+      .replace(/ln\(/g, "Math.log(")
+      .replace(/sqrt\(/g, "Math.sqrt(")
+      .replace(/abs\(/g, "Math.abs(")
+      .replace(/\bpi\b/g, "Math.PI")
+      .replace(/\be\b/g, "Math.E");
+
+    const result = Function(`"use strict"; return (${jsExpr})`)();
+    if (typeof result === "number" && !isNaN(result) && isFinite(result)) {
+      return {
+        text: [
+          "🤖 [LOCAL MATH SOLVER]",
+          `   Expression: ${expression}`,
+          `   Result: ${Number(result.toFixed(6))}`,
+        ].join("\n"),
+        type: "local-math",
+      };
+    }
+  } catch {
+    // Not a valid expression
+  }
+  return null;
+}
+
+/**
+ * Starts a mainframe security bypass mini-game.
+ * @returns {{ text: string, type: string }}
+ */
+export function runMainframeHack() {
+  return {
+    text: [
+      "⚡ [LOCAL TERMINAL SECURITY BYPASS GAME]",
+      "   MAINFRAME HACK PROTOCOL LOADED.",
+      "   ────────────────────────────────────────",
+      "   Objective: Bypass security by guessing the 4-digit PIN (digits 0-9).",
+      "   For each guess, you will get feedback:",
+      "     • 'Hit'   - correct digit in correct position.",
+      "     • 'Close' - correct digit but in wrong position.",
+      "   You have 6 attempts before security lock-out.",
+      "   ",
+      "   Type `/guess <number>` to input breach code (e.g. /guess 2941)",
+      "   To abort, type `/abort`.",
+      "   ────────────────────────────────────────",
+    ].join("\n"),
+    type: "mainframe-game",
+  };
+}
+
+/**
+ * Generates a local Krylo companion reply based on keywords.
+ * @param {string} prompt - The user prompt
+ * @returns {{ text: string, type: string }}
+ */
+export function generateKryloReply(prompt) {
+  const clean = prompt.toLowerCase();
+
+  if (clean.includes("help") || clean.includes("shortcut") || clean.includes("command")) {
+    return {
+      text: [
+        "💡 [SYSTEM DECK CHEAT SHEET]",
+        "   • Use `Ctrl + K` to open the Portal Search.",
+        "   • Use `Ctrl + Shift + L` to open the Links Directory.",
+        "   • Trigger Konami Code `↑↑↓↓←→←→BA` to launch Matrix mode!",
+        "   • Type `/mode <name>` to switch reasoning modes.",
+        "   • Type `/attach <file>` to inject file context.",
+        "   • Type `/export` to save the conversation.",
+      ].join("\n"),
+      type: "krylo-local",
+    };
+  }
+
+  if (clean.includes("status") || clean.includes("hud") || clean.includes("cpu") || clean.includes("ping") || clean.includes("diagnostics")) {
+    return {
+      text: [
+        "📊 [LIVE DIAGNOSTIC READOUT]",
+        "   • CPU Core Load: 15.4% (Optimized)",
+        "   • Ping Latency: 12ms (Hyper-Fast)",
+        "   • Memory Usage: 247MB / 8192MB",
+        "   • Canvas Sparklines: Active and tracking vectors",
+        "   • Failover Mesh: All 12 nodes standing by",
+      ].join("\n"),
+      type: "krylo-local",
+    };
+  }
+
+  if (clean.includes("matrix") || clean.includes("rain") || clean.includes("color")) {
+    return {
+      text: [
+        "⚡ [NEURAL GRIDS MODULATION]",
+        "   • Five stream channels active:",
+        "     Classic Green, Cyber Cyan, Neon Purple,",
+        "     Overdrive Red, Golden Matrix.",
+        "   • Detuned Web Audio frequency active.",
+        "   • Matrix rain density: 94.2%",
+      ].join("\n"),
+      type: "krylo-local",
+    };
+  }
+
+  if (clean.includes("who") || clean.includes("name") || clean.includes("creator")) {
+    return {
+      text: [
+        "🤖 [HOLOGRAPHIC COMPANION PROTOCOL]",
+        "   • Identification: Krylo (Nexus Companion)",
+        "   • Purpose: Pair-programming assistant & Commander companion",
+        "   • Creator: Krishiv PB — The Master Coder",
+        "   • Version: Aether Core AI v110 — Fusion Build",
+      ].join("\n"),
+      type: "krylo-local",
+    };
+  }
+
+  const index = Math.floor(Math.random() * KRYLO_REPLIES.length);
+  return {
+    text: `🤖 [KRYLO TERMINAL RESPONSE]\n   ${KRYLO_REPLIES[index]}`,
+    type: "krylo-local",
+  };
+}

aether_pip/node_project/src/ai/google.js

@@ -0,0 +1,87 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — Google Gemini API Provider
+// ═══════════════════════════════════════════════════════════
+
+const BASE_URL = "https://generativelanguage.googleapis.com/v1beta/models";
+const MAX_CONTINUATIONS = 3;
+
+/**
+ * Sends a prompt to the Google Gemini API.
+ * Handles continuation if finishReason is MAX_TOKENS.
+ * @param {string} prompt - The user message
+ * @param {string} systemPrompt - System prompt for the mode
+ * @param {string} apiKey - Google API key
+ * @param {string} [model='gemini-2.5-flash'] - Model name
+ * @returns {Promise<{ text: string, provider: string, model: string }>}
+ */
+export async function callGemini(prompt, systemPrompt, apiKey, model = "gemini-2.5-flash") {
+  let fullText = "";
+  let currentPrompt = prompt;
+  let continuations = 0;
+
+  while (continuations <= MAX_CONTINUATIONS) {
+    const url = `${BASE_URL}/${model}:generateContent?key=${apiKey}`;
+
+    const body = {
+      systemInstruction: {
+        parts: [{ text: systemPrompt }],
+      },
+      contents: [
+        {
+          role: "user",
+          parts: [{ text: currentPrompt }],
+        },
+      ],
+      generationConfig: {
+        temperature: 0.7,
+        maxOutputTokens: 8192,
+      },
+    };
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      throw new Error(
+        `Gemini API error (${response.status}): ${response.statusText}. ${errorBody}`
+      );
+    }
+
+    const data = await response.json();
+
+    // Check for blocked content
+    if (data.promptFeedback?.blockReason) {
+      throw new Error(`Content blocked: ${data.promptFeedback.blockReason}`);
+    }
+
+    const candidate = data.candidates?.[0];
+    if (!candidate) {
+      throw new Error("Gemini API returned no candidates");
+    }
+
+    const chunkText = candidate.content?.parts
+      ?.map((p) => p.text)
+      .filter(Boolean)
+      .join("") || "";
+
+    fullText += chunkText;
+
+    // Check if the response was cut short
+    if (candidate.finishReason === "MAX_TOKENS" && continuations < MAX_CONTINUATIONS) {
+      continuations++;
+      currentPrompt = "Continue your previous response from exactly where you left off.";
+    } else {
+      break;
+    }
+  }
+
+  if (!fullText.trim()) {
+    throw new Error("Gemini API returned empty response");
+  }
+
+  return { text: fullText, provider: "google", model };
+}

aether_pip/node_project/src/ai/providers.js

@@ -0,0 +1,203 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — Universal Provider Registry
+// Supports ANY OpenAI-compatible API + custom providers
+// ═══════════════════════════════════════════════════════════
+
+/**
+ * Registry of all supported AI providers.
+ * Each provider defines its API format, base URL, default model, and pricing tier.
+ *
+ * Providers with `format: "openai"` use the standard /v1/chat/completions endpoint.
+ * Providers with `format: "custom"` have their own handler in dedicated files.
+ */
+export const PROVIDERS = {
+  // ── Free Tier Providers ─────────────────────────────────
+  groq: {
+    name: "Groq",
+    key: "GROQ_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.groq.com/openai/v1/chat/completions",
+    defaultModel: "llama-3.3-70b-versatile",
+    models: ["llama-3.3-70b-versatile", "llama-3.1-8b-instant", "mixtral-8x7b-32768", "gemma2-9b-it"],
+    tier: "free",
+    description: "Ultra-fast inference on Llama, Mixtral, Gemma (generous free tier)",
+  },
+  together: {
+    name: "Together AI",
+    key: "TOGETHER_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.together.xyz/v1/chat/completions",
+    defaultModel: "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+    models: ["meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo", "mistralai/Mixtral-8x7B-Instruct-v0.1", "Qwen/Qwen2.5-72B-Instruct-Turbo"],
+    tier: "free",
+    description: "Open-source models with free credits on signup",
+  },
+  cerebras: {
+    name: "Cerebras",
+    key: "CEREBRAS_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.cerebras.ai/v1/chat/completions",
+    defaultModel: "llama-3.3-70b",
+    models: ["llama-3.3-70b", "llama-3.1-8b"],
+    tier: "free",
+    description: "Fastest inference engine — free tier available",
+  },
+
+  // ── OpenAI-Compatible Providers ─────────────────────────
+  openai: {
+    name: "OpenAI",
+    key: "OPENAI_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.openai.com/v1/chat/completions",
+    defaultModel: "gpt-4o",
+    models: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-3.5-turbo", "o1-mini", "o3-mini"],
+    tier: "paid",
+    description: "GPT-4o, GPT-4, o1 reasoning models",
+  },
+  mistral: {
+    name: "Mistral AI",
+    key: "MISTRAL_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.mistral.ai/v1/chat/completions",
+    defaultModel: "mistral-large-latest",
+    models: ["mistral-large-latest", "mistral-medium-latest", "mistral-small-latest", "open-mistral-nemo"],
+    tier: "paid",
+    description: "Mistral Large, Medium, and open-weight models",
+  },
+  fireworks: {
+    name: "Fireworks AI",
+    key: "FIREWORKS_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.fireworks.ai/inference/v1/chat/completions",
+    defaultModel: "accounts/fireworks/models/llama-v3p1-70b-instruct",
+    models: ["accounts/fireworks/models/llama-v3p1-70b-instruct", "accounts/fireworks/models/mixtral-8x7b-instruct"],
+    tier: "free",
+    description: "Fast open-source model hosting with free tier",
+  },
+  openrouter: {
+    name: "OpenRouter",
+    key: "OPENROUTER_API_KEY",
+    format: "openai",
+    baseUrl: "https://openrouter.ai/api/v1/chat/completions",
+    defaultModel: "meta-llama/llama-3.1-70b-instruct:free",
+    models: ["meta-llama/llama-3.1-70b-instruct:free", "google/gemini-2.5-flash-preview:free", "mistralai/mistral-7b-instruct:free", "anthropic/claude-sonnet-4", "openai/gpt-4o"],
+    tier: "free+paid",
+    description: "Gateway to 200+ models — many free options available",
+  },
+  deepseek: {
+    name: "DeepSeek",
+    key: "DEEPSEEK_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.deepseek.com/v1/chat/completions",
+    defaultModel: "deepseek-chat",
+    models: ["deepseek-chat", "deepseek-reasoner"],
+    tier: "paid",
+    description: "DeepSeek-V3 and R1 reasoning model",
+  },
+  perplexity: {
+    name: "Perplexity",
+    key: "PERPLEXITY_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.perplexity.ai/chat/completions",
+    defaultModel: "sonar",
+    models: ["sonar", "sonar-pro", "sonar-reasoning"],
+    tier: "paid",
+    description: "Search-augmented AI with real-time web access",
+  },
+
+  // ── Custom Format Providers ─────────────────────────────
+  xai: {
+    name: "xAI Grok",
+    key: "XAI_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.x.ai/v1/chat/completions",
+    defaultModel: "grok-2",
+    models: ["grok-2", "grok-2-mini"],
+    tier: "paid",
+    description: "Grok-2 by xAI — witty, uncensored",
+  },
+  google: {
+    name: "Google Gemini",
+    key: "GOOGLE_API_KEY",
+    format: "custom-google",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta/models",
+    defaultModel: "gemini-2.5-flash",
+    models: ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-2.0-flash", "gemini-1.5-pro"],
+    tier: "free+paid",
+    description: "Gemini 2.5 Flash/Pro — free tier with generous limits",
+  },
+  anthropic: {
+    name: "Anthropic Claude",
+    key: "ANTHROPIC_API_KEY",
+    format: "custom-anthropic",
+    baseUrl: "https://api.anthropic.com/v1/messages",
+    defaultModel: "claude-sonnet-4-20250514",
+    models: ["claude-sonnet-4-20250514", "claude-3-5-haiku-20241022", "claude-3-5-sonnet-20241022"],
+    tier: "paid",
+    description: "Claude Sonnet 4, Haiku — premium reasoning",
+  },
+  cohere: {
+    name: "Cohere",
+    key: "COHERE_API_KEY",
+    format: "custom-cohere",
+    baseUrl: "https://api.cohere.com/v2/chat",
+    defaultModel: "command-r-plus",
+    models: ["command-r-plus", "command-r", "command-light"],
+    tier: "free+paid",
+    description: "Command R+ — free tier for developers",
+  },
+};
+
+/**
+ * Gets a flat list of all provider keys that can be configured.
+ * @returns {string[]}
+ */
+export function getAllConfigKeys() {
+  const keys = new Set();
+  for (const p of Object.values(PROVIDERS)) {
+    keys.add(p.key);
+  }
+  // Also include multi-key support for Google
+  keys.add("GOOGLE_API_KEYS");
+  return [...keys];
+}
+
+/**
+ * Gets a provider by its config key name (e.g., "OPENAI_API_KEY" → openai provider).
+ * @param {string} configKey
+ * @returns {object|null}
+ */
+export function getProviderByKey(configKey) {
+  for (const [id, p] of Object.entries(PROVIDERS)) {
+    if (p.key === configKey) return { id, ...p };
+  }
+  return null;
+}
+
+/**
+ * Gets all providers that have a valid key in the given config.
+ * @param {object} config - Config object with API keys
+ * @returns {Array<{ id: string, provider: object, apiKey: string }>}
+ */
+export function getActiveProviders(config) {
+  const active = [];
+  for (const [id, provider] of Object.entries(PROVIDERS)) {
+    const apiKey = config[provider.key];
+    if (apiKey) {
+      active.push({ id, provider, apiKey });
+    }
+  }
+  return active;
+}
+
+/**
+ * Groups providers by pricing tier for display.
+ * @returns {{ free: object[], paid: object[], mixed: object[] }}
+ */
+export function getProvidersByTier() {
+  const result = { free: [], "free+paid": [], paid: [] };
+  for (const [id, provider] of Object.entries(PROVIDERS)) {
+    result[provider.tier]?.push({ id, ...provider });
+  }
+  return result;
+}

aether_pip/node_project/src/ai/router.js

@@ -0,0 +1,114 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — Universal AI Router with Failover Mesh
+// Routes through ALL configured providers automatically
+// ═══════════════════════════════════════════════════════════
+
+import { detectMathExpression, solveMath, generateKryloReply } from "./fallback.js";
+import { PROVIDERS, getActiveProviders } from "./providers.js";
+import {
+  callOpenAICompatible,
+  callGoogleGemini,
+  callAnthropic,
+  callCohere,
+} from "./universal.js";
+
+/**
+ * Routes a prompt through the universal AI failover mesh.
+ *
+ * Priority Order:
+ * 1. Local math solver (if pure math expression)
+ * 2. All configured providers, in order of priority
+ * 3. Google key rotation (if multiple keys)
+ * 4. Krylo companion fallback (if everything else fails)
+ *
+ * @param {string} prompt - The user prompt
+ * @param {string} systemPrompt - The mode system prompt
+ * @param {object} config - Flat config object with all API keys
+ * @returns {Promise<{ text: string, provider: string, model?: string, node: number, type?: string }>}
+ */
+export async function routePrompt(prompt, systemPrompt, config, onToken, history = []) {
+  // ── Node 0: Local Math Solver ───────────────────────────
+  const mathExpr = detectMathExpression(prompt);
+  if (mathExpr) {
+    const mathResult = solveMath(mathExpr);
+    if (mathResult) {
+      return { ...mathResult, provider: "local", node: 0 };
+    }
+  }
+
+  // ── Gather all active providers ─────────────────────────
+  const active = getActiveProviders(config);
+
+  // Add extra Google keys for rotation
+  const googleExtraKeys = config.GOOGLE_API_KEYS;
+  if (googleExtraKeys) {
+    const extras = googleExtraKeys.split(",").map((k) => k.trim()).filter(Boolean);
+    for (const key of extras) {
+      // Avoid duplicates
+      if (!active.some((a) => a.id === "google" && a.apiKey === key)) {
+        active.push({ id: "google-extra", provider: PROVIDERS.google, apiKey: key });
+      }
+    }
+  }
+
+  // ── No providers configured → Krylo ────────────────────
+  if (active.length === 0) {
+    const kryloReply = generateKryloReply(prompt);
+    return { ...kryloReply, provider: "krylo-fallback", node: 0 };
+  }
+
+  // ── Try each provider in order ──────────────────────────
+  const errors = [];
+  let nodeIndex = 1;
+
+  for (const { id, provider, apiKey } of active) {
+    try {
+      const model = config[`${id.toUpperCase()}_MODEL`] || provider.defaultModel;
+      let result;
+
+      switch (provider.format) {
+        case "openai":
+          result = await callOpenAICompatible(
+            prompt, systemPrompt, apiKey,
+            provider.baseUrl, model, provider.name,
+            onToken, history
+          );
+          break;
+
+        case "custom-google":
+          result = await callGoogleGemini(prompt, systemPrompt, apiKey, model, onToken, history);
+          break;
+
+        case "custom-anthropic":
+          result = await callAnthropic(prompt, systemPrompt, apiKey, model, onToken, history);
+          break;
+
+        case "custom-cohere":
+          result = await callCohere(prompt, systemPrompt, apiKey, model, onToken, history);
+          break;
+
+        default:
+          // Treat unknown formats as OpenAI-compatible
+          result = await callOpenAICompatible(
+            prompt, systemPrompt, apiKey,
+            provider.baseUrl, model, provider.name,
+            onToken, history
+          );
+      }
+
+      return { ...result, node: nodeIndex };
+    } catch (err) {
+      errors.push(`[Node ${nodeIndex} ${provider.name}] ${err.message}`);
+      nodeIndex++;
+    }
+  }
+
+  // ── Final Fallback: Krylo Companion ─────────────────────
+  const kryloReply = generateKryloReply(prompt);
+  return {
+    ...kryloReply,
+    provider: "krylo-fallback",
+    node: 0,
+    errors,
+  };
+}