nubos-pilot 0.2.1 → 0.3.0

package/bin/install.js

@@ -15,6 +15,7 @@ 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 runtimeAssetsMod = require('../lib/install/runtime-assets.cjs');
 
 const cyan = '\x1b[36m', green = '\x1b[32m', yellow = '\x1b[33m',
       red = '\x1b[31m', blue = '\x1b[38;5;33m',
@@ -53,6 +54,8 @@ const OPENCODE_SUBPATH = path.join('.opencode', 'nubos-pilot');
 const OPENCODE_MANIFEST_PREFIX = '.opencode/nubos-pilot/';
 const SOURCE_OPENCODE_DIR = path.join(__dirname, '..', 'templates', 'opencode', 'payload');
 const OPENCODE_JSON_TEMPLATE = path.join(__dirname, '..', 'templates', 'opencode', 'opencode.json');
+const SOURCE_WORKFLOWS_DIR = path.join(__dirname, '..', 'workflows');
+const SOURCE_AGENTS_DIR = path.join(__dirname, '..', 'agents');
 
 function _autoAskUser(spec) {
   return Promise.resolve({
@@ -149,6 +152,17 @@ function _readExistingScope(projectRoot) {
   } catch { return null; }
 }
 
+function _readExistingRuntimes(projectRoot) {
+  const cfgPath = path.join(_stateDirFor(projectRoot), 'config.json');
+  if (!fs.existsSync(cfgPath)) return null;
+  try {
+    const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));
+    if (Array.isArray(cfg.runtimes) && cfg.runtimes.length) return cfg.runtimes.slice();
+    if (cfg.runtime) return [cfg.runtime];
+    return null;
+  } catch { return null; }
+}
+
 function detectMode(projectRoot, scope) {
   const s = scope || _readExistingScope(projectRoot) || 'local';
   const payloadDir = _payloadDirFor(projectRoot, s);
@@ -194,7 +208,7 @@ async function _runInitQuestions(detectedRuntime, askUser, flags) {
     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,
+      question: 'Which runtime(s) would you like to install for?',
       options: labels, default: [labels[detectedIdx]] })).value;
     runtimes = Array.isArray(picked) && picked.length && typeof picked[0] === 'string'
       && picked[0].includes('(')
@@ -344,13 +358,31 @@ async function _runInstallLocked(ctx) {
   try { pkgVersion = String(require('../package.json').version || '0.0.0'); } catch {}
   const newManifest = manifestMod.buildManifest(tmp, pkgVersion);
 
+  const selectedRuntimesEarly = (initConfig && initConfig.runtimes)
+    || (initConfig ? [initConfig.runtime] : null)
+    || _readExistingRuntimes(projectRoot)
+    || [];
+  const opencodeSelected = selectedRuntimesEarly.includes('opencode');
+
+  const assetPlans = runtimeAssetsMod.planRuntimeAssets({
+    selectedRuntimes: selectedRuntimesEarly,
+    scope: resolvedScope,
+    projectRoot,
+    workflowsDir: SOURCE_WORKFLOWS_DIR,
+    agentsDir: SOURCE_AGENTS_DIR,
+  });
+  const assetEntries = runtimeAssetsMod.manifestEntriesForPlans(assetPlans);
+  for (const k of Object.keys(assetEntries)) {
+    newManifest.files[k] = assetEntries[k];
+  }
+
   const opencodeTarget = _opencodePayloadDirFor(projectRoot, resolvedScope);
   const opencodeManifestPrefix = _opencodeManifestPrefix(resolvedScope);
   const opencodeTmp = path.join(stateDir, '.opencode.tmp');
   try { fs.rmSync(opencodeTmp, { recursive: true, force: true }); } catch {}
   try {
   let opencodeManifest = null;
-  if (fs.existsSync(SOURCE_OPENCODE_DIR)) {
+  if (opencodeSelected && fs.existsSync(SOURCE_OPENCODE_DIR)) {
     _copyTree(SOURCE_OPENCODE_DIR, opencodeTmp);
     opencodeManifest = manifestMod.buildManifest(opencodeTmp, pkgVersion);
     for (const rel of Object.keys(opencodeManifest.files)) {
@@ -388,7 +420,7 @@ async function _runInstallLocked(ctx) {
       wouldWrite: Object.keys(newManifest.files).length,
       wouldBackup: backupLog.length, wouldDelete: diff.stale.length,
       wouldWriteGemini: true,
-      wouldWriteOpencodeJson: !fs.existsSync(path.join(projectRoot, 'opencode.json')),
+      wouldWriteOpencodeJson: opencodeSelected && !fs.existsSync(path.join(projectRoot, 'opencode.json')),
       stale: diff.stale, changed: diff.changed, added: diff.added };
     process.stdout.write(JSON.stringify(summary, null, 2) + '\n');
     try { stagingMod.cleanStaleStaging(payloadBase); } catch {}
@@ -436,11 +468,31 @@ async function _runInstallLocked(ctx) {
         try { fs.unlinkSync(relFs); } catch {}
       }
     }
+  } else if (!opencodeSelected && fs.existsSync(opencodeTarget)) {
+    try { fs.rmSync(opencodeTarget, { recursive: true, force: true }); } catch {}
+    const opencodeParent = path.dirname(opencodeTarget);
+    try { fs.rmdirSync(opencodeParent); } catch {}
+    const projectOpencodeJson = path.join(projectRoot, 'opencode.json');
+    if (fs.existsSync(projectOpencodeJson) && fs.existsSync(OPENCODE_JSON_TEMPLATE)) {
+      try {
+        const template = fs.readFileSync(OPENCODE_JSON_TEMPLATE, 'utf-8');
+        const existing = fs.readFileSync(projectOpencodeJson, 'utf-8');
+        if (existing === template) fs.unlinkSync(projectOpencodeJson);
+      } catch {}
+    }
   }
 
   const selectedRuntimes = (initConfig && initConfig.runtimes) || (initConfig ? [initConfig.runtime] : []);
   _rewriteManagedMarkdown(projectRoot, selectedRuntimes);
 
+  if (assetPlans.length) {
+    runtimeAssetsMod.writeRuntimeAssets(assetPlans);
+  }
+  const assetStale = diff.stale.filter(runtimeAssetsMod.isAssetManifestKey);
+  if (assetStale.length) {
+    runtimeAssetsMod.removeStaleAssets(assetStale, resolvedScope, projectRoot);
+  }
+
   if (initConfig && initConfig.mcp && !dryRun) {
     try {
       const mcpWriter = require('../lib/install/mcp-writer.cjs');
@@ -455,10 +507,12 @@ async function _runInstallLocked(ctx) {
     }
   }
 
-  const projectOpencodeJson = path.join(projectRoot, 'opencode.json');
-  if (!fs.existsSync(projectOpencodeJson) && fs.existsSync(OPENCODE_JSON_TEMPLATE)) {
-    const template = fs.readFileSync(OPENCODE_JSON_TEMPLATE, 'utf-8');
-    atomicWriteFileSync(projectOpencodeJson, template);
+  if (opencodeSelected) {
+    const projectOpencodeJson = path.join(projectRoot, 'opencode.json');
+    if (!fs.existsSync(projectOpencodeJson) && fs.existsSync(OPENCODE_JSON_TEMPLATE)) {
+      const template = fs.readFileSync(OPENCODE_JSON_TEMPLATE, 'utf-8');
+      atomicWriteFileSync(projectOpencodeJson, template);
+    }
   }
 
   try { _repairCodexConfig(); } catch (err) {
@@ -503,15 +557,34 @@ function _runUninstallLocked(projectRoot) {
     }
   }
 
+  const payloadBase = scope === 'global' ? os.homedir() : projectRoot;
   let removed = 0;
+  const assetDirs = new Set();
   for (const rel of Object.keys(manifest.files)) {
-    const abs = path.join(payloadDir, rel);
-    try { fs.unlinkSync(abs); removed++; } catch (err) {
+    const isAsset = runtimeAssetsMod.isAssetManifestKey(rel);
+    const abs = isAsset ? path.join(payloadBase, rel) : path.join(payloadDir, rel);
+    try {
+      fs.unlinkSync(abs);
+      removed++;
+      if (isAsset) assetDirs.add(path.dirname(abs));
+    } catch (err) {
       if (err && err.code !== 'ENOENT') {
         console.error(yellow + '  [uninstall] ' + rel + ' not removed: ' + err.message + reset);
       }
     }
   }
+  const sortedDirs = Array.from(assetDirs).sort((a, b) => b.length - a.length);
+  for (const dir of sortedDirs) {
+    let cur = dir;
+    while (cur && cur.startsWith(payloadBase) && cur !== payloadBase) {
+      try {
+        const entries = fs.readdirSync(cur);
+        if (entries.length > 0) break;
+        fs.rmdirSync(cur);
+      } catch { break; }
+      cur = path.dirname(cur);
+    }
+  }
 
   try { fs.unlinkSync(path.join(payloadDir, '.manifest.json')); } catch {}
 

package/lib/install/runtime-assets.cjs

@@ -0,0 +1,145 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const registryMod = require('./runtimes-registry.cjs');
+
+function _hashFile(file) {
+  const h = crypto.createHash('sha256');
+  h.update(fs.readFileSync(file));
+  return h.digest('hex');
+}
+
+function _listMarkdown(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter((n) => n.endsWith('.md'))
+    .sort();
+}
+
+function _payloadBase(scope, projectRoot) {
+  return scope === 'global' ? os.homedir() : projectRoot;
+}
+
+function _toPosix(p) {
+  return p.split(path.sep).join('/');
+}
+
+function planRuntimeAssets({ selectedRuntimes, scope, projectRoot, workflowsDir, agentsDir }) {
+  const base = _payloadBase(scope, projectRoot);
+  const workflows = _listMarkdown(workflowsDir);
+  const agents = _listMarkdown(agentsDir);
+  const plans = [];
+  for (const id of selectedRuntimes || []) {
+    const meta = registryMod.getRuntimeMeta(id);
+    if (!meta) continue;
+    const configDir = registryMod.runtimeConfigDir(meta, scope, projectRoot);
+    if (meta.commandsSubdir) {
+      for (const file of workflows) {
+        const targetFile = path.join(configDir, meta.commandsSubdir, file);
+        plans.push({
+          runtime: id,
+          kind: 'command',
+          sourceFile: path.join(workflowsDir, file),
+          targetFile,
+          manifestKey: _toPosix(path.relative(base, targetFile)),
+        });
+      }
+    }
+    if (meta.agentsSubdir) {
+      for (const file of agents) {
+        const targetFile = path.join(configDir, meta.agentsSubdir, file);
+        plans.push({
+          runtime: id,
+          kind: 'agent',
+          sourceFile: path.join(agentsDir, file),
+          targetFile,
+          manifestKey: _toPosix(path.relative(base, targetFile)),
+        });
+      }
+    }
+  }
+  return plans;
+}
+
+function manifestEntriesForPlans(plans) {
+  const entries = Object.create(null);
+  for (const plan of plans) {
+    entries[plan.manifestKey] = _hashFile(plan.sourceFile);
+  }
+  return entries;
+}
+
+function writeRuntimeAssets(plans) {
+  const written = [];
+  for (const plan of plans) {
+    fs.mkdirSync(path.dirname(plan.targetFile), { recursive: true });
+    fs.copyFileSync(plan.sourceFile, plan.targetFile);
+    written.push(plan.targetFile);
+  }
+  return written;
+}
+
+function removeStaleAssets(staleKeys, scope, projectRoot) {
+  const base = _payloadBase(scope, projectRoot);
+  const removed = [];
+  const dirs = new Set();
+  for (const key of staleKeys || []) {
+    if (!_isAssetKey(key)) continue;
+    const abs = path.join(base, key);
+    try {
+      fs.unlinkSync(abs);
+      removed.push(abs);
+      dirs.add(path.dirname(abs));
+    } catch {}
+  }
+  _pruneEmptyDirs(dirs, base);
+  return removed;
+}
+
+function _isAssetKey(key) {
+  if (typeof key !== 'string') return false;
+  if (key.startsWith('~/')) return true;
+  if (key.startsWith('.')) {
+    if (key.startsWith('.claude/commands/')) return true;
+    if (key.startsWith('.claude/agents/')) return true;
+    for (const meta of registryMod.RUNTIMES) {
+      if (meta.commandsSubdir) {
+        if (key.startsWith(meta.localDir + '/' + meta.commandsSubdir + '/')) return true;
+      }
+      if (meta.agentsSubdir) {
+        if (key.startsWith(meta.localDir + '/' + meta.agentsSubdir + '/')) return true;
+      }
+    }
+  }
+  return false;
+}
+
+function _pruneEmptyDirs(dirSet, base) {
+  const sorted = Array.from(dirSet).sort((a, b) => b.length - a.length);
+  for (const dir of sorted) {
+    let cur = dir;
+    while (cur && cur.startsWith(base) && cur !== base) {
+      try {
+        const entries = fs.readdirSync(cur);
+        if (entries.length > 0) break;
+        fs.rmdirSync(cur);
+      } catch { break; }
+      cur = path.dirname(cur);
+    }
+  }
+}
+
+function isAssetManifestKey(key) {
+  return _isAssetKey(key);
+}
+
+module.exports = {
+  planRuntimeAssets,
+  manifestEntriesForPlans,
+  writeRuntimeAssets,
+  removeStaleAssets,
+  isAssetManifestKey,
+};

package/lib/install/runtimes-registry.cjs

@@ -13,6 +13,8 @@ const RUNTIMES = [
     agentsMd: 'CLAUDE.md',
     agentsMdScope: 'project',
     payloadSubdir: 'nubos-pilot',
+    commandsSubdir: 'commands/np',
+    agentsSubdir: 'agents',
   },
   {
     id: 'antigravity',
@@ -113,6 +115,8 @@ const RUNTIMES = [
     agentsMd: 'AGENTS.md',
     agentsMdScope: 'dir',
     payloadSubdir: 'nubos-pilot',
+    commandsSubdir: 'command/np',
+    agentsSubdir: 'agent',
   },
   {
     id: 'qwen',

package/lib/runtime/_readline.cjs

@@ -89,8 +89,13 @@ function _parseAnswer(type, rawLine, options, def) {
 }
 
 const NUBOS_BLUE = '\x1b[38;5;33m';
+const ANSI_YELLOW = '\x1b[33m';
 const ANSI_RESET = '\x1b[0m';
 
+function _stripAnsi(s) {
+  return String(s).replace(/\x1b\[[0-9;]*m/g, '');
+}
+
 function _defaultDisplay(type, options, def) {
   if (def == null) {
     if (type === 'confirm') return '[y/n]';
@@ -129,7 +134,7 @@ async function askUserReadline({ type, question, options, def }) {
     );
   }
   process.stderr.write('\n');
-  process.stderr.write('  ' + question + '\n');
+  process.stderr.write('  ' + ANSI_YELLOW + _stripAnsi(question) + ANSI_RESET + '\n');
   process.stderr.write('\n');
   if (type === 'select' || type === 'multiselect') {
     if (options) {

package/package.json

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