@elizaos/plugin-linear 1.2.5 → 1.2.7

package/dist/index.js

@@ -360,770 +360,1012 @@ var LinearService = _LinearService;
 
 // src/actions/createIssue.ts
 import {
+  ModelType,
   logger as logger2
 } from "@elizaos/core";
-var createIssueTemplate = `Create a new Linear issue based on the user's request. Extract the necessary information from the conversation.
+var createIssueTemplate = `Given the user's request, extract the information needed to create a Linear issue.
 
-Recent conversation:
-{{recentMessages}}
+User request: "{{userMessage}}"
 
-When creating the issue:
-1. The title should be clear and concise
-2. The description should include all relevant details from the conversation
-3. Determine the appropriate team based on context
-4. Set priority if mentioned (1=Urgent, 2=High, 3=Normal, 4=Low)
-5. If no team is specified, use the default team
-
-Response format should be a valid JSON block:
-\`\`\`json
+Extract and return ONLY a JSON object (no markdown formatting, no code blocks) with the following structure:
 {
-  "title": "Clear, actionable issue title",
-  "description": "Detailed description with context from the conversation",
-  "teamId": "team-id or null to use default",
-  "priority": 3,
-  "shouldCreate": true
+  "title": "Brief, clear issue title",
+  "description": "Detailed description of the issue (optional)",
+  "teamKey": "Team key if mentioned (e.g., ENG, PROD)",
+  "priority": "Priority level if mentioned (1=urgent, 2=high, 3=normal, 4=low)",
+  "labels": ["label1", "label2"] (if any labels are mentioned),
+  "assignee": "Assignee username or email if mentioned"
 }
-\`\`\`
-`;
-var createLinearIssueAction = {
+
+Return only the JSON object, no other text.`;
+var createIssueAction = {
   name: "CREATE_LINEAR_ISSUE",
   description: "Create a new issue in Linear",
-  similes: ["create issue", "new issue", "file issue", "report issue", "create ticket", "new ticket"],
-  async validate(runtime, _message, state) {
+  similes: ["create-linear-issue", "new-linear-issue", "add-linear-issue"],
+  examples: [[
+    {
+      name: "User",
+      content: {
+        text: "Create a new issue: Fix login button not working on mobile devices"
+      }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll create that issue for you in Linear.",
+        actions: ["CREATE_LINEAR_ISSUE"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: {
+        text: "Create a bug report for the ENG team: API returns 500 error when updating user profile"
+      }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll create a bug report for the engineering team right away.",
+        actions: ["CREATE_LINEAR_ISSUE"]
+      }
+    }
+  ]],
+  async validate(runtime, _message, _state) {
     try {
-      const linearService = runtime.getService("linear");
-      return !!linearService;
+      const apiKey = runtime.getSetting("LINEAR_API_KEY");
+      return !!apiKey;
     } catch {
       return false;
     }
   },
-  async handler(runtime, message, state, options) {
+  async handler(runtime, message, _state, _options) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      if (options?.title && options?.teamId) {
-        const issueInput2 = {
-          title: String(options.title),
-          description: options.description ? String(options.description) : void 0,
-          teamId: String(options.teamId),
-          priority: options.priority ? Number(options.priority) : 3,
-          assigneeId: options.assigneeId ? String(options.assigneeId) : void 0,
-          labelIds: options.labelIds ? options.labelIds : void 0,
-          projectId: options.projectId ? String(options.projectId) : void 0
-        };
-        const issue2 = await linearService.createIssue(issueInput2);
+      const content = message.content.text;
+      if (!content) {
         return {
-          success: true,
-          data: {
-            issue: {
-              id: issue2.id,
-              identifier: issue2.identifier,
-              title: issue2.title,
-              url: issue2.url
+          text: "Please provide a description for the issue.",
+          success: false
+        };
+      }
+      const structuredData = _options?.issueData;
+      let issueData;
+      if (structuredData) {
+        issueData = structuredData;
+      } else {
+        const prompt = createIssueTemplate.replace("{{userMessage}}", content);
+        const response = await runtime.useModel(ModelType.TEXT_LARGE, {
+          prompt
+        });
+        if (!response) {
+          throw new Error("Failed to extract issue information");
+        }
+        try {
+          const cleanedResponse = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+          const parsed = JSON.parse(cleanedResponse);
+          issueData = {
+            title: parsed.title,
+            description: parsed.description,
+            priority: parsed.priority
+          };
+          if (parsed.teamKey) {
+            const teams = await linearService.getTeams();
+            const team = teams.find(
+              (t) => t.key.toLowerCase() === parsed.teamKey.toLowerCase()
+            );
+            if (team) {
+              issueData.teamId = team.id;
             }
-          },
-          metadata: {
-            issueId: issue2.id,
-            identifier: issue2.identifier
           }
-        };
+          if (parsed.assignee) {
+            const users = await linearService.getUsers();
+            const user = users.find(
+              (u) => u.email === parsed.assignee || u.name.toLowerCase().includes(parsed.assignee.toLowerCase())
+            );
+            if (user) {
+              issueData.assigneeId = user.id;
+            }
+          }
+          if (!issueData.teamId) {
+            const teams = await linearService.getTeams();
+            if (teams.length > 0) {
+              issueData.teamId = teams[0].id;
+              logger2.warn(`No team specified, using default team: ${teams[0].name}`);
+            }
+          }
+        } catch (parseError) {
+          logger2.error("Failed to parse LLM response:", parseError);
+          issueData = {
+            title: content.length > 100 ? content.substring(0, 100) + "..." : content,
+            description: content
+          };
+          const teams = await linearService.getTeams();
+          if (teams.length > 0) {
+            issueData.teamId = teams[0].id;
+            logger2.warn(`Using default team for fallback: ${teams[0].name}`);
+          }
+        }
       }
-      const response = await runtime.generateText({
-        messages: state.messages || [],
-        context: createIssueTemplate
-      });
-      const parsed = JSON.parse(response.trim().replace(/```json\n?|\n?```/g, ""));
-      if (!parsed.shouldCreate) {
+      if (!issueData.title) {
         return {
-          success: false,
-          error: "Not enough information to create an issue"
+          text: "Could not determine issue title. Please provide more details.",
+          success: false
         };
       }
-      let teamId = parsed.teamId;
-      let teamName;
-      if (!teamId) {
-        const teams = await linearService.getTeams();
-        if (teams.length === 0) {
-          throw new Error("No teams available in Linear workspace");
-        }
-        teamId = teams[0].id;
-        teamName = teams[0].name;
-      } else {
-        try {
-          const team = await linearService.getTeam(teamId);
-          teamName = team.name;
-        } catch {
-        }
+      if (!issueData.teamId) {
+        return {
+          text: "No Linear teams found. Please ensure at least one team exists in your Linear workspace.",
+          success: false
+        };
       }
-      const issueInput = {
-        title: parsed.title,
-        description: parsed.description,
-        teamId,
-        priority: parsed.priority || 3
-      };
-      const issue = await linearService.createIssue(issueInput);
-      logger2.info(`Created Linear issue: ${issue.identifier} - ${issue.title}`);
+      const issue = await linearService.createIssue(issueData);
       return {
+        text: `Created issue: ${issue.title} (${issue.identifier})`,
         success: true,
         data: {
-          issue: {
-            id: issue.id,
-            identifier: issue.identifier,
-            title: issue.title,
-            url: issue.url,
-            teamName
-          }
-        },
-        metadata: {
           issueId: issue.id,
-          identifier: issue.identifier
+          identifier: issue.identifier,
+          url: issue.url
         }
       };
     } catch (error) {
-      logger2.error("Failed to create Linear issue:", error);
+      logger2.error("Failed to create issue:", error);
       return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to create issue"
+        text: `Failed to create issue: ${error instanceof Error ? error.message : "Unknown error"}`,
+        success: false
       };
     }
-  },
-  examples: [
+  }
+};
+
+// src/actions/getIssue.ts
+import { logger as logger3 } from "@elizaos/core";
+var getIssueAction = {
+  name: "GET_LINEAR_ISSUE",
+  description: "Get details of a specific Linear issue",
+  similes: ["get-linear-issue", "show-linear-issue", "view-linear-issue"],
+  examples: [[
     {
-      input: "Create a new issue: Fix login button not working on mobile devices",
-      output: "Created issue ENG-123: Fix login button not working on mobile devices",
-      explanation: "Creates a new issue with the provided title"
+      name: "User",
+      content: {
+        text: "Show me issue ENG-123"
+      }
     },
     {
-      input: "File a bug report: Users cannot upload images larger than 5MB, getting timeout errors",
-      output: "Created issue BUG-456: Image upload timeout for files > 5MB",
-      explanation: "Creates a bug report with extracted details"
+      name: "Assistant",
+      content: {
+        text: "I'll get the details for issue ENG-123.",
+        actions: ["GET_LINEAR_ISSUE"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: {
+        text: "What's the status of BUG-456?"
+      }
     },
     {
-      input: "Create a high priority ticket for the payment processing error we discussed",
-      output: "Created high priority issue PAY-789: Payment processing error investigation",
-      explanation: "Creates an issue with priority based on conversation context"
+      name: "Assistant",
+      content: {
+        text: "Let me check the status of BUG-456 for you.",
+        actions: ["GET_LINEAR_ISSUE"]
+      }
     }
-  ]
-};
-
-// src/actions/getIssue.ts
-import {
-  logger as logger3
-} from "@elizaos/core";
-var getLinearIssueAction = {
-  name: "GET_LINEAR_ISSUE",
-  description: "Get details of a specific Linear issue by ID or identifier",
-  similes: ["get issue", "show issue", "fetch issue", "view issue", "issue details", "what is issue"],
-  async validate(runtime, _message, state) {
+  ]],
+  async validate(runtime, _message, _state) {
     try {
-      const linearService = runtime.getService("linear");
-      return !!linearService;
+      const apiKey = runtime.getSetting("LINEAR_API_KEY");
+      return !!apiKey;
     } catch {
       return false;
     }
   },
-  async handler(runtime, message, state, options) {
+  async handler(runtime, message, _state, _options) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      let issueId;
-      if (options?.issueId) {
-        issueId = String(options.issueId);
-      } else {
-        const issuePattern = /\b[A-Z]+-\d+\b/;
-        const match = message.content.text?.match(issuePattern);
-        if (match) {
-          issueId = match[0];
-        }
+      const content = message.content.text;
+      if (!content) {
+        return {
+          text: "Please specify an issue ID.",
+          success: false
+        };
       }
-      if (!issueId) {
+      const issueMatch = content.match(/(\w+-\d+)/);
+      if (!issueMatch) {
         return {
-          success: false,
-          error: "No issue ID or identifier provided"
+          text: "Please provide a valid issue ID (e.g., ENG-123).",
+          success: false
         };
       }
+      const issueId = issueMatch[1];
       const issue = await linearService.getIssue(issueId);
-      const [assignee, state2, team, labels] = await Promise.all([
-        issue.assignee,
-        issue.state,
-        issue.team,
-        issue.labels()
-      ]);
-      const labelList = await labels.nodes;
-      const issueData = {
+      const assignee = await issue.assignee;
+      const state = await issue.state;
+      const team = await issue.team;
+      const labels = await issue.labels();
+      const project = await issue.project;
+      const issueDetails = {
         id: issue.id,
         identifier: issue.identifier,
         title: issue.title,
         description: issue.description,
-        url: issue.url,
         priority: issue.priority,
         priorityLabel: issue.priorityLabel,
-        estimate: issue.estimate,
+        url: issue.url,
         createdAt: issue.createdAt,
         updatedAt: issue.updatedAt,
         dueDate: issue.dueDate,
+        estimate: issue.estimate,
         assignee: assignee ? {
           id: assignee.id,
           name: assignee.name,
           email: assignee.email
         } : null,
-        state: {
-          id: state2.id,
-          name: state2.name,
-          type: state2.type,
-          color: state2.color
-        },
-        team: {
+        state: state ? {
+          id: state.id,
+          name: state.name,
+          type: state.type,
+          color: state.color
+        } : null,
+        team: team ? {
           id: team.id,
           name: team.name,
           key: team.key
-        },
-        labels: labelList.map((label) => ({
+        } : null,
+        labels: labels.nodes.map((label) => ({
           id: label.id,
           name: label.name,
           color: label.color
-        }))
+        })),
+        project: project ? {
+          id: project.id,
+          name: project.name
+        } : null
       };
-      logger3.info(`Retrieved Linear issue: ${issue.identifier}`);
+      let responseText = `Issue ${issue.identifier}: ${issue.title}
+`;
+      responseText += `Status: ${state?.name || "Unknown"}
+`;
+      responseText += `Priority: ${issue.priorityLabel}
+`;
+      if (assignee) {
+        responseText += `Assignee: ${assignee.name}
+`;
+      }
+      if (issue.dueDate) {
+        responseText += `Due: ${new Date(issue.dueDate).toLocaleDateString()}
+`;
+      }
+      if (issue.description) {
+        responseText += `
+Description: ${issue.description}
+`;
+      }
+      responseText += `
+View in Linear: ${issue.url}`;
       return {
+        text: responseText,
         success: true,
-        data: {
-          issue: issueData
-        },
-        metadata: {
-          issueId: issue.id,
-          identifier: issue.identifier
-        }
+        data: issueDetails
       };
     } catch (error) {
-      logger3.error("Failed to get Linear issue:", error);
+      logger3.error("Failed to get issue:", error);
       return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to get issue"
+        text: `Failed to get issue: ${error instanceof Error ? error.message : "Unknown error"}`,
+        success: false
       };
     }
-  },
-  examples: [
+  }
+};
+
+// src/actions/updateIssue.ts
+import { logger as logger4 } from "@elizaos/core";
+var updateIssueAction = {
+  name: "UPDATE_LINEAR_ISSUE",
+  description: "Update an existing Linear issue",
+  similes: ["update-linear-issue", "edit-linear-issue", "modify-linear-issue"],
+  examples: [[
     {
-      input: "Show me issue ENG-123",
-      output: "Issue ENG-123: Fix login button on mobile\nStatus: In Progress\nAssignee: John Doe\nPriority: High",
-      explanation: "Retrieves issue details by identifier"
+      name: "User",
+      content: {
+        text: 'Update issue ENG-123 title to "Fix login button on all devices"'
+      }
     },
     {
-      input: "Get details for BUG-456",
-      output: "Issue BUG-456: Image upload timeout\nStatus: Todo\nAssignee: Unassigned\nPriority: Urgent\nLabels: bug, performance",
-      explanation: "Fetches comprehensive issue information"
+      name: "Assistant",
+      content: {
+        text: "I'll update the title of issue ENG-123 for you.",
+        actions: ["UPDATE_LINEAR_ISSUE"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: {
+        text: "Change the priority of BUG-456 to high"
+      }
     },
     {
-      input: "What is the status of FEAT-789?",
-      output: "Issue FEAT-789: Add dark mode support\nStatus: Done\nAssignee: Jane Smith\nCompleted: 2 days ago",
-      explanation: "Shows current status and details of an issue"
+      name: "Assistant",
+      content: {
+        text: "I'll change the priority of BUG-456 to high.",
+        actions: ["UPDATE_LINEAR_ISSUE"]
+      }
     }
-  ]
-};
-
-// src/actions/updateIssue.ts
-import {
-  logger as logger4
-} from "@elizaos/core";
-var updateLinearIssueAction = {
-  name: "UPDATE_LINEAR_ISSUE",
-  description: "Update an existing Linear issue",
-  similes: ["update issue", "modify issue", "change issue", "edit issue"],
-  async validate(runtime, _message, state) {
+  ]],
+  async validate(runtime, _message, _state) {
     try {
-      const linearService = runtime.getService("linear");
-      return !!linearService;
+      const apiKey = runtime.getSetting("LINEAR_API_KEY");
+      return !!apiKey;
     } catch {
       return false;
     }
   },
-  async handler(runtime, message, state, options) {
+  async handler(runtime, message, _state, _options) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      const issueId = options?.issueId ? String(options.issueId) : void 0;
-      if (!issueId) {
+      const content = message.content.text;
+      if (!content) {
         return {
-          success: false,
-          error: "Issue ID is required"
+          text: "Please provide update instructions for the issue.",
+          success: false
         };
       }
+      const issueMatch = content.match(/(\w+-\d+)/);
+      if (!issueMatch) {
+        return {
+          text: "Please specify an issue ID (e.g., ENG-123) to update.",
+          success: false
+        };
+      }
+      const issueId = issueMatch[1];
       const updates = {};
-      if (options?.title !== void 0) updates.title = String(options.title);
-      if (options?.description !== void 0) updates.description = String(options.description);
-      if (options?.priority !== void 0) updates.priority = Number(options.priority);
-      if (options?.assigneeId !== void 0) updates.assigneeId = String(options.assigneeId);
-      if (options?.stateId !== void 0) updates.stateId = String(options.stateId);
-      if (options?.labelIds !== void 0) updates.labelIds = options.labelIds;
-      if (options?.projectId !== void 0) updates.projectId = String(options.projectId);
-      if (options?.estimate !== void 0) updates.estimate = Number(options.estimate);
-      if (options?.dueDate !== void 0) updates.dueDate = new Date(String(options.dueDate));
-      const issue = await linearService.updateIssue(issueId, updates);
-      logger4.info(`Updated Linear issue: ${issue.identifier}`);
+      const titleMatch = content.match(/title to ["'](.+?)["']/i);
+      if (titleMatch) {
+        updates.title = titleMatch[1];
+      }
+      const priorityMatch = content.match(/priority (?:to |as )?(\w+)/i);
+      if (priorityMatch) {
+        const priorityMap = {
+          "urgent": 1,
+          "high": 2,
+          "normal": 3,
+          "medium": 3,
+          "low": 4
+        };
+        const priority = priorityMap[priorityMatch[1].toLowerCase()];
+        if (priority) {
+          updates.priority = priority;
+        }
+      }
+      const descMatch = content.match(/description to ["'](.+?)["']/i);
+      if (descMatch) {
+        updates.description = descMatch[1];
+      }
+      const statusMatch = content.match(/status to (\w+)/i);
+      if (statusMatch) {
+        logger4.warn("Status updates not yet implemented");
+      }
+      if (Object.keys(updates).length === 0) {
+        return {
+          text: `No valid updates found. Please specify what to update (e.g., "Update issue ENG-123 title to 'New Title'")`,
+          success: false
+        };
+      }
+      const updatedIssue = await linearService.updateIssue(issueId, updates);
+      const updateSummary = Object.entries(updates).map(([key, value]) => `${key}: ${value}`).join(", ");
       return {
+        text: `Updated issue ${updatedIssue.identifier}: ${updateSummary}`,
         success: true,
         data: {
-          issue: {
-            id: issue.id,
-            identifier: issue.identifier,
-            title: issue.title,
-            url: issue.url
-          }
-        },
-        metadata: {
-          issueId: issue.id,
-          identifier: issue.identifier,
-          updates: Object.keys(updates)
+          issueId: updatedIssue.id,
+          identifier: updatedIssue.identifier,
+          updates,
+          url: updatedIssue.url
         }
       };
     } catch (error) {
-      logger4.error("Failed to update Linear issue:", error);
+      logger4.error("Failed to update issue:", error);
       return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to update issue"
+        text: `Failed to update issue: ${error instanceof Error ? error.message : "Unknown error"}`,
+        success: false
       };
     }
-  },
-  examples: [
-    {
-      input: 'Update issue ENG-123 title to "Fix login button on all devices"',
-      output: "Updated issue ENG-123: Fix login button on all devices",
-      explanation: "Updates the title of an existing issue"
-    }
-  ]
+  }
 };
 
 // src/actions/searchIssues.ts
 import {
+  ModelType as ModelType2,
   logger as logger5
 } from "@elizaos/core";
-var searchIssuesTemplate = `Extract search criteria from the user's request to search Linear issues.
-
-Recent conversation:
-{{recentMessages}}
+var searchTemplate = `Extract search criteria from the user's request for Linear issues.
 
-Extract search filters like:
-- query: Text to search in title/description
-- state: Issue states (todo, in-progress, done, canceled)
-- assignee: Assignee names or IDs
-- label: Label names
-- priority: Priority levels (1=Urgent, 2=High, 3=Normal, 4=Low)
-- team: Team name or ID
-- project: Project name or ID
+User request: "{{userMessage}}"
 
-Response format should be a valid JSON block:
-\`\`\`json
+Extract and return ONLY a JSON object (no markdown formatting, no code blocks) with these possible filters:
 {
-  "query": "search text or null",
-  "state": ["state1", "state2"] or null,
-  "assignee": ["assignee"] or null,
-  "label": ["label1", "label2"] or null,
-  "priority": [1, 2] or null,
-  "team": "team-name" or null,
-  "project": "project-name" or null,
-  "limit": 20
+  "query": "general search text",
+  "state": "filter by state name (e.g., 'In Progress', 'Done', 'Todo')",
+  "assignee": "filter by assignee name or email",
+  "priority": "filter by priority (1=urgent, 2=high, 3=normal, 4=low)",
+  "team": "filter by team name or key",
+  "label": "filter by label name",
+  "hasAssignee": true/false - whether issue should have an assignee,
+  "limit": number of results to return (default 10)
 }
-\`\`\`
-`;
-var searchLinearIssuesAction = {
+
+Only include fields that are mentioned. Return only the JSON object.`;
+var searchIssuesAction = {
   name: "SEARCH_LINEAR_ISSUES",
-  description: "Search for issues in Linear based on various criteria",
-  similes: ["search issues", "find issues", "list issues", "show issues", "query issues", "filter issues"],
-  async validate(runtime, _message, state) {
+  description: "Search for issues in Linear with various filters",
+  similes: ["search-linear-issues", "find-linear-issues", "query-linear-issues"],
+  examples: [[
+    {
+      name: "User",
+      content: {
+        text: "Show me all open bugs"
+      }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll search for all open bug issues in Linear.",
+        actions: ["SEARCH_LINEAR_ISSUES"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: {
+        text: "Find high priority issues assigned to me"
+      }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll search for high priority issues assigned to you.",
+        actions: ["SEARCH_LINEAR_ISSUES"]
+      }
+    }
+  ]],
+  async validate(runtime, _message, _state) {
     try {
-      const linearService = runtime.getService("linear");
-      return !!linearService;
+      const apiKey = runtime.getSetting("LINEAR_API_KEY");
+      return !!apiKey;
     } catch {
       return false;
     }
   },
-  async handler(runtime, message, state, options) {
+  async handler(runtime, message, _state, _options) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      let filters;
-      if (options && Object.keys(options).length > 0) {
-        filters = {
-          query: options.query ? String(options.query) : void 0,
-          state: options.state,
-          assignee: options.assignee,
-          label: options.label,
-          priority: options.priority,
-          team: options.team ? String(options.team) : void 0,
-          project: options.project ? String(options.project) : void 0,
-          limit: options.limit ? Number(options.limit) : 20
+      const content = message.content.text;
+      if (!content) {
+        return {
+          text: "Please provide search criteria for issues.",
+          success: false
         };
+      }
+      let filters = {};
+      if (_options?.filters) {
+        filters = _options.filters;
       } else {
-        const response = await runtime.generateText({
-          messages: state.messages || [],
-          context: searchIssuesTemplate
+        const prompt = searchTemplate.replace("{{userMessage}}", content);
+        const response = await runtime.useModel(ModelType2.TEXT_LARGE, {
+          prompt
         });
-        filters = JSON.parse(response.trim().replace(/```json\n?|\n?```/g, ""));
-      }
-      if (!filters.limit) {
-        filters.limit = 20;
+        if (!response) {
+          filters = { query: content };
+        } else {
+          try {
+            const cleanedResponse = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+            const parsed = JSON.parse(cleanedResponse);
+            filters = {
+              query: parsed.query,
+              state: parsed.state ? [parsed.state] : void 0,
+              assignee: parsed.assignee ? [parsed.assignee] : void 0,
+              priority: parsed.priority ? [parsed.priority] : void 0,
+              team: parsed.team,
+              label: parsed.label ? [parsed.label] : void 0,
+              limit: parsed.limit
+            };
+            Object.keys(filters).forEach((key) => {
+              if (filters[key] === void 0) {
+                delete filters[key];
+              }
+            });
+          } catch (parseError) {
+            logger5.error("Failed to parse search filters:", parseError);
+            filters = { query: content };
+          }
+        }
       }
+      filters.limit = _options?.limit || 10;
       const issues = await linearService.searchIssues(filters);
-      const issuesWithDetails = await Promise.all(
-        issues.map(async (issue) => {
-          const [assignee, state2, team] = await Promise.all([
-            issue.assignee,
-            issue.state,
-            issue.team
-          ]);
-          return {
-            id: issue.id,
-            identifier: issue.identifier,
-            title: issue.title,
-            url: issue.url,
-            priority: issue.priority,
-            priorityLabel: issue.priorityLabel,
-            createdAt: issue.createdAt,
-            updatedAt: issue.updatedAt,
-            assignee: assignee ? assignee.name : "Unassigned",
-            state: state2.name,
-            team: team.name
-          };
-        })
-      );
-      logger5.info(`Found ${issues.length} Linear issues matching criteria`);
+      if (issues.length === 0) {
+        return {
+          text: "No issues found matching your search criteria.",
+          success: true,
+          data: {
+            issues: [],
+            filters,
+            count: 0
+          }
+        };
+      }
+      const issueList = await Promise.all(issues.map(async (issue, index) => {
+        const state = await issue.state;
+        return `${index + 1}. ${issue.identifier}: ${issue.title} (${state?.name || "No state"})`;
+      }));
+      const issueText = issueList.join("\n");
       return {
+        text: `Found ${issues.length} issue${issues.length === 1 ? "" : "s"}:
+${issueText}`,
         success: true,
         data: {
-          issues: issuesWithDetails,
-          count: issues.length,
-          filters
-        },
-        metadata: {
-          searchFilters: filters,
-          resultCount: issues.length
+          issues: issues.map((i) => ({
+            id: i.id,
+            identifier: i.identifier,
+            title: i.title,
+            description: i.description,
+            url: i.url,
+            state: i.state,
+            priority: i.priority,
+            priorityLabel: i.priorityLabel,
+            assignee: i.assignee
+          })),
+          filters,
+          count: issues.length
         }
       };
     } catch (error) {
-      logger5.error("Failed to search Linear issues:", error);
+      logger5.error("Failed to search issues:", error);
       return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to search issues"
+        text: `Failed to search issues: ${error instanceof Error ? error.message : "Unknown error"}`,
+        success: false
       };
     }
-  },
-  examples: [
+  }
+};
+
+// src/actions/createComment.ts
+import { logger as logger6 } from "@elizaos/core";
+var createCommentAction = {
+  name: "CREATE_LINEAR_COMMENT",
+  description: "Create a comment on a Linear issue",
+  similes: ["create-linear-comment", "add-linear-comment", "comment-on-linear-issue"],
+  examples: [[
     {
-      input: "Show me all open bugs",
-      output: 'Found 5 open issues labeled as "bug":\n1. BUG-123: Login timeout issue\n2. BUG-124: Image upload fails\n...',
-      explanation: "Searches for issues with bug label in open states"
+      name: "User",
+      content: {
+        text: "Comment on ENG-123: This has been fixed in the latest release"
+      }
     },
     {
-      input: "Find high priority issues assigned to me",
-      output: "Found 3 high priority issues assigned to you:\n1. FEAT-456: Implement user dashboard\n2. BUG-789: Fix payment processing\n...",
-      explanation: "Searches for high priority issues assigned to the current user"
+      name: "Assistant",
+      content: {
+        text: "I'll add that comment to issue ENG-123.",
+        actions: ["CREATE_LINEAR_COMMENT"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: {
+        text: "Add a comment to BUG-456: Need more information from the reporter"
+      }
     },
     {
-      input: "Search for issues related to authentication",
-      output: 'Found 4 issues matching "authentication":\n1. SEC-001: Add 2FA support\n2. BUG-234: Password reset not working\n...',
-      explanation: "Performs text search across issue titles and descriptions"
+      name: "Assistant",
+      content: {
+        text: "I'll post that comment on BUG-456 right away.",
+        actions: ["CREATE_LINEAR_COMMENT"]
+      }
     }
-  ]
-};
-
-// src/actions/createComment.ts
-import {
-  logger as logger6
-} from "@elizaos/core";
-var createLinearCommentAction = {
-  name: "CREATE_LINEAR_COMMENT",
-  description: "Add a comment to a Linear issue",
-  similes: ["comment on issue", "add comment", "reply to issue"],
-  async validate(runtime, _message, state) {
+  ]],
+  async validate(runtime, _message, _state) {
     try {
-      const linearService = runtime.getService("linear");
-      return !!linearService;
+      const apiKey = runtime.getSetting("LINEAR_API_KEY");
+      return !!apiKey;
     } catch {
       return false;
     }
   },
-  async handler(runtime, message, state, options) {
+  async handler(runtime, message, _state, _options) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      const issueId = options?.issueId ? String(options.issueId) : void 0;
-      const body = options?.body ? String(options.body) : message.content.text;
-      if (!issueId || !body) {
+      const content = message.content.text;
+      if (!content) {
         return {
-          success: false,
-          error: "Issue ID and comment body are required"
+          text: "Please provide a message with the issue ID and comment content.",
+          success: false
         };
       }
-      const commentInput = {
-        issueId,
-        body
-      };
-      const comment = await linearService.createComment(commentInput);
-      logger6.info(`Created comment on Linear issue: ${issueId}`);
+      const issueMatch = content.match(/(?:comment on|add.*comment.*to)\s+(\w+-\d+):?\s*(.*)/i);
+      if (!issueMatch) {
+        return {
+          text: 'Please specify the issue ID and comment content. Example: "Comment on ENG-123: This looks good"',
+          success: false
+        };
+      }
+      const [, issueIdentifier, commentBody] = issueMatch;
+      const issue = await linearService.getIssue(issueIdentifier);
+      const comment = await linearService.createComment({
+        issueId: issue.id,
+        body: commentBody.trim()
+      });
       return {
+        text: `Comment added to issue ${issueIdentifier}: "${commentBody.trim()}"`,
         success: true,
         data: {
-          comment: {
-            id: comment.id,
-            body: comment.body,
-            createdAt: comment.createdAt
-          }
-        },
-        metadata: {
           commentId: comment.id,
-          issueId
+          issueId: issue.id
         }
       };
     } catch (error) {
-      logger6.error("Failed to create Linear comment:", error);
+      logger6.error("Failed to create comment:", error);
       return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to create comment"
+        text: `Failed to create comment: ${error instanceof Error ? error.message : "Unknown error"}`,
+        success: false
       };
     }
-  },
-  examples: [
-    {
-      input: "Comment on ENG-123: This has been fixed in the latest release",
-      output: "Added comment to issue ENG-123",
-      explanation: "Adds a comment to an existing issue"
-    }
-  ]
+  }
 };
 
 // src/actions/listTeams.ts
-import {
-  logger as logger7
-} from "@elizaos/core";
-var listLinearTeamsAction = {
+import { logger as logger7 } from "@elizaos/core";
+var listTeamsAction = {
   name: "LIST_LINEAR_TEAMS",
-  description: "List all teams in the Linear workspace",
-  similes: ["show teams", "get teams", "list teams", "view teams"],
-  async validate(runtime, _message, state) {
+  description: "List all teams in Linear",
+  similes: ["list-linear-teams", "show-linear-teams", "get-linear-teams"],
+  examples: [[
+    {
+      name: "User",
+      content: {
+        text: "Show me all teams"
+      }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll list all the teams in Linear for you.",
+        actions: ["LIST_LINEAR_TEAMS"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: {
+        text: "What teams are available?"
+      }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "Let me show you all the available teams.",
+        actions: ["LIST_LINEAR_TEAMS"]
+      }
+    }
+  ]],
+  async validate(runtime, _message, _state) {
     try {
-      const linearService = runtime.getService("linear");
-      return !!linearService;
+      const apiKey = runtime.getSetting("LINEAR_API_KEY");
+      return !!apiKey;
     } catch {
       return false;
     }
   },
-  async handler(runtime, message, state, options) {
+  async handler(runtime, _message, _state, _options) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
       const teams = await linearService.getTeams();
-      const teamsData = teams.map((team) => ({
-        id: team.id,
-        name: team.name,
-        key: team.key,
-        description: team.description
-      }));
-      logger7.info(`Retrieved ${teams.length} Linear teams`);
+      if (teams.length === 0) {
+        return {
+          text: "No teams found in Linear.",
+          success: true,
+          data: {
+            teams: []
+          }
+        };
+      }
+      const teamList = teams.map(
+        (team, index) => `${index + 1}. ${team.name} (${team.key})${team.description ? ` - ${team.description}` : ""}`
+      ).join("\n");
       return {
+        text: `Found ${teams.length} team${teams.length === 1 ? "" : "s"}:
+${teamList}`,
         success: true,
         data: {
-          teams: teamsData,
+          teams: teams.map((t) => ({
+            id: t.id,
+            name: t.name,
+            key: t.key,
+            description: t.description
+          })),
           count: teams.length
-        },
-        metadata: {
-          teamCount: teams.length
         }
       };
     } catch (error) {
-      logger7.error("Failed to list Linear teams:", error);
+      logger7.error("Failed to list teams:", error);
       return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to list teams"
+        text: `Failed to list teams: ${error instanceof Error ? error.message : "Unknown error"}`,
+        success: false
       };
     }
-  },
-  examples: [
-    {
-      input: "Show me all teams",
-      output: "Found 3 teams:\n1. Engineering (ENG)\n2. Design (DES)\n3. Product (PROD)",
-      explanation: "Lists all teams in the workspace"
-    }
-  ]
+  }
 };
 
 // src/actions/listProjects.ts
-import {
-  logger as logger8
-} from "@elizaos/core";
-var listLinearProjectsAction = {
+import { logger as logger8 } from "@elizaos/core";
+var listProjectsAction = {
   name: "LIST_LINEAR_PROJECTS",
-  description: "List projects in Linear, optionally filtered by team",
-  similes: ["show projects", "get projects", "list projects", "view projects"],
-  async validate(runtime, _message, state) {
+  description: "List all projects in Linear",
+  similes: ["list-linear-projects", "show-linear-projects", "get-linear-projects"],
+  examples: [[
+    {
+      name: "User",
+      content: {
+        text: "Show me all projects"
+      }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll list all the projects in Linear for you.",
+        actions: ["LIST_LINEAR_PROJECTS"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: {
+        text: "What projects do we have?"
+      }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "Let me show you all the available projects.",
+        actions: ["LIST_LINEAR_PROJECTS"]
+      }
+    }
+  ]],
+  async validate(runtime, _message, _state) {
     try {
-      const linearService = runtime.getService("linear");
-      return !!linearService;
+      const apiKey = runtime.getSetting("LINEAR_API_KEY");
+      return !!apiKey;
     } catch {
       return false;
     }
   },
-  async handler(runtime, message, state, options) {
+  async handler(runtime, _message, _state, _options) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      const teamId = options?.teamId ? String(options.teamId) : void 0;
-      const projects = await linearService.getProjects(teamId);
-      const projectsData = await Promise.all(
+      const projects = await linearService.getProjects();
+      if (projects.length === 0) {
+        return {
+          text: "No projects found in Linear.",
+          success: true,
+          data: {
+            projects: []
+          }
+        };
+      }
+      const projectsWithDetails = await Promise.all(
         projects.map(async (project) => {
-          const team = await project.team;
+          const teamsQuery = await project.teams();
+          const teams = await teamsQuery.nodes;
           return {
-            id: project.id,
-            name: project.name,
-            description: project.description,
-            state: project.state,
-            teamName: team?.name,
-            startDate: project.startDate,
-            targetDate: project.targetDate
+            ...project,
+            teamsList: teams
           };
         })
       );
-      logger8.info(`Retrieved ${projects.length} Linear projects`);
+      const projectList = projectsWithDetails.map((project, index) => {
+        const teamNames = project.teamsList.map((t) => t.name).join(", ") || "No teams";
+        return `${index + 1}. ${project.name}${project.description ? ` - ${project.description}` : ""} (Teams: ${teamNames})`;
+      }).join("\n");
       return {
+        text: `Found ${projects.length} project${projects.length === 1 ? "" : "s"}:
+${projectList}`,
         success: true,
         data: {
-          projects: projectsData,
+          projects: projectsWithDetails.map((p) => ({
+            id: p.id,
+            name: p.name,
+            description: p.description,
+            url: p.url,
+            teams: p.teamsList.map((t) => ({
+              id: t.id,
+              name: t.name,
+              key: t.key
+            })),
+            state: p.state,
+            progress: p.progress,
+            startDate: p.startDate,
+            targetDate: p.targetDate
+          })),
           count: projects.length
-        },
-        metadata: {
-          projectCount: projects.length,
-          teamFilter: teamId
         }
       };
     } catch (error) {
-      logger8.error("Failed to list Linear projects:", error);
+      logger8.error("Failed to list projects:", error);
       return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to list projects"
+        text: `Failed to list projects: ${error instanceof Error ? error.message : "Unknown error"}`,
+        success: false
       };
     }
-  },
-  examples: [
-    {
-      input: "Show me all projects",
-      output: "Found 5 projects:\n1. Q1 2024 Roadmap\n2. Mobile App Redesign\n3. API v2 Migration...",
-      explanation: "Lists all projects in the workspace"
-    }
-  ]
+  }
 };
 
 // src/actions/getActivity.ts
-import {
-  logger as logger9
-} from "@elizaos/core";
-var getLinearActivityAction = {
+import { logger as logger9 } from "@elizaos/core";
+var getActivityAction = {
   name: "GET_LINEAR_ACTIVITY",
-  description: "Get recent Linear activity log",
-  similes: ["show activity", "get activity", "view activity", "activity log"],
-  async validate(runtime, _message, state) {
+  description: "Get recent Linear activity",
+  similes: ["get-linear-activity", "show-linear-activity", "view-linear-activity"],
+  examples: [[
+    {
+      name: "User",
+      content: {
+        text: "Show me recent Linear activity"
+      }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll check the recent Linear activity for you.",
+        actions: ["GET_LINEAR_ACTIVITY"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: {
+        text: "What's been happening in Linear?"
+      }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "Let me show you the recent Linear activity.",
+        actions: ["GET_LINEAR_ACTIVITY"]
+      }
+    }
+  ]],
+  async validate(runtime, _message, _state) {
     try {
-      const linearService = runtime.getService("linear");
-      return !!linearService;
+      const apiKey = runtime.getSetting("LINEAR_API_KEY");
+      return !!apiKey;
     } catch {
       return false;
     }
   },
-  async handler(runtime, message, state, options) {
+  async handler(runtime, _message, _state, _options) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      const limit = options?.limit ? Number(options.limit) : 50;
-      const filter = options?.filter ? options.filter : void 0;
-      const activity = linearService.getActivityLog(limit, filter);
-      logger9.info(`Retrieved ${activity.length} Linear activity items`);
+      const activity = linearService.getActivityLog();
+      if (activity.length === 0) {
+        return {
+          text: "No recent Linear activity found.",
+          success: true,
+          data: {
+            activity: []
+          }
+        };
+      }
+      const activityText = activity.slice(0, 10).map((item, index) => {
+        const description = `${item.action} ${item.resource_type} ${item.resource_id}${item.error ? ` (failed: ${item.error})` : ""}`;
+        return `${index + 1}. ${description}`;
+      }).join("\n");
       return {
+        text: `Recent Linear activity:
+${activityText}`,
         success: true,
         data: {
-          activity,
+          activity: activity.slice(0, 10),
           count: activity.length
-        },
-        metadata: {
-          activityCount: activity.length
         }
       };
     } catch (error) {
       logger9.error("Failed to get Linear activity:", error);
       return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to get activity"
+        text: `Failed to get Linear activity: ${error instanceof Error ? error.message : "Unknown error"}`,
+        success: false
       };
     }
-  },
-  examples: [
-    {
-      input: "Show me recent Linear activity",
-      output: "Recent activity:\n1. Created issue ENG-123\n2. Updated issue BUG-456\n3. Added comment to FEAT-789...",
-      explanation: "Shows recent Linear operations performed by the agent"
-    }
-  ]
+  }
 };
 
 // src/actions/clearActivity.ts
-import {
-  logger as logger10
-} from "@elizaos/core";
-var clearLinearActivityAction = {
+import { logger as logger10 } from "@elizaos/core";
+var clearActivityAction = {
   name: "CLEAR_LINEAR_ACTIVITY",
   description: "Clear the Linear activity log",
-  similes: ["clear activity", "reset activity", "delete activity log"],
-  async validate(runtime, _message, state) {
+  similes: ["clear-linear-activity", "reset-linear-activity", "delete-linear-activity"],
+  examples: [[
+    {
+      name: "User",
+      content: {
+        text: "Clear the Linear activity log"
+      }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll clear the Linear activity log for you.",
+        actions: ["CLEAR_LINEAR_ACTIVITY"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: {
+        text: "Reset Linear activity"
+      }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll reset the Linear activity log now.",
+        actions: ["CLEAR_LINEAR_ACTIVITY"]
+      }
+    }
+  ]],
+  async validate(runtime, _message, _state) {
     try {
-      const linearService = runtime.getService("linear");
-      return !!linearService;
+      const apiKey = runtime.getSetting("LINEAR_API_KEY");
+      return !!apiKey;
     } catch {
       return false;
     }
   },
-  async handler(runtime, message, state, options) {
+  async handler(runtime, message, _state, _options) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      linearService.clearActivityLog();
-      logger10.info("Cleared Linear activity log");
+      await linearService.clearActivityLog();
       return {
-        success: true,
-        data: {
-          message: "Activity log cleared successfully"
-        }
+        text: "Linear activity log has been cleared.",
+        success: true
       };
     } catch (error) {
       logger10.error("Failed to clear Linear activity:", error);
       return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to clear activity"
+        text: `Failed to clear Linear activity: ${error instanceof Error ? error.message : "Unknown error"}`,
+        success: false
       };
     }
-  },
-  examples: [
-    {
-      input: "Clear the Linear activity log",
-      output: "Linear activity log has been cleared",
-      explanation: "Clears all stored activity history"
-    }
-  ]
+  }
 };
 
 // src/providers/issues.ts
@@ -1299,29 +1541,26 @@ ${activityList.join("\n")}`;
 
 // src/index.ts
 var linearPlugin = {
-  name: "linear",
-  description: "Linear integration plugin for issue tracking and project management",
+  name: "@elizaos/plugin-linear",
+  description: "Plugin for integrating with Linear issue tracking system",
   services: [LinearService],
   actions: [
-    createLinearIssueAction,
-    getLinearIssueAction,
-    updateLinearIssueAction,
-    searchLinearIssuesAction,
-    createLinearCommentAction,
-    listLinearTeamsAction,
-    listLinearProjectsAction,
-    getLinearActivityAction,
-    clearLinearActivityAction
+    createIssueAction,
+    getIssueAction,
+    updateIssueAction,
+    searchIssuesAction,
+    createCommentAction,
+    listTeamsAction,
+    listProjectsAction,
+    getActivityAction,
+    clearActivityAction
   ],
   providers: [
     linearIssuesProvider,
     linearTeamsProvider,
     linearProjectsProvider,
     linearActivityProvider
-  ],
-  // No evaluators or events for this plugin
-  evaluators: [],
-  events: {}
+  ]
 };
 export {
   LinearAPIError,