metame-cli 1.5.19 → 1.5.21

package/scripts/core/reactive-paths.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const path = require('path');
+
+/**
+ * Resolve new per-project reactive file paths.
+ *
+ * Structure: ~/.metame/reactive/<key>/{memory,l2cache,state,events,latest}.{md,jsonl}
+ *
+ * @param {string} projectKey
+ * @param {string} metameDir - e.g. ~/.metame
+ * @returns {{ dir: string, memory: string, l2cache: string, state: string, events: string, latest: string }}
+ */
+function resolveReactivePaths(projectKey, metameDir) {
+  const dir = path.join(metameDir, 'reactive', projectKey);
+  return {
+    dir,
+    memory: path.join(dir, 'memory.md'),
+    l2cache: path.join(dir, 'l2cache.md'),
+    state: path.join(dir, 'state.md'),
+    events: path.join(dir, 'events.jsonl'),
+    latest: path.join(dir, 'latest.md'),
+  };
+}
+
+/**
+ * Resolve legacy (pre-migration) flat paths for a project.
+ * Used by the migration script to locate old files.
+ *
+ * @param {string} projectKey
+ * @param {string} metameDir
+ * @returns {{ memory: string, l2cache: string, state: string, events: string, latest: string }}
+ */
+function resolveLegacyPaths(projectKey, metameDir) {
+  return {
+    memory: path.join(metameDir, 'memory', 'now', `${projectKey}_memory.md`),
+    l2cache: path.join(metameDir, 'memory', 'now', `${projectKey}_l2cache.md`),
+    state: path.join(metameDir, 'memory', 'now', `${projectKey}.md`),
+    events: path.join(metameDir, 'events', `${projectKey}.jsonl`),
+    latest: path.join(metameDir, 'memory', 'agents', `${projectKey}_latest.md`),
+  };
+}
+
+module.exports = { resolveReactivePaths, resolveLegacyPaths };

package/scripts/core/reactive-paths.test.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const path = require('path');
+const { resolveReactivePaths, resolveLegacyPaths } = require('./reactive-paths');
+
+describe('resolveReactivePaths', () => {
+  it('returns correct directory structure', () => {
+    const p = resolveReactivePaths('scientist', '/home/user/.metame');
+    assert.equal(p.dir, path.join('/home/user/.metame', 'reactive', 'scientist'));
+    assert.equal(p.memory, path.join(p.dir, 'memory.md'));
+    assert.equal(p.l2cache, path.join(p.dir, 'l2cache.md'));
+    assert.equal(p.state, path.join(p.dir, 'state.md'));
+    assert.equal(p.events, path.join(p.dir, 'events.jsonl'));
+    assert.equal(p.latest, path.join(p.dir, 'latest.md'));
+  });
+
+  it('works with different keys', () => {
+    const p = resolveReactivePaths('my_project', '/tmp/meta');
+    assert.equal(p.dir, path.join('/tmp/meta', 'reactive', 'my_project'));
+    assert.equal(p.events, path.join('/tmp/meta', 'reactive', 'my_project', 'events.jsonl'));
+  });
+});
+
+describe('resolveLegacyPaths', () => {
+  it('returns flat legacy paths', () => {
+    const p = resolveLegacyPaths('scientist', '/home/user/.metame');
+    assert.equal(p.memory, path.join('/home/user/.metame', 'memory', 'now', 'scientist_memory.md'));
+    assert.equal(p.l2cache, path.join('/home/user/.metame', 'memory', 'now', 'scientist_l2cache.md'));
+    assert.equal(p.state, path.join('/home/user/.metame', 'memory', 'now', 'scientist.md'));
+    assert.equal(p.events, path.join('/home/user/.metame', 'events', 'scientist.jsonl'));
+    assert.equal(p.latest, path.join('/home/user/.metame', 'memory', 'agents', 'scientist_latest.md'));
+  });
+});

package/scripts/core/reactive-prompt.js

@@ -0,0 +1,51 @@
+'use strict';
+
+/**
+ * core/reactive-prompt.js — Pure function to wrap reactive prompts
+ *
+ * Injects reactive mode instructions, working memory, and retry warnings
+ * into agent prompts. Zero I/O, zero side effects.
+ */
+
+/**
+ * Build a reactive-mode prompt wrapper around the original prompt.
+ *
+ * @param {string} originalPrompt - The original prompt text
+ * @param {object} opts
+ * @param {number} opts.depth - Current reactive depth
+ * @param {number} opts.maxDepth - Maximum allowed depth
+ * @param {string} opts.completionSignal - Signal string for mission completion
+ * @param {string} [opts.workingMemory] - Optional working memory content
+ * @param {boolean} [opts.isRetry] - Whether this is a retry after no signal
+ * @returns {string} Wrapped prompt string
+ */
+function buildReactivePrompt(originalPrompt, opts) {
+  const { depth, maxDepth, completionSignal, workingMemory, isRetry } = opts;
+
+  const parts = [];
+
+  parts.push(`[REACTIVE MODE] depth ${depth}/${maxDepth}`);
+  parts.push('Rules:');
+  parts.push('1. After completing the current step, you MUST output NEXT_DISPATCH: <target> "<prompt>" to trigger the next step');
+  parts.push(`2. Only output ${completionSignal} when ALL objectives are achieved`);
+  parts.push('3. Do NOT exit silently — failing to output a signal means the task chain breaks');
+
+  if (isRetry) {
+    parts.push('');
+    parts.push('Warning: you did not output any signal in the previous round, causing task interruption. Check progress and continue.');
+  }
+
+  if (workingMemory && workingMemory.trim()) {
+    parts.push('');
+    parts.push('[Working Memory]');
+    parts.push(workingMemory.trim());
+  }
+
+  parts.push('');
+  parts.push('---');
+  parts.push(originalPrompt);
+
+  return parts.join('\n');
+}
+
+module.exports = { buildReactivePrompt };

package/scripts/core/reactive-prompt.test.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const { buildReactivePrompt } = require('./reactive-prompt');
+
+describe('buildReactivePrompt', () => {
+  it('wraps prompt with reactive mode header (no memory, no retry)', () => {
+    const result = buildReactivePrompt('Do the task', {
+      depth: 3,
+      maxDepth: 50,
+      completionSignal: 'MISSION_COMPLETE',
+    });
+    assert.ok(result.includes('[REACTIVE MODE] depth 3/50'));
+    assert.ok(result.includes('NEXT_DISPATCH'));
+    assert.ok(result.includes('MISSION_COMPLETE'));
+    assert.ok(result.includes('Do the task'));
+    assert.ok(!result.includes('[Working Memory]'));
+    assert.ok(!result.includes('Warning:'));
+  });
+
+  it('injects working memory when provided', () => {
+    const result = buildReactivePrompt('Do the task', {
+      depth: 1,
+      maxDepth: 10,
+      completionSignal: 'DONE',
+      workingMemory: '## Recent Decisions\n- chose option A',
+    });
+    assert.ok(result.includes('[Working Memory]'));
+    assert.ok(result.includes('## Recent Decisions'));
+    assert.ok(result.includes('chose option A'));
+  });
+
+  it('includes retry warning when isRetry is true', () => {
+    const result = buildReactivePrompt('Check progress', {
+      depth: 5,
+      maxDepth: 50,
+      completionSignal: 'MISSION_COMPLETE',
+      isRetry: true,
+    });
+    assert.ok(result.includes('Warning:'));
+    assert.ok(result.includes('previous round'));
+  });
+
+  it('does not inject Working Memory block when workingMemory is empty string', () => {
+    const result = buildReactivePrompt('Do stuff', {
+      depth: 2,
+      maxDepth: 20,
+      completionSignal: 'MISSION_COMPLETE',
+      workingMemory: '',
+    });
+    assert.ok(!result.includes('[Working Memory]'));
+  });
+
+  it('does not inject Working Memory block when workingMemory is whitespace only', () => {
+    const result = buildReactivePrompt('Do stuff', {
+      depth: 2,
+      maxDepth: 20,
+      completionSignal: 'MISSION_COMPLETE',
+      workingMemory: '   \n  ',
+    });
+    assert.ok(!result.includes('[Working Memory]'));
+  });
+
+  it('does not inject Working Memory block when workingMemory is undefined', () => {
+    const result = buildReactivePrompt('Do stuff', {
+      depth: 2,
+      maxDepth: 20,
+      completionSignal: 'MISSION_COMPLETE',
+      workingMemory: undefined,
+    });
+    assert.ok(!result.includes('[Working Memory]'));
+  });
+
+  it('includes both retry warning and working memory when both present', () => {
+    const result = buildReactivePrompt('Continue', {
+      depth: 4,
+      maxDepth: 50,
+      completionSignal: 'MISSION_COMPLETE',
+      workingMemory: 'Some context',
+      isRetry: true,
+    });
+    assert.ok(result.includes('Warning:'));
+    assert.ok(result.includes('[Working Memory]'));
+    assert.ok(result.includes('Some context'));
+    assert.ok(result.includes('Continue'));
+  });
+});

package/scripts/core/reactive-signal.js

@@ -0,0 +1,40 @@
+'use strict';
+
+/**
+ * core/reactive-signal.js — Pure function for no-signal decision logic
+ *
+ * Determines the next action when a reactive agent completes output:
+ * proceed, retry (if no signal detected), or pause (after max retries).
+ * Zero I/O, zero side effects.
+ */
+
+/**
+ * Calculate the next action based on signal presence and retry count.
+ *
+ * @param {object} params
+ * @param {boolean} params.hasSignals - Whether any signals were detected in output
+ * @param {boolean} params.isComplete - Whether completion signal was detected
+ * @param {number} params.noSignalCount - Current consecutive no-signal count
+ * @param {number} params.maxRetries - Maximum retries before pausing
+ * @returns {{ action: 'proceed'|'retry'|'pause', nextNoSignalCount: number, pauseReason?: string }}
+ */
+function calculateNextAction({ hasSignals, isComplete, noSignalCount, maxRetries }) {
+  if (isComplete) {
+    return { action: 'proceed', nextNoSignalCount: 0 };
+  }
+
+  if (hasSignals) {
+    return { action: 'proceed', nextNoSignalCount: 0 };
+  }
+
+  // No signals detected
+  const nextCount = noSignalCount + 1;
+
+  if (nextCount >= maxRetries) {
+    return { action: 'pause', nextNoSignalCount: nextCount, pauseReason: 'no_signal_repeated' };
+  }
+
+  return { action: 'retry', nextNoSignalCount: nextCount };
+}
+
+module.exports = { calculateNextAction };

package/scripts/core/reactive-signal.test.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const { calculateNextAction } = require('./reactive-signal');
+
+describe('calculateNextAction', () => {
+  it('returns proceed with count=0 when isComplete', () => {
+    const result = calculateNextAction({
+      hasSignals: false,
+      isComplete: true,
+      noSignalCount: 2,
+      maxRetries: 3,
+    });
+    assert.equal(result.action, 'proceed');
+    assert.equal(result.nextNoSignalCount, 0);
+    assert.equal(result.pauseReason, undefined);
+  });
+
+  it('returns proceed with count=0 when hasSignals (not complete)', () => {
+    const result = calculateNextAction({
+      hasSignals: true,
+      isComplete: false,
+      noSignalCount: 1,
+      maxRetries: 3,
+    });
+    assert.equal(result.action, 'proceed');
+    assert.equal(result.nextNoSignalCount, 0);
+  });
+
+  it('returns retry when no signals and count+1 < maxRetries', () => {
+    const result = calculateNextAction({
+      hasSignals: false,
+      isComplete: false,
+      noSignalCount: 0,
+      maxRetries: 3,
+    });
+    assert.equal(result.action, 'retry');
+    assert.equal(result.nextNoSignalCount, 1);
+    assert.equal(result.pauseReason, undefined);
+  });
+
+  it('returns retry when count+1 is still less than maxRetries', () => {
+    const result = calculateNextAction({
+      hasSignals: false,
+      isComplete: false,
+      noSignalCount: 1,
+      maxRetries: 3,
+    });
+    assert.equal(result.action, 'retry');
+    assert.equal(result.nextNoSignalCount, 2);
+  });
+
+  it('returns pause when count+1 >= maxRetries', () => {
+    const result = calculateNextAction({
+      hasSignals: false,
+      isComplete: false,
+      noSignalCount: 2,
+      maxRetries: 3,
+    });
+    assert.equal(result.action, 'pause');
+    assert.equal(result.nextNoSignalCount, 3);
+    assert.equal(result.pauseReason, 'no_signal_repeated');
+  });
+
+  it('returns pause when count already exceeds maxRetries', () => {
+    const result = calculateNextAction({
+      hasSignals: false,
+      isComplete: false,
+      noSignalCount: 5,
+      maxRetries: 3,
+    });
+    assert.equal(result.action, 'pause');
+    assert.equal(result.nextNoSignalCount, 6);
+    assert.equal(result.pauseReason, 'no_signal_repeated');
+  });
+
+  it('isComplete takes priority over hasSignals', () => {
+    const result = calculateNextAction({
+      hasSignals: true,
+      isComplete: true,
+      noSignalCount: 2,
+      maxRetries: 3,
+    });
+    assert.equal(result.action, 'proceed');
+    assert.equal(result.nextNoSignalCount, 0);
+  });
+});

package/scripts/core/thread-chat-id.js

@@ -0,0 +1,52 @@
+'use strict';
+
+/**
+ * thread-chat-id.js — Pure utilities for Feishu topic-based session isolation.
+ *
+ * Composite ID format: "thread:{chatId}:{threadId}"
+ *   chatId   = Feishu group chat ID  (e.g. "oc_xxx")
+ *   threadId = topic root message ID (e.g. "om_yyy")
+ *
+ * Zero dependencies. Zero side effects.
+ */
+
+const PREFIX = 'thread:';
+
+function buildThreadChatId(chatId, threadId) {
+  const c = String(chatId || '').trim();
+  const t = String(threadId || '').trim();
+  if (!c || !t) return c || '';
+  return `${PREFIX}${c}:${t}`;
+}
+
+function parseThreadChatId(compositeId) {
+  const id = String(compositeId || '');
+  if (!id.startsWith(PREFIX)) return null;
+  const firstColon = PREFIX.length;
+  const secondColon = id.indexOf(':', firstColon);
+  if (secondColon === -1) return null;
+  const chatId = id.slice(firstColon, secondColon);
+  const threadId = id.slice(secondColon + 1);
+  if (!chatId || !threadId) return null;
+  return { chatId, threadId };
+}
+
+function isThreadChatId(id) {
+  return typeof id === 'string' && id.startsWith(PREFIX) && parseThreadChatId(id) !== null;
+}
+
+/**
+ * Extract the raw Feishu chat ID regardless of whether the input
+ * is a composite thread ID or a plain chat ID.
+ */
+function rawChatId(id) {
+  const parsed = parseThreadChatId(id);
+  return parsed ? parsed.chatId : String(id || '');
+}
+
+module.exports = {
+  buildThreadChatId,
+  parseThreadChatId,
+  isThreadChatId,
+  rawChatId,
+};

package/scripts/core/thread-chat-id.test.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const {
+  buildThreadChatId,
+  parseThreadChatId,
+  isThreadChatId,
+  rawChatId,
+} = require('./thread-chat-id');
+
+describe('buildThreadChatId', () => {
+  it('builds composite ID from chatId and threadId', () => {
+    assert.equal(buildThreadChatId('oc_123', 'om_abc'), 'thread:oc_123:om_abc');
+  });
+
+  it('trims whitespace', () => {
+    assert.equal(buildThreadChatId(' oc_123 ', ' om_abc '), 'thread:oc_123:om_abc');
+  });
+
+  it('returns plain chatId when threadId is empty', () => {
+    assert.equal(buildThreadChatId('oc_123', ''), 'oc_123');
+    assert.equal(buildThreadChatId('oc_123', null), 'oc_123');
+    assert.equal(buildThreadChatId('oc_123', undefined), 'oc_123');
+  });
+
+  it('returns empty string when chatId is empty', () => {
+    assert.equal(buildThreadChatId('', 'om_abc'), '');
+    assert.equal(buildThreadChatId(null, 'om_abc'), '');
+  });
+
+  it('returns empty string when both are empty', () => {
+    assert.equal(buildThreadChatId('', ''), '');
+  });
+});
+
+describe('parseThreadChatId', () => {
+  it('parses valid composite ID', () => {
+    assert.deepEqual(parseThreadChatId('thread:oc_123:om_abc'), {
+      chatId: 'oc_123',
+      threadId: 'om_abc',
+    });
+  });
+
+  it('handles threadId containing colons', () => {
+    assert.deepEqual(parseThreadChatId('thread:oc_123:om_abc:extra'), {
+      chatId: 'oc_123',
+      threadId: 'om_abc:extra',
+    });
+  });
+
+  it('returns null for plain chatId', () => {
+    assert.equal(parseThreadChatId('oc_123'), null);
+  });
+
+  it('returns null for empty string', () => {
+    assert.equal(parseThreadChatId(''), null);
+  });
+
+  it('returns null for null/undefined', () => {
+    assert.equal(parseThreadChatId(null), null);
+    assert.equal(parseThreadChatId(undefined), null);
+  });
+
+  it('returns null when prefix present but missing parts', () => {
+    assert.equal(parseThreadChatId('thread:'), null);
+    assert.equal(parseThreadChatId('thread:oc_123'), null);
+    assert.equal(parseThreadChatId('thread::om_abc'), null);
+    assert.equal(parseThreadChatId('thread:oc_123:'), null);
+  });
+});
+
+describe('isThreadChatId', () => {
+  it('returns true for valid composite ID', () => {
+    assert.equal(isThreadChatId('thread:oc_123:om_abc'), true);
+  });
+
+  it('returns false for plain chatId', () => {
+    assert.equal(isThreadChatId('oc_123'), false);
+  });
+
+  it('returns false for malformed thread prefix', () => {
+    assert.equal(isThreadChatId('thread:'), false);
+    assert.equal(isThreadChatId('thread:oc_123'), false);
+  });
+
+  it('returns false for non-string', () => {
+    assert.equal(isThreadChatId(null), false);
+    assert.equal(isThreadChatId(123), false);
+  });
+});
+
+describe('rawChatId', () => {
+  it('extracts chatId from composite', () => {
+    assert.equal(rawChatId('thread:oc_123:om_abc'), 'oc_123');
+  });
+
+  it('returns plain chatId as-is', () => {
+    assert.equal(rawChatId('oc_123'), 'oc_123');
+  });
+
+  it('returns empty string for null', () => {
+    assert.equal(rawChatId(null), '');
+  });
+});
+
+describe('round-trip', () => {
+  it('build then parse preserves values', () => {
+    const built = buildThreadChatId('oc_foo', 'om_bar');
+    const parsed = parseThreadChatId(built);
+    assert.deepEqual(parsed, { chatId: 'oc_foo', threadId: 'om_bar' });
+  });
+});