nolo-cli 0.1.10 → 0.1.11

package/ai/types.ts

@@ -1,55 +0,0 @@
-// 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

@@ -1,323 +0,0 @@
-/**
- * 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

@@ -1,73 +0,0 @@
-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

@@ -1,106 +0,0 @@
-// 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;
-}