nolo-cli 0.1.30 → 0.1.32

package/server/handlers/agentRun/autonomousRuntime.ts

@@ -1,355 +0,0 @@
-import { DataType } from "../../../create/types";
-import type { DialogRuntimeProfile } from "../../../app/types";
-import { createPageServer } from "../../../render/page/server/createPage";
-import serverDb from "../../../database/server/db";
-
-type RuntimeCheckpointLike = {
-  toolCallCount?: number;
-  lastToolNames?: string[];
-} | null | undefined;
-
-type AutonomousWorkbenchDocKey = "mission" | "checkpoint" | "ideas";
-
-type AutonomousWorkbenchDoc = {
-  key: AutonomousWorkbenchDocKey;
-  title: string;
-  purpose: string;
-  dbKey: string;
-};
-
-type AutonomousRuntimeContext = {
-  block: string | null;
-  turnInstruction: string | null;
-  requiredTools: string[];
-  disabledTools: string[];
-  exclusiveTools: string[];
-};
-
-type AutonomousWorkbenchDocSpec = {
-  key: AutonomousWorkbenchDocKey;
-  title: string;
-  purpose: string;
-  initialContent: string;
-};
-
-const DURABLE_ASSET_TOOLS = new Set([
-  "createDoc",
-  "updateDoc",
-  "createSkillDoc",
-  "importSkill",
-  "rememberMemory",
-  "writeFile",
-  "applyEdit",
-  "updateSelf",
-  "createTable",
-  "addTableRow",
-]);
-
-const WORKBENCH_TARGET_PATTERN =
-  /(24h|workbench|工作台|mission|checkpoint|ideas|固定工作台|doc|文档)/i;
-
-const WORKBENCH_WRITE_ACTION_PATTERN =
-  /(updateDoc|append|追加|写入|更新|维护|记录|沉淀|保存|补充)/i;
-
-const NON_DOC_EXPLORATION_TOOLS = [
-  "checkEnv",
-  "execShell",
-  "codeSearch",
-  "read",
-  "readFile",
-  "fetchWebpage",
-  "exa_search",
-  "exa-search",
-];
-
-function shortAgentLabel(agentKey: string): string {
-  const trimmed = agentKey.trim();
-  if (trimmed.length <= 24) return trimmed;
-  return `${trimmed.slice(0, 10)}...${trimmed.slice(-10)}`;
-}
-
-function buildMissionDocContent(agentKey: string): string {
-  return [
-    "# 24h Mission",
-    "",
-    `- agentKey: \`${agentKey}\``,
-    "- role: 长期自主发展的 agent",
-    "- default objective: 持续产出可复用资产，而不是反复空总结",
-    "",
-    "## Identity",
-    "- 主动推进长期 mission",
-    "- 可以提出产品、赚钱、自动化、自我改进方向",
-    "- 优先沉淀 doc / memory / 实验结论 / 代码，而不是只停留在聊天",
-    "",
-    "## Current Mission",
-    "- current_focus: 维护一个可验证、可接力、低噪声的长期 agent 记忆/工作台系统",
-    "- success_condition: 下一轮 agent 能从 Checkpoint / Memory / Procedural runbook 恢复任务，而不是靠聊天猜测",
-    "- next_step: 每次真实任务后用 audit 判断推荐优化层；没有失败证据时不新增 summary/memory/skill",
-    "- failure_policy: 如果 running/stale、checkpoint、memory recall 任一层失败，先记录证据和 dialog id，再修最低层原因",
-    "",
-    "## Asset Strategy",
-    "- 能沉淀成长期工作台的内容，优先写 doc",
-    "- 用户偏好和近期复用经验，优先写 user memory",
-    "- 共享协作规则，才写 space memory",
-    "- 重复 3 次以上的排障流程，优先沉淀 procedural memory；只有需要可执行工具链时再升级 skill",
-    "",
-    "## Experiment Log Seed",
-    "- date: 2026-04-30",
-    "- result: 初始 mission 已结构化，后续每轮应补充证据、下一步和失败处理策略",
-  ].join("\n");
-}
-
-function buildCheckpointDocContent(agentKey: string): string {
-  return [
-    "# 24h Checkpoint Log",
-    "",
-    `- agentKey: \`${agentKey}\``,
-    "- 用于持续追加每一轮真正有价值的结果，而不是泛泛汇报",
-    "",
-    "## Logging Rules",
-    "- 记录完成的代码/文档/实验/记忆沉淀",
-    "- 记录失败尝试及其原因",
-    "- 记录下一步最高 ROI 的动作",
-    "",
-    "## Checkpoint Entry: initial-baseline",
-    "- case: workbench-initialization",
-    "- completed: 创建可持续追加的 24h Checkpoint，并固定结构化字段",
-    "- evidence: doc contains case/completed/evidence/next_step/failure_or_blocker/optimization_target",
-    "- next_step: 每轮真实实验后追加一条带 dialog id、marker、测试结果和推荐优化层的记录",
-    "- failure_or_blocker: none",
-    "- optimization_target: none",
-  ].join("\n");
-}
-
-function buildIdeasDocContent(agentKey: string): string {
-  return [
-    "# 24h Ideas Backlog",
-    "",
-    `- agentKey: \`${agentKey}\``,
-    "- 用于沉淀产品、赚钱、自动化、自我改进方向",
-    "",
-    "## Capture Rules",
-    "- 先记 raw ideas，再挑选 promising ideas",
-    "- 每条想法尽量附带 why now / evidence / next experiment",
-    "- 不要把只在当前轮短暂有效的碎片塞满整页",
-    "",
-    "## Idea Entry: memory-continuity-baseline",
-    "- idea: 把 memory 系统优化拆成 hypothesis ladder，用真实 Qwen、audit 和回归测试决定是否投入",
-    "- why_now: checkpoint 已能接力，下一步收益来自更准的失败定位，而不是更多记忆层",
-    "- evidence: H0-H5 均有脚本化实验入口；Checkpoint / Memory / Procedural runbook 可被真实 Qwen 验证",
-    "- next_experiment: 每个新优化先跑 continuity audit，再决定优化 runtime、workbench、summary、memory 或 skill",
-    "- expected_roi: high when it prevents adding low-value memory mechanisms; otherwise observe only",
-  ].join("\n");
-}
-
-function buildAutonomousWorkbenchSpecs(agentKey: string): AutonomousWorkbenchDocSpec[] {
-  const label = shortAgentLabel(agentKey);
-  return [
-    {
-      key: "mission",
-      title: `24h Mission · ${label}`,
-      purpose: "长期身份、当前 mission、约束与策略的主状态页",
-      initialContent: buildMissionDocContent(agentKey),
-    },
-    {
-      key: "checkpoint",
-      title: `24h Checkpoint · ${label}`,
-      purpose: "持续追加阶段进展、失败原因、实验结果与下一步",
-      initialContent: buildCheckpointDocContent(agentKey),
-    },
-    {
-      key: "ideas",
-      title: `24h Ideas · ${label}`,
-      purpose: "沉淀产品、赚钱、自动化、自我改进等长期想法与验证路径",
-      initialContent: buildIdeasDocContent(agentKey),
-    },
-  ];
-}
-
-function detectDurableAssetSignal(toolNames?: string[] | null): boolean {
-  return Array.isArray(toolNames) && toolNames.some((toolName) => DURABLE_ASSET_TOOLS.has(toolName));
-}
-
-function isDirectWorkbenchMaintenanceInput(userInput: string): boolean {
-  if (/(不要|无需|不用|不需要).{0,12}(updateDoc|append|追加|写入|更新|维护|记录|沉淀|保存|补充|文档|doc)/i.test(userInput)) {
-    return false;
-  }
-  return WORKBENCH_WRITE_ACTION_PATTERN.test(userInput) && WORKBENCH_TARGET_PATTERN.test(userInput);
-}
-
-function buildAutonomousRuntimeBlock(args: {
-  docs: AutonomousWorkbenchDoc[];
-  checkpoint?: RuntimeCheckpointLike;
-  hasSpaceWorkbench: boolean;
-  directWorkbenchMaintenance: boolean;
-}): string {
-  if (args.hasSpaceWorkbench && args.directWorkbenchMaintenance && args.docs.length > 0) {
-    const writableDocs = args.docs.filter((doc) =>
-      doc.key === "checkpoint" || doc.key === "ideas"
-    );
-    return [
-      "--- Autonomous runtime: direct workbench maintenance ---",
-      "本轮是固定工作台维护任务。唯一动作：直接调用 updateDoc，不要调用其他工具，不要猜测 dbKey，不要编辑代码。",
-      "可写工作台 dbKey：",
-      ...writableDocs.map((doc) => `- ${doc.key}: ${doc.dbKey}`),
-      "调用时 id 必须逐字使用上面列出的 checkpoint 或 ideas 的 page-... 字符串。",
-      "调用格式：updateDoc({ id: 'page-...', mode: 'append', content })。",
-      "如果本轮是实验、观察、checkpoint、接力、运行连续性任务，写入 checkpoint；如果本轮是产品想法、机会、backlog，写入 ideas。",
-      "checkpoint content 必须使用以下字段，字段名不要改：",
-      "## Checkpoint Entry: <marker 或日期>",
-      "- case: <本轮任务/实验对象>",
-      "- completed: <已经完成了什么>",
-      "- evidence: <dialog id、marker、工具调用、audit 分数、测试结果等证据>",
-      "- next_step: <下一轮可直接执行的一步>",
-      "- failure_or_blocker: <失败原因或 none>",
-      "- optimization_target: <runtime-continuity|workbench-injection|checkpoint-structure|passive-summary|proactive-summary|memory-recall|memory-janitor|none>",
-      "ideas content 必须使用以下字段，字段名不要改：idea、why_now、evidence、next_experiment、expected_roi。",
-      "content 必须包含本轮用户给出的 marker 或 case；没有 marker 时自己生成一个短 marker。",
-    ].join("\n");
-  }
-
-  const lines = [
-    "--- Autonomous runtime ---",
-    "你正在执行长期 autonomous runtime。优先持续产出可复用资产：代码、doc、memory、实验结论、可执行方案。",
-    "可以主动提出产品、赚钱、自动化、自我改进方向，但高价值想法应沉淀到 ideas / checkpoint 之类的 doc，而不是只留在聊天里。",
-    "用户偏好、你的短中期连续性、最近有效经验 → user/private memory。",
-    "共享协作规则、空间共识、团队约定 → space/shared memory。",
-    "需要跨轮次共读和维护的 mission / checkpoint / ideas / runbook / experiment log → doc layer。",
-  ];
-
-  if (args.hasSpaceWorkbench && args.docs.length > 0) {
-    lines.push("固定工作台：");
-    for (const doc of args.docs) {
-      lines.push(`- ${doc.key}: ${doc.title} — dbKey=${doc.dbKey} — ${doc.purpose}`);
-    }
-    lines.push("当本轮目标是维护 mission / checkpoint / ideas，且对应 dbKey 已在固定工作台列出时，直接调用 updateDoc({ id: dbKey, mode: 'append' 或 'replace', content })。");
-    lines.push("不要为了查找这些固定工作台 doc 去搜索代码库或读取环境；只有缺少 dbKey 或任务确实依赖运行环境时才做额外探查。");
-    lines.push("如果这些 doc 仍然空泛，优先把它们推进到可持续接力的状态。");
-  } else {
-    lines.push("当前没有可用的 space 工作台时，先用 memory 保持连续性；后续拿到 space 再创建并接管 mission / checkpoint / ideas doc。");
-  }
-
-  const likelyLooping =
-    !!args.checkpoint &&
-    (args.checkpoint.toolCallCount ?? 0) >= 2 &&
-    !detectDurableAssetSignal(args.checkpoint.lastToolNames);
-  if (likelyLooping) {
-    lines.push("如果你发现自己连续几轮都在重复读取/总结，却没有留下新资产，优先切换到更新 doc、记录实验、形成明确下一步，而不是继续同类审计。");
-  }
-
-  return lines.join("\n");
-}
-
-async function ensureAutonomousWorkbenchDocs(args: {
-  userId: string;
-  spaceId: string;
-  agentKey: string;
-}): Promise<AutonomousWorkbenchDoc[]> {
-  const { userId, spaceId, agentKey } = args;
-  const spaceKey = `space-${spaceId}`;
-  const spaceRecord = (await serverDb.get(spaceKey).catch(() => null)) as Record<string, any> | null;
-  const contents = spaceRecord?.contents ?? {};
-  const specs = buildAutonomousWorkbenchSpecs(agentKey);
-  const docs: AutonomousWorkbenchDoc[] = [];
-
-  for (const spec of specs) {
-    const existingEntry = Object.entries(contents).find(([, value]) => {
-      if (!value || typeof value !== "object") return false;
-      const record = value as Record<string, any>;
-      return record.type === DataType.DOC && record.title === spec.title;
-    });
-
-    if (existingEntry) {
-      const entryKey = existingEntry[0];
-      const record = existingEntry[1] as Record<string, any>;
-      docs.push({
-        key: spec.key,
-        title: spec.title,
-        purpose: spec.purpose,
-        dbKey:
-          typeof record.contentKey === "string" && record.contentKey.trim()
-            ? record.contentKey.trim()
-            : entryKey,
-      });
-      continue;
-    }
-
-    const created = await createPageServer({
-      userId,
-      title: spec.title,
-      content: spec.initialContent,
-      spaceId,
-    });
-    docs.push({
-      key: spec.key,
-      title: spec.title,
-      purpose: spec.purpose,
-      dbKey: created.dbKey,
-    });
-  }
-
-  return docs;
-}
-
-export async function resolveAutonomousRuntimeBlock(args: {
-  runtimeProfile?: DialogRuntimeProfile;
-  userId?: string | null;
-  spaceId?: string | null;
-  agentKey: string;
-  checkpoint?: RuntimeCheckpointLike;
-  userInput?: string | null;
-}): Promise<string | null> {
-  const context = await resolveAutonomousRuntimeContext(args);
-  return context.block;
-}
-
-export async function resolveAutonomousRuntimeContext(args: {
-  runtimeProfile?: DialogRuntimeProfile;
-  userId?: string | null;
-  spaceId?: string | null;
-  agentKey: string;
-  checkpoint?: RuntimeCheckpointLike;
-  userInput?: string | null;
-}): Promise<AutonomousRuntimeContext> {
-  if (args.runtimeProfile !== "autonomous") {
-    return {
-      block: null,
-      turnInstruction: null,
-      requiredTools: [],
-      disabledTools: [],
-      exclusiveTools: [],
-    };
-  }
-
-  const normalizedUserId = args.userId?.trim();
-  const normalizedSpaceId = args.spaceId?.trim();
-  const docs =
-    normalizedUserId && normalizedSpaceId
-      ? await ensureAutonomousWorkbenchDocs({
-          userId: normalizedUserId,
-          spaceId: normalizedSpaceId,
-          agentKey: args.agentKey,
-        })
-      : [];
-
-  const hasWorkbenchDocs = docs.length > 0;
-  const directWorkbenchMaintenance =
-    hasWorkbenchDocs &&
-    typeof args.userInput === "string" &&
-    isDirectWorkbenchMaintenanceInput(args.userInput);
-
-  const block = buildAutonomousRuntimeBlock({
-    docs,
-    checkpoint: args.checkpoint,
-    hasSpaceWorkbench: !!(normalizedUserId && normalizedSpaceId),
-    directWorkbenchMaintenance,
-  });
-
-  return {
-    block,
-    turnInstruction: directWorkbenchMaintenance ? block : null,
-    requiredTools: hasWorkbenchDocs ? ["updateDoc"] : [],
-    disabledTools: directWorkbenchMaintenance ? NON_DOC_EXPLORATION_TOOLS : [],
-    exclusiveTools: directWorkbenchMaintenance ? ["updateDoc"] : [],
-  };
-}

package/server/handlers/agentRun/backgroundRunDialog.ts

@@ -1,31 +0,0 @@
-import {
-  type PreparedRunDialog,
-  type PrepareRunDialogOptions,
-  prepareRunDialog,
-} from "./runDialogPreparation";
-
-export type BackgroundRunDialog =
-  | PreparedRunDialog
-  | {
-      error: string;
-      status: number;
-    };
-
-export function isBackgroundRunDialogError(
-  result: BackgroundRunDialog,
-): result is Extract<BackgroundRunDialog, { error: string }> {
-  return "error" in result;
-}
-
-export async function prepareBackgroundRunDialog(
-  options: PrepareRunDialogOptions,
-): Promise<BackgroundRunDialog> {
-  try {
-    return await prepareRunDialog(options);
-  } catch (error: any) {
-    return {
-      error: error?.message ?? "Failed to create dialog",
-      status: error?.status ?? 500,
-    };
-  }
-}