nolo-cli 0.1.8 → 0.1.10

package/ai/agent/planSlice.ts

@@ -0,0 +1,259 @@
+// ai/agent/planSlice.ts
+// 管理计划（Plan）的 Redux 状态
+// 支持普通步骤和反思步骤（reflect step）
+
+import { type PayloadAction, createSlice } from "@reduxjs/toolkit";
+import type { RootState } from "app/store";
+
+// --- Interfaces ---
+
+export interface PlanState {
+  planDetails: string;
+  currentProgress: number;
+}
+
+// 单个工具调用的接口
+export interface ToolCall {
+  tool_name: string;
+  parameters: any;
+}
+
+// 反思决策的输出结构
+export interface ReflectDecision {
+  action: "continue" | "stop" | "insert_steps";
+  reason: string;
+  steps?: Omit<Step, "status" | "result">[]; // 仅当 action 是 insert_steps 时
+}
+
+// Step 类型：normal 或 reflect
+export type StepType = "normal" | "reflect";
+
+export interface Step {
+  id: string;
+  title: string;
+  type?: StepType; // 默认 "normal"
+  status: "pending" | "in-progress" | "completed" | "failed";
+
+  // normal step 使用
+  calls?: ToolCall[];
+
+  // reflect step 使用
+  reflectInput?: string; // 给反思 LLM 的提示
+
+  // 通用
+  details?: any;
+  result?: any[]; // normal step: 工具调用结果; reflect step: ReflectDecision
+}
+
+// Plan 执行配置
+export interface PlanExecutionConfig {
+  maxReflectCount?: number; // 最多允许多少次 reflect step，默认不限
+  maxTotalSteps?: number; // 最多执行多少个 step（包括动态插入的），默认不限
+  maxTimeMs?: number; // 最大执行时间（毫秒），默认不限
+}
+
+interface PlanSliceState {
+  plan: PlanState | null;
+  steps: Step[];
+  currentStep: string | null;
+  executionConfig: PlanExecutionConfig | null;
+  // 执行统计
+  stats: {
+    reflectCount: number;
+    totalStepsExecuted: number;
+    startTime: number | null;
+  };
+}
+
+// --- Initial State ---
+
+const initialState: PlanSliceState = {
+  plan: null,
+  steps: [],
+  currentStep: null,
+  executionConfig: null,
+  stats: {
+    reflectCount: 0,
+    totalStepsExecuted: 0,
+    startTime: null,
+  },
+};
+
+// --- Slice Definition ---
+
+const planSlice = createSlice({
+  name: "plan",
+  initialState,
+  reducers: {
+    // 设置整个计划的顶层信息
+    setPlan: (state, action: PayloadAction<PlanState>) => {
+      state.plan = action.payload;
+    },
+
+    // 更新计划的整体进度
+    updatePlanProgress: (state, action: PayloadAction<number>) => {
+      if (state.plan) {
+        state.plan.currentProgress = action.payload;
+      }
+    },
+
+    // 清除整个计划
+    clearPlan: (state) => {
+      state.plan = null;
+      state.steps = [];
+      state.currentStep = null;
+      state.executionConfig = null;
+      state.stats = {
+        reflectCount: 0,
+        totalStepsExecuted: 0,
+        startTime: null,
+      };
+    },
+
+    // 设置计划的所有步骤
+    setSteps: (state, action: PayloadAction<Step[]>) => {
+      state.steps = action.payload;
+    },
+
+    // 更新单个步骤的状态或结果
+    updateStep: (
+      state,
+      action: PayloadAction<{ id: string; updates: Partial<Step> }>
+    ) => {
+      const step = state.steps.find((s) => s.id === action.payload.id);
+      if (step) {
+        Object.assign(step, action.payload.updates);
+      }
+    },
+
+    // 设置当前正在执行的步骤ID
+    setCurrentStep: (state, action: PayloadAction<string | null>) => {
+      state.currentStep = action.payload;
+    },
+
+    // 清除所有步骤信息
+    clearSteps: (state) => {
+      state.steps = [];
+      state.currentStep = null;
+    },
+
+    // 新增：在指定步骤之后插入新步骤
+    insertStepsAfter: (
+      state,
+      action: PayloadAction<{
+        afterStepId: string;
+        newSteps: Step[];
+      }>
+    ) => {
+      const { afterStepId, newSteps } = action.payload;
+      const index = state.steps.findIndex((s) => s.id === afterStepId);
+      if (index !== -1) {
+        // 在 afterStepId 之后插入新步骤
+        state.steps.splice(index + 1, 0, ...newSteps);
+      }
+    },
+
+    // 新增：移除指定步骤之后的所有待执行步骤
+    removeStepsAfter: (state, action: PayloadAction<string>) => {
+      const afterStepId = action.payload;
+      const index = state.steps.findIndex((s) => s.id === afterStepId);
+      if (index !== -1) {
+        // 只保留 afterStepId 及之前的步骤，以及已完成的步骤
+        state.steps = state.steps.filter(
+          (s, i) => i <= index || s.status === "completed"
+        );
+      }
+    },
+
+    // 新增：设置执行配置
+    setExecutionConfig: (
+      state,
+      action: PayloadAction<PlanExecutionConfig | null>
+    ) => {
+      state.executionConfig = action.payload;
+    },
+
+    // 新增：更新执行统计
+    updateStats: (
+      state,
+      action: PayloadAction<Partial<PlanSliceState["stats"]>>
+    ) => {
+      Object.assign(state.stats, action.payload);
+    },
+
+    // 新增：增加反思计数
+    incrementReflectCount: (state) => {
+      state.stats.reflectCount += 1;
+    },
+
+    // 新增：增加已执行步骤计数
+    incrementStepsExecuted: (state) => {
+      state.stats.totalStepsExecuted += 1;
+    },
+
+    // 新增：设置开始时间
+    setStartTime: (state, action: PayloadAction<number>) => {
+      state.stats.startTime = action.payload;
+    },
+  },
+  selectors: {
+    selectPlanState: (state: PlanSliceState) => state.plan,
+    selectStepsState: (state: PlanSliceState) => state.steps,
+    selectCurrentStepIdState: (state: PlanSliceState) => state.currentStep,
+    selectExecutionConfigState: (state: PlanSliceState) =>
+      state.executionConfig,
+    selectStatsState: (state: PlanSliceState) => state.stats,
+  },
+});
+
+// --- Exports ---
+
+export const {
+  setPlan,
+  updatePlanProgress,
+  clearPlan,
+  setSteps,
+  updateStep,
+  setCurrentStep,
+  clearSteps,
+  insertStepsAfter,
+  removeStepsAfter,
+  setExecutionConfig,
+  updateStats,
+  incrementReflectCount,
+  incrementStepsExecuted,
+  setStartTime,
+} = planSlice.actions;
+
+export default planSlice.reducer;
+
+// Selectors
+export const selectPlan = (state: RootState): PlanState | null =>
+  state.plan.plan;
+
+export const selectSteps = (state: RootState): Step[] => state.plan.steps;
+
+export const selectCurrentStepId = (state: RootState): string | null =>
+  state.plan.currentStep;
+
+export const selectCurrentStepDetails = (state: RootState): Step | null => {
+  if (!state.plan.currentStep) return null;
+  return (
+    state.plan.steps.find((step) => step.id === state.plan.currentStep) || null
+  );
+};
+
+export const selectExecutionConfig = (
+  state: RootState
+): PlanExecutionConfig | null => state.plan.executionConfig;
+
+export const selectPlanStats = (state: RootState): PlanSliceState["stats"] =>
+  state.plan.stats;
+
+// 新增：获取待执行的步骤
+export const selectPendingSteps = (state: RootState): Step[] =>
+  state.plan.steps.filter((s) => s.status === "pending");
+
+// 新增：获取已完成的步骤
+export const selectCompletedSteps = (state: RootState): Step[] =>
+  state.plan.steps.filter((s) => s.status === "completed");

package/ai/agent/referenceUtils.ts

@@ -0,0 +1,229 @@
+import type { AppDispatch } from "app/store";
+import type { ReferenceItem } from "app/types";
+import { read } from "database/dbSlice";
+import {
+  extractRuntimePageCapabilities,
+  resolveSkillGraphFromRoots,
+  type SkillRuntimePageLike,
+} from "ai/skills/referenceRuntime";
+
+export type ResolvedReferenceAssets = {
+  references: ReferenceItem[];
+  referencedTools: string[];
+  recommendedSkillTools: string[];
+  recommendedSkillHints: string[];
+  skillPromptPatches: string[];
+  contentByKey: Map<string, any>;
+};
+
+export type ResolvedContentTools = {
+  tools: string[];
+  recommendedSkillTools: string[];
+  recommendedSkillHints: string[];
+  skillPromptPatches: string[];
+  contentByKey: Map<string, any>;
+};
+
+const loadContentsByKeys = async (
+  keys: string[],
+  dispatch: AppDispatch,
+  preloaded?: Map<string, any>
+): Promise<Map<string, any>> => {
+  const contentByKey = new Map<string, SkillRuntimePageLike>();
+  const uniqueKeys = Array.from(new Set(keys.filter(Boolean)));
+  await Promise.all(
+    uniqueKeys.map(async (dbKey) => {
+      if (preloaded?.has(dbKey)) {
+        const content = preloaded.get(dbKey);
+        if (content) contentByKey.set(dbKey, content);
+        return;
+      }
+      try {
+        const content = await dispatch(read({ dbKey })).unwrap();
+        if (content) contentByKey.set(dbKey, content);
+      } catch {
+        // ignore missing content
+      }
+    })
+  );
+  return contentByKey;
+};
+
+export const resolveReferenceAssets = async (
+references: ReferenceItem[] | undefined,
+dispatch: AppDispatch)
+: Promise<ResolvedReferenceAssets> => {
+  if (!Array.isArray(references) || references.length === 0) {
+    return {
+      references: [],
+      referencedTools: [],
+      recommendedSkillTools: [],
+      recommendedSkillHints: [],
+      skillPromptPatches: [],
+      contentByKey: new Map(),
+    };
+  }
+
+  const entries = await Promise.all(
+    references.
+    filter((ref) => ref?.dbKey).
+    map(async (ref) => {
+      try {
+        const content = await dispatch(read({ dbKey: ref.dbKey })).unwrap();
+        return { ref, content };
+      } catch {
+        return { ref, content: null };
+      }
+    })
+  );
+
+  const contentByKey = new Map<string, any>();
+  const toolSet = new Set<string>();
+  const recommendedToolSet = new Set<string>();
+  const recommendedSkillHints = new Set<string>();
+  const skillPromptPatches = new Set<string>();
+  const normalizedReferences: ReferenceItem[] = [];
+  const hardSkillKeys = new Set<string>();
+  const softSkillKeys = new Set<string>();
+
+  for (const { ref, content } of entries) {
+    if (content) {
+      contentByKey.set(ref.dbKey, content);
+    }
+
+    const capabilities = extractRuntimePageCapabilities(content);
+    for (const tool of capabilities.directTools) {
+      toolSet.add(tool);
+    }
+    for (const tool of capabilities.hardSkillTools) {
+      toolSet.add(tool);
+    }
+    for (const hint of capabilities.softSkillHints) {
+      recommendedSkillHints.add(hint);
+    }
+    for (const patch of capabilities.promptPatches) {
+      skillPromptPatches.add(patch);
+    }
+    for (const skillKey of capabilities.hardSkillKeys) {
+      hardSkillKeys.add(skillKey);
+    }
+    for (const skillKey of capabilities.softSkillKeys) {
+      softSkillKeys.add(skillKey);
+    }
+
+    normalizedReferences.push({
+      ...ref,
+      type: capabilities.shouldUpgradeReference ? "instruction" : ref.type,
+    });
+  }
+
+  const resolvedSkillLinks = await resolveSkillGraphFromRoots({
+    roots: [
+      ...Array.from(hardSkillKeys).map((identifier) => ({ identifier, mode: "required" as const })),
+      ...Array.from(softSkillKeys).map((identifier) => ({ identifier, mode: "recommended" as const })),
+    ],
+    loadPage: async (identifier) => {
+      const loaded = await loadContentsByKeys([identifier], dispatch, contentByKey);
+      return loaded.get(identifier) ?? null;
+    },
+    contentByKey,
+  });
+  resolvedSkillLinks.contentByKey.forEach((value, key) => contentByKey.set(key, value));
+  for (const tool of resolvedSkillLinks.requiredTools) {
+    toolSet.add(tool);
+  }
+  for (const tool of resolvedSkillLinks.recommendedTools) {
+    recommendedToolSet.add(tool);
+  }
+  for (const hint of resolvedSkillLinks.recommendedSkillHints) {
+    recommendedSkillHints.add(hint);
+  }
+  for (const patch of resolvedSkillLinks.skillPromptPatches) {
+    skillPromptPatches.add(patch);
+  }
+
+  return {
+    references: normalizedReferences,
+    referencedTools: Array.from(toolSet),
+    recommendedSkillTools: Array.from(recommendedToolSet),
+    recommendedSkillHints: Array.from(recommendedSkillHints),
+    skillPromptPatches: Array.from(skillPromptPatches),
+    contentByKey
+  };
+};
+
+export const resolveToolsFromKeys = async (
+keys: string[],
+dispatch: AppDispatch,
+preloaded?: Map<string, any>)
+: Promise<ResolvedContentTools> => {
+  if (!Array.isArray(keys) || keys.length === 0) {
+    return {
+      tools: [],
+      recommendedSkillTools: [],
+      recommendedSkillHints: [],
+      skillPromptPatches: [],
+      contentByKey: new Map(),
+    };
+  }
+
+  const contentByKey = await loadContentsByKeys(keys, dispatch, preloaded);
+  const toolSet = new Set<string>();
+  const recommendedToolSet = new Set<string>();
+  const recommendedSkillHints = new Set<string>();
+  const skillPromptPatches = new Set<string>();
+  const hardSkillKeys = new Set<string>();
+  const softSkillKeys = new Set<string>();
+
+  for (const content of contentByKey.values()) {
+    const capabilities = extractRuntimePageCapabilities(content);
+    for (const tool of [...capabilities.directTools, ...capabilities.hardSkillTools]) {
+      toolSet.add(tool);
+    }
+    for (const hint of capabilities.softSkillHints) {
+      recommendedSkillHints.add(hint);
+    }
+    for (const patch of capabilities.promptPatches) {
+      skillPromptPatches.add(patch);
+    }
+    for (const skillKey of capabilities.hardSkillKeys) {
+      hardSkillKeys.add(skillKey);
+    }
+    for (const skillKey of capabilities.softSkillKeys) {
+      softSkillKeys.add(skillKey);
+    }
+  }
+
+  const resolvedSkillLinks = await resolveSkillGraphFromRoots({
+    roots: [
+      ...Array.from(hardSkillKeys).map((identifier) => ({ identifier, mode: "required" as const })),
+      ...Array.from(softSkillKeys).map((identifier) => ({ identifier, mode: "recommended" as const })),
+    ],
+    loadPage: async (identifier) => {
+      const loaded = await loadContentsByKeys([identifier], dispatch, contentByKey);
+      return loaded.get(identifier) ?? null;
+    },
+    contentByKey,
+  });
+  resolvedSkillLinks.contentByKey.forEach((value, key) => contentByKey.set(key, value));
+  for (const tool of resolvedSkillLinks.requiredTools) {
+    toolSet.add(tool);
+  }
+  for (const tool of resolvedSkillLinks.recommendedTools) {
+    recommendedToolSet.add(tool);
+  }
+  for (const hint of resolvedSkillLinks.recommendedSkillHints) {
+    recommendedSkillHints.add(hint);
+  }
+  for (const patch of resolvedSkillLinks.skillPromptPatches) {
+    skillPromptPatches.add(patch);
+  }
+
+  return {
+    tools: Array.from(toolSet),
+    recommendedSkillTools: Array.from(recommendedToolSet),
+    recommendedSkillHints: Array.from(recommendedSkillHints),
+    skillPromptPatches: Array.from(skillPromptPatches),
+    contentByKey
+  };
+};