@mrclrchtr/supi-code-intelligence 1.8.0 → 1.9.1

package/src/use-case/types.ts

@@ -1,8 +1,8 @@
 // Shared typed data interfaces between use-case and presentation layers.
 
-import type { ArchitectureModel } from "../architecture.ts";
-import type { StructuralSubstrate } from "../substrates/types.ts";
+import type { ArchitectureModel } from "../model.ts";
 import type { BriefDetails } from "../types.ts";
+import type { CodeProvider } from "../workspace/request-context.ts";
 
 // ── Overview use-case ────────────────────────────────────────────────
 
@@ -33,7 +33,7 @@ export type BriefInput =
 
 export interface BriefDeps {
   model: ArchitectureModel | null;
-  structural: StructuralSubstrate;
+  provider: CodeProvider | null;
   cwd: string;
 }
 

package/src/workspace/request-context.ts

@@ -0,0 +1,139 @@
+/**
+ * Central access point for code-intelligence to read shared workspace
+ * runtime capability state from @mrclrchtr/supi-code-runtime.
+ *
+ * Replaces the old local provider registry/wiring layer. The substrate
+ * packages (supi-lsp, supi-tree-sitter) publish their capabilities into
+ * the shared runtime via getDefaultWorkspaceRuntime(). This module reads
+ * that same singleton to provide per-cwd capability state to the
+ * code_* tool use-cases.
+ */
+
+import {
+  type CodeLocation,
+  type CodePosition,
+  type CodeResult,
+  type CodeSymbol,
+  getDefaultWorkspaceRuntime,
+  type SemanticProvider,
+  type StructuralProvider,
+} from "@mrclrchtr/supi-code-runtime/api";
+import type { CalleesData, ExportData, ImportData, NodeAtData, OutlineData } from "../types.ts";
+
+/**
+ * Unified code analysis provider combining semantic (LSP-backed) and
+ * structural (tree-sitter-backed) operations.
+ *
+ * This is the same shape as the old CodeProvider interface, now backed
+ * by the shared workspace runtime instead of a local registry.
+ */
+export interface CodeProvider extends SemanticProvider, StructuralProvider {}
+
+/** Availability state for the code provider in a workspace. */
+export type CodeProviderState =
+  | { kind: "ready"; provider: CodeProvider }
+  | { kind: "unavailable"; reason: string };
+
+/**
+ * Get the code provider state for a workspace cwd from the shared runtime.
+ *
+ * Returns `ready` if at least one capability (semantic or structural) is
+ * available. The provider object delegates to whichever capability is
+ * present — null / unsupported-language for the missing ones.
+ *
+ * Returns `unavailable` if no capabilities are registered.
+ */
+export function getCodeProvider(cwd: string): CodeProviderState {
+  const runtime = getDefaultWorkspaceRuntime();
+  const ws = runtime.getWorkspace(cwd);
+
+  const hasSemantic = ws.semantic.state.kind === "ready" && ws.semantic.provider !== null;
+  const hasStructural = ws.structural.state.kind === "ready" && ws.structural.provider !== null;
+
+  if (!hasSemantic && !hasStructural) {
+    return {
+      kind: "unavailable",
+      reason: "No code provider initialized for this workspace",
+    };
+  }
+
+  return {
+    kind: "ready",
+    provider: createCompositeProvider(
+      (hasSemantic ? ws.semantic.provider : null) as SemanticProvider | null,
+      (hasStructural ? ws.structural.provider : null) as StructuralProvider | null,
+    ),
+  };
+}
+
+/**
+ * Create a single CodeProvider that delegates semantic methods to the
+ * semantic (LSP) provider and structural methods to the structural
+ * (tree-sitter) provider.
+ */
+function createCompositeProvider(
+  semantic: SemanticProvider | null,
+  structural: StructuralProvider | null,
+): CodeProvider {
+  return {
+    // Semantic methods
+    async references(filePath: string, position: CodePosition): Promise<CodeLocation[] | null> {
+      return semantic?.references(filePath, position) ?? null;
+    },
+    async implementation(filePath: string, position: CodePosition): Promise<CodeLocation[] | null> {
+      return semantic?.implementation(filePath, position) ?? null;
+    },
+    async documentSymbols(filePath: string): Promise<CodeSymbol[] | null> {
+      return semantic?.documentSymbols(filePath) ?? null;
+    },
+    async workspaceSymbols(query: string): Promise<CodeSymbol[] | null> {
+      return semantic?.workspaceSymbols(query) ?? null;
+    },
+
+    // Structural methods
+    async calleesAt(
+      file: string,
+      line: number,
+      character: number,
+    ): Promise<CodeResult<CalleesData>> {
+      return (
+        structural?.calleesAt(file, line, character) ?? {
+          kind: "unavailable",
+          message: "Structural analysis not available. Use tree_sitter_callees.",
+        }
+      );
+    },
+    async exports(file: string): Promise<CodeResult<ExportData[]>> {
+      return (
+        structural?.exports(file) ?? {
+          kind: "unavailable",
+          message: "Structural analysis not available. Use tree_sitter_exports.",
+        }
+      );
+    },
+    async outline(file: string): Promise<CodeResult<OutlineData[]>> {
+      return (
+        structural?.outline(file) ?? {
+          kind: "unavailable",
+          message: "Structural analysis not available. Use tree_sitter_outline.",
+        }
+      );
+    },
+    async imports(file: string): Promise<CodeResult<ImportData[]>> {
+      return (
+        structural?.imports(file) ?? {
+          kind: "unavailable",
+          message: "Structural analysis not available. Use tree_sitter_imports.",
+        }
+      );
+    },
+    async nodeAt(file: string, line: number, character: number): Promise<CodeResult<NodeAtData>> {
+      return (
+        structural?.nodeAt(file, line, character) ?? {
+          kind: "unavailable",
+          message: "Structural analysis not available. Use tree_sitter_node_at.",
+        }
+      );
+    },
+  };
+}

package/node_modules/@mrclrchtr/supi-core/src/extension.ts

@@ -1 +0,0 @@
-export { registerSettingsCommand as default } from "./settings/settings-command.ts";

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

@@ -1 +0,0 @@
-export { registerSettingsCommand as default } from "./settings/settings-command.ts";

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

@@ -1 +0,0 @@
-export { registerSettingsCommand as default } from "./settings/settings-command.ts";

package/src/substrates/lsp-adapter.ts

@@ -1,197 +0,0 @@
-// LSP semantic substrate adapter — wraps SessionLspService into SemanticSubstrate.
-
-import type { CodeLocation, CodePosition } from "@mrclrchtr/supi-core/types";
-import {
-  getSessionLspService,
-  type SessionLspService,
-  waitForSessionLspService,
-} from "@mrclrchtr/supi-lsp/api";
-import type { CodeSymbol, SemanticSubstrate } from "./types.ts";
-
-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";
-}
-
-/**
- * Create a SemanticSubstrate backed by the session-scoped LSP service.
- *
- * The adapter handles service acquisition, readiness waiting, and
- * normalizes LSP types into CodeLocation / CodeSymbol.
- */
-export function createSemanticSubstrate(cwd: string): SemanticSubstrate {
-  return {
-    references: async (filePath, position) =>
-      withService(cwd, (lsp) =>
-        lsp.references(filePath, position).then((locs) =>
-          locs
-            ? locs.map((l: { uri: string; range: { start: CodePosition; end: CodePosition } }) => ({
-                uri: l.uri,
-                range: l.range,
-              }))
-            : null,
-        ),
-      ),
-
-    implementation: async (filePath, position) =>
-      withService(cwd, async (lsp) => {
-        const result = await lsp.implementation(filePath, position);
-        if (!result) return null;
-        const list: Array<Record<string, unknown>> = Array.isArray(result) ? result : [result];
-        return list.map(toCodeLocation).filter(Boolean) as CodeLocation[];
-      }),
-
-    documentSymbols: async (filePath) =>
-      withService(cwd, async (lsp) => {
-        const symbols = await lsp.documentSymbols(filePath);
-        if (!symbols) return null;
-        return flattenDocumentSymbols(symbols, filePath);
-      }),
-
-    workspaceSymbols: async (query) =>
-      withService(cwd, async (lsp) => {
-        const results = await lsp.workspaceSymbol(query);
-        if (!results) return null;
-        return results.map(toCodeSymbol);
-      }),
-  };
-}
-
-// ── Acquisition ─────────────────────────────────────────────────────
-
-async function acquire(cwd: string): Promise<SessionLspService | null> {
-  const state = getSessionLspService(cwd);
-  if (state.kind === "ready") return state.service;
-  if (state.kind === "pending") {
-    const waited = await waitForSessionLspService(cwd, 250);
-    return waited.kind === "ready" ? waited.service : null;
-  }
-  return null;
-}
-
-async function withService<T>(
-  cwd: string,
-  fn: (lsp: SessionLspService) => Promise<T | null>,
-): Promise<T | null> {
-  const lsp = await acquire(cwd);
-  if (!lsp) return null;
-  return fn(lsp);
-}
-
-// ── Type mapping ────────────────────────────────────────────────────
-
-function toCodeLocation(loc: Record<string, unknown>): CodeLocation | null {
-  const uri = loc.uri ?? loc.targetUri;
-  // LocationLink has targetSelectionRange (precise symbol span) and targetRange (full range).
-  // Location has range only. Prefer the most precise: targetSelectionRange > targetRange > range.
-  const range = loc.targetSelectionRange ?? loc.targetRange ?? loc.range;
-  if (typeof uri !== "string") return null;
-  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 },
-    },
-  };
-}
-
-function flattenDocumentSymbols(
-  symbols: Array<{
-    name: string;
-    kind: number;
-    selectionRange?: { start: { line: number; character: number } };
-    children?: Array<unknown>;
-  }>,
-  filePath: string,
-  container: string | null = null,
-): CodeSymbol[] {
-  const result: CodeSymbol[] = [];
-
-  for (const sym of symbols) {
-    const start =
-      sym.selectionRange?.start ??
-      (sym as { location?: { range?: { start: { line: number; character: number } } } }).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(sym.children) && sym.children.length > 0) {
-      result.push(
-        ...flattenDocumentSymbols(
-          sym.children as Array<{
-            name: string;
-            kind: number;
-            selectionRange?: { start: { line: number; character: number } };
-            children?: Array<unknown>;
-          }>,
-          filePath,
-          sym.name,
-        ),
-      );
-    }
-  }
-
-  return result;
-}
-
-function toCodeSymbol(sym: {
-  name: string;
-  kind: number;
-  containerName?: string | null;
-  location?: {
-    uri: string;
-    range?: { start: { line: number; character: number } };
-  } | null;
-}): 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/src/substrates/tree-sitter-adapter.ts

@@ -1,173 +0,0 @@
-// Tree-sitter structural substrate adapter — wraps TreeSitterService into StructuralSubstrate.
-
-import {
-  createTreeSitterSession,
-  getSessionTreeSitterService,
-} from "@mrclrchtr/supi-tree-sitter/api";
-import type {
-  CalleesData,
-  ExportData,
-  ImportData,
-  NodeAtData,
-  OutlineData,
-  StructuralResult,
-  StructuralSubstrate,
-} from "./types.ts";
-
-/**
- * Create a StructuralSubstrate backed by the tree-sitter service.
- *
- * Reuses the shared session-scoped service when available, falling back to
- * a short-lived owned session (disposed after the operation).
- */
-export function createStructuralSubstrate(cwd: string): StructuralSubstrate {
-  return {
-    calleesAt: (file, line, character) =>
-      withSession(cwd, (s) => s.calleesAt(file, line, character)).then(mapResult(mapCallees)),
-
-    exports: (file) => withSession(cwd, (s) => s.exports(file)).then(mapResult(mapExports)),
-
-    outline: (file) => withSession(cwd, (s) => s.outline(file)).then(mapResult(mapOutline)),
-
-    imports: (file) => withSession(cwd, (s) => s.imports(file)).then(mapResult(mapImports)),
-
-    nodeAt: (file, line, character) =>
-      withSession(cwd, (s) => s.nodeAt(file, line, character)).then(mapResult(mapNodeAt)),
-  };
-}
-
-// ── Session acquisition ─────────────────────────────────────────────
-
-async function withSession<T>(
-  cwd: string,
-  fn: (session: {
-    calleesAt: (f: string, l: number, c: number) => Promise<unknown>;
-    exports: (f: string) => Promise<unknown>;
-    outline: (f: string) => Promise<unknown>;
-    imports: (f: string) => Promise<unknown>;
-    nodeAt: (f: string, l: number, c: number) => Promise<unknown>;
-  }) => Promise<T>,
-): Promise<T> {
-  const current = getSessionTreeSitterService(cwd);
-  if (current.kind === "ready") {
-    return fn(current.service);
-  }
-  const session = createTreeSitterSession(cwd);
-  try {
-    return await fn(session);
-  } finally {
-    session.dispose();
-  }
-}
-
-// ── Generic result mapper ───────────────────────────────────────────
-
-function mapResult<T>(mapData: (data: unknown) => T): (raw: unknown) => StructuralResult<T> {
-  return (raw) => {
-    const r = raw as { kind: string; data?: unknown };
-    if (r.kind === "success") {
-      return { kind: "success", data: mapData(r.data) };
-    }
-    return raw as StructuralResult<T>;
-  };
-}
-
-// ── Mapping helpers (unpack nested `range` into flat fields) ────────
-
-type RangeLike = {
-  startLine: number;
-  startCharacter: number;
-  endLine: number;
-  endCharacter: number;
-};
-
-function takeRange(r: RangeLike): {
-  startLine: number;
-  startCharacter: number;
-  endLine: number;
-  endCharacter: number;
-} {
-  return {
-    startLine: r.startLine,
-    startCharacter: r.startCharacter,
-    endLine: r.endLine,
-    endCharacter: r.endCharacter,
-  };
-}
-
-function mapExports(data: unknown): ExportData[] {
-  const items = data as Array<{
-    name: string;
-    kind: string;
-    range: RangeLike;
-    moduleSpecifier?: string;
-  }>;
-  return items.map((item) => ({
-    name: item.name,
-    kind: item.kind,
-    ...takeRange(item.range),
-    moduleSpecifier: item.moduleSpecifier,
-  }));
-}
-
-function mapOutline(data: unknown): OutlineData[] {
-  const items = data as Array<{
-    name: string;
-    kind: string;
-    range: RangeLike;
-    children?: unknown[];
-  }>;
-  return items.map((item) => ({
-    name: item.name,
-    kind: item.kind,
-    ...takeRange(item.range),
-    children: item.children ? mapOutline(item.children) : undefined,
-  }));
-}
-
-function mapImports(data: unknown): ImportData[] {
-  const items = data as Array<{
-    moduleSpecifier: string;
-    range: RangeLike;
-  }>;
-  return items.map((item) => ({
-    moduleSpecifier: item.moduleSpecifier,
-    ...takeRange(item.range),
-  }));
-}
-
-function mapNodeAt(data: unknown): NodeAtData {
-  const d = data as {
-    type: string;
-    range: RangeLike;
-    text: string;
-    ancestry: Array<{ type: string; range: RangeLike }>;
-  };
-  return {
-    type: d.type,
-    ...takeRange(d.range),
-    text: d.text,
-    ancestry: d.ancestry.map((a) => ({
-      type: a.type,
-      ...takeRange(a.range),
-    })),
-  };
-}
-
-function mapCallees(data: unknown): CalleesData {
-  const d = data as {
-    enclosingScope: { name: string; range: RangeLike };
-    callees: Array<{ name: string; range: RangeLike }>;
-  };
-  return {
-    enclosingScope: {
-      name: d.enclosingScope.name,
-      startLine: d.enclosingScope.range.startLine,
-      endLine: d.enclosingScope.range.endLine,
-    },
-    callees: d.callees.map((c) => ({
-      name: c.name,
-      startLine: c.range.startLine,
-    })),
-  };
-}