mono-pilot 0.2.10 → 0.2.13

package/dist/src/extensions/commands/image-model.js

@@ -0,0 +1,214 @@
+import { DynamicBorder } from "@mariozechner/pi-coding-agent";
+import { Container, SelectList, Text } from "@mariozechner/pi-tui";
+import { loadMonoPilotConfigObject, saveMonoPilotConfigObject } from "../../config/mono-pilot.js";
+import { applyImageGenSelection, extractImageGenConfig } from "../../config/image-gen.js";
+const USAGE = [
+    "Usage:",
+    "  /image-model            (open interactive picker)",
+    "  /image-model list",
+    "  /image-model use <provider> [modelId]",
+    "  /image-model <provider> [modelId]",
+].join("\n");
+export function registerImageModelCommands(pi) {
+    pi.registerCommand("image-model", {
+        description: "Switch image generation model/provider from config.json",
+        handler: async (args, ctx) => {
+            let config;
+            try {
+                config = await loadMonoPilotConfigObject();
+            }
+            catch (error) {
+                notify(ctx, error.message, "error");
+                return;
+            }
+            const { providers, selection } = extractImageGenConfig(config);
+            const providerNames = Object.keys(providers);
+            if (providerNames.length === 0) {
+                notify(ctx, "No imageGenProviders configured in ~/.mono-pilot/config.json.", "warning");
+                return;
+            }
+            const trimmedArgs = args.trim();
+            if (!trimmedArgs) {
+                if (!ctx.hasUI) {
+                    notify(ctx, `Interactive picker unavailable.\n${USAGE}`, "warning");
+                    return;
+                }
+                const entries = buildEntries(providers);
+                if (entries.length === 0) {
+                    notify(ctx, "No image models configured.", "warning");
+                    return;
+                }
+                const selected = await pickImageModel(ctx, entries, selection.provider, selection.model);
+                if (!selected) {
+                    notify(ctx, "Image model selection cancelled.", "info");
+                    return;
+                }
+                applyImageGenSelection(config, {
+                    provider: selected.provider,
+                    model: selected.model,
+                });
+                try {
+                    await saveMonoPilotConfigObject(config);
+                }
+                catch (error) {
+                    notify(ctx, error.message, "error");
+                    return;
+                }
+                const modelSuffix = selected.model ? ` (${selected.model})` : "";
+                notify(ctx, `Image model set to ${selected.provider}${modelSuffix}.`, "info");
+                return;
+            }
+            const command = parseCommand(args);
+            switch (command.cmd) {
+                case "list": {
+                    notify(ctx, formatProviders(providers, selection.provider, selection.model), "info");
+                    return;
+                }
+                case "use": {
+                    if (!command.provider) {
+                        notify(ctx, `Missing provider.\n${USAGE}`, "warning");
+                        return;
+                    }
+                    const providerConfig = providers[command.provider];
+                    if (!providerConfig) {
+                        notify(ctx, `Unknown provider: ${command.provider}.\n${formatProviders(providers)}`, "warning");
+                        return;
+                    }
+                    const nextModel = resolveModelSelection(providerConfig, command.model, command.provider === selection.provider ? selection.model : undefined);
+                    if (command.model && providerConfig.models?.length && nextModel !== command.model) {
+                        notify(ctx, `Unknown model for ${command.provider}: ${command.model}.\n${formatModels(providerConfig)}`, "warning");
+                        return;
+                    }
+                    applyImageGenSelection(config, {
+                        provider: command.provider,
+                        model: nextModel,
+                    });
+                    try {
+                        await saveMonoPilotConfigObject(config);
+                    }
+                    catch (error) {
+                        notify(ctx, error.message, "error");
+                        return;
+                    }
+                    const modelSuffix = nextModel ? ` (${nextModel})` : "";
+                    notify(ctx, `Image model set to ${command.provider}${modelSuffix}.`, "info");
+                    return;
+                }
+                case "current":
+                default: {
+                    notify(ctx, formatProviders(providers, selection.provider, selection.model, true), "info");
+                    return;
+                }
+            }
+        },
+    });
+}
+function parseCommand(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return { cmd: "current" };
+    const parts = trimmed.split(/\s+/);
+    const [first, second, third] = parts;
+    if (first === "list") {
+        return { cmd: "list" };
+    }
+    if (first === "use") {
+        return { cmd: "use", provider: second, model: third };
+    }
+    return { cmd: "use", provider: first, model: second };
+}
+function resolveModelSelection(provider, modelOverride, currentModel) {
+    if (modelOverride)
+        return modelOverride;
+    if (currentModel)
+        return currentModel;
+    return provider.models?.[0]?.id;
+}
+function buildEntries(providers) {
+    const entries = [];
+    for (const [provider, config] of Object.entries(providers)) {
+        const models = config.models ?? [];
+        if (models.length === 0) {
+            entries.push({ provider, label: provider });
+            continue;
+        }
+        for (const model of models) {
+            const label = model.name ? `${provider} · ${model.name}` : `${provider} · ${model.id}`;
+            entries.push({ provider, model: model.id, label });
+        }
+    }
+    return entries;
+}
+async function pickImageModel(ctx, entries, currentProvider, currentModel) {
+    const items = entries.map((entry, index) => {
+        const isCurrent = entry.provider === currentProvider && entry.model === currentModel;
+        return {
+            value: String(index),
+            label: isCurrent ? `${entry.label} (current)` : entry.label,
+            description: entry.model ? entry.model : "(provider default)",
+        };
+    });
+    const currentIndex = entries.findIndex((entry) => entry.provider === currentProvider && entry.model === currentModel);
+    const result = await ctx.ui.custom((tui, theme, _kb, done) => {
+        const container = new Container();
+        container.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+        container.addChild(new Text(theme.fg("accent", theme.bold("Select Image Model")), 1, 0));
+        const selectList = new SelectList(items, Math.min(items.length, 10), {
+            selectedPrefix: (text) => theme.fg("accent", text),
+            selectedText: (text) => theme.fg("accent", text),
+            description: (text) => theme.fg("muted", text),
+            scrollInfo: (text) => theme.fg("dim", text),
+            noMatch: (text) => theme.fg("warning", text),
+        });
+        if (currentIndex >= 0) {
+            selectList.setSelectedIndex(currentIndex);
+        }
+        selectList.onSelect = (item) => done(item.value);
+        selectList.onCancel = () => done(null);
+        container.addChild(selectList);
+        container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc cancel"), 1, 0));
+        container.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+        return {
+            render: (width) => container.render(width),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => {
+                selectList.handleInput(data);
+                tui.requestRender();
+            },
+        };
+    });
+    if (!result)
+        return undefined;
+    const index = Number(result);
+    return Number.isFinite(index) ? entries[index] : undefined;
+}
+function formatModels(provider) {
+    const models = provider.models ?? [];
+    if (models.length === 0) {
+        return "No models configured for this provider.";
+    }
+    const lines = models.map((model) => {
+        const label = model.name ? `${model.id} (${model.name})` : model.id;
+        return `  - ${label}`;
+    });
+    return `Available models:\n${lines.join("\n")}`;
+}
+function formatProviders(providers, currentProvider, currentModel, includeUsage = false) {
+    const lines = Object.entries(providers).map(([name, provider]) => {
+        const label = currentProvider === name ? "*" : "-";
+        const modelLabel = currentProvider === name && currentModel ? ` (${currentModel})` : "";
+        const models = provider.models?.map((model) => model.id).join(", ") ?? "(no models)";
+        return `${label} ${name}${modelLabel}: ${models}`;
+    });
+    const header = includeUsage ? `${USAGE}\n\nConfigured providers:` : "Configured providers:";
+    return `${header}\n${lines.join("\n")}`;
+}
+function notify(ctx, message, level) {
+    if (ctx.hasUI && ctx.ui?.notify) {
+        ctx.ui.notify(message, level);
+    }
+    else {
+        const prefix = level === "error" ? "[error]" : level === "warning" ? "[warn]" : "[info]";
+        console.log(`${prefix} ${message}`);
+    }
+}

package/dist/src/extensions/game/bus-injection.js

@@ -0,0 +1,47 @@
+export function createGameBusMessageInjector(pi, options) {
+    let pending = [];
+    let timer = null;
+    const seenSeq = new Set();
+    const seenQueue = [];
+    function markSeen(seq) {
+        if (seenSeq.has(seq))
+            return false;
+        seenSeq.add(seq);
+        seenQueue.push(seq);
+        if (seenQueue.length > 200) {
+            const dropped = seenQueue.splice(0, seenQueue.length - 200);
+            for (const id of dropped)
+                seenSeq.delete(id);
+        }
+        return true;
+    }
+    function flush() {
+        if (pending.length === 0)
+            return;
+        const msgs = pending;
+        pending = [];
+        timer = null;
+        const lines = msgs.map((m) => {
+            const text = typeof m.payload === "object" && m.payload !== null && "text" in m.payload
+                ? m.payload.text
+                : JSON.stringify(m.payload);
+            const sender = m.fromName?.trim() ? m.fromName.trim() : "GM";
+            const ch = m.channel && m.channel !== "public" ? ` [${m.channel}]` : "";
+            return `[from ${sender}${ch}] ${text}`;
+        });
+        const envelope = "<bus_messages>\n" + lines.join("\n") + "\n</bus_messages>\n\n" +
+            "You received the above in-world messages from GM. " +
+            "Stay in character and reply using BusSend when needed.";
+        pi.sendUserMessage(envelope, { deliverAs: "followUp" });
+    }
+    return (msg) => {
+        if (msg.channel && msg.channel !== options.gmChannel)
+            return;
+        if (!markSeen(msg.seq))
+            return;
+        pending.push(msg);
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(flush, 300);
+    };
+}

package/dist/src/extensions/game/identity.js

@@ -0,0 +1,83 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+const PROFILE_FILE = "profile.json";
+const IDENTITY_FILE = "identity.md";
+export function getGameChannel(workspaceCwd, channelOverride) {
+    const override = channelOverride?.trim();
+    if (override)
+        return override;
+    const hash = createHash("sha1").update(workspaceCwd).digest("hex").slice(0, 10);
+    return `game:${hash}`;
+}
+export function getGameGmChannel(gameChannel) {
+    return `${gameChannel}:gm`;
+}
+function parseProfile(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function readIdentityPrompt(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const raw = readFileSync(path, "utf-8").trim();
+        return raw.length > 0 ? raw : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractDisplayNameFromIdentity(identityPrompt) {
+    if (!identityPrompt)
+        return undefined;
+    for (const line of identityPrompt.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        const match = trimmed.match(/^角色\s*[：:]\s*(.+)$/);
+        if (match?.[1])
+            return match[1].trim();
+    }
+    return undefined;
+}
+export function loadGameIdentity(workspaceCwd) {
+    const profilePath = resolve(workspaceCwd, PROFILE_FILE);
+    const identityPath = resolve(workspaceCwd, IDENTITY_FILE);
+    const profile = parseProfile(profilePath);
+    const identityPrompt = readIdentityPrompt(identityPath);
+    const fromProfile = typeof profile.displayName === "string" ? profile.displayName.trim() : "";
+    const fromIdentity = extractDisplayNameFromIdentity(identityPrompt);
+    const fallback = basename(workspaceCwd);
+    const tools = resolveToolList(profile);
+    const displayName = fromProfile || fromIdentity || fallback;
+    return {
+        displayName,
+        identityPrompt,
+        profilePath,
+        identityPath,
+        tools,
+    };
+}
+function resolveToolList(profile) {
+    const hasTools = typeof profile === "object" && profile !== null && "tools" in profile;
+    if (!hasTools)
+        return undefined;
+    const raw = profile.tools;
+    if (!Array.isArray(raw)) {
+        console.warn("[mono-game] profile.tools must be an array of strings");
+        return [];
+    }
+    return raw
+        .filter((value) => typeof value === "string")
+        .map((value) => value.trim())
+        .filter(Boolean);
+}

package/dist/src/extensions/game/mailbox.js

@@ -0,0 +1,61 @@
+let activeBus = null;
+let gmChannel;
+let listenerInstalled = false;
+const mailbox = [];
+const seenSeq = new Set();
+let roundGateSeq = null;
+export function setMailBoxHandle(bus, options) {
+    activeBus = bus;
+    gmChannel = options?.gmChannel;
+    if (!bus) {
+        listenerInstalled = false;
+        mailbox.length = 0;
+        roundGateSeq = null;
+        return;
+    }
+    if (listenerInstalled)
+        return;
+    listenerInstalled = true;
+    bus.onMessage((msg) => {
+        if (gmChannel && msg.channel === gmChannel) {
+            roundGateSeq = msg.seq;
+            return;
+        }
+        if (seenSeq.has(msg.seq))
+            return;
+        seenSeq.add(msg.seq);
+        mailbox.push(msg);
+    });
+}
+export function isMailBoxConnected() {
+    return Boolean(activeBus);
+}
+export function readMailBox(options) {
+    const limit = options?.limit ?? mailbox.length;
+    const clear = options?.clear ?? true;
+    const gateSeq = roundGateSeq;
+    const items = [];
+    const indices = [];
+    for (let i = 0; i < mailbox.length && items.length < limit; i++) {
+        const msg = mailbox[i];
+        if (gateSeq !== null && msg.seq > gateSeq)
+            continue;
+        items.push(msg);
+        indices.push(i);
+    }
+    if (clear && indices.length > 0) {
+        for (let i = indices.length - 1; i >= 0; i--) {
+            const idx = indices[i];
+            const [removed] = mailbox.splice(idx, 1);
+            if (removed)
+                seenSeq.delete(removed.seq);
+        }
+    }
+    return items;
+}
+export function getMailBoxCount() {
+    const gateSeq = roundGateSeq;
+    if (gateSeq === null)
+        return mailbox.length;
+    return mailbox.reduce((count, msg) => (msg.seq <= gateSeq ? count + 1 : count), 0);
+}

package/dist/src/extensions/game/system-prompt.js

@@ -0,0 +1,134 @@
+import { getGameChannel, getGameGmChannel, loadGameIdentity } from "./identity.js";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+const NO_DESCRIPTION_PLACEHOLDER = "No short description provided.";
+const AVAILABLE_TOOLS_TOKEN = "{{AVAILABLE_TOOLS_BULLETS}}";
+const DISPLAY_NAME_TOKEN = "{{DISPLAY_NAME}}";
+const IDENTITY_PROMPT_TOKEN = "{{IDENTITY_PROMPT}}";
+const GAME_CHANNEL_TOKEN = "{{GAME_CHANNEL}}";
+const GM_CHANNEL_TOKEN = "{{GM_CHANNEL}}";
+const GAME_RULES_TOKEN = "{{GAME_RULES}}";
+const ROLE_MANUAL_TOKEN = "{{ROLE_MANUAL}}";
+const GAME_RULES_FILENAME = "游戏说明.md";
+const ROLE_MANUAL_FILENAME = "角色手册.md";
+const GAME_SYSTEM_PROMPT_TEMPLATE = `You are a role-play agent in a multi-agent murder mystery simulation.
+
+Agent identity:
+- Display name: ${DISPLAY_NAME_TOKEN}
+
+Core goal:
+- Stay in character and advance the story coherently.
+- Keep private knowledge private unless role rules allow disclosure.
+- Use communication tools to coordinate with other agents in-world.
+
+Behavior rules:
+- Default to in-character responses.
+- If the user gives an explicit out-of-character instruction, follow it directly.
+- Prefer concise responses unless the user asks for long-form narration.
+- Treat <bus_messages> as incoming in-world messages from other agents.
+- Use BusSend to reply to other agents when needed.
+- Check MailBox once for unread messages before taking action; avoid repeated checks.
+- Strictly follow guidance received from the GM channel.
+- The GM channel is receive-only; never send messages to it.
+
+Channel subscriptions (explicit):
+- \`${GAME_CHANNEL_TOKEN}\`: public message board (check MailBox).
+- \`${GM_CHANNEL_TOKEN}\`: GM instructions (auto-injected into user message, receive-only).
+
+Game rules:
+${GAME_RULES_TOKEN}
+
+Role manual:
+${ROLE_MANUAL_TOKEN}
+
+Character sheet:
+${IDENTITY_PROMPT_TOKEN}
+
+Available tools:
+${AVAILABLE_TOOLS_TOKEN}`;
+function getFirstDescriptionLine(description) {
+    if (!description)
+        return NO_DESCRIPTION_PLACEHOLDER;
+    for (const line of description.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0)
+            return trimmed;
+    }
+    return NO_DESCRIPTION_PLACEHOLDER;
+}
+function buildActiveToolBullets(activeToolNames, allTools) {
+    const activeSet = new Set(activeToolNames);
+    const lines = allTools
+        .filter((tool) => activeSet.has(tool.name))
+        .map((tool) => `- ${tool.name}: ${getFirstDescriptionLine(tool.description)}`);
+    return lines.length > 0 ? lines.join("\n") : "- (none)";
+}
+function loadGameDocs(workspaceCwd, displayName) {
+    const gameRoot = findGameRoot(workspaceCwd);
+    if (!gameRoot)
+        return {};
+    return {
+        gameRules: readText(resolve(gameRoot, GAME_RULES_FILENAME)),
+        roleManual: readRoleManual(workspaceCwd),
+    };
+}
+function findGameRoot(startDir) {
+    let current = resolve(startDir);
+    for (;;) {
+        if (existsSync(resolve(current, GAME_RULES_FILENAME)))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function readRoleManual(roleDir) {
+    return readText(resolve(roleDir, ROLE_MANUAL_FILENAME));
+}
+function readText(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const raw = readFileSync(path, "utf-8").trim();
+        return raw.length > 0 ? raw : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export default function gameSystemPromptExtension(pi) {
+    pi.on("before_agent_start", (_event, ctx) => {
+        const tools = buildActiveToolBullets(pi.getActiveTools(), pi.getAllTools());
+        const identity = loadGameIdentity(ctx.cwd);
+        const identityPrompt = identity.identityPrompt ?? "(missing .mono-game/identity.md)";
+        const channelOverride = pi.getFlag("game-channel");
+        const gameChannel = getGameChannel(ctx.cwd, typeof channelOverride === "string" ? channelOverride : undefined);
+        const gmChannel = getGameGmChannel(gameChannel);
+        const docs = loadGameDocs(ctx.cwd, identity.displayName);
+        const gameRules = docs.gameRules ?? "(missing 游戏说明.md)";
+        const roleManual = docs.roleManual ?? "(missing 角色手册)";
+        const gamePrompt = GAME_SYSTEM_PROMPT_TEMPLATE
+            .split(AVAILABLE_TOOLS_TOKEN)
+            .join(tools)
+            .split(DISPLAY_NAME_TOKEN)
+            .join(identity.displayName)
+            .split(IDENTITY_PROMPT_TOKEN)
+            .join(identityPrompt)
+            .split(GAME_CHANNEL_TOKEN)
+            .join(gameChannel)
+            .split(GM_CHANNEL_TOKEN)
+            .join(gmChannel)
+            .split(GAME_RULES_TOKEN)
+            .join(gameRules)
+            .split(ROLE_MANUAL_TOKEN)
+            .join(roleManual);
+        try {
+            writeFileSync(".mono-game/system-prompt.txt", gamePrompt, "utf-8");
+        }
+        catch (err) {
+            console.warn("[mono-game] failed to write system prompt", String(err));
+        }
+        return { systemPrompt: gamePrompt };
+    });
+}

package/dist/src/extensions/game/tools.js

@@ -0,0 +1,28 @@
+import busSendExtension from "../../tools/bus-send.js";
+import mailboxExtension from "../../tools/mailbox.js";
+import readFileExtension from "../../tools/read-file.js";
+const TOOL_REGISTRY = [
+    { key: "bussend", name: "BusSend", extension: busSendExtension },
+    { key: "mailbox", name: "MailBox", extension: mailboxExtension },
+    { key: "readfile", name: "ReadFile", extension: readFileExtension },
+];
+export function resolveGameToolExtensions(allowlist) {
+    if (!allowlist) {
+        return TOOL_REGISTRY.map((tool) => tool.extension);
+    }
+    const normalized = allowlist.map((value) => normalizeToolName(value));
+    const allowed = new Set(normalized.filter(Boolean));
+    const selected = TOOL_REGISTRY.filter((tool) => allowed.has(tool.key) || allowed.has(tool.name.toLowerCase()));
+    const known = new Set([
+        ...TOOL_REGISTRY.map((tool) => tool.key),
+        ...TOOL_REGISTRY.map((tool) => tool.name.toLowerCase()),
+    ]);
+    const unknown = normalized.filter((value) => value && !known.has(value));
+    if (unknown.length > 0) {
+        console.warn(`[mono-game] unknown tools in profile: ${unknown.join(", ")}`);
+    }
+    return selected.map((tool) => tool.extension);
+}
+function normalizeToolName(value) {
+    return value.trim().toLowerCase();
+}