metame-cli 1.4.34 → 1.5.1

package/scripts/telegram-adapter.js

@@ -12,6 +12,8 @@ const path = require('path');
 
 const API_BASE = 'https://api.telegram.org';
 
+const { StringDecoder } = require('string_decoder');
+
 /**
  * Make an HTTPS request to Telegram Bot API
  */
@@ -34,8 +36,10 @@ function apiRequest(token, method, params = {}, timeout = 10000, signal = null)
 
     const req = https.request(options, (res) => {
       let data = '';
-      res.on('data', (chunk) => { data += chunk; });
+      const decoder = new StringDecoder('utf8');
+      res.on('data', (chunk) => { data += decoder.write(chunk); });
       res.on('end', () => {
+        data += decoder.end();
         try {
           const parsed = JSON.parse(data);
           if (parsed.ok) {
@@ -252,7 +256,7 @@ function createBot(token) {
             resolve(destPath);
           });
           fileStream.on('error', (err) => {
-            fs.unlink(destPath, () => {});
+            fs.unlink(destPath, () => { });
             reject(err);
           });
         }).on('error', reject);
@@ -324,7 +328,7 @@ function createBot(token) {
       });
     },
 
-};
+  };
 }
 
 /**
@@ -369,11 +373,11 @@ function toTelegramMarkdownV2(md) {
   while ((m = pattern.exec(md)) !== null) {
     if (m.index > last) out += escapePlain(md.slice(last, m.index));
 
-    if      (m[1] !== undefined) out += '```' + m[1].replace(/[`\\]/g, '\\$&') + '```';
-    else if (m[2] !== undefined) out += '`'   + m[2].replace(/[`\\]/g, '\\$&') + '`';
-    else if (m[3] !== undefined) out += '*'   + toTelegramMarkdownV2(m[3]) + '*';
-    else if (m[4] !== undefined) out += '_'   + toTelegramMarkdownV2(m[4]) + '_';
-    else if (m[5] !== undefined) out += '_'   + toTelegramMarkdownV2(m[5]) + '_';
+    if (m[1] !== undefined) out += '```' + m[1].replace(/[`\\]/g, '\\$&') + '```';
+    else if (m[2] !== undefined) out += '`' + m[2].replace(/[`\\]/g, '\\$&') + '`';
+    else if (m[3] !== undefined) out += '*' + toTelegramMarkdownV2(m[3]) + '*';
+    else if (m[4] !== undefined) out += '_' + toTelegramMarkdownV2(m[4]) + '_';
+    else if (m[5] !== undefined) out += '_' + toTelegramMarkdownV2(m[5]) + '_';
     else if (m[6] !== undefined) out += '[' + toTelegramMarkdownV2(m[6]) + '](' + m[7].replace(/[()\\]/g, '\\$&') + ')';
     else if (m[9] !== undefined) out += '*' + escapePlain(m[9]) + '*';
     else if (m[10] !== undefined) {

package/scripts/usage-classifier.js

@@ -94,7 +94,7 @@ function classifyTaskUsage(task, context = {}, opts = {}) {
 
   if (!joined) return fallbackCategory;
   if (/\bteam[-_\s]?task\b|团队|协作|handoff|dispatch/.test(joined)) return 'team_task';
-  if (/\bskill[-_\s]?(?:evo|evolution|manager|scout)\b|技能演化/.test(joined)) return 'skill_evolution';
+  if (/\bskill[-_\s]?(?:evo|evolution|manager)\b|技能演化/.test(joined)) return 'skill_evolution';
   if (/\bmemory(?:-extract)?\b|记忆|facts?|recall|retriev|rag/.test(joined)) return 'memory';
   if (/\bdistill\b|\bcognition\b|认知|反思|洞察/.test(joined)) return 'cognition';
   if (/\bheartbeat\b|提醒|定时|cron|every\s+\d/.test(joined)) return 'heartbeat';

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);
-  });
-});