@ryuu-reinzz/ryuu-cli 0.0.0-stage → 0.3.1

package/src/providers/registry.js

@@ -0,0 +1,104 @@
+import { ProviderError } from '../utils/errors.js';
+
+/**
+ * Multi-provider registry.
+ *
+ * Providers are registered by ID and can be instantiated on demand with a
+ * config object. The registry keeps a cache of created providers so the same
+ * instance is reused across requests within a session.
+ *
+ * Usage:
+ *   const registry = new ProviderRegistry();
+ *   registry.register('tokenharbor', createTokenHarborProvider);
+ *   const provider = await registry.resolve('tokenharbor', config, { logger });
+ *
+ * Provider factories receive (config, deps) and must return an object with at
+ * least `chat(...)`, `ping()`, and a `model` getter (matching the existing
+ * NvidiaProvider interface).
+ */
+export class ProviderRegistry {
+  constructor(factories = {}) {
+    this.factories = new Map();
+    this.providers = new Map();
+    for (const [id, factory] of Object.entries(factories)) {
+      this.factories.set(id, factory);
+    }
+  }
+
+  /** Register a provider factory under an id. Overwrites any existing one. */
+  register(id, factory) {
+    if (!id || typeof id !== 'string') {
+      throw new ProviderError('Provider id must be a non-empty string.', {
+        code: 'INVALID_PROVIDER_ID',
+      });
+    }
+    if (typeof factory !== 'function') {
+      throw new ProviderError(`Provider factory for ${id} must be a function.`, {
+        code: 'INVALID_PROVIDER_FACTORY',
+      });
+    }
+    this.factories.set(id, factory);
+    this.providers.delete(id); // drop any cached instance for the old factory
+  }
+
+  /** Unregister a provider and drop any cached instance. */
+  unregister(id) {
+    this.factories.delete(id);
+    this.providers.delete(id);
+  }
+
+  /** Check whether a provider id is known (registered or already instantiated). */
+  has(id) {
+    return this.factories.has(id) || this.providers.has(id);
+  }
+
+  /** List all known provider ids. */
+  list() {
+    return [...this.factories.keys()];
+  }
+
+  /** Return a cached provider instance, or null when none exists yet. */
+  get(id) {
+    return this.providers.get(id) || null;
+  }
+
+  /** Create (and cache) a provider instance for the given id. */
+  create(id, config, deps = {}) {
+    const factory = this.factories.get(id);
+    if (!factory) {
+      throw new ProviderError(`Unknown provider: ${id}. Registered: ${this.list().join(', ') || '(none)'}`, {
+        code: 'UNKNOWN_PROVIDER',
+      });
+    }
+    const provider = factory(config, deps);
+    this.providers.set(id, provider);
+    return provider;
+  }
+
+  /** Resolve a provider: return the cached instance or create a new one. */
+  resolve(id, config, deps = {}) {
+    if (!this.has(id)) {
+      throw new ProviderError(`Unknown provider: ${id}. Registered: ${this.list().join(', ') || '(none)'}`, {
+        code: 'UNKNOWN_PROVIDER',
+      });
+    }
+    const existing = this.providers.get(id);
+    if (existing) return existing;
+    return this.create(id, config, deps);
+  }
+
+  /** Create providers for every registered id (e.g. for health checks). */
+  async createAll(config, deps = {}) {
+    const instances = new Map();
+    for (const id of this.list()) {
+      try {
+        instances.set(id, this.create(id, config, deps));
+      } catch {
+        // Providers that fail to instantiate are simply skipped.
+      }
+    }
+    return instances;
+  }
+}
+
+export const defaultRegistry = new ProviderRegistry();

package/src/services/clipboard.js

@@ -0,0 +1,38 @@
+/**
+ * Copying to the terminal clipboard with OSC 52.
+ *
+ * The sequence is written to the tty, so the copy happens in the terminal
+ * emulator (or terminal multiplexer) rather than through an OS command: it works
+ * over SSH, needs no `pbcopy`/`xclip`/`clip.exe`, and touches no other process.
+ * Terminals that ignore OSC 52 simply do nothing, which is why callers report the
+ * result instead of assuming the clipboard changed.
+ */
+
+/** Terminals cap OSC 52 payloads (xterm's default is ~75k of base64). */
+const MAX_CHARS = 100_000;
+
+/** The raw sequence for `text`, or null when there is nothing to copy. */
+export function clipboardPayload(text, { limit = MAX_CHARS } = {}) {
+  const value = String(text ?? '');
+  if (!value.trim()) return null;
+  const kept = value.length > limit ? value.slice(0, limit) : value;
+  return {
+    sequence: `\x1b]52;c;${Buffer.from(kept, 'utf8').toString('base64')}\x1b\\`,
+    chars: [...kept].length,
+    truncated: kept.length < value.length,
+  };
+}
+
+/**
+ * Put `text` on the clipboard. Returns `{ ok, chars, truncated, reason }`; a
+ * failure is reported, never thrown, because a copy must not break a session.
+ */
+export function copyToClipboard(text, { output = process.stdout } = {}) {
+  const payload = clipboardPayload(text);
+  if (!payload) return { ok: false, reason: 'empty', chars: 0 };
+  if (!output || output.isTTY === false || !output.write) {
+    return { ok: false, reason: 'no-tty', chars: 0 };
+  }
+  output.write(payload.sequence);
+  return { ok: true, chars: payload.chars, truncated: payload.truncated };
+}

package/src/services/diff.js

@@ -0,0 +1,153 @@
+/**
+ * Unified diff generation for edit previews and /diff.
+ * Line-based LCS with a bounded matrix; very large files fall back to a
+ * whole-file replacement hunk instead of consuming unbounded memory.
+ */
+
+const MAX_CELLS = 2_000_000;
+
+function splitLines(text) {
+  return String(text ?? '').split('\n');
+}
+
+/** @returns {{type: 'equal'|'del'|'add', line: string}[]} */
+export function diffLines(oldText, newText) {
+  const a = splitLines(oldText);
+  const b = splitLines(newText);
+  const n = a.length;
+  const m = b.length;
+
+  if (n * m > MAX_CELLS) {
+    return [
+      ...a.map((line) => ({ type: 'del', line })),
+      ...b.map((line) => ({ type: 'add', line })),
+    ];
+  }
+
+  const width = m + 1;
+  const dp = new Int32Array((n + 1) * width);
+  for (let i = n - 1; i >= 0; i -= 1) {
+    for (let j = m - 1; j >= 0; j -= 1) {
+      dp[i * width + j] = a[i] === b[j]
+        ? dp[(i + 1) * width + (j + 1)] + 1
+        : Math.max(dp[(i + 1) * width + j], dp[i * width + (j + 1)]);
+    }
+  }
+
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      ops.push({ type: 'equal', line: a[i] });
+      i += 1;
+      j += 1;
+    } else if (dp[(i + 1) * width + j] >= dp[i * width + (j + 1)]) {
+      ops.push({ type: 'del', line: a[i] });
+      i += 1;
+    } else {
+      ops.push({ type: 'add', line: b[j] });
+      j += 1;
+    }
+  }
+  while (i < n) {
+    ops.push({ type: 'del', line: a[i] });
+    i += 1;
+  }
+  while (j < m) {
+    ops.push({ type: 'add', line: b[j] });
+    j += 1;
+  }
+  return ops;
+}
+
+/**
+ * Produce a standard unified diff. Returns '' when contents are identical.
+ *
+ * @param {string} oldText
+ * @param {string} newText
+ * @param {{oldLabel?: string, newLabel?: string, context?: number, maxLines?: number}} options
+ */
+export function createUnifiedDiff(oldText, newText, {
+  oldLabel = 'a/file',
+  newLabel = 'b/file',
+  context = 3,
+  maxLines = 400,
+} = {}) {
+  if (oldText === newText) return '';
+  const ops = diffLines(oldText, newText);
+
+  // Mark which ops are changes, then group with context.
+  const changed = ops.map((op) => op.type !== 'equal');
+  const hunks = [];
+  let index = 0;
+  while (index < ops.length) {
+    if (!changed[index]) {
+      index += 1;
+      continue;
+    }
+    let start = Math.max(0, index - context);
+    let end = index;
+    // Extend while later changes are within 2*context of the current end.
+    while (end < ops.length) {
+      if (changed[end]) {
+        end += 1;
+        continue;
+      }
+      let nextChange = end;
+      while (nextChange < ops.length && !changed[nextChange]) nextChange += 1;
+      if (nextChange < ops.length && nextChange - end <= context * 2) {
+        end = nextChange;
+        continue;
+      }
+      break;
+    }
+    const hunkEnd = Math.min(ops.length, end + context);
+    hunks.push({ start, end: hunkEnd });
+    index = hunkEnd;
+  }
+
+  const oldLineAt = new Array(ops.length);
+  const newLineAt = new Array(ops.length);
+  let oldNo = 1;
+  let newNo = 1;
+  for (let k = 0; k < ops.length; k += 1) {
+    oldLineAt[k] = oldNo;
+    newLineAt[k] = newNo;
+    if (ops[k].type !== 'add') oldNo += 1;
+    if (ops[k].type !== 'del') newNo += 1;
+  }
+
+  const output = [`--- ${oldLabel}`, `+++ ${newLabel}`];
+  let emitted = 0;
+  for (const hunk of hunks) {
+    if (emitted >= maxLines) {
+      output.push(`@@ diff truncated after ${maxLines} lines @@`);
+      break;
+    }
+    const slice = ops.slice(hunk.start, hunk.end);
+    const oldCount = slice.filter((op) => op.type !== 'add').length;
+    const newCount = slice.filter((op) => op.type !== 'del').length;
+    const oldStart = oldCount === 0 ? oldLineAt[hunk.start] - 1 : oldLineAt[hunk.start];
+    const newStart = newCount === 0 ? newLineAt[hunk.start] - 1 : newLineAt[hunk.start];
+    output.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
+    for (const op of slice) {
+      const prefix = op.type === 'equal' ? ' ' : op.type === 'del' ? '-' : '+';
+      output.push(`${prefix}${op.line}`);
+      emitted += 1;
+      if (emitted >= maxLines) break;
+    }
+  }
+  return output.join('\n');
+}
+
+export function diffStats(oldText, newText) {
+  const ops = diffLines(oldText, newText);
+  let added = 0;
+  let removed = 0;
+  for (const op of ops) {
+    if (op.type === 'add') added += 1;
+    else if (op.type === 'del') removed += 1;
+  }
+  return { added, removed, changed: added + removed };
+}

package/src/services/doctor.js

@@ -0,0 +1,126 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { checkRuntime } from '../config/load.js';
+import { redact } from '../utils/redaction.js';
+
+const execFileAsync = promisify(execFile);
+
+const PASS = 'pass';
+const WARN = 'warn';
+const FAIL = 'fail';
+const SKIP = 'skip';
+
+/**
+ * Diagnostics that never print secrets. With { live: true } it performs one
+ * small chat request; otherwise it stays fully offline.
+ */
+export async function runDoctor({ config, workspace, provider = null, live = false, logger = null } = {}) {
+  const checks = [];
+  const add = (name, status, detail) => checks.push({ name, status, detail });
+
+  try {
+    const runtime = checkRuntime();
+    add('runtime', runtime.major >= 25 ? PASS : WARN, `Node.js ${process.version} (target: Node.js 25.x)`);
+  } catch (error) {
+    add('runtime', FAIL, error.message);
+  }
+
+  const apiKeyPath = config.apiKeyPath || 'providers.nvidia.apiKey';
+  const providerName = config.providerName || 'NVIDIA Integrate API';
+  const providerId = config.providerId || 'nvidia';
+  add(
+    'config',
+    config.apiKey ? PASS : FAIL,
+    config.apiKey ? `${apiKeyPath} is set (value hidden)` : `${apiKeyPath} is missing`,
+  );
+  add('provider.endpoint', PASS, `${providerName} (${providerId}) at ${config.baseURL} (OpenAI-compatible chat.completions)`);
+  add('provider.model', config.apiKey ? PASS : WARN, config.model);
+  const providerRows = Array.isArray(config.providers) ? config.providers : [];
+  add(
+    'provider.catalog',
+    providerRows.length > 0 ? PASS : FAIL,
+    providerRows.length > 0
+      ? providerRows
+          .map((provider) => `${provider.id}${provider.id === providerId ? '*' : ''}: ${provider.apiKey ? 'key set' : `no key (${provider.apiKeyPath})`}`)
+          .join(' · ')
+      : 'no providers configured',
+  );
+  add(
+    'web_search',
+    config.webSearchApiKey ? PASS : SKIP,
+    config.webSearchApiKey
+      ? `${config.webSearchEndpoint} (key hidden, ${config.webSearchResults} result cap)`
+      : 'Disabled: set webSearch.serperApiKey in config.json to enable the web_search tool.',
+  );
+
+  if (workspace) {
+    try {
+      const probeName = `.ryuu/doctor-probe-${crypto.randomBytes(3).toString('hex')}.txt`;
+      await workspace.writeText(probeName, 'ryuu doctor probe\n');
+      const readBack = await workspace.readText(probeName);
+      await workspace.remove(probeName);
+      add('workspace.write', readBack.text.startsWith('ryuu doctor probe') ? PASS : FAIL, `Read/write OK in ${workspace.root}`);
+    } catch (error) {
+      add('workspace.write', FAIL, `Cannot write inside workspace: ${error.message}`);
+    }
+  } else {
+    add('workspace.write', FAIL, 'Workspace is not available');
+  }
+
+  for (const [label, dir] of [['state.history', config.historyDir], ['state.logs', config.logDir], ['state.undo', config.undoDir]]) {
+    try {
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+      await fsp.access(dir, fs.constants.W_OK);
+      add(label, PASS, dir);
+    } catch (error) {
+      add(label, FAIL, `${dir} is not writable: ${error.message}`);
+    }
+  }
+
+  try {
+    const { stdout } = await execFileAsync('git', ['--version'], { timeout: 5000 });
+    add('git', PASS, stdout.trim());
+  } catch {
+    add('git', WARN, 'Git is not installed; /diff and inspect_git will report unavailable.');
+  }
+
+  if (!config.apiKey) {
+    add('provider.connectivity', SKIP, `Skipped: no API key. Set ${apiKeyPath}, then run /doctor live.`);
+  } else if (!live) {
+    add('provider.connectivity', SKIP, 'Offline check only. Run /doctor live (or `ryuu --doctor --live`) for one small API call.');
+  } else if (!provider) {
+    add('provider.connectivity', FAIL, 'Provider is not initialized.');
+  } else {
+    const result = await provider.ping();
+    if (result.ok) {
+      add('provider.connectivity', PASS, `${providerName} · ${result.model} responded in ${result.latencyMs}ms`);
+    } else {
+      add('provider.connectivity', FAIL, redact(`${result.error.code}: ${result.error.message}`));
+    }
+  }
+
+  logger?.info('doctor finished', { ok: !checks.some((check) => check.status === FAIL), live });
+  return {
+    live,
+    ok: !checks.some((check) => check.status === FAIL),
+    checks,
+  };
+}
+
+export function formatDoctor(report) {
+  const icon = { pass: 'PASS', warn: 'WARN', fail: 'FAIL', skip: 'SKIP' };
+  const lines = ['Ryuu Agent CLI doctor'];
+  for (const check of report.checks) {
+    lines.push(`[${icon[check.status] || check.status}] ${check.name}: ${check.detail}`);
+  }
+  lines.push(report.ok ? 'Result: ready (warnings are informational).' : 'Result: blocking issues found.');
+  return lines.join('\n');
+}
+
+export function doctorLogPath(config) {
+  return path.join(config.logDir, 'agent.log');
+}

package/src/services/logger.js

@@ -0,0 +1,190 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRedactor } from '../utils/redaction.js';
+
+export const LEVELS = { debug: 10, info: 20, warn: 30, error: 40, silent: 100 };
+
+const MAX_LOG_BYTES = 5 * 1024 * 1024;
+const MAX_REASONING_CHARS = 2_000_000;
+
+/**
+ * Leveled logger. Everything written to the log file and to stderr passes
+ * through the redactor first. Model output and tool output are logged as
+ * bounded previews, never full credential material.
+ */
+export class Logger {
+  constructor({ level = 'info', file = null, secrets = [], stderr = null, echo = false, maxPreview = 2000 } = {}) {
+    this.level = LEVELS[level] ?? LEVELS.info;
+    this.levelName = level;
+    this.file = file;
+    this.stderr = stderr;
+    this.echo = echo;
+    this.maxPreview = maxPreview;
+    this.redact = createRedactor(secrets);
+    this.enabled = this.level < LEVELS.silent;
+    if (this.file && this.enabled) {
+      try {
+        fs.mkdirSync(path.dirname(this.file), { recursive: true, mode: 0o700 });
+        this.#restrictPermissions();
+        this.#rotateIfNeeded();
+      } catch (error) {
+        this.file = null;
+        this.stderr?.write(`[warn] Cannot create log file: ${error.message}\n`);
+      }
+    }
+  }
+
+  get logFile() {
+    return this.file;
+  }
+
+  setLevel(level) {
+    if (LEVELS[level] === undefined) return;
+    this.level = LEVELS[level];
+    this.levelName = level;
+    this.enabled = this.level < LEVELS.silent;
+  }
+
+  child(bindings = {}) {
+    const logger = Object.create(this);
+    logger.bindings = { ...(this.bindings || {}), ...bindings };
+    logger.child = Logger.prototype.child;
+    logger.log = Logger.prototype.log;
+    logger.writeLine = Logger.prototype.writeLine;
+    return logger;
+  }
+
+  debug(message, meta) {
+    this.log('debug', message, meta);
+  }
+
+  info(message, meta) {
+    this.log('info', message, meta);
+  }
+
+  warn(message, meta) {
+    this.log('warn', message, meta);
+  }
+
+  error(message, meta) {
+    this.log('error', message, meta);
+  }
+
+  log(level, message, meta) {
+    if (LEVELS[level] < this.level) return;
+    const entry = {
+      ts: new Date().toISOString(),
+      level,
+      msg: this.#preview(message),
+      ...(this.bindings || {}),
+    };
+    if (meta !== undefined) {
+      entry.meta = this.#sanitizeMeta(meta);
+    }
+    this.writeLine(entry);
+  }
+
+  #preview(value) {
+    const text = typeof value === 'string' ? value : safeStringify(value);
+    const bounded = text.length > this.maxPreview ? `${text.slice(0, this.maxPreview)}…[truncated]` : text;
+    return this.redact(bounded);
+  }
+
+  #sanitizeMeta(meta) {
+    const text = safeStringify(meta);
+    const bounded = text.length > this.maxPreview ? `${text.slice(0, this.maxPreview)}…[truncated]` : text;
+    const cleaned = this.redact(bounded);
+    try {
+      return JSON.parse(cleaned);
+    } catch {
+      return cleaned;
+    }
+  }
+
+  /**
+   * Persist provider-exposed reasoning separately from the main log. The text
+   * is redacted and bounded; the returned path is safe to show in the UI.
+   */
+  writeReasoning({ sessionId = 'session', step = null, text = '' } = {}) {
+    if (!this.file || !this.enabled || !text) return null;
+    const safeId = String(sessionId).replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 80) || 'session';
+    const dir = path.join(path.dirname(this.file), 'reasoning');
+    const file = path.join(dir, `reasoning-${safeId}.log`);
+    const clean = this.redact(String(text));
+    const body = clean.length > MAX_REASONING_CHARS
+      ? `${clean.slice(0, MAX_REASONING_CHARS)}\n…[reasoning truncated at ${MAX_REASONING_CHARS} chars]`
+      : clean;
+    try {
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+      if (process.platform !== 'win32') {
+        try {
+          fs.chmodSync(dir, 0o700);
+          if (fs.existsSync(file)) fs.chmodSync(file, 0o600);
+        } catch {
+          // Non-fatal; the text is still redacted.
+        }
+      }
+      const header = `\n=== step ${step ?? '?'} · ${new Date().toISOString()} ===\n`;
+      fs.appendFileSync(file, `${header}${body}\n`, { encoding: 'utf8', mode: 0o600 });
+      return file;
+    } catch (error) {
+      this.stderr?.write(`[warn] Cannot write reasoning log: ${error.message}\n`);
+      return null;
+    }
+  }
+
+  writeLine(entry) {
+    const line = this.redact(safeStringify(entry));
+    if (this.file && this.enabled) {
+      try {
+        fs.appendFileSync(this.file, `${line}\n`, { encoding: 'utf8', mode: 0o600 });
+      } catch {
+        // Logging must never crash the agent; keep stderr usable instead.
+      }
+    }
+    if (this.echo && this.stderr) {
+      this.stderr.write(`${line}\n`);
+    }
+  }
+
+  /** Logs may contain workspace excerpts, so keep them owner-only on POSIX. */
+  #restrictPermissions() {
+    if (!this.file || process.platform === 'win32') return;
+    try {
+      fs.chmodSync(path.dirname(this.file), 0o700);
+      if (fs.existsSync(this.file)) fs.chmodSync(this.file, 0o600);
+    } catch {
+      // Non-fatal: the log is still redacted even if chmod is unavailable.
+    }
+  }
+
+  #rotateIfNeeded() {
+    if (!this.file || !fs.existsSync(this.file)) return;
+    const stat = fs.statSync(this.file);
+    if (stat.size < MAX_LOG_BYTES) return;
+    const backup = `${this.file}.1`;
+    fs.rmSync(backup, { force: true });
+    fs.renameSync(this.file, backup);
+  }
+}
+
+export function createLogger(config, { stderr = process.stderr, secrets = [], echo = false } = {}) {
+  return new Logger({
+    level: config.logLevel,
+    file: config.logDir ? path.join(config.logDir, 'agent.log') : null,
+    secrets: [config.apiKey, ...secrets].filter(Boolean),
+    stderr,
+    echo,
+  });
+}
+
+function safeStringify(value) {
+  if (value instanceof Error) {
+    return JSON.stringify({ name: value.name, message: value.message, code: value.code, stack: value.stack });
+  }
+  try {
+    return JSON.stringify(value, (key, item) => (typeof item === 'bigint' ? item.toString() : item));
+  } catch {
+    return String(value);
+  }
+}