progress

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.

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/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_configuration/src/analyser/linter/rules.rs

@@ -46,7 +46,7 @@ impl std::str::FromStr for RuleGroup {
 #[cfg_attr(feature = "schema", derive(JsonSchema))]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct Rules {
-    #[doc = r" It enables the lint rules recommended by Postgres Tools. `true` by default."]
+    #[doc = r" It enables the lint rules recommended by Postgres Language Server. `true` by default."]
     #[serde(skip_serializing_if = "Option::is_none")]
     pub recommended: Option<bool>,
     #[doc = r" It enables ALL rules. The rules that belong to `nursery` won't be enabled."]

crates/pgls_fs/src/path.rs

@@ -87,7 +87,7 @@ impl From<FileKind> for FileKinds {
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub struct PgLSPath {
     path: PathBuf,
-    /// Determines the kind of the file inside Postgres Tools. Some files are considered as configuration files, others as manifest files, and others as files to handle
+    /// Determines the kind of the file inside Postgres Language Server. Some files are considered as configuration files, others as manifest files, and others as files to handle
     kind: FileKinds,
     /// Whether this path (usually a file) was fixed as a result of a format/lint/check command with the `--write` filag.
     was_written: bool,

docs/codegen/src/cli_doc.rs

@@ -1,4 +1,4 @@
-use pgls_cli::pgt_command;
+use pgls_cli::pg_l_s_command;
 use std::{fs, path::Path};
 
 use crate::utils;
@@ -11,7 +11,7 @@ pub fn generate_cli_doc(docs_dir: &Path) -> anyhow::Result<()> {
     let new_content = utils::replace_section(
         &content,
         "CLI_REF",
-        &pgt_command().render_markdown("postgres-language-server"),
+        &pg_l_s_command().render_markdown("postgres-language-server"),
     );
 
     fs::write(file_path, &new_content)?;

docs/getting_started.md

@@ -71,14 +71,14 @@ Run `postgres-language-server --help` for all options. The CLI options take prec
 
 The Postgres Language Server is available as an extension in your favorite editors.
 
-- VSCode: The language server is available on the [VSCode Marketplace](https://marketplace.visualstudio.com/items?itemName=Supabase.postgrestools). It's published from [this repo](https://github.com/supabase-community/postgrestools-vscode).
+- VSCode: The language server is available on the [VSCode Marketplace](https://marketplace.visualstudio.com/items?itemName=Supabase.postgrestools). It's published from [this repo](https://github.com/supabase-community/postgres-language-server-vscode).
 - Neovim: You will have to install `nvim-lspconfig`, and follow the [instructions](https://github.com/neovim/nvim-lspconfig/blob/master/doc/configs.md#postgres_lsp).
 - Emacs: The language client is available through [lsp-mode](https://github.com/emacs-lsp/lsp-mode). For more details, refer to their [manual page](https://emacs-lsp.github.io/lsp-mode/page/lsp-postgres/).
 - Zed: The language server is available as an Extension. It's published from [this repo](https://github.com/LoamStudios/zed-postgres-language-server).
 
 ### Continuous Integration
 
-Run `postgres-language-server check` in your CI pipeline to lint your schema changes and enforce code quality across your team. We provide a [GitHub Action](https://github.com/supabase-community/postgrestools-cli-action) to setup the Postgres Language Server in your runner.
+Run `postgres-language-server check` in your CI pipeline to lint your schema changes and enforce code quality across your team. We provide a [GitHub Action](https://github.com/supabase-community/postgres-language-server-cli-action) to setup the Postgres Language Server in your runner.
 
 See the [Continuous Integration](/guides/continuous_integration) guide for an example.
 

docs/guides/continuous_integration.md

@@ -4,7 +4,7 @@ Running the Postgres Language Server in a CI environment can boost your teams co
 
 ### GitHub Actions
 
-We provide a first-party [GitHub Action](https://github.com/supabase-community/postgrestools-cli-action) to setup the CLI in your runner. Here's what a simple workflow might look like:
+We provide a first-party [GitHub Action](https://github.com/supabase-community/postgres-language-server-cli-action) to setup the CLI in your runner. Here's what a simple workflow might look like:
 
 ```yaml
 jobs: