@keyou007/agent-bot 0.1.15-alpha.0 → 0.1.15-alpha.1

package/src/feishu/FeishuMarkdown.ts

@@ -1,3 +1,5 @@
+import path from "node:path";
+
 interface FenceState {
   indent: string;
   marker: "`" | "~";
@@ -9,7 +11,7 @@ const FENCE_OPENER = /^([ \t]*)((?:`{3,})|(?:~{3,}))(.*)$/;
 const MARKDOWN_LINK = /(!?)\[([^\]\r\n]*)\]\((<?[^)\r\n]+>?)\)/g;
 const LOCAL_FILE_LINE_REFERENCE = /(:\d+(?::\d+)?)$/;
 
-export function normalizeFeishuMarkdown(markdown: string): string {
+export function normalizeFeishuMarkdown(markdown: string, projectCwd?: string): string {
   const lines = markdown.match(/[^\r\n]*(?:\r\n|\n)|[^\r\n]+$/g) ?? [];
   let fence: FenceState | undefined;
 
@@ -19,7 +21,7 @@ export function normalizeFeishuMarkdown(markdown: string): string {
 
     if (!fence) {
       const opener = FENCE_OPENER.exec(body);
-      if (!opener?.[2]) return `${includeLocalFileLineReferences(body)}${ending}`;
+      if (!opener?.[2]) return `${includeLocalFileLineReferences(body, projectCwd)}${ending}`;
 
       const indent = opener[1] ?? "";
       const delimiter = opener[2];
@@ -40,7 +42,7 @@ export function normalizeFeishuMarkdown(markdown: string): string {
   }).join("");
 }
 
-function includeLocalFileLineReferences(markdown: string): string {
+function includeLocalFileLineReferences(markdown: string, projectCwd?: string): string {
   return markdown.replace(MARKDOWN_LINK, (link, imageMarker: string, label: string, rawTarget: string) => {
     if (imageMarker) return link;
 
@@ -48,11 +50,68 @@ function includeLocalFileLineReferences(markdown: string): string {
     if (!isLocalFileTarget(target)) return link;
 
     const reference = LOCAL_FILE_LINE_REFERENCE.exec(target)?.[1];
-    if (!reference || label.endsWith(reference)) return link;
-    return `[${label}${reference}](${rawTarget})`;
+    const projectPathLabel = projectCwd ? projectFilePathLabel(target, projectCwd, reference) : undefined;
+    const normalizedLabel = projectPathLabel
+      ?? (reference && !label.endsWith(reference) ? `${label}${reference}` : label);
+    return normalizedLabel === label ? link : `[${normalizedLabel}](${rawTarget})`;
   });
 }
 
+function projectFilePathLabel(
+  target: string,
+  projectCwd: string,
+  reference: string | undefined,
+): string | undefined {
+  const targetWithoutReference = reference ? target.slice(0, -reference.length) : target;
+  const filePath = localFilePath(targetWithoutReference);
+  if (!filePath) return undefined;
+  if (!isInsideProject(filePath, projectCwd)) {
+    return `${displayAbsolutePath(filePath)}${reference ?? ""}`;
+  }
+
+  const pathApi = usesWindowsPaths(filePath, projectCwd) ? path.win32 : path.posix;
+  const parsed = pathApi.parse(filePath);
+  if (Array.from(parsed.name).length > 5) return undefined;
+
+  const parentName = pathApi.basename(pathApi.dirname(filePath));
+  if (!parentName) return undefined;
+  return `${parentName}${pathApi.sep}${parsed.base}${reference ?? ""}`;
+}
+
+function localFilePath(target: string): string | undefined {
+  if (!/^file:\/\//i.test(target)) return normalizeWindowsDrivePrefix(target);
+
+  let value = target.slice("file://".length);
+  try {
+    value = decodeURIComponent(value);
+  } catch {
+    // Keep malformed percent escapes visible instead of dropping the link.
+  }
+  if (/^\/[a-z]:[\\/]/i.test(value)) return value.slice(1);
+  if (value.startsWith("/")) return value;
+  return `//${value}`;
+}
+
+function normalizeWindowsDrivePrefix(value: string): string {
+  return /^\/[a-z]:[\\/]/i.test(value) ? value.slice(1) : value;
+}
+
+function isInsideProject(filePath: string, projectCwd: string): boolean {
+  const pathApi = usesWindowsPaths(filePath, projectCwd) ? path.win32 : path.posix;
+  const relative = pathApi.relative(pathApi.resolve(projectCwd), pathApi.resolve(filePath));
+  return relative === ""
+    || (relative !== ".." && !relative.startsWith(`..${pathApi.sep}`) && !pathApi.isAbsolute(relative));
+}
+
+function displayAbsolutePath(filePath: string): string {
+  if (!usesWindowsPaths(filePath)) return path.posix.normalize(filePath);
+  return path.win32.normalize(filePath);
+}
+
+function usesWindowsPaths(...values: string[]): boolean {
+  return values.some((value) => /^\/?[a-z]:[\\/]/i.test(value) || /^\\\\/.test(value));
+}
+
 function unwrapMarkdownTarget(target: string): string {
   return target.startsWith("<") && target.endsWith(">") ? target.slice(1, -1) : target;
 }

package/src/feishu/FeishuMessageClient.ts

@@ -7,6 +7,7 @@ import type { AppConfig } from "../config/schema.js";
 import { normalizeFeishuMarkdown } from "./FeishuMarkdown.js";
 import { LOCAL_CARD_IMAGE_PATH } from "./LocalCardImage.js";
 import { renderMarkdownWithLocalImages } from "./LocalImageMarkdown.js";
+import { splitFinalResponseBranding } from "./FinalResponseBranding.js";
 import {
   renderMergedForwardPrompt,
   renderReferencedMessage,
@@ -101,6 +102,7 @@ export class FeishuMessageClient implements FeishuOutbound {
     expiresAt: number;
   };
   private readonly sendQueues = new Map<string, Promise<void>>();
+  private readonly cardUpdateQueues = new Map<string, Promise<void>>();
   private readonly lastSendAt = new Map<string, number>();
   private readonly imageUploads = new Map<string, { mtimeMs: number; upload: Promise<string> }>();
   private readonly imageDownloads = new Map<string, Promise<string>>();
@@ -288,11 +290,7 @@ export class FeishuMessageClient implements FeishuOutbound {
 
   async sendMarkdown(contextKey: string, markdown: string, idempotencyKey?: string): Promise<string | undefined> {
     const normalizedMarkdown = normalizeFeishuMarkdown(markdown);
-    const elements = await renderMarkdownWithLocalImages(
-      normalizedMarkdown,
-      (filePath) => this.uploadImageCached(filePath),
-      (error, filePath) => this.logger.warn({ error, filePath }, "Failed to upload local image to Feishu."),
-    );
+    const elements = await this.renderFinalAnswerElements(normalizedMarkdown);
     return this.sendMessage(
       contextKey,
       "interactive",
@@ -334,11 +332,7 @@ export class FeishuMessageClient implements FeishuOutbound {
     idempotencyKey?: string,
   ): Promise<string | undefined> {
     const normalizedMarkdown = normalizeFeishuMarkdown(markdown);
-    const elements = await renderMarkdownWithLocalImages(
-      normalizedMarkdown,
-      (filePath) => this.uploadImageCached(filePath),
-      (error, filePath) => this.logger.warn({ error, filePath }, "Failed to upload local image to Feishu."),
-    );
+    const elements = await this.renderFinalAnswerElements(normalizedMarkdown);
     return this.replyMessage(
       contextKey,
       target,
@@ -364,9 +358,28 @@ export class FeishuMessageClient implements FeishuOutbound {
     );
   }
 
+  private async renderFinalAnswerElements(markdown: string): Promise<Array<Record<string, unknown>>> {
+    const { content, branding } = splitFinalResponseBranding(markdown);
+    const elements = content
+      ? await renderMarkdownWithLocalImages(
+        content,
+        (filePath) => this.uploadImageCached(filePath),
+        (error, filePath) => this.logger.warn({ error, filePath }, "Failed to upload local image to Feishu."),
+      )
+      : [];
+    if (!branding) return elements;
+    return [
+      ...elements,
+      { tag: "hr" },
+      { tag: "markdown", content: branding, text_size: "notation" },
+    ];
+  }
+
   async updateInteractiveCard(messageId: string, card: Record<string, unknown>): Promise<void> {
-    const preparedCard = await this.prepareInteractiveCard(card);
-    await this.updateInteractiveCardNow(messageId, preparedCard);
+    await this.enqueueCardUpdate(messageId, async () => {
+      const preparedCard = await this.prepareInteractiveCard(card);
+      await this.updateInteractiveCardNow(messageId, preparedCard);
+    });
   }
 
   private async updateInteractiveCardNow(
@@ -626,6 +639,22 @@ export class FeishuMessageClient implements FeishuOutbound {
     return queued;
   }
 
+  private enqueueCardUpdate(messageId: string, task: () => Promise<void>): Promise<void> {
+    const previous = this.cardUpdateQueues.get(messageId) ?? Promise.resolve();
+    const queued = previous.catch(() => undefined).then(task);
+    const stored = queued.then(
+      () => undefined,
+      () => undefined,
+    );
+    this.cardUpdateQueues.set(messageId, stored);
+    stored.finally(() => {
+      if (this.cardUpdateQueues.get(messageId) === stored) {
+        this.cardUpdateQueues.delete(messageId);
+      }
+    });
+    return queued;
+  }
+
   private async getTenantAccessToken(): Promise<string> {
     const now = Date.now();
     if (this.token && this.token.expiresAt > now + 60_000) {

package/src/feishu/FeishuTurnPresenter.ts

@@ -8,7 +8,11 @@ import { splitMarkdown } from "../presentation/splitMarkdown.js";
 import type { TurnViewState } from "../presentation/turnViewTypes.js";
 import { CardRenderer } from "./CardRenderer.js";
 import { CardUpdateScheduler } from "./CardUpdateScheduler.js";
+import { normalizeFeishuMarkdown } from "./FeishuMarkdown.js";
 import type { FeishuOutbound, MessageReplyTarget } from "./types.js";
+import {
+  FINAL_RESPONSE_BRANDING_BLOCK,
+} from "./FinalResponseBranding.js";
 import { createId } from "../utils/id.js";
 import { createHash } from "node:crypto";
 
@@ -50,7 +54,6 @@ export interface FeishuTurnPresenterOptions {
 
 const MAX_FINAL_TABLES_PER_CARD = 5;
 const DEFAULT_ELAPSED_UPDATE_INTERVAL_MS = 3_000;
-const FINAL_RESPONSE_BRANDING = "> Powered by [AgentBot](https://github.com/keyou/agent-bot)";
 const FINAL_RESPONSE_BRANDING_MIN_LENGTH = 1_000;
 
 interface TurnEntry {
@@ -536,7 +539,7 @@ export class FeishuTurnPresenter {
     if (delivery?.finalDelivered || !state.finalResponse) return;
     const finalChunkLength = this.options.finalChunkLength ?? 4_000;
     const chunks = brandedFinalChunks(
-      state.finalResponse,
+      normalizeFeishuMarkdown(state.finalResponse, state.projectCwd),
       finalChunkLength,
     );
     const messageIds = [...(delivery?.finalMessageIds ?? [])];
@@ -582,17 +585,17 @@ function brandedFinalChunks(response: string, maxLength: number): string[] {
 
   const last = chunks.pop();
   if (last === undefined) return chunks;
-  const reservedLength = FINAL_RESPONSE_BRANDING.length + 2;
+  const reservedLength = FINAL_RESPONSE_BRANDING_BLOCK.length + 2;
   const brandedContentLimit = maxLength - reservedLength;
-  if (brandedContentLimit < 32) return [...chunks, last, FINAL_RESPONSE_BRANDING];
+  if (brandedContentLimit < 32) return [...chunks, last, FINAL_RESPONSE_BRANDING_BLOCK];
 
   const lastParts = splitMarkdown(last, brandedContentLimit, MAX_FINAL_TABLES_PER_CARD);
   const lastContent = lastParts.pop();
   if (lastContent === undefined || lastContent.length > brandedContentLimit) {
-    return [...chunks, ...lastParts, lastContent ?? last, FINAL_RESPONSE_BRANDING];
+    return [...chunks, ...lastParts, lastContent ?? last, FINAL_RESPONSE_BRANDING_BLOCK];
   }
   const separator = lastContent.endsWith("\n\n") ? "" : lastContent.endsWith("\n") ? "\n" : "\n\n";
-  return [...chunks, ...lastParts, `${lastContent}${separator}${FINAL_RESPONSE_BRANDING}`];
+  return [...chunks, ...lastParts, `${lastContent}${separator}${FINAL_RESPONSE_BRANDING_BLOCK}`];
 }
 
 function eventPriority(event: AgentEvent): "normal" | "critical" {

package/src/feishu/FinalResponseBranding.ts

@@ -0,0 +1,18 @@
+export const FINAL_RESPONSE_BRANDING = "> Powered by [AgentBot](https://github.com/keyou/agent-bot)";
+export const FINAL_RESPONSE_BRANDING_BLOCK = `----\n\n${FINAL_RESPONSE_BRANDING}`;
+
+export function splitFinalResponseBranding(markdown: string): {
+  content: string;
+  branding?: string;
+} {
+  if (markdown === FINAL_RESPONSE_BRANDING_BLOCK) {
+    return { content: "", branding: FINAL_RESPONSE_BRANDING };
+  }
+
+  const suffix = `\n\n${FINAL_RESPONSE_BRANDING_BLOCK}`;
+  if (!markdown.endsWith(suffix)) return { content: markdown };
+  return {
+    content: markdown.slice(0, -suffix.length),
+    branding: FINAL_RESPONSE_BRANDING,
+  };
+}

package/src/logging/DailyLogStream.ts

@@ -0,0 +1,88 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Writable } from "node:stream";
+
+interface DailyLogStreamOptions {
+  clock?: () => Date;
+  mode?: number;
+  beforeOpen?: (filePath: string) => void;
+}
+
+export class DailyLogStream extends Writable {
+  private currentPath?: string;
+  private lastPath?: string;
+  private currentStream?: fs.WriteStream;
+  private readonly clock: () => Date;
+
+  constructor(
+    private readonly basePath: string,
+    private readonly options: DailyLogStreamOptions = {},
+  ) {
+    super();
+    this.clock = options.clock ?? (() => new Date());
+  }
+
+  get filePath(): string | undefined {
+    return this.currentPath ?? this.lastPath;
+  }
+
+  override _write(
+    chunk: string | Buffer,
+    encoding: BufferEncoding,
+    callback: (error?: Error | null) => void,
+  ): void {
+    let stream: fs.WriteStream;
+    try {
+      stream = this.streamFor(this.clock());
+    } catch (error) {
+      callback(error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
+    stream.write(chunk, encoding, callback);
+  }
+
+  override _final(callback: (error?: Error | null) => void): void {
+    const stream = this.currentStream;
+    this.currentStream = undefined;
+    this.currentPath = undefined;
+    if (!stream) {
+      callback();
+      return;
+    }
+    stream.end(callback);
+  }
+
+  override _destroy(error: Error | null, callback: (error?: Error | null) => void): void {
+    this.currentStream?.destroy();
+    this.currentStream = undefined;
+    this.currentPath = undefined;
+    callback(error);
+  }
+
+  private streamFor(date: Date): fs.WriteStream {
+    const targetPath = dailyLogPath(this.basePath, date);
+    if (this.currentStream && this.currentPath === targetPath) return this.currentStream;
+
+    const previous = this.currentStream;
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    this.options.beforeOpen?.(targetPath);
+    this.currentPath = targetPath;
+    this.lastPath = targetPath;
+    this.currentStream = fs.createWriteStream(targetPath, {
+      flags: "a",
+      ...(this.options.mode === undefined ? {} : { mode: this.options.mode }),
+    });
+    previous?.end();
+    return this.currentStream;
+  }
+}
+
+export function dailyLogPath(basePath: string, date: Date): string {
+  const parsed = path.parse(basePath);
+  const dateStamp = [
+    date.getFullYear(),
+    String(date.getMonth() + 1).padStart(2, "0"),
+    String(date.getDate()).padStart(2, "0"),
+  ].join("-");
+  return path.join(parsed.dir, `${parsed.name}.${dateStamp}${parsed.ext}`);
+}

package/src/logging/logger.ts

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import pino, { type Logger } from "pino";
 import type { AppConfig } from "../config/schema.js";
+import { DailyLogStream } from "./DailyLogStream.js";
 
 export function createLogger(config: AppConfig): Logger {
   const streams: pino.StreamEntry[] = [
@@ -13,7 +14,7 @@ export function createLogger(config: AppConfig): Logger {
   if (config.logging.path) {
     fs.mkdirSync(path.dirname(config.logging.path), { recursive: true });
     streams.push({
-      stream: fs.createWriteStream(config.logging.path, { flags: "a" }),
+      stream: new DailyLogStream(config.logging.path),
     });
   }