@youtyan/code-viewer 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youtyan/code-viewer",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Local browser-based git diff viewer",
   "type": "module",
   "bin": {

package/web/app.js

@@ -382,12 +382,13 @@
       button.innerHTML = expanded ? iconSvg("octicon-fold", FOLD_16_PATH) : iconSvg("octicon-unfold", UNFOLD_16_PATH);
     }
     function buildTree(files) {
-      const root = { name: "", dirs: {}, files: [], path: "", minOrder: Infinity };
+      const root = { name: "", dirs: {}, files: [], path: "", minOrder: Infinity, explicit: true };
       for (const f of files) {
         const parts = f.path.split("/");
         let node = root;
         let acc = "";
-        for (let i = 0;i < parts.length - 1; i++) {
+        const dirPartCount = f.type === "tree" ? parts.length : parts.length - 1;
+        for (let i = 0;i < dirPartCount; i++) {
           const p = parts[i];
           acc = acc ? acc + "/" + p : p;
           if (!node.dirs[p]) {
@@ -397,11 +398,15 @@
           if (typeof f.order === "number" && f.order < node.minOrder)
             node.minOrder = f.order;
         }
+        if (f.type === "tree") {
+          node.explicit = true;
+          continue;
+        }
         node.files.push(f);
       }
       function compress(node) {
         const ks = Object.keys(node.dirs);
-        while (ks.length === 1 && node.files.length === 0 && node !== root) {
+        while (ks.length === 1 && node.files.length === 0 && !node.explicit && node !== root) {
           const only = node.dirs[ks[0]];
           node.name = node.name ? node.name + "/" + only.name : only.name;
           node.dirs = only.dirs;
@@ -432,6 +437,8 @@
           const li = document.createElement("li");
           li.className = "tree-dir";
           li.dataset.dirpath = dir.path;
+          if (dir.explicit)
+            li.dataset.explicit = "true";
           li.style.setProperty("--lvl-pad", 12 + depth * 14 + "px");
           const chev = document.createElement("span");
           chev.className = "chev";
@@ -650,17 +657,19 @@
         const match = matches(card.dataset.path || "");
         card.classList.toggle("hidden-by-filter", !match);
       });
-      updateTreeDirVisibility();
+      updateTreeDirVisibility(matches, filter.kind !== "empty" && !invalid);
       if (typeof applyViewedState === "function")
         applyViewedState();
     }
-    function updateTreeDirVisibility() {
+    function updateTreeDirVisibility(dirMatches, filterActive = false) {
       $$("#filelist .tree-dir").forEach((dir) => {
         const childUl = dir.nextElementSibling;
         if (!childUl || !childUl.classList.contains("tree-children"))
           return;
         const anyVisible = !!childUl.querySelector(".tree-file:not(.hidden):not(.hidden-by-tests)");
-        dir.classList.toggle("hidden", !anyVisible);
+        const explicitVisible = dir.dataset.explicit === "true" && !filterActive;
+        const selfMatches = filterActive && !!dirMatches && dirMatches(dir.dataset.dirpath || "");
+        dir.classList.toggle("hidden", !anyVisible && !explicitVisible && !selfMatches);
       });
     }
     let SERVER_GENERATION = 0;
@@ -1030,10 +1039,11 @@
           throw new Error("failed to load repository tree");
         return r.json();
       })).then((meta) => {
-        const files = meta.entries.filter((entry) => entry.type !== "tree").map((entry, index) => ({
+        const files = meta.entries.map((entry, index) => ({
           order: index + 1,
           path: entry.path,
-          display_path: entry.path
+          display_path: entry.path,
+          type: entry.type
         }));
         renderSidebar(files, (file) => {
           setRoute({ screen: "file", path: file.path, ref, view: "blob", range: currentRange() });

package/web-src/server/cache.ts

@@ -0,0 +1,13 @@
+// Short enough that a browser reload self-heals stale git data, while still
+// coalescing bursts from one render pass.
+export const CACHE_TTL_MS = 1500;
+
+export type TimedCacheEntry<T> = T & { storedAt: number };
+
+export function cacheFresh<T>(
+  cached: TimedCacheEntry<T> | undefined,
+  now = Date.now(),
+  ttlMs = CACHE_TTL_MS,
+): cached is TimedCacheEntry<T> {
+  return !!cached && now - cached.storedAt <= ttlMs;
+}

package/web-src/server/git.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 export type GitFileMeta = {
@@ -130,27 +130,72 @@ function normalizeTreePath(path: string): string {
   return path.replace(/^\/+|\/+$/g, '');
 }
 
-function directChildren(paths: string[], basePath: string): GitTreeEntry[] {
-  const base = normalizeTreePath(basePath);
-  const prefix = base ? `${base}/` : '';
-  const entries = new Map<string, GitTreeEntry>();
-  for (const rawPath of paths) {
-    if (!rawPath || (prefix && !rawPath.startsWith(prefix))) continue;
-    const rest = prefix ? rawPath.slice(prefix.length) : rawPath;
-    if (!rest) continue;
-    const slash = rest.indexOf('/');
-    const name = slash >= 0 ? rest.slice(0, slash) : rest;
-    const childPath = prefix + name;
-    const type = slash >= 0 ? 'tree' : 'blob';
-    const existing = entries.get(childPath);
-    if (!existing || existing.type !== 'tree') entries.set(childPath, { name, path: childPath, type });
-  }
-  return [...entries.values()].sort((a, b) => {
+function sortTreeEntries(entries: GitTreeEntry[]): GitTreeEntry[] {
+  return [...entries].sort((a, b) => {
     if (a.type !== b.type) return a.type === 'tree' ? -1 : 1;
     return a.name.localeCompare(b.name);
   });
 }
 
+function worktreeDirectChildren(cwd: string, path: string): GitTreeEntry[] {
+  const base = normalizeTreePath(path);
+  const dir = join(cwd, base);
+  try {
+    return sortTreeEntries(readdirSync(dir, { withFileTypes: true }).map((entry) => {
+      const entryPath = base ? `${base}/${entry.name}` : entry.name;
+      return {
+        name: entry.name,
+        path: entryPath,
+        type: entry.isDirectory() ? 'tree' as const : 'blob' as const,
+      };
+    }));
+  } catch {
+    return [];
+  }
+}
+
+function worktreeRecursiveFiles(cwd: string, path: string): GitTreeEntry[] {
+  const base = normalizeTreePath(path);
+  const trackedArgs = ['git', '-c', 'core.quotepath=false', 'ls-files', '-z'];
+  if (base) trackedArgs.push('--', `${base}/`);
+  const tracked = run(trackedArgs, cwd);
+  const paths = tracked.code === 0 ? tracked.stdout.split('\0').filter(Boolean) : [];
+  paths.push(...untracked(cwd, base));
+  return [...new Set(paths)].filter(Boolean).sort().map((entryPath) => ({
+    name: entryPath.split('/').pop() || entryPath,
+    path: entryPath,
+    type: 'blob' as const,
+  }));
+}
+
+function gitTreeEntries(ref: string, path: string, cwd: string, recursive: boolean): { code: number; entries: GitTreeEntry[]; stderr: string } {
+  const base = normalizeTreePath(path);
+  const args = ['git', '-c', 'core.quotepath=false', 'ls-tree'];
+  if (recursive) args.push('-r');
+  args.push('-z', '--full-tree', ref, '--');
+  if (base) args.push(`${base}/`);
+  const res = run(args, cwd);
+  if (res.code !== 0) return { code: res.code, entries: [], stderr: res.stderr };
+  const allowedTypes = recursive ? 'blob|commit' : 'tree|blob|commit';
+  let entries = res.stdout.split('\0').filter(Boolean).map((rec) => {
+    const match = rec.match(new RegExp(`^\\d+\\s+(${allowedTypes})\\s+[0-9a-fA-F]+\\t(.+)$`));
+    if (!match) return null;
+    const entryPath = match[2];
+    return { name: entryPath.split('/').pop() || entryPath, path: entryPath, type: match[1] as GitTreeEntry['type'] };
+  }).filter((entry): entry is GitTreeEntry => !!entry);
+  if (recursive) entries.sort((a, b) => a.path.localeCompare(b.path));
+  else entries = sortTreeEntries(entries);
+  return { code: 0, entries, stderr: '' };
+}
+
+function combineDirectAndRecursiveFiles(directEntries: GitTreeEntry[], fileEntries: GitTreeEntry[]): GitTreeEntry[] {
+  const seen = new Set(directEntries.map((entry) => entry.path));
+  return [
+    ...directEntries,
+    ...fileEntries.filter((entry) => !seen.has(entry.path)),
+  ];
+}
+
 export function worktreeEntries(cwd: string, path: string): GitTreeEntry[] {
   return listTree('worktree', path, cwd).entries;
 }
@@ -175,41 +220,16 @@ export function listTree(
 ): { code: number; entries: GitTreeEntry[]; stderr: string } {
   const base = normalizeTreePath(path);
   if (ref === 'worktree') {
-    const trackedArgs = ['git', '-c', 'core.quotepath=false', 'ls-files', '-z'];
-    if (!options.recursive) trackedArgs.push('--', base ? `${base}/` : '.');
-    const tracked = run(trackedArgs, cwd);
-    const paths = tracked.code === 0 ? tracked.stdout.split('\0').filter(Boolean) : [];
-    paths.push(...untracked(cwd, options.recursive ? '' : base));
-    const uniquePaths = [...new Set(paths)].filter(Boolean);
-    const entries = options.recursive
-      ? uniquePaths.sort().map((entryPath) => ({
-        name: entryPath.split('/').pop() || entryPath,
-        path: entryPath,
-        type: 'blob' as const,
-      }))
-      : directChildren(uniquePaths, base);
-    return { code: 0, entries, stderr: '' };
+    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 args = ['git', '-c', 'core.quotepath=false', 'ls-tree'];
-  if (options.recursive) args.push('-r');
-  args.push('-z', '--full-tree', ref, '--');
-  if (!options.recursive && base) args.push(`${base}/`);
-  const res = run(args, cwd);
-  if (res.code !== 0) return { code: res.code, entries: [], stderr: res.stderr };
-  const allowedTypes = options.recursive ? 'blob|commit' : 'tree|blob|commit';
-  const entries = res.stdout.split('\0').filter(Boolean).map((rec) => {
-    const match = rec.match(new RegExp(`^\\d+\\s+(${allowedTypes})\\s+[0-9a-fA-F]+\\t(.+)$`));
-    if (!match) return null;
-    const entryPath = match[2];
-    return { name: entryPath.split('/').pop() || entryPath, path: entryPath, type: match[1] as GitTreeEntry['type'] };
-  }).filter((entry): entry is GitTreeEntry => !!entry);
-  entries.sort((a, b) => {
-    if (options.recursive) return a.path.localeCompare(b.path);
-    if (a.type !== b.type) return a.type === 'tree' ? -1 : 1;
-    return a.name.localeCompare(b.name);
-  });
-  return { code: 0, entries, stderr: '' };
+  const direct = gitTreeEntries(ref, base, cwd, false);
+  if (direct.code !== 0 || !options.recursive) return direct;
+  const recursive = gitTreeEntries(ref, base, cwd, true);
+  if (recursive.code !== 0) return recursive;
+  return { code: 0, entries: combineDirectAndRecursiveFiles(direct.entries, recursive.entries), stderr: '' };
 }
 
 export function untrackedMeta(cwd: string): GitFileMeta[] {

package/web-src/server/preview.ts

@@ -4,6 +4,7 @@ import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { basename, extname, join, normalize, relative } from 'node:path';
 import { APP_ENTRY_PATHS, SPA_PATHS } from '../routes';
 import type { DiffMeta, FileDiffResponse, FileMeta, FileRangeResponse, RepoTreeResponse } from '../types';
+import { cacheFresh, type TimedCacheEntry } from './cache';
 import * as git from './git';
 import { isSameWorktreeRange } from './range';
 
@@ -24,8 +25,8 @@ let listenPort = 0;
 
 const enc = new TextEncoder();
 const sseClients = new Set<ReadableStreamDefaultController<Uint8Array>>();
-const fileCache = new Map<string, string>();
-const metaCache = new Map<string, { body: string; sig: string }>();
+const fileCache = new Map<string, TimedCacheEntry<{ diffText: string }>>();
+const metaCache = new Map<string, TimedCacheEntry<{ body: string; sig: string }>>();
 
 function parseCli() {
   const rest: string[] = [];
@@ -242,14 +243,14 @@ function handleDiffJson(url: URL) {
       fileCache.clear();
     }
     const body = JSON.stringify(payload);
-    metaCache.set(key, { body, sig });
+    metaCache.set(key, { body, sig, storedAt: Date.now() });
     return new Response(body, { headers: { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' } });
   }
   const cached = metaCache.get(key);
-  if (cached) return new Response(cached.body, { headers: { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' } });
+  if (cacheFresh(cached)) return new Response(cached.body, { headers: { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' } });
   const payload = computePayload(extras, range);
   const body = JSON.stringify(payload);
-  metaCache.set(key, { body, sig: JSON.stringify({ ...payload, generation: undefined }) });
+  metaCache.set(key, { body, sig: JSON.stringify({ ...payload, generation: undefined }), storedAt: Date.now() });
   return new Response(body, { headers: { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' } });
 }
 
@@ -262,8 +263,13 @@ function safeRepoPath(path: string) {
   return path === '' || safePath(path);
 }
 
+function isGitInternalPath(path: string): boolean {
+  return path === '.git' || path.startsWith('.git/');
+}
+
 function safeWorktreePath(path: string): string | null {
   if (!safePath(path)) return null;
+  if (isGitInternalPath(path)) return null;
   const full = join(cwd, path);
   if (!existsSync(full)) return null;
   const realCwd = realpathSync(cwd);
@@ -296,6 +302,7 @@ function handleTree(url: URL) {
   const target = url.searchParams.get('ref') || url.searchParams.get('target') || 'worktree';
   const path = (url.searchParams.get('path') || '').replace(/^\/+|\/+$/g, '');
   if (!safeRepoPath(path)) return text('invalid path', 400);
+  if ((target === 'worktree' || target === '') && isGitInternalPath(path)) return text('forbidden', 403);
   if (target !== 'worktree' && !git.verifyTreeRef(target, cwd)) return text('invalid target', 400);
   const recursive = url.searchParams.get('recursive') === '1';
   const entries = git.listTree(target, path, cwd, { recursive }).entries;
@@ -337,9 +344,12 @@ function handleFileDiff(url: URL) {
   const cacheKey = isUntracked
     ? `u\0${path}\0${extras.join('\0')}`
     : `t\0${path}\0${oldPath || ''}\0${[...extras, ...args].join('\0')}`;
-  let diffText = fileCache.get(cacheKey);
+  const cached = fileCache.get(cacheKey);
+  let diffText: string;
   let errText = '';
-  if (!diffText) {
+  if (cacheFresh(cached)) {
+    diffText = cached.diffText;
+  } else {
     if (isUntracked) {
       diffText = git.untrackedFileDiff(extras, path, cwd).stdout || '';
     } else {
@@ -347,7 +357,7 @@ function handleFileDiff(url: URL) {
       diffText = res.stdout || '';
       if (res.code !== 0) errText = res.stderr;
     }
-    fileCache.set(cacheKey, diffText);
+    fileCache.set(cacheKey, { diffText, storedAt: Date.now() });
   }
   const mode = url.searchParams.get('mode') || 'full';
   const truncated = mode === 'preview'