@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/src/analysis/signals/project.ts

@@ -1,189 +0,0 @@
-import * as path from "node:path";
-import { readJsonFile } from "@mrclrchtr/supi-core/config";
-import type { SessionLspServiceState } from "@mrclrchtr/supi-lsp/api";
-
-export interface PrioritySignalsSummary {
-  diagnosticsCount: number;
-  lowCoverageCount: number;
-  unusedCount: number;
-  warnings: string[];
-}
-
-export interface LoadedSignals {
-  diagnostics: Array<{ file: string; total: number; errors: number; warnings: number }>;
-  coverageByFile: Map<string, number>;
-  unusedFiles: Set<string>;
-  unusedExports: Array<{ file: string; name: string }>;
-}
-
-export interface LoadPrioritizationSignalsOptions {
-  coveragePath?: string;
-  unusedPath?: string;
-}
-
-export function summarizePrioritySignalsForFiles(
-  cwd: string,
-  files: Iterable<string>,
-  lspService: SessionLspServiceState,
-): PrioritySignalsSummary | null {
-  const loaded = loadPrioritizationSignals(cwd, lspService);
-  const relevantFiles = new Set([...files].map((file) => path.resolve(cwd, file)));
-  if (relevantFiles.size === 0) return null;
-
-  const warnings: string[] = [];
-
-  const matchingDiagnostics = loaded.diagnostics.filter((entry) =>
-    relevantFiles.has(path.resolve(entry.file)),
-  );
-  const diagnosticsCount = matchingDiagnostics.reduce((sum, entry) => sum + entry.total, 0);
-  for (const entry of matchingDiagnostics.slice(0, 3)) {
-    warnings.push(
-      `Diagnostics: \`${path.relative(cwd, entry.file)}\` (${entry.total} total${entry.errors > 0 ? `, ${entry.errors} errors` : ""}${entry.warnings > 0 ? `, ${entry.warnings} warnings` : ""})`,
-    );
-  }
-
-  const lowCoverage = [...loaded.coverageByFile.entries()]
-    .filter(([file, pct]) => relevantFiles.has(path.resolve(file)) && pct < 50)
-    .sort((a, b) => a[1] - b[1]);
-  for (const [file, pct] of lowCoverage.slice(0, 3)) {
-    warnings.push(`Low coverage: \`${path.relative(cwd, file)}\` (${pct.toFixed(0)}%)`);
-  }
-
-  const unusedFileMatches = [...loaded.unusedFiles]
-    .filter((file) => relevantFiles.has(path.resolve(file)))
-    .sort((a, b) => a.localeCompare(b));
-  for (const file of unusedFileMatches.slice(0, 3)) {
-    warnings.push(`Unused file: \`${path.relative(cwd, file)}\``);
-  }
-
-  const unusedExportMatches = loaded.unusedExports
-    .filter((entry) => relevantFiles.has(path.resolve(entry.file)))
-    .sort((a, b) => a.name.localeCompare(b.name));
-  for (const entry of unusedExportMatches.slice(0, 3)) {
-    warnings.push(`Unused export: \`${entry.name}\` in \`${path.relative(cwd, entry.file)}\``);
-  }
-
-  const summary: PrioritySignalsSummary = {
-    diagnosticsCount,
-    lowCoverageCount: lowCoverage.length,
-    unusedCount: unusedFileMatches.length + unusedExportMatches.length,
-    warnings,
-  };
-
-  return summary.diagnosticsCount > 0 || summary.lowCoverageCount > 0 || summary.unusedCount > 0
-    ? summary
-    : null;
-}
-
-export function loadPrioritizationSignals(
-  cwd: string,
-  lspService: SessionLspServiceState,
-  options: LoadPrioritizationSignalsOptions = {},
-): LoadedSignals {
-  return {
-    diagnostics: loadDiagnostics(cwd, lspService),
-    coverageByFile: loadCoverageSummary(cwd, options.coveragePath),
-    unusedFiles: loadUnusedFiles(cwd, options.unusedPath),
-    unusedExports: loadUnusedExports(cwd, options.unusedPath),
-  };
-}
-
-export function appendPrioritySignalsSection(
-  lines: string[],
-  summary: PrioritySignalsSummary | null,
-): void {
-  if (!summary || summary.warnings.length === 0) return;
-  lines.push("## Priority Signals");
-  for (const warning of summary.warnings.slice(0, 6)) {
-    lines.push(`- ${warning}`);
-  }
-  lines.push("");
-}
-
-function loadDiagnostics(
-  cwd: string,
-  lspService: SessionLspServiceState,
-): Array<{ file: string; total: number; errors: number; warnings: number }> {
-  if (lspService.kind !== "ready") return [];
-  if (typeof lspService.service.getOutstandingDiagnosticSummary !== "function") return [];
-
-  return lspService.service.getOutstandingDiagnosticSummary(2).map((entry) => ({
-    file: path.resolve(cwd, entry.file),
-    total: entry.total,
-    errors: entry.errors,
-    warnings: entry.warnings,
-  }));
-}
-
-function loadCoverageSummary(cwd: string, coveragePathInput?: string): Map<string, number> {
-  const coveragePath = path.resolve(cwd, coveragePathInput ?? "coverage/coverage-summary.json");
-  const parsed = readJsonFile(coveragePath);
-  if (!parsed) return new Map();
-
-  const map = new Map<string, number>();
-  for (const [file, value] of Object.entries(parsed)) {
-    if (file === "total" || typeof value !== "object" || value === null) continue;
-    const linesPct = getPct(value, "lines");
-    const statementsPct = getPct(value, "statements");
-    const pct = Math.min(linesPct ?? 100, statementsPct ?? 100);
-    map.set(path.resolve(cwd, file), pct);
-  }
-  return map;
-}
-
-function loadUnusedFiles(cwd: string, unusedPath?: string): Set<string> {
-  const parsed = loadKnipJson(cwd, unusedPath);
-  const values = Array.isArray(parsed?.files) ? parsed.files : [];
-  const files = values
-    .map((value) => toPathString(value))
-    .filter((value): value is string => Boolean(value))
-    .map((file) => path.resolve(cwd, file));
-  return new Set(files);
-}
-
-function loadUnusedExports(
-  cwd: string,
-  unusedPath?: string,
-): Array<{ file: string; name: string }> {
-  const parsed = loadKnipJson(cwd, unusedPath);
-  const values = Array.isArray(parsed?.exports) ? parsed.exports : [];
-  const exports: Array<{ file: string; name: string }> = [];
-
-  for (const value of values) {
-    if (typeof value === "string") {
-      exports.push({ file: path.resolve(cwd, value), name: path.basename(value) });
-      continue;
-    }
-    if (typeof value !== "object" || value === null) continue;
-    const record = value as Record<string, unknown>;
-    const file = toPathString(record.file) ?? toPathString(record.path);
-    const name = typeof record.name === "string" ? record.name : null;
-    if (file && name) {
-      exports.push({ file: path.resolve(cwd, file), name });
-    }
-  }
-
-  return exports;
-}
-
-function loadKnipJson(cwd: string, unusedPath?: string): Record<string, unknown> | null {
-  return readJsonFile(path.resolve(cwd, unusedPath ?? "knip.json"));
-}
-
-function getPct(value: object, key: string): number | null {
-  const candidate = (value as Record<string, unknown>)[key];
-  if (typeof candidate !== "object" || candidate === null) return null;
-  const pct = (candidate as Record<string, unknown>).pct;
-  return typeof pct === "number" ? pct : null;
-}
-
-function toPathString(value: unknown): string | null {
-  if (typeof value === "string") return value;
-  if (typeof value !== "object" || value === null) return null;
-  const record = value as Record<string, unknown>;
-  return typeof record.file === "string"
-    ? record.file
-    : typeof record.path === "string"
-      ? record.path
-      : null;
-}

package/src/analysis/target/bridge.ts

@@ -1,152 +0,0 @@
-/**
- * Unified target resolution facade through src/analysis/target/*.
- *
- * This is the canonical resolution path. It handles anchored coordinates,
- * file-only, symbol discovery, and disambiguation cases through one path.
- */
-
-import type { SemanticProvider } from "@mrclrchtr/supi-code-runtime/api";
-import { normalizePath } from "../search/ripgrep.ts";
-import { resolveAnchoredSymbolTarget } from "./anchored.ts";
-import { resolveFileTargetGroup as resolveFile } from "./file.ts";
-import { normalizeQuery, type QueryInput } from "./query.ts";
-import { resolveSymbolTarget as resolveSymbol } from "./symbol.ts";
-import type {
-  NormalizedQuery,
-  ResolvedTargetData,
-  ResolvedTargetGroupData,
-  TargetOutcome,
-} from "./types.ts";
-
-export type { QueryInput } from "./query.ts";
-
-/**
- * Resolve a target from action params through one canonical path.
- *
- * Returns either a resolved target, a target group, or an error string.
- */
-export async function resolveTarget(
-  params: QueryInput,
-  cwd: string,
-  semantic?: SemanticProvider,
-): Promise<ResolvedTargetData | ResolvedTargetGroupData | string> {
-  const query = normalizeQuery(params);
-
-  switch (query.kind) {
-    case "anchored":
-      return resolveAnchoredCase(query, cwd, semantic);
-
-    case "file": {
-      const result = await resolveFile(query.file, cwd);
-      if (result.kind === "error") return result.message;
-      return result.group;
-    }
-
-    case "symbol": {
-      if (!semantic) {
-        return "**Error:** Symbol discovery requires active LSP. Use `file` + coordinates, or enable LSP and retry.";
-      }
-      const outcome = await resolveSymbol(query.symbol, cwd, semantic, {
-        path: query.path,
-        kind: query.symbolKind,
-        exportedOnly: query.exportedOnly,
-      });
-      if (outcome.kind === "resolved") return outcome.target;
-      if (outcome.kind === "error") return outcome.message;
-      if (outcome.kind !== "disambiguation") {
-        return "**Error:** Unexpected resolution outcome.";
-      }
-      // Disambiguation — format candidates
-      return formatDisambiguation(query.symbol, outcome);
-    }
-
-    case "invalid":
-      return `**Error:** ${query.reason}`;
-  }
-}
-
-/**
- * Anchored case: route file + line + character through the same provider-backed
- * symbol resolver as `code_resolve`/`code_orientation` (resolveAnchoredSymbolTarget),
- * so `code_graph`/`code_impact` resolve real symbol targets (exact identifier
- * hit or declaration-header snap) instead of anonymous point targets.
- * Per ADR 0003 — no silent `name:null` point targets.
- */
-async function resolveAnchoredCase(
-  query: Extract<NormalizedQuery, { kind: "anchored" }>,
-  cwd: string,
-  semantic: SemanticProvider | undefined,
-): Promise<ResolvedTargetData | string> {
-  const resolvedFile = normalizePath(query.file, cwd);
-  const result = await resolveAnchoredSymbolTarget(
-    resolvedFile,
-    query.line,
-    query.character,
-    semantic ?? null,
-  );
-  if (result.kind === "error") return result.message;
-  if (result.kind === "resolved") return result.target;
-  if (result.kind === "disambiguation") {
-    return formatAnchoredDisambiguation(query.file, query.line, query.character, result);
-  }
-  return "**Error:** Unexpected resolution outcome.";
-}
-
-function formatDisambiguation(
-  symbol: string,
-  result: Extract<TargetOutcome, { kind: "disambiguation" }>,
-): string {
-  const lines: string[] = [];
-  lines.push(`# Disambiguation needed for \`${symbol}\``);
-  lines.push("");
-  const omitNote = result.omittedCount > 0 ? ` (+${result.omittedCount} more)` : "";
-  lines.push(
-    `Found ${result.candidates.length} candidates${omitNote}. Rerun with anchored coordinates:`,
-  );
-  lines.push("");
-
-  for (const c of result.candidates) {
-    const kind = c.kind ? ` (${c.kind})` : "";
-    const container = c.container ? ` in ${c.container}` : "";
-    lines.push(
-      `${c.rank}. **${c.name}**${kind}${container} — \`${c.file}\`:${c.line}:${c.character}`,
-    );
-  }
-
-  lines.push("");
-  if (result.candidates.length > 0) {
-    const first = result.candidates[0];
-    lines.push(
-      `Example: rerun with \`file: "${first.file}"\`, \`line: ${first.line}\`, and \`character: ${first.character}\`.`,
-    );
-  }
-
-  return lines.join("\n");
-}
-
-/** Format anchored-coordinate disambiguation (multiple symbols match one coordinate). */
-function formatAnchoredDisambiguation(
-  file: string,
-  line: number,
-  character: number,
-  result: Extract<TargetOutcome, { kind: "disambiguation" }>,
-): string {
-  const lines: string[] = [];
-  lines.push(`# Disambiguation needed at \`${file}:${line}:${character}\``);
-  lines.push("");
-  const omitNote = result.omittedCount > 0 ? ` (+${result.omittedCount} more)` : "";
-  lines.push(
-    `Found ${result.candidates.length} symbol candidates at this coordinate${omitNote}. Use \`code_resolve\` to pick one:`,
-  );
-  lines.push("");
-
-  for (const c of result.candidates) {
-    const kind = c.kind ? ` (${c.kind})` : "";
-    const container = c.container ? ` in ${c.container}` : "";
-    lines.push(
-      `${c.rank}. **${c.name}**${kind}${container} — \`${c.file}\`:${c.line}:${c.character}`,
-    );
-  }
-
-  return lines.join("\n");
-}

package/src/analysis/target/file-resolution.ts

@@ -1,125 +0,0 @@
-/**
- * File-level resolution logic for code_resolve.
- *
- * Extracted from resolve/service.ts. Handles file-only resolution and
- * path-like query resolution for the code_resolve tool.
- */
-
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import type { WorkspaceCodeIntelligenceSession } from "../../session/session.ts";
-import type { CodeProvider } from "../provider.ts";
-import { normalizePath } from "../search/ripgrep.ts";
-import { resolveFileTargetGroup as resolveFile } from "./file.ts";
-import {
-  type ResolveServiceParams,
-  type ResolveServiceResult,
-  registerFromTarget,
-} from "./resolve-common.ts";
-
-/** Resolve file-only (no coordinates) input. */
-export async function resolveFileOnlyInput(
-  params: ResolveServiceParams,
-  session: WorkspaceCodeIntelligenceSession,
-  maxResults: number,
-  provider: CodeProvider | null,
-): Promise<ResolveServiceResult> {
-  const cwd = session.cwd;
-  const file = params.file;
-  if (!file) {
-    return { kind: "error", message: "**Error:** File required for file-level resolution." };
-  }
-  const resolvedFile = normalizePath(file, cwd);
-  if (!existsSync(resolvedFile)) {
-    return { kind: "error", message: `**Error:** File not found: \`${file}\`` };
-  }
-  const outcome = await resolveFile(file, cwd, {
-    semantic: provider ?? undefined,
-    structural: provider ?? undefined,
-  });
-  if (outcome.kind === "error") {
-    return { kind: "error", message: outcome.message };
-  }
-  const targets = outcome.group.targets
-    .slice(0, maxResults)
-    .map((t) =>
-      registerFromTarget({ ...t, position: t.position, confidence: t.confidence }, session, "file"),
-    );
-  return {
-    kind: "resolved",
-    targets,
-    confidence: outcome.group.confidence,
-    omittedCount: Math.max(0, outcome.group.targets.length - maxResults),
-    nextQueries: [
-      "Use `targetId` with `code_graph` for reference tracking",
-      "Use `targetId` with `code_impact` for blast radius",
-    ],
-  };
-}
-
-/** Handle a path-like query with kind: "file". */
-export async function resolvePathQuery(
-  query: string,
-  session: WorkspaceCodeIntelligenceSession,
-  maxResults: number,
-  provider: CodeProvider | null,
-): Promise<ResolveServiceResult | null> {
-  const cwd = session.cwd;
-  const candidatePath = resolvePathLikeQuery(query, cwd);
-  if (!candidatePath) return null;
-  const outcome = await resolveFile(candidatePath, cwd, {
-    semantic: provider ?? undefined,
-    structural: provider ?? undefined,
-  });
-  if (outcome.kind === "error") return null;
-  const targets = outcome.group.targets
-    .slice(0, maxResults)
-    .map((t) =>
-      registerFromTarget({ ...t, position: t.position, confidence: t.confidence }, session, "file"),
-    );
-  return {
-    kind: "resolved",
-    targets,
-    confidence: outcome.group.confidence,
-    omittedCount: Math.max(0, outcome.group.targets.length - maxResults),
-    nextQueries: [
-      "Use `targetId` with `code_graph` for reference tracking",
-      "Use `targetId` with `code_impact` for blast radius",
-    ],
-  };
-}
-
-/** Attempt file-level resolution when query looks like a file path. */
-export async function tryPathLikeQuery(
-  params: ResolveServiceParams,
-  session: WorkspaceCodeIntelligenceSession,
-  maxResults: number,
-  provider: CodeProvider | null,
-): Promise<ResolveServiceResult | null> {
-  if (params.kind !== "file" && params.kind !== "File") return null;
-  const query = params.query;
-  if (!query || !isPathLike(query)) return null;
-  return resolvePathQuery(query, session, maxResults, provider);
-}
-
-export function isPathLike(query: string): boolean {
-  return (
-    query.includes("/") || query.includes("\\") || query.endsWith(".ts") || query.endsWith(".js")
-  );
-}
-
-/**
- * Attempt to resolve a path-like query string to an absolute file path.
- * Returns null if the path cannot be resolved to an existing file.
- */
-export function resolvePathLikeQuery(query: string, cwd: string): string | null {
-  const candidate = resolve(cwd, query);
-  if (existsSync(candidate)) {
-    return candidate;
-  }
-  for (const ext of [".ts", ".tsx", ".js", ".jsx", ".json", ".md"]) {
-    const withExt = candidate + ext;
-    if (existsSync(withExt)) return withExt;
-  }
-  return null;
-}

package/src/analysis/target/planner.ts

@@ -1,92 +0,0 @@
-/**
- * Central planner for code-intelligence tool routing.
- *
- * Reads capability state from the shared workspace broker and returns
- * routing decisions for each tool intent. Keeps the execution strategy
- * explicit and centralized instead of scattering capability checks
- * across per-tool execute files.
- *
- * This is the canonical planner — src/planner/planner.ts becomes a
- * thin forwarder to here.
- */
-
-import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
-import type { CodeIntelligenceToolName, PlannerRoute } from "../../types/index.ts";
-
-interface RouteAvailability {
-  semanticAvailable: boolean;
-  structuralAvailable: boolean;
-  refactorAvailable: boolean;
-}
-
-function readAvailability(cwd: string): RouteAvailability {
-  const runtime = getDefaultWorkspaceRuntime();
-  const workspace = runtime.getWorkspace(cwd);
-  return {
-    semanticAvailable:
-      (workspace.semantic.state.kind === "ready" || workspace.semantic.state.kind === "pending") &&
-      workspace.semantic.provider !== null,
-    structuralAvailable:
-      workspace.structural.state.kind === "ready" && workspace.structural.provider !== null,
-    refactorAvailable: workspace.semantic.refactorAvailable,
-  };
-}
-
-function withPreferred(
-  availability: RouteAvailability,
-  preferred: PlannerRoute["preferred"],
-): PlannerRoute {
-  return { ...availability, preferred };
-}
-
-function semanticOnly(availability: RouteAvailability): PlannerRoute["preferred"] {
-  return availability.semanticAvailable ? "semantic" : "unavailable";
-}
-
-function briefPreferred(availability: RouteAvailability): PlannerRoute["preferred"] {
-  if (availability.semanticAvailable) return "semantic";
-  if (availability.structuralAvailable) return "structural";
-  return "unavailable";
-}
-
-/**
- * Get the routing decision for a tool intent in a workspace.
- */
-export function routeFor(cwd: string, tool: CodeIntelligenceToolName): PlannerRoute {
-  const availability = readAvailability(cwd);
-
-  if (tool === "code_graph") {
-    // code_graph dispatches per-relation at execution time. Return the best
-    // available preference; the executor handles per-relation unavailability.
-    if (availability.semanticAvailable) return withPreferred(availability, "semantic");
-    if (availability.structuralAvailable) return withPreferred(availability, "structural");
-    return withPreferred(availability, "unavailable");
-  }
-
-  if (tool === "code_orientation" || tool === "code_inspect") {
-    return withPreferred(availability, briefPreferred(availability));
-  }
-
-  if (tool === "code_impact") {
-    return withPreferred(availability, semanticOnly(availability));
-  }
-
-  if (tool === "code_refactor_plan") {
-    return withPreferred(availability, availability.refactorAvailable ? "semantic" : "unavailable");
-  }
-
-  if (tool === "code_refactor_apply") {
-    // Plan application does not require a live semantic provider — validity
-    // is enforced through fingerprint comparison in the executor.
-    // Return semantic-preferred so the route check never blocks valid plans.
-    return withPreferred(availability, "semantic");
-  }
-
-  if (tool === "code_health") {
-    // code_health reads diagnostics and server state from the LSP service
-    // directly; it does not require live semantic/structural providers.
-    return withPreferred(availability, "search");
-  }
-
-  return withPreferred(availability, briefPreferred(availability));
-}

package/src/analysis/target/query.ts

@@ -1,74 +0,0 @@
-/**
- * Query normalization — converts raw tool/action parameters into a
- * pre-classified {@link NormalizedQuery}.
- *
- * This is the first step in the targeting pipeline. Callers receive
- * a disambiguated query kind so downstream resolvers can dispatch
- * without re-checking input shapes.
- */
-
-import type { NormalizedQuery } from "./types.ts";
-
-export interface QueryInput {
-  path?: string;
-  file?: string;
-  line?: number;
-  character?: number;
-  symbol?: string;
-  kind?: string;
-  exportedOnly?: boolean;
-}
-
-/**
- * Normalize a raw params bag into a typed {@link NormalizedQuery}.
- *
- * Priority order:
- * 1. anchored: file + line + character
- * 2. scoped symbol: file + symbol (without coordinates) — uses file as path scope for symbol discovery
- * 3. file: file without coordinates or symbol
- * 4. symbol: symbol without file
- * 5. invalid: neither file nor symbol
- */
-export function normalizeQuery(input: QueryInput): NormalizedQuery {
-  if (input.file && input.line != null && input.character != null) {
-    return {
-      kind: "anchored",
-      file: input.file,
-      line: input.line,
-      character: input.character,
-    };
-  }
-
-  // Scoped symbol: both file and symbol present, no line/character.
-  // The file acts as a path scope for symbol discovery — resolves to a
-  // precise target within that file rather than a file-level group.
-  if (input.file && input.symbol) {
-    return {
-      kind: "symbol",
-      symbol: input.symbol,
-      path: input.file,
-      symbolKind: input.kind,
-      exportedOnly: input.exportedOnly,
-    };
-  }
-
-  if (input.file) {
-    return { kind: "file", file: input.file };
-  }
-
-  if (input.symbol) {
-    return {
-      kind: "symbol",
-      symbol: input.symbol,
-      path: input.path,
-      symbolKind: input.kind,
-      exportedOnly: input.exportedOnly,
-    };
-  }
-
-  return {
-    kind: "invalid",
-    reason:
-      "Semantic actions require either anchored coordinates (`file`, `line`, `character`) or a `symbol` for discovery.",
-  };
-}