nubos-pilot 0.1.0

package/lib/install/mcp-writer.cjs

@@ -0,0 +1,127 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { atomicWriteFileSync, NubosPilotError } = require('../core.cjs');
+
+const DEFAULT_MCP_NAME = 'nubos';
+const DEFAULT_MCP_URL = 'https://mcp.nubos.cloud/mcp/nubos';
+const DEFAULT_MCP_TOKEN = '4f81676a6be2f069d55769e877d133dba44a98ea263e24b5dfecd7fb7ed448ba';
+
+function _resolveTarget(runtime, scope, projectRoot, home) {
+  const h = home || os.homedir();
+  if (runtime === 'claude') {
+    return scope === 'global'
+      ? { kind: 'claude-json', path: path.join(h, '.claude.json') }
+      : { kind: 'claude-json', path: path.join(projectRoot, '.mcp.json') };
+  }
+  if (runtime === 'codex') {
+    return { kind: 'codex-toml', path: path.join(h, '.codex', 'config.toml') };
+  }
+  if (runtime === 'gemini') {
+    return scope === 'global'
+      ? { kind: 'gemini-json', path: path.join(h, '.gemini', 'settings.json') }
+      : { kind: 'gemini-json', path: path.join(projectRoot, '.gemini', 'settings.json') };
+  }
+  if (runtime === 'opencode') {
+    return scope === 'global'
+      ? { kind: 'opencode-json', path: path.join(h, '.config', 'opencode', 'opencode.json') }
+      : { kind: 'opencode-json', path: path.join(projectRoot, 'opencode.json') };
+  }
+  throw new NubosPilotError('unknown-runtime',
+    'Unknown runtime for MCP config: ' + runtime, { runtime });
+}
+
+function _readJson(filePath) {
+  if (!fs.existsSync(filePath)) return {};
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf-8')); }
+  catch { return {}; }
+}
+
+function _writeJson(target, nextObj, dryRun) {
+  if (dryRun) return { path: target.path, wouldWrite: true };
+  fs.mkdirSync(path.dirname(target.path), { recursive: true });
+  atomicWriteFileSync(target.path, JSON.stringify(nextObj, null, 2) + '\n');
+  return { path: target.path, wrote: true };
+}
+
+function _claudeWriter({ target, token, url, name, dryRun }) {
+  const existing = _readJson(target.path);
+  const servers = existing.mcpServers || {};
+  servers[name] = {
+    type: 'http',
+    url,
+    headers: { Authorization: 'Bearer ' + token },
+  };
+  existing.mcpServers = servers;
+  return _writeJson(target, existing, dryRun);
+}
+
+function _geminiWriter({ target, token, url, name, dryRun }) {
+  const existing = _readJson(target.path);
+  const servers = existing.mcpServers || {};
+  servers[name] = {
+    httpUrl: url,
+    headers: { Authorization: 'Bearer ' + token },
+  };
+  existing.mcpServers = servers;
+  return _writeJson(target, existing, dryRun);
+}
+
+function _opencodeWriter({ target, token, url, name, dryRun }) {
+  const existing = _readJson(target.path);
+  if (!existing.$schema) existing.$schema = 'https://opencode.ai/config.json';
+  const mcp = existing.mcp || {};
+  mcp[name] = {
+    type: 'remote',
+    url,
+    headers: { Authorization: 'Bearer ' + token },
+  };
+  existing.mcp = mcp;
+  return _writeJson(target, existing, dryRun);
+}
+
+function _codexWriter({ target, token, url, name, dryRun }) {
+  const existing = fs.existsSync(target.path)
+    ? fs.readFileSync(target.path, 'utf-8') : '';
+  const header = '[mcp_servers.' + name + ']';
+  if (existing.includes(header)) {
+    return { path: target.path, wrote: false, reason: 'already-configured' };
+  }
+  const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+  const block = prefix
+    + '\n' + header + '\n'
+    + 'command = "npx"\n'
+    + 'args = ["-y", "mcp-remote", "' + url + '", "--header", "Authorization: Bearer ' + token + '"]\n';
+  if (dryRun) return { path: target.path, wouldWrite: true };
+  fs.mkdirSync(path.dirname(target.path), { recursive: true });
+  atomicWriteFileSync(target.path, existing + block);
+  return { path: target.path, wrote: true };
+}
+
+const WRITERS = {
+  'claude-json': _claudeWriter,
+  'gemini-json': _geminiWriter,
+  'opencode-json': _opencodeWriter,
+  'codex-toml': _codexWriter,
+};
+
+function writeMcpConfig(opts) {
+  const o = opts || {};
+  if (!o.runtime) throw new NubosPilotError('missing-arg', 'runtime is required');
+  if (!o.projectRoot) throw new NubosPilotError('missing-arg', 'projectRoot is required');
+  const scope = o.scope || 'local';
+  const token = o.token || process.env.NUBOS_MCP_TOKEN || DEFAULT_MCP_TOKEN;
+  const url = o.url || process.env.NUBOS_MCP_URL || DEFAULT_MCP_URL;
+  const name = o.name || DEFAULT_MCP_NAME;
+  const target = _resolveTarget(o.runtime, scope, o.projectRoot, o.home);
+  const writer = WRITERS[target.kind];
+  return writer({ target, token, url, name, dryRun: !!o.dryRun });
+}
+
+module.exports = {
+  writeMcpConfig,
+  DEFAULT_MCP_NAME,
+  DEFAULT_MCP_URL,
+  DEFAULT_MCP_TOKEN,
+  _resolveTarget,
+};

package/lib/install/runtime-detect.cjs

@@ -0,0 +1,44 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { detect: runtimeDetect } = require('../runtime/index.cjs');
+
+const DEFAULT_PATH_PROBES = ['claude', 'codex', 'gemini'];
+
+function _defaultPathProbe(bin) {
+  try {
+    execFileSync('which', [bin], { stdio: 'ignore' });
+    return bin;
+  } catch {
+    return null;
+  }
+}
+
+function detectRuntime(opts) {
+  const options = opts || {};
+  const cwd = options.cwd || process.cwd();
+  const pathProbe =
+    typeof options.pathProbe === 'function' ? options.pathProbe : _defaultPathProbe;
+
+  const primary = runtimeDetect({ cwd });
+  if (primary && primary.source !== 'default') {
+    return primary;
+  }
+
+  for (const bin of DEFAULT_PATH_PROBES) {
+    let hit = null;
+    try { hit = pathProbe(bin); } catch { hit = null; }
+    if (hit) return { runtime: bin, source: 'path' };
+  }
+
+  if (fs.existsSync(path.join(cwd, '.claude'))) {
+    return { runtime: 'claude', source: 'disk' };
+  }
+  if (fs.existsSync(path.join(cwd, '.codex'))) {
+    return { runtime: 'codex', source: 'disk' };
+  }
+
+  return { runtime: 'generic-readline', source: 'default' };
+}
+
+module.exports = { detectRuntime };

package/lib/install/staging.cjs

@@ -0,0 +1,149 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { NubosPilotError } = require('../core.cjs');
+
+const STAGING_SUBPATH = path.join('.claude', 'nubos-pilot.tmp');
+const TARGET_SUBPATH = path.join('.claude', 'nubos-pilot');
+const CLAUDE_SUBPATH = '.claude';
+
+function _resolveStagingPath(projectRoot) {
+  return path.join(projectRoot, STAGING_SUBPATH);
+}
+
+function _resolveTargetPath(projectRoot) {
+  return path.join(projectRoot, TARGET_SUBPATH);
+}
+
+function stageDir(projectRoot) {
+  const tmp = _resolveStagingPath(projectRoot);
+  try {
+    fs.mkdirSync(tmp, { recursive: true });
+  } catch (err) {
+    throw new NubosPilotError(
+      'staging-mkdir-failed',
+      'Kann Staging-Verzeichnis nicht anlegen: ' + (err && err.message),
+      { tmp },
+    );
+  }
+  return tmp;
+}
+
+function cleanStaleStaging(projectRoot) {
+  const tmp = _resolveStagingPath(projectRoot);
+  if (!fs.existsSync(tmp)) return false;
+  try {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  } catch (err) {
+    throw new NubosPilotError(
+      'staging-clean-failed',
+      'Kann verwaistes Staging nicht entfernen: ' + (err && err.message),
+      { tmp },
+    );
+  }
+  return true;
+}
+
+function _dirIsEmpty(dir) {
+  try {
+    const entries = fs.readdirSync(dir);
+    return entries.length === 0;
+  } catch {
+    return true;
+  }
+}
+
+function finalizeSwap(projectRoot) {
+  const tmp = _resolveStagingPath(projectRoot);
+  const target = _resolveTargetPath(projectRoot);
+  const claudeDir = path.join(projectRoot, CLAUDE_SUBPATH);
+  if (!fs.existsSync(tmp)) {
+    throw new NubosPilotError(
+      'staging-swap-failed',
+      'Kein Staging-Verzeichnis zum Finalisieren gefunden',
+      { phase: 'pre-check', tmp, target },
+    );
+  }
+
+  try {
+    fs.mkdirSync(claudeDir, { recursive: true });
+  } catch (err) {
+    throw new NubosPilotError(
+      'staging-swap-failed',
+      'Kann .claude/ Parent-Dir nicht anlegen: ' + (err && err.message),
+      { phase: 'mkdir-parent', tmp, target },
+    );
+  }
+
+  let oldPath = null;
+  const targetExists = fs.existsSync(target);
+  if (targetExists && !_dirIsEmpty(target)) {
+    oldPath = path.join(claudeDir, 'nubos-pilot.old-' + Date.now());
+    try {
+      fs.renameSync(target, oldPath);
+      console.error(
+        '  [staging] alte Installation nach ' +
+          path.basename(oldPath) +
+          ' verschoben',
+      );
+    } catch (err) {
+      throw new NubosPilotError(
+        'staging-swap-failed',
+        'Kann alte Installation nicht beiseite schieben: ' + (err && err.message),
+        { phase: 'rename-old', tmp, target, old: oldPath },
+      );
+    }
+  } else if (targetExists) {
+    try {
+      fs.rmdirSync(target);
+    } catch (err) {
+      throw new NubosPilotError(
+        'staging-swap-failed',
+        'Kann leeres Ziel-Dir nicht entfernen: ' + (err && err.message),
+        { phase: 'remove-empty-target', tmp, target },
+      );
+    }
+  }
+
+  try {
+    fs.renameSync(tmp, target);
+    console.error(
+      '  [staging] neue Installation nach ' +
+        path.basename(target) +
+        ' geswapt',
+    );
+  } catch (err) {
+    if (oldPath) {
+      try { fs.renameSync(oldPath, target); } catch {}
+    }
+    throw new NubosPilotError(
+      'staging-swap-failed',
+      'Kann Staging nicht finalisieren: ' + (err && err.message),
+      { phase: 'rename-in', tmp, target, old: oldPath },
+    );
+  }
+
+  if (oldPath) {
+    try {
+      fs.rmSync(oldPath, { recursive: true, force: true });
+      console.error(
+        '  [staging] alte Installation (' +
+          path.basename(oldPath) +
+          ') entfernt',
+      );
+    } catch (err) {
+      throw new NubosPilotError(
+        'staging-swap-failed',
+        'Kann alte Installation nicht aufräumen: ' + (err && err.message),
+        { phase: 'cleanup-old', tmp, target, old: oldPath },
+      );
+    }
+  }
+
+  return target;
+}
+
+module.exports = {
+  stageDir,
+  finalizeSwap,
+  cleanStaleStaging,
+};

package/lib/metrics-aggregate.cjs

@@ -0,0 +1,229 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const readline = require('node:readline');
+const { NubosPilotError, findProjectRoot } = require('./core.cjs');
+
+const SAFE_PHASE_RE = /^[A-Za-z0-9._-]+$/;
+
+function _zeroPhaseShape(phase) {
+  return {
+    phase,
+    record_count: 0,
+    total_tokens_in: null,
+    total_tokens_out: null,
+    partial_tokens: false,
+    avg_duration_ms_by_tier: {},
+    avg_duration_ms_by_agent: {},
+    retry_count_sum: 0,
+    error_count: 0,
+    error_rate: 0,
+    agents_seen: [],
+    first_record_at: null,
+    last_record_at: null,
+  };
+}
+
+function _readJsonlLines(filePath, onRecord) {
+  return new Promise((resolve, reject) => {
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    stream.on('error', (err) => {
+      if (err && err.code === 'ENOENT') { resolve(); return; }
+      reject(err);
+    });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    rl.on('line', (raw) => {
+      const line = String(raw).trim();
+      if (!line) return;
+      try {
+        const rec = JSON.parse(line);
+        onRecord(rec);
+      } catch (_err) {
+        process.stderr.write('metrics-aggregate: skipping malformed JSONL line in ' + filePath + '\n');
+      }
+    });
+    rl.on('close', () => resolve());
+    rl.on('error', (err) => reject(err));
+  });
+}
+
+function _metricsDir(cwd) {
+  const root = findProjectRoot(cwd || process.cwd());
+  return path.join(root, '.nubos-pilot', 'metrics');
+}
+
+function _aggregateFromRecords(records, phase) {
+  const shape = _zeroPhaseShape(phase);
+  let tokensInSum = 0;
+  let tokensOutSum = 0;
+  let anyNull = false;
+  let anyValue = false;
+  const durByTier = {};
+  const countByTier = {};
+  const durByAgent = {};
+  const countByAgent = {};
+  const agentsSet = new Set();
+  for (const r of records) {
+    if (!r || typeof r !== 'object') continue;
+    shape.record_count += 1;
+    if (r.agent) agentsSet.add(String(r.agent));
+    if (typeof r.retry_count === 'number') shape.retry_count_sum += r.retry_count;
+    if (r.status && r.status !== 'ok') shape.error_count += 1;
+    if (r.started_at) {
+      if (!shape.first_record_at || r.started_at < shape.first_record_at) shape.first_record_at = r.started_at;
+      if (!shape.last_record_at || r.started_at > shape.last_record_at) shape.last_record_at = r.started_at;
+    }
+    if (r.tokens_in === null || r.tokens_out === null) {
+      anyNull = true;
+    } else {
+      anyValue = true;
+      tokensInSum += Number(r.tokens_in) || 0;
+      tokensOutSum += Number(r.tokens_out) || 0;
+    }
+    const d = typeof r.duration_ms === 'number' ? r.duration_ms : null;
+    if (d !== null) {
+      if (r.tier) {
+        durByTier[r.tier] = (durByTier[r.tier] || 0) + d;
+        countByTier[r.tier] = (countByTier[r.tier] || 0) + 1;
+      }
+      if (r.agent) {
+        durByAgent[r.agent] = (durByAgent[r.agent] || 0) + d;
+        countByAgent[r.agent] = (countByAgent[r.agent] || 0) + 1;
+      }
+    }
+  }
+  shape.agents_seen = Array.from(agentsSet).sort();
+  if (anyValue && anyNull) {
+    shape.total_tokens_in = tokensInSum;
+    shape.total_tokens_out = tokensOutSum;
+    shape.partial_tokens = true;
+  } else if (anyValue) {
+    shape.total_tokens_in = tokensInSum;
+    shape.total_tokens_out = tokensOutSum;
+    shape.partial_tokens = false;
+  } else {
+    shape.total_tokens_in = null;
+    shape.total_tokens_out = null;
+    shape.partial_tokens = false;
+  }
+  shape.error_rate = shape.record_count > 0 ? shape.error_count / shape.record_count : 0;
+  for (const t of Object.keys(durByTier)) {
+    shape.avg_duration_ms_by_tier[t] = durByTier[t] / countByTier[t];
+  }
+  for (const a of Object.keys(durByAgent)) {
+    shape.avg_duration_ms_by_agent[a] = durByAgent[a] / countByAgent[a];
+  }
+  return shape;
+}
+
+async function aggregatePhase(phase, opts) {
+  const phaseStr = String(phase);
+  if (!SAFE_PHASE_RE.test(phaseStr)) {
+    throw new NubosPilotError(
+      'metrics-invalid-phase',
+      'metrics-aggregate phase must match /^[A-Za-z0-9._-]+$/: ' + phaseStr,
+      { phase: phaseStr },
+    );
+  }
+  let dir;
+  try {
+    dir = _metricsDir(opts && opts.cwd);
+  } catch (err) {
+    if (err && err.code === 'not-in-project') return _zeroPhaseShape(phaseStr);
+    throw err;
+  }
+  const filePath = path.join(dir, 'phase-' + phaseStr + '.jsonl');
+  const records = [];
+  await _readJsonlLines(filePath, (r) => records.push(r));
+  return _aggregateFromRecords(records, phaseStr);
+}
+
+async function aggregateSession(sinceIso, opts) {
+  let dir;
+  try {
+    dir = _metricsDir(opts && opts.cwd);
+  } catch (err) {
+    if (err && err.code === 'not-in-project') {
+      return {
+        since_iso: sinceIso || null,
+        record_count: 0,
+        by_phase: {},
+        total_tokens_in: null,
+        total_tokens_out: null,
+        partial_tokens: false,
+        total_duration_ms: 0,
+        error_count: 0,
+        phases_touched: [],
+      };
+    }
+    throw err;
+  }
+  let files;
+  try {
+    files = fs.readdirSync(dir);
+  } catch (err) {
+    if (err && err.code === 'ENOENT') {
+      return {
+        since_iso: sinceIso || null,
+        record_count: 0,
+        by_phase: {},
+        total_tokens_in: null,
+        total_tokens_out: null,
+        partial_tokens: false,
+        total_duration_ms: 0,
+        error_count: 0,
+        phases_touched: [],
+      };
+    }
+    throw err;
+  }
+  const relevant = files.filter((f) => /^(phase-.+|meta)\.jsonl$/.test(f)).sort();
+  const byPhaseRecords = {};
+  for (const f of relevant) {
+    const key = f === 'meta.jsonl' ? 'meta' : f.slice('phase-'.length, -('.jsonl'.length));
+    byPhaseRecords[key] = byPhaseRecords[key] || [];
+    await _readJsonlLines(path.join(dir, f), (r) => {
+      if (sinceIso && r && r.started_at && r.started_at < sinceIso) return;
+      byPhaseRecords[key].push(r);
+    });
+  }
+  const by_phase = {};
+  let record_count = 0;
+  let total_duration_ms = 0;
+  let error_count = 0;
+  let tokensIn = 0;
+  let tokensOut = 0;
+  let anyNull = false;
+  let anyValue = false;
+  for (const key of Object.keys(byPhaseRecords)) {
+    const agg = _aggregateFromRecords(byPhaseRecords[key], key);
+    by_phase[key] = agg;
+    record_count += agg.record_count;
+    error_count += agg.error_count;
+    for (const r of byPhaseRecords[key]) {
+      if (!r || typeof r !== 'object') continue;
+      if (typeof r.duration_ms === 'number') total_duration_ms += r.duration_ms;
+      if (r.tokens_in === null || r.tokens_out === null) {
+        anyNull = true;
+      } else {
+        anyValue = true;
+        tokensIn += Number(r.tokens_in) || 0;
+        tokensOut += Number(r.tokens_out) || 0;
+      }
+    }
+  }
+  const total_tokens_in = anyValue ? tokensIn : null;
+  const total_tokens_out = anyValue ? tokensOut : null;
+  return {
+    since_iso: sinceIso || null,
+    record_count,
+    by_phase,
+    total_tokens_in,
+    total_tokens_out,
+    partial_tokens: anyValue && anyNull,
+    total_duration_ms,
+    error_count,
+    phases_touched: Object.keys(by_phase).sort(),
+  };
+}
+
+module.exports = { aggregatePhase, aggregateSession, _readJsonlLines };