@mrclrchtr/supi-code-intelligence 1.16.1 → 2.0.0

package/src/ui/markdown/gather.ts

@@ -0,0 +1,177 @@
+/**
+ * Substrate context gathering for symbol briefs and point inspection (code_inspect).
+ *
+ * Extracted from generate-brief.ts to keep the file within the
+ * noExcessiveLinesPerFile threshold.
+ */
+
+import { resolve } from "node:path";
+import type { SourceRange } from "@mrclrchtr/supi-code-runtime/api";
+import type { SessionLspServiceState } from "@mrclrchtr/supi-lsp/api";
+import type { CodeProvider } from "../../analysis/provider.ts";
+import { diagnosticMessageString } from "../../substrate/lsp/utils.ts";
+
+export interface TreeSitterContext {
+  nodeInfo: {
+    type: string;
+    text: string;
+    startLine: number;
+    startCharacter: number;
+    ancestry: Array<{
+      type: string;
+      startLine: number;
+      startCharacter: number;
+      endLine: number;
+      endCharacter: number;
+    }>;
+  } | null;
+  outline: Array<{ name: string; kind: string; startLine: number; endLine: number }>;
+  imports: Array<{ moduleSpecifier: string }>;
+  exports: Array<{ name: string; kind: string }>;
+  /** Best-effort LSP hover info at the anchored position. `null` when unavailable. */
+  hover: { contents: string; range?: SourceRange } | null;
+  /** Best-effort LSP definition targets at the anchored position. `null` when unavailable. */
+  definition: Array<{ uri: string; range: SourceRange }> | null;
+  /** Best-effort code action titles at the anchored position. `null` when unavailable. */
+  codeActions: Array<{ title: string; kind?: string }> | null;
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: best-effort substrate gathering with independent try/catch blocks kept together for readability
+export async function gatherTreeSitterContext(
+  provider: CodeProvider | null,
+  relPath: string,
+  line: number,
+  character: number,
+): Promise<TreeSitterContext> {
+  let nodeInfo: TreeSitterContext["nodeInfo"] = null;
+  let outline: TreeSitterContext["outline"] = [];
+  let imports: TreeSitterContext["imports"] = [];
+  let exports: TreeSitterContext["exports"] = [];
+  let hover: TreeSitterContext["hover"] = null;
+  let definition: TreeSitterContext["definition"] = null;
+  let codeActions: TreeSitterContext["codeActions"] = null;
+
+  if (!provider)
+    return { nodeInfo, outline, imports, exports, hover, definition: null, codeActions: null };
+
+  try {
+    const nodeResult = await provider.nodeAt(relPath, line, character);
+    if (nodeResult.kind === "success") {
+      nodeInfo = {
+        type: nodeResult.data.type,
+        text: nodeResult.data.text,
+        startLine: nodeResult.data.startLine,
+        startCharacter: nodeResult.data.startCharacter,
+        ancestry: nodeResult.data.ancestry ?? [],
+      };
+    }
+
+    const outlineResult = await provider.outline(relPath);
+    if (outlineResult.kind === "success") {
+      outline = outlineResult.data.map((item) => ({
+        name: item.name,
+        kind: item.kind,
+        startLine: item.startLine,
+        endLine: item.endLine,
+      }));
+    }
+
+    const importsResult = await provider.imports(relPath);
+    if (importsResult.kind === "success") {
+      imports = importsResult.data;
+    }
+
+    const exportsResult = await provider.exports(relPath);
+    if (exportsResult.kind === "success") {
+      exports = exportsResult.data.map((item) => ({
+        name: item.name,
+        kind: item.kind,
+      }));
+    }
+
+    // Best-effort hover — LSP expects 0-based coordinates
+    if (provider.hover) {
+      try {
+        const hoverResult = await provider.hover(relPath, {
+          line: line - 1,
+          character: character - 1,
+        });
+        if (hoverResult) hover = hoverResult;
+      } catch {
+        // hover failed — continue without it
+      }
+    }
+
+    // Best-effort definition — LSP expects 0-based coordinates
+    if (provider.definition) {
+      try {
+        const defResult = await provider.definition(relPath, {
+          line: line - 1,
+          character: character - 1,
+        });
+        if (defResult && defResult.length > 0) {
+          definition = defResult.map((loc) => ({
+            uri: loc.uri,
+            range: loc.range,
+          }));
+        }
+      } catch {
+        // definition failed — continue without it
+      }
+    }
+
+    // Best-effort code actions — LSP expects 0-based coordinates
+    if (provider.codeActionTitles) {
+      try {
+        const titles = await provider.codeActionTitles(relPath, {
+          line: line - 1,
+          character: character - 1,
+        });
+        if (titles && titles.length > 0) {
+          codeActions = titles.map((a) => ({
+            title: a.title,
+            kind: a.kind,
+          }));
+        }
+      } catch {
+        // code actions failed — continue without it
+      }
+    }
+  } catch {
+    // Provider not available
+  }
+
+  return { nodeInfo, outline, imports, exports, hover, definition, codeActions };
+}
+
+export interface NearbyDiagnostic {
+  line: number;
+  severity: number;
+  message: string;
+}
+
+// biome-ignore lint/complexity/useMaxParams: lspService is a DI seam, not a logic parameter
+export async function gatherNearbyDiagnostics(
+  cwd: string,
+  file: string,
+  line: number,
+  maxResults: number,
+  lspService: SessionLspServiceState,
+): Promise<NearbyDiagnostic[]> {
+  if (lspService.kind !== "ready") return [];
+
+  try {
+    const diagnostics = await lspService.service.fileDiagnostics(resolve(cwd, file), 4);
+    if (!diagnostics || diagnostics.length === 0) return [];
+
+    const nearby = diagnostics.filter((d) => Math.abs(d.range.start.line + 1 - line) <= 2);
+    const chosen = nearby.length > 0 ? nearby : diagnostics;
+    return chosen.slice(0, maxResults).map((d) => ({
+      line: d.range.start.line + 1,
+      severity: d.severity ?? 1,
+      message: diagnosticMessageString(d),
+    }));
+  } catch {
+    return [];
+  }
+}

package/src/{use-case/build-overview.ts → ui/markdown/overview-data.ts}

@@ -1,7 +1,7 @@
 // Typed overview data builder from ArchitectureModel.
 
-import { formatGitContext, gatherGitContext } from "../git-context.ts";
-import type { ArchitectureModel } from "../model.ts";
+import type { ArchitectureModel } from "../../analysis/architecture/model.ts";
+import { formatGitContext, gatherGitContext } from "../../analysis/signals/git.ts";
 import type { OverviewData, OverviewModule } from "./types.ts";
 
 /**

package/src/{presentation → ui}/markdown/overview.ts

@@ -1,7 +1,7 @@
 // Hidden overview markdown renderer for the first-turn session injection.
 // Consumes OverviewData produced by the overview use-case.
 
-import type { OverviewData } from "../../use-case/types.ts";
+import type { OverviewData } from "./types.ts";
 
 /**
  * Render the compact architecture overview for first-turn session injection.
@@ -53,7 +53,7 @@ export function renderOverview(data: OverviewData): string {
     lines.push(data.gitContextOverview);
   }
 
-  lines.push("_Use `code_brief` for deeper context on any module or file._");
+  lines.push('_For deeper orientation, use `code_orientation({ focus: "..." })`._');
 
   return lines.join("\n");
 }

package/src/ui/markdown/types.ts

@@ -0,0 +1,80 @@
+// Shared typed data interfaces between use-case and presentation layers.
+
+import type { SessionLspServiceState } 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";
+
+// ── Overview use-case ────────────────────────────────────────────────
+
+export interface OverviewModule {
+  name: string;
+  shortName: string;
+  description: string | null;
+  isLeaf: boolean;
+  internalDeps: string[];
+}
+
+export interface OverviewData {
+  projectName: string | null;
+  projectDescription: string | null;
+  modules: OverviewModule[];
+  omittedModuleCount: number;
+  gitContextOverview: string | null;
+}
+
+// ── Inspect use-case ─────────────────────────────────────────────────
+
+export interface InspectInput {
+  file: string;
+  line: number;
+  character: number;
+  maxResults?: number;
+}
+
+export interface InspectDeps {
+  provider: CodeProvider | null;
+  cwd: string;
+  lspService: SessionLspServiceState;
+}
+
+export interface InspectUseCaseResult {
+  content: string;
+  details: InspectDetails;
+}
+
+// ── Orientation use-case ─────────────────────────────────────────────────
+
+export type OrientationSection = "defs" | "docs" | "diagnostics";
+
+export interface OrientationTarget {
+  file: string;
+  line: number;
+  character: number;
+  name: string | null;
+  kind: string | null;
+  /** Which anchor this target carries; strict consumers refuse declaration anchors. */
+  anchorKind: AnchorKind;
+}
+
+export interface OrientationInput {
+  target?: OrientationTarget | null;
+  /** 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;
+  provider: CodeProvider | null;
+  cwd: string;
+  lspService: SessionLspServiceState;
+}
+
+export interface OrientationUseCaseResult {
+  content: string;
+  details: ContextDetails;
+}

package/{node_modules/@mrclrchtr/supi-lsp/src/ui/renderer.ts → src/ui/message-renderer.ts}

@@ -1,3 +1,8 @@
+// LSP context diagnostic message renderer — TUI renderer for lsp-context messages.
+//
+// Ported from supi-lsp's renderer. Inline diagnostic rendering for the
+// diagnostic messages injected by before_agent_start.
+
 import type { ThemeColor } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
 
@@ -41,7 +46,7 @@ function hasDiagnosticCounts(totals: DiagnosticCounts): boolean {
   return totals.errors > 0 || totals.warnings > 0 || totals.information > 0 || totals.hints > 0;
 }
 
-function buildLspContextCollapsed(
+function buildCollapsed(
   diagnostics: LspContextDetails["diagnostics"],
   totals: DiagnosticCounts | undefined,
   staleWarning: string | null | undefined,
@@ -61,11 +66,11 @@ function buildLspContextCollapsed(
   return `${summary}\n${theme.fg("warning", staleWarning)}`;
 }
 
-function formatFileDiagnosticEntry(d: DiagnosticCounts): string {
+function formatFileEntry(d: DiagnosticCounts): string {
   return formatDiagnosticCounts(d, { fg: (_color, text) => text });
 }
 
-function formatExpandedDetails(
+function buildExpanded(
   diagnostics: LspContextDetails["diagnostics"],
   token: string | undefined,
   staleWarning: string | null | undefined,
@@ -77,7 +82,7 @@ function formatExpandedDetails(
   }
   if (diagnostics && diagnostics.length > 0) {
     for (const d of diagnostics) {
-      lines.push(theme.fg("dim", `  ${d.file}: ${formatFileDiagnosticEntry(d)}`));
+      lines.push(theme.fg("dim", `  ${d.file}: ${formatFileEntry(d)}`));
     }
   }
   if (token) {
@@ -86,8 +91,6 @@ function formatExpandedDetails(
   return lines.join("\n");
 }
 
-export type { LspContextDetails };
-
 export function registerLspMessageRenderer(
   pi: import("@earendil-works/pi-coding-agent").ExtensionAPI,
 ): void {
@@ -107,10 +110,8 @@ export function registerLspMessageRenderer(
     );
 
     const staleWarning = details?.staleWarning;
-    const collapsed = buildLspContextCollapsed(diagnostics, totals, staleWarning, theme);
-    const expandedDetails = expanded
-      ? formatExpandedDetails(diagnostics, token, staleWarning, theme)
-      : "";
+    const collapsed = buildCollapsed(diagnostics, totals, staleWarning, theme);
+    const expandedDetails = expanded ? buildExpanded(diagnostics, token, staleWarning, theme) : "";
     const fullText = expandedDetails ? `${collapsed}\n${expandedDetails}` : collapsed;
 
     const box = new Box(1, 1, (t) => theme.bg("customMessageBg", t));

package/src/ui/status-command.ts

@@ -0,0 +1,260 @@
+// Code Intelligence status command — toggleable center dialog with persistent
+// status bar, custom footer, and below-editor widget for LSP + structural awareness.
+
+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 {
+  evaluateCoverageWarnings,
+  gatherCoverageEvalInput,
+} from "../analysis/coverage/coverage-warnings.ts";
+import { getCodeProvider } from "../analysis/provider.ts";
+import { type CiStatusData, createCiStatusDialog } from "./status-overlay.ts";
+
+const STATUS_KEY = "code-intelligence";
+const WIDGET_KEY = "code-intelligence";
+
+interface InspectorState {
+  handle: unknown;
+  close: (() => void) | null;
+}
+
+const inspector: InspectorState = { handle: null, close: null };
+
+/** Register the interactive /supi-ci-status overlay command. */
+export function registerCiStatusCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi-ci-status", {
+    description: "Toggle code intelligence status — LSP and structural analysis state",
+    handler: async (_args: string, ctx: ExtensionContext) => {
+      if (inspector.close) {
+        inspector.close();
+        return;
+      }
+
+      const dataRef = { current: await gatherCiStatusData(ctx.cwd, pi) };
+      updateStatusAndWidget(ctx, dataRef.current);
+
+      // Custom footer while overlay is open — reads latest data via ref
+      ctx.ui.setFooter((_tui, _theme) => ({
+        render(width: number): string[] {
+          return [truncateFooterLine(renderFooterLine(ctx, dataRef.current), width)];
+        },
+        invalidate(): void {},
+      }));
+
+      void ctx.ui
+        .custom<void>(
+          (tui, theme, _kb, done) => {
+            inspector.close = () => done(undefined);
+            return createCiStatusDialog(dataRef.current, {
+              theme: theme as unknown as import("./status-overlay.ts").CiDialogTheme,
+              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);
+              },
+              onRefresh: async () => {
+                const fresh = await gatherCiStatusData(ctx.cwd, pi);
+                dataRef.current = fresh;
+                updateStatusAndWidget(ctx, fresh);
+                return fresh;
+              },
+            });
+          },
+          {
+            overlay: true,
+            overlayOptions: {
+              anchor: "center",
+              width: "66%",
+              minWidth: 60,
+              maxHeight: "85%",
+              visible: (termWidth: number) => termWidth >= 60,
+            },
+            onHandle: (handle) => {
+              inspector.handle = handle;
+            },
+          },
+        )
+        .finally(() => {
+          inspector.handle = null;
+          inspector.close = null;
+          clearStatusAndWidget(ctx);
+          ctx.ui.setFooter(undefined);
+        });
+    },
+  });
+}
+
+/** 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 diagnostics =
+    lspState && lspState.kind === "ready"
+      ? lspState.service.getOutstandingDiagnosticSummary(1)
+      : [];
+  const semanticState = deriveSemanticCapabilityState(workspace, lspState);
+
+  // Sort: errors desc, warnings desc, info desc, hints desc
+  diagnostics.sort((a, b) => {
+    if (b.errors !== a.errors) return b.errors - a.errors;
+    if (b.warnings !== a.warnings) return b.warnings - a.warnings;
+    if (b.information !== a.information) return b.information - a.information;
+    return b.hints - a.hints;
+  });
+
+  const structState = workspace.structural.state;
+  const structKind = structState.kind;
+  const structReason = structState.kind === "unavailable" ? structState.reason : undefined;
+
+  const activeTools = pi.getActiveTools().filter((t) => t.startsWith("code_"));
+
+  // Evaluate degraded coverage from available data
+  const degradedCoverage = evaluateCoverageWarnings(gatherCoverageEvalInput(cwd, null));
+
+  return {
+    servers,
+    diagnostics,
+    capabilities: {
+      semantic: semanticState,
+      structural: {
+        kind: structKind,
+        reason: structReason,
+        providerAvailable: structState.kind === "ready",
+      },
+      refactorAvailable: workspace.semantic.refactorAvailable,
+    },
+    activeTools,
+    degradedCoverage: degradedCoverage.hasWarnings ? degradedCoverage : undefined,
+  };
+}
+
+function deriveSemanticCapabilityState(
+  workspace: {
+    semantic: {
+      state: { kind: string };
+      provider: unknown | null;
+    };
+  },
+  lspState: SessionLspServiceState | null,
+): CiStatusData["capabilities"]["semantic"] {
+  if (lspState?.kind === "ready") {
+    return {
+      kind: workspace.semantic.state.kind === "pending" ? "pending" : "ready",
+      providerAvailable: workspace.semantic.provider !== null,
+    };
+  }
+  if (workspace.semantic.state.kind === "pending" || lspState?.kind === "pending") {
+    return {
+      kind: "pending",
+      providerAvailable: workspace.semantic.provider !== null,
+    };
+  }
+  if (lspState?.kind === "inactive") {
+    return { kind: "inactive", providerAvailable: workspace.semantic.provider !== null };
+  }
+  if (lspState?.kind === "disabled") {
+    return {
+      kind: "disabled",
+      reason: "LSP is disabled in settings",
+      providerAvailable: workspace.semantic.provider !== null,
+    };
+  }
+  return {
+    kind: workspace.semantic.state.kind,
+    reason: lspState && "reason" in lspState ? lspState.reason : "No LSP service",
+    providerAvailable: workspace.semantic.provider !== null,
+  };
+}
+
+/** Render the custom footer line. */
+function renderFooterLine(ctx: ExtensionContext, data: CiStatusData): string {
+  const t = ctx.ui.theme;
+  const parts: string[] = [];
+  const running = data.servers.filter((s) => s.status === "running").length;
+  if (running > 0) {
+    parts.push(
+      t.fg("accent", "λ ci") + t.fg("dim", ` ${running} server${running === 1 ? "" : "s"}`),
+    );
+  }
+  const totalErrors = data.diagnostics.reduce((sum, d) => sum + d.errors, 0);
+  if (totalErrors > 0) {
+    parts.push(t.fg("error", `${totalErrors} error${totalErrors === 1 ? "" : "s"}`));
+  }
+  const totalWarnings = data.diagnostics.reduce((sum, d) => sum + d.warnings, 0);
+  if (totalWarnings > 0) {
+    parts.push(t.fg("warning", `${totalWarnings} warning${totalWarnings === 1 ? "" : "s"}`));
+  }
+  const structKind = data.capabilities.structural.kind;
+  if (structKind === "ready") parts.push(t.fg("success", "✓ ts"));
+  if (parts.length === 0) return t.fg("dim", "CI — no data available");
+  return parts.join(t.fg("dim", "  "));
+}
+
+function truncateFooterLine(line: string, width: number): string {
+  return truncateToWidth(line, width, "…");
+}
+
+/** Update the persistent status bar and below-editor widget. */
+function updateStatusAndWidget(ctx: ExtensionContext, data: CiStatusData): void {
+  const t = ctx.ui.theme;
+
+  // Status bar: concise one-liner
+  const parts: string[] = [t.fg("accent", "λ ci")];
+  const runningServers = data.servers.filter((s) => s.status === "running").length;
+  if (runningServers > 0) {
+    parts.push(t.fg("dim", `${runningServers} server${runningServers === 1 ? "" : "s"}`));
+  }
+  const totalErrors = data.diagnostics.reduce((sum, d) => sum + d.errors, 0);
+  if (totalErrors > 0) {
+    parts.push(t.fg("error", `${totalErrors} error${totalErrors === 1 ? "" : "s"}`));
+  }
+  const totalWarnings = data.diagnostics.reduce((sum, d) => sum + d.warnings, 0);
+  if (totalWarnings > 0) {
+    parts.push(t.fg("warning", `${totalWarnings} warning${totalWarnings === 1 ? "" : "s"}`));
+  }
+  const structKind = data.capabilities.structural.kind;
+  if (structKind === "ready") parts.push(t.fg("success", "✓ ts"));
+
+  const statusText = parts.length > 1 ? parts.join(t.fg("dim", " · ")) : undefined;
+  ctx.ui.setStatus(STATUS_KEY, statusText);
+
+  // Widget (below editor) — top problem files
+  if (data.diagnostics.length > 0) {
+    const top = data.diagnostics.slice(0, 2);
+    const fileLines = top.map((d) => {
+      const counts: string[] = [];
+      if (d.errors > 0) {
+        counts.push(t.fg("error", `${d.errors} error${d.errors === 1 ? "" : "s"}`));
+      }
+      if (d.warnings > 0) {
+        counts.push(t.fg("warning", `${d.warnings} warning${d.warnings === 1 ? "" : "s"}`));
+      }
+      return `  ${d.file} (${counts.join(", ")})`;
+    });
+    const more = data.diagnostics.length - top.length;
+    const moreSuffix = more > 0 ? t.fg("dim", ` +${more} more`) : "";
+    ctx.ui.setWidget(
+      WIDGET_KEY,
+      [
+        t.fg("accent", `λ CI — ${data.diagnostics.length} files with issues`) + moreSuffix,
+        ...fileLines,
+      ],
+      { placement: "belowEditor" },
+    );
+  } else {
+    ctx.ui.setWidget(WIDGET_KEY, undefined);
+  }
+}
+
+function clearStatusAndWidget(ctx: ExtensionContext): void {
+  ctx.ui.setStatus(STATUS_KEY, undefined);
+  ctx.ui.setWidget(WIDGET_KEY, undefined);
+}