fix: resolve issues #16, #17, #18 and bump to v0.3.16

- #16: relations list returns empty because GraphQL query omitted state.id,
  causing WorkflowState deserialization to silently fail. Added id to all
  state fields in the relations query.
- #17: project name lookup now tolerates filtered query failures and falls
  through to paginated lookup. Error message suggests using slugId.
- #18: api query/mutate now auto-detect piped stdin without requiring '-'
  positional arg. Explicit '-' still works.
- Fix pre-existing cargo fmt and clippy warnings.
- Bump version to 0.3.16.

Author: Finesssee

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "linear-cli"
-version = "0.3.15"
+version = "0.3.16"
 edition = "2021"
 description = "A powerful CLI for Linear.app - manage issues, projects, cycles, and more from your terminal"
 authors = ["scwrcd"]

Cargo.toml

@@ -304,6 +304,8 @@ pub async fn resolve_label_id(
 }
 
 /// Resolve a project name or slug to a UUID.
+/// Falls back to paginated lookup if the filtered query fails (some team/project
+/// combinations cause the Linear API to reject name-based lookups).
 pub async fn resolve_project_id(
     client: &LinearClient,
     project: &str,
@@ -313,34 +315,81 @@ pub async fn resolve_project_id(
         return Ok(project.to_string());
     }
 
-    let config = ResolverConfig {
-        cache_type: CacheType::Projects,
-        filtered_query: r#"
+    // Check cache first
+    if !cache_opts.no_cache {
+        let cache = Cache::with_ttl(cache_opts.effective_ttl_seconds())?;
+        if let Some(cached) = cache
+            .get(CacheType::Projects)
+            .and_then(|data| data.as_array().cloned())
+        {
+            if let Some(id) = find_project_id(&cached, project) {
+                return Ok(id);
+            }
+        }
+    }
+
+    // Try filtered query first (fast path) -- tolerate errors and fall through
+    let filtered_result = client
+        .query(
+            r#"
             query($project: String!) {
                 projects(first: 50, filter: { name: { eqIgnoreCase: $project } }) {
                     nodes { id name slugId }
                 }
             }
-        "#,
-        filtered_var_name: "project",
-        filtered_nodes_path: &["data", "projects", "nodes"],
-        paginated_query: r#"
-            query($first: Int, $after: String) {
-                projects(first: $first, after: $after) {
-                    nodes { id name slugId }
-                    pageInfo { hasNextPage endCursor }
-                }
+            "#,
+            Some(json!({ "project": project })),
+        )
+        .await;
+
+    if let Ok(result) = filtered_result {
+        let empty = vec![];
+        let nodes = get_nested_array(&result, &["data", "projects", "nodes"]).unwrap_or(&empty);
+        if let Some(id) = find_project_id(nodes, project) {
+            return Ok(id);
+        }
+    }
+
+    // Fallback: paginate through all projects
+    let pagination = PaginationOptions {
+        all: true,
+        page_size: Some(250),
+        ..Default::default()
+    };
+    let all_items = paginate_nodes(
+        client,
+        r#"
+        query($first: Int, $after: String) {
+            projects(first: $first, after: $after) {
+                nodes { id name slugId }
+                pageInfo { hasNextPage endCursor }
             }
+        }
         "#,
-        paginated_nodes_path: &["data", "projects", "nodes"],
-        paginated_page_info_path: &["data", "projects", "pageInfo"],
-        not_found_msg: &format!(
-            "Project not found: {}. Use linear-cli p list to see available projects.",
-            project
-        ),
-    };
+        serde_json::Map::new(),
+        &["data", "projects", "nodes"],
+        &["data", "projects", "pageInfo"],
+        &pagination,
+        250,
+    )
+    .await?;
 
-    resolve_id(client, project, cache_opts, &config, find_project_id).await
+    if !cache_opts.no_cache {
+        let cache = Cache::with_ttl(cache_opts.effective_ttl_seconds())?;
+        let _ = cache.set(CacheType::Projects, json!(all_items));
+    }
+
+    if let Some(id) = find_project_id(&all_items, project) {
+        return Ok(id);
+    }
+
+    anyhow::bail!(
+        "Could not resolve project \"{}\". \
+         Tip: try using the project's slugId (UUID) instead:\n  \
+         linear-cli issues update <ID> --project \"<slugId>\"\n\
+         You can find project slugIds via: linear-cli projects list",
+        project
+    )
 }
 
 /// Resolve a state name to a UUID for a given team.
@@ -531,7 +580,11 @@ impl AuthState {
     pub fn needs_refresh(&self) -> bool {
         match self {
             AuthState::ApiKey(_) => false,
-            AuthState::OAuth { expires_at, refresh_token, .. } => {
+            AuthState::OAuth {
+                expires_at,
+                refresh_token,
+                ..
+            } => {
                 if refresh_token.is_none() {
                     return false;
                 }
@@ -700,7 +753,8 @@ impl LinearClient {
         if let Ok(Some(oauth)) = config::get_oauth_config(&profile) {
             if !oauth.access_token.is_empty() {
                 // If token has a refresh_token or isn't expired, use OAuth
-                let is_expired = oauth.expires_at
+                let is_expired = oauth
+                    .expires_at
                     .map(|exp| chrono::Utc::now().timestamp() >= (exp - 300))
                     .unwrap_or(false);
 
@@ -740,8 +794,14 @@ impl LinearClient {
         }
 
         match &*auth {
-            AuthState::OAuth { refresh_token, client_id, profile, .. } => {
-                let refresh_token = refresh_token.as_ref()
+            AuthState::OAuth {
+                refresh_token,
+                client_id,
+                profile,
+                ..
+            } => {
+                let refresh_token = refresh_token
+                    .as_ref()
                     .context("OAuth token expired but no refresh token available")?;
 
                 let new_tokens = crate::oauth::refresh_tokens(client_id, refresh_token).await?;
@@ -762,7 +822,8 @@ impl LinearClient {
                     scopes,
                 };
                 #[cfg(feature = "secure-storage")]
-                let persist_result = if config::oauth_uses_secure_storage(profile).unwrap_or(false) {
+                let persist_result = if config::oauth_uses_secure_storage(profile).unwrap_or(false)
+                {
                     config::save_oauth_config_secure(profile, &oauth_config)
                 } else {
                     config::save_oauth_config(profile, &oauth_config)
@@ -843,7 +904,10 @@ mod tests {
             expires_at: Some(chrono::Utc::now().timestamp() - 100), // expired
             profile: "default".to_string(),
         };
-        assert!(!state.needs_refresh(), "OAuth without refresh token should not need refresh even if expired");
+        assert!(
+            !state.needs_refresh(),
+            "OAuth without refresh token should not need refresh even if expired"
+        );
     }
 
     #[test]
@@ -855,7 +919,10 @@ mod tests {
             expires_at: Some(chrono::Utc::now().timestamp() - 100), // expired
             profile: "default".to_string(),
         };
-        assert!(state.needs_refresh(), "OAuth with expired token and refresh token should need refresh");
+        assert!(
+            state.needs_refresh(),
+            "OAuth with expired token and refresh token should need refresh"
+        );
     }
 
     #[test]
@@ -867,7 +934,10 @@ mod tests {
             expires_at: Some(chrono::Utc::now().timestamp() + 200), // within 5min buffer
             profile: "default".to_string(),
         };
-        assert!(state.needs_refresh(), "OAuth expiring within buffer should need refresh");
+        assert!(
+            state.needs_refresh(),
+            "OAuth expiring within buffer should need refresh"
+        );
     }
 
     #[test]
@@ -879,7 +949,10 @@ mod tests {
             expires_at: Some(chrono::Utc::now().timestamp() + 3600), // 1 hour from now
             profile: "default".to_string(),
         };
-        assert!(!state.needs_refresh(), "OAuth with fresh token should not need refresh");
+        assert!(
+            !state.needs_refresh(),
+            "OAuth with fresh token should not need refresh"
+        );
     }
 
     #[test]
@@ -891,7 +964,10 @@ mod tests {
             expires_at: None, // no expiry (legacy token)
             profile: "default".to_string(),
         };
-        assert!(!state.needs_refresh(), "OAuth without expiry should not need refresh");
+        assert!(
+            !state.needs_refresh(),
+            "OAuth without expiry should not need refresh"
+        );
     }
 
     #[test]
@@ -911,6 +987,9 @@ mod tests {
     fn test_auth_state_debug() {
         let state = AuthState::ApiKey("key".to_string());
         let debug = format!("{:?}", state);
-        assert!(debug.contains("ApiKey"), "Debug output should contain variant name");
+        assert!(
+            debug.contains("ApiKey"),
+            "Debug output should contain variant name"
+        );
     }
 }

src/api.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use clap::Subcommand;
 use serde_json::{json, Map, Value};
-use std::io::{self, BufRead};
+use std::io::{self, BufRead, IsTerminal};
 
 use crate::api::LinearClient;
 use crate::output::{print_json_owned, OutputOptions};
@@ -14,10 +14,11 @@ pub enum ApiCommands {
     linear api query '{ viewer { id name email } }'
     linear api query '{ teams { nodes { id key name } } }'
     linear api query -v teamId=abc123 'query($teamId: String!) { team(id: $teamId) { name } }'
+    echo '{ viewer { id } }' | linear api query
     echo '{ viewer { id } }' | linear api query -"#)]
     Query {
-        /// GraphQL query string. Use "-" to read from stdin.
-        query: String,
+        /// GraphQL query string. Use "-" to read from stdin, or omit when piping.
+        query: Option<String>,
 
         /// Variables as key=value pairs (e.g. -v id=abc123 -v name=test)
         #[arg(short = 'v', long = "variable", value_name = "KEY=VALUE")]
@@ -39,10 +40,11 @@ pub enum ApiCommands {
     #[command(after_help = r#"EXAMPLES:
     linear api mutate -v title="New Issue" -v teamId=abc123 \
         'mutation($title: String!, $teamId: String!) { issueCreate(input: { title: $title, teamId: $teamId }) { issue { id identifier } } }'
-    cat mutation.graphql | linear api mutate -v id=abc123 -"#)]
+    cat mutation.graphql | linear api mutate -
+    echo '...' | linear api mutate"#)]
     Mutate {
-        /// GraphQL mutation string. Use "-" to read from stdin.
-        query: String,
+        /// GraphQL mutation string. Use "-" to read from stdin, or omit when piping.
+        query: Option<String>,
 
         /// Variables as key=value pairs (e.g. -v id=abc123 -v name=test)
         #[arg(short = 'v', long = "variable", value_name = "KEY=VALUE")]
@@ -58,16 +60,57 @@ pub async fn handle(cmd: ApiCommands, output: &OutputOptions) -> Result<()> {
             paginate,
             nodes_path,
             page_info_path,
-        } => run_query(&query, &variables, paginate, &nodes_path, &page_info_path, output).await,
-        ApiCommands::Mutate { query, variables } => run_mutate(&query, &variables, output).await,
+        } => {
+            let resolved = resolve_query_source(query)?;
+            run_query(
+                &resolved,
+                &variables,
+                paginate,
+                &nodes_path,
+                &page_info_path,
+                output,
+            )
+            .await
+        }
+        ApiCommands::Mutate { query, variables } => {
+            let resolved = resolve_query_source(query)?;
+            run_mutate(&resolved, &variables, output).await
+        }
     }
 }
 
+/// Resolve the GraphQL query source: explicit string, "-" for stdin, or auto-detect piped stdin.
+fn resolve_query_source(query: Option<String>) -> Result<String> {
+    match query {
+        Some(q) if q == "-" => read_stdin(),
+        Some(q) => Ok(q),
+        None => {
+            if !io::stdin().is_terminal() {
+                read_stdin()
+            } else {
+                anyhow::bail!(
+                    "No query provided. Pass a GraphQL query string as an argument, \
+                     or pipe one via stdin:\n  \
+                     echo '{{ viewer {{ id }} }}' | linear-cli api query"
+                )
+            }
+        }
+    }
+}
+
+fn read_stdin() -> Result<String> {
+    let stdin = io::stdin();
+    let lines: Vec<String> = stdin.lock().lines().map_while(Result::ok).collect();
+    let query = lines.join("\n");
+    if query.trim().is_empty() {
+        anyhow::bail!("Empty query received from stdin");
+    }
+    Ok(query)
+}
+
 fn read_query(input: &str) -> Result<String> {
     if input == "-" {
-        let stdin = io::stdin();
-        let lines: Vec<String> = stdin.lock().lines().map_while(Result::ok).collect();
-        Ok(lines.join("\n"))
+        read_stdin()
     } else {
         Ok(input.to_string())
     }
@@ -161,11 +204,7 @@ async fn run_query(
     Ok(())
 }
 
-async fn run_mutate(
-    query_str: &str,
-    variables: &[String],
-    output: &OutputOptions,
-) -> Result<()> {
+async fn run_mutate(query_str: &str, variables: &[String], output: &OutputOptions) -> Result<()> {
     let query = read_query(query_str)?;
     let vars = parse_variables(variables)?;
     let client = LinearClient::new()?;
@@ -238,4 +277,19 @@ mod tests {
         let q = read_query("{ viewer { id } }").unwrap();
         assert_eq!(q, "{ viewer { id } }");
     }
+
+    #[test]
+    fn test_resolve_query_source_explicit() {
+        let q = resolve_query_source(Some("{ viewer { id } }".to_string())).unwrap();
+        assert_eq!(q, "{ viewer { id } }");
+    }
+
+    #[test]
+    fn test_resolve_query_source_none_tty() {
+        // When stdin is a TTY and no query provided, should error
+        // In test environment stdin is usually not a TTY, so this may read empty stdin
+        // and return an error either way
+        let result = resolve_query_source(None);
+        assert!(result.is_err());
+    }
 }