@mrclrchtr/supi-tree-sitter 1.3.1 → 1.5.0

package/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;
+}

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

@@ -0,0 +1,36 @@
+// Context provider registry for SuPi extensions.
+//
+// Extensions declare context data providers via `registerContextProvider()` during their
+// factory function. The `/supi-context` command reads them via `getRegisteredContextProviders()`.
+
+import { createRegistry } from "../registry-utils.ts";
+
+export interface ContextProvider {
+  /** Unique identifier — e.g. "rtk" */
+  id: string;
+  /** Human-readable label shown in the report */
+  label: string;
+  /** Return structured data for display, or null when unavailable. */
+  getData: () => Record<string, string | number> | null;
+}
+
+const registry = createRegistry<ContextProvider>("context-provider-registry");
+
+/**
+ * Register a context data provider for an extension.
+ * Call during the extension factory function (not async handlers).
+ * Duplicate ids replace the previous registration.
+ */
+export function registerContextProvider(provider: ContextProvider): void {
+  registry.register(provider.id, provider);
+}
+
+/** Get all registered context providers in registration order. */
+export function getRegisteredContextProviders(): ContextProvider[] {
+  return registry.getAll();
+}
+
+/** Clear the registry — used by tests. */
+export function clearRegisteredContextProviders(): void {
+  registry.clear();
+}

package/node_modules/@mrclrchtr/supi-core/src/context/context-tag.ts

@@ -0,0 +1,31 @@
+// XML context tag wrapping for SuPi extensions.
+//
+// Produces machine-parseable <extension-context> blocks that:
+// - Are LLM-friendly (structured XML)
+// - Carry metadata via attributes (source, file, turn, etc.)
+// - Can be reconstructed from session history via regex
+
+/**
+ * Wrap content in an `<extension-context>` XML tag.
+ *
+ * @param source - Extension identifier (e.g. "supi-claude-md", "supi-lsp")
+ * @param content - The text content to wrap
+ * @param attrs - Optional additional attributes (rendered as key="value")
+ * @returns Formatted XML string
+ */
+export function wrapExtensionContext(
+  source: string,
+  content: string,
+  attrs?: Record<string, string | number>,
+): string {
+  const attrParts = [`source="${source}"`];
+
+  if (attrs) {
+    for (const [key, value] of Object.entries(attrs)) {
+      attrParts.push(`${key}="${String(value)}"`);
+    }
+  }
+
+  const openTag = `<extension-context ${attrParts.join(" ")}>`;
+  return `${openTag}\n${content}\n</extension-context>`;
+}

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

@@ -0,0 +1,255 @@
+// Shared debug event registry for SuPi extensions.
+//
+// Extensions record session-local diagnostic events here. The user-facing
+// supi-debug extension owns policy/configuration and exposes events through a
+// command/tool while this module stays dependency-free for producers.
+
+export type DebugLevel = "debug" | "info" | "warning" | "error";
+export type DebugAgentAccess = "off" | "sanitized" | "raw";
+export type DebugNotifyLevel = "off" | "warning" | "error";
+
+export interface DebugRegistryConfig {
+  /** Whether producers should retain debug events. */
+  enabled: boolean;
+  /** What the agent-callable debug tool may return. */
+  agentAccess: DebugAgentAccess;
+  /** Maximum number of session-local events to keep in memory. */
+  maxEvents: number;
+  /** Minimum level that should notify the user; interpreted by UI extensions. */
+  notifyLevel: DebugNotifyLevel;
+}
+
+export const DEBUG_REGISTRY_DEFAULTS: DebugRegistryConfig = {
+  enabled: false,
+  agentAccess: "sanitized",
+  maxEvents: 100,
+  notifyLevel: "off",
+};
+
+export interface DebugEventInput {
+  source: string;
+  level: DebugLevel;
+  category: string;
+  message: string;
+  cwd?: string;
+  data?: unknown;
+  rawData?: unknown;
+}
+
+export interface DebugEvent extends DebugEventInput {
+  id: number;
+  timestamp: number;
+  data?: unknown;
+  rawData?: unknown;
+}
+
+export interface DebugEventQuery {
+  source?: string;
+  level?: DebugLevel;
+  category?: string;
+  limit?: number;
+  includeRaw?: boolean;
+  allowRaw?: boolean;
+}
+
+export interface DebugEventView {
+  id: number;
+  timestamp: number;
+  source: string;
+  level: DebugLevel;
+  category: string;
+  message: string;
+  cwd?: string;
+  data?: unknown;
+  rawData?: unknown;
+}
+
+export interface DebugEventQueryResult {
+  events: DebugEventView[];
+  rawAccessDenied: boolean;
+}
+
+export interface DebugSummary {
+  total: number;
+  byLevel: Partial<Record<DebugLevel, number>>;
+  bySource: Record<string, number>;
+}
+
+interface DebugRegistryState {
+  config: DebugRegistryConfig;
+  events: DebugEvent[];
+  nextId: number;
+}
+
+const REGISTRY_KEY = Symbol.for("@mrclrchtr/supi-core/debug-registry");
+const SECRET_KEY_RE = /(?:token|password|passwd|secret|api[_-]?key|authorization|credential)/i;
+const ENV_SECRET_RE =
+  /\b([A-Za-z0-9_]*(?:token|password|passwd|secret|api[_-]?key|authorization|credential)[A-Za-z0-9_]*)=(?:'[^']*'|"[^"]*"|\S+)/gi;
+const AUTH_HEADER_RE = /\b(authorization\s*[:=]\s*)(?:bearer\s+)?[^\s;&|]+/gi;
+const URL_SECRET_RE =
+  /([?&](?:token|password|passwd|secret|api[_-]?key|authorization|credential)=)[^&\s]+/gi;
+const REDACTED = "[REDACTED]";
+
+function cloneConfig(config: DebugRegistryConfig): DebugRegistryConfig {
+  return { ...config };
+}
+
+function getState(): DebugRegistryState {
+  let state = (globalThis as Record<symbol, unknown>)[REGISTRY_KEY] as
+    | DebugRegistryState
+    | undefined;
+  if (!state) {
+    state = {
+      config: cloneConfig(DEBUG_REGISTRY_DEFAULTS),
+      events: [],
+      nextId: 1,
+    };
+    (globalThis as Record<symbol, unknown>)[REGISTRY_KEY] = state;
+  }
+  return state;
+}
+
+function normalizeMaxEvents(value: number): number {
+  if (!Number.isFinite(value) || value <= 0) {
+    return DEBUG_REGISTRY_DEFAULTS.maxEvents;
+  }
+  return Math.floor(value);
+}
+
+function trimToMaxEvents(state: DebugRegistryState): void {
+  const maxEvents = normalizeMaxEvents(state.config.maxEvents);
+  if (state.events.length <= maxEvents) {
+    return;
+  }
+  state.events.splice(0, state.events.length - maxEvents);
+}
+
+function matchesQuery(event: DebugEvent, query: DebugEventQuery): boolean {
+  if (query.source && event.source !== query.source) return false;
+  if (query.level && event.level !== query.level) return false;
+  if (query.category && event.category !== query.category) return false;
+  return true;
+}
+
+function sanitizeString(value: string): string {
+  return value
+    .replace(ENV_SECRET_RE, (_match, key: string) => `${key}=${REDACTED}`)
+    .replace(AUTH_HEADER_RE, (_match, prefix: string) => `${prefix}${REDACTED}`)
+    .replace(URL_SECRET_RE, (_match, prefix: string) => `${prefix}${REDACTED}`);
+}
+
+function redactValue(value: unknown, depth: number): unknown {
+  if (depth <= 0) return "[MaxDepth]";
+  if (typeof value === "string") return sanitizeString(value);
+  if (typeof value !== "object" || value === null) return value;
+  if (Array.isArray(value)) return value.map((item) => redactValue(item, depth - 1));
+
+  const redacted: Record<string, unknown> = {};
+  for (const [key, item] of Object.entries(value)) {
+    redacted[key] = SECRET_KEY_RE.test(key) ? REDACTED : redactValue(item, depth - 1);
+  }
+  return redacted;
+}
+
+/** Configure the shared debug registry. Existing events are trimmed to the new max size. */
+export function configureDebugRegistry(config: Partial<DebugRegistryConfig>): DebugRegistryConfig {
+  const state = getState();
+  state.config = {
+    ...state.config,
+    ...config,
+    maxEvents: normalizeMaxEvents(config.maxEvents ?? state.config.maxEvents),
+  };
+  trimToMaxEvents(state);
+  return getDebugRegistryConfig();
+}
+
+/** Return the active debug registry configuration. */
+export function getDebugRegistryConfig(): DebugRegistryConfig {
+  return cloneConfig(getState().config);
+}
+
+/** Best-effort redaction helper for data exposed through sanitized debug views. */
+export function redactDebugData<T>(value: T): T {
+  return redactValue(value, 8) as T;
+}
+
+/** Record a session-local debug event if debugging is enabled. */
+export function recordDebugEvent(input: DebugEventInput): DebugEvent | null {
+  const state = getState();
+  if (!state.config.enabled) {
+    return null;
+  }
+
+  const event: DebugEvent = {
+    ...input,
+    id: state.nextId++,
+    timestamp: Date.now(),
+    data: input.data === undefined ? undefined : redactDebugData(input.data),
+  };
+  state.events.push(event);
+  trimToMaxEvents(state);
+  return { ...event };
+}
+
+/** Query retained debug events newest-first. Results are sanitized unless raw access is requested and allowed. */
+export function getDebugEvents(query: DebugEventQuery = {}): DebugEventQueryResult {
+  const state = getState();
+  const allowRaw = Boolean(
+    query.includeRaw && query.allowRaw && state.config.agentAccess === "raw",
+  );
+  const rawAccessDenied = Boolean(query.includeRaw && !allowRaw);
+  const limit = query.limit && query.limit > 0 ? Math.floor(query.limit) : state.config.maxEvents;
+
+  const events = state.events
+    .filter((event) => matchesQuery(event, query))
+    .slice()
+    .reverse()
+    .slice(0, limit)
+    .map((event): DebugEventView => {
+      const view: DebugEventView = {
+        id: event.id,
+        timestamp: event.timestamp,
+        source: event.source,
+        level: event.level,
+        category: event.category,
+        message: event.message,
+        cwd: event.cwd,
+        data: event.data,
+      };
+      if (allowRaw && event.rawData !== undefined) {
+        view.rawData = event.rawData;
+      }
+      return view;
+    });
+
+  return { events, rawAccessDenied };
+}
+
+/** Return aggregate debug counts suitable for summary displays. */
+export function getDebugSummary(): DebugSummary | null {
+  const events = getState().events;
+  if (events.length === 0) {
+    return null;
+  }
+
+  const summary: DebugSummary = { total: events.length, byLevel: {}, bySource: {} };
+  for (const event of events) {
+    summary.byLevel[event.level] = (summary.byLevel[event.level] ?? 0) + 1;
+    summary.bySource[event.source] = (summary.bySource[event.source] ?? 0) + 1;
+  }
+  return summary;
+}
+
+/** Clear retained events while preserving configuration. */
+export function clearDebugEvents(): void {
+  const state = getState();
+  state.events = [];
+}
+
+/** Reset the debug registry to defaults; intended for tests. */
+export function resetDebugRegistry(): void {
+  const state = getState();
+  state.config = cloneConfig(DEBUG_REGISTRY_DEFAULTS);
+  state.events = [];
+  state.nextId = 1;
+}

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

@@ -0,0 +1 @@
+export { registerSettingsCommand as default } from "./settings/settings-command.ts";

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

@@ -0,0 +1,85 @@
+// supi-core — shared infrastructure for SuPi extensions.
+// Provides XML context tag wrapping, unified config system, context-message utilities,
+// and settings registry for supi-wide TUI settings.
+
+export type { SupiConfigLocation, SupiConfigOptions } from "./config/config.ts";
+export {
+  loadSupiConfig,
+  loadSupiConfigForScope,
+  removeSupiConfigKey,
+  writeSupiConfig,
+} from "./config/config.ts";
+export type { ConfigSettingsHelpers, ConfigSettingsOptions } from "./config/config-settings.ts";
+export { registerConfigSettings } from "./config/config-settings.ts";
+export type { ContextMessageLike } from "./context/context-messages.ts";
+export {
+  findLastUserMessageIndex,
+  getContextToken,
+  getPromptContent,
+  pruneAndReorderContextMessages,
+  restorePromptContent,
+} from "./context/context-messages.ts";
+export type { ContextProvider } from "./context/context-provider-registry.ts";
+export {
+  clearRegisteredContextProviders,
+  getRegisteredContextProviders,
+  registerContextProvider,
+} from "./context/context-provider-registry.ts";
+export { wrapExtensionContext } from "./context/context-tag.ts";
+export type {
+  DebugAgentAccess,
+  DebugEvent,
+  DebugEventInput,
+  DebugEventQuery,
+  DebugEventQueryResult,
+  DebugEventView,
+  DebugLevel,
+  DebugNotifyLevel,
+  DebugRegistryConfig,
+  DebugSummary,
+} from "./debug-registry.ts";
+export {
+  clearDebugEvents,
+  configureDebugRegistry,
+  DEBUG_REGISTRY_DEFAULTS,
+  getDebugEvents,
+  getDebugRegistryConfig,
+  getDebugSummary,
+  recordDebugEvent,
+  redactDebugData,
+  resetDebugRegistry,
+} from "./debug-registry.ts";
+export { fileToUri, resolveToolPath, stripToolPathPrefix, uriToFile } from "./path-utils.ts";
+export type { KnownRootEntry } from "./project-roots.ts";
+export {
+  buildKnownRootsMap,
+  byPathDepth,
+  dedupeTopmostRoots,
+  findProjectRoot,
+  isWithin,
+  isWithinOrEqual,
+  mergeKnownRoots,
+  resolveKnownRoot,
+  segmentCount,
+  sortRootsBySpecificity,
+  walkProject,
+} from "./project-roots.ts";
+export { createRegistry, createSessionStateRegistry } from "./registry-utils.ts";
+export { getActiveBranchEntries } from "./session-utils.ts";
+export { registerSettingsCommand } from "./settings/settings-command.ts";
+export type { SettingsScope, SettingsSection } from "./settings/settings-registry.ts";
+export {
+  clearRegisteredSettings,
+  getRegisteredSettings,
+  registerSettings,
+} from "./settings/settings-registry.ts";
+export { createInputSubmenu, openSettingsOverlay } from "./settings/settings-ui.ts";
+export type { TitleTarget } from "./terminal.ts";
+export {
+  DONE_SYMBOL,
+  formatTitle,
+  signalBell,
+  signalDone,
+  signalWaiting,
+  WAITING_SYMBOL,
+} from "./terminal.ts";

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

@@ -0,0 +1,40 @@
+import * as path from "node:path";
+
+/** Strip pi's optional leading `@` file-path prefix from a tool input. */
+export function stripToolPathPrefix(target: string): string {
+  return target.startsWith("@") ? target.slice(1) : target;
+}
+
+/**
+ * Resolve a tool-style file path from a session cwd.
+ *
+ * Built-in pi file tools accept a leading `@` prefix in path arguments, so
+ * shared SuPi path helpers normalize that prefix before resolving relative
+ * paths.
+ */
+export function resolveToolPath(cwd: string, target: string): string {
+  return path.resolve(cwd, stripToolPathPrefix(target));
+}
+
+/** Convert a file path to a file:// URI. */
+export function fileToUri(filePath: string): string {
+  const resolved = path.resolve(filePath);
+  if (process.platform === "win32") {
+    return `file:///${resolved.replace(/\\/g, "/")}`;
+  }
+  return `file://${resolved}`;
+}
+
+/** Convert a file:// URI to a file path. */
+export function uriToFile(uri: string): string {
+  if (!uri.startsWith("file://")) return uri;
+  let filePath = decodeURIComponent(uri.slice(7));
+  if (
+    process.platform === "win32" &&
+    filePath.startsWith("/") &&
+    /^[A-Za-z]:/.test(filePath.slice(1))
+  ) {
+    filePath = filePath.slice(1);
+  }
+  return filePath;
+}