nubos-pilot 0.1.0 → 0.2.1

package/bin/install.js

@@ -14,9 +14,37 @@ const agentsMdMod = require('../lib/install/agents-md.cjs');
 const codexTomlMod = require('../lib/install/codex-toml.cjs');
 const runtimeDetectMod = require('../lib/install/runtime-detect.cjs');
 const backupMod = require('../lib/install/backup.cjs');
+const registryMod = require('../lib/install/runtimes-registry.cjs');
 
 const cyan = '\x1b[36m', green = '\x1b[32m', yellow = '\x1b[33m',
-      red = '\x1b[31m', dim = '\x1b[2m', reset = '\x1b[0m';
+      red = '\x1b[31m', blue = '\x1b[38;5;33m',
+      dim = '\x1b[2m', bold = '\x1b[1m', reset = '\x1b[0m';
+
+const LOGO = [
+  ' ███╗   ██╗██╗   ██╗██████╗  ██████╗ ███████╗',
+  ' ████╗  ██║██║   ██║██╔══██╗██╔═══██╗██╔════╝',
+  ' ██╔██╗ ██║██║   ██║██████╔╝██║   ██║███████╗',
+  ' ██║╚██╗██║██║   ██║██╔══██╗██║   ██║╚════██║',
+  ' ██║ ╚████║╚██████╔╝██████╔╝╚██████╔╝███████║',
+  ' ╚═╝  ╚═══╝ ╚═════╝ ╚═════╝  ╚═════╝ ╚══════╝',
+];
+
+function _printBanner() {
+  let pkgVersion = '0.0.0';
+  let pkgDesc = '';
+  try {
+    const pkg = require('../package.json');
+    pkgVersion = String(pkg.version || '0.0.0');
+    pkgDesc = String(pkg.description || '');
+  } catch {}
+  process.stderr.write('\n');
+  for (const line of LOGO) process.stderr.write(blue + line + reset + '\n');
+  process.stderr.write('\n');
+  process.stderr.write(' ' + bold + blue + 'Nubos Pilot' + reset
+    + dim + ' v' + pkgVersion + reset + '\n');
+  if (pkgDesc) process.stderr.write(' ' + dim + pkgDesc + reset + '\n');
+  process.stderr.write('\n');
+}
 
 const PAYLOAD_SUBPATH = path.join('.claude', 'nubos-pilot');
 const STATE_SUBPATH = '.nubos-pilot';
@@ -38,16 +66,26 @@ const MANAGED_BLOCK_INNER =
   + ' for planning and execution.\n\nRun `npx nubos-pilot doctor`'
   + ' to check install integrity.';
 
-const VALID_AGENTS = ['claude', 'codex', 'gemini', 'opencode'];
+const VALID_AGENTS = registryMod.listRuntimeIds();
 const VALID_SCOPES = ['local', 'global'];
 
+function _parseAgentsFlag(value) {
+  return String(value || '')
+    .split(/[,\s]+/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
 function parseInstallFlags(args) {
-  const flags = { agent: null, scope: null, mcp: false, yes: false };
+  const flags = { agent: null, agents: null, scope: null, mcp: false, yes: false };
   const rest = [];
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     if (a === '--agent' || a === '-a') { flags.agent = args[++i] || null; continue; }
     if (a.startsWith('--agent=')) { flags.agent = a.slice('--agent='.length); continue; }
+    if (a === '--agents') { flags.agents = _parseAgentsFlag(args[++i]); continue; }
+    if (a.startsWith('--agents=')) { flags.agents = _parseAgentsFlag(a.slice('--agents='.length)); continue; }
+    if (a === '--all') { flags.agents = VALID_AGENTS.slice(); continue; }
     if (a === '--scope' || a === '-s') { flags.scope = args[++i] || null; continue; }
     if (a.startsWith('--scope=')) { flags.scope = a.slice('--scope='.length); continue; }
     if (a === '--mcp') { flags.mcp = true; continue; }
@@ -59,6 +97,21 @@ function parseInstallFlags(args) {
       '--agent must be one of: ' + VALID_AGENTS.join(', '),
       { flag: '--agent', got: flags.agent });
   }
+  if (flags.agents !== null) {
+    for (const a of flags.agents) {
+      if (!VALID_AGENTS.includes(a)) {
+        throw new NubosPilotError('invalid-flag',
+          '--agents values must be one of: ' + VALID_AGENTS.join(', '),
+          { flag: '--agents', got: a });
+      }
+    }
+    if (flags.agents.length === 0) {
+      throw new NubosPilotError('invalid-flag',
+        '--agents requires at least one value',
+        { flag: '--agents' });
+    }
+    if (!flags.agent) flags.agent = flags.agents[0];
+  }
   if (flags.scope !== null && !VALID_SCOPES.includes(flags.scope)) {
     throw new NubosPilotError('invalid-flag',
       '--scope must be one of: ' + VALID_SCOPES.join(', '),
@@ -123,10 +176,35 @@ function _copyTree(src, dst) {
   }
 }
 
+function _runtimeSelectLabels() {
+  return registryMod.RUNTIMES.map((r) => {
+    const home = registryMod.runtimeGlobalDir(r).replace(process.env.HOME || '', '~');
+    return r.label + '  (' + home + ')';
+  });
+}
+
 async function _runInitQuestions(detectedRuntime, askUser, flags) {
   const f = flags || {};
-  const runtime = f.agent || (await askUser({ type: 'select', question: 'Welche Runtime nutzt du?',
-    options: VALID_AGENTS, default: detectedRuntime || 'claude' })).value;
+  let runtimes;
+  if (f.agents && f.agents.length) {
+    runtimes = f.agents.slice();
+  } else if (f.agent) {
+    runtimes = [f.agent];
+  } else {
+    const labels = _runtimeSelectLabels();
+    const detectedIdx = Math.max(0, VALID_AGENTS.indexOf(detectedRuntime || 'claude'));
+    const picked = (await askUser({ type: 'multiselect',
+      question: yellow + 'Which runtime(s) would you like to install for?' + reset,
+      options: labels, default: [labels[detectedIdx]] })).value;
+    runtimes = Array.isArray(picked) && picked.length && typeof picked[0] === 'string'
+      && picked[0].includes('(')
+      ? picked.map((label) => {
+          const idx = labels.indexOf(label);
+          return VALID_AGENTS[idx];
+        })
+      : (Array.isArray(picked) ? picked : [picked]);
+  }
+  const runtime = runtimes[0];
   const scope = f.scope || (await askUser({ type: 'select', question: 'Installation scope?',
     options: VALID_SCOPES, default: 'local' })).value;
   const model_profile = (await askUser({ type: 'select', question: 'Model-Profile?',
@@ -141,7 +219,7 @@ async function _runInitQuestions(detectedRuntime, askUser, flags) {
   const plan_checker = (await askUser({ type: 'confirm', question: 'Enable plan_checker?', default: true })).value;
   const verifier = (await askUser({ type: 'confirm', question: 'Enable verifier?', default: true })).value;
   const response_language = (await askUser({ type: 'input', question: 'Response language (ISO-639 code)?', default: 'en' })).value;
-  return { runtime, scope, mcp: !!f.mcp, model_profile, commit_docs, branching_strategy, phase_branch_template,
+  return { runtime, runtimes, scope, mcp: !!f.mcp, model_profile, commit_docs, branching_strategy, phase_branch_template,
     milestone_branch_template, parallelization, research, plan_checker, verifier, response_language };
 }
 
@@ -157,7 +235,9 @@ function _repairCodexConfig() {
   return true;
 }
 
-function _rewriteManagedMarkdown(projectRoot) {
+const LEGACY_AGENTS = new Set(['claude', 'codex', 'gemini', 'opencode']);
+
+function _rewriteManagedMarkdown(projectRoot, runtimes) {
   const claudePath = path.join(projectRoot, 'CLAUDE.md');
   const agentsPath = path.join(projectRoot, 'AGENTS.md');
   const geminiPath = path.join(projectRoot, 'GEMINI.md');
@@ -174,10 +254,12 @@ function _rewriteManagedMarkdown(projectRoot) {
   } else if (claudeExists) {
     agentsBase = agentsMdMod.generateAgentsMd(fs.readFileSync(claudePath, 'utf-8'), 'codex');
   } else {
-    return; 
+    agentsBase = null;
+  }
+  if (agentsBase !== null) {
+    const agentsNext = managedBlockMod.rewriteBlock(agentsBase, MANAGED_BLOCK_INNER);
+    atomicWriteFileSync(agentsPath, agentsNext);
   }
-  const agentsNext = managedBlockMod.rewriteBlock(agentsBase, MANAGED_BLOCK_INNER);
-  atomicWriteFileSync(agentsPath, agentsNext);
 
   let geminiBase;
   if (fs.existsSync(geminiPath)) {
@@ -185,10 +267,30 @@ function _rewriteManagedMarkdown(projectRoot) {
   } else if (claudeExists) {
     geminiBase = agentsMdMod.generateAgentsMd(fs.readFileSync(claudePath, 'utf-8'), 'gemini');
   } else {
-    return;
+    geminiBase = null;
+  }
+  if (geminiBase !== null) {
+    const geminiNext = managedBlockMod.rewriteBlock(geminiBase, MANAGED_BLOCK_INNER);
+    atomicWriteFileSync(geminiPath, geminiNext);
+  }
+
+  const extras = (runtimes || []).filter((id) => !LEGACY_AGENTS.has(id));
+  for (const id of extras) {
+    const meta = registryMod.getRuntimeMeta(id);
+    if (!meta) continue;
+    const targetPath = registryMod.runtimeAgentsPath(meta, 'local', projectRoot);
+    let base;
+    if (fs.existsSync(targetPath)) {
+      base = fs.readFileSync(targetPath, 'utf-8');
+    } else if (claudeExists) {
+      base = agentsMdMod.generateAgentsMd(fs.readFileSync(claudePath, 'utf-8'), 'codex');
+    } else {
+      base = '';
+    }
+    const next = managedBlockMod.rewriteBlock(base, MANAGED_BLOCK_INNER);
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    atomicWriteFileSync(targetPath, next);
   }
-  const geminiNext = managedBlockMod.rewriteBlock(geminiBase, MANAGED_BLOCK_INNER);
-  atomicWriteFileSync(geminiPath, geminiNext);
 }
 
 async function runInstall(opts) {
@@ -208,6 +310,7 @@ async function runInstall(opts) {
 
 async function _runInstallLocked(ctx) {
   const { projectRoot, mode, dryRun, askUser, sourceDir, stateDir, flags } = ctx;
+  _printBanner();
   console.error(cyan + '→ nubos-pilot install (mode=' + mode + ')' + reset);
 
   const preliminaryScope = (flags && flags.scope) || _readExistingScope(projectRoot) || 'local';
@@ -335,7 +438,8 @@ async function _runInstallLocked(ctx) {
     }
   }
 
-  _rewriteManagedMarkdown(projectRoot);
+  const selectedRuntimes = (initConfig && initConfig.runtimes) || (initConfig ? [initConfig.runtime] : []);
+  _rewriteManagedMarkdown(projectRoot, selectedRuntimes);
 
   if (initConfig && initConfig.mcp && !dryRun) {
     try {
@@ -413,8 +517,26 @@ function _runUninstallLocked(projectRoot) {
 
   try { fs.rmdirSync(payloadDir); } catch {  }
 
-  for (const name of ['CLAUDE.md', 'AGENTS.md', 'GEMINI.md']) {
-    const p = path.join(projectRoot, name);
+  const cfgPath = path.join(_stateDirFor(projectRoot), 'config.json');
+  let installedRuntimes = [];
+  try {
+    const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));
+    installedRuntimes = cfg.runtimes || (cfg.runtime ? [cfg.runtime] : []);
+  } catch {}
+
+  const legacyFiles = ['CLAUDE.md', 'AGENTS.md', 'GEMINI.md'];
+  const extraFiles = [];
+  for (const id of installedRuntimes) {
+    if (LEGACY_AGENTS.has(id)) continue;
+    const meta = registryMod.getRuntimeMeta(id);
+    if (!meta) continue;
+    extraFiles.push(registryMod.runtimeAgentsPath(meta, 'local', projectRoot));
+  }
+
+  const toStrip = legacyFiles
+    .map((n) => path.join(projectRoot, n))
+    .concat(extraFiles);
+  for (const p of toStrip) {
     if (!fs.existsSync(p)) continue;
     const stripped = managedBlockMod.stripBlock(fs.readFileSync(p, 'utf-8'));
     if (!stripped || !stripped.trim()) {

package/lib/install/runtimes-registry.cjs

@@ -0,0 +1,197 @@
+'use strict';
+
+const os = require('node:os');
+const path = require('node:path');
+
+const RUNTIMES = [
+  {
+    id: 'claude',
+    label: 'Claude Code',
+    localDir: '.claude',
+    globalDir: ['.claude'],
+    envConfigDir: 'CLAUDE_CONFIG_DIR',
+    agentsMd: 'CLAUDE.md',
+    agentsMdScope: 'project',
+    payloadSubdir: 'nubos-pilot',
+  },
+  {
+    id: 'antigravity',
+    label: 'Antigravity',
+    localDir: '.agent',
+    globalDir: ['.gemini', 'antigravity'],
+    envConfigDir: 'ANTIGRAVITY_CONFIG_DIR',
+    agentsMd: 'AGENTS.md',
+    agentsMdScope: 'project',
+    payloadSubdir: 'nubos-pilot',
+  },
+  {
+    id: 'augment',
+    label: 'Augment',
+    localDir: '.augment',
+    globalDir: ['.augment'],
+    envConfigDir: 'AUGMENT_CONFIG_DIR',
+    agentsMd: 'AGENTS.md',
+    agentsMdScope: 'project',
+    payloadSubdir: 'nubos-pilot',
+  },
+  {
+    id: 'cline',
+    label: 'Cline',
+    localDir: '.',
+    globalDir: ['.cline'],
+    envConfigDir: 'CLINE_CONFIG_DIR',
+    agentsMd: '.clinerules',
+    agentsMdScope: 'project',
+    payloadSubdir: '.clinerules-nubos-pilot',
+  },
+  {
+    id: 'codebuddy',
+    label: 'CodeBuddy',
+    localDir: '.codebuddy',
+    globalDir: ['.codebuddy'],
+    envConfigDir: 'CODEBUDDY_CONFIG_DIR',
+    agentsMd: 'AGENTS.md',
+    agentsMdScope: 'project',
+    payloadSubdir: 'nubos-pilot',
+  },
+  {
+    id: 'codex',
+    label: 'Codex',
+    localDir: '.codex',
+    globalDir: ['.codex'],
+    envConfigDir: 'CODEX_HOME',
+    agentsMd: 'AGENTS.md',
+    agentsMdScope: 'project',
+    payloadSubdir: 'nubos-pilot',
+  },
+  {
+    id: 'copilot',
+    label: 'Copilot',
+    localDir: '.github',
+    globalDir: ['.copilot'],
+    envConfigDir: 'COPILOT_CONFIG_DIR',
+    agentsMd: 'copilot-instructions.md',
+    agentsMdScope: 'dir',
+    payloadSubdir: 'nubos-pilot',
+  },
+  {
+    id: 'cursor',
+    label: 'Cursor',
+    localDir: '.cursor',
+    globalDir: ['.cursor'],
+    envConfigDir: 'CURSOR_CONFIG_DIR',
+    agentsMd: 'rules/nubos-pilot.mdc',
+    agentsMdScope: 'dir',
+    payloadSubdir: 'nubos-pilot',
+  },
+  {
+    id: 'gemini',
+    label: 'Gemini',
+    localDir: '.gemini',
+    globalDir: ['.gemini'],
+    envConfigDir: 'GEMINI_CONFIG_DIR',
+    agentsMd: 'GEMINI.md',
+    agentsMdScope: 'project',
+    payloadSubdir: 'nubos-pilot',
+  },
+  {
+    id: 'kilo',
+    label: 'Kilo',
+    localDir: '.kilo',
+    globalDir: ['.config', 'kilo'],
+    envConfigDir: 'KILO_CONFIG_DIR',
+    agentsMd: 'AGENTS.md',
+    agentsMdScope: 'project',
+    payloadSubdir: 'nubos-pilot',
+  },
+  {
+    id: 'opencode',
+    label: 'OpenCode',
+    localDir: '.opencode',
+    globalDir: ['.config', 'opencode'],
+    envConfigDir: 'OPENCODE_CONFIG_DIR',
+    agentsMd: 'AGENTS.md',
+    agentsMdScope: 'dir',
+    payloadSubdir: 'nubos-pilot',
+  },
+  {
+    id: 'qwen',
+    label: 'Qwen Code',
+    localDir: '.qwen',
+    globalDir: ['.qwen'],
+    envConfigDir: 'QWEN_CONFIG_DIR',
+    agentsMd: 'AGENTS.md',
+    agentsMdScope: 'project',
+    payloadSubdir: 'nubos-pilot',
+  },
+  {
+    id: 'trae',
+    label: 'Trae',
+    localDir: '.trae',
+    globalDir: ['.trae'],
+    envConfigDir: 'TRAE_CONFIG_DIR',
+    agentsMd: 'AGENTS.md',
+    agentsMdScope: 'project',
+    payloadSubdir: 'nubos-pilot',
+  },
+  {
+    id: 'windsurf',
+    label: 'Windsurf',
+    localDir: '.windsurf',
+    globalDir: ['.codeium', 'windsurf'],
+    envConfigDir: 'WINDSURF_CONFIG_DIR',
+    agentsMd: '.windsurfrules',
+    agentsMdScope: 'project',
+    payloadSubdir: '.windsurf-nubos-pilot',
+  },
+];
+
+const RUNTIME_INDEX = new Map(RUNTIMES.map((r) => [r.id, r]));
+
+function listRuntimeIds() {
+  return RUNTIMES.map((r) => r.id);
+}
+
+function getRuntimeMeta(id) {
+  return RUNTIME_INDEX.get(id) || null;
+}
+
+function runtimeGlobalDir(meta) {
+  if (meta.envConfigDir && process.env[meta.envConfigDir]) {
+    const v = process.env[meta.envConfigDir];
+    return v.startsWith('~') ? path.join(os.homedir(), v.slice(1)) : v;
+  }
+  return path.join(os.homedir(), ...(meta.globalDir || [meta.localDir]));
+}
+
+function runtimeLocalDir(meta, projectRoot) {
+  return path.join(projectRoot, meta.localDir || '.');
+}
+
+function runtimeConfigDir(meta, scope, projectRoot) {
+  return scope === 'global'
+    ? runtimeGlobalDir(meta)
+    : runtimeLocalDir(meta, projectRoot);
+}
+
+function runtimePayloadDir(meta, scope, projectRoot) {
+  return path.join(runtimeConfigDir(meta, scope, projectRoot), meta.payloadSubdir);
+}
+
+function runtimeAgentsPath(meta, scope, projectRoot) {
+  if (meta.agentsMdScope === 'dir') {
+    return path.join(runtimeConfigDir(meta, scope, projectRoot), meta.agentsMd);
+  }
+  return path.join(projectRoot, meta.agentsMd);
+}
+
+module.exports = {
+  RUNTIMES,
+  listRuntimeIds,
+  getRuntimeMeta,
+  runtimeGlobalDir,
+  runtimeLocalDir,
+  runtimeConfigDir,
+  runtimePayloadDir,
+  runtimeAgentsPath,
+};

package/lib/runtime/_contract.test.cjs

@@ -6,7 +6,11 @@ const REQUIRED_KEYS = ['name', 'detectHints', 'capabilities', 'paths', 'askUser'
 const CAP_KEYS = ['askUserQuestion', 'slashCommands', 'agentsMd', 'textMode', 'modelResolution'];
 const VALID_TEXT_MODE = ['auto', 'force', 'off'];
 const VALID_MODEL_RES = ['explicit', 'inherit', 'profile'];
-const VALID_AGENTS_MD = [null, 'AGENTS.md', 'GEMINI.md', 'CLAUDE.md'];
+const VALID_AGENTS_MD = [
+  null, 'AGENTS.md', 'GEMINI.md', 'CLAUDE.md',
+  '.clinerules', '.windsurfrules',
+  'rules/nubos-pilot.mdc', 'copilot-instructions.md',
+];
 
 for (const name of listRuntimes()) {
   test('RT-contract(' + name + '): exports all required keys', () => {

package/lib/runtime/_readline.cjs

@@ -51,7 +51,7 @@ function _parseAnswer(type, rawLine, options, def) {
   }
   if (type === 'multiselect') {
     if (line === '' && def != null) return def;
-    const parts = line.split(',').map((s) => s.trim()).filter(Boolean);
+    const parts = line.split(/[\s,]+/).map((s) => s.trim()).filter(Boolean);
     const picks = [];
     for (const p of parts) {
       const n = Number(p);
@@ -88,6 +88,36 @@ function _parseAnswer(type, rawLine, options, def) {
   );
 }
 
+const NUBOS_BLUE = '\x1b[38;5;33m';
+const ANSI_RESET = '\x1b[0m';
+
+function _defaultDisplay(type, options, def) {
+  if (def == null) {
+    if (type === 'confirm') return '[y/n]';
+    return '';
+  }
+  if (type === 'confirm') {
+    if (def === true) return '[Y/n]';
+    if (def === false) return '[y/N]';
+    return '[y/n]';
+  }
+  if (type === 'select') {
+    if (options) {
+      const idx = options.indexOf(def);
+      if (idx >= 0) return '[' + (idx + 1) + ']';
+    }
+    return '[' + String(def) + ']';
+  }
+  if (type === 'multiselect') {
+    if (Array.isArray(def) && options) {
+      const idxs = def.map((v) => options.indexOf(v));
+      if (idxs.every((i) => i >= 0)) return '[' + idxs.map((i) => i + 1).join(',') + ']';
+    }
+    return '[' + (Array.isArray(def) ? def.join(',') : String(def)) + ']';
+  }
+  return '[' + String(def) + ']';
+}
+
 async function askUserReadline({ type, question, options, def }) {
   const hasTTY = !!process.stdin.isTTY;
   if (!hasTTY && !_readlineImpl) {
@@ -98,20 +128,25 @@ async function askUserReadline({ type, question, options, def }) {
       { question },
     );
   }
-  process.stderr.write(question + '\n');
+  process.stderr.write('\n');
+  process.stderr.write('  ' + question + '\n');
+  process.stderr.write('\n');
   if (type === 'select' || type === 'multiselect') {
     if (options) {
       for (let i = 0; i < options.length; i++) {
-        process.stderr.write('  ' + (i + 1) + ') ' + String(options[i]) + '\n');
+        process.stderr.write(
+          '  ' + NUBOS_BLUE + (i + 1) + ')' + ANSI_RESET + ' ' + String(options[i]) + '\n',
+        );
       }
     }
-    if (type === 'multiselect') process.stderr.write('(comma-separated indices) ');
-    else process.stderr.write('> ');
-  } else if (type === 'confirm') {
-    process.stderr.write('[y/n] ');
-  } else {
-    process.stderr.write('> ');
+    process.stderr.write('\n');
+    if (type === 'multiselect') {
+      process.stderr.write('  Select multiple: 1,2,6 or 1 2 6\n');
+      process.stderr.write('\n');
+    }
   }
+  const marker = _defaultDisplay(type, options, def);
+  process.stderr.write('  Choice' + (marker ? ' ' + marker : '') + ': ');
   const line = await _readOneLine();
   return { value: _parseAnswer(type, line, options, def), source: 'readline' };
 }

package/lib/runtime/antigravity.cjs

@@ -0,0 +1,35 @@
+const { askUserReadline } = require('./_readline.cjs');
+
+async function askUser(spec) {
+  return askUserReadline({
+    type: spec && spec.type,
+    question: spec && spec.question,
+    options: spec && spec.options,
+    def: spec ? spec.default : undefined,
+  });
+}
+
+module.exports = {
+  name: 'antigravity',
+  detectHints: {
+    env: ['ANTIGRAVITY_CONFIG_DIR'],
+    pathBinary: 'antigravity',
+    diskMarkers: ['.agent/', '.gemini/antigravity/'],
+  },
+  capabilities: {
+    askUserQuestion: false,
+    slashCommands: false,
+    agentsMd: 'AGENTS.md',
+    textMode: 'auto',
+    modelResolution: 'inherit',
+  },
+  paths: {
+    payload: '.agent/nubos-pilot/',
+    config: null,
+    agentsMd: 'AGENTS.md',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei wird von Antigravity konsumiert. '
+    + 'Interaktive Prompts laufen über readline (stderr).',
+  askUser,
+};

package/lib/runtime/augment.cjs

@@ -0,0 +1,35 @@
+const { askUserReadline } = require('./_readline.cjs');
+
+async function askUser(spec) {
+  return askUserReadline({
+    type: spec && spec.type,
+    question: spec && spec.question,
+    options: spec && spec.options,
+    def: spec ? spec.default : undefined,
+  });
+}
+
+module.exports = {
+  name: 'augment',
+  detectHints: {
+    env: ['AUGMENT_CONFIG_DIR'],
+    pathBinary: 'augment',
+    diskMarkers: ['.augment/'],
+  },
+  capabilities: {
+    askUserQuestion: false,
+    slashCommands: false,
+    agentsMd: 'AGENTS.md',
+    textMode: 'auto',
+    modelResolution: 'inherit',
+  },
+  paths: {
+    payload: '.augment/nubos-pilot/',
+    config: null,
+    agentsMd: 'AGENTS.md',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei wird von Augment konsumiert. '
+    + 'Interaktive Prompts laufen über readline (stderr).',
+  askUser,
+};

package/lib/runtime/cline.cjs

@@ -0,0 +1,35 @@
+const { askUserReadline } = require('./_readline.cjs');
+
+async function askUser(spec) {
+  return askUserReadline({
+    type: spec && spec.type,
+    question: spec && spec.question,
+    options: spec && spec.options,
+    def: spec ? spec.default : undefined,
+  });
+}
+
+module.exports = {
+  name: 'cline',
+  detectHints: {
+    env: ['CLINE_CONFIG_DIR'],
+    pathBinary: 'cline',
+    diskMarkers: ['.clinerules'],
+  },
+  capabilities: {
+    askUserQuestion: false,
+    slashCommands: false,
+    agentsMd: '.clinerules',
+    textMode: 'auto',
+    modelResolution: 'inherit',
+  },
+  paths: {
+    payload: '.clinerules-nubos-pilot/',
+    config: null,
+    agentsMd: '.clinerules',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei (.clinerules) wird von Cline konsumiert. '
+    + 'Interaktive Prompts laufen über readline (stderr).',
+  askUser,
+};

package/lib/runtime/codebuddy.cjs

@@ -0,0 +1,35 @@
+const { askUserReadline } = require('./_readline.cjs');
+
+async function askUser(spec) {
+  return askUserReadline({
+    type: spec && spec.type,
+    question: spec && spec.question,
+    options: spec && spec.options,
+    def: spec ? spec.default : undefined,
+  });
+}
+
+module.exports = {
+  name: 'codebuddy',
+  detectHints: {
+    env: ['CODEBUDDY_CONFIG_DIR'],
+    pathBinary: 'codebuddy',
+    diskMarkers: ['.codebuddy/'],
+  },
+  capabilities: {
+    askUserQuestion: false,
+    slashCommands: false,
+    agentsMd: 'AGENTS.md',
+    textMode: 'auto',
+    modelResolution: 'inherit',
+  },
+  paths: {
+    payload: '.codebuddy/nubos-pilot/',
+    config: null,
+    agentsMd: 'AGENTS.md',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei wird von CodeBuddy konsumiert. '
+    + 'Interaktive Prompts laufen über readline (stderr).',
+  askUser,
+};

package/lib/runtime/copilot.cjs

@@ -0,0 +1,35 @@
+const { askUserReadline } = require('./_readline.cjs');
+
+async function askUser(spec) {
+  return askUserReadline({
+    type: spec && spec.type,
+    question: spec && spec.question,
+    options: spec && spec.options,
+    def: spec ? spec.default : undefined,
+  });
+}
+
+module.exports = {
+  name: 'copilot',
+  detectHints: {
+    env: ['COPILOT_CONFIG_DIR'],
+    pathBinary: 'copilot',
+    diskMarkers: ['.github/copilot-instructions.md', '.copilot/'],
+  },
+  capabilities: {
+    askUserQuestion: false,
+    slashCommands: false,
+    agentsMd: 'copilot-instructions.md',
+    textMode: 'auto',
+    modelResolution: 'inherit',
+  },
+  paths: {
+    payload: '.github/nubos-pilot/',
+    config: null,
+    agentsMd: '.github/copilot-instructions.md',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei (.github/copilot-instructions.md) wird von GitHub Copilot konsumiert. '
+    + 'Interaktive Prompts laufen über readline (stderr).',
+  askUser,
+};

package/lib/runtime/cursor.cjs

@@ -0,0 +1,35 @@
+const { askUserReadline } = require('./_readline.cjs');
+
+async function askUser(spec) {
+  return askUserReadline({
+    type: spec && spec.type,
+    question: spec && spec.question,
+    options: spec && spec.options,
+    def: spec ? spec.default : undefined,
+  });
+}
+
+module.exports = {
+  name: 'cursor',
+  detectHints: {
+    env: ['CURSOR_CONFIG_DIR'],
+    pathBinary: 'cursor',
+    diskMarkers: ['.cursor/', '.cursorrules'],
+  },
+  capabilities: {
+    askUserQuestion: false,
+    slashCommands: false,
+    agentsMd: 'rules/nubos-pilot.mdc',
+    textMode: 'auto',
+    modelResolution: 'inherit',
+  },
+  paths: {
+    payload: '.cursor/nubos-pilot/',
+    config: null,
+    agentsMd: '.cursor/rules/nubos-pilot.mdc',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei (.cursor/rules/nubos-pilot.mdc) wird von Cursor konsumiert. '
+    + 'Interaktive Prompts laufen über readline (stderr).',
+  askUser,
+};

package/lib/runtime/index.cjs

@@ -3,7 +3,11 @@ const path = require('node:path');
 const { NubosPilotError } = require('../core.cjs');
 const { getRuntime: _askuserGetRuntime } = require('../askuser.cjs');
 
-const KNOWN_RUNTIMES = ['claude', 'opencode', 'codex', 'gemini'];
+const KNOWN_RUNTIMES = [
+  'claude', 'antigravity', 'augment', 'cline', 'codebuddy',
+  'codex', 'copilot', 'cursor', 'gemini', 'kilo',
+  'opencode', 'qwen', 'trae', 'windsurf',
+];
 
 function listRuntimes() {
   return KNOWN_RUNTIMES.slice();

package/lib/runtime/index.test.cjs

@@ -47,15 +47,21 @@ function writeConfig(cwd, json) {
   fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify(json), 'utf-8');
 }
 
-test('RTI-1: listRuntimes returns four known runtimes in canonical order', () => {
-  assert.deepEqual(rt.listRuntimes(), ['claude', 'opencode', 'codex', 'gemini']);
+const EXPECTED_RUNTIMES = [
+  'claude', 'antigravity', 'augment', 'cline', 'codebuddy',
+  'codex', 'copilot', 'cursor', 'gemini', 'kilo',
+  'opencode', 'qwen', 'trae', 'windsurf',
+];
+
+test('RTI-1: listRuntimes returns 14 known runtimes in canonical order', () => {
+  assert.deepEqual(rt.listRuntimes(), EXPECTED_RUNTIMES);
 });
 
 test('RTI-2: listRuntimes returns defensive copy — mutation does not leak', () => {
   const a = rt.listRuntimes();
   a.push('pwned');
   const b = rt.listRuntimes();
-  assert.deepEqual(b, ['claude', 'opencode', 'codex', 'gemini']);
+  assert.deepEqual(b, EXPECTED_RUNTIMES);
 });
 
 test('RTI-3: getAdapter("nonexistent") throws NubosPilotError with code runtime-unknown', () => {
@@ -71,7 +77,7 @@ test('RTI-4: getAdapter unknown-runtime error details.known lists KNOWN_RUNTIMES
     assert.fail('should throw');
   } catch (err) {
     assert.equal(err.code, 'runtime-unknown');
-    assert.deepEqual(err.details.known, ['claude', 'opencode', 'codex', 'gemini']);
+    assert.deepEqual(err.details.known, EXPECTED_RUNTIMES);
     assert.equal(err.details.name, 'mystery');
   }
 });

package/lib/runtime/kilo.cjs

@@ -0,0 +1,35 @@
+const { askUserReadline } = require('./_readline.cjs');
+
+async function askUser(spec) {
+  return askUserReadline({
+    type: spec && spec.type,
+    question: spec && spec.question,
+    options: spec && spec.options,
+    def: spec ? spec.default : undefined,
+  });
+}
+
+module.exports = {
+  name: 'kilo',
+  detectHints: {
+    env: ['KILO_CONFIG_DIR'],
+    pathBinary: 'kilo',
+    diskMarkers: ['.kilo/', '.config/kilo/'],
+  },
+  capabilities: {
+    askUserQuestion: false,
+    slashCommands: false,
+    agentsMd: 'AGENTS.md',
+    textMode: 'auto',
+    modelResolution: 'inherit',
+  },
+  paths: {
+    payload: '.kilo/nubos-pilot/',
+    config: null,
+    agentsMd: 'AGENTS.md',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei wird von Kilo konsumiert. '
+    + 'Interaktive Prompts laufen über readline (stderr).',
+  askUser,
+};

package/lib/runtime/qwen.cjs

@@ -0,0 +1,35 @@
+const { askUserReadline } = require('./_readline.cjs');
+
+async function askUser(spec) {
+  return askUserReadline({
+    type: spec && spec.type,
+    question: spec && spec.question,
+    options: spec && spec.options,
+    def: spec ? spec.default : undefined,
+  });
+}
+
+module.exports = {
+  name: 'qwen',
+  detectHints: {
+    env: ['QWEN_CONFIG_DIR'],
+    pathBinary: 'qwen',
+    diskMarkers: ['.qwen/'],
+  },
+  capabilities: {
+    askUserQuestion: false,
+    slashCommands: false,
+    agentsMd: 'AGENTS.md',
+    textMode: 'auto',
+    modelResolution: 'inherit',
+  },
+  paths: {
+    payload: '.qwen/nubos-pilot/',
+    config: null,
+    agentsMd: 'AGENTS.md',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei wird von Qwen Code konsumiert. '
+    + 'Interaktive Prompts laufen über readline (stderr).',
+  askUser,
+};

package/lib/runtime/trae.cjs

@@ -0,0 +1,35 @@
+const { askUserReadline } = require('./_readline.cjs');
+
+async function askUser(spec) {
+  return askUserReadline({
+    type: spec && spec.type,
+    question: spec && spec.question,
+    options: spec && spec.options,
+    def: spec ? spec.default : undefined,
+  });
+}
+
+module.exports = {
+  name: 'trae',
+  detectHints: {
+    env: ['TRAE_CONFIG_DIR'],
+    pathBinary: 'trae',
+    diskMarkers: ['.trae/'],
+  },
+  capabilities: {
+    askUserQuestion: false,
+    slashCommands: false,
+    agentsMd: 'AGENTS.md',
+    textMode: 'auto',
+    modelResolution: 'inherit',
+  },
+  paths: {
+    payload: '.trae/nubos-pilot/',
+    config: null,
+    agentsMd: 'AGENTS.md',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei wird von Trae konsumiert. '
+    + 'Interaktive Prompts laufen über readline (stderr).',
+  askUser,
+};

package/lib/runtime/windsurf.cjs

@@ -0,0 +1,35 @@
+const { askUserReadline } = require('./_readline.cjs');
+
+async function askUser(spec) {
+  return askUserReadline({
+    type: spec && spec.type,
+    question: spec && spec.question,
+    options: spec && spec.options,
+    def: spec ? spec.default : undefined,
+  });
+}
+
+module.exports = {
+  name: 'windsurf',
+  detectHints: {
+    env: ['WINDSURF_CONFIG_DIR'],
+    pathBinary: 'windsurf',
+    diskMarkers: ['.windsurf/', '.windsurfrules', '.codeium/windsurf/'],
+  },
+  capabilities: {
+    askUserQuestion: false,
+    slashCommands: false,
+    agentsMd: '.windsurfrules',
+    textMode: 'auto',
+    modelResolution: 'inherit',
+  },
+  paths: {
+    payload: '.windsurf-nubos-pilot/',
+    config: null,
+    agentsMd: '.windsurfrules',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei (.windsurfrules) wird von Windsurf konsumiert. '
+    + 'Interaktive Prompts laufen über readline (stderr).',
+  askUser,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nubos-pilot",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "AI-driven planning and execution tool for code projects",
   "homepage": "https://github.com/Nubos-AI/nubos-pilot",
   "repository": {