difit 4.0.5 → 4.0.6

package/dist/types/diff.d.ts

@@ -32,7 +32,7 @@ export interface ParsedDiff {
     chunks: DiffChunk[];
 }
 export type DiffViewMode = 'split' | 'unified';
-export type LegacyDiffViewMode = 'side-by-side' | 'inline';
+type LegacyDiffViewMode = 'side-by-side' | 'inline';
 export type DiffSide = 'old' | 'new';
 export type DiffLineRange = number | {
     start: number;
@@ -168,11 +168,11 @@ export interface CommentThread {
     codeContent?: string;
     messages: DiffCommentMessage[];
 }
-export interface RevisionOption {
+interface RevisionOption {
     value: string;
     label: string;
 }
-export interface BranchInfo {
+interface BranchInfo {
     name: string;
     current: boolean;
 }
@@ -199,7 +199,7 @@ export interface FileExpandedState {
     oldTotalLines?: number;
     newTotalLines?: number;
 }
-export interface ExpandedRange {
+interface ExpandedRange {
     chunkIndex: number;
     direction: 'up' | 'down';
     count: number;

package/dist/types/watch.d.ts

@@ -5,12 +5,41 @@ export declare enum DiffMode {
     DOT = "dot",// HEAD vs working (all changes)
     SPECIFIC = "specific"
 }
+type WatchChangeType = 'file' | 'commit' | 'staging';
+interface ConnectedWatchEvent {
+    type: 'connected';
+    diffMode: DiffMode;
+    changeType: WatchChangeType;
+    timestamp: string;
+    message?: string;
+}
+interface ReloadWatchEvent {
+    type: 'reload';
+    diffMode: DiffMode;
+    changeType: WatchChangeType;
+    timestamp: string;
+    message?: string;
+}
+interface ErrorWatchEvent {
+    type: 'error';
+    diffMode: DiffMode;
+    changeType: WatchChangeType;
+    timestamp: string;
+    message?: string;
+}
+interface CommentsChangedWatchEvent {
+    type: 'commentsChanged';
+    version: number;
+    timestamp: string;
+}
+export type WatchEvent = ConnectedWatchEvent | ReloadWatchEvent | ErrorWatchEvent | CommentsChangedWatchEvent;
 export interface ClientWatchState {
     isWatchEnabled: boolean;
     diffMode: DiffMode;
     shouldReload: boolean;
     isReloading: boolean;
     lastChangeTime: Date | null;
-    lastChangeType: 'file' | 'commit' | 'staging' | null;
+    lastChangeType: WatchChangeType | null;
     connectionStatus: 'connected' | 'disconnected' | 'reconnecting';
 }
+export {};

package/dist/utils/commentImports.d.ts

@@ -3,7 +3,9 @@ interface MergeCommentImportsResult {
     threads: DiffCommentThread[];
     warnings: string[];
 }
+export declare function normalizeCommentImports(input: unknown): CommentImport[];
 export declare function parseCommentImportValue(value: string): CommentImport[];
+export declare function mergeCommentThreads(existingThreads: DiffCommentThread[], incomingThreads: DiffCommentThread[]): MergeCommentImportsResult;
 export declare function serializeCommentImports(commentImports: CommentImport[]): string;
 export declare function mergeCommentImports(existingThreads: DiffCommentThread[], commentImports: CommentImport[]): MergeCommentImportsResult;
 export {};

package/dist/utils/commentImports.js

@@ -105,7 +105,7 @@ function normalizeCommentImportEntry(value) {
     };
     return normalized;
 }
-function normalizeCommentImports(input) {
+export function normalizeCommentImports(input) {
     if (Array.isArray(input)) {
         return input.map((entry) => normalizeCommentImportEntry(entry));
     }
@@ -204,6 +204,124 @@ function createImportedReply(commentImport, now) {
         updatedAt,
     };
 }
+function cloneLineRange(line) {
+    if (typeof line === 'number') {
+        return line;
+    }
+    return {
+        start: line.start,
+        end: line.end,
+    };
+}
+function clonePosition(position) {
+    return {
+        side: position.side,
+        line: cloneLineRange(position.line),
+    };
+}
+function cloneCodeSnapshot(snapshot) {
+    if (!snapshot) {
+        return undefined;
+    }
+    return {
+        content: snapshot.content,
+        language: snapshot.language,
+    };
+}
+function cloneMessage(message) {
+    return {
+        id: message.id,
+        body: message.body,
+        author: message.author,
+        createdAt: message.createdAt,
+        updatedAt: message.updatedAt,
+    };
+}
+function cloneThread(thread) {
+    return {
+        id: thread.id,
+        filePath: thread.filePath,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt,
+        position: clonePosition(thread.position),
+        codeSnapshot: cloneCodeSnapshot(thread.codeSnapshot),
+        messages: thread.messages.map(cloneMessage),
+    };
+}
+function messagesMatch(left, right) {
+    if (left.id === right.id) {
+        return true;
+    }
+    if (normalizeAuthor(left.author) !== normalizeAuthor(right.author)) {
+        return false;
+    }
+    return left.body === right.body && left.createdAt === right.createdAt;
+}
+function threadsMatch(left, right) {
+    if (left.id === right.id) {
+        return true;
+    }
+    if (left.filePath !== right.filePath || !positionsMatch(left.position, right.position)) {
+        return false;
+    }
+    const leftRoot = left.messages[0];
+    const rightRoot = right.messages[0];
+    if (!leftRoot || !rightRoot) {
+        return false;
+    }
+    return messagesMatch(leftRoot, rightRoot);
+}
+function sortReplies(left, right) {
+    const createdAtOrder = left.createdAt.localeCompare(right.createdAt);
+    if (createdAtOrder !== 0) {
+        return createdAtOrder;
+    }
+    return left.id.localeCompare(right.id);
+}
+function pickNewerMessage(existingMessage, incomingMessage) {
+    if (incomingMessage.updatedAt.localeCompare(existingMessage.updatedAt) >= 0) {
+        return cloneMessage(incomingMessage);
+    }
+    return cloneMessage(existingMessage);
+}
+function mergeThread(existingThread, incomingThread) {
+    const mergedMessages = existingThread.messages.map(cloneMessage);
+    for (const incomingMessage of incomingThread.messages) {
+        const matchIndex = mergedMessages.findIndex((message) => messagesMatch(message, incomingMessage));
+        if (matchIndex >= 0) {
+            mergedMessages[matchIndex] = pickNewerMessage(mergedMessages[matchIndex], incomingMessage);
+            continue;
+        }
+        mergedMessages.push(cloneMessage(incomingMessage));
+    }
+    const [rootMessage, ...replyMessages] = mergedMessages;
+    const orderedMessages = rootMessage
+        ? [rootMessage, ...replyMessages.sort(sortReplies)]
+        : replyMessages.sort(sortReplies);
+    const updatedAt = orderedMessages.reduce((latest, message) => maxIsoTimestamp(latest, message.updatedAt), maxIsoTimestamp(existingThread.updatedAt, incomingThread.updatedAt));
+    return {
+        ...cloneThread(existingThread),
+        createdAt: existingThread.createdAt.localeCompare(incomingThread.createdAt) <= 0
+            ? existingThread.createdAt
+            : incomingThread.createdAt,
+        updatedAt,
+        position: clonePosition(existingThread.position),
+        codeSnapshot: cloneCodeSnapshot(incomingThread.codeSnapshot ?? existingThread.codeSnapshot),
+        messages: orderedMessages,
+    };
+}
+export function mergeCommentThreads(existingThreads, incomingThreads) {
+    const threads = existingThreads.map(cloneThread);
+    for (const incomingThread of incomingThreads) {
+        const existingIndex = threads.findIndex((thread) => threadsMatch(thread, incomingThread));
+        if (existingIndex < 0) {
+            threads.push(cloneThread(incomingThread));
+            continue;
+        }
+        threads[existingIndex] = mergeThread(threads[existingIndex], incomingThread);
+    }
+    return { threads, warnings: [] };
+}
 function serializeLineRange(line) {
     if (typeof line === 'number') {
         return line;

package/dist/utils/editorOptions.d.ts

@@ -1,37 +1,60 @@
-export declare const EDITOR_OPTIONS: readonly [{
-    readonly id: "vscode";
-    readonly label: "VS Code";
-    readonly protocol: "vscode";
-    readonly cliCommand: "code";
-    readonly cliArgs: readonly [];
-    readonly lineFormat: "goto-flag";
-    readonly aliases: readonly ["vscode", "code"];
-}, {
-    readonly id: "cursor";
-    readonly label: "Cursor";
-    readonly protocol: "cursor";
-    readonly cliCommand: "cursor";
-    readonly cliArgs: readonly [];
-    readonly lineFormat: "goto-flag";
-    readonly aliases: readonly ["cursor"];
-}, {
-    readonly id: "zed";
-    readonly label: "Zed";
-    readonly protocol: "zed";
-    readonly cliCommand: "zed";
-    readonly cliArgs: readonly [];
-    readonly lineFormat: "path-suffix";
-    readonly aliases: readonly ["zed"];
-}, {
-    readonly id: "none";
-    readonly label: "Hide “Open in editor” button";
-    readonly protocol: null;
-    readonly cliCommand: null;
-    readonly cliArgs: readonly [];
-    readonly lineFormat: "goto-flag";
-    readonly aliases: readonly ["none", "disabled", "off"];
-}];
-export type EditorOption = (typeof EDITOR_OPTIONS)[number];
-export type EditorOptionId = EditorOption['id'];
+export type EditorOptionId = 'vscode' | 'cursor' | 'zed' | 'textmate' | 'bbedit' | 'emacs' | 'macvim' | 'sublime' | 'nova' | 'custom' | 'none';
+interface EditorOption {
+    readonly id: EditorOptionId;
+    readonly label: string;
+    /**
+     * Executable to run. Empty string for the `custom` placeholder (filled in by
+     * the user) and for `none` (open-in-editor disabled).
+     */
+    readonly command: string;
+    /**
+     * Whitespace-separated argument template. Supports the `%file` and `%line`
+     * placeholders. Parsed just before spawning so quoted segments survive:
+     * e.g. `'-l %line "%file"'`.
+     */
+    readonly argsTemplate: string;
+}
+export declare const CUSTOM_EDITOR_ID: EditorOptionId;
+export declare const NONE_EDITOR_ID: EditorOptionId;
 export declare const DEFAULT_EDITOR_ID: EditorOptionId;
+export declare const EDITOR_OPTIONS: readonly [EditorOption, ...EditorOption[]];
+export declare const DEFAULT_EDITOR_OPTION: EditorOption;
+/**
+ * Case-insensitive lookup by id. Used mostly for the `DIFIT_EDITOR` / `EDITOR`
+ * environment-variable fallback on the server; the browser UI passes the full
+ * `{id, command, argsTemplate}` shape so it does not rely on this helper.
+ */
 export declare const resolveEditorOption: (input?: string) => EditorOption;
+/**
+ * Tokenise a user-supplied arguments template string into individual CLI
+ * arguments. Supports single and double quoted segments so paths and flags
+ * containing spaces can be preserved.
+ *
+ * Inside double-quoted segments `\"` decodes to a literal `"` and `\\` to a
+ * literal `\`, mirroring common shell intuition. Other `\x` sequences pass
+ * through untouched so Lisp/regex fragments like `\s` or `\$` stay intact.
+ * Single-quoted segments are fully literal. The template is handed to
+ * `spawn` as argv directly – no shell is involved.
+ */
+export declare const parseEditorArgsTemplate: (template: string | undefined | null) => string[];
+interface EditorSpawnSpec {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+interface BuildEditorSpawnSpecInput {
+    readonly command: string;
+    readonly argsTemplate: string;
+    readonly filePath: string;
+    readonly lineNumber: number | null;
+}
+/**
+ * Build the final `{ command, args }` tuple to hand to `child_process.spawn`.
+ * Returns `null` when the command is empty so callers can surface a clear
+ * "not configured" error instead of spawning an empty process.
+ *
+ * `%file` and `%line` are substituted as-is inside each token, so composite
+ * tokens such as `"%file:%line"` become `"/abs/file.ts:42"`. When no line
+ * number is available the substitution falls back to `1`.
+ */
+export declare const buildEditorSpawnSpec: (input: BuildEditorSpawnSpecInput) => EditorSpawnSpec | null;
+export {};

package/dist/utils/editorOptions.js

@@ -1,45 +1,171 @@
+export const CUSTOM_EDITOR_ID = 'custom';
+export const NONE_EDITOR_ID = 'none';
+export const DEFAULT_EDITOR_ID = 'vscode';
 export const EDITOR_OPTIONS = [
     {
         id: 'vscode',
         label: 'VS Code',
-        protocol: 'vscode',
-        cliCommand: 'code',
-        cliArgs: [],
-        lineFormat: 'goto-flag',
-        aliases: ['vscode', 'code'],
+        command: 'code',
+        argsTemplate: '-g %file:%line',
     },
     {
         id: 'cursor',
         label: 'Cursor',
-        protocol: 'cursor',
-        cliCommand: 'cursor',
-        cliArgs: [],
-        lineFormat: 'goto-flag',
-        aliases: ['cursor'],
+        command: 'cursor',
+        argsTemplate: '-g %file:%line',
     },
     {
         id: 'zed',
         label: 'Zed',
-        protocol: 'zed',
-        cliCommand: 'zed',
-        cliArgs: [],
-        lineFormat: 'path-suffix',
-        aliases: ['zed'],
+        command: 'zed',
+        argsTemplate: '%file:%line',
+    },
+    {
+        id: 'textmate',
+        label: 'TextMate',
+        command: 'mate',
+        argsTemplate: '-l %line %file',
+    },
+    {
+        id: 'bbedit',
+        label: 'BBEdit',
+        command: 'bbedit',
+        argsTemplate: '+%line %file',
+    },
+    {
+        id: 'emacs',
+        label: 'Emacs',
+        command: 'emacsclient',
+        argsTemplate: '--no-wait +%line %file',
+    },
+    {
+        id: 'macvim',
+        label: 'MacVim',
+        command: 'mvim',
+        argsTemplate: '--remote-silent +%line %file',
+    },
+    {
+        id: 'sublime',
+        label: 'Sublime Text',
+        command: 'subl',
+        argsTemplate: '%file:%line',
+    },
+    {
+        id: 'nova',
+        label: 'Nova',
+        command: 'nova',
+        argsTemplate: 'open %file -l %line',
+    },
+    {
+        id: 'custom',
+        label: 'Custom…',
+        command: '',
+        argsTemplate: '',
     },
     {
         id: 'none',
         label: 'Hide “Open in editor” button',
-        protocol: null,
-        cliCommand: null,
-        cliArgs: [],
-        lineFormat: 'goto-flag',
-        aliases: ['none', 'disabled', 'off'],
+        command: '',
+        argsTemplate: '',
     },
 ];
-export const DEFAULT_EDITOR_ID = 'vscode';
+export const DEFAULT_EDITOR_OPTION = EDITOR_OPTIONS.find((option) => option.id === DEFAULT_EDITOR_ID) ?? EDITOR_OPTIONS[0];
+/**
+ * Case-insensitive lookup by id. Used mostly for the `DIFIT_EDITOR` / `EDITOR`
+ * environment-variable fallback on the server; the browser UI passes the full
+ * `{id, command, argsTemplate}` shape so it does not rely on this helper.
+ */
 export const resolveEditorOption = (input) => {
     const normalized = (input ?? DEFAULT_EDITOR_ID).toLowerCase();
-    const matched = EDITOR_OPTIONS.find((option) => option.id === normalized || option.aliases.some((alias) => alias === normalized));
-    const fallback = EDITOR_OPTIONS.find((option) => option.id === DEFAULT_EDITOR_ID);
-    return matched ?? fallback ?? EDITOR_OPTIONS[0];
+    const matched = EDITOR_OPTIONS.find((option) => option.id === normalized);
+    return matched ?? DEFAULT_EDITOR_OPTION;
+};
+/**
+ * Tokenise a user-supplied arguments template string into individual CLI
+ * arguments. Supports single and double quoted segments so paths and flags
+ * containing spaces can be preserved.
+ *
+ * Inside double-quoted segments `\"` decodes to a literal `"` and `\\` to a
+ * literal `\`, mirroring common shell intuition. Other `\x` sequences pass
+ * through untouched so Lisp/regex fragments like `\s` or `\$` stay intact.
+ * Single-quoted segments are fully literal. The template is handed to
+ * `spawn` as argv directly – no shell is involved.
+ */
+export const parseEditorArgsTemplate = (template) => {
+    const input = template ?? '';
+    const tokens = [];
+    const n = input.length;
+    let i = 0;
+    while (i < n) {
+        while (i < n && /\s/.test(input[i] ?? ''))
+            i++;
+        if (i >= n)
+            break;
+        let token = '';
+        let inQuote = null;
+        while (i < n) {
+            const ch = input[i];
+            if (ch === undefined)
+                break;
+            if (inQuote === '"') {
+                if (ch === '\\' && i + 1 < n) {
+                    const next = input[i + 1];
+                    if (next === '"' || next === '\\') {
+                        token += next;
+                        i += 2;
+                        continue;
+                    }
+                }
+                if (ch === inQuote) {
+                    inQuote = null;
+                    i++;
+                }
+                else {
+                    token += ch;
+                    i++;
+                }
+                continue;
+            }
+            if (inQuote === "'") {
+                if (ch === inQuote) {
+                    inQuote = null;
+                    i++;
+                }
+                else {
+                    token += ch;
+                    i++;
+                }
+                continue;
+            }
+            if (ch === '"' || ch === "'") {
+                inQuote = ch;
+                i++;
+                continue;
+            }
+            if (/\s/.test(ch))
+                break;
+            token += ch;
+            i++;
+        }
+        tokens.push(token);
+    }
+    return tokens;
+};
+/**
+ * Build the final `{ command, args }` tuple to hand to `child_process.spawn`.
+ * Returns `null` when the command is empty so callers can surface a clear
+ * "not configured" error instead of spawning an empty process.
+ *
+ * `%file` and `%line` are substituted as-is inside each token, so composite
+ * tokens such as `"%file:%line"` become `"/abs/file.ts:42"`. When no line
+ * number is available the substitution falls back to `1`.
+ */
+export const buildEditorSpawnSpec = (input) => {
+    const command = input.command.trim();
+    if (!command)
+        return null;
+    const tokens = parseEditorArgsTemplate(input.argsTemplate);
+    const lineValue = String(input.lineNumber ?? 1);
+    const args = tokens.map((piece) => piece.replaceAll('%file', input.filePath).replaceAll('%line', lineValue));
+    return { command, args };
 };