@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/src/ui/markdown/overview-data.ts

@@ -1,36 +1,158 @@
-// Typed overview data builder from ArchitectureModel.
+// Typed overview data builder from directly observed package-manifest facts.
 
-import type { ArchitectureModel } from "../../analysis/architecture/model.ts";
-import { formatGitContext, gatherGitContext } from "../../analysis/signals/git.ts";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { detectGrammar } from "@mrclrchtr/supi-tree-sitter/api";
+import type {
+  ArchitectureModel,
+  ManifestField,
+  ModuleInfo,
+} from "../../analysis/architecture/model.ts";
 import type { OverviewData, OverviewModule } from "./types.ts";
 
+/** Maximum number of modules shown in the overview. */
+const MAX_MODULES = 8;
+/** Maximum characters per module description before truncation. */
+const MAX_DESCRIPTION_LENGTH = 60;
+
+/** Grammar ID to short language tag for the overview. */
+const GRAMMAR_LANGUAGE_TAGS: Record<string, string> = {
+  javascript: "js",
+  typescript: "ts",
+  tsx: "tsx",
+  python: "py",
+  rust: "rs",
+  go: "go",
+  c: "c",
+  cpp: "cpp",
+  java: "java",
+  kotlin: "kt",
+  ruby: "rb",
+  bash: "sh",
+  html: "html",
+  r: "r",
+  sql: "sql",
+};
+
 /**
- * Build structured overview data from an architecture model.
- * No markdown rendering — callers pass the result to a presentation renderer.
+ * Build structured overview data from the same factual package collector used
+ * by on-demand Orientation. No markdown rendering happens here.
  */
 export function buildOverviewData(model: ArchitectureModel): OverviewData | null {
   if (model.modules.length === 0) return null;
 
-  const dependedOn = new Set(model.edges.map((e) => e.to));
-
-  const modules: OverviewModule[] = model.modules.slice(0, 8).map((mod) => ({
-    name: mod.name,
-    shortName: mod.name.replace(/^@[^/]+\//, ""),
-    description: mod.description,
-    isLeaf: !dependedOn.has(mod.name),
-    internalDeps: mod.internalDeps,
-  }));
-
-  const omittedModuleCount = Math.max(0, model.modules.length - 8);
-
-  const gitCtx = gatherGitContext(model.root);
-  const gitContextOverview = gitCtx ? formatGitContext(gitCtx) : null;
+  const sorted = [...model.modules].sort((left, right) =>
+    left.relativePath.localeCompare(right.relativePath),
+  );
+  const modules = sorted.slice(0, MAX_MODULES).map((module) => overviewModule(module, model));
+  const detectedLanguages = detectModuleLanguages(sorted.slice(0, MAX_MODULES));
 
   return {
     projectName: model.name,
     projectDescription: model.description,
     modules,
-    omittedModuleCount,
-    gitContextOverview,
+    omittedModuleCount: Math.max(0, model.modules.length - MAX_MODULES),
+    detectedLanguages: detectedLanguages.length > 0 ? detectedLanguages : null,
   };
 }
+
+function overviewModule(module: ModuleInfo, model: ArchitectureModel): OverviewModule {
+  const name = module.name ?? module.relativePath;
+  return {
+    name,
+    shortName: module.name?.replace(/^@[^/]+\//, "") ?? module.relativePath,
+    description: truncateDescription(module.description),
+    declaredDependencies: model.edges
+      .filter((edge) => edge.from === module.name)
+      .map((edge) => edge.to),
+    declaredEntrypoints: declaredEntrypoints(module.fields),
+  };
+}
+
+/** Preserve field labels rather than selecting one inferred package entrypoint. */
+function declaredEntrypoints(fields: readonly ManifestField[]): string[] {
+  return fields.flatMap(declaredEntrypointsForField);
+}
+
+function declaredEntrypointsForField(field: ManifestField): string[] {
+  if (field.field === "pi.extensions") {
+    return stringValues(field.value).map((value) => `pi.extensions: ${value}`);
+  }
+  if (field.field === "main" || field.field === "module") {
+    return typeof field.value === "string" ? [`${field.field}: ${field.value}`] : [];
+  }
+  if (field.field !== "exports") return [];
+  if (typeof field.value === "string") return [`exports: ${field.value}`];
+  return isRecord(field.value) && typeof field.value["."] === "string"
+    ? [`exports["."]: ${field.value["."]}`]
+    : [];
+}
+
+function stringValues(value: unknown): string[] {
+  if (typeof value === "string") return [value];
+  return Array.isArray(value)
+    ? value.filter((entry): entry is string => typeof entry === "string")
+    : [];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function truncateDescription(description: string | null): string | null {
+  if (!description) return null;
+  if (description.length <= MAX_DESCRIPTION_LENGTH) return description;
+  return `${description.slice(0, MAX_DESCRIPTION_LENGTH - 1)}…`;
+}
+
+/**
+ * Detect languages present in the first two levels of each module directory.
+ *
+ * Uses Tree-sitter's extension-to-grammar mapping for conservative,
+ * documented detection. Returns short language tags sorted alphabetically.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: language detection with file-system scanning naturally has many branches
+function detectModuleLanguages(modules: readonly { root: string }[]): string[] {
+  const detected = new Set<string>();
+
+  for (const mod of modules) {
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(mod.root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    // Scan top-level files first.
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      scanFileForLanguage(entry.name, detected);
+    }
+
+    // Scan one level deeper for nested source directories (e.g. src/).
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules")
+        continue;
+      try {
+        const subEntries = fs.readdirSync(path.join(mod.root, entry.name), {
+          withFileTypes: true,
+        });
+        for (const subEntry of subEntries) {
+          if (!subEntry.isFile()) continue;
+          scanFileForLanguage(subEntry.name, detected);
+        }
+      } catch {
+        // Skip unreadable subdirectories.
+      }
+    }
+  }
+
+  return [...detected].sort();
+}
+
+/** Use the structural provider's published grammar mapping for overview language tags. */
+function scanFileForLanguage(fileName: string, detected: Set<string>): void {
+  const grammar = detectGrammar(fileName);
+  const tag = grammar ? GRAMMAR_LANGUAGE_TAGS[grammar] : null;
+  if (tag) detected.add(tag);
+}

package/src/ui/markdown/overview.ts

@@ -3,9 +3,12 @@
 
 import type { OverviewData } from "./types.ts";
 
+/** Soft token budget — log a warning when exceeded. */
+const OVERVIEW_TOKEN_BUDGET = 600;
+
 /**
  * Render the compact architecture overview for first-turn session injection.
- * Targets roughly 500 tokens.
+ * Targets at most 600 estimated tokens; logs a supi_debug warning when exceeded.
  */
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: module-edge overview rendering with multiple formatting paths is clearer as one function
 export function renderOverview(data: OverviewData): string {
@@ -25,20 +28,23 @@ export function renderOverview(data: OverviewData): string {
   lines.push("");
 
   for (const mod of data.modules) {
-    const deps = mod.internalDeps.filter((d) =>
+    const deps = mod.declaredDependencies.filter((d) =>
       data.modules.some((m) => m.name === d || m.shortName === d),
     );
 
+    const entrypointSuffix =
+      mod.declaredEntrypoints.length > 0 ? ` [${mod.declaredEntrypoints.join(", ")}]` : "";
+
     if (deps.length === 0) {
       lines.push(
-        `- **${mod.shortName}**${mod.isLeaf ? " (leaf)" : ""}${mod.description ? ` — ${mod.description}` : ""}`,
+        `- **${mod.shortName}**${entrypointSuffix}${mod.description ? ` — ${mod.description}` : ""}`,
       );
     } else {
       const depNames = deps.slice(0, 4).map((d) => d.replace(/^@[^/]+\//, ""));
       const depStr = depNames.join(", ");
       const suffix = deps.length > 4 ? ` +${deps.length - 4} more` : "";
       lines.push(
-        `- **${mod.shortName}** → ${depStr}${suffix}${mod.description ? ` — ${mod.description}` : ""}`,
+        `- **${mod.shortName}** → ${depStr}${suffix}${entrypointSuffix}${mod.description ? ` — ${mod.description}` : ""}`,
       );
     }
   }
@@ -49,11 +55,24 @@ export function renderOverview(data: OverviewData): string {
 
   lines.push("");
 
-  if (data.gitContextOverview) {
-    lines.push(data.gitContextOverview);
+  if (data.detectedLanguages && data.detectedLanguages.length > 0) {
+    lines.push(`**Detected:** ${data.detectedLanguages.join(", ")}`);
+    lines.push("");
   }
 
-  lines.push('_For deeper orientation, use `code_orientation({ focus: "..." })`._');
+  lines.push('_For deeper orientation, use `code_orientation({ focus: { path: "..." } })`._');
+  lines.push("");
+  lines.push("_(session snapshot)_");
+
+  const output = lines.join("\n");
+
+  return output;
+}
 
-  return lines.join("\n");
+/** Estimated token count using the repository convention. */
+export function estimateTokens(content: string): number {
+  return Math.ceil(content.length / 4);
 }
+
+/** The soft token budget for the overview. */
+export { OVERVIEW_TOKEN_BUDGET };

package/src/ui/markdown/types.ts

@@ -1,19 +1,21 @@
 // Shared typed data interfaces between use-case and presentation layers.
 
-import type { SessionLspServiceState } from "@mrclrchtr/supi-lsp/api";
+import type { WorkspaceLspRuntimeState } from "@mrclrchtr/supi-lsp/api";
 import type { ArchitectureModel } from "../../analysis/architecture/model.ts";
 import type { CodeProvider } from "../../analysis/provider.ts";
 import type { AnchorKind } from "../../session/target-store.ts";
-import type { ContextDetails, InspectDetails } from "../../types/details.ts";
+import type { InspectDetails } from "../../types/details.ts";
 
-// ── Overview use-case ────────────────────────────────────────────────
+// ── Overview use-case ───────────────────────────────────────────────
 
 export interface OverviewModule {
   name: string;
   shortName: string;
   description: string | null;
-  isLeaf: boolean;
-  internalDeps: string[];
+  /** Manifest-declared package relationships to other discovered packages. */
+  declaredDependencies: string[];
+  /** Field-labelled manifest path declarations, never selected by precedence. */
+  declaredEntrypoints: string[];
 }
 
 export interface OverviewData {
@@ -21,7 +23,8 @@ export interface OverviewData {
   projectDescription: string | null;
   modules: OverviewModule[];
   omittedModuleCount: number;
-  gitContextOverview: string | null;
+  /** Detected source languages (e.g. ["ts", "js", "py"]). */
+  detectedLanguages: string[] | null;
 }
 
 // ── Inspect use-case ─────────────────────────────────────────────────
@@ -36,7 +39,7 @@ export interface InspectInput {
 export interface InspectDeps {
   provider: CodeProvider | null;
   cwd: string;
-  lspService: SessionLspServiceState;
+  lspRuntime: WorkspaceLspRuntimeState;
 }
 
 export interface InspectUseCaseResult {
@@ -63,18 +66,11 @@ export interface OrientationInput {
   /** Resolved orientation focus path for project/module/directory/file orientation. */
   focus?: string;
   maxResults?: number;
-  /** Show git context in orientation output. Defaults to true. */
-  showGitContext?: boolean;
 }
 
 export interface OrientationDeps {
-  model: ArchitectureModel | null;
+  model: ArchitectureModel;
   provider: CodeProvider | null;
   cwd: string;
-  lspService: SessionLspServiceState;
-}
-
-export interface OrientationUseCaseResult {
-  content: string;
-  details: ContextDetails;
+  lspRuntime: WorkspaceLspRuntimeState;
 }

package/src/ui/status-command.ts

@@ -4,12 +4,11 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
-import type { SessionLspServiceState } from "@mrclrchtr/supi-lsp/api";
+import { getWorkspaceLspRuntime, type WorkspaceLspRuntimeState } from "@mrclrchtr/supi-lsp/api";
 import {
-  evaluateCoverageWarnings,
-  gatherCoverageEvalInput,
-} from "../analysis/coverage/coverage-warnings.ts";
-import { getCodeProvider } from "../analysis/provider.ts";
+  evaluateCapabilityWarnings,
+  gatherCapabilityWarningInput,
+} from "../analysis/capability/capability-warnings.ts";
 import { type CiStatusData, createCiStatusDialog } from "./status-overlay.ts";
 
 const STATUS_KEY = "code-intelligence";
@@ -20,10 +19,9 @@ interface InspectorState {
   close: (() => void) | null;
 }
 
-const inspector: InspectorState = { handle: null, close: null };
-
 /** Register the interactive /supi-ci-status overlay command. */
 export function registerCiStatusCommand(pi: ExtensionAPI): void {
+  const inspector: InspectorState = { handle: null, close: null };
   pi.registerCommand("supi-ci-status", {
     description: "Toggle code intelligence status — LSP and structural analysis state",
     handler: async (_args: string, ctx: ExtensionContext) => {
@@ -52,10 +50,9 @@ export function registerCiStatusCommand(pi: ExtensionAPI): void {
               done: () => done(undefined),
               tui,
               fetchDetailedDiagnostics: async (maxSeverity) => {
-                const ps = getCodeProvider(ctx.cwd);
-                const lspState = ps.kind === "ready" ? ps.lspService : null;
-                if (lspState?.kind !== "ready") return [];
-                return lspState.service.getOutstandingDiagnostics(maxSeverity);
+                const lspState = getWorkspaceLspRuntime(ctx.cwd);
+                if (lspState.kind !== "ready") return [];
+                return lspState.runtime.getOutstandingDiagnostics(maxSeverity);
               },
               onRefresh: async () => {
                 const fresh = await gatherCiStatusData(ctx.cwd, pi);
@@ -92,15 +89,17 @@ export function registerCiStatusCommand(pi: ExtensionAPI): void {
 /** Gather a snapshot of LSP and structural state for the dialog. */
 async function gatherCiStatusData(cwd: string, pi: ExtensionAPI): Promise<CiStatusData> {
   const workspace = getDefaultWorkspaceRuntime().getWorkspace(cwd);
-  const providerState = getCodeProvider(cwd);
-  const lspState = providerState.kind === "ready" ? providerState.lspService : null;
-
-  const servers = lspState && lspState.kind === "ready" ? lspState.service.getProjectServers() : [];
+  const lspState = getWorkspaceLspRuntime(cwd);
+  const serverInventoryAvailable = lspState.kind === "ready" || lspState.kind === "disabled";
+  const servers = lspState.kind === "ready" ? lspState.runtime.getProjectServers() : [];
+  const semanticAvailable = servers.some(
+    (server) => server.status === "running" && server.ready === true,
+  );
   const diagnostics =
-    lspState && lspState.kind === "ready"
-      ? lspState.service.getOutstandingDiagnosticSummary(1)
+    lspState.kind === "ready" && semanticAvailable
+      ? lspState.runtime.getOutstandingDiagnosticSummary(1)
       : [];
-  const semanticState = deriveSemanticCapabilityState(workspace, lspState);
+  const semanticState = deriveSemanticCapabilityState(workspace, lspState, semanticAvailable);
 
   // Sort: errors desc, warnings desc, info desc, hints desc
   diagnostics.sort((a, b) => {
@@ -116,12 +115,14 @@ async function gatherCiStatusData(cwd: string, pi: ExtensionAPI): Promise<CiStat
 
   const activeTools = pi.getActiveTools().filter((t) => t.startsWith("code_"));
 
-  // Evaluate degraded coverage from available data
-  const degradedCoverage = evaluateCoverageWarnings(gatherCoverageEvalInput(cwd, null));
+  // Evaluate current Capability Warnings from available data.
+  const capabilityWarnings = evaluateCapabilityWarnings(gatherCapabilityWarningInput(cwd, null));
 
   return {
     servers,
     diagnostics,
+    serverInventoryAvailable,
+    semanticAvailable,
     capabilities: {
       semantic: semanticState,
       structural: {
@@ -132,7 +133,7 @@ async function gatherCiStatusData(cwd: string, pi: ExtensionAPI): Promise<CiStat
       refactorAvailable: workspace.semantic.refactorAvailable,
     },
     activeTools,
-    degradedCoverage: degradedCoverage.hasWarnings ? degradedCoverage : undefined,
+    capabilityWarnings: capabilityWarnings.hasWarnings ? capabilityWarnings : undefined,
   };
 }
 
@@ -143,24 +144,31 @@ function deriveSemanticCapabilityState(
       provider: unknown | null;
     };
   },
-  lspState: SessionLspServiceState | null,
+  lspState: WorkspaceLspRuntimeState,
+  semanticAvailable: boolean,
 ): CiStatusData["capabilities"]["semantic"] {
-  if (lspState?.kind === "ready") {
-    return {
-      kind: workspace.semantic.state.kind === "pending" ? "pending" : "ready",
-      providerAvailable: workspace.semantic.provider !== null,
-    };
+  if (lspState.kind === "ready") {
+    return semanticAvailable
+      ? {
+          kind: "ready",
+          providerAvailable: workspace.semantic.provider !== null,
+        }
+      : {
+          kind: "pending",
+          reason: "No active, ready project servers",
+          providerAvailable: workspace.semantic.provider !== null,
+        };
   }
-  if (workspace.semantic.state.kind === "pending" || lspState?.kind === "pending") {
+  if (workspace.semantic.state.kind === "pending" || lspState.kind === "pending") {
     return {
       kind: "pending",
       providerAvailable: workspace.semantic.provider !== null,
     };
   }
-  if (lspState?.kind === "inactive") {
+  if (lspState.kind === "inactive") {
     return { kind: "inactive", providerAvailable: workspace.semantic.provider !== null };
   }
-  if (lspState?.kind === "disabled") {
+  if (lspState.kind === "disabled") {
     return {
       kind: "disabled",
       reason: "LSP is disabled in settings",
@@ -169,7 +177,7 @@ function deriveSemanticCapabilityState(
   }
   return {
     kind: workspace.semantic.state.kind,
-    reason: lspState && "reason" in lspState ? lspState.reason : "No LSP service",
+    reason: "reason" in lspState ? lspState.reason : "No LSP service",
     providerAvailable: workspace.semantic.provider !== null,
   };
 }

package/src/ui/status-overlay.ts

@@ -17,7 +17,7 @@ import type {
   OutstandingDiagnosticSummaryEntry,
   ProjectServerInfo,
 } from "@mrclrchtr/supi-lsp/api";
-import type { CoverageWarningReport } from "../analysis/coverage/coverage-warnings.ts";
+import type { CapabilityWarningReport } from "../analysis/capability/capability-warnings.ts";
 import { diagnosticMessageString } from "../substrate/lsp/utils.ts";
 
 /**
@@ -33,6 +33,10 @@ export interface CiDialogTheme {
 
 export interface CiStatusData {
   servers: ProjectServerInfo[];
+  /** Whether the server list is complete status evidence. */
+  serverInventoryAvailable: boolean;
+  /** Whether diagnostics and semantic absence claims are currently supported. */
+  semanticAvailable: boolean;
   /** Sorted: errors desc, then warnings desc, then info desc, then hints desc. */
   diagnostics: OutstandingDiagnosticSummaryEntry[];
   capabilities: {
@@ -41,8 +45,8 @@ export interface CiStatusData {
     refactorAvailable: boolean;
   };
   activeTools: string[];
-  /** Coverage warnings for degraded semantic/structural substrate. Undefined when fully healthy. */
-  degradedCoverage?: CoverageWarningReport;
+  /** Supplemental Capability Warnings. Undefined when fully healthy. */
+  capabilityWarnings?: CapabilityWarningReport;
 }
 
 /** Fetcher for full diagnostic details when a file row is expanded. */
@@ -108,7 +112,7 @@ export class CiStatusDialog {
     this.addProblemsSection(container, width);
     container.addChild(new Spacer(1));
     this.addCapabilitiesSection(container);
-    this.addDegradedCoverageSection(container);
+    this.addCapabilityWarningsSection(container);
     this.addToolsSection(container, width);
     container.addChild(new Text(this.renderKeyHints(), 1, 0));
     container.addChild(new DynamicBorder((s: string) => this.theme.fg("accent", s)));
@@ -296,12 +300,17 @@ export class CiStatusDialog {
 
   private addEmptyServerRow(container: Container): void {
     const t = this.theme;
-    const sem = this.data.capabilities.semantic;
-    if (sem.kind !== "ready") {
-      container.addChild(new Text(t.fg("dim", "  no LSP session for this workspace"), 1, 0));
-    } else {
-      container.addChild(new Text(t.fg("dim", "  no configured language servers"), 1, 0));
+    if (!this.data.serverInventoryAvailable) {
+      container.addChild(new Text(t.fg("dim", "  server inventory unavailable"), 1, 0));
+      return;
+    }
+    if (this.data.capabilities.semantic.kind === "disabled") {
+      container.addChild(new Text(t.fg("dim", "  all language servers disabled"), 1, 0));
+      return;
     }
+    container.addChild(
+      new Text(t.fg("dim", "  no active project servers; routes may start lazily"), 1, 0),
+    );
   }
 
   private addServerRow(container: Container, server: ProjectServerInfo): void {
@@ -362,9 +371,8 @@ export class CiStatusDialog {
 
   private addEmptyProblemsRow(container: Container): void {
     const t = this.theme;
-    const sem = this.data.capabilities.semantic;
-    if (sem.kind !== "ready") {
-      container.addChild(new Text(t.fg("dim", "  (LSP not ready)"), 1, 0));
+    if (!this.data.semanticAvailable) {
+      container.addChild(new Text(t.fg("dim", "  (diagnostics unavailable)"), 1, 0));
     } else {
       container.addChild(new Text(t.fg("success", "  ✓ no issues"), 1, 0));
     }
@@ -451,13 +459,13 @@ export class CiStatusDialog {
     );
   }
 
-  private addDegradedCoverageSection(container: Container): void {
-    const warnings = this.data.degradedCoverage;
+  private addCapabilityWarningsSection(container: Container): void {
+    const warnings = this.data.capabilityWarnings;
     if (!warnings?.hasWarnings) return;
 
     const t = this.theme;
     container.addChild(new Spacer(1));
-    container.addChild(new Text(t.fg("error", t.bold(" Degraded Coverage")), 1, 0));
+    container.addChild(new Text(t.fg("error", t.bold(" Capability Warnings")), 1, 0));
 
     for (const w of warnings.warnings) {
       const lang = w.language ? `${t.fg("accent", w.language)} ` : "";