diffstalker 0.1.7 → 0.2.0

package/dist/ipc/CommandClient.js

@@ -0,0 +1,165 @@
+/**
+ * Unix socket IPC client for controlling diffstalker remotely.
+ * Sends JSON commands and receives responses.
+ */
+import * as net from 'net';
+export class CommandClient {
+    socketPath;
+    timeout;
+    constructor(socketPath, timeout = 5000) {
+        this.socketPath = socketPath;
+        this.timeout = timeout;
+    }
+    /**
+     * Send a command and wait for response
+     */
+    async send(command) {
+        return new Promise((resolve, reject) => {
+            const socket = net.createConnection(this.socketPath);
+            let buffer = '';
+            let timeoutId;
+            const cleanup = () => {
+                clearTimeout(timeoutId);
+                socket.destroy();
+            };
+            timeoutId = setTimeout(() => {
+                cleanup();
+                reject(new Error(`Command timed out after ${this.timeout}ms`));
+            }, this.timeout);
+            socket.on('connect', () => {
+                socket.write(JSON.stringify(command) + '\n');
+            });
+            socket.on('data', (data) => {
+                buffer += data.toString();
+                const newlineIndex = buffer.indexOf('\n');
+                if (newlineIndex !== -1) {
+                    const json = buffer.substring(0, newlineIndex);
+                    cleanup();
+                    try {
+                        resolve(JSON.parse(json));
+                    }
+                    catch (err) {
+                        reject(new Error(`Invalid JSON response: ${json}`));
+                    }
+                }
+            });
+            socket.on('error', (err) => {
+                cleanup();
+                reject(err);
+            });
+        });
+    }
+    // Convenience methods for common operations
+    async navigateUp() {
+        return this.send({ action: 'navigateUp' });
+    }
+    async navigateDown() {
+        return this.send({ action: 'navigateDown' });
+    }
+    async switchTab(tab) {
+        return this.send({ action: 'switchTab', tab });
+    }
+    async togglePane() {
+        return this.send({ action: 'togglePane' });
+    }
+    async stage() {
+        return this.send({ action: 'stage' });
+    }
+    async unstage() {
+        return this.send({ action: 'unstage' });
+    }
+    async stageAll() {
+        return this.send({ action: 'stageAll' });
+    }
+    async unstageAll() {
+        return this.send({ action: 'unstageAll' });
+    }
+    async commit(message) {
+        return this.send({ action: 'commit', message });
+    }
+    async refresh() {
+        return this.send({ action: 'refresh' });
+    }
+    async getState() {
+        const result = await this.send({ action: 'getState' });
+        if (!result.success) {
+            throw new Error(result.error || 'Failed to get state');
+        }
+        if (!result.state) {
+            throw new Error('No state returned');
+        }
+        return result.state;
+    }
+    async quit() {
+        return this.send({ action: 'quit' });
+    }
+    /**
+     * Ping the server to check if it's ready
+     * Returns { success: true, ready: boolean }
+     */
+    async ping() {
+        return this.send({ action: 'ping' });
+    }
+    /**
+     * Wait for the server socket file to exist
+     */
+    async waitForSocketFile(maxWait = 10000, pollInterval = 100) {
+        const fs = await import('fs');
+        const startTime = Date.now();
+        while (Date.now() - startTime < maxWait) {
+            if (fs.existsSync(this.socketPath)) {
+                return; // Socket file exists
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        }
+        throw new Error(`Socket file not found after ${maxWait}ms: ${this.socketPath}`);
+    }
+    /**
+     * Wait for the server socket to be available and accepting connections
+     */
+    async waitForSocket(maxWait = 10000, pollInterval = 100) {
+        const startTime = Date.now();
+        let lastError = null;
+        let attempts = 0;
+        // First wait for the socket file to exist
+        await this.waitForSocketFile(maxWait, pollInterval);
+        // Then wait for it to accept connections
+        while (Date.now() - startTime < maxWait) {
+            attempts++;
+            try {
+                await this.ping();
+                return; // Socket is available
+            }
+            catch (err) {
+                // Socket not available yet, wait and retry
+                lastError = err;
+                await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            }
+        }
+        throw new Error(`Socket not accepting connections after ${maxWait}ms (${attempts} attempts). Last error: ${lastError?.message}`);
+    }
+    /**
+     * Wait for the server to be fully ready (socket + handler registered)
+     */
+    async waitForServer(maxWait = 10000, pollInterval = 100) {
+        const startTime = Date.now();
+        // First wait for socket to be available
+        await this.waitForSocket(maxWait, pollInterval);
+        // Then wait for the app to be ready (handler registered)
+        while (Date.now() - startTime < maxWait) {
+            try {
+                const result = await this.ping();
+                if (result.success && result.ready) {
+                    return; // App is ready
+                }
+                // Socket available but handler not ready yet
+                await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            }
+            catch {
+                // Connection failed, wait and retry
+                await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            }
+        }
+        throw new Error(`Server not ready after ${maxWait}ms`);
+    }
+}

package/dist/ipc/CommandServer.js

@@ -0,0 +1,152 @@
+/**
+ * Unix socket IPC server for remote control of diffstalker.
+ * Receives JSON commands and dispatches them to the app.
+ */
+import * as net from 'net';
+import * as fs from 'fs';
+import { EventEmitter } from 'events';
+export class CommandServer extends EventEmitter {
+    server = null;
+    socketPath;
+    handler = null;
+    ready = false;
+    constructor(socketPath) {
+        super();
+        this.socketPath = socketPath;
+    }
+    /**
+     * Set the command handler (called by App after initialization)
+     */
+    setHandler(handler) {
+        this.handler = handler;
+    }
+    /**
+     * Mark the app as ready (called after handler is set and app is initialized)
+     */
+    notifyReady() {
+        this.ready = true;
+        this.emit('ready');
+    }
+    /**
+     * Check if the app is ready
+     */
+    isReady() {
+        return this.ready && this.handler !== null;
+    }
+    /**
+     * Start listening for connections
+     */
+    async start() {
+        // Remove existing socket file if it exists
+        if (fs.existsSync(this.socketPath)) {
+            fs.unlinkSync(this.socketPath);
+        }
+        return new Promise((resolve, reject) => {
+            this.server = net.createServer((socket) => {
+                this.handleConnection(socket);
+            });
+            this.server.on('error', (err) => {
+                reject(err);
+            });
+            this.server.listen(this.socketPath, () => {
+                // Set socket permissions to user-only
+                fs.chmodSync(this.socketPath, 0o600);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the server and clean up
+     */
+    stop() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+        // Clean up socket file
+        if (fs.existsSync(this.socketPath)) {
+            fs.unlinkSync(this.socketPath);
+        }
+    }
+    /**
+     * Handle an incoming connection
+     */
+    handleConnection(socket) {
+        let buffer = '';
+        socket.on('data', async (data) => {
+            buffer += data.toString();
+            // Process complete JSON messages (newline-delimited)
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || ''; // Keep incomplete line in buffer
+            for (const line of lines) {
+                if (line.trim()) {
+                    const result = await this.processCommand(line);
+                    socket.write(JSON.stringify(result) + '\n');
+                }
+            }
+        });
+        socket.on('error', (err) => {
+            this.emit('error', err);
+        });
+    }
+    /**
+     * Process a single command
+     */
+    async processCommand(json) {
+        try {
+            const command = JSON.parse(json);
+            // ping can be handled without a handler - used to check readiness
+            if (command.action === 'ping') {
+                return { success: true, ready: this.isReady() };
+            }
+            if (!this.handler) {
+                return { success: false, error: 'No handler registered' };
+            }
+            switch (command.action) {
+                case 'navigateUp':
+                    this.handler.navigateUp();
+                    return { success: true };
+                case 'navigateDown':
+                    this.handler.navigateDown();
+                    return { success: true };
+                case 'switchTab':
+                    this.handler.switchTab(command.tab);
+                    return { success: true };
+                case 'togglePane':
+                    this.handler.togglePane();
+                    return { success: true };
+                case 'stage':
+                    await this.handler.stage();
+                    return { success: true };
+                case 'unstage':
+                    await this.handler.unstage();
+                    return { success: true };
+                case 'stageAll':
+                    await this.handler.stageAll();
+                    return { success: true };
+                case 'unstageAll':
+                    await this.handler.unstageAll();
+                    return { success: true };
+                case 'commit':
+                    await this.handler.commit(command.message);
+                    return { success: true };
+                case 'refresh':
+                    await this.handler.refresh();
+                    return { success: true };
+                case 'getState':
+                    return { success: true, state: this.handler.getState() };
+                case 'quit':
+                    this.handler.quit();
+                    return { success: true };
+                default:
+                    return {
+                        success: false,
+                        error: `Unknown action: ${command.action}`,
+                    };
+            }
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+}

package/dist/state/CommitFlowState.js

@@ -0,0 +1,86 @@
+import { EventEmitter } from 'node:events';
+import { validateCommit, formatCommitMessage } from '../services/commitService.js';
+const DEFAULT_STATE = {
+    message: '',
+    amend: false,
+    isCommitting: false,
+    error: null,
+    inputFocused: false,
+};
+/**
+ * CommitFlowState manages commit panel state independently of React.
+ */
+export class CommitFlowState extends EventEmitter {
+    _state = { ...DEFAULT_STATE };
+    getHeadMessage;
+    onCommit;
+    onSuccess;
+    stagedCount = 0;
+    constructor(options) {
+        super();
+        this.getHeadMessage = options.getHeadMessage;
+        this.onCommit = options.onCommit;
+        this.onSuccess = options.onSuccess;
+    }
+    get state() {
+        return this._state;
+    }
+    update(partial) {
+        this._state = { ...this._state, ...partial };
+        this.emit('change', this._state);
+    }
+    setStagedCount(count) {
+        this.stagedCount = count;
+    }
+    setMessage(message) {
+        this.update({ message, error: null });
+    }
+    setInputFocused(focused) {
+        this.update({ inputFocused: focused });
+        this.emit('focus-change', focused);
+    }
+    async toggleAmend() {
+        const newAmend = !this._state.amend;
+        this.update({ amend: newAmend });
+        // Load HEAD message when amend is enabled
+        if (newAmend && !this._state.message) {
+            try {
+                const msg = await this.getHeadMessage();
+                if (msg) {
+                    this.update({ message: msg });
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+    }
+    async submit() {
+        const validation = validateCommit(this._state.message, this.stagedCount, this._state.amend);
+        if (!validation.valid) {
+            this.update({ error: validation.error });
+            return;
+        }
+        this.update({ isCommitting: true, error: null });
+        try {
+            await this.onCommit(formatCommitMessage(this._state.message), this._state.amend);
+            this.update({
+                message: '',
+                amend: false,
+                isCommitting: false,
+                inputFocused: false,
+            });
+            this.onSuccess();
+        }
+        catch (err) {
+            this.update({
+                isCommitting: false,
+                error: err instanceof Error ? err.message : 'Commit failed',
+            });
+        }
+    }
+    reset() {
+        this._state = { ...DEFAULT_STATE };
+        this.emit('change', this._state);
+    }
+}

package/dist/state/UIState.js

@@ -0,0 +1,182 @@
+import { EventEmitter } from 'node:events';
+const DEFAULT_STATE = {
+    currentPane: 'files',
+    bottomTab: 'diff',
+    selectedIndex: 0,
+    fileListScrollOffset: 0,
+    diffScrollOffset: 0,
+    historyScrollOffset: 0,
+    compareScrollOffset: 0,
+    explorerScrollOffset: 0,
+    explorerFileScrollOffset: 0,
+    historySelectedIndex: 0,
+    compareSelectedIndex: 0,
+    includeUncommitted: false,
+    explorerSelectedIndex: 0,
+    wrapMode: false,
+    autoTabEnabled: false,
+    mouseEnabled: true,
+    showMiddleDots: false,
+    hideHiddenFiles: true,
+    hideGitignored: true,
+    splitRatio: 0.4,
+    activeModal: null,
+    pendingDiscard: null,
+    commitInputFocused: false,
+};
+/**
+ * UIState manages all UI-related state independently of React.
+ * It emits events when state changes so widgets can update.
+ */
+export class UIState extends EventEmitter {
+    _state;
+    constructor(initialState = {}) {
+        super();
+        this._state = { ...DEFAULT_STATE, ...initialState };
+    }
+    get state() {
+        return this._state;
+    }
+    update(partial) {
+        this._state = { ...this._state, ...partial };
+        this.emit('change', this._state);
+    }
+    // Navigation
+    setPane(pane) {
+        if (this._state.currentPane !== pane) {
+            this.update({ currentPane: pane });
+            this.emit('pane-change', pane);
+        }
+    }
+    setTab(tab) {
+        if (this._state.bottomTab !== tab) {
+            // Map tab to appropriate pane
+            const paneMap = {
+                diff: 'files',
+                commit: 'commit',
+                history: 'history',
+                compare: 'compare',
+                explorer: 'explorer',
+            };
+            this.update({
+                bottomTab: tab,
+                currentPane: paneMap[tab],
+            });
+            this.emit('tab-change', tab);
+        }
+    }
+    setSelectedIndex(index) {
+        if (this._state.selectedIndex !== index) {
+            this.update({ selectedIndex: index });
+            this.emit('selection-change', index);
+        }
+    }
+    // Scroll operations
+    setFileListScrollOffset(offset) {
+        this.update({ fileListScrollOffset: Math.max(0, offset) });
+        this.emit('scroll-change', { type: 'fileList', offset });
+    }
+    setDiffScrollOffset(offset) {
+        this.update({ diffScrollOffset: Math.max(0, offset) });
+        this.emit('scroll-change', { type: 'diff', offset });
+    }
+    setHistoryScrollOffset(offset) {
+        this.update({ historyScrollOffset: Math.max(0, offset) });
+        this.emit('scroll-change', { type: 'history', offset });
+    }
+    setCompareScrollOffset(offset) {
+        this.update({ compareScrollOffset: Math.max(0, offset) });
+        this.emit('scroll-change', { type: 'compare', offset });
+    }
+    setExplorerScrollOffset(offset) {
+        this.update({ explorerScrollOffset: Math.max(0, offset) });
+        this.emit('scroll-change', { type: 'explorer', offset });
+    }
+    setExplorerFileScrollOffset(offset) {
+        this.update({ explorerFileScrollOffset: Math.max(0, offset) });
+        this.emit('scroll-change', { type: 'explorerFile', offset });
+    }
+    // History navigation
+    setHistorySelectedIndex(index) {
+        this.update({ historySelectedIndex: Math.max(0, index) });
+    }
+    // Compare navigation
+    setCompareSelectedIndex(index) {
+        this.update({ compareSelectedIndex: Math.max(0, index) });
+    }
+    toggleIncludeUncommitted() {
+        this.update({ includeUncommitted: !this._state.includeUncommitted });
+    }
+    // Explorer navigation
+    setExplorerSelectedIndex(index) {
+        this.update({ explorerSelectedIndex: Math.max(0, index) });
+    }
+    // Display toggles
+    toggleWrapMode() {
+        this.update({ wrapMode: !this._state.wrapMode, diffScrollOffset: 0 });
+    }
+    toggleAutoTab() {
+        this.update({ autoTabEnabled: !this._state.autoTabEnabled });
+    }
+    toggleMouse() {
+        this.update({ mouseEnabled: !this._state.mouseEnabled });
+    }
+    toggleMiddleDots() {
+        this.update({ showMiddleDots: !this._state.showMiddleDots });
+    }
+    toggleHideHiddenFiles() {
+        this.update({ hideHiddenFiles: !this._state.hideHiddenFiles });
+    }
+    toggleHideGitignored() {
+        this.update({ hideGitignored: !this._state.hideGitignored });
+    }
+    // Split ratio
+    adjustSplitRatio(delta) {
+        const newRatio = Math.min(0.85, Math.max(0.15, this._state.splitRatio + delta));
+        this.update({ splitRatio: newRatio });
+    }
+    setSplitRatio(ratio) {
+        this.update({ splitRatio: Math.min(0.85, Math.max(0.15, ratio)) });
+    }
+    // Modals
+    openModal(modal) {
+        this.update({ activeModal: modal });
+        this.emit('modal-change', modal);
+    }
+    closeModal() {
+        this.update({ activeModal: null });
+        this.emit('modal-change', null);
+    }
+    toggleModal(modal) {
+        if (this._state.activeModal === modal) {
+            this.closeModal();
+        }
+        else {
+            this.openModal(modal);
+        }
+    }
+    // Discard confirmation
+    setPendingDiscard(file) {
+        this.update({ pendingDiscard: file });
+    }
+    // Commit input focus
+    setCommitInputFocused(focused) {
+        this.update({ commitInputFocused: focused });
+    }
+    // Helper for toggling between panes
+    togglePane() {
+        const { bottomTab, currentPane } = this._state;
+        if (bottomTab === 'diff' || bottomTab === 'commit') {
+            this.setPane(currentPane === 'files' ? 'diff' : 'files');
+        }
+        else if (bottomTab === 'history') {
+            this.setPane(currentPane === 'history' ? 'diff' : 'history');
+        }
+        else if (bottomTab === 'compare') {
+            this.setPane(currentPane === 'compare' ? 'diff' : 'compare');
+        }
+        else if (bottomTab === 'explorer') {
+            this.setPane(currentPane === 'explorer' ? 'diff' : 'explorer');
+        }
+    }
+}

package/dist/types/tabs.js

@@ -0,0 +1,4 @@
+/**
+ * Shared type definitions for tabs and panes.
+ */
+export {};