@mrclrchtr/supi-code-intelligence 1.8.0 → 1.9.1

package/node_modules/@mrclrchtr/supi-lsp/node_modules/typescript/package.json

@@ -0,0 +1,118 @@
+{
+    "name": "typescript",
+    "author": "Microsoft Corp.",
+    "homepage": "https://www.typescriptlang.org/",
+    "version": "6.0.3",
+    "license": "Apache-2.0",
+    "description": "TypeScript is a language for application scale JavaScript development",
+    "keywords": [
+        "TypeScript",
+        "Microsoft",
+        "compiler",
+        "language",
+        "javascript"
+    ],
+    "bugs": {
+        "url": "https://github.com/microsoft/TypeScript/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/microsoft/TypeScript.git"
+    },
+    "main": "./lib/typescript.js",
+    "typings": "./lib/typescript.d.ts",
+    "bin": {
+        "tsc": "./bin/tsc",
+        "tsserver": "./bin/tsserver"
+    },
+    "engines": {
+        "node": ">=14.17"
+    },
+    "files": [
+        "bin",
+        "lib",
+        "!lib/enu",
+        "LICENSE.txt",
+        "README.md",
+        "SECURITY.md",
+        "ThirdPartyNoticeText.txt",
+        "!**/.gitattributes"
+    ],
+    "devDependencies": {
+        "@dprint/formatter": "^0.4.1",
+        "@dprint/typescript": "0.93.4",
+        "@esfx/canceltoken": "^1.0.0",
+        "@eslint/js": "^10.0.1",
+        "@octokit/rest": "^22.0.1",
+        "@types/chai": "^4.3.20",
+        "@types/minimist": "^1.2.5",
+        "@types/mocha": "^10.0.10",
+        "@types/ms": "^2.1.0",
+        "@types/node": "latest",
+        "@types/source-map-support": "^0.5.10",
+        "@types/which": "^3.0.4",
+        "@typescript-eslint/rule-tester": "^8.56.1",
+        "@typescript-eslint/type-utils": "^8.56.1",
+        "@typescript-eslint/utils": "^8.56.1",
+        "azure-devops-node-api": "^15.1.3",
+        "c8": "^10.1.3",
+        "chai": "^4.5.0",
+        "chokidar": "^4.0.3",
+        "diff": "^8.0.3",
+        "dprint": "^0.49.1",
+        "esbuild": "^0.27.3",
+        "eslint": "^10.0.2",
+        "eslint-plugin-regexp": "^3.0.0",
+        "fast-xml-parser": "^5.4.1",
+        "glob": "^10.5.0",
+        "globals": "^17.4.0",
+        "hereby": "^1.12.0",
+        "jsonc-parser": "^3.3.1",
+        "knip": "^5.85.0",
+        "minimist": "^1.2.8",
+        "mocha": "^10.8.2",
+        "mocha-fivemat-progress-reporter": "^0.1.0",
+        "monocart-coverage-reports": "^2.12.9",
+        "ms": "^2.1.3",
+        "picocolors": "^1.1.1",
+        "playwright": "^1.58.2",
+        "source-map-support": "^0.5.21",
+        "tslib": "^2.8.1",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.56.1",
+        "which": "^3.0.1"
+    },
+    "overrides": {
+        "typescript@*": "$typescript"
+    },
+    "scripts": {
+        "test": "hereby runtests-parallel --light=false",
+        "test:eslint-rules": "hereby run-eslint-rules-tests",
+        "build": "npm run build:compiler && npm run build:tests",
+        "build:compiler": "hereby local",
+        "build:tests": "hereby tests",
+        "build:tests:notypecheck": "hereby tests --no-typecheck",
+        "clean": "hereby clean",
+        "gulp": "hereby",
+        "lint": "hereby lint",
+        "knip": "hereby knip",
+        "format": "dprint fmt",
+        "setup-hooks": "node scripts/link-hooks.mjs"
+    },
+    "browser": {
+        "fs": false,
+        "os": false,
+        "path": false,
+        "crypto": false,
+        "buffer": false,
+        "source-map-support": false,
+        "inspector": false,
+        "perf_hooks": false
+    },
+    "packageManager": "npm@8.19.4",
+    "volta": {
+        "node": "22.22.0",
+        "npm": "8.19.4"
+    },
+    "gitHead": "050880ce59e30b356b686bd3144efe24f875ebc8"
+}

package/node_modules/@mrclrchtr/supi-lsp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "1.8.0",
+  "version": "1.9.1",
   "description": "SuPi LSP extension — Language Server Protocol integration for pi",
   "license": "MIT",
   "repository": {
@@ -26,10 +26,14 @@
     "vscode-jsonrpc": "^8.2.1",
     "vscode-languageserver-protocol": "^3.17.5",
     "vscode-languageserver-types": "^3.17.5",
-    "@mrclrchtr/supi-core": "1.8.0"
+    "@mrclrchtr/supi-code-runtime": "1.9.1",
+    "@mrclrchtr/supi-core": "1.9.1"
   },
   "bundledDependencies": [
+    "@mrclrchtr/supi-code-runtime",
     "@mrclrchtr/supi-core",
+    "ignore",
+    "typescript",
     "vscode-jsonrpc",
     "vscode-languageserver-protocol",
     "vscode-languageserver-types"
@@ -56,14 +60,15 @@
   },
   "pi": {
     "extensions": [
-      "./src/extension.ts",
-      "node_modules/@mrclrchtr/supi-core/src/extension.ts"
-    ]
+      "./src/extension.ts"
+    ],
+    "image": "https://raw.githubusercontent.com/mrclrchtr/supi/main/packages/supi-lsp/assets/logo.png"
   },
   "main": "src/api.ts",
   "exports": {
     "./api": "./src/api.ts",
     "./extension": "./src/extension.ts",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./provider/lsp-semantic-provider": "./src/provider/lsp-semantic-provider.ts"
   }
 }

package/node_modules/@mrclrchtr/supi-lsp/src/handlers/session-lifecycle.ts

@@ -8,6 +8,7 @@ import type {
   ExtensionContext,
   SessionStartEvent,
 } from "@earendil-works/pi-coding-agent";
+import type { WorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
 import { loadConfig, resolveLanguageAlias } from "../config/config.ts";
 import { clearTsconfigCache } from "../config/tsconfig-scope.ts";
 import { scanWorkspaceSentinels } from "../diagnostics/workspace-sentinels.ts";
@@ -18,6 +19,10 @@ import {
   type LspRuntimeState,
   refreshProjectServers,
 } from "../session/lsp-state.ts";
+import {
+  registerLspCapabilities,
+  unregisterLspCapabilities,
+} from "../session/runtime-registration.ts";
 import {
   scanMissingServers,
   scanProjectCapabilities,
@@ -38,11 +43,15 @@ import { updateLspUi } from "../ui/ui.ts";
  * Register session lifecycle handlers (start, shutdown, and agent-end cleanup).
  *
  * - `session_start`: initialises the LspManager, starts detected servers, wires
- *   dynamic tool guidance, and syncs UI state.
+ *   dynamic tool guidance, publishes runtime capabilities, and syncs UI state.
  * - `session_shutdown`: tears down the manager and clears runtime state.
  * - `agent_end`: refreshes project-server info and updates the LSP status UI.
  */
-export function registerSessionLifecycleHandlers(pi: ExtensionAPI, state: LspRuntimeState): void {
+export function registerSessionLifecycleHandlers(
+  pi: ExtensionAPI,
+  state: LspRuntimeState,
+  runtime: WorkspaceRuntime,
+): void {
   // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: session_start orchestrates setup, server detection, settings, and persistence.
   pi.on("session_start", async (_event: SessionStartEvent, ctx: ExtensionContext) => {
     if (state.manager) {
@@ -100,10 +109,9 @@ export function registerSessionLifecycleHandlers(pi: ExtensionAPI, state: LspRun
     state.lastDiagnosticsFingerprint = null;
     state.currentContextToken = null;
     state.lspActive = true;
-    setSessionLspServiceState(cwd, {
-      kind: "ready",
-      service: new SessionLspService(state.manager),
-    });
+    const service = new SessionLspService(state.manager);
+    setSessionLspServiceState(cwd, { kind: "ready", service });
+    registerLspCapabilities(runtime, cwd, service);
     registerLspTools(pi, buildLspToolPromptSurfaces(state.projectServers, cwd));
     ensureLspToolsActive(pi);
     persistLspActiveState(pi, state);
@@ -113,7 +121,9 @@ export function registerSessionLifecycleHandlers(pi: ExtensionAPI, state: LspRun
   pi.on("session_shutdown", async () => {
     clearTsconfigCache();
     if (state.manager) {
-      clearSessionLspService(state.manager.getCwd());
+      const cwd = state.manager.getCwd();
+      unregisterLspCapabilities(runtime, cwd);
+      clearSessionLspService(cwd);
       await state.manager.shutdownAll();
       state.manager = null;
     }

package/node_modules/@mrclrchtr/supi-lsp/src/lsp.ts

@@ -3,6 +3,7 @@
 // modules so each orchestration concern lives in its own file.
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
 import { registerDiagnosticInjectionHandlers } from "./handlers/diagnostic-injection.ts";
 import { registerSessionLifecycleHandlers } from "./handlers/session-lifecycle.ts";
 import { registerLspStatusCommand } from "./handlers/status-command.ts";
@@ -18,6 +19,7 @@ import { registerLspMessageRenderer } from "./ui/renderer.ts";
 export default function lspExtension(pi: ExtensionAPI) {
   registerLspSettings();
   const state = createRuntimeState();
+  const runtime = getDefaultWorkspaceRuntime();
 
   registerLspAwareToolOverrides(pi, {
     getInlineSeverity: () => state.inlineSeverity,
@@ -26,7 +28,7 @@ export default function lspExtension(pi: ExtensionAPI) {
   });
 
   registerLspTools(pi, defaultLspToolPromptSurfaces);
-  registerSessionLifecycleHandlers(pi, state);
+  registerSessionLifecycleHandlers(pi, state, runtime);
   registerDiagnosticInjectionHandlers(pi, state);
   registerWorkspaceRecoveryHandler(pi, state);
   registerTreePersistHandlers(pi, state);

package/node_modules/@mrclrchtr/supi-lsp/src/manager/capability-index.ts

@@ -0,0 +1,24 @@
+// Capability index — indexes and queries server capabilities.
+
+import type { ServerCapabilities } from "../config/types.ts";
+import { getSupportedLspServerActions } from "../tool/tool-specs.ts";
+import type { LspManager } from "./manager.ts";
+
+/**
+ * Indexes and queries what each server supports.
+ */
+export interface CapabilityIndex {
+  /** Get the list of supported LSP actions for a server's capabilities. */
+  getSupportedActions(capabilities: ServerCapabilities | null | undefined): string[];
+}
+
+/**
+ * Create a CapabilityIndex for a workspace.
+ */
+export function createCapabilityIndex(_manager: LspManager): CapabilityIndex {
+  return {
+    getSupportedActions(capabilities) {
+      return getSupportedLspServerActions(capabilities);
+    },
+  };
+}

package/node_modules/@mrclrchtr/supi-lsp/src/manager/client-pool.ts

@@ -0,0 +1,33 @@
+// Client pool — manages LSP client lifecycle (start, stop, reconnect).
+
+import type { LspManager } from "./manager.ts";
+
+/**
+ * Manages the lifecycle of LSP client instances for a workspace.
+ * Currently delegates to LspManager; the extraction will grow
+ * as responsibilities are migrated from manager.ts.
+ */
+export interface ClientPool {
+  /**
+   * Ensure a file has an active client and return it.
+   * Returns null if no server can serve the file.
+   */
+  ensureFileOpen(filePath: string): ReturnType<LspManager["ensureFileOpen"]>;
+
+  /** Shut down all active clients. */
+  shutdownAll(): Promise<void>;
+}
+
+/**
+ * Create a ClientPool backed by LspManager.
+ */
+export function createClientPool(manager: LspManager): ClientPool {
+  return {
+    async ensureFileOpen(filePath: string) {
+      return manager.ensureFileOpen(filePath);
+    },
+    async shutdownAll() {
+      return manager.shutdownAll();
+    },
+  };
+}

package/node_modules/@mrclrchtr/supi-lsp/src/manager/diagnostic-store.ts

@@ -0,0 +1,51 @@
+// Diagnostic store — stores, aggregates, and queries diagnostics.
+
+import type { Diagnostic } from "../config/types.ts";
+import type { LspManager } from "./manager.ts";
+
+/**
+ * Stores and queries diagnostics per file.
+ * Currently delegates to LspManager methods.
+ */
+export interface DiagnosticStore {
+  /** Get workspace diagnostic summary grouped by file. */
+  getDiagnosticSummary(): Array<{ file: string; errors: number; warnings: number }>;
+
+  /** Get outstanding diagnostics at or above severity. */
+  getOutstandingDiagnostics(
+    maxSeverity?: number,
+  ): Array<{ file: string; diagnostics: Diagnostic[] }>;
+
+  /** Get outstanding diagnostic summary grouped by file. */
+  getOutstandingDiagnosticSummary(maxSeverity?: number): Array<{
+    file: string;
+    total: number;
+    errors: number;
+    warnings: number;
+    information: number;
+    hints: number;
+  }>;
+
+  /** Sync a file and return its diagnostics. */
+  syncAndGetDiagnostics(filePath: string, maxSeverity?: number): Promise<Diagnostic[] | null>;
+}
+
+/**
+ * Create a DiagnosticStore backed by LspManager.
+ */
+export function createDiagnosticStore(manager: LspManager): DiagnosticStore {
+  return {
+    getDiagnosticSummary() {
+      return manager.getDiagnosticSummary();
+    },
+    getOutstandingDiagnostics(maxSeverity = 1) {
+      return manager.getOutstandingDiagnostics(maxSeverity);
+    },
+    getOutstandingDiagnosticSummary(maxSeverity = 1) {
+      return manager.getOutstandingDiagnosticSummary(maxSeverity);
+    },
+    async syncAndGetDiagnostics(filePath: string, maxSeverity = 4) {
+      return manager.syncFileAndGetDiagnostics(filePath, maxSeverity);
+    },
+  };
+}

package/node_modules/@mrclrchtr/supi-lsp/src/manager/recovery-coordinator.ts

@@ -0,0 +1,37 @@
+// Recovery coordinator — orchestrates stale diagnostic recovery.
+
+import type { LspManager } from "./manager.ts";
+
+/**
+ * Orchestrates stale diagnostic detection and recovery.
+ */
+export interface RecoveryCoordinator {
+  /**
+   * Trigger a workspace-wide diagnostics refresh.
+   * Returns info about refreshed/restarted clients and stale assessment.
+   */
+  recover(options?: {
+    restartIfStillStale?: boolean;
+    maxWaitMs?: number;
+    quietMs?: number;
+  }): Promise<{
+    refreshedClients: number;
+    restartedClients: number;
+    staleAssessment: {
+      suspected: boolean;
+      matchedFiles: Array<{ file: string; diagnostics: unknown[] }>;
+      warning: string | null;
+    };
+  }>;
+}
+
+/**
+ * Create a RecoveryCoordinator backed by LspManager.
+ */
+export function createRecoveryCoordinator(manager: LspManager): RecoveryCoordinator {
+  return {
+    async recover(options) {
+      return manager.recoverWorkspaceDiagnostics(options);
+    },
+  };
+}

package/node_modules/@mrclrchtr/supi-lsp/src/manager/workspace-router.ts

@@ -0,0 +1,44 @@
+// Workspace router — routes files to the correct LSP client based on project root.
+
+import type { ProjectServerInfo } from "../config/server-config.ts";
+import type { LspManager } from "./manager.ts";
+
+/**
+ * Routes file paths to the correct LSP client and tracks
+ * which project roots are known.
+ */
+export interface WorkspaceRouter {
+  /** Check whether a file can be served by any active server. */
+  canServeFile(filePath: string): boolean;
+
+  /** Check whether a source file type is supported. */
+  isSupportedSourceFile(filePath: string): boolean;
+
+  /** Get known project server info. */
+  getProjectServers(): ProjectServerInfo[];
+
+  /** Register detected servers from the workspace scan. */
+  registerDetectedServers(servers: Array<{ language: string; root: string }>): void;
+}
+
+/**
+ * Create a WorkspaceRouter backed by LspManager.
+ */
+export function createWorkspaceRouter(manager: LspManager): WorkspaceRouter {
+  return {
+    canServeFile(filePath: string) {
+      return manager.canServeFile(filePath);
+    },
+    isSupportedSourceFile(filePath: string) {
+      return manager.isSupportedSourceFile(filePath);
+    },
+    getProjectServers(): ProjectServerInfo[] {
+      return manager.getKnownProjectServers([]);
+    },
+    registerDetectedServers(servers: Array<{ language: string; root: string }>) {
+      manager.registerDetectedServers(
+        servers as unknown as Parameters<typeof manager.registerDetectedServers>[0],
+      );
+    },
+  };
+}

package/node_modules/@mrclrchtr/supi-lsp/src/provider/lsp-semantic-provider.ts

@@ -0,0 +1,156 @@
+// LSP semantic provider adapter — wraps SessionLspService into the shared
+// SemanticProvider contract from supi-code-runtime.
+
+import type {
+  CodeLocation,
+  CodePosition,
+  CodeSymbol,
+  SemanticProvider,
+} from "@mrclrchtr/supi-code-runtime/api";
+import type { DocumentSymbol, Location, LocationLink, SymbolInformation } from "../config/types.ts";
+import type { SessionLspService } from "../session/service-registry.ts";
+
+/**
+ * Create a SemanticProvider backed by a SessionLspService.
+ * Maps LSP types into the shared code-runtime types.
+ */
+export function createLspSemanticProvider(lsp: SessionLspService): SemanticProvider {
+  return {
+    async references(filePath: string, position: CodePosition): Promise<CodeLocation[] | null> {
+      const refResult = await lsp.references(filePath, position);
+      if (!refResult) return null;
+      const mapped: CodeLocation[] = [];
+      for (const item of refResult) {
+        const loc = toCodeLocation(item);
+        if (loc) mapped.push(loc);
+      }
+      return mapped;
+    },
+
+    async implementation(filePath: string, position: CodePosition): Promise<CodeLocation[] | null> {
+      const implResult = await lsp.implementation(filePath, position);
+      if (!implResult) return null;
+      const normalized = Array.isArray(implResult) ? implResult : [implResult];
+      const mapped: CodeLocation[] = [];
+      for (const item of normalized) {
+        const loc = toCodeLocation(item);
+        if (loc) mapped.push(loc);
+      }
+      return mapped;
+    },
+
+    async documentSymbols(filePath: string): Promise<CodeSymbol[] | null> {
+      const symbols = await lsp.documentSymbols(filePath);
+      if (!symbols) return null;
+      return flattenDocumentSymbols(symbols, filePath);
+    },
+
+    async workspaceSymbols(query: string): Promise<CodeSymbol[] | null> {
+      const results = await lsp.workspaceSymbol(query);
+      if (!results) return null;
+      return results.map((sym) => toCodeSymbol(sym as SymbolInformation));
+    },
+  };
+}
+
+// ── Type conversion helpers ───────────────────────────────────────────
+
+function toCodeLocation(item: Location | LocationLink): CodeLocation | null {
+  const loc = item as Record<string, unknown>;
+  const uri = loc.uri ?? loc.targetUri;
+  if (typeof uri !== "string") return null;
+
+  // Prefer targetSelectionRange > targetRange > range
+  const range = loc.targetSelectionRange ?? loc.targetRange ?? loc.range;
+  if (!range || typeof range !== "object") return null;
+
+  const r = range as { start: Record<string, unknown>; end: Record<string, unknown> };
+  const start = r.start;
+  const end = r.end;
+  if (!start || !end) return null;
+
+  return {
+    uri,
+    range: {
+      start: { line: (start.line as number) ?? 0, character: (start.character as number) ?? 0 },
+      end: { line: (end.line as number) ?? 0, character: (end.character as number) ?? 0 },
+    },
+  };
+}
+
+const SYMBOL_KIND_NAMES: Record<number, string> = {
+  1: "File",
+  2: "Module",
+  3: "Namespace",
+  4: "Package",
+  5: "Class",
+  6: "Method",
+  7: "Property",
+  8: "Field",
+  9: "Constructor",
+  10: "Enum",
+  11: "Interface",
+  12: "Function",
+  13: "Variable",
+  14: "Constant",
+  15: "String",
+  16: "Number",
+  17: "Boolean",
+  18: "Array",
+  19: "Object",
+  20: "Key",
+  21: "Null",
+  22: "EnumMember",
+  23: "Struct",
+  24: "Event",
+  25: "Operator",
+  26: "TypeParameter",
+};
+
+function symbolKindName(kind: number): string {
+  return SYMBOL_KIND_NAMES[kind] ?? "Unknown";
+}
+
+function flattenDocumentSymbols(
+  symbols: DocumentSymbol[] | SymbolInformation[],
+  filePath: string,
+  container: string | null = null,
+): CodeSymbol[] {
+  const result: CodeSymbol[] = [];
+
+  for (const sym of symbols) {
+    // DocumentSymbol has selectionRange; SymbolInformation has location
+    const ds = sym as DocumentSymbol;
+    const si = sym as SymbolInformation;
+    const start = ds.selectionRange?.start ?? si.location?.range?.start;
+    if (!start) continue;
+
+    result.push({
+      name: sym.name,
+      kind: symbolKindName(sym.kind),
+      file: filePath,
+      line: start.line + 1,
+      character: start.character + 1,
+      container,
+    });
+
+    if (Array.isArray(ds.children) && ds.children.length > 0) {
+      result.push(...flattenDocumentSymbols(ds.children, filePath, sym.name));
+    }
+  }
+
+  return result;
+}
+
+function toCodeSymbol(sym: SymbolInformation): CodeSymbol {
+  const uri = sym.location?.uri ?? "";
+  const start = sym.location?.range?.start;
+  return {
+    name: sym.name,
+    kind: symbolKindName(sym.kind),
+    file: uri.startsWith("file://") ? decodeURIComponent(uri.slice(7)) : uri,
+    line: start ? start.line + 1 : 0,
+    character: start ? start.character + 1 : 0,
+    container: sym.containerName ?? null,
+  };
+}

package/node_modules/@mrclrchtr/supi-lsp/src/session/runtime-registration.ts

@@ -0,0 +1,39 @@
+/**
+ * LSP-to-runtime capability registration.
+ *
+ * Adapts a SessionLspService into the runtime's SemanticProvider interface
+ * and registers/unregisters it with the shared WorkspaceRuntime at session
+ * lifecycle boundaries.
+ */
+
+import type { WorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
+import { createLspSemanticProvider } from "../provider/lsp-semantic-provider.ts";
+import type { SessionLspService } from "./service-registry.ts";
+
+/**
+ * Register LSP capabilities for a workspace cwd.
+ *
+ * Wraps SessionLspService into a SemanticProvider via the existing
+ * semantic adapter and publishes it into the shared workspace runtime
+ * so that code-intelligence and other consumers can discover semantic
+ * analysis availability.
+ */
+export function registerLspCapabilities(
+  runtime: WorkspaceRuntime,
+  cwd: string,
+  service: SessionLspService,
+): void {
+  const provider = createLspSemanticProvider(service);
+  runtime.registerSemantic(cwd, provider);
+}
+
+/**
+ * Unregister LSP capabilities for a workspace cwd.
+ *
+ * Clears only the semantic capability slot — structural (tree-sitter)
+ * state is left intact so that a later tree-sitter session_start does
+ * not needlessly wipe LSP state on its own restart path.
+ */
+export function unregisterLspCapabilities(runtime: WorkspaceRuntime, cwd: string): void {
+  runtime.clearSemantic(cwd);
+}

package/node_modules/@mrclrchtr/supi-lsp/src/tool/register-tools.ts

@@ -47,7 +47,6 @@ function createToolExecutor(
     params: unknown,
   ) => Promise<string>,
 ) {
-  // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
   return async (
     _toolCallId: string,
     params: unknown,