Issue(IssueArgs),

    /// OpenAgents project management

    Project(ProjectArgs),

    /// Repository milestones

    Milestone(MilestoneArgs),

    /// Repository tracking and operations

    Repo(RepoArgs),

    /// OpenAgents interactive Coder agent session and autonomous tools

        #[arg(short = 'R', long, help = "Repository as owner/repo")]

        repo: Option<String>,

    },

    /// Put an existing issue on a milestone, or take it off one

    ///

    /// `issue create --milestone` was the only way to attach one, so an issue

    /// filed without a milestone could never be given one outside the browser.

    Milestone {

        #[arg(help = "Issue number")]

        number: u64,

        #[arg(long, value_name = "NUMBER", help = "Milestone number to put the issue on")]

        set: Option<u64>,

        #[arg(long, help = "Take the issue off whatever milestone it is on")]

        clear: bool,

        #[arg(short = 'R', long, help = "Repository as owner/repo")]

        repo: Option<String>,

    },

}

#[derive(Args, Debug)]

pub struct MilestoneArgs {

    #[command(subcommand)]

    pub action: MilestoneAction,

}

#[derive(Subcommand, Debug)]

pub enum MilestoneAction {

    /// List the milestones of a repository

    List {

        #[arg(short = 'R', long, help = "Repository as owner/repo")]

        repo: Option<String>,

    },

    /// Open a new milestone

    Create {

        #[arg(help = "Milestone title")]

        title: String,

        #[arg(long, help = "What the milestone is for")]

        description: Option<String>,

        #[arg(long, value_name = "DATE", help = "Due date, as the server stores it")]

        due_on: Option<String>,

        #[arg(short = 'R', long, help = "Repository as owner/repo")]

        repo: Option<String>,

    },

    /// Delete a milestone

    Delete {

        #[arg(help = "Milestone number")]

        number: u64,

        #[arg(short = 'R', long, help = "Repository as owner/repo")]

        repo: Option<String>,

    },

}

#[derive(Args, Debug)]

        Commands::Project(project) => {

            run_project(project.action, &api_base, token, cli.json).await

        }

        Commands::Milestone(milestone) => {

            run_milestone(milestone.action, &api_base, token, cli.json).await

        }

        Commands::Repo(repo) => run_repo(repo.action, &endpoint, &cred_store, cli.json).await,

        Commands::Coder(coder) => {

            // The session talks to the selected endpoint like every other

        IssueAction::Milestones { repo } => {

            let target = target_or_fail(repo);

            let value = or_fail(tracker.list_milestones(&target).await);

            let rows = value

                .get("milestones")

                .and_then(serde_json::Value::as_array)

                .cloned()

                .unwrap_or_default();

            let human: Vec<String> = if rows.is_empty() {

                vec!["No milestones found.".to_string()]

            } else {

                rows.iter()

                    .map(|row| {

                        format!(

                            "{}{}{}",

                            pad(&format!("#{}", number_or_question(row, "number")), 7),

                            pad(&field(row, "state"), 8),

                            field(row, "title")

                        )

                    })

                    .collect()

            emit(json, &value, &milestone_listing(&value));

        }

        IssueAction::Milestone {

            number,

            set,

            clear,

            repo,

        } => {

            // Two ways to say what the milestone should become, and they

            // disagree. Guessing which one was meant is how an issue ends up on

            // a milestone the caller was trying to take it off.

            let milestone = match (set, clear) {

                (Some(_), true) => {

                    fail("Use either --set or --clear, not both.");

                }

                (None, false) => {

                    fail(

                        "Say what the milestone should become: --set <number> to put the issue on one, or --clear to take it off.",

                    );

                }

                (Some(number), false) => Some(number),

                (None, true) => None,

            };

            emit(json, &value, &human);

            let target = target_or_fail(repo);

            let value = or_fail(tracker.set_issue_milestone(&target, number, milestone).await);

            // Report what came BACK, not what was asked for. A server that

            // accepted the request and stored something else is the case a

            // printed echo of the argument would hide.

            let stored = value.get("milestone").and_then(|m| {

                if m.is_null() {

                    None

                } else {

                    Some(m)

                }

            });

            let human = match stored {

                Some(m) => format!(

                    "Issue #{} is on milestone #{} {}",

                    number,

                    number_or_question(m, "number"),

                    field(m, "title")

                ),

                None => format!("Issue #{} is on no milestone.", number),

            };

            emit(json, &value, &[human]);

        }

    }

}

/// The rows `milestone list` and `issue milestones` both print.

///

/// One renderer, so the two entry points cannot describe the same milestone

/// differently.

fn milestone_listing(value: &serde_json::Value) -> Vec<String> {

    let rows = value

        .get("milestones")

        .and_then(serde_json::Value::as_array)

        .cloned()

        .unwrap_or_default();

    if rows.is_empty() {

        return vec!["No milestones found.".to_string()];

    }

    rows.iter()

        .map(|row| {

            format!(

                "{}{}{}",

                pad(&format!("#{}", number_or_question(row, "number")), 7),

                pad(&field(row, "state"), 8),

                field(row, "title")

            )

        })

        .collect()

}

/// `oa milestone`: the write half the API has always had and neither CLI reached.

///

/// `create` and `delete` existed on the client and were wired to nothing, so a

/// milestone could only be opened or removed in a browser -- which made

/// milestones useless to agents, and agents file most of the issues here.

async fn run_milestone(

    action: MilestoneAction,

    api_base: &str,

    token: Option<String>,

    json: bool,

) {

    let tracker = crate::tracker::TrackerClient::new(api_base, token);

    match action {

        MilestoneAction::List { repo } => {

            let target = target_or_fail(repo);

            let value = or_fail(tracker.list_milestones(&target).await);

            emit(json, &value, &milestone_listing(&value));

        }

        MilestoneAction::Create {

            title,

            description,

            due_on,

            repo,

        } => {

            let target = target_or_fail(repo);

            let value = or_fail(

                tracker

                    .create_milestone(

                        &target,

                        &title,

                        description.as_deref(),

                        due_on.as_deref(),

                    )

                    .await,

            );

            // The server assigns the number. Printing the one it returned is

            // the only way the caller learns what to pass to `--set`.

            let human = format!(

                "Opened milestone #{} {}",

                number_or_question(&value, "number"),

                field(&value, "title")

            );

            emit(json, &value, &[human]);

        }

        MilestoneAction::Delete { number, repo } => {

            let target = target_or_fail(repo);

            // A 204 carries no body, so there is nothing to report back but the

            // number that was asked for and the fact that the server accepted it.

            let value = or_fail(tracker.delete_milestone(&target, number).await);

            emit(json, &value, &[format!("Deleted milestone #{}.", number)]);

        }

    }

}

        .await

    }

    /// Put an existing issue on a milestone, or take it off one.

    ///

    /// `None` sends an explicit JSON `null`, which is how the server is told to

    /// clear the field; omitting the key would leave the milestone where it is

    /// and report success, which is the shape of "clear" that does nothing.

    ///

    /// Like [`Self::set_issue_state`], this sends only the one field. A `PATCH`

    /// carrying `body` would replace the issue text.

    pub async fn set_issue_milestone(

        &self,

        target: &RepoTarget,

        number: u64,

        milestone: Option<u64>,

    ) -> Result<Value, ApiError> {

        self.request(

            "set the milestone of an issue",

            "PATCH",

            &Self::issue_path(target, number),

            Some(json!({ "milestone": milestone })),

            &[200],

        )

        .await

    }

    pub async fn list_comments(&self, target: &RepoTarget, number: u64) -> Result<Value, ApiError> {

        self.request(

            "list issue comments",

//! The milestone write half of the tracker client, asserted on the request it sends.

//!

//! `create_milestone` and `delete_milestone` existed on `TrackerClient` and were

//! wired to no subcommand, and there was no way at all to put an existing issue on

//! a milestone: `issue create --milestone` was the only write. So milestones could

//! only be managed in a browser, which makes them useless to agents — and agents

//! file most of the issues here.

//!

//! These run against a stub server on localhost rather than the live tracker,

//! because they are WRITE paths: a test that proves `milestone delete` works by

//! deleting a real milestone is not a test anyone can run twice. The assertions are

//! on the method, path, and body the client actually put on the wire, which is what

//! was wrong — a route that was never called, not a response that was misread.

use openagents_cli::tracker::{RepoTarget, TrackerClient};

use std::io::{BufRead, BufReader, Read, Write};

use std::net::TcpListener;

use std::sync::mpsc::{channel, Receiver};

/// One request the stub server saw, reduced to what these tests assert on.

#[derive(Debug, Clone)]

struct SeenRequest {

    method: String,

    path: String,

    body: serde_json::Value,

}

struct StubApi {

    base: String,

    seen: Receiver<SeenRequest>,

}

/// Serve exactly one request with `status` and `body`, and report what was asked.

///

/// Deliberately minimal: it reads the request line, the headers, and exactly

/// `Content-Length` bytes of body. Anything it cannot parse it reports as a null

/// body rather than guessing, so a client that sent nothing is distinguishable

/// from one that sent something unreadable.

fn start_stub_api(status: u16, body: serde_json::Value) -> StubApi {

    let listener = TcpListener::bind("127.0.0.1:0").unwrap();

    let port = listener.local_addr().unwrap().port();

    let (sender, seen) = channel();

    std::thread::spawn(move || {

        let Ok((stream, _)) = listener.accept() else {

            return;

        };

        let mut reader = BufReader::new(stream);

        let mut request_line = String::new();

        if reader.read_line(&mut request_line).is_err() {

            return;

        }

        let mut parts = request_line.split_whitespace();

        let method = parts.next().unwrap_or_default().to_string();

        let path = parts.next().unwrap_or_default().to_string();

        let mut content_length = 0usize;

        loop {

            let mut header = String::new();

            match reader.read_line(&mut header) {

                Ok(0) => break,

                Ok(_) => {}

                Err(_) => return,

            }

            let trimmed = header.trim_end();

            if trimmed.is_empty() {

                break;

            }

            if let Some((name, value)) = trimmed.split_once(':') {

                if name.eq_ignore_ascii_case("content-length") {

                    content_length = value.trim().parse().unwrap_or(0);

                }

            }

        }

        let mut raw = vec![0u8; content_length];

        if content_length > 0 && reader.read_exact(&mut raw).is_err() {

            return;

        }

        let parsed = if raw.is_empty() {

            serde_json::Value::Null

        } else {

            serde_json::from_slice(&raw).unwrap_or(serde_json::Value::Null)

        };

        let _ = sender.send(SeenRequest {

            method,

            path,

            body: parsed,

        });

        let payload = if body.is_null() {

            String::new()

        } else {

            body.to_string()

        };

        let response = format!(

            "HTTP/1.1 {status} X\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{payload}",

            payload.len()

        );

        let stream = reader.get_mut();

        let _ = stream.write_all(response.as_bytes());

        let _ = stream.flush();

    });

    StubApi {

        base: format!("http://127.0.0.1:{port}/api/v1"),

        seen,

    }

}

fn target() -> RepoTarget {

    RepoTarget::parse("octavia/project").unwrap()

}

fn seen(stub: &StubApi) -> SeenRequest {

    stub.seen

        .recv_timeout(std::time::Duration::from_secs(10))

        .expect("the client never sent a request")

}

#[tokio::test]

async fn create_milestone_posts_to_the_repository_route() {

    let stub = start_stub_api(

        201,

        serde_json::json!({ "number": 7, "title": "Ship it", "state": "open" }),

    );

    let client = TrackerClient::new(&stub.base, None);

    let value = client

        .create_milestone(&target(), "Ship it", Some("the tail of #76"), None)

        .await

        .expect("the stub answered 201");

    let request = seen(&stub);

    assert_eq!(request.method, "POST");

    assert_eq!(request.path, "/api/v1/repos/octavia/project/milestones");

    assert_eq!(

        request.body,

        serde_json::json!({ "title": "Ship it", "description": "the tail of #76" }),

        "an unset due date must be omitted, not sent as null"

    );

    // The number is the server's. It is what `issue milestone --set` has to be

    // given, so a client that invented one would be sending callers to a

    // milestone that does not exist.

    assert_eq!(value.get("number").and_then(|n| n.as_u64()), Some(7));

}

#[tokio::test]

async fn delete_milestone_uses_the_numbered_route_and_accepts_an_empty_204() {

    let stub = start_stub_api(204, serde_json::Value::Null);

    let client = TrackerClient::new(&stub.base, None);

    client

        .delete_milestone(&target(), 7)

        .await

        .expect("a 204 with no body is success, not a parse failure");

    let request = seen(&stub);

    assert_eq!(request.method, "DELETE");

    assert_eq!(request.path, "/api/v1/repos/octavia/project/milestones/7");

}

#[tokio::test]

async fn setting_a_milestone_patches_that_field_and_no_other() {

    let stub = start_stub_api(

        200,

        serde_json::json!({ "number": 129, "milestone": { "number": 7, "title": "Ship it" } }),

    );

    let client = TrackerClient::new(&stub.base, None);

    client

        .set_issue_milestone(&target(), 129, Some(7))

        .await

        .unwrap();

    let request = seen(&stub);

    assert_eq!(request.method, "PATCH");

    assert_eq!(request.path, "/api/v1/repos/octavia/project/issues/129");

    // A PATCH carrying `body` would replace the issue text.

    assert_eq!(request.body, serde_json::json!({ "milestone": 7 }));

}

#[tokio::test]

async fn clearing_a_milestone_sends_an_explicit_null_rather_than_omitting_the_key() {

    let stub = start_stub_api(200, serde_json::json!({ "number": 129, "milestone": null }));

    let client = TrackerClient::new(&stub.base, None);

    client

        .set_issue_milestone(&target(), 129, None)

        .await

        .unwrap();

    let request = seen(&stub);

    // Omitting the key would leave the milestone where it is and still answer

    // 200 — a clear that does nothing and reports success.

    assert!(

        request.body.get("milestone").is_some(),

        "the key must be present; the body was {}",

        request.body

    );

    assert!(

        request.body["milestone"].is_null(),

        "the key must carry null; the body was {}",

        request.body

    );

}

#[tokio::test]

async fn a_refused_milestone_number_is_an_error_not_a_quiet_success() {

    let stub = start_stub_api(

        422,

        serde_json::json!({

            "message": "Validation Failed",

            "code": "validation_failed",

            "errors": { "milestone": ["Milestone #99999 does not exist in this repository"] }

        }),

    );

    let client = TrackerClient::new(&stub.base, None);

    let refused = client

        .set_issue_milestone(&target(), 129, Some(99_999))

        .await;

    let error = refused.expect_err("a 422 must not be reported as a stored milestone");

    let text = error.to_string();

    assert!(

        text.contains("99999") || text.contains("Validation Failed"),

        "the refusal must name what the server rejected; got {text}"

    );

}

    }),

).pipe(Command.withDescription("Read, add, or remove the prerequisites of an issue"));

/**

 * The milestone surface, on both CLIs, because the API always had it and

 * neither client reached it.

 *

 * `issue create --milestone` was the only write: an issue filed without one

 * could never be given one, and a milestone could only be opened or removed in

 * a browser, which made milestones useless to agents -- and agents file most of

 * the issues here.

 */

const milestoneNumberArgument = Argument.string("milestone").pipe(

  Argument.withDescription("Milestone number"),

);

const milestoneRow = (value: Record<string, unknown>): string =>

  `${`#${String(value["number"] ?? "?")}`.padEnd(7)}${String(value["state"] ?? "").padEnd(8)}${String(

    value["title"] ?? "",

  )}`;

/** One renderer, so `milestone list` and any other listing cannot disagree. */

const milestoneListHuman = (value: unknown): ReadonlyArray<string> => {

  const listed = rows(value, "milestones");

  return listed.length === 0 ? ["No milestones found."] : listed.map(milestoneRow);

};

/**

 * The listing, under two names.

 *

 * `oa issue milestones` is the name the Rust CLI already published, and

 * `openagents milestone list` is where the write half lives. Both are the same

 * handler, so the two cannot describe the same repository differently.

 */

const makeMilestoneListCommand = (name: "list" | "milestones") =>

  Command.make(name, { repo: repositoryOverrideFlag }, ({ repo }) =>

    Effect.gen(function* () {

      const flags = yield* rootCommand;

      const session = yield* resolveApiSession(endpointOverrides(flags));

      const target = yield* resolveTrackerTarget(repo, session.endpoint.origin);

      const issues = yield* IssueClient;

      const output = yield* Output;

      const value = yield* issues.milestones({

        origin: session.endpoint.origin,

        token: session.token,

        ...target,

      });

      yield* output.write({ value, human: milestoneListHuman(value) }, outputMode(flags.json));

    }),

  ).pipe(Command.withDescription("List the milestones of a repository"));

const milestoneListCommand = makeMilestoneListCommand("list");

const issueMilestonesCommand = makeMilestoneListCommand("milestones");

const milestoneTitleArgument = Argument.string("title").pipe(

  Argument.withDescription("Milestone title"),

);

const milestoneDescriptionFlag = Flag.string("description").pipe(

  Flag.optional,

  Flag.withDescription("What the milestone is for"),

);

const milestoneDueOnFlag = Flag.string("due-on").pipe(

  Flag.optional,

  Flag.withDescription("Due date, as the server stores it"),

);

const milestoneCreateCommand = Command.make(

  "create",

  {

    title: milestoneTitleArgument,

    repo: repositoryOverrideFlag,

    description: milestoneDescriptionFlag,

    dueOn: milestoneDueOnFlag,

  },

  ({ description, dueOn, repo, title }) =>

    Effect.gen(function* () {

      if (title.trim() === "") {

        return yield* new InputError({ message: "Pass the milestone title." });

      }

      const flags = yield* rootCommand;

      const session = yield* resolveApiSession(endpointOverrides(flags));

      const target = yield* resolveTrackerTarget(repo, session.endpoint.origin);

      const issues = yield* IssueClient;

      const output = yield* Output;

      const value = yield* issues.createMilestone({

        origin: session.endpoint.origin,

        token: session.token,

        ...target,

        title,

        ...(Option.isNone(description) ? {} : { description: description.value }),

        ...(Option.isNone(dueOn) ? {} : { dueOn: dueOn.value }),

      });

      // The server assigns the number. Printing the one it returned is how the

      // caller learns what to pass to `issue milestone --set`.

      const created = record(value);

      yield* output.write(

        {

          value,

          human: [

            `Opened milestone #${String(created["number"] ?? "?")} ${String(created["title"] ?? "")}`,

          ],

        },

        outputMode(flags.json),

      );

    }),

).pipe(Command.withDescription("Open a new milestone"));

const milestoneDeleteCommand = Command.make(

  "delete",

  { milestone: milestoneNumberArgument, repo: repositoryOverrideFlag },

  ({ milestone, repo }) =>

    Effect.gen(function* () {

      const number = yield* parseTrackerNumber("A milestone number", milestone);

      const flags = yield* rootCommand;

      const session = yield* resolveApiSession(endpointOverrides(flags));

      const target = yield* resolveTrackerTarget(repo, session.endpoint.origin);

      const issues = yield* IssueClient;

      const output = yield* Output;

      // A 204 carries no body, so there is nothing to report but the number

      // that was asked for and the fact that the server accepted it.

      const value = yield* issues.deleteMilestone({

        origin: session.endpoint.origin,

        token: session.token,

        ...target,

        milestone: number,

      });

      yield* output.write(

        { value, human: [`Deleted milestone #${String(number)}.`] },

        outputMode(flags.json),

      );

    }),

).pipe(Command.withDescription("Delete a milestone"));

const milestoneCommand = Command.make("milestone").pipe(

  Command.withDescription("Repository milestones"),

  Command.withSubcommands([milestoneListCommand, milestoneCreateCommand, milestoneDeleteCommand]),

);

const issueMilestoneSetFlag = Flag.string("set").pipe(

  Flag.optional,

  Flag.withDescription("Milestone number to put the issue on"),

);

const issueMilestoneClearFlag = Flag.boolean("clear").pipe(

  Flag.withDescription("Take the issue off whatever milestone it is on"),

);

const issueMilestoneCommand = Command.make(

  "milestone",

  {

    number: issueNumberArgument,

    repo: repositoryOverrideFlag,

    set: issueMilestoneSetFlag,

    clear: issueMilestoneClearFlag,

  },

  ({ clear, number, repo, set }) =>

    Effect.gen(function* () {

      // Two ways to say what the milestone should become, and they disagree.

      // Guessing which was meant is how an issue lands on a milestone the

      // caller was trying to take it off.

      if (Option.isSome(set) && clear) {

        return yield* new InputError({ message: "Use either --set or --clear, not both." });

      }

      if (Option.isNone(set) && !clear) {

        return yield* new InputError({

          message:

            "Say what the milestone should become: --set <number> to put the issue on one, or --clear to take it off.",

        });

      }

      const issueNumber = yield* parseTrackerNumber("An issue number", number);

      const milestone = Option.isNone(set)

        ? null

        : yield* parseTrackerNumber("A milestone number", set.value);

      const flags = yield* rootCommand;

      const session = yield* resolveApiSession(endpointOverrides(flags));

      const target = yield* resolveTrackerTarget(repo, session.endpoint.origin);

      const issues = yield* IssueClient;

      const output = yield* Output;

      const value = yield* issues.setMilestone({

        origin: session.endpoint.origin,

        token: session.token,

        ...target,

        number: issueNumber,

        milestone,

      });

      // Report what came BACK, not what was asked for. A server that accepted

      // the request and stored something else is exactly what an echo hides.

      const stored = record(value)["milestone"];

      const human =

        stored === null || stored === undefined

          ? `Issue #${String(issueNumber)} is on no milestone.`

          : `Issue #${String(issueNumber)} is on milestone #${String(

              record(stored)["number"] ?? "?",

            )} ${String(record(stored)["title"] ?? "")}`;

      yield* output.write({ value, human: [human] }, outputMode(flags.json));

    }),

).pipe(Command.withDescription("Put an existing issue on a milestone, or take it off one"));

const issueCommand = Command.make("issue").pipe(

  Command.withDescription("Read and write issues"),

  Command.withSubcommands([

    issueAssignRunCommand,

    issueUnassignRunCommand,

    issueDepsCommand,

    issueMilestoneCommand,

    issueMilestonesCommand,

  ]),

);

    identityCommand,

    issueCommand,

    memoryCommand,

    milestoneCommand,

    projectCommand,

    providerCommand,

    repoCommand,

  readonly number: number;

}

export interface MilestoneCreateInput extends AuthenticatedApi, RepositoryTarget {

  readonly title: string;

  readonly description?: string;

  readonly dueOn?: string;

}

export interface MilestoneNumberInput extends AuthenticatedApi, RepositoryTarget {

  readonly milestone: number;

}

interface IssueClientInterface {

  readonly list: (input: IssueListInput) => Effect.Effect<IssueListResult, CliError>;

  readonly view: (input: IssueNumberInput) => Effect.Effect<unknown, CliError>;

  readonly removeDependency: (

    input: IssueNumberInput & { readonly blockedBy: number },

  ) => Effect.Effect<unknown, CliError>;

  readonly milestones: (

    input: AuthenticatedApi & RepositoryTarget,

  ) => Effect.Effect<unknown, CliError>;

  readonly createMilestone: (input: MilestoneCreateInput) => Effect.Effect<unknown, CliError>;

  readonly deleteMilestone: (input: MilestoneNumberInput) => Effect.Effect<unknown, CliError>;

  /**

   * Put an existing issue on a milestone, or take it off one.

   *

   * `milestone: null` is sent explicitly, because that is how the server is

   * told to clear the field. Omitting the key would leave the milestone where

   * it is and still answer 200, which is a "clear" that does nothing and

   * reports success.

   */

  readonly setMilestone: (

    input: IssueNumberInput & { readonly milestone: number | null },

  ) => Effect.Effect<unknown, CliError>;

}

export class IssueClient extends Context.Service<IssueClient, IssueClientInterface>()(

const issuePath = (input: RepositoryTarget & { readonly number: number }) =>

  `${issuesPath(input)}/${input.number}`;

const milestonesPath = (input: RepositoryTarget) =>

  `${repositoryPath(input.owner, input.repo)}/milestones`;

const listQuery = (input: IssueListInput, page: number): string => {

  const parameters = new URLSearchParams({ state: input.state ?? "open", page: String(page) });

  // The list route names its search parameter `q` and its label parameter

          path: `${issuePath(input)}/dependencies/${input.blockedBy}`,

          acceptedStatuses: [200],

        }),

      milestones: (input) =>

        request("list milestones", {

          origin: input.origin,

          token: input.token,

          method: "GET",

          path: milestonesPath(input),

          acceptedStatuses: [200],

        }),

      createMilestone: (input) =>

        request("create a milestone", {

          origin: input.origin,

          token: input.token,

          method: "POST",

          path: milestonesPath(input),

          body: {

            title: input.title,

            ...(input.description === undefined ? {} : { description: input.description }),

            ...(input.dueOn === undefined ? {} : { due_on: input.dueOn }),

          },

          acceptedStatuses: [201],

        }),

      // The route answers 204 with no body when the milestone is gone.

      deleteMilestone: (input) =>

        request("delete a milestone", {

          origin: input.origin,

          token: input.token,

          method: "DELETE",

          path: `${milestonesPath(input)}/${input.milestone}`,

          acceptedStatuses: [200, 204],

        }),

      // Like `setState`, this sends the one field. A `PATCH` carrying `body`

      // would replace the issue text.

      setMilestone: (input) =>

        request("set the milestone of an issue", {

          origin: input.origin,

          token: input.token,

          method: "PATCH",

          path: issuePath(input),

          body: { milestone: input.milestone },

          acceptedStatuses: [200],

        }),

    });

  }),

);

    );

  });

});

/**

 * The milestone write half. The API has carried all of it since the milestone

 * routes landed; neither CLI reached it, so a milestone could only be opened,

 * removed, or attached to an existing issue in a browser.

 *

 * Every assertion here is on the REQUEST the client actually built -- method,

 * path, and body -- because the bug being fixed is a route that was never

 * called, not a response that was misread.

 */

describe("the milestone client", () => {

  const captured = (

    response: ApiResponse,

  ): { readonly requests: Array<ApiRequest>; readonly layer: Layer.Layer<IssueClient> } => {

    const requests: Array<ApiRequest> = [];

    return {

      requests,

      layer: layerFromHandler((input) =>

        Effect.sync(() => {

          requests.push(input);

          return response;

        }),

      ),

    };

  };

  it("lists milestones from the repository route", async () => {

    const { layer, requests } = captured({

      status: 200,

      body: { milestones: [{ number: 3, title: "Ship it", state: "open" }] },

    });

    const value = await Effect.runPromise(

      Effect.gen(function* () {

        const issues = yield* IssueClient;

        return yield* issues.milestones(target);

      }).pipe(Effect.provide(layer)),

    );

    expect(requests[0]?.method).toBe("GET");

    expect(requests[0]?.path).toBe("/api/v1/repos/octavia/project/milestones");

    expect(value).toEqual({ milestones: [{ number: 3, title: "Ship it", state: "open" }] });

  });

  it("creates a milestone and reports the number the server assigned", async () => {

    const { layer, requests } = captured({

      status: 201,

      body: { number: 7, title: "Ship it", state: "open" },

    });

    const value = await Effect.runPromise(

      Effect.gen(function* () {

        const issues = yield* IssueClient;

        return yield* issues.createMilestone({

          ...target,

          title: "Ship it",

          description: "the tail of #76",

        });

      }).pipe(Effect.provide(layer)),

    );

    expect(requests[0]?.method).toBe("POST");

    expect(requests[0]?.path).toBe("/api/v1/repos/octavia/project/milestones");

    expect(requests[0]?.body).toEqual({ title: "Ship it", description: "the tail of #76" });

    // The number is the server's, not one the CLI made up: it is what `issue

    // milestone --set` has to be given.

    expect((value as Record<string, unknown>)["number"]).toBe(7);

  });

  it("omits an unset description and due date rather than sending an empty one", async () => {

    const { layer, requests } = captured({ status: 201, body: { number: 8, title: "Bare" } });

    await Effect.runPromise(

      Effect.gen(function* () {

        const issues = yield* IssueClient;

        return yield* issues.createMilestone({ ...target, title: "Bare" });

      }).pipe(Effect.provide(layer)),

    );

    expect(requests[0]?.body).toEqual({ title: "Bare" });

  });

  it("accepts the 204 a delete answers with", async () => {

    const { layer, requests } = captured({ status: 204, body: undefined });

    await Effect.runPromise(

      Effect.gen(function* () {

        const issues = yield* IssueClient;

        return yield* issues.deleteMilestone({ ...target, milestone: 7 });

      }).pipe(Effect.provide(layer)),

    );

    expect(requests[0]?.method).toBe("DELETE");

    expect(requests[0]?.path).toBe("/api/v1/repos/octavia/project/milestones/7");

  });

  it("puts an existing issue on a milestone, sending that field and no other", async () => {

    const { layer, requests } = captured({

      status: 200,

      body: { number: 129, milestone: { number: 7, title: "Ship it" } },

    });

    await Effect.runPromise(

      Effect.gen(function* () {

        const issues = yield* IssueClient;

        return yield* issues.setMilestone({ ...target, number: 129, milestone: 7 });

      }).pipe(Effect.provide(layer)),

    );

    expect(requests[0]?.method).toBe("PATCH");

    expect(requests[0]?.path).toBe("/api/v1/repos/octavia/project/issues/129");

    // A PATCH carrying `body` would replace the issue text.

    expect(requests[0]?.body).toEqual({ milestone: 7 });

  });

  it("clears a milestone by sending an explicit null, not by omitting the key", async () => {

    const { layer, requests } = captured({ status: 200, body: { number: 129, milestone: null } });

    await Effect.runPromise(

      Effect.gen(function* () {

        const issues = yield* IssueClient;

        return yield* issues.setMilestone({ ...target, number: 129, milestone: null });

      }).pipe(Effect.provide(layer)),

    );

    // Omitting the key would leave the milestone where it is and still answer

    // 200 -- a clear that does nothing and reports success.

    expect(requests[0]?.body).toEqual({ milestone: null });

    expect(Object.hasOwn(requests[0]?.body as object, "milestone")).toBe(true);

  });

  it("reports a rejected milestone number by the field the server named", async () => {

    const failure = await Effect.runPromise(

      Effect.gen(function* () {

        const issues = yield* IssueClient;

        return yield* issues.setMilestone({ ...target, number: 129, milestone: 99999 });

      }).pipe(

        Effect.provide(

          layerFromHandler(() =>

            Effect.succeed({

              status: 422,

              body: {

                message: "Validation Failed",

                code: "validation_failed",

                status: 422,

                documentation_url: "http://localhost:4000/api/v1",

                request_id: "request-2",

                errors: { milestone: ["Milestone #99999 does not exist in this repository"] },

              },

            }),

          ),

        ),

        Effect.flip,

      ),

    );

    expect(failure).toBeInstanceOf(ApiError);

    expect((failure as ApiError).status).toBe(422);

    expect((failure as ApiError).message).toBe(

      "Validation Failed (milestone: Milestone #99999 does not exist in this repository)",

    );

  });

});

    );

  });

  it("puts an existing issue on a milestone from the command line", async () => {

    const requests: Array<ApiRequest> = [];

    const { run, written } = harness((input) =>

      Effect.sync(() => {

        requests.push(input);

        return {

          status: 200,

          body: { ...issueBody(129), milestone: { number: 7, title: "Ship it" } },

        };

      }),

    );

    await run(["issue", "milestone", "129", "--set", "7", "-R", "octavia/project"]);

    expect(requests[0]?.method).toBe("PATCH");

    expect(requests[0]?.path).toBe("/api/v1/repos/octavia/project/issues/129");

    expect(requests[0]?.body).toEqual({ milestone: 7 });

    // The line names the milestone the server RETURNED, so a server that stored

    // something other than what was asked for is visible instead of echoed over.