nubos-pilot 0.6.2 → 0.6.3

package/bin/np-tools/session-aggregate.test.cjs

@@ -0,0 +1,120 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const mod = require('./session-aggregate.cjs');
+
+function mkSandbox(opts) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-sa-'));
+  const state = path.join(dir, '.nubos-pilot');
+  fs.mkdirSync(path.join(state, 'metrics'), { recursive: true });
+  const records = (opts && opts.records) || [];
+  const byPhase = {};
+  for (const r of records) {
+    const key = r.phase || 'meta';
+    (byPhase[key] = byPhase[key] || []).push(r);
+  }
+  for (const key of Object.keys(byPhase)) {
+    const fname = key === 'meta' ? 'meta.jsonl' : 'phase-' + key + '.jsonl';
+    fs.writeFileSync(
+      path.join(state, 'metrics', fname),
+      byPhase[key].map((r) => JSON.stringify(r)).join('\n'),
+    );
+  }
+  if (opts && opts.pointer) {
+    fs.mkdirSync(path.join(state, 'reports'), { recursive: true });
+    fs.writeFileSync(path.join(state, 'reports', '.last-session'), opts.pointer);
+  }
+  return dir;
+}
+
+function captureStdout() {
+  const chunks = [];
+  return {
+    stream: { write: (c) => { chunks.push(c); } },
+    read: () => chunks.join(''),
+  };
+}
+
+test('SA-1: aggregates with no pointer (full project)', async () => {
+  const dir = mkSandbox({
+    records: [
+      {
+        schema_version: 2, started_at: '2026-04-10T10:00:00Z', phase: 'P1',
+        agent: 'a', tier: 't', resolved_model: 'm',
+        plan: 'PL1', task: 'TA1', tokens_in: 10, tokens_out: 20,
+        duration_ms: 100, status: 'ok', runtime: 'claude', retry_count: 0,
+      },
+    ],
+  });
+  try {
+    const cap = captureStdout();
+    const rc = await mod.run([], { cwd: dir, stdout: cap.stream });
+    assert.equal(rc, 0);
+    const out = JSON.parse(cap.read());
+    assert.equal(out.record_count, 1);
+    assert.equal(out.total_tokens_in, 10);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SA-2: --since override honoured', async () => {
+  const dir = mkSandbox({
+    records: [
+      {
+        schema_version: 2, started_at: '2026-04-10T10:00:00Z', phase: 'P1',
+        agent: 'a', tier: 't', resolved_model: 'm',
+        plan: 'PL1', task: 'TA1', tokens_in: 10, tokens_out: 20,
+        duration_ms: 100, status: 'ok', runtime: 'claude', retry_count: 0,
+      },
+      {
+        schema_version: 2, started_at: '2026-04-20T10:00:00Z', phase: 'P1',
+        agent: 'a', tier: 't', resolved_model: 'm',
+        plan: 'PL1', task: 'TA2', tokens_in: 5, tokens_out: 7,
+        duration_ms: 50, status: 'ok', runtime: 'claude', retry_count: 0,
+      },
+    ],
+  });
+  try {
+    const cap = captureStdout();
+    await mod.run(['--since', '2026-04-15T00:00:00Z'], { cwd: dir, stdout: cap.stream });
+    const out = JSON.parse(cap.read());
+    assert.equal(out.record_count, 1);
+    assert.equal(out.total_tokens_in, 5);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SA-3: existing pointer used when no --since override', async () => {
+  const dir = mkSandbox({
+    pointer: '2026-04-15T00:00:00Z',
+    records: [
+      {
+        schema_version: 2, started_at: '2026-04-10T10:00:00Z', phase: 'P1',
+        agent: 'a', tier: 't', resolved_model: 'm',
+        plan: 'PL1', task: 'TA1', tokens_in: 10, tokens_out: 20,
+        duration_ms: 100, status: 'ok', runtime: 'claude', retry_count: 0,
+      },
+      {
+        schema_version: 2, started_at: '2026-04-20T10:00:00Z', phase: 'P1',
+        agent: 'a', tier: 't', resolved_model: 'm',
+        plan: 'PL1', task: 'TA2', tokens_in: 5, tokens_out: 7,
+        duration_ms: 50, status: 'ok', runtime: 'claude', retry_count: 0,
+      },
+    ],
+  });
+  try {
+    const cap = captureStdout();
+    await mod.run([], { cwd: dir, stdout: cap.stream });
+    const out = JSON.parse(cap.read());
+    assert.equal(out.record_count, 1);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/bin/np-tools/session-pointer-write.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  NubosPilotError,
+  projectStateDir,
+  withFileLock,
+  atomicWriteFileSync,
+} = require('../../lib/core.cjs');
+
+const LOCK_TIMEOUT_MS = 10000;
+const ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
+
+function _parseArgs(args) {
+  const rest = [];
+  for (const a of args || []) {
+    if (!a.startsWith('-')) rest.push(a);
+  }
+  return { iso: rest[0] || null };
+}
+
+function _validateIso(raw) {
+  if (!raw) {
+    throw new NubosPilotError('session-pointer-missing-iso',
+      'ISO-8601 UTC timestamp required (e.g. 2026-04-22T12:34:56Z)', {});
+  }
+  if (!ISO_RE.test(raw)) {
+    throw new NubosPilotError('session-pointer-invalid-iso',
+      'timestamp must be ISO-8601 UTC (YYYY-MM-DDTHH:MM:SSZ)', { iso: raw });
+  }
+  return raw;
+}
+
+function _pointerPath(cwd) {
+  return path.join(projectStateDir(cwd), 'reports', '.last-session');
+}
+
+function run(args, opts) {
+  const o = opts || {};
+  const cwd = o.cwd || process.cwd();
+  const stdout = o.stdout || process.stdout;
+  const parsed = _parseArgs(args || []);
+  const iso = _validateIso(parsed.iso);
+
+  const pointer = _pointerPath(cwd);
+  fs.mkdirSync(path.dirname(pointer), { recursive: true });
+
+  withFileLock(pointer, () => atomicWriteFileSync(pointer, iso), { timeoutMs: LOCK_TIMEOUT_MS });
+
+  stdout.write(JSON.stringify({ ok: true, pointer, iso }));
+  return 0;
+}
+
+module.exports = { run, _parseArgs, _validateIso, _pointerPath };

package/bin/np-tools/session-pointer-write.test.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const mod = require('./session-pointer-write.cjs');
+
+function mkSandbox() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-spw-'));
+  fs.mkdirSync(path.join(dir, '.nubos-pilot'));
+  return dir;
+}
+
+function captureStdout() {
+  const chunks = [];
+  return {
+    stream: { write: (c) => { chunks.push(c); } },
+    read: () => chunks.join(''),
+  };
+}
+
+test('SPW-1: writes pointer atomically', () => {
+  const dir = mkSandbox();
+  try {
+    const cap = captureStdout();
+    const iso = '2026-04-22T12:34:56Z';
+    const rc = mod.run([iso], { cwd: dir, stdout: cap.stream });
+    assert.equal(rc, 0);
+    const written = fs.readFileSync(path.join(dir, '.nubos-pilot', 'reports', '.last-session'), 'utf-8');
+    assert.equal(written, iso);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SPW-2: missing iso throws', () => {
+  assert.throws(
+    () => mod.run([], { cwd: '/tmp', stdout: { write: () => {} } }),
+    (err) => err.code === 'session-pointer-missing-iso',
+  );
+});
+
+test('SPW-3: invalid iso throws', () => {
+  assert.throws(
+    () => mod._validateIso('not-a-date'),
+    (err) => err.code === 'session-pointer-invalid-iso',
+  );
+});
+
+test('SPW-4: accepts fractional seconds', () => {
+  assert.equal(mod._validateIso('2026-04-22T12:34:56.789Z'), '2026-04-22T12:34:56.789Z');
+});
+
+test('SPW-5: rejects missing Z suffix', () => {
+  assert.throws(
+    () => mod._validateIso('2026-04-22T12:34:56'),
+    (err) => err.code === 'session-pointer-invalid-iso',
+  );
+});

package/bin/np-tools/state-dir.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+const path = require('node:path');
+const { projectStateDir, NubosPilotError } = require('../../lib/core.cjs');
+
+const SUBDIR_RE = /^[a-zA-Z0-9._-][a-zA-Z0-9._/-]*$/;
+
+function _parseArgs(args) {
+  const out = { subdir: null };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--subdir' || a === '-s') { out.subdir = args[++i] || null; continue; }
+  }
+  return out;
+}
+
+function _validateSubdir(raw) {
+  if (raw == null) return null;
+  const s = String(raw);
+  if (s.includes('..')) {
+    throw new NubosPilotError('state-dir-invalid-subdir',
+      'subdir must not contain ".."', { subdir: raw });
+  }
+  if (path.isAbsolute(s)) {
+    throw new NubosPilotError('state-dir-invalid-subdir',
+      'subdir must be relative', { subdir: raw });
+  }
+  if (!SUBDIR_RE.test(s)) {
+    throw new NubosPilotError('state-dir-invalid-subdir',
+      'subdir contains forbidden characters', { subdir: raw });
+  }
+  return s;
+}
+
+function run(args, opts) {
+  const o = opts || {};
+  const cwd = o.cwd || process.cwd();
+  const stdout = o.stdout || process.stdout;
+  const parsed = _parseArgs(args || []);
+  const subdir = _validateSubdir(parsed.subdir);
+  const base = projectStateDir(cwd);
+  const out = subdir == null ? base : path.join(base, subdir);
+  stdout.write(out);
+  return 0;
+}
+
+module.exports = { run, _parseArgs, _validateSubdir };

package/bin/np-tools/state-dir.test.cjs

@@ -0,0 +1,72 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const mod = require('./state-dir.cjs');
+
+function mkSandbox() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-sd-'));
+  fs.mkdirSync(path.join(dir, '.nubos-pilot'));
+  return dir;
+}
+
+function captureStdout() {
+  const chunks = [];
+  return {
+    stream: { write: (c) => { chunks.push(c); } },
+    read: () => chunks.join(''),
+  };
+}
+
+test('SD-1: run() without --subdir returns .nubos-pilot path', () => {
+  const dir = mkSandbox();
+  try {
+    const cap = captureStdout();
+    const rc = mod.run([], { cwd: dir, stdout: cap.stream });
+    assert.equal(rc, 0);
+    assert.equal(cap.read(), path.join(dir, '.nubos-pilot'));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SD-2: --subdir notes appends the segment', () => {
+  const dir = mkSandbox();
+  try {
+    const cap = captureStdout();
+    const rc = mod.run(['--subdir', 'notes'], { cwd: dir, stdout: cap.stream });
+    assert.equal(rc, 0);
+    assert.equal(cap.read(), path.join(dir, '.nubos-pilot', 'notes'));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SD-3: .. in subdir rejected', () => {
+  assert.throws(
+    () => mod._validateSubdir('../etc'),
+    (err) => err.code === 'state-dir-invalid-subdir',
+  );
+});
+
+test('SD-4: absolute subdir rejected', () => {
+  assert.throws(
+    () => mod._validateSubdir('/etc/passwd'),
+    (err) => err.code === 'state-dir-invalid-subdir',
+  );
+});
+
+test('SD-5: special chars rejected', () => {
+  assert.throws(
+    () => mod._validateSubdir('x$(whoami)'),
+    (err) => err.code === 'state-dir-invalid-subdir',
+  );
+});
+
+test('SD-6: nested slash allowed (threads/open)', () => {
+  assert.equal(mod._validateSubdir('threads/open'), 'threads/open');
+});

package/bin/np-tools/state-incr.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+const { NubosPilotError } = require('../../lib/core.cjs');
+const { mutateState } = require('../../lib/state.cjs');
+
+const ALLOWED_KEYS = new Set(['pending_todos']);
+
+function _parseArgs(args) {
+  const rest = [];
+  for (const a of args || []) {
+    if (!a.startsWith('-')) rest.push(a);
+  }
+  return { key: rest[0] || null };
+}
+
+function run(args, opts) {
+  const o = opts || {};
+  const cwd = o.cwd || process.cwd();
+  const stdout = o.stdout || process.stdout;
+  const parsed = _parseArgs(args || []);
+
+  if (!parsed.key) {
+    throw new NubosPilotError('state-incr-missing-key',
+      'state counter key required', { allowed: Array.from(ALLOWED_KEYS) });
+  }
+  if (!ALLOWED_KEYS.has(parsed.key)) {
+    throw new NubosPilotError('state-incr-unknown-key',
+      'state counter key not in whitelist: ' + parsed.key,
+      { key: parsed.key, allowed: Array.from(ALLOWED_KEYS) });
+  }
+
+  const next = mutateState((doc) => {
+    const current = doc.frontmatter[parsed.key];
+    const asNumber = typeof current === 'number' && Number.isFinite(current) ? current : 0;
+    doc.frontmatter[parsed.key] = asNumber + 1;
+    return doc;
+  }, cwd);
+
+  stdout.write(JSON.stringify({ ok: true, key: parsed.key, value: next.frontmatter[parsed.key] }));
+  return 0;
+}
+
+module.exports = { run, _parseArgs, ALLOWED_KEYS };

package/bin/np-tools/state-incr.test.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const mod = require('./state-incr.cjs');
+
+const STATE_SEED = [
+  '---',
+  'schema_version: 2',
+  'milestone: null',
+  'milestone_name: null',
+  'current_phase: null',
+  'current_plan: null',
+  'current_task: null',
+  'last_updated: null',
+  'progress:',
+  '  total_phases: 0',
+  '  completed_phases: 0',
+  '  total_plans: 0',
+  '  completed_plans: 0',
+  '  percent: 0',
+  'session:',
+  '  stopped_at: null',
+  '  resume_file: null',
+  '  last_activity: null',
+  '---',
+  '',
+  '# State',
+  '',
+].join('\n');
+
+function mkSandbox(withCounter) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-si-'));
+  fs.mkdirSync(path.join(dir, '.nubos-pilot'));
+  let content = STATE_SEED;
+  if (withCounter != null) {
+    content = content.replace('schema_version: 2', 'schema_version: 2\npending_todos: ' + withCounter);
+  }
+  fs.writeFileSync(path.join(dir, '.nubos-pilot', 'STATE.md'), content);
+  return dir;
+}
+
+function captureStdout() {
+  const chunks = [];
+  return {
+    stream: { write: (c) => { chunks.push(c); } },
+    read: () => chunks.join(''),
+  };
+}
+
+test('SI-1: first increment sets pending_todos to 1', () => {
+  const dir = mkSandbox();
+  try {
+    const cap = captureStdout();
+    const rc = mod.run(['pending_todos'], { cwd: dir, stdout: cap.stream });
+    assert.equal(rc, 0);
+    const out = JSON.parse(cap.read());
+    assert.equal(out.ok, true);
+    assert.equal(out.value, 1);
+    const written = fs.readFileSync(path.join(dir, '.nubos-pilot', 'STATE.md'), 'utf-8');
+    assert.match(written, /pending_todos: 1/);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SI-2: increments existing counter', () => {
+  const dir = mkSandbox(3);
+  try {
+    const cap = captureStdout();
+    mod.run(['pending_todos'], { cwd: dir, stdout: cap.stream });
+    const out = JSON.parse(cap.read());
+    assert.equal(out.value, 4);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SI-3: unknown key rejected', () => {
+  const dir = mkSandbox();
+  try {
+    assert.throws(
+      () => mod.run(['bogus'], { cwd: dir, stdout: { write: () => {} } }),
+      (err) => err.code === 'state-incr-unknown-key',
+    );
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SI-4: missing key rejected', () => {
+  assert.throws(
+    () => mod.run([], { cwd: '/tmp', stdout: { write: () => {} } }),
+    (err) => err.code === 'state-incr-missing-key',
+  );
+});

package/bin/np-tools/thread-resume.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { NubosPilotError, atomicWriteFileSync } = require('../../lib/core.cjs');
+const { extractFrontmatter } = require('../../lib/frontmatter.cjs');
+
+const FRONTMATTER_ORDER = ['slug', 'status', 'created', 'last_resumed'];
+
+function _parseArgs(args) {
+  const out = { path: null, today: null };
+  const rest = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!a.startsWith('-')) { rest.push(a); continue; }
+    if (a === '--today' || a === '-t') { out.today = args[++i] || null; continue; }
+  }
+  if (rest.length) out.path = rest[0];
+  return out;
+}
+
+function _bumpStatus(cur) {
+  const s = String(cur || 'OPEN');
+  if (s === 'OPEN') return 'IN_PROGRESS';
+  return s;
+}
+
+function _serialize(fm, body) {
+  const lines = ['---'];
+  const seen = new Set();
+  for (const k of FRONTMATTER_ORDER) {
+    if (k in fm) { lines.push(k + ': ' + fm[k]); seen.add(k); }
+  }
+  for (const k of Object.keys(fm)) {
+    if (!seen.has(k)) lines.push(k + ': ' + fm[k]);
+  }
+  lines.push('---');
+  return lines.join('\n') + '\n' + body;
+}
+
+function run(args, opts) {
+  const o = opts || {};
+  const cwd = o.cwd || process.cwd();
+  const stdout = o.stdout || process.stdout;
+  const parsed = _parseArgs(args || []);
+
+  if (!parsed.path) {
+    throw new NubosPilotError('thread-resume-missing-path',
+      'thread path required', {});
+  }
+  const today = parsed.today || new Date().toISOString().slice(0, 10);
+
+  const resolved = path.resolve(cwd, parsed.path);
+  let raw;
+  try {
+    raw = fs.readFileSync(resolved, 'utf-8');
+  } catch (err) {
+    throw new NubosPilotError('thread-resume-read-error',
+      'cannot read thread file: ' + (err && err.message),
+      { path: resolved, cause: err && err.code });
+  }
+
+  let parts;
+  try {
+    parts = extractFrontmatter(raw);
+  } catch (err) {
+    throw new NubosPilotError('thread-resume-parse-error',
+      'thread frontmatter invalid: ' + (err && err.message),
+      { path: resolved, cause: err && err.code });
+  }
+
+  const fm = Object.assign({}, parts.frontmatter);
+  fm.status = _bumpStatus(fm.status);
+  fm.last_resumed = today;
+
+  const out = _serialize(fm, parts.body);
+  atomicWriteFileSync(resolved, out);
+
+  stdout.write(JSON.stringify({ ok: true, path: resolved, status: fm.status, last_resumed: fm.last_resumed }));
+  return 0;
+}
+
+module.exports = { run, _parseArgs, _bumpStatus, _serialize, FRONTMATTER_ORDER };