@ship-cli/core 0.0.1

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

@@ -0,0 +1,98 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schedule from "effect/Schedule";
+import * as Duration from "effect/Duration";
+import { ProjectRepository, type CreateProjectInput } from "../../../ports/ProjectRepository.js";
+import { LinearClientService } from "./LinearClient.js";
+import { Project, type TeamId } from "../../../domain/Task.js";
+import { LinearApiError, TaskError } from "../../../domain/Errors.js";
+import { mapProject } 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 getProjects = (teamId: TeamId): Effect.Effect<ReadonlyArray<Project>, LinearApiError> =>
+    withRetryAndTimeout(
+      Effect.gen(function* () {
+        const client = yield* linearClient.client();
+        const team = yield* Effect.tryPromise({
+          try: () => client.team(teamId),
+          catch: (e) => new LinearApiError({ message: `Failed to fetch team: ${e}`, cause: e }),
+        });
+        const projects = yield* Effect.tryPromise({
+          try: () => team.projects(),
+          catch: (e) => new LinearApiError({ message: `Failed to fetch projects: ${e}`, cause: e }),
+        });
+        return projects.nodes.map((p) => mapProject(p, teamId));
+      }),
+      "Fetching projects",
+    );
+
+  const createProject = (
+    teamId: TeamId,
+    input: CreateProjectInput,
+  ): Effect.Effect<Project, TaskError | LinearApiError> =>
+    withRetryAndTimeout(
+      Effect.gen(function* () {
+        const client = yield* linearClient.client();
+
+        const createInput: { name: string; description?: string; teamIds: string[] } = {
+          name: input.name,
+          teamIds: [teamId],
+        };
+        if (input.description) {
+          createInput.description = input.description;
+        }
+
+        const result = yield* Effect.tryPromise({
+          try: () => client.createProject(createInput),
+          catch: (e) => new LinearApiError({ message: `Failed to create project: ${e}`, cause: e }),
+        });
+
+        if (!result.success) {
+          return yield* Effect.fail(new TaskError({ message: "Failed to create project" }));
+        }
+
+        const project = yield* Effect.tryPromise({
+          try: async () => {
+            const p = await result.project;
+            if (!p) throw new Error("Project not returned");
+            return p;
+          },
+          catch: (e) =>
+            new LinearApiError({ message: `Failed to get created project: ${e}`, cause: e }),
+        });
+
+        return mapProject(project, teamId);
+      }),
+      "Creating project",
+    );
+
+  return {
+    getProjects,
+    createProject,
+  };
+});
+
+export const ProjectRepositoryLive = Layer.effect(ProjectRepository, make);

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

@@ -0,0 +1,100 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schedule from "effect/Schedule";
+import * as Duration from "effect/Duration";
+import { TeamRepository, type CreateTeamInput } from "../../../ports/TeamRepository.js";
+import { LinearClientService } from "./LinearClient.js";
+import { Team, type TeamId } from "../../../domain/Task.js";
+import { LinearApiError, TaskError } from "../../../domain/Errors.js";
+import { mapTeam } 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 getTeams = (): Effect.Effect<ReadonlyArray<Team>, LinearApiError> =>
+    withRetryAndTimeout(
+      Effect.gen(function* () {
+        const client = yield* linearClient.client();
+        const teams = yield* Effect.tryPromise({
+          try: () => client.teams(),
+          catch: (e) => new LinearApiError({ message: `Failed to fetch teams: ${e}`, cause: e }),
+        });
+        return teams.nodes.map(mapTeam);
+      }),
+      "Fetching teams",
+    );
+
+  const getTeam = (id: TeamId): Effect.Effect<Team, LinearApiError> =>
+    withRetryAndTimeout(
+      Effect.gen(function* () {
+        const client = yield* linearClient.client();
+        const team = yield* Effect.tryPromise({
+          try: () => client.team(id),
+          catch: (e) => new LinearApiError({ message: `Failed to fetch team: ${e}`, cause: e }),
+        });
+        return mapTeam(team);
+      }),
+      "Fetching team",
+    );
+
+  const createTeam = (input: CreateTeamInput): Effect.Effect<Team, TaskError | LinearApiError> =>
+    withRetryAndTimeout(
+      Effect.gen(function* () {
+        const client = yield* linearClient.client();
+
+        const result = yield* Effect.tryPromise({
+          try: () =>
+            client.createTeam({
+              name: input.name,
+              key: input.key,
+            }),
+          catch: (e) => new LinearApiError({ message: `Failed to create team: ${e}`, cause: e }),
+        });
+
+        if (!result.success) {
+          return yield* Effect.fail(new TaskError({ message: "Failed to create team" }));
+        }
+
+        const team = yield* Effect.tryPromise({
+          try: async () => {
+            const t = await result.team;
+            if (!t) throw new Error("Team not returned");
+            return t;
+          },
+          catch: (e) => new LinearApiError({ message: `Failed to get created team: ${e}`, cause: e }),
+        });
+
+        return mapTeam(team);
+      }),
+      "Creating team",
+    );
+
+  return {
+    getTeams,
+    getTeam,
+    createTeam,
+  };
+});
+
+export const TeamRepositoryLive = Layer.effect(TeamRepository, make);

package/src/adapters/driving/cli/commands/block.ts

@@ -0,0 +1,63 @@
+import * as Command from "@effect/cli/Command";
+import * as Args from "@effect/cli/Args";
+import * as Options from "@effect/cli/Options";
+import * as Effect from "effect/Effect";
+import * as Console from "effect/Console";
+import { ConfigRepository } from "../../../../ports/ConfigRepository.js";
+import { IssueRepository } from "../../../../ports/IssueRepository.js";
+import type { TaskId } from "../../../../domain/Task.js";
+
+const blockerArg = Args.text({ name: "blocker" }).pipe(
+  Args.withDescription("Task that is blocking (e.g., ENG-123)"),
+);
+
+const blockedArg = Args.text({ name: "blocked" }).pipe(
+  Args.withDescription("Task that is blocked (e.g., ENG-456)"),
+);
+
+const jsonOption = Options.boolean("json").pipe(
+  Options.withDescription("Output as JSON"),
+  Options.withDefault(false),
+);
+
+export const blockCommand = Command.make(
+  "block",
+  { blocker: blockerArg, blocked: blockedArg, json: jsonOption },
+  ({ blocker, blocked, json }) =>
+    Effect.gen(function* () {
+      const config = yield* ConfigRepository;
+      const issueRepo = yield* IssueRepository;
+
+      yield* config.load(); // Ensure initialized
+
+      // Get both tasks to get their IDs
+      const blockerTask = yield* issueRepo
+        .getTaskByIdentifier(blocker)
+        .pipe(Effect.catchTag("TaskNotFoundError", () => issueRepo.getTask(blocker as TaskId)));
+
+      const blockedTask = yield* issueRepo
+        .getTaskByIdentifier(blocked)
+        .pipe(Effect.catchTag("TaskNotFoundError", () => issueRepo.getTask(blocked as TaskId)));
+
+      // Add the blocking relationship
+      yield* issueRepo.addBlocker(blockedTask.id, blockerTask.id);
+
+      if (json) {
+        yield* Console.log(
+          JSON.stringify({
+            status: "blocked",
+            blocker: {
+              id: blockerTask.id,
+              identifier: blockerTask.identifier,
+            },
+            blocked: {
+              id: blockedTask.id,
+              identifier: blockedTask.identifier,
+            },
+          }),
+        );
+      } else {
+        yield* Console.log(`${blockerTask.identifier} now blocks ${blockedTask.identifier}`);
+      }
+    }),
+);

package/src/adapters/driving/cli/commands/blocked.ts

@@ -0,0 +1,61 @@
+import * as Command from "@effect/cli/Command";
+import * as Options from "@effect/cli/Options";
+import * as Effect from "effect/Effect";
+import * as Console from "effect/Console";
+import * as Option from "effect/Option";
+import { ConfigRepository } from "../../../../ports/ConfigRepository.js";
+import { IssueRepository } from "../../../../ports/IssueRepository.js";
+import type { Task } from "../../../../domain/Task.js";
+
+const jsonOption = Options.boolean("json").pipe(
+  Options.withDescription("Output as JSON"),
+  Options.withDefault(false),
+);
+
+const formatBlockedTask = (task: Task): string[] => {
+  const lines: string[] = [];
+  lines.push(`${task.identifier}: ${task.title}`);
+  lines.push(`  Status: ${task.state.name}`);
+  lines.push(`  Priority: ${task.priority}`);
+  if (task.blockedBy.length > 0) {
+    lines.push(`  Blocked by: ${task.blockedBy.join(", ")}`);
+  }
+  return lines;
+};
+
+export const blockedCommand = Command.make("blocked", { json: jsonOption }, ({ json }) =>
+  Effect.gen(function* () {
+    const config = yield* ConfigRepository;
+    const issueRepo = yield* IssueRepository;
+
+    const cfg = yield* config.load();
+    const projectId = Option.getOrUndefined(cfg.linear.projectId);
+    const blockedTasks = yield* issueRepo.getBlockedTasks(cfg.linear.teamId, projectId);
+
+    if (json) {
+      const output = blockedTasks.map((t) => ({
+        id: t.id,
+        identifier: t.identifier,
+        title: t.title,
+        priority: t.priority,
+        state: t.state.name,
+        stateType: t.state.type,
+        blockedBy: t.blockedBy,
+        url: t.url,
+      }));
+      yield* Console.log(JSON.stringify(output, null, 2));
+    } else {
+      if (blockedTasks.length === 0) {
+        yield* Console.log("No blocked tasks found.");
+      } else {
+        yield* Console.log(`Found ${blockedTasks.length} blocked task(s):\n`);
+        for (const task of blockedTasks) {
+          for (const line of formatBlockedTask(task)) {
+            yield* Console.log(line);
+          }
+          yield* Console.log("");
+        }
+      }
+    }
+  }),
+);

package/src/adapters/driving/cli/commands/create.ts

@@ -0,0 +1,83 @@
+import * as Command from "@effect/cli/Command";
+import * as Args from "@effect/cli/Args";
+import * as Options from "@effect/cli/Options";
+import * as Effect from "effect/Effect";
+import * as Console from "effect/Console";
+import * as Option from "effect/Option";
+import { ConfigRepository } from "../../../../ports/ConfigRepository.js";
+import { IssueRepository } from "../../../../ports/IssueRepository.js";
+import { CreateTaskInput, Priority, TaskType } from "../../../../domain/Task.js";
+
+const titleArg = Args.text({ name: "title" }).pipe(Args.withDescription("Task title"));
+
+const descriptionOption = Options.text("description").pipe(
+  Options.withAlias("d"),
+  Options.withDescription("Task description"),
+  Options.optional,
+);
+
+const priorityOption = Options.choice("priority", ["urgent", "high", "medium", "low", "none"]).pipe(
+  Options.withAlias("p"),
+  Options.withDescription("Task priority"),
+  Options.withDefault("medium" as const),
+);
+
+const typeOption = Options.choice("type", ["bug", "feature", "task", "epic", "chore"]).pipe(
+  Options.withAlias("t"),
+  Options.withDescription("Task type"),
+  Options.withDefault("task" as const),
+);
+
+const jsonOption = Options.boolean("json").pipe(
+  Options.withDescription("Output as JSON"),
+  Options.withDefault(false),
+);
+
+export const createCommand = Command.make(
+  "create",
+  {
+    title: titleArg,
+    description: descriptionOption,
+    priority: priorityOption,
+    type: typeOption,
+    json: jsonOption,
+  },
+  ({ title, description, priority, type, json }) =>
+    Effect.gen(function* () {
+      const config = yield* ConfigRepository;
+      const issueRepo = yield* IssueRepository;
+
+      const cfg = yield* config.load();
+
+      const input = new CreateTaskInput({
+        title,
+        description: Option.isSome(description) ? Option.some(description.value) : Option.none(),
+        priority: priority as Priority,
+        type: type as TaskType,
+        projectId: cfg.linear.projectId,
+      });
+
+      const task = yield* issueRepo.createTask(cfg.linear.teamId, input);
+
+      if (json) {
+        yield* Console.log(
+          JSON.stringify({
+            status: "created",
+            task: {
+              id: task.id,
+              identifier: task.identifier,
+              title: task.title,
+              priority: task.priority,
+              state: task.state.name,
+              url: task.url,
+            },
+          }),
+        );
+      } else {
+        yield* Console.log(`Created: ${task.identifier} - ${task.title}`);
+        yield* Console.log(`Priority: ${task.priority}`);
+        yield* Console.log(`URL: ${task.url}`);
+        yield* Console.log(`\nRun 'ship start ${task.identifier}' to begin work.`);
+      }
+    }),
+);

package/src/adapters/driving/cli/commands/done.ts

@@ -0,0 +1,82 @@
+import * as Command from "@effect/cli/Command";
+import * as Args from "@effect/cli/Args";
+import * as Options from "@effect/cli/Options";
+import * as Effect from "effect/Effect";
+import * as Console from "effect/Console";
+import * as Option from "effect/Option";
+import { ConfigRepository } from "../../../../ports/ConfigRepository.js";
+import { IssueRepository } from "../../../../ports/IssueRepository.js";
+import { UpdateTaskInput, type TaskId } from "../../../../domain/Task.js";
+
+const taskIdArg = Args.text({ name: "task-id" }).pipe(
+  Args.withDescription("Task identifier (e.g., ENG-123)"),
+);
+
+const reasonOption = Options.text("reason").pipe(
+  Options.withAlias("r"),
+  Options.withDescription("Reason or summary of completion"),
+  Options.optional,
+);
+
+const jsonOption = Options.boolean("json").pipe(
+  Options.withDescription("Output as JSON"),
+  Options.withDefault(false),
+);
+
+export const doneCommand = Command.make(
+  "done",
+  { taskId: taskIdArg, reason: reasonOption, json: jsonOption },
+  ({ taskId, reason, json }) =>
+    Effect.gen(function* () {
+      const config = yield* ConfigRepository;
+      const issueRepo = yield* IssueRepository;
+
+      yield* config.load(); // Ensure initialized
+
+      // Get the task
+      const task = yield* issueRepo
+        .getTaskByIdentifier(taskId)
+        .pipe(Effect.catchTag("TaskNotFoundError", () => issueRepo.getTask(taskId as TaskId)));
+
+      // Check if already done (Linear's "completed" or "canceled" state type)
+      if (task.isDone) {
+        if (json) {
+          yield* Console.log(JSON.stringify({ status: "already_done", task: taskId }));
+        } else {
+          yield* Console.log(`Task ${task.identifier} is already done (${task.state.name}).`);
+        }
+        return;
+      }
+
+      // Update status to done
+      const updateInput = new UpdateTaskInput({
+        title: Option.none(),
+        description: Option.none(),
+        status: Option.some("done"),
+        priority: Option.none(),
+      });
+
+      const updatedTask = yield* issueRepo.updateTask(task.id, updateInput);
+
+      if (json) {
+        yield* Console.log(
+          JSON.stringify({
+            status: "completed",
+            task: {
+              id: updatedTask.id,
+              identifier: updatedTask.identifier,
+              title: updatedTask.title,
+              state: updatedTask.state.name,
+            },
+            reason: Option.getOrNull(reason),
+          }),
+        );
+      } else {
+        yield* Console.log(`Completed: ${updatedTask.identifier} - ${updatedTask.title}`);
+        if (Option.isSome(reason)) {
+          yield* Console.log(`Reason: ${reason.value}`);
+        }
+        yield* Console.log(`\nRun 'ship ready' to see the next available task.`);
+      }
+    }),
+);

package/src/adapters/driving/cli/commands/init.ts

@@ -0,0 +1,194 @@
+import * as Command from "@effect/cli/Command";
+import * as Options from "@effect/cli/Options";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as clack from "@clack/prompts";
+import { ConfigRepository } from "../../../../ports/ConfigRepository.js";
+import { AuthService } from "../../../../ports/AuthService.js";
+import { TeamRepository } from "../../../../ports/TeamRepository.js";
+import { ProjectRepository } from "../../../../ports/ProjectRepository.js";
+import { LinearConfig } from "../../../../domain/Config.js";
+import type { Team, Project } from "../../../../domain/Task.js";
+
+const teamOption = Options.text("team").pipe(
+  Options.withAlias("t"),
+  Options.withDescription("Team ID or key to use"),
+  Options.optional,
+);
+
+const projectOption = Options.text("project").pipe(
+  Options.withAlias("p"),
+  Options.withDescription("Project ID or name to use"),
+  Options.optional,
+);
+
+export const initCommand = Command.make(
+  "init",
+  { team: teamOption, project: projectOption },
+  ({ team, project }) =>
+    Effect.gen(function* () {
+      const config = yield* ConfigRepository;
+      const auth = yield* AuthService;
+      const teamRepo = yield* TeamRepository;
+      const projectRepo = yield* ProjectRepository;
+
+      clack.intro("ship init");
+
+      // Check if already initialized
+      const exists = yield* config.exists();
+      if (exists) {
+        const partial = yield* config.loadPartial();
+        if (Option.isSome(partial.auth) && Option.isSome(partial.linear)) {
+          clack.note(
+            `Team: ${partial.linear.value.teamKey}${Option.isSome(partial.linear.value.projectId) ? `\nProject: ${partial.linear.value.projectId.value}` : ""}`,
+            "Already initialized",
+          );
+          clack.outro("Run 'ship ready' to see available tasks.");
+          return;
+        }
+      }
+
+      // Step 1: Authenticate if needed
+      const isAuth = yield* auth.isAuthenticated();
+      if (!isAuth) {
+        clack.note(
+          "Create a personal API key at:\nhttps://linear.app/settings/api",
+          "Linear Authentication",
+        );
+
+        const apiKey = yield* Effect.tryPromise({
+          try: () =>
+            clack.text({
+              message: "Paste your API key",
+              placeholder: "lin_api_...",
+              validate: (value) => {
+                if (!value) return "API key is required";
+                if (!value.startsWith("lin_api_")) return "API key should start with lin_api_";
+              },
+            }),
+          catch: () => new Error("Prompt cancelled"),
+        });
+
+        if (clack.isCancel(apiKey)) {
+          clack.cancel("Setup cancelled");
+          return;
+        }
+
+        const spinner = clack.spinner();
+        spinner.start("Validating API key...");
+
+        yield* auth
+          .saveApiKey(apiKey as string)
+          .pipe(Effect.tapError(() => Effect.sync(() => spinner.stop("Invalid API key"))));
+
+        spinner.stop("Authenticated");
+      } else {
+        clack.log.success("Already authenticated");
+      }
+
+      // Step 2: Get teams
+      const teamSpinner = clack.spinner();
+      teamSpinner.start("Fetching teams...");
+      const teams = yield* teamRepo.getTeams();
+      teamSpinner.stop("Teams loaded");
+
+      if (teams.length === 0) {
+        clack.log.error("No teams found. Please create a team in Linear first.");
+        clack.outro("Setup incomplete");
+        return;
+      }
+
+      // Select team
+      let selectedTeam: Team;
+      if (Option.isSome(team)) {
+        const found = teams.find((t) => t.id === team.value || t.key === team.value);
+        if (!found) {
+          clack.log.error(`Team '${team.value}' not found.`);
+          clack.note(teams.map((t) => `${t.key} - ${t.name}`).join("\n"), "Available teams");
+          clack.outro("Setup incomplete");
+          return;
+        }
+        selectedTeam = found;
+        clack.log.success(`Using team: ${selectedTeam.key}`);
+      } else if (teams.length === 1) {
+        selectedTeam = teams[0]!;
+        clack.log.success(`Using team: ${selectedTeam.key} - ${selectedTeam.name}`);
+      } else {
+        const teamChoice = yield* Effect.tryPromise({
+          try: () =>
+            clack.select({
+              message: "Select a team",
+              options: teams.map((t) => ({
+                value: t.id,
+                label: `${t.key} - ${t.name}`,
+              })),
+            }),
+          catch: () => new Error("Prompt cancelled"),
+        });
+
+        if (clack.isCancel(teamChoice)) {
+          clack.cancel("Setup cancelled");
+          return;
+        }
+
+        selectedTeam = teams.find((t) => t.id === teamChoice)!;
+      }
+
+      // Step 3: Get projects (optional)
+      const projectSpinner = clack.spinner();
+      projectSpinner.start("Fetching projects...");
+      const projects = yield* projectRepo.getProjects(selectedTeam.id);
+      projectSpinner.stop("Projects loaded");
+
+      let selectedProject: Project | undefined;
+      if (Option.isSome(project)) {
+        selectedProject = projects.find((p) => p.id === project.value || p.name === project.value);
+        if (!selectedProject) {
+          clack.log.warn(
+            `Project '${project.value}' not found, continuing without project filter.`,
+          );
+        }
+      } else if (projects.length > 0) {
+        const projectChoice = yield* Effect.tryPromise({
+          try: () =>
+            clack.select({
+              message: "Select a project (optional)",
+              options: [
+                { value: null, label: "No project filter" },
+                ...projects.map((p) => ({
+                  value: p.id,
+                  label: p.name,
+                })),
+              ],
+            }),
+          catch: () => new Error("Prompt cancelled"),
+        });
+
+        if (clack.isCancel(projectChoice)) {
+          clack.cancel("Setup cancelled");
+          return;
+        }
+
+        if (projectChoice) {
+          selectedProject = projects.find((p) => p.id === projectChoice);
+        }
+      }
+
+      // Step 4: Save config and update .gitignore
+      const linearConfig = new LinearConfig({
+        teamId: selectedTeam.id,
+        teamKey: selectedTeam.key,
+        projectId: selectedProject ? Option.some(selectedProject.id) : Option.none(),
+      });
+
+      yield* config.saveLinear(linearConfig);
+      yield* config.ensureGitignore();
+
+      clack.note(
+        `Team: ${selectedTeam.key} - ${selectedTeam.name}${selectedProject ? `\nProject: ${selectedProject.name}` : ""}`,
+        "Workspace initialized",
+      );
+
+      clack.outro("Run 'ship ready' to see available tasks.");
+    }),
+);