@ship-cli/core 0.0.2 → 0.1.0

package/src/adapters/driven/linear/IssueRepositoryLive.ts

@@ -1,499 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Schedule from "effect/Schedule";
-import * as Duration from "effect/Duration";
-import { LinearDocument, type Issue, type WorkflowState, type IssueRelation } from "@linear/sdk";
-import { IssueRepository } from "../../../ports/IssueRepository.js";
-import { LinearClientService } from "./LinearClient.js";
-import {
-  Task,
-  TaskId,
-  TeamId,
-  CreateTaskInput,
-  UpdateTaskInput,
-  TaskFilter,
-  type ProjectId,
-} from "../../../domain/Task.js";
-import { LinearApiError, TaskError, TaskNotFoundError } from "../../../domain/Errors.js";
-import { mapIssueToTask, priorityToLinear, statusToLinearStateType } from "./Mapper.js";
-
-// Retry policy: exponential backoff with max 3 retries
-const retryPolicy = Schedule.intersect(
-  Schedule.exponential(Duration.millis(100)),
-  Schedule.recurs(3),
-);
-
-// Timeout for API calls: 30 seconds
-const API_TIMEOUT = Duration.seconds(30);
-
-const withRetryAndTimeout = <A, E>(
-  effect: Effect.Effect<A, E>,
-  operation: string,
-): Effect.Effect<A, E | LinearApiError> =>
-  effect.pipe(
-    Effect.timeoutFail({
-      duration: API_TIMEOUT,
-      onTimeout: () => new LinearApiError({ message: `${operation} timed out after 30 seconds` }),
-    }),
-    Effect.retry(retryPolicy),
-  );
-
-const make = Effect.gen(function* () {
-  const linearClient = yield* LinearClientService;
-
-  const getTask = (id: TaskId): Effect.Effect<Task, TaskNotFoundError | LinearApiError> =>
-    withRetryAndTimeout(
-      Effect.gen(function* () {
-        const client = yield* linearClient.client();
-        const issue = yield* Effect.tryPromise({
-          try: () => client.issue(id),
-          catch: (e) => new LinearApiError({ message: `Failed to fetch issue: ${e}`, cause: e }),
-        });
-        if (!issue) {
-          return yield* Effect.fail(new TaskNotFoundError({ taskId: id }));
-        }
-        return yield* Effect.tryPromise({
-          try: () => mapIssueToTask(issue),
-          catch: (e) => new LinearApiError({ message: `Failed to map issue: ${e}`, cause: e }),
-        });
-      }),
-      "Fetching task",
-    );
-
-  const getTaskByIdentifier = (
-    identifier: string,
-  ): Effect.Effect<Task, TaskNotFoundError | LinearApiError> =>
-    withRetryAndTimeout(
-      Effect.gen(function* () {
-        const client = yield* linearClient.client();
-
-        // Validate identifier format (e.g., "BRI-123")
-        const match = identifier.match(/^([A-Z]+)-(\d+)$/i);
-        if (!match) {
-          return yield* Effect.fail(new TaskNotFoundError({ taskId: identifier }));
-        }
-        const [, teamKey, numberStr] = match;
-        const number = parseInt(numberStr, 10);
-
-        const issues = yield* Effect.tryPromise({
-          try: () =>
-            client.issues({
-              filter: {
-                number: { eq: number },
-                team: { key: { eq: teamKey.toUpperCase() } },
-              },
-            }),
-          catch: (e) => new LinearApiError({ message: `Failed to search issues: ${e}`, cause: e }),
-        });
-
-        const issue = issues.nodes[0];
-        if (!issue) {
-          return yield* Effect.fail(new TaskNotFoundError({ taskId: identifier }));
-        }
-
-        return yield* Effect.tryPromise({
-          try: () => mapIssueToTask(issue),
-          catch: (e) => new LinearApiError({ message: `Failed to map issue: ${e}`, cause: e }),
-        });
-      }),
-      "Fetching task by identifier",
-    );
-
-  const createTask = (
-    teamId: TeamId,
-    input: CreateTaskInput,
-  ): Effect.Effect<Task, TaskError | LinearApiError> =>
-    withRetryAndTimeout(
-      Effect.gen(function* () {
-        const client = yield* linearClient.client();
-
-        const createInput: Parameters<typeof client.createIssue>[0] = {
-          teamId,
-          title: input.title,
-          priority: priorityToLinear(input.priority),
-        };
-
-        if (Option.isSome(input.description)) {
-          createInput.description = input.description.value;
-        }
-
-        if (Option.isSome(input.projectId)) {
-          createInput.projectId = input.projectId.value;
-        }
-
-        const issuePayload = yield* Effect.tryPromise({
-          try: () => client.createIssue(createInput),
-          catch: (e) => new LinearApiError({ message: `Failed to create issue: ${e}`, cause: e }),
-        });
-
-        if (!issuePayload.success) {
-          return yield* Effect.fail(new TaskError({ message: "Failed to create issue" }));
-        }
-
-        const issue = yield* Effect.tryPromise({
-          try: async () => {
-            const i = await issuePayload.issue;
-            if (!i) throw new Error("Issue not returned");
-            return i;
-          },
-          catch: (e) =>
-            new LinearApiError({ message: `Failed to get created issue: ${e}`, cause: e }),
-        });
-
-        return yield* Effect.tryPromise({
-          try: () => mapIssueToTask(issue),
-          catch: (e) => new LinearApiError({ message: `Failed to map issue: ${e}`, cause: e }),
-        });
-      }),
-      "Creating task",
-    );
-
-  const updateTask = (
-    id: TaskId,
-    input: UpdateTaskInput,
-  ): Effect.Effect<Task, TaskNotFoundError | TaskError | LinearApiError> =>
-    withRetryAndTimeout(
-      Effect.gen(function* () {
-        const client = yield* linearClient.client();
-
-        const updatePayload: Record<string, unknown> = {};
-
-        if (Option.isSome(input.title)) {
-          updatePayload.title = input.title.value;
-        }
-
-        if (Option.isSome(input.description)) {
-          updatePayload.description = input.description.value;
-        }
-
-        if (Option.isSome(input.priority)) {
-          updatePayload.priority = priorityToLinear(input.priority.value);
-        }
-
-        if (Option.isSome(input.status)) {
-          const issue = yield* Effect.tryPromise({
-            try: () => client.issue(id),
-            catch: (e) => new LinearApiError({ message: `Failed to fetch issue: ${e}`, cause: e }),
-          });
-
-          if (!issue) {
-            return yield* Effect.fail(new TaskNotFoundError({ taskId: id }));
-          }
-
-          const teamFetch = issue.team;
-          if (!teamFetch) {
-            return yield* Effect.fail(new TaskError({ message: "Issue has no team" }));
-          }
-
-          const team = yield* Effect.tryPromise({
-            try: () => teamFetch,
-            catch: (e) => new LinearApiError({ message: `Failed to fetch team: ${e}`, cause: e }),
-          });
-
-          const states = yield* Effect.tryPromise({
-            try: () => team.states(),
-            catch: (e) => new LinearApiError({ message: `Failed to fetch states: ${e}`, cause: e }),
-          });
-
-          const targetStateType = statusToLinearStateType(input.status.value);
-          const targetState = states.nodes.find((s: WorkflowState) => s.type === targetStateType);
-
-          if (targetState) {
-            updatePayload.stateId = targetState.id;
-          }
-        }
-
-        const result = yield* Effect.tryPromise({
-          try: () => client.updateIssue(id, updatePayload),
-          catch: (e) => new LinearApiError({ message: `Failed to update issue: ${e}`, cause: e }),
-        });
-
-        if (!result.success) {
-          return yield* Effect.fail(new TaskError({ message: "Failed to update issue" }));
-        }
-
-        const updatedIssue = yield* Effect.tryPromise({
-          try: async () => {
-            const i = await result.issue;
-            if (!i) throw new Error("Issue not returned");
-            return i;
-          },
-          catch: (e) =>
-            new LinearApiError({ message: `Failed to get updated issue: ${e}`, cause: e }),
-        });
-
-        return yield* Effect.tryPromise({
-          try: () => mapIssueToTask(updatedIssue),
-          catch: (e) => new LinearApiError({ message: `Failed to map issue: ${e}`, cause: e }),
-        });
-      }),
-      "Updating task",
-    );
-
-  const listTasks = (
-    teamId: TeamId,
-    filter: TaskFilter,
-  ): Effect.Effect<ReadonlyArray<Task>, LinearApiError> =>
-    withRetryAndTimeout(
-      Effect.gen(function* () {
-        const client = yield* linearClient.client();
-
-        const linearFilter: Record<string, unknown> = {
-          team: { id: { eq: teamId } },
-        };
-
-        if (Option.isSome(filter.status)) {
-          const stateType = statusToLinearStateType(filter.status.value);
-          linearFilter.state = { type: { eq: stateType } };
-        }
-
-        if (Option.isSome(filter.priority)) {
-          linearFilter.priority = { eq: priorityToLinear(filter.priority.value) };
-        }
-
-        if (Option.isSome(filter.projectId)) {
-          linearFilter.project = { id: { eq: filter.projectId.value } };
-        }
-
-        if (filter.assignedToMe) {
-          const viewer = yield* Effect.tryPromise({
-            try: () => client.viewer,
-            catch: (e) => new LinearApiError({ message: `Failed to fetch viewer: ${e}`, cause: e }),
-          });
-          linearFilter.assignee = { id: { eq: viewer.id } };
-        }
-
-        const issues = yield* Effect.tryPromise({
-          try: () => client.issues({ filter: linearFilter }),
-          catch: (e) => new LinearApiError({ message: `Failed to fetch issues: ${e}`, cause: e }),
-        });
-
-        return yield* Effect.all(
-          issues.nodes.map((issue: Issue) =>
-            Effect.tryPromise({
-              try: () => mapIssueToTask(issue),
-              catch: (e) => new LinearApiError({ message: `Failed to map issue: ${e}`, cause: e }),
-            }),
-          ),
-        );
-      }),
-      "Listing tasks",
-    );
-
-  const getReadyTasks = (
-    teamId: TeamId,
-    projectId?: ProjectId,
-  ): Effect.Effect<ReadonlyArray<Task>, LinearApiError> =>
-    withRetryAndTimeout(
-      Effect.gen(function* () {
-        const client = yield* linearClient.client();
-
-        const filter: Record<string, unknown> = {
-          team: { id: { eq: teamId } },
-          state: { type: { in: ["backlog", "unstarted"] } },
-        };
-
-        if (projectId) {
-          filter.project = { id: { eq: projectId } };
-        }
-
-        const issues = yield* Effect.tryPromise({
-          try: () => client.issues({ filter }),
-          catch: (e) => new LinearApiError({ message: `Failed to fetch issues: ${e}`, cause: e }),
-        });
-
-        const tasks = yield* Effect.all(
-          issues.nodes.map((issue: Issue) =>
-            Effect.tryPromise({
-              try: async () => {
-                const task = await mapIssueToTask(issue);
-                const relations = await issue.relations();
-                const blockedByRelations = relations?.nodes?.filter(
-                  (r: IssueRelation) => r.type === "blocks",
-                );
-                if (blockedByRelations && blockedByRelations.length > 0) {
-                  return null;
-                }
-                return task;
-              },
-              catch: (e) => new LinearApiError({ message: `Failed to map issue: ${e}`, cause: e }),
-            }),
-          ),
-        );
-
-        return tasks.filter((t): t is Task => t !== null);
-      }),
-      "Fetching ready tasks",
-    );
-
-  const getBlockedTasks = (
-    teamId: TeamId,
-    projectId?: ProjectId,
-  ): Effect.Effect<ReadonlyArray<Task>, LinearApiError> =>
-    withRetryAndTimeout(
-      Effect.gen(function* () {
-        const client = yield* linearClient.client();
-
-        const filter: Record<string, unknown> = {
-          team: { id: { eq: teamId } },
-          state: { type: { in: ["backlog", "unstarted", "started"] } },
-        };
-
-        if (projectId) {
-          filter.project = { id: { eq: projectId } };
-        }
-
-        const issues = yield* Effect.tryPromise({
-          try: () => client.issues({ filter }),
-          catch: (e) => new LinearApiError({ message: `Failed to fetch issues: ${e}`, cause: e }),
-        });
-
-        const tasks = yield* Effect.all(
-          issues.nodes.map((issue: Issue) =>
-            Effect.tryPromise({
-              try: async () => {
-                const relations = await issue.relations();
-                const blockedByRelations = relations?.nodes?.filter(
-                  (r: IssueRelation) => r.type === "blocks",
-                );
-                if (!blockedByRelations || blockedByRelations.length === 0) {
-                  return null;
-                }
-                return mapIssueToTask(issue);
-              },
-              catch: (e) =>
-                new LinearApiError({ message: `Failed to process issue: ${e}`, cause: e }),
-            }),
-          ),
-        );
-
-        return tasks.filter((t): t is Task => t !== null);
-      }),
-      "Fetching blocked tasks",
-    );
-
-  const addBlocker = (
-    blockedId: TaskId,
-    blockerId: TaskId,
-  ): Effect.Effect<void, TaskNotFoundError | TaskError | LinearApiError> =>
-    withRetryAndTimeout(
-      Effect.gen(function* () {
-        const client = yield* linearClient.client();
-
-        const result = yield* Effect.tryPromise({
-          try: () =>
-            client.createIssueRelation({
-              issueId: blockedId,
-              relatedIssueId: blockerId,
-              type: LinearDocument.IssueRelationType.Blocks,
-            }),
-          catch: (e) =>
-            new LinearApiError({ message: `Failed to create relation: ${e}`, cause: e }),
-        });
-
-        if (!result.success) {
-          return yield* Effect.fail(
-            new TaskError({ message: "Failed to create blocking relation" }),
-          );
-        }
-      }),
-      "Adding blocker",
-    );
-
-  const removeBlocker = (
-    blockedId: TaskId,
-    blockerId: TaskId,
-  ): Effect.Effect<void, TaskNotFoundError | TaskError | LinearApiError> =>
-    withRetryAndTimeout(
-      Effect.gen(function* () {
-        const client = yield* linearClient.client();
-
-        const blocked = yield* Effect.tryPromise({
-          try: () => client.issue(blockedId),
-          catch: (e) => new LinearApiError({ message: `Failed to fetch issue: ${e}`, cause: e }),
-        });
-
-        if (!blocked) {
-          return yield* Effect.fail(new TaskNotFoundError({ taskId: blockedId }));
-        }
-
-        const relations = yield* Effect.tryPromise({
-          try: () => blocked.relations(),
-          catch: (e) =>
-            new LinearApiError({ message: `Failed to fetch relations: ${e}`, cause: e }),
-        });
-
-        const relationToDelete = yield* Effect.tryPromise({
-          try: async () => {
-            for (const r of relations?.nodes ?? []) {
-              if (r.type === "blocks") {
-                const relatedIssue = await (r as IssueRelation & { relatedIssue: Promise<Issue> })
-                  .relatedIssue;
-                if (relatedIssue?.id === blockerId) {
-                  return r;
-                }
-              }
-            }
-            return undefined;
-          },
-          catch: (e) => new LinearApiError({ message: `Failed to find relation: ${e}`, cause: e }),
-        });
-
-        if (!relationToDelete) {
-          return;
-        }
-
-        yield* Effect.tryPromise({
-          try: () => client.deleteIssueRelation(relationToDelete.id),
-          catch: (e) =>
-            new LinearApiError({ message: `Failed to delete relation: ${e}`, cause: e }),
-        });
-      }),
-      "Removing blocker",
-    );
-
-  const getBranchName = (id: TaskId): Effect.Effect<string, TaskNotFoundError | LinearApiError> =>
-    withRetryAndTimeout(
-      Effect.gen(function* () {
-        const client = yield* linearClient.client();
-
-        const issue = yield* Effect.tryPromise({
-          try: () => client.issue(id),
-          catch: (e) => new LinearApiError({ message: `Failed to fetch issue: ${e}`, cause: e }),
-        });
-
-        if (!issue) {
-          return yield* Effect.fail(new TaskNotFoundError({ taskId: id }));
-        }
-
-        if (issue.branchName) {
-          return issue.branchName;
-        }
-
-        const slug = issue.title
-          .toLowerCase()
-          .replace(/[^a-z0-9]+/g, "-")
-          .replace(/^-|-$/g, "")
-          .slice(0, 50);
-
-        return `${issue.identifier.toLowerCase()}-${slug}`;
-      }),
-      "Getting branch name",
-    );
-
-  return {
-    getTask,
-    getTaskByIdentifier,
-    createTask,
-    updateTask,
-    listTasks,
-    getReadyTasks,
-    getBlockedTasks,
-    addBlocker,
-    removeBlocker,
-    getBranchName,
-  };
-});
-
-export const IssueRepositoryLive = Layer.effect(IssueRepository, make);

package/src/adapters/driven/linear/LinearClient.ts

@@ -1,33 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Context from "effect/Context";
-import * as Layer from "effect/Layer";
-import { LinearClient as LinearSDK } from "@linear/sdk";
-import { AuthService } from "../../../ports/AuthService.js";
-import { LinearApiError } from "../../../domain/Errors.js";
-
-export interface LinearClientService {
-  readonly client: () => Effect.Effect<LinearSDK, LinearApiError>;
-}
-
-export const LinearClientService = Context.GenericTag<LinearClientService>("LinearClientService");
-
-const make = Effect.gen(function* () {
-  const auth = yield* AuthService;
-
-  const client = (): Effect.Effect<LinearSDK, LinearApiError> =>
-    Effect.gen(function* () {
-      const apiKey = yield* auth
-        .getApiKey()
-        .pipe(
-          Effect.mapError(
-            (e) => new LinearApiError({ message: `Authentication required: ${e.message}` }),
-          ),
-        );
-
-      return new LinearSDK({ apiKey });
-    });
-
-  return { client };
-});
-
-export const LinearClientLive = Layer.effect(LinearClientService, make);

package/src/adapters/driven/linear/Mapper.ts

@@ -1,142 +0,0 @@
-import * as Option from "effect/Option";
-import type {
-  Issue,
-  Team as LinearTeam,
-  Project as LinearProject,
-  WorkflowState as LinearWorkflowState,
-} from "@linear/sdk";
-import {
-  Task,
-  TaskId,
-  Priority,
-  Team,
-  TeamId,
-  Project,
-  ProjectId,
-  WorkflowState,
-  WorkflowStateType,
-  type TaskStatus,
-} from "../../../domain/Task.js";
-
-// Map Linear state type to our WorkflowStateType
-const mapStateType = (stateType: string): WorkflowStateType => {
-  switch (stateType) {
-    case "backlog":
-      return "backlog";
-    case "unstarted":
-      return "unstarted";
-    case "started":
-      return "started";
-    case "completed":
-      return "completed";
-    case "canceled":
-      return "canceled";
-    default:
-      return "unstarted"; // Safe default
-  }
-};
-
-// Map Linear WorkflowState to our WorkflowState
-const mapWorkflowState = (state: LinearWorkflowState | undefined): WorkflowState => {
-  return new WorkflowState({
-    id: state?.id ?? "",
-    name: state?.name ?? "Unknown",
-    type: mapStateType(state?.type ?? "unstarted"),
-  });
-};
-
-// Map our TaskStatus to Linear state type for filtering/updating
-export const statusToLinearStateType = (status: TaskStatus): WorkflowStateType => {
-  switch (status) {
-    case "backlog":
-      return "backlog";
-    case "todo":
-      return "unstarted";
-    case "in_progress":
-    case "in_review":
-      return "started";
-    case "done":
-      return "completed";
-    case "cancelled":
-      return "canceled";
-  }
-};
-
-// Map Linear priority (0-4, where 0 = no priority, 1 = urgent, 4 = low)
-const mapPriority = (priority: number): Priority => {
-  switch (priority) {
-    case 0:
-      return "none";
-    case 1:
-      return "urgent";
-    case 2:
-      return "high";
-    case 3:
-      return "medium";
-    case 4:
-      return "low";
-    default:
-      return "none";
-  }
-};
-
-// Map our Priority to Linear priority number
-export const priorityToLinear = (priority: Priority): number => {
-  switch (priority) {
-    case "urgent":
-      return 1;
-    case "high":
-      return 2;
-    case "medium":
-      return 3;
-    case "low":
-      return 4;
-    case "none":
-      return 0;
-  }
-};
-
-export const mapIssueToTask = async (issue: Issue): Promise<Task> => {
-  // Fetch related data
-  const state = await issue.state;
-  const labels = await issue.labels();
-  const team = await issue.team;
-
-  // Get blocking relations
-  // Note: Linear SDK doesn't directly expose relations, we'll handle this in the repository
-  const blockedBy: TaskId[] = [];
-  const blocks: TaskId[] = [];
-
-  return new Task({
-    id: issue.id as TaskId,
-    identifier: issue.identifier,
-    title: issue.title,
-    description: issue.description ? Option.some(issue.description) : Option.none(),
-    state: mapWorkflowState(state),
-    priority: mapPriority(issue.priority),
-    type: Option.none(), // Linear doesn't have issue types in the same way
-    teamId: (team?.id ?? "") as TeamId,
-    projectId: Option.none(), // Will be populated if needed
-    branchName: issue.branchName ? Option.some(issue.branchName) : Option.none(),
-    url: issue.url,
-    labels: labels?.nodes?.map((l) => l.name) ?? [],
-    blockedBy,
-    blocks,
-    createdAt: issue.createdAt,
-    updatedAt: issue.updatedAt,
-  });
-};
-
-export const mapTeam = (team: LinearTeam): Team =>
-  new Team({
-    id: team.id as TeamId,
-    name: team.name,
-    key: team.key,
-  });
-
-export const mapProject = (project: LinearProject, teamId: string): Project =>
-  new Project({
-    id: project.id as ProjectId,
-    name: project.name,
-    teamId: teamId as TeamId,
-  });