Not a issue. Using github copilot

[ket000]

Can we not use GitHub copilot agent to generate and fix code. It would be nice to run the agent to loop thru code and suggest fixes.

[lhecker]

Are you saying we should use Copilot, but only for suggesting fixes, not for actually fixing them? In that case, that's fine with me, but I won't be using the bot for it (like what .NET is currently testing). Please feel free to use Copilot locally to find things that need fixing.

I'll be closing this issue for now. If you have any questions or would like to continue discussing this, please feel free to continue commenting here.

Relatedly, we've received lots and lots of PRs in the last few days that were clearly written by LLMs. Almost all of them were incorrect one way or another unfortunately, which did not spark a lot of joy. This mirrors my experience experimenting with Copilot Agent mode locally and as such I don't plan to use it in the foreseeable future.

[ket000]

I am using github copilot for my internal projects and it is very good at resolving the issue provided I am careful on reviewing the suggestion and still applying my intelligence. What I really wanting is to feed the code to github copilot , then explain the issue reported and see what it comes up with. Same with features for e.g. I want to take latest code and ask github copilot to modify so that it can open multiple files from command line (One of my feature requests) and also open them in a tab. (Will replace nedit as it is too slow over a wan link working on files hosted on remote servers). While I am not a rust expert, I have a good vision on what I want and see how copilot can help to add a feature that I can use. Since it is based on rust, setting up environment to compile it locally is very easy.

I am using copilot in my daily tasks and see what it comes up it. If it is garbage then throw it but if it useful then use it.

Eventually it will come up to a point where we will instead of writing code, will write features and bugs and copilot agent will simply implement it and then we can polish it to make sure it is doing what it supposed to.

Suggestion is to use it for advice, but only accept the advice if it passes your sanity check. Similar to you reviewing code changes provided by other contributors.

Also not sure if LLM can identify duplicate feature requests or bugs and automatically update the issue and make life easier. Based on your responses, I am not sure how you are keeping up to it.

My eventual motivation is to use this as a POC to test LLM capabilities as it matures and add features that I need even before it is added to official release or will never be added for whatever reason. Since the code is open source, it works perfectly. That is why I said not an issue.

Any way thanks for all this work and I am really excited for the future of this project as I now have a working cli editor that I can use in windows / mac / linux which I use for my work and have access to all 3 environments.

I am hoping rust eventually becomes defacto language for development. I have used copilot to convert lot of powershell or bash scripts to generate native rust code that can be simple executable that I can distribute to my users so that they can simply execute it without worrying about installation on configuration. These executables are what I call micro code that does only one thing for custom use case. With copilot I can now do it myself and if needed borrow code from what is already written.

Sorry for long post.

[ket000]

Just wanted to share this with you.

Time taken : 1 hour. Skills : Very basic rust language understanding.

Prompt for Github Copilot

can you read the rust code posted in https://github.com/microsoft/edit and add enhancement to add support to read multiple files from command line and open it in a tabbed interface. Currently it only supports opening one file from command line and does not open them in tabs. Once the editor is open it can open multiple files and we can access one file at a time.

It could not read the code at a link, but was able to read once I downloaded it and make suggestions.
No Tabbed interface yet/

1 Code Changes to enable multiple file support from command line with the help of github copilot

To do list : Add support for wildcard to filename.

final binary size with successfull code generation.

05/23/2025 04:05 PM 214,016 edit.exe

modified main.rs and document.rs

main.rs

modified handle_args function in main.rs
and DocumentManager in document.rs

====================
handle_args - main.rs

fn handle_args(state: &mut State) -> apperr::Result {
let mut cwd = env::current_dir()?;
let mut paths = Vec::new();

// Collect all positional arguments (skip options)
let mut args = env::args_os().skip(1);
while let Some(arg) = args.next() {
    if arg == "-h" || arg == "--help" || (cfg!(windows) && arg == "/?") {
        print_help();
        return Ok(true);
    } else if arg == "-v" || arg == "--version" {
        print_version();
        return Ok(true);
    } else if arg == "-" {
        // We'll check for a redirected stdin no matter what, so we can just ignore "-".
    } else if arg.to_string_lossy().starts_with('-') {
        // Skip unknown options for now
        continue;
    } else {
        let p = cwd.join(Path::new(&arg));
        let p = path::normalize(&p);
        if let Some(parent) = p.parent() {
            cwd = parent.to_path_buf();
        }
        paths.push(p);
    }
}

if let Some(mut file) = sys::open_stdin_if_redirected() {
    let doc = state.documents.add_untitled()?;
    let mut tb = doc.buffer.borrow_mut();
    tb.read_file(&mut file, None)?;
    tb.mark_as_dirty();
} else if !paths.is_empty() {
    for path in paths.iter() {
        state.documents.add_file_path_back(path)?;
    }
    // Set the first file as active tab (if any files were opened)
    if !paths.is_empty() {
        state.documents.set_active_by_index(0);
    }
} else {
    state.documents.add_untitled()?;
}

state.file_picker_pending_dir = DisplayablePathBuf::new(cwd);
Ok(false)

}

==========================
set_active_by_index - document.rs

/// Makes the document at the given index active (0 = front).
pub fn set_active_by_index(&mut self, idx: usize) {
    if idx == 0 || self.list.len() <= 1 {
        return;
    }
    let mut cursor = self.list.cursor_front_mut();
    for _ in 0..idx {
        if cursor.current().is_some() {
            cursor.move_next();
        } else {
            return; // idx out of bounds
        }
    }
    if cursor.current().is_some() {
        let list = cursor.remove_current_as_list().unwrap();
        self.list.cursor_front_mut().splice_before(list);
    }
}  

==========================
add_file_path_back - document.rs

pub fn add_file_path_back(&mut self, path: &Path) -> apperr::Result<&mut Document> {
let (path, goto) = Self::parse_filename_goto(path);
let path = path::normalize(path);

let mut file = match Self::open_for_reading(&path) {
    Ok(file) => Some(file),
    Err(err) if sys::apperr_is_not_found(err) => None,
    Err(err) => return Err(err),
};

let file_id = if file.is_some() { Some(sys::file_id(file.as_ref(), &path)?) } else { None };

// Check if the file is already open.
if file_id.is_some() && self.update_active(|doc| doc.file_id == file_id) {
    let doc = self.active_mut().unwrap();
    if let Some(goto) = goto {
        doc.buffer.borrow_mut().cursor_move_to_logical(goto);
    }
    return Ok(doc);
}

let buffer = TextBuffer::new_rc(false)?;
{
    let mut tb = buffer.borrow_mut();
    tb.set_margin_enabled(true);
    tb.set_line_highlight_enabled(true);

    if let Some(file) = &mut file {
        tb.read_file(file, None)?;

        if let Some(goto) = goto
            && goto != Default::default()
        {
            tb.cursor_move_to_logical(goto);
        }
    }
}

let mut doc = Document {
    buffer,
    path: None,
    dir: None,
    filename: Default::default(),
    file_id,
    new_file_counter: 0,
};
doc.set_path(path);

self.list.push_back(doc);
Ok(self.list.back_mut().unwrap())

}

[lhecker]

add_file_path_back is redundant with what we already have, but this approach is very similar to what I suggested here: #143 (comment)
That's quite nice. You can try to implement features with this if you'd like. But you have to test your changes locally before submitting a PR. I won't be able to assist you too much, since I only have a few hours each day to respond to everyone on Github.

[ket000]

I understand. I do not expect you to take my code or even implement my changes. My point is github copilot is empowering me to implement what I want immediately instead of waiting for days or months to what I need instead of mainstream code to implement the same. It may not be most efficient but meets my need. I know eventually your team may add the features or you may never add for valid reasons. Previously I could not imagine doing thing like this without understanding the language syntax or spending many hours trying to build one. This is just 2 years of github copilot. With more advancement in future, I can not imagine where it goes. Again not expecting anything from you, but wanted to share if this benefits anyone. Also in the process learning new skills. I know adding third party crates increases the binary size, but for my need that is fine. It is still very small file and does what I really want.

Updated code using glob 0.3.2 crate to handle wild cards in command line argument. All generated by copilot. While this may not be most efficient, it works and satisfies my need. With code expertise you have, you might be able to generate much efficient code or tweak the generated code. Now only thing I need is tab support and I am good.

so I can now run
edit.exe f*.sql and it opens all the files and I can navigate. I Can use ctrl + P and up or down arrow to navigate.

binary size : 05/23/2025 05:11 PM 227,328 edit.exe

[dependencies]
glob = "0.3.2"

====================
handle_args - main.rs - wildcard

fn handle_args(state: &mut State) -> apperr::Result {
let mut cwd = env::current_dir()?;
let mut paths = Vec::new();

// Collect all positional arguments (skip options)
let mut args = env::args_os().skip(1);
while let Some(arg) = args.next() {
    if arg == "-h" || arg == "--help" || (cfg!(windows) && arg == "/?") {
        print_help();
        return Ok(true);
    } else if arg == "-v" || arg == "--version" {
        print_version();
        return Ok(true);
    } else if arg == "-" {
        // We'll check for a redirected stdin no matter what, so we can just ignore "-".
    } else if arg.to_string_lossy().starts_with('-') {
        // Skip unknown options for now
        continue;
    } else {
        // Check for wildcard characters
        let arg_str = arg.to_string_lossy();
        if arg_str.contains('*') || arg_str.contains('?') || arg_str.contains('[') {
            // Expand wildcard
            let pattern = cwd.join(&arg).to_string_lossy().to_string();
            for entry in glob(&pattern).expect("Failed to read glob pattern") {
                if let Ok(path) = entry {
                    let p = path::normalize(&path);
                    if let Some(parent) = p.parent() {
                        cwd = parent.to_path_buf();
                    }
                    paths.push(p);
                }
            }
        } else {
            let p = cwd.join(&arg);
            let p = path::normalize(&p);
            if let Some(parent) = p.parent() {
                cwd = parent.to_path_buf();
            }
            paths.push(p);
        }

    }
}

if let Some(mut file) = sys::open_stdin_if_redirected() {
    let doc = state.documents.add_untitled()?;
    let mut tb = doc.buffer.borrow_mut();
    tb.read_file(&mut file, None)?;
    tb.mark_as_dirty();
} else if !paths.is_empty() {
    for path in paths.iter() {
        state.documents.add_file_path_back(path)?;
    }
    // Set the first file as active tab (if any files were opened)
    if !paths.is_empty() {
        state.documents.set_active_by_index(0);
    }
} else {
    state.documents.add_untitled()?;
}

state.file_picker_pending_dir = DisplayablePathBuf::new(cwd);
Ok(false)

}

[lhecker]

That's not something I'd make part of the editor. In my opinion, glob expressions should generally be handled by the shell. That is, when you type edit *.txt in Linux, your shell will replace it with all matches. Edit doesn't need to do anything beyond that. (This works slightly different on Windows with PowerShell.) Put differently, it's rare that you would use glob for parsing arguments.

[ket000]

Got it. On windows terminal using * does not expand it. Linux does. Again no expectation that you will implement it. I was just demoing the concept that each end user can use to customize it for their use case with minimal effort. Without glob it does not work on windows. On the other hand nano.exe handles it. Again this is a nuance of cross platform work.