pi-discord-bot 0.1.1

package/dist/agent-session-ops.js

@@ -0,0 +1,157 @@
+import { flattenTreeNodes, summarizeTreeNode } from "./agent-tree.js";
+import { findModelByReference, formatModel, modelSortKey, resolveScopedModels } from "./agent-models.js";
+export function createSessionOps(params) {
+    const { session, sessionManager, modelRegistry, settingsManager, runState } = params;
+    return {
+        async newSession() {
+            await session.newSession();
+            runState.pendingTools.clear();
+        },
+        renameSession(name) {
+            session.setSessionName(name);
+        },
+        getSessionInfo() {
+            const card = this.getSessionCardData();
+            return [card.title, ...card.fields.map((field) => `${field.name}: ${field.value}`)].join("\n");
+        },
+        getTreeSummary() {
+            const roots = sessionManager.getTree();
+            if (roots.length === 0)
+                return "Session tree is empty.";
+            return summarizeTreeNode({ entry: { id: "root", type: "root" }, children: roots }, 0, []).slice(1).join("\n");
+        },
+        getTreeBrowserData() {
+            const roots = sessionManager.getTree();
+            const currentId = sessionManager.getLeafId() ?? undefined;
+            const entries = flattenTreeNodes(roots, currentId ?? null);
+            return {
+                title: session.sessionName ? `Session tree · ${session.sessionName}` : "Session tree",
+                description: entries.length === 0
+                    ? "This session tree is empty."
+                    : [currentId ? `**Current leaf**: \`${currentId}\`` : "**Current leaf**: none", `**Entries**: ${entries.length}`, "Use the dropdown to navigate to a different entry."].join("\n"),
+                entries,
+                currentId,
+            };
+        },
+        async navigateTree(targetId) {
+            const result = await session.navigateTree(targetId, { summarize: false });
+            if (result.cancelled)
+                return `Navigation to ${targetId} was cancelled.`;
+            return `Moved session tree leaf to ${targetId}.`;
+        },
+        getSessionCardData() {
+            const stats = session.getSessionStats();
+            return {
+                title: session.sessionName ? `Session · ${session.sessionName}` : "Session",
+                fields: [
+                    { name: "Model", value: formatModel(session.model), inline: false },
+                    { name: "File", value: stats.sessionFile ?? "In-memory", inline: false },
+                    { name: "ID", value: stats.sessionId, inline: false },
+                    { name: "Messages", value: `user ${stats.userMessages} · assistant ${stats.assistantMessages} · tools ${stats.toolCalls}`, inline: false },
+                    { name: "Tokens", value: `in ${stats.tokens.input} · out ${stats.tokens.output} · total ${stats.tokens.total}`, inline: false },
+                    { name: "Cost", value: `$${stats.cost.toFixed(4)}`, inline: true },
+                    { name: "Thinking", value: settingsManager.getDefaultThinkingLevel() ?? "off", inline: true },
+                    { name: "Transport", value: settingsManager.getTransport(), inline: true },
+                    { name: "Scoped models", value: session.scopedModels.length > 0 ? session.scopedModels.map((item) => `${item.model.provider}/${item.model.id}`).join("\n") : "All available models", inline: false },
+                ],
+            };
+        },
+        listModels(search) {
+            const query = search?.trim().toLowerCase();
+            const models = modelRegistry.getAvailable()
+                .filter((model) => !query || `${model.provider}/${model.id}`.toLowerCase().includes(query) || model.id.toLowerCase().includes(query))
+                .sort((a, b) => {
+                const [ap, ak] = modelSortKey(a);
+                const [bp, bk] = modelSortKey(b);
+                return ap - bp || ak.localeCompare(bk);
+            });
+            if (models.length === 0)
+                return query ? `No available models match \`${search}\`.` : "No available models. Authenticate with Pi first.";
+            return models.map((model) => `${session.model && session.model.provider === model.provider && session.model.id === model.id ? "*" : "-"} ${model.provider}/${model.id}`).join("\n");
+        },
+        currentModel() {
+            return formatModel(session.model);
+        },
+        async setModel(reference) {
+            modelRegistry.refresh();
+            const resolved = findModelByReference(modelRegistry, reference);
+            if (!resolved.model)
+                throw new Error(resolved.error ?? "Model not found.");
+            await session.setModel(resolved.model);
+            return formatModel(session.model);
+        },
+        getScopedModels() {
+            if (session.scopedModels.length === 0)
+                return "Scoped models: all available models";
+            return `Scoped models:\n${session.scopedModels.map((item) => `- ${item.model.provider}/${item.model.id}`).join("\n")}`;
+        },
+        setScopedModels(patterns) {
+            const list = patterns.split(",").map((item) => item.trim()).filter(Boolean);
+            if (list.length === 0)
+                return "Usage: /scoped-models <pattern[,pattern...]>";
+            modelRegistry.refresh();
+            const resolved = resolveScopedModels(modelRegistry, list);
+            if (resolved.length === 0)
+                return `No available models matched: ${list.join(", ")}`;
+            settingsManager.setEnabledModels(list);
+            session.setScopedModels(resolved);
+            return `Scoped models set:\n${resolved.map((item) => `- ${item.model.provider}/${item.model.id}`).join("\n")}`;
+        },
+        clearScopedModels() {
+            settingsManager.setEnabledModels(undefined);
+            session.setScopedModels([]);
+            return "Cleared scoped models. Pi will use all available models.";
+        },
+        async compact(customInstructions) {
+            await session.compact(customInstructions || undefined);
+            return "Compaction complete.";
+        },
+        async reload() {
+            modelRegistry.refresh();
+            await session.reload();
+            return "Reloaded settings, skills, prompts, extensions, and model registry.";
+        },
+        getSettingsSummary() {
+            return [
+                `Transport: ${settingsManager.getTransport()}`,
+                `Thinking: ${settingsManager.getDefaultThinkingLevel() ?? "off"}`,
+                `Steering mode: ${settingsManager.getSteeringMode()}`,
+                `Follow-up mode: ${settingsManager.getFollowUpMode()}`,
+                `Auto compact: ${settingsManager.getCompactionEnabled() ? "on" : "off"}`,
+            ].join("\n");
+        },
+        cycleThinkingSetting() {
+            const order = ["off", "minimal", "low", "medium", "high", "xhigh"];
+            const current = settingsManager.getDefaultThinkingLevel() ?? "off";
+            const next = order[(order.indexOf(current) + 1) % order.length];
+            settingsManager.setDefaultThinkingLevel(next);
+            session.setThinkingLevel(next);
+            return this.getSettingsSummary();
+        },
+        cycleTransportSetting() {
+            const order = ["auto", "sse", "websocket"];
+            const current = settingsManager.getTransport();
+            const next = order[(order.indexOf(current) + 1 + order.length) % order.length];
+            settingsManager.setTransport(next);
+            return this.getSettingsSummary();
+        },
+        toggleSteeringModeSetting() {
+            const next = settingsManager.getSteeringMode() === "all" ? "one-at-a-time" : "all";
+            settingsManager.setSteeringMode(next);
+            session.setSteeringMode(next);
+            return this.getSettingsSummary();
+        },
+        toggleFollowUpModeSetting() {
+            const next = settingsManager.getFollowUpMode() === "all" ? "one-at-a-time" : "all";
+            settingsManager.setFollowUpMode(next);
+            session.setFollowUpMode(next);
+            return this.getSettingsSummary();
+        },
+        toggleAutoCompactSetting() {
+            const next = !settingsManager.getCompactionEnabled();
+            settingsManager.setCompactionEnabled(next);
+            session.setAutoCompactionEnabled(next);
+            return this.getSettingsSummary();
+        },
+    };
+}

package/dist/agent-tools.js

@@ -0,0 +1,224 @@
+import { Type } from "@sinclair/typebox";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+export function createDiscordCustomTools(params) {
+    const { scratchDir, runState } = params;
+    const noContextError = () => ({ content: [{ type: "text", text: "No active Discord context." }], details: {}, isError: true });
+    return [{
+            name: "attach",
+            label: "Attach file",
+            description: "Upload a local file from the workspace back to Discord.",
+            parameters: Type.Object({
+                filePath: Type.String({ description: "Absolute or scratch-relative path to the file to upload" }),
+                title: Type.Optional(Type.String({ description: "Optional display name for the uploaded file" })),
+                label: Type.Optional(Type.String({ description: "Short user-visible label for the action" })),
+            }),
+            execute: async (_toolCallId, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return { content: [{ type: "text", text: "No active Discord context; cannot upload file." }], details: {} };
+                const filePath = params.filePath.startsWith("/") ? params.filePath : join(scratchDir, params.filePath);
+                if (!existsSync(filePath)) {
+                    return { content: [{ type: "text", text: `File not found: ${filePath}` }], details: {}, isError: true };
+                }
+                await ctx.uploadFile(filePath, params.title);
+                return { content: [{ type: "text", text: `Uploaded ${params.title ?? filePath} to Discord.` }], details: { filePath, title: params.title ?? null } };
+            },
+        }, {
+            name: "discord_list_channels",
+            label: "List Discord guild channels",
+            description: "List guild channels visible to the bot in the current server.",
+            parameters: Type.Object({ label: Type.Optional(Type.String()) }),
+            execute: async () => {
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const channels = await ctx.listGuildChannels();
+                return { content: [{ type: "text", text: `Found ${channels.length} channels.` }], details: { channels } };
+            },
+        }, {
+            name: "discord_resolve_channel",
+            label: "Resolve Discord channel",
+            description: "Resolve a guild channel or category by name or ID.",
+            parameters: Type.Object({ query: Type.String({ description: "Channel or category name or ID" }), label: Type.Optional(Type.String()) }),
+            execute: async (_id, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const resolved = await ctx.resolveGuildChannel(params.query);
+                return { content: [{ type: "text", text: `Resolved ${params.query} to ${resolved.name}.` }], details: resolved };
+            },
+        }, {
+            name: "discord_resolve_member",
+            label: "Resolve Discord member",
+            description: "Resolve a guild member by username, display name, or ID.",
+            parameters: Type.Object({ query: Type.String({ description: "Member username, display name, or ID" }), label: Type.Optional(Type.String()) }),
+            execute: async (_id, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const resolved = await ctx.resolveGuildMember(params.query);
+                return { content: [{ type: "text", text: `Resolved ${params.query} to ${resolved.displayName}.` }], details: resolved };
+            },
+        }, {
+            name: "discord_resolve_role",
+            label: "Resolve Discord role",
+            description: "Resolve a guild role by name or ID.",
+            parameters: Type.Object({ query: Type.String({ description: "Role name or ID" }), label: Type.Optional(Type.String()) }),
+            execute: async (_id, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const resolved = await ctx.resolveGuildRole(params.query);
+                return { content: [{ type: "text", text: `Resolved ${params.query} to role ${resolved.name}.` }], details: resolved };
+            },
+        }, {
+            name: "discord_create_channel",
+            label: "Create Discord text channel",
+            description: "Create a guild text channel after approval.",
+            parameters: Type.Object({ name: Type.String(), parentId: Type.Optional(Type.String()), topic: Type.Optional(Type.String()), label: Type.Optional(Type.String()) }),
+            execute: async (_id, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const approved = await ctx.confirmAction({ title: "Approve channel creation", description: `Create a new text channel named \`${params.name}\`?`, bullets: [params.parentId ? `Parent category: ${params.parentId}` : "No parent category", params.topic ? `Topic: ${params.topic}` : "No topic"], caution: "This changes the Discord server structure.", approveLabel: "Create channel" });
+                if (!approved)
+                    return { content: [{ type: "text", text: "Channel creation cancelled." }], details: { approved: false } };
+                const created = await ctx.createGuildTextChannel(params);
+                return { content: [{ type: "text", text: `Created channel ${created.name}.` }], details: created };
+            },
+        }, {
+            name: "discord_create_private_channel",
+            label: "Create private Discord text channel",
+            description: "Create a private guild text channel after approval.",
+            parameters: Type.Object({ name: Type.String(), parentId: Type.Optional(Type.String()), topic: Type.Optional(Type.String()), memberIds: Type.Optional(Type.Array(Type.String())), roleIds: Type.Optional(Type.Array(Type.String())), label: Type.Optional(Type.String()) }),
+            execute: async (_id, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const approved = await ctx.confirmAction({ title: "Approve private channel creation", description: `Create a new private text channel named \`${params.name}\`?`, bullets: [params.parentId ? `Parent category: ${params.parentId}` : "No parent category", params.topic ? `Topic: ${params.topic}` : "No topic", params.memberIds?.length ? `Extra allowed members: ${params.memberIds.join(", ")}` : "No extra allowed members", params.roleIds?.length ? `Extra allowed roles: ${params.roleIds.join(", ")}` : "No extra allowed roles", "Visible only to allowed users/roles and the bot unless you change permissions later"], caution: "This changes the Discord server structure and permissions.", approveLabel: "Create private channel" });
+                if (!approved)
+                    return { content: [{ type: "text", text: "Private channel creation cancelled." }], details: { approved: false } };
+                const created = await ctx.createGuildTextChannel({ ...params, private: true });
+                return { content: [{ type: "text", text: `Created private channel ${created.name}.` }], details: created };
+            },
+        }, {
+            name: "discord_create_category",
+            label: "Create Discord category",
+            description: "Create a guild category after approval.",
+            parameters: Type.Object({ name: Type.String(), label: Type.Optional(Type.String()) }),
+            execute: async (_id, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const approved = await ctx.confirmAction({ title: "Approve category creation", description: `Create a category named \`${params.name}\`?`, caution: "This changes the Discord server structure.", approveLabel: "Create category" });
+                if (!approved)
+                    return { content: [{ type: "text", text: "Category creation cancelled." }], details: { approved: false } };
+                const created = await ctx.createGuildCategory(params);
+                return { content: [{ type: "text", text: `Created category ${created.name}.` }], details: created };
+            },
+        }, {
+            name: "discord_rename_channel",
+            label: "Rename Discord channel",
+            description: "Rename a guild channel after approval.",
+            parameters: Type.Object({ channelId: Type.String(), name: Type.String(), label: Type.Optional(Type.String()) }),
+            execute: async (_id, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const approved = await ctx.confirmAction({ title: "Approve channel rename", description: `Rename channel \`${params.channelId}\` to \`${params.name}\`?`, caution: "This changes an existing Discord channel.", approveLabel: "Rename" });
+                if (!approved)
+                    return { content: [{ type: "text", text: "Channel rename cancelled." }], details: { approved: false } };
+                const updated = await ctx.renameGuildChannel(params);
+                return { content: [{ type: "text", text: `Renamed channel to ${updated.name}.` }], details: updated };
+            },
+        }, {
+            name: "discord_move_channel",
+            label: "Move Discord channel",
+            description: "Move a guild channel into or out of a category after approval.",
+            parameters: Type.Object({ channelId: Type.String(), parentId: Type.Optional(Type.String()), label: Type.Optional(Type.String()) }),
+            execute: async (_id, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const approved = await ctx.confirmAction({ title: "Approve channel move", description: params.parentId ? `Move channel \`${params.channelId}\` into category \`${params.parentId}\`?` : `Remove channel \`${params.channelId}\` from its category?`, caution: "This changes the Discord server layout.", approveLabel: "Move channel" });
+                if (!approved)
+                    return { content: [{ type: "text", text: "Channel move cancelled." }], details: { approved: false } };
+                const updated = await ctx.moveGuildChannel({ channelId: params.channelId, parentId: params.parentId ?? null });
+                return { content: [{ type: "text", text: `Moved channel ${updated.name}.` }], details: updated };
+            },
+        }, {
+            name: "discord_delete_channel",
+            label: "Delete Discord channel",
+            description: "Delete a guild channel after approval.",
+            parameters: Type.Object({ channelId: Type.String(), label: Type.Optional(Type.String()) }),
+            execute: async (_id, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const approved = await ctx.confirmAction({ title: "Approve channel deletion", description: `Delete channel \`${params.channelId}\`?`, bullets: ["This cannot be undone through the bot."], caution: "This permanently deletes a Discord channel.", approveLabel: "Delete channel" });
+                if (!approved)
+                    return { content: [{ type: "text", text: "Channel deletion cancelled." }], details: { approved: false } };
+                const deleted = await ctx.deleteGuildChannel(params);
+                return { content: [{ type: "text", text: `Deleted channel ${deleted.id}.` }], details: deleted };
+            },
+        }, {
+            name: "discord_create_thread",
+            label: "Create Discord thread",
+            description: "Create a thread in the current guild channel after approval.",
+            parameters: Type.Object({ name: Type.String(), autoArchiveDuration: Type.Optional(Type.Union([Type.Literal(60), Type.Literal(1440), Type.Literal(4320), Type.Literal(10080)])), label: Type.Optional(Type.String()) }),
+            execute: async (_id, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const approved = await ctx.confirmAction({ title: "Approve thread creation", description: `Create a thread named \`${params.name}\` in the current channel?`, bullets: [params.autoArchiveDuration ? `Auto archive: ${params.autoArchiveDuration} minutes` : "Auto archive: 1440 minutes"], caution: "This creates a new thread in the current guild channel.", approveLabel: "Create thread" });
+                if (!approved)
+                    return { content: [{ type: "text", text: "Thread creation cancelled." }], details: { approved: false } };
+                const created = await ctx.createThreadFromCurrentChannel(params);
+                return { content: [{ type: "text", text: `Created thread ${created.name}.` }], details: created };
+            },
+        }, {
+            name: "discord_rename_thread",
+            label: "Rename Discord thread",
+            description: "Rename a thread after approval.",
+            parameters: Type.Object({ threadId: Type.String(), name: Type.String(), label: Type.Optional(Type.String()) }),
+            execute: async (_id, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const approved = await ctx.confirmAction({ title: "Approve thread rename", description: `Rename thread \`${params.threadId}\` to \`${params.name}\`?`, caution: "This changes an existing Discord thread.", approveLabel: "Rename thread" });
+                if (!approved)
+                    return { content: [{ type: "text", text: "Thread rename cancelled." }], details: { approved: false } };
+                const updated = await ctx.renameThread(params);
+                return { content: [{ type: "text", text: `Renamed thread to ${updated.name}.` }], details: updated };
+            },
+        }, {
+            name: "discord_archive_thread",
+            label: "Archive Discord thread",
+            description: "Archive or unarchive a thread after approval.",
+            parameters: Type.Object({ threadId: Type.String(), archived: Type.Optional(Type.Boolean()), locked: Type.Optional(Type.Boolean()), label: Type.Optional(Type.String()) }),
+            execute: async (_id, rawParams) => {
+                const params = rawParams;
+                const ctx = runState.ctx;
+                if (!ctx)
+                    return noContextError();
+                const approved = await ctx.confirmAction({ title: params.archived === false ? "Approve thread unarchive" : "Approve thread archive", description: `${params.archived === false ? "Unarchive" : "Archive"} thread \`${params.threadId}\`?`, bullets: [typeof params.locked === "boolean" ? `Set locked=${params.locked}` : "Leave lock state unchanged"], caution: "This changes an existing Discord thread state.", approveLabel: params.archived === false ? "Unarchive" : "Archive" });
+                if (!approved)
+                    return { content: [{ type: "text", text: "Thread archive action cancelled." }], details: { approved: false } };
+                const updated = await ctx.archiveThread(params);
+                return { content: [{ type: "text", text: `${updated.archived ? "Archived" : "Unarchived"} thread ${updated.id}.` }], details: updated };
+            },
+        }];
+}

package/dist/agent-tree.js

@@ -0,0 +1,52 @@
+function truncate(text, max = 1800) {
+    return text.length <= max ? text : `${text.slice(0, max - 3)}...`;
+}
+export function getTreeEntryPreview(entry) {
+    if (entry.type === "message") {
+        const role = entry.message?.role ?? "unknown";
+        const content = typeof entry.message?.content === "string"
+            ? entry.message.content
+            : Array.isArray(entry.message?.content)
+                ? entry.message.content.filter((part) => part?.type === "text").map((part) => part.text).join("\n")
+                : "";
+        return `${role} — ${truncate(String(content).replace(/\s+/g, " "), 80)}`;
+    }
+    if (entry.type === "branch_summary")
+        return `branch summary — ${truncate(entry.summary ?? "", 80)}`;
+    if (entry.type === "compaction")
+        return `compaction — ${truncate(entry.summary ?? "", 80)}`;
+    if (entry.type === "model_change")
+        return `model change — ${entry.provider}/${entry.modelId}`;
+    if (entry.type === "thinking_level_change")
+        return `thinking — ${entry.thinkingLevel}`;
+    if (entry.type === "label")
+        return `label — ${entry.label ?? "(cleared)"}`;
+    if (entry.type === "session_info")
+        return `session info — ${entry.name ?? "(unnamed)"}`;
+    return `${entry.type} ${entry.id}`;
+}
+export function summarizeTreeNode(node, depth = 0, lines = []) {
+    const indent = "  ".repeat(depth);
+    const entry = node.entry;
+    let title = `${getTreeEntryPreview(entry)} (${entry.id})`;
+    if (node.label)
+        title += ` [${node.label}]`;
+    lines.push(`${indent}- ${title}`);
+    for (const child of node.children ?? [])
+        summarizeTreeNode(child, depth + 1, lines);
+    return lines;
+}
+export function flattenTreeNodes(nodes, currentId, depth = 0, out = []) {
+    for (const node of nodes) {
+        out.push({
+            id: node.entry.id,
+            depth,
+            type: node.entry.type,
+            preview: getTreeEntryPreview(node.entry),
+            label: node.label,
+            isCurrent: node.entry.id === currentId,
+        });
+        flattenTreeNodes(node.children ?? [], currentId, depth + 1, out);
+    }
+    return out;
+}

package/dist/agent-tree.test.js

@@ -0,0 +1,31 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { flattenTreeNodes, getTreeEntryPreview, summarizeTreeNode } from "./agent-tree.js";
+test("getTreeEntryPreview formats message entries", () => {
+    const preview = getTreeEntryPreview({
+        type: "message",
+        id: "m1",
+        message: { role: "user", content: [{ type: "text", text: "hello\nworld" }] },
+    });
+    assert.match(preview, /^user — hello world/);
+});
+test("flattenTreeNodes preserves depth and current marker", () => {
+    const nodes = [{
+            entry: { id: "root", type: "message", message: { role: "user", content: "root" } },
+            children: [{ entry: { id: "child", type: "model_change", provider: "openai", modelId: "gpt-4.1" }, children: [] }],
+        }];
+    const flat = flattenTreeNodes(nodes, "child");
+    assert.equal(flat.length, 2);
+    assert.equal(flat[0].depth, 0);
+    assert.equal(flat[1].depth, 1);
+    assert.equal(flat[1].isCurrent, true);
+});
+test("summarizeTreeNode renders nested bullet tree", () => {
+    const lines = summarizeTreeNode({
+        entry: { id: "r", type: "message", message: { role: "user", content: "root" } },
+        children: [{ entry: { id: "c", type: "session_info", name: "test" }, children: [] }],
+    });
+    assert.equal(lines.length, 2);
+    assert.match(lines[0], /^- user — root \(r\)$/);
+    assert.match(lines[1], /^  - session info — test \(c\)$/);
+});

package/dist/agent-types.js

@@ -0,0 +1 @@
+export {};

package/dist/agent.js

@@ -0,0 +1,93 @@
+import { Agent } from "@mariozechner/pi-agent-core";
+import { AgentSession, AuthStorage, convertToLlm, createCodingTools, createExtensionRuntime, ModelRegistry, SessionManager, } from "@mariozechner/pi-coding-agent";
+import { join } from "node:path";
+import { createDiscordSettingsManager } from "./context.js";
+import { resolveInitialModel, formatModel } from "./agent-models.js";
+import { buildAppendSystemPrompt, getMemory, loadDiscordSkills } from "./agent-prompt.js";
+import { createDiscordCustomTools } from "./agent-tools.js";
+import { createSessionOps } from "./agent-session-ops.js";
+import { runAgentTurn, wireSessionUpdates } from "./agent-runner.js";
+const runners = new Map();
+export function getOrCreateRunner(workspaceDir, conversationKey) {
+    const existing = runners.get(conversationKey);
+    if (existing)
+        return existing;
+    const created = createRunner(workspaceDir, conversationKey);
+    runners.set(conversationKey, created);
+    return created;
+}
+function createRunner(workspaceDir, conversationKey) {
+    const conversationDir = join(workspaceDir, conversationKey);
+    const scratchDir = join(conversationDir, "scratch");
+    const contextFile = join(conversationDir, "context.jsonl");
+    const tools = createCodingTools(scratchDir);
+    const baseToolsOverride = Object.fromEntries(tools.map((tool) => [tool.name, tool]));
+    const authStorage = AuthStorage.create();
+    const modelRegistry = ModelRegistry.create(authStorage);
+    const sessionManager = SessionManager.open(contextFile, conversationDir);
+    const settingsManager = createDiscordSettingsManager(workspaceDir);
+    const skills = loadDiscordSkills(conversationDir);
+    let appendSystemPrompt = buildAppendSystemPrompt(workspaceDir, conversationKey, getMemory(conversationDir));
+    const resourceLoader = {
+        getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
+        getSkills: () => ({ skills, diagnostics: [] }),
+        getPrompts: () => ({ prompts: [], diagnostics: [] }),
+        getThemes: () => ({ themes: [], diagnostics: [] }),
+        getAgentsFiles: () => ({ agentsFiles: [] }),
+        getSystemPrompt: () => undefined,
+        getAppendSystemPrompt: () => [appendSystemPrompt],
+        extendResources: () => { },
+        reload: async () => { },
+    };
+    const runState = {
+        ctx: null,
+        queue: Promise.resolve(),
+        stopReason: "stop",
+        errorMessage: undefined,
+        pendingTools: new Map(),
+    };
+    const customTools = createDiscordCustomTools({ scratchDir, runState });
+    const initialModel = resolveInitialModel(modelRegistry, settingsManager);
+    let agent;
+    agent = new Agent({
+        initialState: {
+            systemPrompt: "",
+            model: initialModel,
+            thinkingLevel: settingsManager.getDefaultThinkingLevel() ?? "off",
+            tools,
+        },
+        convertToLlm,
+        getApiKey: async () => {
+            const currentModel = agent.state.model;
+            const key = currentModel ? await authStorage.getApiKey(currentModel.provider) : undefined;
+            if (!key)
+                throw new Error(`No auth configured for ${formatModel(currentModel)}. Use Pi auth/login first.`);
+            return key;
+        },
+    });
+    const loaded = sessionManager.buildSessionContext();
+    if (loaded.messages.length > 0)
+        agent.state.messages = loaded.messages;
+    const session = new AgentSession({
+        agent,
+        sessionManager,
+        settingsManager,
+        cwd: scratchDir,
+        modelRegistry,
+        resourceLoader,
+        baseToolsOverride,
+        customTools,
+    });
+    wireSessionUpdates(session, runState);
+    const sessionOps = createSessionOps({ session, sessionManager, modelRegistry, settingsManager, runState });
+    return {
+        async run(ctx) {
+            appendSystemPrompt = buildAppendSystemPrompt(workspaceDir, conversationKey, getMemory(conversationDir));
+            return runAgentTurn({ ctx, conversationDir, scratchDir, sessionManager, agent, session, runState });
+        },
+        abort() {
+            void session.abort();
+        },
+        ...sessionOps,
+    };
+}

package/dist/context.js

@@ -0,0 +1,58 @@
+import { SettingsManager } from "@mariozechner/pi-coding-agent";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+export function syncLogToSessionManager(sessionManager, channelDir, excludeMessageId) {
+    const logPath = join(channelDir, "log.jsonl");
+    if (!existsSync(logPath))
+        return 0;
+    const existing = new Set();
+    for (const entry of sessionManager.getEntries()) {
+        if (entry.type !== "message")
+            continue;
+        const message = entry.message;
+        if (message.role !== "user")
+            continue;
+        const content = message.content;
+        if (typeof content === "string")
+            existing.add(content);
+        if (Array.isArray(content)) {
+            for (const part of content) {
+                if (typeof part === "object" && part && "type" in part && part.type === "text" && "text" in part) {
+                    existing.add(String(part.text));
+                }
+            }
+        }
+    }
+    const lines = readFileSync(logPath, "utf-8").split("\n").filter(Boolean);
+    const toAppend = [];
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            if (entry.isBot)
+                continue;
+            if (excludeMessageId && entry.messageId === excludeMessageId)
+                continue;
+            const text = `[${entry.authorName ?? entry.authorId ?? "unknown"}]: ${entry.text ?? ""}`;
+            if (existing.has(text))
+                continue;
+            existing.add(text);
+            toAppend.push({
+                timestamp: entry.date ? new Date(entry.date).getTime() : Date.now(),
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text }],
+                    timestamp: entry.date ? new Date(entry.date).getTime() : Date.now(),
+                },
+            });
+        }
+        catch { }
+    }
+    toAppend.sort((a, b) => a.timestamp - b.timestamp);
+    for (const item of toAppend) {
+        sessionManager.appendMessage(item.message);
+    }
+    return toAppend.length;
+}
+export function createDiscordSettingsManager(_workspaceDir) {
+    return SettingsManager.create();
+}

package/dist/context.test.js

@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { syncLogToSessionManager } from "./context.js";
+test("syncLogToSessionManager appends only non-bot, non-duplicate messages", () => {
+    const dir = mkdtempSync(join(tmpdir(), "pi-discord-bot-test-"));
+    writeFileSync(join(dir, "log.jsonl"), [
+        JSON.stringify({ messageId: "1", authorName: "alice", text: "hello", date: "2026-01-01T00:00:00.000Z", isBot: false }),
+        JSON.stringify({ messageId: "2", authorName: "bot", text: "reply", date: "2026-01-01T00:00:01.000Z", isBot: true }),
+        JSON.stringify({ messageId: "3", authorName: "alice", text: "hello", date: "2026-01-01T00:00:02.000Z", isBot: false }),
+    ].join("\n"));
+    const appended = [];
+    const sessionManager = {
+        getEntries: () => [],
+        appendMessage: (message) => appended.push(message),
+    };
+    const count = syncLogToSessionManager(sessionManager, dir);
+    assert.equal(count, 1);
+    assert.equal(appended.length, 1);
+    assert.equal(appended[0].content[0].text, "[alice]: hello");
+});
+test("syncLogToSessionManager respects excludeMessageId", () => {
+    const dir = mkdtempSync(join(tmpdir(), "pi-discord-bot-test-"));
+    writeFileSync(join(dir, "log.jsonl"), JSON.stringify({ messageId: "1", authorName: "alice", text: "hello", date: "2026-01-01T00:00:00.000Z", isBot: false }));
+    const appended = [];
+    const sessionManager = {
+        getEntries: () => [],
+        appendMessage: (message) => appended.push(message),
+    };
+    const count = syncLogToSessionManager(sessionManager, dir, "1");
+    assert.equal(count, 0);
+    assert.equal(appended.length, 0);
+});