@visual-z/xeno 0.8.4 → 0.9.1

package/src/core/observation-view.ts

@@ -1,152 +0,0 @@
-/**
- * How a bounded observation is presented to the model.
- *
- * The complete bytes always live in a blob (D8: reference, never inline), so
- * this is only a view -- but it is the view the model reasons from. Keeping
- * only the head, as this module's predecessor did, cuts exactly the part a
- * failing build or test run prints last: the error and the summary. Codex
- * keeps half of each end (`utils/string/src/truncate.rs`); so does this.
- */
-import type { ArtifactRef } from "./events.ts";
-
-export interface BytePreview {
-  unit: "utf8_bytes";
-  complete: boolean;
-  visible: readonly (readonly [number, number])[];
-  next_offset: number | null;
-}
-const object = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value);
-const natural = (value: unknown): value is number => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-export function isObservationArtifact(value: unknown): value is ArtifactRef {
-  return object(value) && typeof value["sha256"] === "string" && /^[a-f0-9]{64}$/.test(value["sha256"]) && typeof value["path"] === "string" && natural(value["bytes"]);
-}
-/** The same coverage invariant serves file reads and search projections. */
-export function isBytePreview(value: unknown, total: number): value is BytePreview {
-  if (!object(value) || value["unit"] !== "utf8_bytes" || typeof value["complete"] !== "boolean" || !Array.isArray(value["visible"])) return false;
-  let last = 0, prefix = 0;
-  for (const range of value["visible"]) {
-    if (!Array.isArray(range) || range.length !== 2 || !natural(range[0]) || !natural(range[1]) || range[0] < last || range[1] <= range[0] || range[1] > total) return false;
-    if (prefix === range[0]) prefix = range[1];
-    last = range[1];
-  }
-  return value["complete"] === (prefix === total) && value["next_offset"] === (value["complete"] ? null : prefix);
-}
-
-/** A UTF-8 continuation byte: cutting before one would split a character. */
-const continuation = (byte: number | undefined) => byte !== undefined && (byte & 0xc0) === 0x80;
-
-/**
- * Head and tail of an observation within `limit` bytes.
- *
- * `head` is the first bytes and `tail` the last bytes of an observation of
- * `total` bytes; each need only be as long as `limit`. When the whole
- * observation fits, it is returned unchanged. Otherwise the marker, which is
- * given the omitted byte count and the byte offset where the gap starts (so
- * the model can page the missing middle back), sits between the two ends.
- * Cuts land on character boundaries, which is why a view can come out a few
- * bytes under budget but never over it for valid UTF-8 input.
- */
-export function headTailView(
-  head: Uint8Array,
-  tail: Uint8Array,
-  total: number,
-  limit: number,
-  marker: (omitted: number, offset: number) => string,
-): string {
-  // Legacy command callers require the recovery locator even below its minimum display budget.
-  return headTailSelection(head, tail, total, limit, marker, true).text;
-}
-
-/** Half-open byte ranges in the original observation, excluding presentation markers. */
-export function headTailSelection(
-  head: Uint8Array, tail: Uint8Array, total: number, limit: number,
-  marker: (omitted: number, offset: number) => string, allowOversizeMarker = false,
-): { text: string; visible: [number, number][] } {
-  const decoder = new TextDecoder();
-  if (total <= limit && head.length >= total) return { text: decoder.decode(head.subarray(0, total)), visible: total ? [[0, total]] : [] };
-  // Digits of the real numbers never exceed digits of `total`, so this bounds
-  // the marker before the cut points that decide its numbers are known.
-  const reserve = new TextEncoder().encode(marker(total, total)).length;
-  if (reserve > limit && !allowOversizeMarker) {
-    const bytes = new TextEncoder().encode(marker(total, 0));
-    let end = Math.max(0, Math.min(Math.floor(limit), bytes.length));
-    while (end > 0 && continuation(bytes[end])) end--;
-    return { text: decoder.decode(bytes.subarray(0, end)), visible: [] };
-  }
-  const budget = Math.max(0, limit - reserve);
-  let headEnd = Math.min(Math.floor(budget / 2), head.length);
-  while (headEnd > 0 && continuation(head[headEnd])) headEnd--;
-  let tailStart = tail.length - Math.min(budget - headEnd, tail.length);
-  while (tailStart < tail.length && continuation(tail[tailStart])) tailStart++;
-  const kept = tail.length - tailStart;
-  return { text: decoder.decode(head.subarray(0, headEnd)) +
-    marker(total - headEnd - kept, headEnd) +
-    decoder.decode(tail.subarray(tailStart)),
-    visible: [...(headEnd ? [[0, headEnd] as [number, number]] : []), ...(kept ? [[total - kept, total] as [number, number]] : [])] };
-}
-
-/**
- * The text a terminal would finally show for output that redraws lines with
- * `\r` (progress bars). Within each `\n`-separated line, a carriage return
- * moves back to column 0 and the following characters overwrite, one code
- * point each; characters not overwritten stay. `\r\n` is thus a plain line
- * break. Other control sequences (`ESC[K` and the like) are left as they are.
- *
- * A view only: the archived bytes keep every frame (D8). Without this a 6.3KB
- * brew download of 48 frames reached the model whole (carriage-return-view
- * card), though a terminal showed one line.
- */
-export function foldCarriageReturns(text: string): string {
-  if (!text.includes("\r")) return text;
-  return text.split("\n").map(line => {
-    if (!line.includes("\r")) return line;
-    let screen: string[] = [];
-    for (const frame of line.split("\r")) {
-      const chars = Array.from(frame);
-      screen = chars.concat(screen.slice(chars.length));
-    }
-    return screen.join("");
-  }).join("\n");
-}
-
-/** Signals a shell reports as 128+n; the common ones a model can act on. */
-const SIGNALS: Readonly<Record<number, string>> = {
-  1: "SIGHUP", 2: "SIGINT", 6: "SIGABRT", 9: "SIGKILL", 11: "SIGSEGV", 13: "SIGPIPE", 15: "SIGTERM",
-};
-
-const seconds = (ms: number) => `${Number((ms / 1000).toFixed(1))}s`;
-
-/**
- * First line of a command result.
- *
- * `exit N` stays first because both the TUI and the log readers key on it.
- * What follows states facts the exit code alone hides: a timeout reads as
- * `exit 143`, which a model otherwise takes for the program's own failure and
- * reruns unchanged (codex puts wall time and exit in the same header,
- * `core/src/tools/context.rs`).
- */
-export function commandHeader(input: {
-  exit: number;
-  wallMs: number;
-  stopped?: "timeout" | "cancelled";
-  /** The timeout actually applied. */
-  timeoutMs: number;
-  /** What the model asked for, when that differs from what was applied. */
-  requestedMs?: number;
-  managed?: boolean;
-}): string {
-  const parts = [`exit ${input.exit}`, `${(input.wallMs / 1000).toFixed(1)}s`];
-  if (input.stopped === "timeout") {
-    const requested = input.requestedMs !== undefined && input.requestedMs !== input.timeoutMs
-      ? ` (requested ${seconds(input.requestedMs)}, capped)` : "";
-    // A deadline requests cleanup, but cannot by itself prove absence of
-    // partial side effects or successful cleanup (R3 / R10).
-    parts.push(`timed out after ${seconds(input.timeoutMs)}${requested}; process group cleanup requested; ` +
-      "inspect partial effects and cleanup before deciding on a new invocation or a larger timeout");
-  } else if (input.stopped === "cancelled") {
-    parts.push("cancelled; process group cleanup requested");
-  } else if (input.exit > 128 && SIGNALS[input.exit - 128] !== undefined) {
-    parts.push(`128+${input.exit - 128}: likely terminated by ${SIGNALS[input.exit - 128]}`);
-  }
-  return parts.join(" · ");
-}

package/src/core/outcome.ts

@@ -1,44 +0,0 @@
-/** O.1 / D11: execution termination is a fact, distinct from verified work. */
-const STATUS = {
-  model_end: "completed",
-  tool_completed: "completed",
-  cancelled: "cancelled",
-  not_started: "cancelled",
-  max_turns: "stopped",
-  context_budget: "stopped",
-  stalled: "stopped",
-  no_progress: "stopped",
-  output_limit: "stopped",
-  timeout: "stopped",
-  model_refusal: "failed",
-  provider_error: "failed",
-  execution_error: "failed",
-  projection_invalid: "failed",
-  tool_failed: "failed",
-  unknown: "unknown",
-} as const;
-
-export type ExecutionReason = keyof typeof STATUS;
-export type ExecutionOutcome = {
-  status: (typeof STATUS)[ExecutionReason];
-  reason: ExecutionReason;
-};
-
-export function executionOutcome(reason: ExecutionReason): ExecutionOutcome {
-  return { status: STATUS[reason], reason };
-}
-
-/** Unknown/legacy provider reasons never silently turn into success. */
-export function modelOutcome(reason: string | null): ExecutionOutcome {
-  if (reason === "end_turn" || reason === "stop" || reason === "stop_sequence") return executionOutcome("model_end");
-  if (reason === "max_tokens" || reason === "length") return executionOutcome("output_limit");
-  if (reason === "refusal" || reason === "content_filter") return executionOutcome("model_refusal");
-  if (reason === "error") return executionOutcome("provider_error");
-  return executionOutcome("unknown");
-}
-
-export function isExecutionOutcome(value: unknown): value is ExecutionOutcome {
-  if (value === null || typeof value !== "object" || !("reason" in value) || !("status" in value)) return false;
-  return typeof value.reason === "string" && Object.hasOwn(STATUS, value.reason) &&
-    value.status === STATUS[value.reason as ExecutionReason];
-}

package/src/core/overflow.ts

@@ -1,59 +0,0 @@
-/**
- * Whether a provider error means "the prompt does not fit the window".
- *
- * That failure needs a different remedy from every other one: retrying the
- * same request fails the same way (so it must not be retried even when a
- * relay reports it as a 5xx), and the only thing that makes it succeed is a
- * smaller projection. Providers word it differently and none shares a code,
- * so recognition is by message text.
- *
- * Patterns ported from pi-mono `packages/ai/src/utils/overflow.ts` (MIT,
- * commit 6f75515); the provider each one came from is kept beside it. A
- * provider not listed here surfaces as an ordinary error, which is the safe
- * direction: a missed overflow ends the turn visibly, a false one would cut
- * a healthy context.
- */
-const OVERFLOW_PATTERNS: readonly RegExp[] = [
-  /prompt (?:is )?too long/i, // Anthropic, z.ai
-  /request_too_large/i, // Anthropic byte-size overflow (413)
-  /input is too long for requested model/i, // Amazon Bedrock
-  /exceeds the context window/i, // OpenAI (Completions & Responses)
-  /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i, // OpenAI-compatible proxies
-  /input token count.*exceeds the maximum/i, // Google Gemini
-  /maximum prompt length is \d+/i, // xAI
-  /reduce the length of the messages/i, // Groq
-  /maximum context length is \d+ tokens/i, // OpenRouter
-  /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i, // OpenRouter / Poolside
-  /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i, // Together AI
-  /exceeds the limit of \d+/i, // GitHub Copilot
-  /exceeds the available context size/i, // llama.cpp
-  /greater than the context length/i, // LM Studio
-  /context window exceeds limit/i, // MiniMax
-  /exceeded model token limit/i, // Kimi
-  /too large for model with \d+ maximum context length/i, // Mistral
-  /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i, // DS4
-  /model_context_window_exceeded/i, // z.ai finish reason surfaced as error text
-  /prompt too long; exceeded (?:max )?context length/i, // Ollama
-  /range of input length should be/i, // DashScope / Qwen
-  /context[_ ]length[_ ]exceeded/i, // generic
-  /too many tokens/i, // generic
-  /token limit exceeded/i, // generic
-];
-
-/** Throttling that happens to mention tokens; excluded even when a pattern above matches. */
-const NOT_OVERFLOW: readonly RegExp[] = [
-  /^(Throttling error|Service unavailable):/i,
-  /throttl/i,
-  /rate limit/i,
-  /too many requests/i,
-  /please wait/i,
-];
-
-/** Cerebras answers an oversized request with a bodiless 400 / 413. */
-const BODYLESS = /^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i;
-
-export function isContextOverflow(message: string, status?: number): boolean {
-  if (status === 429) return false;
-  if (NOT_OVERFLOW.some((pattern) => pattern.test(message))) return false;
-  return OVERFLOW_PATTERNS.some((pattern) => pattern.test(message)) || BODYLESS.test(message.trim());
-}

package/src/core/packages.ts

@@ -1,47 +0,0 @@
-/** Pi package identities and filters, independent of installation and I/O (D13). */
-import { parseResourcePattern, type ResourceKind } from "./resource-selection.ts";
-
-export type PackageDeclaration = string | ({ source: string; autoload?: boolean } & Partial<Record<ResourceKind, readonly string[]>>);
-export type PackageSource =
-  | { kind: "local"; id: string; path: string; source: string; pinned: true }
-  | { kind: "npm"; id: string; name: string; spec: string; version?: string; source: string; pinned: boolean }
-  | { kind: "git"; id: string; repo: string; ref?: string; source: string; pinned: boolean };
-export function packageDeclaration(value: unknown): value is PackageDeclaration {
-  if (typeof value === "string") return value.trim().length > 0;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const entry = value as Record<string, unknown>;
-  return typeof entry["source"] === "string" && entry["source"].trim().length > 0 &&
-    (entry["autoload"] === undefined || typeof entry["autoload"] === "boolean") &&
-    ["extensions", "skills", "prompts", "themes"].every(key => entry[key] === undefined || Array.isArray(entry[key]) && entry[key].every(p => typeof p === "string"));
-}
-export function packageConfig(value: PackageDeclaration): Exclude<PackageDeclaration, string> { return typeof value === "string" ? { source: value } : value; }
-export function parsePackageSource(raw: string, localPath: (path: string) => string): PackageSource {
-  const source = raw.trim(); if (!source || source.startsWith("-") || /[\x00-\x1f]/.test(source)) throw Error("Invalid package source");
-  if (source.startsWith("npm:")) {
-    const spec = source.slice(4), at = spec.lastIndexOf("@"), name = at > 0 ? spec.slice(0, at) : spec, version = at > 0 ? spec.slice(at + 1) : undefined;
-    if (!/^(?:@[a-zA-Z0-9][a-zA-Z0-9._-]*\/)?[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name) || version === "" || version?.startsWith("-")) throw Error("Invalid npm package source");
-    return { kind: "npm", id: "npm:" + name, source, name, spec, ...(version === undefined ? {} : { version }), pinned: !!version && /^v?\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(version) };
-  }
-  if (/^(git:|git\+|https?:\/\/|ssh:\/\/|git@)/.test(source)) {
-    let repo = source.replace(/^git:(?!\/\/)/, "").replace(/^git\+/, ""), ref: string | undefined;
-    const hash = repo.lastIndexOf("#"), at = repo.lastIndexOf("@");
-    const authorityEnd = /^\w+:\/\//.test(repo) ? repo.indexOf("/",repo.indexOf("://")+3) : repo.startsWith("git@") ? repo.indexOf(":") : repo.indexOf("/");
-    const split = hash >= 0 ? hash : at > authorityEnd && authorityEnd >= 0 ? at : -1;
-    if (split >= 0) { ref = repo.slice(split + 1); repo = repo.slice(0, split); if (!ref || ref.startsWith("-")) throw Error("Invalid git ref"); }
-    if (!/^(\w+:\/\/|git@|\/|\.\.?\/)/.test(repo)) repo = "https://" + repo;
-    const remote = /^\w+:\/\//.test(repo) ? new URL(repo) : undefined;
-    const canonical = (remote ? remote.host.toLowerCase()+remote.pathname : repo.replace(/^git@([^:]+):/, "$1/")).replace(/\.git\/?$/, "").replace(/\/$/, "");
-    if (!canonical.includes("/")) throw Error("Invalid git repository");
-    return { kind: "git", source, repo, id: "git:" + canonical, ...(ref === undefined ? {} : { ref }), pinned: ref !== undefined };
-  }
-  const path = localPath(source); return { kind: "local", id: "local:" + path, source, path, pinned: true };
-}
-
-/** Missing filters inherit; [] excludes all; ordinary positive patterns form a whitelist. */
-export function packageResourceEnabled(patterns: readonly string[] | undefined, matches: (pattern: string, exact: boolean) => boolean, inherited = true): boolean {
-  if (patterns === undefined) return inherited;
-  if (patterns.length === 0) return false;
-  let enabled = patterns.some(pattern => !/^[!+-]/.test(pattern)) ? false : inherited;
-  for (const raw of patterns) { const pattern = parseResourcePattern(raw); if (matches(pattern.pattern,pattern.explicit)) enabled = pattern.enabled; }
-  return enabled;
-}

package/src/core/patch.ts

@@ -1,130 +0,0 @@
-/** Codex patch grammar with exact, unambiguous matching (D9 / R4). No I/O. */
-import { assertNever } from "./exhaustive.ts";
-
-// Assumed resource ceilings, not measured: reject oversized plans before retaining hunks.
-export const MAX_PATCH_CHARS = 2 * 1024 * 1024;
-export const MAX_PATCH_FILES = 100;
-export interface PatchChunk {
-  oldLines: readonly string[];
-  newLines: readonly string[];
-  anchor?: string;
-  endOfFile: boolean;
-}
-export type PatchOperation =
-  | { kind: "add"; path: string; content: string }
-  | { kind: "delete"; path: string }
-  | { kind: "update"; path: string; movePath?: string; chunks: readonly PatchChunk[] };
-export class PatchError extends Error {
-  readonly code: "invalid_input" | "not_found" | "ambiguous_edit";
-  constructor(code: PatchError["code"], message: string) { super(message); this.code = code; }
-}
-const invalid = (message: string): never => { throw new PatchError("invalid_input", message); };
-const pathValue = (text: string): string => {
-  if (!text.trim() || text.includes("\0")) return invalid("patch paths must be nonempty and contain no NUL");
-  return text;
-};
-const fileHeader = (line: string) => /^\*\*\* (?:Add|Delete|Update) File: /.test(line);
-
-/** Parse all operations before the store resolves any target or changes a byte. */
-export function parsePatch(text: string): PatchOperation[] {
-  if (text.length > MAX_PATCH_CHARS) return invalid("patch exceeds the character budget");
-  const lines = text.replaceAll("\r\n", "\n").trim().split("\n");
-  if (lines[0] !== "*** Begin Patch" || lines.at(-1) !== "*** End Patch")
-    return invalid("patch must begin with *** Begin Patch and end with *** End Patch");
-  const operations: PatchOperation[] = [];
-  let index = 1;
-  while (index < lines.length - 1) {
-    if (operations.length >= MAX_PATCH_FILES) return invalid("patch exceeds the file budget");
-    const header = lines[index++]!;
-    if (header.startsWith("*** Add File: ")) {
-      const path = pathValue(header.slice("*** Add File: ".length));
-      const added: string[] = [];
-      while (index < lines.length - 1 && !fileHeader(lines[index]!)) {
-        const line = lines[index++]!;
-        if (!line.startsWith("+")) return invalid(`added lines must start with +: ${path}`);
-        added.push(line.slice(1));
-      }
-      operations.push({ kind: "add", path, content: added.length ? added.join("\n") + "\n" : "" });
-      continue;
-    }
-    if (header.startsWith("*** Delete File: ")) {
-      operations.push({ kind: "delete", path: pathValue(header.slice("*** Delete File: ".length)) });
-      continue;
-    }
-    if (!header.startsWith("*** Update File: ")) return invalid(`unexpected patch line ${index}: ${header}`);
-    const path = pathValue(header.slice("*** Update File: ".length));
-    const moveLine = lines[index];
-    const movePath = moveLine?.startsWith("*** Move to: ") ? pathValue(moveLine.slice("*** Move to: ".length)) : undefined;
-    if (movePath !== undefined) index++;
-    const chunks: PatchChunk[] = [];
-    while (index < lines.length - 1 && !fileHeader(lines[index]!)) {
-      const marker = lines[index++]!;
-      if (marker !== "@@" && !marker.startsWith("@@ ")) return invalid(`update hunks must start with @@: ${path}`);
-      const oldLines: string[] = [], newLines: string[] = [];
-      let endOfFile = false, changed = false;
-      while (index < lines.length - 1 && !fileHeader(lines[index]!) && !lines[index]!.startsWith("@@")) {
-        const line = lines[index++]!;
-        if (line === "*** End of File") { endOfFile = true; break; }
-        const prefix = line[0];
-        if (prefix !== " " && prefix !== "+" && prefix !== "-") return invalid(`invalid update line: ${path}`);
-        if (prefix !== "+") oldLines.push(line.slice(1));
-        if (prefix !== "-") newLines.push(line.slice(1));
-        if (prefix !== " ") changed = true;
-      }
-      if (!changed) return invalid(`update hunk makes no change: ${path}`);
-      chunks.push({ oldLines, newLines, endOfFile, ...(marker === "@@" ? {} : { anchor: marker.slice(3) }) });
-      if (endOfFile && index < lines.length - 1 && !fileHeader(lines[index]!)) return invalid(`End of File must finish the update: ${path}`);
-    }
-    if (!chunks.length && movePath === undefined) return invalid(`update has no hunks: ${path}`);
-    operations.push({ kind: "update", path, chunks, ...(movePath === undefined ? {} : { movePath }) });
-  }
-  if (!operations.length) return invalid("patch is empty");
-  return operations;
-}
-
-/** Keep BOM, line endings and final-newline status; ambiguous contexts require a reread. */
-export function applyPatchChunks(before: string, chunks: readonly PatchChunk[]): string {
-  const bom = before.startsWith("\uFEFF") ? "\uFEFF" : "";
-  const body = before.slice(bom.length);
-  const ending = body.includes("\r\n") ? "\r\n" : "\n";
-  const normalized = body.replaceAll("\r\n", "\n");
-  if (normalized.includes("\r")) return invalid("patch updates do not support bare CR line endings");
-  if (ending === "\r\n" && body.replaceAll("\r\n", "").includes("\n"))
-    return invalid("patch updates require a consistent line ending; mixed LF/CRLF bytes were preserved");
-  const finalNewline = normalized.endsWith("\n");
-  const lines = normalized ? normalized.split("\n") : [];
-  if (finalNewline) lines.pop();
-  let cursor = 0;
-  for (const chunk of chunks) {
-    let start = cursor;
-    if (chunk.anchor !== undefined) {
-      const anchors = lines.flatMap((line, at) => at >= cursor && line === chunk.anchor ? [at] : []);
-      if (anchors.length !== 1) throw new PatchError(anchors.length ? "ambiguous_edit" : "not_found", "patch anchor must match exactly once after the preceding hunk");
-      start = anchors[0]! + 1;
-    }
-    const matches: number[] = [];
-    for (let at = start; at <= lines.length - chunk.oldLines.length; at++) {
-      if (chunk.endOfFile && at + chunk.oldLines.length !== lines.length) continue;
-      if (chunk.oldLines.every((line, offset) => lines[at + offset] === line)) matches.push(at);
-    }
-    if (!chunk.oldLines.length && !chunk.endOfFile) {
-      if (chunk.anchor !== undefined || lines.length === 0) matches.splice(0, matches.length, start);
-      else throw new PatchError("ambiguous_edit", "insertion needs an anchor, End of File, or an empty source");
-    }
-    if (matches.length !== 1) throw new PatchError(matches.length ? "ambiguous_edit" : "not_found", "patch context must match exactly once; read current content and add context");
-    const at = matches[0]!;
-    lines.splice(at, chunk.oldLines.length, ...chunk.newLines);
-    cursor = at + chunk.newLines.length;
-  }
-  return bom + lines.join(ending) + (finalNewline && lines.length ? ending : "");
-}
-
-export function patchPaths(operations: readonly PatchOperation[]): string[] {
-  return operations.flatMap(operation => {
-    switch (operation.kind) {
-      case "add": case "delete": return [operation.path];
-      case "update": return operation.movePath === undefined ? [operation.path] : [operation.path, operation.movePath];
-      default: return assertNever(operation, "patchPaths");
-    }
-  });
-}

package/src/core/path-suggestions.ts

@@ -1,59 +0,0 @@
-/**
- * Existing paths that a missing one probably meant.
- *
- * Models guess paths, and most guesses in a reviewed session (flotil: 11 of
- * 11 ENOENT) had the right file name in the wrong directory or a near
- * spelling. OpenCode's read tool suggests up to three entries of the same
- * directory whose name contains, or is contained in, the requested one
- * (`packages/opencode/src/tool/read.ts`); that misses a wrong directory, so
- * this ranks the whole workspace listing, file name first.
- *
- * Pure and deterministic: the result depends on the set of candidates, never
- * their order, so the same failure always names the same paths.
- */
-import { editDistance } from "./text-normalize.ts";
-
-/** OpenCode's count: enough to cover a wrong directory, short enough to read at a glance. */
-export const PATH_SUGGESTION_LIMIT = 3;
-
-/** Containment of a shorter name is too weak a signal below this length (assumed: "a" is in everything). */
-const MIN_CONTAINED = 3;
-
-const baseName = (path: string) => path.slice(path.lastIndexOf("/") + 1);
-const stem = (name: string) => { const dot = name.lastIndexOf("."); return dot > 0 ? name.slice(0, dot) : name; };
-
-/**
- * Rank tier of `name` against the wanted file name, or null when unrelated.
- * 0: same name; 1: same name without extension; 2: one name contains the
- * other; 3: a near spelling (edit distance within a quarter of the length).
- */
-function tier(name: string, wanted: string, distance: number): number | null {
-  if (name === wanted) return 0;
-  if (stem(name) === stem(wanted) && stem(name).length > 0) return 1;
-  const shorter = name.length < wanted.length ? name : wanted, longer = shorter === name ? wanted : name;
-  if (shorter.length >= MIN_CONTAINED && longer.includes(shorter)) return 2;
-  if (distance <= Math.max(1, Math.floor(wanted.length / 4))) return 3;
-  return null;
-}
-
-/**
- * Up to `limit` workspace-relative paths from `candidates` closest to the
- * missing `target`, best first. Paths use "/" separators; comparison ignores
- * case. The target itself is never suggested.
- */
-export function nearestPaths(target: string, candidates: readonly string[], limit = PATH_SUGGESTION_LIMIT): string[] {
-  const wantedPath = target.replace(/^\.\//, "").toLowerCase();
-  const wanted = baseName(wantedPath);
-  if (wanted.length === 0 || limit <= 0) return [];
-  const ranked: { path: string; tier: number; name: number; whole: number }[] = [];
-  for (const path of new Set(candidates)) {
-    const lower = path.toLowerCase();
-    if (lower === wantedPath) continue;
-    const name = baseName(lower), distance = editDistance(name, wanted);
-    const rank = tier(name, wanted, distance);
-    if (rank === null) continue;
-    ranked.push({ path, tier: rank, name: distance, whole: editDistance(lower, wantedPath) });
-  }
-  ranked.sort((a, b) => a.tier - b.tier || a.name - b.name || a.whole - b.whole || (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
-  return ranked.slice(0, limit).map(item => item.path);
-}