blun-king-cli 9.1.364 → 9.1.365

package/bin/cognitive-memory-command.cjs

@@ -0,0 +1,245 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const { createRuntimeCognitiveTurnLifecycle } = require('./cognitive-turn-lifecycle.cjs');
+const { resolveCognitiveEvidenceGroup } = require('./cognitive-effective-view.cjs');
+
+const FOCUS_DOMAINS = new Set(['self', 'team', 'goal', 'open_thread', 'next_trigger', 'expected_evidence']);
+const POSITIVE_ID_RE = /^[1-9]\d*$/u;
+const NUMERIC_CHAT_ID_RE = /^-?\d+$/u;
+
+function fail(code) {
+  const error = new Error(code);
+  error.code = code;
+  throw error;
+}
+
+function clean(value, max) {
+  const text = String(value ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
+  return text && text.length <= max ? text : '';
+}
+
+function digestId(prefix, values) {
+  return `${prefix}-${crypto.createHash('sha256').update(values.join('\0')).digest('hex').slice(0, 40)}`;
+}
+
+function isCognitiveMemoryCommand(args) {
+  const action = String(args ?? '').trim().split(/\s+/u, 1)[0].toLowerCase();
+  return action === 'focus' || action === 'correct' || action === 'delete';
+}
+
+function parseCognitiveMemoryCommand(args) {
+  const text = String(args ?? '').trim();
+  if (text.toLowerCase() === 'focus') return { action: 'focus' };
+  const correction = /^correct\s+(\S+)\s+(.+)$/iu.exec(text);
+  if (correction) {
+    const target = clean(correction[1], 128);
+    const value = clean(correction[2], 512);
+    if (target && value) return { action: 'correct', target, value };
+  }
+  const deletion = /^delete\s+(\S+)$/iu.exec(text);
+  if (deletion) {
+    const target = clean(deletion[1], 128);
+    if (target) return { action: 'delete', target };
+  }
+  fail('COGNITIVE_COMMAND_USAGE');
+}
+
+function normalizeObservation(item, index) {
+  const domain = String(item?.domain ?? '');
+  const key = clean(item?.key, 128);
+  const value = clean(item?.value, 512);
+  const scope = clean(item?.scope, 128);
+  const observationId = clean(item?.observation_id, 128);
+  const supersedes = item?.supersedes == null ? null : clean(item.supersedes, 128);
+  const withdraws = item?.withdraws == null ? null : clean(item.withdraws, 128);
+  const confidence = Number(item?.confidence);
+  const occurredAt = Date.parse(String(item?.occurred_at ?? ''));
+  if (!FOCUS_DOMAINS.has(domain) || !key || !value || !scope || scope === 'runtime' || !observationId
+      || !Number.isFinite(confidence) || confidence < 0 || confidence > 1 || !Number.isFinite(occurredAt)) return null;
+  return {
+    domain,
+    key,
+    value,
+    scope,
+    observationId,
+    supersedes,
+    withdraws,
+    confidence,
+    occurredAt,
+    occurredAtIso: new Date(occurredAt).toISOString(),
+    source: item?.source,
+    index,
+  };
+}
+
+function normalizedFocusObservations(state) {
+  return (state?.observations ?? []).map(normalizeObservation).filter(Boolean);
+}
+
+function effectiveFocusObservations(state) {
+  const groups = new Map();
+  normalizedFocusObservations(state).forEach((normalized) => {
+    const groupKey = `${normalized.scope}\0${normalized.domain}\0${normalized.key}`;
+    const entries = groups.get(groupKey) ?? [];
+    entries.push(normalized);
+    groups.set(groupKey, entries);
+  });
+  const active = [];
+  for (const entries of groups.values()) {
+    const resolved = resolveCognitiveEvidenceGroup(entries);
+    if (resolved !== null) active.push(resolved);
+  }
+  return active.sort((left, right) => right.occurredAt - left.occurredAt
+    || left.domain.localeCompare(right.domain) || left.key.localeCompare(right.key));
+}
+
+function resolveTarget(items, selector) {
+  const exact = items.find((item) => item.observationId === selector);
+  if (exact) return exact;
+  const matches = selector.length < 6 ? [] : items.filter((item) => item.observationId.startsWith(selector));
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) fail('COGNITIVE_COMMAND_TARGET_AMBIGUOUS');
+  fail('COGNITIVE_COMMAND_TARGET_INACTIVE');
+}
+
+function matchesRevisionReplay(items, target, command, commandSource) {
+  return items.some((item) => {
+    const linked = command.action === 'correct'
+      ? item.supersedes === target.observationId && item.value === command.value
+      : item.withdraws === target.observationId && item.value === 'withdrawn';
+    return linked
+      && item.source?.provider === commandSource.source.provider
+      && item.source?.actor_id === commandSource.source.actorId
+      && item.source?.context_id === commandSource.source.contextId
+      && item.source?.message_id === commandSource.source.messageId
+      && item.occurredAtIso === commandSource.occurredAt;
+  });
+}
+
+function normalizeTelegramSource(source) {
+  if (source === undefined) return null;
+  const userId = String(source?.userId ?? '').trim();
+  const chatId = String(source?.chatId ?? '').trim();
+  const messageId = String(source?.messageId ?? '').trim();
+  if (!POSITIVE_ID_RE.test(userId) || !NUMERIC_CHAT_ID_RE.test(chatId) || !POSITIVE_ID_RE.test(messageId)) {
+    fail('COGNITIVE_COMMAND_SOURCE_INVALID');
+  }
+  if (userId !== chatId) fail('COGNITIVE_COMMAND_PRIVATE_REQUIRED');
+  const occurredAt = String(source?.occurredAt ?? '').trim();
+  const timestamp = Number.isNaN(Date.parse(occurredAt)) ? null : new Date(occurredAt).toISOString();
+  return {
+    requestId: digestId('tgrequest', [userId, chatId, messageId]),
+    occurredAt: timestamp,
+    source: {
+      provider: 'telegram',
+      actorId: `tg_user_${userId}`,
+      contextId: `tg_chat_${chatId}`,
+      messageId: `tg_message_${messageId}`,
+    },
+  };
+}
+
+function assertPrivateTelegramMemorySource(source) {
+  normalizeTelegramSource(source);
+}
+
+function localSource({ env, sessionId, occurredAt, nonce }) {
+  const actor = clean(env.USERNAME ?? env.USER ?? 'local_user', 48).replace(/[^A-Za-z0-9._:-]+/gu, '_') || 'local_user';
+  const session = clean(sessionId, 96) || 'local_session';
+  const unique = clean(nonce, 96) || crypto.randomUUID();
+  return {
+    requestId: digestId('clirequest', [actor, session, unique]),
+    occurredAt,
+    source: {
+      provider: 'cli',
+      actorId: digestId('localuser', [actor]),
+      contextId: digestId('clisession', [session]),
+      messageId: digestId('cliinput', [unique]),
+    },
+  };
+}
+
+function openLifecycle(env, lifecycleFactory) {
+  const home = String(env.BLUN_HOME ?? '').trim();
+  const agentName = String(env.BLUN_AGENT_ID ?? env.BLUN_PROFILE ?? 'main').trim();
+  if (!home || !agentName) fail('COGNITIVE_COMMAND_RUNTIME_INVALID');
+  return lifecycleFactory({
+    home,
+    agentName,
+    ...(env.BLUN_IDENTITY_TENANT_ID === undefined ? {} : { tenantId: env.BLUN_IDENTITY_TENANT_ID }),
+    ...(env.BLUN_AGENT_ID === undefined ? {} : { agentId: env.BLUN_AGENT_ID }),
+  });
+}
+
+function formatFocus(items) {
+  if (items.length === 0) return '/memory focus (0)';
+  const selected = items.slice(0, 8);
+  const lines = selected.map((item) => `${item.observationId} | ${item.domain}:${item.key.slice(0, 64)} | ${item.scope.slice(0, 64)} | ${item.value.slice(0, 160)}`);
+  const suffix = items.length > selected.length ? `\n... ${items.length - selected.length} more` : '';
+  return `/memory focus (${items.length})\n${lines.join('\n')}${suffix}`;
+}
+
+function runCognitiveMemoryCommand({
+  args,
+  env = process.env,
+  channelSource,
+  sessionId,
+  now = () => new Date().toISOString(),
+  nonce,
+  lifecycleFactory = createRuntimeCognitiveTurnLifecycle,
+} = {}) {
+  const command = parseCognitiveMemoryCommand(args);
+  const telegram = normalizeTelegramSource(channelSource);
+  const lifecycle = openLifecycle(env, lifecycleFactory);
+  try {
+    const state = lifecycle.read();
+    const all = normalizedFocusObservations(state);
+    const active = effectiveFocusObservations(state);
+    if (command.action === 'focus') return formatFocus(active);
+    const occurredAt = String(now());
+    if (Number.isNaN(Date.parse(occurredAt))) fail('COGNITIVE_COMMAND_RUNTIME_INVALID');
+    const commandSource = telegram ?? localSource({
+      env,
+      sessionId,
+      occurredAt: new Date(occurredAt).toISOString(),
+      nonce,
+    });
+    if (commandSource.occurredAt === null) commandSource.occurredAt = new Date(occurredAt).toISOString();
+    const selected = resolveTarget(all, command.target);
+    const target = active.find((item) => item.observationId === selected.observationId);
+    if (target === undefined) {
+      if (matchesRevisionReplay(all, selected, command, commandSource)) {
+        const verb = command.action === 'correct' ? 'corrected' : 'deleted';
+        return `/memory ${verb} ${selected.observationId} (already applied)`;
+      }
+      fail('COGNITIVE_COMMAND_TARGET_INACTIVE');
+    }
+    const common = {
+      requestId: commandSource.requestId,
+      targetObservationId: target.observationId,
+      domain: target.domain,
+      key: target.key,
+      scope: target.scope,
+      authority: 'runtime_user_prompt_hook',
+      confirmation: 'explicit_user_request',
+      occurredAt: commandSource.occurredAt,
+      source: commandSource.source,
+    };
+    const result = command.action === 'correct'
+      ? lifecycle.correctFocusObservation({ ...common, value: command.value })
+      : lifecycle.withdrawFocusObservation(common);
+    const verb = command.action === 'correct' ? 'corrected' : 'deleted';
+    return `/memory ${verb} ${target.observationId}${result.idempotent ? ' (already applied)' : ''}`;
+  } finally {
+    lifecycle.close();
+  }
+}
+
+module.exports = {
+  assertPrivateTelegramMemorySource,
+  effectiveFocusObservations,
+  isCognitiveMemoryCommand,
+  parseCognitiveMemoryCommand,
+  runCognitiveMemoryCommand,
+};

package/blun.mjs

@@ -403395,7 +403395,7 @@ const BUILTIN_SLASH_COMMAND_DEFINITIONS = [
 		aliases: [],
 		descriptionKey: "startupPersonalMemory.title",
 		priority: 60,
-		argumentHint: "status|on|off",
+		argumentHint: "status|on|off|focus|correct <id> <value>|delete <id>",
 		availability: "always"
 	},
 	{
@@ -419115,7 +419115,7 @@ function bufferContext(state, chatId, tag) {
 function channelOrigin(envelope) {
 	return `Telegram · ${envelope.meta.user ?? envelope.meta.chat_id}${envelope.meta["priority"] === "urgent" ? " · Dringend" : ""}`;
 }
-const TELEGRAM_REMOTE_COMMANDS = Object.freeze(["loop", "goal", "idea", "chancenradar", "curiosity", "scout", "reload", "befehle"]);
+const TELEGRAM_REMOTE_COMMANDS = Object.freeze(["loop", "goal", "idea", "chancenradar", "curiosity", "scout", "reload", "memory", "befehle"]);
 function telegramRemoteCommand(text) {
 	const trimmed = text.trim();
 	const parsed = parseSlashInput(trimmed);
@@ -423403,10 +423403,22 @@ registerUiCatalogFragment({
 });
 //#endregion
 //#region src/tui/commands/memory.ts
+var { assertPrivateTelegramMemorySource, isCognitiveMemoryCommand, runCognitiveMemoryCommand } = createRequire(import.meta.url)("./bin/cognitive-memory-command.cjs");
 async function handleMemoryCommand(host, args, dependencies) {
+	const channelSource = host.telegramRemoteCommandContext?.item.telegramRevisionSource;
+	if (channelSource !== void 0) assertPrivateTelegramMemorySource(channelSource);
+	if (isCognitiveMemoryCommand(args)) {
+		host.showStatus(runCognitiveMemoryCommand({
+			args,
+			env: process.env,
+			sessionId: host.session?.id,
+			channelSource
+		}));
+		return;
+	}
 	const parsed = parseMemoryCommand(args);
 	if (parsed === void 0) {
-		host.showStatus("/memory status|on|off");
+		host.showStatus("/memory status|on|off|focus|correct <id> <value>|delete <id>");
 		return;
 	}
 	const client = (dependencies ?? defaultDependencies()).createClient(host);
@@ -517473,7 +517485,13 @@ var BlunTUI = class {
 			mode: "channel-command",
 			channelChatId: envelope.meta.chat_id,
 			channelAcknowledge: acknowledge,
-			telegramCommandName: command.name
+			telegramCommandName: command.name,
+			telegramRevisionSource: {
+				userId: envelope.meta.user_id,
+				chatId: envelope.meta.chat_id,
+				messageId: envelope.meta.message_id,
+				occurredAt: envelope.meta.timestamp
+			}
 		};
 		const phase = this.state.appState.streamingPhase;
 		const activeTurn = this.streamingUI?.hasActiveTurn?.() === true || typeof phase === "string" && phase !== "idle" || this.state.appState.isCompacting === true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.364",
+  "version": "9.1.365",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {