nubos-pilot 1.0.2 → 1.0.4

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

@@ -0,0 +1,241 @@
+'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 { Writable } = require('node:stream');
+
+const memoryIndex = require('./memory-index.cjs');
+const memoryQuery = require('./memory-query.cjs');
+const memoryAdd = require('./memory-add.cjs');
+const memoryRebuild = require('./memory-rebuild.cjs');
+const memoryStats = require('./memory-stats.cjs');
+
+function _sandbox(enabled = true) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-memory-cli-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  if (enabled) {
+    fs.writeFileSync(
+      path.join(root, '.nubos-pilot', 'config.json'),
+      JSON.stringify({ memory: { enabled: true, model: 'mock-v1', alpha: 0.6 } }),
+      'utf-8',
+    );
+  } else {
+    fs.writeFileSync(
+      path.join(root, '.nubos-pilot', 'config.json'),
+      JSON.stringify({ memory: { enabled: false } }),
+      'utf-8',
+    );
+  }
+  return root;
+}
+
+function _capture() {
+  const chunks = [];
+  const stream = new Writable({
+    write(chunk, _enc, cb) { chunks.push(chunk); cb(); },
+  });
+  stream.text = () => Buffer.concat(chunks).toString('utf-8');
+  return stream;
+}
+
+function _hashEmbed(text, dim) {
+  const v = new Float32Array(dim);
+  let s = 1;
+  for (let i = 0; i < text.length; i++) s = (s * 31 + text.charCodeAt(i)) & 0x7fffffff;
+  for (let i = 0; i < dim; i++) {
+    s = (s * 1103515245 + 12345) & 0x7fffffff;
+    v[i] = (s % 1000) / 1000;
+  }
+  let n = 0;
+  for (let i = 0; i < dim; i++) n += v[i] * v[i];
+  n = Math.sqrt(n) || 1;
+  for (let i = 0; i < dim; i++) v[i] /= n;
+  return v;
+}
+
+function _mockProvider() {
+  return {
+    modelId: 'mock-v1',
+    dim: 8,
+    async embed(texts) { return texts.map((t) => _hashEmbed(t, 8)); },
+  };
+}
+
+function _mockIndex() {
+  let entries = new Map();
+  return {
+    add(id, vec) { entries.set(id, vec); },
+    remove(id) { entries.delete(id); },
+    size() { return entries.size; },
+    isEmpty() { return entries.size === 0; },
+    clear() { entries = new Map(); },
+    search(vec, k) {
+      const hits = [];
+      for (const [id, v] of entries.entries()) {
+        let dot = 0;
+        for (let i = 0; i < vec.length; i++) dot += vec[i] * v[i];
+        hits.push({ id, score: dot });
+      }
+      hits.sort((a, b) => b.score - a.score);
+      return hits.slice(0, k);
+    },
+  };
+}
+
+function _mocks(root) {
+  return { cwd: root, provider: _mockProvider(), indexEngine: _mockIndex(), alpha: 0.6 };
+}
+
+test('MEMC-1: memory-index --records JSON array writes records and prints {added, skipped}', async () => {
+  const root = _sandbox();
+  try {
+    const out = _capture();
+    const records = JSON.stringify([
+      { type: 'learning', title: 'A', body: 'b1' },
+      { type: 'learning', title: 'B', body: 'b2' },
+    ]);
+    const exit = await memoryIndex.run(['--records', records], { ..._mocks(root), stdout: out });
+    assert.equal(exit, 0);
+    const parsed = JSON.parse(out.text());
+    assert.equal(parsed.added, 2);
+    assert.equal(parsed.skipped, 0);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MEMC-2: memory-index --records-file reads JSONL', async () => {
+  const root = _sandbox();
+  try {
+    const filePath = path.join(root, 'records.jsonl');
+    const lines = [
+      JSON.stringify({ type: 'critic', title: 'finding-1', body: 'b' }),
+      JSON.stringify({ type: 'research', title: 'decision-1', body: 'b' }),
+    ];
+    fs.writeFileSync(filePath, lines.join('\n'), 'utf-8');
+
+    const out = _capture();
+    await memoryIndex.run(['--records-file', filePath], { ..._mocks(root), stdout: out });
+    const parsed = JSON.parse(out.text());
+    assert.equal(parsed.added, 2);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MEMC-3: memory-query prints top-k JSON array', async () => {
+  const root = _sandbox();
+  try {
+    const ctx = _mocks(root);
+    await memoryIndex.run(
+      ['--records', JSON.stringify([
+        { type: 'learning', title: 'A', body: 'a' },
+        { type: 'learning', title: 'B', body: 'b' },
+      ])],
+      { ...ctx, stdout: _capture() },
+    );
+
+    const queryOut = _capture();
+    await memoryQuery.run(['--text', 'a', '--k', '5'], { ...ctx, stdout: queryOut });
+    const hits = JSON.parse(queryOut.text());
+    assert.ok(Array.isArray(hits));
+    assert.ok(hits.length >= 1);
+    assert.ok('id' in hits[0] && 'score' in hits[0] && 'record' in hits[0]);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MEMC-4: memory-add inserts a single record and prints {added, id}', async () => {
+  const root = _sandbox();
+  try {
+    const out = _capture();
+    const exit = await memoryAdd.run(
+      ['--type', 'learning', '--title', 'A', '--body', 'b', '--tags', 'feature-flags,filament'],
+      { ..._mocks(root), stdout: out },
+    );
+    assert.equal(exit, 0);
+    const parsed = JSON.parse(out.text());
+    assert.equal(parsed.added, true);
+    assert.match(parsed.id, /^[0-9a-f]{8}-/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MEMC-5: memory-stats returns count + dim + model', async () => {
+  const root = _sandbox();
+  try {
+    const ctx = _mocks(root);
+    await memoryAdd.run(['--type', 'learning', '--title', 'A', '--body', 'b'], { ...ctx, stdout: _capture() });
+
+    const statsOut = _capture();
+    memoryStats.run([], { ...ctx, stdout: statsOut });
+    const stats = JSON.parse(statsOut.text());
+    assert.equal(stats.count, 1);
+    assert.equal(stats.dim, 8);
+    assert.equal(stats.model, 'mock-v1');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MEMC-6: memory-rebuild re-embeds existing records', async () => {
+  const root = _sandbox();
+  try {
+    const ctx = _mocks(root);
+    await memoryIndex.run(
+      ['--records', JSON.stringify([
+        { type: 'learning', title: 'A', body: 'a' },
+        { type: 'learning', title: 'B', body: 'b' },
+      ])],
+      { ...ctx, stdout: _capture() },
+    );
+
+    const rebuildOut = _capture();
+    await memoryRebuild.run([], { ...ctx, stdout: rebuildOut });
+    const result = JSON.parse(rebuildOut.text());
+    assert.equal(result.reembedded, 2);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MEMC-7: production path with memory.enabled=false errors with memory-disabled', () => {
+  const root = _sandbox(false);
+  try {
+    assert.throws(
+      () => memoryStats.run([], { cwd: root, stdout: _capture() }),
+      (err) => err.name === 'NubosPilotError' && err.code === 'memory-disabled',
+    );
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MEMC-8: memory-query without text errors with memory-query-missing-text', async () => {
+  const root = _sandbox();
+  try {
+    await assert.rejects(
+      memoryQuery.run([], { ..._mocks(root), stdout: _capture() }),
+      (err) => err.code === 'memory-query-missing-text',
+    );
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MEMC-9: memory-index without records errors with memory-index-missing-records', async () => {
+  const root = _sandbox();
+  try {
+    await assert.rejects(
+      memoryIndex.run([], { ..._mocks(root), stdout: _capture() }),
+      (err) => err.code === 'memory-index-missing-records',
+    );
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

package/bin/np-tools/messages-archive.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+const { NubosPilotError } = require('../../lib/core.cjs');
+const { archive } = require('../../lib/messaging.cjs');
+
+function _parseArgs(args) {
+  const out = { id: null };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--id') { out.id = args[++i] || null; continue; }
+    if (!a.startsWith('--') && !out.id) { out.id = a; continue; }
+  }
+  return out;
+}
+
+function run(args, opts) {
+  const o = opts || {};
+  const cwd = o.cwd || process.cwd();
+  const stdout = o.stdout || process.stdout;
+  const parsed = _parseArgs(Array.isArray(args) ? args : []);
+
+  if (!parsed.id) {
+    throw new NubosPilotError(
+      'messages-missing-id',
+      'msg-id required (positional or --id)',
+      {},
+    );
+  }
+
+  archive(parsed.id, cwd);
+  stdout.write(JSON.stringify({ archived: parsed.id }) + '\n');
+  return 0;
+}
+
+module.exports = { run, _parseArgs };

package/bin/np-tools/messages-inbox.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+const { inbox } = require('../../lib/messaging.cjs');
+
+function _parseArgs(args) {
+  const out = { agent: null, kind: null, since: null, phase: null };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--agent') { out.agent = args[++i] || null; continue; }
+    if (a === '--kind')  { out.kind = args[++i] || null; continue; }
+    if (a === '--since') { out.since = args[++i] || null; continue; }
+    if (a === '--phase') { out.phase = args[++i] || null; continue; }
+    if (a === '--task')  { out.phase = args[++i] || null; continue; }
+  }
+  return out;
+}
+
+function run(args, opts) {
+  const o = opts || {};
+  const cwd = o.cwd || process.cwd();
+  const stdout = o.stdout || process.stdout;
+  const parsed = _parseArgs(Array.isArray(args) ? args : []);
+
+  const result = inbox(parsed.agent, {
+    kind: parsed.kind || undefined,
+    since: parsed.since || undefined,
+    phase: parsed.phase || undefined,
+  }, cwd);
+
+  stdout.write(JSON.stringify(result) + '\n');
+  return 0;
+}
+
+module.exports = { run, _parseArgs };

package/bin/np-tools/messages-send.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+const fs = require('node:fs');
+const { NubosPilotError } = require('../../lib/core.cjs');
+const { send } = require('../../lib/messaging.cjs');
+
+function _parseArgs(args) {
+  const out = {
+    from: null, to: null, phase: null, round: null,
+    kind: null, subject: null, body: null, bodyFile: null,
+    expectsReply: false, inReplyTo: null,
+  };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--from')          { out.from = args[++i] || null; continue; }
+    if (a === '--to')            { out.to = args[++i] || null; continue; }
+    if (a === '--phase')         { out.phase = args[++i] || null; continue; }
+    if (a === '--task')          { out.phase = args[++i] || null; continue; }
+    if (a === '--round')         { out.round = args[++i] || null; continue; }
+    if (a === '--kind')          { out.kind = args[++i] || null; continue; }
+    if (a === '--subject')       { out.subject = args[++i] || null; continue; }
+    if (a === '--body')          { out.body = args[++i] || null; continue; }
+    if (a === '--body-file')     { out.bodyFile = args[++i] || null; continue; }
+    if (a === '--expects-reply') { out.expectsReply = true; continue; }
+    if (a === '--in-reply-to')   { out.inReplyTo = args[++i] || null; continue; }
+  }
+  return out;
+}
+
+function run(args, opts) {
+  const o = opts || {};
+  const cwd = o.cwd || process.cwd();
+  const stdout = o.stdout || process.stdout;
+  const parsed = _parseArgs(Array.isArray(args) ? args : []);
+
+  let body = parsed.body || '';
+  if (parsed.bodyFile) {
+    try { body = fs.readFileSync(parsed.bodyFile, 'utf-8'); }
+    catch (err) {
+      throw new NubosPilotError(
+        'messages-body-file-read-failed',
+        'failed to read --body-file: ' + (err && err.message),
+        { path: parsed.bodyFile },
+      );
+    }
+  }
+
+  let round = null;
+  if (parsed.round !== null && parsed.round !== '') {
+    const n = Number(parsed.round);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n < 0) {
+      throw new NubosPilotError(
+        'messages-invalid-round',
+        '--round must be a non-negative integer; got: ' + JSON.stringify(parsed.round),
+        { round: parsed.round },
+      );
+    }
+    round = n;
+  }
+
+  const result = send({
+    from: parsed.from,
+    to: parsed.to,
+    phase: parsed.phase,
+    round,
+    kind: parsed.kind,
+    subject: parsed.subject,
+    body,
+    expects_reply: parsed.expectsReply,
+    in_reply_to: parsed.inReplyTo,
+  }, cwd);
+
+  stdout.write(JSON.stringify(result) + '\n');
+  return 0;
+}
+
+module.exports = { run, _parseArgs };

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

@@ -0,0 +1,35 @@
+'use strict';
+
+const { NubosPilotError } = require('../../lib/core.cjs');
+const { thread } = require('../../lib/messaging.cjs');
+
+function _parseArgs(args) {
+  const out = { id: null };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--id') { out.id = args[++i] || null; continue; }
+    if (!a.startsWith('--') && !out.id) { out.id = a; continue; }
+  }
+  return out;
+}
+
+function run(args, opts) {
+  const o = opts || {};
+  const cwd = o.cwd || process.cwd();
+  const stdout = o.stdout || process.stdout;
+  const parsed = _parseArgs(Array.isArray(args) ? args : []);
+
+  if (!parsed.id) {
+    throw new NubosPilotError(
+      'messages-missing-id',
+      'msg-id required (positional or --id)',
+      {},
+    );
+  }
+
+  const result = thread(parsed.id, cwd);
+  stdout.write(JSON.stringify(result) + '\n');
+  return 0;
+}
+
+module.exports = { run, _parseArgs };

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

@@ -0,0 +1,183 @@
+'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 { Writable } = require('node:stream');
+
+const send = require('./messages-send.cjs');
+const inbox = require('./messages-inbox.cjs');
+const archiveCmd = require('./messages-archive.cjs');
+const thread = require('./messages-thread.cjs');
+
+function _sandbox() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-messages-cli-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  return root;
+}
+
+function _capture() {
+  const chunks = [];
+  const stream = new Writable({
+    write(chunk, _enc, cb) { chunks.push(chunk); cb(); },
+  });
+  stream.text = () => Buffer.concat(chunks).toString('utf-8');
+  return stream;
+}
+
+test('MSC-1: messages-send writes inbox file and prints id JSON', () => {
+  const root = _sandbox();
+  try {
+    const out = _capture();
+    const exit = send.run(
+      ['--from', 'np-critic', '--to', 'np-executor',
+       '--phase', 'M016-S001-T0001', '--kind', 'notify',
+       '--subject', 'style', '--body', 'lint warning'],
+      { cwd: root, stdout: out },
+    );
+    assert.equal(exit, 0);
+    const parsed = JSON.parse(out.text());
+    assert.match(parsed.id, /^\d+-/);
+    assert.ok(fs.existsSync(parsed.path));
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MSC-2: messages-send --body-file reads body from disk', () => {
+  const root = _sandbox();
+  try {
+    const bodyFile = path.join(root, 'body.txt');
+    fs.writeFileSync(bodyFile, 'multi\nline\nbody', 'utf-8');
+    const out = _capture();
+    send.run(
+      ['--from', 'a', '--to', 'b', '--phase', 'P', '--kind', 'notify',
+       '--subject', 's', '--body-file', bodyFile],
+      { cwd: root, stdout: out },
+    );
+    const parsed = JSON.parse(out.text());
+    const stored = JSON.parse(fs.readFileSync(parsed.path, 'utf-8'));
+    assert.equal(stored.body, 'multi\nline\nbody');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MSC-3: messages-send --expects-reply sets the flag', () => {
+  const root = _sandbox();
+  try {
+    const out = _capture();
+    send.run(
+      ['--from', 'a', '--to', 'b', '--phase', 'P', '--kind', 'request',
+       '--subject', 's', '--body', 'q', '--expects-reply'],
+      { cwd: root, stdout: out },
+    );
+    const parsed = JSON.parse(out.text());
+    const stored = JSON.parse(fs.readFileSync(parsed.path, 'utf-8'));
+    assert.equal(stored.expects_reply, true);
+    assert.equal(stored.kind, 'request');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MSC-4: messages-inbox lists messages for an agent as JSON array', () => {
+  const root = _sandbox();
+  try {
+    const sendOut = _capture();
+    send.run(
+      ['--from', 'a', '--to', 'b', '--phase', 'P', '--kind', 'notify',
+       '--subject', 's', '--body', 'hi'],
+      { cwd: root, stdout: sendOut },
+    );
+    const inboxOut = _capture();
+    const exit = inbox.run(['--agent', 'b'], { cwd: root, stdout: inboxOut });
+    assert.equal(exit, 0);
+    const list = JSON.parse(inboxOut.text());
+    assert.ok(Array.isArray(list));
+    assert.equal(list.length, 1);
+    assert.equal(list[0].subject, 's');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MSC-5: messages-archive moves a notify message and prints archived id', () => {
+  const root = _sandbox();
+  try {
+    const sendOut = _capture();
+    send.run(
+      ['--from', 'a', '--to', 'b', '--phase', 'P', '--kind', 'notify',
+       '--subject', 's', '--body', 'hi'],
+      { cwd: root, stdout: sendOut },
+    );
+    const sentId = JSON.parse(sendOut.text()).id;
+    const archiveOut = _capture();
+    const exit = archiveCmd.run([sentId], { cwd: root, stdout: archiveOut });
+    assert.equal(exit, 0);
+    assert.deepEqual(JSON.parse(archiveOut.text()), { archived: sentId });
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MSC-6: messages-archive without reply on expects_reply=true throws envelope code', () => {
+  const root = _sandbox();
+  try {
+    const sendOut = _capture();
+    send.run(
+      ['--from', 'a', '--to', 'b', '--phase', 'P', '--kind', 'request',
+       '--subject', 's', '--body', 'q', '--expects-reply'],
+      { cwd: root, stdout: sendOut },
+    );
+    const reqId = JSON.parse(sendOut.text()).id;
+    assert.throws(
+      () => archiveCmd.run([reqId], { cwd: root, stdout: _capture() }),
+      (err) => err.name === 'NubosPilotError' && err.code === 'messages-archive-without-reply',
+    );
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MSC-7: messages-thread prints causal reply chain', () => {
+  const root = _sandbox();
+  try {
+    const reqOut = _capture();
+    send.run(
+      ['--from', 'a', '--to', 'b', '--phase', 'P', '--kind', 'request',
+       '--subject', 's', '--body', 'q', '--expects-reply'],
+      { cwd: root, stdout: reqOut },
+    );
+    const reqId = JSON.parse(reqOut.text()).id;
+    const respOut = _capture();
+    send.run(
+      ['--from', 'b', '--to', 'a', '--phase', 'P', '--kind', 'response',
+       '--subject', 's', '--body', 'a', '--in-reply-to', reqId],
+      { cwd: root, stdout: respOut },
+    );
+
+    const threadOut = _capture();
+    thread.run([reqId], { cwd: root, stdout: threadOut });
+    const chain = JSON.parse(threadOut.text());
+    assert.equal(chain.length, 2);
+    assert.equal(chain[0].kind, 'request');
+    assert.equal(chain[1].kind, 'response');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MSC-8: messages-archive without id throws messages-missing-id', () => {
+  const root = _sandbox();
+  try {
+    assert.throws(
+      () => archiveCmd.run([], { cwd: root, stdout: _capture() }),
+      (err) => err.name === 'NubosPilotError' && err.code === 'messages-missing-id',
+    );
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});