roborank 0.1.0 → 0.1.1

package/bin/roborank.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { run } from '../src/index.js';
 
-const { code, stdout, stderr } = await run(process.argv.slice(2));
+const { code, stdout, stderr } = await run(process.argv.slice(2), { tty: process.stdout.isTTY === true });
 if (stdout) process.stdout.write(stdout + '\n');
 if (stderr) process.stderr.write(stderr + '\n');
 process.exit(code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roborank",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Roborank CLI — run your site's SEO findings and fixes from the terminal or from an AI coding agent",
   "type": "module",
   "bin": {

package/src/format.js

@@ -0,0 +1,70 @@
+// Human-readable rendering for terminal use. JSON stays the contract for
+// agents and pipes; this only runs when stdout is a TTY and --json is absent.
+
+const MAX_CELL = 48;
+
+function isPlainObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function cell(v) {
+  if (v === null || v === undefined) return '-';
+  if (v === true) return 'yes';
+  if (v === false) return 'no';
+  if (typeof v === 'number') {
+    if (Number.isInteger(v)) return v.toLocaleString('en-US');
+    // Ratios like ctr read better as percentages, but only obvious ones.
+    if (v > 0 && v < 1) return (v * 100).toFixed(1) + '%';
+    return String(Math.round(v * 10) / 10);
+  }
+  if (Array.isArray(v)) return v.length ? `[${v.length} items]` : '[]';
+  if (isPlainObject(v)) return '{…}';
+  let s = String(v);
+  // Timestamps: the date part carries the signal.
+  if (/^\d{4}-\d{2}-\d{2}T/.test(s)) s = s.slice(0, 10);
+  if (s.length > MAX_CELL) s = s.slice(0, MAX_CELL - 1) + '…';
+  return s;
+}
+
+function table(rows) {
+  const cols = [];
+  for (const r of rows) for (const k of Object.keys(r)) if (!cols.includes(k)) cols.push(k);
+  const grid = rows.map(r => cols.map(c => cell(r[c])));
+  const widths = cols.map((c, i) => Math.max(c.length, ...grid.map(g => g[i].length)));
+  const line = (parts) => parts.map((p, i) => p.padEnd(widths[i])).join('  ').trimEnd();
+  return [
+    line(cols),
+    line(widths.map(w => '-'.repeat(w))),
+    ...grid.map(line),
+  ].join('\n');
+}
+
+function keyValues(obj, indent = '') {
+  const lines = [];
+  for (const [k, v] of Object.entries(obj)) {
+    if (Array.isArray(v) && v.length && v.every(isPlainObject)) {
+      lines.push(`${indent}${k}:`);
+      lines.push(table(v).split('\n').map(l => indent + '  ' + l).join('\n'));
+    } else if (Array.isArray(v) && v.length && v.every(x => !isPlainObject(x) && !Array.isArray(x))) {
+      lines.push(`${indent}${k}:`);
+      for (const x of v) lines.push(`${indent}  ${cell(x)}`);
+    } else if (isPlainObject(v)) {
+      lines.push(`${indent}${k}:`);
+      lines.push(keyValues(v, indent + '  '));
+    } else {
+      lines.push(`${indent}${k}: ${cell(v)}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+/** Render any tool payload for humans. */
+export function pretty(payload) {
+  if (payload === null || payload === undefined) return '';
+  if (typeof payload !== 'object') return String(payload);
+  if (Array.isArray(payload)) {
+    if (!payload.length) return '(nothing found)';
+    return payload.every(isPlainObject) ? table(payload) : payload.map(cell).join('\n');
+  }
+  return keyValues(payload);
+}

package/src/index.js

@@ -3,6 +3,7 @@ import { resolveToken, resolveApi, writeConfig, readConfig, clearConfig, configP
 import { callTool, listTools, ApiError, ToolError } from './client.js';
 import { TOOL_COMMANDS, helpText } from './commands.js';
 import { writeProjectDoc } from './init.js';
+import { pretty } from './format.js';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
@@ -21,7 +22,7 @@ const VERSION = (() => {
  * Returns { code, stdout, stderr } instead of writing/exiting itself, so the
  * behaviour is testable and the bin shim stays trivial.
  */
-export async function run(argv, { _fetch = fetch, env = process.env } = {}) {
+export async function run(argv, { _fetch = fetch, env = process.env, tty = false } = {}) {
   const out = [];
   const err = [];
   const { flags, positionals } = parseArgv(argv);
@@ -29,8 +30,12 @@ export async function run(argv, { _fetch = fetch, env = process.env } = {}) {
 
   // --raw=false should mean false, not "a non-empty string is truthy".
   const raw = flags.raw === true || flags.raw === 'true' || flags.raw === '1';
+  const wantJson = flags.json === true || flags.json === 'true' || flags.json === '1';
+  // Humans at a terminal get tables; pipes, agents, --json and --raw get JSON.
+  const human = tty && !raw && !wantJson;
   const print = (obj) => {
-    out.push(typeof obj === 'string' ? obj : JSON.stringify(obj, null, raw ? 0 : 2));
+    if (typeof obj === 'string') { out.push(obj); return; }
+    out.push(human ? pretty(obj) : JSON.stringify(obj, null, raw ? 0 : 2));
   };
   const done = (code = EXIT.OK) => ({ code, stdout: out.join('\n'), stderr: err.join('\n') });