@mrclrchtr/supi-code-intelligence 1.8.0 → 1.9.0

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/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;
+}

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

@@ -0,0 +1,2 @@
+// supi-core path domain — file and URI path utilities.
+export { fileToUri, resolveToolPath, stripToolPathPrefix, uriToFile } from "./path-utils.ts";

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

@@ -0,0 +1,170 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const IGNORED_DIRECTORIES = new Set(["node_modules", ".git", ".pnpm"]);
+
+/**
+ * Walk a project directory tree, calling `onDirectory` for each directory.
+ * Skips `node_modules`, `.git`, and `.pnpm`.
+ * Stops at depth 0.
+ */
+export function walkProject(
+  directory: string,
+  depth: number,
+  onDirectory: (directory: string, entryNames: Set<string>) => void,
+): void {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  const entryNames = new Set(entries.map((entry) => entry.name));
+  onDirectory(directory, entryNames);
+
+  if (depth <= 0) return;
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (IGNORED_DIRECTORIES.has(entry.name)) continue;
+    walkProject(path.join(directory, entry.name), depth - 1, onDirectory);
+  }
+}
+
+/**
+ * Search upward from `startDir` for any of the `markers` files/dirs.
+ * Returns the directory containing the first found marker, or `fallback`.
+ */
+export function findProjectRoot(startDir: string, markers: string[], fallback: string): string {
+  let dir = path.resolve(startDir);
+  const root = path.parse(dir).root;
+
+  while (dir !== root) {
+    for (const marker of markers) {
+      if (fs.existsSync(path.join(dir, marker))) {
+        return dir;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return fallback;
+}
+
+/**
+ * Deduplicate overlapping roots, keeping only the topmost (shortest path) roots.
+ */
+export function dedupeTopmostRoots(roots: string[]): string[] {
+  const accepted: string[] = [];
+
+  for (const root of [...new Set(roots.map((entry) => path.resolve(entry)))].sort(byPathDepth)) {
+    const isChild = accepted.some((parent) => root !== parent && isWithin(parent, root));
+    if (!isChild) {
+      accepted.push(root);
+    }
+  }
+
+  return accepted;
+}
+
+/**
+ * Minimal shape accepted by `buildKnownRootsMap`.
+ * Structurally compatible with `DetectedProjectServer` and similar
+ * `{ name, root }` records — callers may pass a wider type safely.
+ */
+export type KnownRootEntry = { name: string; root: string };
+
+/**
+ * Build a map of language/server name to sorted, deduplicated root paths.
+ *
+ * Accepts an array of detected project entries (e.g. from LSP project discovery)
+ * and groups them by name with roots sorted by specificity.
+ */
+export function buildKnownRootsMap(detected: KnownRootEntry[]): Map<string, string[]> {
+  const next = new Map<string, string[]>();
+
+  for (const entry of detected) {
+    const roots = next.get(entry.name) ?? [];
+    if (!roots.includes(entry.root)) roots.push(entry.root);
+    next.set(entry.name, sortRootsBySpecificity(roots));
+  }
+
+  return next;
+}
+
+/**
+ * Merge a new root into an existing list, deduplicating and sorting.
+ *
+ * Returns the original reference when the root is already present.
+ */
+export function mergeKnownRoots(roots: string[], root: string): string[] {
+  if (roots.includes(root)) return roots;
+  return sortRootsBySpecificity([...roots, root]);
+}
+
+/**
+ * Resolve the most specific known root that contains `filePath`.
+ *
+ * Searches the given roots list (presumed sorted by specificity) and returns
+ * the first root that contains or equals `filePath`.
+ *
+ * @returns The matching root string, or `null` when none match.
+ */
+export function resolveKnownRoot(filePath: string, roots: string[]): string | null {
+  const resolvedPath = path.resolve(filePath);
+  return roots.find((root) => isWithinOrEqual(root, resolvedPath)) ?? null;
+}
+
+/**
+ * Sort roots by specificity (deepest/longest first), then alphabetically.
+ *
+ * Deduplicates by resolved path before sorting.
+ */
+export function sortRootsBySpecificity(roots: string[]): string[] {
+  return [...new Set(roots.map((root) => path.resolve(root)))].sort(
+    (a, b) => b.length - a.length || a.localeCompare(b),
+  );
+}
+
+/**
+ * Check if `child` is strictly inside `parent`.
+ *
+ * Returns `true` when `child` is a subdirectory of `parent`.
+ * Returns `false` for the same path.
+ */
+export function isWithin(parent: string, child: string): boolean {
+  const relative = path.relative(parent, child);
+  return relative !== "" && !relative.startsWith(`..${path.sep}`) && relative !== "..";
+}
+
+/**
+ * Check if `filePath` is inside `root` or is the same path.
+ *
+ * Combines exact-path equality with `isWithin` semantics.
+ */
+export function isWithinOrEqual(root: string, filePath: string): boolean {
+  const relative = path.relative(root, filePath);
+  return relative === "" || isWithin(root, filePath);
+}
+
+/**
+ * Comparator for sorting paths by depth (shallowest first), then alphabetically.
+ *
+ * Useful with `.sort()` on arrays of path strings.
+ */
+export function byPathDepth(a: string, b: string): number {
+  const depthDiff = segmentCount(a) - segmentCount(b);
+  return depthDiff !== 0 ? depthDiff : a.localeCompare(b);
+}
+
+/**
+ * Count path segments in a resolved absolute path.
+ *
+ * @example segmentCount("/a/b/c") // 3
+ */
+export function segmentCount(target: string): number {
+  return path.resolve(target).split(path.sep).filter(Boolean).length;
+}

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

@@ -0,0 +1,15 @@
+// supi-core project domain — project root discovery and traversal.
+export type { KnownRootEntry } from "./project-roots.ts";
+export {
+  buildKnownRootsMap,
+  byPathDepth,
+  dedupeTopmostRoots,
+  findProjectRoot,
+  isWithin,
+  isWithinOrEqual,
+  mergeKnownRoots,
+  resolveKnownRoot,
+  segmentCount,
+  sortRootsBySpecificity,
+  walkProject,
+} from "./project-roots.ts";

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

@@ -0,0 +1,86 @@
+// 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.
+
+import * as path from "node:path";
+
+const SYMBOL_PREFIX = "@mrclrchtr/supi-core/";
+
+function getGlobalRegistryMap<T>(name: string): Map<string, T> {
+  const key = Symbol.for(SYMBOL_PREFIX + name);
+  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;
+}
+
+/**
+ * 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 getMap = (): Map<string, T> => getGlobalRegistryMap<T>(name);
+
+  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();
+    },
+  };
+}
+
+/**
+ * Create a named session-state registry keyed by normalized cwd.
+ *
+ * This helper is intended for session-scoped runtime services that should be
+ * shared across duplicate jiti module instances while keeping package-specific
+ * state unions and convenience wrappers local to the calling package.
+ */
+export function createSessionStateRegistry<TState>(name: string) {
+  const getMap = (): Map<string, TState> => getGlobalRegistryMap<TState>(name);
+  const normalizeCwd = (cwd: string): string => path.resolve(cwd);
+
+  return {
+    /** Get the current state for one session cwd. */
+    get: (cwd: string): TState | undefined => {
+      return getMap().get(normalizeCwd(cwd));
+    },
+
+    /** Store the current state for one session cwd. */
+    set: (cwd: string, state: TState): void => {
+      getMap().set(normalizeCwd(cwd), state);
+    },
+
+    /** Clear the current state for one session cwd. */
+    clear: (cwd: string): void => {
+      getMap().delete(normalizeCwd(cwd));
+    },
+  };
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/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-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/session.ts

@@ -0,0 +1,4 @@
+// supi-core session domain — session utilities and registries.
+
+export { createRegistry, createSessionStateRegistry } from "./registry-utils.ts";
+export { getActiveBranchEntries } from "./session-utils.ts";

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/settings/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-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/settings/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-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/settings/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-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/settings-ui.ts

@@ -0,0 +1,2 @@
+// supi-core settings-ui domain — settings TUI components (imports pi-tui at runtime, heavy).
+export { createInputSubmenu, openSettingsOverlay } from "./settings/settings-ui.ts";

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

@@ -0,0 +1,9 @@
+// supi-core settings domain — settings registry (lightweight, type-only pi-tui import).
+
+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";

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

@@ -0,0 +1,11 @@
+/** 0-based position used by LSP and code-intelligence internally. */
+export interface CodePosition {
+  line: number;
+  character: number;
+}
+
+/** Normalized location — flat replacement for LSP's nested Location/range shape. */
+export interface CodeLocation {
+  uri: string;
+  range: { start: CodePosition; end: CodePosition };
+}