@mbe24/99problems 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mbe24/99problems",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "GitHub issue conversation fetcher CLI",
   "bin": {
     "99problems": "./npm/bin/99problems.js"
@@ -9,13 +9,13 @@
     "postinstall": "node npm/install.js"
   },
   "optionalDependencies": {
-    "@mbe24/99problems-win32-x64": "0.2.0",
-    "@mbe24/99problems-linux-x64": "0.2.0",
-    "@mbe24/99problems-darwin-x64": "0.2.0",
-    "@mbe24/99problems-darwin-arm64": "0.2.0",
-    "@mbe24/99problems-linux-arm64": "0.2.0"
+    "@mbe24/99problems-win32-x64": "0.3.1",
+    "@mbe24/99problems-linux-x64": "0.3.1",
+    "@mbe24/99problems-darwin-x64": "0.3.1",
+    "@mbe24/99problems-darwin-arm64": "0.3.1",
+    "@mbe24/99problems-linux-arm64": "0.3.1"
   },
-  "license": "MIT",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/mbe24/99problems"

package/rust-toolchain.toml

@@ -0,0 +1,4 @@
+[toolchain]
+channel = "stable"
+profile = "minimal"
+components = ["clippy", "rustfmt"]

package/src/cmd/config/key.rs

@@ -0,0 +1,126 @@
+use anyhow::{Result, anyhow};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum ConfigKey {
+    DefaultInstance,
+    InstanceField { alias: String, field: InstanceField },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum InstanceField {
+    Platform,
+    Url,
+    Token,
+    AccountEmail,
+    Repo,
+    State,
+    Type,
+    Deployment,
+    PerPage,
+}
+
+impl InstanceField {
+    pub(crate) fn as_str(self) -> &'static str {
+        match self {
+            InstanceField::Platform => "platform",
+            InstanceField::Url => "url",
+            InstanceField::Token => "token",
+            InstanceField::AccountEmail => "account_email",
+            InstanceField::Repo => "repo",
+            InstanceField::State => "state",
+            InstanceField::Type => "type",
+            InstanceField::Deployment => "deployment",
+            InstanceField::PerPage => "per_page",
+        }
+    }
+}
+
+impl ConfigKey {
+    /// Parse a key path used by `config get/set/unset`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error when the key path is malformed or unsupported.
+    pub(crate) fn parse(raw: &str) -> Result<Self> {
+        let trimmed = raw.trim();
+        if trimmed == "default_instance" {
+            return Ok(Self::DefaultInstance);
+        }
+
+        let parts: Vec<&str> = trimmed.split('.').collect();
+        if parts.len() != 3 || parts.first() != Some(&"instances") {
+            return Err(anyhow!(
+                "Invalid key path '{raw}'. Use 'default_instance' or 'instances.<alias>.<field>'."
+            ));
+        }
+        let alias = parts[1].trim();
+        if alias.is_empty() {
+            return Err(anyhow!(
+                "Invalid key path '{raw}': instance alias cannot be empty."
+            ));
+        }
+
+        let field = match parts[2] {
+            "platform" => InstanceField::Platform,
+            "url" => InstanceField::Url,
+            "token" => InstanceField::Token,
+            "account_email" => InstanceField::AccountEmail,
+            "repo" => InstanceField::Repo,
+            "state" => InstanceField::State,
+            "type" => InstanceField::Type,
+            "deployment" => InstanceField::Deployment,
+            "per_page" => InstanceField::PerPage,
+            other => {
+                return Err(anyhow!(
+                    "Unsupported instance field '{other}'. Supported: platform, url, token, account_email, repo, state, type, deployment, per_page."
+                ));
+            }
+        };
+
+        Ok(Self::InstanceField {
+            alias: alias.to_string(),
+            field,
+        })
+    }
+
+    pub(crate) fn is_secret(&self) -> bool {
+        matches!(
+            self,
+            Self::InstanceField {
+                field: InstanceField::Token,
+                ..
+            }
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_default_instance() {
+        assert_eq!(
+            ConfigKey::parse("default_instance").unwrap(),
+            ConfigKey::DefaultInstance
+        );
+    }
+
+    #[test]
+    fn parses_instance_field() {
+        let key = ConfigKey::parse("instances.work.platform").unwrap();
+        assert_eq!(
+            key,
+            ConfigKey::InstanceField {
+                alias: "work".to_string(),
+                field: InstanceField::Platform
+            }
+        );
+    }
+
+    #[test]
+    fn rejects_invalid_path() {
+        let err = ConfigKey::parse("instances.work").unwrap_err().to_string();
+        assert!(err.contains("Invalid key path"));
+    }
+}

package/src/cmd/config/mod.rs

@@ -0,0 +1,218 @@
+mod key;
+mod render;
+mod store;
+mod write;
+
+use anyhow::{Result, anyhow};
+use clap::{Args, Subcommand, ValueEnum};
+
+use key::ConfigKey;
+use render::render_value;
+use store::{ReadScope, WriteScope};
+
+#[derive(Args, Debug)]
+#[command(
+    next_line_help = true,
+    after_help = "Examples:\n  99problems config list\n  99problems config set default_instance work-gitlab\n  99problems config get instances.work-gitlab.repo --scope resolved"
+)]
+pub(crate) struct ConfigArgs {
+    #[command(subcommand)]
+    pub(crate) command: ConfigSubcommand,
+}
+
+#[derive(Subcommand, Debug)]
+pub(crate) enum ConfigSubcommand {
+    /// Print config file path for a scope
+    Path {
+        #[arg(long, value_enum, default_value = "local")]
+        scope: PathScope,
+    },
+    /// List all configured keys in a scope
+    List {
+        #[arg(long, value_enum, default_value = "resolved")]
+        scope: ReadScopeArg,
+        #[arg(long)]
+        show_secrets: bool,
+    },
+    /// Read one configured key
+    Get {
+        key: String,
+        #[arg(long, value_enum, default_value = "resolved")]
+        scope: ReadScopeArg,
+        #[arg(long)]
+        show_secrets: bool,
+    },
+    /// Set a configured key
+    Set {
+        key: String,
+        value: String,
+        #[arg(long, value_enum, default_value = "local")]
+        scope: WriteScopeArg,
+    },
+    /// Unset a configured key
+    Unset {
+        key: String,
+        #[arg(long, value_enum, default_value = "local")]
+        scope: WriteScopeArg,
+    },
+}
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+pub(crate) enum PathScope {
+    Home,
+    Local,
+}
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+pub(crate) enum ReadScopeArg {
+    Home,
+    Local,
+    Resolved,
+}
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+pub(crate) enum WriteScopeArg {
+    Home,
+    Local,
+}
+
+impl From<PathScope> for ReadScope {
+    fn from(value: PathScope) -> Self {
+        match value {
+            PathScope::Home => Self::Home,
+            PathScope::Local => Self::Local,
+        }
+    }
+}
+
+impl From<ReadScopeArg> for ReadScope {
+    fn from(value: ReadScopeArg) -> Self {
+        match value {
+            ReadScopeArg::Home => Self::Home,
+            ReadScopeArg::Local => Self::Local,
+            ReadScopeArg::Resolved => Self::Resolved,
+        }
+    }
+}
+
+impl From<WriteScopeArg> for WriteScope {
+    fn from(value: WriteScopeArg) -> Self {
+        match value {
+            WriteScopeArg::Home => Self::Home,
+            WriteScopeArg::Local => Self::Local,
+        }
+    }
+}
+
+/// Run the `config` command family.
+///
+/// # Errors
+///
+/// Returns an error if scope loading fails, key parsing/validation fails,
+/// or set/unset operations fail to persist.
+pub(crate) fn run(args: &ConfigArgs) -> Result<()> {
+    match &args.command {
+        ConfigSubcommand::Path { scope } => run_path((*scope).into()),
+        ConfigSubcommand::List {
+            scope,
+            show_secrets,
+        } => run_list((*scope).into(), *show_secrets),
+        ConfigSubcommand::Get {
+            key,
+            scope,
+            show_secrets,
+        } => run_get(key, (*scope).into(), *show_secrets),
+        ConfigSubcommand::Set { key, value, scope } => run_set(key, value, (*scope).into()),
+        ConfigSubcommand::Unset { key, scope } => run_unset(key, (*scope).into()),
+    }
+}
+
+fn run_path(scope: ReadScope) -> Result<()> {
+    let path = store::path_for_read_scope(scope)?;
+    println!("{}", path.display());
+    Ok(())
+}
+
+fn run_list(scope: ReadScope, show_secrets: bool) -> Result<()> {
+    let cfg = store::load_dotfile_scope(scope)?;
+    let entries = store::list_entries(&cfg);
+    for (key, value, is_secret) in entries {
+        println!("{key}={}", render_value(&value, is_secret, show_secrets));
+    }
+    Ok(())
+}
+
+fn run_get(key_raw: &str, scope: ReadScope, show_secrets: bool) -> Result<()> {
+    let key = ConfigKey::parse(key_raw)?;
+    let cfg = store::load_dotfile_scope(scope)?;
+    let value = store::get_key_value(&cfg, &key).ok_or_else(|| {
+        anyhow!(
+            "Key '{key_raw}' is not set for scope '{}'.",
+            scope_name(scope)
+        )
+    })?;
+
+    println!(
+        "{key_raw}={}",
+        render_value(&value, key.is_secret(), show_secrets)
+    );
+    Ok(())
+}
+
+fn run_set(key_raw: &str, value: &str, scope: WriteScope) -> Result<()> {
+    let key = ConfigKey::parse(key_raw)?;
+    write::set(scope, &key, value)?;
+    let display_value = if key.is_secret() {
+        "****".to_string()
+    } else {
+        value.to_string()
+    };
+    println!(
+        "Set {key_raw}={display_value} in {} scope.",
+        scope_name_write(scope)
+    );
+    Ok(())
+}
+
+fn run_unset(key_raw: &str, scope: WriteScope) -> Result<()> {
+    let key = ConfigKey::parse(key_raw)?;
+    write::unset(scope, &key)?;
+    println!("Unset {key_raw} in {} scope.", scope_name_write(scope));
+    Ok(())
+}
+
+fn scope_name(scope: ReadScope) -> &'static str {
+    match scope {
+        ReadScope::Home => "home",
+        ReadScope::Local => "local",
+        ReadScope::Resolved => "resolved",
+    }
+}
+
+fn scope_name_write(scope: WriteScope) -> &'static str {
+    match scope {
+        WriteScope::Home => "home",
+        WriteScope::Local => "local",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cmd::config::key::InstanceField;
+
+    #[test]
+    fn parse_key_paths() {
+        assert!(matches!(
+            ConfigKey::parse("default_instance").unwrap(),
+            ConfigKey::DefaultInstance
+        ));
+        assert!(matches!(
+            ConfigKey::parse("instances.work.platform").unwrap(),
+            ConfigKey::InstanceField {
+                alias,
+                field: InstanceField::Platform
+            } if alias == "work"
+        ));
+    }
+}

package/src/cmd/config/render.rs

@@ -0,0 +1,33 @@
+pub(crate) fn mask_secret(value: &str) -> String {
+    if value.is_empty() {
+        return "****".to_string();
+    }
+    for prefix in ["github_pat_", "glpat_", "ghp_", "AT"] {
+        if value.starts_with(prefix) {
+            return format!("{prefix}****");
+        }
+    }
+    if value.len() <= 4 {
+        return "****".to_string();
+    }
+    format!("{}****", &value[..4])
+}
+
+pub(crate) fn render_value(value: &str, is_secret: bool, show_secrets: bool) -> String {
+    if is_secret && !show_secrets {
+        mask_secret(value)
+    } else {
+        value.to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn masks_prefix_tokens() {
+        assert_eq!(mask_secret("glpat_abc123"), "glpat_****");
+        assert_eq!(mask_secret("ATATT3xFfGF05..."), "AT****");
+    }
+}