commit 6ee4129ccbd1fa9955cbee62e7299d4e8d41f541 · dunkirk.sh/tangled-cli

+54 -1

crates/tangled-api/src/client.rs

···

       49
       49
        
               Ok(res.json::<TRes>().await?)

     

       50
       50
        
           }

     

       51
       51
        
       

     

       52
       52
       -
           async fn get_json<TRes: DeserializeOwned>(

     

       52
       52
       +
           pub async fn get_json<TRes: DeserializeOwned>(

     

       53
       53
        
               &self,

     

       54
       54
        
               method: &str,

     

       55
       55
        
               params: &[(&str, String)],

     
···

       1121
       1121
        
                   .post_json("com.atproto.repo.createRecord", &req, Some(access_jwt))

     

       1122
       1122
        
                   .await?;

     

       1123
       1123
        
               Self::uri_rkey(&res.uri).ok_or_else(|| anyhow!("missing rkey in pull comment uri"))

     

       1124
       1124
       +
           }

     

       1125
       1125
       +
       

     

       1126
       1126
       +
           pub async fn merge_pull(

     

       1127
       1127
       +
               &self,

     

       1128
       1128
       +
               pull_did: &str,

     

       1129
       1129
       +
               pull_rkey: &str,

     

       1130
       1130
       +
               repo_did: &str,

     

       1131
       1131
       +
               repo_name: &str,

     

       1132
       1132
       +
               pds_base: &str,

     

       1133
       1133
       +
               access_jwt: &str,

     

       1134
       1134
       +
           ) -> Result<()> {

     

       1135
       1135
       +
               // Fetch the pull request to get patch and target branch

     

       1136
       1136
       +
               let pds_client = TangledClient::new(pds_base);

     

       1137
       1137
       +
               let pull = pds_client

     

       1138
       1138
       +
                   .get_pull_record(pull_did, pull_rkey, Some(access_jwt))

     

       1139
       1139
       +
                   .await?;

     

       1140
       1140
       +
       

     

       1141
       1141
       +
               // Get service auth token for the knot

     

       1142
       1142
       +
               let sa = self.service_auth_token(pds_base, access_jwt).await?;

     

       1143
       1143
       +
       

     

       1144
       1144
       +
               #[derive(Serialize)]

     

       1145
       1145
       +
               struct MergeReq<'a> {

     

       1146
       1146
       +
                   did: &'a str,

     

       1147
       1147
       +
                   name: &'a str,

     

       1148
       1148
       +
                   patch: &'a str,

     

       1149
       1149
       +
                   branch: &'a str,

     

       1150
       1150
       +
                   #[serde(skip_serializing_if = "Option::is_none")]

     

       1151
       1151
       +
                   #[serde(rename = "commitMessage")]

     

       1152
       1152
       +
                   commit_message: Option<&'a str>,

     

       1153
       1153
       +
                   #[serde(skip_serializing_if = "Option::is_none")]

     

       1154
       1154
       +
                   #[serde(rename = "commitBody")]

     

       1155
       1155
       +
                   commit_body: Option<&'a str>,

     

       1156
       1156
       +
               }

     

       1157
       1157
       +
       

     

       1158
       1158
       +
               let commit_body = if pull.body.is_empty() {

     

       1159
       1159
       +
                   None

     

       1160
       1160
       +
               } else {

     

       1161
       1161
       +
                   Some(pull.body.as_str())

     

       1162
       1162
       +
               };

     

       1163
       1163
       +
       

     

       1164
       1164
       +
               let req = MergeReq {

     

       1165
       1165
       +
                   did: repo_did,

     

       1166
       1166
       +
                   name: repo_name,

     

       1167
       1167
       +
                   patch: &pull.patch,

     

       1168
       1168
       +
                   branch: &pull.target.branch,

     

       1169
       1169
       +
                   commit_message: Some(&pull.title),

     

       1170
       1170
       +
                   commit_body,

     

       1171
       1171
       +
               };

     

       1172
       1172
       +
       

     

       1173
       1173
       +
               let _: serde_json::Value = self

     

       1174
       1174
       +
                   .post_json("sh.tangled.repo.merge", &req, Some(&sa))

     

       1175
       1175
       +
                   .await?;

     

       1176
       1176
       +
               Ok(())

     

       1124
       1177
        
           }

     

       1125
       1178
        
       }

     

       1126
       1179

-40

crates/tangled-cli/src/cli.rs

···

       284
       284
        
       #[derive(Args, Debug, Clone)]

     

       285
       285
        
       pub struct PrMergeArgs {

     

       286
       286
        
           pub id: String,

     

       287
       287
       -
           #[arg(long, default_value_t = false)]

     

       288
       288
       -
           pub squash: bool,

     

       289
       289
       -
           #[arg(long, default_value_t = false)]

     

       290
       290
       -
           pub rebase: bool,

     

       291
       291
       -
           #[arg(long, default_value_t = false)]

     

       292
       292
       -
           pub no_ff: bool,

     

       293
       287
        
       }

     

       294
       288
        
       

     

       295
       289
        
       #[derive(Subcommand, Debug, Clone)]

     

       296
       290
        
       pub enum KnotCommand {

     

       297
       297
       -
           List(KnotListArgs),

     

       298
       298
       -
           Add(KnotAddArgs),

     

       299
       299
       -
           Verify(KnotVerifyArgs),

     

       300
       300
       -
           SetDefault(KnotRefArgs),

     

       301
       301
       -
           Remove(KnotRefArgs),

     

       302
       291
        
           /// Migrate a repository to another knot

     

       303
       292
        
           Migrate(KnotMigrateArgs),

     

       304
       304
       -
       }

     

       305
       305
       -
       

     

       306
       306
       -
       #[derive(Args, Debug, Clone)]

     

       307
       307
       -
       pub struct KnotListArgs {

     

       308
       308
       -
           #[arg(long, default_value_t = false)]

     

       309
       309
       -
           pub public: bool,

     

       310
       310
       -
           #[arg(long, default_value_t = false)]

     

       311
       311
       -
           pub owned: bool,

     

       312
       312
       -
       }

     

       313
       313
       -
       

     

       314
       314
       -
       #[derive(Args, Debug, Clone)]

     

       315
       315
       -
       pub struct KnotAddArgs {

     

       316
       316
       -
           pub url: String,

     

       317
       317
       -
           #[arg(long)]

     

       318
       318
       -
           pub did: Option<String>,

     

       319
       319
       -
           #[arg(long)]

     

       320
       320
       -
           pub name: Option<String>,

     

       321
       321
       -
           #[arg(long, default_value_t = false)]

     

       322
       322
       -
           pub verify: bool,

     

       323
       323
       -
       }

     

       324
       324
       -
       

     

       325
       325
       -
       #[derive(Args, Debug, Clone)]

     

       326
       326
       -
       pub struct KnotVerifyArgs {

     

       327
       327
       -
           pub url: String,

     

       328
       328
       -
       }

     

       329
       329
       -
       

     

       330
       330
       -
       #[derive(Args, Debug, Clone)]

     

       331
       331
       -
       pub struct KnotRefArgs {

     

       332
       332
       -
           pub url: String,

     

       333
       293
        
       }

     

       334
       294
        
       

     

       335
       295
        
       #[derive(Args, Debug, Clone)]

+1 -39

crates/tangled-cli/src/commands/knot.rs

···

       1
       1
       -
       use crate::cli::{

     

       2
       2
       -
           Cli, KnotAddArgs, KnotCommand, KnotListArgs, KnotMigrateArgs, KnotRefArgs, KnotVerifyArgs,

     

       3
       3
       -
       };

     

       1
       1
       +
       use crate::cli::{Cli, KnotCommand, KnotMigrateArgs};

     

       4
       2
        
       use anyhow::anyhow;

     

       5
       3
        
       use anyhow::Result;

     

       6
       4
        
       use git2::{Direction, Repository as GitRepository, StatusOptions};

     
···

       9
       7
        
       

     

       10
       8
        
       pub async fn run(_cli: &Cli, cmd: KnotCommand) -> Result<()> {

     

       11
       9
        
           match cmd {

     

       12
       12
       -
               KnotCommand::List(args) => list(args).await,

     

       13
       13
       -
               KnotCommand::Add(args) => add(args).await,

     

       14
       14
       -
               KnotCommand::Verify(args) => verify(args).await,

     

       15
       15
       -
               KnotCommand::SetDefault(args) => set_default(args).await,

     

       16
       16
       -
               KnotCommand::Remove(args) => remove(args).await,

     

       17
       10
        
               KnotCommand::Migrate(args) => migrate(args).await,

     

       18
       11
        
           }

     

       19
       19
       -
       }

     

       20
       20
       -
       

     

       21
       21
       -
       async fn list(args: KnotListArgs) -> Result<()> {

     

       22
       22
       -
           println!(

     

       23
       23
       -
               "Knot list (stub) public={} owned={}",

     

       24
       24
       -
               args.public, args.owned

     

       25
       25
       -
           );

     

       26
       26
       -
           Ok(())

     

       27
       27
       -
       }

     

       28
       28
       -
       

     

       29
       29
       -
       async fn add(args: KnotAddArgs) -> Result<()> {

     

       30
       30
       -
           println!(

     

       31
       31
       -
               "Knot add (stub) url={} did={:?} name={:?} verify={}",

     

       32
       32
       -
               args.url, args.did, args.name, args.verify

     

       33
       33
       -
           );

     

       34
       34
       -
           Ok(())

     

       35
       35
       -
       }

     

       36
       36
       -
       

     

       37
       37
       -
       async fn verify(args: KnotVerifyArgs) -> Result<()> {

     

       38
       38
       -
           println!("Knot verify (stub) url={}", args.url);

     

       39
       39
       -
           Ok(())

     

       40
       40
       -
       }

     

       41
       41
       -
       

     

       42
       42
       -
       async fn set_default(args: KnotRefArgs) -> Result<()> {

     

       43
       43
       -
           println!("Knot set-default (stub) url={}", args.url);

     

       44
       44
       -
           Ok(())

     

       45
       45
       -
       }

     

       46
       46
       -
       

     

       47
       47
       -
       async fn remove(args: KnotRefArgs) -> Result<()> {

     

       48
       48
       -
           println!("Knot remove (stub) url={}", args.url);

     

       49
       49
       -
           Ok(())

     

       50
       12
        
       }

     

       51
       13
        
       

     

       52
       14
        
       async fn migrate(args: KnotMigrateArgs) -> Result<()> {

+65 -3

crates/tangled-cli/src/commands/pr.rs

···

       183
       183
        
           Ok(())

     

       184
       184
        
       }

     

       185
       185
        
       

     

       186
       186
       -
       async fn merge(_args: PrMergeArgs) -> Result<()> {

     

       187
       187
       -
           // Placeholder: merging requires server-side merge call with the patch and target branch.

     

       188
       188
       -
           println!("Merge via CLI is not implemented yet. Use the web UI for now.");

     

       186
       186
       +
       async fn merge(args: PrMergeArgs) -> Result<()> {

     

       187
       187
       +
           let mgr = SessionManager::default();

     

       188
       188
       +
           let session = mgr

     

       189
       189
       +
               .load()?

     

       190
       190
       +
               .ok_or_else(|| anyhow!("Please login first: tangled auth login"))?;

     

       191
       191
       +
           let (did, rkey) = parse_record_id(&args.id, &session.did)?;

     

       192
       192
       +
           let pds = session

     

       193
       193
       +
               .pds

     

       194
       194
       +
               .clone()

     

       195
       195
       +
               .or_else(|| std::env::var("TANGLED_PDS_BASE").ok())

     

       196
       196
       +
               .unwrap_or_else(|| "https://bsky.social".into());

     

       197
       197
       +
       

     

       198
       198
       +
           // Get the PR to find the target repo

     

       199
       199
       +
           let pds_client = tangled_api::TangledClient::new(&pds);

     

       200
       200
       +
           let pull = pds_client

     

       201
       201
       +
               .get_pull_record(&did, &rkey, Some(session.access_jwt.as_str()))

     

       202
       202
       +
               .await?;

     

       203
       203
       +
       

     

       204
       204
       +
           // Parse the target repo AT-URI to get did and name

     

       205
       205
       +
           let target_repo = &pull.target.repo;

     

       206
       206
       +
           // Format: at://did:plc:.../sh.tangled.repo/rkey

     

       207
       207
       +
           let parts: Vec<&str> = target_repo.strip_prefix("at://").unwrap_or(target_repo).split('/').collect();

     

       208
       208
       +
           if parts.len() < 2 {

     

       209
       209
       +
               return Err(anyhow!("Invalid target repo AT-URI: {}", target_repo));

     

       210
       210
       +
           }

     

       211
       211
       +
           let repo_did = parts[0];

     

       212
       212
       +
       

     

       213
       213
       +
           // Get repo info to find the name

     

       214
       214
       +
           // Parse rkey from target repo AT-URI

     

       215
       215
       +
           let repo_rkey = if parts.len() >= 4 {

     

       216
       216
       +
               parts[3]

     

       217
       217
       +
           } else {

     

       218
       218
       +
               return Err(anyhow!("Invalid target repo AT-URI: {}", target_repo));

     

       219
       219
       +
           };

     

       220
       220
       +
       

     

       221
       221
       +
           #[derive(serde::Deserialize)]

     

       222
       222
       +
           struct Rec {

     

       223
       223
       +
               name: String,

     

       224
       224
       +
           }

     

       225
       225
       +
           #[derive(serde::Deserialize)]

     

       226
       226
       +
           struct GetRes {

     

       227
       227
       +
               value: Rec,

     

       228
       228
       +
           }

     

       229
       229
       +
           let params = [

     

       230
       230
       +
               ("repo", repo_did.to_string()),

     

       231
       231
       +
               ("collection", "sh.tangled.repo".to_string()),

     

       232
       232
       +
               ("rkey", repo_rkey.to_string()),

     

       233
       233
       +
           ];

     

       234
       234
       +
           let repo_rec: GetRes = pds_client

     

       235
       235
       +
               .get_json("com.atproto.repo.getRecord", &params, Some(session.access_jwt.as_str()))

     

       236
       236
       +
               .await?;

     

       237
       237
       +
       

     

       238
       238
       +
           // Call merge on the default Tangled API base (tngl.sh)

     

       239
       239
       +
           let api = tangled_api::TangledClient::default();

     

       240
       240
       +
           api.merge_pull(

     

       241
       241
       +
               &did,

     

       242
       242
       +
               &rkey,

     

       243
       243
       +
               repo_did,

     

       244
       244
       +
               &repo_rec.value.name,

     

       245
       245
       +
               &pds,

     

       246
       246
       +
               &session.access_jwt,

     

       247
       247
       +
           )

     

       248
       248
       +
           .await?;

     

       249
       249
       +
       

     

       250
       250
       +
           println!("Merged PR {}:{}", did, rkey);

     

       189
       251
        
           Ok(())

     

       190
       252
        
       }

     

       191
       253