@mrclrchtr/supi-code-intelligence 1.8.0 → 1.9.0

package/src/use-case/generate-affected.ts

@@ -3,7 +3,7 @@
 // returns fully rendered content + details metadata.
 
 import * as path from "node:path";
-import { buildArchitectureModel, findModuleForPath, getDependents } from "../architecture.ts";
+import { buildArchitectureModel, findModuleForPath, getDependents } from "../model.ts";
 import {
   renderAffectedFileLevel,
   renderAffectedSingle,
@@ -11,9 +11,9 @@ import {
 import { summarizePrioritySignalsForFiles } from "../prioritization-signals.ts";
 import { resolveTarget } from "../resolve-target.ts";
 import { isResolvedTargetGroup } from "../semantic-action-helpers.ts";
-import type { SemanticSubstrate } from "../substrates/types.ts";
 import type { ResolvedTarget, ResolvedTargetGroup } from "../target-resolution.ts";
 import type { AffectedDetails, CodeIntelResult, ConfidenceMode } from "../types.ts";
+import type { CodeProvider } from "../workspace/request-context.ts";
 import {
   aggregatePerTarget,
   collectReferences,
@@ -31,6 +31,7 @@ export interface AffectedInput {
 
 export interface AffectedDeps {
   cwd: string;
+  provider: CodeProvider | null;
 }
 
 /** Execute the affected use-case — target resolution, reference collection, analysis, and rendering. */
@@ -38,9 +39,26 @@ export async function executeAffected(
   input: AffectedInput,
   deps: AffectedDeps,
 ): Promise<CodeIntelResult> {
-  const semantic: SemanticSubstrate = await import("../substrates/lsp-adapter.ts").then((m) =>
-    m.createSemanticSubstrate(deps.cwd),
-  );
+  const semantic = deps.provider;
+  if (!semantic) {
+    return {
+      content:
+        "**Error:** Affected analysis requires an active code provider (LSP). Enable LSP and retry.",
+      details: {
+        type: "affected" as const,
+        data: {
+          confidence: "unavailable",
+          directCount: 0,
+          downstreamCount: 0,
+          riskLevel: "low",
+          checkNext: [],
+          likelyTests: [],
+          omittedCount: 0,
+          nextQueries: ["Provide `file`, `line`, `character` or a `symbol` to resolve the target"],
+        },
+      },
+    };
+  }
   const target = await resolveTarget(input, deps.cwd, semantic);
 
   if (typeof target === "string") {
@@ -90,7 +108,7 @@ async function executeSingleAffected(
   symbolName: string,
   input: AffectedInput,
   cwd: string,
-  semantic: SemanticSubstrate,
+  semantic: CodeProvider,
 ): Promise<CodeIntelResult> {
   const refs = await collectReferences(target, cwd, semantic);
   const model = await buildArchitectureModel(cwd);
@@ -132,7 +150,7 @@ async function executeFileLevelAffected(
   targetGroup: ResolvedTargetGroup,
   input: AffectedInput,
   cwd: string,
-  semantic: SemanticSubstrate,
+  semantic: CodeProvider,
 ): Promise<CodeIntelResult> {
   const perTarget = await Promise.all(
     targetGroup.targets.map(async (t) => ({

package/src/use-case/generate-brief.ts

@@ -3,14 +3,14 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ArchitectureModel } from "../architecture.ts";
-import { findModuleForPath } from "../architecture.ts";
 import { generateFocusedBrief, generateProjectBrief } from "../brief.ts";
+import type { ArchitectureModel } from "../model.ts";
+import { findModuleForPath } from "../model.ts";
 import { renderAnchoredBrief, renderSymbolBrief } from "../presentation/markdown/brief.ts";
 import { normalizePath } from "../search-helpers.ts";
-import type { SemanticSubstrate, StructuralSubstrate } from "../substrates/types.ts";
 import type { TargetResolutionResult } from "../target-resolution.ts";
 import { resolveSymbolTarget } from "../target-resolution.ts";
+import type { CodeProvider } from "../workspace/request-context.ts";
 import type { BriefDeps, BriefInput, BriefUseCaseResult } from "./types.ts";
 
 // ── TreeSitterContext is an intermediate data shape from the use-case ──
@@ -100,7 +100,7 @@ async function executeAnchoredBrief(
   }
 
   const relPath = path.relative(deps.cwd, resolvedFile);
-  const context = await gatherTreeSitterContext(deps.structural, relPath, line, character);
+  const context = await gatherTreeSitterContext(deps.provider, relPath, line, character);
 
   const details = {
     confidence: "structural" as const,
@@ -150,9 +150,24 @@ async function executeSymbolBrief(
     };
   }
 
-  const semanticModule = await import("../substrates/lsp-adapter.ts");
-  const semantic: SemanticSubstrate = semanticModule.createSemanticSubstrate(deps.cwd);
-  const resolved = await resolveSymbolTarget(symbol, deps.cwd, semantic, {
+  const provider = deps.provider;
+  if (!provider) {
+    return {
+      content: `**Error:** Symbol discovery requires an active code provider. Use \`file\` + coordinates, or enable LSP and retry.`,
+      details: {
+        confidence: "unavailable",
+        focusTarget: symbol,
+        startHere: [],
+        publicSurfaces: [],
+        dependencySummary: null,
+        omittedCount: 0,
+        nextQueries: [
+          "Use `file` + coordinates for a precise symbol brief, or enable LSP and retry",
+        ],
+      },
+    };
+  }
+  const resolved = await resolveSymbolTarget(symbol, deps.cwd, provider, {
     path: scopePath,
   });
 
@@ -196,7 +211,7 @@ async function executeSymbolBrief(
 
   const mod = findModuleForPath(deps.model, target.file);
   const context = await gatherTreeSitterContext(
-    deps.structural,
+    deps.provider,
     relPath,
     target.displayLine,
     target.displayCharacter,
@@ -233,7 +248,7 @@ async function executeSymbolBrief(
 // ── Helpers ───────────────────────────────────────────────────────────
 
 async function gatherTreeSitterContext(
-  structural: StructuralSubstrate,
+  provider: CodeProvider | null,
   relPath: string,
   line: number,
   character: number,
@@ -243,8 +258,10 @@ async function gatherTreeSitterContext(
   let imports: TreeSitterContext["imports"] = [];
   let exports: TreeSitterContext["exports"] = [];
 
+  if (!provider) return { nodeInfo, outline, imports, exports };
+
   try {
-    const nodeResult = await structural.nodeAt(relPath, line, character);
+    const nodeResult = await provider.nodeAt(relPath, line, character);
     if (nodeResult.kind === "success") {
       nodeInfo = {
         type: nodeResult.data.type,
@@ -254,7 +271,7 @@ async function gatherTreeSitterContext(
       };
     }
 
-    const outlineResult = await structural.outline(relPath);
+    const outlineResult = await provider.outline(relPath);
     if (outlineResult.kind === "success") {
       outline = outlineResult.data.map((item) => ({
         name: item.name,
@@ -264,12 +281,12 @@ async function gatherTreeSitterContext(
       }));
     }
 
-    const importsResult = await structural.imports(relPath);
+    const importsResult = await provider.imports(relPath);
     if (importsResult.kind === "success") {
       imports = importsResult.data;
     }
 
-    const exportsResult = await structural.exports(relPath);
+    const exportsResult = await provider.exports(relPath);
     if (exportsResult.kind === "success") {
       exports = exportsResult.data.map((item) => ({
         name: item.name,
@@ -277,7 +294,7 @@ async function gatherTreeSitterContext(
       }));
     }
   } catch {
-    // Tree-sitter not available
+    // Provider not available
   }
 
   return { nodeInfo, outline, imports, exports };

package/src/use-case/generate-pattern.ts

@@ -13,8 +13,8 @@ import {
 import type { CodeQueryParams } from "../query-params.ts";
 import type { RgMatch } from "../search-helpers.ts";
 import { normalizePath, runRipgrep, runRipgrepDetailed } from "../search-helpers.ts";
-import type { StructuralSubstrate } from "../substrates/types.ts";
 import type { CodeIntelResult, SearchDetails } from "../types.ts";
+import type { CodeProvider } from "../workspace/request-context.ts";
 
 export interface PatternInput {
   pattern: string;
@@ -28,7 +28,7 @@ export interface PatternInput {
 
 export interface PatternDeps {
   cwd: string;
-  structural?: StructuralSubstrate;
+  provider: CodeProvider | null;
 }
 
 /** Execute the pattern search use-case. */
@@ -56,7 +56,7 @@ export async function executePattern(
       deps.cwd,
       relScope,
       maxResults,
-      deps.structural,
+      deps.provider,
     );
   }
 
@@ -117,9 +117,9 @@ async function executeStructuredSearch(
   cwd: string,
   relScope: string,
   _maxResults: number,
-  structural?: StructuralSubstrate,
+  provider: CodeProvider | null,
 ): Promise<CodeIntelResult> {
-  if (!structural) {
+  if (!provider) {
     return {
       content: `**Error:** Structured ${kind} search requires tree-sitter, which is not available.`,
       details: undefined,
@@ -131,7 +131,7 @@ async function executeStructuredSearch(
     scopePath,
     cwd,
     relScope,
-    structural,
+    provider,
   );
 
   if (typeof structured === "string") {
@@ -150,7 +150,7 @@ async function executeStructuredSearch(
       input.pattern,
       kind as "definition" | "export" | "import",
       relScope,
-      structural,
+      provider,
       structured ?? undefined,
     );
     return {
@@ -253,7 +253,7 @@ function getRegexMatches(options: {
 export async function executePatternAction(
   params: CodeQueryParams,
   cwd: string,
-  structural?: StructuralSubstrate,
+  provider?: CodeProvider | null,
 ): Promise<CodeIntelResult> {
   return executePattern(
     {
@@ -265,6 +265,6 @@ export async function executePatternAction(
       contextLines: params.contextLines,
       summary: params.summary,
     },
-    { cwd, structural },
+    { cwd, provider: provider ?? null },
   );
 }

package/src/use-case/generate-relations.ts

@@ -1,5 +1,5 @@
 // Relations orchestration use-case — dispatches by kind (callers/callees/implementations),
-// coordinates target resolution and substrate access, and returns fully rendered results.
+// coordinates target resolution and provider access, and returns fully rendered results.
 import * as path from "node:path";
 import {
   renderCalleesResult,
@@ -9,9 +9,9 @@ import {
 import { resolveTarget } from "../resolve-target.ts";
 import { isInProjectPath, uriToFile } from "../search-helpers.ts";
 import { isResolvedTargetGroup } from "../semantic-action-helpers.ts";
-import type { SemanticSubstrate, StructuralSubstrate } from "../substrates/types.ts";
 import type { ResolvedTarget, ResolvedTargetGroup } from "../target-resolution.ts";
 import type { CodeIntelResult, SearchDetails } from "../types.ts";
+import type { CodeProvider } from "../workspace/request-context.ts";
 import { aggregatePerTarget, collectReferences } from "./support/semantic-references.ts";
 export interface RelationsInput {
   kind: "callers" | "callees" | "implementations";
@@ -26,6 +26,7 @@ export interface RelationsInput {
 type RelationsResolutionParams = Omit<RelationsInput, "kind">;
 export interface RelationsDeps {
   cwd: string;
+  provider: CodeProvider | null;
 }
 export async function executeRelations(
   input: RelationsInput,
@@ -45,9 +46,23 @@ async function executeCallers(
   input: RelationsResolutionParams,
   deps: RelationsDeps,
 ): Promise<CodeIntelResult> {
-  const semantic: SemanticSubstrate = await import("../substrates/lsp-adapter.ts").then((m) =>
-    m.createSemanticSubstrate(deps.cwd),
-  );
+  const semantic = deps.provider;
+  if (!semantic) {
+    return {
+      content:
+        "**Error:** Caller discovery requires an active code provider (LSP). Enable LSP and retry.",
+      details: {
+        type: "search" as const,
+        data: {
+          confidence: "unavailable",
+          scope: null,
+          candidateCount: 0,
+          omittedCount: 0,
+          nextQueries: ["Provide `file`, `line`, `character` or a `symbol` to resolve the target"],
+        },
+      },
+    };
+  }
   const target = await resolveTarget(input, deps.cwd, semantic);
   if (typeof target === "string") {
     return {
@@ -73,7 +88,7 @@ async function executeSingleCallers(
   target: ResolvedTarget,
   input: RelationsResolutionParams,
   cwd: string,
-  semantic: SemanticSubstrate,
+  semantic: CodeProvider,
 ): Promise<CodeIntelResult> {
   const result = await collectReferences(target, cwd, semantic);
   if (result.refs.length > 0) {
@@ -125,7 +140,7 @@ async function executeFileLevelCallers(
   targetGroup: ResolvedTargetGroup,
   input: RelationsResolutionParams,
   cwd: string,
-  semantic: SemanticSubstrate,
+  semantic: CodeProvider,
 ): Promise<CodeIntelResult> {
   const aggregated = await aggregatePerTarget(targetGroup.targets, (target) =>
     collectReferences(target, cwd, semantic),
@@ -169,15 +184,32 @@ async function executeFileLevelCallers(
       "Use `file` + coordinates to drill into one symbol precisely",
     ],
   };
-  return { content: lines.join("\n"), details: { type: "search" as const, data: details } };
+  return {
+    content: lines.join("\n"),
+    details: { type: "search" as const, data: details },
+  };
 }
 async function executeImplementations(
   input: RelationsResolutionParams,
   deps: RelationsDeps,
 ): Promise<CodeIntelResult> {
-  const semantic: SemanticSubstrate = await import("../substrates/lsp-adapter.ts").then((m) =>
-    m.createSemanticSubstrate(deps.cwd),
-  );
+  const semantic = deps.provider;
+  if (!semantic) {
+    return {
+      content:
+        "**Error:** Implementation discovery requires an active code provider (LSP). Enable LSP and retry.",
+      details: {
+        type: "search" as const,
+        data: {
+          confidence: "unavailable",
+          scope: null,
+          candidateCount: 0,
+          omittedCount: 0,
+          nextQueries: ["Provide `file`, `line`, `character` or a `symbol` to resolve the target"],
+        },
+      },
+    };
+  }
   const target = await resolveTarget(input, deps.cwd, semantic);
   if (typeof target === "string") {
     return {
@@ -225,7 +257,10 @@ async function executeImplementations(
           "`code_brief` on containing modules for deeper context",
         ],
       };
-      return { content, details: { type: "search" as const, data: searchDetails } };
+      return {
+        content,
+        details: { type: "search" as const, data: searchDetails },
+      };
     }
     return {
       content: target.name
@@ -287,13 +322,24 @@ async function executeCallees(
   input: RelationsResolutionParams,
   deps: RelationsDeps,
 ): Promise<CodeIntelResult> {
-  const semantic: SemanticSubstrate = await import("../substrates/lsp-adapter.ts").then((m) =>
-    m.createSemanticSubstrate(deps.cwd),
-  );
-  const structural: StructuralSubstrate = await import("../substrates/tree-sitter-adapter.ts").then(
-    (m) => m.createStructuralSubstrate(deps.cwd),
-  );
-  const target = await resolveTarget(input, deps.cwd, semantic);
+  const provider = deps.provider;
+  if (!provider) {
+    return {
+      content:
+        "**Error:** Callee discovery requires an active code provider. Enable LSP and tree-sitter and retry.",
+      details: {
+        type: "search" as const,
+        data: {
+          confidence: "unavailable",
+          scope: null,
+          candidateCount: 0,
+          omittedCount: 0,
+          nextQueries: ["Provide `file`, `line`, `character` or a `symbol` to resolve the target"],
+        },
+      },
+    };
+  }
+  const target = await resolveTarget(input, deps.cwd, provider);
   if (typeof target === "string") {
     return {
       content: target,
@@ -326,7 +372,7 @@ async function executeCallees(
   }
   const relPath = path.relative(deps.cwd, target.file);
   try {
-    const result = await structural.calleesAt(relPath, target.displayLine, target.displayCharacter);
+    const result = await provider.calleesAt(relPath, target.displayLine, target.displayCharacter);
     if (result.kind !== "success") {
       return {
         content: `No callee data available for ${relPath}:${target.displayLine}:${target.displayCharacter}.\n\nUse \`tree_sitter_callees\` with \`file\`, \`line\`, and \`character\` for structural drill-down.`,

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";