lin-cli 0.5.0

A fast CLI for Linear
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use anyhow::{Result, bail};
use serde_json::json;

use crate::api::client::LinearClient;
use crate::api::queries::*;
use crate::api::types::*;
use crate::api::upload;
use crate::output;

pub async fn view(client: &LinearClient, issue_id: &str, show_ids: bool) -> Result<()> {
    let data: IssueCommentsData = client
        .execute(COMMENTS_QUERY, Some(json!({ "id": issue_id })))
        .await?;

    let comments = data.issue.comments.nodes;
    output::print_header(&format!("Comments ({})", comments.len()));

    if comments.is_empty() {
        println!("  No comments.");
        return Ok(());
    }

    for comment in &comments {
        let author = comment
            .user
            .as_ref()
            .map(|u| u.name.as_str())
            .unwrap_or("Unknown");
        let date = comment
            .created_at
            .as_deref()
            .map(output::format_date)
            .unwrap_or_default();

        println!();
        if show_ids {
            println!("  [{}]", comment.id);
        }
        println!("  {} — {}", author, date);
        println!("  {}", comment.body);
    }

    Ok(())
}

pub async fn add(
    client: &LinearClient,
    issue_id: &str,
    body: &str,
    attachment_path: Option<&str>,
) -> Result<()> {
    let mut final_body = body.to_string();

    // Upload attachment and embed markdown link
    if let Some(file_path) = attachment_path {
        let asset_url = upload::upload_file(client, file_path).await?;
        let filename = std::path::Path::new(file_path)
            .file_name()
            .map(|n| n.to_string_lossy().to_string())
            .unwrap_or_else(|| "attachment".to_string());
        final_body = format!("{}\n\n[{}]({})", final_body, filename, asset_url);
    }

    let input = json!({
        "issueId": issue_id,
        "body": final_body,
    });

    let data: CommentCreateData = client
        .execute(COMMENT_CREATE_MUTATION, Some(json!({ "input": input })))
        .await?;

    if !data.comment_create.success {
        bail!("Failed to create comment");
    }

    output::print_success("Comment added");
    Ok(())
}

pub async fn edit(
    client: &LinearClient,
    comment_id: &str,
    body: &str,
    attachment_path: Option<&str>,
) -> Result<()> {
    let mut final_body = body.to_string();

    // Upload attachment and embed markdown link
    if let Some(file_path) = attachment_path {
        let asset_url = upload::upload_file(client, file_path).await?;
        let filename = std::path::Path::new(file_path)
            .file_name()
            .map(|n| n.to_string_lossy().to_string())
            .unwrap_or_else(|| "attachment".to_string());
        final_body = format!("{}\n\n[{}]({})", final_body, filename, asset_url);
    }

    let input = json!({ "body": final_body });

    let data: CommentUpdateData = client
        .execute(
            COMMENT_UPDATE_MUTATION,
            Some(json!({ "id": comment_id, "input": input })),
        )
        .await?;

    if !data.comment_update.success {
        bail!("Failed to update comment");
    }

    output::print_success("Comment updated");
    Ok(())
}