@ai-setting/roy-agent-core 1.0.0

package/src/env/workflow/storage/workflow-repo.ts

@@ -0,0 +1,342 @@
+/**
+ * @fileoverview Workflow Repository
+ * 
+ * SQLite-based repository for workflow CRUD operations.
+ */
+
+import { randomUUID } from 'crypto';
+import type { Workflow, WorkflowDefinition, WorkflowMetadata, WorkflowConfig } from '../types';
+import { getDatabase } from './sqlite';
+
+// Row interface matching database schema
+export interface WorkflowRow {
+  id: string;
+  name: string;
+  version: string;
+  description: string | null;
+  definition: string;
+  config: string;
+  metadata: string;
+  tags: string;
+  task_id: number | null;
+  created_at: string;
+  updated_at: string;
+}
+
+// Query options for listing workflows
+export interface ListWorkflowsOptions {
+  limit?: number;
+  offset?: number;
+  orderBy?: 'name' | 'created_at' | 'updated_at';
+  order?: 'asc' | 'desc';
+  tag?: string;
+  taskId?: number;   // 新增：按任务 ID 精确过滤
+  search?: string;    // 新增：搜索 description + tags
+}
+
+// Update options
+export interface UpdateWorkflowOptions {
+  name?: string;
+  version?: string;
+  description?: string;
+  definition?: WorkflowDefinition;
+  config?: WorkflowConfig;
+  metadata?: WorkflowMetadata;
+  tags?: string[];
+}
+
+/**
+ * Row to Workflow conversion helper
+ */
+export function rowToWorkflow(row: WorkflowRow): Workflow {
+  const metadata = JSON.parse(row.metadata) as WorkflowMetadata;
+  // Merge task_id from column into metadata
+  if (row.task_id !== null) {
+    metadata.taskId = row.task_id;
+  }
+  return {
+    id: row.id,
+    name: row.name,
+    version: row.version,
+    description: row.description || undefined,
+    definition: JSON.parse(row.definition) as WorkflowDefinition,
+    config: JSON.parse(row.config) as WorkflowConfig,
+    metadata,
+    tags: JSON.parse(row.tags) as string[],
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at),
+  };
+}
+
+/**
+ * WorkflowRepository class
+ * 
+ * Provides CRUD operations for workflows in SQLite.
+ */
+export class WorkflowRepository {
+  private db: ReturnType<typeof getDatabase>;
+
+  constructor(db?: ReturnType<typeof getDatabase>) {
+    this.db = db || getDatabase();
+  }
+
+  /**
+   * Create a new workflow
+   */
+  create(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Workflow {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+
+    const stmt = this.db.prepare(`
+      INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, task_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    stmt.run(
+      id,
+      workflow.name,
+      workflow.version,
+      workflow.description || null,
+      JSON.stringify(workflow.definition),
+      JSON.stringify(workflow.config),
+      JSON.stringify(workflow.metadata),
+      JSON.stringify(workflow.tags),
+      workflow.metadata?.taskId || null,  // 新增
+      now,
+      now
+    );
+
+    return {
+      ...workflow,
+      id,
+      createdAt: new Date(now),
+      updatedAt: new Date(now),
+    };
+  }
+
+  /**
+   * Create a workflow from definition only
+   */
+  createFromDefinition(definition: WorkflowDefinition, options?: {
+    config?: WorkflowConfig;
+    metadata?: WorkflowMetadata;
+    tags?: string[];
+  }): Workflow {
+    const workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'> = {
+      name: definition.name,
+      version: definition.version,
+      description: definition.description,
+      definition,
+      config: options?.config || definition.config || {},
+      metadata: options?.metadata || definition.metadata || {},
+      tags: options?.tags || definition.metadata?.tags || [],
+    };
+
+    return this.create(workflow);
+  }
+
+  /**
+   * Get a workflow by ID
+   */
+  getById(id: string): Workflow | undefined {
+    const row = this.db.prepare('SELECT * FROM workflows WHERE id = ?').get(id) as WorkflowRow | undefined;
+    if (!row) return undefined;
+    return rowToWorkflow(row);
+  }
+
+  /**
+   * Get a workflow by name (returns latest version)
+   */
+  getByName(name: string): Workflow | undefined {
+    const row = this.db.prepare(
+      'SELECT * FROM workflows WHERE name = ? ORDER BY updated_at DESC LIMIT 1'
+    ).get(name) as WorkflowRow | undefined;
+    if (!row) return undefined;
+    return rowToWorkflow(row);
+  }
+
+  /**
+   * Get a specific version of a workflow by name
+   */
+  getByNameAndVersion(name: string, version: string): Workflow | undefined {
+    const row = this.db.prepare(
+      'SELECT * FROM workflows WHERE name = ? AND version = ?'
+    ).get(name, version) as WorkflowRow | undefined;
+    if (!row) return undefined;
+    return rowToWorkflow(row);
+  }
+
+  /**
+   * List workflows with optional filtering and pagination
+   */
+  list(options?: ListWorkflowsOptions): Workflow[] {
+    let sql = 'SELECT * FROM workflows';
+    const params: any[] = [];
+    const conditions: string[] = [];
+
+    // Filter by tag
+    if (options?.tag) {
+      conditions.push('tags LIKE ?');
+      params.push(`%${options.tag}%`);
+    }
+
+    // Filter by taskId - SQLite INTEGER comparison
+    if (options?.taskId !== undefined) {
+      conditions.push('task_id = ?');
+      params.push(options.taskId);
+    }
+
+    // Apply WHERE clause
+    if (conditions.length > 0) {
+      sql += ' WHERE ' + conditions.join(' AND ');
+    }
+
+    // Order by
+    const orderBy = options?.orderBy || 'updated_at';
+    const order = options?.order || 'desc';
+    sql += ` ORDER BY ${orderBy} ${order.toUpperCase()}`;
+
+    // Pagination
+    if (options?.limit !== undefined) {
+      sql += ' LIMIT ?';
+      params.push(options.limit);
+    }
+    if (options?.offset !== undefined) {
+      sql += ' OFFSET ?';
+      params.push(options.offset);
+    }
+
+    const rows = this.db.prepare(sql).all(...params) as WorkflowRow[];
+    let workflows = rows.map(rowToWorkflow);
+
+    // Apply search filter in-memory (description + tags)
+    if (options?.search) {
+      // Lazy import to avoid circular dependency
+      const { parseSearchQuery, matchesQuery } = require('../../session/search-query-parser');
+      const query = parseSearchQuery(options.search);
+      workflows = workflows.filter(w => {
+        // Search in description
+        const descMatch = w.description ? matchesQuery(w.description, query) : false;
+        // Search in tags
+        const tagsMatch = w.tags.some(tag => matchesQuery(tag, query));
+        // Match if description OR any tag matches
+        return descMatch || tagsMatch;
+      });
+    }
+
+    return workflows;
+  }
+
+  /**
+   * List all versions of a workflow by name
+   */
+  listVersions(name: string): Workflow[] {
+    const rows = this.db.prepare(
+      'SELECT * FROM workflows WHERE name = ? ORDER BY version DESC'
+    ).all(name) as WorkflowRow[];
+    return rows.map(rowToWorkflow);
+  }
+
+  /**
+   * Update a workflow
+   */
+  update(id: string, updates: UpdateWorkflowOptions): Workflow | undefined {
+    const existing = this.getById(id);
+    if (!existing) return undefined;
+
+    const now = new Date().toISOString();
+    const setClauses: string[] = ['updated_at = ?'];
+    const params: any[] = [now];
+
+    if (updates.name !== undefined) {
+      setClauses.push('name = ?');
+      params.push(updates.name);
+    }
+    if (updates.version !== undefined) {
+      setClauses.push('version = ?');
+      params.push(updates.version);
+    }
+    if (updates.description !== undefined) {
+      setClauses.push('description = ?');
+      params.push(updates.description);
+    }
+    if (updates.definition !== undefined) {
+      setClauses.push('definition = ?');
+      params.push(JSON.stringify(updates.definition));
+    }
+    if (updates.config !== undefined) {
+      setClauses.push('config = ?');
+      params.push(JSON.stringify(updates.config));
+    }
+    if (updates.metadata !== undefined) {
+      setClauses.push('metadata = ?');
+      params.push(JSON.stringify(updates.metadata));
+      // Update task_id column if taskId is present in metadata
+      if (updates.metadata.taskId !== undefined) {
+        setClauses.push('task_id = ?');
+        params.push(updates.metadata.taskId);
+      }
+    }
+    if (updates.tags !== undefined) {
+      setClauses.push('tags = ?');
+      params.push(JSON.stringify(updates.tags));
+    }
+
+    params.push(id);
+
+    this.db.prepare(`UPDATE workflows SET ${setClauses.join(', ')} WHERE id = ?`).run(...params);
+
+    return this.getById(id);
+  }
+
+  /**
+   * Delete a workflow
+   */
+  delete(id: string): boolean {
+    const existing = this.getById(id);
+    if (!existing) return false;
+
+    this.db.prepare('DELETE FROM workflows WHERE id = ?').run(id);
+    return true;
+  }
+
+  /**
+   * Check if a workflow exists
+   */
+  exists(id: string): boolean {
+    const result = this.db.prepare('SELECT 1 FROM workflows WHERE id = ?').get(id);
+    return result !== undefined;
+  }
+
+  /**
+   * Check if a workflow with name and version exists
+   */
+  existsByNameAndVersion(name: string, version: string): boolean {
+    const result = this.db.prepare('SELECT 1 FROM workflows WHERE name = ? AND version = ?').get(name, version);
+    return result !== undefined;
+  }
+
+  /**
+   * Get total count of workflows
+   */
+  count(): number {
+    const result = this.db.prepare('SELECT COUNT(*) as count FROM workflows').get() as { count: number };
+    return result.count;
+  }
+
+  /**
+   * Search workflows by name (partial match)
+   */
+  search(query: string, limit?: number): Workflow[] {
+    let sql = 'SELECT * FROM workflows WHERE name LIKE ? ORDER BY updated_at DESC';
+    const params: any[] = [`%${query}%`];
+
+    if (limit !== undefined) {
+      sql += ' LIMIT ?';
+      params.push(limit);
+    }
+
+    const rows = this.db.prepare(sql).all(...params) as WorkflowRow[];
+    return rows.map(rowToWorkflow);
+  }
+}

package/src/env/workflow/tools/ask-user-tool.ts

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview AskUserTool - Tool for requesting user input in workflow
+ * 
+ * When an AgentNode calls this tool, it throws AskUserError to interrupt
+ * the workflow, allowing the workflow to pause and wait for user response.
+ */
+
+import { z } from 'zod';
+import type { ToolInfo, ToolContext } from '../../tool/types';
+import { AskUserError } from '../types/workflow-hil';
+
+// ==================== Input Schema ====================
+
+/**
+ * AskUserTool input schema
+ */
+export const AskUserInputSchema = z.object({
+  query: z.string().describe('The question or request to ask the user'),
+  options: z.array(z.string()).optional().describe('Optional choices for the user'),
+  required_confirm: z.boolean().optional().describe('If true, user must explicitly confirm'),
+});
+
+export type AskUserInput = z.infer<typeof AskUserInputSchema>;
+
+// ==================== Tool Definition ====================
+
+/**
+ * AskUserTool
+ * 
+ * A special tool that can be called by Agent to request user input.
+ * Calling this tool will throw AskUserError, which the Executor will
+ * catch and convert to a workflow pause event.
+ */
+export type AskUserTool = ToolInfo<typeof AskUserInputSchema>;
+
+export const askUserTool: AskUserTool = {
+  name: 'ask_user',
+  description: 'Ask user for input or confirmation. Use this tool when you need user input or validation to continue the workflow.',
+  
+  parameters: AskUserInputSchema,
+  
+  /**
+   * Execute the tool
+   * 
+   * @param args - Tool arguments including query
+   * @param context - Tool context
+   * @throws AskUserError - Always throws to interrupt workflow
+   */
+  async execute(
+    args: AskUserInput,
+    context: ToolContext
+  ): Promise<{ success: boolean; output: string }> {
+    // Extract context info from metadata with fallbacks
+    const runId = (context.metadata?.runId as string) || 'unknown';
+    const sessionId = (context.metadata?.sessionId as string) || `workflow_${runId}`;
+    const nodeId = (context.metadata?.nodeId as string) || 'unknown';
+    
+    // Build query with options if provided
+    let fullQuery = args.query;
+    if (args.options && args.options.length > 0) {
+      fullQuery = `${args.query} (选项: ${args.options.join(', ')})`;
+    }
+    
+    // Throw AskUserError to interrupt workflow
+    throw new AskUserError(
+      runId,
+      sessionId,
+      nodeId,
+      'agent',
+      fullQuery
+    );
+  },
+  
+  metadata: {
+    category: 'workflow',
+    tags: ['human-in-loop', 'user-input'],
+    version: '1.0.0',
+  },
+};
+
+// Export singleton instance (alias)
+export const askUserToolInstance = askUserTool;

package/src/env/workflow/tools/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Workflow Tools - Phase 7
+ * 
+ * Export all workflow-related tools
+ */
+
+// Run Workflow Tool
+export {
+  createRunWorkflowTool,
+  initRunWorkflowTool,
+  getRunWorkflowTool,
+  resetRunWorkflowTool,
+  RunWorkflowInputSchema,
+  type RunWorkflowInput,
+  type RunWorkflowTool,
+  type RunWorkflowToolInterface,
+} from "./run-workflow";
+
+// Ask User Tool
+export {
+  askUserTool,
+  askUserToolInstance,
+  AskUserInputSchema,
+  type AskUserTool,
+  type AskUserInput,
+} from "./ask-user-tool";