@friendlyrobot/discord-pi-agent 0.6.0 → 0.7.0

package/README.md

@@ -96,6 +96,38 @@ The initial post body becomes the first prompt. Sessions survive restarts.
 - `startupMessage` default: `Bot is online and ready.`
 - `shutdownOnSignals` default: `true`
 
+### Logging
+
+The package uses `pino` for structured logs.
+
+Behavior:
+
+- when stdout is a TTY, logs use `pino-pretty` for readable local console output
+- when stdout is not a TTY, logs stay as JSON
+
+Log level env vars:
+
+- `DISCORD_PI_AGENT_LOG_LEVEL`
+- `LOG_LEVEL` fallback
+
+Default level is `info`.
+
+For detailed prompt and tool monitoring during local runs, use:
+
+```bash
+DISCORD_PI_AGENT_LOG_LEVEL=debug
+```
+
+Pretty console logs use:
+
+- colors
+- local timestamp (`SYS:standard`)
+- level first
+- hidden `pid` and `hostname`
+- module-aware labels like `[discord-gateway]`
+- direction markers like `IN` and `OUT`
+- multi-line payload blocks for easier input/output inspection
+
 ### Forum channel options
 
 - `discordAllowedForumChannelIds` — string array of forum channel IDs to respond in

package/dist/index.js

@@ -13,8 +13,46 @@ import {
   SettingsManager
 } from "@mariozechner/pi-coding-agent";
 
+// src/logger.ts
+import pino from "pino";
+var loggerLevel = process.env.DISCORD_PI_AGENT_LOG_LEVEL || process.env.LOG_LEVEL || "info";
+var usePrettyTransport = process.stdout.isTTY;
+var baseOptions = {
+  level: loggerLevel
+};
+var logger = usePrettyTransport ? pino({
+  ...baseOptions,
+  transport: {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      colorizeObjects: true,
+      levelFirst: true,
+      translateTime: "SYS:standard",
+      ignore: "pid,hostname",
+      singleLine: false,
+      messageFormat: "[{module}] {if direction}{direction} {end}{msg}"
+    }
+  }
+}) : pino(baseOptions);
+function createModuleLogger(moduleName) {
+  return logger.child({ module: moduleName });
+}
+function logPayload(targetLogger, options) {
+  targetLogger.debug({
+    ...options.context,
+    direction: options.direction,
+    payloadLength: options.content.length
+  }, formatPayloadBlock(options.label, options.content));
+}
+function formatPayloadBlock(label, content) {
+  return [label, "----- BEGIN -----", content, "----- END -----"].join(`
+`);
+}
+
 // src/markdown-table-transformer.ts
 import { Lexer } from "marked";
+var logger2 = createModuleLogger("markdown-table-transformer");
 var CODE_BLOCK_WRAPPER = "```\n{TABLE}\n```";
 async function transformMarkdownTablesToCodeBlocks(text) {
   const normalized = normalizeCodeFences(text);
@@ -58,19 +96,30 @@ async function formatWithPrettier(text) {
     });
     return formatted.trim();
   } catch (error) {
-    console.error("[markdown-table-transformer] Prettier formatting failed:", error);
+    logger2.error({
+      error
+    }, "Prettier formatting failed");
     return text;
   }
 }
 
 // src/reply-buffer.ts
+var logger3 = createModuleLogger("reply-buffer");
 async function collectReply(session, prompt, options = {}) {
   const logPrefix = options.logPrefix ?? "[agent]";
   let streamedText = "";
   let eventCount = 0;
   let toolCount = 0;
   let sawAgentEnd = false;
-  console.log(`${logPrefix} prompt start`, { prompt });
+  logger3.debug({ logPrefix }, "prompt start");
+  logPayload(logger3, {
+    direction: "IN",
+    label: `${logPrefix} prompt content`,
+    content: prompt,
+    context: {
+      logPrefix
+    }
+  });
   const unsubscribe = session.subscribe((event) => {
     eventCount += 1;
     if (event.type === "message_update") {
@@ -81,23 +130,26 @@ async function collectReply(session, prompt, options = {}) {
     }
     if (event.type === "tool_execution_start") {
       toolCount += 1;
-      console.log(`${logPrefix} tool start`, {
+      logger3.debug({
         toolName: event.toolName,
-        input: truncateForLog(JSON.stringify(event.args))
-      });
+        input: truncateForLog(JSON.stringify(event.args)),
+        logPrefix
+      }, "tool start");
     }
     if (event.type === "tool_execution_end") {
-      console.log(`${logPrefix} tool end`, {
+      logger3.debug({
         toolName: event.toolName,
         isError: event.isError,
-        output: truncateForLog(extractToolOutput(event.result))
-      });
+        output: truncateForLog(extractToolOutput(event.result)),
+        logPrefix
+      }, "tool end");
     }
     if (event.type === "agent_end") {
       sawAgentEnd = true;
-      console.log(`${logPrefix} agent end`, {
-        messageCount: event.messages.length
-      });
+      logger3.debug({
+        messageCount: event.messages.length,
+        logPrefix
+      }, "agent end");
     }
   });
   try {
@@ -108,25 +160,36 @@ async function collectReply(session, prompt, options = {}) {
   const errorMessage = session.agent.state.errorMessage?.trim();
   const fallbackText = getLatestAssistantText(session.messages);
   const finalText = streamedText.trim() || fallbackText.trim();
-  console.log(`${logPrefix} prompt done`, {
+  logger3.debug({
     eventCount,
     toolCount,
     sawAgentEnd,
     streamedTextLength: streamedText.trim().length,
     fallbackTextLength: fallbackText.trim().length,
-    errorMessage
-  });
+    errorMessage,
+    logPrefix
+  }, "prompt done");
   if (errorMessage) {
     return errorMessage;
   }
   if (finalText) {
     const transformed = await transformMarkdownTablesToCodeBlocks(finalText);
-    console.log("[DEBUG] Table transformation comparison:", `
-=== RAW finalText ===
-` + finalText + `
-=== TRANSFORMED ===
-` + transformed + `
-=== END ===`);
+    logPayload(logger3, {
+      direction: "OUT",
+      label: `${logPrefix} assistant final text`,
+      content: finalText,
+      context: {
+        logPrefix
+      }
+    });
+    logPayload(logger3, {
+      direction: "OUT",
+      label: `${logPrefix} assistant transformed text`,
+      content: transformed,
+      context: {
+        logPrefix
+      }
+    });
     return transformed;
   }
   return "No response generated.";
@@ -163,6 +226,8 @@ function getLatestAssistantText(messages) {
 }
 
 // src/agent-service.ts
+var logger4 = createModuleLogger("agent-service");
+
 class AgentService {
   config;
   authStorage;
@@ -184,19 +249,19 @@ class AgentService {
   async initialize() {
     await fs.mkdir(this.config.agentDir, { recursive: true });
     await fs.mkdir(this.getSessionDir(), { recursive: true });
-    console.log("[agent] config", {
+    logger4.info({
       cwd: this.config.cwd,
       agentDir: this.config.agentDir,
       sessionDir: this.getSessionDir(),
       modelProvider: this.config.modelProvider,
       modelId: this.config.modelId,
       thinkingLevel: this.config.thinkingLevel
-    });
+    }, "config");
     await this.resourceLoader.reload();
-    console.log("[agent] resources loaded", {
+    logger4.info({
       extensions: this.resourceLoader.getExtensions().extensions.map((extension) => extension.path),
       agentsFiles: this.resourceLoader.getAgentsFiles().agentsFiles.map((file) => file.path)
-    });
+    }, "resources loaded");
     await this.createOrResumeSession();
     await this.ensureConfiguredModel();
   }
@@ -218,11 +283,11 @@ class AgentService {
       sessionManager: SessionManager.continueRecent(this.config.cwd, sessionDir),
       thinkingLevel: this.config.thinkingLevel
     });
-    console.log("[agent] scoped session created", {
+    logger4.info({
       sessionDir,
       sessionId: session.sessionId,
       sessionFile: session.sessionFile
-    });
+    }, "scoped session created");
     await this.ensureModelForSession(session);
     return session;
   }
@@ -302,11 +367,11 @@ class AgentService {
       thinkingLevel: this.config.thinkingLevel
     });
     this.session = session;
-    console.log("[agent] session ready", {
+    logger4.info({
       sessionId: session.sessionId,
       sessionFile: session.sessionFile,
       restoredModel: session.model ? `${session.model.provider}/${session.model.id}` : null
-    });
+    }, "session ready");
   }
   async ensureConfiguredModel() {
     await this.ensureModelForSession(this.requireSession());
@@ -314,25 +379,25 @@ class AgentService {
   async ensureModelForSession(session) {
     const desiredModel = this.modelRegistry.find(this.config.modelProvider, this.config.modelId);
     const availableModels = await this.modelRegistry.getAvailable();
-    console.log("[agent] available models", {
+    logger4.debug({
       count: availableModels.length,
       matches: availableModels.filter((model) => {
         return model.provider === this.config.modelProvider;
       }).map((model) => `${model.provider}/${model.id}`)
-    });
+    }, "available models");
     if (!desiredModel) {
       throw new Error(`Configured model not found: ${this.config.modelProvider}/${this.config.modelId}. Check your pi agent config and installed extensions.`);
     }
     if (isSameModel(session.model, desiredModel)) {
-      console.log("[agent] model already selected", {
+      logger4.info({
         model: `${desiredModel.provider}/${desiredModel.id}`
-      });
+      }, "model already selected");
       return;
     }
-    console.log("[agent] switching model", {
+    logger4.info({
       from: session.model ? `${session.model.provider}/${session.model.id}` : null,
       to: `${desiredModel.provider}/${desiredModel.id}`
-    });
+    }, "switching model");
     await session.setModel(desiredModel);
     await this.applyConfiguredThinkingLevelForSession(session);
   }
@@ -350,14 +415,14 @@ class AgentService {
       const available = session.getAvailableThinkingLevels();
       if (available.includes(this.config.thinkingLevel)) {
         session.setThinkingLevel(this.config.thinkingLevel);
-        console.log("[agent] thinking level applied", {
+        logger4.info({
           level: this.config.thinkingLevel
-        });
+        }, "thinking level applied");
       } else {
-        console.log("[agent] thinking level not available for model", {
+        logger4.debug({
           requested: this.config.thinkingLevel,
           available
-        });
+        }, "thinking level not available for model");
       }
     }
   }
@@ -855,6 +920,7 @@ function normalizeContextValue(value) {
 }
 
 // src/discord-gateway-client.ts
+var logger5 = createModuleLogger("discord-gateway");
 function getAuthorDisplayName(message) {
   return message.member?.displayName || message.author.globalName || message.author.username;
 }
@@ -916,17 +982,18 @@ function stopTypingInterval(interval) {
 async function sendReply(message, text) {
   const channel = message.channel;
   if (!channel.isSendable()) {
-    console.log("[gateway] reply skipped, channel not sendable", {
+    logger5.debug({
       messageId: message.id
-    });
+    }, "reply skipped, channel not sendable");
     return;
   }
   const chunks = chunkMessage(text);
-  console.log("[gateway] sending reply", {
+  logger5.info({
+    direction: "OUT",
     messageId: message.id,
     chunkCount: chunks.length,
     textLength: text.length
-  });
+  }, "sending reply");
   const [firstChunk, ...remainingChunks] = chunks;
   if (!firstChunk) {
     return;
@@ -937,10 +1004,10 @@ async function sendReply(message, text) {
       await channel.send(chunk);
     }
   } catch (error) {
-    console.error("[gateway] send reply failed", {
+    logger5.error({
       messageId: message.id,
       error
-    });
+    }, "send reply failed");
   }
 }
 async function startGatewayClient(config, agentService, sessionRegistry, authConfig) {
@@ -954,7 +1021,7 @@ async function startGatewayClient(config, agentService, sessionRegistry, authCon
     partials: [Partials.Channel]
   });
   client.once(Events.ClientReady, async (readyClient) => {
-    console.log(`[gateway] logged in as ${readyClient.user.tag}`);
+    logger5.info({ userTag: readyClient.user.tag }, "logged in");
     if (!authConfig.startupMessage) {
       return;
     }
@@ -962,43 +1029,40 @@ async function startGatewayClient(config, agentService, sessionRegistry, authCon
       const user = await readyClient.users.fetch(authConfig.discordAllowedUserId);
       const dmChannel = await user.createDM();
       await dmChannel.send(authConfig.startupMessage);
-      console.log("[gateway] sent startup dm", {
+      logger5.info({
         userId: authConfig.discordAllowedUserId
-      });
+      }, "sent startup dm");
     } catch (error) {
-      console.error("[gateway] failed to send startup dm", error);
+      logger5.error({ error }, "failed to send startup dm");
     }
   });
   client.on(Events.MessageCreate, async (message) => {
-    if (message.channel.isThread()) {
-      console.log("[gateway:debug] thread message raw", {
-        messageId: message.id,
-        authorId: message.author.id,
-        authorTag: message.author.tag,
-        channelId: message.channel.id,
-        channelType: message.channel.type,
-        parentId: message.channel.parentId,
-        parentType: message.channel.parent?.type,
-        guildId: message.guild?.id,
-        content: message.content.slice(0, 500)
-      });
-    }
-    console.log("[gateway] message received", {
+    logger5.info({
+      direction: "IN",
       messageId: message.id,
       authorId: message.author.id,
       channelType: message.channel.type,
-      content: message.content.slice(0, 200)
+      preview: message.content.slice(0, 200)
+    }, "message received");
+    logPayload(logger5, {
+      direction: "IN",
+      label: "gateway message content",
+      content: message.content,
+      context: {
+        messageId: message.id,
+        authorId: message.author.id
+      }
     });
     try {
       await onMessage(message, config, agentService, sessionRegistry, authConfig);
     } catch (error) {
-      console.error("[gateway] message handling failed", error);
+      logger5.error({ error, direction: "IN" }, "message handling failed");
       await sendReply(message, "The bot hit an error while handling that message.");
     }
   });
   client.on(Events.ThreadDelete, async (thread) => {
     const scope = `thread:${thread.id}`;
-    console.log("[gateway] thread deleted", { threadId: thread.id, scope });
+    logger5.info({ threadId: thread.id, scope }, "thread deleted");
     await sessionRegistry.remove(scope);
   });
   await client.login(config.discordBotToken);
@@ -1006,41 +1070,41 @@ async function startGatewayClient(config, agentService, sessionRegistry, authCon
 }
 async function onMessage(message, config, agentService, sessionRegistry, authConfig) {
   if (message.author.bot) {
-    console.log("[gateway] ignored bot message", { messageId: message.id });
+    logger5.debug({ messageId: message.id }, "ignored bot message");
     return;
   }
   if (message.system) {
-    console.log("[gateway] ignored system message", { messageId: message.id });
+    logger5.debug({ messageId: message.id }, "ignored system message");
     return;
   }
   const scope = resolveScope(message);
   if (scope === null) {
-    console.log("[gateway] unsupported channel type, ignoring", {
+    logger5.debug({
       messageId: message.id,
       channelType: message.channel.type
-    });
+    }, "unsupported channel type, ignoring");
     return;
   }
   if (!isAuthorized(message, scope, authConfig)) {
-    console.log("[gateway] unauthorized", {
+    logger5.debug({
       messageId: message.id,
       authorId: message.author.id,
       scope
-    });
+    }, "unauthorized");
     return;
   }
   const content = message.content.trim();
   if (!content) {
-    console.log("[gateway] ignored empty message", { messageId: message.id });
+    logger5.debug({ messageId: message.id }, "ignored empty message");
     return;
   }
   const { entry, created } = await sessionRegistry.getOrCreate(scope);
   const { session, promptQueue } = entry;
   if (created && scope.startsWith("thread:") && message.channel.isThread()) {
-    console.log("[gateway] new thread session", {
+    logger5.info({
       scope,
       threadName: message.channel.name
-    });
+    }, "new thread session");
   }
   let typingInterval = null;
   if (message.channel.isSendable()) {
@@ -1054,7 +1118,7 @@ async function onMessage(message, config, agentService, sessionRegistry, authCon
   if (commandResult.handled) {
     stopTypingInterval(typingInterval);
     if (commandResult.archive && scope.startsWith("thread:")) {
-      console.log("[gateway] archiving thread", { scope });
+      logger5.info({ scope }, "archiving thread");
       const archiveChannel = message.channel;
       if (archiveChannel.isSendable()) {
         await archiveChannel.send(commandResult.response ?? "Archiving...");
@@ -1064,16 +1128,16 @@ async function onMessage(message, config, agentService, sessionRegistry, authCon
           await archiveChannel.setArchived(true);
         }
       } catch (error) {
-        console.error("[gateway] failed to archive thread", error);
+        logger5.error({ error }, "failed to archive thread");
       }
       await sessionRegistry.remove(scope);
       return;
     }
-    console.log("[gateway] command handled", {
+    logger5.info({
       messageId: message.id,
       command: content,
       hasResponse: Boolean(commandResult.response)
-    });
+    }, "command handled");
     if (commandResult.response) {
       await sendReply(message, commandResult.response);
     }
@@ -1081,32 +1145,54 @@ async function onMessage(message, config, agentService, sessionRegistry, authCon
   }
   if (!message.channel.isSendable()) {
     stopTypingInterval(typingInterval);
-    console.log("[gateway] channel not sendable", { messageId: message.id });
+    logger5.debug({ messageId: message.id }, "channel not sendable");
     return;
   }
   const queuePosition = promptQueue.getSnapshot().pending;
-  console.log("[queue] enqueue request", {
+  logger5.debug({
     scope,
     messageId: message.id,
     queuePosition
-  });
+  }, "enqueue request");
   if (queuePosition > 0) {
     await sendReply(message, `Queued. ${queuePosition} request(s) ahead of this one.`);
   }
   const response = await promptQueue.enqueue(async () => {
-    console.log(`[queue] processing message ${message.id} in scope ${scope}`);
+    logger5.debug({
+      messageId: message.id,
+      scope
+    }, "processing message");
     const promptContent = buildDiscordPromptContent(message, scope, content, config);
+    logPayload(logger5, {
+      direction: "IN",
+      label: "gateway prompt content",
+      content: promptContent,
+      context: {
+        scope,
+        messageId: message.id
+      }
+    });
     const transformedPrompt = await config.promptTransform(promptContent);
     return collectReply(session, transformedPrompt, {
       logPrefix: `[agent:${session.sessionId}]`
     });
   });
   stopTypingInterval(typingInterval);
-  console.log("[gateway] response ready", {
+  logger5.info({
+    direction: "OUT",
     scope,
     messageId: message.id,
     responseLength: response.length,
     preview: response.slice(0, 200)
+  }, "response ready");
+  logPayload(logger5, {
+    direction: "OUT",
+    label: "gateway response content",
+    content: response,
+    context: {
+      scope,
+      messageId: message.id
+    }
   });
   await sendReply(message, response);
 }
@@ -1163,6 +1249,7 @@ function sessionDirForScope(agentDir, scope) {
   }
   throw new Error(`Unknown session scope: ${scope}`);
 }
+var logger6 = createModuleLogger("session-registry");
 
 class SessionRegistry {
   scopes = new Map;
@@ -1184,11 +1271,11 @@ class SessionRegistry {
       createdAt: new Date
     };
     this.scopes.set(scope, entry);
-    console.log("[session-registry] scope registered", {
+    logger6.info({
       scope,
       sessionDir,
       sessionId: session.sessionId
-    });
+    }, "scope registered");
     return { entry, created: true };
   }
   async remove(scope) {
@@ -1196,7 +1283,7 @@ class SessionRegistry {
     if (!entry) {
       return;
     }
-    console.log("[session-registry] removing scope", { scope });
+    logger6.info({ scope }, "removing scope");
     await entry.session.abort();
     entry.session.dispose();
     this.scopes.delete(scope);
@@ -1208,7 +1295,7 @@ class SessionRegistry {
     return Array.from(this.scopes.keys());
   }
   async shutdownAll() {
-    console.log("[session-registry] shutting down all scopes", this.scopes.size);
+    logger6.info({ count: this.scopes.size }, "shutting down all scopes");
     const scopes = Array.from(this.scopes.keys());
     for (const scope of scopes) {
       await this.remove(scope);
@@ -1217,12 +1304,13 @@ class SessionRegistry {
 }
 
 // src/index.ts
+var logger7 = createModuleLogger("index");
 async function startDiscordGateway(config) {
   const resolvedConfig = resolveGatewayConfig(config);
   const agentService = new AgentService(resolvedConfig);
-  console.log("[gateway] initializing agent service");
+  logger7.info("initializing agent service");
   await agentService.initialize();
-  console.log("[gateway] agent ready", agentService.getStatus());
+  logger7.info(agentService.getStatus(), "agent ready");
   const authConfig = {
     discordAllowedUserId: resolvedConfig.discordAllowedUserId,
     discordAllowedForumChannelIds: resolvedConfig.discordAllowedForumChannelIds,
@@ -1253,10 +1341,10 @@ function createGatewayStopHandler(client, agentService, sessionRegistry, config)
       return;
     }
     stopped = true;
-    console.log("[shutdown] stopping discord gateway", {
+    logger7.info({
       cwd: config.cwd,
       agentDir: config.agentDir
-    });
+    }, "stopping discord gateway");
     client.destroy();
     await sessionRegistry.shutdownAll();
     await agentService.shutdown();
@@ -1264,9 +1352,9 @@ function createGatewayStopHandler(client, agentService, sessionRegistry, config)
 }
 function registerSignalHandlers(stop) {
   const handleSignal = (signal) => {
-    console.log(`[shutdown] received ${signal}`);
+    logger7.info({ signal }, "received signal");
     stop().finally(() => {
-      console.log("[shutdown] done");
+      logger7.info("done");
       process.exit(0);
     });
   };

package/dist/logger.d.ts

@@ -0,0 +1,11 @@
+import { type Logger } from "pino";
+export declare const logger: Logger<never, boolean>;
+export declare function createModuleLogger(moduleName: string): Logger;
+type PayloadLogOptions = {
+    direction: "IN" | "OUT";
+    label: string;
+    content: string;
+    context?: Record<string, unknown>;
+};
+export declare function logPayload(targetLogger: Logger, options: PayloadLogOptions): void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friendlyrobot/discord-pi-agent",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Reusable Discord gateway bridge for persistent pi agent sessions",
   "license": "MIT",
   "type": "module",
@@ -40,11 +40,13 @@
     "discord.js": "^14.26.4",
     "dotenv": "^17.4.2",
     "marked": "^18.0.3",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
     "prettier": "^3.8.3"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",
-    "@typescript/native-preview": "^7.0.0-dev.20260504.1",
+    "@typescript/native-preview": "^7.0.0-dev.20260506.1",
     "@vitest/ui": "^4.1.5",
     "vitest": "^4.1.5"
   }