@mrclrchtr/supi-code-intelligence 1.7.0 → 1.9.0

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,8 @@
+![SuPi](assets/logo.png)
+
 # @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
 
@@ -14,31 +16,39 @@ For local development:
 pi install ./packages/supi-tree-sitter
 ```
 
-After editing the source, run `/reload`.
+![Tree-sitter outline in action](https://raw.githubusercontent.com/mrclrchtr/supi/main/screenshots/supi-tree-sitter.png)
 
 ## What you get
 
-After install, pi gets one tool:
+After install, pi gets **6 focused tools** for parser-based structural analysis:
+
+- `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)
+
+### Outline, imports, exports
+
+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
 
-- `tree_sitter` — inspect code structure through Tree-sitter parsers instead of plain text search
+### Node-at, query, callees
 
-## `tree_sitter` actions
+These tools work across all or most supported grammars:
 
-| 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 |
+- `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`)
@@ -52,10 +62,25 @@ The current tool description covers:
 - R (`.r`)
 - SQL (`.sql`)
 
+## Architecture
+
+`@mrclrchtr/supi-tree-sitter` is the **structural substrate** in SuPi's
+code-understanding stack. It depends on `@mrclrchtr/supi-core` and
+`@mrclrchtr/supi-code-runtime` for shared contracts, and provides structural
+analysis via a session-scoped Tree-sitter service that publishes its
+capabilities into the shared workspace runtime.
+
+```text
+supi-code-runtime  ← shared contracts + workspace runtime
+    ↑
+supi-tree-sitter  ← Tree-sitter WASM + session-scoped service + runtime capabilities
+```
+
 ## Package surfaces
 
 - `@mrclrchtr/supi-tree-sitter/api` — reusable parsing session factory, shared session-scoped structural service access, and shared result types
 - `@mrclrchtr/supi-tree-sitter/extension` — pi extension entrypoint
+- `@mrclrchtr/supi-tree-sitter/provider/tree-sitter-provider` — shared StructuralProvider adapter
 
 Owned session example:
 
@@ -84,7 +109,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-code-runtime/README.md

@@ -0,0 +1,13 @@
+# @mrclrchtr/supi-code-runtime
+
+Shared workspace context, capability contracts, and canonical types for the SuPi code-understanding stack.
+
+This is a **library-only package** — it has no pi extension surface, no user-facing tools, and no UI. It provides the shared abstractions that `supi-lsp`, `supi-tree-sitter`, and `supi-code-intelligence` use to communicate capability availability.
+
+## Package surfaces
+
+- `@mrclrchtr/supi-code-runtime/api` — shared canonical types, capability interfaces, workspace runtime registry, and typed request context
+
+## License
+
+MIT

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

@@ -0,0 +1,97 @@
+![SuPi](assets/logo.png)
+
+# @mrclrchtr/supi-core
+
+Shared infrastructure for SuPi extensions.
+
+This is a **pure library** — it does not register any pi commands or tools. The `/supi-settings` command is now available through `@mrclrchtr/supi-settings`.
+
+## Install
+
+```bash
+pnpm add @mrclrchtr/supi-core
+```
+
+## Package surfaces
+
+- `@mrclrchtr/supi-core/api` — reusable helpers for other packages and extensions
+
+## What you get from the API
+
+### Config helpers
+
+- `loadSupiConfig()` — merged config with resolution order `defaults <- global <- project`
+- `loadSupiConfigForScope()` — load one scope at a time for settings UIs
+- `writeSupiConfig()` — persist values
+- `removeSupiConfigKey()` — remove a key or override
+
+Config file locations:
+
+- global: `~/.pi/agent/supi/config.json`
+- project: `.pi/supi/config.json`
+
+### Settings helpers
+
+- `registerSettings()` — register an arbitrary settings section
+- `registerConfigSettings()` — register a config-backed settings section with scoped persistence helpers
+- `registerSettingsCommand()` — register `/supi-settings`
+- `openSettingsOverlay()` — open the shared settings UI directly
+- `createInputSubmenu()` — helper for simple text-entry submenus
+
+The built-in settings UI supports:
+
+- project/global scope toggle
+- grouped extension sections
+- searchable setting lists
+
+### Context helpers
+
+- `wrapExtensionContext()` — wrap injected text in SuPi's `<extension-context>` tag
+- `findLastUserMessageIndex()`
+- `getContextToken()`
+- `getPromptContent()`
+- `pruneAndReorderContextMessages()`
+- `restorePromptContent()`
+
+### Shared registries
+
+- context-provider registry for `/supi-context`
+- debug-event registry for producers that want shared debug capture
+- settings registry used by `/supi-settings`
+
+### Project and session helpers
+
+- project-root detection and directory walking helpers such as `findProjectRoot()` and `walkProject()`
+- active-branch session helper: `getActiveBranchEntries()`
+- terminal helpers such as `formatTitle()`, `signalWaiting()`, and `signalDone()`
+
+## Example
+
+```ts
+import { loadSupiConfig, registerConfigSettings, wrapExtensionContext } from "@mrclrchtr/supi-core/api";
+
+const config = loadSupiConfig("my-extension", process.cwd(), {
+  enabled: true,
+});
+
+registerConfigSettings({
+  id: "my-extension",
+  label: "My Extension",
+  section: "my-extension",
+  defaults: { enabled: true },
+  buildItems: () => [],
+  persistChange: () => {},
+});
+
+const message = wrapExtensionContext("my-extension", "hello", {
+  file: "CLAUDE.md",
+  turn: 1,
+});
+```
+
+## Source
+
+- `src/api.ts` — exported library surface
+- `src/config.ts` — shared config loading and writing
+- `src/config-settings.ts` — config-backed settings registration helper
+- `src/settings-ui.ts` — shared settings overlay

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

@@ -0,0 +1,57 @@
+{
+  "name": "@mrclrchtr/supi-core",
+  "version": "1.9.0",
+  "description": "SuPi core — shared infrastructure for SuPi extensions (XML context tags, config system)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mrclrchtr/supi.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "pi",
+    "pi-coding-agent"
+  ],
+  "files": [
+    "src/**/*.ts",
+    "!__tests__"
+  ],
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
+    },
+    "typebox": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "25.9.1",
+    "vitest": "4.1.7"
+  },
+  "main": "src/api.ts",
+  "exports": {
+    "./api": "./src/api.ts",
+    "./config": "./src/config.ts",
+    "./context": "./src/context.ts",
+    "./debug": "./src/debug-registry.ts",
+    "./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"
+  }
+}

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

@@ -0,0 +1,30 @@
+// supi-core — shared infrastructure for SuPi extensions.
+// Provides XML context tag wrapping, unified config system, context-message utilities,
+// settings registry for supi-wide TUI settings, and a shared tool-spec/registration framework.
+//
+// Convenience barrel — re-exports all domain entry points.
+// For lighter imports, use one of the domain subpaths directly
+// (e.g. @mrclrchtr/supi-core/config, @mrclrchtr/supi-core/context).
+
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./config.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./context.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./debug-registry.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./path.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./project.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./session.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./settings.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./settings-ui.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./terminal.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./tool-framework.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./types.ts";