@mrclrchtr/supi-code-intelligence 1.16.1 → 2.0.1

package/src/tool/register-tools.ts

@@ -1,32 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-  CODE_INTELLIGENCE_TOOL_PROMPT_SURFACES,
-  type CodeIntelligenceToolPromptSurfaceMap,
-} from "./guidance.ts";
-import { CODE_INTELLIGENCE_TOOL_SPECS } from "./tool-specs.ts";
-
-/** Register the focused code-intelligence tool surface from shared specs. */
-export function registerCodeIntelligenceTools(
-  pi: ExtensionAPI,
-  promptSurfaces: CodeIntelligenceToolPromptSurfaceMap = CODE_INTELLIGENCE_TOOL_PROMPT_SURFACES,
-): void {
-  for (const spec of CODE_INTELLIGENCE_TOOL_SPECS) {
-    const surface = promptSurfaces[spec.name];
-    pi.registerTool({
-      name: spec.name,
-      label: spec.label,
-      description: surface.description,
-      promptSnippet: surface.promptSnippet,
-      promptGuidelines: surface.promptGuidelines,
-      parameters: spec.parameters,
-      // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
-      execute: async (_toolCallId, params, _signal, _onUpdate, ctx: ExtensionContext) => {
-        const { content, details } = await spec.run(params, { cwd: ctx.cwd });
-        return {
-          content: [{ type: "text" as const, text: content }],
-          details,
-        };
-      },
-    });
-  }
-}

package/src/tool/tool-specs.ts

@@ -1,190 +0,0 @@
-import { StringEnum } from "@earendil-works/pi-ai";
-import { type TSchema, Type } from "typebox";
-import type { CodeIntelResult } from "../types.ts";
-import { executeAffectedTool } from "./execute-affected.ts";
-import { executeBriefTool } from "./execute-brief.ts";
-import { executeMapTool } from "./execute-map.ts";
-import { executePatternTool } from "./execute-pattern.ts";
-import { executeRefactorTool } from "./execute-refactor.ts";
-import { executeRelationsTool } from "./execute-relations.ts";
-
-const PathParam = Type.String({ description: "Scope path" });
-const FileParam = Type.String({ description: "Target file" });
-const LineParam = Type.Number({ description: "1-based line" });
-const CharacterParam = Type.Number({ description: "1-based UTF-16 column" });
-const SymbolParam = Type.String({ description: "Symbol name" });
-const PatternParam = Type.String({ description: "Search pattern" });
-const RegexParam = Type.Boolean({ description: "Regex search" });
-const ExportedOnlyParam = Type.Boolean({ description: "Exported symbols only" });
-const MaxResultsParam = Type.Number({ description: "Max results" });
-const ContextLinesParam = Type.Number({ description: "Context lines" });
-const SummaryParam = Type.Boolean({ description: "Summarize by directory" });
-const StructuredPatternKindParam = Type.String({
-  description: "Structured kind: definition | export | import",
-});
-
-export const CODE_INTELLIGENCE_TOOL_NAMES = [
-  "code_brief",
-  "code_map",
-  "code_relations",
-  "code_affected",
-  "code_pattern",
-  "code_refactor",
-] as const;
-export type CodeIntelligenceToolName = (typeof CODE_INTELLIGENCE_TOOL_NAMES)[number];
-
-export const CODE_RELATION_KIND_NAMES = ["callers", "callees", "implementations"] as const;
-export type CodeRelationsKind = (typeof CODE_RELATION_KIND_NAMES)[number];
-
-const CodeRelationsKindEnum = StringEnum(CODE_RELATION_KIND_NAMES);
-
-const CodeBriefParameters = Type.Object(
-  {
-    path: Type.Optional(PathParam),
-    file: Type.Optional(FileParam),
-    line: Type.Optional(LineParam),
-    character: Type.Optional(CharacterParam),
-    symbol: Type.Optional(SymbolParam),
-    maxResults: Type.Optional(MaxResultsParam),
-  },
-  { additionalProperties: false },
-);
-
-const CodeMapParameters = Type.Object(
-  {
-    path: Type.Optional(Type.String({ description: "Project/package/dir path" })),
-  },
-  { additionalProperties: false },
-);
-
-const CodeRelationsParameters = Type.Object(
-  {
-    kind: CodeRelationsKindEnum,
-    path: Type.Optional(PathParam),
-    file: Type.Optional(FileParam),
-    line: Type.Optional(LineParam),
-    character: Type.Optional(CharacterParam),
-    symbol: Type.Optional(SymbolParam),
-    exportedOnly: Type.Optional(ExportedOnlyParam),
-    maxResults: Type.Optional(MaxResultsParam),
-  },
-  { additionalProperties: false },
-);
-
-const CodeAffectedParameters = Type.Object(
-  {
-    file: Type.Optional(FileParam),
-    line: Type.Optional(LineParam),
-    character: Type.Optional(CharacterParam),
-    symbol: Type.Optional(SymbolParam),
-    exportedOnly: Type.Optional(ExportedOnlyParam),
-    maxResults: Type.Optional(MaxResultsParam),
-  },
-  { additionalProperties: false },
-);
-
-const CodePatternParameters = Type.Object(
-  {
-    path: Type.Optional(PathParam),
-    pattern: PatternParam,
-    regex: Type.Optional(RegexParam),
-    kind: Type.Optional(StructuredPatternKindParam),
-    maxResults: Type.Optional(MaxResultsParam),
-    contextLines: Type.Optional(ContextLinesParam),
-    summary: Type.Optional(SummaryParam),
-  },
-  { additionalProperties: false },
-);
-
-const CodeRefactorParameters = Type.Object(
-  {
-    operation: Type.String({ description: "Refactor operation: rename" }),
-    file: FileParam,
-    line: LineParam,
-    character: CharacterParam,
-    newName: Type.String({ description: "New name for rename operation" }),
-  },
-  { additionalProperties: false },
-);
-
-export interface CodeIntelligenceToolDefinitionSpec {
-  name: CodeIntelligenceToolName;
-  label: string;
-  description: string;
-  promptSnippet: string;
-  basePromptGuidelines: string[];
-  parameters: TSchema;
-  run: (params: unknown, ctx: { cwd: string }) => Promise<CodeIntelResult> | CodeIntelResult;
-}
-
-export const CODE_INTELLIGENCE_TOOL_SPECS = [
-  {
-    name: "code_brief",
-    label: "Code Brief",
-    description: "Prioritized brief for a project, package, directory, file, or symbol.",
-    promptSnippet: "code_brief — prioritized code orientation",
-    basePromptGuidelines: [
-      "Use code_brief for prioritized orientation on a project, package, file, or symbol.",
-      "Use code_brief before deeper drill-down when you need a start-here recommendation.",
-    ],
-    parameters: CodeBriefParameters,
-    run: (params, ctx) => executeBriefTool(params as Parameters<typeof executeBriefTool>[0], ctx),
-  },
-  {
-    name: "code_map",
-    label: "Code Map",
-    description: "Factual map of a repo, package, or directory.",
-    promptSnippet: "code_map — factual repo or directory map",
-    basePromptGuidelines: ["Use code_map for counts, directories, language mix, and landmarks."],
-    parameters: CodeMapParameters,
-    run: (params, ctx) => executeMapTool(params as Parameters<typeof executeMapTool>[0], ctx),
-  },
-  {
-    name: "code_relations",
-    label: "Code Relations",
-    description: "Trace callers, callees, or implementations for a resolved target.",
-    promptSnippet: "code_relations — callers, callees, or implementations",
-    basePromptGuidelines: [
-      "Use code_relations(kind) for `callers`, `callees`, or `implementations`.",
-    ],
-    parameters: CodeRelationsParameters,
-    run: (params, ctx) =>
-      executeRelationsTool(params as Parameters<typeof executeRelationsTool>[0], ctx),
-  },
-  {
-    name: "code_affected",
-    label: "Code Affected",
-    description: "Estimate blast radius and downstream impact for a target.",
-    promptSnippet: "code_affected — blast radius and impact",
-    basePromptGuidelines: [
-      "Use code_affected before edits to estimate blast radius and follow-up checks.",
-    ],
-    parameters: CodeAffectedParameters,
-    run: (params, ctx) =>
-      executeAffectedTool(params as Parameters<typeof executeAffectedTool>[0], ctx),
-  },
-  {
-    name: "code_pattern",
-    label: "Code Pattern",
-    description: "Run explicit search with literal, regex, or structured matching.",
-    promptSnippet: "code_pattern — explicit code search",
-    basePromptGuidelines: [
-      "Use code_pattern for literal, regex, or structured search in a bounded path.",
-    ],
-    parameters: CodePatternParameters,
-    run: (params, ctx) =>
-      executePatternTool(params as Parameters<typeof executePatternTool>[0], ctx),
-  },
-  {
-    name: "code_refactor",
-    label: "Code Refactor",
-    description: "Apply a precise semantic refactor (rename) with direct-apply safety checks.",
-    promptSnippet: "code_refactor — semantic refactor with direct apply",
-    basePromptGuidelines: [
-      "Use code_refactor for safe semantic rename operations with precise workspace edits.",
-    ],
-    parameters: CodeRefactorParameters,
-    run: (params, ctx) =>
-      executeRefactorTool(params as Parameters<typeof executeRefactorTool>[0], ctx),
-  },
-] as const satisfies readonly CodeIntelligenceToolDefinitionSpec[];

package/src/tool/validation.ts

@@ -1,43 +0,0 @@
-import * as fs from "node:fs";
-import type { CodeQueryParams } from "../query-params.ts";
-import { normalizePath } from "../search-helpers.ts";
-
-const STRUCTURED_PATTERN_KINDS = new Set(["definition", "export", "import"]);
-
-/** Shared validation for focused tool inputs that can anchor into files. */
-export function validateFocusedToolParams(
-  params: Pick<CodeQueryParams, "path" | "file" | "line" | "character">,
-  cwd: string,
-): string | null {
-  if (params.path && (params.line != null || params.character != null)) {
-    return "**Error:** `line` and `character` require `file`, not `path`. Use `path` to scope/focus; use `file` to anchor a position.";
-  }
-
-  if (params.file) {
-    const resolvedFile = normalizePath(params.file, cwd);
-    if (fs.existsSync(resolvedFile) && fs.statSync(resolvedFile).isDirectory()) {
-      return "**Error:** `file` points to a directory. Use `path` to scope a directory; use `file` to anchor a position in a file.";
-    }
-  }
-
-  if ((params.line != null || params.character != null) && !params.file) {
-    return "**Error:** `line` and `character` require `file`.";
-  }
-
-  return null;
-}
-
-/** Shared validation for explicit pattern-tool input. */
-export function validatePatternToolParams(
-  params: Pick<CodeQueryParams, "path" | "file" | "line" | "character" | "kind">,
-  cwd: string,
-): string | null {
-  const commonError = validateFocusedToolParams(params, cwd);
-  if (commonError) return commonError;
-
-  if (params.kind && !STRUCTURED_PATTERN_KINDS.has(params.kind)) {
-    return "**Error:** `code_pattern` `kind` must be one of `definition`, `export`, or `import`.";
-  }
-
-  return null;
-}

package/src/types.ts

@@ -1,169 +0,0 @@
-// ── Canonical shared types for the code-understanding stack ─────────────
-
-/** 0-based LSP position. */
-export interface CodePosition {
-  line: number;
-  character: number;
-}
-
-/** A source range spanning two CodePositions. */
-export interface SourceRange {
-  start: CodePosition;
-  end: CodePosition;
-}
-
-/** A code location (file URI + range). */
-export interface CodeLocation {
-  uri: string;
-  range: SourceRange;
-}
-
-/** A discovered symbol / declaration. */
-export interface CodeSymbol {
-  name: string;
-  kind: string;
-  file: string;
-  line: number;
-  character: number;
-  container?: string | null;
-}
-
-/** Discriminated result union for provider operations. */
-export type CodeResult<T> =
-  | { kind: "success"; data: T }
-  | { kind: "unsupported-language"; file: string; message: string }
-  | { kind: "file-access-error"; file: string; message: string }
-  | { kind: "validation-error"; message: string }
-  | { kind: "runtime-error"; message: string }
-  | { kind: "unavailable"; message: string };
-
-/** Result confidence classification. */
-export type ConfidenceMode = "semantic" | "structural" | "heuristic" | "unavailable";
-
-/** Provider availability states. */
-export type ProviderAvailability =
-  | { kind: "pending" }
-  | { kind: "ready" }
-  | { kind: "disabled" }
-  | { kind: "inactive" }
-  | { kind: "unavailable"; reason: string };
-
-// ── Structural data shapes (value types, range-flattened) ──────────────
-
-export interface OutlineData {
-  name: string;
-  kind: string;
-  startLine: number;
-  startCharacter: number;
-  endLine: number;
-  endCharacter: number;
-  children?: OutlineData[];
-}
-
-export interface ExportData {
-  name: string;
-  kind: string;
-  startLine: number;
-  startCharacter: number;
-  endLine: number;
-  endCharacter: number;
-  moduleSpecifier?: string;
-}
-
-export interface ImportData {
-  moduleSpecifier: string;
-  startLine: number;
-  startCharacter: number;
-  endLine: number;
-  endCharacter: number;
-}
-
-export interface NodeAtData {
-  type: string;
-  startLine: number;
-  startCharacter: number;
-  endLine: number;
-  endCharacter: number;
-  text: string;
-  ancestry: Array<{
-    type: string;
-    startLine: number;
-    startCharacter: number;
-    endLine: number;
-    endCharacter: number;
-  }>;
-}
-
-export interface CalleesData {
-  enclosingScope: { name: string; startLine: number; endLine: number };
-  callees: Array<{ name: string; startLine: number }>;
-}
-
-// ── Existing code-intelligence types ──────────────────────────────────
-
-import type { PrioritySignalsSummary } from "./prioritization-signals.ts";
-
-/** Structured details metadata returned alongside markdown brief content. */
-export interface BriefDetails {
-  confidence: ConfidenceMode;
-  focusTarget: string | null;
-  startHere: Array<{ target: string; reason: string }>;
-  publicSurfaces: string[];
-  dependencySummary: { moduleCount: number; edgeCount: number } | null;
-  omittedCount: number;
-  nextQueries: string[];
-  prioritySignals?: PrioritySignalsSummary | null;
-}
-
-/** Structured details metadata for factual map results. */
-export interface MapDetails {
-  scope: string | null;
-  totalFiles: number;
-  childDirectoryCount: number;
-  landmarkCount: number;
-  nextQueries: string[];
-}
-
-/** Structured details metadata for relationship and pattern results. */
-export interface SearchDetails {
-  confidence: ConfidenceMode;
-  scope: string | null;
-  candidateCount: number;
-  omittedCount: number;
-  nextQueries: string[];
-}
-
-/** Structured details metadata for affected analysis results. */
-export interface AffectedDetails {
-  confidence: ConfidenceMode;
-  directCount: number;
-  downstreamCount: number;
-  riskLevel: "low" | "medium" | "high";
-  checkNext: string[];
-  likelyTests: string[];
-  omittedCount: number;
-  nextQueries: string[];
-  prioritySignals?: PrioritySignalsSummary | null;
-}
-
-/** Disambiguation candidate for ambiguous symbol resolution. */
-export interface DisambiguationCandidate {
-  name: string;
-  kind: string | null;
-  container: string | null;
-  file: string;
-  line: number;
-  character: number;
-  reason: string;
-  rank: number;
-}
-
-/** Tool result shape returned by executeAction. */
-export interface CodeIntelResult {
-  content: string;
-  details?:
-    | { type: "brief"; data: BriefDetails }
-    | { type: "map"; data: MapDetails }
-    | { type: "search"; data: SearchDetails }
-    | { type: "affected"; data: AffectedDetails };
-}