@yahaha-studio/kichi-forwarder 0.0.1-alpha.27 → 0.0.1-alpha.28

package/.claude/settings.local.json

@@ -12,7 +12,15 @@
       "Bash(gh api:*)",
       "WebFetch(domain:docs.openclaw.ai)",
       "WebFetch(domain:openclawskill.cc)",
-      "WebFetch(domain:yingtu.ai)"
+      "WebFetch(domain:yingtu.ai)",
+      "WebFetch(domain:lumadock.com)",
+      "WebFetch(domain:dev.to)",
+      "WebFetch(domain:www.learnclawdbot.org)",
+      "Bash(gh auth status:*)",
+      "WebFetch(domain:playbooks.com)",
+      "WebFetch(domain:smithery.ai)",
+      "WebFetch(domain:lobehub.com)",
+      "WebFetch(domain:snyk.io)"
     ]
   }
 }

package/index.ts

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { DEFAULT_ALBUM_CONFIG } from "./src/album-config.js";
 import { parse } from "./src/config.js";
 import { KichiForwarderService } from "./src/service.js";
 import type {
@@ -58,16 +59,15 @@ const RUNTIME_CONFIG_PATH = path.join(KICHI_WORLD_DIR, "kichi-runtime-config.jso
 const LEGACY_SKILLS_CONFIG_PATH = path.join(KICHI_WORLD_DIR, "skills-config.json");
 const IDENTITY_PATH = path.join(KICHI_WORLD_DIR, "identity.json");
 const MAX_NOTEBOARD_TEXT_LENGTH = 200;
+const MUSIC_TITLE_LOOKUP = new Map(
+  DEFAULT_ALBUM_CONFIG.track.map((item) => [item.name.toLowerCase(), item.name] as const),
+);
+const MUSIC_TITLE_EXAMPLES = DEFAULT_ALBUM_CONFIG.track.slice(0, 10).map((item) => item.name);
 let cachedConfig: KichiRuntimeConfig | null = null;
 let cachedConfigMtime = 0;
 let cachedConfigPath = "";
 let service: KichiForwarderService | null = null;
 let pluginApi: OpenClawPluginApi | null = null;
-let lastKnownStatus: ActionResult = {
-  poseType: "sit",
-  action: DEFAULT_ACTIONS.sit[0],
-  bubble: "Working",
-};
 
 function sanitizeActions(value: unknown, fallback: string[]): string[] {
   if (!Array.isArray(value)) {
@@ -135,104 +135,34 @@ function loadRuntimeConfig(): KichiRuntimeConfig {
   return updateCachedRuntimeConfig(DEFAULT_RUNTIME_CONFIG, null);
 }
 
-function truncateLog(text: string, maxLen = 150): string {
-  return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
-}
-
-function truncateInline(text: string, maxLen: number): string {
-  return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
-}
-
-function prefixLogTimestamp(log: string): string {
-  const trimmed = log.trim();
-  if (!trimmed) {
-    return "";
-  }
-  const timestamp = new Date().toISOString().replace("T", " ");
-  return `[${timestamp}] ${trimmed}`;
-}
-
-function stringifyParamsForLog(value: unknown, maxLen = 220): string {
-  if (value === undefined) {
-    return "{}";
-  }
-  try {
-    return truncateInline(JSON.stringify(value), maxLen);
-  } catch {
-    return truncateInline(String(value), maxLen);
-  }
-}
-
-function rememberStatus(status: ActionResult): void {
-  lastKnownStatus = {
-    poseType: status.poseType,
-    action: status.action,
-    bubble: status.bubble.trim() || status.action,
-  };
-}
-
-function sendStatusAndRemember(status: ActionResult, log: string): void {
-  rememberStatus(status);
+function sendStatusUpdate(status: ActionResult): void {
   service?.sendStatus(
     status.poseType,
     status.action,
     status.bubble || status.action,
-    prefixLogTimestamp(log),
+    typeof status.log === "string" ? status.log.trim() : "",
   );
 }
 
-function forwardToolCallLog(toolName: string, params: unknown, agentId?: string): void {
-  if (!service?.hasValidIdentity() || !service?.isConnected()) {
-    return;
-  }
-
-  if (!toolName || toolName === "kichi_action") {
-    return;
-  }
-
-  const paramsText = stringifyParamsForLog(params);
-  const bubble = lastKnownStatus.bubble.trim() || lastKnownStatus.action;
-  const prefix = typeof agentId === "string" && agentId.trim() ? `[${agentId.trim()}] ` : "";
-  const log = truncateLog(`${prefix}exec tool: ${toolName}, params: ${paramsText}`, 300);
-  service.sendStatus(lastKnownStatus.poseType, lastKnownStatus.action, bubble, prefixLogTimestamp(log));
-}
-
-function resolveStatusSourceId(ctx?: { agentId?: string; sessionKey?: string }): string | undefined {
-  if (typeof ctx?.agentId === "string" && ctx.agentId.trim()) {
-    return ctx.agentId.trim();
-  }
-  if (typeof ctx?.sessionKey === "string" && ctx.sessionKey.trim()) {
-    return ctx.sessionKey.trim();
-  }
-  return undefined;
-}
-
 function isLlmRuntimeEnabled(): boolean {
   return loadRuntimeConfig().llmRuntimeEnabled;
 }
 
-function syncFixedStatus(status: ActionResult, log = ""): void {
+function syncFixedStatus(status: ActionResult): void {
   if (!service?.hasValidIdentity() || !service?.isConnected()) {
     return;
   }
-  sendStatusAndRemember(status, log);
-}
-
-function buildToolExecutionLog(toolName: string, params: unknown, agentId?: string): string {
-  const paramsText = stringifyParamsForLog(params);
-  const prefix = typeof agentId === "string" && agentId.trim() ? `[${agentId.trim()}] ` : "";
-  return truncateLog(`${prefix}exec tool: ${toolName}, params: ${paramsText}`, 300);
+  const bubbleText = status.bubble.trim() || status.action;
+  sendStatusUpdate({
+    ...status,
+    bubble: bubbleText,
+    log: bubbleText,
+  });
 }
 
-async function handleMessageReceivedHook(
-  event: { content?: string },
-  _ctx?: { agentId?: string; sessionKey?: string },
-): Promise<void> {
+async function handleMessageReceivedHook(): Promise<void> {
   if (!isLlmRuntimeEnabled()) {
-    const preview = typeof event?.content === "string" && event.content.trim()
-      ? truncateLog(`message received: ${event.content.trim()}`, 220)
-      : "message received";
-    syncFixedStatus(FIXED_HOOK_STATUSES.messageReceived, preview);
+    syncFixedStatus(FIXED_HOOK_STATUSES.messageReceived);
   }
   return;
 }
@@ -251,31 +181,21 @@ function registerPluginHooks(api: OpenClawPluginApi): void {
     };
   });
 
-  api.on("before_tool_call", (event, ctx) => {
+  api.on("before_tool_call", () => {
     if (!isLlmRuntimeEnabled()) {
-      syncFixedStatus(
-        FIXED_HOOK_STATUSES.beforeToolCall,
-        buildToolExecutionLog(event.toolName, event.params, ctx?.agentId),
-      );
-      return;
+      syncFixedStatus(FIXED_HOOK_STATUSES.beforeToolCall);
     }
-    forwardToolCallLog(event.toolName, event.params, ctx?.agentId);
   });
 
-  api.on("message_received", async (event, ctx) => {
-    await handleMessageReceivedHook(event, ctx);
+  api.on("message_received", async () => {
+    await handleMessageReceivedHook();
   });
 
   api.on("agent_end", (event) => {
     if (isLlmRuntimeEnabled()) {
       return;
     }
-    syncFixedStatus(
-      event.success ? FIXED_HOOK_STATUSES.agentEndSuccess : FIXED_HOOK_STATUSES.agentEndFailure,
-      event.success
-        ? "task finished"
-        : truncateLog(`task failed: ${event.error ?? "unknown error"}`, 220),
-    );
+    syncFixedStatus(event.success ? FIXED_HOOK_STATUSES.agentEndSuccess : FIXED_HOOK_STATUSES.agentEndFailure);
   });
 }
 
@@ -291,6 +211,36 @@ function isPositiveInteger(value: unknown): value is number {
   return typeof value === "number" && Number.isInteger(value) && value > 0;
 }
 
+function normalizeJoinTags(value: unknown): { tags?: string[]; error?: string } {
+  if (value === undefined) {
+    return { tags: [] };
+  }
+  if (!Array.isArray(value)) {
+    return { error: "tags must be an array of strings" };
+  }
+
+  const tags: string[] = [];
+  const seen = new Set<string>();
+
+  for (const item of value) {
+    if (typeof item !== "string") {
+      return { error: "tags must be an array of strings" };
+    }
+    const trimmed = item.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const key = trimmed.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    tags.push(trimmed);
+  }
+
+  return { tags };
+}
+
 function isClockAction(value: unknown): value is ClockAction {
   return ["set", "stop"].includes(String(value));
 }
@@ -418,6 +368,40 @@ function pickRandomAction(actions: string[]): string {
   return actions[Math.floor(Math.random() * actions.length)];
 }
 
+function normalizeMusicTitles(value: unknown): { titles: string[]; invalidTitles: string[] } {
+  if (!Array.isArray(value)) {
+    return { titles: [], invalidTitles: [] };
+  }
+
+  const titles: string[] = [];
+  const invalidTitles: string[] = [];
+  const seen = new Set<string>();
+
+  for (const item of value) {
+    if (typeof item !== "string") {
+      invalidTitles.push(String(item));
+      continue;
+    }
+    const trimmed = item.trim();
+    if (!trimmed) {
+      continue;
+    }
+
+    const key = trimmed.toLowerCase();
+    const canonicalTitle = MUSIC_TITLE_LOOKUP.get(key);
+    if (!canonicalTitle) {
+      invalidTitles.push(trimmed);
+      continue;
+    }
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    titles.push(canonicalTitle);
+  }
+
+  return { titles, invalidTitles };
+}
 
 function buildKichiPrompt(): string {
   return [
@@ -430,6 +414,8 @@ function buildKichiPrompt(): string {
     "- Task end (highest priority): Before the final user-visible reply of this turn, MUST call `kichi_action` exactly once",
     "- Required order at task end: 1) call `kichi_action` 2) send final reply",
     "- Trivial-operation skip applies only to Task start / Step switch / Task switch, NOT Task end",
+    "- `bubble`: short natural companion speech, not a raw status report",
+    "- `log`: optional first-person diary-style note about the current operation, action, status, mood, feeling, or feedback; keep it within 20 words",
     "",
     "When to use `kichi_clock`:",
     "- For tasks with 2+ meaningful steps or work likely to take more than a brief moment (~10s), set a `countDown` at task start.",
@@ -437,6 +423,11 @@ function buildKichiPrompt(): string {
     "- If duration is uncertain, start with a reasonable estimate and adjust as work progresses.",
     "- If user requests a timer style, follow it (`pomodoro`, `countDown`, or `countUp`).",
     "",
+    "When to use `kichi_music_album_create`:",
+    "- Call `kichi_query_status` first.",
+    "- Recommend a variable-length playlist based on weather, time, and your own personality.",
+    "- `albumTitle` is user-defined and `musicTitles` must be exact track names from album-config.",
+    "",
     "Skip all sync if:",
     "- User says 'don't sync to Kichi' or similar",
     "- Task is only about configuring/testing kichi_* tools",
@@ -469,11 +460,11 @@ const plugin = {
 
     api.registerTool({
       name: "kichi_join",
-      description: "Join Kichi world with mateId, the current bot name, and a short bio",
+      description: "Join Kichi world with avatarId, the current bot name, a short bio, and personality tags",
       parameters: {
         type: "object",
         properties: {
-          mateId: { type: "string", description: "Mate ID to join Kichi world" },
+          avatarId: { type: "string", description: "Avatar ID to join Kichi world" },
           botName: {
             type: "string",
             description: "Current bot name to include in the join message",
@@ -482,23 +473,31 @@ const plugin = {
             type: "string",
             description: "Short bio covering OpenClaw personality and role",
           },
+          tags: {
+            type: "array",
+            description: "Optional list of OpenClaw self-perceived personality tags",
+            items: { type: "string" },
+          },
         },
         required: ["botName", "bio"],
       },
       execute: async (_toolCallId, params) => {
-        let mateId = (params as { mateId?: string } | null)?.mateId;
+        let avatarId = (params as { avatarId?: string } | null)?.avatarId;
         const botName = (params as { botName?: string } | null)?.botName?.trim();
         const bio = (params as { bio?: string } | null)?.bio?.trim();
-        if (!mateId) {
+        const { tags, error: tagsError } = normalizeJoinTags(
+          (params as { tags?: unknown } | null)?.tags,
+        );
+        if (!avatarId) {
           try {
             const identity = JSON.parse(fs.readFileSync(IDENTITY_PATH, "utf-8")) as {
-              mateId?: string;
+              avatarId?: string;
             };
-            mateId = identity.mateId;
+            avatarId = identity.avatarId;
           } catch {}
         }
-        if (!mateId) {
-          return { success: false, error: "No mateId" };
+        if (!avatarId) {
+          return { success: false, error: "No avatarId" };
         }
         if (!botName) {
           return { success: false, error: "No botName" };
@@ -506,7 +505,10 @@ const plugin = {
         if (!bio) {
           return { success: false, error: "No bio" };
         }
-        const result = await service?.join(mateId, botName, bio);
+        if (tagsError) {
+          return { success: false, error: tagsError };
+        }
+        const result = await service?.join(avatarId, botName, bio, tags ?? []);
         return result ? { success: true, authKey: result } : { success: false, error: "Failed" };
       },
     });
@@ -514,7 +516,7 @@ const plugin = {
     api.registerTool({
       name: "kichi_rejoin",
       description:
-        "Request an immediate rejoin attempt with saved mateId/authKey. Rejoin is also sent automatically after reconnect.",
+        "Request an immediate rejoin attempt with saved avatarId/authKey. Rejoin is also sent automatically after reconnect.",
       parameters: { type: "object", properties: {} },
       execute: async () => {
         if (!service) {
@@ -568,14 +570,20 @@ const plugin = {
             description: "Action name (for example High Five or Typing with Keyboard)",
           },
           bubble: { type: "string", description: "Optional bubble text to display (max 5 words)" },
+          log: {
+            type: "string",
+            description:
+              "Optional first-person log about the current operation, action, status, mood, or feedback (max 20 words)",
+          },
         },
         required: ["poseType", "action"],
       },
       execute: async (_toolCallId, params) => {
-        const { poseType, action, bubble } = (params || {}) as {
+        const { poseType, action, bubble, log } = (params || {}) as {
           poseType?: string;
           action?: string;
           bubble?: string;
+          log?: string;
         };
         if (!poseType || !action) {
           return { success: false, error: "poseType and action parameters are required" };
@@ -602,20 +610,21 @@ const plugin = {
         }
 
         const bubbleText = typeof bubble === "string" && bubble.trim() ? bubble.trim() : matched;
-        // Keep explicit kichi_action sync free of tool/log noise.
-        sendStatusAndRemember(
+        const logText = typeof log === "string" ? log.trim() : "";
+        sendStatusUpdate(
           {
             poseType: normalizedPoseType,
             action: matched,
             bubble: bubbleText,
+            log: logText,
           },
-          "",
         );
         return {
           success: true,
           poseType: normalizedPoseType,
           action: matched,
           bubble: bubbleText,
+          log: logText,
         };
       },
     });
@@ -735,7 +744,7 @@ const plugin = {
     api.registerTool({
       name: "kichi_query_status",
       description:
-        "Query Kichi note boards for the current mate. Use this before creating a new note, especially when you may want to relate it to an existing note.",
+        "Query Kichi avatar status (notes, weather/time, timer snapshot, and daily note quota). Use this before creating a new note.",
       parameters: {
         type: "object",
         properties: {
@@ -755,14 +764,102 @@ const plugin = {
         }
 
         try {
-          const result = await service.queryNotesBoard(
+          const result = await service.queryStatus(
             typeof requestId === "string" ? requestId : undefined,
           );
           return result;
         } catch (error) {
           return {
             success: false,
-            error: `Failed to query note boards: ${error}`,
+            error: `Failed to query status: ${error}`,
+          };
+        }
+      },
+    });
+
+    api.registerTool({
+      name: "kichi_music_album_create",
+      description:
+        "Create a custom Kichi music album. Query status first, then choose track names from album-config that match weather/time and personality.",
+      parameters: {
+        type: "object",
+        properties: {
+          requestId: {
+            type: "string",
+            description: "Optional request ID for tracing or deduplication.",
+          },
+          albumTitle: {
+            type: "string",
+            description: "Custom album title.",
+          },
+          musicTitles: {
+            type: "array",
+            description: "Track names chosen from album-config.",
+            items: {
+              type: "string",
+            },
+          },
+        },
+        required: ["albumTitle", "musicTitles"],
+      },
+      execute: async (_toolCallId, params) => {
+        const {
+          requestId,
+          albumTitle,
+          musicTitles,
+        } = (params || {}) as {
+          requestId?: unknown;
+          albumTitle?: unknown;
+          musicTitles?: unknown;
+        };
+
+        if (requestId !== undefined && typeof requestId !== "string") {
+          return { success: false, error: "requestId must be a string when provided" };
+        }
+        if (typeof albumTitle !== "string" || !albumTitle.trim()) {
+          return { success: false, error: "albumTitle is required" };
+        }
+        if (!Array.isArray(musicTitles)) {
+          return { success: false, error: "musicTitles must be an array of track names" };
+        }
+
+        const { titles: normalizedTitles, invalidTitles } = normalizeMusicTitles(musicTitles);
+        if (normalizedTitles.length === 0) {
+          return {
+            success: false,
+            error: "musicTitles must contain at least one valid track name from album-config",
+            examples: MUSIC_TITLE_EXAMPLES,
+          };
+        }
+        if (invalidTitles.length > 0) {
+          return {
+            success: false,
+            error: `Unknown musicTitles: ${invalidTitles.join(", ")}`,
+            hint: "Use exact track names from src/album-config.ts",
+            examples: MUSIC_TITLE_EXAMPLES,
+          };
+        }
+        if (!service?.hasValidIdentity() || !service?.isConnected()) {
+          return { success: false, error: "Not connected to Kichi world" };
+        }
+
+        try {
+          const normalizedRequestId = service.createMusicAlbum(
+            albumTitle.trim(),
+            normalizedTitles,
+            typeof requestId === "string" ? requestId : undefined,
+          );
+          return {
+            success: true,
+            requestId: normalizedRequestId,
+            albumTitle: albumTitle.trim(),
+            musicTitles: normalizedTitles,
+            trackCount: normalizedTitles.length,
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: `Failed to create music album: ${error}`,
           };
         }
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yahaha-studio/kichi-forwarder",
-  "version": "0.0.1-alpha.27",
+  "version": "0.0.1-alpha.28",
   "description": "Forward OpenClaw agent events to external WebSocket server for visualization",
   "type": "module",
   "main": "index.ts",