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

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);
+  }
+}

package/src/services/preferences.js

@@ -0,0 +1,249 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import {
+  DEFAULT_PROVIDER_ID,
+  MODEL_ID_PATTERN,
+  MAX_MODEL_ID_LENGTH,
+  normalizeModelId,
+  normalizeProviderId,
+} from '../providers/catalog.js';
+
+/**
+ * User preferences that survive CLI restarts: the active provider, the active
+ * model, and the model ids added with `/addmodel`.
+ *
+ * The state lives in the workspace's `.ryuu` folder next to sessions, logs,
+ * undo and cache, so the choice follows the project the CLI is run from.
+ * Values are validated before being read back, so a hand-edited or corrupt
+ * file can never put an invalid provider/model id into the config.
+ *
+ * Shape (all keys optional):
+ *   {
+ *     "provider": "tokenharbor",
+ *     "model": "deepseek-v4.1-flash:free",
+ *     "providerModel": { "nvidia": "…", "tokenharbor": "…" },
+ *     "providerModels": { "nvidia": ["added-id"] },
+ *     "models": ["legacy ids, read as the active provider's list"]
+ *   }
+ */
+
+/** Upper bound on user-added models, so the list cannot grow without limit. */
+export const MAX_CUSTOM_MODELS = 100;
+export { MAX_MODEL_ID_LENGTH, MODEL_ID_PATTERN, normalizeModelId };
+
+/** Root of the local state folder for a workspace. */
+export function stateDirFor(workspace) {
+  return path.join(workspace || '.', '.ryuu');
+}
+
+export function preferencesFile(dir) {
+  return path.join(dir, 'preferences.json');
+}
+
+/** Read the whole preferences object; {} when absent or corrupt. Never throws. */
+export async function readPreferences(dir) {
+  try {
+    const data = JSON.parse(await fsp.readFile(preferencesFile(dir), 'utf8'));
+    return data && typeof data === 'object' && !Array.isArray(data) ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Merge a patch into preferences.json. Other keys are preserved, so adding or
+ * removing a model never forgets the selected model, and switching a model
+ * never forgets the added ones.
+ */
+async function writePreferences(dir, patch) {
+  try {
+    const payload = {
+      ...(await readPreferences(dir)),
+      ...patch,
+      updatedAt: new Date().toISOString(),
+    };
+    await fsp.mkdir(dir, { recursive: true });
+    await fsp.writeFile(preferencesFile(dir), `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeModelList(raw) {
+  if (!Array.isArray(raw)) return [];
+  const models = [];
+  for (const entry of raw) {
+    const model = normalizeModelId(entry);
+    if (model && !models.includes(model)) models.push(model);
+    if (models.length >= MAX_CUSTOM_MODELS) break;
+  }
+  return models;
+}
+
+/** A validated `provider -> [model ids]` map (unknown entries skipped). */
+function modelListMap(raw) {
+  const map = {};
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return map;
+  for (const [id, list] of Object.entries(raw)) {
+    const providerId = normalizeProviderId(id);
+    if (providerId) map[providerId] = normalizeModelList(list);
+  }
+  return map;
+}
+
+/** A validated `provider -> model id` map. */
+function modelChoiceMap(raw) {
+  const map = {};
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return map;
+  for (const [id, model] of Object.entries(raw)) {
+    const providerId = normalizeProviderId(id);
+    const normalized = normalizeModelId(model);
+    if (providerId && normalized) map[providerId] = normalized;
+  }
+  return map;
+}
+
+/** Read the persisted model, or null when absent/invalid. Never throws. */
+export async function readModelPreference(dir) {
+  return normalizeModelId((await readPreferences(dir)).model);
+}
+
+/**
+ * Persist the model choice. With a provider id the choice is also recorded for
+ * that provider, so switching providers remembers each one's last model.
+ * Returns false (no throw) for invalid ids.
+ */
+export async function writeModelPreference(dir, model, { providerId = null } = {}) {
+  const id = normalizeModelId(model);
+  if (!id) return false;
+  const provider = normalizeProviderId(providerId);
+  if (!provider) return writePreferences(dir, { model: id });
+  const prefs = await readPreferences(dir);
+  return writePreferences(dir, {
+    model: id,
+    providerModel: { ...modelChoiceMap(prefs.providerModel), [provider]: id },
+  });
+}
+
+/** Last model chosen for a provider (falls back to the legacy top-level value). */
+export async function readProviderModel(dir, providerId) {
+  const provider = normalizeProviderId(providerId);
+  if (!provider) return null;
+  const prefs = await readPreferences(dir);
+  const choices = modelChoiceMap(prefs.providerModel);
+  if (choices[provider]) return choices[provider];
+  const hasChoices = Object.keys(choices).length > 0;
+  // Backwards compatibility: files written before per-provider models existed
+  // stored one top-level `model` for the then-active provider.
+  if (!hasChoices) {
+    const active = normalizeProviderId(prefs.provider) || DEFAULT_PROVIDER_ID;
+    if (provider === active) return normalizeModelId(prefs.model);
+  }
+  return null;
+}
+
+/** Persist a model choice for one provider without changing the active model. */
+export async function writeProviderModel(dir, providerId, model) {
+  const provider = normalizeProviderId(providerId);
+  const id = normalizeModelId(model);
+  if (!provider || !id) return false;
+  const prefs = await readPreferences(dir);
+  return writePreferences(dir, {
+    providerModel: { ...modelChoiceMap(prefs.providerModel), [provider]: id },
+  });
+}
+
+/** Read the persisted provider id, or null when absent/invalid. Never throws. */
+export async function readProviderPreference(dir) {
+  return normalizeProviderId((await readPreferences(dir)).provider);
+}
+
+/** Persist the active provider id. Returns false (no throw) for invalid ids. */
+export async function writeProviderPreference(dir, providerId) {
+  const id = normalizeProviderId(providerId);
+  if (!id) return false;
+  return writePreferences(dir, { provider: id });
+}
+
+/**
+ * The ids added with `/addmodel` for one provider, in insertion order,
+ * de-duplicated and validated. A corrupt entry is skipped instead of failing
+ * the whole list. Without a provider id the legacy shared list is returned.
+ */
+export async function readCustomModels(dir, providerId = null) {
+  const prefs = await readPreferences(dir);
+  const legacy = normalizeModelList(prefs.models);
+  const provider = normalizeProviderId(providerId);
+  if (!provider) return legacy;
+  const map = modelListMap(prefs.providerModels);
+  if (Array.isArray(map[provider])) return map[provider];
+  const active = normalizeProviderId(prefs.provider) || DEFAULT_PROVIDER_ID;
+  return provider === active ? legacy : [];
+}
+
+async function writeCustomModels(dir, providerId, models) {
+  const provider = normalizeProviderId(providerId);
+  if (!provider) return writePreferences(dir, { models });
+  const prefs = await readPreferences(dir);
+  return writePreferences(dir, {
+    providerModels: { ...modelListMap(prefs.providerModels), [provider]: models },
+  });
+}
+
+/**
+ * Add an id to a provider's saved model list. Returns { ok, reason, models };
+ * reason is 'invalid' | 'exists' | 'limit' | 'write' when ok is false.
+ */
+export async function addCustomModel(dir, id, providerId = null) {
+  const models = await readCustomModels(dir, providerId);
+  const model = normalizeModelId(id);
+  if (!model) return { ok: false, reason: 'invalid', models };
+  if (models.includes(model)) return { ok: false, reason: 'exists', models };
+  if (models.length >= MAX_CUSTOM_MODELS) return { ok: false, reason: 'limit', models };
+  const next = [...models, model];
+  const saved = await writeCustomModels(dir, providerId, next);
+  return saved ? { ok: true, reason: null, models: next } : { ok: false, reason: 'write', models };
+}
+
+/**
+ * Remove an id from a provider's saved model list. Returns { ok, reason,
+ * models }; reason is 'missing' | 'write' when ok is false.
+ */
+export async function removeCustomModel(dir, id, providerId = null) {
+  const models = await readCustomModels(dir, providerId);
+  const model = normalizeModelId(id);
+  if (!model || !models.includes(model)) return { ok: false, reason: 'missing', models };
+  const next = models.filter((entry) => entry !== model);
+  const saved = await writeCustomModels(dir, providerId, next);
+  return saved ? { ok: true, reason: null, models: next } : { ok: false, reason: 'write', models };
+}
+
+/**
+ * Apply the persisted `/provider` choice at startup. An explicit flag or a
+ * `provider` key in config.json wins and is never overwritten. Returns true when raw.provider
+ * was changed.
+ */
+export async function applyPersistedProvider(raw, { flagProvider = null, stateDir = null } = {}) {
+  if (flagProvider || raw.provider || !stateDir) return false;
+  const persisted = await readProviderPreference(stateDir);
+  if (!persisted) return false;
+  raw.provider = persisted;
+  return true;
+}
+
+/**
+ * Apply the persisted model at startup.
+ * Precedence: explicit --model flag (this run only) > persisted choice for the
+ * selected provider > the provider's own model variable > catalog default.
+ * Returns true when raw.model was changed.
+ */
+export async function applyPersistedModel(raw, { flagModel = null, stateDir = null, providerId = null } = {}) {
+  if (flagModel || !stateDir) return false;
+  const persisted = providerId
+    ? await readProviderModel(stateDir, providerId)
+    : await readModelPreference(stateDir);
+  if (!persisted || persisted === raw.model) return false;
+  raw.model = persisted;
+  return true;
+}