@ship-cli/core 0.0.2 → 0.1.0

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

@@ -1,135 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,12 +0,0 @@
-#!/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

@@ -1,42 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

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

package/src/infrastructure/Layers.ts

@@ -1,45 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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");