@elizaos/plugin-linear 1.2.5

package/dist/index.js

@@ -0,0 +1,1333 @@
+// src/services/linear.ts
+import { logger, Service } from "@elizaos/core";
+import { LinearClient } from "@linear/sdk";
+
+// src/types/index.ts
+var LinearAPIError = class extends Error {
+  constructor(message, status, response) {
+    super(message);
+    this.status = status;
+    this.response = response;
+    this.name = "LinearAPIError";
+  }
+};
+var LinearAuthenticationError = class extends LinearAPIError {
+  constructor(message) {
+    super(message, 401);
+    this.name = "LinearAuthenticationError";
+  }
+};
+var LinearRateLimitError = class extends LinearAPIError {
+  constructor(message, resetTime) {
+    super(message, 429);
+    this.resetTime = resetTime;
+    this.name = "LinearRateLimitError";
+  }
+};
+
+// src/services/linear.ts
+var _LinearService = class _LinearService extends Service {
+  constructor(runtime) {
+    super(runtime);
+    this.capabilityDescription = "Linear API integration for issue tracking, project management, and team collaboration";
+    this.activityLog = [];
+    const apiKey = runtime?.getSetting("LINEAR_API_KEY");
+    const workspaceId = runtime?.getSetting("LINEAR_WORKSPACE_ID");
+    if (!apiKey) {
+      throw new LinearAuthenticationError("Linear API key is required");
+    }
+    this.linearConfig = {
+      LINEAR_API_KEY: apiKey,
+      LINEAR_WORKSPACE_ID: workspaceId
+    };
+    this.workspaceId = workspaceId;
+    this.config = {
+      LINEAR_API_KEY: apiKey,
+      LINEAR_WORKSPACE_ID: workspaceId
+    };
+    this.client = new LinearClient({
+      apiKey: this.linearConfig.LINEAR_API_KEY
+    });
+  }
+  static async start(runtime) {
+    const service = new _LinearService(runtime);
+    await service.validateConnection();
+    logger.info("Linear service started successfully");
+    return service;
+  }
+  async stop() {
+    this.activityLog = [];
+    logger.info("Linear service stopped");
+  }
+  // Validate the API connection
+  async validateConnection() {
+    try {
+      const viewer = await this.client.viewer;
+      logger.info(`Linear connected as user: ${viewer.email}`);
+    } catch (error) {
+      throw new LinearAuthenticationError("Failed to authenticate with Linear API");
+    }
+  }
+  // Log activity
+  logActivity(action, resourceType, resourceId, details, success, error) {
+    const activity = {
+      id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      action,
+      resource_type: resourceType,
+      resource_id: resourceId,
+      details,
+      success,
+      error
+    };
+    this.activityLog.push(activity);
+    if (this.activityLog.length > 1e3) {
+      this.activityLog = this.activityLog.slice(-1e3);
+    }
+  }
+  // Get activity log
+  getActivityLog(limit, filter) {
+    let filtered = [...this.activityLog];
+    if (filter) {
+      filtered = filtered.filter((item) => {
+        return Object.entries(filter).every(([key, value]) => {
+          return item[key] === value;
+        });
+      });
+    }
+    return filtered.slice(-(limit || 100));
+  }
+  // Clear activity log
+  clearActivityLog() {
+    this.activityLog = [];
+    logger.info("Linear activity log cleared");
+  }
+  // Team operations
+  async getTeams() {
+    try {
+      const teams = await this.client.teams();
+      const teamList = await teams.nodes;
+      this.logActivity("list_teams", "team", "all", { count: teamList.length }, true);
+      return teamList;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("list_teams", "team", "all", {}, false, errorMessage);
+      throw new LinearAPIError(`Failed to fetch teams: ${errorMessage}`);
+    }
+  }
+  async getTeam(teamId) {
+    try {
+      const team = await this.client.team(teamId);
+      this.logActivity("get_team", "team", teamId, { name: team.name }, true);
+      return team;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("get_team", "team", teamId, {}, false, errorMessage);
+      throw new LinearAPIError(`Failed to fetch team: ${errorMessage}`);
+    }
+  }
+  // Issue operations
+  async createIssue(input) {
+    try {
+      const issuePayload = await this.client.createIssue({
+        title: input.title,
+        description: input.description,
+        teamId: input.teamId,
+        priority: input.priority,
+        assigneeId: input.assigneeId,
+        labelIds: input.labelIds,
+        projectId: input.projectId,
+        stateId: input.stateId,
+        estimate: input.estimate,
+        dueDate: input.dueDate
+      });
+      const issue = await issuePayload.issue;
+      if (!issue) {
+        throw new Error("Failed to create issue");
+      }
+      this.logActivity("create_issue", "issue", issue.id, {
+        title: input.title,
+        teamId: input.teamId
+      }, true);
+      return issue;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("create_issue", "issue", "new", input, false, errorMessage);
+      throw new LinearAPIError(`Failed to create issue: ${errorMessage}`);
+    }
+  }
+  async getIssue(issueId) {
+    try {
+      const issue = await this.client.issue(issueId);
+      this.logActivity("get_issue", "issue", issueId, {
+        title: issue.title,
+        identifier: issue.identifier
+      }, true);
+      return issue;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("get_issue", "issue", issueId, {}, false, errorMessage);
+      throw new LinearAPIError(`Failed to fetch issue: ${errorMessage}`);
+    }
+  }
+  async updateIssue(issueId, updates) {
+    try {
+      const updatePayload = await this.client.updateIssue(issueId, {
+        title: updates.title,
+        description: updates.description,
+        priority: updates.priority,
+        assigneeId: updates.assigneeId,
+        labelIds: updates.labelIds,
+        projectId: updates.projectId,
+        stateId: updates.stateId,
+        estimate: updates.estimate,
+        dueDate: updates.dueDate
+      });
+      const issue = await updatePayload.issue;
+      if (!issue) {
+        throw new Error("Failed to update issue");
+      }
+      this.logActivity("update_issue", "issue", issueId, updates, true);
+      return issue;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("update_issue", "issue", issueId, updates, false, errorMessage);
+      throw new LinearAPIError(`Failed to update issue: ${errorMessage}`);
+    }
+  }
+  async searchIssues(filters) {
+    try {
+      const query = this.client.issues({
+        first: filters.limit || 50,
+        filter: filters.query ? {
+          or: [
+            { title: { containsIgnoreCase: filters.query } },
+            { description: { containsIgnoreCase: filters.query } }
+          ]
+        } : void 0
+      });
+      const issues = await query;
+      const issueList = await issues.nodes;
+      this.logActivity("search_issues", "issue", "search", {
+        filters,
+        count: issueList.length
+      }, true);
+      return issueList;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("search_issues", "issue", "search", filters, false, errorMessage);
+      throw new LinearAPIError(`Failed to search issues: ${errorMessage}`);
+    }
+  }
+  // Comment operations
+  async createComment(input) {
+    try {
+      const commentPayload = await this.client.createComment({
+        body: input.body,
+        issueId: input.issueId
+      });
+      const comment = await commentPayload.comment;
+      if (!comment) {
+        throw new Error("Failed to create comment");
+      }
+      this.logActivity("create_comment", "comment", comment.id, {
+        issueId: input.issueId,
+        bodyLength: input.body.length
+      }, true);
+      return comment;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("create_comment", "comment", "new", input, false, errorMessage);
+      throw new LinearAPIError(`Failed to create comment: ${errorMessage}`);
+    }
+  }
+  // Project operations
+  async getProjects(teamId) {
+    try {
+      const query = this.client.projects({
+        first: 100
+      });
+      const projects = await query;
+      let projectList = await projects.nodes;
+      if (teamId) {
+        const filteredProjects = await Promise.all(
+          projectList.map(async (project) => {
+            const projectTeams = await project.teams();
+            const teamsList = await projectTeams.nodes;
+            const hasTeam = teamsList.some((team) => team.id === teamId);
+            return hasTeam ? project : null;
+          })
+        );
+        projectList = filteredProjects.filter(Boolean);
+      }
+      this.logActivity("list_projects", "project", "all", {
+        count: projectList.length,
+        teamId
+      }, true);
+      return projectList;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("list_projects", "project", "all", { teamId }, false, errorMessage);
+      throw new LinearAPIError(`Failed to fetch projects: ${errorMessage}`);
+    }
+  }
+  async getProject(projectId) {
+    try {
+      const project = await this.client.project(projectId);
+      this.logActivity("get_project", "project", projectId, {
+        name: project.name
+      }, true);
+      return project;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("get_project", "project", projectId, {}, false, errorMessage);
+      throw new LinearAPIError(`Failed to fetch project: ${errorMessage}`);
+    }
+  }
+  // User operations
+  async getUsers() {
+    try {
+      const users = await this.client.users();
+      const userList = await users.nodes;
+      this.logActivity("list_users", "user", "all", {
+        count: userList.length
+      }, true);
+      return userList;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("list_users", "user", "all", {}, false, errorMessage);
+      throw new LinearAPIError(`Failed to fetch users: ${errorMessage}`);
+    }
+  }
+  async getCurrentUser() {
+    try {
+      const user = await this.client.viewer;
+      this.logActivity("get_current_user", "user", user.id, {
+        email: user.email,
+        name: user.name
+      }, true);
+      return user;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("get_current_user", "user", "current", {}, false, errorMessage);
+      throw new LinearAPIError(`Failed to fetch current user: ${errorMessage}`);
+    }
+  }
+  // Label operations
+  async getLabels(teamId) {
+    try {
+      const query = this.client.issueLabels({
+        first: 100,
+        filter: teamId ? {
+          team: { id: { eq: teamId } }
+        } : void 0
+      });
+      const labels = await query;
+      const labelList = await labels.nodes;
+      this.logActivity("list_labels", "label", "all", {
+        count: labelList.length,
+        teamId
+      }, true);
+      return labelList;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("list_labels", "label", "all", { teamId }, false, errorMessage);
+      throw new LinearAPIError(`Failed to fetch labels: ${errorMessage}`);
+    }
+  }
+  // Workflow state operations
+  async getWorkflowStates(teamId) {
+    try {
+      const states = await this.client.workflowStates({
+        filter: {
+          team: { id: { eq: teamId } }
+        }
+      });
+      const stateList = await states.nodes;
+      this.logActivity("list_workflow_states", "team", teamId, {
+        count: stateList.length
+      }, true);
+      return stateList;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logActivity("list_workflow_states", "team", teamId, {}, false, errorMessage);
+      throw new LinearAPIError(`Failed to fetch workflow states: ${errorMessage}`);
+    }
+  }
+};
+_LinearService.serviceType = "linear";
+var LinearService = _LinearService;
+
+// src/actions/createIssue.ts
+import {
+  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.
+
+Recent conversation:
+{{recentMessages}}
+
+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
+{
+  "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
+}
+\`\`\`
+`;
+var createLinearIssueAction = {
+  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) {
+    try {
+      const linearService = runtime.getService("linear");
+      return !!linearService;
+    } catch {
+      return false;
+    }
+  },
+  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);
+        return {
+          success: true,
+          data: {
+            issue: {
+              id: issue2.id,
+              identifier: issue2.identifier,
+              title: issue2.title,
+              url: issue2.url
+            }
+          },
+          metadata: {
+            issueId: issue2.id,
+            identifier: issue2.identifier
+          }
+        };
+      }
+      const response = await runtime.generateText({
+        messages: state.messages || [],
+        context: createIssueTemplate
+      });
+      const parsed = JSON.parse(response.trim().replace(/```json\n?|\n?```/g, ""));
+      if (!parsed.shouldCreate) {
+        return {
+          success: false,
+          error: "Not enough information to create an issue"
+        };
+      }
+      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 {
+        }
+      }
+      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}`);
+      return {
+        success: true,
+        data: {
+          issue: {
+            id: issue.id,
+            identifier: issue.identifier,
+            title: issue.title,
+            url: issue.url,
+            teamName
+          }
+        },
+        metadata: {
+          issueId: issue.id,
+          identifier: issue.identifier
+        }
+      };
+    } catch (error) {
+      logger2.error("Failed to create Linear issue:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to create 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"
+    },
+    {
+      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"
+    },
+    {
+      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"
+    }
+  ]
+};
+
+// 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) {
+    try {
+      const linearService = runtime.getService("linear");
+      return !!linearService;
+    } catch {
+      return false;
+    }
+  },
+  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];
+        }
+      }
+      if (!issueId) {
+        return {
+          success: false,
+          error: "No issue ID or identifier provided"
+        };
+      }
+      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 = {
+        id: issue.id,
+        identifier: issue.identifier,
+        title: issue.title,
+        description: issue.description,
+        url: issue.url,
+        priority: issue.priority,
+        priorityLabel: issue.priorityLabel,
+        estimate: issue.estimate,
+        createdAt: issue.createdAt,
+        updatedAt: issue.updatedAt,
+        dueDate: issue.dueDate,
+        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: {
+          id: team.id,
+          name: team.name,
+          key: team.key
+        },
+        labels: labelList.map((label) => ({
+          id: label.id,
+          name: label.name,
+          color: label.color
+        }))
+      };
+      logger3.info(`Retrieved Linear issue: ${issue.identifier}`);
+      return {
+        success: true,
+        data: {
+          issue: issueData
+        },
+        metadata: {
+          issueId: issue.id,
+          identifier: issue.identifier
+        }
+      };
+    } catch (error) {
+      logger3.error("Failed to get Linear issue:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get 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"
+    },
+    {
+      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"
+    },
+    {
+      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"
+    }
+  ]
+};
+
+// 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) {
+    try {
+      const linearService = runtime.getService("linear");
+      return !!linearService;
+    } catch {
+      return false;
+    }
+  },
+  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) {
+        return {
+          success: false,
+          error: "Issue ID is required"
+        };
+      }
+      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}`);
+      return {
+        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)
+        }
+      };
+    } catch (error) {
+      logger4.error("Failed to update Linear issue:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to update issue"
+      };
+    }
+  },
+  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 {
+  logger as logger5
+} from "@elizaos/core";
+var searchIssuesTemplate = `Extract search criteria from the user's request to search Linear issues.
+
+Recent conversation:
+{{recentMessages}}
+
+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
+
+Response format should be a valid JSON block:
+\`\`\`json
+{
+  "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
+}
+\`\`\`
+`;
+var searchLinearIssuesAction = {
+  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) {
+    try {
+      const linearService = runtime.getService("linear");
+      return !!linearService;
+    } catch {
+      return false;
+    }
+  },
+  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
+        };
+      } else {
+        const response = await runtime.generateText({
+          messages: state.messages || [],
+          context: searchIssuesTemplate
+        });
+        filters = JSON.parse(response.trim().replace(/```json\n?|\n?```/g, ""));
+      }
+      if (!filters.limit) {
+        filters.limit = 20;
+      }
+      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`);
+      return {
+        success: true,
+        data: {
+          issues: issuesWithDetails,
+          count: issues.length,
+          filters
+        },
+        metadata: {
+          searchFilters: filters,
+          resultCount: issues.length
+        }
+      };
+    } catch (error) {
+      logger5.error("Failed to search Linear issues:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to search issues"
+      };
+    }
+  },
+  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"
+    },
+    {
+      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"
+    },
+    {
+      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"
+    }
+  ]
+};
+
+// 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) {
+    try {
+      const linearService = runtime.getService("linear");
+      return !!linearService;
+    } catch {
+      return false;
+    }
+  },
+  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) {
+        return {
+          success: false,
+          error: "Issue ID and comment body are required"
+        };
+      }
+      const commentInput = {
+        issueId,
+        body
+      };
+      const comment = await linearService.createComment(commentInput);
+      logger6.info(`Created comment on Linear issue: ${issueId}`);
+      return {
+        success: true,
+        data: {
+          comment: {
+            id: comment.id,
+            body: comment.body,
+            createdAt: comment.createdAt
+          }
+        },
+        metadata: {
+          commentId: comment.id,
+          issueId
+        }
+      };
+    } catch (error) {
+      logger6.error("Failed to create Linear comment:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to create comment"
+      };
+    }
+  },
+  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 = {
+  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) {
+    try {
+      const linearService = runtime.getService("linear");
+      return !!linearService;
+    } catch {
+      return false;
+    }
+  },
+  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`);
+      return {
+        success: true,
+        data: {
+          teams: teamsData,
+          count: teams.length
+        },
+        metadata: {
+          teamCount: teams.length
+        }
+      };
+    } catch (error) {
+      logger7.error("Failed to list Linear teams:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to list teams"
+      };
+    }
+  },
+  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 = {
+  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) {
+    try {
+      const linearService = runtime.getService("linear");
+      return !!linearService;
+    } catch {
+      return false;
+    }
+  },
+  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(
+        projects.map(async (project) => {
+          const team = await project.team;
+          return {
+            id: project.id,
+            name: project.name,
+            description: project.description,
+            state: project.state,
+            teamName: team?.name,
+            startDate: project.startDate,
+            targetDate: project.targetDate
+          };
+        })
+      );
+      logger8.info(`Retrieved ${projects.length} Linear projects`);
+      return {
+        success: true,
+        data: {
+          projects: projectsData,
+          count: projects.length
+        },
+        metadata: {
+          projectCount: projects.length,
+          teamFilter: teamId
+        }
+      };
+    } catch (error) {
+      logger8.error("Failed to list Linear projects:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to list projects"
+      };
+    }
+  },
+  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 = {
+  name: "GET_LINEAR_ACTIVITY",
+  description: "Get recent Linear activity log",
+  similes: ["show activity", "get activity", "view activity", "activity log"],
+  async validate(runtime, _message, state) {
+    try {
+      const linearService = runtime.getService("linear");
+      return !!linearService;
+    } catch {
+      return false;
+    }
+  },
+  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`);
+      return {
+        success: true,
+        data: {
+          activity,
+          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"
+      };
+    }
+  },
+  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 = {
+  name: "CLEAR_LINEAR_ACTIVITY",
+  description: "Clear the Linear activity log",
+  similes: ["clear activity", "reset activity", "delete activity log"],
+  async validate(runtime, _message, state) {
+    try {
+      const linearService = runtime.getService("linear");
+      return !!linearService;
+    } catch {
+      return false;
+    }
+  },
+  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");
+      return {
+        success: true,
+        data: {
+          message: "Activity log cleared successfully"
+        }
+      };
+    } catch (error) {
+      logger10.error("Failed to clear Linear activity:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to clear activity"
+      };
+    }
+  },
+  examples: [
+    {
+      input: "Clear the Linear activity log",
+      output: "Linear activity log has been cleared",
+      explanation: "Clears all stored activity history"
+    }
+  ]
+};
+
+// src/providers/issues.ts
+var linearIssuesProvider = {
+  name: "LINEAR_ISSUES",
+  description: "Provides context about recent Linear issues",
+  get: async (runtime, _message, _state) => {
+    try {
+      const linearService = runtime.getService("linear");
+      if (!linearService) {
+        return {
+          text: "Linear service is not available"
+        };
+      }
+      const issues = await linearService.searchIssues({ limit: 10 });
+      if (issues.length === 0) {
+        return {
+          text: "No recent Linear issues found"
+        };
+      }
+      const issuesList = await Promise.all(
+        issues.map(async (issue) => {
+          const [assignee, state] = await Promise.all([
+            issue.assignee,
+            issue.state
+          ]);
+          return `- ${issue.identifier}: ${issue.title} (${state?.name || "Unknown"}, ${assignee?.name || "Unassigned"})`;
+        })
+      );
+      const text = `Recent Linear Issues:
+${issuesList.join("\n")}`;
+      return {
+        text,
+        data: {
+          issues: issues.map((issue) => ({
+            id: issue.id,
+            identifier: issue.identifier,
+            title: issue.title
+          }))
+        }
+      };
+    } catch (error) {
+      return {
+        text: "Error retrieving Linear issues"
+      };
+    }
+  }
+};
+
+// src/providers/teams.ts
+var linearTeamsProvider = {
+  name: "LINEAR_TEAMS",
+  description: "Provides context about Linear teams",
+  get: async (runtime, _message, _state) => {
+    try {
+      const linearService = runtime.getService("linear");
+      if (!linearService) {
+        return {
+          text: "Linear service is not available"
+        };
+      }
+      const teams = await linearService.getTeams();
+      if (teams.length === 0) {
+        return {
+          text: "No Linear teams found"
+        };
+      }
+      const teamsList = teams.map(
+        (team) => `- ${team.name} (${team.key}): ${team.description || "No description"}`
+      );
+      const text = `Linear Teams:
+${teamsList.join("\n")}`;
+      return {
+        text,
+        data: {
+          teams: teams.map((team) => ({
+            id: team.id,
+            name: team.name,
+            key: team.key
+          }))
+        }
+      };
+    } catch (error) {
+      return {
+        text: "Error retrieving Linear teams"
+      };
+    }
+  }
+};
+
+// src/providers/projects.ts
+var linearProjectsProvider = {
+  name: "LINEAR_PROJECTS",
+  description: "Provides context about active Linear projects",
+  get: async (runtime, _message, _state) => {
+    try {
+      const linearService = runtime.getService("linear");
+      if (!linearService) {
+        return {
+          text: "Linear service is not available"
+        };
+      }
+      const projects = await linearService.getProjects();
+      if (projects.length === 0) {
+        return {
+          text: "No Linear projects found"
+        };
+      }
+      const activeProjects = projects.filter(
+        (project) => project.state === "started" || project.state === "planned"
+      );
+      const projectsList = activeProjects.slice(0, 10).map(
+        (project) => `- ${project.name}: ${project.state} (${project.startDate || "No start date"} - ${project.targetDate || "No target date"})`
+      );
+      const text = `Active Linear Projects:
+${projectsList.join("\n")}`;
+      return {
+        text,
+        data: {
+          projects: activeProjects.slice(0, 10).map((project) => ({
+            id: project.id,
+            name: project.name,
+            state: project.state
+          }))
+        }
+      };
+    } catch (error) {
+      return {
+        text: "Error retrieving Linear projects"
+      };
+    }
+  }
+};
+
+// src/providers/activity.ts
+var linearActivityProvider = {
+  name: "LINEAR_ACTIVITY",
+  description: "Provides context about recent Linear activity",
+  get: async (runtime, _message, _state) => {
+    try {
+      const linearService = runtime.getService("linear");
+      if (!linearService) {
+        return {
+          text: "Linear service is not available"
+        };
+      }
+      const activity = linearService.getActivityLog(10);
+      if (activity.length === 0) {
+        return {
+          text: "No recent Linear activity"
+        };
+      }
+      const activityList = activity.map((item) => {
+        const status = item.success ? "\u2713" : "\u2717";
+        const time = new Date(item.timestamp).toLocaleTimeString();
+        return `${status} ${time}: ${item.action} ${item.resource_type} ${item.resource_id}`;
+      });
+      const text = `Recent Linear Activity:
+${activityList.join("\n")}`;
+      return {
+        text,
+        data: {
+          activity: activity.slice(0, 10)
+        }
+      };
+    } catch (error) {
+      return {
+        text: "Error retrieving Linear activity"
+      };
+    }
+  }
+};
+
+// src/index.ts
+var linearPlugin = {
+  name: "linear",
+  description: "Linear integration plugin for issue tracking and project management",
+  services: [LinearService],
+  actions: [
+    createLinearIssueAction,
+    getLinearIssueAction,
+    updateLinearIssueAction,
+    searchLinearIssuesAction,
+    createLinearCommentAction,
+    listLinearTeamsAction,
+    listLinearProjectsAction,
+    getLinearActivityAction,
+    clearLinearActivityAction
+  ],
+  providers: [
+    linearIssuesProvider,
+    linearTeamsProvider,
+    linearProjectsProvider,
+    linearActivityProvider
+  ],
+  // No evaluators or events for this plugin
+  evaluators: [],
+  events: {}
+};
+export {
+  LinearAPIError,
+  LinearAuthenticationError,
+  LinearRateLimitError,
+  LinearService,
+  linearPlugin
+};
+//# sourceMappingURL=index.js.map