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

package/src/cli/width.js

@@ -0,0 +1,48 @@
+/** ANSI control sequences (colours, cursor moves) that take no columns. */
+export const ANSI_SEQUENCE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+
+const ZERO_WIDTH_RE = /[\u0300-\u036f\u0483-\u0489\u200b-\u200f\u202a-\u202e\u2060-\u2064\ufeff]/;
+
+/** Code point ranges that occupy two terminal columns (CJK, kana, emoji…). */
+const WIDE_RANGES = [
+  [0x1100, 0x115f],
+  [0x2e80, 0x303e],
+  [0x3041, 0x33ff],
+  [0x3400, 0x4dbf],
+  [0x4e00, 0x9fff],
+  [0xa000, 0xa4cf],
+  [0xa960, 0xa97f],
+  [0xac00, 0xd7a3],
+  [0xf900, 0xfaff],
+  [0xfe10, 0xfe19],
+  [0xfe30, 0xfe6f],
+  [0xff00, 0xff60],
+  [0xffe0, 0xffe6],
+  [0x1f300, 0x1f64f],
+  [0x1f680, 0x1f6ff],
+  [0x1f900, 0x1f9ff],
+  [0x1fa70, 0x1faff],
+  [0x20000, 0x3fffd],
+];
+
+/** Terminal columns for one code point (0 for marks, 2 for wide glyphs). */
+export function charWidth(code) {
+  if (!code) return 0;
+  if (ZERO_WIDTH_RE.test(String.fromCodePoint(code))) return 0;
+  for (const [start, end] of WIDE_RANGES) {
+    if (code >= start && code <= end) return 2;
+  }
+  return 1;
+}
+
+/**
+ * Printable columns of a string. The box border math depends on this: counting
+ * characters instead made CJK reasoning lines wrap, so the cursor-up erase
+ * walked the wrong number of rows and the screen scrolled itself apart.
+ */
+export function displayWidth(text, { ansi = false } = {}) {
+  const value = ansi ? String(text ?? '').replace(ANSI_SEQUENCE, '') : String(text ?? '');
+  let width = 0;
+  for (const char of value) width += charWidth(char.codePointAt(0));
+  return width;
+}

package/src/config/load.js

@@ -0,0 +1,137 @@
+import { ConfigError } from '../utils/errors.js';
+import { getSetting } from './settings.js';
+
+// The provider/model catalog lives with the providers; re-exported here so the
+// existing import sites (and the documented defaults) keep one location.
+export { DEFAULT_BASE_URL, DEFAULT_MODEL, MODEL_CATALOG } from '../providers/catalog.js';
+
+/**
+ * config.json `agent` keys mapped to their raw-config names. The names are the
+ * same on purpose: one vocabulary for the file, the settings editor and the
+ * validated config.
+ */
+export const AGENT_SETTING_KEYS = [
+  'maxSteps',
+  'maxOutputTokens',
+  'requestTimeoutMs',
+  'streamIdleTimeoutMs',
+  'maxRetries',
+  'maxRecoveryAttempts',
+  'recoveryBackoffMs',
+  'maxFileBytes',
+  'maxSearchResults',
+  'maxToolOutputBytes',
+  'maxTaskDurationMs',
+  'maxContextChars',
+  'approvalPolicy',
+  'logLevel',
+  'allowShell',
+  'debug',
+  'historyDir',
+  'logDir',
+];
+
+/**
+ * config.json `webSearch` keys mapped to the raw-config key they fill.
+ *
+ * `duckduckgoEnabled`, `duckduckgoCommand` and `duckduckgoArgs` are stored
+ * flat under `webSearch` for a simpler editor row each.
+ */
+export const WEB_SETTING_KEYS = {
+  serperApiKey: 'webSearchApiKey',
+  youApiKey: 'youApiKey',
+  firecrawlApiKey: 'firecrawlApiKey',
+  tavilyApiKey: 'tavilyApiKey',
+  results: 'webSearchResults',
+  timeoutMs: 'webSearchTimeoutMs',
+  providers: 'webSearchProviders',
+  enabled: 'webSearchEnabled',
+  fallback: 'webSearchFallback',
+  disabled: 'webSearchDisabled',
+  endpoint: 'webSearchEndpoint',
+  authHeader: 'webSearchAuthHeader',
+  mcpTimeoutMs: 'webMcpTimeoutMs',
+  mcpMaxRetries: 'webMcpMaxRetries',
+  debug: 'webMcpDebug',
+  duckduckgoEnabled: 'duckduckgoMcpEnabled',
+  duckduckgoCommand: 'duckduckgoMcpCommand',
+  duckduckgoArgs: 'duckduckgoMcpArgs',
+};
+
+/** A list setting is stored as an array but validated as a comma list. */
+function rawListValue(value) {
+  if (!Array.isArray(value)) return value;
+  return value.length > 0 ? value.join(',') : 'none';
+}
+
+/**
+ * Build a raw, unvalidated config object from the user's config.json contents.
+ *
+ * This is the only configuration source: no `.env`, no environment variables.
+ * CLI flags are applied on top by the entry point, and the workspace's
+ * `.ryuu/preferences.json` supplies the last `/provider` and `/model` choices.
+ */
+export function buildRawConfig(settings = {}, { cwd = process.cwd() } = {}) {
+  const data = settings && typeof settings === 'object' && !Array.isArray(settings) ? settings : {};
+
+  // One credentials entry per provider: the key, the base URL override and the
+  // model chosen in `providerModel`. Providers without stored values still get
+  // their catalog defaults from `buildProviders`.
+  const credentials = {};
+  const storedProviders = data.providers && typeof data.providers === 'object' ? data.providers : {};
+  for (const [id, stored] of Object.entries(storedProviders)) {
+    if (!stored || typeof stored !== 'object' || Array.isArray(stored)) continue;
+    credentials[id] = {
+      apiKey: typeof stored.apiKey === 'string' ? stored.apiKey : '',
+      baseURL: typeof stored.baseURL === 'string' ? stored.baseURL : '',
+      model: '',
+    };
+    // Per-provider request overrides (River's `reasoningEffort`, a
+    // pass-through `extraBody`, ...) are stored next to the key.
+    for (const field of ['reasoningEffort', 'thinking', 'extraBody', 'requestParams']) {
+      if (stored[field] !== undefined) credentials[id][field] = stored[field];
+    }
+  }
+  const storedModels = data.providerModel && typeof data.providerModel === 'object' ? data.providerModel : {};
+  for (const [id, model] of Object.entries(storedModels)) {
+    if (typeof model !== 'string') continue;
+    if (!credentials[id]) credentials[id] = { apiKey: '', baseURL: '', model: '' };
+    credentials[id].model = model;
+  }
+
+  const raw = {
+    provider: typeof data.provider === 'string' ? data.provider : null,
+    model: null,
+    providerCredentials: credentials,
+    extraProviders: data.extraProviders ?? null,
+    workspace: '.',
+    cwd,
+  };
+  for (const key of AGENT_SETTING_KEYS) {
+    raw[key] = getSetting(data, `agent.${key}`);
+  }
+  for (const [settingsKey, rawKey] of Object.entries(WEB_SETTING_KEYS)) {
+    const value = getSetting(data, `webSearch.${settingsKey}`);
+    raw[rawKey] = rawListValue(value);
+  }
+  // The selected model comes from the same place the editor writes it.
+  const activeProvider = typeof raw.provider === 'string' ? raw.provider.trim().toLowerCase() : '';
+  if (activeProvider) raw.model = getSetting(data, `providerModel.${activeProvider}`) ?? null;
+  return raw;
+}
+
+/** Verify the Node.js runtime is new enough for the APIs used here. */
+export function checkRuntime({ nodeVersion = process.versions.node } = {}) {
+  const major = Number.parseInt(nodeVersion.split('.')[0], 10);
+  const warnings = [];
+  if (!Number.isFinite(major) || major < 22) {
+    throw new ConfigError(
+      `Node.js ${nodeVersion} is too old. Ryuu Agent CLI requires Node.js 22+ (target: Node.js 25.x).`,
+      { nodeVersion },
+    );
+  }
+  if (major < 25) {
+    warnings.push(`Node.js ${nodeVersion} detected. Ryuu Agent CLI targets Node.js 25.x; older majors are untested.`);
+  }
+  return { major, warnings };
+}

package/src/config/scaffold.js

@@ -0,0 +1,50 @@
+import { BUILTIN_PROVIDERS } from '../providers/catalog.js';
+import { AGENT_SETTING_KEYS, WEB_SETTING_KEYS } from './load.js';
+import { SETTINGS_VERSION, readSettings, settingsFile, writeSettings } from './settings.js';
+
+/**
+ * First-run configuration scaffolding.
+ *
+ * `config.json` is the only configuration source, so a missing file used to
+ * leave a new install with nothing to look at. `buildSettingsSkeleton` returns
+ * the documented shape with every editable key present and empty: an empty
+ * value means "use the built-in default" during validation, which lets the file
+ * double as a checklist without changing behaviour.
+ */
+export function buildSettingsSkeleton({ providerIds = BUILTIN_PROVIDERS.map((provider) => provider.id) } = {}) {
+  const providers = {};
+  const providerModel = {};
+  for (const id of providerIds) {
+    providers[id] = { apiKey: '', baseURL: '' };
+    providerModel[id] = '';
+  }
+  const skeleton = {
+    version: SETTINGS_VERSION,
+    provider: '',
+    providers,
+    providerModel,
+    extraProviders: [],
+    agent: {},
+    webSearch: {},
+  };
+  for (const key of AGENT_SETTING_KEYS) skeleton.agent[key] = '';
+  for (const key of Object.keys(WEB_SETTING_KEYS)) skeleton.webSearch[key] = '';
+  return skeleton;
+}
+
+/**
+ * Create the settings file when it is missing. Existing files are returned
+ * untouched (including a malformed one, which readSettings reports), so a
+ * startup never overwrites something the user wrote.
+ *
+ * Returns the readSettings result plus `created`; the file is written with the
+ * same atomic, owner-only path as every other settings save.
+ */
+export async function ensureSettingsFile({ file = null, ...options } = {}) {
+  const target = file || settingsFile(options);
+  const current = await readSettings({ file: target });
+  if (current.exists) return { ...current, created: false };
+  const data = buildSettingsSkeleton();
+  await writeSettings(data, { file: target });
+  return { file: target, exists: true, created: true, data };
+}