difit 4.0.5 → 4.0.7

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 };
 };

package/dist/utils/editorOptions.test.js

@@ -1,24 +1,216 @@
 import { describe, expect, it } from 'vitest';
-import { DEFAULT_EDITOR_ID, EDITOR_OPTIONS, resolveEditorOption } from './editorOptions';
+import { buildEditorSpawnSpec, CUSTOM_EDITOR_ID, DEFAULT_EDITOR_ID, EDITOR_OPTIONS, NONE_EDITOR_ID, parseEditorArgsTemplate, resolveEditorOption, } from './editorOptions';
 describe('editorOptions', () => {
-    it('includes Zed in editor options', () => {
+    it('includes Zed in editor options with the unified command+args shape', () => {
         const zed = EDITOR_OPTIONS.find((option) => option.id === 'zed');
         expect(zed).toBeDefined();
         expect(zed).toMatchObject({
             id: 'zed',
             label: 'Zed',
-            protocol: 'zed',
-            cliCommand: 'zed',
-            lineFormat: 'path-suffix',
+            command: 'zed',
+            argsTemplate: '%file:%line',
         });
     });
-    it('resolves zed editor from id', () => {
+    it('resolves zed editor from id and case-insensitively', () => {
         expect(resolveEditorOption('zed').id).toBe('zed');
-    });
-    it('resolves zed editor case-insensitively', () => {
         expect(resolveEditorOption('ZED').id).toBe('zed');
     });
-    it('falls back to default editor when unknown value is passed', () => {
+    it('falls back to the default editor when an unknown value is passed', () => {
         expect(resolveEditorOption('unknown-editor').id).toBe(DEFAULT_EDITOR_ID);
     });
+    it('keeps the "none" option with empty command/args so the UI can hide inputs', () => {
+        const none = EDITOR_OPTIONS.find((option) => option.id === NONE_EDITOR_ID);
+        expect(none).toBeDefined();
+        expect(none?.command).toBe('');
+        expect(none?.argsTemplate).toBe('');
+    });
+    it('exposes a "custom" placeholder entry with empty command/args', () => {
+        const custom = EDITOR_OPTIONS.find((option) => option.id === CUSTOM_EDITOR_ID);
+        expect(custom).toBeDefined();
+        expect(custom?.label).toBe('Custom…');
+        expect(custom?.command).toBe('');
+        expect(custom?.argsTemplate).toBe('');
+    });
+    it('excludes editors that are no longer widely used for code review', () => {
+        const ids = EDITOR_OPTIONS.map((option) => option.id);
+        for (const deprecated of ['textwrangler', 'lyx', 'texmaker', 'alpha', 'atom', 'textadept']) {
+            expect(ids, `${deprecated} should not be registered`).not.toContain(deprecated);
+        }
+    });
+    describe('preset editor templates', () => {
+        const cases = [
+            {
+                id: 'vscode',
+                command: 'code',
+                argsTemplate: '-g %file:%line',
+                expectedArgs: ['-g', '/tmp/file.ts:42'],
+            },
+            {
+                id: 'cursor',
+                command: 'cursor',
+                argsTemplate: '-g %file:%line',
+                expectedArgs: ['-g', '/tmp/file.ts:42'],
+            },
+            {
+                id: 'zed',
+                command: 'zed',
+                argsTemplate: '%file:%line',
+                expectedArgs: ['/tmp/file.ts:42'],
+            },
+            {
+                id: 'textmate',
+                command: 'mate',
+                argsTemplate: '-l %line %file',
+                expectedArgs: ['-l', '42', '/tmp/file.ts'],
+            },
+            {
+                id: 'bbedit',
+                command: 'bbedit',
+                argsTemplate: '+%line %file',
+                expectedArgs: ['+42', '/tmp/file.ts'],
+            },
+            {
+                id: 'emacs',
+                command: 'emacsclient',
+                argsTemplate: '--no-wait +%line %file',
+                expectedArgs: ['--no-wait', '+42', '/tmp/file.ts'],
+            },
+            {
+                id: 'macvim',
+                command: 'mvim',
+                argsTemplate: '--remote-silent +%line %file',
+                expectedArgs: ['--remote-silent', '+42', '/tmp/file.ts'],
+            },
+            {
+                id: 'sublime',
+                command: 'subl',
+                argsTemplate: '%file:%line',
+                expectedArgs: ['/tmp/file.ts:42'],
+            },
+            {
+                id: 'nova',
+                command: 'nova',
+                argsTemplate: 'open %file -l %line',
+                expectedArgs: ['open', '/tmp/file.ts', '-l', '42'],
+            },
+        ];
+        for (const testCase of cases) {
+            it(`registers ${testCase.id} with the expected command and template`, () => {
+                const option = EDITOR_OPTIONS.find((entry) => entry.id === testCase.id);
+                expect(option, `${testCase.id} should be registered`).toBeDefined();
+                expect(option?.command).toBe(testCase.command);
+                expect(option?.argsTemplate).toBe(testCase.argsTemplate);
+            });
+            it(`builds a spawn spec for ${testCase.id} with %file/%line substituted`, () => {
+                const option = resolveEditorOption(testCase.id);
+                const spec = buildEditorSpawnSpec({
+                    command: option.command,
+                    argsTemplate: option.argsTemplate,
+                    filePath: '/tmp/file.ts',
+                    lineNumber: 42,
+                });
+                expect(spec).not.toBeNull();
+                expect(spec?.command).toBe(testCase.command);
+                expect(spec?.args).toEqual(testCase.expectedArgs);
+            });
+        }
+    });
+    describe('parseEditorArgsTemplate', () => {
+        it('splits whitespace-separated tokens', () => {
+            expect(parseEditorArgsTemplate('-l %line %file')).toEqual(['-l', '%line', '%file']);
+        });
+        it('collapses runs of whitespace', () => {
+            expect(parseEditorArgsTemplate('  -l   %line\t%file  ')).toEqual(['-l', '%line', '%file']);
+        });
+        it('preserves double-quoted segments', () => {
+            expect(parseEditorArgsTemplate('+%line "%file"')).toEqual(['+%line', '%file']);
+        });
+        it('preserves single-quoted segments', () => {
+            expect(parseEditorArgsTemplate("'%file' -line %line")).toEqual(['%file', '-line', '%line']);
+        });
+        it('keeps adjacent quoted and unquoted fragments in a single token', () => {
+            expect(parseEditorArgsTemplate('"%file":%line')).toEqual(['%file:%line']);
+        });
+        it('returns an empty array for empty or whitespace-only input', () => {
+            expect(parseEditorArgsTemplate('')).toEqual([]);
+            expect(parseEditorArgsTemplate('   \t  ')).toEqual([]);
+            expect(parseEditorArgsTemplate(undefined)).toEqual([]);
+            expect(parseEditorArgsTemplate(null)).toEqual([]);
+        });
+        it('decodes \\" and \\\\ inside double-quoted segments', () => {
+            expect(parseEditorArgsTemplate('--msg "say \\"hi\\""')).toEqual(['--msg', 'say "hi"']);
+            expect(parseEditorArgsTemplate('"a\\\\b"')).toEqual(['a\\b']);
+        });
+        it('leaves other backslash sequences inside double quotes untouched', () => {
+            expect(parseEditorArgsTemplate('"\\s+ \\$PATH"')).toEqual(['\\s+ \\$PATH']);
+        });
+        it('treats single-quoted segments as fully literal', () => {
+            expect(parseEditorArgsTemplate('\'say \\"hi\\"\'')).toEqual(['say \\"hi\\"']);
+        });
+        it('supports an emacsclient --eval template with escaped double quotes', () => {
+            const template = '--eval "(tctony/persp-view-file-line-external \\"%file\\" %line)"';
+            expect(parseEditorArgsTemplate(template)).toEqual([
+                '--eval',
+                '(tctony/persp-view-file-line-external "%file" %line)',
+            ]);
+        });
+    });
+    describe('buildEditorSpawnSpec', () => {
+        it('returns null when the command is blank', () => {
+            expect(buildEditorSpawnSpec({
+                command: '',
+                argsTemplate: '-l %line %file',
+                filePath: '/tmp/file.ts',
+                lineNumber: 1,
+            })).toBeNull();
+            expect(buildEditorSpawnSpec({
+                command: '   ',
+                argsTemplate: '%file',
+                filePath: '/tmp/file.ts',
+                lineNumber: 1,
+            })).toBeNull();
+        });
+        it('trims the command and substitutes %file and %line', () => {
+            const spec = buildEditorSpawnSpec({
+                command: '  mate  ',
+                argsTemplate: '-l %line "%file"',
+                filePath: '/tmp/file.ts',
+                lineNumber: 12,
+            });
+            expect(spec).toEqual({
+                command: 'mate',
+                args: ['-l', '12', '/tmp/file.ts'],
+            });
+        });
+        it('substitutes line 1 when no line number is provided', () => {
+            const spec = buildEditorSpawnSpec({
+                command: 'mate',
+                argsTemplate: '-l %line %file',
+                filePath: '/tmp/file.ts',
+                lineNumber: null,
+            });
+            expect(spec?.args).toEqual(['-l', '1', '/tmp/file.ts']);
+        });
+        it('returns an empty args array when the template is empty', () => {
+            const spec = buildEditorSpawnSpec({
+                command: 'my-editor',
+                argsTemplate: '',
+                filePath: '/tmp/file.ts',
+                lineNumber: 3,
+            });
+            expect(spec).toEqual({ command: 'my-editor', args: [] });
+        });
+        it('builds a spawn spec for an emacsclient --eval elisp invocation', () => {
+            const spec = buildEditorSpawnSpec({
+                command: 'emacsclient',
+                argsTemplate: '--eval "(tctony/persp-view-file-line-external \\"%file\\" %line)"',
+                filePath: '/tmp/foo.ts',
+                lineNumber: 42,
+            });
+            expect(spec).toEqual({
+                command: 'emacsclient',
+                args: ['--eval', '(tctony/persp-view-file-line-external "/tmp/foo.ts" 42)'],
+            });
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "difit",
-  "version": "4.0.5",
+  "version": "4.0.7",
   "description": "A lightweight command-line tool that spins up a local web server to display Git commit diffs in a GitHub-like Files changed view",
   "keywords": [
     "cli",
@@ -37,9 +37,12 @@
   },
   "scripts": {
     "dev": "node scripts/dev.js",
+    "dev:site": "pnpm run build:cli && node scripts/export-site-data.js && vite --config vite.config.site.ts --open /",
     "dev:cli": "tsc --project tsconfig.cli.json && NODE_ENV=development node dist/cli/index.js",
-    "build": "tsc -b && vite build",
+    "build": "pnpm run build:cli && vite build",
+    "build:site": "pnpm run build:cli && GITHUB_PAGES=true vite build --config vite.config.site.ts",
     "build:cli": "tsc --project tsconfig.cli.json",
+    "export:site-data": "node scripts/export-site-data.js",
     "package:vscode": "pnpm -C packages/vscode run package",
     "start": "pnpm run build && node dist/cli/index.js",
     "check": "oxlint . --type-aware --type-check --deny-warnings --report-unused-disable-directives",
@@ -93,7 +96,7 @@
     "happy-dom": "^20.0.0",
     "knip": "^6.0.0",
     "lefthook": "^2.0.0",
-    "oxfmt": "^0.45.0",
+    "oxfmt": "^0.46.0",
     "oxlint": "^1.49.0",
     "oxlint-tsgolint": "^0.21.0",
     "playwright": "^1.54.1",
@@ -107,5 +110,5 @@
   "engines": {
     "node": ">=21.0.0"
   },
-  "packageManager": "pnpm@10.33.0"
+  "packageManager": "pnpm@10.33.2"
 }

package/dist/client/assets/architecture-YZFGNWBL-Cs2Q6RQP.js

@@ -1 +0,0 @@
-import"./chunk-K5T4RW27-DmamW1Ds.js";import{n as e}from"./chunk-7N4EOEYR-DPgxysWq.js";export{e as createArchitectureServices};