mioku-plugin-agent 0.1.0

package/configs/base.ts

@@ -0,0 +1,11 @@
+import type { AgentBaseConfig } from "../types";
+
+export const BASE_CONFIG: AgentBaseConfig = {
+  access: {
+    allowAdmins: false,
+    users: [],
+  },
+  workspaceDir: "",
+  permissionLevel: "workspace-write",
+  model: "",
+};

package/configs/context-window.ts

@@ -0,0 +1,15 @@
+import type { AgentSettingsConfig } from "../types";
+
+export const CONTEXT_WINDOW_CHOICES = [
+  { label: "128K", value: 128 * 1024 },
+  { label: "256K", value: 256 * 1024 },
+  { label: "512K", value: 512 * 1024 },
+  { label: "1M", value: 1024 * 1024 },
+  { label: "10M", value: 10 * 1024 * 1024 },
+];
+
+export const DEFAULT_CONTEXT_WINDOW = 512 * 1024;
+
+export function compactionThresholdTokens(maxContextTokens: number): number {
+  return Math.max(1, Math.floor(maxContextTokens * 0.9375));
+}

package/configs/settings.ts

@@ -0,0 +1,39 @@
+import type { AgentSettingsConfig } from "../types";
+import {
+  DEFAULT_CONTEXT_WINDOW,
+  compactionThresholdTokens,
+} from "./context-window";
+
+export const SETTINGS_CONFIG: AgentSettingsConfig = {
+  maxIterations: 500,
+  temperature: 1,
+  maxContextTokens: DEFAULT_CONTEXT_WINDOW,
+  stream: true,
+  enableMarkdownScreenshot: true,
+  compaction: {
+    enabled: true,
+    keepRecentMessages: 20,
+  },
+  webSearch: {
+    enabled: true,
+    baseUrl: "https://search.crystelf.top/",
+    timeoutMs: 8000,
+    defaultLimit: 5,
+    maxLimit: 8,
+    maxSearchCount: 50,
+  },
+  webFetch: {
+    enabled: true,
+    timeoutMs: 15_000,
+    maxChars: 12_000,
+  },
+  bash: {
+    enabled: true,
+    timeoutMs: 120_000,
+    approvalTimeoutMs: 5 * 60_000,
+  },
+  dataCollection: {
+    enabled: true,
+  },
+  debug: false,
+};

package/core/activity.ts

@@ -0,0 +1,236 @@
+import type {
+  ForwardSendNode,
+  ForwardSendOptions,
+  MessageSegment,
+  MiokuContext,
+} from "mioku";
+import type { AgentPermissionLevel } from "../types";
+
+export type ActivityKind = "bash" | "write" | "edit";
+
+export interface ActivityEntry {
+  kind: ActivityKind;
+  title: string;
+  purpose?: string;
+  note?: string;
+  output?: string;
+  ok: boolean;
+  durationMs: number;
+}
+
+export interface ActivityRecord {
+  kind: ActivityKind;
+  title: string;
+  purpose?: string;
+  note?: string;
+  output?: string;
+  ok?: boolean;
+  durationMs?: number;
+}
+
+export interface BashActivityResult {
+  exitCode: number | null;
+  timedOut: boolean;
+  error?: string;
+  stdout?: string;
+  stderr?: string;
+}
+
+const KIND_LABELS: Record<ActivityKind, string> = {
+  bash: "命令",
+  write: "写入",
+  edit: "编辑",
+};
+
+const OUTPUT_EXCERPT = 240;
+
+function truncate(text: string, max: number): string {
+  const value = String(text ?? "").replace(/\s+/g, " ").trim();
+  return value.length > max ? `${value.slice(0, max)}…` : value;
+}
+
+function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  const seconds = ms / 1000;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  return `${minutes}m${Math.round(seconds % 60)}s`;
+}
+
+function formatClock(date: Date): string {
+  const pad = (value: number) => String(value).padStart(2, "0");
+  return `${date.getFullYear()}/${pad(date.getMonth() + 1)}/${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+export class TurnActivity {
+  private entries: ActivityEntry[] = [];
+  private startedAt = Date.now();
+  private subject = "";
+
+  constructor(private enabled: boolean) {}
+
+  setSubject(text: string): void {
+    this.subject = truncate(text, 24);
+  }
+
+  record(input: ActivityRecord): void {
+    if (!this.enabled) return;
+    this.entries.push({
+      kind: input.kind,
+      title: truncate(input.title, 200) || "(未命名)",
+      purpose: input.purpose ? truncate(input.purpose, 200) : undefined,
+      note: input.note ? truncate(input.note, 200) : undefined,
+      output: input.output,
+      ok: input.ok ?? true,
+      durationMs: input.durationMs ?? 0,
+    });
+  }
+
+  recordTool(
+    toolName: string,
+    args: Record<string, unknown>,
+    result: unknown,
+    durationMs: number,
+  ): void {
+    if (!this.enabled) return;
+    if (toolName !== "write" && toolName !== "edit") return;
+    const record = (result ?? {}) as Record<string, unknown>;
+    const detail = record.error
+      ? `错误：${truncate(String(record.error), 160)}`
+      : toolName === "write" && typeof record.bytes === "number"
+        ? `${record.bytes} 字节`
+        : toolName === "edit" && typeof record.replacements === "number"
+          ? `${record.replacements} 处替换`
+          : undefined;
+    this.record({
+      kind: toolName,
+      title: String(args?.file_path ?? ""),
+      note: detail,
+      ok: !record.error && record.success !== false,
+      durationMs,
+    });
+  }
+
+  recordBash(
+    notice: {
+      command: string;
+      level: AgentPermissionLevel;
+      purpose: string;
+      reason?: string;
+    },
+    result: BashActivityResult,
+    startedAt: number,
+  ): void {
+    this.record({
+      kind: "bash",
+      title: notice.command,
+      purpose: notice.purpose,
+      note: notice.reason,
+      output: bashOutput(result),
+      ok: result.exitCode === 0 && !result.timedOut && !result.error,
+      durationMs: Date.now() - startedAt,
+    });
+  }
+
+  get total(): number {
+    return this.entries.length;
+  }
+
+  get failureCount(): number {
+    return this.entries.filter((entry) => !entry.ok).length;
+  }
+
+  private stats(): string {
+    const counts = new Map<ActivityKind, number>();
+    for (const entry of this.entries) {
+      counts.set(entry.kind, (counts.get(entry.kind) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+      .map(([kind, count]) => `${KIND_LABELS[kind]} ${count}`)
+      .join(" · ");
+  }
+
+  buildDisplay(): ForwardSendOptions {
+    const failures = this.failureCount;
+    return {
+      source: "Agent 执行记录",
+      news: [
+        { text: `${this.total} 项操作` },
+        ...(this.subject ? [{ text: this.subject }] : []),
+      ],
+      summary: [this.stats(), failures > 0 ? `失败 ${failures}` : "全部成功"]
+        .filter(Boolean)
+        .join(" · "),
+    };
+  }
+
+  buildNodes(
+    ctx: MiokuContext,
+    userId: string,
+    nickname: string,
+  ): ForwardSendNode[] {
+    const nodes: ForwardSendNode[] = [
+      {
+        user_id: userId,
+        nickname,
+        content: [ctx.segment.text(this.buildInfoText())],
+      },
+    ];
+    for (const [index, entry] of this.entries.entries()) {
+      nodes.push({
+        user_id: userId,
+        nickname,
+        content: [ctx.segment.text(buildEntryText(entry, index + 1))],
+      });
+    }
+    return nodes;
+  }
+
+  buildInfoText(): string {
+    const failures = this.failureCount;
+    return [
+      "【Agent 执行记录】",
+      `时间：${formatClock(new Date(this.startedAt))}`,
+      `操作：${this.total} 项（${this.stats()}）`,
+      `结果：${failures > 0 ? `失败 ${failures} 项` : "全部成功"}`,
+      `耗时：${formatDuration(Date.now() - this.startedAt)}`,
+      `简介：${this.subject ? `针对「${this.subject}」` : "本次任务"}按时间顺序执行了以下操作。`,
+    ].join("\n");
+  }
+
+  buildFallbackSegments(ctx: MiokuContext): MessageSegment[] {
+    const display = this.buildDisplay();
+    const header = [
+      display.source,
+      display.news?.map((item) => item.text).join(" / "),
+      display.summary,
+    ]
+      .filter(Boolean)
+      .join("\n");
+    const segments: MessageSegment[] = [ctx.segment.text(header)];
+    for (const [index, entry] of this.entries.entries()) {
+      segments.push(ctx.segment.text(buildEntryText(entry, index + 1)));
+    }
+    return segments;
+  }
+}
+
+function buildEntryText(entry: ActivityEntry, index: number): string {
+  const lines = [
+    `[${index}] ${KIND_LABELS[entry.kind]} · ${entry.ok ? "成功" : "失败"} · ${formatDuration(entry.durationMs)}`,
+    entry.title,
+  ];
+  if (entry.purpose) lines.push(`用途：${entry.purpose}`);
+  if (entry.note) lines.push(`备注：${entry.note}`);
+  if (entry.output) lines.push(entry.output);
+  return lines.join("\n");
+}
+
+function bashOutput(result: BashActivityResult): string | undefined {
+  if (result.error) return `错误：${truncate(result.error, OUTPUT_EXCERPT)}`;
+  if (result.timedOut) return "超时：命令被强制结束";
+  if (result.exitCode === 0) return undefined;
+  const detail = `${result.stderr || ""}`.trim() || `${result.stdout || ""}`.trim();
+  if (!detail) return `退出码：${result.exitCode}`;
+  return `输出：${truncate(detail, OUTPUT_EXCERPT)}`;
+}

package/core/attachment.ts

@@ -0,0 +1,50 @@
+import * as fsp from "node:fs/promises";
+import type { Bot, MessageSegment, MessageTarget, MiokuContext } from "mioku";
+
+export function isLocalFilePath(value: string): boolean {
+  return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value);
+}
+
+export function normalizeImageSource(file: string): string {
+  const value = String(file ?? "").trim();
+  if (!value) return value;
+  if (/^(?:file|base64|data|https?):/i.test(value)) return value;
+  if (isLocalFilePath(value)) return `file://${value}`;
+  return value;
+}
+
+export async function sendImageSource(
+  ctx: MiokuContext,
+  bot: Bot,
+  target: MessageTarget,
+  source: string,
+  prefix: MessageSegment[] = [],
+): Promise<boolean> {
+  const value = String(source ?? "").trim();
+  if (!value) return false;
+  try {
+    if (isLocalFilePath(value)) {
+      const buffer = await fsp.readFile(value);
+      await bot.sendMessage(target, [...prefix, ctx.segment.image(buffer)]);
+      return true;
+    }
+    await bot.sendMessage(target, [
+      ...prefix,
+      ctx.segment.image(normalizeImageSource(value)),
+    ]);
+    return true;
+  } catch (err) {
+    ctx.logger.warn(`[agent] failed to send image ${value}: ${err}`);
+    return false;
+  }
+}
+
+export async function sendLocalFile(
+  ctx: MiokuContext,
+  bot: Bot,
+  target: MessageTarget,
+  filePath: string,
+  name: string,
+): Promise<void> {
+  await bot.sendMessage(target, [ctx.segment.file(filePath, { name })]);
+}

package/core/chat-config.ts

@@ -0,0 +1,24 @@
+import type { ConfigService } from "mioku";
+import type { ChatSharedConfig } from "../types";
+
+export async function readChatSharedConfig(
+  configService: ConfigService | undefined,
+): Promise<ChatSharedConfig> {
+  if (!configService) return { persona: "", replyStyle: "", emotion: null };
+  const personalization = await configService
+    .getConfig("chat", "personalization")
+    .catch(() => null);
+  return {
+    persona: String(personalization?.persona ?? ""),
+    replyStyle: String(personalization?.replyStyle?.baseStyle ?? ""),
+    emotion:
+      personalization?.emotion && typeof personalization.emotion === "object"
+        ? {
+            defaultEmotion: String(
+              personalization.emotion.defaultEmotion ?? "default",
+            ),
+            emotions: personalization.emotion.emotions ?? {},
+          }
+        : null,
+  };
+}

package/core/compaction.ts

@@ -0,0 +1,97 @@
+import type { AgentHost } from "../types";
+import { compactionThresholdTokens } from "../configs/context-window";
+
+export function estimateTokens(text: string): number {
+  const normalized = String(text ?? "").trim();
+  if (!normalized) return 0;
+  const cjkChars = normalized.match(/[\u3400-\u9fff\u3040-\u30ff]/g)?.length || 0;
+  const latinWords = normalized.match(/[A-Za-z0-9_]+/g)?.length || 0;
+  const symbols = Math.max(0, normalized.length - cjkChars);
+  return Math.max(1, Math.ceil(cjkChars * 0.6 + latinWords * 1.3 + symbols / 6));
+}
+
+export function estimateHistoryTokens(
+  messages: Array<{ content: string }>,
+): number {
+  return messages.reduce((sum, message) => sum + estimateTokens(message.content), 0);
+}
+
+function transcript(messages: Array<{ role: string; content: string }>): string {
+  return messages
+    .map((message) => {
+      const speaker =
+        message.role === "user" ? "USER" : message.role === "assistant" ? "AGENT" : "SYSTEM";
+      return `${speaker}: ${message.content}`;
+    })
+    .join("\n\n");
+}
+
+export interface CompactionResult {
+  compacted: boolean;
+  reason: string;
+  freedTokens: number;
+}
+
+export async function maybeCompact(
+  host: AgentHost,
+  userId: number,
+  options: { force?: boolean } = {},
+): Promise<CompactionResult> {
+  const settings = host.getSettings();
+  const compaction = settings.compaction;
+  if (!compaction.enabled && !options.force) {
+    return { compacted: false, reason: "compaction disabled", freedTokens: 0 };
+  }
+  const thresholdTokens = compactionThresholdTokens(settings.maxContextTokens);
+
+  const session = host.sessions.get(userId);
+  const messages = host.db.getMessagesAfter(session.sessionId, session.summaryUpTo);
+  if (messages.length <= compaction.keepRecentMessages) {
+    return {
+      compacted: false,
+      reason: `only ${messages.length} message(s), need more than ${compaction.keepRecentMessages}`,
+      freedTokens: 0,
+    };
+  }
+
+  const older = messages.slice(0, messages.length - compaction.keepRecentMessages);
+  const olderTokens = estimateHistoryTokens(older);
+  if (!options.force && olderTokens < thresholdTokens) {
+    return {
+      compacted: false,
+      reason: `~${olderTokens} tokens below threshold ${thresholdTokens}`,
+      freedTokens: 0,
+    };
+  }
+
+  const resolved = host.resolveModel();
+  const worker = resolved?.working ?? resolved?.instance;
+  if (!worker) {
+    return { compacted: false, reason: "no model available", freedTokens: 0 };
+  }
+
+  const previousSummary = session.summary
+    ? `Previous summary:\n${session.summary}\n\n`
+    : "";
+  const prompt = `${previousSummary}Conversation to summarize:\n\n${transcript(older)}\n\nWrite an updated running summary in English for an AI agent's long-term context. Keep: the user's requests and goals, key facts learned (files, paths, decisions, outcomes), open tasks and unresolved questions. Be factual and compact. Output only the summary text.`;
+
+  try {
+    const response = await worker.complete({
+      model: resolved?.workingModel || resolved?.model || "",
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0.3,
+    });
+    const summary = response.content?.trim();
+    if (!summary) {
+      return { compacted: false, reason: "empty summary from model", freedTokens: 0 };
+    }
+    host.db.setSummary(session.sessionId, summary, older[older.length - 1].id);
+    host.logger.info(
+      `[agent] compacted ${older.length} messages for user ${userId} (freed ~${olderTokens} tokens)`,
+    );
+    return { compacted: true, reason: `${older.length} messages condensed`, freedTokens: olderTokens };
+  } catch (err) {
+    host.logger.warn(`[agent] compaction failed: ${err}`);
+    return { compacted: false, reason: `compaction failed: ${err}`, freedTokens: 0 };
+  }
+}