@mrclrchtr/supi-code-intelligence 1.7.0 → 1.9.0

package/src/actions/callers-action.ts

@@ -1,253 +0,0 @@
-// Callers action — find call sites for a symbol.
-
-import * as path from "node:path";
-import { getSemanticService } from "../providers/semantic-provider.ts";
-import type { CodeQueryParams as ActionParams } from "../query-params.ts";
-import { resolveTarget } from "../resolve-target.ts";
-import { filterOutDeclaration, isInProjectPath, uriToFile } from "../search-helpers.ts";
-import {
-  dedupeFileLineRefs,
-  highestConfidence,
-  isResolvedTargetGroup,
-} from "../semantic-action-helpers.ts";
-import type { ResolvedTarget, ResolvedTargetGroup } from "../target-resolution.ts";
-import type { CodeIntelResult, ConfidenceMode, SearchDetails } from "../types.ts";
-
-export async function executeCallersAction(
-  params: ActionParams,
-  cwd: string,
-): Promise<CodeIntelResult> {
-  const target = await resolveTarget(params, cwd);
-  if (typeof target === "string") {
-    return {
-      content: target,
-      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"],
-        },
-      },
-    };
-  }
-
-  if (isResolvedTargetGroup(target)) {
-    return executeFileLevelCallers(target, params, cwd);
-  }
-
-  const result = await collectCallerRefs(target, params, cwd);
-  if (result.refs.length > 0) {
-    const content = formatTargetCallers(
-      `Callers of \`${target.name ?? "symbol"}\``,
-      result,
-      cwd,
-      params,
-    );
-    const details: SearchDetails = {
-      confidence: result.confidence,
-      scope: params.path ?? null,
-      candidateCount: result.candidateCount,
-      omittedCount: result.externalCount,
-      nextQueries: [
-        "`code_affected` for impact analysis",
-        "Use `code_pattern` only when you explicitly want text-search hints",
-      ],
-    };
-    return { content, details: { type: "search" as const, data: details } };
-  }
-
-  if (target.name) {
-    return {
-      content: `No references found for \`${target.name}\` (${result.confidence}).`,
-      details: {
-        type: "search" as const,
-        data: {
-          confidence: result.confidence,
-          scope: params.path ?? null,
-          candidateCount: 0,
-          omittedCount: 0,
-          nextQueries: ["Use `code_affected` before editing a broadly referenced target"],
-        },
-      },
-    };
-  }
-
-  const relPath = path.relative(cwd, target.file);
-  return {
-    content: `No caller data available for ${relPath}:${target.displayLine}:${target.displayCharacter}.`,
-    details: {
-      type: "search" as const,
-      data: {
-        confidence: "unavailable",
-        scope: params.path ?? null,
-        candidateCount: 0,
-        omittedCount: 0,
-        nextQueries: ["Enable LSP for semantic caller resolution or use `code_pattern` explicitly"],
-      },
-    },
-  };
-}
-
-interface CallerRef {
-  file: string;
-  line: number;
-}
-
-interface CallerCollection {
-  refs: CallerRef[];
-  confidence: ConfidenceMode;
-  externalCount: number;
-  candidateCount: number;
-}
-
-async function executeFileLevelCallers(
-  targetGroup: ResolvedTargetGroup,
-  params: ActionParams,
-  cwd: string,
-): Promise<CodeIntelResult> {
-  const perTarget = await Promise.all(
-    targetGroup.targets.map(async (target) => ({
-      target,
-      result: await collectCallerRefs(target, params, cwd),
-    })),
-  );
-
-  const withRefs = perTarget.filter((entry) => entry.result.refs.length > 0);
-  const uniqueRefs = dedupeFileLineRefs(withRefs.flatMap((entry) => entry.result.refs));
-  const confidence = highestConfidence(perTarget.map((entry) => entry.result.confidence));
-  const externalCount = perTarget.reduce((sum, entry) => sum + entry.result.externalCount, 0);
-
-  const lines: string[] = [];
-  lines.push(`# Callers in \`${targetGroup.displayName}\``);
-  lines.push("");
-  lines.push(
-    `**${targetGroup.targets.length} exported target${targetGroup.targets.length !== 1 ? "s" : ""}** | **${uniqueRefs.length} reference${uniqueRefs.length !== 1 ? "s" : ""}** (${confidence})`,
-  );
-  if (externalCount > 0) {
-    lines.push(`_+${externalCount} external reference${externalCount !== 1 ? "s" : ""}_`);
-  }
-  lines.push("");
-
-  for (const entry of withRefs) {
-    lines.push(`## \`${entry.target.name ?? "symbol"}\``);
-    addRefList(lines, entry.result.refs, cwd, params.maxResults ?? 5);
-    lines.push("");
-  }
-
-  if (withRefs.length === 0) {
-    lines.push("No caller references found for the discovered file-level targets.");
-    lines.push("");
-  }
-
-  const details: SearchDetails = {
-    confidence,
-    scope: params.path ?? null,
-    candidateCount: uniqueRefs.length,
-    omittedCount: externalCount,
-    nextQueries: [
-      "`code_affected` for impact analysis",
-      "Use `file` + coordinates to drill into one symbol precisely",
-    ],
-  };
-
-  return { content: lines.join("\n"), details: { type: "search" as const, data: details } };
-}
-
-async function collectCallerRefs(
-  target: ResolvedTarget,
-  _params: ActionParams,
-  cwd: string,
-): Promise<CallerCollection> {
-  const lsp = await getSemanticService(cwd, { waitForReady: true });
-  if (!lsp) {
-    return { refs: [], confidence: "unavailable", externalCount: 0, candidateCount: 0 };
-  }
-
-  const refs = await lsp.references(target.file, target.position);
-  if (refs === null) {
-    return { refs: [], confidence: "unavailable", externalCount: 0, candidateCount: 0 };
-  }
-
-  const filtered = filterOutDeclaration(refs, target.file, target.position);
-  const projectRefs: CallerRef[] = [];
-  let externalCount = 0;
-
-  for (const ref of refs) {
-    const filePath = uriToFile(ref.uri);
-    if (!isInProjectPath(filePath, cwd)) {
-      externalCount++;
-    }
-  }
-
-  for (const ref of filtered) {
-    const filePath = uriToFile(ref.uri);
-    if (isInProjectPath(filePath, cwd)) {
-      projectRefs.push({ file: path.relative(cwd, filePath), line: ref.range.start.line + 1 });
-    }
-  }
-
-  return {
-    refs: projectRefs,
-    confidence: "semantic",
-    externalCount,
-    candidateCount: projectRefs.length,
-  };
-}
-
-function formatTargetCallers(
-  title: string,
-  result: CallerCollection,
-  cwd: string,
-  params: ActionParams,
-): string {
-  const lines: string[] = [];
-  lines.push(`# ${title}`);
-  lines.push("");
-  lines.push(
-    `**${result.candidateCount} reference${result.candidateCount !== 1 ? "s" : ""}** (${result.confidence})`,
-  );
-  if (result.externalCount > 0) {
-    lines.push(
-      `_+${result.externalCount} external reference${result.externalCount !== 1 ? "s" : ""}_`,
-    );
-  }
-  lines.push("");
-  addRefList(lines, result.refs, cwd, params.maxResults ?? 5);
-  return lines.join("\n");
-}
-
-function addRefList(lines: string[], refs: CallerRef[], cwd: string, maxResults: number): void {
-  const byFile = groupRefsByFile(refs, cwd);
-  let shown = 0;
-  for (const [file, locations] of byFile) {
-    if (shown >= maxResults) break;
-    lines.push(`### ${file}`);
-    for (const loc of locations.slice(0, 5)) {
-      lines.push(`- L${loc}`);
-    }
-    if (locations.length > 5) {
-      lines.push(`- _+${locations.length - 5} more in this file_`);
-    }
-    lines.push("");
-    shown++;
-  }
-
-  if (byFile.size > maxResults) {
-    lines.push(
-      `_+${byFile.size - maxResults} more files omitted. Narrow with \`path\` or increase \`maxResults\`._`,
-    );
-  }
-}
-
-function groupRefsByFile(refs: CallerRef[], _cwd: string): Map<string, number[]> {
-  const byFile = new Map<string, number[]>();
-  for (const ref of refs) {
-    const group = byFile.get(ref.file) ?? [];
-    group.push(ref.line);
-    byFile.set(ref.file, group);
-  }
-  return byFile;
-}

package/src/actions/implementations-action.ts

@@ -1,172 +0,0 @@
-// Implementations action — find concrete implementations via LSP.
-
-import * as path from "node:path";
-import { getSemanticService } from "../providers/semantic-provider.ts";
-import type { CodeQueryParams as ActionParams } from "../query-params.ts";
-import { resolveTarget } from "../resolve-target.ts";
-import { isInProjectPath, uriToFile } from "../search-helpers.ts";
-import { isResolvedTargetGroup } from "../semantic-action-helpers.ts";
-import type { CodeIntelResult, SearchDetails } from "../types.ts";
-
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: implementation lookup keeps semantic and unsupported-file paths explicit for maintainability
-export async function executeImplementationsAction(
-  params: ActionParams,
-  cwd: string,
-): Promise<CodeIntelResult> {
-  const target = await resolveTarget(params, cwd);
-  if (typeof target === "string") {
-    return {
-      content: target,
-      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"],
-        },
-      },
-    };
-  }
-
-  if (isResolvedTargetGroup(target)) {
-    return {
-      content: `**Error:** File-level implementation discovery is not available for \`${path.relative(cwd, target.file)}\`.\n\nProvide \`line\` and \`character\`, or a \`symbol\` for discovery.`,
-      details: {
-        type: "search" as const,
-        data: {
-          confidence: "unavailable",
-          scope: params.path ?? null,
-          candidateCount: 0,
-          omittedCount: 0,
-          nextQueries: ["Use `file` + coordinates or `symbol` for implementation lookup"],
-        },
-      },
-    };
-  }
-
-  const lsp = await getSemanticService(cwd, { waitForReady: true });
-  const relPath = path.relative(cwd, target.file);
-
-  if (lsp) {
-    const impls = await lsp.implementation(target.file, target.position);
-    if (impls !== null) {
-      const locations = Array.isArray(impls) ? impls : [impls];
-      if (locations.length > 0) {
-        const content = formatSemanticImpls(locations, cwd, params.maxResults ?? 8);
-        const { project: projectLocs, external: externalLocs } = partitionImpls(locations, cwd);
-        const searchDetails: SearchDetails = {
-          confidence: "semantic",
-          scope: params.path ?? null,
-          candidateCount: projectLocs.length,
-          omittedCount: externalLocs.length,
-          nextQueries: [
-            "`code_affected` before changing implementations",
-            "`code_brief` on containing modules for deeper context",
-          ],
-        };
-        return { content, details: { type: "search" as const, data: searchDetails } };
-      }
-
-      const semanticEmptyDetails: SearchDetails = {
-        confidence: "semantic",
-        scope: params.path ?? null,
-        candidateCount: 0,
-        omittedCount: 0,
-        nextQueries: [
-          "`code_pattern` only if you explicitly want text-search hints for likely implementations",
-        ],
-      };
-      return {
-        content: target.name
-          ? `No implementations found for \`${target.name}\`.`
-          : `No implementations found for ${relPath}:${target.displayLine}:${target.displayCharacter}.`,
-        details: { type: "search" as const, data: semanticEmptyDetails },
-      };
-    }
-  }
-
-  return {
-    content: target.name
-      ? `No implementations found for \`${target.name}\`.`
-      : `No implementations found for ${relPath}:${target.displayLine}:${target.displayCharacter}.`,
-    details: {
-      type: "search" as const,
-      data: {
-        confidence: "unavailable",
-        scope: params.path ?? null,
-        candidateCount: 0,
-        omittedCount: 0,
-        nextQueries: ["Enable LSP for semantic implementation resolution."],
-      },
-    },
-  };
-}
-
-function partitionImpls(
-  locations: Array<{
-    uri?: string;
-    targetUri?: string;
-    range?: { start: { line: number } };
-    targetRange?: { start: { line: number } };
-  }>,
-  cwd: string,
-): { project: typeof locations; external: typeof locations } {
-  const project: typeof locations = [];
-  const external: typeof locations = [];
-  for (const loc of locations) {
-    const uri = loc.uri ?? loc.targetUri ?? "";
-    const filePath = uriToFile(uri);
-    if (filePath && isInProjectPath(filePath, cwd)) {
-      project.push(loc);
-    } else {
-      external.push(loc);
-    }
-  }
-  return { project, external };
-}
-
-function formatSemanticImpls(
-  locations: Array<{
-    uri?: string;
-    targetUri?: string;
-    range?: { start: { line: number } };
-    targetRange?: { start: { line: number } };
-  }>,
-  cwd: string,
-  maxResults: number,
-): string {
-  const { project: projectLocs, external: externalLocs } = partitionImpls(locations, cwd);
-
-  const lines: string[] = [];
-  lines.push("# Implementations (semantic)");
-  lines.push("");
-  lines.push(`**${projectLocs.length} implementation${projectLocs.length !== 1 ? "s" : ""}**`);
-  if (externalLocs.length > 0) {
-    const suffix =
-      externalLocs.length === 1
-        ? "+1 external implementation"
-        : `+${externalLocs.length} external implementations`;
-    lines.push(`_${suffix} (node_modules, .pnpm, or out-of-tree)_`);
-  }
-  lines.push("");
-
-  let shown = 0;
-  for (const loc of projectLocs) {
-    if (shown >= maxResults) break;
-    const uri = loc.uri ?? loc.targetUri ?? "";
-    const range = loc.range ?? loc.targetRange ?? null;
-    const filePath = uriToFile(uri);
-    const implRelPath = path.relative(cwd, filePath);
-    const line = range ? range.start.line + 1 : 0;
-    lines.push(`- \`${implRelPath}\`:${line}`);
-    shown++;
-  }
-
-  if (projectLocs.length > maxResults) {
-    lines.push(`- _+${projectLocs.length - maxResults} more omitted_`);
-  }
-  lines.push("");
-  return lines.join("\n");
-}