@youtyan/code-viewer 0.1.14 → 0.1.16

package/web-src/server/range.ts

@@ -3,6 +3,234 @@ export type DiffRange = {
   to?: string;
 };
 
+export type ByteRange = {
+  start: number;
+  end: number;
+};
+
+export type ByteRangeParseResult =
+  | { kind: 'range'; range: ByteRange }
+  | { kind: 'invalid' }
+  | { kind: 'unsatisfiable' };
+
+export type LineRangeResult = {
+  lines: string[];
+  total: number;
+  complete: boolean;
+};
+
+export type LineOffsetIndex = {
+  size: number;
+  total: number;
+  newlines: Uint32Array | Float64Array;
+};
+
+export type IndexedLineByteRange = {
+  start: number;
+  endExclusive: number;
+};
+
+export type BytesWithLineOffsetIndex = {
+  bytes: Uint8Array;
+  index: LineOffsetIndex;
+};
+
 export function isSameWorktreeRange(range: DiffRange): boolean {
   return range.from === 'worktree' && range.to === 'worktree';
 }
+
+export function parseHttpByteRange(header: string | null, size: number): ByteRangeParseResult {
+  if (!header) return { kind: 'invalid' };
+  if (size < 1) return { kind: 'unsatisfiable' };
+  const match = header.match(/^bytes=(\d*)-(\d*)$/);
+  if (!match) return { kind: 'invalid' };
+  const [, rawStart, rawEnd] = match;
+  if (!rawStart && !rawEnd) return { kind: 'invalid' };
+  let start: number;
+  let end: number;
+  if (!rawStart) {
+    const suffixLength = Number(rawEnd);
+    if (!Number.isSafeInteger(suffixLength) || suffixLength < 1) return { kind: 'unsatisfiable' };
+    start = Math.max(0, size - suffixLength);
+    end = size - 1;
+  } else {
+    start = Number(rawStart);
+    end = rawEnd ? Number(rawEnd) : size - 1;
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end)) return { kind: 'invalid' };
+    if (end >= size) end = size - 1;
+  }
+  if (start < 0 || end < start || start >= size) return { kind: 'unsatisfiable' };
+  return { kind: 'range', range: { start, end } };
+}
+
+export async function collectLineRangeFromStream(stream: ReadableStream<Uint8Array>, start: number, end: number): Promise<LineRangeResult> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  const lines: string[] = [];
+  let lineNo = 1;
+  let pending = '';
+  let hasMore = false;
+
+  const pushLine = (line: string) => {
+    if (line.endsWith('\r')) line = line.slice(0, -1);
+    if (lineNo >= start && lineNo <= end) lines.push(line);
+    else if (lineNo > end) hasMore = true;
+    lineNo++;
+  };
+
+  while (!hasMore) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    pending += decoder.decode(chunk.value, { stream: true });
+    let newline = pending.indexOf('\n');
+    while (newline !== -1) {
+      pushLine(pending.slice(0, newline));
+      pending = pending.slice(newline + 1);
+      if (hasMore) break;
+      newline = pending.indexOf('\n');
+    }
+  }
+  if (hasMore) {
+    try { await reader.cancel(); } catch { /* best effort */ }
+    return { lines, total: lineNo - 1, complete: false };
+  }
+  pending += decoder.decode();
+  if (pending.length > 0) pushLine(pending);
+  if (hasMore) return { lines, total: lineNo - 1, complete: false };
+  return { lines, total: Math.max(0, lineNo - 1), complete: true };
+}
+
+export function buildLineOffsetIndex(bytes: Uint8Array): LineOffsetIndex {
+  const builder = createLineOffsetIndexBuilder(bytes.length);
+  for (let index = 0; index < bytes.length; index++) {
+    if (bytes[index] === 10) builder.push(index);
+  }
+  const lastByte = bytes.length > 0 ? bytes[bytes.length - 1] : -1;
+  return builder.finish(bytes.length, bytes.length > 0 && lastByte !== 10);
+}
+
+export async function buildLineOffsetIndexFromStream(stream: ReadableStream<Uint8Array>, size: number): Promise<LineOffsetIndex> {
+  const reader = stream.getReader();
+  const builder = createLineOffsetIndexBuilder(size);
+  let offset = 0;
+  let lastByte = -1;
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    const bytes = chunk.value;
+    for (let index = 0; index < bytes.length; index++) {
+      const byte = bytes[index];
+      if (byte === 10) builder.push(offset + index);
+      lastByte = byte;
+    }
+    offset += bytes.length;
+  }
+  return builder.finish(offset, offset > 0 && lastByte !== 10);
+}
+
+export async function collectByteRangeFromStream(stream: ReadableStream<Uint8Array>, start: number, endExclusive: number): Promise<Uint8Array> {
+  const reader = stream.getReader();
+  const chunks: Uint8Array[] = [];
+  let offset = 0;
+  let total = 0;
+  while (offset < endExclusive) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    const chunkStart = offset;
+    const chunkEnd = offset + chunk.value.byteLength;
+    if (chunkEnd > start && chunkStart < endExclusive) {
+      const sliceStart = Math.max(0, start - chunkStart);
+      const sliceEnd = Math.min(chunk.value.byteLength, endExclusive - chunkStart);
+      const slice = chunk.value.subarray(sliceStart, sliceEnd);
+      chunks.push(slice);
+      total += slice.byteLength;
+    }
+    offset = chunkEnd;
+  }
+  try { await reader.cancel(); } catch { /* best effort */ }
+  if (chunks.length === 1) return chunks[0];
+  const bytes = new Uint8Array(total);
+  let writeOffset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, writeOffset);
+    writeOffset += chunk.byteLength;
+  }
+  return bytes;
+}
+
+export async function collectBytesWithLineOffsetIndexFromStream(stream: ReadableStream<Uint8Array>, sizeHint: number): Promise<BytesWithLineOffsetIndex> {
+  const reader = stream.getReader();
+  const builder = createLineOffsetIndexBuilder(sizeHint);
+  const chunks: Uint8Array[] = [];
+  let offset = 0;
+  let lastByte = -1;
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    const bytes = chunk.value;
+    chunks.push(bytes);
+    for (let index = 0; index < bytes.length; index++) {
+      const byte = bytes[index];
+      if (byte === 10) builder.push(offset + index);
+      lastByte = byte;
+    }
+    offset += bytes.length;
+  }
+  const collected = new Uint8Array(offset);
+  let writeOffset = 0;
+  for (const chunk of chunks) {
+    collected.set(chunk, writeOffset);
+    writeOffset += chunk.byteLength;
+  }
+  return {
+    bytes: collected,
+    index: builder.finish(offset, offset > 0 && lastByte !== 10),
+  };
+}
+
+function createLineOffsetIndexBuilder(size: number) {
+  const useFloat64 = size > 0xffffffff;
+  let capacity = 1024;
+  let length = 0;
+  let offsets: Uint32Array | Float64Array = useFloat64 ? new Float64Array(capacity) : new Uint32Array(capacity);
+  const grow = () => {
+    capacity *= 2;
+    const next = useFloat64 ? new Float64Array(capacity) : new Uint32Array(capacity);
+    next.set(offsets);
+    offsets = next;
+  };
+  return {
+    push(offset: number) {
+      if (length >= capacity) grow();
+      offsets[length++] = offset;
+    },
+    finish(totalSize: number, hasTrailingLine: boolean): LineOffsetIndex {
+      return {
+        size: totalSize,
+        total: length + (hasTrailingLine ? 1 : 0),
+        newlines: offsets.slice(0, length) as Uint32Array | Float64Array,
+      };
+    },
+  };
+}
+
+export function lineByteRangeForIndex(index: LineOffsetIndex, start: number, end: number): IndexedLineByteRange | null {
+  const normalizedStart = Math.max(1, Math.floor(start));
+  const normalizedEnd = Math.max(normalizedStart, Math.floor(end));
+  if (normalizedStart > index.total) return null;
+  const lastLine = Math.min(normalizedEnd, index.total);
+  const byteStart = normalizedStart <= 1 ? 0 : index.newlines[normalizedStart - 2] + 1;
+  const byteEnd = lastLine <= index.newlines.length ? index.newlines[lastLine - 1] : index.size;
+  return { start: byteStart, endExclusive: byteEnd };
+}
+
+export function collectLineRangeFromIndexedText(text: string, index: LineOffsetIndex, start: number, end: number): LineRangeResult {
+  const normalizedStart = Math.max(1, Math.floor(start));
+  const normalizedEnd = Math.max(normalizedStart, Math.floor(end));
+  if (normalizedStart > index.total) return { lines: [], total: index.total, complete: true };
+  const expectedLines = Math.min(normalizedEnd, index.total) - normalizedStart + 1;
+  const lines = text.length
+    ? text.split('\n').map(line => line.endsWith('\r') ? line.slice(0, -1) : line)
+    : Array.from({ length: expectedLines }, () => '');
+  return { lines, total: index.total, complete: end >= index.total };
+}

package/web-src/server/runtime.d.ts

@@ -1,7 +1,17 @@
+interface BunFile extends globalThis.Blob {
+  arrayBuffer(): Promise<ArrayBuffer>;
+  slice(start?: number, end?: number, contentType?: string): BunFile;
+  stream(): ReadableStream<Uint8Array<ArrayBuffer>>;
+  text(): Promise<string>;
+}
+
 declare const Bun: {
+  file(path: string): BunFile;
   spawn(args: string[], opts?: Record<string, unknown>): {
     kill(signal?: string): void;
     exited: Promise<number>;
+    stdout?: ReadableStream<Uint8Array>;
+    stderr?: ReadableStream<Uint8Array>;
   };
   spawnSync(args: string[], opts?: Record<string, unknown>): {
     exitCode: number;

package/web-src/server/search.ts

@@ -12,10 +12,11 @@ export function normalizeGrepMax(value: string | null): number {
   return Math.min(parsed, GREP_ABSOLUTE_MAX);
 }
 
-export function isSkippableSearchPath(path: string): boolean {
+export function isSkippableSearchPath(path: string, omitDirNames: string[] = []): boolean {
+  const omitDirs = new Set(omitDirNames.map(name => name.toLowerCase()));
   return path.split(/[\\/]+/).some(part => {
     const lower = part.toLowerCase();
-    return lower === '.git' || lower === 'node_modules';
+    return lower === '.git' || omitDirs.has(lower);
   });
 }
 
@@ -51,8 +52,9 @@ export function buildFileSearchList(ref: string, generation: number, entries: Gi
   };
 }
 
-export function buildRgArgs(query: string, max: number, paths: string[], regex = false): string[] {
+export function buildRgArgs(query: string, max: number, paths: string[], regex = false, omitDirNames: string[] = []): string[] {
   const safePaths = paths.length ? paths : ['.'];
+  const omitGlobs = omitDirNames.flatMap(name => ['--glob', `!${name}/**`, '--glob', `!**/${name}/**`]);
   const args = [
     'rg',
     '--no-config',
@@ -66,6 +68,7 @@ export function buildRgArgs(query: string, max: number, paths: string[], regex =
     String(max),
     '--max-filesize',
     '2M',
+    ...omitGlobs,
     '-e',
     query,
     '--',
@@ -75,7 +78,7 @@ export function buildRgArgs(query: string, max: number, paths: string[], regex =
   return args;
 }
 
-export function parseRgOutput(stdout: string, max: number): GrepMatch[] {
+export function parseRgOutput(stdout: string, max: number, omitDirNames: string[] = []): GrepMatch[] {
   const matches: GrepMatch[] = [];
   for (const line of stdout.split('\n')) {
     if (!line || matches.length >= max) continue;
@@ -85,17 +88,17 @@ export function parseRgOutput(stdout: string, max: number): GrepMatch[] {
     const lineNo = Number(parsed[2]);
     const column = Number(parsed[3]);
     const preview = parsed[4];
-    if (!path || !lineNo || !column || isSkippableSearchPath(path)) continue;
+    if (!path || !lineNo || !column || isSkippableSearchPath(path, omitDirNames)) continue;
     matches.push({ path, line: lineNo, column, preview: preview.slice(0, 500) });
   }
   return matches;
 }
 
-export function parseGitGrepOutput(stdout: string, ref: string, max: number): GrepMatch[] {
+export function parseGitGrepOutput(stdout: string, ref: string, max: number, omitDirNames: string[] = []): GrepMatch[] {
   const prefix = ref + ':';
   const normalized = stdout
     .split('\n')
     .map(line => line.startsWith(prefix) ? line.slice(prefix.length) : line)
     .join('\n');
-  return parseRgOutput(normalized, max);
+  return parseRgOutput(normalized, max, omitDirNames);
 }

package/web-src/types.ts

@@ -38,7 +38,7 @@ export type RepoTreeEntry = {
   path: string;
   type: 'tree' | 'blob' | 'commit';
   children_omitted?: true;
-  children_omitted_reason?: 'ignored' | 'internal';
+  children_omitted_reason?: 'heavy' | 'internal' | 'truncated';
 };
 
 export type RepoTreeResponse = {
@@ -54,6 +54,15 @@ export type RepoTreeResponse = {
   } | null;
 };
 
+export type SettingsResponse = {
+  project: string;
+  scope: {
+    omit_dirs_effective: string[];
+    omit_dirs_built_in: string[];
+    max_entries: number;
+  };
+};
+
 export type FileSearchListResponse = {
   ref: string;
   generation: number;
@@ -97,7 +106,13 @@ export type FileRangeResponse = {
   start: number;
   end: number;
   lines: string[];
+  /**
+   * When complete is true, total is the file's total line count.
+   * When complete is false, total is only the highest line number the server
+   * had to scan to prove more lines exist.
+   */
   total: number;
+  complete?: boolean;
   generation?: number;
 };