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

package/src/services/provider-settings.js

@@ -0,0 +1,226 @@
+import { getSetting, updateSettings } from '../config/settings.js';
+import {
+  BUILTIN_PROVIDERS,
+  MAX_EXTRA_PROVIDERS,
+  MAX_MODELS_PER_PROVIDER,
+  normalizeModelId,
+  normalizeProviderId,
+} from '../providers/catalog.js';
+
+/**
+ * Provider and model management for config.json.
+ *
+ * `/provider add|del` and `/addmodel|/delmodel` edit the same `extraProviders`
+ * list the file already uses, so a provider added at runtime is indistinguishable
+ * from one written by hand and survives restarts. Built-in providers are
+ * read-only: only their added model ids (in .ryuu/preferences.json) are editable.
+ */
+
+const BUILTIN_IDS = new Set(BUILTIN_PROVIDERS.map((provider) => provider.id));
+
+export function isBuiltinProviderId(id) {
+  return BUILTIN_IDS.has(String(id ?? '').trim().toLowerCase());
+}
+
+/** The stored extraProviders array, never the module-level default. */
+export function readExtraProviders(settings) {
+  const value = getSetting(settings, 'extraProviders');
+  return Array.isArray(value) ? value : [];
+}
+
+function modelIdsOf(entry) {
+  if (!Array.isArray(entry?.models)) return [];
+  return entry.models
+    .map((model) => normalizeModelId(typeof model === 'string' ? model : model?.id))
+    .filter(Boolean);
+}
+
+function normalizeBaseUrl(value) {
+  const text = String(value ?? '').trim();
+  if (!text) return null;
+  try {
+    const parsed = new URL(text);
+    if (!['http:', 'https:'].includes(parsed.protocol)) return null;
+    if (parsed.username || parsed.password) return null;
+    return parsed.toString().replace(/\/$/, '');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Add a user provider. The id comes from the name, so `/provider add river …`
+ * creates `river` and stores its key under `providers.river.apiKey`.
+ * Returns { ok, reason } with reason 'builtin' | 'exists' | 'invalid' |
+ * 'url' | 'limit' | 'write'.
+ */
+export async function addExtraProvider({ name, baseURL, apiKey = '', label = null }) {
+  const id = normalizeProviderId(name);
+  if (!id) return { ok: false, reason: 'invalid' };
+  if (BUILTIN_IDS.has(id)) return { ok: false, reason: 'builtin' };
+  const url = normalizeBaseUrl(baseURL);
+  if (!url) return { ok: false, reason: 'url' };
+  let reason = null;
+  let updated = false;
+  try {
+    await updateSettings((draft) => {
+      const entries = readExtraProviders(draft).filter((entry) => entry && typeof entry === 'object');
+      const existing = entries.find((entry) => normalizeProviderId(entry.id) === id);
+      if (existing) {
+        // Re-adding with a key is the documented way to update it.
+        if (!apiKey) {
+          reason = 'exists';
+          return draft;
+        }
+        draft.providers = draft.providers && typeof draft.providers === 'object' ? draft.providers : {};
+        const stored = draft.providers[id] && typeof draft.providers[id] === 'object' ? draft.providers[id] : {};
+        draft.providers[id] = { ...stored, apiKey: String(apiKey).trim() };
+        updated = true;
+        return draft;
+      }
+      if (entries.length >= MAX_EXTRA_PROVIDERS) {
+        reason = 'limit';
+        return draft;
+      }
+      entries.push({
+        id,
+        name: label || name,
+        baseURL: url,
+        models: [],
+        capabilities: { streaming: true, tools: true, reasoning: false, multimodal: false },
+      });
+      draft.extraProviders = entries;
+      if (apiKey) {
+        draft.providers = draft.providers && typeof draft.providers === 'object' ? draft.providers : {};
+        const stored = draft.providers[id] && typeof draft.providers[id] === 'object' ? draft.providers[id] : {};
+        draft.providers[id] = { ...stored, apiKey: String(apiKey).trim() };
+      } else if (draft.providers && typeof draft.providers === 'object' && !draft.providers[id]) {
+        draft.providers[id] = { apiKey: '' };
+      }
+      return draft;
+    });
+  } catch {
+    return { ok: false, reason: 'write' };
+  }
+  return reason ? { ok: false, reason } : { ok: true, reason: null, id, baseURL: url, updated };
+}
+
+/**
+ * Remove a user provider plus its credentials and remembered model.
+ * Returns { ok, reason } with reason 'builtin' | 'missing' | 'active' | 'write'.
+ */
+export async function removeExtraProvider(id, { active = false } = {}) {
+  const provider = normalizeProviderId(id);
+  if (!provider) return { ok: false, reason: 'missing' };
+  if (BUILTIN_IDS.has(provider)) return { ok: false, reason: 'builtin' };
+  if (active) return { ok: false, reason: 'active' };
+  let reason = null;
+  try {
+    await updateSettings((draft) => {
+      const entries = readExtraProviders(draft);
+      const index = entries.findIndex((entry) => normalizeProviderId(entry?.id) === provider);
+      if (index === -1) {
+        reason = 'missing';
+        return draft;
+      }
+      entries.splice(index, 1);
+      draft.extraProviders = entries;
+      if (draft.providers && typeof draft.providers === 'object') delete draft.providers[provider];
+      if (draft.providerModel && typeof draft.providerModel === 'object') delete draft.providerModel[provider];
+      return draft;
+    });
+  } catch {
+    return { ok: false, reason: 'write' };
+  }
+  return reason ? { ok: false, reason } : { ok: true, reason: null };
+}
+
+/**
+ * Append a model id to a user provider's `models`. The first model also becomes
+ * the provider's default. Returns { ok, reason, added, models } with reason
+ * 'missing' | 'builtin' | 'invalid' | 'exists' | 'limit' | 'write'.
+ */
+export async function addExtraProviderModel(id, model, { label = null } = {}) {
+  const provider = normalizeProviderId(id);
+  const modelId = normalizeModelId(model);
+  if (!provider) return { ok: false, reason: 'missing' };
+  if (!modelId) return { ok: false, reason: 'invalid' };
+  if (BUILTIN_IDS.has(provider)) return { ok: false, reason: 'builtin' };
+  let reason = null;
+  let models = [];
+  try {
+    await updateSettings((draft) => {
+      const entries = readExtraProviders(draft);
+      const entry = entries.find((item) => normalizeProviderId(item?.id) === provider);
+      if (!entry) {
+        reason = 'missing';
+        return draft;
+      }
+      models = modelIdsOf(entry);
+      if (models.includes(modelId)) {
+        reason = 'exists';
+        return draft;
+      }
+      if (models.length >= MAX_MODELS_PER_PROVIDER) {
+        reason = 'limit';
+        return draft;
+      }
+      models.push(modelId);
+      const storedNames = Array.isArray(entry.models)
+        ? new Map(entry.models.map((item) => [normalizeModelId(typeof item === 'string' ? item : item?.id), typeof item === 'object' ? item?.name : null]))
+        : new Map();
+      entry.models = models.map((item) => {
+        const display = storedNames.get(item);
+        return display && display !== item ? { id: item, name: display } : item;
+      });
+      if (!normalizeModelId(entry.defaultModel)) entry.defaultModel = modelId;
+      entry.name = entry.name || label || provider;
+      return draft;
+    });
+  } catch {
+    return { ok: false, reason: 'write' };
+  }
+  return reason ? { ok: false, reason, models } : { ok: true, reason: null, added: modelId, models };
+}
+
+/**
+ * Remove a model id from a user provider and recompute its default.
+ * Returns { ok, reason, models, defaultModel } with reason 'missing' | 'builtin'
+ * | 'invalid' | 'absent' | 'write'.
+ */
+export async function removeExtraProviderModel(id, model) {
+  const provider = normalizeProviderId(id);
+  const modelId = normalizeModelId(model);
+  if (!provider) return { ok: false, reason: 'missing' };
+  if (!modelId) return { ok: false, reason: 'invalid' };
+  if (BUILTIN_IDS.has(provider)) return { ok: false, reason: 'builtin' };
+  let reason = null;
+  let models = [];
+  let defaultModel = null;
+  try {
+    await updateSettings((draft) => {
+      const entries = readExtraProviders(draft);
+      const entry = entries.find((item) => normalizeProviderId(item?.id) === provider);
+      if (!entry) {
+        reason = 'missing';
+        return draft;
+      }
+      const current = modelIdsOf(entry);
+      if (!current.includes(modelId)) {
+        reason = 'absent';
+        models = current;
+        return draft;
+      }
+      models = current.filter((item) => item !== modelId);
+      entry.models = models;
+      if (normalizeModelId(entry.defaultModel) === modelId) entry.defaultModel = models[0] || null;
+      defaultModel = normalizeModelId(entry.defaultModel);
+      return draft;
+    });
+  } catch {
+    return { ok: false, reason: 'write' };
+  }
+  return reason
+    ? { ok: false, reason, models }
+    : { ok: true, reason: null, models, defaultModel };
+}

package/src/services/sessions.js

@@ -0,0 +1,279 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { createRedactor } from '../utils/redaction.js';
+import { SessionError } from '../utils/errors.js';
+
+const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,80}$/;
+
+export function createSessionId(now = new Date()) {
+  const stamp = now.toISOString().replace(/[-:T]/g, '').slice(0, 14);
+  return `${stamp}-${crypto.randomBytes(3).toString('hex')}`;
+}
+
+export function createSessionRecord({ task, model, workspace, id } = {}) {
+  const now = new Date().toISOString();
+  return {
+    id: id || createSessionId(),
+    task: task || '',
+    model: model || '',
+    workspace: workspace || '',
+    status: 'active',
+    createdAt: now,
+    updatedAt: now,
+    steps: 0,
+    durationMs: null,
+    // Per-task model telemetry: how many calls, how long they took, how long
+    // the first token took, and how many reads the worklog made unnecessary.
+    modelCalls: 0,
+    requestMs: 0,
+    firstTokenMs: null,
+    cachedReads: 0,
+    metrics: {},
+    tokenUsage: { prompt: 0, completion: 0, total: 0 },
+    changedFiles: [],
+    commands: [],
+    issues: [],
+    plan: '',
+    transcript: [],
+    // Conversation memory handed to the next task (user/assistant turns only).
+    conversation: [],
+  };
+}
+
+/**
+ * Session store under `.ryuu/sessions` (gitignored). Stored transcript entries
+ * are bounded previews only; full file contents and secrets are never persisted.
+ */
+export class SessionStore {
+  constructor({ dir, secrets = [], logger = null }) {
+    this.dir = dir;
+    this.logger = logger;
+    this.redact = createRedactor(secrets);
+  }
+
+  #fileFor(id) {
+    if (!ID_PATTERN.test(id)) throw new SessionError(`Invalid session id: ${id}`, { id });
+    return path.join(this.dir, `${id}.json`);
+  }
+
+  async #ensureDir() {
+    await fsp.mkdir(this.dir, { recursive: true, mode: 0o700 });
+  }
+
+  /** Bound and redact a session before it touches disk. */
+  sanitize(session) {
+    const sanitized = {
+      ...session,
+      task: this.redact(String(session.task || '')).slice(0, 4000),
+      plan: this.redact(String(session.plan || '')).slice(0, 4000),
+      durationMs: Number.isFinite(session.durationMs) ? session.durationMs : null,
+      modelCalls: Number(session.modelCalls) || 0,
+      requestMs: Number(session.requestMs) || 0,
+      firstTokenMs: Number.isFinite(session.firstTokenMs) ? session.firstTokenMs : null,
+      cachedReads: Number(session.cachedReads) || 0,
+      metrics: session.metrics && typeof session.metrics === 'object' ? { ...session.metrics } : {},
+      worklog: this.#sanitizeWorklog(session.worklog),
+      changedFiles: (session.changedFiles || []).slice(0, 500),
+      commands: (session.commands || []).slice(0, 200).map((cmd) => ({
+        ...cmd,
+        argv: Array.isArray(cmd.argv) ? cmd.argv.map((part) => this.redact(String(part)).slice(0, 300)) : [],
+        output: this.redact(String(cmd.output || '')).slice(0, 2000),
+      })),
+      issues: (session.issues || []).slice(0, 100).map((issue) => this.redact(String(issue)).slice(0, 1000)),
+      conversation: (session.conversation || []).slice(-40).map((entry) => ({
+        role: entry.role === 'assistant' ? 'assistant' : 'user',
+        content: this.redact(String(entry.content || '')).slice(0, 4000),
+      })),
+      transcript: (session.transcript || []).slice(-200).map((entry) => ({
+        role: entry.role,
+        ...(entry.name ? { name: entry.name } : {}),
+        ...(entry.ok !== undefined ? { ok: entry.ok } : {}),
+        content: this.redact(String(entry.content || '')).slice(0, 4000),
+        ...(entry.durationMs !== undefined ? { durationMs: entry.durationMs } : {}),
+        ...(entry.at ? { at: entry.at } : {}),
+      })),
+    };
+    return sanitized;
+  }
+
+  /** Bounded, redacted worklog: enough to resume, small enough to store. */
+  #sanitizeWorklog(worklog) {
+    if (!worklog || typeof worklog !== 'object') return null;
+    return {
+      plan: this.redact(String(worklog.plan || '')).slice(0, 1500),
+      files: (worklog.files || []).slice(-40).map((entry) => ({
+        path: this.redact(String(entry?.path || '')).slice(0, 400),
+        read: Boolean(entry?.read),
+        changed: Boolean(entry?.changed),
+        ranges: Array.isArray(entry?.ranges) ? entry.ranges.slice(-4) : [],
+        mtimeMs: Number.isFinite(entry?.mtimeMs) ? entry.mtimeMs : null,
+        totalLines: Number.isFinite(entry?.totalLines) ? entry.totalLines : null,
+        lines: Number.isFinite(entry?.lines) ? entry.lines : null,
+        tool: entry?.tool ? String(entry.tool).slice(0, 40) : null,
+      })),
+      commands: (worklog.commands || []).slice(-12).map((command) => ({
+        argv: this.redact(String(command?.argv || '')).slice(0, 200),
+        exitCode: command?.exitCode ?? null,
+        durationMs: command?.durationMs ?? null,
+        status: command?.status ? String(command.status).slice(0, 40) : null,
+      })),
+      findings: (worklog.findings || []).slice(-12).map((finding) => this.redact(String(finding)).slice(0, 300)),
+      tasks: (worklog.tasks || []).slice(-6).map((entry) => ({
+        task: this.redact(String(entry?.task || '')).slice(0, 160),
+        status: String(entry?.status || '').slice(0, 40),
+        changedFiles: (entry?.changedFiles || []).slice(0, 8).map((file) => this.redact(String(file)).slice(0, 400)),
+      })),
+    };
+  }
+
+  async save(session) {
+    await this.#ensureDir();
+    const sanitized = this.sanitize({ ...session, updatedAt: new Date().toISOString() });
+    const file = this.#fileFor(sanitized.id);
+    const tmp = `${file}.${process.pid}.tmp`;
+    await fsp.writeFile(tmp, `${JSON.stringify(sanitized, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await fsp.rename(tmp, file);
+    this.logger?.debug('session saved', { id: sanitized.id, file });
+    return sanitized;
+  }
+
+  async load(id) {
+    const file = this.#fileFor(id);
+    try {
+      const text = await fsp.readFile(file, 'utf8');
+      return JSON.parse(text);
+    } catch (error) {
+      if (error.code === 'ENOENT') throw new SessionError(`Session not found: ${id}`, { id });
+      if (error instanceof SyntaxError) throw new SessionError(`Session file is corrupt: ${id}`, { id });
+      throw new SessionError(`Cannot load session ${id}: ${error.message}`, { id });
+    }
+  }
+
+  async list({ limit = 50 } = {}) {
+    if (!fs.existsSync(this.dir)) return [];
+    const entries = await fsp.readdir(this.dir);
+    const sessions = [];
+    for (const entry of entries) {
+      if (!entry.endsWith('.json')) continue;
+      const id = entry.slice(0, -5);
+      if (!ID_PATTERN.test(id)) continue;
+      try {
+        const data = JSON.parse(await fsp.readFile(path.join(this.dir, entry), 'utf8'));
+        sessions.push({
+          id: data.id || id,
+          task: (data.task || '').slice(0, 120),
+          status: data.status,
+          model: data.model,
+          createdAt: data.createdAt,
+          updatedAt: data.updatedAt,
+          steps: data.steps || 0,
+          durationMs: Number.isFinite(data.durationMs) ? data.durationMs : null,
+          tokenUsage: data.tokenUsage || null,
+          changedFiles: (data.changedFiles || []).length,
+        });
+      } catch {
+        sessions.push({ id, task: '(unreadable session file)', status: 'corrupt', createdAt: null, updatedAt: null });
+      }
+    }
+    sessions.sort((a, b) => String(b.updatedAt || '').localeCompare(String(a.updatedAt || '')));
+    return sessions.slice(0, limit);
+  }
+
+  async delete(id) {
+    const file = this.#fileFor(id);
+    try {
+      await fsp.unlink(file);
+      return true;
+    } catch (error) {
+      if (error.code === 'ENOENT') return false;
+      throw new SessionError(`Cannot delete session ${id}: ${error.message}`, { id });
+    }
+  }
+
+  async clear() {
+    if (!fs.existsSync(this.dir)) return 0;
+    const entries = await fsp.readdir(this.dir);
+    let removed = 0;
+    for (const entry of entries) {
+      if (!entry.endsWith('.json')) continue;
+      await fsp.rm(path.join(this.dir, entry), { force: true });
+      removed += 1;
+    }
+    return removed;
+  }
+}
+
+/**
+ * Project summary cache. The fingerprint covers manifests and directory shape,
+ * so any relevant change invalidates the cached summary automatically.
+ */
+export class ProjectSummaryCache {
+  constructor({ file, ttlMs = 0 }) {
+    this.file = file;
+    this.ttlMs = ttlMs;
+  }
+
+  fingerprint(workspace) {
+    const hash = crypto.createHash('sha256');
+    const manifests = ['package.json', 'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'pyproject.toml', 'go.mod', 'Cargo.toml'];
+    for (const name of manifests) {
+      const file = path.join(workspace, name);
+      try {
+        const stat = fs.statSync(file);
+        hash.update(`${name}:${stat.size}:${stat.mtimeMs}`);
+      } catch {
+        hash.update(`${name}:-`);
+      }
+    }
+    try {
+      const top = fs.readdirSync(workspace, { withFileTypes: true })
+        .filter((entry) => !entry.name.startsWith('.'))
+        .map((entry) => `${entry.isDirectory() ? 'd' : 'f'}:${entry.name}`)
+        .sort();
+      hash.update(top.join('|'));
+    } catch {
+      hash.update('unreadable');
+    }
+    return hash.digest('hex').slice(0, 32);
+  }
+
+  read() {
+    try {
+      return JSON.parse(fs.readFileSync(this.file, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+
+  get(workspace) {
+    const cached = this.read();
+    if (!cached) return null;
+    const fingerprint = this.fingerprint(workspace);
+    if (cached.fingerprint !== fingerprint) return null;
+    if (this.ttlMs > 0 && Date.now() - new Date(cached.updatedAt).getTime() > this.ttlMs) return null;
+    return cached;
+  }
+
+  set(workspace, summary) {
+    const payload = {
+      fingerprint: this.fingerprint(workspace),
+      summary,
+      updatedAt: new Date().toISOString(),
+    };
+    try {
+      fs.mkdirSync(path.dirname(this.file), { recursive: true });
+      const tmp = `${this.file}.${process.pid}.tmp`;
+      fs.writeFileSync(tmp, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 });
+      fs.renameSync(tmp, this.file);
+    } catch {
+      // Cache failures are never fatal.
+    }
+    return payload;
+  }
+
+  invalidate() {
+    fs.rmSync(this.file, { force: true });
+  }
+}

package/src/services/undo.js

@@ -0,0 +1,133 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { FileChangedError, ToolError } from '../utils/errors.js';
+
+/**
+ * Undo records exact before/after snapshots for file operations performed by
+ * this agent session. /undo only reverts when the file still matches the
+ * recorded after-state; it refuses otherwise instead of clobbering user edits.
+ *
+ * Snapshots live under .ryuu/undo (gitignored) and never include secret files,
+ * which the workspace tool layer blocks before an undo record can be created.
+ */
+export class UndoManager {
+  constructor({ workspace, dir = null, logger = null, maxEntries = 40 } = {}) {
+    this.workspace = workspace;
+    this.dir = dir;
+    this.logger = logger;
+    this.maxEntries = maxEntries;
+    this.entries = [];
+    this.sessionId = null;
+  }
+
+  reset(sessionId) {
+    this.sessionId = sessionId;
+    this.entries = [];
+  }
+
+  record(entry) {
+    this.entries.push({ ...entry, at: new Date().toISOString() });
+    if (this.entries.length > this.maxEntries) this.entries.shift();
+    this.#persist();
+  }
+
+  list() {
+    return this.entries.map((entry, index) => ({
+      index,
+      kind: entry.kind,
+      path: entry.path,
+      to: entry.to,
+      at: entry.at,
+    }));
+  }
+
+  get size() {
+    return this.entries.length;
+  }
+
+  last() {
+    return this.entries.at(-1) || null;
+  }
+
+  async revertLast() {
+    const entry = this.last();
+    if (!entry) throw new ToolError('Nothing to undo in this session.');
+    await this.revert(entry);
+    this.entries.pop();
+    this.#persist();
+    return entry;
+  }
+
+  /** Revert a recorded change after checking the file has not changed again. */
+  async revert(entry) {
+    switch (entry.kind) {
+      case 'write': {
+        const current = await this.#readCurrent(entry.path);
+        if (current !== entry.after) {
+          throw new FileChangedError(`${entry.path} changed after the agent edit; refusing to overwrite. Inspect it or use git.`);
+        }
+        if (entry.before === null) {
+          await this.workspace.remove(entry.path);
+        } else {
+          await this.workspace.writeText(entry.path, entry.before);
+        }
+        break;
+      }
+      case 'delete': {
+        if (await this.workspace.exists(entry.path)) {
+          throw new FileChangedError(`${entry.path} exists again; refusing to overwrite it with the deleted snapshot.`);
+        }
+        await this.workspace.writeText(entry.path, entry.before);
+        break;
+      }
+      case 'move': {
+        if (!(await this.workspace.exists(entry.to))) {
+          throw new FileChangedError(`Moved file is missing: ${entry.to}. Cannot move it back.`);
+        }
+        await this.workspace.move(entry.to, entry.path, { overwrite: false });
+        break;
+      }
+      default:
+        throw new ToolError(`Unknown undo entry kind: ${entry.kind}`);
+    }
+    this.logger?.info('undo applied', { kind: entry.kind, path: entry.path });
+    return entry;
+  }
+
+  async #readCurrent(relPath) {
+    try {
+      const file = await this.workspace.readText(relPath);
+      return file.text;
+    } catch (error) {
+      if (error.code === 'NOT_FOUND') return null;
+      throw error;
+    }
+  }
+
+  #persist() {
+    if (!this.dir || !this.sessionId) return;
+    try {
+      fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+      const tmp = path.join(this.dir, `${this.sessionId}.tmp`);
+      fs.writeFileSync(tmp, `${JSON.stringify(this.entries, null, 2)}\n`, { mode: 0o600 });
+      fs.renameSync(tmp, path.join(this.dir, `${this.sessionId}.json`));
+    } catch (error) {
+      this.logger?.warn('failed to persist undo stack', { error: error.message });
+    }
+  }
+
+  async load(sessionId) {
+    if (!this.dir) return 0;
+    this.sessionId = sessionId;
+    try {
+      const raw = await fsp.readFile(path.join(this.dir, `${sessionId}.json`), 'utf8');
+      const parsed = JSON.parse(raw);
+      this.entries = Array.isArray(parsed) ? parsed : [];
+      return this.entries.length;
+    } catch {
+      this.entries = [];
+      return 0;
+    }
+  }
+}