nolo-cli 0.1.8 → 0.1.10

package/ai/types.ts

@@ -0,0 +1,55 @@
+// packages/ai/types.ts
+
+export type ModeType =
+  | "text"
+  | "image"
+  | "stream"
+  | "audio"
+  | "speech"
+  | "surf"
+  | "vision";
+
+export interface PromptFormData {
+  name: string;
+  content: string;
+  category?: string;
+  tags?: string[];
+}
+
+export interface Contexts {
+  // High priority: context from the user's current input for this request.
+  currentInputContext?: string | null;
+
+  // Medium priority: references from past conversation messages.
+  historyContext?: string | null;
+
+  // Specific rules and processes for the bot/agent.
+  botInstructionsContext?: string | null;
+
+  // General knowledge base documents for lookup.
+  botKnowledgeContext?: string | null;
+
+  // 🔹 新增：用户级通用提示词
+  userGlobalPrompt?: string;
+
+  /** 当前正在编辑的对象描述（表格 / 页面 / 文章等），由 buildEditingContextSummary 构造 */
+  editingContext?: string | null;
+
+  /** 当前对话里最近一次 app 相关工具调用提炼出的工作记忆，不依赖右侧 editing target */
+  appWorkingMemory?: string | null;
+
+  /** 当前所在的 Space 信息（Agent 所处的工作台），包含标题、描述等 */
+  spaceContext?: string | null;
+
+  /** 用户偏好与自动化边界（tone / capture / read policy） */
+  userPolicyContext?: string | null;
+
+  /** 对话增量摘要：已压缩的历史消息概要 */
+  dialogSummary?: string | null;
+
+  /** 主动工作摘要：阶段性沉淀，不代表原始消息已被裁剪 */
+  proactiveSummary?: string | null;
+
+  /** 压缩消息中提取的引用 Key */
+  referenceKeys?: string[];
+}

package/ai/workflow/workflowExecutor.ts

@@ -0,0 +1,323 @@
+/**
+ * Workflow Executor
+ *
+ * Deterministic execution engine — zero LLM orchestration tokens.
+ * Each step runs directly without asking LLM "what to do next".
+ * Only "llm" type steps call the model (single call, no tool loop).
+ */
+
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import type { RootState } from "app/store";
+import { runLlm } from "ai/agent/agentSlice";
+import { toolExecutors } from "ai/tools";
+import {
+  setWorkflow,
+  updateStep,
+  incrementStepsExecuted,
+  incrementFailedSteps,
+} from "./workflowSlice";
+import type {
+  WorkflowDefinition,
+  WorkflowStep,
+  WorkflowToolStep,
+  WorkflowLlmStep,
+  WorkflowParallelStep,
+  WorkflowStepState,
+  WorkflowResult,
+} from "./workflowTypes";
+
+// --- Template Resolution ---
+
+/**
+ * Resolves {{steps.<id>.result}} and {{steps.<id>.result[N]}} templates.
+ * Walks nested objects/arrays recursively.
+ */
+function resolveTemplates(
+  value: any,
+  results: Record<string, any>
+): any {
+  if (typeof value === "string") {
+    return value.replace(
+      /\{\{steps\.([^.}\s]+)\.result(\[\d+\])?\}\}/g,
+      (match, stepId, indexPart) => {
+        const stepResult = results[stepId];
+        if (stepResult === undefined) {
+          console.warn(`Workflow: cannot resolve {{steps.${stepId}.result}} — step not completed yet`);
+          return match;
+        }
+        let resolved = stepResult;
+        if (indexPart) {
+          const idx = parseInt(indexPart.slice(1, -1), 10);
+          if (Array.isArray(resolved) && idx < resolved.length) {
+            resolved = resolved[idx];
+          } else {
+            console.warn(`Workflow: index ${idx} out of range for steps.${stepId}.result`);
+            return match;
+          }
+        }
+        return typeof resolved === "object" ? JSON.stringify(resolved) : String(resolved);
+      }
+    );
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => resolveTemplates(v, results));
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, resolveTemplates(v, results)])
+    );
+  }
+  return value;
+}
+
+// --- Condition Evaluation (safe allowlist interpreter) ---
+
+/**
+ * Validates that an expression contains ONLY:
+ *   - steps.<identifier> property paths
+ *   - comparison operators: === !== > < >= <=
+ *   - logical operators: && || !
+ *   - string literals, number literals, boolean/null keywords
+ *   - parentheses and whitespace
+ *
+ * Strategy: substitute every safe token with a placeholder, then assert
+ * nothing else remains. This allowlist approach is far more robust than a
+ * blocklist, which can be bypassed with Unicode escapes or bracket notation.
+ */
+function isSafeConditionExpression(expr: string): boolean {
+  let s = expr.trim();
+  if (!s) return false;
+
+  // 1. Replace double/single-quoted string literals (no newlines inside)
+  s = s.replace(/"[^"\n\\]*(?:\\.[^"\n\\]*)*"/g, "0");
+  s = s.replace(/'[^'\n\\]*(?:\\.[^'\n\\]*)*/g, "0");
+
+  // 2. Replace number literals (int / float)
+  s = s.replace(/\b\d+(?:\.\d+)?\b/g, "0");
+
+  // 3. Replace allowed keywords
+  s = s.replace(/\b(true|false|null|undefined)\b/g, "0");
+
+  // 4. Replace steps.<dotted-path> (e.g. steps.fetchData.output)
+  s = s.replace(/\bsteps\.[a-zA-Z_][a-zA-Z0-9_.]*\b/g, "0");
+
+  // 5. What's left should only be operators, parens, whitespace
+  //    Allowed characters: 0 (placeholder) space ( ) ! & | = < >
+  return /^[0\s()!&|=<>]+$/.test(s);
+}
+
+/**
+ * Safely resolves a dotted property path like "steps.fetchData.output"
+ * against the given results object. Returns undefined for any unknown path.
+ */
+function resolvePath(path: string, results: Record<string, any>): unknown {
+  // path must be "steps.<segment>[.<segment>...]"
+  const parts = path.split(".");
+  if (parts[0] !== "steps" || parts.length < 2) return undefined;
+  let cur: any = results;
+  for (let i = 1; i < parts.length; i++) {
+    if (cur === null || cur === undefined || typeof cur !== "object") return undefined;
+    cur = cur[parts[i]];
+  }
+  return cur;
+}
+
+/**
+ * Evaluates a condition expression against step results.
+ *
+ * Uses an allowlist validator to guarantee the expression contains nothing
+ * but property lookups, comparison/logical operators, and literals before
+ * delegating to the JS engine. This eliminates the code-execution surface
+ * that a keyword blocklist cannot reliably close.
+ */
+function evaluateCondition(
+  expression: string,
+  results: Record<string, any>
+): boolean {
+  if (!isSafeConditionExpression(expression)) {
+    console.warn(
+      `Workflow: condition expression rejected by allowlist: "${expression}"`
+    );
+    return false;
+  }
+  try {
+    // At this point the expression has been validated to contain only safe
+    // tokens. We substitute all steps.* paths with their runtime values so
+    // the final eval string never needs to reference external globals.
+    const resolved = expression.replace(
+      /\bsteps\.[a-zA-Z_][a-zA-Z0-9_.]*\b/g,
+      (match) => JSON.stringify(resolvePath(match, results))
+    );
+    // eslint-disable-next-line no-new-func
+    const fn = new Function(`"use strict"; return !!(${resolved})`);
+    return fn();
+  } catch (e) {
+    console.warn(`Workflow: condition eval failed: "${expression}"`, e);
+    return false;
+  }
+}
+
+
+
+/**
+ * Executes `fn` up to `maxRetries + 1` times total.
+ * Throws the last error if all attempts fail.
+ */
+async function executeWithRetry<T>(
+  fn: () => Promise<T>,
+  maxRetries: number
+): Promise<T> {
+  let lastError: any;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  throw lastError;
+}
+
+// --- Single Step Executors ---
+
+async function executeToolStep(
+  step: WorkflowToolStep,
+  results: Record<string, any>,
+  thunkApi: any
+): Promise<any> {
+  const executor = toolExecutors[step.tool];
+  if (!executor) throw new Error(`Workflow: unknown tool "${step.tool}"`);
+  const resolvedArgs = resolveTemplates(step.args, results);
+  const result = await executor(resolvedArgs, thunkApi);
+  return result?.rawData ?? result;
+}
+
+async function executeLlmStep(
+  step: WorkflowLlmStep,
+  results: Record<string, any>,
+  thunkApi: any
+): Promise<any> {
+  const { dispatch } = thunkApi;
+  const resolvedPrompt = resolveTemplates(step.prompt, results);
+  const result = await dispatch(
+    runLlm({
+      content: resolvedPrompt,
+      isStreaming: false,
+      ...(step.model && { modelOverride: step.model }),
+    })
+  ).unwrap();
+  return result;
+}
+
+async function executeParallelStep(
+  step: WorkflowParallelStep,
+  results: Record<string, any>,
+  thunkApi: any
+): Promise<Record<string, any>> {
+  const subResults = await Promise.all(
+    step.steps.map(async (sub) => {
+      const subResult =
+        sub.type === "tool"
+          ? await executeToolStep(sub as WorkflowToolStep, results, thunkApi)
+          : await executeLlmStep(sub as WorkflowLlmStep, results, thunkApi);
+      return [sub.id, subResult] as [string, any];
+    })
+  );
+  return Object.fromEntries(subResults);
+}
+
+// --- Main Executor Thunk ---
+
+export const runWorkflow = createAsyncThunk<
+  WorkflowResult,
+  { definition: WorkflowDefinition; dialogKey?: string },
+  { state: RootState }
+>("workflow/run", async ({ definition }, thunkApi) => {
+  const { dispatch } = thunkApi;
+
+  // Initialize Redux state for UI visibility
+  const initialStepStates: WorkflowStepState[] = definition.steps.map((s) => ({
+    id: s.id,
+    title: s.title,
+    type: s.type,
+    status: "pending",
+  }));
+  dispatch(setWorkflow({ title: definition.title, steps: initialStepStates }));
+
+  const results: Record<string, any> = {};
+  // Set of step IDs to skip (controlled by condition steps)
+  const skippedIds = new Set<string>();
+
+  for (const step of definition.steps) {
+    if (skippedIds.has(step.id)) {
+      dispatch(updateStep({ id: step.id, updates: { status: "skipped" } }));
+      continue;
+    }
+
+    dispatch(updateStep({ id: step.id, updates: { status: "in-progress" } }));
+
+    try {
+      let result: any;
+
+      if (step.type === "tool" || step.type === "llm") {
+        const retryable = step as WorkflowToolStep | WorkflowLlmStep;
+        const policy = retryable.onError ?? "stop";
+        const maxRetries =
+          policy === "retry" ? ((retryable as WorkflowToolStep).retryCount ?? 1) : 0;
+
+        result = await executeWithRetry(
+          () =>
+            step.type === "tool"
+              ? executeToolStep(step as WorkflowToolStep, results, thunkApi)
+              : executeLlmStep(step as WorkflowLlmStep, results, thunkApi),
+          maxRetries
+        );
+
+      } else if (step.type === "parallel") {
+        result = await executeParallelStep(step, results, thunkApi);
+        // Flatten sub-step results into the top-level map so subsequent steps
+        // can reference them directly via {{steps.<subId>.result}}.
+        for (const [subId, subResult] of Object.entries(
+          result as Record<string, any>
+        )) {
+          results[subId] = subResult;
+        }
+
+      } else if (step.type === "condition") {
+        const passed = evaluateCondition(step.check, results);
+        result = { passed, check: step.check };
+        const active = passed ? step.ifTrue : step.ifFalse;
+        const inactive = passed ? step.ifFalse : step.ifTrue;
+        // Mark steps not on the active branch as skipped
+        if (inactive) inactive.forEach((id) => skippedIds.add(id));
+        // Steps on the active branch are explicitly NOT skipped
+        if (active) active.forEach((id) => skippedIds.delete(id));
+      }
+
+      results[step.id] = result;
+      dispatch(updateStep({ id: step.id, updates: { status: "completed", result } }));
+      dispatch(incrementStepsExecuted());
+
+    } catch (err: any) {
+      dispatch(incrementFailedSteps());
+      dispatch(
+        updateStep({ id: step.id, updates: { status: "failed", error: err?.message ?? String(err) } })
+      );
+
+      const policy = (step as WorkflowToolStep | WorkflowLlmStep).onError ?? "stop";
+
+      if (policy === "stop") {
+        return {
+          success: false,
+          results,
+          failedStep: step.id,
+          error: err?.message ?? String(err),
+        };
+      }
+      // skip / retry-exhausted: record null and continue
+      results[step.id] = null;
+    }
+  }
+
+  return { success: true, results };
+});

package/ai/workflow/workflowSlice.ts

@@ -0,0 +1,73 @@
+import { type PayloadAction, createSlice } from "@reduxjs/toolkit";
+import type { RootState } from "app/store";
+import type {
+  WorkflowStepState,
+  WorkflowExecutionStats,
+} from "./workflowTypes";
+
+interface WorkflowSliceState {
+  title: string | null;
+  steps: WorkflowStepState[];
+  stats: WorkflowExecutionStats;
+}
+
+const initialState: WorkflowSliceState = {
+  title: null,
+  steps: [],
+  stats: {
+    startTime: null,
+    totalStepsExecuted: 0,
+    failedSteps: 0,
+  },
+};
+
+const workflowSlice = createSlice({
+  name: "workflow",
+  initialState,
+  reducers: {
+    setWorkflow: (
+      state,
+      action: PayloadAction<{ title: string; steps: WorkflowStepState[] }>
+    ) => {
+      state.title = action.payload.title;
+      state.steps = action.payload.steps;
+      state.stats = { startTime: Date.now(), totalStepsExecuted: 0, failedSteps: 0 };
+    },
+
+    updateStep: (
+      state,
+      action: PayloadAction<{ id: string; updates: Partial<WorkflowStepState> }>
+    ) => {
+      const step = state.steps.find((s) => s.id === action.payload.id);
+      if (step) Object.assign(step, action.payload.updates);
+    },
+
+    incrementStepsExecuted: (state) => {
+      state.stats.totalStepsExecuted += 1;
+    },
+
+    incrementFailedSteps: (state) => {
+      state.stats.failedSteps += 1;
+    },
+
+    clearWorkflow: () => initialState,
+  },
+});
+
+export const {
+  setWorkflow,
+  updateStep,
+  incrementStepsExecuted,
+  incrementFailedSteps,
+  clearWorkflow,
+} = workflowSlice.actions;
+
+export const selectWorkflowSteps = (state: RootState) => state.workflow.steps;
+export const selectWorkflowTitle = (state: RootState) => state.workflow.title;
+export const selectWorkflowStats = (state: RootState) => state.workflow.stats;
+export const selectPendingSteps = (state: RootState) =>
+  state.workflow.steps.filter((s) => s.status === "pending");
+export const selectCompletedSteps = (state: RootState) =>
+  state.workflow.steps.filter((s) => s.status === "completed");
+
+export default workflowSlice.reducer;

package/ai/workflow/workflowTypes.ts

@@ -0,0 +1,106 @@
+// Workflow: deterministic execution engine, zero LLM orchestration tokens.
+// LLM calls createWorkflow once to define steps; engine executes without further LLM involvement.
+// Only "llm" type steps invoke the model; all others run as pure tool calls.
+
+export type WorkflowStepStatus = "pending" | "in-progress" | "completed" | "failed" | "skipped";
+
+export type OnErrorPolicy = "stop" | "skip" | "retry";
+
+// --- Step Types ---
+
+export interface WorkflowToolStep {
+  id: string;
+  type: "tool";
+  title?: string;
+  /** Registered tool name */
+  tool: string;
+  /** Args supporting {{steps.<id>.result}} and {{steps.<id>.result[N]}} templates */
+  args: Record<string, any>;
+  onError?: OnErrorPolicy;
+  retryCount?: number;
+}
+
+export interface WorkflowLlmStep {
+  id: string;
+  type: "llm";
+  title?: string;
+  /** Prompt supporting {{steps.<id>.result}} templates */
+  prompt: string;
+  model?: string;
+  onError?: OnErrorPolicy;
+}
+
+/** All steps inside run concurrently via Promise.all */
+export interface WorkflowParallelStep {
+  id: string;
+  type: "parallel";
+  title?: string;
+  steps: (WorkflowToolStep | WorkflowLlmStep)[];
+}
+
+/**
+ * Pure JS condition check — no LLM.
+ * `check` is a JS expression string evaluated with step results in scope.
+ *
+ * Supported syntax (allowlist):
+ *   - Dotted property access: `steps.<stepId>.<property>[.<nested>...]`
+ *   - Comparison operators: === !== > < >= <=
+ *   - Logical operators: && || !
+ *   - String / number / boolean / null literals
+ *   - Parentheses for grouping
+ *
+ * Note: bracket notation (`steps['id']`) and `.result` wrappers are NOT supported.
+ * The value stored for each step is the raw executor return value, accessed directly:
+ * e.g. `"steps.validate.isValid === true"`
+ *      `"steps.score.value >= 80 && steps.flag.ok !== false"`
+ */
+export interface WorkflowConditionStep {
+  id: string;
+  type: "condition";
+  title?: string;
+  check: string;
+  /** Step IDs to execute when check is truthy (skip others) */
+  ifTrue?: string[];
+  /** Step IDs to execute when check is falsy (skip others) */
+  ifFalse?: string[];
+}
+
+export type WorkflowStep =
+  | WorkflowToolStep
+  | WorkflowLlmStep
+  | WorkflowParallelStep
+  | WorkflowConditionStep;
+
+// --- Workflow Definition ---
+
+export interface WorkflowDefinition {
+  title: string;
+  steps: WorkflowStep[];
+}
+
+// --- Execution State (stored in Redux) ---
+
+export interface WorkflowStepState {
+  id: string;
+  title?: string;
+  type: WorkflowStep["type"];
+  status: WorkflowStepStatus;
+  result?: any;
+  error?: string;
+}
+
+export interface WorkflowExecutionStats {
+  startTime: number | null;
+  totalStepsExecuted: number;
+  failedSteps: number;
+}
+
+// --- Result ---
+
+export interface WorkflowResult {
+  success: boolean;
+  /** Results keyed by step id */
+  results: Record<string, any>;
+  failedStep?: string;
+  error?: string;
+}