@mrclrchtr/supi-code-intelligence 1.8.0 → 1.9.0

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,

package/node_modules/@mrclrchtr/supi-tree-sitter/README.md

@@ -1,3 +1,5 @@
+![SuPi](assets/logo.png)
+
 # @mrclrchtr/supi-tree-sitter
 
 Adds focused structural code analysis tools to the [pi coding agent](https://github.com/earendil-works/pi) using Tree-sitter parsers.
@@ -14,7 +16,7 @@ For local development:
 pi install ./packages/supi-tree-sitter
 ```
 
-After editing the source, run `/reload`.
+![Tree-sitter outline in action](https://raw.githubusercontent.com/mrclrchtr/supi/main/screenshots/supi-tree-sitter.png)
 
 ## What you get
 
@@ -60,10 +62,25 @@ Coordinates use **1-based** line and character columns. Character positions use
 - R (`.r`)
 - SQL (`.sql`)
 
+## Architecture
+
+`@mrclrchtr/supi-tree-sitter` is the **structural substrate** in SuPi's
+code-understanding stack. It depends on `@mrclrchtr/supi-core` and
+`@mrclrchtr/supi-code-runtime` for shared contracts, and provides structural
+analysis via a session-scoped Tree-sitter service that publishes its
+capabilities into the shared workspace runtime.
+
+```text
+supi-code-runtime  ← shared contracts + workspace runtime
+    ↑
+supi-tree-sitter  ← Tree-sitter WASM + session-scoped service + runtime capabilities
+```
+
 ## Package surfaces
 
 - `@mrclrchtr/supi-tree-sitter/api` — reusable parsing session factory, shared session-scoped structural service access, and shared result types
 - `@mrclrchtr/supi-tree-sitter/extension` — pi extension entrypoint
+- `@mrclrchtr/supi-tree-sitter/provider/tree-sitter-provider` — shared StructuralProvider adapter
 
 Owned session example:
 

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/README.md

@@ -0,0 +1,13 @@
+# @mrclrchtr/supi-code-runtime
+
+Shared workspace context, capability contracts, and canonical types for the SuPi code-understanding stack.
+
+This is a **library-only package** — it has no pi extension surface, no user-facing tools, and no UI. It provides the shared abstractions that `supi-lsp`, `supi-tree-sitter`, and `supi-code-intelligence` use to communicate capability availability.
+
+## Package surfaces
+
+- `@mrclrchtr/supi-code-runtime/api` — shared canonical types, capability interfaces, workspace runtime registry, and typed request context
+
+## License
+
+MIT

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/README.md

@@ -0,0 +1,97 @@
+![SuPi](assets/logo.png)
+
+# @mrclrchtr/supi-core
+
+Shared infrastructure for SuPi extensions.
+
+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
+
+```bash
+pnpm add @mrclrchtr/supi-core
+```
+
+## Package surfaces
+
+- `@mrclrchtr/supi-core/api` — reusable helpers for other packages and extensions
+
+## What you get from the API
+
+### Config helpers
+
+- `loadSupiConfig()` — merged config with resolution order `defaults <- global <- project`
+- `loadSupiConfigForScope()` — load one scope at a time for settings UIs
+- `writeSupiConfig()` — persist values
+- `removeSupiConfigKey()` — remove a key or override
+
+Config file locations:
+
+- global: `~/.pi/agent/supi/config.json`
+- project: `.pi/supi/config.json`
+
+### Settings helpers
+
+- `registerSettings()` — register an arbitrary settings section
+- `registerConfigSettings()` — register a config-backed settings section with scoped persistence helpers
+- `registerSettingsCommand()` — register `/supi-settings`
+- `openSettingsOverlay()` — open the shared settings UI directly
+- `createInputSubmenu()` — helper for simple text-entry submenus
+
+The built-in settings UI supports:
+
+- project/global scope toggle
+- grouped extension sections
+- searchable setting lists
+
+### Context helpers
+
+- `wrapExtensionContext()` — wrap injected text in SuPi's `<extension-context>` tag
+- `findLastUserMessageIndex()`
+- `getContextToken()`
+- `getPromptContent()`
+- `pruneAndReorderContextMessages()`
+- `restorePromptContent()`
+
+### Shared registries
+
+- context-provider registry for `/supi-context`
+- debug-event registry for producers that want shared debug capture
+- settings registry used by `/supi-settings`
+
+### Project and session helpers
+
+- project-root detection and directory walking helpers such as `findProjectRoot()` and `walkProject()`
+- active-branch session helper: `getActiveBranchEntries()`
+- terminal helpers such as `formatTitle()`, `signalWaiting()`, and `signalDone()`
+
+## Example
+
+```ts
+import { loadSupiConfig, registerConfigSettings, wrapExtensionContext } from "@mrclrchtr/supi-core/api";
+
+const config = loadSupiConfig("my-extension", process.cwd(), {
+  enabled: true,
+});
+
+registerConfigSettings({
+  id: "my-extension",
+  label: "My Extension",
+  section: "my-extension",
+  defaults: { enabled: true },
+  buildItems: () => [],
+  persistChange: () => {},
+});
+
+const message = wrapExtensionContext("my-extension", "hello", {
+  file: "CLAUDE.md",
+  turn: 1,
+});
+```
+
+## Source
+
+- `src/api.ts` — exported library surface
+- `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-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@mrclrchtr/supi-core",
+  "version": "1.9.0",
+  "description": "SuPi core — shared infrastructure for SuPi extensions (XML context tags, config system)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mrclrchtr/supi.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "pi",
+    "pi-coding-agent"
+  ],
+  "files": [
+    "src/**/*.ts",
+    "!__tests__"
+  ],
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
+    },
+    "typebox": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "25.9.1",
+    "vitest": "4.1.7"
+  },
+  "main": "src/api.ts",
+  "exports": {
+    "./api": "./src/api.ts",
+    "./config": "./src/config.ts",
+    "./context": "./src/context.ts",
+    "./debug": "./src/debug-registry.ts",
+    "./package.json": "./package.json",
+    "./path": "./src/path.ts",
+    "./project": "./src/project.ts",
+    "./session": "./src/session.ts",
+    "./settings": "./src/settings.ts",
+    "./settings-ui": "./src/settings-ui.ts",
+    "./terminal": "./src/terminal.ts",
+    "./tool-framework": "./src/tool-framework.ts",
+    "./types": "./src/types.ts"
+  }
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/api.ts

@@ -0,0 +1,30 @@
+// supi-core — shared infrastructure for SuPi extensions.
+// Provides XML context tag wrapping, unified config system, context-message utilities,
+// settings registry for supi-wide TUI settings, and a shared tool-spec/registration framework.
+//
+// Convenience barrel — re-exports all domain entry points.
+// For lighter imports, use one of the domain subpaths directly
+// (e.g. @mrclrchtr/supi-core/config, @mrclrchtr/supi-core/context).
+
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./config.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./context.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./debug-registry.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./path.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./project.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./session.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./settings.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./settings-ui.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./terminal.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./tool-framework.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./types.ts";

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/config/config-settings.ts

@@ -0,0 +1,76 @@
+// Config-aware settings helper for SuPi config-backed settings sections.
+// Wraps registerSettings() and centralizes selected-scope loading + scoped persistence.
+
+import type { SettingItem } from "@earendil-works/pi-tui";
+import type { SettingsScope } from "../settings/settings-registry.ts";
+import { registerSettings } from "../settings/settings-registry.ts";
+import { loadSupiConfigForScope, removeSupiConfigKey, writeSupiConfig } from "./config.ts";
+
+export interface ConfigSettingsHelpers {
+  /** Write a key to the selected scope's config section. */
+  set(key: string, value: unknown): void;
+  /** Remove a key from the selected scope's config section. */
+  unset(key: string): void;
+}
+
+export interface ConfigSettingsOptions<T> {
+  /** Extension identifier — e.g. "lsp", "claude-md" */
+  id: string;
+  /** Human-readable label shown in the UI */
+  label: string;
+  /** SuPi config section name — e.g. "lsp", "claude-md" */
+  section: string;
+  /** Default config values */
+  defaults: T;
+  /** Build SettingItem[] from scoped config. Called by loadValues. */
+  buildItems: (settings: T, scope: SettingsScope, cwd: string) => SettingItem[];
+  /** Handle a settings change with scoped persistence helpers. */
+  persistChange: (
+    scope: SettingsScope,
+    cwd: string,
+    settingId: string,
+    value: string,
+    helpers: ConfigSettingsHelpers,
+  ) => void;
+  /** Optional home directory for config resolution (testing). */
+  homeDir?: string;
+}
+
+/**
+ * Register a config-backed settings section.
+ *
+ * Loads display values from the selected scope only (`defaults <- selected scope`)
+ * instead of merged effective runtime config. Provides scoped `set` / `unset`
+ * persistence helpers so extensions don't need to wire `writeSupiConfig` /
+ * `removeSupiConfigKey` by hand.
+ */
+export function registerConfigSettings<T>(options: ConfigSettingsOptions<T>): void {
+  registerSettings({
+    id: options.id,
+    label: options.label,
+    loadValues: (scope, cwd) => {
+      const settings = loadSupiConfigForScope(options.section, cwd, options.defaults, {
+        scope,
+        homeDir: options.homeDir,
+      });
+      return options.buildItems(settings, scope, cwd);
+    },
+    persistChange: (scope, cwd, settingId, value) => {
+      const helpers: ConfigSettingsHelpers = {
+        set: (key, val) => {
+          writeSupiConfig(
+            { section: options.section, scope, cwd },
+            { [key]: val },
+            { homeDir: options.homeDir },
+          );
+        },
+        unset: (key) => {
+          removeSupiConfigKey({ section: options.section, scope, cwd }, key, {
+            homeDir: options.homeDir,
+          });
+        },
+      };
+      options.persistChange(scope, cwd, settingId, value, helpers);
+    },
+  });
+}