@mrclrchtr/supi-code-intelligence 0.1.0

package/node_modules/@mrclrchtr/supi-core/src/registry-utils.ts

@@ -0,0 +1,54 @@
+// Shared registry utility for SuPi extensions.
+//
+// Provides a globalThis-backed registry pattern so that all jiti module instances
+// (resolved through different node_modules symlinks) share the same Map.
+// Without this, each symlink path gets its own module copy and its own Map,
+// so registrations from one instance are invisible to consumers in another.
+
+const SYMBOL_PREFIX = "@mrclrchtr/supi-core/";
+
+/**
+ * Create a named registry backed by `globalThis` + `Symbol.for`.
+ *
+ * The registry is lazily initialized on first access and shared across all
+ * jiti module instances via the global symbol namespace.
+ *
+ * @typeParam T - The value type stored in the registry.
+ * @param name - Unique registry name (used to construct the `Symbol.for` key).
+ * @returns An object with `register`, `getAll`, and `clear` functions.
+ */
+export function createRegistry<T>(name: string) {
+  const key = Symbol.for(SYMBOL_PREFIX + name);
+
+  const getMap = (): Map<string, T> => {
+    let map = (globalThis as Record<symbol, unknown>)[key] as Map<string, T> | undefined;
+    if (!map) {
+      map = new Map<string, T>();
+      (globalThis as Record<symbol, unknown>)[key] = map;
+    }
+    return map;
+  };
+
+  return {
+    /**
+     * Register a value by id. Duplicate ids silently replace the previous registration.
+     */
+    register: (id: string, value: T): void => {
+      getMap().set(id, value);
+    },
+
+    /**
+     * Get all registered values in registration order.
+     */
+    getAll: (): T[] => {
+      return Array.from(getMap().values());
+    },
+
+    /**
+     * Clear all entries from the registry (primarily for tests).
+     */
+    clear: (): void => {
+      getMap().clear();
+    },
+  };
+}

package/node_modules/@mrclrchtr/supi-core/src/session-utils.ts

@@ -0,0 +1,29 @@
+// Generic session-file tree-walking utilities.
+
+import type { FileEntry, SessionEntry } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Resolve the active branch path using PI's append-only tree semantics.
+ *
+ * The active branch is the path from the **last entry** (current leaf)
+ * back to the root via `parentId`. This follows PI's tree structure where
+ * entries are append-only and the last entry in the file is always the
+ * current leaf of the active branch.
+ */
+export function getActiveBranchEntries(entries: FileEntry[]): SessionEntry[] {
+  const sessionEntries = entries.filter((e): e is SessionEntry => e.type !== "session");
+  const byId = new Map(sessionEntries.map((entry) => [entry.id, entry]));
+  const leaf = sessionEntries.at(-1);
+  if (!leaf) return [];
+
+  const path: SessionEntry[] = [];
+  const visited = new Set<string>();
+  let current: SessionEntry | undefined = leaf;
+  while (current) {
+    if (visited.has(current.id)) break;
+    visited.add(current.id);
+    path.unshift(current);
+    current = current.parentId ? byId.get(current.parentId) : undefined;
+  }
+  return path;
+}

package/node_modules/@mrclrchtr/supi-core/src/settings-command.ts

@@ -0,0 +1,15 @@
+// /supi-settings command registration.
+//
+// Thin wrapper that registers the command and delegates to openSettingsOverlay.
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { openSettingsOverlay } from "./settings-ui.ts";
+
+export function registerSettingsCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi-settings", {
+    description: "Manage SuPi extension settings",
+    handler: async (_args, ctx) => {
+      openSettingsOverlay(ctx);
+    },
+  });
+}

package/node_modules/@mrclrchtr/supi-core/src/settings-registry.ts

@@ -0,0 +1,41 @@
+// Settings registry for SuPi extensions.
+//
+// Extensions declare their settings via `registerSettings()` during their
+// factory function. The generic settings UI reads them via `getRegisteredSettings()`.
+
+import type { SettingItem } from "@earendil-works/pi-tui";
+import { createRegistry } from "./registry-utils.ts";
+
+export type SettingsScope = "project" | "global";
+
+export interface SettingsSection {
+  /** Extension identifier — e.g. "lsp", "claude-md" */
+  id: string;
+  /** Human-readable label shown in the UI */
+  label: string;
+  /** Load current SettingItem[] for the given scope */
+  loadValues: (scope: SettingsScope, cwd: string) => SettingItem[];
+  /** Persist a change back to config */
+  persistChange: (scope: SettingsScope, cwd: string, settingId: string, value: string) => void;
+}
+
+const registry = createRegistry<SettingsSection>("settings-registry");
+
+/**
+ * Register a settings section for an extension.
+ * Call during the extension factory function (not async handlers).
+ * Duplicate ids replace the previous registration.
+ */
+export function registerSettings(section: SettingsSection): void {
+  registry.register(section.id, section);
+}
+
+/** Get all registered settings sections in registration order. */
+export function getRegisteredSettings(): SettingsSection[] {
+  return registry.getAll();
+}
+
+/** Clear the registry — used by tests. */
+export function clearRegisteredSettings(): void {
+  registry.clear();
+}

package/node_modules/@mrclrchtr/supi-core/src/settings-ui.ts

@@ -0,0 +1,226 @@
+// Generic settings overlay for SuPi extensions.
+//
+// Uses pi-tui's SettingsList with scope toggle (Tab), extension grouping,
+// and search. Each extension declares its settings via registerSettings().
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import {
+  Container,
+  Input,
+  Key,
+  matchesKey,
+  type SettingItem,
+  SettingsList,
+  Text,
+} from "@earendil-works/pi-tui";
+import {
+  getRegisteredSettings,
+  type SettingsScope,
+  type SettingsSection,
+} from "./settings-registry.ts";
+
+// ── Input submenu component ──────────────────────────────────
+
+/**
+ * Creates a pi-tui Input-backed submenu component with enter-to-confirm
+ * and escape-to-cancel handling.
+ *
+ * @param currentValue - Initial value for the text input.
+ * @param label - Label text displayed above the input.
+ * @param done - Callback invoked with the confirmed value, or undefined on cancel.
+ */
+export function createInputSubmenu(
+  currentValue: string,
+  label: string,
+  done: (selectedValue?: string) => void,
+): {
+  render: (width: number) => string[];
+  invalidate: () => void;
+  handleInput: (data: string) => boolean;
+} {
+  const input = new Input();
+  input.setValue(currentValue);
+
+  return {
+    render: (_width: number) => {
+      const lines = [`  ${label}`];
+      lines.push(...input.render(_width));
+      lines.push("  enter confirm • esc cancel");
+      return lines;
+    },
+    invalidate: () => {
+      input.invalidate();
+    },
+    handleInput: (data: string) => {
+      if (matchesKey(data, Key.escape)) {
+        done();
+        return true;
+      }
+      if (matchesKey(data, Key.enter)) {
+        done(input.getValue());
+        return true;
+      }
+      input.handleInput(data);
+      return true;
+    },
+  };
+}
+
+// ── Types ────────────────────────────────────────────────────
+
+interface OverlayState {
+  scope: SettingsScope;
+  cwd: string;
+}
+
+// ── Pure helpers ─────────────────────────────────────────────
+
+function getScopeLabel(scope: SettingsScope): string {
+  return scope === "project" ? "Project" : "Global";
+}
+
+function buildFlatItems(
+  sections: SettingsSection[],
+  scope: SettingsScope,
+  cwd: string,
+): SettingItem[] {
+  const items: SettingItem[] = [];
+  for (const section of sections) {
+    const sectionItems = section.loadValues(scope, cwd);
+    for (const item of sectionItems) {
+      items.push({
+        ...item,
+        id: `${section.id}.${item.id}`,
+        label: `${section.label}: ${item.label}`,
+      });
+    }
+  }
+  return items;
+}
+
+function findSectionAndId(
+  sections: SettingsSection[],
+  flatId: string,
+): { section: SettingsSection; itemId: string } | null {
+  const dotIndex = flatId.indexOf(".");
+  if (dotIndex === -1) return null;
+  const sectionId = flatId.slice(0, dotIndex);
+  const itemId = flatId.slice(dotIndex + 1);
+  const section = sections.find((s) => s.id === sectionId);
+  if (!section) return null;
+  return { section, itemId };
+}
+
+// ── Component ────────────────────────────────────────────────
+
+interface SettingsOverlayDeps {
+  state: OverlayState;
+  container: Container;
+  settingsList: SettingsList | null;
+  tui: Parameters<Parameters<ExtensionContext["ui"]["custom"]>[0]>[0];
+  theme: Parameters<Parameters<ExtensionContext["ui"]["custom"]>[0]>[1];
+  done: () => void;
+}
+
+function createSettingsList(deps: SettingsOverlayDeps): SettingsList {
+  const sections = getRegisteredSettings();
+  const items = buildFlatItems(sections, deps.state.scope, deps.state.cwd);
+  const onChange = (flatId: string, newValue: string) => {
+    const found = findSectionAndId(sections, flatId);
+    if (found) {
+      found.section.persistChange(deps.state.scope, deps.state.cwd, found.itemId, newValue);
+    }
+    // Re-read all values to reflect persisted changes, but keep the list
+    // instance (and its selectedIndex) intact.
+    const updatedItems = buildFlatItems(sections, deps.state.scope, deps.state.cwd);
+    for (const updated of updatedItems) {
+      const existing = items.find((i) => i.id === updated.id);
+      if (existing && existing.currentValue !== updated.currentValue) {
+        settingsList.updateValue(updated.id, updated.currentValue);
+      }
+    }
+    deps.tui.requestRender();
+  };
+  const settingsList = new SettingsList(
+    items,
+    Math.min(items.length + 4, 20),
+    getSettingsListTheme(),
+    onChange,
+    () => deps.done(),
+    { enableSearch: true },
+  );
+  return settingsList;
+}
+
+function rebuildSettingsList(deps: SettingsOverlayDeps): SettingsList {
+  const settingsList = createSettingsList(deps);
+  deps.settingsList = settingsList;
+
+  deps.container.clear();
+  deps.container.addChild(createHeaderComponent(deps));
+  deps.container.addChild(settingsList);
+
+  return settingsList;
+}
+
+function createHeaderComponent(deps: SettingsOverlayDeps): Text {
+  const { theme, state } = deps;
+  const scopeLabel = getScopeLabel(state.scope);
+  const otherScope = state.scope === "project" ? "Global" : "Project";
+  const headerText = new Text(
+    `${theme.fg("accent", theme.bold("SuPi Settings"))}  ${theme.fg("text", `Scope: ${scopeLabel}`)} ${theme.fg("dim", `(tab → ${otherScope})`)}`,
+    0,
+    0,
+  );
+  return headerText;
+}
+
+function handleScopeToggle(deps: SettingsOverlayDeps): void {
+  deps.state.scope = deps.state.scope === "project" ? "global" : "project";
+  rebuildSettingsList(deps);
+  deps.tui.requestRender();
+}
+
+// ── Entry point ──────────────────────────────────────────────
+
+export function openSettingsOverlay(ctx: ExtensionContext): void {
+  const sections = getRegisteredSettings();
+  if (sections.length === 0) {
+    ctx.ui.notify("No settings registered by SuPi extensions", "info");
+    return;
+  }
+
+  void ctx.ui.custom<void>((tui, theme, _kb, done) => {
+    const state: OverlayState = { scope: "project", cwd: ctx.cwd };
+    const container = new Container();
+
+    const deps: SettingsOverlayDeps = {
+      state,
+      container,
+      settingsList: null,
+      tui,
+      theme,
+      done,
+    };
+
+    rebuildSettingsList(deps);
+
+    const component = {
+      render: (width: number) => container.render(width),
+      invalidate: () => container.invalidate(),
+      handleInput: (data: string) => {
+        if (matchesKey(data, Key.tab)) {
+          handleScopeToggle(deps);
+          return true;
+        }
+        // Delegate input to the settings list (always set after rebuildSettingsList)
+        deps.settingsList?.handleInput?.(data);
+        deps.tui.requestRender();
+        return true;
+      },
+    };
+
+    return component;
+  });
+}

package/node_modules/@mrclrchtr/supi-core/src/terminal.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared terminal title formatting and signaling utilities.
+ *
+ * Centralized place for pi title convention (π prefix), completion (✓)
+ * and waiting (●) indicators, and the audible terminal bell.
+ */
+import path from "node:path";
+
+/** Unicode checkmark shown when the agent finishes a turn. */
+export const DONE_SYMBOL = "\u2713";
+/** Unicode dot shown when waiting for user input. */
+export const WAITING_SYMBOL = "\u25CF";
+
+/** Minimal UI surface needed for title operations. */
+export interface TitleTarget {
+  ui: {
+    setTitle?(title: string): void;
+  };
+}
+
+/**
+ * Format pi's canonical terminal title from session name and cwd.
+ * Falls back gracefully when either is missing.
+ *
+ * @example
+ *   formatTitle("my-session", "/home/projects/foo")  // "π - my-session - foo"
+ *   formatTitle(undefined, "/home/projects/foo")      // "π - foo"
+ *   formatTitle("my-session")                         // "π - my-session"
+ *   formatTitle()                                     // "π"
+ */
+export function formatTitle(sessionName?: string, cwd?: string): string {
+  const base = cwd ? path.basename(cwd) : undefined;
+  if (sessionName && base) return `π - ${sessionName} - ${base}`;
+  if (sessionName) return `π - ${sessionName}`;
+  if (base) return `π - ${base}`;
+  return "π";
+}
+
+/** Sound the audible terminal bell (ASCII BEL). */
+export function signalBell(): void {
+  process.stdout.write("\x07");
+}
+
+/**
+ * Set the terminal title to indicate the agent is waiting for user input.
+ * Prefixes with ● and sounds the terminal bell.
+ */
+export function signalWaiting(ctx: TitleTarget, title: string): void {
+  ctx.ui.setTitle?.(`${WAITING_SYMBOL}  ${title}`);
+  signalBell();
+}
+
+/**
+ * Set the terminal title to indicate the agent turn has completed.
+ * Prefixes with ✓ and sounds the terminal bell.
+ */
+export function signalDone(ctx: TitleTarget, title: string): void {
+  ctx.ui.setTitle?.(`${DONE_SYMBOL} ${title}`);
+  signalBell();
+}

package/node_modules/@mrclrchtr/supi-lsp/README.md

@@ -0,0 +1,112 @@
+# @mrclrchtr/supi-lsp
+
+Language Server Protocol integration for the [pi coding agent](https://github.com/earendil-works/pi).
+
+## Install
+
+```bash
+pi install npm:@mrclrchtr/supi-lsp
+```
+
+## What it adds
+
+- `lsp` tool with `hover`, `definition`, `references`, `diagnostics`, `symbols`, `rename`, `code_actions`, `workspace_symbol`, `search`, `symbol_hover`, and `recover`
+- Stable system-prompt guidance that tells the agent to prefer LSP over grep/rg for code navigation
+- Proactive project scanning and eager startup of detected language servers
+- Automatic stale-diagnostic recovery when workspace sentinels change (`package.json`, root lockfiles, `tsconfig*`, generated `*.d.ts` files`) before the next agent turn, plus immediate recovery after successful `write` or `edit` calls for those paths
+- Inline diagnostic surfacing around reads, writes, and edits
+- Compact diagnostic context injection when outstanding diagnostics change, with stale-diagnostic warnings when needed
+- `/lsp-status` status overlay
+
+## Public library API
+
+In addition to the extension entrypoint, `@mrclrchtr/supi-lsp` exports a reusable session-scoped service API for peer extensions:
+
+```ts
+import { getSessionLspService, SessionLspService } from "@mrclrchtr/supi-lsp";
+
+const state = getSessionLspService("/project");
+
+if (state.kind === "ready") {
+  const service = state.service;
+  const hover = await service.hover("src/index.ts", { line: 5, character: 10 });
+  const defs = await service.definition("src/index.ts", { line: 5, character: 10 });
+  const refs = await service.references("src/index.ts", { line: 5, character: 10 });
+  const impls = await service.implementation("src/index.ts", { line: 5, character: 10 });
+  const symbols = await service.documentSymbols("src/index.ts");
+  const projectServers = service.getProjectServers();
+}
+```
+
+Peer extensions can import from the package root without reaching into private files.
+
+## Tool actions
+
+The `lsp` tool supports these actions:
+
+- `hover`: type info at a position
+- `definition`: go to definition
+- `references`: find all references
+- `diagnostics`: per-file or project-wide diagnostics
+- `symbols`: document symbols
+- `rename`: workspace-wide rename
+- `code_actions`: quick fixes at a position
+- `workspace_symbol`: fuzzy symbol search across the project
+- `search`: symbol search with text fallback
+- `symbol_hover`: hover by symbol name
+- `recover`: refresh diagnostics after workspace-wide dependency, config, or generated-type changes
+
+Line and character positions are **1-based**.
+
+Example:
+
+```json
+{
+  "action": "definition",
+  "file": "src/index.ts",
+  "line": 12,
+  "character": 8
+}
+```
+
+## Configuration
+
+If your install surface includes `/supi-settings` (for example via `@mrclrchtr/supi`), this package contributes an LSP settings section there. Use that panel to:
+
+- enable or disable LSP globally
+- control the severity threshold
+- select active language servers
+- configure file exclusion patterns
+
+## Commands
+
+`/lsp-status` toggles an overlay showing active language servers and outstanding diagnostics:
+
+```text
+ λ LSP inspector  /lsp-status toggles
+ 3 servers running • 12 open files • 5 errors • 2 warnings
+
+ Servers
+   typescript  running    24 open files
+   python      running     8 open files
+   bash        running     0 open files
+
+ Problems
+   src/lsp.ts:42       Cannot find name 'foo'          ts(2304)
+   src/manager.ts:108  Property 'bar' does not exist   ts(2339)
+```
+
+When no servers are available, the overlay shows `no LSP servers available for this project`. A compact status summary is always visible in the pi status bar.
+
+## Requirements
+
+- `@earendil-works/pi-coding-agent`
+- `@earendil-works/pi-tui`
+- `typebox`
+- relevant language servers installed and available on `PATH`
+- `@mrclrchtr/supi-core`
+
+## Source
+
+- Extension entrypoint: `lsp.ts`
+- Public library surface: `index.ts`

package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-core/README.md

@@ -0,0 +1,90 @@
+# @mrclrchtr/supi-core
+
+Shared infrastructure for SuPi packages.
+
+## Install
+
+Use it as a dependency in another extension package:
+
+```bash
+pnpm add @mrclrchtr/supi-core
+```
+
+## Package role
+
+`@mrclrchtr/supi-core` is a library package. It does **not** register a pi extension and is not meant to be installed as a standalone pi package.
+
+## What it provides
+
+Current exports cover:
+
+- shared config loading, scoped reads, writes, and key removal
+- config-backed settings registration helpers for `/supi-settings`
+- the shared settings registry, overlay UI, and `registerSettingsCommand()` helper
+- XML `<extension-context>` wrapping plus context-message utilities
+- context-provider and debug-event registries reused across SuPi packages
+- project root and path helpers reused by packages such as `supi-lsp`
+
+## Config system
+
+Config resolution order:
+
+```text
+defaults <- global <- project
+```
+
+Config file locations:
+
+- global: `~/.pi/agent/supi/config.json`
+- project: `.pi/supi/config.json`
+
+Main helpers:
+
+- `loadSupiConfig()` — effective merged config (`defaults <- global <- project`)
+- `loadSupiConfigForScope()` — raw single-scope config for settings UIs (`defaults <- selected scope`)
+- `writeSupiConfig()`
+- `removeSupiConfigKey()`
+- `registerConfigSettings()`
+
+## Context and settings helpers
+
+- `wrapExtensionContext()`
+- `findLastUserMessageIndex()`
+- `getContextToken()`
+- `pruneAndReorderContextMessages()`
+- `registerSettings()`
+- `registerSettingsCommand()`
+- `openSettingsOverlay()`
+
+## Example
+
+```ts
+import { loadSupiConfig, registerConfigSettings, wrapExtensionContext } from "@mrclrchtr/supi-core";
+
+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", {
+  turn: 1,
+  file: "CLAUDE.md",
+});
+```
+
+## Requirements
+
+- `@earendil-works/pi-coding-agent`
+- `@earendil-works/pi-tui`
+
+## Source
+
+- Main exports: `src/index.ts`

package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-core/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@mrclrchtr/supi-core",
+  "version": "0.1.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": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "vitest": "^4.1.4"
+  },
+  "main": "src/index.ts"
+}