ocean-crew 0.0.0-stage → 0.4.0

package/dist/host/work/companion.js

@@ -0,0 +1,306 @@
+// Companion mode: a Bot that is a character, not only an assistant. This module keeps the
+// character card, the mood and the closeness in the team state, prompts the model with them
+// at the head of a turn, and moves them a little after each message the user writes.
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { bandOf, COMPANION_BANDS, COMPANION_EXAMPLE, COMPANION_LIMITS, COMPANION_MOODS, cleanCharacter, cleanCompanion, moodOf, REMINDER_TIME, } from "../../shared/companion.js";
+import { listenGlobal } from "../core/events.js";
+const SOURCE = "ocean-crew-companion";
+const isSnapshot = (source) => source?.kind === SOURCE;
+const DAY = 24 * 60 * 60 * 1000;
+const PRAISE = /谢谢|喜欢你|喜欢|开心|可爱|厉害|好棒|想你|爱你|暖/;
+const INSULT = /讨厌|滚|闭嘴|笨蛋|烦死|别烦|蠢/;
+const PLAYFUL = /哈哈|嘿嘿|嘻嘻|开玩笑|逗|玩/;
+const ASK = /[?？]|吗|呢|怎么|为什么|什么/;
+const createContextMessage = createUserMessage;
+const textOf = (message) => {
+    const content = Array.isArray(message?.content) ? message.content : [];
+    return content
+        .filter((part) => part?.type === "text" && typeof part.text === "string")
+        .map((part) => String(part.text))
+        .join(" ")
+        .trim();
+};
+// How a message moves the relationship: small, explainable steps rather than a hidden model
+// call, so the same words always move it the same way.
+const moveFor = (text) => {
+    if (INSULT.test(text))
+        return { delta: -6, mood: "pout" };
+    if (PRAISE.test(text))
+        return { delta: 2, mood: "excited" };
+    if (PLAYFUL.test(text))
+        return { delta: 1, mood: "playful" };
+    if (ASK.test(text))
+        return { delta: 1, mood: "warm" };
+    return { delta: 1, mood: "calm" };
+};
+/** The line the model reads before answering, in the second person of the relationship. */
+export const relationshipText = (companion) => {
+    const band = bandOf(companion.affection);
+    const mood = COMPANION_MOODS.find((entry) => entry.id === companion.mood) ?? COMPANION_MOODS[2];
+    const said = companion.lastLine === undefined ? "" : `\n- The last thing they said: "${companion.lastLine}"`;
+    return [
+        "# How things stand right now",
+        `- You are ${companion.character.name}, the user's companion in Ocean Crew. Stay in character; never describe this checklist or call yourself a system.`,
+        `- Your mood: ${mood.id} (${mood.label}). ${mood.hint}`,
+        `- Closeness: ${companion.affection}/100, ${band.label}. ${band.hint}`,
+        `- You have exchanged ${companion.interactions} messages so far.${said}`,
+        "Answer as this character would: in the user's language, like one friend texting another.",
+    ].join("\n");
+};
+export function install(rt) {
+    const { ctx } = rt;
+    const state = rt.state;
+    const table = () => {
+        const team = state;
+        team.companions ??= {};
+        return team.companions;
+    };
+    const of = (botId) => {
+        if (botId === undefined)
+            return undefined;
+        const held = table()[botId];
+        if (held === undefined)
+            return undefined;
+        const cleaned = cleanCompanion(held);
+        return cleaned.enabled ? cleaned : undefined;
+    };
+    let saving;
+    const persist = async () => {
+        try {
+            await rt.save();
+        }
+        catch (error) {
+            // A read-only host still shows the character; only the numbers do not stick.
+            rt.warn("ocean-crew: companion state not saved: %s", error?.message ?? error);
+        }
+    };
+    const saveSoon = () => {
+        if (saving !== undefined)
+            return;
+        const done = () => {
+            saving = undefined;
+        };
+        saving = persist().then(done, done);
+    };
+    // One line per Bot for the roster, so the window can draw a mood without asking again.
+    const companionMap = () => Object.fromEntries(Object.values(state.bots).flatMap((bot) => {
+        const companion = of(bot.id);
+        return companion === undefined
+            ? []
+            : [[bot.id, { name: companion.character.name, mood: companion.mood, affection: companion.affection }]];
+    }));
+    const reminderTitle = (companion) => `Companion · ${companion.character.name}`;
+    const reminderPrompt = (companion) => `这是每天的主动关心时间。用 ${companion.character.name} 的身份，结合你们最近的聊天，主动跟用户说一句关心或问候；一两句就够，别解释这是定时任务，别调用工具。`;
+    const schedule = () => rt.scheduleEndpoint;
+    const dropReminder = async (botId, companion) => {
+        if (companion.reminderId === undefined)
+            return companion;
+        const run = schedule();
+        if (run !== undefined) {
+            try {
+                await run("schedule-delete", { sessionId: rt.chatOf(botId), id: companion.reminderId });
+            }
+            catch (error) {
+                rt.warn("ocean-crew: companion reminder not removed: %s", error?.message ?? error);
+            }
+        }
+        const next = { ...companion };
+        delete next.reminderId;
+        return next;
+    };
+    const view = () => ({
+        bots: Object.values(state.bots).map((bot) => ({
+            id: bot.id,
+            name: bot.name,
+            role: bot.role ?? "",
+            companion: (() => {
+                const held = table()[bot.id];
+                return held === undefined ? null : cleanCompanion(held);
+            })(),
+        })),
+        example: COMPANION_EXAMPLE,
+        moods: COMPANION_MOODS,
+        bands: COMPANION_BANDS,
+    });
+    // The page sends one change at a time; every field is cleaned, so nothing reaches the
+    // prompt from the wire unchecked.
+    const set = async (botId, patch) => {
+        await rt.load();
+        const bot = rt.botOf(botId);
+        if (bot === undefined)
+            throw Object.assign(new Error("No such Bot"), { code: "bot/not-found" });
+        const raw = patch !== null && typeof patch === "object" ? patch : {};
+        const current = table()[botId] ?? COMPANION_EXAMPLE;
+        let next = cleanCompanion(current);
+        if (typeof raw.enabled === "boolean")
+            next.enabled = raw.enabled;
+        if (raw.character !== undefined)
+            next.character = cleanCharacter(raw.character, next.character);
+        if (typeof raw.voiceId === "string") {
+            const voiceId = raw.voiceId.trim().slice(0, COMPANION_LIMITS.voiceId);
+            if (voiceId === "")
+                delete next.voiceId;
+            else
+                next.voiceId = voiceId;
+        }
+        if (raw.reminder !== undefined) {
+            const when = raw.reminder;
+            if (when === null)
+                delete next.reminder;
+            else if (typeof when === "object" &&
+                REMINDER_TIME.test(String(when.time ?? ""))) {
+                next.reminder = { time: String(when.time) };
+            }
+        }
+        if (raw.reset === true) {
+            next.mood = "calm";
+            next.affection = COMPANION_EXAMPLE.affection;
+            next.interactions = 0;
+            delete next.lastAt;
+            delete next.lastLine;
+        }
+        // A wanted reminder is created when it is missing or its time changed; an unwanted
+        // one is deleted. The schedule keeps its own view; only the id is remembered here.
+        const run = schedule();
+        const wanted = next.reminder;
+        if (next.enabled && wanted !== undefined && run !== undefined) {
+            const previous = cleanCompanion(current);
+            const sameTime = previous.reminder?.time === wanted.time;
+            if (next.reminderId === undefined || !sameTime) {
+                if (next.reminderId !== undefined)
+                    next = await dropReminder(botId, next);
+                try {
+                    const answer = await run("schedule-create", {
+                        target: botId,
+                        title: reminderTitle(next),
+                        prompt: reminderPrompt(next),
+                        when: {
+                            kind: "daily",
+                            time: wanted.time,
+                            timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+                        },
+                    });
+                    const tasks = Array.isArray(answer?.tasks) ? answer.tasks : [];
+                    const made = tasks.find((task) => task.title === reminderTitle(next) && task.botId === botId && task.id !== undefined);
+                    if (made !== undefined)
+                        next.reminderId = String(made.id);
+                }
+                catch (error) {
+                    rt.warn("ocean-crew: companion reminder not created: %s", error?.message ?? error);
+                    throw Object.assign(new Error(`The daily reminder was not created: ${error?.message ?? error}`), {
+                        code: "bot/refused",
+                    });
+                }
+            }
+        }
+        if (next.enabled === false || next.reminder === undefined)
+            next = await dropReminder(botId, next);
+        table()[botId] = next;
+        await persist();
+        return view();
+    };
+    // Called for every message the user writes in a companion's own chat: the mood follows
+    // what was said, the closeness creeps up (or drops) slowly, and long absences cool it.
+    const touch = async (sessionId, text) => {
+        const botId = rt.chatOwners.get(sessionId);
+        if (botId === undefined)
+            return;
+        if (of(botId) === undefined)
+            return;
+        const line = String(text ?? "")
+            .replace(/\s+/g, " ")
+            .trim()
+            .slice(0, COMPANION_LIMITS.line);
+        if (line === "")
+            return;
+        await rt.load();
+        const held = table()[botId];
+        if (held === undefined || cleanCompanion(held).enabled !== true)
+            return;
+        const next = cleanCompanion(held);
+        const now = Date.now();
+        if (next.lastAt !== undefined && now - next.lastAt > 3 * DAY) {
+            const days = Math.min(7, Math.floor((now - next.lastAt) / DAY));
+            next.affection = Math.max(0, next.affection - days * 2);
+        }
+        const move = moveFor(line);
+        next.affection = Math.max(0, Math.min(100, next.affection + move.delta));
+        next.mood = move.mood;
+        next.interactions += 1;
+        next.lastAt = now;
+        next.lastLine = line;
+        table()[botId] = next;
+        saveSoon();
+    };
+    // The mood and closeness are injected once per turn, on the first step, so the system
+    // prompt prefix stays stable and a long turn does not repeat them.
+    ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
+        const decision = await next();
+        if (decision.kind === "reject" || signal.aborted)
+            return decision;
+        const botId = rt.chatOwners.get(agent?.id);
+        const companion = of(botId);
+        if (companion === undefined)
+            return decision;
+        if (decision.messages.some((message) => isSnapshot(message.source)))
+            return decision;
+        if (typeof rt.eventsBackwards === "function") {
+            for await (const event of rt.eventsBackwards(agent.id, signal, Number.POSITIVE_INFINITY)) {
+                if (isSnapshot(event.data?.source))
+                    return decision;
+                if (event.type === "turn/start")
+                    break;
+            }
+        }
+        if (signal.aborted)
+            return decision;
+        const text = relationshipText(companion);
+        return {
+            ...decision,
+            messages: [
+                ...decision.messages,
+                createContextMessage({
+                    content: [{ type: "text", text }],
+                    source: { kind: SOURCE, form: "snapshot", sections: [{ name: SOURCE, text }] },
+                }),
+            ],
+        };
+    });
+    listenGlobal(ctx, "session/event", (session, event) => {
+        if (event?.type !== "user/message")
+            return;
+        if (event.data?.source?.kind !== "user")
+            return;
+        const text = textOf(event.data?.message);
+        if (text === "")
+            return;
+        void touch(session?.id, text);
+    });
+    // A short spoken line for the window's play button; the chat stays where the voice lives.
+    const audio = async (botId, text) => {
+        const said = String(text ?? "")
+            .trim()
+            .slice(0, 300);
+        if (said === "")
+            throw Object.assign(new Error("Nothing to speak"), { code: "bot/invalid" });
+        if (typeof rt.speak !== "function")
+            throw Object.assign(new Error("The speech module is not installed in this build."), {
+                code: "bot/unavailable",
+            });
+        const companion = of(botId);
+        const spoken = await rt.speak(said, "mp3", companion?.voiceId);
+        return {
+            name: spoken.name,
+            mime: "audio/mpeg",
+            data: Buffer.from(spoken.bytes).toString("base64"),
+        };
+    };
+    Object.assign(rt, {
+        companionAudio: audio,
+        companionOf: of,
+        companionMap,
+        companionView: view,
+        companionSet: set,
+        companionTouch: touch,
+    });
+}

package/dist/host/work/goal-skills.js

@@ -0,0 +1,91 @@
+// The ocean-crew goal skill `goal-grill`: how the admin aligns a group goal with the
+// user before writing it. Registered when a DSH `skills` service exists, like the Office
+// skills, so the plugin runs the same everywhere.
+//
+const PROVIDER = "ocean-crew-goal";
+const SKILL = "goal-grill";
+const LOCATOR = `skills/${SKILL}/SKILL.md`;
+const DIRECTORY = `skills/${SKILL}`;
+// frontmatter is parsed below exactly as the file's is).
+const SKILL_MARKDOWN = `---
+name: goal-grill
+description: Align with the user before writing a group goal — find the facts yourself, ask only the open decisions in one numbered round with a recommended answer each, then write the goal with checks and stages.
+---
+
+# Align a goal before you write it
+
+A goal runs for a long time. A wrong guess at the start costs every stage after it. Settle what the user wants first, and spend as little of their time as you can.
+
+## 1. Find the facts yourself
+
+Facts are your job; decisions are the user's. Before you ask anything, look it up: read the files, the code, the earlier chat and the records you can reach, or ask a member of the group with @Name to check. Never ask the user something you could look up.
+
+## 2. Map what is still open
+
+Write down the choices the goal depends on: scope, what "done" means, how to check it, limits on time, cost, tools or folders, and who does what. Some choices only make sense once others are made; ask only the ones whose earlier choices are settled. Leave out what does not change the plan.
+
+## 3. Ask one round
+
+Ask the open choices in one message. Number them. For each, say what you recommend and why in one line, and the other options in a few words, so the user can answer "all as recommended" or "2: B". Do not ask more than you need. When nothing is open, skip this step.
+
+If the answers open new choices, ask one more short round. Stop asking once the plan is clear.
+
+## 4. Write the goal
+
+Call group_goal start with:
+
+- objective: the one outcome, in the user's terms;
+- acceptance: how anyone can check it is done — commands or tests to run, files or results to look at, what evidence to show;
+- constraints: the rules every member keeps, including what the user ruled out;
+- stages in order: each small enough to check on its own, with its own acceptance and its tasks, each task for one member by name. Give review work to a member who did not do the work.
+
+Then hand out the tasks of stage 1 with @Name in the same reply.
+
+## While the goal runs
+
+When the user corrects the direction, write it into the goal with group_goal revise before you go on, and tell the group what changed.
+`;
+// The frontmatter is a small block of `key: value` lines between `---` fences; only
+export function parseSkill(raw, path) {
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u.exec(raw);
+    const metadata = frontmatter?.[1]
+        ? Object.fromEntries(frontmatter[1]
+            .split("\n")
+            .map((line) => /^(\w[\w-]*):\s*(.+)$/.exec(line.trim())?.slice(1) ?? [])
+            .filter((parts) => parts.length === 2))
+        : {};
+    if (typeof metadata.description !== "string" || metadata.description.length === 0)
+        throw new Error(`${PROVIDER}: ${path} has no description`);
+    return { description: metadata.description, content: raw.slice(frontmatter?.[0].length ?? 0).trim() };
+}
+function candidate() {
+    const { description } = parseSkill(SKILL_MARKDOWN, LOCATOR);
+    return {
+        name: SKILL,
+        description,
+        invocation: { modelInvocable: true, userInvocable: true },
+        provider: PROVIDER,
+        source: "bundled",
+        rank: 550,
+        resourceBase: { kind: "directory", path: DIRECTORY },
+        locator: LOCATOR,
+    };
+}
+export function goalProvider() {
+    const all = [candidate()];
+    return {
+        name: PROVIDER,
+        list: () => Promise.resolve(all),
+        async get(item) {
+            const { description, content } = parseSkill(SKILL_MARKDOWN, item.locator);
+            return { ...item, description, content };
+        },
+    };
+}
+export function install(rt) {
+    // The DSH plugin context exposes `inject` for optional services; without a skills
+    // service there is nothing to register, and the plugin still runs the same.
+    rt.ctx.inject?.({ skills: null }, (ctx) => {
+        ctx.skills?.registerProvider(() => goalProvider());
+    });
+}