pi-readseek 0.3.8 → 0.3.10

package/src/tui-render-utils.ts

@@ -37,6 +37,33 @@ export function isRendererExpanded(options?: { expanded?: boolean }, context?: {
   return context?.expanded ?? options?.expanded ?? false;
 }
 
+export interface RenderResultContext {
+  isPartial: boolean;
+  isError: boolean;
+  expanded: boolean;
+  width: number | undefined;
+  cwd: string;
+  context: Record<string, any>;
+}
+
+/**
+ * Resolve the shared render context for a tool's `renderResult`, which may
+ * receive its context either as a trailing `rest[0]` argument or folded into
+ * `options`. Returns the common flags plus the raw context object for callers
+ * that need fields beyond the common set (e.g. `lastComponent`).
+ */
+export function resolveRenderResultContext(options: any, rest: any[]): RenderResultContext {
+  const context = rest[0] ?? options ?? {};
+  return {
+    isPartial: context.isPartial ?? options?.isPartial ?? false,
+    isError: context.isError ?? false,
+    expanded: isRendererExpanded(options, context),
+    width: context.width ?? options?.width,
+    cwd: context.cwd ?? process.cwd(),
+    context,
+  };
+}
+
 export function normalizeWidth(width: unknown, fallback = 80): number {
   return typeof width === "number" && Number.isFinite(width) && width > 0 ? Math.floor(width) : fallback;
 }

package/src/write.ts

@@ -66,11 +66,6 @@ const MAX_BYTES = 50 * 1024;
 const WRITE_PROMPT_METADATA = defineToolPromptMetadata({
   promptUrl: new URL("../prompts/write.md", import.meta.url),
   promptSnippet: "Create or overwrite a complete file and return edit anchors",
-  promptGuidelines: [
-    "Use write to create new files or intentionally replace whole files.",
-    "Use edit instead of write for small changes or appends to existing files.",
-    "Remember write overwrites existing files without confirmation.",
-  ],
 });
 
 type WriteDiffFields = {

package/src/binary-resolution.ts

@@ -1,77 +0,0 @@
-import { existsSync as defaultExistsSync, readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, resolve } from "node:path";
-
-const require = createRequire(import.meta.url);
-
-export interface ResolveBundledBinDeps {
-  resolvePackageJson?: (specifier: string) => string;
-  readPackageJson?: (packageJsonPath: string) => string;
-  existsSync?: (candidate: string) => boolean;
-  platform?: NodeJS.Platform;
-}
-
-function defaultResolvePackageJson(specifier: string): string {
-  return require.resolve(specifier);
-}
-
-function defaultReadPackageJson(packageJsonPath: string): string {
-  return readFileSync(packageJsonPath, "utf8");
-}
-
-function binEntryFor(packageJsonText: string, binName: string): string | undefined {
-  const parsed = JSON.parse(packageJsonText) as { bin?: string | Record<string, string> };
-  if (typeof parsed.bin === "string") return parsed.bin;
-  return parsed.bin?.[binName];
-}
-
-function commandCandidates(basePath: string, platform: NodeJS.Platform): string[] {
-  if (platform !== "win32") return [basePath];
-  return [`${basePath}.exe`, basePath];
-}
-
-function firstExisting(candidates: string[], existsSync: (candidate: string) => boolean): string | undefined {
-  return candidates.find((candidate) => existsSync(candidate));
-}
-
-export interface ExecutableCommand {
-  command: string;
-  argsPrefix: string[];
-}
-
-export function executableCommand(binaryPath: string, platform: NodeJS.Platform = process.platform): ExecutableCommand {
-  if (platform === "win32" && /\.js$/i.test(binaryPath)) {
-    return { command: process.execPath, argsPrefix: [binaryPath] };
-  }
-  return { command: binaryPath, argsPrefix: [] };
-}
-
-export function resolveBundledBin(
-  packageName: string,
-  binName: string,
-  fallbackCommand: string,
-  deps: ResolveBundledBinDeps = {},
-): string {
-  const resolvePackageJson = deps.resolvePackageJson ?? defaultResolvePackageJson;
-  const readPackageJson = deps.readPackageJson ?? defaultReadPackageJson;
-  const existsSync = deps.existsSync ?? defaultExistsSync;
-  const platform = deps.platform ?? process.platform;
-
-  try {
-    const packageJsonPath = resolvePackageJson(`${packageName}/package.json`);
-    const packageDir = dirname(packageJsonPath);
-    const binEntry = binEntryFor(readPackageJson(packageJsonPath), binName);
-    if (!binEntry) return fallbackCommand;
-
-
-    const packageBinCandidate = firstExisting(
-      commandCandidates(resolve(packageDir, binEntry), platform),
-      existsSync,
-    );
-    if (packageBinCandidate) return packageBinCandidate;
-  } catch {
-    // Fall through to PATH fallback.
-  }
-
-  return fallbackCommand;
-}

package/src/find-parsers.ts

@@ -1,89 +0,0 @@
-const SIZE_MULTIPLIERS: Record<string, number> = {
-  "": 1,
-  B: 1,
-  K: 1024,
-  KB: 1024,
-  M: 1024 * 1024,
-  MB: 1024 * 1024,
-  G: 1024 ** 3,
-  GB: 1024 ** 3,
-};
-
-export function parseSize(field: string, value: number | string): number {
-  if (typeof value === "number") {
-    if (!Number.isFinite(value) || value < 0) {
-      throw new Error(
-        `Invalid ${field} value: ${value} (expected a non-negative number of bytes)`,
-      );
-    }
-    return value;
-  }
-
-  const match = /^\s*(\d+(?:\.\d+)?)\s*([a-zA-Z]*)\s*$/.exec(value);
-  if (!match) {
-    throw new Error(
-      `Invalid ${field} value: ${JSON.stringify(value)} ` +
-        `(expected a number with optional B/K/KB/M/MB/G/GB suffix; units are 1024-based)`,
-    );
-  }
-
-  const num = parseFloat(match[1]);
-  const suffix = match[2].toUpperCase();
-  const mult = SIZE_MULTIPLIERS[suffix];
-  if (mult === undefined) {
-    throw new Error(
-      `Invalid ${field} value: ${JSON.stringify(value)} ` +
-        `(unknown unit '${match[2]}'; accepted: B, K, KB, M, MB, G, GB)`,
-    );
-  }
-
-  return Math.round(num * mult);
-}
-
-const RELATIVE_UNIT_MS: Record<string, number> = {
-  m: 60 * 1000,
-  h: 60 * 60 * 1000,
-  d: 24 * 60 * 60 * 1000,
-};
-
-const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-const ISO_TS_RE =
-  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/;
-
-export function parseRelativeOrIsoDate(
-  field: string,
-  value: string,
-  now: Date = new Date(),
-): Date {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(
-      `Invalid ${field} value: ${JSON.stringify(value)} ` +
-        `(expected ISO date/timestamp or relative shorthand like '1h', '24h', '7d', '30m')`,
-    );
-  }
-
-  const rel = /^\s*(\d+)\s*([mhd])\s*$/.exec(value);
-  if (rel) {
-    const n = parseInt(rel[1], 10);
-    return new Date(now.getTime() - n * RELATIVE_UNIT_MS[rel[2]]);
-  }
-
-  if (ISO_DATE_RE.test(value)) {
-    const parsed = new Date(`${value}T00:00:00.000Z`);
-    if (!Number.isNaN(parsed.getTime())) {
-      return parsed;
-    }
-  }
-
-  if (ISO_TS_RE.test(value)) {
-    const parsed = new Date(value);
-    if (!Number.isNaN(parsed.getTime())) {
-      return parsed;
-    }
-  }
-
-  throw new Error(
-    `Invalid ${field} value: ${JSON.stringify(value)} ` +
-      `(expected ISO date/timestamp or relative shorthand like '1h', '24h', '7d', '30m')`,
-  );
-}

package/src/find-stat.ts

@@ -1,36 +0,0 @@
-import * as fsPromises from "node:fs/promises";
-import type { Stats } from "node:fs";
-import { resolve as resolvePath } from "node:path";
-
-export const DEFAULT_STAT_CONCURRENCY = 32;
-export const _testable = {
-  stat: fsPromises.stat,
-};
-
-export async function statAllWithConcurrency(
-  relPaths: string[],
-  baseDir: string,
-  concurrency: number = DEFAULT_STAT_CONCURRENCY,
-): Promise<(Stats | null)[]> {
-  const requested = Number.isFinite(concurrency)
-    ? concurrency
-    : DEFAULT_STAT_CONCURRENCY;
-  const limit = Math.max(1, Math.min(requested, DEFAULT_STAT_CONCURRENCY));
-  const out: (Stats | null)[] = new Array(relPaths.length).fill(null);
-  let next = 0;
-
-  async function worker() {
-    while (true) {
-      const i = next++;
-      if (i >= relPaths.length) return;
-      try {
-        out[i] = await _testable.stat(resolvePath(baseDir, relPaths[i]));
-      } catch {
-        out[i] = null;
-      }
-    }
-  }
-
-  await Promise.all(Array.from({ length: Math.min(limit, relPaths.length) }, () => worker()));
-  return out;
-}

package/src/persistent-map-cache.ts

@@ -1,230 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { createHash, randomBytes } from "node:crypto";
-import { open, readFile, writeFile as fsWriteFile, mkdir as fsMkdir, rename, readdir, stat, unlink } from "node:fs/promises";
-import xxhashWasm from "xxhash-wasm";
-import type { FileMap } from "./readseek/types.js";
-import { resolveReadseekJsonSettings } from "./readseek-settings.js";
-
-/**
- * Resolve the on-disk map-cache directory using config precedence:
- * 1. `PI_HASHLINE_MAP_CACHE_DIR` (when non-empty) — used verbatim.
- * 2. JSON `mapCache.dir` (when configured).
- * 3. `$XDG_CACHE_HOME/pi-readseek/maps` (when non-empty).
- * 4. `~/.cache/pi-readseek/maps`.
- */
-function resolveCacheDir(): string {
-  const explicit = process.env.PI_HASHLINE_MAP_CACHE_DIR;
-  if (explicit && explicit.length > 0) return explicit;
-
-  const configured = resolveReadseekJsonSettings().settings.mapCache?.dir;
-  if (configured && configured.length > 0) return configured;
-
-  const xdg = process.env.XDG_CACHE_HOME;
-  if (xdg && xdg.length > 0) return join(xdg, "pi-readseek/maps");
-
-  return join(homedir(), ".cache/pi-readseek/maps");
-}
-
-export function persistenceEnabled(): boolean {
-  if (process.env.PI_HASHLINE_NO_PERSIST_MAPS === "1") return false;
-  const configured = resolveReadseekJsonSettings().settings.mapCache?.enabled;
-  if (configured !== undefined) return configured;
-  return true;
-}
-
-/**
- * Build a deterministic hex cache key from the five input components.
- * Uses SHA-256 truncated to 32 hex chars; collision-safe for our purposes
- * and short enough for readable filenames.
- */
-export function computeKey(
-  absolutePath: string,
-  mtimeMs: number,
-  contentHash: string,
-  mapperName: string,
-  mapperVersion: number,
-): string {
-  return createHash("sha256")
-    .update(`${absolutePath}\0${mtimeMs}\0${contentHash}\0${mapperName}\0${mapperVersion}`)
-    .digest("hex")
-    .slice(0, 32);
-}
-
-const CONTENT_HASH_WINDOW_BYTES = 64 * 1024;
-
-let xxhashReady: Promise<{ h32Raw: (b: Uint8Array, seed?: number) => number }> | null = null;
-
-function loadXxhash(): Promise<{ h32Raw: (b: Uint8Array, seed?: number) => number }> {
-  if (!xxhashReady) {
-    xxhashReady = xxhashWasm().then((h) => ({ h32Raw: h.h32Raw }));
-  }
-
-  return xxhashReady;
-}
-
-/**
- * xxHash32 hex digest over the first 64 KB of `absPath`. Returns "" if the
- * file cannot be opened or read — the caller treats that as a miss.
- */
-export async function contentHashFor64k(absPath: string): Promise<string> {
-  try {
-    const fh = await open(absPath, "r");
-    try {
-      const buf = Buffer.alloc(CONTENT_HASH_WINDOW_BYTES);
-      const { bytesRead } = await fh.read(buf, 0, CONTENT_HASH_WINDOW_BYTES, 0);
-      const view = buf.subarray(0, bytesRead);
-      const { h32Raw } = await loadXxhash();
-      const n = h32Raw(view, 0) >>> 0;
-      return n.toString(16).padStart(8, "0");
-    } finally {
-      await fh.close();
-    }
-  } catch {
-    return "";
-  }
-}
-
-function keyPath(key: string): string {
-  return join(resolveCacheDir(), `${key}.json`);
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-function isStringArray(value: unknown): value is string[] {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-
-function isFileSymbolLike(value: unknown): boolean {
-  if (!isRecord(value)) return false;
-  if (typeof value.name !== "string") return false;
-  if (typeof value.kind !== "string") return false;
-  if (typeof value.startLine !== "number") return false;
-  if (typeof value.endLine !== "number") return false;
-  if (value.signature !== undefined && typeof value.signature !== "string") return false;
-  if (value.children !== undefined && (!Array.isArray(value.children) || !value.children.every(isFileSymbolLike))) {
-    return false;
-  }
-  if (value.modifiers !== undefined && !isStringArray(value.modifiers)) return false;
-  if (value.docstring !== undefined && typeof value.docstring !== "string") return false;
-  if (value.isExported !== undefined && typeof value.isExported !== "boolean") return false;
-  return true;
-}
-
-function isTruncatedInfoLike(value: unknown): boolean {
-  if (!isRecord(value)) return false;
-  return (
-    typeof value.totalSymbols === "number"
-    && typeof value.shownSymbols === "number"
-    && typeof value.omittedSymbols === "number"
-  );
-}
-
-const DETAIL_LEVELS = new Set(["full", "compact", "minimal", "outline", "truncated"]);
-
-function isFileMap(value: unknown): value is FileMap {
-  if (!isRecord(value)) return false;
-  if (typeof value.path !== "string") return false;
-  if (typeof value.totalLines !== "number") return false;
-  if (typeof value.totalBytes !== "number") return false;
-  if (typeof value.language !== "string") return false;
-  if (!Array.isArray(value.symbols) || !value.symbols.every(isFileSymbolLike)) return false;
-  if (!isStringArray(value.imports)) return false;
-  if (typeof value.detailLevel !== "string" || !DETAIL_LEVELS.has(value.detailLevel)) return false;
-  if (value.truncatedInfo !== undefined && !isTruncatedInfoLike(value.truncatedInfo)) return false;
-  return true;
-}
-
-/** Read a cached FileMap. Returns null on any failure (missing, corrupt, unreadable). */
-export async function readCached(key: string): Promise<FileMap | null> {
-  if (!persistenceEnabled()) return null;
-
-  try {
-    const raw = await readFile(keyPath(key), "utf-8");
-    const parsed: unknown = JSON.parse(raw);
-    return isFileMap(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-async function tryWriteCachedRaw(key: string, map: FileMap): Promise<boolean> {
-  if (!persistenceEnabled()) return false;
-  const dir = resolveCacheDir();
-  const target = join(dir, `${key}.json`);
-  const tmp = join(dir, `${key}.${randomBytes(6).toString("hex")}.tmp`);
-  try {
-    await fsMkdir(dir, { recursive: true });
-    await fsWriteFile(tmp, JSON.stringify(map));
-    await rename(tmp, target);
-    return true;
-  } catch {
-    try {
-      await unlink(tmp);
-    } catch {
-      // ignore temp-file cleanup failures
-    }
-    return false;
-  }
-}
-
-/** Low-level atomic write. Internal helper. */
-async function writeCachedRaw(key: string, map: FileMap): Promise<void> {
-  await tryWriteCachedRaw(key, map);
-}
-
-const EVICTION_INTERVAL = 20;
-const EVICTION_CAP = 5000;
-let writeCounter = 0;
-
-
-const CACHE_KEY_FILE = /^[0-9a-f]{32}\.json$/;
-async function maybeEvict(): Promise<void> {
-  try {
-    const dir = resolveCacheDir();
-    const names = (await readdir(dir)).filter((n) => CACHE_KEY_FILE.test(n));
-    if (names.length <= EVICTION_CAP) return;
-
-    const entries: Array<{ path: string; age: number }> = [];
-    for (const name of names) {
-      const path = join(dir, name);
-      try {
-        const s = await stat(path);
-        const age = (s.atimeMs ?? s.mtimeMs) || 0;
-        entries.push({ path, age });
-      } catch {
-        // ignore individual stat failures
-      }
-    }
-
-    entries.sort((a, b) => a.age - b.age);
-    const excess = entries.length - EVICTION_CAP;
-    for (let i = 0; i < excess; i += 1) {
-      try {
-        await unlink(entries[i].path);
-      } catch {
-        // ignore individual unlink failures
-      }
-    }
-  } catch {
-    // Swallow eviction errors — never propagate.
-  }
-}
-
-/**
- * Public atomic write. Counts successful invocations so eviction can trigger lazily.
- */
-export async function writeCached(key: string, map: FileMap): Promise<void> {
-  if (!(await tryWriteCachedRaw(key, map))) return;
-  writeCounter += 1;
-  if (writeCounter % EVICTION_INTERVAL === 0) {
-    try {
-      await maybeEvict();
-    } catch {
-      // Swallow eviction errors at the call site too.
-    }
-  }
-}
-

package/src/readseek/language-detect.ts

@@ -1,29 +0,0 @@
-import type { LanguageInfo } from "./types.js";
-
-const EXTENSION_LANGUAGE_MAP: Record<string, LanguageInfo> = {
-  ".rs": { id: "rust", name: "Rust" },
-  ".c": { id: "cpp", name: "C" },
-  ".cc": { id: "cpp", name: "C++" },
-  ".cpp": { id: "cpp", name: "C++" },
-  ".cxx": { id: "cpp", name: "C++" },
-  ".hpp": { id: "c-header", name: "C/C++ Header" },
-  ".h": { id: "c-header", name: "C/C++ Header" },
-  ".hxx": { id: "c-header", name: "C/C++ Header" },
-  ".java": { id: "java", name: "Java" },
-};
-
-export function detectLanguage(filePath: string): LanguageInfo | null {
-  const normalized = filePath.toLowerCase();
-  for (const [ext, language] of Object.entries(EXTENSION_LANGUAGE_MAP)) {
-    if (normalized.endsWith(ext)) return language;
-  }
-  return null;
-}
-
-export function isSupported(filePath: string): boolean {
-  return detectLanguage(filePath) !== null;
-}
-
-export function getSupportedExtensions(): string[] {
-  return Object.keys(EXTENSION_LANGUAGE_MAP);
-}