diffstalker 0.1.6 → 0.2.0

package/dist/utils/formatDate.js

@@ -1 +1,39 @@
-export function formatDate(t){const o=new Date().getTime()-t.getTime(),e=Math.floor(o/(1e3*60*60)),n=Math.floor(o/(1e3*60*60*24));return e<1?`${Math.floor(o/6e4)}m ago`:e<48?`${e}h ago`:n<=14?`${n}d ago`:t.toLocaleDateString("en-US",{month:"short",day:"numeric"})}export function formatDateAbsolute(t){return t.toLocaleString("en-US",{year:"numeric",month:"short",day:"numeric",hour:"2-digit",minute:"2-digit"})}
+/**
+ * Format a date relative to now:
+ * - Hours for first 48 hours (e.g., "3h ago", "47h ago")
+ * - Days for first 14 days (e.g., "3d ago")
+ * - Date after that (e.g., "Jan 15")
+ */
+export function formatDate(date) {
+    const now = new Date();
+    const diff = now.getTime() - date.getTime();
+    const hours = Math.floor(diff / (1000 * 60 * 60));
+    const days = Math.floor(diff / (1000 * 60 * 60 * 24));
+    if (hours < 1) {
+        const mins = Math.floor(diff / (1000 * 60));
+        return `${mins}m ago`;
+    }
+    else if (hours < 48) {
+        return `${hours}h ago`;
+    }
+    else if (days <= 14) {
+        return `${days}d ago`;
+    }
+    else {
+        return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+    }
+}
+/**
+ * Format a date as an absolute date/time string.
+ * Used for commit details where exact timestamp is needed.
+ * Example: "Jan 15, 2024, 10:30 AM"
+ */
+export function formatDateAbsolute(date) {
+    return date.toLocaleString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+}

package/dist/utils/formatPath.js

@@ -1 +1,58 @@
-export function shortenPath(e,f){if(e.length<=f)return e;const i=Math.max(f,20);if(e.length<=i)return e;const t=e.split("/");if(t.length===1){const n=Math.floor((i-1)/2);return e.slice(0,n)+"\u2026"+e.slice(-(i-n-1))}const l=t[t.length-1],h=t[0],o="/\u2026/";if(h.length+o.length+l.length>i){const n=i-2;if(l.length>n){const r=Math.floor((n-1)/2);return"\u2026/"+l.slice(0,r)+"\u2026"+l.slice(-(n-r-1))}return"\u2026/"+l}let c=h,s=1;for(;s<t.length-1;){const n=t[s],r=c+"/"+n;if(r.length+o.length+l.length<=i)c=r,s++;else break}return s===t.length-1?e:c+o+l}
+/**
+ * Shorten a file path to fit within maxLength by putting ellipsis in the middle.
+ * Keeps the first directory and filename visible as they're most informative.
+ *
+ * Example: "src/components/very/long/path/to/Component.tsx" (maxLength: 40)
+ *       -> "src/components/…/Component.tsx"
+ */
+export function shortenPath(path, maxLength) {
+    if (path.length <= maxLength) {
+        return path;
+    }
+    // Minimum length we'll go (don't truncate too aggressively)
+    const minLength = 20;
+    const effectiveMax = Math.max(maxLength, minLength);
+    if (path.length <= effectiveMax) {
+        return path;
+    }
+    const parts = path.split('/');
+    // If it's just a filename with no directories, truncate the middle of the filename
+    if (parts.length === 1) {
+        const half = Math.floor((effectiveMax - 1) / 2);
+        return path.slice(0, half) + '…' + path.slice(-(effectiveMax - half - 1));
+    }
+    const filename = parts[parts.length - 1];
+    const firstPart = parts[0];
+    // Reserve space for: firstPart + "/…/" + filename
+    const ellipsis = '/…/';
+    const minRequired = firstPart.length + ellipsis.length + filename.length;
+    // If even the minimum doesn't fit, just show ellipsis + filename
+    if (minRequired > effectiveMax) {
+        const availableForFilename = effectiveMax - 2; // "…/"
+        if (filename.length > availableForFilename) {
+            // Truncate filename itself
+            const half = Math.floor((availableForFilename - 1) / 2);
+            return ('…/' + filename.slice(0, half) + '…' + filename.slice(-(availableForFilename - half - 1)));
+        }
+        return '…/' + filename;
+    }
+    // Try to include more path parts from the start
+    let prefix = firstPart;
+    let i = 1;
+    while (i < parts.length - 1) {
+        const nextPart = parts[i];
+        const candidate = prefix + '/' + nextPart;
+        if (candidate.length + ellipsis.length + filename.length <= effectiveMax) {
+            prefix = candidate;
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    // If we included all parts, return original (shouldn't happen given length check)
+    if (i === parts.length - 1) {
+        return path;
+    }
+    return prefix + ellipsis + filename;
+}

package/dist/utils/languageDetection.js

@@ -0,0 +1,236 @@
+/**
+ * Language detection and syntax highlighting utilities for file content.
+ * Uses the emphasize package for ANSI terminal colors.
+ */
+import { createEmphasize } from 'emphasize';
+import { common } from 'lowlight';
+// Create emphasize instance with common languages
+const emphasize = createEmphasize(common);
+// Map file extensions to highlight.js language names
+const EXTENSION_TO_LANGUAGE = {
+    // TypeScript/JavaScript
+    ts: 'typescript',
+    tsx: 'typescript',
+    js: 'javascript',
+    jsx: 'javascript',
+    mjs: 'javascript',
+    cjs: 'javascript',
+    // Web
+    html: 'xml',
+    htm: 'xml',
+    xml: 'xml',
+    svg: 'xml',
+    css: 'css',
+    scss: 'scss',
+    sass: 'scss',
+    less: 'less',
+    // Data formats
+    json: 'json',
+    yaml: 'yaml',
+    yml: 'yaml',
+    toml: 'ini',
+    // Shell/Config
+    sh: 'bash',
+    bash: 'bash',
+    zsh: 'bash',
+    fish: 'bash',
+    ps1: 'powershell',
+    bat: 'dos',
+    cmd: 'dos',
+    // Systems languages
+    c: 'c',
+    h: 'c',
+    cpp: 'cpp',
+    hpp: 'cpp',
+    cc: 'cpp',
+    cxx: 'cpp',
+    rs: 'rust',
+    go: 'go',
+    zig: 'zig',
+    // JVM
+    java: 'java',
+    kt: 'kotlin',
+    kts: 'kotlin',
+    scala: 'scala',
+    groovy: 'groovy',
+    gradle: 'groovy',
+    // Scripting
+    py: 'python',
+    rb: 'ruby',
+    pl: 'perl',
+    lua: 'lua',
+    php: 'php',
+    r: 'r',
+    // Functional
+    hs: 'haskell',
+    ml: 'ocaml',
+    fs: 'fsharp',
+    fsx: 'fsharp',
+    ex: 'elixir',
+    exs: 'elixir',
+    erl: 'erlang',
+    clj: 'clojure',
+    cljs: 'clojure',
+    // .NET
+    cs: 'csharp',
+    vb: 'vbnet',
+    // Documentation
+    md: 'markdown',
+    markdown: 'markdown',
+    rst: 'plaintext',
+    txt: 'plaintext',
+    // Config/Build
+    Makefile: 'makefile',
+    Dockerfile: 'dockerfile',
+    cmake: 'cmake',
+    ini: 'ini',
+    conf: 'ini',
+    cfg: 'ini',
+    // SQL
+    sql: 'sql',
+    // Other
+    vim: 'vim',
+    diff: 'diff',
+    patch: 'diff',
+};
+// Special filenames that map to languages
+const FILENAME_TO_LANGUAGE = {
+    Makefile: 'makefile',
+    makefile: 'makefile',
+    GNUmakefile: 'makefile',
+    Dockerfile: 'dockerfile',
+    dockerfile: 'dockerfile',
+    Jenkinsfile: 'groovy',
+    Vagrantfile: 'ruby',
+    Gemfile: 'ruby',
+    Rakefile: 'ruby',
+    '.gitignore': 'plaintext',
+    '.gitattributes': 'plaintext',
+    '.editorconfig': 'ini',
+    '.prettierrc': 'json',
+    '.eslintrc': 'json',
+    'tsconfig.json': 'json',
+    'package.json': 'json',
+    'package-lock.json': 'json',
+    'bun.lockb': 'plaintext',
+    'yarn.lock': 'yaml',
+    'pnpm-lock.yaml': 'yaml',
+    'Cargo.toml': 'ini',
+    'Cargo.lock': 'ini',
+    'go.mod': 'go',
+    'go.sum': 'plaintext',
+};
+// Cache of available languages
+let availableLanguages = null;
+function getAvailableLanguages() {
+    if (!availableLanguages) {
+        availableLanguages = new Set(emphasize.listLanguages());
+    }
+    return availableLanguages;
+}
+/**
+ * Get the highlight.js language name from a file path.
+ * Returns null if the language cannot be determined or is not supported.
+ */
+export function getLanguageFromPath(filePath) {
+    if (!filePath)
+        return null;
+    // Check special filenames first
+    const filename = filePath.split('/').pop() ?? '';
+    if (FILENAME_TO_LANGUAGE[filename]) {
+        const lang = FILENAME_TO_LANGUAGE[filename];
+        return getAvailableLanguages().has(lang) ? lang : null;
+    }
+    // Get extension
+    const ext = filename.includes('.') ? filename.split('.').pop()?.toLowerCase() : null;
+    if (!ext)
+        return null;
+    const lang = EXTENSION_TO_LANGUAGE[ext];
+    if (!lang)
+        return null;
+    // Verify language is available
+    return getAvailableLanguages().has(lang) ? lang : null;
+}
+/**
+ * Apply syntax highlighting to a line of code.
+ * Returns the highlighted string with ANSI escape codes.
+ * If highlighting fails, returns the original content.
+ * Skips highlighting for lines that look like comments (heuristic for multi-line context).
+ */
+export function highlightLine(content, language) {
+    if (!content || !language)
+        return content;
+    try {
+        const result = emphasize.highlight(language, content);
+        return result.value;
+    }
+    catch {
+        // If highlighting fails, return original content
+        return content;
+    }
+}
+/**
+ * Apply syntax highlighting preserving background color.
+ * Replaces full ANSI resets with foreground-only resets so that
+ * the caller's background color is not cleared.
+ * Returns the highlighted string, or original content if highlighting fails.
+ */
+export function highlightLinePreserveBg(content, language) {
+    if (!content || !language)
+        return content;
+    try {
+        const result = emphasize.highlight(language, content);
+        // Replace full reset (\x1b[0m) with foreground-only reset (\x1b[39m)
+        // This preserves any background color set by the caller
+        return result.value.replace(/\x1b\[0m/g, '\x1b[39m');
+    }
+    catch {
+        return content;
+    }
+}
+/**
+ * Highlight multiple lines as a block, preserving multi-line context
+ * (e.g., block comments, multi-line strings).
+ * Returns an array of highlighted lines.
+ */
+export function highlightBlock(lines, language) {
+    if (!language || lines.length === 0)
+        return lines;
+    try {
+        // Join lines and highlight as one block to preserve state
+        const block = lines.join('\n');
+        const result = emphasize.highlight(language, block);
+        return result.value.split('\n');
+    }
+    catch {
+        return lines;
+    }
+}
+/**
+ * Highlight multiple lines as a block, preserving background color.
+ * Returns an array of highlighted lines with foreground-only resets.
+ */
+export function highlightBlockPreserveBg(lines, language) {
+    if (!language || lines.length === 0)
+        return lines;
+    try {
+        const block = lines.join('\n');
+        const result = emphasize.highlight(language, block);
+        // Replace full resets with foreground-only resets
+        const highlighted = result.value.replace(/\x1b\[0m/g, '\x1b[39m');
+        return highlighted.split('\n');
+    }
+    catch {
+        return lines;
+    }
+}
+/**
+ * Apply syntax highlighting to multiple lines.
+ * More efficient than calling highlightLine for each line
+ * as it reuses the language detection.
+ */
+export function highlightLines(lines, language) {
+    if (!language || lines.length === 0)
+        return lines;
+    return lines.map((line) => highlightLine(line, language));
+}

package/dist/utils/layoutCalculations.js

@@ -1 +1,98 @@
-import{getFileListSectionCounts as h}from"./fileCategories.js";export{getFileListSectionCounts}from"./fileCategories.js";export function getFileListTotalRows(o){const{modifiedCount:t,untrackedCount:i,stagedCount:n}=h(o);let r=0;return t>0&&(r+=1+t),i>0&&(t>0&&(r+=1),r+=1+i),n>0&&((t>0||i>0)&&(r+=1),r+=1+n),r}export function calculatePaneHeights(o,t,i=.4){const n=getFileListTotalRows(o),r=3,a=Math.floor(t*i),s=Math.max(r,Math.min(n,a)),f=t-s;return{topPaneHeight:s,bottomPaneHeight:f}}export function getRowForFileIndex(o,t,i,n){let r=0;if(o<t)return 1+o;t>0&&(r+=1+t);const a=t;if(o<a+i){const g=o-a;return t>0&&(r+=1),r+1+g}i>0&&(t>0&&(r+=1),r+=1+i);const s=t+i,f=o-s;return(t>0||i>0)&&(r+=1),r+1+f}export function calculateScrollOffset(o,t,i){return o<t?Math.max(0,o-1):o>=t+i?o-i+1:t}
+import { getFileListSectionCounts } from './fileCategories.js';
+// Re-export for backwards compatibility
+export { getFileListSectionCounts } from './fileCategories.js';
+/**
+ * Calculate total rows for the FileList component.
+ * Accounts for headers and spacers between sections.
+ */
+export function getFileListTotalRows(files) {
+    const { modifiedCount, untrackedCount, stagedCount } = getFileListSectionCounts(files);
+    let rows = 0;
+    // Modified section
+    if (modifiedCount > 0) {
+        rows += 1 + modifiedCount; // header + files
+    }
+    // Untracked section
+    if (untrackedCount > 0) {
+        if (modifiedCount > 0)
+            rows += 1; // spacer
+        rows += 1 + untrackedCount; // header + files
+    }
+    // Staged section
+    if (stagedCount > 0) {
+        if (modifiedCount > 0 || untrackedCount > 0)
+            rows += 1; // spacer
+        rows += 1 + stagedCount; // header + files
+    }
+    return rows;
+}
+/**
+ * Calculate the heights of the top (file list) and bottom (diff/commit/etc) panes
+ * based on the number of files and available content area.
+ *
+ * The top pane grows to fit files up to 40% of content height.
+ * The bottom pane gets the remaining space.
+ */
+export function calculatePaneHeights(files, contentHeight, maxTopRatio = 0.4) {
+    // Calculate content rows needed for staging area
+    // Uses getFileListTotalRows for consistency with FileList rendering
+    const neededRows = getFileListTotalRows(files);
+    // Minimum height of 3 (header + 2 lines for empty state)
+    const minHeight = 3;
+    // Maximum is maxTopRatio of content area
+    const maxHeight = Math.floor(contentHeight * maxTopRatio);
+    // Use the smaller of needed or max, but at least min
+    const topHeight = Math.max(minHeight, Math.min(neededRows, maxHeight));
+    const bottomHeight = contentHeight - topHeight;
+    return { topPaneHeight: topHeight, bottomPaneHeight: bottomHeight };
+}
+/**
+ * Calculate which row in the file list a file at a given index occupies.
+ * This accounts for headers and spacers in the list.
+ * File order: Modified → Untracked → Staged (matches FileList.tsx)
+ */
+export function getRowForFileIndex(selectedIndex, modifiedCount, untrackedCount, _stagedCount) {
+    let row = 0;
+    // Modified section
+    if (selectedIndex < modifiedCount) {
+        // In modified section: header + file rows
+        return 1 + selectedIndex;
+    }
+    if (modifiedCount > 0) {
+        row += 1 + modifiedCount; // header + files
+    }
+    // Untracked section
+    const untrackedStart = modifiedCount;
+    if (selectedIndex < untrackedStart + untrackedCount) {
+        // In untracked section
+        const untrackedIdx = selectedIndex - untrackedStart;
+        if (modifiedCount > 0)
+            row += 1; // spacer
+        return row + 1 + untrackedIdx; // header + file position
+    }
+    if (untrackedCount > 0) {
+        if (modifiedCount > 0)
+            row += 1; // spacer
+        row += 1 + untrackedCount; // header + files
+    }
+    // Staged section
+    const stagedStart = modifiedCount + untrackedCount;
+    const stagedIdx = selectedIndex - stagedStart;
+    if (modifiedCount > 0 || untrackedCount > 0)
+        row += 1; // spacer
+    return row + 1 + stagedIdx; // header + file position
+}
+/**
+ * Calculate the scroll offset needed to keep a selected row visible.
+ */
+export function calculateScrollOffset(selectedRow, currentScrollOffset, visibleHeight) {
+    // Scroll up if selected is above visible area
+    if (selectedRow < currentScrollOffset) {
+        return Math.max(0, selectedRow - 1);
+    }
+    // Scroll down if selected is below visible area
+    else if (selectedRow >= currentScrollOffset + visibleHeight) {
+        return selectedRow - visibleHeight + 1;
+    }
+    return currentScrollOffset;
+}

package/dist/utils/lineBreaking.js

@@ -1,5 +1,88 @@
-export function breakLine(t,n,i=!0){if(n<=0)return[{text:t,isContinuation:!1}];if(t.length<=n)return[{text:t,isContinuation:!1}];const r=[];let e=t,o=!0;for(;e.length>0;){if(e.length<=n){r.push({text:e,isContinuation:!o});break}r.push({text:e.slice(0,n),isContinuation:!o}),e=e.slice(n),o=!1}return i&&l(t,n,r),r}function l(t,n,i){const r=i.map(e=>e.text).join("");if(r!==t)throw new Error(`[LineBreaking] Content was lost during breaking!
-Original (${t.length} chars): "${t.slice(0,50)}${t.length>50?"...":""}"
-Joined (${r.length} chars): "${r.slice(0,50)}${r.length>50?"...":""}"`);for(let e=0;e<i.length;e++){const o=i[e];if(o.text.length>n&&n>=1)throw new Error(`[LineBreaking] Segment ${e} exceeds maxWidth!
-Segment length: ${o.text.length}, maxWidth: ${n}
-Segment: "${o.text.slice(0,50)}${o.text.length>50?"...":""}"`)}if(i.length>0&&i[0].isContinuation)throw new Error("[LineBreaking] First segment incorrectly marked as continuation!");for(let e=1;e<i.length;e++)if(!i[e].isContinuation)throw new Error(`[LineBreaking] Segment ${e} should be marked as continuation but isn't!`)}export function getLineRowCount(t,n){return n<=0||t.length<=n?1:Math.ceil(t.length/n)}
+/**
+ * Utilities for manually breaking long lines at exact character boundaries.
+ * This gives us full control over line wrapping behavior in the diff view.
+ */
+/**
+ * Break a string into segments that fit within the given width.
+ * Breaks at exact character boundaries for predictable, consistent output.
+ *
+ * @param content - The string to break
+ * @param maxWidth - Maximum width for each segment
+ * @param validate - If true, validates the result and throws on errors (default: true)
+ * @returns Array of line segments
+ */
+export function breakLine(content, maxWidth, validate = true) {
+    if (maxWidth <= 0) {
+        return [{ text: content, isContinuation: false }];
+    }
+    if (content.length <= maxWidth) {
+        return [{ text: content, isContinuation: false }];
+    }
+    const segments = [];
+    let remaining = content;
+    let isFirst = true;
+    while (remaining.length > 0) {
+        if (remaining.length <= maxWidth) {
+            segments.push({ text: remaining, isContinuation: !isFirst });
+            break;
+        }
+        segments.push({
+            text: remaining.slice(0, maxWidth),
+            isContinuation: !isFirst,
+        });
+        remaining = remaining.slice(maxWidth);
+        isFirst = false;
+    }
+    // Validate the result
+    if (validate) {
+        validateBreakResult(content, maxWidth, segments);
+    }
+    return segments;
+}
+/**
+ * Validate that line breaking produced correct results.
+ * Throws an error if validation fails, making issues visible during development.
+ */
+function validateBreakResult(original, maxWidth, segments) {
+    // Check 1: Segments should join to equal original
+    const joined = segments.map((s) => s.text).join('');
+    if (joined !== original) {
+        throw new Error(`[LineBreaking] Content was lost during breaking!\n` +
+            `Original (${original.length} chars): "${original.slice(0, 50)}${original.length > 50 ? '...' : ''}"\n` +
+            `Joined (${joined.length} chars): "${joined.slice(0, 50)}${joined.length > 50 ? '...' : ''}"`);
+    }
+    // Check 2: No segment should exceed maxWidth (except if maxWidth is too small)
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if (segment.text.length > maxWidth && maxWidth >= 1) {
+            throw new Error(`[LineBreaking] Segment ${i} exceeds maxWidth!\n` +
+                `Segment length: ${segment.text.length}, maxWidth: ${maxWidth}\n` +
+                `Segment: "${segment.text.slice(0, 50)}${segment.text.length > 50 ? '...' : ''}"`);
+        }
+    }
+    // Check 3: First segment should not be marked as continuation
+    if (segments.length > 0 && segments[0].isContinuation) {
+        throw new Error(`[LineBreaking] First segment incorrectly marked as continuation!`);
+    }
+    // Check 4: Subsequent segments should be marked as continuation
+    for (let i = 1; i < segments.length; i++) {
+        if (!segments[i].isContinuation) {
+            throw new Error(`[LineBreaking] Segment ${i} should be marked as continuation but isn't!`);
+        }
+    }
+}
+/**
+ * Calculate how many visual rows a content string will take when broken.
+ *
+ * @param content - The string content
+ * @param maxWidth - Maximum width per row
+ * @returns Number of rows needed
+ */
+export function getLineRowCount(content, maxWidth) {
+    if (maxWidth <= 0)
+        return 1;
+    if (content.length <= maxWidth)
+        return 1;
+    // Simple math since we break at exact boundaries
+    return Math.ceil(content.length / maxWidth);
+}