@ship-cli/core 0.0.1

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

@@ -0,0 +1,87 @@
+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 { TaskFilter, type TaskStatus, type Priority, type Task } from "../../../../domain/Task.js";
+
+const jsonOption = Options.boolean("json").pipe(
+  Options.withDescription("Output as JSON"),
+  Options.withDefault(false),
+);
+
+const statusOption = Options.choice("status", [
+  "backlog",
+  "todo",
+  "in_progress",
+  "in_review",
+  "done",
+  "cancelled",
+]).pipe(Options.withAlias("s"), Options.withDescription("Filter by status"), Options.optional);
+
+const priorityOption = Options.choice("priority", ["urgent", "high", "medium", "low", "none"]).pipe(
+  Options.withAlias("P"),
+  Options.withDescription("Filter by priority"),
+  Options.optional,
+);
+
+const mineOption = Options.boolean("mine").pipe(
+  Options.withAlias("m"),
+  Options.withDescription("Show only tasks assigned to me"),
+  Options.withDefault(false),
+);
+
+const formatTask = (task: Task): string => {
+  const priority = task.priority === "urgent" ? "[!]" : task.priority === "high" ? "[^]" : "   ";
+  const stateName = task.state.name.padEnd(11);
+  return `${priority} ${task.identifier.padEnd(10)} ${stateName} ${task.title}`;
+};
+
+export const listCommand = Command.make(
+  "list",
+  { json: jsonOption, status: statusOption, priority: priorityOption, mine: mineOption },
+  ({ json, status, priority, mine }) =>
+    Effect.gen(function* () {
+      const config = yield* ConfigRepository;
+      const issueRepo = yield* IssueRepository;
+
+      const cfg = yield* config.load();
+
+      const filter = new TaskFilter({
+        status: Option.isSome(status) ? Option.some(status.value as TaskStatus) : Option.none(),
+        priority: Option.isSome(priority) ? Option.some(priority.value as Priority) : Option.none(),
+        projectId: cfg.linear.projectId,
+        assignedToMe: mine,
+      });
+
+      const taskList = yield* issueRepo.listTasks(cfg.linear.teamId, filter);
+
+      if (json) {
+        const output = taskList.map((t) => ({
+          id: t.id,
+          identifier: t.identifier,
+          title: t.title,
+          priority: t.priority,
+          state: t.state.name,
+          stateType: t.state.type,
+          labels: t.labels,
+          url: t.url,
+          branchName: Option.getOrNull(t.branchName),
+        }));
+        yield* Console.log(JSON.stringify(output, null, 2));
+      } else {
+        if (taskList.length === 0) {
+          yield* Console.log("No tasks found matching the filter.");
+        } else {
+          yield* Console.log(`Found ${taskList.length} task(s):\n`);
+          yield* Console.log("PRI IDENTIFIER  STATUS      TITLE");
+          yield* Console.log("─".repeat(60));
+          for (const task of taskList) {
+            yield* Console.log(formatTask(task));
+          }
+        }
+      }
+    }),
+);

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

@@ -0,0 +1,46 @@
+import * as Command from "@effect/cli/Command";
+import * as Effect from "effect/Effect";
+import * as clack from "@clack/prompts";
+import { AuthService } from "../../../../ports/AuthService.js";
+
+export const loginCommand = Command.make("login", {}, () =>
+  Effect.gen(function* () {
+    const auth = yield* AuthService;
+
+    clack.intro("ship login");
+
+    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("Login 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("API key validated");
+
+    clack.outro("Run 'ship init' to select your team and project.");
+  }),
+);

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

@@ -0,0 +1,114 @@
+import * as Command from "@effect/cli/Command";
+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 { TaskFilter, type Task } from "../../../../domain/Task.js";
+
+const AGENT_GUIDANCE = `## Agent Restrictions
+
+1. **Never create issues without user confirmation**
+2. **Check blockers before starting work** - blocked tasks should be surfaced
+3. **Small, focused tasks only** - if a task seems too large, suggest splitting
+4. **Always update status** - in_progress when starting, done when complete
+5. **Stack blocking tasks** - work on blockers first, stack changes appropriately
+6. **Use conventional commits** - format: type(TASK-ID): description
+
+## CLI Commands
+
+- \`ship ready --json\` - List tasks with no blockers
+- \`ship show <id> --json\` - Show task details
+- \`ship start <id>\` - Begin work (sets status to in_progress)
+- \`ship done <id> --reason "msg"\` - Complete task
+- \`ship blocked --json\` - Show blocked tasks
+- \`ship block <blocker> <blocked>\` - Create blocking relationship
+- \`ship unblock <blocker> <blocked>\` - Remove blocking relationship
+- \`ship list --json\` - List all tasks
+- \`ship create "title" -p priority -t type\` - Create new task
+
+Always use \`--json\` flag for programmatic output.`;
+
+const formatTaskCompact = (task: Task): string => {
+  const priority = task.priority === "urgent" ? "!" : task.priority === "high" ? "^" : "";
+  return `${priority}${task.identifier}: ${task.title} [${task.state.name}]`;
+};
+
+export const primeCommand = Command.make("prime", {}, () =>
+  Effect.gen(function* () {
+    const config = yield* ConfigRepository;
+    const issueRepo = yield* IssueRepository;
+
+    const cfg = yield* config.load();
+    const projectId = Option.getOrUndefined(cfg.linear.projectId);
+
+    // Get ready and blocked tasks
+    const [readyTasks, blockedTasks] = yield* Effect.all([
+      issueRepo.getReadyTasks(cfg.linear.teamId, projectId),
+      issueRepo.getBlockedTasks(cfg.linear.teamId, projectId),
+    ]);
+
+    // Get in-progress tasks (filter by "started" state type)
+    const filter = new TaskFilter({
+      status: Option.some("in_progress"),
+      priority: Option.none(),
+      projectId: cfg.linear.projectId,
+      assignedToMe: false,
+    });
+    const allTasks = yield* issueRepo.listTasks(cfg.linear.teamId, filter);
+
+    // Filter to only "started" state type tasks
+    const inProgressTasks = allTasks.filter((t: Task) => t.state.type === "started");
+
+    // Build context output
+    const lines: string[] = [];
+
+    lines.push("<ship-context>");
+    lines.push(`Team: ${cfg.linear.teamKey}`);
+    if (Option.isSome(cfg.linear.projectId)) {
+      lines.push(`Project: ${cfg.linear.projectId.value}`);
+    }
+    lines.push("");
+
+    if (inProgressTasks.length > 0) {
+      lines.push("## In Progress");
+      for (const task of inProgressTasks) {
+        lines.push(`- ${formatTaskCompact(task)}`);
+      }
+      lines.push("");
+    }
+
+    if (readyTasks.length > 0) {
+      lines.push("## Ready to Work");
+      for (const task of readyTasks.slice(0, 10)) {
+        lines.push(`- ${formatTaskCompact(task)}`);
+      }
+      if (readyTasks.length > 10) {
+        lines.push(`  ... and ${readyTasks.length - 10} more`);
+      }
+      lines.push("");
+    }
+
+    if (blockedTasks.length > 0) {
+      lines.push("## Blocked");
+      for (const task of blockedTasks.slice(0, 5)) {
+        lines.push(`- ${formatTaskCompact(task)}`);
+        if (task.blockedBy.length > 0) {
+          lines.push(`  Blocked by: ${task.blockedBy.join(", ")}`);
+        }
+      }
+      if (blockedTasks.length > 5) {
+        lines.push(`  ... and ${blockedTasks.length - 5} more`);
+      }
+      lines.push("");
+    }
+
+    lines.push("</ship-context>");
+    lines.push("");
+    lines.push("<ship-guidance>");
+    lines.push(AGENT_GUIDANCE);
+    lines.push("</ship-guidance>");
+
+    yield* Console.log(lines.join("\n"));
+  }),
+);

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

@@ -0,0 +1,155 @@
+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 { ProjectRepository } from "../../../../ports/ProjectRepository.js";
+import { LinearConfig } from "../../../../domain/Config.js";
+import type { Project, ProjectId } from "../../../../domain/Task.js";
+
+const CREATE_NEW = "__create_new__" as const;
+const NO_PROJECT = null;
+
+export const projectCommand = Command.make("project", {}, () =>
+  Effect.gen(function* () {
+    const config = yield* ConfigRepository;
+    const auth = yield* AuthService;
+    const projectRepo = yield* ProjectRepository;
+
+    clack.intro("ship project");
+
+    // Check authentication
+    const isAuth = yield* auth.isAuthenticated();
+    if (!isAuth) {
+      clack.log.error("Not authenticated. Run 'ship login' first.");
+      clack.outro("Setup required");
+      return;
+    }
+
+    // Check team is configured
+    const partial = yield* config.loadPartial();
+    if (Option.isNone(partial.linear)) {
+      clack.log.error("No team configured. Run 'ship init' first.");
+      clack.outro("Setup required");
+      return;
+    }
+
+    const currentConfig = partial.linear.value;
+    clack.log.info(`Team: ${currentConfig.teamKey}`);
+
+    if (Option.isSome(currentConfig.projectId)) {
+      clack.log.info(`Current project: ${currentConfig.projectId.value}`);
+    }
+
+    // Fetch projects
+    const spinner = clack.spinner();
+    spinner.start("Fetching projects...");
+    const projects = yield* projectRepo.getProjects(currentConfig.teamId);
+    spinner.stop("Projects loaded");
+
+    // Select project or create new
+    const currentProjectId = Option.isSome(currentConfig.projectId)
+      ? currentConfig.projectId.value
+      : null;
+
+    const projectOptions: Array<{
+      value: ProjectId | typeof CREATE_NEW | typeof NO_PROJECT;
+      label: string;
+      hint?: string;
+    }> = [
+      { value: NO_PROJECT, label: "No project filter", hint: "show all team tasks" },
+      ...projects.map((p) =>
+        currentProjectId === p.id
+          ? { value: p.id, label: p.name, hint: "current" as const }
+          : { value: p.id, label: p.name },
+      ),
+      { value: CREATE_NEW, label: "Create new project..." },
+    ];
+
+    const projectChoice = yield* Effect.tryPromise({
+      try: () =>
+        clack.select({
+          message: "Select a project",
+          options: projectOptions,
+        }),
+      catch: () => new Error("Prompt cancelled"),
+    });
+
+    if (clack.isCancel(projectChoice)) {
+      clack.cancel("Cancelled");
+      return;
+    }
+
+    let selectedProject: Project | undefined;
+
+    if (projectChoice === CREATE_NEW) {
+      // Create new project
+      const projectName = yield* Effect.tryPromise({
+        try: () =>
+          clack.text({
+            message: "Project name",
+            placeholder: "My Project",
+            validate: (v) => (!v ? "Name is required" : undefined),
+          }),
+        catch: () => new Error("Prompt cancelled"),
+      });
+
+      if (clack.isCancel(projectName)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+
+      const projectDesc = yield* Effect.tryPromise({
+        try: () =>
+          clack.text({
+            message: "Description (optional)",
+            placeholder: "A brief description of the project",
+          }),
+        catch: () => new Error("Prompt cancelled"),
+      });
+
+      if (clack.isCancel(projectDesc)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+
+      const createSpinner = clack.spinner();
+      createSpinner.start("Creating project...");
+
+      const createInput = { name: projectName as string } as { name: string; description?: string };
+      if (projectDesc) {
+        createInput.description = projectDesc as string;
+      }
+
+      selectedProject = yield* projectRepo.createProject(currentConfig.teamId, createInput);
+
+      createSpinner.stop(`Created project: ${selectedProject.name}`);
+    } else if (projectChoice !== NO_PROJECT) {
+      const found = projects.find((p) => p.id === projectChoice);
+      if (!found) {
+        clack.log.error("Selected project not found. Please try again.");
+        clack.outro("Error");
+        return;
+      }
+      selectedProject = found;
+    }
+
+    // Save updated config
+    const linearConfig = new LinearConfig({
+      teamId: currentConfig.teamId,
+      teamKey: currentConfig.teamKey,
+      projectId: selectedProject ? Option.some(selectedProject.id) : Option.none(),
+    });
+
+    yield* config.saveLinear(linearConfig);
+
+    if (selectedProject) {
+      clack.log.success(`Switched to project: ${selectedProject.name}`);
+    } else {
+      clack.log.success("Cleared project filter");
+    }
+
+    clack.outro("Run 'ship ready' to see available tasks.");
+  }),
+);

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

@@ -0,0 +1,73 @@
+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 formatTaskDetailed = (task: Task): string[] => {
+  const lines: string[] = [];
+  const priority =
+    task.priority === "urgent"
+      ? "URGENT"
+      : task.priority === "high"
+        ? "HIGH"
+        : task.priority === "medium"
+          ? "MEDIUM"
+          : task.priority === "low"
+            ? "LOW"
+            : "";
+
+  lines.push(`${task.identifier}: ${task.title}`);
+  if (priority) lines.push(`  Priority: ${priority}`);
+  if (task.labels.length > 0) lines.push(`  Labels: ${task.labels.join(", ")}`);
+  if (Option.isSome(task.branchName)) lines.push(`  Branch: ${task.branchName.value}`);
+  lines.push(`  URL: ${task.url}`);
+  return lines;
+};
+
+export const readyCommand = Command.make("ready", { 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 readyTasks = yield* issueRepo.getReadyTasks(cfg.linear.teamId, projectId);
+
+    if (json) {
+      const output = readyTasks.map((t) => ({
+        id: t.id,
+        identifier: t.identifier,
+        title: t.title,
+        priority: t.priority,
+        state: t.state.name,
+        stateType: t.state.type,
+        labels: t.labels,
+        url: t.url,
+        branchName: Option.getOrNull(t.branchName),
+      }));
+      yield* Console.log(JSON.stringify(output, null, 2));
+    } else {
+      if (readyTasks.length === 0) {
+        yield* Console.log("No ready tasks found.");
+        yield* Console.log("All tasks may be blocked or completed.");
+      } else {
+        yield* Console.log(`Found ${readyTasks.length} ready task(s):\n`);
+        for (const task of readyTasks) {
+          for (const line of formatTaskDetailed(task)) {
+            yield* Console.log(line);
+          }
+          yield* Console.log("");
+        }
+      }
+    }
+  }),
+);

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

@@ -0,0 +1,94 @@
+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 { IssueRepository } from "../../../../ports/IssueRepository.js";
+import type { Task, TaskId } from "../../../../domain/Task.js";
+
+const taskIdArg = Args.text({ name: "task-id" }).pipe(
+  Args.withDescription("Task identifier (e.g., ENG-123)"),
+);
+
+const jsonOption = Options.boolean("json").pipe(
+  Options.withDescription("Output as JSON"),
+  Options.withDefault(false),
+);
+
+const formatTask = (task: Task): string[] => {
+  const lines: string[] = [];
+
+  lines.push(`${task.identifier}: ${task.title}`);
+  lines.push("─".repeat(50));
+  lines.push(`Status:   ${task.state.name}`);
+  lines.push(`Priority: ${task.priority}`);
+
+  if (task.labels.length > 0) {
+    lines.push(`Labels:   ${task.labels.join(", ")}`);
+  }
+
+  if (Option.isSome(task.branchName)) {
+    lines.push(`Branch:   ${task.branchName.value}`);
+  }
+
+  lines.push(`URL:      ${task.url}`);
+
+  if (Option.isSome(task.description)) {
+    lines.push("");
+    lines.push("Description:");
+    lines.push(task.description.value);
+  }
+
+  if (task.blockedBy.length > 0) {
+    lines.push("");
+    lines.push(`Blocked by: ${task.blockedBy.join(", ")}`);
+  }
+
+  if (task.blocks.length > 0) {
+    lines.push(`Blocks: ${task.blocks.join(", ")}`);
+  }
+
+  return lines;
+};
+
+export const showCommand = Command.make(
+  "show",
+  { taskId: taskIdArg, json: jsonOption },
+  ({ taskId, json }) =>
+    Effect.gen(function* () {
+      const issueRepo = yield* IssueRepository;
+
+      // Try to get by identifier first (ENG-123 format)
+      const task = yield* issueRepo.getTaskByIdentifier(taskId).pipe(
+        Effect.catchTag("TaskNotFoundError", () =>
+          // Fallback to ID lookup
+          issueRepo.getTask(taskId as TaskId),
+        ),
+      );
+
+      if (json) {
+        const output = {
+          id: task.id,
+          identifier: task.identifier,
+          title: task.title,
+          description: Option.getOrNull(task.description),
+          priority: task.priority,
+          state: task.state.name,
+          stateType: task.state.type,
+          labels: task.labels,
+          url: task.url,
+          branchName: Option.getOrNull(task.branchName),
+          blockedBy: task.blockedBy,
+          blocks: task.blocks,
+          createdAt: task.createdAt.toISOString(),
+          updatedAt: task.updatedAt.toISOString(),
+        };
+        yield* Console.log(JSON.stringify(output, null, 2));
+      } else {
+        for (const line of formatTask(task)) {
+          yield* Console.log(line);
+        }
+      }
+    }),
+);

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

@@ -0,0 +1,99 @@
+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 jsonOption = Options.boolean("json").pipe(
+  Options.withDescription("Output as JSON"),
+  Options.withDefault(false),
+);
+
+export const startCommand = Command.make(
+  "start",
+  { taskId: taskIdArg, json: jsonOption },
+  ({ taskId, 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 in progress (Linear's "started" state type)
+      if (task.state.type === "started") {
+        if (json) {
+          yield* Console.log(JSON.stringify({ status: "already_in_progress", task: taskId }));
+        } else {
+          yield* Console.log(`Task ${task.identifier} is already in progress (${task.state.name}).`);
+        }
+        return;
+      }
+
+      // Check if blocked
+      if (task.blockedBy.length > 0) {
+        if (json) {
+          yield* Console.log(
+            JSON.stringify({
+              status: "blocked",
+              task: taskId,
+              blockedBy: task.blockedBy,
+            }),
+          );
+        } else {
+          yield* Console.log(
+            `Warning: Task ${task.identifier} is blocked by: ${task.blockedBy.join(", ")}`,
+          );
+          yield* Console.log("Consider working on the blocking tasks first.");
+        }
+        // Continue anyway - user might want to start despite blockers
+      }
+
+      // Update status to in_progress
+      const updateInput = new UpdateTaskInput({
+        title: Option.none(),
+        description: Option.none(),
+        status: Option.some("in_progress"),
+        priority: Option.none(),
+      });
+
+      const updatedTask = yield* issueRepo.updateTask(task.id, updateInput);
+
+      // Get branch name
+      const branchName = yield* issueRepo.getBranchName(task.id);
+
+      if (json) {
+        yield* Console.log(
+          JSON.stringify({
+            status: "started",
+            task: {
+              id: updatedTask.id,
+              identifier: updatedTask.identifier,
+              title: updatedTask.title,
+              state: updatedTask.state.name,
+              branchName,
+            },
+          }),
+        );
+      } else {
+        yield* Console.log(`Started: ${updatedTask.identifier} - ${updatedTask.title}`);
+        yield* Console.log(`Status: ${updatedTask.state.name}`);
+        yield* Console.log(`\nBranch name: ${branchName}`);
+        yield* Console.log("\nTo create a jj change with this branch (Phase 2):");
+        yield* Console.log(`  jj new -m "${updatedTask.identifier}: ${updatedTask.title}"`);
+        yield* Console.log(`  jj bookmark create ${branchName}`);
+      }
+    }),
+);