chore: remaining renamings (#582)

- PgTPath -> PgLSPath
- PgTCommand -> PgLSCommand

and a bunch of updates within comments

Author: psteinroe

.vscode/settings.json

@@ -1,3 +1,3 @@
 {
-  "postgrestools.bin": "./target/debug/postgrestools"
+  "postgres-language-server.bin": "./target/debug/postgres-language-server"
 }

AGENTS.md

@@ -62,11 +62,11 @@ just new-crate <name>
 ```
 
 ### CLI Usage
-The main CLI binary is `postgrestools`:
+The main CLI binary is `postgres-language-server` (legacy name: `postgrestools`):
 ```bash
 cargo run -p pgls_cli -- check file.sql
 # or after building:
-./target/release/postgrestools check file.sql
+./target/release/postgres-language-server check file.sql
 ```
 
 ## Architecture
@@ -103,8 +103,8 @@ The project uses a modular Rust workspace with crates prefixed with `pgls_`:
 ### TypeScript Packages
 Located in `packages/` and `editors/`:
 - VSCode extension in `editors/code/`
-- Backend JSON-RPC bridge in `packages/@postgrestools/backend-jsonrpc/`
-- Main TypeScript package in `packages/@postgrestools/postgrestools/`
+- Backend JSON-RPC bridge in `packages/@postgres-language-server/backend-jsonrpc/` (legacy: `packages/@postgrestools/backend-jsonrpc/`)
+- Main TypeScript package in `packages/@postgres-language-server/postgres-language-server/` (legacy: `packages/@postgrestools/postgrestools/`)
 
 ### Database Integration
 The server connects to a Postgres database to build an in-memory schema cache containing tables, columns, functions, and type information. This enables accurate autocompletion and type checking.
@@ -150,6 +150,21 @@ Many parser structures are generated from PostgreSQL's protobuf definitions usin
 ### Database Schema
 The `pgls_schema_cache` crate contains SQL queries in `src/queries/` that introspect the database schema to build the in-memory cache.
 
-### Multi-Platform Support  
+### Code Refactoring Tools
+The project has `ast-grep` available for advanced code search and refactoring tasks. ast-grep is a structural search/replace tool that understands code syntax, making it useful for:
+- Renaming types, functions, or variables across the codebase
+- Finding and replacing code patterns
+- Performing structural code transformations
+
+Example usage:
+```bash
+# Search for a pattern
+ast-grep --pattern 'struct $NAME { $$$FIELDS }'
+
+# Replace a pattern across files
+ast-grep --pattern 'OldType' --rewrite 'NewType' --update-all
+```
+
+### Multi-Platform Support
 The project includes platform-specific allocators and build configurations for Windows, macOS, and Linux.
 - Seeing the Treesitter tree for an SQL query can be helpful to debug and implement features. To do this, create a file with an SQL query, and run `just tree-print <file.sql>`.

crates/pgls_cli/src/commands/mod.rs

@@ -19,7 +19,7 @@ pub(crate) mod version;
 #[bpaf(options, version(VERSION))]
 #[allow(clippy::large_enum_variant)]
 /// Postgres Tools official CLI. Use it to check the health of your project or run it to check single files.
-pub enum PgtCommand {
+pub enum PgLSCommand {
     /// Shows the version information and quit.
     #[bpaf(command)]
     Version(#[bpaf(external(cli_options), hide_usage)] CliOptions),
@@ -218,19 +218,19 @@ pub enum PgtCommand {
     PrintSocket,
 }
 
-impl PgtCommand {
+impl PgLSCommand {
     const fn cli_options(&self) -> Option<&CliOptions> {
         match self {
-            PgtCommand::Version(cli_options)
-            | PgtCommand::Check { cli_options, .. }
-            | PgtCommand::Dblint { cli_options, .. } => Some(cli_options),
-            PgtCommand::LspProxy { .. }
-            | PgtCommand::Start { .. }
-            | PgtCommand::Stop
-            | PgtCommand::Init
-            | PgtCommand::RunServer { .. }
-            | PgtCommand::Clean
-            | PgtCommand::PrintSocket => None,
+            PgLSCommand::Version(cli_options)
+            | PgLSCommand::Check { cli_options, .. }
+            | PgLSCommand::Dblint { cli_options, .. } => Some(cli_options),
+            PgLSCommand::LspProxy { .. }
+            | PgLSCommand::Start { .. }
+            | PgLSCommand::Stop
+            | PgLSCommand::Init
+            | PgLSCommand::RunServer { .. }
+            | PgLSCommand::Clean
+            | PgLSCommand::PrintSocket => None,
         }
     }
 
@@ -315,6 +315,6 @@ mod tests {
     /// Tests that all CLI options adhere to the invariants expected by `bpaf`.
     #[test]
     fn check_options() {
-        pgt_command().check_invariants(false);
+        pg_l_s_command().check_invariants(false);
     }
 }

crates/pgls_cli/src/execute/process_file.rs

@@ -5,7 +5,7 @@ use crate::execute::config::ExecutionMode;
 use crate::execute::walk::TraversalOptions;
 use check::check_file;
 use pgls_diagnostics::Error;
-use pgls_fs::PgTPath;
+use pgls_fs::PgLSPath;
 use std::marker::PhantomData;
 use std::ops::Deref;
 
@@ -103,7 +103,7 @@ impl<'ctx, 'app> Deref for SharedTraversalOptions<'ctx, 'app> {
 /// diagnostics were emitted, or compare the formatted code with the original
 /// content of the file and emit a diff or write the new content to the disk if
 /// write mode is enabled
-pub(crate) fn process_file(ctx: &TraversalOptions, pgls_path: &PgTPath) -> FileResult {
+pub(crate) fn process_file(ctx: &TraversalOptions, pgls_path: &PgLSPath) -> FileResult {
     tracing::trace_span!("process_file", path = ?pgls_path).in_scope(move || {
         let shared_context = &SharedTraversalOptions::new(ctx);
 

crates/pgls_cli/src/execute/process_file/workspace_file.rs

@@ -1,7 +1,7 @@
 use crate::execute::diagnostics::{ResultExt, ResultIoExt};
 use crate::execute::process_file::SharedTraversalOptions;
 use pgls_diagnostics::{Error, category};
-use pgls_fs::{File, OpenOptions, PgTPath};
+use pgls_fs::{File, OpenOptions, PgLSPath};
 use pgls_workspace::workspace::{FileGuard, OpenFileParams};
 use pgls_workspace::{Workspace, WorkspaceError};
 use std::path::{Path, PathBuf};
@@ -24,7 +24,7 @@ impl<'ctx, 'app> WorkspaceFile<'ctx, 'app> {
         ctx: &SharedTraversalOptions<'ctx, 'app>,
         path: &Path,
     ) -> Result<Self, Error> {
-        let pgls_path = PgTPath::new(path);
+        let pgls_path = PgLSPath::new(path);
         let open_options = OpenOptions::default()
             .read(true)
             .write(ctx.config.allows_writes());

crates/pgls_cli/src/execute/walk.rs

@@ -5,7 +5,7 @@ use crate::reporter::{Report, TraversalData};
 use crate::{CliDiagnostic, CliSession};
 use crossbeam::channel::{Receiver, Sender, unbounded};
 use pgls_diagnostics::{DiagnosticExt, Error, Resource};
-use pgls_fs::{FileSystem, PathInterner, PgTPath};
+use pgls_fs::{FileSystem, PathInterner, PgLSPath};
 use pgls_fs::{TraversalContext, TraversalScope};
 use pgls_workspace::dome::Dome;
 use pgls_workspace::workspace::IsPathIgnoredParams;
@@ -133,7 +133,7 @@ fn traverse_inputs(
     fs: &dyn FileSystem,
     inputs: Vec<OsString>,
     ctx: &TraversalOptions,
-) -> (Duration, BTreeSet<PgTPath>) {
+) -> (Duration, BTreeSet<PgLSPath>) {
     let start = Instant::now();
     fs.traversal(Box::new(move |scope: &dyn TraversalScope| {
         for input in inputs {
@@ -299,11 +299,11 @@ pub(crate) struct TraversalOptions<'ctx, 'app> {
     pub(crate) remaining_diagnostics: &'ctx AtomicU32,
 
     /// List of paths that should be processed
-    pub(crate) evaluated_paths: RwLock<BTreeSet<PgTPath>>,
+    pub(crate) evaluated_paths: RwLock<BTreeSet<PgLSPath>>,
 }
 
 impl TraversalOptions<'_, '_> {
-    pub(crate) fn increment_changed(&self, path: &PgTPath) {
+    pub(crate) fn increment_changed(&self, path: &PgLSPath) {
         self.changed.fetch_add(1, Ordering::Relaxed);
         self.evaluated_paths
             .write()
@@ -329,15 +329,15 @@ impl TraversalContext for TraversalOptions<'_, '_> {
         &self.interner
     }
 
-    fn evaluated_paths(&self) -> BTreeSet<PgTPath> {
+    fn evaluated_paths(&self) -> BTreeSet<PgLSPath> {
         self.evaluated_paths.read().unwrap().clone()
     }
 
     fn push_diagnostic(&self, error: Error) {
         self.push_message(error);
     }
 
-    fn can_handle(&self, pgls_path: &PgTPath) -> bool {
+    fn can_handle(&self, pgls_path: &PgLSPath) -> bool {
         let path = pgls_path.as_path();
 
         let is_valid_file = self.fs.path_is_file(path)
@@ -372,22 +372,22 @@ impl TraversalContext for TraversalOptions<'_, '_> {
         true
     }
 
-    fn handle_path(&self, path: PgTPath) {
+    fn handle_path(&self, path: PgLSPath) {
         handle_file(self, &path)
     }
 
-    fn store_path(&self, path: PgTPath) {
+    fn store_path(&self, path: PgLSPath) {
         self.evaluated_paths
             .write()
             .unwrap()
-            .insert(PgTPath::new(path.as_path()));
+            .insert(PgLSPath::new(path.as_path()));
     }
 }
 
 /// This function wraps the [process_file] function implementing the traversal
 /// in a [catch_unwind] block and emit diagnostics in case of error (either the
 /// traversal function returns Err or panics)
-fn handle_file(ctx: &TraversalOptions, path: &PgTPath) {
+fn handle_file(ctx: &TraversalOptions, path: &PgLSPath) {
     match catch_unwind(move || process_file(ctx, path)) {
         Ok(Ok(FileStatus::Changed)) => {
             ctx.increment_changed(path);

crates/pgls_cli/src/lib.rs

@@ -25,7 +25,7 @@ mod service;
 mod workspace;
 
 use crate::cli_options::ColorsArg;
-pub use crate::commands::{PgtCommand, pgt_command};
+pub use crate::commands::{PgLSCommand, pg_l_s_command};
 pub use crate::logging::{LoggingLevel, setup_cli_subscriber};
 use crate::reporter::Report;
 pub use diagnostics::CliDiagnostic;
@@ -57,19 +57,19 @@ impl<'app> CliSession<'app> {
     }
 
     /// Main function to run the CLI
-    pub fn run(self, command: PgtCommand) -> Result<(), CliDiagnostic> {
+    pub fn run(self, command: PgLSCommand) -> Result<(), CliDiagnostic> {
         let has_metrics = command.has_metrics();
         if has_metrics {
             crate::metrics::init_metrics();
         }
 
         let result = match command {
-            PgtCommand::Version(_) => commands::version::version(self),
-            PgtCommand::Dblint {
+            PgLSCommand::Version(_) => commands::version::version(self),
+            PgLSCommand::Dblint {
                 cli_options,
                 configuration,
             } => commands::dblint::dblint(self, &cli_options, configuration),
-            PgtCommand::Check {
+            PgLSCommand::Check {
                 cli_options,
                 configuration,
                 paths,
@@ -89,21 +89,21 @@ impl<'app> CliSession<'app> {
                     since,
                 },
             ),
-            PgtCommand::Clean => commands::clean::clean(self),
-            PgtCommand::Start {
+            PgLSCommand::Clean => commands::clean::clean(self),
+            PgLSCommand::Start {
                 config_path,
                 log_path,
                 log_prefix_name,
             } => commands::daemon::start(self, config_path, Some(log_path), Some(log_prefix_name)),
-            PgtCommand::Stop => commands::daemon::stop(self),
-            PgtCommand::Init => commands::init::init(self),
-            PgtCommand::LspProxy {
+            PgLSCommand::Stop => commands::daemon::stop(self),
+            PgLSCommand::Init => commands::init::init(self),
+            PgLSCommand::LspProxy {
                 config_path,
                 log_path,
                 log_prefix_name,
                 ..
             } => commands::daemon::lsp_proxy(config_path, Some(log_path), Some(log_prefix_name)),
-            PgtCommand::RunServer {
+            PgLSCommand::RunServer {
                 stop_on_disconnect,
                 config_path,
                 log_path,
@@ -118,7 +118,7 @@ impl<'app> CliSession<'app> {
                 Some(log_level),
                 Some(log_kind),
             ),
-            PgtCommand::PrintSocket => commands::daemon::print_socket(),
+            PgLSCommand::PrintSocket => commands::daemon::print_socket(),
         };
 
         if has_metrics {

crates/pgls_cli/src/main.rs

@@ -1,7 +1,7 @@
 //! This is the main binary
 
 use pgls_cli::{
-    CliDiagnostic, CliSession, PgtCommand, open_transport, pgt_command, setup_panic_handler,
+    CliDiagnostic, CliSession, PgLSCommand, open_transport, pg_l_s_command, setup_panic_handler,
     to_color_mode,
 };
 use pgls_console::{ConsoleExt, EnvConsole, markup};
@@ -31,7 +31,7 @@ fn main() -> ExitCode {
     set_bottom_frame(main as usize);
 
     let mut console = EnvConsole::default();
-    let command = pgt_command().fallback_to_usage().run();
+    let command = pg_l_s_command().fallback_to_usage().run();
 
     console.set_color(to_color_mode(command.get_color()));
 
@@ -50,7 +50,7 @@ fn main() -> ExitCode {
     }
 }
 
-fn run_workspace(console: &mut EnvConsole, command: PgtCommand) -> Result<(), CliDiagnostic> {
+fn run_workspace(console: &mut EnvConsole, command: PgLSCommand) -> Result<(), CliDiagnostic> {
     // If the `--use-server` CLI flag is set, try to open a connection to an
     // existing server socket
     let workspace = if command.should_use_server() {

crates/pgls_cli/src/reporter/mod.rs

@@ -7,7 +7,7 @@ use crate::cli_options::{CliOptions, CliReporter};
 use crate::diagnostics::CliDiagnostic;
 use pgls_console::Console;
 use pgls_diagnostics::{Error, Severity};
-use pgls_fs::PgTPath;
+use pgls_fs::PgLSPath;
 use std::collections::BTreeSet;
 use std::path::PathBuf;
 use std::time::Duration;
@@ -54,7 +54,7 @@ impl From<CliReporter> for ReportMode {
 
 #[derive(Debug)]
 pub struct TraversalData {
-    pub evaluated_paths: BTreeSet<PgTPath>,
+    pub evaluated_paths: BTreeSet<PgLSPath>,
     pub changed: usize,
     pub unchanged: usize,
     pub matches: usize,

crates/pgls_cli/src/reporter/terminal.rs

@@ -4,7 +4,7 @@ use pgls_console::fmt::Formatter;
 use pgls_console::{Console, ConsoleExt, fmt, markup};
 use pgls_diagnostics::advice::ListAdvice;
 use pgls_diagnostics::{Diagnostic, Error, PrintDiagnostic};
-use pgls_fs::PgTPath;
+use pgls_fs::PgLSPath;
 use std::borrow::Cow;
 use std::collections::BTreeSet;
 
@@ -51,7 +51,7 @@ fn log_diagnostics(console: &mut dyn Console, config: &ReportConfig, diagnostics
     }
 }
 
-fn log_evaluated_paths(console: &mut dyn Console, evaluated_paths: &BTreeSet<PgTPath>) {
+fn log_evaluated_paths(console: &mut dyn Console, evaluated_paths: &BTreeSet<PgLSPath>) {
     let evaluated_paths_diagnostic = EvaluatedPathsDiagnostic {
         advice: ListAdvice {
             list: evaluated_paths