finchie/pijul_extension - Change OUADGWKR6A7G3UHCLSC7AWLJIMS45Y56NPVTQ7FENJPYNTAMXXMAC

Create fully-initialized `SourceControl` object in `event_loop`

Uses a ThreadsafeFunction to perform JS function calls - mainly scm::create_source_control and SourceControl::create_resource_group. The only relevant functionality not yet implemented is QuickDiffProvider, which will be added in an upcoming change.

Created by finchie on December 22, 2025

OUADGWKR6A7G3UHCLSC7AWLJIMS45Y56NPVTQ7FENJPYNTAMXXMAC

Dependencies

In channels

main

Change contents

Replacement in extensions/vscode/src/lib.rs at line 393 [2.108513]
B:BD[2.118517] → [6.642:682]
```
    event_loop::start(&vscode_object)?;
```
[2.118517]
[3.114]
```
    event_loop::start(env, &vscode_object)?;
```

Replacement in extensions/vscode/src/event_loop/threadsafe_function.rs at line 6 [5.772]

B:BD[5.866] → [5.866:965]

    create_source_control: vscode_sys::threadsafe_function::scm::create_source_control::Prototype,

[5.866]

[6.729]

    initialize_source_control: initialize_source_control::Prototype,

Replacement in extensions/vscode/src/event_loop/threadsafe_function.rs at line 11 [5.772]

B:BD[5.995] → [6.799:869]

    pub fn get(vscode_object: &Object) -> Result<Self, napi::Error> {

[5.995]

[5.1058]

    pub fn get(env: &napi::Env, vscode_object: &Object) -> Result<Self, napi::Error> {

Replacement in extensions/vscode/src/event_loop/threadsafe_function.rs at line 13 [5.772]

B:BD[5.1076] → [5.1076:1111]

B:BD[5.1111] → [6.870:968]

            create_source_control:
                vscode_sys::threadsafe_function::scm::create_source_control::get(vscode_object)?,

[5.1076]

[6.968]

            initialize_source_control: env
                .create_function_from_closure(
                    "initialize_source_control",
                    initialize_source_control::callback,
                )?
                .build_threadsafe_function()
                .build()?,

Replacement in extensions/vscode/src/event_loop/threadsafe_function.rs at line 24 [5.772]
B:BD[5.1217] → [5.1217:1257]
```
    pub async fn create_source_control(
```
[5.1217]
[5.1257]
```
    pub async fn initialize_source_control(
```
Deletion in extensions/vscode/src/event_loop/threadsafe_function.rs at line 26 [5.772]
B:BD[5.1272] → [5.1272:1314]
```
        id: String,
        name: String,
```

Replacement in extensions/vscode/src/event_loop/threadsafe_function.rs at line 27 [5.772]

∅:D[6.1107] → [5.1333:1405]

B:BD[5.1333] → [5.1333:1405]

B:BD[5.1405] → [6.1108:1169]

    ) -> Result<vscode_sys::reference::SourceControlRef, napi::Error> {
        let arguments = FnArgs::from((id, name, Some(uri)));

[6.1107]

[5.1461]

        pijul_label: String,
        changes_label: String,
        untracked_label: String,
    ) -> Result<
        (
            vscode_sys::reference::SourceControlRef,
            vscode_sys::reference::SourceControlResourceGroupRef,
            vscode_sys::reference::SourceControlResourceGroupRef,
        ),
        napi::Error,
    > {
        let arguments = FnArgs::from((uri, pijul_label, changes_label, untracked_label));

Replacement in extensions/vscode/src/event_loop/threadsafe_function.rs at line 40 [5.772]

B:BD[5.1462] → [5.1462:1525]

        self.create_source_control.call_async(arguments).await

[5.1462]

[6.1170]

        self.initialize_source_control.call_async(arguments).await

Insertion in extensions/vscode/src/event_loop/threadsafe_function.rs at line 50 [5.772]

[6.1401]

[5.1525]

    }
}
mod initialize_source_control {
    use napi::bindgen_prelude::{FnArgs, FunctionCallContext};
    use crate::vscode_sys;
    pub type Arguments = (vscode_sys::reference::UriRef, String, String, String);
    pub type Return = (
        vscode_sys::reference::SourceControlRef,
        vscode_sys::reference::SourceControlResourceGroupRef,
        vscode_sys::reference::SourceControlResourceGroupRef,
    );
    pub type Prototype = napi::threadsafe_function::ThreadsafeFunction<
        FnArgs<Arguments>,
        Return,
        FnArgs<Arguments>,
        napi::Status,
        false,
        false,
        0,
    >;
    pub fn callback(function_call_context: FunctionCallContext) -> Result<Return, napi::Error> {
        let (repository_uri_ref, pijul_label, changes_label, untracked_label): Arguments =
            function_call_context.args()?;
        let source_control = vscode_sys::scm::create_source_control(
            function_call_context.env,
            "pijul",
            &pijul_label,
            &repository_uri_ref.get_inner(function_call_context.env)?,
        )?;
        let unrecorded_changes = source_control.create_resource_group("changes", &changes_label)?;
        let untracked_paths =
            source_control.create_resource_group("untracked", &untracked_label)?;
        Ok((
            source_control.create_ref()?,
            unrecorded_changes.create_ref()?,
            untracked_paths.create_ref()?,
        ))

Insertion in extensions/vscode/src/event_loop/mod.rs at line 1 [3.171]
[3.171]
[3.172]
```
use std::collections::HashMap;
```
Insertion in extensions/vscode/src/event_loop/mod.rs at line 7 [3.171]
[3.259]
[4.1732]
```
use crate::vscode_sys;
```

Insertion in extensions/vscode/src/event_loop/mod.rs at line 19 [3.171]

[5.1618]

}
struct Repository {
    repository: pijul_extension::FileSystemRepository,
    source_control: vscode_sys::reference::SourceControlRef,
    open_editors: HashMap<Utf8PathBuf, vscode_sys::reference::TextEditorRef>,
    unrecorded_changes: vscode_sys::reference::SourceControlResourceGroupRef,
    untracked_paths: vscode_sys::reference::SourceControlResourceGroupRef,

Insertion in extensions/vscode/src/event_loop/mod.rs at line 35 [3.171]
[3.560]
[3.560]
```
    let mut repositories: HashMap<Utf8PathBuf, Repository> = HashMap::new();
```

Replacement in extensions/vscode/src/event_loop/mod.rs at line 71 [3.171]

B:BD[6.2356] → [6.2356:2428]

                    let repository_uri_ref = match threadsafe_functions

[6.2356]

[6.2428]

                    let std::collections::hash_map::Entry::Vacant(repository_entry) =
                        repositories.entry(repository_path.clone())
                    else {
                        tracing::warn!(message = "Ignoring existing repository");
                        continue;
                    };
                    let repository_uri = match threadsafe_functions

Replacement in extensions/vscode/src/event_loop/mod.rs at line 82 [3.171]

B:BD[6.2544] → [6.2544:2614]

                        Ok(repository_uri_ref) => repository_uri_ref,

[6.2544]

[6.2614]

                        Ok(repository_uri) => repository_uri,

Insertion in extensions/vscode/src/event_loop/mod.rs at line 92 [3.171]

[6.2971]


                    let (source_control, unrecorded_changes, untracked_paths) =
                        match threadsafe_functions
                            .initialize_source_control(
                                repository_uri,
                                String::from("Pijul"),
                                String::from("Changes"),
                                String::from("Untracked"),
                            )
                            .await
                        {
                            Ok(initialized_source_control) => initialized_source_control,
                            Err(error) => {
                                tracing::error!(
                                    message = "Unable to create source control",
                                    ?error
                                );
                                continue;
                            }
                        };

Replacement in extensions/vscode/src/event_loop/mod.rs at line 113 [3.171]

∅:D[6.2972] → [5.2001:2073]

B:BD[5.2001] → [5.2001:2073]

B:BD[5.2073] → [6.2973:3197]

∅:D[6.3197] → [5.2171:2519]

B:BD[5.2171] → [5.2171:2519]

                    let source_control_ref = match threadsafe_functions
                        .create_source_control(
                            String::from("pijul"),
                            String::from("Pijul"),
                            repository_uri_ref,
                        )
                        .await
                    {
                        Ok(source_control_ref) => source_control_ref,
                        Err(error) => {
                            tracing::error!(message = "Unable to create source control", ?error);
                            continue;
                        }
                    };

[6.2972]

[6.3198]

                    let file_system_repository =
                        match pijul_extension::FileSystemRepository::new(&repository_path) {
                            Ok(repository) => repository,
                            Err(error) => {
                                tracing::error!(message = "Failed to open repository", ?error);
                                continue;
                            }
                        };
                    repository_entry.insert(Repository {
                        repository: file_system_repository,
                        source_control,
                        open_editors: HashMap::new(),
                        unrecorded_changes,
                        untracked_paths,
                    });

Replacement in extensions/vscode/src/event_loop/mod.rs at line 130 [3.171]

B:BD[6.3199] → [6.3199:3289]

                    tracing::info!(message = "Opened workspace folder", ?workspace_path);

[6.3199]

[5.2519]

                    tracing::info!(
                        message = "Opened repository",
                        ?repository_path,
                        ?workspace_path
                    );

Replacement in extensions/vscode/src/event_loop/mod.rs at line 146 [3.171]

B:BD[5.2595] → [6.3290:3473]

pub fn start(vscode_object: &napi::bindgen_prelude::Object) -> Result<(), napi::Error> {
    let threadsafe_functions = threadsafe_function::ThreadsafeFunctions::get(vscode_object)?;

[5.2595]

[5.2738]

pub fn start(
    env: &napi::Env,
    vscode_object: &napi::bindgen_prelude::Object,
) -> Result<(), napi::Error> {
    let threadsafe_functions = threadsafe_function::ThreadsafeFunctions::get(env, vscode_object)?;