pi-readseek 0.7.7 → 0.7.9

package/src/readseek/enums.ts

@@ -1,38 +0,0 @@
-/**
- * Symbol kinds supported by mappers.
- */
-export enum SymbolKind {
-  Class = "class",
-  Function = "function",
-  Method = "method",
-  Variable = "variable",
-  Constant = "constant",
-  Interface = "interface",
-  Type = "type",
-  Enum = "enum",
-  Struct = "struct",
-  Import = "import",
-  Module = "module",
-  Namespace = "namespace",
-  Property = "property",
-  Heading = "heading",
-  Table = "table",
-  View = "view",
-  Procedure = "procedure",
-  Trigger = "trigger",
-  Index = "index",
-  Schema = "schema",
-  Signal = "signal",
-  Unknown = "unknown",
-}
-
-/**
- * Detail levels for map generation.
- */
-export enum DetailLevel {
-  Full = "full",
-  Compact = "compact",
-  Minimal = "minimal",
-  Outline = "outline",
-  Truncated = "truncated",
-}

package/src/readseek/formatter.ts

@@ -1,350 +0,0 @@
-import { basename } from "node:path";
-
-import type { FileMap, FileSymbol } from "./types.js";
-
-import { THRESHOLDS } from "./constants.js";
-import { DetailLevel } from "./enums.js";
-
-const BOX_LINE = "───────────────────────────────────────";
-
-/**
- * Format a file size for display.
- */
-function formatSize(bytes: number): string {
-  if (bytes < 1024) {
-    return `${bytes} B`;
-  }
-  if (bytes < 1024 * 1024) {
-    return `${(bytes / 1024).toFixed(1)} KB`;
-  }
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-
-/**
- * Format a number with comma separators.
- */
-function formatNumber(n: number): string {
-  return n.toLocaleString("en-US");
-}
-
-/**
- * Format a symbol for display.
- */
-function formatSymbol(symbol: FileSymbol, indent = 0): string {
-  const prefix = "  ".repeat(indent);
-  const lineRange =
-    symbol.startLine === symbol.endLine
-      ? `[${symbol.startLine}]`
-      : `[${symbol.startLine}-${symbol.endLine}]`;
-
-  const { name } = symbol;
-
-  // Format based on kind
-  let formatted: string;
-  switch (symbol.kind) {
-    case "class":
-    case "interface":
-    case "struct":
-    case "enum":
-    case "type": {
-      formatted = `${prefix}${symbol.kind} ${name}: ${lineRange}`;
-      break;
-    }
-    case "function":
-    case "method": {
-      formatted = `${prefix}${name}: ${lineRange}`;
-      break;
-    }
-    case "variable":
-    case "constant": {
-      formatted = `${prefix}${name} = ... ${lineRange}`;
-      break;
-    }
-    default: {
-      formatted = `${prefix}${name}: ${lineRange}`;
-    }
-  }
-
-  return formatted;
-}
-
-/**
- * Format symbols recursively.
- */
-function formatSymbols(
-  symbols: FileSymbol[],
-  level: DetailLevel,
-  indent = 0
-): string[] {
-  const lines: string[] = [];
-
-  for (const symbol of symbols) {
-    lines.push(formatSymbol(symbol, indent));
-
-    // Add children for full, compact, and minimal levels (not outline or truncated)
-    if (
-      level !== DetailLevel.Outline &&
-      level !== DetailLevel.Truncated &&
-      symbol.children?.length
-    ) {
-      // For minimal, flatten children
-      if (level === DetailLevel.Minimal) {
-        for (const child of symbol.children) {
-          lines.push(formatSymbol(child, indent + 1));
-        }
-      } else {
-        lines.push(...formatSymbols(symbol.children, level, indent + 1));
-      }
-    }
-  }
-
-  return lines;
-}
-
-/**
- * Format a complete file map to a string.
- */
-function formatFileMap(map: FileMap, level?: DetailLevel): string {
-  const effectiveLevel = level ?? map.detailLevel;
-  const fileName = basename(map.path);
-
-  const lines: string[] = [
-    "",
-    BOX_LINE,
-    `File Map: ${fileName}`,
-    `${formatNumber(map.totalLines)} lines │ ${formatSize(map.totalBytes)} │ ${map.language}`,
-    BOX_LINE,
-    "",
-  ];
-
-  // Add detail level notice if reduced from Full
-  if (map.truncatedInfo) {
-    const { shownSymbols, totalSymbols } = map.truncatedInfo;
-    lines.push(
-      `[Map ≤${formatSize(THRESHOLDS.MAX_TRUNCATED_BYTES)} | ${shownSymbols} of ${formatNumber(totalSymbols)} symbols]`
-    );
-    lines.push("");
-  } else if (effectiveLevel === DetailLevel.Outline) {
-    lines.push(`[Map ≤${formatSize(THRESHOLDS.MAX_OUTLINE_BYTES)} | outline]`);
-    lines.push("");
-  } else if (effectiveLevel === DetailLevel.Minimal) {
-    lines.push(`[Map ≤${formatSize(THRESHOLDS.MAX_MAP_BYTES)} | minimal]`);
-    lines.push("");
-  } else if (effectiveLevel === DetailLevel.Compact) {
-    lines.push(
-      `[Map ≤${formatSize(THRESHOLDS.COMPACT_TARGET_BYTES)} | compact]`
-    );
-    lines.push("");
-  }
-
-  // Add symbols
-  if (map.truncatedInfo) {
-    // Truncated format: first half, separator, second half
-    const half = Math.floor(map.symbols.length / 2);
-    const firstSymbols = map.symbols.slice(0, half);
-    const lastSymbols = map.symbols.slice(half);
-
-    // Format first batch
-    const firstLines = formatSymbols(firstSymbols, effectiveLevel);
-    lines.push(...firstLines);
-
-    // Add separator
-    lines.push("");
-    lines.push(
-      `  ─ ─ ─ ${formatNumber(map.truncatedInfo.omittedSymbols)} more symbols ─ ─ ─`
-    );
-    lines.push("");
-
-    // Format last batch
-    const lastLines = formatSymbols(lastSymbols, effectiveLevel);
-    lines.push(...lastLines);
-  } else {
-    // Normal format
-    const symbolLines = formatSymbols(map.symbols, effectiveLevel);
-    lines.push(...symbolLines);
-  }
-
-  // Add footer with appropriate guidance
-  lines.push("");
-  lines.push(BOX_LINE);
-  if (map.truncatedInfo) {
-    // For truncated maps, provide specific guidance on finding omitted symbols
-    const firstShown = map.symbols.slice(0, Math.floor(map.symbols.length / 2));
-    const lastShown = map.symbols.slice(Math.floor(map.symbols.length / 2));
-    const lastFirst = firstShown.at(-1);
-    const firstLast = lastShown.at(0);
-    if (lastFirst && firstLast) {
-      const omitStart = lastFirst.endLine + 1;
-      const omitEnd = firstLast.startLine - 1;
-      lines.push(
-        `Omitted symbols are in lines ${formatNumber(omitStart)}-${formatNumber(omitEnd)}.`
-      );
-    }
-    lines.push(
-      "Use read(path, offset=LINE, limit=N) to view specific sections."
-    );
-  } else {
-    lines.push("Use read(path, offset=LINE, limit=N) for targeted reads.");
-  }
-  lines.push(BOX_LINE);
-
-  return lines.join("\n");
-}
-
-/**
- * Reduce detail level of a file map.
- */
-function reduceToLevel(map: FileMap, level: DetailLevel): FileMap {
-  if (level === DetailLevel.Outline) {
-    // Remove all children
-    return {
-      ...map,
-      detailLevel: DetailLevel.Outline,
-      symbols: map.symbols.map((s) => ({
-        name: s.name,
-        kind: s.kind,
-        startLine: s.startLine,
-        endLine: s.endLine,
-      })),
-    };
-  }
-
-  if (level === DetailLevel.Minimal) {
-    return {
-      ...map,
-      detailLevel: DetailLevel.Minimal,
-      symbols: map.symbols.map((s) => ({
-        name: s.name,
-        kind: s.kind,
-        startLine: s.startLine,
-        endLine: s.endLine,
-        children: s.children?.map((c) => ({
-          name: c.name,
-          kind: c.kind,
-          startLine: c.startLine,
-          endLine: c.endLine,
-        })),
-      })),
-    };
-  }
-
-  if (level === DetailLevel.Compact) {
-    return { ...map, detailLevel: DetailLevel.Compact };
-  }
-
-  return { ...map, detailLevel: DetailLevel.Full };
-}
-
-/**
- * Reduce a file map to truncated form: first N + last N symbols only.
- * Used when even Outline level exceeds budget.
- */
-function reduceToTruncated(
-  map: FileMap,
-  symbolsEach: number = THRESHOLDS.TRUNCATED_SYMBOLS_EACH
-): FileMap {
-  const { symbols } = map;
-  const total = symbols.length;
-
-  if (total <= symbolsEach * 2) {
-    // Not enough symbols to truncate, return as outline
-    return reduceToLevel(map, DetailLevel.Outline);
-  }
-
-  const firstSymbols = symbols.slice(0, symbolsEach).map((s) => ({
-    name: s.name,
-    kind: s.kind,
-    startLine: s.startLine,
-    endLine: s.endLine,
-  }));
-
-  const lastSymbols = symbols.slice(-symbolsEach).map((s) => ({
-    name: s.name,
-    kind: s.kind,
-    startLine: s.startLine,
-    endLine: s.endLine,
-  }));
-
-  return {
-    ...map,
-    symbols: [...firstSymbols, ...lastSymbols],
-    detailLevel: DetailLevel.Truncated,
-    truncatedInfo: {
-      totalSymbols: total,
-      shownSymbols: symbolsEach * 2,
-      omittedSymbols: total - symbolsEach * 2,
-    },
-  };
-}
-
-/**
- * Format a file map with automatic budget enforcement.
- * Reduces detail level until the map fits within the budget.
- */
-export function formatFileMapWithBudget(
-  map: FileMap,
-  maxBytes = THRESHOLDS.MAX_TRUNCATED_BYTES
-): string {
-  // Tiered budgets: progressively reduce detail level
-  const tiers: { level: DetailLevel; budget: number }[] = [
-    { level: DetailLevel.Full, budget: THRESHOLDS.FULL_TARGET_BYTES },
-    { level: DetailLevel.Compact, budget: THRESHOLDS.COMPACT_TARGET_BYTES },
-    { level: DetailLevel.Minimal, budget: THRESHOLDS.MAX_MAP_BYTES },
-    { level: DetailLevel.Outline, budget: THRESHOLDS.MAX_OUTLINE_BYTES },
-  ];
-
-  for (const { level, budget } of tiers) {
-    const reduced = reduceToLevel(map, level);
-    const formatted = formatFileMap(reduced, level);
-    const size = Buffer.byteLength(formatted, "utf8");
-
-    if (size <= budget && size <= maxBytes) {
-      return formatted;
-    }
-  }
-
-  // Outline exceeded budget - need to truncate symbols
-  // First check if full outline fits in maxBytes (just not in outline budget)
-  const outline = reduceToLevel(map, DetailLevel.Outline);
-  const outlineFormatted = formatFileMap(outline, DetailLevel.Outline);
-  const outlineSize = Buffer.byteLength(outlineFormatted, "utf8");
-
-  if (outlineSize <= maxBytes) {
-    // Outline fits in truncated budget, use it
-    return outlineFormatted;
-  }
-
-  // Need to truncate - binary search for maximum symbols that fit
-  const totalSymbols = map.symbols.length;
-  const minSymbols = 10; // Guaranteed minimum
-  const maxSymbolsEach = Math.floor(totalSymbols / 2); // Can't show more than half on each side
-
-  let low = minSymbols;
-  let high = maxSymbolsEach;
-  let bestResult: string | null = null;
-
-  while (low <= high) {
-    const mid = Math.floor((low + high) / 2);
-    const truncated = reduceToTruncated(map, mid);
-    const formatted = formatFileMap(truncated, DetailLevel.Truncated);
-    const size = Buffer.byteLength(formatted, "utf8");
-
-    if (size <= maxBytes) {
-      // This fits, try to show more
-      bestResult = formatted;
-      low = mid + 1;
-    } else {
-      // Too big, show fewer
-      high = mid - 1;
-    }
-  }
-
-  // Return best result or fallback to minimum
-  if (bestResult) {
-    return bestResult;
-  }
-
-  // Absolute fallback: minimum symbols (guaranteed to fit)
-  const minimal = reduceToTruncated(map, minSymbols);
-  return formatFileMap(minimal, DetailLevel.Truncated);
-}

package/src/readseek/symbol-error-format.ts

@@ -1,18 +0,0 @@
-import type { FileMap } from "./types.js";
-import type { SymbolMatch } from "./symbol-lookup.js";
-
-export function formatAmbiguous(query: string, candidates: SymbolMatch[]): string {
-	const lines = candidates.map((c) => `- ${c.name} (${c.kind}) — lines ${c.startLine}-${c.endLine}`);
-	const hints = candidates.map((c) => `${query}@${c.startLine}`).join(" or ");
-	return [
-		`Symbol '${query}' is ambiguous.`,
-		"Matches:",
-		...lines,
-		`Use ${hints} to select by start line.`,
-	].join("\n");
-}
-
-export function formatNotFound(query: string, map: FileMap): string {
-	const available = map.symbols.slice(0, 20).map((s) => s.name).join(", ");
-	return `[Warning: symbol '${query}' not found. Available symbols: ${available}]`;
-}

package/src/readseek/symbol-lookup.ts

@@ -1,240 +0,0 @@
-import type { FileMap, FileSymbol } from "./types.js";
-import type { SymbolKind } from "./enums.js";
-import { traverseSymbolTree } from "./symbol-tree.js";
-
-export interface SymbolMatch {
-  name: string;
-  kind: SymbolKind;
-  startLine: number;
-  endLine: number;
-  parentName?: string;
-}
-
-type SymbolLookupResult =
-  | { type: "found"; symbol: SymbolMatch }
-  | { type: "ambiguous"; candidates: SymbolMatch[] }
-  | {
-      type: "fuzzy";
-      symbol: SymbolMatch;
-      tier: "camelCase" | "substring";
-      otherCandidates: SymbolMatch[];
-    }
-  | { type: "not-found"; message?: string; candidates?: SymbolMatch[] };
-
-function toMatch(symbol: FileSymbol, parentName?: string): SymbolMatch {
-  return {
-    name: symbol.name,
-    kind: symbol.kind,
-    startLine: symbol.startLine,
-    endLine: symbol.endLine,
-    ...(parentName ? { parentName } : {}),
-  };
-}
-
-interface SymbolCandidate {
-  symbol: FileSymbol;
-  parentName?: string;
-}
-
-function toMatches(candidates: SymbolCandidate[]): SymbolMatch[] {
-  return candidates.map((candidate) => toMatch(candidate.symbol, candidate.parentName));
-}
-
-function flattenSymbols(symbols: FileSymbol[]): SymbolCandidate[] {
-  return traverseSymbolTree(symbols, (symbol, parentName) => ({ symbol, parentName }));
-}
-
-function resolveDotPath(symbols: FileSymbol[], parts: string[]): SymbolCandidate[] {
-  let candidates: SymbolCandidate[] = symbols
-    .filter((symbol) => symbol.name === parts[0])
-    .map((symbol) => ({ symbol }));
-
-  for (let i = 1; i < parts.length; i++) {
-    const nextCandidates: SymbolCandidate[] = [];
-
-    for (const candidate of candidates) {
-      for (const child of candidate.symbol.children ?? []) {
-        if (child.name === parts[i]) {
-          nextCandidates.push({ symbol: child, parentName: candidate.symbol.name });
-        }
-      }
-    }
-
-    candidates = nextCandidates;
-  }
-
-  return candidates;
-}
-
-const JAVA_TOP_LEVEL_TYPE_KINDS = new Set(["class", "interface", "enum", "module"]);
-
-function preferJavaTopLevelType(map: FileMap, candidates: SymbolCandidate[]): SymbolCandidate | undefined {
-  if (map.language !== "Java") return undefined;
-  const topLevelTypes = candidates.filter(
-    (candidate) => !candidate.parentName && JAVA_TOP_LEVEL_TYPE_KINDS.has(candidate.symbol.kind),
-  );
-  return topLevelTypes.length === 1 ? topLevelTypes[0] : undefined;
-}
-
-function resolveDotPathSuffix(symbols: FileSymbol[], parts: string[]): SymbolCandidate[] {
-  for (let start = 1; start < parts.length; start++) {
-    const candidates = resolveDotPath(symbols, parts.slice(start));
-    if (candidates.length > 0) return candidates;
-  }
-  return [];
-}
-
-export function findSymbol(map: FileMap, query: string): SymbolLookupResult {
-  const q = query.trim();
-  if (!q) return { type: "not-found" };
-  if (map.symbols.length === 0) return { type: "not-found" };
-
-  const allSymbols = flattenSymbols(map.symbols);
-
-  const atLineMatch = /^(.+?)@(\d+)$/.exec(q);
-  if (atLineMatch) {
-    const namePart = atLineMatch[1];
-    const lineNum = Number.parseInt(atLineMatch[2], 10);
-    let pool: SymbolCandidate[];
-    if (namePart.includes(".")) {
-      const parts = namePart.split(".").map((p) => p.trim());
-      pool = parts.every((p) => p.length > 0)
-        ? resolveDotPath(map.symbols, parts)
-        : [];
-      if (pool.length === 0) {
-        pool = allSymbols.filter((c) => c.symbol.name === namePart);
-      }
-    } else {
-      pool = allSymbols.filter((c) => c.symbol.name === namePart);
-    }
-    // drop candidates without usable startLine. If that empties
-    // the pool entirely, surface any same-leaf-name decls elsewhere in the file
-    // so the user can see real candidate lines.
-    pool = pool.filter((c) => Number.isFinite(c.symbol.startLine) && c.symbol.startLine > 0);
-    if (pool.length === 0) {
-      const leaf = namePart.split(".").pop() ?? namePart;
-      const sameLeaf = allSymbols.filter(
-        (c) => c.symbol.name === leaf
-          && Number.isFinite(c.symbol.startLine)
-          && c.symbol.startLine > 0,
-      );
-      if (sameLeaf.length > 0) {
-        const list = sameLeaf
-          .slice(0, 5)
-          .map((c) => `${c.parentName ? c.parentName + "." : ""}${c.symbol.name}@${c.symbol.startLine}`)
-          .join(", ");
-        return {
-          type: "not-found",
-          message: `${q} not found. Candidates: ${list}`,
-          candidates: toMatches(sameLeaf.slice(0, 5)),
-        };
-      }
-    }
-    if (pool.length > 0) {
-      const containing = pool.filter(
-        (c) => c.symbol.startLine <= lineNum && c.symbol.endLine >= lineNum,
-      );
-      if (containing.length > 0) {
-        return { type: "found", symbol: toMatch(containing[0].symbol, containing[0].parentName) };
-      }
-      const below = pool
-        .filter((c) => c.symbol.startLine >= lineNum)
-        .sort((a, b) => a.symbol.startLine - b.symbol.startLine);
-      if (below.length) {
-        return { type: "found", symbol: toMatch(below[0].symbol, below[0].parentName) };
-      }
-      const above = pool
-        .filter((c) => c.symbol.startLine < lineNum)
-        .sort((a, b) => b.symbol.startLine - a.symbol.startLine);
-      if (above.length) {
-        return { type: "found", symbol: toMatch(above[0].symbol, above[0].parentName) };
-      }
-    }
-  }
-
-  const exact = allSymbols.filter((c) => c.symbol.name === q);
-  if (exact.length === 1) return { type: "found", symbol: toMatch(exact[0].symbol, exact[0].parentName) };
-  if (exact.length > 1) {
-    const preferred = preferJavaTopLevelType(map, exact);
-    if (preferred) return { type: "found", symbol: toMatch(preferred.symbol, preferred.parentName) };
-    return { type: "ambiguous", candidates: toMatches(exact.slice(0, 5)) };
-  }
-
-  if (q.includes(".")) {
-    const parts = q.split(".").map((p) => p.trim());
-    if (parts.length >= 2 && parts.every((p) => p.length > 0)) {
-      const candidates = resolveDotPath(map.symbols, parts);
-      if (candidates.length === 1) {
-        return { type: "found", symbol: toMatch(candidates[0].symbol, candidates[0].parentName) };
-      }
-      if (candidates.length > 1) {
-        return {
-          type: "ambiguous",
-          candidates: toMatches(candidates.slice(0, 5)),
-        };
-      }
-      const suffixCandidates = resolveDotPathSuffix(map.symbols, parts);
-      if (suffixCandidates.length === 1) {
-        return { type: "found", symbol: toMatch(suffixCandidates[0].symbol, suffixCandidates[0].parentName) };
-      }
-      if (suffixCandidates.length > 1) {
-        return {
-          type: "ambiguous",
-          candidates: toMatches(suffixCandidates.slice(0, 5)),
-        };
-      }
-    }
-  }
-
-  const qLower = q.toLowerCase();
-
-  // Tier 1: case-insensitive exact
-  const ci = allSymbols.filter((c) => c.symbol.name.toLowerCase() === qLower);
-  if (ci.length === 1) return { type: "found", symbol: toMatch(ci[0].symbol, ci[0].parentName) };
-  if (ci.length > 1) return { type: "ambiguous", candidates: toMatches(ci.slice(0, 5)) };
-
-  // Tier 2: prefix match
-  const prefix = allSymbols.filter((c) => c.symbol.name.toLowerCase().startsWith(qLower));
-  if (prefix.length === 1) return { type: "found", symbol: toMatch(prefix[0].symbol, prefix[0].parentName) };
-  if (prefix.length > 1) return { type: "ambiguous", candidates: toMatches(prefix.slice(0, 5)) };
-
-  // Tier 3: camelCase word boundary match
-  const camelCase = allSymbols.filter((c) => {
-    const words = c.symbol.name.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/[\s_]+/);
-    return words.some((w) => w === qLower);
-  });
-
-  // Tier 4: substring match
-  const partial = allSymbols.filter((c) => c.symbol.name.toLowerCase().includes(qLower));
-  const buildOtherCandidates = (chosen: SymbolCandidate): SymbolMatch[] => {
-    const pool: SymbolCandidate[] = [];
-    const seen = new Set<FileSymbol>();
-    seen.add(chosen.symbol);
-    for (const c of [...camelCase, ...partial]) {
-      if (seen.has(c.symbol)) continue;
-      seen.add(c.symbol);
-      pool.push(c);
-    }
-    return toMatches(pool.slice(0, 4));
-  };
-  if (camelCase.length === 1) {
-    return {
-      type: "fuzzy",
-      symbol: toMatch(camelCase[0].symbol, camelCase[0].parentName),
-      tier: "camelCase",
-      otherCandidates: buildOtherCandidates(camelCase[0]),
-    };
-  }
-  if (camelCase.length > 1) return { type: "ambiguous", candidates: toMatches(camelCase.slice(0, 5)) };
-  if (partial.length === 1) {
-    return {
-      type: "fuzzy",
-      symbol: toMatch(partial[0].symbol, partial[0].parentName),
-      tier: "substring",
-      otherCandidates: buildOtherCandidates(partial[0]),
-    };
-  }
-  if (partial.length > 1) return { type: "ambiguous", candidates: toMatches(partial.slice(0, 5)) };
-
-  return { type: "not-found" };
-}

package/src/readseek/symbol-tree.ts

@@ -1,21 +0,0 @@
-import type { FileSymbol } from "./types.js";
-
-/**
- * Depth-first walk over a readseek symbol tree. {@link visit} is called for
- * every symbol with the enclosing symbol's name as `parentName` (undefined at
- * the top level); its results are returned flattened in pre-order.
- */
-export function traverseSymbolTree<T>(
-  symbols: FileSymbol[],
-  visit: (symbol: FileSymbol, parentName?: string) => T,
-): T[] {
-  const result: T[] = [];
-  const walk = (nodes: FileSymbol[], parentName?: string) => {
-    for (const symbol of nodes) {
-      result.push(visit(symbol, parentName));
-      if (symbol.children?.length) walk(symbol.children, symbol.name);
-    }
-  };
-  walk(symbols);
-  return result;
-}