@minded-ai/mindedjs 1.0.67 → 1.0.69

package/src/playbooks/playbooks.ts

@@ -0,0 +1,203 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+import * as ejs from 'ejs';
+import { MindedConnection } from '../platform/mindedConnection';
+import { MindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
+import { getConfig } from '../platform/config';
+import { logger } from '../utils/logger';
+import { OutputBlockData } from '@editorjs/editorjs';
+
+export type Playbook = {
+  id: string;
+  name: string;
+  blocks: OutputBlockData[];
+}
+
+/**
+ * Convert EditorJS blocks to markdown
+ */
+function editorJsToMarkdown(blocks: OutputBlockData[]): string {
+  if (!blocks || blocks.length === 0) {
+    return '';
+  }
+
+  return blocks.map(block => {
+    switch (block.type) {
+      case 'header': {
+        const level = block.data?.level || 1;
+        const headerPrefix = '#'.repeat(level);
+        return `${headerPrefix} ${block.data?.text || ''}`;
+      }
+
+      case 'paragraph': {
+        return block.data?.text || '';
+      }
+
+      case 'list': {
+        const items = block.data?.items || [];
+        const style = block.data?.style || 'unordered';
+        return items.map((item: string, index: number) => {
+          if (style === 'ordered') {
+            return `${index + 1}. ${item}`;
+          } else {
+            return `- ${item}`;
+          }
+        }).join('\n');
+      }
+
+      case 'quote': {
+        const text = block.data?.text || '';
+        const caption = block.data?.caption ? `\n*${block.data.caption}*` : '';
+        return `> ${text}${caption}`;
+      }
+
+      case 'code': {
+        const code = block.data?.code || '';
+        return `\`\`\`\n${code}\n\`\`\``;
+      }
+
+      case 'delimiter': {
+        return '---';
+      }
+
+      default: {
+        logger.warn(`Unknown playbook block type: ${block.type}`);
+        return '';
+      }
+    }
+  }).join('\n\n');
+}
+
+/**
+ * Load playbooks from directories or platform
+ */
+export async function loadPlaybooks(
+  mindedConnection: MindedConnection | null,
+  playbooksDirectories?: string[]
+): Promise<Playbook[]> {
+  const { env, isDeployed } = getConfig();
+  let playbooks: Playbook[] = [];
+
+  if (['sandbox-staging', 'sandbox'].includes(env) && isDeployed && mindedConnection) {
+    // Load from platform
+    const response = await mindedConnection.awaitEmit<object, { playbooks?: Playbook[]; error?: string }>(
+      MindedConnectionSocketMessageType.GET_PLAYBOOKS,
+      {},
+    );
+
+    if (response?.error) {
+      throw new Error(`Failed to load playbooks from platform: ${response.error}`);
+    }
+
+    playbooks = response?.playbooks || [];
+  } else if (playbooksDirectories) {
+    // Load from directories
+    playbooks = loadPlaybooksFromDirectories(playbooksDirectories);
+  }
+
+  return playbooks;
+}
+
+/**
+ * Load playbooks from local directories
+ */
+function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
+  const playbooks: Playbook[] = [];
+
+  for (const directory of directories) {
+    if (!fs.existsSync(directory)) {
+      logger.info(`Playbooks directory does not exist: ${directory}`);
+      continue;
+    }
+
+    const files = getAllYamlFiles(directory);
+
+    for (const file of files) {
+      try {
+        const fileContent = fs.readFileSync(file, 'utf8');
+        const playbook = yaml.load(fileContent) as Playbook;
+
+        if (playbook && playbook.name && playbook.blocks) {
+          playbooks.push(playbook);
+          logger.info(`Loaded playbook: ${playbook.name} from ${file}`);
+        } else {
+          logger.warn(`Invalid playbook structure in ${file}`);
+        }
+      } catch (error) {
+        logger.error(`Failed to load playbook file ${file}: ${error}`);
+      }
+    }
+  }
+
+  return playbooks;
+}
+
+/**
+ * Recursively get all YAML files in a directory
+ */
+function getAllYamlFiles(dir: string): string[] {
+  const files: string[] = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...getAllYamlFiles(fullPath));
+    } else if (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Compile playbooks into a single string with EJS and placeholders
+ */
+export function compilePlaybooks(playbooks: Playbook[], params: Record<string, any> = {}): string {
+  if (playbooks.length === 0) {
+    return '';
+  }
+
+  // Combine all playbooks into sections
+  const sections = playbooks.map((playbook) => {
+    const markdownContent = editorJsToMarkdown(playbook.blocks);
+    return `# ${playbook.name}\n${markdownContent}`;
+  });
+
+  const combinedPlaybooks = sections.join('\n\n');
+
+  try {
+    // First, render with EJS
+    let compiledPlaybooks = ejs.render(combinedPlaybooks, params);
+
+    // Then, replace placeholders in {} format
+    compiledPlaybooks = replacePlaceholders(compiledPlaybooks, params);
+
+    return compiledPlaybooks;
+  } catch (error) {
+    logger.error({ message: 'Error compiling playbooks', error });
+    return combinedPlaybooks; // Return uncompiled if there's an error
+  }
+}
+
+/**
+ * Replace placeholders in {key} format
+ */
+function replacePlaceholders(text: string, params: Record<string, any>): string {
+  return text.replace(/\{([^}]+)\}/g, (match, key) => {
+    const keys = key.split('.');
+    let value: any = params;
+
+    for (const k of keys) {
+      if (value && typeof value === 'object' && k in value) {
+        value = value[k];
+      } else {
+        return match; // Return original if key not found
+      }
+    }
+
+    return String(value);
+  });
+}

package/src/types/Agent.types.ts

@@ -1,13 +1,20 @@
-import { AgentEventRequestPayloads, AgentEventResponsePayloads } from "../events/AgentEvents";
-import { LLMConfig } from "./LLM.types";
+import { AgentEventRequestPayloads, AgentEventResponsePayloads } from '../events/AgentEvents';
+import { LLMConfig } from './LLM.types';
 
-export type EmitSignature<Memory, E extends keyof AgentEventRequestPayloads<Memory>> = (event: E, payload: AgentEventRequestPayloads<Memory>[E]) => Promise<(AgentEventResponsePayloads<Memory>[E])[]>;
+export type EmitSignature<Memory, E extends keyof AgentEventRequestPayloads<Memory>> = (
+  event: E,
+  payload: AgentEventRequestPayloads<Memory>[E],
+) => Promise<AgentEventResponsePayloads<Memory>[E][]>;
 
 export type MindedSDKConfig = {
   flows: string[];
   llm: LLMConfig;
   tools: string[];
-}
+  /**
+   * Optional directories containing playbook definition files. If omitted, no playbooks will be loaded.
+   */
+  playbooks?: string[];
+};
 
 /**
  * Parameters for the Agent invoke method
@@ -37,7 +44,7 @@ export interface TriggerInvocationHistory extends FlowHistory {
   appName?: string;
   triggerName: string;
   triggerBody: any;
-};
+}
 
 export interface AppActionInvocationHistory extends FlowHistory {
   type: FlowHistoryType.APP_ACTION_INVOCATION;
@@ -47,4 +54,4 @@ export interface AppActionInvocationHistory extends FlowHistory {
 export enum SessionType {
   VOICE = 'voice',
   TEXT = 'text',
-}
+}