@youtyan/code-viewer 0.1.7 → 0.1.9

package/web-src/server/dev-assets.ts

@@ -0,0 +1,37 @@
+import { basename } from 'node:path';
+
+export type WatchFn = (
+  path: string,
+  options: { persistent?: boolean },
+  listener: (eventType: string, filename: string | Buffer | null) => void,
+) => unknown;
+
+type DevAssetReloadOptions = {
+  enabled: boolean;
+  webRoot: string;
+  watchedFiles: readonly string[];
+  watch: WatchFn;
+  sendReload: () => void;
+  setTimeoutFn?: typeof setTimeout;
+  clearTimeoutFn?: typeof clearTimeout;
+  debounceMs?: number;
+};
+
+export function startDevAssetReload(options: DevAssetReloadOptions): boolean {
+  if (!options.enabled) return false;
+  const watched = new Set(options.watchedFiles);
+  const setTimer = options.setTimeoutFn || setTimeout;
+  const clearTimer = options.clearTimeoutFn || clearTimeout;
+  const debounceMs = options.debounceMs ?? 150;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  options.watch(options.webRoot, { persistent: false }, (_event, filename) => {
+    if (!filename || !watched.has(basename(filename.toString()))) return;
+    if (timer) clearTimer(timer);
+    timer = setTimer(() => {
+      timer = null;
+      options.sendReload();
+    }, debounceMs);
+  });
+  return true;
+}

package/web-src/server/dev.ts

@@ -56,7 +56,12 @@ function startServer() {
   firstStart = false;
   server = Bun.spawn([
     'bun', 'run', 'web-src/server/preview.ts', ...args,
-  ], { cwd: ROOT, stdout: 'inherit', stderr: 'inherit' }) as ChildProcess;
+  ], {
+    cwd: ROOT,
+    stdout: 'inherit',
+    stderr: 'inherit',
+    env: { ...process.env, CODE_VIEWER_DEV: '1' },
+  }) as ChildProcess;
 }
 
 async function restartServer() {

package/web-src/server/git.ts

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { existsSync, lstatSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 export type GitFileMeta = {
@@ -17,6 +17,7 @@ export type GitTreeEntry = {
   name: string;
   path: string;
   type: 'tree' | 'blob' | 'commit';
+  children_omitted?: true;
 };
 
 function run(args: string[], cwd: string): { code: number; stdout: string; stderr: string } {
@@ -28,6 +29,15 @@ function run(args: string[], cwd: string): { code: number; stdout: string; stder
   };
 }
 
+function runBytes(args: string[], cwd: string): { code: number; stdout: Uint8Array; stderr: string } {
+  const proc = Bun.spawnSync(args, { cwd, stdout: 'pipe', stderr: 'pipe' });
+  return {
+    code: proc.exitCode,
+    stdout: new Uint8Array(proc.stdout),
+    stderr: new TextDecoder().decode(proc.stderr),
+  };
+}
+
 export function repoRoot(cwd: string): string | null {
   const res = run(['git', 'rev-parse', '--show-toplevel'], cwd);
   return res.code === 0 ? res.stdout.trimEnd() : null;
@@ -42,6 +52,15 @@ export function show(ref: string, path: string, cwd: string): { code: number; st
   return run(['git', 'show', `${ref}:${path}`], cwd);
 }
 
+export function showBytes(ref: string, path: string, cwd: string): { code: number; stdout: Uint8Array; stderr: string } {
+  return runBytes(['git', 'show', `${ref}:${path}`], cwd);
+}
+
+export function objectSize(ref: string, path: string, cwd: string): { code: number; size: number; stderr: string } {
+  const res = run(['git', 'cat-file', '-s', `${ref}:${path}`], cwd);
+  return { code: res.code, size: Number(res.stdout.trim()) || 0, stderr: res.stderr };
+}
+
 export function verifyTreeRef(ref: string, cwd: string): boolean {
   if (!ref || ref === 'worktree') return false;
   if (ref.startsWith('-')) return false;
@@ -143,10 +162,13 @@ function worktreeDirectChildren(cwd: string, path: string): GitTreeEntry[] {
   try {
     return sortTreeEntries(readdirSync(dir, { withFileTypes: true }).map((entry) => {
       const entryPath = base ? `${base}/${entry.name}` : entry.name;
+      const type = entry.isDirectory()
+        ? hasDotGitEntry(join(dir, entry.name)) ? 'commit' as const : 'tree' as const
+        : 'blob' as const;
       return {
         name: entry.name,
         path: entryPath,
-        type: entry.isDirectory() ? 'tree' as const : 'blob' as const,
+        type,
       };
     }));
   } catch {
@@ -154,6 +176,15 @@ function worktreeDirectChildren(cwd: string, path: string): GitTreeEntry[] {
   }
 }
 
+function hasDotGitEntry(dir: string): boolean {
+  try {
+    lstatSync(join(dir, '.git'));
+    return true;
+  } catch (err) {
+    return !!err && typeof err === 'object' && 'code' in err && err.code !== 'ENOENT';
+  }
+}
+
 function worktreeRecursiveFiles(cwd: string, path: string): GitTreeEntry[] {
   const base = normalizeTreePath(path);
   const trackedArgs = ['git', '-c', 'core.quotepath=false', 'ls-files', '-z'];
@@ -196,6 +227,31 @@ function combineDirectAndRecursiveFiles(directEntries: GitTreeEntry[], fileEntri
   ];
 }
 
+function ignoredWorktreePaths(cwd: string, path: string): Set<string> {
+  const base = normalizeTreePath(path);
+  const args = ['git', '-c', 'core.quotepath=false', 'status', '--ignored', '--porcelain=v1', '-z', '--'];
+  if (base) args.push(`${base}/`);
+  const res = run(args, cwd);
+  const ignored = new Set<string>();
+  if (res.code !== 0) return ignored;
+  const records = res.stdout.split('\0').filter(Boolean);
+  for (let i = 0; i < records.length; i++) {
+    const rec = records[i];
+    if (!rec.startsWith('!! ')) continue;
+    const path = rec.slice(3).replace(/\/+$/g, '');
+    if (path) ignored.add(path);
+  }
+  return ignored;
+}
+
+function annotateOmittedWorktreeChildren(entries: GitTreeEntry[], ignoredPaths: Set<string>): GitTreeEntry[] {
+  return entries.map((entry) => {
+    return entry.type === 'tree' && ignoredPaths.has(entry.path)
+      ? { ...entry, children_omitted: true }
+      : entry;
+  });
+}
+
 export function worktreeEntries(cwd: string, path: string): GitTreeEntry[] {
   return listTree('worktree', path, cwd).entries;
 }
@@ -221,8 +277,11 @@ export function listTree(
   const base = normalizeTreePath(path);
   if (ref === 'worktree') {
     const directEntries = worktreeDirectChildren(cwd, base);
-    if (!options.recursive) return { code: 0, entries: directEntries, stderr: '' };
-    return { code: 0, entries: combineDirectAndRecursiveFiles(directEntries, worktreeRecursiveFiles(cwd, base)), stderr: '' };
+    const ignoredPaths = ignoredWorktreePaths(cwd, base);
+    const annotatedDirectEntries = annotateOmittedWorktreeChildren(directEntries, ignoredPaths);
+    if (!options.recursive) return { code: 0, entries: annotatedDirectEntries, stderr: '' };
+    const recursiveEntries = worktreeRecursiveFiles(cwd, base);
+    return { code: 0, entries: combineDirectAndRecursiveFiles(annotatedDirectEntries, recursiveEntries), stderr: '' };
   }
 
   const direct = gitTreeEntries(ref, base, cwd, false);
@@ -302,17 +361,65 @@ export function truncateToNHunks(diffText: string, n: number): {
   totalHunks: number;
   renderedHunks: number;
   lineCount: number;
+  lineTruncated: boolean;
+};
+export function truncateToNHunks(diffText: string, n: number, maxLines: number): {
+  text: string;
+  totalHunks: number;
+  renderedHunks: number;
+  lineCount: number;
+  lineTruncated: boolean;
+};
+export function truncateToNHunks(diffText: string, n: number, maxLines = Number.POSITIVE_INFINITY): {
+  text: string;
+  totalHunks: number;
+  renderedHunks: number;
+  lineCount: number;
+  lineTruncated: boolean;
 } {
   const { header, hunks } = splitHunks(diffText);
   if (hunks.length === 0) {
-    return { text: diffText, totalHunks: 0, renderedHunks: 0, lineCount: (diffText.match(/\n/g) || []).length };
+    const lines = diffText.split('\n');
+    const lineTruncated = Number.isFinite(maxLines) && lines.length > maxLines;
+    const text = lineTruncated ? lines.slice(0, maxLines).join('\n') : diffText;
+    return {
+      text,
+      totalHunks: 0,
+      renderedHunks: 0,
+      lineCount: (text.match(/\n/g) || []).length,
+      lineTruncated,
+    };
+  }
+  const maxHunks = Math.min(n, hunks.length);
+  const rendered: string[] = [];
+  let renderedHunks = 0;
+  let usedLines = (header.match(/\n/g) || []).length;
+  let lineTruncated = false;
+  for (let index = 0; index < maxHunks; index++) {
+    const hunk = hunks[index];
+    const lines = hunk.split('\n');
+    const separatorLines = rendered.length > 0 ? 1 : 0;
+    const remaining = maxLines - usedLines - separatorLines;
+    if (remaining <= 0) {
+      lineTruncated = true;
+      break;
+    }
+    if (Number.isFinite(maxLines) && lines.length > remaining) {
+      rendered.push(lines.slice(0, remaining).join('\n'));
+      renderedHunks++;
+      lineTruncated = true;
+      break;
+    }
+    rendered.push(hunk);
+    renderedHunks++;
+    usedLines += separatorLines + lines.length;
   }
-  const renderedHunks = Math.min(n, hunks.length);
-  const text = header + hunks.slice(0, renderedHunks).join('\n');
+  const text = header + rendered.join('\n');
   return {
     text,
     totalHunks: hunks.length,
     renderedHunks,
     lineCount: (text.match(/\n/g) || []).length,
+    lineTruncated,
   };
 }