@mrclrchtr/supi-code-intelligence 1.7.0 → 1.8.0

package/node_modules/@mrclrchtr/supi-lsp/src/tool/service-actions.ts

@@ -128,6 +128,147 @@ export async function executeLookup(
   }
 }
 
+// ---------------------------------------------------------------------------
+// Focused lookup tools (replacing the old multiplexed executeLookup)
+// ---------------------------------------------------------------------------
+
+export interface LspPositionToolParams {
+  file: string;
+  line: number;
+  character: number;
+}
+
+export interface LspRenameToolParams {
+  file: string;
+  line: number;
+  character: number;
+  newName: string;
+}
+
+export async function executeHover(
+  service: SessionLspService,
+  cwd: string,
+  params: LspPositionToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+    const position = toZeroBased(params.line, params.character);
+    const hover = await service.hover(params.file, position);
+    return hover ? formatHover(hover) : "No hover information available at this position.";
+  } catch (error) {
+    return formatUnexpectedFailure("hover", error);
+  }
+}
+
+export async function executeDefinition(
+  service: SessionLspService,
+  cwd: string,
+  params: LspPositionToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+    const position = toZeroBased(params.line, params.character);
+    const result = await service.definition(params.file, position);
+    if (!result) return "No definition found.";
+    const locations = normalizeLocations(result);
+    return locations.length > 0
+      ? formatLocations("Definition", locations, cwd)
+      : "No definition found.";
+  } catch (error) {
+    return formatUnexpectedFailure("definition", error);
+  }
+}
+
+export async function executeReferences(
+  service: SessionLspService,
+  cwd: string,
+  params: LspPositionToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+    const position = toZeroBased(params.line, params.character);
+    const references = await service.references(params.file, position);
+    return references && references.length > 0
+      ? formatLocations("References", references, cwd)
+      : "No references found.";
+  } catch (error) {
+    return formatUnexpectedFailure("references", error);
+  }
+}
+
+export async function executeImplementation(
+  service: SessionLspService,
+  cwd: string,
+  params: LspPositionToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+    const position = toZeroBased(params.line, params.character);
+    const result = await service.implementation(params.file, position);
+    if (!result) return "No implementation found.";
+    const locations = normalizeLocations(result);
+    return locations.length > 0
+      ? formatLocations("Implementation", locations, cwd)
+      : "No implementation found.";
+  } catch (error) {
+    return formatUnexpectedFailure("implementation", error);
+  }
+}
+
+export async function executeRename(
+  service: SessionLspService,
+  cwd: string,
+  params: LspRenameToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+    const newName = params.newName?.trim();
+    if (!newName) {
+      return "Validation error: `newName` is required for rename.";
+    }
+    const position = toZeroBased(params.line, params.character);
+    const edit = await service.rename(params.file, position, newName);
+    return edit ? formatWorkspaceEdit(edit, cwd) : "Rename not available at this position.";
+  } catch (error) {
+    return formatUnexpectedFailure("rename", error);
+  }
+}
+
+export async function executeCodeActions(
+  service: SessionLspService,
+  cwd: string,
+  params: LspPositionToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+    const position = toZeroBased(params.line, params.character);
+    const actions = await service.codeActions(params.file, position);
+    return actions && actions.length > 0
+      ? formatCodeActions(actions)
+      : "No code actions available at this position.";
+  } catch (error) {
+    return formatUnexpectedFailure("code actions", error);
+  }
+}
+
 export async function executeDocumentSymbols(
   service: SessionLspService,
   cwd: string,

package/node_modules/@mrclrchtr/supi-lsp/src/tool/tool-specs.ts

@@ -1,81 +1,59 @@
-import { StringEnum } from "@earendil-works/pi-ai";
 import { type TSchema, Type } from "typebox";
 import type { ServerCapabilities } from "../config/types.ts";
 import type { SessionLspService } from "../session/service-registry.ts";
 import {
+  LSP_CODE_ACTIONS_TOOL,
+  LSP_DEFINITION_TOOL,
   LSP_DIAGNOSTICS_TOOL,
   LSP_DOCUMENT_SYMBOLS_TOOL,
-  LSP_LOOKUP_TOOL,
+  LSP_HOVER_TOOL,
+  LSP_IMPLEMENTATION_TOOL,
   LSP_RECOVER_TOOL,
-  LSP_REFACTOR_TOOL,
+  LSP_REFERENCES_TOOL,
+  LSP_RENAME_TOOL,
   LSP_WORKSPACE_SYMBOLS_TOOL,
   type LspToolName,
 } from "./names.ts";
 import {
+  executeCodeActions,
+  executeDefinition,
   executeDiagnostics,
   executeDocumentSymbols,
-  executeLookup,
+  executeHover,
+  executeImplementation,
   executeRecover,
-  executeRefactor,
+  executeReferences,
+  executeRename,
   executeWorkspaceSymbols,
 } from "./service-actions.ts";
 
-const FileParam = Type.String({ description: "File path (relative or absolute)" });
-const LineParam = Type.Number({ description: "1-based line number", minimum: 1 });
-const CharacterParam = Type.Number({ description: "1-based column number", minimum: 1 });
-const QueryParam = Type.String({ description: "Symbol query string" });
-const NewNameParam = Type.String({ description: "New name for rename" });
+// Shared parameter builders
+const FileParam = Type.String({ description: "File path" });
+const LineParam = Type.Number({ description: "1-based line", minimum: 1 });
+const CharacterParam = Type.Number({ description: "1-based column", minimum: 1 });
+const QueryParam = Type.String({ description: "Symbol query" });
+const NewNameParam = Type.String({ description: "New name" });
 
-export const LSP_LOOKUP_KIND_NAMES = [
-  "hover",
-  "definition",
-  "references",
-  "implementation",
-] as const;
-export const LSP_REFACTOR_KIND_NAMES = ["rename", "code_actions"] as const;
-
-const LookupKindEnum = StringEnum(LSP_LOOKUP_KIND_NAMES);
-const RefactorKindEnum = StringEnum(LSP_REFACTOR_KIND_NAMES);
-
-const LookupParameters = Type.Object(
-  {
-    kind: LookupKindEnum,
-    file: FileParam,
-    line: LineParam,
-    character: CharacterParam,
-  },
+// Parameter schemas
+const PositionParams = Type.Object(
+  { file: FileParam, line: LineParam, character: CharacterParam },
   { additionalProperties: false },
 );
 
-const DocumentSymbolsParameters = Type.Object(
-  {
-    file: FileParam,
-  },
+const RenameParams = Type.Object(
+  { file: FileParam, line: LineParam, character: CharacterParam, newName: NewNameParam },
   { additionalProperties: false },
 );
 
+const DocumentSymbolsParameters = Type.Object({ file: FileParam }, { additionalProperties: false });
+
 const WorkspaceSymbolsParameters = Type.Object(
-  {
-    query: QueryParam,
-  },
+  { query: QueryParam },
   { additionalProperties: false },
 );
 
 const DiagnosticsParameters = Type.Object(
-  {
-    file: Type.Optional(FileParam),
-  },
-  { additionalProperties: false },
-);
-
-const RefactorParameters = Type.Object(
-  {
-    kind: RefactorKindEnum,
-    file: FileParam,
-    line: LineParam,
-    character: CharacterParam,
-    newName: Type.Optional(NewNameParam),
-  },
+  { file: Type.Optional(FileParam) },
   { additionalProperties: false },
 );
 
@@ -89,36 +67,57 @@ export interface LspToolDefinitionSpec {
   basePromptGuidelines: string[];
   parameters: TSchema;
   run: (service: SessionLspService, cwd: string, params: unknown) => Promise<string>;
-  includeCoverageGuidelines?: boolean;
 }
 
 export const LSP_TOOL_DEFINITION_SPECS = [
   {
-    name: LSP_LOOKUP_TOOL,
-    label: "LSP Lookup",
-    description:
-      "Language Server Protocol lookup tool — semantic hover, definition, references, and implementation for supported files. Use lsp_lookup when you know the file and 1-based line/character position and need semantic drill-down rather than text search.",
-    promptSnippet:
-      "lsp_lookup — semantic hover/definition/references/implementation at a known file position",
+    name: LSP_HOVER_TOOL,
+    label: "LSP Hover",
+    description: "Semantic hover/type info at a file position.",
+    promptSnippet: "lsp_hover — hover/type info",
+    basePromptGuidelines: ["Use lsp_hover(file,line,character) for semantic hover/type info."],
+    parameters: PositionParams,
+    run: (service, cwd, params) =>
+      executeHover(service, cwd, params as Parameters<typeof executeHover>[2]),
+  },
+  {
+    name: LSP_DEFINITION_TOOL,
+    label: "LSP Definition",
+    description: "Jump to a symbol definition at a file position.",
+    promptSnippet: "lsp_definition — jump to definition",
     basePromptGuidelines: [
-      'Use lsp_lookup with `kind: "hover"` for semantic type or symbol information at a known `file`, `line`, and `character`.',
-      'Use lsp_lookup with `kind: "definition"`, `"references"`, or `"implementation"` for semantic navigation at a known position.',
-      "Use lsp_lookup after code_brief, code_map, or tree_sitter has already narrowed the target file and position.",
+      "Use lsp_definition(file,line,character) to jump to a symbol definition.",
     ],
-    parameters: LookupParameters,
+    parameters: PositionParams,
+    run: (service, cwd, params) =>
+      executeDefinition(service, cwd, params as Parameters<typeof executeDefinition>[2]),
+  },
+  {
+    name: LSP_REFERENCES_TOOL,
+    label: "LSP References",
+    description: "Find semantic references to a symbol at a file position.",
+    promptSnippet: "lsp_references — semantic references",
+    basePromptGuidelines: ["Use lsp_references(file,line,character) for semantic references."],
+    parameters: PositionParams,
     run: (service, cwd, params) =>
-      executeLookup(service, cwd, params as Parameters<typeof executeLookup>[2]),
-    includeCoverageGuidelines: true,
+      executeReferences(service, cwd, params as Parameters<typeof executeReferences>[2]),
+  },
+  {
+    name: LSP_IMPLEMENTATION_TOOL,
+    label: "LSP Implementation",
+    description: "Find implementations from a file position.",
+    promptSnippet: "lsp_implementation — implementations",
+    basePromptGuidelines: ["Use lsp_implementation(file,line,character) for implementations."],
+    parameters: PositionParams,
+    run: (service, cwd, params) =>
+      executeImplementation(service, cwd, params as Parameters<typeof executeImplementation>[2]),
   },
   {
     name: LSP_DOCUMENT_SYMBOLS_TOOL,
     label: "LSP Document Symbols",
-    description:
-      "Language Server Protocol document symbols tool — list semantic declarations in one supported file. Use lsp_document_symbols when you need a symbol-aware outline rather than raw text structure.",
-    promptSnippet: "lsp_document_symbols — semantic declarations for one supported file",
-    basePromptGuidelines: [
-      "Use lsp_document_symbols(file) for semantic declarations in one supported file.",
-    ],
+    description: "List semantic declarations in one file.",
+    promptSnippet: "lsp_document_symbols — one-file semantic outline",
+    basePromptGuidelines: ["Use lsp_document_symbols(file) for one-file semantic declarations."],
     parameters: DocumentSymbolsParameters,
     run: (service, cwd, params) =>
       executeDocumentSymbols(service, cwd, params as Parameters<typeof executeDocumentSymbols>[2]),
@@ -126,12 +125,9 @@ export const LSP_TOOL_DEFINITION_SPECS = [
   {
     name: LSP_WORKSPACE_SYMBOLS_TOOL,
     label: "LSP Workspace Symbols",
-    description:
-      "Language Server Protocol workspace symbols tool — semantic symbol-name lookup across the current project. Use lsp_workspace_symbols to find declarations by name before opening a specific file.",
-    promptSnippet: "lsp_workspace_symbols — semantic symbol-name lookup across the project",
-    basePromptGuidelines: [
-      "Use lsp_workspace_symbols(query) for semantic symbol-name lookup across the current project.",
-    ],
+    description: "Find symbol declarations by name across the project.",
+    promptSnippet: "lsp_workspace_symbols — project symbol lookup",
+    basePromptGuidelines: ["Use lsp_workspace_symbols(query) to find declarations by name."],
     parameters: WorkspaceSymbolsParameters,
     run: (service, cwd, params) =>
       executeWorkspaceSymbols(
@@ -143,38 +139,42 @@ export const LSP_TOOL_DEFINITION_SPECS = [
   {
     name: LSP_DIAGNOSTICS_TOOL,
     label: "LSP Diagnostics",
-    description:
-      "Language Server Protocol diagnostics tool — current diagnostics for one file or a workspace summary. Use lsp_diagnostics for semantic compiler or language-server issues instead of guessing from text alone.",
-    promptSnippet: "lsp_diagnostics — current diagnostics for one file or the workspace",
-    basePromptGuidelines: [
-      "Use lsp_diagnostics(file?) when you need current diagnostics for one file or a workspace-level summary.",
-    ],
+    description: "Show semantic diagnostics for one file or the workspace.",
+    promptSnippet: "lsp_diagnostics — semantic diagnostics",
+    basePromptGuidelines: ["Use lsp_diagnostics(file?) for semantic diagnostics."],
     parameters: DiagnosticsParameters,
     run: (service, cwd, params) =>
       executeDiagnostics(service, cwd, params as Parameters<typeof executeDiagnostics>[2]),
   },
   {
-    name: LSP_REFACTOR_TOOL,
-    label: "LSP Refactor",
-    description:
-      "Language Server Protocol refactor tool — semantic rename planning and code actions at a known file position. Use lsp_refactor when you need language-server-backed edits or quick-fix suggestions.",
-    promptSnippet: "lsp_refactor — semantic rename planning and code actions at a known position",
+    name: LSP_RENAME_TOOL,
+    label: "LSP Rename",
+    description: "Plan a semantic rename from a file position.",
+    promptSnippet: "lsp_rename — semantic rename plan",
     basePromptGuidelines: [
-      'Use lsp_refactor with `kind: "rename"` for semantic rename planning at a known `file`, `line`, and `character`.',
-      'Use lsp_refactor with `kind: "code_actions"` for semantic fixes or refactors at a known position.',
+      "Use lsp_rename(file,line,character,newName) to plan a semantic rename.",
     ],
-    parameters: RefactorParameters,
+    parameters: RenameParams,
+    run: (service, cwd, params) =>
+      executeRename(service, cwd, params as Parameters<typeof executeRename>[2]),
+  },
+  {
+    name: LSP_CODE_ACTIONS_TOOL,
+    label: "LSP Code Actions",
+    description: "List code fixes/refactors at a file position.",
+    promptSnippet: "lsp_code_actions — quick fixes/refactors",
+    basePromptGuidelines: ["Use lsp_code_actions(file,line,character) for quick fixes/refactors."],
+    parameters: PositionParams,
     run: (service, cwd, params) =>
-      executeRefactor(service, cwd, params as Parameters<typeof executeRefactor>[2]),
+      executeCodeActions(service, cwd, params as Parameters<typeof executeCodeActions>[2]),
   },
   {
     name: LSP_RECOVER_TOOL,
     label: "LSP Recover",
-    description:
-      "Language Server Protocol recover tool — refresh diagnostics after workspace changes and stale language-server state. Use lsp_recover when new files, generated types, or config updates leave diagnostics out of sync.",
-    promptSnippet: "lsp_recover — refresh stale diagnostics after workspace changes",
+    description: "Refresh LSP diagnostics after workspace changes.",
+    promptSnippet: "lsp_recover — refresh stale diagnostics",
     basePromptGuidelines: [
-      "Use lsp_recover() when diagnostics look stale after workspace-level changes or generated-file updates.",
+      "Use lsp_recover() when diagnostics look stale after workspace changes.",
     ],
     parameters: RecoverParameters,
     run: (service) => executeRecover(service),

package/node_modules/@mrclrchtr/supi-lsp/src/utils.ts

@@ -7,7 +7,7 @@ export {
   fileToUri,
   resolveToolPath as resolveSessionPath,
   uriToFile,
-} from "@mrclrchtr/supi-core/api";
+} from "@mrclrchtr/supi-core/path";
 
 // ── Language ID Detection ─────────────────────────────────────────────
 

package/node_modules/@mrclrchtr/supi-lsp/src/workspace-change.ts

@@ -0,0 +1,40 @@
+// Workspace change tracking helpers shared by handlers/session-lifecycle.ts,
+// handlers/diagnostic-injection.ts, and handlers/workspace-recovery.ts.
+
+import * as path from "node:path";
+import { clearTsconfigCache } from "./config/tsconfig-scope.ts";
+import type { FileEvent } from "./config/types.ts";
+import { syncWorkspaceSentinelSnapshot } from "./diagnostics/workspace-sentinels.ts";
+import type { LspRuntimeState } from "./session/lsp-state.ts";
+
+/** Update the state's workspace-change tracking fields after a file modification. */
+export function markWorkspaceChange(state: LspRuntimeState): void {
+  state.lastWorkspaceChangeAt = Date.now();
+  state.staleSuspected = true;
+  state.lastDiagnosticsFingerprint = null;
+  state.currentContextToken = null;
+}
+
+/** Notify the LSP manager about file changes and reset pull-diagnostic state. */
+export function softRecoverWorkspaceChanges(state: LspRuntimeState, changes: FileEvent[]): boolean {
+  if (!state.manager || changes.length === 0) return false;
+
+  clearTsconfigCache();
+  state.manager.clearAllPullResultIds();
+  state.manager.notifyWorkspaceFileChanges(changes);
+  markWorkspaceChange(state);
+  return true;
+}
+
+/** Sync the sentinel-file snapshot and recover from any detected changes. */
+export function refreshWorkspaceSentinels(state: LspRuntimeState, cwd: string): boolean {
+  const { snapshot, changes } = syncWorkspaceSentinelSnapshot(cwd, state.sentinelSnapshot);
+  state.sentinelSnapshot = snapshot;
+  return softRecoverWorkspaceChanges(state, changes);
+}
+
+/** Check whether a given file path's extension suggests tsconfig-scope invalidation. */
+export function shouldInvalidateTsconfigScopeCache(filePath: string): boolean {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext === ".json" || ext === ".jsonc";
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/README.md

@@ -1,6 +1,6 @@
 # @mrclrchtr/supi-tree-sitter
 
-Adds a `tree_sitter` tool to the [pi coding agent](https://github.com/earendil-works/pi) for parser-based structural code analysis.
+Adds focused structural code analysis tools to the [pi coding agent](https://github.com/earendil-works/pi) using Tree-sitter parsers.
 
 ## Install
 
@@ -18,27 +18,35 @@ After editing the source, run `/reload`.
 
 ## What you get
 
-After install, pi gets one tool:
+After install, pi gets **6 focused tools** for parser-based structural analysis:
 
-- `tree_sitter` — inspect code structure through Tree-sitter parsers instead of plain text search
+- `tree_sitter_outline` — shallow structural outline of declarations in JavaScript/TypeScript files
+- `tree_sitter_imports` — list imports in JavaScript/TypeScript files
+- `tree_sitter_exports` — list exports in JavaScript/TypeScript files
+- `tree_sitter_node_at` — find the exact syntax node and ancestry at a position (any supported grammar)
+- `tree_sitter_query` — run a custom Tree-sitter query against a file (any supported grammar)
+- `tree_sitter_callees` — find outgoing calls from the enclosing function or method at a position (most grammars)
 
-## `tree_sitter` actions
+### Outline, imports, exports
 
-| Action | What it is for | Current language coverage |
-| --- | --- | --- |
-| `outline` | List structural declarations such as functions, classes, interfaces, and methods | JavaScript / TypeScript only |
-| `imports` | List import statements | JavaScript / TypeScript only |
-| `exports` | List export declarations, re-exports, and export assignments | JavaScript / TypeScript only |
-| `node_at` | Show the syntax node at a position, including ancestry | Any supported grammar |
-| `query` | Run a custom Tree-sitter query against a file | Any supported grammar |
-| `callees` | Find outgoing calls from the enclosing function or method at a position | Supported for most grammars, but not all |
+These three tools work on JavaScript, TypeScript, JSX, and TSX files. They provide parser-level structural information without needing a language server:
+
+- `tree_sitter_outline` — top-level declarations plus class/interface/enum members
+- `tree_sitter_imports` — module specifiers and source locations for each import
+- `tree_sitter_exports` — kind, name, and module specifier (for re-exports) of each export
+
+### Node-at, query, callees
+
+These tools work across all or most supported grammars:
+
+- `tree_sitter_node_at` — exact syntax node type and ancestry at a given file position
+- `tree_sitter_query` — custom Tree-sitter query pattern matching on any supported grammar
+- `tree_sitter_callees` — outgoing calls from the enclosing function or method at a given position
 
 Coordinates use **1-based** line and character columns. Character positions use UTF-16 code units. Relative paths resolve from the session cwd, and a leading `@` on file paths is stripped.
 
 ## Supported file families
 
-The current tool description covers:
-
 - JavaScript / TypeScript (`.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`, `.cjs`, `.mts`, `.cts`)
 - Python (`.py`, `.pyi`)
 - Rust (`.rs`)
@@ -84,7 +92,10 @@ if (state.kind === "ready") {
 
 ## Source
 
-- `src/tree-sitter.ts` — tool registration and action handling
+- `src/tool/tool-specs.ts` — single source of truth for the public tool surface
+- `src/tool/guidance.ts` — prompt surfaces derived from tool specs
+- `src/tool/register-tools.ts` — focused tool registration driven by tool specs
+- `src/tree-sitter.ts` — extension entrypoint (thin wire-up)
 - `src/session/runtime.ts` — parser and query runtime
 - `src/session/session.ts` — runtime-backed service helpers and owned session API
 - `src/session/service-registry.ts` — shared session-scoped structural service registry

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "SuPi core — shared infrastructure for SuPi extensions (XML context tags, config system)",
   "license": "MIT",
   "repository": {
@@ -37,8 +37,19 @@
   "main": "src/api.ts",
   "exports": {
     "./api": "./src/api.ts",
+    "./config": "./src/config.ts",
+    "./context": "./src/context.ts",
+    "./debug": "./src/debug-registry.ts",
     "./extension": "./src/extension.ts",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./path": "./src/path.ts",
+    "./project": "./src/project.ts",
+    "./session": "./src/session.ts",
+    "./settings": "./src/settings.ts",
+    "./settings-ui": "./src/settings-ui.ts",
+    "./terminal": "./src/terminal.ts",
+    "./tool-framework": "./src/tool-framework.ts",
+    "./types": "./src/types.ts"
   },
   "pi": {
     "extensions": [