baldart 3.9.0 → 3.12.0

package/src/utils/lsp-adapters/ruby.js

@@ -0,0 +1,30 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Ruby LSP adapter — ruby-lsp (Shopify).
+ *
+ * Installed as a gem; system-mode. Users on Bundler-managed projects may
+ * prefer to add `gem 'ruby-lsp', group: :development` to their Gemfile and
+ * `bundle install` instead — we print the simple gem install command for
+ * portability.
+ */
+class RubyAdapter {
+  constructor(cwd = process.cwd()) { this.cwd = cwd; }
+
+  get name() { return 'ruby'; }
+  get label() { return 'Ruby (ruby-lsp)'; }
+  get binary() { return 'ruby-lsp'; }
+  get installMode() { return 'system'; }
+
+  installCommand() { return 'gem install ruby-lsp'; }
+  verifyCommand() { return 'ruby-lsp --version'; }
+  claudePluginId() { return null; }
+
+  static detect(cwd = process.cwd()) {
+    const markers = ['Gemfile', '.ruby-version', 'config.ru'];
+    return markers.some(m => fs.existsSync(path.join(cwd, m)));
+  }
+}
+
+module.exports = RubyAdapter;

package/src/utils/lsp-adapters/rust.js

@@ -0,0 +1,26 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Rust LSP adapter — rust-analyzer.
+ *
+ * Installed through rustup as a toolchain component. System-mode only.
+ */
+class RustAdapter {
+  constructor(cwd = process.cwd()) { this.cwd = cwd; }
+
+  get name() { return 'rust'; }
+  get label() { return 'Rust (rust-analyzer)'; }
+  get binary() { return 'rust-analyzer'; }
+  get installMode() { return 'system'; }
+
+  installCommand() { return 'rustup component add rust-analyzer'; }
+  verifyCommand() { return 'rust-analyzer --version'; }
+  claudePluginId() { return null; }
+
+  static detect(cwd = process.cwd()) {
+    return fs.existsSync(path.join(cwd, 'Cargo.toml'));
+  }
+}
+
+module.exports = RustAdapter;

package/src/utils/lsp-adapters/typescript.js

@@ -0,0 +1,54 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * TypeScript / JavaScript LSP adapter.
+ *
+ * Language server: `typescript-language-server` (Node, npm).
+ * Install mode: project-local devDep — keeps the binary inside the consumer
+ * repo's node_modules and avoids polluting the user's global env.
+ *
+ * Detection signal: presence of `tsconfig.json`, `jsconfig.json`, or a
+ * `package.json` referencing typescript in deps/devDeps.
+ */
+class TypeScriptAdapter {
+  constructor(cwd = process.cwd()) { this.cwd = cwd; }
+
+  get name() { return 'typescript'; }
+  get label() { return 'TypeScript / JavaScript'; }
+  get binary() { return 'typescript-language-server'; }
+
+  /** 'npm-dev' = npm devDependency, 'system' = printed install instructions. */
+  get installMode() { return 'npm-dev'; }
+
+  /** npm package to install when mode='npm-dev'. */
+  get npmPackage() { return 'typescript-language-server typescript'; }
+
+  /** Shell command the user (or installer) should run. */
+  installCommand() {
+    return 'npm install --save-dev typescript-language-server typescript';
+  }
+
+  /** Verify the binary is reachable (no execution side effects). */
+  verifyCommand() { return 'npx --no-install typescript-language-server --version'; }
+
+  /** Claude Code code-intelligence plugin id, if any. Null = use generic LSP. */
+  claudePluginId() { return null; }
+
+  /** Autodetect whether this language is in scope for the project. */
+  static detect(cwd = process.cwd()) {
+    const markers = ['tsconfig.json', 'jsconfig.json'];
+    for (const m of markers) {
+      if (fs.existsSync(path.join(cwd, m))) return true;
+    }
+    try {
+      const pkgPath = path.join(cwd, 'package.json');
+      if (!fs.existsSync(pkgPath)) return false;
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const allDeps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+      return Boolean(allDeps.typescript);
+    } catch { return false; }
+  }
+}
+
+module.exports = TypeScriptAdapter;

package/src/utils/lsp-installer.js

@@ -0,0 +1,118 @@
+const { execSync } = require('child_process');
+const { detectAll, getAdapter, listAdapters } = require('./lsp-adapters');
+const UI = require('./ui');
+
+/**
+ * High-level LSP installer used by `baldart configure` and the `lsp-bootstrap`
+ * skill / doctor step. Owns the install + verify side effects so the command
+ * layers stay thin.
+ *
+ * Contract:
+ *   - Pure detection (no install) when only `detectLanguages` is called.
+ *   - All mutating ops respect `--non-interactive` via the `interactive` flag.
+ *   - Returns plain objects (no throws) so the caller can render results.
+ */
+class LspInstaller {
+  constructor(cwd = process.cwd()) { this.cwd = cwd; }
+
+  /** Languages whose marker files exist under cwd. */
+  detectLanguages() { return detectAll(this.cwd); }
+
+  /** Adapters that BALDART knows about (regardless of detection). */
+  knownAdapters() { return listAdapters(); }
+
+  /**
+   * Build a recommendation list from detected languages. Each entry carries
+   * the install command and the install mode so the UI can decide whether
+   * to run it automatically (npm-dev) or just print it (system).
+   */
+  recommend(langs = this.detectLanguages()) {
+    return langs.map(name => {
+      const a = getAdapter(name, this.cwd);
+      return {
+        name: a.name,
+        label: a.label,
+        binary: a.binary,
+        installMode: a.installMode,
+        installCommand: a.installCommand(),
+        verifyCommand: a.verifyCommand(),
+        claudePluginId: a.claudePluginId()
+      };
+    });
+  }
+
+  /**
+   * Install one or more language servers. Returns `{ installed, skipped, manual }`.
+   *  - npm-dev adapters: executed in-process (npm install --save-dev …).
+   *  - system adapters: never executed automatically; surfaced under `manual`
+   *    so the caller can print the command for the user to run.
+   *
+   * `opts.interactive`: when true, asks confirmation per server (default true).
+   * `opts.dryRun`:      when true, no commands are executed.
+   */
+  async installServers(serverNames, opts = {}) {
+    const { interactive = true, dryRun = false } = opts;
+    const installed = [];
+    const skipped = [];
+    const manual = [];
+
+    for (const name of serverNames) {
+      let a;
+      try { a = getAdapter(name, this.cwd); }
+      catch (err) { skipped.push({ name, reason: err.message }); continue; }
+
+      if (a.installMode === 'system') {
+        manual.push({
+          name: a.name,
+          label: a.label,
+          command: a.installCommand()
+        });
+        continue;
+      }
+
+      if (interactive) {
+        const ok = await UI.confirm(`Install ${a.label} via \`${a.installCommand()}\`?`, true);
+        if (!ok) { skipped.push({ name, reason: 'user declined' }); continue; }
+      }
+
+      if (dryRun) { installed.push({ name, dryRun: true }); continue; }
+
+      const spinner = UI.spinner(`Installing ${a.label}…`).start();
+      try {
+        execSync(a.installCommand(), { cwd: this.cwd, stdio: 'pipe' });
+        spinner.succeed(`Installed ${a.label}`);
+        installed.push({ name });
+      } catch (err) {
+        spinner.fail(`Failed to install ${a.label}`);
+        skipped.push({ name, reason: err.message.split('\n')[0] });
+      }
+    }
+
+    return { installed, skipped, manual };
+  }
+
+  /**
+   * Verify each named server's binary is reachable. Returns
+   * `[{ name, ok, output | error }]`. Never throws.
+   */
+  verifyServers(serverNames) {
+    return serverNames.map(name => {
+      let a;
+      try { a = getAdapter(name, this.cwd); }
+      catch (err) { return { name, ok: false, error: err.message }; }
+
+      try {
+        const out = execSync(a.verifyCommand(), {
+          cwd: this.cwd,
+          stdio: ['ignore', 'pipe', 'pipe'],
+          timeout: 8000
+        }).toString().trim();
+        return { name, ok: true, output: out };
+      } catch (err) {
+        return { name, ok: false, error: (err.message || '').split('\n')[0] };
+      }
+    });
+  }
+}
+
+module.exports = LspInstaller;