@renseiai/agentfactory-linear 0.8.0

package/dist/src/frontend-adapter.js

@@ -0,0 +1,314 @@
+/**
+ * LinearFrontendAdapter
+ *
+ * Implements the WorkSchedulingFrontend interface (defined in @renseiai/agentfactory)
+ * by wrapping the LinearAgentClient. This adapter translates between abstract,
+ * frontend-agnostic types and Linear-specific concepts.
+ *
+ * Structural typing note: This class structurally satisfies the WorkSchedulingFrontend
+ * interface from @renseiai/agentfactory without an explicit `implements` clause, avoiding
+ * a circular package dependency (core depends on linear at runtime, linear depends on
+ * core only for types). Consumers who import both packages can assign this to
+ * WorkSchedulingFrontend.
+ */
+// ---------------------------------------------------------------------------
+// Status mapping
+// ---------------------------------------------------------------------------
+const ABSTRACT_TO_LINEAR = {
+    icebox: 'Icebox',
+    backlog: 'Backlog',
+    started: 'Started',
+    finished: 'Finished',
+    delivered: 'Delivered',
+    accepted: 'Accepted',
+    rejected: 'Rejected',
+    canceled: 'Canceled',
+};
+const LINEAR_TO_ABSTRACT = {
+    Icebox: 'icebox',
+    Backlog: 'backlog',
+    Started: 'started',
+    Finished: 'finished',
+    Delivered: 'delivered',
+    Accepted: 'accepted',
+    Rejected: 'rejected',
+    Canceled: 'canceled',
+};
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Map a Linear SDK Issue to an AbstractIssue.
+ */
+async function toAbstractIssue(issue) {
+    const state = await issue.state;
+    const labels = await issue.labels();
+    const parent = await issue.parent;
+    const project = await issue.project;
+    const nativeStatus = state?.name ?? 'Backlog';
+    const status = LINEAR_TO_ABSTRACT[nativeStatus] ?? 'backlog';
+    return {
+        id: issue.id,
+        identifier: issue.identifier,
+        title: issue.title,
+        description: issue.description ?? undefined,
+        url: issue.url,
+        status,
+        priority: issue.priority,
+        labels: labels.nodes.map((l) => l.name),
+        parentId: parent?.id,
+        project: project?.name,
+        createdAt: issue.createdAt,
+    };
+}
+/**
+ * Map a Linear SDK Comment to an AbstractComment.
+ */
+async function toAbstractComment(comment) {
+    const user = await comment.user;
+    return {
+        id: comment.id,
+        body: comment.body,
+        userId: user?.id,
+        userName: user?.name,
+        createdAt: comment.createdAt,
+    };
+}
+// ---------------------------------------------------------------------------
+// Adapter
+// ---------------------------------------------------------------------------
+/**
+ * Linear frontend adapter that wraps LinearAgentClient.
+ *
+ * Structurally satisfies WorkSchedulingFrontend from @renseiai/agentfactory.
+ */
+export class LinearFrontendAdapter {
+    client;
+    name = 'linear';
+    constructor(client) {
+        this.client = client;
+    }
+    // ---- Status mapping ----
+    /**
+     * Resolve an abstract status to its Linear-native name.
+     */
+    resolveStatus(abstract) {
+        return ABSTRACT_TO_LINEAR[abstract];
+    }
+    /**
+     * Map a Linear-native status name to its abstract equivalent.
+     * Defaults to 'backlog' for unknown statuses.
+     */
+    abstractStatus(nativeStatus) {
+        return LINEAR_TO_ABSTRACT[nativeStatus] ?? 'backlog';
+    }
+    // ---- Read operations ----
+    /**
+     * Fetch an issue by ID or identifier and map to AbstractIssue.
+     */
+    async getIssue(id) {
+        const issue = await this.client.getIssue(id);
+        return toAbstractIssue(issue);
+    }
+    /**
+     * List issues in a project filtered by abstract status.
+     *
+     * Uses the underlying LinearClient directly since LinearAgentClient
+     * does not expose a project-scoped issue listing method.
+     */
+    async listIssuesByStatus(project, status) {
+        const nativeStatus = this.resolveStatus(status);
+        const linearClient = this.client.linearClient;
+        const issueConnection = await linearClient.issues({
+            filter: {
+                project: { name: { eq: project } },
+                state: { name: { eq: nativeStatus } },
+            },
+        });
+        const results = [];
+        for (const issue of issueConnection.nodes) {
+            results.push(await toAbstractIssue(issue));
+        }
+        return results;
+    }
+    /**
+     * Get comments for an issue and map to AbstractComment[].
+     */
+    async getIssueComments(id) {
+        const comments = await this.client.getIssueComments(id);
+        const results = [];
+        for (const comment of comments) {
+            results.push(await toAbstractComment(comment));
+        }
+        return results;
+    }
+    /**
+     * List issues in a project filtered by abstract status, excluding
+     * those that are blocked by other issues (have incoming "blocks" relations).
+     */
+    async getUnblockedIssues(project, status) {
+        const allIssues = await this.listIssuesByStatus(project, status);
+        const results = [];
+        for (const issue of allIssues) {
+            const relations = await this.client.getIssueRelations(issue.id);
+            // An issue is blocked if another issue has an outgoing "blocks" relation to it
+            // (appears as an inverse relation with type "blocks")
+            const isBlocked = relations.inverseRelations.some((r) => r.type === 'blocks');
+            if (!isBlocked) {
+                results.push(issue);
+            }
+        }
+        return results;
+    }
+    /**
+     * Check if an issue has child issues (is a parent issue).
+     */
+    async isParentIssue(id) {
+        return this.client.isParentIssue(id);
+    }
+    /**
+     * Check if an issue has a parent (is a child/sub-issue).
+     */
+    async isChildIssue(id) {
+        return this.client.isChildIssue(id);
+    }
+    /**
+     * Get sub-issues of a parent issue, mapped to AbstractIssue[].
+     */
+    async getSubIssues(id) {
+        const subIssues = await this.client.getSubIssues(id);
+        const results = [];
+        for (const issue of subIssues) {
+            results.push(await toAbstractIssue(issue));
+        }
+        return results;
+    }
+    // ---- Write operations ----
+    /**
+     * Transition an issue to a new status.
+     */
+    async transitionIssue(id, status) {
+        const nativeStatus = this.resolveStatus(status);
+        // LinearAgentClient.updateIssueStatus expects LinearWorkflowStatus
+        // which does not include 'Icebox', so we handle that case via updateIssue
+        if (nativeStatus === 'Icebox') {
+            const issue = await this.client.getIssue(id);
+            const team = await issue.team;
+            if (team) {
+                const statuses = await this.client.getTeamStatuses(team.id);
+                const stateId = statuses['Icebox'];
+                if (stateId) {
+                    await this.client.updateIssue(id, { stateId });
+                    return;
+                }
+            }
+            throw new Error(`Cannot transition issue ${id} to Icebox: status not found`);
+        }
+        await this.client.updateIssueStatus(id, nativeStatus);
+    }
+    /**
+     * Create a comment on an issue.
+     */
+    async createComment(id, body) {
+        await this.client.createComment(id, body);
+    }
+    /**
+     * Create a blocker issue that blocks the source issue.
+     * Creates the issue in Icebox with a "Needs Human" label (if found),
+     * then creates a "blocks" relation from the blocker to the source.
+     */
+    async createBlockerIssue(sourceId, data) {
+        // Determine the team — use provided teamId or look it up from the source issue
+        let teamId = data.teamId;
+        if (!teamId) {
+            const sourceIssue = await this.client.getIssue(sourceId);
+            const team = await sourceIssue.team;
+            if (!team) {
+                throw new Error(`Cannot create blocker: source issue ${sourceId} has no team`);
+            }
+            teamId = team.id;
+        }
+        // Find the Icebox state
+        const statuses = await this.client.getTeamStatuses(teamId);
+        const iceboxStateId = statuses['Icebox'];
+        // Find the "Needs Human" label
+        const allLabels = await this.client.linearClient.issueLabels();
+        const needsHumanLabel = allLabels.nodes.find((l) => l.name.toLowerCase() === 'needs human');
+        const issue = await this.client.createIssue({
+            title: data.title,
+            description: data.description,
+            teamId,
+            projectId: data.projectId,
+            ...(iceboxStateId && { stateId: iceboxStateId }),
+            ...(needsHumanLabel && { labelIds: [needsHumanLabel.id] }),
+        });
+        // Create blocking relation: blocker blocks source issue
+        await this.client.createIssueRelation({
+            issueId: issue.id,
+            relatedIssueId: sourceId,
+            type: 'blocks',
+        });
+        return toAbstractIssue(issue);
+    }
+    /**
+     * Create a new issue and return it as AbstractIssue.
+     */
+    async createIssue(data) {
+        // Resolve status name to state ID if provided
+        let stateId;
+        if (data.status && data.teamId) {
+            const nativeStatus = this.resolveStatus(data.status);
+            const statuses = await this.client.getTeamStatuses(data.teamId);
+            stateId = statuses[nativeStatus];
+        }
+        const issue = await this.client.createIssue({
+            title: data.title,
+            teamId: data.teamId,
+            description: data.description,
+            projectId: data.projectId,
+            stateId,
+            parentId: data.parentId,
+            priority: data.priority,
+        });
+        return toAbstractIssue(issue);
+    }
+    // ---- Agent session operations ----
+    /**
+     * Create an agent session on an issue.
+     * Returns the session ID.
+     */
+    async createAgentSession(issueId, externalUrls) {
+        const result = await this.client.createAgentSessionOnIssue({
+            issueId,
+            externalUrls,
+        });
+        if (!result.sessionId) {
+            throw new Error(`Failed to create agent session on issue: ${issueId}`);
+        }
+        return result.sessionId;
+    }
+    /**
+     * Update an existing agent session.
+     */
+    async updateAgentSession(sessionId, data) {
+        await this.client.updateAgentSession({
+            sessionId,
+            externalUrls: data.externalUrls,
+            plan: data.plan,
+        });
+    }
+    /**
+     * Create an activity on an agent session.
+     * Wraps the content as a ThoughtActivityContent.
+     */
+    async createActivity(sessionId, type, content) {
+        const activityContent = {
+            type: 'thought',
+            body: content,
+        };
+        await this.client.createAgentActivity({
+            agentSessionId: sessionId,
+            content: activityContent,
+        });
+    }
+}

package/dist/src/frontend-adapter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=frontend-adapter.test.d.ts.map

package/dist/src/frontend-adapter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontend-adapter.test.d.ts","sourceRoot":"","sources":["../../src/frontend-adapter.test.ts"],"names":[],"mappings":""}