@mrclrchtr/supi-code-intelligence 1.8.0 → 1.9.0

package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-code-runtime/src/types.ts

@@ -0,0 +1,110 @@
+/**
+ * Canonical shared types for the SuPi code-understanding stack.
+ *
+ * These types are package-agnostic and used across supi-lsp, supi-tree-sitter,
+ * and supi-code-intelligence for communicating code analysis results,
+ * capability availability, and structural data shapes.
+ */
+
+// ── Position and location types ────────────────────────────────────────
+
+/** 0-based LSP position. */
+export interface CodePosition {
+  line: number;
+  character: number;
+}
+
+/** A source range spanning two CodePositions. */
+export interface SourceRange {
+  start: CodePosition;
+  end: CodePosition;
+}
+
+/** A code location (file URI + range). */
+export interface CodeLocation {
+  uri: string;
+  range: SourceRange;
+}
+
+// ── Symbol types ───────────────────────────────────────────────────────
+
+/** A discovered symbol / declaration. */
+export interface CodeSymbol {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  character: number;
+  container?: string | null;
+}
+
+// ── Result types ───────────────────────────────────────────────────────
+
+/**
+ * Discriminated result union for provider operations.
+ *
+ * Used primarily by structural (tree-sitter-backed) operations that
+ * have explicit error and unsupported-language states. Semantic operations
+ * use `null` to signal absence.
+ */
+export type CodeResult<T> =
+  | { kind: "success"; data: T }
+  | { kind: "unsupported-language"; file: string; message: string }
+  | { kind: "file-access-error"; file: string; message: string }
+  | { kind: "validation-error"; message: string }
+  | { kind: "runtime-error"; message: string }
+  | { kind: "unavailable"; message: string };
+
+/** Result confidence classification. */
+export type ConfidenceMode = "semantic" | "structural" | "heuristic" | "unavailable";
+
+// ── Structural data shapes (value types, range-flattened) ──────────────
+
+export interface OutlineData {
+  name: string;
+  kind: string;
+  startLine: number;
+  startCharacter: number;
+  endLine: number;
+  endCharacter: number;
+  children?: OutlineData[];
+}
+
+export interface ExportData {
+  name: string;
+  kind: string;
+  startLine: number;
+  startCharacter: number;
+  endLine: number;
+  endCharacter: number;
+  moduleSpecifier?: string;
+}
+
+export interface ImportData {
+  moduleSpecifier: string;
+  startLine: number;
+  startCharacter: number;
+  endLine: number;
+  endCharacter: number;
+}
+
+export interface NodeAtData {
+  type: string;
+  startLine: number;
+  startCharacter: number;
+  endLine: number;
+  endCharacter: number;
+  text: string;
+  ancestry: Array<{
+    type: string;
+    startLine: number;
+    startCharacter: number;
+    endLine: number;
+    endCharacter: number;
+  }>;
+}
+
+export interface CalleesData {
+  enclosingScope: { name: string; startLine: number; endLine: number };
+  callees: Array<{ name: string; startLine: number }>;
+}

package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-code-runtime/src/workspace/context.ts

@@ -0,0 +1,41 @@
+/**
+ * Typed request context helper for consumers that need a convenient view
+ * of the capability state for a workspace cwd.
+ *
+ * This is the primary way that `supi-code-intelligence` reads capability
+ * state from the shared runtime. Substrates register providers through
+ * {@link WorkspaceRuntime} directly.
+ */
+
+import type { CapabilityState, SemanticProvider, StructuralProvider } from "../capability/types.ts";
+import type { WorkspaceRuntime } from "./runtime.ts";
+
+/**
+ * A workspace-scoped request context that provides access to active
+ * semantic and structural capabilities along with their availability
+ * state and the cached project model.
+ */
+export interface WorkspaceContext {
+  /** The working directory this context is scoped to. */
+  cwd: string;
+  /** Semantic analysis capability state and provider. */
+  semantic: { state: CapabilityState; provider: SemanticProvider | null };
+  /** Structural analysis capability state and provider. */
+  structural: { state: CapabilityState; provider: StructuralProvider | null };
+}
+
+/**
+ * Create a typed workspace context from the shared runtime.
+ *
+ * @param cwd - The working directory for this context.
+ * @param runtime - The shared workspace runtime instance.
+ * @returns A snapshot of the capability state for this workspace.
+ */
+export function createWorkspaceContext(cwd: string, runtime: WorkspaceRuntime): WorkspaceContext {
+  const ws = runtime.getWorkspace(cwd);
+  return {
+    cwd,
+    semantic: ws.semantic,
+    structural: ws.structural,
+  };
+}

package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-code-runtime/src/workspace/runtime.ts

@@ -0,0 +1,170 @@
+/**
+ * Workspace-scoped capability registry.
+ *
+ * Substrates (LSP, tree-sitter) register their capabilities per cwd
+ * at session startup. Code-intelligence reads capability state from
+ * this registry instead of maintaining a local provider composition
+ * layer.
+ *
+ * Capabilities are independent: registering a semantic provider does not
+ * affect an already-registered structural provider for the same cwd.
+ */
+
+import type { CapabilityState, SemanticProvider, StructuralProvider } from "../capability/types.ts";
+
+// ── Public types ───────────────────────────────────────────────────────
+
+/**
+ * The combined capability state for a workspace.
+ * Each capability slot includes both the availability state and the
+ * provider instance (null when not ready).
+ */
+export interface WorkspaceCapabilities {
+  semantic: { state: CapabilityState; provider: SemanticProvider | null };
+  structural: { state: CapabilityState; provider: StructuralProvider | null };
+}
+
+// ── Defaults ───────────────────────────────────────────────────────────
+
+const DEFAULT_UNAVAILABLE_REASON = "No provider registered for this workspace";
+
+function createDefaultCapabilities(): WorkspaceCapabilities {
+  return {
+    semantic: {
+      state: { kind: "unavailable", reason: DEFAULT_UNAVAILABLE_REASON },
+      provider: null,
+    },
+    structural: {
+      state: { kind: "unavailable", reason: DEFAULT_UNAVAILABLE_REASON },
+      provider: null,
+    },
+  };
+}
+
+// ── Runtime ────────────────────────────────────────────────────────────
+
+/**
+ * Workspace-scoped capability registry keyed by cwd/project root.
+ *
+ * Each workspace stores independent capability state for semantic
+ * (LSP-backed) and structural (tree-sitter-backed) analysis. Substrates
+ * register their capabilities at session start; consumers read them
+ * as needed.
+ *
+ * The registry is intentionally unopinionated about which capabilities
+ * are required — a workspace may have only semantic, only structural,
+ * both, or neither.
+ */
+export class WorkspaceRuntime {
+  readonly #workspaces = new Map<string, WorkspaceCapabilities>();
+
+  /**
+   * Get the capability state for a workspace cwd.
+   * Returns a default "unavailable" state if the workspace
+   * has never been registered.
+   */
+  getWorkspace(cwd: string): WorkspaceCapabilities {
+    return this.#workspaces.get(cwd) ?? createDefaultCapabilities();
+  }
+
+  /**
+   * Register a semantic provider for a workspace.
+   * Replaces any existing semantic provider for the same cwd
+   * without affecting the structural provider.
+   */
+  registerSemantic(cwd: string, provider: SemanticProvider): void {
+    const existing = this.#workspaces.get(cwd);
+    if (existing) {
+      existing.semantic = { state: { kind: "ready" }, provider };
+    } else {
+      this.#workspaces.set(cwd, {
+        semantic: { state: { kind: "ready" }, provider },
+        structural: createDefaultCapabilities().structural,
+      });
+    }
+  }
+
+  /**
+   * Register a structural provider for a workspace.
+   * Replaces any existing structural provider for the same cwd
+   * without affecting the semantic provider.
+   */
+  registerStructural(cwd: string, provider: StructuralProvider): void {
+    const existing = this.#workspaces.get(cwd);
+    if (existing) {
+      existing.structural = { state: { kind: "ready" }, provider };
+    } else {
+      this.#workspaces.set(cwd, {
+        semantic: createDefaultCapabilities().semantic,
+        structural: { state: { kind: "ready" }, provider },
+      });
+    }
+  }
+
+  /**
+   * Remove all capability state for a single workspace cwd.
+   */
+  clearWorkspace(cwd: string): void {
+    this.#workspaces.delete(cwd);
+  }
+
+  /**
+   * Clear only the semantic capability slot for a workspace.
+   * Leaves the structural slot untouched.
+   */
+  clearSemantic(cwd: string): void {
+    const ws = this.#workspaces.get(cwd);
+    if (!ws) return;
+    ws.semantic = createDefaultCapabilities().semantic;
+    // If both slots are now unavailable, remove the entire entry
+    if (ws.semantic.state.kind === "unavailable" && ws.structural.state.kind === "unavailable") {
+      this.#workspaces.delete(cwd);
+    }
+  }
+
+  /**
+   * Clear only the structural capability slot for a workspace.
+   * Leaves the semantic slot untouched.
+   */
+  clearStructural(cwd: string): void {
+    const ws = this.#workspaces.get(cwd);
+    if (!ws) return;
+    ws.structural = createDefaultCapabilities().structural;
+    // If both slots are now unavailable, remove the entire entry
+    if (ws.semantic.state.kind === "unavailable" && ws.structural.state.kind === "unavailable") {
+      this.#workspaces.delete(cwd);
+    }
+  }
+
+  /**
+   * Remove all capability state for every workspace.
+   */
+  clearAll(): void {
+    this.#workspaces.clear();
+  }
+}
+
+// ── Default singleton ───────────────────────────────────────────────────
+
+const RUNTIME_SYMBOL = Symbol.for("@mrclrchtr/supi-code-runtime/default-runtime");
+
+/**
+ * Get the shared default workspace runtime instance.
+ *
+ * Backed by `globalThis` + `Symbol.for` so that all jiti module instances
+ * (even duplicate loads through separate `node_modules` paths) share the
+ * same WorkspaceRuntime. Without this, standalone installs where
+ * `supi-lsp`, `supi-tree-sitter`, and `supi-code-intelligence` each bundle
+ * their own copy of `@mrclrchtr/supi-code-runtime` would get separate
+ * runtimes — LSP/tree-sitter would register capabilities into one while
+ * code-intelligence reads from another.
+ */
+export function getDefaultWorkspaceRuntime(): WorkspaceRuntime {
+  const g = globalThis as Record<symbol, unknown>;
+  let runtime = g[RUNTIME_SYMBOL] as WorkspaceRuntime | undefined;
+  if (!runtime) {
+    runtime = new WorkspaceRuntime();
+    g[RUNTIME_SYMBOL] = runtime;
+  }
+  return runtime;
+}

package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-core/README.md

@@ -1,29 +1,20 @@
+![SuPi](assets/logo.png)
+
 # @mrclrchtr/supi-core
 
 Shared infrastructure for SuPi extensions.
 
-This package is mainly for extension authors. It gives you a common config system, settings plumbing, context helpers, registries, and a small extension surface that registers `/supi-settings`.
+This is a **pure library** — it does not register any pi commands or tools. The `/supi-settings` command is now available through `@mrclrchtr/supi-settings`.
 
 ## Install
 
-### As a dependency for another extension
-
 ```bash
 pnpm add @mrclrchtr/supi-core
 ```
 
-### As a pi package
-
-```bash
-pi install npm:@mrclrchtr/supi-core
-```
-
-Installing it as a pi package adds the minimal `/supi-settings` extension surface.
-
 ## Package surfaces
 
 - `@mrclrchtr/supi-core/api` — reusable helpers for other packages and extensions
-- `@mrclrchtr/supi-core/extension` — minimal pi extension that registers `/supi-settings`
 
 ## What you get from the API
 
@@ -101,7 +92,6 @@ const message = wrapExtensionContext("my-extension", "hello", {
 ## Source
 
 - `src/api.ts` — exported library surface
-- `src/extension.ts` — minimal `/supi-settings` entrypoint
 - `src/config.ts` — shared config loading and writing
 - `src/config-settings.ts` — config-backed settings registration helper
 - `src/settings-ui.ts` — shared settings overlay

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

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "SuPi core — shared infrastructure for SuPi extensions (XML context tags, config system)",
   "license": "MIT",
   "repository": {
@@ -40,7 +40,6 @@
     "./config": "./src/config.ts",
     "./context": "./src/context.ts",
     "./debug": "./src/debug-registry.ts",
-    "./extension": "./src/extension.ts",
     "./package.json": "./package.json",
     "./path": "./src/path.ts",
     "./project": "./src/project.ts",
@@ -50,10 +49,5 @@
     "./terminal": "./src/terminal.ts",
     "./tool-framework": "./src/tool-framework.ts",
     "./types": "./src/types.ts"
-  },
-  "pi": {
-    "extensions": [
-      "./src/extension.ts"
-    ]
   }
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "SuPi LSP extension — Language Server Protocol integration for pi",
   "license": "MIT",
   "repository": {
@@ -26,9 +26,11 @@
     "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.0",
+    "@mrclrchtr/supi-core": "1.9.0"
   },
   "bundledDependencies": [
+    "@mrclrchtr/supi-code-runtime",
     "@mrclrchtr/supi-core",
     "vscode-jsonrpc",
     "vscode-languageserver-protocol",
@@ -56,14 +58,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);
+    },
+  };
+}