pim-agent 0.0.1 → 0.10.0

package/packages/telegram/src/Config.ts

@@ -0,0 +1,148 @@
+import { join } from "node:path";
+
+import { Cli as Argv } from "#core/shared/Cli";
+import { Fs } from "#core/shared/Fs";
+import { Paths } from "#core/shared/Paths";
+
+export type Cli = {
+  readonly token?: string;
+  readonly allow?: string;
+  readonly cwd?: string;
+  readonly model?: string;
+  readonly configDir?: string;
+  readonly printConfig: boolean;
+};
+
+export type TelegramConfig = {
+  readonly token: string;
+  readonly allow: ReadonlyArray<number>;
+  readonly cwd: string;
+  readonly model?: string;
+  readonly configDir: string;
+};
+
+export const THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+] as const;
+export type ThinkingLevelOpt = (typeof THINKING_LEVELS)[number];
+
+export const LOGS_MODES = ["off", "tool", "text", "verbose"] as const;
+export type LogsMode = (typeof LOGS_MODES)[number];
+
+function parseArgs(args: ReadonlyArray<string>): Cli {
+  let token: string | undefined;
+  let allow: string | undefined;
+  let cwd: string | undefined;
+  let model: string | undefined;
+  let configDir: string | undefined;
+  let printConfig = false;
+
+  Argv.scan(args, (key, take) => {
+    switch (key) {
+      case "--token":
+        token = take();
+        break;
+      case "--allow":
+        allow = take();
+        break;
+      case "--cwd":
+        cwd = take();
+        break;
+      case "--model":
+        model = take();
+        break;
+      case "--config-dir":
+        configDir = take();
+        break;
+      case "--print-config":
+        printConfig = true;
+        break;
+      case "--mode":
+        take();
+        break;
+    }
+  });
+  return { token, allow, cwd, model, configDir, printConfig };
+}
+
+async function load(cli: Cli): Promise<TelegramConfig> {
+  const configDir = cli.configDir ?? join(Paths.pimHomeDir(), "telegram");
+
+  const filePath = join(configDir, "config.json");
+  const fileConfig = await Fs.readJsonOrEmpty<Partial<TelegramConfig>>(
+    filePath,
+    {}
+  );
+
+  const token =
+    cli.token ?? process.env.PIM_TELEGRAM_BOT_TOKEN ?? fileConfig.token;
+  if (!token) {
+    throw new Error(
+      "Bot token required (set --token, PIM_TELEGRAM_BOT_TOKEN, or 'token' in config.json)"
+    );
+  }
+
+  const allowSrc = cli.allow ?? process.env.PIM_TELEGRAM_ALLOW;
+  const allow = allowSrc
+    ? parseAllow(allowSrc)
+    : normalizeAllow(fileConfig.allow);
+
+  const cwd = cli.cwd ?? fileConfig.cwd ?? process.cwd();
+  const model = cli.model ?? fileConfig.model;
+
+  return { token, allow, cwd, model, configDir };
+}
+
+async function save(config: TelegramConfig): Promise<void> {
+  const filePath = join(config.configDir, "config.json");
+  const data = JSON.stringify(
+    {
+      token: config.token,
+      allow: config.allow,
+      cwd: config.cwd,
+      model: config.model,
+    },
+    null,
+    2
+  );
+  await Fs.writeAtomic(filePath, data, 0o600);
+}
+
+function parseAllow(s: string): ReadonlyArray<number> {
+  return s
+    .split(",")
+    .map((x) => x.trim())
+    .filter((x) => x.length > 0)
+    .map((x) => {
+      const n = Number(x);
+      if (!Number.isFinite(n)) {
+        throw new Error(`Invalid chat ID in allow list: ${x}`);
+      }
+      return n;
+    });
+}
+
+function normalizeAllow(value: unknown): ReadonlyArray<number> {
+  if (value === undefined || value === null) {
+    return [];
+  }
+  if (typeof value === "string") {
+    return parseAllow(value);
+  }
+  if (typeof value === "number") {
+    return parseAllow(String(value));
+  }
+  if (Array.isArray(value)) {
+    return parseAllow(value.join(","));
+  }
+  throw new Error(
+    `Invalid 'allow' in config.json: expected number, string, or array, got ${typeof value}`
+  );
+}
+
+export const Config = { parseArgs, load, save };

package/packages/telegram/src/Markdown.ts

@@ -0,0 +1,235 @@
+import { MarkdownPainter } from "#core/view/MarkdownPainter";
+
+type Align = "left" | "center" | "right";
+
+type TableRow = ReadonlyArray<string>;
+
+type Segment =
+  | { readonly kind: "md"; readonly text: string }
+  | {
+      readonly kind: "table";
+      readonly rows: ReadonlyArray<TableRow>;
+      readonly aligns: ReadonlyArray<Align | undefined>;
+    };
+
+type RenderOptions = {
+  readonly italics?: boolean;
+};
+
+const SAFE_LINK = /^(https?:|tg:|mailto:)/i;
+
+// Bun's GFM strikes on a lone `~`; Telegram and CommonMark require `~~`.
+const STRIKETHROUGH = /(?<!~)~~(?!~)((?:[^~]|~(?!~))+?)~~(?!~)/g;
+
+function toHtml(md: string, options: RenderOptions = {}): string {
+  const segments = split(md);
+  let out = "";
+  for (const seg of segments) {
+    out +=
+      seg.kind === "md"
+        ? renderMd(seg.text, options)
+        : renderTable(seg.rows, seg.aligns);
+  }
+  return out.trim();
+}
+
+function escape(s: string): string {
+  return MarkdownPainter.escape(s);
+}
+
+const RENDERERS = {
+  text: (c: string): string => escape(c).replace(STRIKETHROUGH, "<s>$1</s>"),
+  paragraph: (c: string): string => `<p>${c}</p>`,
+  heading: (c: string, meta?: { level?: number }): string => {
+    const level = Math.min(6, Math.max(1, meta?.level ?? 1));
+    return `<h${level}>${c}</h${level}>`;
+  },
+  strong: (c: string): string => `<b>${c}</b>`,
+  emphasis: (c: string): string => `<i>${c}</i>`,
+  codespan: (c: string): string => `<code>${c}</code>`,
+  code: (c: string, meta?: { language?: string }): string => {
+    const body = c.replace(/\n+$/, "");
+    const lang = meta?.language;
+    if (lang === "math") {
+      return `<tg-math-block>${body}</tg-math-block>`;
+    }
+    const open = lang
+      ? `<pre><code class="language-${escape(lang)}">`
+      : "<pre>";
+    const close = lang ? "</code></pre>" : "</pre>";
+    return `${open}${body}${close}`;
+  },
+  link: (c: string, meta?: { href?: string }): string => {
+    const href = meta?.href ?? "";
+    return SAFE_LINK.test(href) ? `<a href="${escape(href)}">${c}</a>` : c;
+  },
+  image: (c: string, meta?: { src?: string }): string => {
+    const src = meta?.src ?? "";
+    const alt = c || src;
+    return SAFE_LINK.test(src) ? `<a href="${escape(src)}">${alt}</a>` : alt;
+  },
+  blockquote: (c: string): string => `<blockquote>${c}</blockquote>`,
+  list: (c: string, meta?: { ordered?: boolean; start?: number }): string => {
+    if (meta?.ordered) {
+      const start = meta.start ?? 1;
+      const startAttr = start > 1 ? ` start="${start}"` : "";
+      return `<ol${startAttr}>${c}</ol>`;
+    }
+    return `<ul>${c}</ul>`;
+  },
+  listItem: (c: string, meta?: { checked?: boolean }): string =>
+    listItemHtml(c.replace(/\n+$/, ""), meta?.checked),
+  hr: (): string => "<hr/>",
+  br: (): string => "<br>",
+  table: (c: string): string => c,
+};
+
+const ITALIC_RENDERERS = {
+  ...RENDERERS,
+  paragraph: (c: string): string => `<p>${italic(c)}</p>`,
+  heading: (c: string, meta?: { level?: number }): string => {
+    const level = Math.min(6, Math.max(1, meta?.level ?? 1));
+    return `<h${level}>${italic(c)}</h${level}>`;
+  },
+  listItem: (c: string, meta?: { checked?: boolean }): string =>
+    listItemHtml(italicListItemBody(c.replace(/\n+$/, "")), meta?.checked),
+};
+
+function listItemHtml(body: string, checked?: boolean): string {
+  if (checked === true) {
+    return `<li><input type="checkbox" checked> ${body}</li>`;
+  }
+  if (checked === false) {
+    return `<li><input type="checkbox"> ${body}</li>`;
+  }
+  return `<li>${body}</li>`;
+}
+
+function renderMd(md: string, options: RenderOptions = {}): string {
+  if (!md.trim()) {
+    return "";
+  }
+  return Bun.markdown.render(md, renderers(options), {
+    strikethrough: false,
+  });
+}
+
+function renderers(options: RenderOptions): typeof RENDERERS {
+  return options.italics ? ITALIC_RENDERERS : RENDERERS;
+}
+
+function italic(text: string): string {
+  return text ? `<i>${text}</i>` : "";
+}
+
+// Italicize only the leading text: a child <ul>/<ol> inside <i> is invalid HTML.
+function italicListItemBody(body: string): string {
+  const nestedListIndex = body.search(/<(?:ul|ol)\b/);
+  if (nestedListIndex < 0) {
+    return italic(body);
+  }
+  const before = body.slice(0, nestedListIndex);
+  return `${italic(before)}${body.slice(nestedListIndex)}`;
+}
+
+function renderInline(md: string): string {
+  return renderMd(md)
+    .replace(/^<p>/, "")
+    .replace(/<\/p>$/, "")
+    .trim();
+}
+
+function split(md: string): ReadonlyArray<Segment> {
+  const lines = md.split("\n");
+  const segments: Segment[] = [];
+  let buf: string[] = [];
+
+  const flushMd = (): void => {
+    if (buf.length > 0) {
+      segments.push({ kind: "md", text: buf.join("\n") });
+      buf = [];
+    }
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    const next = lines[i + 1];
+    if (isPipeLine(line) && next !== undefined && isTableSeparator(next)) {
+      flushMd();
+      const rows: string[][] = [parseRow(line)];
+      const aligns = parseAligns(next);
+      i += 1;
+      while (i + 1 < lines.length && isPipeLine(lines[i + 1]!)) {
+        i += 1;
+        rows.push(parseRow(lines[i]!));
+      }
+      segments.push({ kind: "table", rows, aligns });
+      continue;
+    }
+    buf.push(line);
+  }
+  flushMd();
+  return segments;
+}
+
+function isPipeLine(line: string): boolean {
+  return /^\s*\|.*\|\s*$/.test(line);
+}
+
+function isTableSeparator(line: string): boolean {
+  return /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)+\|?\s*$/.test(line);
+}
+
+function parseRow(line: string): string[] {
+  const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+  return trimmed.split("|").map((cell) => cell.trim());
+}
+
+function parseAligns(sep: string): (Align | undefined)[] {
+  return parseRow(sep).map((cell) => {
+    const left = cell.startsWith(":");
+    const right = cell.endsWith(":");
+    if (left && right) {
+      return "center";
+    }
+    if (right) {
+      return "right";
+    }
+    if (left) {
+      return "left";
+    }
+    return undefined;
+  });
+}
+
+function renderTable(
+  rows: ReadonlyArray<TableRow>,
+  aligns: ReadonlyArray<Align | undefined>
+): string {
+  if (rows.length < 2) {
+    return "";
+  }
+  const header = rows[0]!;
+  const dataRows = rows.slice(1);
+  if (dataRows.length === 0) {
+    return "";
+  }
+  const attr = (col: number): string => {
+    const align = aligns[col];
+    return align ? ` align="${align}"` : "";
+  };
+  const cells = (row: TableRow, tag: "th" | "td"): string =>
+    header
+      .map((_, c) => `<${tag}${attr(c)}>${renderInline(row[c] ?? "")}</${tag}>`)
+      .join("");
+
+  let out = "<table>";
+  out += `<tr>${cells(header, "th")}</tr>`;
+  for (const row of dataRows) {
+    out += `<tr>${cells(row, "td")}</tr>`;
+  }
+  out += "</table>";
+  return out;
+}
+
+export const Markdown = { toHtml, escape };

package/packages/telegram/src/Message.ts

@@ -0,0 +1,152 @@
+import type { PromptOptions } from "@earendil-works/pi-coding-agent";
+import type { Context, Filter } from "grammy";
+import { extname, join } from "node:path";
+
+import {
+  AttachmentStore,
+  type StoredAttachment,
+} from "#core/attachments/AttachmentStore";
+import { Attachments } from "#core/attachments/Attachments";
+import type { SessionId } from "./Session";
+
+type FileRef = {
+  readonly fileId: string;
+  readonly uniqueId?: string;
+  readonly name?: string;
+  readonly mimeType: string;
+  readonly ext: string;
+};
+
+export type Prompt = {
+  readonly text: string;
+  readonly options: Pick<PromptOptions, "images">;
+};
+
+const REPLY_QUOTE_HEAD = 128;
+const REPLY_QUOTE_TAIL = 128;
+
+async function toPrompt(
+  ctx: Filter<Context, "message">,
+  token: string,
+  configDir: string,
+  sessionId: SessionId
+): Promise<Prompt | undefined> {
+  const message = ctx.message;
+  const text = ("text" in message ? message.text : undefined) ?? "";
+  const caption = ("caption" in message ? message.caption : undefined) ?? "";
+  const files = await download(ctx, token, configDir, sessionId);
+  const { lines: attachments, images } = Attachments.render(files);
+
+  const body = (text || caption || "").trim();
+  if (!body && images.length === 0 && attachments.length === 0) {
+    return undefined;
+  }
+  const replyContext = buildReplyContext(ctx);
+  const promptText = [replyContext, body, ...attachments]
+    .filter(Boolean)
+    .join("\n\n")
+    .trim();
+  return {
+    text: promptText,
+    options: images.length > 0 ? { images } : {},
+  };
+}
+
+function buildReplyContext(
+  ctx: Filter<Context, "message">
+): string | undefined {
+  const reply = ctx.message.reply_to_message;
+  if (!reply) {
+    return undefined;
+  }
+  const raw = ctx.message.quote?.text ?? reply.text ?? reply.caption ?? "";
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  const truncated =
+    trimmed.length > REPLY_QUOTE_HEAD + REPLY_QUOTE_TAIL + 1
+      ? `${trimmed.slice(0, REPLY_QUOTE_HEAD)}…${trimmed.slice(-REPLY_QUOTE_TAIL)}`
+      : trimmed;
+  const quoted = truncated
+    .split("\n")
+    .map((line) => `> ${line}`)
+    .join("\n");
+  const isFromBot = reply.from?.id === ctx.me.id;
+  const label = isFromBot
+    ? "Replying to your earlier message:"
+    : "Replying to my earlier message:";
+  return `${label}\n${quoted}`;
+}
+
+async function download(
+  ctx: Filter<Context, "message">,
+  token: string,
+  configDir: string,
+  sessionId: SessionId
+): Promise<ReadonlyArray<StoredAttachment>> {
+  const ref = refOf(ctx);
+  if (!ref) {
+    return [];
+  }
+  const telegramFile = await ctx.api.getFile(ref.fileId);
+  if (!telegramFile.file_path) {
+    return [];
+  }
+  const url = `https://api.telegram.org/file/bot${token}/${telegramFile.file_path}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Telegram file download failed: ${response.status}`);
+  }
+  const store = new AttachmentStore(join(configDir, "attachments"));
+  return [
+    await store.store(String(sessionId.chatId), {
+      bytes: await response.arrayBuffer(),
+      mimeType: ref.mimeType,
+      stem: ref.uniqueId ?? ref.fileId,
+      ext:
+        extname(telegramFile.file_path) || extname(ref.name ?? "") || ref.ext,
+    }),
+  ];
+}
+
+const MEDIA_KINDS = [
+  {
+    key: "document",
+    defaultMime: "application/octet-stream",
+    defaultExt: ".bin",
+  },
+  { key: "video", defaultMime: "video/mp4", defaultExt: ".mp4" },
+  { key: "audio", defaultMime: "audio/mpeg", defaultExt: ".mp3" },
+  { key: "voice", defaultMime: "audio/ogg", defaultExt: ".ogg" },
+] as const;
+
+function refOf(ctx: Filter<Context, "message">): FileRef | undefined {
+  const message = ctx.message;
+  if ("photo" in message && message.photo) {
+    const photo = message.photo.at(-1)!;
+    return {
+      fileId: photo.file_id,
+      uniqueId: photo.file_unique_id,
+      mimeType: "image/jpeg",
+      ext: ".jpg",
+    };
+  }
+  for (const { key, defaultMime, defaultExt } of MEDIA_KINDS) {
+    const file = key in message ? message[key] : undefined;
+    if (!file) {
+      continue;
+    }
+    const name = "file_name" in file ? file.file_name : undefined;
+    return {
+      fileId: file.file_id,
+      uniqueId: file.file_unique_id,
+      name,
+      mimeType: file.mime_type ?? defaultMime,
+      ext: extname(name ?? "") || defaultExt,
+    };
+  }
+  return undefined;
+}
+
+export const Message = { toPrompt };