ai-guiders/cascade-ide / Features/EnvironmentReadiness/Application/EnvironmentReadinessSnapshotBuilder.cs

/// <summary>Статическая часть: C# LSP, Markdown LSP (без сетевого вызова). Состояние — <see cref="IdeHostStateChanged"/> (тот же снимок, что на DataBus для IDE Health).</summary>

290

public static IReadOnlyList<AnnunciatorLampItem> BuildLspRows(

291

CascadeIdeSettings settings,

292

string? solutionPath,

293

in IdeHostStateChanged lsp)

294

{

295

var list = new List<AnnunciatorLampItem>(4);

296

list.Add(BuildCSharpRow(settings, solutionPath, lsp.CSharpLspHostPresent, lsp.CSharpLspProcessActive));

297

list.Add(BuildMarkdownRow(settings, solutionPath, lsp.MarkdownLspHostPresent, lsp.MarkdownLspProcessActive));

return list;

}

/// <summary>Проверка <c>dotnet</c> в PATH (как при сборке).</summary>

302

public static async Task<AnnunciatorLampItem> ProbeDotnetAsync(CancellationToken cancellationToken = default)

303

{

304

var r = await DotnetSdkVersionProbe.RunAsync(cancellationToken).ConfigureAwait(false);

305

if (r.Outcome == DotnetSdkVersionProbeOutcome.Success && !string.IsNullOrWhiteSpace(r.Version))

306

{

307

return new AnnunciatorLampItem(

308

EnvironmentReadinessCellIds.DotnetSdk,

309

"dotnet (SDK / CLI)",

310

$"Версия: {r.Version}",

311

AnnunciatorLampLevel.Ok,

312

LampShortLabel: ".NET");

313

}

314

315

if (r.Outcome == DotnetSdkVersionProbeOutcome.ProcessNull)

316

{

317

return new AnnunciatorLampItem(

318

EnvironmentReadinessCellIds.DotnetSdk,

319

"dotnet (SDK / CLI)",

320

"Не удалось запустить процесс dotnet.",

321

AnnunciatorLampLevel.Critical,

322

LampShortLabel: ".NET");

323

}

324

325

if (r.Outcome == DotnetSdkVersionProbeOutcome.Exception)

326

{

327

return new AnnunciatorLampItem(

328

EnvironmentReadinessCellIds.DotnetSdk,

329

"dotnet (SDK / CLI)",

330

$"Не удалось выполнить dotnet --version: {r.ExceptionMessage ?? "unknown error"}",

331

AnnunciatorLampLevel.Critical,

332

LampShortLabel: ".NET");

}

// NonZeroExit

var tail = string.IsNullOrWhiteSpace(r.StdErr) ? $"код выхода {r.ExitCode}" : r.StdErr;

337

return new AnnunciatorLampItem(

338

EnvironmentReadinessCellIds.DotnetSdk,

339

"dotnet (SDK / CLI)",

340

$"dotnet --version не удался ({tail}). Добавь dotnet в PATH или установи SDK.",

341

AnnunciatorLampLevel.Critical,

342

LampShortLabel: ".NET");

343

}

344

345

private static AnnunciatorLampItem BuildCSharpRow(

346

CascadeIdeSettings settings,

347

string? solutionPath,

bool hostPresent,

bool processActive)

{

var csharpLsp = settings.Languages.CSharp.ResolveForRuntime();

352

var provider = csharpLsp.Mode;

353

354

if (string.Equals(provider, CSharpLspProviderIds.ParseOnly, StringComparison.OrdinalIgnoreCase))

355

{

356

return new AnnunciatorLampItem(

357

EnvironmentReadinessCellIds.CSharpLsp,

358

"C# LSP",

359

"Режим «только парсер»: отдельный процесс language server не используется (Roslyn в процессе IDE).",

360

AnnunciatorLampLevel.Advisory,

361

LampShortLabel: "C#");

362

}

363

364

if (!EnvironmentReadinessFileFacts.SolutionPathIsExistingFile(solutionPath))

365

{

366

return new AnnunciatorLampItem(

367

EnvironmentReadinessCellIds.CSharpLsp,

368

"C# LSP",

369

$"Провайдер: {provider}. Открой файл решения (.sln/.slnx), чтобы IDE могла запустить LSP.",

370

AnnunciatorLampLevel.Caution,

371

LampShortLabel: "C#");

372

}

373

374

var (exe, _) = CSharpLspProviderIds.ResolveProcessArgs(

375

provider,

376

solutionPath,

377

csharpLsp.Executable,

378

csharpLsp.Arguments);

379

380

var exeHint = string.IsNullOrWhiteSpace(exe) ? provider : $"{provider}: {exe}";

381

exeHint += FormatPendingSettingsEnvHint(settings.Languages.CSharp, provider);

if (!hostPresent)

{

return new AnnunciatorLampItem(

386

EnvironmentReadinessCellIds.CSharpLsp,

387

"C# LSP",

388

$"{exeHint}. Процесс не запущен — проверь путь к исполняемому файлу и аргументы в настройках.",

389

AnnunciatorLampLevel.Caution,

390

LampShortLabel: "C#");

}

if (processActive)

{

return new AnnunciatorLampItem(

396

EnvironmentReadinessCellIds.CSharpLsp,

397

"C# LSP",

398

$"{exeHint}. Процесс активен.",

399

AnnunciatorLampLevel.Ok,

400

LampShortLabel: "C#");

401

}

402

403

return new AnnunciatorLampItem(

404

EnvironmentReadinessCellIds.CSharpLsp,

405

"C# LSP",

406

$"{exeHint}. Процесс не активен (завершился или не прошёл handshake).",

407

AnnunciatorLampLevel.Caution,

408

LampShortLabel: "C#");

409

}

410

411

private static AnnunciatorLampItem BuildMarkdownRow(

412

CascadeIdeSettings settings,

413

string? solutionPath,

bool hostPresent,

bool processActive)

{

var markdownLsp = settings.Languages.Markdown.ResolveForRuntime();

418

var provider = markdownLsp.Mode;

419

420

if (string.Equals(provider, MarkdownLspProviderIds.Off, StringComparison.OrdinalIgnoreCase))

421

{

422

return new AnnunciatorLampItem(

423

EnvironmentReadinessCellIds.MarkdownLsp,

424

"Markdown LSP",

425

"Выключено (диагностики Markdown из отдельного сервера не используются).",

426

AnnunciatorLampLevel.Advisory,

427

LampShortLabel: "MD");

428

}

429

430

if (!EnvironmentReadinessFileFacts.SolutionPathIsExistingFile(solutionPath))

431

{

432

return new AnnunciatorLampItem(

433

EnvironmentReadinessCellIds.MarkdownLsp,

434

"Markdown LSP",

435

$"Провайдер: {provider}. Нужен открытый файл решения, чтобы запустить сервер.",

436

AnnunciatorLampLevel.Caution,

437

LampShortLabel: "MD");

438

}

439

440

var (exe, args) = MarkdownLspProviderIds.ResolveProcessArgs(

441

provider,

442

markdownLsp.Executable,

443

markdownLsp.Arguments);

444

445

var argHint = string.IsNullOrWhiteSpace(args) ? "" : $" {args}";

446

var exeHint = string.IsNullOrWhiteSpace(exe) ? $"{provider}" : $"{provider}: {exe}{argHint}";

447

exeHint += FormatPendingSettingsEnvHint(settings.Languages.Markdown, provider);

if (!hostPresent)

{

return new AnnunciatorLampItem(

452

EnvironmentReadinessCellIds.MarkdownLsp,

453

"Markdown LSP",

454

$"{exeHint}. Процесс не запущен — проверь установку (например Marksman в PATH) или путь в настройках.",

455

AnnunciatorLampLevel.Caution,

456

LampShortLabel: "MD");

}

if (processActive)

{

return new AnnunciatorLampItem(

462

EnvironmentReadinessCellIds.MarkdownLsp,

463

"Markdown LSP",

464

$"{exeHint}. Процесс активен.",

465

AnnunciatorLampLevel.Ok,

466

LampShortLabel: "MD");

467

}

468

469

return new AnnunciatorLampItem(

470

EnvironmentReadinessCellIds.MarkdownLsp,

471

"Markdown LSP",

472

$"{exeHint}. Процесс не активен.",

473

AnnunciatorLampLevel.Caution,

474

LampShortLabel: "MD");

}

/// <summary>

/// Полный набор строк для страницы «готовность окружения» (ADR 0023): блок Dev Tools (агент, LSP, dotnet), затем env, затем переменные.

479

/// Дополнительные проверки добавлять сюда, чтобы не раздувать ViewModel.

480

/// </summary>

481

public static async Task<IReadOnlyList<AnnunciatorLampItem>> BuildAllRowsAsync(

482

CascadeIdeSettings settings,

483

string? solutionPath,

484

IdeHostStateChanged lsp,

485

bool isMcpStdioHost = false,

486

string? activeAiProvider = null,

487

CancellationToken cancellationToken = default)

488

{

489

var agent = BuildAgentRow(isMcpStdioHost, activeAiProvider);

490

var envRows = BuildEnvProbeRows(EnvironmentReadinessEnvSnapshot.FromSettings(settings), settings);

491

var lspRows = BuildLspRows(settings, solutionPath, lsp);

492

var dotnet = await ProbeDotnetAsync(cancellationToken).ConfigureAwait(false);

493

494

var devToolDetails = new List<AnnunciatorLampItem>(1 + lspRows.Count + 1) { agent };

495

devToolDetails.AddRange(lspRows);

496

devToolDetails.Add(dotnet);

497

498

var devToolsSection = BuildDevToolsSectionRow(devToolDetails);

499

var envSection = BuildEnvSectionRow(envRows);

500

501

var combined = new List<AnnunciatorLampItem>(devToolDetails.Count + envRows.Count + 2);

502

combined.Add(devToolsSection);

503

combined.AddRange(devToolDetails);

504

combined.Add(envSection);

505

combined.AddRange(envRows);

return combined;

}

private static string FormatPendingSettingsEnvHint(CSharpLanguageServerSettings csharp, string mode)

510

{

511

var profile = mode switch

512

{

513

"OmniSharp" => csharp.OmniSharp,

514

"CSharpLs" => csharp.CSharpLs,

515

"Custom" => csharp.Custom,

516

_ => csharp.ParseOnly,

517

};

518

return FormatPendingEnvVar(profile.ExecutableEnv);

519

}

520

521

private static string FormatPendingSettingsEnvHint(MarkdownLanguageServerSettings markdown, string mode)

522

{

523

var profile = mode switch

524

{

525

"Marksman" => markdown.Marksman,

526

"Custom" => markdown.Custom,

527

_ => markdown.Off,

528

};

529

return FormatPendingEnvVar(profile.ExecutableEnv);

530

}

531

532

private static string FormatPendingEnvVar(string? environmentVariableName)

533

{

534

if (string.IsNullOrWhiteSpace(environmentVariableName)

535

|| SettingsEnvResolver.IsPathLookupSentinel(environmentVariableName))

536

return "";

537

538

return SettingsEnvResolver.TryGetEnvironmentValue(environmentVariableName) is null

539

? $" (ожидается {environmentVariableName.Trim()})"

: "";

}

}