@muskanmeet/invoicing-design-system 0.1.0

package/.local/skills/artifacts/artifacts/automation/files/src/mastra/workflows/workflow.ts

@@ -0,0 +1,203 @@
+// Use Inngest-compatible versions for this project
+// These are initialized with init(inngest) to work with the Inngest workflow engine
+import { createStep, createWorkflow } from "../inngest";
+import { z } from "zod";
+import { automationAgent } from "../agents/agent";
+
+/**
+ * Mastra Workflow with Mocked Steps
+ *
+ * MASTRA WORKFLOW GUIDE:
+ * - Workflows orchestrate multiple steps in sequence
+ * - Each step has typed inputs/outputs for reliability
+ * - Steps can use agents, tools, or custom logic (conditionals, loops, etc)
+ */
+
+/**
+ * CALLING TOOLS IN WORKFLOW STEPS:
+ * When calling tool.execute() in a step, you must narrow the return type before accessing properties.
+ * tool.execute() returns `ValidationError | OutputType`, so check for errors first:
+ *
+ *     const result = await myTool.execute(input, { mastra });
+ *     if ('error' in result && result.error) throw new Error(result.message);
+ *     return { data: result.someProperty }; // Now typed correctly
+ *
+ * Note: Don't use `error` as a field name in tool output schemas (reserved for ValidationError).
+ * Note: Step chaining with .then() requires `as any` casts due to Inngest type inference (see below).
+ */
+
+/**
+ * Step 1: Process with Agent
+ * This step demonstrates how to use an agent within a workflow
+ */
+const processWithAgent = createStep({
+  id: "process-with-agent",
+  description:
+    "Processes the input message using an AI agent with optional analysis", // Must contain a clear, concise description of what the step does.
+
+  // Define what this step expects as input
+  inputSchema: z.object({
+    message: z.string().describe("Message to process"),
+    includeAnalysis: z
+      .boolean()
+      .optional()
+      .describe("Whether to include detailed analysis"),
+  }),
+
+  // Defines what this step will output. Must match the inputSchema of the next step.
+  outputSchema: z.object({
+    agentResponse: z.string(),
+    processedData: z
+      .object({
+        original: z.string(),
+        processed: z.string(),
+        timestamp: z.string(),
+      })
+      .optional(),
+  }),
+
+  // Step logic - mastra is available for logging and utilities
+  execute: async ({ inputData, mastra }) => {
+    const logger = mastra?.getLogger();
+    logger?.info("🚀 [Step 1] Processing with agent...");
+
+    // Construct a prompt for the agent
+    const prompt = `
+      Please process the following message using the example tool:
+      "${inputData.message}"
+
+      ${inputData.includeAnalysis ? "Also provide a brief analysis of the results." : ""}
+    `;
+
+    // Call the agent using generate or stream
+    const response = await automationAgent.generate(
+      [{ role: "user", content: prompt }],
+      // We can add other properties, for instance the thread id keeps track of the message history.  Check Mastra docs for more information.
+    );
+
+    logger?.info("✅ [Step 1] Agent processing complete");
+
+    // In a real workflow, you might:
+    // - Parse structured data from the response
+    // - Extract specific information
+    // - Handle errors gracefully
+
+    return {
+      agentResponse: response.text,
+      processedData: {
+        original: inputData.message,
+        processed: inputData.message.toUpperCase(), // Simple mock processing
+        timestamp: new Date().toISOString(),
+      },
+    };
+  },
+});
+
+/**
+ * Step 2: Output Results
+ * This step demonstrates how to handle and output results
+ */
+const outputResults = createStep({
+  id: "output-results",
+  description:
+    "Formats the agent's response and puts it in the form of a summary.", // Must contain a clear, concise description of what the step does.
+
+  // This step receives the output from the previous step
+  inputSchema: z.object({
+    agentResponse: z.string(),
+    processedData: z
+      .object({
+        original: z.string(),
+        processed: z.string(),
+        timestamp: z.string(),
+      })
+      .optional(),
+  }),
+
+  // Final output schema - this is what the workflow returns
+  outputSchema: z.object({
+    summary: z.string(),
+    formattedOutput: z.string(),
+    success: z.boolean(),
+  }),
+
+  execute: async ({ inputData, mastra }) => {
+    const logger = mastra?.getLogger();
+    logger?.info("📤 [Step 2] Outputting results...");
+
+    /**
+     * In a real workflow, this step might:
+     * - Send data to an API
+     * - Write to a database
+     * - Send an email
+     * - Update a UI
+     * - Trigger webhooks
+     * - Store in a file system
+     */
+
+    // For this example, we'll format and log the output
+    const formattedOutput = `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📊 WORKFLOW RESULTS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🤖 Agent Response:
+${inputData.agentResponse}
+
+📝 Processed Data:
+${
+  inputData.processedData
+    ? `
+  • Original: ${inputData.processedData.original}
+  • Processed: ${inputData.processedData.processed}
+  • Timestamp: ${inputData.processedData.timestamp}
+`
+    : "No processed data available"
+}
+`;
+
+    // Log the output using Mastra logger
+    logger?.info(formattedOutput);
+    logger?.info("✅ [Step 2] Results formatted and logged");
+
+    return {
+      summary: `Successfully processed message with ${inputData.processedData?.original.length || 0} characters`,
+      formattedOutput,
+      success: true,
+    };
+  },
+});
+
+/**
+ * MASTRA STEPS:
+ * Remember:  There are many ways of structing a workflow, including boolean operations (conditionals, etc), looping, etc.
+ * Please read the Mastra docs as instructed for more information if you need to setup a complex workflow. Mastra comes with many powerful primitives to help you build workflows.
+ * We critically chain our steps in order to accomplish the user's desired automation.
+ */
+
+/**
+ * Create the workflow by chaining steps
+ */
+export const automationWorkflow = createWorkflow({
+  id: "automation-workflow",
+
+  // Define the initial input schema for the entire workflow
+  inputSchema: z.object({
+    message: z.string().describe("Message to process through the workflow"),
+    includeAnalysis: z
+      .boolean()
+      .optional()
+      .describe("Whether to include detailed analysis"),
+  }) as any, // TS workaround: Inngest type system incompatibility with Zod schemas
+
+  // Define the final output schema (should match the last step's output)
+  outputSchema: z.object({
+    summary: z.string(),
+    formattedOutput: z.string(),
+    success: z.boolean(),
+  }),
+})
+  // Chain your steps in order
+  .then(processWithAgent as any) // TS workaround: type inference issues with Inngest step chaining
+  .then(outputResults as any)
+  .commit();

package/.local/skills/artifacts/artifacts/automation/files/src/triggers/cronTriggers.ts

@@ -0,0 +1,61 @@
+/**
+ * Cron Trigger - Time-based Workflow Scheduling
+ *
+ * This module provides time-based triggering for Mastra workflows using cron expressions.
+ * Unlike webhook-based triggers, cron triggers run on a schedule without external events.
+ *
+ * PATTERN:
+ * 1. Define the cron schedule with a standard cron expression
+ * 2. Pass the workflow to be executed
+ * 3. Call registerCronTrigger BEFORE mastra initialization (not in apiRoutes array)
+ *
+ * IMPORTANT: Unlike webhook triggers, cron triggers are registered by calling
+ * registerCronTrigger() directly in src/mastra/index.ts, NOT by spreading into apiRoutes.
+ * This is because cron triggers don't create HTTP endpoints.
+ *
+ * CRON EXPRESSION FORMAT:
+ * Standard 5-field cron format: minute hour day-of-month month day-of-week
+ *
+ * Example cron expressions:
+ * Daily at 8 AM, every 2 hours, every 5 minutes, weekly on Sunday
+ */
+
+import { registerCronWorkflow } from "../mastra/inngest";
+
+/**
+ * Register a cron-based trigger
+ *
+ * Usage in src/mastra/index.ts (call BEFORE mastra initialization):
+ *
+ * ```typescript
+ * import { physicsJokeWorkflow } from "./workflows/physicsJokeWorkflow";
+ * import { registerCronTrigger } from "../triggers/cronTriggers";
+ *
+ * // Register cron trigger (call this before creating the mastra instance)
+ * registerCronTrigger({
+ *   cronExpression: "0 8 * * *", // Daily at 8 AM
+ *   workflow: physicsJokeWorkflow
+ * });
+ *
+ * export const mastra = new Mastra({
+ *   // ... rest of mastra config
+ * });
+ * ```
+ *
+ * Note: Returns empty array for consistency with trigger file conventions,
+ * but this should NOT be spread into apiRoutes array.
+ */
+export function registerCronTrigger({
+  cronExpression,
+  workflow,
+}: {
+  cronExpression: string;
+  workflow: any;
+}) {
+  // Delegate to the helper in inngest/index.ts which manages inngestFunctions
+  registerCronWorkflow(cronExpression, workflow);
+
+  // Returns empty array for consistency with trigger file conventions
+  // Note: Do NOT spread this into apiRoutes - cron triggers don't create HTTP routes
+  return [];
+}

package/.local/skills/artifacts/artifacts/automation/files/src/triggers/exampleConnectorTrigger.ts

@@ -0,0 +1,153 @@
+/**
+ * Example Connector Trigger - Linear Webhook Handler
+ *
+ * This demonstrates how to create a webhook handler for any connector.
+ * Linear is just an example - replace with your connector name.
+ *
+ * PATTERN:
+ * 1. Define types for the webhook payload (optional, but helpful)
+ * 2. Create a registration function that sets up the webhook route
+ * 3. Pass the full payload to the handler - let the consumer pick what they need
+ * 4. Register in src/mastra/index.ts
+ *
+ * See docs/triggers/webhook_connector_triggers.md for complete guide.
+ */
+
+import { registerApiRoute } from "../mastra/inngest";
+import type { Mastra } from "@mastra/core";
+
+/**
+ * Linear webhook payload structure
+ * Based on: https://developers.linear.app/docs/graphql/webhooks
+ */
+export type LinearWebhookPayload = {
+  action: string; // e.g., "create", "update", "remove"
+  type: string; // e.g., "Issue", "Comment", "Project"
+  data: {
+    id: string;
+    title: string;
+    description?: string;
+    [key: string]: any;
+  };
+  createdAt: string;
+  organizationId: string;
+  [key: string]: any;
+};
+
+/**
+ * Trigger info passed to your handler
+ */
+export type TriggerInfoLinearIssueCreated = {
+  type: "linear/issue.created";
+  payload: LinearWebhookPayload;
+};
+
+type LinearTriggerHandler = (
+  mastra: Mastra,
+  triggerInfo: TriggerInfoLinearIssueCreated,
+  runId?: string,
+) => Promise<any>;
+
+/**
+ * Register a Linear webhook trigger handler
+ *
+ * Usage in src/mastra/index.ts:
+ *
+ * ```typescript
+ * import { automationWorkflow } from "./workflows/workflow";
+ * import { inngest } from "./inngest";
+ *
+ * ...registerLinearTrigger({
+ *   triggerType: "linear/issue.created",
+ *   handler: async (mastra, triggerInfo, runId) => {
+ *     // Extract what you need from the payload
+ *     const data = triggerInfo.payload?.data || {};
+ *     const title = data.title || data.name || "Untitled";
+ *
+ *     // Create a run of the workflow unless one was provided
+ *     if (!runId) {
+ *       runId = (await automationWorkflow.createRun()).runId;
+ *     }
+ *
+ *     // Start the workflow
+ *     return await inngest.send({
+ *       name: `workflow.${automationWorkflow.id}`,
+ *       data: {
+ *         runId,
+ *         inputData: {
+ *           message: `Linear Issue: ${title}`,
+ *           includeAnalysis: true,
+ *         },
+ *       },
+ *     });
+ *   }
+ * })
+ * ```
+ */
+export function registerLinearTrigger({
+  triggerType,
+  handler,
+}: {
+  triggerType: "linear/issue.created";
+  handler: LinearTriggerHandler;
+}) {
+  return [
+    registerApiRoute("/linear/webhook", {
+      method: "POST",
+      handler: async (c) => {
+        const mastra = c.get("mastra");
+        const logger = mastra?.getLogger();
+
+        try {
+          const payload = await c.req.json();
+          console.log("📥 [Linear] Webhook received", { payload });
+
+          // Only process Issue creation events
+          if (payload.action !== "create" || payload.type !== "Issue") {
+            console.log("⏭️ [Linear] Skipping event", {
+              action: payload.action,
+              type: payload.type,
+            });
+            return c.json({ success: true, skipped: true });
+          }
+
+          // Ensure data exists (use empty object as fallback)
+          if (!payload.data) {
+            console.log("⚠️ [Linear] Missing data field, using empty object");
+            payload.data = {};
+          }
+
+          // Pass the full payload - let the consumer pick what they need
+          const triggerInfo: TriggerInfoLinearIssueCreated = {
+            type: triggerType,
+            payload: payload as LinearWebhookPayload,
+          };
+
+          // Extract potential runId from request headers
+          const runId = c.req.header("x-mastra-run-id");
+
+          console.log("🚀 [Linear] Triggering handler");
+
+          const result = await handler(mastra, triggerInfo, runId);
+
+          console.log("✅ [Linear] Handler completed", { result });
+
+          return c.json({ success: true, result });
+        } catch (error) {
+          logger?.error("❌ [Linear] Error processing webhook", {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+          });
+
+          return c.json(
+            {
+              success: false,
+              error: error instanceof Error ? error.message : String(error),
+            },
+            500,
+          );
+        }
+      },
+    }),
+  ];
+}