@ship-cli/core 0.0.1

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

@@ -0,0 +1,134 @@
+import * as Command from "@effect/cli/Command";
+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 { LinearConfig } from "../../../../domain/Config.js";
+import type { Team, TeamId } from "../../../../domain/Task.js";
+
+const CREATE_NEW = "__create_new__" as const;
+
+export const teamCommand = Command.make("team", {}, () =>
+  Effect.gen(function* () {
+    const config = yield* ConfigRepository;
+    const auth = yield* AuthService;
+    const teamRepo = yield* TeamRepository;
+
+    clack.intro("ship team");
+
+    // Check authentication
+    const isAuth = yield* auth.isAuthenticated();
+    if (!isAuth) {
+      clack.log.error("Not authenticated. Run 'ship login' first.");
+      clack.outro("Setup required");
+      return;
+    }
+
+    // Show current team
+    const partial = yield* config.loadPartial();
+    if (Option.isSome(partial.linear)) {
+      clack.log.info(`Current team: ${partial.linear.value.teamKey}`);
+    }
+
+    // Fetch teams
+    const spinner = clack.spinner();
+    spinner.start("Fetching teams...");
+    const teams = yield* teamRepo.getTeams();
+    spinner.stop("Teams loaded");
+
+    // Select team or create new
+    const currentTeamId = Option.isSome(partial.linear) ? partial.linear.value.teamId : null;
+    const teamOptions: Array<{ value: TeamId | typeof CREATE_NEW; label: string; hint?: string }> = [
+      ...teams.map((t) =>
+        currentTeamId === t.id
+          ? { value: t.id, label: `${t.key} - ${t.name}`, hint: "current" as const }
+          : { value: t.id, label: `${t.key} - ${t.name}` },
+      ),
+      { value: CREATE_NEW, label: "Create new team..." },
+    ];
+
+    const teamChoice = yield* Effect.tryPromise({
+      try: () =>
+        clack.select({
+          message: "Select a team",
+          options: teamOptions,
+        }),
+      catch: () => new Error("Prompt cancelled"),
+    });
+
+    if (clack.isCancel(teamChoice)) {
+      clack.cancel("Cancelled");
+      return;
+    }
+
+    let selectedTeam: Team;
+
+    if (teamChoice === CREATE_NEW) {
+      // Create new team
+      const teamName = yield* Effect.tryPromise({
+        try: () =>
+          clack.text({
+            message: "Team name",
+            placeholder: "My Team",
+            validate: (v) => (!v ? "Name is required" : undefined),
+          }),
+        catch: () => new Error("Prompt cancelled"),
+      });
+
+      if (clack.isCancel(teamName)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+
+      const teamKey = yield* Effect.tryPromise({
+        try: () =>
+          clack.text({
+            message: "Team key (short identifier, e.g. ENG)",
+            placeholder: "ENG",
+            validate: (v) => {
+              if (!v) return "Key is required";
+              if (!/^[A-Z]{2,5}$/.test(v.toUpperCase())) return "Key must be 2-5 uppercase letters";
+            },
+          }),
+        catch: () => new Error("Prompt cancelled"),
+      });
+
+      if (clack.isCancel(teamKey)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+
+      const createSpinner = clack.spinner();
+      createSpinner.start("Creating team...");
+
+      selectedTeam = yield* teamRepo.createTeam({
+        name: teamName as string,
+        key: (teamKey as string).toUpperCase(),
+      });
+
+      createSpinner.stop(`Created team: ${selectedTeam.key}`);
+    } else {
+      const found = teams.find((t) => t.id === teamChoice);
+      if (!found) {
+        clack.log.error("Selected team not found. Please try again.");
+        clack.outro("Error");
+        return;
+      }
+      selectedTeam = found;
+    }
+
+    // Save new team config (clears project since it's team-specific)
+    const linearConfig = new LinearConfig({
+      teamId: selectedTeam.id,
+      teamKey: selectedTeam.key,
+      projectId: Option.none(),
+    });
+
+    yield* config.saveLinear(linearConfig);
+
+    clack.log.success(`Switched to team: ${selectedTeam.key} - ${selectedTeam.name}`);
+    clack.outro("Run 'ship project' to select a project.");
+  }),
+);

package/src/adapters/driving/cli/commands/unblock.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 was blocking (e.g., ENG-123)"),
+);
+
+const blockedArg = Args.text({ name: "blocked" }).pipe(
+  Args.withDescription("Task that was blocked (e.g., ENG-456)"),
+);
+
+const jsonOption = Options.boolean("json").pipe(
+  Options.withDescription("Output as JSON"),
+  Options.withDefault(false),
+);
+
+export const unblockCommand = Command.make(
+  "unblock",
+  { 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)));
+
+      // Remove the blocking relationship
+      yield* issueRepo.removeBlocker(blockedTask.id, blockerTask.id);
+
+      if (json) {
+        yield* Console.log(
+          JSON.stringify({
+            status: "unblocked",
+            blocker: {
+              id: blockerTask.id,
+              identifier: blockerTask.identifier,
+            },
+            blocked: {
+              id: blockedTask.id,
+              identifier: blockedTask.identifier,
+            },
+          }),
+        );
+      } else {
+        yield* Console.log(`${blockerTask.identifier} no longer blocks ${blockedTask.identifier}`);
+      }
+    }),
+);

package/src/adapters/driving/cli/main.ts

@@ -0,0 +1,70 @@
+import * as Command from "@effect/cli/Command";
+import * as Console from "effect/Console";
+import { initCommand } from "./commands/init.js";
+import { loginCommand } from "./commands/login.js";
+import { teamCommand } from "./commands/team.js";
+import { projectCommand } from "./commands/project.js";
+import { readyCommand } from "./commands/ready.js";
+import { listCommand } from "./commands/list.js";
+import { showCommand } from "./commands/show.js";
+import { startCommand } from "./commands/start.js";
+import { doneCommand } from "./commands/done.js";
+import { createCommand } from "./commands/create.js";
+import { blockCommand } from "./commands/block.js";
+import { unblockCommand } from "./commands/unblock.js";
+import { blockedCommand } from "./commands/blocked.js";
+import { primeCommand } from "./commands/prime.js";
+
+// Root command
+const ship = Command.make("ship", {}, () =>
+  Console.log(`ship - Linear + jj workflow CLI
+
+Usage: ship <command> [options]
+
+Commands:
+  init              Initialize workspace and authenticate
+  login             Re-authenticate with Linear
+  team              Switch team
+  project           Switch project
+  
+  ready             List tasks ready to work on (no blockers)
+  blocked           List blocked tasks
+  list              List all tasks with filters
+  show <id>         Show task details
+  create <title>    Create new task
+  
+  start <id>        Start working on a task
+  done <id>         Mark task as complete
+  
+  block <a> <b>     Mark task A as blocking task B
+  unblock <a> <b>   Remove blocking relationship
+  
+  prime             Output AI-optimized context
+
+Run 'ship <command> --help' for more information on a command.`),
+);
+
+// Combine all commands
+export const command = ship.pipe(
+  Command.withSubcommands([
+    initCommand,
+    loginCommand,
+    teamCommand,
+    projectCommand,
+    readyCommand,
+    listCommand,
+    showCommand,
+    startCommand,
+    doneCommand,
+    createCommand,
+    blockCommand,
+    unblockCommand,
+    blockedCommand,
+    primeCommand,
+  ]),
+);
+
+export const run = Command.run(command, {
+  name: "ship",
+  version: "0.0.1",
+});

package/src/bin.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as Effect from "effect/Effect";
+import { run } from "./adapters/driving/cli/main.js";
+import { AppLayer } from "./infrastructure/Layers.js";
+
+// Run the CLI
+run(process.argv).pipe(
+  Effect.provide(AppLayer),
+  NodeRuntime.runMain({ disableErrorReporting: false }),
+);

package/src/domain/Config.ts

@@ -0,0 +1,42 @@
+import * as Schema from "effect/Schema";
+import { ProjectId, TeamId } from "./Task.js";
+
+// Personal API key from https://linear.app/settings/api
+export class AuthConfig extends Schema.Class<AuthConfig>("AuthConfig")({
+  apiKey: Schema.String,
+}) {}
+
+export class LinearConfig extends Schema.Class<LinearConfig>("LinearConfig")({
+  teamId: TeamId,
+  teamKey: Schema.String,
+  projectId: Schema.OptionFromNullOr(ProjectId),
+}) {}
+
+export class GitConfig extends Schema.Class<GitConfig>("GitConfig")({
+  defaultBranch: Schema.optionalWith(Schema.String, { default: () => "main" }),
+}) {}
+
+export class PrConfig extends Schema.Class<PrConfig>("PrConfig")({
+  openBrowser: Schema.optionalWith(Schema.Boolean, { default: () => true }),
+}) {}
+
+export class CommitConfig extends Schema.Class<CommitConfig>("CommitConfig")({
+  conventionalFormat: Schema.optionalWith(Schema.Boolean, { default: () => true }),
+}) {}
+
+export class ShipConfig extends Schema.Class<ShipConfig>("ShipConfig")({
+  linear: LinearConfig,
+  auth: AuthConfig,
+  git: Schema.optionalWith(GitConfig, { default: () => new GitConfig({}) }),
+  pr: Schema.optionalWith(PrConfig, { default: () => new PrConfig({}) }),
+  commit: Schema.optionalWith(CommitConfig, { default: () => new CommitConfig({}) }),
+}) {}
+
+// Partial config for when we're initializing
+export class PartialShipConfig extends Schema.Class<PartialShipConfig>("PartialShipConfig")({
+  linear: Schema.OptionFromNullOr(LinearConfig),
+  auth: Schema.OptionFromNullOr(AuthConfig),
+  git: Schema.optionalWith(GitConfig, { default: () => new GitConfig({}) }),
+  pr: Schema.optionalWith(PrConfig, { default: () => new PrConfig({}) }),
+  commit: Schema.optionalWith(CommitConfig, { default: () => new CommitConfig({}) }),
+}) {}

package/src/domain/Errors.ts

@@ -0,0 +1,89 @@
+import * as Data from "effect/Data";
+
+// === Task Errors ===
+
+export class TaskNotFoundError extends Data.TaggedError("TaskNotFoundError")<{
+  readonly taskId: string;
+}> {
+  get message() {
+    return `Task not found: ${this.taskId}`;
+  }
+}
+
+export class TaskError extends Data.TaggedError("TaskError")<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+
+// === Auth Errors ===
+
+export class AuthError extends Data.TaggedError("AuthError")<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+
+export class NotAuthenticatedError extends Data.TaggedError("NotAuthenticatedError")<{
+  readonly message: string;
+}> {}
+
+// === Config Errors ===
+
+export class ConfigError extends Data.TaggedError("ConfigError")<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+
+export class ConfigNotFoundError extends Data.TaggedError("ConfigNotFoundError")<{
+  readonly message: string;
+}> {}
+
+export class WorkspaceNotInitializedError extends Data.TaggedError("WorkspaceNotInitializedError")<{
+  readonly message: string;
+}> {
+  static readonly default = new WorkspaceNotInitializedError({
+    message: "Workspace not initialized. Run 'ship init' first.",
+  });
+}
+
+// === VCS Errors ===
+
+export class VcsError extends Data.TaggedError("VcsError")<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+
+export class JjNotInstalledError extends Data.TaggedError("JjNotInstalledError")<{
+  readonly message: string;
+}> {
+  static readonly default = new JjNotInstalledError({
+    message: "jj is not installed. Visit https://jj-vcs.github.io/jj/",
+  });
+}
+
+// === PR Errors ===
+
+export class PrError extends Data.TaggedError("PrError")<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+
+export class GhNotInstalledError extends Data.TaggedError("GhNotInstalledError")<{
+  readonly message: string;
+}> {
+  static readonly default = new GhNotInstalledError({
+    message: "gh CLI is not installed. Visit https://cli.github.com/",
+  });
+}
+
+// === Linear API Errors ===
+
+export class LinearApiError extends Data.TaggedError("LinearApiError")<{
+  readonly message: string;
+  readonly statusCode?: number;
+  readonly cause?: unknown;
+}> {}
+
+export class RateLimitError extends Data.TaggedError("RateLimitError")<{
+  readonly message: string;
+  readonly retryAfter?: number;
+}> {}

package/src/domain/Task.ts

@@ -0,0 +1,124 @@
+import * as Schema from "effect/Schema";
+
+// === Branded Types ===
+
+export const TaskId = Schema.String.pipe(Schema.brand("TaskId"));
+export type TaskId = typeof TaskId.Type;
+
+export const TeamId = Schema.String.pipe(Schema.brand("TeamId"));
+export type TeamId = typeof TeamId.Type;
+
+export const ProjectId = Schema.String.pipe(Schema.brand("ProjectId"));
+export type ProjectId = typeof ProjectId.Type;
+
+// === Enums ===
+
+// Linear's workflow state types (not custom state names)
+export const WorkflowStateType = Schema.Literal(
+  "backlog",
+  "unstarted",
+  "started",
+  "completed",
+  "canceled",
+);
+export type WorkflowStateType = typeof WorkflowStateType.Type;
+
+// For backwards compatibility - maps to Linear state types
+export const TaskStatus = Schema.Literal(
+  "backlog",
+  "todo",
+  "in_progress",
+  "in_review",
+  "done",
+  "cancelled",
+);
+export type TaskStatus = typeof TaskStatus.Type;
+
+export const Priority = Schema.Literal("urgent", "high", "medium", "low", "none");
+export type Priority = typeof Priority.Type;
+
+export const TaskType = Schema.Literal("bug", "feature", "task", "epic", "chore");
+export type TaskType = typeof TaskType.Type;
+
+export const DependencyType = Schema.Literal("blocks", "blocked_by", "related", "duplicate");
+export type DependencyType = typeof DependencyType.Type;
+
+// === Domain Models ===
+
+export class Dependency extends Schema.Class<Dependency>("Dependency")({
+  id: Schema.String,
+  type: DependencyType,
+  relatedTaskId: TaskId,
+}) {}
+
+// Workflow state from Linear (custom states)
+export class WorkflowState extends Schema.Class<WorkflowState>("WorkflowState")({
+  id: Schema.String,
+  name: Schema.String,
+  type: WorkflowStateType,
+}) {}
+
+export class Task extends Schema.Class<Task>("Task")({
+  id: TaskId,
+  identifier: Schema.String, // e.g., "ENG-123"
+  title: Schema.String,
+  description: Schema.OptionFromNullOr(Schema.String),
+  state: WorkflowState, // The actual Linear state (custom or default)
+  priority: Priority,
+  type: Schema.OptionFromNullOr(TaskType),
+  teamId: TeamId,
+  projectId: Schema.OptionFromNullOr(ProjectId),
+  branchName: Schema.OptionFromNullOr(Schema.String),
+  url: Schema.String,
+  labels: Schema.Array(Schema.String),
+  blockedBy: Schema.Array(TaskId),
+  blocks: Schema.Array(TaskId),
+  createdAt: Schema.Date,
+  updatedAt: Schema.Date,
+}) {
+  // Helper to check if task is in a "done" state (completed or canceled)
+  get isDone(): boolean {
+    return this.state.type === "completed" || this.state.type === "canceled";
+  }
+
+  // Helper to check if task is actionable (not done)
+  get isActionable(): boolean {
+    return !this.isDone;
+  }
+}
+
+export class Team extends Schema.Class<Team>("Team")({
+  id: TeamId,
+  name: Schema.String,
+  key: Schema.String, // e.g., "ENG"
+}) {}
+
+export class Project extends Schema.Class<Project>("Project")({
+  id: ProjectId,
+  name: Schema.String,
+  teamId: TeamId,
+}) {}
+
+// === Input Types ===
+
+export class CreateTaskInput extends Schema.Class<CreateTaskInput>("CreateTaskInput")({
+  title: Schema.String,
+  description: Schema.OptionFromNullOr(Schema.String),
+  priority: Schema.optionalWith(Priority, { default: () => "medium" as const }),
+  type: Schema.optionalWith(TaskType, { default: () => "task" as const }),
+  projectId: Schema.OptionFromNullOr(ProjectId),
+}) {}
+
+export class UpdateTaskInput extends Schema.Class<UpdateTaskInput>("UpdateTaskInput")({
+  title: Schema.OptionFromNullOr(Schema.String),
+  description: Schema.OptionFromNullOr(Schema.String),
+  status: Schema.OptionFromNullOr(TaskStatus),
+  priority: Schema.OptionFromNullOr(Priority),
+}) {}
+
+export class TaskFilter extends Schema.Class<TaskFilter>("TaskFilter")({
+  status: Schema.OptionFromNullOr(TaskStatus),
+  priority: Schema.OptionFromNullOr(Priority),
+  projectId: Schema.OptionFromNullOr(ProjectId),
+  assignedToMe: Schema.optionalWith(Schema.Boolean, { default: () => false }),
+}) {}

package/src/domain/index.ts

@@ -0,0 +1,3 @@
+export * from "./Task.js";
+export * from "./Errors.js";
+export * from "./Config.js";

package/src/infrastructure/Layers.ts

@@ -0,0 +1,45 @@
+import * as Layer from "effect/Layer";
+import * as NodeContext from "@effect/platform-node/NodeContext";
+import { ConfigRepositoryLive } from "../adapters/driven/config/ConfigRepositoryLive.js";
+import { AuthServiceLive } from "../adapters/driven/auth/AuthServiceLive.js";
+import { LinearClientLive } from "../adapters/driven/linear/LinearClient.js";
+import { TeamRepositoryLive } from "../adapters/driven/linear/TeamRepositoryLive.js";
+import { ProjectRepositoryLive } from "../adapters/driven/linear/ProjectRepositoryLive.js";
+import { IssueRepositoryLive } from "../adapters/driven/linear/IssueRepositoryLive.js";
+
+// Layer dependencies:
+// ConfigRepositoryLive: FileSystem + Path -> ConfigRepository
+// AuthServiceLive: ConfigRepository -> AuthService
+// LinearClientLive: AuthService -> LinearClientService
+// TeamRepositoryLive: LinearClientService -> TeamRepository
+// ProjectRepositoryLive: LinearClientService -> ProjectRepository
+// IssueRepositoryLive: LinearClientService -> IssueRepository
+
+// Build the layer chain - each layer provides what the next needs
+// ConfigRepository provides what AuthService needs
+const ConfigAndAuth = AuthServiceLive.pipe(Layer.provideMerge(ConfigRepositoryLive));
+
+// AuthService provides what LinearClient needs
+const ConfigAuthAndLinear = LinearClientLive.pipe(Layer.provideMerge(ConfigAndAuth));
+
+// LinearClientService provides what repositories need
+// Merge all three repository layers together
+const RepositoryLayers = Layer.mergeAll(
+  TeamRepositoryLive,
+  ProjectRepositoryLive,
+  IssueRepositoryLive,
+);
+
+const AllServices = RepositoryLayers.pipe(Layer.provideMerge(ConfigAuthAndLinear));
+
+// Full application layer for Phase 1 (Linear + Config + Auth)
+// Use provideMerge to:
+// 1. Satisfy platform deps (FileSystem, Path) that ConfigRepositoryLive needs
+// 2. Keep platform services (FileSystem, Path, Terminal) in output for @effect/cli
+export const AppLayer = AllServices.pipe(Layer.provideMerge(NodeContext.layer));
+
+// Minimal layer for init/login commands (before full config exists)
+// Also includes TeamRepository and ProjectRepository for init flow
+const MinimalRepositories = Layer.mergeAll(TeamRepositoryLive, ProjectRepositoryLive);
+const MinimalServices = MinimalRepositories.pipe(Layer.provideMerge(ConfigAuthAndLinear));
+export const MinimalLayer = MinimalServices.pipe(Layer.provideMerge(NodeContext.layer));

package/src/ports/AuthService.ts

@@ -0,0 +1,19 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type { AuthConfig } from "../domain/Config.js";
+import type { AuthError, ConfigError, NotAuthenticatedError } from "../domain/Errors.js";
+
+export interface AuthService {
+  /** Save API key after user pastes it */
+  readonly saveApiKey: (apiKey: string) => Effect.Effect<AuthConfig, AuthError>;
+  /** Validate an API key by making a test request */
+  readonly validateApiKey: (apiKey: string) => Effect.Effect<boolean, AuthError>;
+  /** Get the stored API key - may fail if config is corrupted */
+  readonly getApiKey: () => Effect.Effect<string, NotAuthenticatedError | ConfigError>;
+  /** Remove stored credentials */
+  readonly logout: () => Effect.Effect<void, never>;
+  /** Check if we have stored credentials */
+  readonly isAuthenticated: () => Effect.Effect<boolean, never>;
+}
+
+export const AuthService = Context.GenericTag<AuthService>("AuthService");

package/src/ports/ConfigRepository.ts

@@ -0,0 +1,20 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type { AuthConfig, LinearConfig, PartialShipConfig, ShipConfig } from "../domain/Config.js";
+import type { ConfigError, WorkspaceNotInitializedError } from "../domain/Errors.js";
+
+export interface ConfigRepository {
+  readonly load: () => Effect.Effect<ShipConfig, WorkspaceNotInitializedError | ConfigError>;
+  readonly loadPartial: () => Effect.Effect<PartialShipConfig, ConfigError>;
+  readonly save: (config: ShipConfig) => Effect.Effect<void, ConfigError>;
+  readonly savePartial: (config: PartialShipConfig) => Effect.Effect<void, ConfigError>;
+  readonly saveAuth: (auth: AuthConfig) => Effect.Effect<void, ConfigError>;
+  readonly saveLinear: (linear: LinearConfig) => Effect.Effect<void, ConfigError>;
+  readonly exists: () => Effect.Effect<boolean, ConfigError>;
+  readonly getConfigDir: () => Effect.Effect<string, never>;
+  readonly ensureConfigDir: () => Effect.Effect<void, ConfigError>;
+  readonly ensureGitignore: () => Effect.Effect<void, ConfigError>;
+  readonly delete: () => Effect.Effect<void, ConfigError>;
+}
+
+export const ConfigRepository = Context.GenericTag<ConfigRepository>("ConfigRepository");