prior-cli 1.0.0

package/lib/api.js

@@ -0,0 +1,244 @@
+'use strict';
+
+const fetch  = require('node-fetch');
+const { getToken } = require('./config');
+
+const BASE     = 'https://prior.ngrok.app';
+const CLI_BASE = 'https://prior.ngrok.app/cli-backend';
+
+function authHeaders(extra = {}) {
+  const token = getToken();
+  const h = { 'Content-Type': 'application/json', ...extra };
+  if (token) h['Authorization'] = `Bearer ${token}`;
+  return h;
+}
+
+// ── Auth ──────────────────────────────────────────────────────
+
+async function login(username, password) {
+  const res  = await fetch(`${BASE}/network/api/login`, {
+    method:  'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body:    JSON.stringify({ username, password }),
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || data.message || 'Login failed');
+  return data;
+}
+
+// ── CLI Backend ───────────────────────────────────────────────
+
+async function checkBackend() {
+  try {
+    const res = await fetch(`${CLI_BASE}/health`, { timeout: 3000 });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+// Agent chat — SSE stream. Calls onEvent(event) for each SSE event.
+// Events: { type: 'thinking' | 'tool_start' | 'tool_done' | 'tool_error' |
+//           'response_start' | 'response_pause' | 'text' | 'error' | 'done' }
+async function agentChat(messages, opts = {}, onEvent) {
+  const token = getToken();
+  const res = await fetch(`${CLI_BASE}/api/chat`, {
+    method:  'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      messages,
+      model:         opts.model         || undefined,
+      uncensored:    opts.uncensored    || false,
+      cwd:           opts.cwd           || process.cwd(),
+      projectContext: opts.projectContext || undefined,
+      token,
+    }),
+    timeout: 300000,
+  });
+
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error || `HTTP ${res.status}`);
+  }
+
+  return new Promise((resolve, reject) => {
+    let buf = '';
+
+    res.body.on('data', chunk => {
+      buf += chunk.toString();
+      const lines = buf.split('\n');
+      buf = lines.pop();
+
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const raw = line.slice(6).trim();
+        if (!raw) continue;
+        try {
+          const event = JSON.parse(raw);
+          onEvent(event);
+          if (event.type === 'done' || event.type === 'error') resolve();
+        } catch { /* skip malformed SSE */ }
+      }
+    });
+
+    res.body.on('end',   resolve);
+    res.body.on('error', reject);
+  });
+}
+
+// ── Direct AI (fallback, no agent) ───────────────────────────
+
+async function generate(prompt, opts = {}, onChunk) {
+  const res = await fetch(`${BASE}/prior/api/generate`, {
+    method:  'POST',
+    headers: authHeaders(),
+    body:    JSON.stringify({
+      prompt,
+      stream:     true,
+      model:      opts.model      || undefined,
+      uncensored: opts.uncensored || false,
+    }),
+  });
+
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error || err.message || `HTTP ${res.status}`);
+  }
+
+  return new Promise((resolve, reject) => {
+    let full = '';
+    let buf  = '';
+
+    function processLines(raw) {
+      const lines = raw.split('\n');
+      for (const line of lines) {
+        const trimmed = line.replace(/^data:\s*/, '').trim();
+        if (!trimmed || trimmed === '[DONE]') continue;
+        try {
+          const json = JSON.parse(trimmed);
+          const text = json.response ?? json.content ?? json.token ?? '';
+          if (text) { full += text; onChunk(text); }
+        } catch { /* skip */ }
+      }
+    }
+
+    res.body.on('data', chunk => {
+      let raw = chunk.toString();
+      try {
+        const unwrapped = JSON.parse(raw);
+        if (typeof unwrapped === 'string') raw = unwrapped;
+      } catch { /* not outer-encoded */ }
+      buf += raw;
+      const lines = buf.split('\n');
+      buf = lines.pop();
+      processLines(lines.join('\n'));
+    });
+
+    res.body.on('end', () => {
+      if (buf.trim()) {
+        let raw = buf.trim();
+        try { const u = JSON.parse(raw); if (typeof u === 'string') raw = u; } catch {}
+        processLines(raw);
+      }
+      resolve(full);
+    });
+
+    res.body.on('error', reject);
+  });
+}
+
+// ── Image generation ──────────────────────────────────────────
+
+async function generateImage(prompt, opts = {}) {
+  const res  = await fetch(`${BASE}/prior/api/tools/generate-image`, {
+    method:  'POST',
+    headers: authHeaders(),
+    body:    JSON.stringify({
+      prompt,
+      width:  opts.width  || 896,
+      height: opts.height || 896,
+      steps:  opts.steps  || 20,
+    }),
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || data.message || `HTTP ${res.status}`);
+  return data;
+}
+
+async function pollImageProgress(promptId) {
+  const res  = await fetch(`${BASE}/prior/api/tools/image-gen-progress/${promptId}`, {
+    headers: authHeaders(),
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || data.message || `HTTP ${res.status}`);
+  return data;
+}
+
+async function downloadImage(filename) {
+  const res = await fetch(
+    `${BASE}/prior/api/media/images/${encodeURIComponent(filename)}`,
+    { headers: authHeaders() }
+  );
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res;
+}
+
+// ── Other endpoints ───────────────────────────────────────────
+
+async function getModels() {
+  const res  = await fetch(`${BASE}/prior/api/models`, { headers: authHeaders() });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || data.message || `HTTP ${res.status}`);
+  return data;
+}
+
+async function getChats() {
+  const res  = await fetch(`${BASE}/prior/api/prior_ai_chats`, { headers: authHeaders() });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || data.message || `HTTP ${res.status}`);
+  return data;
+}
+
+async function getUsage() {
+  // Try the local backend first — avoids the guest-redirect issue on the public API
+  try {
+    const r = await fetch(`${CLI_BASE}/api/usage`, { headers: authHeaders(), timeout: 5000 });
+    if (r.ok) return await r.json();
+  } catch { /* backend offline, fall through */ }
+
+  // Fallback: public API (may hit redirect issues for some tokens)
+  const res  = await fetch(`${BASE}/prior/api/usage`, { headers: authHeaders() });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || data.message || `HTTP ${res.status}`);
+  return data;
+}
+
+async function getWeather(location) {
+  const res  = await fetch(
+    `${BASE}/prior/api/tools/weather?location=${encodeURIComponent(location)}`,
+    { headers: authHeaders() }
+  );
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || data.message || `HTTP ${res.status}`);
+  return data;
+}
+
+async function search(query) {
+  const res  = await fetch(`${BASE}/prior/api/tools/url-reader`, {
+    method:  'POST',
+    headers: authHeaders(),
+    body:    JSON.stringify({ url: query }),
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || data.message || `HTTP ${res.status}`);
+  return data;
+}
+
+module.exports = {
+  login,
+  checkBackend, agentChat,
+  generate,
+  generateImage, pollImageProgress, downloadImage,
+  getModels, getChats, getUsage, getWeather, search,
+};

package/lib/config.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const CONFIG_DIR  = path.join(os.homedir(), '.prior');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function getConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) return {};
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveConfig(data) {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2));
+}
+
+function getToken()    { return getConfig().token    || null; }
+function getUsername() { return getConfig().username || null; }
+
+function saveAuth(token, username) {
+  saveConfig({ ...getConfig(), token, username });
+}
+
+function clearAuth() {
+  const cfg = getConfig();
+  delete cfg.token;
+  delete cfg.username;
+  saveConfig(cfg);
+}
+
+module.exports = { getConfig, saveConfig, getToken, getUsername, saveAuth, clearAuth, CONFIG_DIR };

package/lib/render.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const chalk = require('chalk');
+const THEME = '#9CE2D4';
+
+// ── Inline markup ─────────────────────────────────────────────
+
+function renderInline(text) {
+  return text
+    .replace(/\*\*\*(.+?)\*\*\*/g, (_,t) => chalk.bold.italic(t))
+    .replace(/\*\*(.+?)\*\*/g,     (_,t) => chalk.bold(t))
+    .replace(/`([^`]+)`/g,          (_,t) => chalk.hex(THEME)(t))
+    .replace(/\*([^*\n]+)\*/g,      (_,t) => chalk.italic(t));
+}
+
+// ── Block renderer ────────────────────────────────────────────
+
+function renderMarkdown(text, indent = '  ') {
+  const lines  = text.split('\n');
+  const out    = [];
+  let inCode   = false;
+  let codeLang = '';
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Code fence open/close
+    const fenceMatch = line.match(/^```(\w*)/);
+    if (fenceMatch) {
+      if (!inCode) {
+        inCode   = true;
+        codeLang = fenceMatch[1] || 'code';
+        out.push(chalk.dim(`${indent}┌─ ${codeLang} ${'─'.repeat(Math.max(0, 36 - codeLang.length))}`));
+      } else {
+        inCode = false;
+        out.push(chalk.dim(`${indent}└${'─'.repeat(40)}`));
+      }
+      continue;
+    }
+
+    if (inCode) {
+      out.push(chalk.hex(THEME)(`${indent}│ `) + chalk.white(line));
+      continue;
+    }
+
+    // Horizontal rule
+    if (/^[-*_]{3,}$/.test(line.trim())) {
+      out.push(chalk.dim(`${indent}${'─'.repeat(44)}`));
+      continue;
+    }
+
+    // Headings
+    let m;
+    if ((m = line.match(/^(#{1,3}) (.+)/))) {
+      const level = m[1].length;
+      const txt   = m[2];
+      if (level === 1) out.push(`\n${indent}${chalk.bold.underline(txt)}`);
+      else if (level === 2) out.push(`\n${indent}${chalk.bold(txt)}`);
+      else out.push(`${indent}${chalk.hex(THEME).bold(txt)}`);
+      continue;
+    }
+
+    // Unordered list
+    if ((m = line.match(/^(\s*)[-*+] (.+)/))) {
+      const pad = ' '.repeat(m[1].length);
+      out.push(`${indent}${pad}${chalk.hex(THEME)('▸')} ${renderInline(m[2])}`);
+      continue;
+    }
+
+    // Ordered list
+    if ((m = line.match(/^(\s*)(\d+)\. (.+)/))) {
+      const pad = ' '.repeat(m[1].length);
+      out.push(`${indent}${pad}${chalk.dim(m[2] + '.')} ${renderInline(m[3])}`);
+      continue;
+    }
+
+    // Blockquote
+    if ((m = line.match(/^> ?(.*)/))) {
+      out.push(chalk.hex(THEME)(`${indent}│ `) + chalk.dim(renderInline(m[1])));
+      continue;
+    }
+
+    // Empty line
+    if (!line.trim()) {
+      out.push('');
+      continue;
+    }
+
+    // Normal paragraph
+    out.push(`${indent}${renderInline(line)}`);
+  }
+
+  return out.join('\n');
+}
+
+module.exports = { renderMarkdown, renderInline };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "prior-cli",
+  "version": "1.0.0",
+  "description": "Prior Network AI — command-line interface",
+  "bin": {
+    "prior": "bin/prior.js"
+  },
+  "scripts": {
+    "start": "node bin/prior.js"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "node-fetch": "^2.7.0",
+    "open": "^8.4.2"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "keywords": [
+    "prior",
+    "ai",
+    "cli"
+  ],
+  "license": "MIT",
+  "files": [
+    "bin/",
+    "lib/"
+  ]
+}