nubos-pilot 0.7.2 → 0.8.0

package/bin/np-tools/stats.test.cjs

@@ -189,6 +189,71 @@ test('STATS-2: unknown subcommand prints usage', async () => {
   assert.match(stderr.toString(), /Usage:/);
 });
 
+test('STATS-MD-1: stats markdown emits English title + headers when no config', async () => {
+  const sb = makeSandbox(DEMO_YAML, DEMO_STATE);
+  writeTaskPlan(sb, 1, 1, 1, 'done');
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const code = await statsCli.run(['markdown'], { cwd: sb, stdout, stderr });
+  assert.equal(code, 0, 'stderr=' + stderr.toString());
+  const out = stdout.toString();
+  assert.match(out, /^## Project Stats/m);
+  assert.match(out, /^\*\*Milestone:\*\*/m);
+  assert.match(out, /^\*\*Progress:\*\*/m);
+  assert.match(out, /^### Phases/m);
+  assert.match(out, /^### Metrics by Phase/m);
+});
+
+test('STATS-MD-2: stats markdown emits German labels when config.response_language=de', async () => {
+  const sb = makeSandbox(DEMO_YAML, DEMO_STATE);
+  fs.writeFileSync(
+    path.join(sb, '.nubos-pilot', 'config.json'),
+    JSON.stringify({ response_language: 'de' }),
+  );
+  writeTaskPlan(sb, 1, 1, 1, 'done');
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const code = await statsCli.run(['markdown'], { cwd: sb, stdout, stderr });
+  assert.equal(code, 0, 'stderr=' + stderr.toString());
+  const out = stdout.toString();
+  assert.match(out, /^## Projekt-Stats/m);
+  assert.match(out, /^\*\*Fortschritt:\*\*/m);
+  assert.match(out, /^\*\*Letzte Aktivität:\*\*/m);
+  assert.match(out, /^\*\*Projekt-Start:\*\*/m);
+  assert.match(out, /^### Phasen/m);
+  assert.match(out, /^### Metriken pro Phase/m);
+  assert.match(out, /Pläne/);
+  assert.equal(/^## Project Stats/m.test(out), false, 'no English title');
+});
+
+test('STATS-MD-3: --lang flag overrides config language', async () => {
+  const sb = makeSandbox(DEMO_YAML, DEMO_STATE);
+  fs.writeFileSync(
+    path.join(sb, '.nubos-pilot', 'config.json'),
+    JSON.stringify({ response_language: 'de' }),
+  );
+  writeTaskPlan(sb, 1, 1, 1, 'done');
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const code = await statsCli.run(['markdown', '--lang', 'en'], { cwd: sb, stdout, stderr });
+  assert.equal(code, 0, 'stderr=' + stderr.toString());
+  assert.match(stdout.toString(), /^## Project Stats/m);
+});
+
+test('STATS-MD-4: _renderMarkdown is a pure function callable without project', () => {
+  const md = statsCli._renderMarkdown({
+    schema_version: 2,
+    milestone: { version: 'v1', name: 'Auth' },
+    phases: [{ number: '1', name: 'F', plans_total: 2, plans_complete: 1, status: 'in-progress' }],
+    plans_total: 2, plans_complete: 1, percent: 50,
+    git: { commits: 5, first_commit_at: '2026-01-01' },
+    last_activity: '2026-04-01T00:00:00Z',
+    metrics_by_phase: {},
+  }, 'de');
+  assert.match(md, /Projekt-Stats/);
+  assert.match(md, /Pläne/);
+});
+
 test('STATS-3: outside project emits NubosPilotError envelope', async () => {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'np-stats-outside-'));
   _sandboxes.push(tmp);

package/lib/dashboard.cjs

@@ -5,6 +5,35 @@ const path = require('node:path');
 
 const { extractFrontmatter } = require('./frontmatter.cjs');
 const { listMilestones, listSlices, listTasks, mId } = require('./layout.cjs');
+const { normalizeLanguage, DEFAULT_LANGUAGE } = require('./language.cjs');
+
+const LABELS = Object.freeze({
+  en: {
+    done: 'done',
+    'in-progress': 'in-progress',
+    pending: 'pending',
+    skipped: 'skipped',
+    parked: 'parked',
+    no_tasks: 'no tasks',
+    no_slices: 'no slices planned',
+    no_milestones: 'No milestones yet. Run /np:new-project or /np:new-milestone.',
+  },
+  de: {
+    done: 'erledigt',
+    'in-progress': 'in Arbeit',
+    pending: 'offen',
+    skipped: 'übersprungen',
+    parked: 'geparkt',
+    no_tasks: 'keine Tasks',
+    no_slices: 'keine Slices geplant',
+    no_milestones: 'Noch keine Milestones. Führe /np:new-project oder /np:new-milestone aus.',
+  },
+});
+
+function _labelsFor(language) {
+  const lang = normalizeLanguage(language || DEFAULT_LANGUAGE);
+  return LABELS[lang] || LABELS[DEFAULT_LANGUAGE];
+}
 
 const ANSI = Object.freeze({
   reset:  '\x1b[0m',
@@ -83,15 +112,15 @@ function collectSnapshot(projectRoot) {
   return { milestones: _collectMilestones(cwd) };
 }
 
-function _summarizeCounts(c, useColor) {
+function _summarizeCounts(c, useColor, labels) {
   const paint = (code, text) => useColor ? code + text + ANSI.reset : text;
   const bits = [];
-  if (c.done)           bits.push(paint(ANSI.green,  c.done           + ' done'));
-  if (c['in-progress']) bits.push(paint(ANSI.yellow, c['in-progress'] + ' in-progress'));
-  if (c.pending)        bits.push(paint(ANSI.gray,   c.pending        + ' pending'));
-  if (c.skipped)        bits.push(paint(ANSI.dim,    c.skipped        + ' skipped'));
-  if (c.parked)         bits.push(paint(ANSI.red,    c.parked         + ' parked'));
-  return bits.join(' · ') || paint(ANSI.dim, 'no tasks');
+  if (c.done)           bits.push(paint(ANSI.green,  c.done           + ' ' + labels.done));
+  if (c['in-progress']) bits.push(paint(ANSI.yellow, c['in-progress'] + ' ' + labels['in-progress']));
+  if (c.pending)        bits.push(paint(ANSI.gray,   c.pending        + ' ' + labels.pending));
+  if (c.skipped)        bits.push(paint(ANSI.dim,    c.skipped        + ' ' + labels.skipped));
+  if (c.parked)         bits.push(paint(ANSI.red,    c.parked         + ' ' + labels.parked));
+  return bits.join(' · ') || paint(ANSI.dim, labels.no_tasks);
 }
 
 function _checkboxRow(statuses, useColor) {
@@ -106,6 +135,7 @@ function _checkboxRow(statuses, useColor) {
 function renderSnapshot(snap, opts) {
   const o = opts || {};
   const useColor = o.color !== false;
+  const labels = _labelsFor(o.language);
   const c = (code, text) => useColor ? code + text + ANSI.reset : text;
   const lines = [];
 
@@ -113,7 +143,7 @@ function renderSnapshot(snap, opts) {
   lines.push('');
 
   if (!snap.milestones || snap.milestones.length === 0) {
-    lines.push(c(ANSI.dim, 'No milestones yet. Run /np:new-project or /np:new-milestone.'));
+    lines.push(c(ANSI.dim, labels.no_milestones));
     lines.push('');
     return lines.join('\n');
   }
@@ -123,10 +153,10 @@ function renderSnapshot(snap, opts) {
     const status = m.status ? '  ' + c(ANSI.dim, '[' + m.status + ']') : '';
     lines.push(c(ANSI.bold, m.id) + name + status);
     if (m.slices.length === 0) {
-      lines.push('  ' + c(ANSI.dim, 'no slices planned'));
+      lines.push('  ' + c(ANSI.dim, labels.no_slices));
     }
     for (const s of m.slices) {
-      lines.push('  ' + c(ANSI.bold, s.full_id) + '  ' + _summarizeCounts(s.counts, useColor));
+      lines.push('  ' + c(ANSI.bold, s.full_id) + '  ' + _summarizeCounts(s.counts, useColor, labels));
       if (s.task_statuses.length > 0) {
         lines.push('  ' + _checkboxRow(s.task_statuses, useColor));
       }
@@ -142,4 +172,5 @@ module.exports = {
   renderSnapshot,
   ANSI,
   STATUS_GLYPHS,
+  LABELS,
 };

package/lib/dashboard.test.cjs

@@ -162,6 +162,89 @@ test('DB-8: empty slice (no tasks) renders "no tasks" indicator', () => {
   }
 });
 
+test('DB-L1: renderSnapshot uses German labels when language=de', () => {
+  const root = _sandbox();
+  try {
+    _writeMeta(root, 1, { name: 'Auth', status: 'active' });
+    _writeTask(root, 1, 1, 1, 'done', 'Login');
+    _writeTask(root, 1, 1, 2, 'in-progress', 'Logout');
+    _writeTask(root, 1, 1, 3, 'pending', 'Reset');
+    const snap = dashboard.collectSnapshot(root);
+    const out = dashboard.renderSnapshot(snap, { color: false, language: 'de' });
+    assert.match(out, /1 erledigt/);
+    assert.match(out, /1 in Arbeit/);
+    assert.match(out, /1 offen/);
+    assert.equal(/\bdone\b/.test(out), false, 'must not leak English label');
+    assert.equal(/in-progress/.test(out), false, 'must not leak English label');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('DB-L2: renderSnapshot uses German "no milestones" line for de', () => {
+  const root = _sandbox();
+  try {
+    const snap = dashboard.collectSnapshot(root);
+    const out = dashboard.renderSnapshot(snap, { color: false, language: 'de' });
+    assert.match(out, /Noch keine Milestones/);
+    assert.equal(/No milestones yet/.test(out), false);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('DB-L3: empty slice renders German "keine Tasks" for de', () => {
+  const root = _sandbox();
+  try {
+    _writeMeta(root, 1, { name: 'Empty' });
+    fs.mkdirSync(path.join(root, '.nubos-pilot', 'milestones', 'M001', 'slices', 'S001', 'tasks'), { recursive: true });
+    const snap = dashboard.collectSnapshot(root);
+    const out = dashboard.renderSnapshot(snap, { color: false, language: 'de' });
+    assert.match(out, /keine Tasks/);
+    assert.equal(/no tasks/.test(out), false);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('DB-L4: milestone without slices renders German "keine Slices geplant"', () => {
+  const root = _sandbox();
+  try {
+    _writeMeta(root, 1, { name: 'NoSlices' });
+    const snap = dashboard.collectSnapshot(root);
+    const out = dashboard.renderSnapshot(snap, { color: false, language: 'de' });
+    assert.match(out, /keine Slices geplant/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('DB-L5: unknown language falls back to English labels', () => {
+  const root = _sandbox();
+  try {
+    _writeMeta(root, 1, { name: 'Auth' });
+    _writeTask(root, 1, 1, 1, 'done', 'X');
+    const snap = dashboard.collectSnapshot(root);
+    const out = dashboard.renderSnapshot(snap, { color: false, language: 'fr' });
+    assert.match(out, /1 done/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('DB-L6: omitted language defaults to English (lib stays pure)', () => {
+  const root = _sandbox();
+  try {
+    _writeMeta(root, 1, { name: 'Auth' });
+    _writeTask(root, 1, 1, 1, 'done', 'X');
+    const snap = dashboard.collectSnapshot(root);
+    const out = dashboard.renderSnapshot(snap, { color: false });
+    assert.match(out, /1 done/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('DB-9: multiple milestones render in numeric order', () => {
   const root = _sandbox();
   try {

package/lib/install/runtime-assets.cjs

@@ -19,6 +19,33 @@ function _listMarkdown(dir) {
     .sort();
 }
 
+function _listSkillDirs(skillsRoot) {
+  if (!skillsRoot || !fs.existsSync(skillsRoot)) return [];
+  return fs.readdirSync(skillsRoot, { withFileTypes: true })
+    .filter((e) => e.isDirectory() && !e.name.startsWith('.'))
+    .map((e) => e.name)
+    .filter((name) => fs.existsSync(path.join(skillsRoot, name, 'SKILL.md')))
+    .sort();
+}
+
+function _walkFiles(dir) {
+  const out = [];
+  const stack = [''];
+  while (stack.length) {
+    const rel = stack.pop();
+    const abs = rel ? path.join(dir, rel) : dir;
+    let entries;
+    try { entries = fs.readdirSync(abs, { withFileTypes: true }); }
+    catch { continue; }
+    for (const e of entries) {
+      const childRel = rel ? path.join(rel, e.name) : e.name;
+      if (e.isDirectory()) stack.push(childRel);
+      else if (e.isFile()) out.push(childRel);
+    }
+  }
+  return out.sort();
+}
+
 function _payloadBase(scope, projectRoot) {
   return scope === 'global' ? os.homedir() : projectRoot;
 }
@@ -27,10 +54,11 @@ function _toPosix(p) {
   return p.split(path.sep).join('/');
 }
 
-function planRuntimeAssets({ selectedRuntimes, scope, projectRoot, workflowsDir, agentsDir }) {
+function planRuntimeAssets({ selectedRuntimes, scope, projectRoot, workflowsDir, agentsDir, skillsDir }) {
   const base = _payloadBase(scope, projectRoot);
   const workflows = _listMarkdown(workflowsDir);
   const agents = _listMarkdown(agentsDir);
+  const skills = _listSkillDirs(skillsDir);
   const plans = [];
   for (const id of selectedRuntimes || []) {
     const meta = registryMod.getRuntimeMeta(id);
@@ -60,6 +88,23 @@ function planRuntimeAssets({ selectedRuntimes, scope, projectRoot, workflowsDir,
         });
       }
     }
+    if (meta.skillsSubdir && skillsDir) {
+      for (const skill of skills) {
+        const skillSrcDir = path.join(skillsDir, skill);
+        for (const rel of _walkFiles(skillSrcDir)) {
+          const sourceFile = path.join(skillSrcDir, rel);
+          const targetFile = path.join(configDir, meta.skillsSubdir, skill, rel);
+          plans.push({
+            runtime: id,
+            kind: 'skill',
+            skillName: skill,
+            sourceFile,
+            targetFile,
+            manifestKey: _toPosix(path.relative(base, targetFile)),
+          });
+        }
+      }
+    }
   }
   return plans;
 }
@@ -105,6 +150,7 @@ function _isAssetKey(key) {
   if (key.startsWith('.')) {
     if (key.startsWith('.claude/commands/')) return true;
     if (key.startsWith('.claude/agents/')) return true;
+    if (key.startsWith('.claude/skills/')) return true;
     for (const meta of registryMod.RUNTIMES) {
       if (meta.commandsSubdir) {
         if (key.startsWith(meta.localDir + '/' + meta.commandsSubdir + '/')) return true;
@@ -112,6 +158,9 @@ function _isAssetKey(key) {
       if (meta.agentsSubdir) {
         if (key.startsWith(meta.localDir + '/' + meta.agentsSubdir + '/')) return true;
       }
+      if (meta.skillsSubdir) {
+        if (key.startsWith(meta.localDir + '/' + meta.skillsSubdir + '/')) return true;
+      }
     }
   }
   return false;

package/lib/install/runtime-assets.test.cjs

@@ -0,0 +1,190 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const runtimeAssets = require('./runtime-assets.cjs');
+
+function _mkTmp(prefix) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function _seedSource(root) {
+  const workflowsDir = path.join(root, 'workflows');
+  const agentsDir = path.join(root, 'agents');
+  const skillsDir = path.join(root, 'skills');
+  fs.mkdirSync(workflowsDir, { recursive: true });
+  fs.mkdirSync(agentsDir, { recursive: true });
+  fs.mkdirSync(path.join(skillsDir, 'np-council'), { recursive: true });
+  fs.mkdirSync(path.join(skillsDir, 'np-shadcn', 'rules'), { recursive: true });
+  fs.mkdirSync(path.join(skillsDir, 'np-shadcn', 'assets'), { recursive: true });
+  fs.mkdirSync(path.join(skillsDir, '.draft'), { recursive: true });
+  fs.mkdirSync(path.join(skillsDir, 'np-incomplete'), { recursive: true });
+
+  fs.writeFileSync(path.join(workflowsDir, 'execute-phase.md'), '# wf');
+  fs.writeFileSync(path.join(agentsDir, 'np-executor.md'), '# agent');
+  fs.writeFileSync(path.join(skillsDir, 'np-council', 'SKILL.md'), '# council');
+  fs.writeFileSync(path.join(skillsDir, 'np-shadcn', 'SKILL.md'), '# shadcn');
+  fs.writeFileSync(path.join(skillsDir, 'np-shadcn', 'rules', 'react.md'), '# rules');
+  fs.writeFileSync(path.join(skillsDir, 'np-shadcn', 'assets', 'preset.json'), '{}');
+  fs.writeFileSync(path.join(skillsDir, '.draft', 'SKILL.md'), '# hidden');
+  fs.writeFileSync(path.join(skillsDir, 'np-incomplete', 'README.md'), '# no skill md');
+
+  return { workflowsDir, agentsDir, skillsDir };
+}
+
+test('planRuntimeAssets: discovers skills automatically and skips invalid dirs', () => {
+  const root = _mkTmp('np-skills-plan-');
+  try {
+    const { workflowsDir, agentsDir, skillsDir } = _seedSource(root);
+    const projectRoot = path.join(root, 'proj');
+    fs.mkdirSync(projectRoot, { recursive: true });
+
+    const plans = runtimeAssets.planRuntimeAssets({
+      selectedRuntimes: ['claude'],
+      scope: 'local',
+      projectRoot,
+      workflowsDir,
+      agentsDir,
+      skillsDir,
+    });
+
+    const skills = plans.filter((p) => p.kind === 'skill');
+    const skillNames = new Set(skills.map((p) => p.skillName));
+    assert.deepStrictEqual([...skillNames].sort(), ['np-council', 'np-shadcn'],
+      'only directories with SKILL.md and no leading dot are taken');
+
+    const shadcnFiles = skills
+      .filter((p) => p.skillName === 'np-shadcn')
+      .map((p) => p.manifestKey)
+      .sort();
+    assert.deepStrictEqual(shadcnFiles, [
+      '.claude/skills/np-shadcn/SKILL.md',
+      '.claude/skills/np-shadcn/assets/preset.json',
+      '.claude/skills/np-shadcn/rules/react.md',
+    ], 'walk yields nested files with posix manifest keys');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('planRuntimeAssets: skips skills for runtimes without skillsSubdir', () => {
+  const root = _mkTmp('np-skills-skip-');
+  try {
+    const { workflowsDir, agentsDir, skillsDir } = _seedSource(root);
+    const projectRoot = path.join(root, 'proj');
+    fs.mkdirSync(projectRoot, { recursive: true });
+
+    const plans = runtimeAssets.planRuntimeAssets({
+      selectedRuntimes: ['codex', 'gemini', 'cursor'],
+      scope: 'local',
+      projectRoot,
+      workflowsDir,
+      agentsDir,
+      skillsDir,
+    });
+
+    assert.strictEqual(plans.filter((p) => p.kind === 'skill').length, 0,
+      'no skill plans for runtimes without skillsSubdir');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('writeRuntimeAssets: copies nested skill files into runtime config dir', () => {
+  const root = _mkTmp('np-skills-write-');
+  try {
+    const { workflowsDir, agentsDir, skillsDir } = _seedSource(root);
+    const projectRoot = path.join(root, 'proj');
+    fs.mkdirSync(projectRoot, { recursive: true });
+
+    const plans = runtimeAssets.planRuntimeAssets({
+      selectedRuntimes: ['claude'],
+      scope: 'local',
+      projectRoot,
+      workflowsDir,
+      agentsDir,
+      skillsDir,
+    });
+    runtimeAssets.writeRuntimeAssets(plans);
+
+    assert.ok(fs.existsSync(path.join(projectRoot, '.claude/skills/np-council/SKILL.md')));
+    assert.ok(fs.existsSync(path.join(projectRoot, '.claude/skills/np-shadcn/SKILL.md')));
+    assert.ok(fs.existsSync(path.join(projectRoot, '.claude/skills/np-shadcn/rules/react.md')));
+    assert.ok(fs.existsSync(path.join(projectRoot, '.claude/skills/np-shadcn/assets/preset.json')));
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('manifestEntriesForPlans: hashes every skill file', () => {
+  const root = _mkTmp('np-skills-hash-');
+  try {
+    const { workflowsDir, agentsDir, skillsDir } = _seedSource(root);
+    const projectRoot = path.join(root, 'proj');
+    fs.mkdirSync(projectRoot, { recursive: true });
+
+    const plans = runtimeAssets.planRuntimeAssets({
+      selectedRuntimes: ['claude'],
+      scope: 'local',
+      projectRoot,
+      workflowsDir,
+      agentsDir,
+      skillsDir,
+    });
+    const entries = runtimeAssets.manifestEntriesForPlans(plans);
+    const skillKeys = Object.keys(entries).filter((k) => k.includes('/skills/'));
+
+    assert.ok(skillKeys.length >= 4, 'each nested skill file gets its own manifest key');
+    for (const k of skillKeys) {
+      assert.match(entries[k], /^[a-f0-9]{64}$/, k + ' has sha256 hash');
+    }
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('isAssetManifestKey: recognises skill paths for all runtimes that opted in', () => {
+  assert.strictEqual(runtimeAssets.isAssetManifestKey('.claude/skills/np-council/SKILL.md'), true);
+  assert.strictEqual(runtimeAssets.isAssetManifestKey('.claude/skills/np-shadcn/rules/react.md'), true);
+  assert.strictEqual(runtimeAssets.isAssetManifestKey('~/.claude/skills/np-council/SKILL.md'), true);
+  assert.strictEqual(runtimeAssets.isAssetManifestKey('.codex/skills/np-council/SKILL.md'), false,
+    'codex did not opt into skills');
+  assert.strictEqual(runtimeAssets.isAssetManifestKey('.claude/nubos-pilot/state.json'), false);
+});
+
+test('removeStaleAssets: deletes nested skill files and prunes empty dirs', () => {
+  const root = _mkTmp('np-skills-stale-');
+  try {
+    const { workflowsDir, agentsDir, skillsDir } = _seedSource(root);
+    const projectRoot = path.join(root, 'proj');
+    fs.mkdirSync(projectRoot, { recursive: true });
+
+    const plans = runtimeAssets.planRuntimeAssets({
+      selectedRuntimes: ['claude'],
+      scope: 'local',
+      projectRoot,
+      workflowsDir,
+      agentsDir,
+      skillsDir,
+    });
+    runtimeAssets.writeRuntimeAssets(plans);
+
+    const stale = [
+      '.claude/skills/np-shadcn/SKILL.md',
+      '.claude/skills/np-shadcn/rules/react.md',
+      '.claude/skills/np-shadcn/assets/preset.json',
+    ];
+    runtimeAssets.removeStaleAssets(stale, 'local', projectRoot);
+
+    assert.strictEqual(fs.existsSync(path.join(projectRoot, '.claude/skills/np-shadcn')), false,
+      'empty skill directory tree pruned');
+    assert.strictEqual(fs.existsSync(path.join(projectRoot, '.claude/skills/np-council/SKILL.md')), true,
+      'untouched skills remain');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

package/lib/install/runtimes-registry.cjs

@@ -15,6 +15,7 @@ const RUNTIMES = [
     payloadSubdir: 'nubos-pilot',
     commandsSubdir: 'commands/np',
     agentsSubdir: 'agents',
+    skillsSubdir: 'skills',
   },
   {
     id: 'antigravity',

package/lib/runtime/_readline.cjs

@@ -1,5 +1,27 @@
 const readline = require('node:readline');
 const { NubosPilotError } = require('../core.cjs');
+const { resolveLanguage, normalizeLanguage } = require('../language.cjs');
+
+const LABELS = Object.freeze({
+  en: {
+    choice: 'Choice',
+    multiselect_hint: 'Select multiple: 1,2,6 or 1 2 6',
+  },
+  de: {
+    choice: 'Auswahl',
+    multiselect_hint: 'Mehrfachauswahl: 1,2,6 oder 1 2 6',
+  },
+});
+
+function _labelsFor(language) {
+  const lang = normalizeLanguage(language || 'en');
+  return LABELS[lang] || LABELS.en;
+}
+
+function _resolveLangForCwd() {
+  try { return resolveLanguage(process.cwd()); }
+  catch { return 'en'; }
+}
 
 let _readlineImpl = null;
 
@@ -39,7 +61,7 @@ function _readOneLine() {
   });
 }
 
-function _parseAnswer(type, rawLine, options, def) {
+function _parseAnswer(type, rawLine, options, def, language) {
   const line = (rawLine == null ? '' : String(rawLine)).trim();
   if (type === 'select') {
     if (line === '' && def != null) return def;
@@ -74,6 +96,10 @@ function _parseAnswer(type, rawLine, options, def) {
     if (line === '' && def != null) return def;
     if (/^y(es)?$/i.test(line)) return true;
     if (/^n(o)?$/i.test(line)) return false;
+    if (normalizeLanguage(language || 'en') === 'de') {
+      if (/^j(a)?$/i.test(line)) return true;
+      if (/^nein$/i.test(line)) return false;
+    }
     if (def != null) return def;
     throw new NubosPilotError(
       'askuser-invalid-response',
@@ -100,15 +126,25 @@ function _stripAnsi(s) {
   return String(s).replace(/\x1b\[[0-9;]*m/g, '');
 }
 
-function _defaultDisplay(type, options, def) {
+function _confirmGlyphs(language) {
+  return normalizeLanguage(language || 'en') === 'de'
+    ? { yes: 'j', no: 'n' }
+    : { yes: 'y', no: 'n' };
+}
+
+function _defaultDisplay(type, options, def, language) {
   if (def == null) {
-    if (type === 'confirm') return '[y/n]';
+    if (type === 'confirm') {
+      const g = _confirmGlyphs(language);
+      return '[' + g.yes + '/' + g.no + ']';
+    }
     return '';
   }
   if (type === 'confirm') {
-    if (def === true) return '[Y/n]';
-    if (def === false) return '[y/N]';
-    return '[y/n]';
+    const g = _confirmGlyphs(language);
+    if (def === true) return '[' + g.yes.toUpperCase() + '/' + g.no + ']';
+    if (def === false) return '[' + g.yes + '/' + g.no.toUpperCase() + ']';
+    return '[' + g.yes + '/' + g.no + ']';
   }
   if (type === 'select') {
     if (options) {
@@ -127,7 +163,7 @@ function _defaultDisplay(type, options, def) {
   return '[' + String(def) + ']';
 }
 
-async function askUserReadline({ type, question, options, def }) {
+async function askUserReadline({ type, question, options, def, language }) {
   const hasTTY = !!process.stdin.isTTY;
   if (!hasTTY && !_readlineImpl) {
     if (def != null) return { value: def, source: 'default' };
@@ -137,6 +173,8 @@ async function askUserReadline({ type, question, options, def }) {
       { question },
     );
   }
+  const lang = language || _resolveLangForCwd();
+  const labels = _labelsFor(lang);
   process.stderr.write('\n');
   process.stderr.write('  ' + ANSI_YELLOW + _stripAnsi(question) + ANSI_RESET + '\n');
   process.stderr.write('\n');
@@ -150,14 +188,14 @@ async function askUserReadline({ type, question, options, def }) {
     }
     process.stderr.write('\n');
     if (type === 'multiselect') {
-      process.stderr.write('  Select multiple: 1,2,6 or 1 2 6\n');
+      process.stderr.write('  ' + labels.multiselect_hint + '\n');
       process.stderr.write('\n');
     }
   }
-  const marker = _defaultDisplay(type, options, def);
-  process.stderr.write('  Choice' + (marker ? ' ' + marker : '') + ': ');
+  const marker = _defaultDisplay(type, options, def, lang);
+  process.stderr.write('  ' + labels.choice + (marker ? ' ' + marker : '') + ': ');
   const line = await _readOneLine();
-  return { value: _parseAnswer(type, line, options, def), source: 'readline' };
+  return { value: _parseAnswer(type, line, options, def, lang), source: 'readline' };
 }
 
 module.exports = { askUserReadline, _readOneLine, _parseAnswer, _setReadlineImplForTests, _hasReadlineImplForTests };