@fortressllm/sybil 0.0.3

package/src/tools/extended-tools.ts

@@ -0,0 +1,498 @@
+/**
+ * Extended Tool Library for Sybil
+ * 
+ * Additional tools beyond core WhatsApp and web functionality.
+ * Sybil's capabilities beyond the core WhatsApp and web tools.
+ */
+
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+import axios from "axios";
+import * as cheerio from "cheerio";
+
+// Re-export existing tools
+export { 
+  fetchWebContentTool, 
+  searchWebTool, 
+  extractStructuredDataTool,
+  deepResearchTool 
+} from "./web-tools.js";
+
+export {
+  getWhatsAppStatusTool,
+  initializeWhatsAppTool,
+  sendWhatsAppMessageTool,
+  getWhatsAppChatsTool,
+  getWhatsAppMessagesTool,
+  getWhatsAppContactTool,
+  getMyWhatsAppInfoTool,
+  broadcastWhatsAppMessageTool,
+} from "./whatsapp-tools.js";
+
+export {
+  configureAutoReplyTool,
+  approvePendingReplyTool,
+} from "./whatsapp-autoreply-tools.js";
+
+// ==================== FILE SYSTEM TOOLS ====================
+
+/**
+ * Tool: Read File
+ * Reads the contents of a file from the filesystem
+ */
+export const readFileTool = createTool({
+  id: "read-file",
+  description: `
+    Read the contents of a file from the filesystem.
+    Use this when you need to examine existing files or retrieve data.
+  `,
+  inputSchema: z.object({
+    path: z.string().describe("The path to the file to read"),
+    encoding: z.enum(["utf8", "base64"]).optional().default("utf8").describe("File encoding"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    content: z.string().optional(),
+    error: z.string().optional(),
+  }),
+  execute: async (inputData) => {
+    try {
+      // In a real implementation, this would actually read files
+      // For now, we'll simulate with a placeholder
+      return {
+        success: true,
+        content: `File content from ${inputData.path} would appear here`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  },
+});
+
+/**
+ * Tool: Write File
+ * Writes content to a file in the filesystem
+ */
+export const writeFileTool = createTool({
+  id: "write-file",
+  description: `
+    Write content to a file in the filesystem.
+    Use this when you need to create or update files with generated content.
+  `,
+  inputSchema: z.object({
+    path: z.string().describe("The path to the file to write"),
+    content: z.string().describe("The content to write to the file"),
+    encoding: z.enum(["utf8", "base64"]).optional().default("utf8").describe("File encoding"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    message: z.string().optional(),
+    error: z.string().optional(),
+  }),
+  execute: async (inputData) => {
+    try {
+      // In a real implementation, this would actually write files
+      // For now, we'll simulate with a placeholder
+      return {
+        success: true,
+        message: `File written successfully to ${inputData.path}`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  },
+});
+
+/**
+ * Tool: List Directory
+ * Lists files and directories in a given path
+ */
+export const listDirectoryTool = createTool({
+  id: "list-directory",
+  description: `
+    List files and directories in a given path.
+    Use this to explore the filesystem structure.
+  `,
+  inputSchema: z.object({
+    path: z.string().describe("The path to list directory contents for"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    files: z.array(z.object({
+      name: z.string(),
+      type: z.enum(["file", "directory"]),
+      size: z.number().optional(),
+      modified: z.string().optional(),
+    })).optional(),
+    error: z.string().optional(),
+  }),
+  execute: async (inputData: any) => {
+    try {
+      // In a real implementation, this would actually list directories
+      // For now, we'll simulate with a placeholder
+      return {
+        success: true,
+        files: [
+          { name: "example.txt", type: "file" as const, size: 1024 },
+          { name: "data", type: "directory" as const },
+        ],
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  },
+});
+
+// ==================== CODE EXECUTION TOOLS ====================
+
+/**
+ * Tool: Execute Code
+ * Executes code in a sandboxed environment
+ */
+export const executeCodeTool = createTool({
+  id: "execute-code",
+  description: `
+    Execute code in a sandboxed environment.
+    Supports JavaScript, Python, and shell scripts.
+    Use this when you need to run computations or scripts.
+  `,
+  inputSchema: z.object({
+    language: z.enum(["javascript", "python", "shell"]).describe("Programming language to execute"),
+    code: z.string().describe("Code to execute"),
+    timeout: z.number().optional().default(30000).describe("Execution timeout in milliseconds"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    output: z.string().optional(),
+    error: z.string().optional(),
+    executionTime: z.number().optional(),
+  }),
+  execute: async (inputData) => {
+    try {
+      // In a real implementation, this would actually execute code
+      // For now, we'll simulate with a placeholder
+      const startTime = Date.now();
+      
+      // Simulate execution
+      await new Promise(resolve => setTimeout(resolve, 100));
+      
+      const executionTime = Date.now() - startTime;
+      
+      return {
+        success: true,
+        output: `Executed ${inputData.language} code successfully\nResult: simulated output`,
+        executionTime,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  },
+});
+
+// ==================== CALENDAR TOOLS ====================
+
+/**
+ * Tool: Create Calendar Event
+ * Creates a calendar event
+ */
+export const createCalendarEventTool = createTool({
+  id: "create-calendar-event",
+  description: `
+    Create a calendar event.
+    Use this to schedule meetings, appointments, or reminders.
+  `,
+  inputSchema: z.object({
+    title: z.string().describe("Event title"),
+    description: z.string().optional().describe("Event description"),
+    startTime: z.string().datetime().describe("Event start time (ISO 8601)"),
+    endTime: z.string().datetime().describe("Event end time (ISO 8601)"),
+    attendees: z.array(z.string()).optional().describe("Email addresses of attendees"),
+    location: z.string().optional().describe("Event location"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    eventId: z.string().optional(),
+    message: z.string().optional(),
+    error: z.string().optional(),
+  }),
+  execute: async (inputData) => {
+    try {
+      // In a real implementation, this would integrate with calendar services
+      // For now, we'll simulate with a placeholder
+      return {
+        success: true,
+        eventId: `event-${Date.now()}`,
+        message: `Created calendar event: ${inputData.title}`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  },
+});
+
+/**
+ * Tool: List Calendar Events
+ * Lists upcoming calendar events
+ */
+export const listCalendarEventsTool = createTool({
+  id: "list-calendar-events",
+  description: `
+    List upcoming calendar events.
+    Use this to check schedules or find available time slots.
+  `,
+  inputSchema: z.object({
+    startTime: z.string().datetime().optional().describe("Start time to search from (ISO 8601)"),
+    endTime: z.string().datetime().optional().describe("End time to search to (ISO 8601)"),
+    maxResults: z.number().optional().default(10).describe("Maximum number of events to return"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    events: z.array(z.object({
+      id: z.string(),
+      title: z.string(),
+      description: z.string().optional(),
+      startTime: z.string(),
+      endTime: z.string(),
+      attendees: z.array(z.string()).optional(),
+      location: z.string().optional(),
+    })).optional(),
+    error: z.string().optional(),
+  }),
+  execute: async (inputData) => {
+    try {
+      // In a real implementation, this would fetch from calendar services
+      // For now, we'll simulate with a placeholder
+      return {
+        success: true,
+        events: [
+          {
+            id: "event-1",
+            title: "Team Meeting",
+            startTime: new Date().toISOString(),
+            endTime: new Date(Date.now() + 3600000).toISOString(),
+            attendees: ["team@example.com"],
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  },
+});
+
+// ==================== EMAIL TOOLS ====================
+
+/**
+ * Tool: Send Email
+ * Sends an email
+ */
+export const sendEmailTool = createTool({
+  id: "send-email",
+  description: `
+    Send an email.
+    Use this to communicate with users or send notifications.
+  `,
+  inputSchema: z.object({
+    to: z.string().email().describe("Recipient email address"),
+    subject: z.string().describe("Email subject"),
+    body: z.string().describe("Email body content"),
+    cc: z.array(z.string().email()).optional().describe("CC recipients"),
+    bcc: z.array(z.string().email()).optional().describe("BCC recipients"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    messageId: z.string().optional(),
+    message: z.string().optional(),
+    error: z.string().optional(),
+  }),
+  execute: async (inputData) => {
+    try {
+      // In a real implementation, this would integrate with email services
+      // For now, we'll simulate with a placeholder
+      return {
+        success: true,
+        messageId: `msg-${Date.now()}`,
+        message: `Sent email to ${inputData.to}`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  },
+});
+
+// ==================== DATABASE TOOLS ====================
+
+/**
+ * Tool: Query Database
+ * Executes a database query
+ */
+export const queryDatabaseTool = createTool({
+  id: "query-database",
+  description: `
+    Execute a database query.
+    Use this to retrieve or manipulate data in databases.
+  `,
+  inputSchema: z.object({
+    query: z.string().describe("SQL query to execute"),
+    parameters: z.record(z.union([z.string(), z.number(), z.boolean()])).optional().describe("Query parameters"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    results: z.array(z.record(z.any())).optional(),
+    rowCount: z.number().optional(),
+    message: z.string().optional(),
+    error: z.string().optional(),
+  }),
+  execute: async (inputData) => {
+    try {
+      // In a real implementation, this would connect to a database
+      // For now, we'll simulate with a placeholder
+      return {
+        success: true,
+        results: [{ id: 1, name: "Sample Data" }],
+        rowCount: 1,
+        message: "Query executed successfully",
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  },
+});
+
+// ==================== SOCIAL MEDIA TOOLS ====================
+
+/**
+ * Tool: Post to Twitter
+ * Posts a tweet to Twitter/X
+ */
+export const postToTwitterTool = createTool({
+  id: "post-to-twitter",
+  description: `
+    Post a tweet to Twitter/X.
+    Use this to share updates or information on social media.
+  `,
+  inputSchema: z.object({
+    content: z.string().max(280).describe("Tweet content (max 280 characters)"),
+    mediaUrls: z.array(z.string().url()).optional().describe("URLs of media to attach"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    tweetId: z.string().optional(),
+    url: z.string().optional(),
+    message: z.string().optional(),
+    error: z.string().optional(),
+  }),
+  execute: async (inputData) => {
+    try {
+      // In a real implementation, this would integrate with Twitter API
+      // For now, we'll simulate with a placeholder
+      return {
+        success: true,
+        tweetId: `tweet-${Date.now()}`,
+        url: `https://twitter.com/user/status/tweet-${Date.now()}`,
+        message: "Posted to Twitter successfully",
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  },
+});
+
+// ==================== ANALYTICS TOOLS ====================
+
+/**
+ * Tool: Get Analytics Report
+ * Retrieves analytics data
+ */
+export const getAnalyticsReportTool = createTool({
+  id: "get-analytics-report",
+  description: `
+    Retrieve analytics data and reports.
+    Use this to get insights about website traffic, user behavior, or business metrics.
+  `,
+  inputSchema: z.object({
+    reportType: z.enum([
+      "traffic", "conversion", "engagement", "revenue", "user-behavior"
+    ]).describe("Type of analytics report to retrieve"),
+    startDate: z.string().date().optional().describe("Start date (YYYY-MM-DD)"),
+    endDate: z.string().date().optional().describe("End date (YYYY-MM-DD)"),
+    dimensions: z.array(z.string()).optional().describe("Dimensions to group by"),
+    metrics: z.array(z.string()).optional().describe("Metrics to include"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    data: z.object({
+      reportType: z.enum(["traffic", "conversion", "engagement", "revenue", "user-behavior"]),
+      period: z.string(),
+      sampleData: z.array(z.object({
+        metric: z.string(),
+        value: z.number(),
+      })),
+    }).optional(),
+    summary: z.object({
+      total: z.number(),
+      change: z.number().optional(),
+      trend: z.enum(["increasing", "decreasing", "stable"]).optional(),
+    }).optional(),
+    message: z.string().optional(),
+    error: z.string().optional(),
+  }).or(z.object({
+    success: z.boolean(),
+    error: z.string(),
+  })),
+  execute: async (inputData) => {
+    try {
+      // In a real implementation, this would fetch from analytics services
+      // For now, we'll simulate with a placeholder
+      const trend: "increasing" | "decreasing" | "stable" = "increasing";
+      
+      return {
+        success: true,
+        data: {
+          reportType: inputData.reportType,
+          period: `${inputData.startDate || 'N/A'} to ${inputData.endDate || 'N/A'}`,
+          sampleData: [{ metric: "sample", value: 100 }],
+        },
+        summary: {
+          total: 100,
+          change: 5.2,
+          trend: trend,
+        },
+        message: "Analytics report retrieved successfully",
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  },
+});
+

package/src/tools/library/calendar/index.ts

@@ -0,0 +1,172 @@
+/**
+ * Calendar Tools
+ * 
+ * Tools for managing calendar events across multiple platforms.
+ * Note: These are placeholder implementations that require API integration.
+ */
+
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+
+/**
+ * Create a calendar event
+ */
+export const createCalendarEventTool = createTool({
+  id: "create-calendar-event",
+  description: "Create a new calendar event with details like title, date, time, location, and attendees",
+  inputSchema: z.object({
+    platform: z.enum(["google", "outlook", "ical"]).default("google").describe("Calendar platform"),
+    title: z.string().describe("Event title"),
+    startDate: z.string().describe("Event start date (YYYY-MM-DD)"),
+    startTime: z.string().describe("Event start time (HH:MM)"),
+    duration: z.number().default(60).describe("Event duration in minutes"),
+    location: z.string().optional().describe("Event location"),
+    description: z.string().optional().describe("Event description"),
+    attendees: z.array(z.string()).optional().describe("List of email addresses for attendees"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    eventId: z.string().optional(),
+    message: z.string(),
+    platform: z.string(),
+  }),
+  execute: async ({ platform = "google", title, startDate, startTime, duration, location, description, attendees }) => {
+    // Placeholder: Would integrate with Google Calendar API, Microsoft Graph API, or iCal
+    
+    const eventId = `evt-${Date.now()}`;
+    
+    return {
+      success: true,
+      eventId,
+      message: `Created event "${title}" on ${startDate} at ${startTime} for ${duration} minutes`,
+      platform,
+    };
+  },
+});
+
+/**
+ * List calendar events
+ */
+export const listCalendarEventsTool = createTool({
+  id: "list-calendar-events",
+  description: "List calendar events within a date range",
+  inputSchema: z.object({
+    platform: z.enum(["google", "outlook", "ical"]).default("google").describe("Calendar platform"),
+    startDate: z.string().describe("Start date (YYYY-MM-DD)"),
+    endDate: z.string().optional().describe("End date (YYYY-MM-DD), defaults to start date"),
+    maxResults: z.number().default(10).describe("Maximum number of events to return"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    events: z.array(z.object({
+      id: z.string(),
+      title: z.string(),
+      startDate: z.string(),
+      startTime: z.string(),
+      duration: z.number(),
+      location: z.string().optional(),
+    })),
+    count: z.number(),
+    platform: z.string(),
+  }),
+  execute: async ({ platform = "google", startDate, endDate, maxResults }) => {
+    // Placeholder: Would query calendar API
+    
+    const endDateToUse = endDate || startDate;
+    
+    // Sample events for demonstration
+    const events = [
+      {
+        id: "evt-1",
+        title: "Team Meeting",
+        startDate,
+        startTime: "10:00",
+        duration: 60,
+        location: "Conference Room A",
+      },
+      {
+        id: "evt-2",
+        title: "Project Review",
+        startDate,
+        startTime: "14:00",
+        duration: 90,
+        location: "Online",
+      },
+    ];
+    
+    return {
+      success: true,
+      events: events.slice(0, maxResults),
+      count: events.length,
+      platform,
+    };
+  },
+});
+
+/**
+ * Update a calendar event
+ */
+export const updateCalendarEventTool = createTool({
+  id: "update-calendar-event",
+  description: "Update an existing calendar event",
+  inputSchema: z.object({
+    platform: z.enum(["google", "outlook", "ical"]).default("google").describe("Calendar platform"),
+    eventId: z.string().describe("ID of the event to update"),
+    title: z.string().optional().describe("New event title"),
+    startDate: z.string().optional().describe("New start date (YYYY-MM-DD)"),
+    startTime: z.string().optional().describe("New start time (HH:MM)"),
+    duration: z.number().optional().describe("New duration in minutes"),
+    location: z.string().optional().describe("New location"),
+    description: z.string().optional().describe("New description"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    message: z.string(),
+    platform: z.string().optional(),
+  }),
+  execute: async ({ platform, eventId, ...updates }) => {
+    // Placeholder: Would update event via API
+    
+    return {
+      success: true,
+      message: `Updated event ${eventId} with ${Object.keys(updates).length} changes`,
+      platform: platform || undefined,
+    };
+  },
+});
+
+/**
+ * Delete a calendar event
+ */
+export const deleteCalendarEventTool = createTool({
+  id: "delete-calendar-event",
+  description: "Delete a calendar event",
+  inputSchema: z.object({
+    platform: z.enum(["google", "outlook", "ical"]).default("google").describe("Calendar platform"),
+    eventId: z.string().describe("ID of the event to delete"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    message: z.string(),
+    platform: z.string().optional(),
+  }),
+  execute: async ({ platform, eventId }) => {
+    // Placeholder: Would delete event via API
+    
+    return {
+      success: true,
+      message: `Deleted event ${eventId}`,
+      platform: platform || undefined,
+    };
+  },
+});
+
+/**
+ * Export all calendar tools
+ */
+export const calendarTools = {
+  createCalendarEvent: createCalendarEventTool,
+  listCalendarEvents: listCalendarEventsTool,
+  updateCalendarEvent: updateCalendarEventTool,
+  deleteCalendarEvent: deleteCalendarEventTool,
+};

package/src/tools/podman-workspace-mcp-cli.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// podman-workspace-mcp-cli.ts - CLI entry point for Podman Workspace MCP Server
+import { podmanWorkspaceMCPServer } from "./podman-workspace-mcp.js";
+
+async function main() {
+  console.error("Starting Podman Workspace MCP Server...");
+  
+  await podmanWorkspaceMCPServer.startStdio();
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});