baldart 3.9.0 → 3.10.0

package/src/commands/doctor.js

@@ -30,6 +30,7 @@ const GitUtils = require('../utils/git');
 const UI = require('../utils/ui');
 const State = require('../utils/state');
 const Hooks = require('../utils/hooks');
+const LspInstaller = require('../utils/lsp-installer');
 
 const FRAMEWORK_DIR = '.framework';
 const REPO_DEFAULT = 'antbald/BALDART';
@@ -196,6 +197,25 @@ async function detectState(cwd, opts = {}) {
 
     state.editGateRegistered = false;
     try { state.editGateRegistered = Hooks.isRegistered(cwd); } catch (_) {}
+
+    // ---- LSP layer (since v3.10.0) -------------------------------------
+    state.lspEnabled = false;
+    state.lspInstalled = [];
+    state.lspBroken = [];
+    try {
+      // Reuse the `config` already parsed above instead of re-reading the file.
+      if (config && !config.__malformed && config.features && config.features.has_lsp_layer === true) {
+        state.lspEnabled = true;
+        const installed = (config.lsp && config.lsp.installed_servers) || [];
+        state.lspInstalled = installed;
+        const autoVerify = !(config.lsp && config.lsp.auto_verify === false);
+        if (autoVerify && installed.length) {
+          const installer = new LspInstaller(cwd);
+          const results = installer.verifyServers(installed);
+          state.lspBroken = results.filter(r => !r.ok).map(r => r.name);
+        }
+      }
+    } catch (_) { /* never block doctor on LSP probe */ }
   }
 
   return state;
@@ -306,6 +326,27 @@ function planActions(state) {
     });
   }
 
+  if (state.lspEnabled && state.lspBroken && state.lspBroken.length > 0) {
+    actions.push({
+      key: 'lsp-fix',
+      label: `Reinstall ${state.lspBroken.length} broken LSP server(s)`,
+      why: `LSP layer is enabled but these language servers are not reachable: ${state.lspBroken.join(', ')}. Symbol search will silently fall back to Grep until they are reinstalled.`,
+      autoOk: false, // touches dev-deps and is the kind of action a user may
+      // have made deliberate (switching from npm pyright to system pyright);
+      // keep the outer prompt + the per-server confirm both alive.
+      run: async () => {
+        const installer = new LspInstaller(state.cwd);
+        const { installed, manual, skipped } = await installer.installServers(state.lspBroken);
+        if (installed.length) UI.success(`Reinstalled: ${installed.map(i => i.name).join(', ')}`);
+        for (const m of manual) {
+          UI.warning(`System-level reinstall required for ${m.label}:`);
+          console.log(`    ${m.command}`);
+        }
+        if (skipped.length) UI.warning(`Skipped: ${skipped.map(s => `${s.name} (${s.reason})`).join(', ')}`);
+      },
+    });
+  }
+
   const remoteAhead = state.remote.fetched && state.remote.behind > 0;
   const hasLocalWork = state.workingTreeDirty > 0 || state.commitsAhead > 0;
 
@@ -437,6 +478,20 @@ function renderDiagnostic(state) {
     state.editGateRegistered ? 'ok' : 'warn'
   ));
 
+  if (state.lspEnabled) {
+    const total = state.lspInstalled.length;
+    const broken = state.lspBroken.length;
+    const value = total === 0
+      ? 'enabled but no servers installed'
+      : broken === 0
+        ? `${total} server(s) verified (${state.lspInstalled.join(', ')})`
+        : `${broken}/${total} broken (${state.lspBroken.join(', ')})`;
+    const severity = total === 0 || broken > 0 ? 'warn' : 'ok';
+    console.log(statusLine('LSP layer', value, severity));
+  } else {
+    console.log(statusLine('LSP layer', 'disabled', 'ok'));
+  }
+
   console.log();
 }
 

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

@@ -0,0 +1,29 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Go LSP adapter — gopls.
+ *
+ * gopls is a Go binary; we can't install it into node_modules. installMode
+ * is 'system' which means the configure flow prints the canonical install
+ * command and the user runs it themselves. The verify step still checks
+ * that the binary is in PATH.
+ */
+class GoAdapter {
+  constructor(cwd = process.cwd()) { this.cwd = cwd; }
+
+  get name() { return 'go'; }
+  get label() { return 'Go (gopls)'; }
+  get binary() { return 'gopls'; }
+  get installMode() { return 'system'; }
+
+  installCommand() { return 'go install golang.org/x/tools/gopls@latest'; }
+  verifyCommand() { return 'gopls version'; }
+  claudePluginId() { return null; }
+
+  static detect(cwd = process.cwd()) {
+    return fs.existsSync(path.join(cwd, 'go.mod'));
+  }
+}
+
+module.exports = GoAdapter;

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

@@ -0,0 +1,49 @@
+const TypeScriptAdapter = require('./typescript');
+const PythonAdapter     = require('./python');
+const GoAdapter         = require('./go');
+const RustAdapter       = require('./rust');
+const RubyAdapter       = require('./ruby');
+
+/**
+ * LSP adapter registry.
+ *
+ * Adding a new language (Java, C/C++, PHP, Elixir, …):
+ *   1. Create `src/utils/lsp-adapters/<lang>.js` exporting a class with the
+ *      same shape as TypeScriptAdapter (name, label, binary, installMode,
+ *      installCommand, verifyCommand, claudePluginId, static detect).
+ *   2. Add it to the REGISTRY below.
+ *   3. (Optional) Wire a Claude Code plugin id if one exists.
+ *
+ * Adapters describe *how* to install/verify a language server; they do NOT
+ * speak LSP themselves. The actual symbol search at runtime happens through
+ * whatever Claude Code plugin or MCP server the user has loaded.
+ */
+const REGISTRY = {
+  typescript: TypeScriptAdapter,
+  python:     PythonAdapter,
+  go:         GoAdapter,
+  rust:       RustAdapter,
+  ruby:       RubyAdapter
+};
+
+function listAdapters() { return Object.keys(REGISTRY); }
+
+function getAdapter(name, cwd) {
+  const Cls = REGISTRY[name];
+  if (!Cls) throw new Error(`Unknown LSP adapter: ${name}. Available: ${listAdapters().join(', ')}`);
+  return new Cls(cwd);
+}
+
+/**
+ * Probe the cwd for every known language and return the names of adapters
+ * whose static detect() fires. Pure: no install side effects.
+ */
+function detectAll(cwd = process.cwd()) {
+  return Object.entries(REGISTRY)
+    .filter(([, Cls]) => {
+      try { return Cls.detect(cwd); } catch { return false; }
+    })
+    .map(([name]) => name);
+}
+
+module.exports = { REGISTRY, listAdapters, getAdapter, detectAll };

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

@@ -0,0 +1,42 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Python LSP adapter — Pyright.
+ *
+ * Pyright ships as both an npm package and a pip package. We default to the
+ * npm devDep route so installs stay project-local and version-pinned without
+ * touching the user's Python env. Users who already drive Python via pip/uv
+ * can override by removing pyright from devDeps and installing system-wide.
+ *
+ * Detection signal: pyproject.toml, setup.py, setup.cfg, requirements.txt,
+ * Pipfile, or a top-level .py source tree.
+ */
+class PythonAdapter {
+  constructor(cwd = process.cwd()) { this.cwd = cwd; }
+
+  get name() { return 'python'; }
+  get label() { return 'Python (Pyright)'; }
+  get binary() { return 'pyright'; }
+  get installMode() { return 'npm-dev'; }
+  get npmPackage() { return 'pyright'; }
+
+  installCommand() { return 'npm install --save-dev pyright'; }
+  verifyCommand() { return 'npx --no-install pyright --version'; }
+  claudePluginId() { return null; }
+
+  static detect(cwd = process.cwd()) {
+    const markers = ['pyproject.toml', 'setup.py', 'setup.cfg', 'requirements.txt', 'Pipfile'];
+    for (const m of markers) {
+      if (fs.existsSync(path.join(cwd, m))) return true;
+    }
+    // Fallback: a `src/` or top-level *.py file is a strong enough signal.
+    try {
+      const entries = fs.readdirSync(cwd);
+      if (entries.some(e => e.endsWith('.py'))) return true;
+    } catch { /* ignore */ }
+    return false;
+  }
+}
+
+module.exports = PythonAdapter;

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;