metame-cli 1.4.34 → 1.5.0

package/scripts/daemon-admin-commands.test.js

@@ -1,333 +0,0 @@
-'use strict';
-
-const { describe, it } = require('node:test');
-const assert = require('node:assert/strict');
-const { createAdminCommandHandler } = require('./daemon-admin-commands');
-const taskEnvelope = require('./daemon-task-envelope');
-
-function createHandler(getAllTasksImpl, overrides = {}) {
-  return createAdminCommandHandler({
-    fs: require('fs'),
-    yaml: { load: () => ({}), dump: () => '' },
-    execSync: () => '',
-    BRAIN_FILE: '/tmp/brain.yaml',
-    CONFIG_FILE: '/tmp/config.yaml',
-    DISPATCH_LOG: '/tmp/dispatch.log',
-    providerMod: null,
-    loadConfig: () => ({}),
-    backupConfig: () => {},
-    writeConfigSafe: () => {},
-    restoreConfig: () => false,
-    getSession: () => null,
-    getAllTasks: getAllTasksImpl,
-    dispatchTask: () => ({ success: true }),
-    log: () => {},
-    skillEvolution: null,
-    taskBoard: null,
-    taskEnvelope: null,
-    ...overrides,
-  });
-}
-
-describe('daemon-admin-commands /tasks', () => {
-  it('renders interval and fixed-time schedules for mobile task list', async () => {
-    const sent = [];
-    const { handleAdminCommand } = createHandler(() => ({
-      general: [
-        { name: 'memory-extract', interval: '4h', enabled: true },
-      ],
-      project: [
-        {
-          name: 'morning-brief',
-          at: '09:00',
-          days: 'weekdays',
-          enabled: true,
-          _project: { key: 'writer', icon: '✍️', name: 'Writer' },
-        },
-      ],
-    }));
-
-    const bot = {
-      sendMessage: async (_chatId, text) => { sent.push(String(text)); },
-    };
-
-    const res = await handleAdminCommand({
-      bot,
-      chatId: 'mobile-user-1',
-      text: '/tasks',
-      config: {},
-      state: {
-        tasks: {
-          'memory-extract': { status: 'success' },
-          'morning-brief': { status: 'never_run' },
-        },
-      },
-    });
-
-    assert.equal(res.handled, true);
-    assert.equal(sent.length, 1);
-    const body = sent[0];
-    assert.match(body, /memory-extract \(every 4h\) success/);
-    assert.match(body, /morning-brief \(at 09:00 weekdays\) never_run/);
-  });
-});
-
-describe('daemon-admin-commands /TeamTask', () => {
-  it('creates team task via /TeamTask create', async () => {
-    const sent = [];
-    const dispatchCalls = [];
-    const { handleAdminCommand } = createHandler(
-      () => ({ general: [], project: [] }),
-      {
-        taskEnvelope,
-        taskBoard: {
-          listScopeParticipants: () => ['planner'],
-        },
-        dispatchTask: (target, packet) => {
-          dispatchCalls.push({ target, packet });
-          return { success: true };
-        },
-      }
-    );
-
-    const bot = {
-      sendMessage: async (_chatId, text) => { sent.push(String(text)); },
-    };
-
-    const res = await handleAdminCommand({
-      bot,
-      chatId: 'mobile-user-2',
-      text: '/TeamTask create coder 重构登录流程 --scope epic_auth',
-      config: {
-        projects: {
-          coder: { name: 'Coder' },
-        },
-      },
-      state: { tasks: {} },
-    });
-
-    assert.equal(res.handled, true);
-    assert.equal(dispatchCalls.length, 1);
-    assert.equal(dispatchCalls[0].target, 'coder');
-    assert.equal(dispatchCalls[0].packet.payload.task_envelope.scope_id, 'epic_auth');
-    assert.match(sent[0], /已创建 TeamTask 并派发/);
-    assert.match(sent[0], /查看: \/TeamTask t_/);
-  });
-
-  it('shows usage when /TeamTask create is missing payload', async () => {
-    const sent = [];
-    const { handleAdminCommand } = createHandler(() => ({ general: [], project: [] }), { taskEnvelope });
-    const bot = {
-      sendMessage: async (_chatId, text) => { sent.push(String(text)); },
-    };
-
-    const res = await handleAdminCommand({
-      bot,
-      chatId: 'mobile-user-2b',
-      text: '/TeamTask create',
-      config: {},
-      state: { tasks: {} },
-    });
-
-    assert.equal(res.handled, true);
-    assert.match(sent[0], /用法: \/TeamTask create <agent> <目标>/);
-  });
-
-  it('lists team tasks via /TeamTask', async () => {
-    const sent = [];
-    const { handleAdminCommand } = createHandler(
-      () => ({ general: [], project: [] }),
-      {
-        taskBoard: {
-          listRecentTasks: () => [
-            {
-              task_id: 't_20260225_abc123',
-              scope_id: 'epic_auth',
-              status: 'running',
-              from_agent: 'user',
-              to_agent: 'coder',
-              goal: '重构登录流程',
-            },
-          ],
-        },
-      }
-    );
-
-    const bot = {
-      sendMessage: async (_chatId, text) => { sent.push(String(text)); },
-    };
-
-    const res = await handleAdminCommand({
-      bot,
-      chatId: 'mobile-user-3',
-      text: '/TeamTask',
-      config: {},
-      state: { tasks: {} },
-    });
-
-    assert.equal(res.handled, true);
-    assert.match(sent[0], /TeamTask \(最近10条\)/);
-    assert.match(sent[0], /查看详情: \/TeamTask <task_id>/);
-    assert.match(sent[0], /续跑: \/TeamTask resume <task_id>/);
-  });
-
-  it('renders detail via /TeamTask <task_id>', async () => {
-    const sent = [];
-    const { handleAdminCommand } = createHandler(
-      () => ({ general: [], project: [] }),
-      {
-        taskBoard: {
-          getTask: () => ({
-            task_id: 't_20260225_xyz789',
-            scope_id: 'epic_auth',
-            status: 'running',
-            priority: 'normal',
-            from_agent: 'planner',
-            to_agent: 'coder',
-            task_kind: 'team',
-            goal: '重构登录流程',
-            definition_of_done: ['提交可运行代码'],
-            artifacts: ['src/login.js'],
-          }),
-          listTaskEvents: () => [],
-          listScopeTasks: () => [],
-          listScopeParticipants: () => ['planner', 'coder'],
-        },
-      }
-    );
-
-    const bot = {
-      sendMessage: async (_chatId, text) => { sent.push(String(text)); },
-    };
-
-    const res = await handleAdminCommand({
-      bot,
-      chatId: 'mobile-user-3b',
-      text: '/TeamTask t_20260225_xyz789',
-      config: {},
-      state: { tasks: {} },
-    });
-
-    assert.equal(res.handled, true);
-    assert.match(sent[0], /🧩 TeamTask: t_20260225_xyz789/);
-    assert.match(sent[0], /Scope: epic_auth/);
-    assert.match(sent[0], /参与者: planner, coder/);
-  });
-
-  it('resumes task via /TeamTask resume <task_id>', async () => {
-    const sent = [];
-    const dispatchCalls = [];
-    const { handleAdminCommand } = createHandler(
-      () => ({ general: [], project: [] }),
-      {
-        taskEnvelope,
-        taskBoard: {
-          getTask: () => ({
-            task_id: 't_20260225_resume1',
-            scope_id: 'epic_auth',
-            status: 'queued',
-            priority: 'normal',
-            from_agent: 'planner',
-            to_agent: 'coder',
-            task_kind: 'team',
-            goal: '重构登录流程',
-            definition_of_done: [],
-            inputs: {},
-            artifacts: [],
-            owned_paths: [],
-            created_at: '2026-02-25T00:00:00.000Z',
-          }),
-          listScopeParticipants: () => ['planner', 'coder'],
-          appendTaskEvent: () => {},
-        },
-        dispatchTask: (target, packet) => {
-          dispatchCalls.push({ target, packet });
-          return { success: true };
-        },
-      }
-    );
-    const bot = {
-      sendMessage: async (_chatId, text) => { sent.push(String(text)); },
-    };
-
-    const res = await handleAdminCommand({
-      bot,
-      chatId: 'mobile-user-3c',
-      text: '/TeamTask resume t_20260225_resume1',
-      config: {
-        projects: {
-          coder: { name: 'Coder' },
-        },
-      },
-      state: { tasks: {} },
-    });
-
-    assert.equal(res.handled, true);
-    assert.equal(dispatchCalls.length, 1);
-    assert.equal(dispatchCalls[0].target, 'coder');
-    assert.match(sent[0], /已续跑 TeamTask: t_20260225_resume1/);
-  });
-
-  it('shows usage when /TeamTask resume is missing task id', async () => {
-    const sent = [];
-    const { handleAdminCommand } = createHandler(
-      () => ({ general: [], project: [] }),
-      {
-        taskBoard: {
-          getTask: () => null,
-        },
-      }
-    );
-    const bot = {
-      sendMessage: async (_chatId, text) => { sent.push(String(text)); },
-    };
-
-    const res = await handleAdminCommand({
-      bot,
-      chatId: 'mobile-user-3d',
-      text: '/TeamTask resume',
-      config: {},
-      state: { tasks: {} },
-    });
-
-    assert.equal(res.handled, true);
-    assert.match(sent[0], /用法: \/TeamTask resume <task_id>/);
-  });
-
-  it('does not handle legacy /task command', async () => {
-    const sent = [];
-    const { handleAdminCommand } = createHandler(() => ({ general: [], project: [] }));
-    const bot = {
-      sendMessage: async (_chatId, text) => { sent.push(String(text)); },
-    };
-    const res = await handleAdminCommand({
-      bot,
-      chatId: 'mobile-user-4',
-      text: '/task',
-      config: {},
-      state: { tasks: {} },
-    });
-
-    assert.equal(res.handled, false);
-    assert.equal(sent.length, 0);
-  });
-
-  it('does not accept legacy /dispatch task syntax', async () => {
-    const sent = [];
-    const { handleAdminCommand } = createHandler(() => ({ general: [], project: [] }));
-    const bot = {
-      sendMessage: async (_chatId, text) => { sent.push(String(text)); },
-    };
-    const res = await handleAdminCommand({
-      bot,
-      chatId: 'mobile-user-5',
-      text: '/dispatch task coder 重构登录流程',
-      config: {},
-      state: { tasks: {} },
-    });
-
-    assert.equal(res.handled, true);
-    assert.match(sent[0], /\/TeamTask create <agent> <目标>/);
-    assert.doesNotMatch(sent[0], /\/dispatch task/);
-  });
-});

package/scripts/daemon-task-envelope.test.js

@@ -1,59 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const {
-  normalizeTaskEnvelope,
-  validateTaskEnvelope,
-  newTaskId,
-  newHandoffId,
-} = require('./daemon-task-envelope');
-
-test('normalizeTaskEnvelope sets defaults for team task', () => {
-  const env = normalizeTaskEnvelope({
-    from_agent: 'assistant',
-    to_agent: 'coder',
-    goal: 'run tests',
-  });
-  assert.ok(env.task_id.startsWith('t_'));
-  assert.equal(env.scope_id, env.task_id);
-  assert.equal(env.task_kind, 'team');
-  assert.equal(env.status, 'queued');
-  assert.equal(env.priority, 'normal');
-  assert.equal(env.from_agent, 'assistant');
-  assert.equal(env.to_agent, 'coder');
-  assert.equal(env.goal, 'run tests');
-  assert.deepEqual(env.participants.sort(), ['assistant', 'coder'].sort());
-});
-
-test('validateTaskEnvelope rejects missing goal', () => {
-  const env = normalizeTaskEnvelope({
-    from_agent: 'assistant',
-    to_agent: 'coder',
-    goal: '',
-  });
-  const v = validateTaskEnvelope(env);
-  assert.equal(v.ok, false);
-  assert.equal(v.error, 'goal_required');
-});
-
-test('id generators return expected prefixes', () => {
-  const taskId = newTaskId(new Date('2026-02-25T00:00:00.000Z'));
-  const handoffId = newHandoffId();
-  assert.ok(taskId.startsWith('t_20260225_'));
-  assert.ok(handoffId.startsWith('h_'));
-});
-
-test('normalizeTaskEnvelope keeps explicit scope and merges participants', () => {
-  const env = normalizeTaskEnvelope({
-    task_id: 't_1',
-    scope_id: 'scope#A/1',
-    from_agent: 'assistant',
-    to_agent: 'reviewer',
-    participants: ['assistant', 'coder'],
-    goal: 'review changes',
-  });
-  assert.equal(env.scope_id, 'scope_A_1');
-  assert.deepEqual(env.participants.sort(), ['assistant', 'coder', 'reviewer'].sort());
-});

package/scripts/daemon-task-scheduler.test.js

@@ -1,106 +0,0 @@
-'use strict';
-
-const { describe, it } = require('node:test');
-const assert = require('node:assert/strict');
-const { _private } = require('./daemon-task-scheduler');
-
-const {
-  parseAtTime,
-  parseDays,
-  nextClockRunAfter,
-  buildTaskSchedule,
-  computeInitialNextRun,
-  nextRunAfter,
-} = _private;
-
-function nextDayOfWeek(base, day) {
-  const d = new Date(base);
-  while (d.getDay() !== day) d.setDate(d.getDate() + 1);
-  return d;
-}
-
-describe('daemon-task-scheduler private helpers', () => {
-  it('parses HH:MM time for clock tasks', () => {
-    assert.deepEqual(parseAtTime('09:30'), { hour: 9, minute: 30 });
-    assert.deepEqual(parseAtTime('23:59'), { hour: 23, minute: 59 });
-    assert.equal(parseAtTime('24:00'), null);
-    assert.equal(parseAtTime('9:7'), null);
-  });
-
-  it('parses days keywords and weekday names', () => {
-    assert.deepEqual([...parseDays('weekdays').days], [1, 2, 3, 4, 5]);
-    assert.deepEqual([...parseDays('weekends').days], [0, 6]);
-    assert.deepEqual([...parseDays(['mon', 'wed', 'fri']).days], [1, 3, 5]);
-    assert.equal(parseDays('daily').days, null);
-    assert.equal(parseDays().days, null);
-    assert.equal(parseDays('funday').ok, false);
-  });
-
-  it('computes next run for daily fixed-time schedule', () => {
-    const schedule = { mode: 'clock', hour: 9, minute: 30, days: null };
-    const fromBefore = new Date(2026, 1, 25, 8, 0, 0, 0).getTime();
-    const fromAfter = new Date(2026, 1, 25, 10, 0, 0, 0).getTime();
-
-    const next1 = new Date(nextClockRunAfter(schedule, fromBefore));
-    const next2 = new Date(nextClockRunAfter(schedule, fromAfter));
-
-    assert.equal(next1.getHours(), 9);
-    assert.equal(next1.getMinutes(), 30);
-    assert.equal(next1.getDate(), 25);
-
-    assert.equal(next2.getHours(), 9);
-    assert.equal(next2.getMinutes(), 30);
-    assert.equal(next2.getDate(), 26);
-  });
-
-  it('computes next run for weekday-only fixed-time schedule', () => {
-    const saturdayBase = nextDayOfWeek(new Date(2026, 1, 1, 8, 0, 0, 0), 6);
-    const schedule = { mode: 'clock', hour: 9, minute: 0, days: parseDays('weekdays').days };
-    const next = new Date(nextClockRunAfter(schedule, saturdayBase.getTime()));
-    const monday = nextDayOfWeek(new Date(saturdayBase), 1);
-
-    assert.equal(next.getDay(), 1);
-    assert.equal(next.getHours(), 9);
-    assert.equal(next.getMinutes(), 0);
-    assert.equal(next.getDate(), monday.getDate());
-    assert.equal(next.getMonth(), monday.getMonth());
-    assert.equal(next.getFullYear(), monday.getFullYear());
-  });
-
-  it('builds interval or clock schedule from task config', () => {
-    const intervalTask = { name: 'a', interval: '2h' };
-    const clockTask = { name: 'b', at: '07:15', days: 'weekdays' };
-
-    const interval = buildTaskSchedule(intervalTask, () => 7200);
-    const clock = buildTaskSchedule(clockTask, () => 3600);
-    const invalid = buildTaskSchedule({ name: 'bad', at: '25:99' }, () => 3600);
-
-    assert.equal(interval.ok, true);
-    assert.equal(interval.schedule.mode, 'interval');
-    assert.equal(interval.schedule.intervalSec, 7200);
-
-    assert.equal(clock.ok, true);
-    assert.equal(clock.schedule.mode, 'clock');
-    assert.equal(clock.schedule.hour, 7);
-    assert.equal(clock.schedule.minute, 15);
-    assert.deepEqual([...clock.schedule.days], [1, 2, 3, 4, 5]);
-
-    assert.equal(invalid.ok, false);
-  });
-
-  it('does catch-up for missed fixed-time runs and computes next run after execution', () => {
-    const task = { name: 'daily-report', at: '09:00' };
-    const schedule = { mode: 'clock', hour: 9, minute: 0, days: null };
-    const now = new Date(2026, 1, 25, 10, 0, 0, 0).getTime();
-    const yesterday = new Date(2026, 1, 24, 9, 0, 0, 0).toISOString();
-    const state = { tasks: { 'daily-report': { last_run: yesterday } } };
-
-    const initial = computeInitialNextRun(task, schedule, state, now, 60, 1);
-    const next = new Date(nextRunAfter(schedule, now));
-
-    assert.equal(initial, now);
-    assert.equal(next.getDate(), 26);
-    assert.equal(next.getHours(), 9);
-    assert.equal(next.getMinutes(), 0);
-  });
-});