@mrclrchtr/supi-code-intelligence 1.8.0 → 1.9.1

package/node_modules/@mrclrchtr/supi-tree-sitter/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-tree-sitter/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-tree-sitter/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-tree-sitter/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-tree-sitter/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "1.8.0",
+  "version": "1.9.1",
   "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-tree-sitter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "1.8.0",
+  "version": "1.9.1",
   "description": "SuPi Tree-sitter extension — structural AST analysis for pi",
   "license": "MIT",
   "repository": {
@@ -24,7 +24,8 @@
   ],
   "dependencies": {
     "web-tree-sitter": "^0.26.8",
-    "@mrclrchtr/supi-core": "1.8.0"
+    "@mrclrchtr/supi-code-runtime": "1.9.1",
+    "@mrclrchtr/supi-core": "1.9.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
@@ -44,18 +45,20 @@
   },
   "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-tree-sitter/assets/logo.png"
   },
   "bundledDependencies": [
+    "@mrclrchtr/supi-code-runtime",
     "@mrclrchtr/supi-core"
   ],
   "main": "src/api.ts",
   "exports": {
     "./api": "./src/api.ts",
     "./extension": "./src/extension.ts",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./provider/tree-sitter-provider": "./src/provider/tree-sitter-provider.ts"
   },
   "scripts": {
     "vendor:wasm": "node scripts/vendor-wasm.mjs",

package/node_modules/@mrclrchtr/supi-tree-sitter/src/provider/tree-sitter-provider.ts

@@ -0,0 +1,144 @@
+// Structural provider adapter — wraps TreeSitterService into the shared
+// StructuralProvider contract from supi-code-runtime.
+
+import type {
+  CalleesData,
+  CodeResult,
+  ExportData,
+  ImportData,
+  NodeAtData,
+  OutlineData,
+  StructuralProvider,
+} from "@mrclrchtr/supi-code-runtime/api";
+import type {
+  CalleesAtResult,
+  ExportRecord,
+  ImportRecord,
+  NodeAtResult,
+  OutlineItem,
+  TreeSitterResult,
+  TreeSitterService,
+} from "../types.ts";
+
+/**
+ * Create a StructuralProvider backed by a TreeSitterService.
+ * Maps tree-sitter's nested `range` shapes into the flat range
+ * fields used by the shared code-runtime types.
+ */
+export function createTreeSitterProvider(service: TreeSitterService): StructuralProvider {
+  return {
+    async calleesAt(file, line, character) {
+      const result = await service.calleesAt(file, line, character);
+      return mapTreeSitterResult(result, mapCalleesAtResult);
+    },
+
+    async exports(file) {
+      const result = await service.exports(file);
+      return mapTreeSitterResult(result, mapExportRecords);
+    },
+
+    async outline(file) {
+      const result = await service.outline(file);
+      return mapTreeSitterResult(result, mapOutlineItems);
+    },
+
+    async imports(file) {
+      const result = await service.imports(file);
+      return mapTreeSitterResult(result, mapImportRecords);
+    },
+
+    async nodeAt(file, line, character) {
+      const result = await service.nodeAt(file, line, character);
+      return mapTreeSitterResult(result, mapNodeAtResult);
+    },
+  };
+}
+
+// ── Generic result mapper ─────────────────────────────────────────────
+
+function mapTreeSitterResult<T, U>(
+  result: TreeSitterResult<T>,
+  mapData: (data: T) => U,
+): CodeResult<U> {
+  switch (result.kind) {
+    case "success":
+      return { kind: "success", data: mapData(result.data) };
+    case "unsupported-language":
+      return { kind: "unsupported-language", file: result.file, message: result.message };
+    case "file-access-error":
+      return { kind: "file-access-error", file: result.file, message: result.message };
+    case "validation-error":
+      return { kind: "validation-error", message: result.message };
+    case "runtime-error":
+      return { kind: "runtime-error", message: result.message };
+  }
+}
+
+// ── Data mappers (nested range → flat fields) ─────────────────────────
+
+type RangeLike = {
+  startLine: number;
+  startCharacter: number;
+  endLine: number;
+  endCharacter: number;
+};
+
+function takeRange(r: RangeLike) {
+  return {
+    startLine: r.startLine,
+    startCharacter: r.startCharacter,
+    endLine: r.endLine,
+    endCharacter: r.endCharacter,
+  };
+}
+
+function mapOutlineItems(items: OutlineItem[]): OutlineData[] {
+  return items.map((item) => ({
+    name: item.name,
+    kind: item.kind,
+    ...takeRange(item.range),
+    children: item.children ? mapOutlineItems(item.children) : undefined,
+  }));
+}
+
+function mapExportRecords(records: ExportRecord[]): ExportData[] {
+  return records.map((record) => ({
+    name: record.name,
+    kind: record.kind,
+    ...takeRange(record.range),
+    moduleSpecifier: record.moduleSpecifier,
+  }));
+}
+
+function mapImportRecords(records: ImportRecord[]): ImportData[] {
+  return records.map((record) => ({
+    moduleSpecifier: record.moduleSpecifier,
+    ...takeRange(record.range),
+  }));
+}
+
+function mapNodeAtResult(result: NodeAtResult): NodeAtData {
+  return {
+    type: result.type,
+    ...takeRange(result.range),
+    text: result.text,
+    ancestry: result.ancestry.map((a) => ({
+      type: a.type,
+      ...takeRange(a.range),
+    })),
+  };
+}
+
+function mapCalleesAtResult(result: CalleesAtResult): CalleesData {
+  return {
+    enclosingScope: {
+      name: result.enclosingScope.name,
+      startLine: result.enclosingScope.range.startLine,
+      endLine: result.enclosingScope.range.endLine,
+    },
+    callees: result.callees.map((c) => ({
+      name: c.name,
+      startLine: c.range.startLine,
+    })),
+  };
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Tree-sitter-to-runtime capability registration.
+ *
+ * Adapts a TreeSitterService into the runtime's StructuralProvider interface
+ * via the existing tree-sitter-provider adapter, and registers/unregisters it
+ * with the shared WorkspaceRuntime at session lifecycle boundaries.
+ */
+
+import type { WorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
+import { createTreeSitterProvider } from "../provider/tree-sitter-provider.ts";
+import type { TreeSitterService } from "../types.ts";
+
+/**
+ * Register tree-sitter structural capabilities for a workspace cwd.
+ *
+ * Wraps TreeSitterService into a StructuralProvider via the existing
+ * structural adapter and publishes it into the shared workspace runtime.
+ */
+export function registerTreeSitterCapabilities(
+  runtime: WorkspaceRuntime,
+  cwd: string,
+  service: TreeSitterService,
+): void {
+  const provider = createTreeSitterProvider(service);
+  runtime.registerStructural(cwd, provider);
+}
+
+/**
+ * Unregister tree-sitter structural capabilities for a workspace cwd.
+ *
+ * Clears only the structural capability slot — semantic (LSP) state
+ * is left intact so that a tree-sitter session restart does not wipe
+ * LSP capabilities that were registered earlier in the same lifecycle.
+ */
+export function unregisterTreeSitterCapabilities(runtime: WorkspaceRuntime, cwd: string): void {
+  runtime.clearStructural(cwd);
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tree-sitter.ts

@@ -1,7 +1,12 @@
 // Tree-sitter extension entry point — registers 6 focused tree_sitter_* tools.
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
 import { TreeSitterRuntime } from "./session/runtime.ts";
+import {
+  registerTreeSitterCapabilities,
+  unregisterTreeSitterCapabilities,
+} from "./session/runtime-registration.ts";
 import {
   clearSessionTreeSitterService,
   setSessionTreeSitterService,
@@ -10,28 +15,33 @@ import { createTreeSitterService } from "./session/session.ts";
 import { registerFocusedTreeSitterTools } from "./tool/register-tools.ts";
 
 export default function treeSitterExtension(pi: ExtensionAPI) {
-  let runtime: TreeSitterRuntime | undefined;
+  let treeSitterRuntime: TreeSitterRuntime | undefined;
   let activeCwd: string | null = null;
+  const workspaceRuntime = getDefaultWorkspaceRuntime();
 
-  registerFocusedTreeSitterTools(pi, () => runtime);
+  registerFocusedTreeSitterTools(pi, () => treeSitterRuntime);
 
   pi.on("session_start", (_event, ctx) => {
-    if (runtime && activeCwd) {
+    if (treeSitterRuntime && activeCwd) {
+      unregisterTreeSitterCapabilities(workspaceRuntime, activeCwd);
       clearSessionTreeSitterService(activeCwd);
-      runtime.dispose();
+      treeSitterRuntime.dispose();
     }
 
     activeCwd = ctx.cwd;
-    runtime = new TreeSitterRuntime(ctx.cwd);
-    setSessionTreeSitterService(ctx.cwd, createTreeSitterService(runtime));
+    treeSitterRuntime = new TreeSitterRuntime(ctx.cwd);
+    const service = createTreeSitterService(treeSitterRuntime);
+    setSessionTreeSitterService(ctx.cwd, service);
+    registerTreeSitterCapabilities(workspaceRuntime, ctx.cwd, service);
   });
 
   pi.on("session_shutdown", () => {
     if (activeCwd) {
+      unregisterTreeSitterCapabilities(workspaceRuntime, activeCwd);
       clearSessionTreeSitterService(activeCwd);
     }
-    runtime?.dispose();
-    runtime = undefined;
+    treeSitterRuntime?.dispose();
+    treeSitterRuntime = undefined;
     activeCwd = null;
   });
 }