vektor-slipstream 1.4.4 → 2.0.0

package/vektor-cli.js

@@ -1,259 +0,0 @@
-/**
- * vektor-cli.js  (v1.5.x patch)
- * VEKTOR Slipstream
- * CLI router — drop-in replacement for the v1.4.x router.
- *
- * New commands added in v1.5.x:
- *   npx vektor agent --tools    full tool suite
- *   npx vektor watch            filesystem watcher
- *   npx vektor sync             P2P memory sync
- *   npx vektor swarm            multi-agent coordination
- *
- * All existing v1.4.x commands (chat, remember, ask, agent) are preserved.
- */
-
-'use strict';
-
-const path = require('path');
-
-// ─── Command registry ─────────────────────────────────────────────────────────
-
-const COMMANDS = {
-  // ── v1.4.x (existing) ──────────────────────────────────────────────────
-  chat:     () => require('./vektor-cli-chat.js').runChat,
-  remember: () => require('./vektor-cli-chat.js').runRemember,
-  ask:      () => require('./vektor-cli-chat.js').runAsk,
-
-  // ── v1.5.x (new) ───────────────────────────────────────────────────────
-
-  /**
-   * npx vektor agent [goal] [--tools web,fs,code] [--continue]
-   * Autonomous agent with web search, file system, code execution.
-   */
-  agent: () => async (argv) => {
-    const { default: runAgent, main } = (() => {
-      try { return require('./vektor-agent.js'); } catch { return require('../vektor-agent.js'); }
-    })();
-    // Delegate to vektor-agent CLI main — it reads process.argv
-    await main?.() ?? runAgent({
-      goal: argv.filter(a => !a.startsWith('-')).join(' '),
-      tools: ['web', 'fs', 'code', 'memory'],
-      provider: process.env.VEKTOR_PROVIDER || 'ollama',
-    });
-  },
-
-  /**
-   * npx vektor watch [path] [--ext js,ts] [--no-llm]
-   * Filesystem watcher — auto-stores change summaries into MAGMA.
-   */
-  watch: () => async (_argv) => {
-    const { startWatch, parseArgs } = (() => {
-      try { return require('./vektor-watch.js'); } catch { return require('../vektor-watch.js'); }
-    })();
-    const opts = parseArgs(process.argv);
-    await startWatch(opts);
-  },
-
-  /**
-   * npx vektor sync --host [--pin X]
-   * npx vektor sync --connect <ip> [--pin X]
-   * Encrypted P2P memory sync between machines.
-   */
-  sync: () => async (_argv) => {
-    const { main } = (() => {
-      try { return require('./vektor-sync.js'); } catch { return require('../vektor-sync.js'); }
-    })();
-    await main?.();
-  },
-
-  /**
-   * npx vektor swarm "goal" [--agents 3] [--roles r1,r2,r3]
-   * Multi-agent swarm coordination.
-   */
-  swarm: () => async (_argv) => {
-    const { main } = (() => {
-      try { return require('./vektor-swarm.js'); } catch { return require('../vektor-swarm.js'); }
-    })();
-    await main?.();
-  },
-
-  // ── Utility ────────────────────────────────────────────────────────────
-
-  providers: () => async (_argv) => {
-    await checkProviders();
-  },
-
-  version: () => async (_argv) => {
-    const pkg = safeRequirePackageJson();
-    console.log(`VEKTOR Slipstream v${pkg.version || '1.5.0'}`);
-  },
-
-  help: () => async (_argv) => {
-    printHelp();
-  },
-};
-
-// ─── Provider checker ─────────────────────────────────────────────────────────
-
-async function checkProviders() {
-  const C = { green: '\x1b[32m', red: '\x1b[31m', dim: '\x1b[2m', reset: '\x1b[0m', bold: '\x1b[1m' };
-  console.log(`\n${C.bold}VEKTOR Provider Status${C.reset}\n`);
-
-  const checks = [
-    { name: 'Claude (Anthropic)', key: 'ANTHROPIC_API_KEY',  test: () => testClaude() },
-    { name: 'OpenAI',             key: 'OPENAI_API_KEY',     test: () => testOpenAI() },
-    { name: 'Groq',               key: 'GROQ_API_KEY',       test: () => testGroq() },
-    { name: 'Google Gemini',      key: 'GEMINI_API_KEY',     test: () => testGemini() },
-    { name: 'Ollama (local)',     key: null,                 test: () => testOllama() },
-  ];
-
-  for (const check of checks) {
-    const hasKey = check.key ? !!process.env[check.key] : true;
-    if (!hasKey) {
-      console.log(`  ${C.red}✗${C.reset}  ${check.name}  ${C.dim}(${check.key} not set)${C.reset}`);
-      continue;
-    }
-    process.stdout.write(`  ⏳ ${check.name}…`);
-    try {
-      const model = await check.test();
-      process.stdout.write(`\r  ${C.green}✓${C.reset}  ${check.name}  ${C.dim}${model}${C.reset}\n`);
-    } catch (err) {
-      process.stdout.write(`\r  ${C.red}✗${C.reset}  ${check.name}  ${C.dim}${err.message}${C.reset}\n`);
-    }
-  }
-  console.log('');
-}
-
-async function testClaude() {
-  const res = await fetchTimeout('https://api.anthropic.com/v1/models', {
-    headers: { 'x-api-key': process.env.ANTHROPIC_API_KEY, 'anthropic-version': '2023-06-01' },
-  }, 5000);
-  const j = await res.json();
-  const m = j.data?.[0]?.id || 'connected';
-  return m;
-}
-async function testOpenAI() {
-  const res = await fetchTimeout('https://api.openai.com/v1/models', {
-    headers: { Authorization: `Bearer ${process.env.OPENAI_API_KEY}` },
-  }, 5000);
-  const j = await res.json();
-  return j.data?.[0]?.id || 'connected';
-}
-async function testGroq() {
-  const res = await fetchTimeout('https://api.groq.com/openai/v1/models', {
-    headers: { Authorization: `Bearer ${process.env.GROQ_API_KEY}` },
-  }, 5000);
-  const j = await res.json();
-  return j.data?.[0]?.id || 'connected';
-}
-async function testGemini() {
-  const res = await fetchTimeout(`https://generativelanguage.googleapis.com/v1beta/models?key=${process.env.GEMINI_API_KEY}`, {}, 5000);
-  const j = await res.json();
-  return j.models?.[0]?.name || 'connected';
-}
-async function testOllama() {
-  const res = await fetchTimeout('http://localhost:11434/api/tags', {}, 3000);
-  const j = await res.json();
-  const models = j.models?.map(m => m.name) || [];
-  if (!models.length) throw new Error('No models installed. Run: ollama pull qwen3');
-  return models.join(', ');
-}
-
-function fetchTimeout(url, opts, ms) {
-  const ctrl = new AbortController();
-  const t = setTimeout(() => ctrl.abort(), ms);
-  return fetch(url, { ...opts, signal: ctrl.signal }).finally(() => clearTimeout(t));
-}
-
-// ─── Help ─────────────────────────────────────────────────────────────────────
-
-function printHelp() {
-  const C = { bold: '\x1b[1m', dim: '\x1b[2m', cyan: '\x1b[36m', green: '\x1b[32m', reset: '\x1b[0m' };
-  console.log(`
-${C.bold}VEKTOR Slipstream CLI${C.reset}
-
-${C.bold}Memory:${C.reset}
-  ${C.cyan}npx vektor remember${C.reset} "text"          Store a fact into MAGMA
-  ${C.cyan}npx vektor ask${C.reset} "question"           Recall + LLM answer
-  ${C.cyan}npx vektor chat${C.reset}                     Interactive persistent-memory chat
-
-${C.bold}Agent (v1.5):${C.reset}
-  ${C.cyan}npx vektor agent${C.reset} "goal"              Basic autonomous agent
-  ${C.cyan}npx vektor agent${C.reset} "goal" ${C.dim}--tools${C.reset}      Full tool suite (web+fs+code)
-  ${C.cyan}npx vektor agent${C.reset} "goal" ${C.dim}--continue${C.reset}   Resume last session
-  ${C.cyan}npx vektor agent${C.reset} "goal" ${C.dim}--tools web,fs,code${C.reset}
-
-${C.bold}Watch (v1.5):${C.reset}
-  ${C.cyan}npx vektor watch${C.reset} [path]              Watch filesystem, auto-store changes
-  ${C.cyan}npx vektor watch${C.reset} src/ ${C.dim}--ext ts,tsx${C.reset}
-  ${C.cyan}npx vektor watch${C.reset} ${C.dim}--no-llm${C.reset}            Heuristic summaries only
-
-${C.bold}Sync (v1.5):${C.reset}
-  ${C.cyan}npx vektor sync${C.reset} --host               Listen for incoming sync
-  ${C.cyan}npx vektor sync${C.reset} --connect <ip>       Sync with host machine
-  ${C.cyan}npx vektor sync${C.reset} --host ${C.dim}--pin 123456${C.reset}
-
-${C.bold}Swarm (v1.5):${C.reset}
-  ${C.cyan}npx vektor swarm${C.reset} "goal"              Multi-agent coordination
-  ${C.cyan}npx vektor swarm${C.reset} "goal" ${C.dim}--agents 4${C.reset}
-  ${C.cyan}npx vektor swarm${C.reset} "goal" ${C.dim}--roles researcher,coder,reviewer${C.reset}
-
-${C.bold}Utilities:${C.reset}
-  ${C.cyan}npx vektor providers${C.reset}                 Test all API key connections
-  ${C.cyan}npx vektor version${C.reset}                   Show version
-  ${C.cyan}npx vektor help${C.reset}                      Show this help
-
-${C.bold}Providers:${C.reset}  ${C.dim}--provider claude|openai|groq|gemini|ollama${C.reset}
-`);
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function safeRequirePackageJson() {
-  const candidates = [
-    path.join(__dirname, 'package.json'),
-    path.join(__dirname, '..', 'package.json'),
-  ];
-  for (const c of candidates) {
-    try { return require(c); } catch { /* skip */ }
-  }
-  return {};
-}
-
-// ─── CLI dispatcher ───────────────────────────────────────────────────────────
-
-async function main() {
-  const argv = process.argv.slice(2);
-  const cmd  = argv[0];
-
-  if (!cmd || cmd === '--help' || cmd === '-h') {
-    printHelp();
-    return;
-  }
-  if (cmd === '--version' || cmd === '-v') {
-    const pkg = safeRequirePackageJson();
-    console.log(`v${pkg.version || '1.5.0'}`);
-    return;
-  }
-
-  const factory = COMMANDS[cmd];
-  if (!factory) {
-    console.error(`Unknown command: ${cmd}\nRun 'npx vektor help' for usage.`);
-    process.exit(1);
-  }
-
-  try {
-    const handler = factory();
-    await handler(argv.slice(1));
-  } catch (err) {
-    console.error(`Error in '${cmd}': ${err.message}`);
-    if (process.env.DEBUG) console.error(err);
-    process.exit(1);
-  }
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = { COMMANDS, main };

package/vektor-licence-prompt.js

@@ -1,128 +0,0 @@
-'use strict';
-/**
- * vektor-licence-prompt.js — fixed for MCP mode (stderr exit, no stdout corruption)
- */
-
-const fs       = require('fs');
-const path     = require('path');
-const os       = require('os');
-const readline = require('readline');
-
-const CACHE_DIR    = path.join(os.homedir(), '.vektor');
-const CACHE_FILE   = path.join(CACHE_DIR, 'licence.json');
-const PURCHASE_URL = 'https://vektormemory.com/product#pricing';
-
-function _getCachedKey() {
-  try {
-    if (!fs.existsSync(CACHE_FILE)) return null;
-    const cache = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
-    for (const entry of Object.values(cache)) {
-      if (entry?.licence_key && entry?.valid === true) return entry.licence_key;
-    }
-    return null;
-  } catch (_) { return null; }
-}
-
-function _saveCachedKey(licenceKey) {
-  try {
-    if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR, { recursive: true });
-    let cache = {};
-    if (fs.existsSync(CACHE_FILE)) {
-      try { cache = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8')); } catch (_) {}
-    }
-    cache['_prompt_key'] = { licence_key: licenceKey, valid: true, saved_at: Date.now() };
-    fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
-  } catch (_) {}
-}
-
-function _prompt(question) {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
-  });
-}
-
-function _printLicenceBanner() {
-  console.log('');
-  console.log('  ╔══════════════════════════════════════════════════════╗');
-  console.log('  ║         VEKTOR SLIPSTREAM — LICENCE REQUIRED         ║');
-  console.log('  ╚══════════════════════════════════════════════════════╝');
-  console.log('');
-  console.log('  A licence key is required to use Vektor Slipstream.');
-  console.log('  Your key was emailed to you after purchase on Polar.');
-  console.log('');
-  console.log('  Purchase at: ' + PURCHASE_URL);
-  console.log('');
-  console.log('  Tip: Set VEKTOR_LICENCE_KEY env var to skip this prompt.');
-  console.log('  e.g. VEKTOR_LICENCE_KEY=YOUR-KEY node your-agent.js');
-  console.log('');
-}
-
-async function resolveAndValidateLicence(validateLicenceFn) {
-
-  // Priority 1 — env var (silent, MCP/server/CI safe)
-  const envKey = process.env.VEKTOR_LICENCE_KEY;
-  if (envKey && envKey.trim().length >= 8) {
-    await validateLicenceFn(envKey.trim());
-    _saveCachedKey(envKey.trim());
-    return;
-  }
-
-  // Priority 2 — cached key
-  const cachedKey = _getCachedKey();
-  if (cachedKey) {
-    try {
-      await validateLicenceFn(cachedKey);
-      return;
-    } catch (e) {
-      process.stderr.write('\n  [vektor] Cached licence key is no longer valid. Please re-enter.\n\n');
-    }
-  }
-
-  // Priority 3 — non-TTY (MCP, CI, piped) — stderr only, never stdout
-  if (!process.stdin.isTTY) {
-    process.stderr.write(
-      '\n[vektor] LICENCE REQUIRED — stdin is not interactive.\n' +
-      '[vektor] Set VEKTOR_LICENCE_KEY env var:\n' +
-      '[vektor]   VEKTOR_LICENCE_KEY=YOUR-KEY node your-agent.js\n' +
-      '[vektor] Purchase at: ' + PURCHASE_URL + '\n\n'
-    );
-    process.exit(1);
-  }
-
-  // Priority 4 — interactive prompt (TTY only)
-  _printLicenceBanner();
-
-  let attempts = 0;
-  while (attempts < 3) {
-    const input = await _prompt('  Paste your licence key › ');
-    if (!input || input.length < 8) {
-      console.log('  ✗ No key entered. Try again.\n');
-      attempts++;
-      continue;
-    }
-    try {
-      await validateLicenceFn(input);
-      _saveCachedKey(input);
-      console.log('  ✓ Licence validated — this machine is now activated.\n');
-      console.log('  Your key has been saved to ~/.vektor/licence.json');
-      console.log('  You will not be prompted again on this machine.\n');
-      return;
-    } catch (e) {
-      console.log('');
-      console.log(e.message);
-      attempts++;
-      if (attempts < 3) {
-        console.log(`  Try again (${3 - attempts} attempt${3 - attempts === 1 ? '' : 's'} remaining)...\n`);
-      }
-    }
-  }
-
-  throw new Error(
-    '\n  Licence validation failed after 3 attempts.\n' +
-    '  Purchase at: ' + PURCHASE_URL + '\n' +
-    '  Already purchased? Contact hello@vektormemory.com\n'
-  );
-}
-
-module.exports = { resolveAndValidateLicence };

package/vektor-licence.js

@@ -1,192 +0,0 @@
-'use strict';
-/**
- * vektor-licence.js
- * Licence validation for VEKTOR Slipstream.
- * Validates against cached licence in ~/.vektor/licence.json
- * or VEKTOR_LICENCE_KEY environment variable.
- */
-
-const fs   = require('fs');
-const path = require('path');
-const os   = require('os');
-const crypto = require('crypto');
-
-const CACHE_PATH  = path.join(os.homedir(), '.vektor', 'licence.json');
-const PURCHASE_URL = 'https://vektormemory.com/product#pricing';
-
-// Known valid key format: UUID v4 uppercase
-const KEY_RE = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
-
-function readCache() {
-  try {
-    if (!fs.existsSync(CACHE_PATH)) return null;
-    const raw = fs.readFileSync(CACHE_PATH, 'utf8');
-    return JSON.parse(raw);
-  } catch { return null; }
-}
-
-function writeCache(key, data) {
-  try {
-    const dir = path.dirname(CACHE_PATH);
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-    fs.writeFileSync(CACHE_PATH, JSON.stringify({ key, ...data, cachedAt: new Date().toISOString() }, null, 2), { mode: 0o600 });
-  } catch { /* ignore */ }
-}
-
-function getCachedKey() {
-  const cache = readCache();
-  return cache?.key || null;
-}
-
-/**
- * Validate a licence key.
- * Checks format, then attempts Polar API verification.
- * Falls back to cached validation if offline.
- */
-async function validateLicence(key) {
-  if (!key) {
-    const envKey   = process.env.VEKTOR_LICENCE_KEY;
-    const cached   = readCache();
-    key = envKey || cached?.key;
-  }
-
-  if (!key) {
-    throw new Error(
-      `\n\n  VEKTOR SLIPSTREAM — Licence Required\n` +
-      `  ─────────────────────────────────────\n` +
-      `  No licence key found.\n\n` +
-      `  Purchase at: ${PURCHASE_URL}\n` +
-      `  Then run:    npx vektor setup\n`
-    );
-  }
-
-  // Format check
-  if (!KEY_RE.test(key.trim())) {
-    throw new Error(`Invalid licence key format. Expected UUID format: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX`);
-  }
-
-  const cleanKey = key.trim().toUpperCase();
-
-  // Check cache first (avoid network on every boot)
-  const cache = readCache();
-  if (cache?.key?.toUpperCase() === cleanKey && cache?.valid) {
-    // Re-validate online max once per 24hrs
-    const cachedAt  = cache.cachedAt ? new Date(cache.cachedAt) : new Date(0);
-    const ageHours  = (Date.now() - cachedAt.getTime()) / 3600000;
-    if (ageHours < 24) {
-      return { valid: true, key: cleanKey, source: 'cache' };
-    }
-  }
-
-  // Online validation via Polar
-  try {
-    const result = await _polarValidate(cleanKey);
-    writeCache(cleanKey, { valid: true, plan: result.plan, activatedAt: result.activatedAt });
-    return { valid: true, key: cleanKey, source: 'polar', ...result };
-  } catch (e) {
-    // If network fails but we have a cached valid key — allow offline use
-    if (cache?.key?.toUpperCase() === cleanKey && cache?.valid) {
-      return { valid: true, key: cleanKey, source: 'cache-offline' };
-    }
-    // New key that's never been validated — can't verify offline
-    if (e.code === 'ENOTFOUND' || e.code === 'ECONNREFUSED' || e.message?.includes('timeout')) {
-      throw new Error(`Licence validation failed: network unavailable. Connect to the internet to activate.`);
-    }
-    throw new Error(`Licence validation failed: ${e.message}`);
-  }
-}
-
-async function _polarValidate(key) {
-  return new Promise((resolve, reject) => {
-    const https = require('https');
-    const body  = JSON.stringify({ licenceKey: key });
-    const opts  = {
-      hostname: 'api.polar.sh',
-      path:     '/v1/users/license-keys/validate',
-      method:   'POST',
-      headers:  {
-        'Content-Type':   'application/json',
-        'Content-Length': Buffer.byteLength(body),
-        'User-Agent':     'vektor-slipstream/1.1.13',
-      },
-    };
-
-    const req = https.request(opts, res => {
-      let data = '';
-      res.setEncoding('utf8');
-      res.on('data', c => data += c);
-      res.on('end', () => {
-        try {
-          const json = JSON.parse(data);
-          if (res.statusCode === 200 && (json.valid || json.status === 'granted')) {
-            resolve({ plan: json.benefit?.description || 'slipstream', activatedAt: json.activated_at });
-          } else if (res.statusCode === 404 || json.valid === false) {
-            reject(new Error(`Invalid licence key. Purchase at: ${PURCHASE_URL}`));
-          } else {
-            // Unknown response — treat as valid if 2xx
-            if (res.statusCode >= 200 && res.statusCode < 300) {
-              resolve({ plan: 'slipstream', activatedAt: new Date().toISOString() });
-            } else {
-              reject(new Error(`Polar API returned ${res.statusCode}`));
-            }
-          }
-        } catch { reject(new Error('Invalid response from licence server')); }
-      });
-    });
-
-    req.setTimeout(8000, () => { req.destroy(); reject(Object.assign(new Error('timeout'), { code: 'ECONNREFUSED' })); });
-    req.on('error', reject);
-    req.write(body);
-    req.end();
-  });
-}
-
-/**
- * Activate a new licence key interactively and cache it.
- */
-async function activateLicence(key) {
-  const result = await validateLicence(key);
-  writeCache(result.key, { valid: true, plan: result.plan, activatedAt: result.activatedAt });
-  return result;
-}
-
-/**
- * Deactivate — clear the local cache.
- */
-function deactivateLicence() {
-  try {
-    if (fs.existsSync(CACHE_PATH)) fs.unlinkSync(CACHE_PATH);
-    return true;
-  } catch { return false; }
-}
-
-/**
- * Get licence status without throwing.
- */
-function getLicenceStatus() {
-  const cache = readCache();
-  const envKey = process.env.VEKTOR_LICENCE_KEY;
-  if (!cache?.key && !envKey) return { status: 'none' };
-  const key = cache?.key || envKey;
-  const cachedAt = cache?.cachedAt ? new Date(cache.cachedAt) : null;
-  const ageHours = cachedAt ? (Date.now() - cachedAt.getTime()) / 3600000 : null;
-  return {
-    status:    cache?.valid ? 'active' : 'unknown',
-    key:       key ? key.slice(0, 8) + '...' : null,
-    plan:      cache?.plan || null,
-    cachedAt:  cache?.cachedAt || null,
-    ageHours:  ageHours ? Math.round(ageHours) : null,
-    source:    envKey ? 'env' : 'cache',
-  };
-}
-
-module.exports = {
-  validateLicence,
-  activateLicence,
-  deactivateLicence,
-  getLicenceStatus,
-  getCachedKey,
-  readCache,
-  CACHE_PATH,
-  PURCHASE_URL,
-};