@mrclrchtr/supi-code-intelligence 1.3.1 → 1.4.0

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

@@ -0,0 +1,258 @@
+// Service-backed LSP tool actions used by the public expert toolset.
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { Position } from "../config/types.ts";
+import { formatDiagnostics } from "../diagnostics/diagnostics.ts";
+import {
+  formatCodeActions,
+  formatDocumentSymbols,
+  formatHover,
+  formatLocations,
+  formatSymbolInformation,
+  formatWorkspaceEdit,
+  formatWorkspaceSymbols,
+  normalizeLocations,
+} from "../format.ts";
+import type { SessionLspService } from "../session/service-registry.ts";
+import { resolveSessionPath } from "../utils.ts";
+
+export type LspLookupKind = "hover" | "definition" | "references" | "implementation";
+export type LspRefactorKind = "rename" | "code_actions";
+
+export interface LspLookupToolParams {
+  kind: LspLookupKind;
+  file: string;
+  line: number;
+  character: number;
+}
+
+export interface LspDocumentSymbolsToolParams {
+  file: string;
+}
+
+export interface LspWorkspaceSymbolsToolParams {
+  query: string;
+}
+
+export interface LspDiagnosticsToolParams {
+  file?: string;
+}
+
+export interface LspRefactorToolParams {
+  kind: LspRefactorKind;
+  file: string;
+  line: number;
+  character: number;
+  newName?: string;
+}
+
+function validatePositivePosition(line: number, character: number): string | null {
+  if (!Number.isInteger(line) || line < 1) {
+    return "Validation error: `line` must be a positive 1-based integer.";
+  }
+  if (!Number.isInteger(character) || character < 1) {
+    return "Validation error: `character` must be a positive 1-based integer.";
+  }
+  return null;
+}
+
+function toZeroBased(line: number, character: number): Position {
+  return { line: line - 1, character: character - 1 };
+}
+
+function validateFile(service: SessionLspService, cwd: string, file: string): string | null {
+  const resolvedPath = resolveSessionPath(cwd, file);
+  if (!fs.existsSync(resolvedPath)) {
+    return `File not found: \`${file}\``;
+  }
+  if (!service.isSupportedSourceFile(file)) {
+    return noServerMessage(resolvedPath);
+  }
+  return null;
+}
+
+function noServerMessage(filePath: string): string {
+  return `No LSP server available for this file type (${path.extname(filePath) || "unknown"})`;
+}
+
+function formatUnexpectedFailure(label: string, error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return `LSP ${label} failed: ${message}`;
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: semantic lookup dispatch stays clearer as a single position-based switch.
+export async function executeLookup(
+  service: SessionLspService,
+  cwd: string,
+  params: LspLookupToolParams,
+): 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);
+    switch (params.kind) {
+      case "hover": {
+        const hover = await service.hover(params.file, position);
+        return hover ? formatHover(hover) : "No hover information available at this position.";
+      }
+      case "definition": {
+        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.";
+      }
+      case "references": {
+        const references = await service.references(params.file, position);
+        return references && references.length > 0
+          ? formatLocations("References", references, cwd)
+          : "No references found.";
+      }
+      case "implementation": {
+        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("lookup", error);
+  }
+}
+
+export async function executeDocumentSymbols(
+  service: SessionLspService,
+  cwd: string,
+  params: LspDocumentSymbolsToolParams,
+): Promise<string> {
+  try {
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+
+    const symbols = await service.documentSymbols(params.file);
+    if (!symbols || symbols.length === 0) return "No document symbols found.";
+
+    if ("children" in symbols[0] || "selectionRange" in symbols[0]) {
+      return formatDocumentSymbols(symbols as import("../config/types.ts").DocumentSymbol[], 0);
+    }
+    return formatSymbolInformation(
+      symbols as import("../config/types.ts").SymbolInformation[],
+      cwd,
+    );
+  } catch (error) {
+    return formatUnexpectedFailure("document symbol lookup", error);
+  }
+}
+
+export async function executeWorkspaceSymbols(
+  service: SessionLspService,
+  cwd: string,
+  params: LspWorkspaceSymbolsToolParams,
+): Promise<string> {
+  try {
+    const query = params.query.trim();
+    if (query.length === 0) {
+      return "Validation error: `query` must be a non-empty string.";
+    }
+
+    const symbols = await service.workspaceSymbol(query);
+    if (!symbols) return "Workspace symbol search is not supported by the active language servers.";
+    if (symbols.length === 0) return `No symbols found for query \`${query}\`.`;
+
+    return formatWorkspaceSymbols(symbols, cwd);
+  } catch (error) {
+    return formatUnexpectedFailure("workspace symbol lookup", error);
+  }
+}
+
+export async function executeDiagnostics(
+  service: SessionLspService,
+  cwd: string,
+  params: LspDiagnosticsToolParams,
+): Promise<string> {
+  try {
+    if (params.file) {
+      const resolvedPath = resolveSessionPath(cwd, params.file);
+      if (!fs.existsSync(resolvedPath)) {
+        return `File not found: \`${params.file}\``;
+      }
+      if (!service.isSupportedSourceFile(params.file)) {
+        return noServerMessage(resolvedPath);
+      }
+
+      const diagnostics = await service.fileDiagnostics(params.file, 4);
+      if (!diagnostics) return noServerMessage(resolvedPath);
+      return formatDiagnostics(resolvedPath, diagnostics, cwd);
+    }
+
+    const summary = service.getWorkspaceDiagnosticSummary();
+    if (summary.length === 0) return "No diagnostics across any files.";
+
+    const lines = ["## Diagnostics Summary", ""];
+    for (const entry of summary) {
+      lines.push(`- **${entry.file}**: ${entry.errors} error(s), ${entry.warnings} warning(s)`);
+    }
+    return lines.join("\n");
+  } catch (error) {
+    return formatUnexpectedFailure("diagnostics", error);
+  }
+}
+
+export async function executeRefactor(
+  service: SessionLspService,
+  cwd: string,
+  params: LspRefactorToolParams,
+): 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);
+
+    if (params.kind === "rename") {
+      if (!params.newName || params.newName.trim().length === 0) {
+        return "Validation error: `newName` is required for rename.";
+      }
+
+      const edit = await service.rename(params.file, position, params.newName.trim());
+      return edit ? formatWorkspaceEdit(edit, cwd) : "Rename not available at this position.";
+    }
+
+    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("refactor", error);
+  }
+}
+
+export async function executeRecover(service: SessionLspService): Promise<string> {
+  try {
+    const result = await service.recoverDiagnostics({ restartIfStillStale: true });
+    const refreshed = pluralize(result.refreshedClients, "client");
+    const restarted = pluralize(result.restartedClients, "client");
+    const status = result.staleAssessment.suspected
+      ? "stale diagnostics still suspected"
+      : "stale diagnostics cleared";
+    const warning = result.staleAssessment.warning ? ` — ${result.staleAssessment.warning}` : "";
+    return `LSP recovery complete: refreshed ${refreshed}, restarted ${restarted}, ${status}${warning}.`;
+  } catch (error) {
+    return formatUnexpectedFailure("recovery", error);
+  }
+}
+
+function pluralize(count: number, word: string): string {
+  return `${count} ${word}${count === 1 ? "" : "s"}`;
+}

package/node_modules/@mrclrchtr/supi-lsp/src/{ui.ts → ui/ui.ts}

@@ -2,10 +2,10 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { DynamicBorder } from "@earendil-works/pi-coding-agent";
 import type { OverlayHandle } from "@earendil-works/pi-tui";
 import { Container, Spacer, Text } from "@earendil-works/pi-tui";
-import type { LspManager } from "./manager/manager.ts";
-import type { OutstandingDiagnosticSummaryEntry } from "./manager/manager-types.ts";
-import type { Diagnostic, ProjectServerInfo } from "./types.ts";
-import { DiagnosticSeverity } from "./types.ts";
+import type { Diagnostic, ProjectServerInfo } from "../config/types.ts";
+import { DiagnosticSeverity } from "../config/types.ts";
+import type { LspManager } from "../manager/manager.ts";
+import type { OutstandingDiagnosticSummaryEntry } from "../manager/manager-types.ts";
 
 export interface LspInspectorState {
   handle: OverlayHandle | null;

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

@@ -27,6 +27,17 @@ export function uriToFile(uri: string): string {
   return filePath;
 }
 
+/**
+ * Resolve a tool-style file path against the active session cwd.
+ *
+ * Built-in pi file tools accept a leading `@` prefix in path arguments, so LSP
+ * helpers strip that prefix as well before resolving relative paths.
+ */
+export function resolveSessionPath(cwd: string, filePath: string): string {
+  const normalizedPath = filePath.startsWith("@") ? filePath.slice(1) : filePath;
+  return path.resolve(cwd, normalizedPath);
+}
+
 // ── Language ID Detection ─────────────────────────────────────────────
 
 const EXT_TO_LANGUAGE: Record<string, string> = {

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

@@ -1,72 +1,79 @@
 # @mrclrchtr/supi-tree-sitter
 
-Structural code analysis for PI — your agent parses code, not just text.
+Adds a `tree_sitter` tool to the [pi coding agent](https://github.com/earendil-works/pi) for parser-based structural code analysis.
 
-Grep matches strings. Tree-sitter parses structure — functions, classes, imports, call chains. The agent stops pattern-matching and starts understanding your code.
-
-## What you get
+## Install
 
-### See code structure
+```bash
+pi install npm:@mrclrchtr/supi-tree-sitter
+```
 
-Extract functions, classes, interfaces, and methods from any file. The agent knows what lives where without reading every line.
+For local development:
 
-### Trace call chains
+```bash
+pi install ./packages/supi-tree-sitter
+```
 
-Find every function call from a given location. The agent follows the code's actual shape instead of guessing from text proximity.
+After editing the source, run `/reload`.
 
-### 14 languages
+## What you get
 
-JavaScript, TypeScript, Python, Rust, Go, C, C++, Java, Kotlin, Ruby, Bash, HTML, R, SQL — get structural analysis for every project you touch.
+After install, pi gets one tool:
 
-Works standalone or alongside LSP. Grammar files are vendored — no native toolchain required at install time.
+- `tree_sitter` — inspect code structure through Tree-sitter parsers instead of plain text search
 
-## Install
+## `tree_sitter` actions
 
-```bash
-pi install npm:@mrclrchtr/supi-tree-sitter
-```
+| 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 |
 
-## Quick look
+Coordinates use **1-based** line and character columns. Character positions use UTF-16 code units.
 
-The agent gets a `tree_sitter` tool with these actions:
+## Supported file families
 
-| Action | What it does |
-|--------|-------------|
-| `outline` | List functions, classes, interfaces in a file |
-| `callees` | Find all function calls from a position |
-| `imports` / `exports` | See what a file imports and exports |
-| `node_at` | Inspect the AST node at any line/column |
-| `query` | Run a custom Tree-sitter query |
+The current tool description covers:
 
-`outline`, `imports`, and `exports` are currently JavaScript/TypeScript only. `node_at`, `query`, and `callees` work across all 14 supported languages. Coordinates are 1-based, matching the `lsp` tool convention.
+- JavaScript / TypeScript (`.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`, `.cjs`, `.mts`, `.cts`)
+- Python (`.py`, `.pyi`)
+- Rust (`.rs`)
+- Go (`.go`, `.mod`)
+- C / C++ (`.c`, `.h`, `.cpp`, `.hpp`, `.cc`, `.cxx`, `.hxx`, `.c++`, `.h++`)
+- Java (`.java`)
+- Kotlin (`.kt`, `.kts`)
+- Ruby (`.rb`)
+- Bash / shell (`.sh`, `.bash`, `.zsh`)
+- HTML (`.html`, `.htm`, `.xhtml`)
+- R (`.r`)
+- SQL (`.sql`)
 
 ## Package surfaces
 
-- `@mrclrchtr/supi-tree-sitter/api` — reusable parsing/session API
+- `@mrclrchtr/supi-tree-sitter/api` — reusable parsing session factory and shared result types
 - `@mrclrchtr/supi-tree-sitter/extension` — pi extension entrypoint
 
-`pi.extensions` still points at the real file path `./src/extension.ts` inside the package. The `/api` and `/extension` paths are consumer-facing package exports, not manifest aliases.
-
-## For extension developers
-
-This package exports a reusable session-scoped parsing service:
+Example:
 
 ```ts
 import { createTreeSitterSession } from "@mrclrchtr/supi-tree-sitter/api";
 
 const session = createTreeSitterSession("/project");
 
-// Check if a file is parseable
-const result = await session.canParse("src/index.ts");
-
-// Get structural outline
+const parseable = await session.canParse("src/index.ts");
 const outline = await session.outline("src/index.ts");
-
-// Trace outgoing calls from a position
 const callees = await session.calleesAt("src/index.ts", 42, 10);
 
-// Always clean up
 session.dispose();
 ```
 
-Call `dispose()` when done.
+## Source
+
+- `src/tree-sitter.ts` — tool registration and action handling
+- `src/runtime.ts` — parser and query runtime
+- `src/session.ts` — reusable session API
+- `src/outline.ts`, `src/imports.ts`, `src/exports.ts`, `src/node-at.ts`, `src/callees.ts` — structural analyses

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

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "SuPi Tree-sitter extension — structural AST analysis for pi",
   "license": "MIT",
   "repository": {

package/node_modules/@mrclrchtr/supi-tree-sitter/src/api.ts

@@ -1,6 +1,6 @@
 // Public tree-sitter session factory and shared types.
 
-export { createTreeSitterSession } from "./session.ts";
+export { createTreeSitterSession } from "./session/session.ts";
 export type {
   CalleesAtResult,
   ExportRecord,

package/node_modules/@mrclrchtr/supi-tree-sitter/src/index.ts

@@ -1,6 +1,6 @@
 // Public session factory and re-exports for @mrclrchtr/supi-tree-sitter.
 
-export { createTreeSitterSession } from "./session.ts";
+export { createTreeSitterSession } from "./session/session.ts";
 export type {
   CalleesAtResult,
   ExportRecord,

package/node_modules/@mrclrchtr/supi-tree-sitter/src/{runtime.ts → session/runtime.ts}

@@ -3,9 +3,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { Language, Parser, Tree } from "web-tree-sitter";
-import { nodeToRange } from "./coordinates.ts";
-import { detectGrammar, resolveGrammarWasmPath } from "./language.ts";
-import type { GrammarId, QueryCapture, TreeSitterResult } from "./types.ts";
+import { nodeToRange } from "../coordinates.ts";
+import { detectGrammar, resolveGrammarWasmPath } from "../language.ts";
+import type { GrammarId, QueryCapture, TreeSitterResult } from "../types.ts";
 
 interface ParserEntry {
   parser: Parser;

package/node_modules/@mrclrchtr/supi-tree-sitter/src/{session.ts → session/session.ts}

@@ -1,14 +1,13 @@
 // Session factory — creates a TreeSitterSession bound to a working directory.
 
-import { detectGrammar, isJsTsGrammar } from "./language.ts";
-import { TreeSitterRuntime } from "./runtime.ts";
+import { detectGrammar, isJsTsGrammar } from "../language.ts";
 import {
   extractExports,
   extractImports,
   extractOutline,
   lookupCalleesAt,
   lookupNodeAt,
-} from "./structure.ts";
+} from "../tool/structure.ts";
 import type {
   CalleesAtResult,
   ExportRecord,
@@ -18,7 +17,8 @@ import type {
   QueryCapture,
   TreeSitterResult,
   TreeSitterSession,
-} from "./types.ts";
+} from "../types.ts";
+import { TreeSitterRuntime } from "./runtime.ts";
 
 /**
  * Create a new Tree-sitter session bound to the given working directory.

package/node_modules/@mrclrchtr/supi-tree-sitter/src/{callees.ts → tool/callees.ts}

@@ -1,8 +1,8 @@
 // Structural callee extraction — enclosing-scope lookup with per-language queries.
 
-import { detectGrammar } from "./language.ts";
-import type { TreeSitterRuntime } from "./runtime.ts";
-import type { GrammarId, SourceRange, TreeSitterResult } from "./types.ts";
+import { detectGrammar } from "../language.ts";
+import type { TreeSitterRuntime } from "../session/runtime.ts";
+import type { GrammarId, SourceRange, TreeSitterResult } from "../types.ts";
 
 /** Result shape returned by lookupCalleesAt. */
 export interface CalleesAtResult {

package/node_modules/@mrclrchtr/supi-tree-sitter/src/{exports.ts → tool/exports.ts}

@@ -1,9 +1,9 @@
 // Export extraction for supported files.
 
-import { nodeToRange } from "./coordinates.ts";
-import type { TreeSitterRuntime } from "./runtime.ts";
-import type { SyntaxNodeLike } from "./syntax-node.ts";
-import type { ExportRecord, TreeSitterResult } from "./types.ts";
+import { nodeToRange } from "../coordinates.ts";
+import type { TreeSitterRuntime } from "../session/runtime.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { ExportRecord, TreeSitterResult } from "../types.ts";
 
 /** Extract export records from a supported file. */
 export async function extractExports(

package/node_modules/@mrclrchtr/supi-tree-sitter/src/{formatting.ts → tool/formatting.ts}

@@ -1,6 +1,6 @@
 // Formatting helpers for tree_sitter tool output.
 
-import type { OutlineItem, TreeSitterResult } from "./types.ts";
+import type { OutlineItem, TreeSitterResult } from "../types.ts";
 
 export const MAX_ITEMS = 100;
 

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/guidance.ts

@@ -0,0 +1,22 @@
+// Prompt guidance and tool description for the tree_sitter tool.
+//
+// Note: We intentionally do NOT include cross-tool routing (e.g., "use lsp for
+// type info") because this package can be installed standalone without supi-lsp.
+
+export const toolDescription = `Tree-sitter tool — parser-level structure and syntax queries for supported files.
+
+Actions: outline, imports, exports, node_at, query, callees.
+
+Use tree_sitter for exact syntax nodes, shallow structure, parsed imports/exports, outgoing calls, or custom AST queries within one file. file is required for all actions. line and character are 1-based UTF-16 coordinates for node_at and callees. query is required for query. outline, imports, and exports are JavaScript/TypeScript-only; node_at and query work across supported grammars; callees works for many grammars. Relative paths resolve from the session working directory.`;
+
+export const promptGuidelines = [
+  "Use tree_sitter.outline(file), tree_sitter.imports(file), or tree_sitter.exports(file) for shallow JavaScript or TypeScript structure without reading the whole file.",
+  "Use tree_sitter.node_at(file, line, character) for the exact syntax node and ancestry at a known position.",
+  "Use tree_sitter.callees(file, line, character) for outgoing calls from the enclosing function or method at a known position.",
+  "Use tree_sitter.query(file, query) for custom Tree-sitter patterns when the built-in actions are not specific enough.",
+  "Use tree_sitter for syntax, node types, source ranges, and other parser-backed structure within one supported file.",
+  "Do not use tree_sitter for type information, cross-file references, semantic renames, or codebase-wide orientation.",
+];
+
+export const promptSnippet =
+  "tree_sitter — parser-backed single-file structure, node lookup, callees, and AST queries";

package/node_modules/@mrclrchtr/supi-tree-sitter/src/{imports.ts → tool/imports.ts}

@@ -1,9 +1,9 @@
 // Import extraction for supported files.
 
-import { nodeToRange } from "./coordinates.ts";
-import type { TreeSitterRuntime } from "./runtime.ts";
-import type { SyntaxNodeLike } from "./syntax-node.ts";
-import type { ImportRecord, TreeSitterResult } from "./types.ts";
+import { nodeToRange } from "../coordinates.ts";
+import type { TreeSitterRuntime } from "../session/runtime.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { ImportRecord, TreeSitterResult } from "../types.ts";
 
 /** Extract import records from a supported file. */
 export async function extractImports(

package/node_modules/@mrclrchtr/supi-tree-sitter/src/{node-at.ts → tool/node-at.ts}

@@ -1,8 +1,8 @@
 // Node-at-position lookup.
 
-import { nodeToRange, publicToTreeSitter, splitSourceLines } from "./coordinates.ts";
-import type { TreeSitterRuntime } from "./runtime.ts";
-import type { NodeAtResult, SourceRange, TreeSitterResult } from "./types.ts";
+import { nodeToRange, publicToTreeSitter, splitSourceLines } from "../coordinates.ts";
+import type { TreeSitterRuntime } from "../session/runtime.ts";
+import type { NodeAtResult, SourceRange, TreeSitterResult } from "../types.ts";
 
 const MAX_ANCESTRY = 10;
 

package/node_modules/@mrclrchtr/supi-tree-sitter/src/{outline.ts → tool/outline.ts}

@@ -1,8 +1,8 @@
 // Outline extraction for supported files.
 
-import { nodeToRange } from "./coordinates.ts";
-import type { SyntaxNodeLike } from "./syntax-node.ts";
-import type { OutlineItem } from "./types.ts";
+import { nodeToRange } from "../coordinates.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { OutlineItem } from "../types.ts";
 
 /** Node types that can be extracted directly as outline items. */
 const OUTLINE_DECLARATION_NODE_TYPES = new Set([

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tree-sitter.ts

@@ -3,6 +3,8 @@
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { detectGrammar, isJsTsGrammar } from "./language.ts";
+import { TreeSitterRuntime } from "./session/runtime.ts";
 import {
   formatNonSuccess,
   formatOutlineItemsCapped,
@@ -11,11 +13,10 @@ import {
   truncatedNotice,
   truncateText,
   validationError,
-} from "./formatting.ts";
-import { detectGrammar, isJsTsGrammar } from "./language.ts";
-import { collectOutline } from "./outline.ts";
-import { TreeSitterRuntime } from "./runtime.ts";
-import { extractExports, extractImports, lookupCalleesAt, lookupNodeAt } from "./structure.ts";
+} from "./tool/formatting.ts";
+import { promptGuidelines, promptSnippet, toolDescription } from "./tool/guidance.ts";
+import { collectOutline } from "./tool/outline.ts";
+import { extractExports, extractImports, lookupCalleesAt, lookupNodeAt } from "./tool/structure.ts";
 
 const TreeSitterActionEnum = StringEnum([
   "outline",
@@ -26,30 +27,6 @@ const TreeSitterActionEnum = StringEnum([
   "callees",
 ] as const);
 
-const toolDescription = `Tree-sitter tool — provides structural AST analysis for supported files.
-
-Actions:
-- outline: Extract structural declarations (functions, classes, interfaces, etc.). JavaScript/TypeScript only.
-- imports: List import statements with module specifiers. JavaScript/TypeScript only.
-- exports: List export declarations, re-exports, and export assignments with names and kinds. JavaScript/TypeScript only.
-- node_at: Find the syntax node at a position. Params: file, line, character
-- query: Run a Tree-sitter query. Params: file, query
-- callees: Find outgoing function/method calls from a position. Params: file, line, character. Supported for most grammars.
-
-Coordinates are 1-based (line, character), compatible with the lsp tool convention.
-Character is a UTF-16 code-unit column.
-Relative file paths resolve from the session working directory.
-
-Supported extensions: .ts, .tsx, .js, .jsx, .mts, .cts, .mjs, .cjs, .py, .pyi, .rs, .go, .mod, .c, .h, .cpp, .hpp, .cc, .cxx, .hxx, .c++, .h++, .java, .kt, .kts, .rb, .sh, .bash, .zsh, .html, .htm, .xhtml, .r, .sql`;
-
-const promptGuidelines = [
-  "Use tree_sitter for structural syntax-tree analysis: extracting declarations, imports, exports, node-at-position lookup, and custom queries.",
-  "Prefer tree_sitter when you need AST node types, exact source ranges, or parser-level structure that semantic language-server tooling does not expose.",
-  "tree_sitter is a standalone structural analysis tool; use semantic language-server features separately when they are available for hover, definitions, references, or diagnostics.",
-];
-
-const promptSnippet = `Use the tree_sitter tool for structural code analysis — outline, imports, exports, node-at-position lookup, and custom queries.`;
-
 export default function treeSitterExtension(pi: ExtensionAPI) {
   let runtime: TreeSitterRuntime | undefined;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-intelligence",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "SuPi Code Intelligence extension — architecture briefs, caller/callee analysis, impact assessment, and pattern search for pi",
   "license": "MIT",
   "repository": {
@@ -19,9 +19,9 @@
     "src/**/*.ts"
   ],
   "dependencies": {
-    "@mrclrchtr/supi-core": "1.3.1",
-    "@mrclrchtr/supi-tree-sitter": "1.3.1",
-    "@mrclrchtr/supi-lsp": "1.3.1"
+    "@mrclrchtr/supi-core": "1.4.0",
+    "@mrclrchtr/supi-lsp": "1.4.0",
+    "@mrclrchtr/supi-tree-sitter": "1.4.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-core",