refineo-cli 0.0.3

package/dist/cjs/cli.js

@@ -0,0 +1,498 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_fs2 = require("fs");
+
+// src/config.ts
+var import_os = require("os");
+var import_path = require("path");
+var import_fs = require("fs");
+var CONFIG_DIR = (0, import_path.join)((0, import_os.homedir)(), ".refineo");
+var CREDENTIALS_FILE = (0, import_path.join)(CONFIG_DIR, "credentials.json");
+var API_BASE_URL = process.env.REFINEO_API_URL || "https://refineo.app";
+function ensureConfigDir() {
+  if (!(0, import_fs.existsSync)(CONFIG_DIR)) {
+    (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+function loadCredentials() {
+  try {
+    if (!(0, import_fs.existsSync)(CREDENTIALS_FILE)) {
+      return null;
+    }
+    const data = (0, import_fs.readFileSync)(CREDENTIALS_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(credentials) {
+  ensureConfigDir();
+  (0, import_fs.writeFileSync)(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), {
+    mode: 384
+    // Read/write for owner only
+  });
+}
+function clearCredentials() {
+  try {
+    if ((0, import_fs.existsSync)(CREDENTIALS_FILE)) {
+      (0, import_fs.unlinkSync)(CREDENTIALS_FILE);
+    }
+  } catch {
+  }
+}
+function isTokenExpired(credentials) {
+  const now = Math.floor(Date.now() / 1e3);
+  return credentials.expiresAt <= now + 60;
+}
+function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const nodeVersion = process.version;
+  let os = "Unknown";
+  if (platform === "darwin") os = "macOS";
+  else if (platform === "win32") os = "Windows";
+  else if (platform === "linux") os = "Linux";
+  return `refineo-cli/0.1.0 (${os}; ${arch}) Node/${nodeVersion}`;
+}
+
+// src/api.ts
+var USER_AGENT = getPlatformInfo();
+async function apiRequest(path, options = {}) {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    throw new Error("Not logged in. Run: refineo login");
+  }
+  let token = credentials.accessToken;
+  if (isTokenExpired(credentials)) {
+    const refreshed = await refreshToken(credentials.refreshToken);
+    if (refreshed) {
+      token = refreshed.accessToken;
+    } else {
+      throw new Error("Session expired. Run: refineo login");
+    }
+  }
+  const response = await fetch(`${API_BASE_URL}${path}`, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${token}`,
+      "User-Agent": USER_AGENT,
+      ...options.headers
+    }
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(error.message || error.error_description || error.error || `HTTP ${response.status}`);
+  }
+  return response.json();
+}
+async function refreshToken(refreshTokenValue) {
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/auth/device/refresh`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT
+      },
+      body: JSON.stringify({
+        refresh_token: refreshTokenValue,
+        grant_type: "refresh_token"
+      })
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    const oldCredentials = loadCredentials();
+    const credentials = {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token,
+      expiresAt: data.expires_at,
+      user: oldCredentials?.user || { email: "", tier: "" }
+    };
+    saveCredentials(credentials);
+    return credentials;
+  } catch {
+    return null;
+  }
+}
+async function startDeviceCodeFlow() {
+  const response = await fetch(`${API_BASE_URL}/api/auth/device/code`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT
+    }
+  });
+  if (!response.ok) {
+    throw new Error("Failed to start login flow");
+  }
+  return response.json();
+}
+async function pollForToken(deviceCode, interval, expiresIn, onPoll) {
+  const startTime = Date.now();
+  const timeout = expiresIn * 1e3;
+  while (Date.now() - startTime < timeout) {
+    onPoll?.();
+    const response = await fetch(`${API_BASE_URL}/api/auth/device/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT
+      },
+      body: JSON.stringify({
+        device_code: deviceCode,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+      })
+    });
+    const data = await response.json();
+    if (response.ok) {
+      const tokenData = data;
+      const credentials = {
+        accessToken: tokenData.access_token,
+        refreshToken: tokenData.refresh_token,
+        expiresAt: tokenData.expires_at,
+        user: tokenData.user || { email: "", tier: "" }
+      };
+      saveCredentials(credentials);
+      return credentials;
+    }
+    const error = data;
+    if (error.error === "authorization_pending") {
+      await new Promise((resolve) => setTimeout(resolve, interval * 1e3));
+      continue;
+    }
+    if (error.error === "slow_down") {
+      await new Promise((resolve) => setTimeout(resolve, (interval + 5) * 1e3));
+      continue;
+    }
+    if (error.error === "access_denied") {
+      throw new Error(
+        error.error_description || "Access denied. CLI requires Pro or Ultra subscription."
+      );
+    }
+    if (error.error === "expired_token") {
+      throw new Error("Login timed out. Please try again.");
+    }
+    throw new Error(error.error_description || error.error || "Login failed");
+  }
+  throw new Error("Login timed out. Please try again.");
+}
+async function humanize(text, model = "enhanced") {
+  const result = await apiRequest("/api/humanize", {
+    method: "POST",
+    body: JSON.stringify({
+      text,
+      model: model === "standard" ? "BALANCE" : "ENHANCED"
+    })
+  });
+  return {
+    humanizedText: result.data.humanizedText,
+    wordCount: result.data.wordCount,
+    model: result.data.model
+  };
+}
+async function getUsage() {
+  const result = await apiRequest("/api/usage");
+  return {
+    tier: result.tier,
+    used: result.used,
+    limit: result.limit,
+    remaining: result.remaining,
+    resetDate: result.resetDate,
+    wordLimit: result.wordLimit,
+    rateLimit: result.rateLimit
+  };
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  red: "\x1B[31m"
+};
+function print(message) {
+  console.log(message);
+}
+function printError(message) {
+  console.error(`${colors.red}Error:${colors.reset} ${message}`);
+}
+function printSuccess(message) {
+  print(`${colors.green}\u2713${colors.reset} ${message}`);
+}
+async function openBrowser(url) {
+  const { exec } = await import("child_process");
+  const { promisify } = await import("util");
+  const execAsync = promisify(exec);
+  const platform = process.platform;
+  let command;
+  if (platform === "darwin") {
+    command = `open "${url}"`;
+  } else if (platform === "win32") {
+    command = `start "" "${url}"`;
+  } else {
+    command = `xdg-open "${url}"`;
+  }
+  try {
+    await execAsync(command);
+  } catch {
+    print(`Please open this URL in your browser: ${url}`);
+  }
+}
+async function loginCommand() {
+  const existing = loadCredentials();
+  if (existing) {
+    print(`Already logged in as ${colors.cyan}${existing.user.email}${colors.reset}`);
+    print(`Tier: ${colors.bold}${existing.user.tier}${colors.reset}`);
+    print(`
+Run ${colors.dim}refineo logout${colors.reset} to switch accounts.`);
+    return;
+  }
+  print(`${colors.bold}Refineo CLI Login${colors.reset}
+`);
+  try {
+    const deviceCode = await startDeviceCodeFlow();
+    print(`Your code: ${colors.bold}${colors.cyan}${deviceCode.user_code}${colors.reset}
+`);
+    print(`Opening browser to authorize...`);
+    print(`${colors.dim}${deviceCode.verification_uri_complete}${colors.reset}
+`);
+    await openBrowser(deviceCode.verification_uri_complete);
+    print(`Waiting for authorization...`);
+    let dots = 0;
+    const credentials = await pollForToken(
+      deviceCode.device_code,
+      deviceCode.interval,
+      deviceCode.expires_in,
+      () => {
+        process.stdout.write(`\rWaiting for authorization${".".repeat(dots++ % 3 + 1)}   `);
+      }
+    );
+    process.stdout.write("\r                                    \r");
+    printSuccess(`Logged in as ${colors.cyan}${credentials.user.email}${colors.reset}`);
+    print(`Tier: ${colors.bold}${credentials.user.tier}${colors.reset}`);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : "Login failed");
+    process.exit(1);
+  }
+}
+function logoutCommand() {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    print("Not logged in.");
+    return;
+  }
+  clearCredentials();
+  printSuccess(`Logged out from ${credentials.user.email}`);
+}
+async function statsCommand() {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    printError("Not logged in. Run: refineo login");
+    process.exit(1);
+  }
+  try {
+    const usage = await getUsage();
+    print(`${colors.bold}Refineo Usage${colors.reset}
+`);
+    print(`Account: ${colors.cyan}${credentials.user.email}${colors.reset}`);
+    print(`Plan: ${colors.bold}${usage.tier}${colors.reset}`);
+    print("");
+    if (usage.limit === -1) {
+      print(`Requests: ${colors.green}Unlimited${colors.reset}`);
+      if (usage.rateLimit) {
+        print(`Rate limit: ${usage.rateLimit} requests/hour`);
+      }
+    } else {
+      const percentage = Math.round(usage.used / usage.limit * 100);
+      const color = percentage >= 90 ? colors.red : percentage >= 70 ? colors.yellow : colors.green;
+      print(`Requests: ${color}${usage.used}${colors.reset} / ${usage.limit} (${percentage}%)`);
+      print(`Remaining: ${usage.remaining}`);
+    }
+    print(`Word limit: ${usage.wordLimit} words/request`);
+    if (usage.resetDate) {
+      print(`Resets: ${usage.resetDate}`);
+    }
+  } catch (error) {
+    printError(error instanceof Error ? error.message : "Failed to get usage");
+    process.exit(1);
+  }
+}
+async function humanizeCommand(args) {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    printError("Not logged in. Run: refineo login");
+    process.exit(1);
+  }
+  let text = "";
+  let model = "enhanced";
+  let inputFile = "";
+  let outputFile = "";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--model" || arg === "-m") {
+      const value = args[++i];
+      if (value === "standard" || value === "enhanced") {
+        model = value;
+      } else {
+        printError('Model must be "standard" or "enhanced"');
+        process.exit(1);
+      }
+    } else if (arg === "--file" || arg === "-f") {
+      inputFile = args[++i];
+    } else if (arg === "--output" || arg === "-o") {
+      outputFile = args[++i];
+    } else if (!arg.startsWith("-")) {
+      text = arg;
+    }
+  }
+  if (inputFile) {
+    if (!(0, import_fs2.existsSync)(inputFile)) {
+      printError(`File not found: ${inputFile}`);
+      process.exit(1);
+    }
+    text = (0, import_fs2.readFileSync)(inputFile, "utf-8");
+  }
+  if (!text) {
+    if (process.stdin.isTTY) {
+      printError('No text provided. Usage: refineo humanize "your text" or echo "text" | refineo humanize');
+      process.exit(1);
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    text = Buffer.concat(chunks).toString("utf-8").trim();
+  }
+  if (!text) {
+    printError("No text provided");
+    process.exit(1);
+  }
+  try {
+    const result = await humanize(text, model);
+    if (outputFile) {
+      const { writeFileSync: writeFileSync2 } = await import("fs");
+      writeFileSync2(outputFile, result.humanizedText);
+      printSuccess(`Output written to ${outputFile}`);
+    } else {
+      print(result.humanizedText);
+    }
+  } catch (error) {
+    printError(error instanceof Error ? error.message : "Humanization failed");
+    process.exit(1);
+  }
+}
+function helpCommand() {
+  print(`
+${colors.bold}Refineo CLI${colors.reset} - AI Text Humanizer
+Version ${VERSION}
+
+${colors.bold}Usage:${colors.reset}
+  refineo <command> [options]
+
+${colors.bold}Commands:${colors.reset}
+  login              Authenticate with your Refineo account
+  logout             Clear stored credentials
+  stats              Show usage statistics
+  humanize <text>    Humanize AI-generated text
+
+${colors.bold}Humanize Options:${colors.reset}
+  -m, --model <model>   Model: "standard" or "enhanced" (default: enhanced)
+  -f, --file <path>     Read input from file
+  -o, --output <path>   Write output to file
+
+${colors.bold}Examples:${colors.reset}
+  ${colors.dim}# Login to your account${colors.reset}
+  refineo login
+
+  ${colors.dim}# Humanize text directly${colors.reset}
+  refineo humanize "The results indicate a significant correlation."
+
+  ${colors.dim}# Use standard model${colors.reset}
+  refineo humanize "Text here" --model standard
+
+  ${colors.dim}# Read from file${colors.reset}
+  refineo humanize --file input.txt --output output.txt
+
+  ${colors.dim}# Pipe from stdin${colors.reset}
+  echo "AI-generated text" | refineo humanize
+
+  ${colors.dim}# Check usage${colors.reset}
+  refineo stats
+
+${colors.bold}More Info:${colors.reset}
+  https://refineo.app/docs/cli
+`);
+}
+function versionCommand() {
+  print(`refineo ${VERSION}`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  switch (command) {
+    case "login":
+      await loginCommand();
+      break;
+    case "logout":
+      logoutCommand();
+      break;
+    case "stats":
+      await statsCommand();
+      break;
+    case "humanize":
+      await humanizeCommand(args.slice(1));
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      helpCommand();
+      break;
+    case "version":
+    case "--version":
+    case "-v":
+      versionCommand();
+      break;
+    case void 0:
+      helpCommand();
+      break;
+    default:
+      printError(`Unknown command: ${command}`);
+      print(`Run ${colors.dim}refineo help${colors.reset} for usage.`);
+      process.exit(1);
+  }
+}
+main().catch((error) => {
+  printError(error instanceof Error ? error.message : "Unknown error");
+  process.exit(1);
+});

package/dist/cjs/config.js

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  API_BASE_URL: () => API_BASE_URL,
+  clearCredentials: () => clearCredentials,
+  getPlatformInfo: () => getPlatformInfo,
+  isTokenExpired: () => isTokenExpired,
+  loadCredentials: () => loadCredentials,
+  saveCredentials: () => saveCredentials
+});
+module.exports = __toCommonJS(config_exports);
+var import_os = require("os");
+var import_path = require("path");
+var import_fs = require("fs");
+var CONFIG_DIR = (0, import_path.join)((0, import_os.homedir)(), ".refineo");
+var CREDENTIALS_FILE = (0, import_path.join)(CONFIG_DIR, "credentials.json");
+var API_BASE_URL = process.env.REFINEO_API_URL || "https://refineo.app";
+function ensureConfigDir() {
+  if (!(0, import_fs.existsSync)(CONFIG_DIR)) {
+    (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+function loadCredentials() {
+  try {
+    if (!(0, import_fs.existsSync)(CREDENTIALS_FILE)) {
+      return null;
+    }
+    const data = (0, import_fs.readFileSync)(CREDENTIALS_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(credentials) {
+  ensureConfigDir();
+  (0, import_fs.writeFileSync)(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), {
+    mode: 384
+    // Read/write for owner only
+  });
+}
+function clearCredentials() {
+  try {
+    if ((0, import_fs.existsSync)(CREDENTIALS_FILE)) {
+      (0, import_fs.unlinkSync)(CREDENTIALS_FILE);
+    }
+  } catch {
+  }
+}
+function isTokenExpired(credentials) {
+  const now = Math.floor(Date.now() / 1e3);
+  return credentials.expiresAt <= now + 60;
+}
+function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const nodeVersion = process.version;
+  let os = "Unknown";
+  if (platform === "darwin") os = "macOS";
+  else if (platform === "win32") os = "Windows";
+  else if (platform === "linux") os = "Linux";
+  return `refineo-cli/0.1.0 (${os}; ${arch}) Node/${nodeVersion}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  API_BASE_URL,
+  clearCredentials,
+  getPlatformInfo,
+  isTokenExpired,
+  loadCredentials,
+  saveCredentials
+});