@mrclrchtr/supi-code-intelligence 1.16.1 → 2.0.1

package/src/target-resolution.ts

@@ -1,122 +0,0 @@
-/**
- * Target resolution — facade that delegates to the structured targeting pipeline
- * while preserving backward-compatible types and exports for existing consumers.
- *
- * New code should import from `./targeting/` directly.
- */
-
-import { type Position, toLspPosition } from "@mrclrchtr/supi-lsp/api";
-import { normalizePath } from "./search-helpers.ts";
-import type { SemanticSubstrate, StructuralSubstrate } from "./substrates/types.ts";
-import { resolveAnchoredTarget as resolveAnchored } from "./targeting/resolve-anchored.ts";
-import { resolveFileTargetGroup as resolveFile } from "./targeting/resolve-file.ts";
-import { resolveSymbolTarget as resolveSymbol } from "./targeting/resolve-symbol.ts";
-import type { ConfidenceMode, DisambiguationCandidate } from "./types.ts";
-
-// ── Re-exported legacy types ──────────────────────────────────────────
-
-export interface ResolvedTarget {
-  file: string;
-  /** 0-based position for LSP API */
-  position: Position;
-  /** 1-based position for user display */
-  displayLine: number;
-  displayCharacter: number;
-  name: string | null;
-  kind: string | null;
-  confidence: ConfidenceMode;
-}
-
-export interface ResolvedTargetGroup {
-  file: string;
-  displayName: string;
-  targets: ResolvedTarget[];
-  confidence: ConfidenceMode;
-}
-
-export type TargetResolutionResult =
-  | { kind: "resolved"; target: ResolvedTarget }
-  | { kind: "disambiguation"; candidates: DisambiguationCandidate[]; omittedCount: number }
-  | { kind: "error"; message: string };
-
-// Re-export normalizePath for consumers who import from target-resolution
-export { normalizePath } from "./search-helpers.ts";
-
-/**
- * Convert 1-based public coordinates to 0-based LSP Position.
- */
-export function toZeroBased(line: number, character: number): Position {
-  return toLspPosition(line, character);
-}
-
-// ── Anchored resolver ─────────────────────────────────────────────────
-
-/**
- * Resolve a target from anchored coordinates (file + line + character).
- * Delegates to the new targeting pipeline after normalizing the file path.
- */
-export function resolveAnchoredTarget(
-  file: string,
-  line: number,
-  character: number,
-  cwd: string,
-): TargetResolutionResult {
-  const resolvedFile = normalizePath(file, cwd);
-  const outcome = resolveAnchored(resolvedFile, line, character);
-
-  if (outcome.kind === "resolved") {
-    return {
-      kind: "resolved",
-      target: outcome.target as ResolvedTarget,
-    };
-  }
-
-  return outcome as TargetResolutionResult;
-}
-
-// ── File-level target group ───────────────────────────────────────────
-
-/**
- * Resolve a file-only request into a group of actionable targets.
- * Delegates to the new targeting pipeline with optional structural substrate.
- */
-export async function resolveFileTargetGroup(
-  file: string,
-  cwd: string,
-  structural?: StructuralSubstrate,
-): Promise<{ kind: "resolved"; group: ResolvedTargetGroup } | { kind: "error"; message: string }> {
-  const outcome = await resolveFile(file, cwd, { structural });
-  if (outcome.kind === "error") return outcome;
-  return {
-    kind: "resolved",
-    group: outcome.group as ResolvedTargetGroup,
-  };
-}
-
-// ── Symbol resolver ───────────────────────────────────────────────────
-
-/**
- * Resolve a target from symbol discovery — finds matching declarations.
- * Symbol discovery is semantic-only; it does not fall back to text search.
- */
-export async function resolveSymbolTarget(
-  symbol: string,
-  cwd: string,
-  semantic: SemanticSubstrate,
-  options?: {
-    path?: string;
-    kind?: string;
-    exportedOnly?: boolean;
-  },
-): Promise<TargetResolutionResult> {
-  const outcome = await resolveSymbol(symbol, cwd, semantic, options);
-
-  if (outcome.kind === "resolved") {
-    return {
-      kind: "resolved",
-      target: outcome.target as ResolvedTarget,
-    };
-  }
-
-  return outcome as TargetResolutionResult;
-}

package/src/targeting/resolve-anchored.ts

@@ -1,80 +0,0 @@
-/**
- * Anchored target resolution — resolves a file + position pair into a
- * typed target outcome using purely filesystem-level validation.
- *
- * This resolver does not require LSP or Tree-sitter. It validates
- * file existence, binary-file guards, and produces the necessary
- * position conversions for downstream semantic operations.
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-const BINARY_EXTENSIONS = new Set([
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".webp",
-  ".bmp",
-  ".ico",
-  ".woff",
-  ".woff2",
-  ".ttf",
-  ".eot",
-  ".zip",
-  ".tar",
-  ".gz",
-  ".bz2",
-  ".pdf",
-  ".doc",
-  ".docx",
-  ".exe",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".wasm",
-  ".node",
-]);
-
-function isBinaryFile(filePath: string): boolean {
-  return BINARY_EXTENSIONS.has(path.extname(filePath).toLowerCase());
-}
-
-/**
- * Resolve an anchored target from file + position.
- *
- * @param file - absolute path to the file
- * @param line - 1-based line
- * @param character - 1-based character
- * @returns Typed outcome: resolved or error
- */
-export function resolveAnchoredTarget(
-  file: string,
-  line: number,
-  character: number,
-): import("./types.ts").TargetOutcome {
-  if (!fs.existsSync(file)) {
-    return { kind: "error", message: `File not found: \`${file}\`` };
-  }
-
-  if (isBinaryFile(file)) {
-    return {
-      kind: "error",
-      message: `File type not supported for semantic analysis: \`${file}\`. Use \`code_pattern\` for explicit text search.`,
-    };
-  }
-
-  return {
-    kind: "resolved",
-    target: {
-      file,
-      position: { line: line - 1, character: character - 1 },
-      displayLine: line,
-      displayCharacter: character,
-      name: null,
-      kind: null,
-      confidence: "semantic",
-    },
-  };
-}

package/src/targeting/resolve-symbol.ts

@@ -1,110 +0,0 @@
-/**
- * Symbol target resolution — discovers symbols via the semantic substrate
- * and returns typed outcomes (resolved, disambiguation, or error).
- *
- * This resolver is semantic-only: it does not fall back to text search
- * or heuristic guessing. Ambiguous matches produce explicit disambiguation.
- */
-
-import * as path from "node:path";
-import { isWithinOrEqual } from "@mrclrchtr/supi-core/project";
-import type { SemanticSubstrate } from "../substrates/types.ts";
-import type { DisambiguationCandidateData, TargetOutcome } from "./types.ts";
-
-const MAX_CANDIDATES = 8;
-const NON_EXPORTED_KINDS = new Set(["Variable", "Field", "Property"]);
-
-/**
- * Resolve a symbol via the semantic substrate.
- *
- * @param symbol - the symbol name to search for
- * @param cwd - session working directory
- * @param semantic - the semantic substrate (LSP-backed)
- * @param options - optional filters: path scope, kind filter, exported-only
- * @returns Typed outcome: resolved, disambiguation, or error
- */
-export async function resolveSymbolTarget(
-  symbol: string,
-  cwd: string,
-  semantic: SemanticSubstrate,
-  options?: {
-    path?: string;
-    kind?: string;
-    exportedOnly?: boolean;
-  },
-): Promise<TargetOutcome> {
-  const results = await semantic.workspaceSymbols(symbol);
-  if (results === null) {
-    return {
-      kind: "error",
-      message: `Symbol discovery for \`${symbol}\` requires active LSP. Use \`file\` + coordinates, or enable LSP and retry.`,
-    };
-  }
-  if (results.length === 0) {
-    return { kind: "error", message: `Symbol not found: \`${symbol}\`` };
-  }
-
-  // Filter by path scope
-  const scopePath = options?.path ? path.resolve(cwd, options.path) : null;
-  let candidates = results.filter((s) => {
-    if (scopePath && !isWithinOrEqual(scopePath, s.file)) return false;
-    return true;
-  });
-
-  // Filter by kind
-  if (options?.kind) {
-    const kindLower = options.kind.toLowerCase();
-    candidates = candidates.filter((s) => s.kind.toLowerCase().includes(kindLower));
-  }
-
-  // Filter to exported symbols only
-  if (options?.exportedOnly) {
-    candidates = candidates.filter((s) => !NON_EXPORTED_KINDS.has(s.kind));
-  }
-
-  // Range-less candidates (line=0,char=0) come from URI-only workspace symbols.
-  // Keep them for disambiguation but don't promote to single-match resolution.
-  const ranged = candidates.filter((s) => s.line > 0 || s.character > 0);
-
-  if (ranged.length === 1) {
-    const c = ranged[0];
-    return {
-      kind: "resolved",
-      target: {
-        file: c.file,
-        position: { line: c.line - 1, character: c.character - 1 },
-        displayLine: c.line,
-        displayCharacter: c.character,
-        name: c.name,
-        kind: c.kind,
-        confidence: "semantic",
-      },
-    };
-  }
-
-  // All candidates lost or only rangeless
-  if (candidates.length === 0) {
-    return {
-      kind: "error",
-      message: `Symbol not found: \`${symbol}\`${scopePath ? ` in path \`${options?.path}\`` : ""}`,
-    };
-  }
-
-  // Multiple candidates — return disambiguation
-  const candidatesOut = candidates.slice(0, MAX_CANDIDATES).map((c, idx) => ({
-    name: c.name,
-    kind: c.kind,
-    container: c.container ?? null,
-    file: path.relative(cwd, c.file),
-    line: c.line,
-    character: c.character,
-    reason: path.relative(cwd, c.file),
-    rank: idx + 1,
-  })) satisfies DisambiguationCandidateData[];
-
-  return {
-    kind: "disambiguation",
-    candidates: candidatesOut,
-    omittedCount: Math.max(0, candidates.length - MAX_CANDIDATES),
-  };
-}

package/src/tool/execute-affected.ts

@@ -1,71 +0,0 @@
-import { routeFor } from "../planner/planner.ts";
-import type { CodeIntelResult } from "../types.ts";
-import { executeAffected } from "../use-case/generate-affected.ts";
-import { getCodeProvider } from "../workspace/request-context.ts";
-import { validateFocusedToolParams } from "./validation.ts";
-
-export interface CodeAffectedToolParams {
-  file?: string;
-  line?: number;
-  character?: number;
-  symbol?: string;
-  exportedOnly?: boolean;
-  maxResults?: number;
-}
-
-/** Execute the public code_affected tool through the affected use-case. */
-export async function executeAffectedTool(
-  params: CodeAffectedToolParams,
-  ctx: { cwd: string },
-): Promise<CodeIntelResult> {
-  const error = validateFocusedToolParams(params, ctx.cwd);
-  if (error) {
-    return { content: error, details: undefined };
-  }
-
-  // Semantic actions require file or symbol
-  if (!params.file && !params.symbol) {
-    return {
-      content:
-        "**Error:** Semantic actions require either anchored coordinates (`file`, `line`, `character`) or a `symbol` for discovery.",
-      details: {
-        type: "affected" as const,
-        data: {
-          confidence: "unavailable" as const,
-          directCount: 0,
-          downstreamCount: 0,
-          riskLevel: "low" as const,
-          checkNext: [],
-          likelyTests: [],
-          omittedCount: 0,
-          nextQueries: ["Provide `file`, `line`, `character` or a `symbol` for discovery"],
-        },
-      },
-    };
-  }
-
-  const route = routeFor(ctx.cwd, "code_affected");
-  if (route.preferred === "unavailable") {
-    return {
-      content:
-        "**Error:** No semantic analysis provider is available for this workspace. Use lsp_* tools directly if needed.",
-      details: {
-        type: "affected" as const,
-        data: {
-          confidence: "unavailable" as const,
-          directCount: 0,
-          downstreamCount: 0,
-          riskLevel: "low" as const,
-          checkNext: [],
-          likelyTests: [],
-          omittedCount: 0,
-          nextQueries: ["Check LSP configuration for this workspace"],
-        },
-      },
-    };
-  }
-
-  const providerState = getCodeProvider(ctx.cwd);
-  const provider = providerState.kind === "ready" ? providerState.provider : null;
-  return executeAffected(params, { cwd: ctx.cwd, provider });
-}

package/src/tool/execute-brief.ts

@@ -1,59 +0,0 @@
-import { buildArchitectureModel } from "../model.ts";
-import { routeFor } from "../planner/planner.ts";
-import type { CodeIntelResult } from "../types.ts";
-import { executeBrief } from "../use-case/generate-brief.ts";
-import type { BriefInput } from "../use-case/types.ts";
-import { getCodeProvider } from "../workspace/request-context.ts";
-import { validateFocusedToolParams } from "./validation.ts";
-
-export interface CodeBriefToolParams {
-  path?: string;
-  file?: string;
-  line?: number;
-  character?: number;
-  symbol?: string;
-  maxResults?: number;
-}
-
-/** Execute the public code_brief tool through the planner-backed use-case layers. */
-export async function executeBriefTool(
-  params: CodeBriefToolParams,
-  ctx: { cwd: string },
-): Promise<CodeIntelResult> {
-  const error = validateFocusedToolParams(params, ctx.cwd);
-  if (error) {
-    return { content: error, details: undefined };
-  }
-
-  const route = routeFor(ctx.cwd, "code_brief");
-  const providerState = getCodeProvider(ctx.cwd);
-  let provider = providerState.kind === "ready" ? providerState.provider : null;
-
-  if (route.preferred === "unavailable") {
-    // code_brief can still work with model-only data even without providers
-    provider = null;
-  }
-  const model = await buildArchitectureModel(ctx.cwd);
-
-  const input: BriefInput = determineInput(params);
-  const deps = { model, provider, cwd: ctx.cwd };
-
-  const result = await executeBrief(input, deps);
-  return { content: result.content, details: { type: "brief", data: result.details } };
-}
-
-function determineInput(params: CodeBriefToolParams): BriefInput {
-  if (params.file && params.line != null && params.character != null) {
-    return { kind: "anchored", file: params.file, line: params.line, character: params.character };
-  }
-  if (params.symbol) {
-    return { kind: "symbol", symbol: params.symbol, path: params.path };
-  }
-  if (params.path) {
-    return { kind: "path", path: params.path };
-  }
-  if (params.file) {
-    return { kind: "file", file: params.file };
-  }
-  return { kind: "project" };
-}

package/src/tool/execute-map.ts

@@ -1,35 +0,0 @@
-import * as fs from "node:fs";
-import { renderMap } from "../presentation/markdown/map.ts";
-import { normalizePath } from "../search-helpers.ts";
-import type { CodeIntelResult } from "../types.ts";
-import { buildMapData } from "../use-case/generate-map.ts";
-
-export interface CodeMapToolParams {
-  path?: string;
-}
-
-/** Execute the public code_map tool with focused directory validation. */
-export async function executeMapTool(
-  params: CodeMapToolParams,
-  ctx: { cwd: string },
-): Promise<CodeIntelResult> {
-  const scopePath = params.path ? normalizePath(params.path, ctx.cwd) : ctx.cwd;
-
-  if (!fs.existsSync(scopePath)) {
-    return {
-      content: `**Error:** code_map path not found: \`${params.path ?? scopePath}\``,
-      details: undefined,
-    };
-  }
-
-  if (!fs.statSync(scopePath).isDirectory()) {
-    return {
-      content: "**Error:** code_map requires a directory path, not a file.",
-      details: undefined,
-    };
-  }
-
-  const data = buildMapData(scopePath, ctx.cwd);
-  const rendered = renderMap(data);
-  return { content: rendered.content, details: { type: "map", data: rendered.details } };
-}

package/src/tool/execute-pattern.ts

@@ -1,29 +0,0 @@
-import type { CodeIntelResult } from "../types.ts";
-import { executePattern } from "../use-case/generate-pattern.ts";
-import { getCodeProvider } from "../workspace/request-context.ts";
-import { validatePatternToolParams } from "./validation.ts";
-
-export interface CodePatternToolParams {
-  path?: string;
-  pattern: string;
-  regex?: boolean;
-  kind?: string;
-  maxResults?: number;
-  contextLines?: number;
-  summary?: boolean;
-}
-
-/** Execute the public code_pattern tool through the pattern use-case. */
-export async function executePatternTool(
-  params: CodePatternToolParams,
-  ctx: { cwd: string },
-): Promise<CodeIntelResult> {
-  const error = validatePatternToolParams(params, ctx.cwd);
-  if (error) {
-    return { content: error, details: undefined };
-  }
-
-  const providerState = getCodeProvider(ctx.cwd);
-  const provider = providerState.kind === "ready" ? providerState.provider : null;
-  return executePattern(params, { cwd: ctx.cwd, provider });
-}

package/src/tool/execute-refactor.ts

@@ -1,101 +0,0 @@
-/**
- * code_refactor tool execution.
- *
- * Routes through the planner to get the refactor-capable semantic provider,
- * calls rename/codeActions, validates the returned edit, applies it,
- * and returns the result.
- */
-
-import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
-import { toLspPosition } from "@mrclrchtr/supi-lsp/api";
-import { routeFor } from "../planner/planner.ts";
-import { renderRefactorResult } from "../presentation/markdown/refactor.ts";
-import { applyWorkspaceEdit } from "../refactor/apply-workspace-edit.ts";
-import { validateEdit } from "../refactor/safety.ts";
-import { normalizePath } from "../search-helpers.ts";
-import type { CodeIntelResult } from "../types.ts";
-
-export interface CodeRefactorToolParams {
-  operation: "rename";
-  file: string;
-  line: number;
-  character: number;
-  newName: string;
-  // Future: "code-action" operation could be added here
-}
-
-/**
- * Execute the code_refactor tool.
- */
-export async function executeRefactorTool(
-  params: CodeRefactorToolParams,
-  ctx: { cwd: string },
-): Promise<CodeIntelResult> {
-  const route = routeFor(ctx.cwd, "code_refactor");
-  if (route.preferred === "unavailable") {
-    return {
-      content:
-        "**Error:** No refactor-capable provider is available for this workspace. Ensure an LSP server is configured and running.",
-      details: undefined,
-    };
-  }
-
-  const runtime = getDefaultWorkspaceRuntime();
-  const ws = runtime.getWorkspace(ctx.cwd);
-  const provider = ws.semantic.provider;
-
-  if (!provider?.rename) {
-    return {
-      content: "**Error:** The active semantic provider does not support rename operations.",
-      details: undefined,
-    };
-  }
-
-  const resolvedFile = normalizePath(params.file, ctx.cwd);
-
-  // Execute the rename operation with 0-based LSP coordinates
-  const refactorResult = await provider.rename(
-    resolvedFile,
-    toLspPosition(params.line, params.character),
-    params.newName,
-  );
-
-  if (refactorResult.kind === "unavailable") {
-    return {
-      content: `**Refactor unavailable:** ${refactorResult.reason}`,
-      details: undefined,
-    };
-  }
-
-  if (refactorResult.kind === "ambiguous") {
-    const candidates = refactorResult.candidates
-      .map((c, i) => {
-        const location = c.file ? `${c.file}${c.line != null ? `:${c.line}` : ""}` : "";
-        return `${i + 1}. ${c.description}${location ? ` (${location})` : ""}`;
-      })
-      .join("\n");
-    return {
-      content: `**Refactor ambiguous:** Multiple matching targets found. Please disambiguate:\n${candidates}`,
-      details: undefined,
-    };
-  }
-
-  // Validate the edit
-  const validation = validateEdit(refactorResult.edits);
-  if (!validation.safe) {
-    return {
-      content: `**Refactor safety check failed:** ${validation.reason}`,
-      details: undefined,
-    };
-  }
-
-  // Apply the edit
-  const applyResult = applyWorkspaceEdit(refactorResult.edits);
-  const content = renderRefactorResult({
-    result: applyResult,
-    operation: `rename "${params.newName}"`,
-    targetDescription: `${resolvedFile}:${params.line}:${params.character}`,
-  });
-
-  return { content, details: undefined };
-}

package/src/tool/execute-relations.ts

@@ -1,79 +0,0 @@
-import { routeFor } from "../planner/planner.ts";
-import type { CodeIntelResult } from "../types.ts";
-import type { RelationsInput } from "../use-case/generate-relations.ts";
-import { executeRelations } from "../use-case/generate-relations.ts";
-import { getCodeProvider } from "../workspace/request-context.ts";
-import type { CodeRelationsKind } from "./tool-specs.ts";
-import { validateFocusedToolParams } from "./validation.ts";
-
-export interface CodeRelationsToolParams {
-  kind: CodeRelationsKind;
-  path?: string;
-  file?: string;
-  line?: number;
-  character?: number;
-  symbol?: string;
-  exportedOnly?: boolean;
-  maxResults?: number;
-}
-
-/** Execute the public code_relations tool through the planner-backed routing. */
-export async function executeRelationsTool(
-  params: CodeRelationsToolParams,
-  ctx: { cwd: string },
-): Promise<CodeIntelResult> {
-  const error = validateFocusedToolParams(params, ctx.cwd);
-  if (error) {
-    return { content: error, details: undefined };
-  }
-
-  // Semantic actions (callers, implementations) or structural (callees) require file or symbol
-  if (!params.file && !params.symbol) {
-    return {
-      content:
-        "**Error:** Relations require either anchored coordinates (`file`, `line`, `character`) or a `symbol` for discovery.",
-      details: {
-        type: "search" as const,
-        data: {
-          confidence: "unavailable" as const,
-          scope: params.path ?? null,
-          candidateCount: 0,
-          omittedCount: 0,
-          nextQueries: ["Provide `file`, `line`, `character` or a `symbol` for discovery"],
-        },
-      },
-    };
-  }
-
-  const route = routeFor(ctx.cwd, "code_relations", params.kind);
-  if (route.preferred === "unavailable") {
-    return {
-      content: `**Error:** No ${params.kind === "callees" ? "structural" : "semantic"} analysis provider is available for this workspace. Use tree_sitter_callees or lsp_* tools directly if needed.`,
-      details: {
-        type: "search" as const,
-        data: {
-          confidence: "unavailable" as const,
-          scope: null,
-          candidateCount: 0,
-          omittedCount: 0,
-          nextQueries: ["Check LSP and tree-sitter configuration"],
-        },
-      },
-    };
-  }
-
-  const input: RelationsInput = {
-    kind: params.kind,
-    path: params.path,
-    file: params.file,
-    line: params.line,
-    character: params.character,
-    symbol: params.symbol,
-    exportedOnly: params.exportedOnly,
-    maxResults: params.maxResults,
-  };
-
-  const providerState = getCodeProvider(ctx.cwd);
-  const provider = providerState.kind === "ready" ? providerState.provider : null;
-  return executeRelations(input, { cwd: ctx.cwd, provider });
-}