@mrclrchtr/supi-code-intelligence 1.7.0 → 1.9.0

package/README.md

@@ -1,3 +1,5 @@
+![SuPi](assets/logo.png)
+
 # @mrclrchtr/supi-code-intelligence
 
 Adds a focused code-understanding toolset to the [pi coding agent](https://github.com/earendil-works/pi).
@@ -14,7 +16,7 @@ For local development:
 pi install ./packages/supi-code-intelligence
 ```
 
-After editing the source, run `/reload`.
+![Code brief in action](https://raw.githubusercontent.com/mrclrchtr/supi/main/screenshots/supi-code-intelligence.png)
 
 ## What you get
 
@@ -26,8 +28,12 @@ After install, pi gets:
 - `code_affected` — blast radius, downstream impact, and risk for a target
 - `code_pattern` — explicit literal, regex, or structured search
 - a lightweight hidden architecture overview injected near the start of a session when a project model can be built
+- **all `lsp_*` expert tools** from `@mrclrchtr/supi-lsp` (hover, definition, references, implementation, diagnostics, rename, code actions, recover, document/workspace symbols)
+- **all `tree_sitter_*` expert tools** from `@mrclrchtr/supi-tree-sitter` (outline, imports, exports, node-at, query, callees)
 - bundled support from `@mrclrchtr/supi-lsp`, `@mrclrchtr/supi-tree-sitter`, and `@mrclrchtr/supi-core`
 
+Installing `@mrclrchtr/supi-code-intelligence` activates all three tool families. Each family is owned and documented by its own package:
+
 This package is for questions like:
 
 - what is in this package or directory?
@@ -36,6 +42,10 @@ This package is for questions like:
 - what is the likely blast radius of a change?
 - where is this pattern defined, imported, or exported?
 
+- `@mrclrchtr/supi-lsp` owns the semantic `lsp_*` tools
+- `@mrclrchtr/supi-tree-sitter` owns the structural `tree_sitter_*` tools
+- `@mrclrchtr/supi-code-intelligence` owns the analysis `code_*` tools and provides cross-family orchestration guidance
+
 ## Tool overview
 
 ### `code_brief`
@@ -96,6 +106,20 @@ Results report confidence such as:
 
 `heuristic` is now primarily a `code_pattern` concern. The other tools prefer explicit unavailable states over silent search fallbacks.
 
+## Architecture
+
+`@mrclrchtr/supi-code-intelligence` is the **orchestration layer** that consumes
+semantic and structural providers through shared contracts.
+
+```text
+supi-code-intelligence  ← hub: CodeProvider registry, types, model, tools
+    ↑         ↑
+supi-lsp    supi-tree-sitter
+ (semantic)   (structural)
+    ↑         ↑
+    └──supi-code-intelligence──┘  ← orchestration, presentation, code_* tools
+```
+
 ## Package surfaces
 
 - `@mrclrchtr/supi-code-intelligence/api` — reusable architecture, brief, and target-resolution helpers
@@ -112,8 +136,11 @@ const overview = generateOverview(model);
 
 ## Source
 
-- `src/code-intelligence.ts` — focused tool registration and session overview injection
+- `src/code-intelligence.ts` — extension entry point: overview injection and tool registration
+- `src/use-case/` — typed orchestration modules for brief, map, relations, affected, and pattern
+- `src/presentation/markdown/` — markdown renderers that format use-case results
+- `src/targeting/` — typed target-resolution pipeline
 - `src/tool/tool-specs.ts` — single source of truth for the public tool surface
 - `src/tool/register-tools.ts` — focused tool registration wiring
 - `src/tool/guidance.ts` — prompt surfaces derived from tool specs
-- `src/actions/*.ts` — domain implementations
+- `src/tool/execute-*.ts` — thin adapters that validate params and route to use-case/presentation layers

package/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-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-code-runtime/node_modules/@mrclrchtr/supi-core/package.json

@@ -0,0 +1,53 @@
+{
+  "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
+    }
+  },
+  "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-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";

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/config/config-settings.ts

@@ -0,0 +1,76 @@
+// Config-aware settings helper for SuPi config-backed settings sections.
+// Wraps registerSettings() and centralizes selected-scope loading + scoped persistence.
+
+import type { SettingItem } from "@earendil-works/pi-tui";
+import type { SettingsScope } from "../settings/settings-registry.ts";
+import { registerSettings } from "../settings/settings-registry.ts";
+import { loadSupiConfigForScope, removeSupiConfigKey, writeSupiConfig } from "./config.ts";
+
+export interface ConfigSettingsHelpers {
+  /** Write a key to the selected scope's config section. */
+  set(key: string, value: unknown): void;
+  /** Remove a key from the selected scope's config section. */
+  unset(key: string): void;
+}
+
+export interface ConfigSettingsOptions<T> {
+  /** Extension identifier — e.g. "lsp", "claude-md" */
+  id: string;
+  /** Human-readable label shown in the UI */
+  label: string;
+  /** SuPi config section name — e.g. "lsp", "claude-md" */
+  section: string;
+  /** Default config values */
+  defaults: T;
+  /** Build SettingItem[] from scoped config. Called by loadValues. */
+  buildItems: (settings: T, scope: SettingsScope, cwd: string) => SettingItem[];
+  /** Handle a settings change with scoped persistence helpers. */
+  persistChange: (
+    scope: SettingsScope,
+    cwd: string,
+    settingId: string,
+    value: string,
+    helpers: ConfigSettingsHelpers,
+  ) => void;
+  /** Optional home directory for config resolution (testing). */
+  homeDir?: string;
+}
+
+/**
+ * Register a config-backed settings section.
+ *
+ * Loads display values from the selected scope only (`defaults <- selected scope`)
+ * instead of merged effective runtime config. Provides scoped `set` / `unset`
+ * persistence helpers so extensions don't need to wire `writeSupiConfig` /
+ * `removeSupiConfigKey` by hand.
+ */
+export function registerConfigSettings<T>(options: ConfigSettingsOptions<T>): void {
+  registerSettings({
+    id: options.id,
+    label: options.label,
+    loadValues: (scope, cwd) => {
+      const settings = loadSupiConfigForScope(options.section, cwd, options.defaults, {
+        scope,
+        homeDir: options.homeDir,
+      });
+      return options.buildItems(settings, scope, cwd);
+    },
+    persistChange: (scope, cwd, settingId, value) => {
+      const helpers: ConfigSettingsHelpers = {
+        set: (key, val) => {
+          writeSupiConfig(
+            { section: options.section, scope, cwd },
+            { [key]: val },
+            { homeDir: options.homeDir },
+          );
+        },
+        unset: (key) => {
+          removeSupiConfigKey({ section: options.section, scope, cwd }, key, {
+            homeDir: options.homeDir,
+          });
+        },
+      };
+      options.persistChange(scope, cwd, settingId, value, helpers);
+    },
+  });
+}

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/config/config.ts

@@ -0,0 +1,186 @@
+// Shared config system for SuPi extensions.
+//
+// Global config: ~/.pi/agent/supi/config.json
+// Project config: .pi/supi/config.json (relative to cwd)
+// Resolution: hardcoded defaults ← global ← project
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const GLOBAL_CONFIG_DIR = ".pi/agent/supi";
+const PROJECT_CONFIG_DIR = ".pi/supi";
+const CONFIG_FILE = "config.json";
+
+function getGlobalConfigPath(homeDir?: string): string {
+  return path.join(homeDir ?? os.homedir(), GLOBAL_CONFIG_DIR, CONFIG_FILE);
+}
+
+function getProjectConfigPath(cwd: string): string {
+  return path.join(cwd, PROJECT_CONFIG_DIR, CONFIG_FILE);
+}
+
+export function readJsonFile(filePath: string): Record<string, unknown> | null {
+  let content: string;
+  try {
+    content = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    // ENOENT or permission error — silent, file may not exist
+    return null;
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    // biome-ignore lint/suspicious/noConsole: deliberate config parse warning
+    console.warn(`[supi-core] Failed to parse config file, ignoring: ${filePath}`);
+    return null;
+  }
+
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    return parsed as Record<string, unknown>;
+  }
+
+  // biome-ignore lint/suspicious/noConsole: deliberate config parse warning
+  console.warn(`[supi-core] Config file root is not an object, ignoring: ${filePath}`);
+  return null;
+}
+
+function shallowMerge<T>(base: T, ...overrides: Array<Record<string, unknown> | null>): T {
+  let result = { ...base };
+  for (const override of overrides) {
+    if (!override) continue;
+    result = { ...result, ...override };
+  }
+  return result;
+}
+
+export interface SupiConfigOptions {
+  homeDir?: string;
+}
+
+/**
+ * Load and merge config for a given extension section.
+ *
+ * Resolution order: defaults ← global ← project
+ */
+export function loadSupiConfig<T>(
+  section: string,
+  cwd: string,
+  defaults: T,
+  options?: SupiConfigOptions,
+): T {
+  const globalConfig = readJsonFile(getGlobalConfigPath(options?.homeDir));
+  const projectConfig = readJsonFile(getProjectConfigPath(cwd));
+
+  const globalSection = extractSection(globalConfig, section);
+  const projectSection = extractSection(projectConfig, section);
+
+  return shallowMerge(defaults, globalSection, projectSection);
+}
+
+/**
+ * Load config for a single scope only.
+ *
+ * Resolution order: defaults ← selected scope
+ *
+ * This is useful for settings UIs that need to show the raw values stored in
+ * one scope, rather than the effective merged config.
+ */
+export function loadSupiConfigForScope<T>(
+  section: string,
+  cwd: string,
+  defaults: T,
+  options: { scope: "global" | "project" } & SupiConfigOptions,
+): T {
+  const config =
+    options.scope === "global"
+      ? readJsonFile(getGlobalConfigPath(options.homeDir))
+      : readJsonFile(getProjectConfigPath(cwd));
+
+  const scopedSection = extractSection(config, section);
+  return shallowMerge(defaults, scopedSection);
+}
+
+export interface SupiConfigLocation {
+  section: string;
+  scope: "global" | "project";
+  cwd: string;
+}
+
+/**
+ * Write config values for a given extension section.
+ */
+export function writeSupiConfig(
+  loc: SupiConfigLocation,
+  value: Record<string, unknown>,
+  options?: SupiConfigOptions,
+): void {
+  const configPath =
+    loc.scope === "global" ? getGlobalConfigPath(options?.homeDir) : getProjectConfigPath(loc.cwd);
+
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const existing = readJsonFile(configPath) ?? {};
+  existing[loc.section] = {
+    ...((existing[loc.section] as Record<string, unknown>) ?? {}),
+    ...value,
+  };
+
+  fs.writeFileSync(configPath, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
+}
+
+/**
+ * Remove a key from a config section.
+ * Used by `interval default` to remove the project override.
+ */
+export function removeSupiConfigKey(
+  loc: SupiConfigLocation,
+  key: string,
+  options?: SupiConfigOptions,
+): void {
+  const configPath =
+    loc.scope === "global" ? getGlobalConfigPath(options?.homeDir) : getProjectConfigPath(loc.cwd);
+
+  const existing = readJsonFile(configPath);
+  if (!existing) return;
+
+  const sectionData = existing[loc.section] as Record<string, unknown> | undefined;
+  if (!sectionData) return;
+
+  delete sectionData[key];
+
+  if (Object.keys(sectionData).length === 0) {
+    delete existing[loc.section];
+  }
+
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const content = Object.keys(existing).length > 0 ? `${JSON.stringify(existing, null, 2)}\n` : "";
+
+  if (content) {
+    // Directory guaranteed to exist since we just read from it
+    fs.writeFileSync(configPath, content, "utf-8");
+  } else {
+    try {
+      fs.unlinkSync(configPath);
+    } catch {
+      // File may not exist
+    }
+  }
+}
+
+function extractSection(
+  config: Record<string, unknown> | null,
+  section: string,
+): Record<string, unknown> | null {
+  if (!config) return null;
+  const data = config[section];
+  if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+    return data as Record<string, unknown>;
+  }
+  return null;
+}

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/config.ts

@@ -0,0 +1,11 @@
+// supi-core config domain — config loading and config-settings helpers.
+export type { SupiConfigLocation, SupiConfigOptions } from "./config/config.ts";
+export {
+  loadSupiConfig,
+  loadSupiConfigForScope,
+  readJsonFile,
+  removeSupiConfigKey,
+  writeSupiConfig,
+} from "./config/config.ts";
+export type { ConfigSettingsHelpers, ConfigSettingsOptions } from "./config/config-settings.ts";
+export { registerConfigSettings } from "./config/config-settings.ts";

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/context/context-messages.ts

@@ -0,0 +1,119 @@
+// Shared context-message utilities for SuPi extensions.
+//
+// Provides a generic prune-and-reorder pattern for extensions that inject
+// managed context messages (via `before_agent_start` with a `customType` and
+// `contextToken`) and maintain them via the `context` event.
+
+/**
+ * Minimal message shape needed for context-message operations.
+ * Extensions cast their event.messages entries to this type.
+ */
+export type ContextMessageLike = {
+  role?: string;
+  customType?: string;
+  content?: unknown;
+  details?: unknown;
+};
+
+/**
+ * Extract the `contextToken` string from a message's `details` object.
+ * Returns `null` when the token is absent or not a string.
+ */
+export function getContextToken(details: unknown): string | null {
+  if (!details || typeof details !== "object") return null;
+  const token = (details as { contextToken?: unknown }).contextToken;
+  return typeof token === "string" ? token : null;
+}
+
+/**
+ * Find the index of the last message with `role: "user"`.
+ * Returns `-1` when no user message exists.
+ */
+export function findLastUserMessageIndex<T extends ContextMessageLike>(messages: T[]): number {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    if (messages[index]?.role === "user") return index;
+  }
+  return -1;
+}
+
+/**
+ * Filter stale context messages and reorder the active one before the last user message.
+ *
+ * - Removes all messages matching `customType` whose token differs from `activeToken`.
+ * - When `activeToken` is `null`, removes **all** messages of that `customType`.
+ * - If the active context message is after the last user message, moves it before.
+ *
+ * Returns the modified array, or the original reference when no changes were needed.
+ */
+export function pruneAndReorderContextMessages<T extends ContextMessageLike>(
+  messages: T[],
+  customType: string,
+  activeToken: string | null,
+): T[] {
+  // Remove stale messages of the target customType
+  const filtered = messages.filter((message) => {
+    if (message.customType !== customType) return true;
+    if (!activeToken) return false;
+    return getContextToken(message.details) === activeToken;
+  });
+
+  if (!activeToken) return filtered;
+
+  // Find the active context message
+  const contextIndex = filtered.findIndex(
+    (message) =>
+      message.customType === customType && getContextToken(message.details) === activeToken,
+  );
+  if (contextIndex === -1) return filtered;
+
+  // Find the last user message
+  const userIndex = findLastUserMessageIndex(filtered);
+  if (userIndex === -1 || contextIndex < userIndex) return filtered;
+
+  // Move context message before last user message
+  const next = [...filtered];
+  const [contextMessage] = next.splice(contextIndex, 1);
+  if (!contextMessage) return filtered;
+  next.splice(userIndex, 0, contextMessage);
+  return next;
+}
+
+/**
+ * Restore the raw prompt content on a context message that was swapped for display text.
+ *
+ * Extensions using `registerMessageRenderer` store their LLM-facing content in
+ * `details.promptContent` and put a human-readable summary in `content`. This function
+ * reverses the swap so the model sees the original prompt content.
+ *
+ * Returns the original array reference when no change is needed.
+ */
+export function restorePromptContent<T extends ContextMessageLike>(
+  messages: T[],
+  customType: string,
+  activeToken: string | null,
+): T[] {
+  if (!activeToken) return messages;
+
+  const index = messages.findIndex(
+    (message) =>
+      message.customType === customType && getContextToken(message.details) === activeToken,
+  );
+  if (index === -1) return messages;
+
+  const promptContent = getPromptContent(messages[index]?.details);
+  if (!promptContent || messages[index]?.content === promptContent) return messages;
+
+  const next = [...messages];
+  next[index] = { ...next[index], content: promptContent };
+  return next;
+}
+
+/**
+ * Extract the `promptContent` string from a message's `details` object.
+ * Returns `null` when absent or not a string.
+ */
+export function getPromptContent(details: unknown): string | null {
+  if (!details || typeof details !== "object") return null;
+  const promptContent = (details as { promptContent?: unknown }).promptContent;
+  return typeof promptContent === "string" ? promptContent : null;
+}