@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/src/tool/graph/orchestrate.ts

@@ -1,259 +0,0 @@
-/**
- * Graph orchestration use-case — unified relation-graph data collection.
- *
- * Resolves a target and collects per-relation data (references, callees,
- * imports, exports, implementations, tests) through the code provider.
- * Returns a rendered CodeIntelResult with structured details.
- *
- * Extracted from execute-graph.ts as part of the thin-executor normalization.
- */
-
-import type { CodeProvider } from "../../analysis/provider.ts";
-import { ensureSemanticReadiness } from "../../analysis/readiness.ts";
-import { toDisplayPath } from "../../analysis/search/ripgrep.ts";
-import { resolveTarget } from "../../analysis/target/bridge.ts";
-import type { AnchorKind } from "../../session/target-store.ts";
-import type { CodeIntelResult } from "../../types/index.ts";
-import { searchErrorResult } from "../infra/error-results.ts";
-import { emitToolProgress } from "../infra/progress.ts";
-import { renderSemanticReadinessTimeout } from "../infra/readiness-message.ts";
-import { assembleGraphResult } from "../result/graph.ts";
-import { type CollectRelationOptions, collectRelation } from "./collect-relation.ts";
-import type { GraphRelation } from "./execute.ts";
-import { renderGraphResult } from "./markdown-base.ts";
-
-/** Relation kinds accepted by code_graph. */
-export type { GraphRelation };
-
-/** Default relation set when none specified. */
-const DEFAULT_RELATIONS: GraphRelation[] = ["references"];
-
-/** Relations that need semantic (LSP) readiness. */
-const SEMANTIC_RELATIONS: GraphRelation[] = ["references", "implements"];
-
-/** Relations that only need a file path, not a position. */
-const FILE_LEVEL_RELATIONS: GraphRelation[] = ["imports", "exports"];
-
-export interface GraphInput {
-  targetId?: string;
-  file?: string;
-  line?: number;
-  character?: number;
-  symbol?: string;
-  scope?: string;
-  relations?: GraphRelation[];
-  calleeDepth?: "direct" | "deep";
-  maxResults?: number;
-  /** Set by pipeline expandTargetId stage. */
-  _expandedName?: string | null;
-  /** Set by pipeline expandTargetId stage. */
-  _expandedAnchorKind?: AnchorKind;
-}
-
-export interface GraphDeps {
-  cwd: string;
-  session: import("../../session/session.ts").WorkspaceCodeIntelligenceSession;
-  /** Ready code provider, or null. */
-  provider: CodeProvider | null;
-  /** Progress callback for long-running relation collection. */
-  onUpdate?: import("@earendil-works/pi-coding-agent").AgentToolUpdateCallback;
-}
-
-/**
- * Execute the graph use-case.
- *
- * Resolves the target and collects all requested relations. The caller
- * (tool executor) has already validated params, expanded targetId, and
- * gated on capability availability.
- */
-export async function executeGraph(input: GraphInput, deps: GraphDeps): Promise<CodeIntelResult> {
-  const requestedRelations = input.relations ?? DEFAULT_RELATIONS;
-  const relations = expandAllRelations(requestedRelations);
-
-  // Semantic readiness — degrades per-relation rather than blocking.
-  const requestedSemantic = relations.some((r) => SEMANTIC_RELATIONS.includes(r));
-  let semanticReadinessError: string | null = null;
-  if (requestedSemantic) {
-    const readiness = await ensureSemanticReadiness(
-      deps.cwd,
-      input.file ? { kind: "file", file: input.file } : { kind: "workspace" },
-    );
-    if (readiness.kind === "timeout") {
-      semanticReadinessError = renderSemanticReadinessTimeout("code_graph", 15_000);
-    } else if (readiness.kind === "unavailable") {
-      semanticReadinessError =
-        "No analysis provider is available for this workspace. Check `code_health` for LSP and tree-sitter status.";
-    }
-  }
-
-  const allFileLevel =
-    relations.length > 0 && relations.every((r) => FILE_LEVEL_RELATIONS.includes(r));
-
-  // Resolve target
-  const target = await resolveGraphTarget(input, deps, allFileLevel);
-  if ("content" in target) return target;
-
-  const { resolvedFile, resolvedPosition, displayName, resolvedAnchorKind } = target;
-  const resolvedDisplayFile = toDisplayPath(deps.cwd, resolvedFile);
-
-  // Collect results per relation
-  const sections = [];
-  const maxResults = input.maxResults ?? 8;
-
-  emitToolProgress(deps.onUpdate, `code_graph: collecting ${relations.length} relation(s)...`);
-
-  for (const rel of relations) {
-    if (relations.length > 1) {
-      emitToolProgress(deps.onUpdate, `code_graph: ${rel}...`);
-    }
-    const opts: CollectRelationOptions = {
-      file: resolvedFile,
-      position: resolvedPosition,
-      displayName,
-      cwd: deps.cwd,
-      provider: deps.provider,
-      maxResults,
-      semanticReadinessError,
-      anchorKind: resolvedAnchorKind,
-      calleeDepth: input.calleeDepth,
-    };
-    const section = await collectRelation(rel, opts);
-    sections.push(section);
-  }
-
-  // Render combined output
-  return buildGraphResult(displayName, sections, resolvedDisplayFile, input.scope);
-}
-
-// ── Target resolution ─────────────────────────────────────────────────
-
-interface ResolvedGraphTarget {
-  resolvedFile: string;
-  resolvedPosition: { line: number; character: number };
-  displayName: string;
-  resolvedAnchorKind: AnchorKind;
-}
-
-async function resolveGraphTarget(
-  input: GraphInput,
-  deps: GraphDeps,
-  allFileLevel: boolean,
-): Promise<ResolvedGraphTarget | CodeIntelResult> {
-  if (allFileLevel) {
-    return resolveFileLevelTarget(input, deps);
-  }
-  return resolvePositionAnchoredTarget(input, deps);
-}
-
-async function resolveFileLevelTarget(
-  input: GraphInput,
-  deps: GraphDeps,
-): Promise<ResolvedGraphTarget | CodeIntelResult> {
-  if (input.file) {
-    return {
-      resolvedFile: input.file,
-      resolvedPosition: { line: 1, character: 1 },
-      displayName: toDisplayPath(deps.cwd, input.file),
-      resolvedAnchorKind: "name",
-    };
-  }
-
-  if (input.symbol) {
-    const target = await resolveTarget(
-      { symbol: input.symbol, path: input.scope },
-      deps.cwd,
-      deps.provider ?? undefined,
-    );
-    if (typeof target === "string") return searchErrorResult(target);
-    if ("targets" in target) {
-      return searchErrorResult(
-        "**Error:** `code_graph` requires a precise target for file-level relations. Use `file` or `targetId` from `code_resolve`.",
-      );
-    }
-    return {
-      resolvedFile: target.file,
-      resolvedPosition: { line: 1, character: 1 },
-      displayName: toDisplayPath(deps.cwd, target.file),
-      resolvedAnchorKind: "name",
-    };
-  }
-
-  if (input.scope) {
-    return searchErrorResult(
-      "**Error:** `code_graph` file-level relations require a `file` or `symbol`, not just `scope`.",
-    );
-  }
-
-  return searchErrorResult("**Error:** `code_graph` requires a target for file-level relations.");
-}
-
-async function resolvePositionAnchoredTarget(
-  input: GraphInput,
-  deps: GraphDeps,
-): Promise<ResolvedGraphTarget | CodeIntelResult> {
-  const target = await resolveTarget(
-    {
-      file: input.file,
-      line: input.line,
-      character: input.character,
-      symbol: input.symbol,
-      path: input.scope,
-    },
-    deps.cwd,
-    deps.provider ?? undefined,
-  );
-  if (typeof target === "string") return searchErrorResult(target);
-
-  if ("targets" in target) {
-    return searchErrorResult(
-      "**Error:** `code_graph` requires a precise target. Use anchored coordinates (`file`, `line`, `character`), `symbol`, or pass a `targetId` from `code_resolve`.",
-    );
-  }
-
-  const resolvedAnchorKind = input._expandedAnchorKind ?? target.anchorKind;
-  const displayName =
-    input._expandedName ??
-    target.name ??
-    `symbol at ${toDisplayPath(deps.cwd, target.file)}:${target.displayLine}`;
-
-  return {
-    resolvedFile: target.file,
-    resolvedPosition: target.position,
-    displayName,
-    resolvedAnchorKind,
-  };
-}
-
-// ── Result assembly ───────────────────────────────────────────────────
-
-function buildGraphResult(
-  displayName: string,
-  sections: Awaited<ReturnType<typeof collectRelation>>[],
-  resolvedDisplayFile: string,
-  scope: string | undefined,
-): CodeIntelResult {
-  const assembly = assembleGraphResult({
-    displayName,
-    sections,
-    resolvedDisplayFile,
-    scope,
-  });
-  const content = renderGraphResult(assembly);
-
-  return {
-    content,
-    details: {
-      type: "search",
-      data: assembly.details,
-    },
-  };
-}
-
-// ── Helpers ───────────────────────────────────────────────────────────
-
-function expandAllRelations(relations: GraphRelation[]): GraphRelation[] {
-  if (!relations.includes("all")) {
-    return relations;
-  }
-  return ["references", "callees", "imports", "exports", "implements", "tests"];
-}

package/src/tool/health/orchestrate.ts

@@ -1,151 +0,0 @@
-/**
- * Health orchestration use-case — gathers workspace health data and
- * returns a rendered CodeIntelResult with structured details.
- *
- * Thin dispatcher: collects all requested sections, assembles the
- * HealthData object, and delegates rendering to the markdown module.
- * Section-specific collection lives in ./sections/.
- */
-
-import type { AgentToolUpdateCallback } from "@earendil-works/pi-coding-agent";
-import type { CapabilityState } from "@mrclrchtr/supi-code-runtime/api";
-import type { SessionLspServiceState } from "@mrclrchtr/supi-lsp/api";
-import {
-  evaluateCoverageWarnings,
-  gatherCoverageEvalInput,
-} from "../../analysis/coverage/coverage-warnings.ts";
-import { loadPrioritizationSignals } from "../../analysis/signals/project.ts";
-import type { CodeIntelResult } from "../../types/index.ts";
-import { assembleHealthResult, type HealthData, type HealthSection } from "../result/health.ts";
-import { renderHealthResult } from "./markdown.ts";
-import { collectCodeActions, collectDiagnostics } from "./sections/diagnostics.ts";
-import {
-  buildHealthEvidenceLists,
-  describeStructuralState,
-  maybeRecover,
-} from "./sections/recovery.ts";
-import {
-  collectCoverageSection,
-  collectGitContext,
-  collectServers,
-  collectUnusedSection,
-  needsPrioritizationSignals,
-} from "./sections/signals.ts";
-
-export interface HealthInput {
-  scope?: string;
-  refresh?: boolean;
-  include?: string[];
-  level?: "summary" | "detailed";
-  coveragePath?: string;
-  unusedPath?: string;
-}
-
-export interface HealthDeps {
-  cwd: string;
-  lspState: SessionLspServiceState;
-  providerAvailable: boolean;
-  semanticStateKind: "pending" | "ready" | "inactive" | "disabled" | "unavailable";
-  structuralState: CapabilityState;
-  lspController: import("@mrclrchtr/supi-lsp/api").LspRuntimeController | null;
-  onUpdate?: AgentToolUpdateCallback;
-  scopeFilter: string | null;
-  lastRefresh: number | undefined;
-}
-
-const DEFAULT_INCLUDE: HealthSection[] = ["diagnostics", "servers"];
-
-/** Last diagnostic refresh time by workspace path (for staleness banner). */
-const lastRefreshByWorkspace = new Map<string, number>();
-
-/** Track a diagnostic refresh for the given workspace. */
-export function trackHealthRefresh(cwd: string): void {
-  lastRefreshByWorkspace.set(cwd, Date.now());
-}
-
-/** Get the last refresh time for a workspace. */
-export function getLastHealthRefresh(cwd: string): number | undefined {
-  return lastRefreshByWorkspace.get(cwd);
-}
-
-/**
- * Execute the health gathering use-case.
- */
-export async function executeHealth(
-  input: HealthInput,
-  deps: HealthDeps,
-): Promise<CodeIntelResult> {
-  const cwd = deps.cwd;
-  const included = (
-    input.include && input.include.length > 0 ? input.include : DEFAULT_INCLUDE
-  ) as HealthSection[];
-  const level = input.level ?? "summary";
-
-  const service = deps.lspState.kind === "ready" ? deps.lspState.service : null;
-
-  const { recovered, lspStatus } = await maybeRecover({
-    service,
-    refresh: input.refresh,
-    lspState: deps.lspState,
-    semanticStateKind: deps.semanticStateKind,
-    onUpdate: deps.onUpdate,
-  });
-  const structuralStatus = describeStructuralState(deps.structuralState);
-
-  const diagnostics = await collectDiagnostics(service, included, deps.scopeFilter, cwd);
-  const servers = collectServers(service, included);
-  const gitContext = collectGitContext(included, cwd);
-  const prioritizationSignals = needsPrioritizationSignals(included)
-    ? loadPrioritizationSignals(cwd, deps.lspState, {
-        coveragePath: input.coveragePath,
-        unusedPath: input.unusedPath,
-      })
-    : null;
-  const coverage = included.includes("coverage")
-    ? collectCoverageSection(prioritizationSignals, cwd, deps.scopeFilter, input.coveragePath)
-    : null;
-  const unused = included.includes("unused")
-    ? collectUnusedSection(prioritizationSignals, cwd, deps.scopeFilter, input.unusedPath)
-    : null;
-
-  const codeActions =
-    level === "detailed" && included.includes("diagnostics")
-      ? await collectCodeActions(service, deps.scopeFilter, cwd)
-      : null;
-
-  const degradedCoverage = evaluateCoverageWarnings(
-    gatherCoverageEvalInput(cwd, deps.lspController),
-  );
-
-  const diagnosticAgeSeconds =
-    deps.lastRefresh != null ? Math.round((Date.now() - deps.lastRefresh) / 1000) : undefined;
-
-  const data: HealthData = {
-    includedSections: included,
-    lspAvailable: service !== null,
-    lspStatus,
-    recovered,
-    structuralStatus,
-    diagnostics,
-    servers,
-    gitContext,
-    scopeFilter: input.scope ? deps.scopeFilter : null,
-    level,
-    codeActions,
-    coverage,
-    unused,
-    degradedCoverage: degradedCoverage.hasWarnings ? degradedCoverage : undefined,
-    diagnosticAgeSeconds,
-  };
-
-  const assembly = assembleHealthResult(data, buildHealthEvidenceLists(gitContext));
-  const content = renderHealthResult(assembly, cwd);
-
-  return {
-    content,
-    details: {
-      type: "health",
-      data: assembly.details,
-    },
-  };
-}

package/src/tool/health/sections/diagnostics.ts

@@ -1,182 +0,0 @@
-// Diagnostics collection and code-action gathering for code_health.
-// Extracted from orchestrate.ts.
-
-import { existsSync, statSync } from "node:fs";
-import { resolve } from "node:path";
-import { isWithinOrEqual } from "@mrclrchtr/supi-core/api";
-import type { SessionLspService } from "@mrclrchtr/supi-lsp/api";
-import type { CodeActionSuggestion, HealthData } from "../markdown.ts";
-
-// ── Diagnostics ───────────────────────────────────────────────────────
-
-export function isScopedFile(scopeFilter: string | null): scopeFilter is string {
-  return scopeFilter !== null && existsSync(scopeFilter) && !isDirectory(scopeFilter);
-}
-
-export async function collectDiagnostics(
-  service: SessionLspService | null,
-  included: string[],
-  scopeFilter: string | null,
-  cwd: string,
-): Promise<HealthData["diagnostics"]> {
-  if (!included.includes("diagnostics") || !service) return [];
-
-  if (isScopedFile(scopeFilter)) {
-    return collectScopedFileDiagnostics(service, scopeFilter);
-  }
-
-  return collectWorkspaceDiagnostics(service, scopeFilter, cwd);
-}
-
-async function collectScopedFileDiagnostics(
-  service: SessionLspService,
-  scopeFilter: string,
-): Promise<HealthData["diagnostics"]> {
-  const diags = await service.fileDiagnostics(scopeFilter, 4);
-  if (!diags || diags.length === 0) {
-    return [];
-  }
-
-  const errors = diags.filter((d) => (d.severity ?? 1) === 1).length;
-  const warnings = diags.filter((d) => (d.severity ?? 1) === 2).length;
-  if (!hasIssueCounts(errors, warnings)) {
-    return [];
-  }
-
-  return [{ file: scopeFilter, errors, warnings }];
-}
-
-function collectWorkspaceDiagnostics(
-  service: SessionLspService,
-  scopeFilter: string | null,
-  cwd: string,
-): HealthData["diagnostics"] {
-  const summary = service.getWorkspaceDiagnosticSummary();
-  const result: HealthData["diagnostics"] = [];
-
-  for (const entry of summary) {
-    const filePath = resolve(cwd, entry.file);
-    if (scopeFilter && !isWithinOrEqual(scopeFilter, filePath)) continue;
-    if (!hasIssueCounts(entry.errors, entry.warnings)) continue;
-    result.push({ file: filePath, errors: entry.errors, warnings: entry.warnings });
-  }
-
-  return result;
-}
-
-function hasIssueCounts(errors: number, warnings: number): boolean {
-  return errors > 0 || warnings > 0;
-}
-
-// ── Code actions ──────────────────────────────────────────────────────
-
-/** Max files to query for code actions in detailed health mode. */
-const MAX_CODE_ACTION_FILES = 5;
-/** Max total code action suggestions to return. */
-const MAX_CODE_ACTION_SUGGESTIONS = 10;
-
-export async function collectCodeActions(
-  service: SessionLspService | null,
-  scopeFilter: string | null,
-  cwd: string,
-): Promise<CodeActionSuggestion[]> {
-  if (!service) return [];
-
-  try {
-    const outstanding = service.getOutstandingDiagnostics(1);
-    const suggestions = await collectFromOutstanding(service, outstanding, scopeFilter, cwd);
-    return suggestions.slice(0, MAX_CODE_ACTION_SUGGESTIONS);
-  } catch {
-    return [];
-  }
-}
-
-async function collectFromOutstanding(
-  service: SessionLspService,
-  outstanding: ReturnType<SessionLspService["getOutstandingDiagnostics"]>,
-  scopeFilter: string | null,
-  cwd: string,
-): Promise<CodeActionSuggestion[]> {
-  const suggestions: CodeActionSuggestion[] = [];
-  let filesQueried = 0;
-
-  for (const entry of outstanding) {
-    if (suggestions.length >= MAX_CODE_ACTION_SUGGESTIONS) break;
-    if (filesQueried >= MAX_CODE_ACTION_FILES) break;
-    if (scopeFilter && !isWithinScope(scopeFilter, entry.file, cwd)) continue;
-
-    const newSuggestions = await collectFileCodeActions(service, entry);
-    if (newSuggestions.length === 0) continue;
-
-    filesQueried++;
-    mergeSuggestions(suggestions, newSuggestions);
-  }
-
-  return suggestions;
-}
-
-function mergeSuggestions(
-  existing: CodeActionSuggestion[],
-  incoming: CodeActionSuggestion[],
-): void {
-  const seen = new Set(existing.map((s) => `${s.file}:${s.title}`));
-  for (const s of incoming) {
-    const key = `${s.file}:${s.title}`;
-    if (!seen.has(key)) {
-      seen.add(key);
-      existing.push(s);
-    }
-  }
-}
-
-async function collectFileCodeActions(
-  service: SessionLspService,
-  entry: {
-    file: string;
-    diagnostics: Array<{
-      severity?: number;
-      range: {
-        start: { line: number; character: number };
-        end: { line: number; character: number };
-      };
-    }>;
-  },
-): Promise<CodeActionSuggestion[]> {
-  const errorDiag = entry.diagnostics.find((d) => (d.severity ?? 1) <= 1);
-  if (!errorDiag) return [];
-
-  try {
-    const actions = await service.codeActions(entry.file, {
-      line: errorDiag.range.start.line,
-      character: errorDiag.range.start.character,
-    });
-    if (!actions || actions.length === 0) return [];
-
-    const result: CodeActionSuggestion[] = [];
-    for (const a of actions) {
-      if (!a.title) continue;
-      result.push({
-        file: entry.file,
-        line: errorDiag.range.start.line + 1,
-        title: a.title,
-        kind: a.kind ?? undefined,
-      });
-    }
-    return result;
-  } catch {
-    return [];
-  }
-}
-
-function isWithinScope(scopeFilter: string, file: string, cwd: string): boolean {
-  const absPath = resolve(cwd, file);
-  return isWithinOrEqual(scopeFilter, absPath);
-}
-
-export function isDirectory(filePath: string): boolean {
-  try {
-    return statSync(filePath).isDirectory();
-  } catch {
-    return false;
-  }
-}

package/src/tool/health/sections/recovery.ts

@@ -1,89 +0,0 @@
-// Recovery, state description, and evidence helpers for code_health.
-// Extracted from orchestrate.ts.
-
-import type { AgentToolUpdateCallback } from "@earendil-works/pi-coding-agent";
-import type { CapabilityState } from "@mrclrchtr/supi-code-runtime/api";
-import type { SessionLspService, SessionLspServiceState } from "@mrclrchtr/supi-lsp/api";
-import { createEvidenceList, type EvidenceListMetadata } from "../../../analysis/evidence.ts";
-import type { GitContext } from "../../../analysis/signals/git.ts";
-import { emitToolProgress } from "../../infra/progress.ts";
-
-// ── Recovery ──────────────────────────────────────────────────────────
-
-interface RecoverOptions {
-  service: SessionLspService | null;
-  refresh: boolean | undefined;
-  lspState: SessionLspServiceState;
-  semanticStateKind?: "pending" | "ready" | "inactive" | "disabled" | "unavailable";
-  onUpdate?: AgentToolUpdateCallback;
-}
-
-export async function maybeRecover(
-  opts: RecoverOptions,
-): Promise<{ recovered: boolean; lspStatus: string }> {
-  const { service, refresh, lspState, semanticStateKind, onUpdate } = opts;
-  let recovered = false;
-  let lspStatus = semanticStateKind === "pending" ? "warming…" : describeLspState(lspState);
-
-  if (refresh && service) {
-    emitToolProgress(onUpdate, "code_health: refreshing diagnostics (may restart LSP)...");
-    try {
-      await service.recoverDiagnostics({ restartIfStillStale: true });
-      recovered = true;
-      lspStatus = "ready (recovered)";
-    } catch {
-      // Recovery failed but we continue
-    }
-  }
-
-  return { recovered, lspStatus };
-}
-
-// ── Evidence lists ────────────────────────────────────────────────────
-
-export function buildHealthEvidenceLists(gitContext: GitContext | null): EvidenceListMetadata[] {
-  if (!gitContext) return [];
-  return [
-    createEvidenceList({
-      key: "health.dirtyFiles",
-      items: gitContext.dirtyFiles,
-      maxResults: 5,
-    }).metadata,
-  ];
-}
-
-// ── State description helpers ─────────────────────────────────────────
-
-export function describeLspState(state: SessionLspServiceState): string {
-  switch (state.kind) {
-    case "ready":
-      return "ready";
-    case "pending":
-      return "starting…";
-    case "inactive":
-      return "inactive on current session branch";
-    case "disabled":
-      return "disabled by configuration";
-    case "unavailable":
-      return `unavailable — ${state.reason}`;
-    default:
-      return "unknown state";
-  }
-}
-
-export function describeStructuralState(state: CapabilityState): string {
-  switch (state.kind) {
-    case "ready":
-      return "ready";
-    case "pending":
-      return "starting…";
-    case "inactive":
-      return "inactive";
-    case "disabled":
-      return "disabled by configuration";
-    case "unavailable":
-      return `unavailable — ${state.reason}`;
-    default:
-      return "unknown state";
-  }
-}