@mrclrchtr/supi-web 7.1.1 → 7.2.1

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

@@ -0,0 +1,356 @@
+import { createHash } from "node:crypto";
+import type {
+  Api,
+  AssistantMessage,
+  Context,
+  Model,
+  ModelsApiStreamOptions,
+  ModelsSimpleStreamOptions,
+  ProviderHeaders,
+} from "@earendil-works/pi-ai";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { TSchema } from "typebox";
+import { Value } from "typebox/value";
+
+// Shared LLM utilities for SuPi extensions.
+//
+// Provides PI-owned model requests, retry logic, structured LLM call helpers,
+// and other common patterns for extensions that interact with AI models.
+
+const MODEL_REQUEST_NAMESPACE = "supi-direct-model-request-v1";
+
+type ModelRequestOptions<T> = Omit<T, "apiKey" | "env" | "sessionId"> & {
+  /** Stable feature scope. Do not include prompt, turn, or retry data. */
+  affinityScope: string;
+  /** PI owns these fields, including for APIs with open-ended option types. */
+  apiKey?: never;
+  env?: never;
+  sessionId?: never;
+};
+
+/** API-specific completion options. PI owns auth, environment, and identity. */
+export type CompleteModelRequestOptions<TApi extends Api = Api> = ModelRequestOptions<
+  ModelsApiStreamOptions<TApi>
+>;
+
+/** Provider-neutral completion options. PI owns auth, environment, and identity. */
+export type CompleteSimpleModelRequestOptions = ModelRequestOptions<ModelsSimpleStreamOptions>;
+
+function createModelRequestAffinityId(
+  sessionId: string,
+  affinityScope: string,
+  model: Model<Api>,
+): string {
+  const material = JSON.stringify([
+    MODEL_REQUEST_NAMESPACE,
+    sessionId,
+    affinityScope,
+    model.provider,
+    model.id,
+  ]);
+  const digest = createHash("sha256").update(material, "utf8").digest("hex");
+  return `supi-${digest.slice(0, 56)}`;
+}
+
+function isOpenCodeModel(model: Model<Api>): boolean {
+  if (model.provider === "opencode" || model.provider === "opencode-go") return true;
+
+  try {
+    return new URL(model.baseUrl).hostname === "opencode.ai";
+  } catch {
+    return false;
+  }
+}
+
+function hasHeader(headers: ProviderHeaders, name: string): boolean {
+  const lowerName = name.toLowerCase();
+  return Object.keys(headers).some((headerName) => headerName.toLowerCase() === lowerName);
+}
+
+function addOpenCodeDefaultHeaders(
+  model: Model<Api>,
+  affinityId: string,
+  headers: ProviderHeaders,
+): ProviderHeaders {
+  if (!isOpenCodeModel(model)) return headers;
+
+  const result = { ...headers };
+  if (!hasHeader(result, "x-opencode-session")) {
+    result["x-opencode-session"] = affinityId;
+  }
+  if (!hasHeader(result, "x-opencode-client")) {
+    result["x-opencode-client"] = "pi";
+  }
+  return result;
+}
+
+/** Keep request identity and header policy identical for both completion paths. */
+function prepareModelRequestOptions<
+  T extends Pick<ModelsSimpleStreamOptions, "signal" | "transformHeaders">,
+>(ctx: ExtensionContext, model: Model<Api>, options: ModelRequestOptions<T>): T {
+  const { affinityScope, transformHeaders: callerTransformHeaders, ...requestOptions } = options;
+  const safeRequestOptions = { ...requestOptions };
+  delete safeRequestOptions.apiKey;
+  delete safeRequestOptions.env;
+  delete safeRequestOptions.sessionId;
+
+  const affinityId = createModelRequestAffinityId(
+    ctx.sessionManager.getSessionId(),
+    affinityScope,
+    model,
+  );
+  const transformHeaders = async (headers: ProviderHeaders): Promise<ProviderHeaders> => {
+    const transformed = callerTransformHeaders ? await callerTransformHeaders(headers) : headers;
+    return addOpenCodeDefaultHeaders(model, affinityId, transformed);
+  };
+
+  // Restore PI's option type after removing owned fields.
+  return {
+    ...safeRequestOptions,
+    signal: safeRequestOptions.signal ?? ctx.signal,
+    sessionId: affinityId,
+    transformHeaders,
+  } as unknown as T;
+}
+
+/**
+ * Complete an API-specific request through PI's model registry.
+ *
+ * PI resolves auth, headers, environment, and the effective endpoint. SuPi adds
+ * a stable opaque feature identity and OpenCode header defaults. This helper
+ * does not retry, validate output, or present errors. It supplies no output cap
+ * when `maxTokens` is omitted; use {@link completeSimpleModelRequest} for PI's
+ * model-derived defaults and context-aware limits.
+ */
+export async function completeModelRequest<TApi extends Api>(
+  ctx: ExtensionContext,
+  model: Model<TApi>,
+  context: Context,
+  options: CompleteModelRequestOptions<TApi>,
+): Promise<AssistantMessage> {
+  return ctx.modelRegistry.complete(
+    model,
+    context,
+    prepareModelRequestOptions<ModelsApiStreamOptions<TApi>>(ctx, model, options),
+  );
+}
+
+/**
+ * Complete a provider-neutral request through PI's registry simple path.
+ *
+ * Requires PI 0.86.0 or later. PI's provider handles simple options, including
+ * model-derived output limits and context estimates. Request identity, header
+ * policy, and error behavior match {@link completeModelRequest}.
+ */
+export async function completeSimpleModelRequest(
+  ctx: ExtensionContext,
+  model: Model<Api>,
+  context: Context,
+  options: CompleteSimpleModelRequestOptions,
+): Promise<AssistantMessage> {
+  return ctx.modelRegistry
+    .streamSimple(
+      model,
+      context,
+      prepareModelRequestOptions<ModelsSimpleStreamOptions>(ctx, model, options),
+    )
+    .result();
+}
+
+/**
+ * Options for {@link withRetry}.
+ */
+export interface WithRetryOptions {
+  /** Maximum number of retry attempts after the initial call. Default: 2 */
+  retries?: number;
+  /** Base delay in milliseconds for exponential backoff. Default: 1000 */
+  baseDelayMs?: number;
+  /** AbortSignal to cancel retry loops. */
+  signal?: AbortSignal;
+  /** Called with each failed attempt's attempt index and error. */
+  logger?: (attempt: number, error: unknown) => void;
+  /** Called before each retry delay with attempt index and computed delay. */
+  onRetry?: (attempt: number, delayMs: number) => void;
+}
+
+/**
+ * Create a promise that resolves after `ms` milliseconds, or rejects if
+ * the signal fires before the timeout elapses.
+ */
+function delay(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    if (signal) {
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(new DOMException("Aborted", "AbortError"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+
+/**
+ * Attempt an async operation with retries and exponential backoff.
+ *
+ * If the signal is already aborted on entry, the operation is skipped entirely.
+ * If the signal aborts during a delay, the delay is cancelled immediately.
+ *
+ * @param fn - The async operation to retry.
+ * @param options - Optional configuration for retries, backoff, signal, and callbacks.
+ * @returns The result on success, or `null` if all attempts fail or the signal aborts.
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  options?: WithRetryOptions,
+): Promise<T | null> {
+  const { retries = 2, baseDelayMs = 1000, signal, logger, onRetry } = options ?? {};
+
+  if (signal?.aborted) return null;
+
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      logger?.(attempt, err);
+      if (attempt >= retries || signal?.aborted) continue;
+
+      const delayMs = baseDelayMs * 2 ** attempt;
+      onRetry?.(attempt, delayMs);
+
+      try {
+        await delay(delayMs, signal);
+      } catch {
+        // delay() only rejects on abort
+        return null;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extract and validate JSON from LLM response content blocks.
+ *
+ * Finds the first JSON object `{...}` in the combined text content,
+ * parses it, and validates against a TypeBox schema.
+ *
+ * @param content - The LLM response content blocks.
+ * @param schema - TypeBox schema to validate against.
+ * @returns The parsed and validated result, or `null` if extraction or validation fails.
+ */
+export function extractJsonFromResponse<T extends TSchema>(
+  content: ReadonlyArray<{ type: string; text?: string }>,
+  schema: T,
+): { parsed: import("typebox").Static<T> } | null {
+  const text = content
+    .filter((c): c is { type: "text"; text: string } => c.type === "text")
+    .map((c) => c.text)
+    .join("");
+
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) return null;
+
+  try {
+    const parsed = JSON.parse(jsonMatch[0]);
+    if (Value.Check(schema, parsed)) {
+      return { parsed } as { parsed: import("typebox").Static<T> };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// ── callWithJsonResponse ───────────────────────────────────────────────────
+
+/**
+ * Options for {@link callWithJsonResponse}.
+ */
+export interface CallWithJsonResponseOptions {
+  /** The prompt to send to the LLM. */
+  prompt: string;
+  /** Stable feature scope for request affinity. Do not include prompt or retry data. */
+  affinityScope: string;
+  /** Optional data context appended to the prompt. */
+  dataContext?: string;
+  /** Maximum tokens for the response. Default: 4096 */
+  maxTokens?: number;
+  /** System prompt for the LLM call. Default: "" */
+  systemPrompt?: string;
+  /** Number of retries for the LLM call. Default: 2 */
+  retries?: number;
+}
+
+/**
+ * Call the LLM with a prompt and validate the JSON response against a TypeBox schema.
+ *
+ * Handles model resolution, retry via `withRetry`, text extraction, JSON
+ * matching, and TypeBox validation. The request itself stays under PI
+ * registry authority through {@link completeModelRequest}.
+ *
+ * Returns `null` when:
+ * - No model is available
+ * - All retries fail
+ * - Response contains no valid JSON
+ * - JSON doesn't match the schema
+ * - The request is aborted
+ *
+ * @param ctx - The extension context for model selection and PI registry access.
+ * @param options - Call options including prompt, schema, and retry config.
+ * @param schema - TypeBox schema to validate the JSON response against.
+ * @returns The parsed and validated result, or `null`.
+ */
+export async function callWithJsonResponse<T extends TSchema>(
+  ctx: ExtensionContext,
+  options: CallWithJsonResponseOptions,
+  schema: T,
+): Promise<{ parsed: import("typebox").Static<T> } | null> {
+  const {
+    prompt,
+    affinityScope,
+    dataContext,
+    maxTokens = 4096,
+    systemPrompt = "",
+    retries = 2,
+  } = options;
+
+  const model = ctx.model ?? ctx.modelRegistry.getAvailable()[0] ?? null;
+  if (!model) return null;
+
+  const fullPrompt = dataContext
+    ? `${prompt}
+
+DATA:
+${dataContext}`
+    : prompt;
+
+  const response = await withRetry(
+    async () =>
+      completeModelRequest(
+        ctx,
+        model,
+        {
+          systemPrompt,
+          messages: [
+            {
+              role: "user",
+              content: [{ type: "text", text: fullPrompt }],
+              timestamp: Date.now(),
+            },
+          ],
+        },
+        {
+          affinityScope,
+          signal: ctx.signal,
+          maxTokens,
+        },
+      ),
+    { retries, baseDelayMs: 1000, signal: ctx.signal },
+  );
+
+  if (!response) return null;
+
+  return extractJsonFromResponse(response.content, schema);
+}

package/node_modules/@mrclrchtr/supi-core/src/model-selection.ts

@@ -0,0 +1,134 @@
+/**
+ * Shared model-selection helpers for SuPi extensions.
+ *
+ * Provides scoped-model listing using PI's `enabledModels` configuration,
+ * matching the same semantics as the `@mrclrchtr/supi-review` model picker.
+ *
+ * @module
+ */
+
+import type { Model } from "@earendil-works/pi-ai/compat";
+import { type ExtensionContext, SettingsManager } from "@earendil-works/pi-coding-agent";
+
+// ── Types ──────────────────────────────────────────────────────────────────
+
+/** A selectable model entry with display metadata. */
+export interface ModelSelection {
+  /** Canonical `provider/model-id` string. */
+  canonicalId: string;
+  /** Provider name, e.g. `"anthropic"`. */
+  provider: string;
+  /** Model id, e.g. `"claude-sonnet-4-5"`. */
+  id: string;
+  // biome-ignore lint/suspicious/noExplicitAny: Model<any> is pi's canonical type
+  model: Model<any>;
+  /** Human-readable label (model name or canonicalId). */
+  label: string;
+  /** Optional description (canonicalId when different from label). */
+  description?: string;
+  /** Whether this model is the current session model. */
+  isCurrent: boolean;
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+/** Build the canonical `provider/model-id` string. */
+export function toCanonicalModelId(
+  model: Pick<NonNullable<ExtensionContext["model"]>, "provider" | "id">,
+): string {
+  return `${model.provider}/${model.id}`;
+}
+
+/**
+ * List selectable models from PI's scoped model configuration.
+ *
+ * Only models that match the configured `enabledModels` patterns are offered.
+ * The current session model is included only when it is inside that scoped set.
+ * Returns an empty array when no scoped model patterns are configured.
+ */
+export function getSelectableModels(
+  ctx: Pick<ExtensionContext, "cwd" | "modelRegistry" | "model">,
+  enabledModelPatterns = SettingsManager.create(ctx.cwd).getEnabledModels(),
+): ModelSelection[] {
+  if (!enabledModelPatterns || enabledModelPatterns.length === 0) {
+    return [];
+  }
+
+  const byCanonicalId = new Map<string, ModelSelection>();
+  const availableModels = filterByEnabledModels(
+    enabledModelPatterns,
+    ctx.modelRegistry.getAvailable(),
+  );
+
+  const addModel = (
+    // biome-ignore lint/suspicious/noExplicitAny: Model<any> is pi's canonical type
+    model: Model<any>,
+    isCurrent: boolean,
+  ) => {
+    const canonicalId = toCanonicalModelId(model);
+    const existing = byCanonicalId.get(canonicalId);
+    if (existing) {
+      if (isCurrent) existing.isCurrent = true;
+      return;
+    }
+
+    byCanonicalId.set(canonicalId, {
+      canonicalId,
+      provider: model.provider,
+      id: model.id,
+      model,
+      label: model.name ?? canonicalId,
+      description: canonicalId,
+      isCurrent,
+    });
+  };
+
+  if (ctx.model && matchModelPatterns(ctx.model, enabledModelPatterns)) {
+    addModel(ctx.model, true);
+  }
+
+  for (const model of availableModels) {
+    addModel(
+      model,
+      ctx.model ? toCanonicalModelId(model) === toCanonicalModelId(ctx.model) : false,
+    );
+  }
+
+  return Array.from(byCanonicalId.values()).sort((a, b) => {
+    if (a.isCurrent !== b.isCurrent) return a.isCurrent ? -1 : 1;
+    return a.canonicalId.localeCompare(b.canonicalId);
+  });
+}
+
+// ── Private helpers ────────────────────────────────────────────────────────
+
+function filterByEnabledModels<T extends { provider: string; id: string }>(
+  patterns: string[],
+  models: T[],
+): T[] {
+  return models.filter((model) => matchModelPatterns(model, patterns));
+}
+
+function matchModelPatterns(model: { provider: string; id: string }, patterns: string[]): boolean {
+  return patterns.some((pattern) => matchModelPattern(model, pattern));
+}
+
+function matchModelPattern(model: { provider: string; id: string }, pattern: string): boolean {
+  const canonicalId = `${model.provider}/${model.id}`;
+  if (pattern.includes("/")) {
+    return simpleGlobMatch(canonicalId, pattern);
+  }
+  return simpleGlobMatch(model.id, pattern) || simpleGlobMatch(canonicalId, pattern);
+}
+
+function simpleGlobMatch(text: string, pattern: string): boolean {
+  if (!pattern.includes("*") && !pattern.includes("?")) {
+    return text.toLowerCase() === pattern.toLowerCase();
+  }
+
+  const regex = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, ".*")
+    .replace(/\?/g, ".");
+  return new RegExp(`^${regex}$`, "i").test(text);
+}

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

@@ -0,0 +1,44 @@
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+/** 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.
+ *
+ * Uses Node's `pathToFileURL` to produce a standards-compliant URI with
+ * proper percent-encoding of spaces, hashes, and other special characters.
+ */
+export function fileToUri(filePath: string): string {
+  return pathToFileURL(filePath).href;
+}
+
+/**
+ * Convert a file:// URI to a file path.
+ *
+ * Uses Node's `fileURLToPath` for standards-compliant decoding. Non-file
+ * URIs are passed through unchanged so consumers (such as LSP diagnostic
+ * handling) remain compatible with non-file URI schemes.
+ */
+export function uriToFile(uri: string): string {
+  if (!uri.startsWith("file://")) return uri;
+  try {
+    return fileURLToPath(uri);
+  } catch {
+    return uri;
+  }
+}

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