paneful 0.9.16 → 0.9.18

package/README.md

@@ -67,6 +67,19 @@ Press `Cmd+P` to open the command palette. Quickly switch projects, launch favou
 
 The sidebar shows the current Git branch next to each project's working directory as a small pill badge. Updates automatically every 10 seconds. Non-git directories show no badge.
 
+### Source Control
+
+Press `Cmd+Shift+G` (or click the branch icon in the toolbar) to open the source control panel — a resizable right-side panel that shows the active project's working changes. Powered by `git status` + `fs.watch`, so updates are instant. Includes:
+
+- **Branch bar** with current branch, ahead/behind counts, and one-click pull (`--ff-only`) and push.
+- **File list** grouped by Staged Changes, Changes, Untracked, and Conflicted. Each row has hover actions for stage, unstage, discard, and "Open in editor" (uses your system's default app association).
+- **Multi-select** with Cmd-click (toggle) and Shift-click (range) for bulk stage/unstage/discard within a group.
+- **Diff view** — click any file to see the full file with line numbers, red/green backgrounds for added/removed lines, and syntax highlighting for ~25 languages (TypeScript, Python, Go, Rust, Swift, Java, C/C++, and more).
+- **Inline commit** message + button; auto-clears on success.
+- **Stash** — create (with optional message, includes untracked), apply, pop, or drop directly from the panel.
+
+The panel only polls its data when open, and the file watcher only runs while focused on the active project — zero overhead when collapsed.
+
 ### AI Agent Detection
 
 Automatically detects when Claude Code or Codex CLI is running in a Paneful terminal. A purple **AI** badge appears next to the project name in the sidebar — pulsing when the agent is actively working, dimmed when idle. Disappears instantly when the agent exits. Uses zero filesystem access; detection is purely in-memory via the PTY process name and terminal output timestamps.
@@ -131,6 +144,7 @@ Paneful checks for newer versions on npm and shows a notification in the sidebar
 | `Ctrl+Shift+Arrow` | Move focus to adjacent pane     |
 | `Shift+Arrow`      | Swap focused pane with adjacent |
 | `Cmd+D`            | Toggle sidebar                  |
+| `Cmd+Shift+G`      | Toggle source control panel     |
 | `Cmd+T`            | Cycle through layout presets    |
 | `Cmd+R`            | Auto reorganize panes           |
 
@@ -155,6 +169,9 @@ npm run build
 
 # Run locally
 npm start
+
+# Install the local build globally (replaces any npm-published version)
+npm -g uninstall paneful; npm run build; npm install -g .; paneful --install-app
 ```
 
 Vite dev server proxies `/ws` and `/api` to `localhost:3000`. Open `http://localhost:5173` or use Chrome in app mode for full keyboard shortcut support:

package/dist/server/git-source-control.js

@@ -0,0 +1,398 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { watch } from 'node:fs';
+const execFileP = promisify(execFile);
+const SAFETY_POLL_MS = 15_000;
+const WATCH_DEBOUNCE_MS = 300;
+// Headroom for whole-file diffs (git -U99999). Most source files fit comfortably.
+const DIFF_MAX_BYTES = 5_000_000;
+const DIFF_TIMEOUT_MS = 5_000;
+const ACTION_TIMEOUT_MS = 10_000;
+const NETWORK_TIMEOUT_MS = 120_000;
+// Force enough unified-diff context to cover any reasonable file
+const FULL_CONTEXT_FLAG = '-U99999';
+// Filenames/dirs in change events to ignore (lots of churn, no user-visible status impact)
+const IGNORE_PATHS = ['.git/objects', '.git/lfs', '.git/logs', 'node_modules', '.next/cache'];
+export class GitSourceControl {
+    projectStore;
+    onStatus;
+    activeProjectId = null;
+    lastStatus = null;
+    safetyTimer = null;
+    debounceTimer = null;
+    watcher = null;
+    polling = false;
+    destroyed = false;
+    paused = true;
+    constructor(projectStore, onStatus) {
+        this.projectStore = projectStore;
+        this.onStatus = onStatus;
+    }
+    setActive(projectId) {
+        if (projectId === this.activeProjectId)
+            return;
+        this.stopWatcher();
+        this.activeProjectId = projectId;
+        this.lastStatus = null;
+        if (projectId && !this.paused) {
+            this.startWatcher(projectId);
+            this.poll();
+        }
+    }
+    resume() {
+        if (this.destroyed || !this.paused)
+            return;
+        this.paused = false;
+        if (this.activeProjectId) {
+            this.startWatcher(this.activeProjectId);
+            this.poll();
+            this.safetyTimer = setInterval(() => this.poll(), SAFETY_POLL_MS);
+        }
+    }
+    pause() {
+        this.paused = true;
+        this.stopWatcher();
+        if (this.safetyTimer) {
+            clearInterval(this.safetyTimer);
+            this.safetyTimer = null;
+        }
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+    }
+    destroy() {
+        this.destroyed = true;
+        this.pause();
+        this.lastStatus = null;
+        this.activeProjectId = null;
+    }
+    startWatcher(projectId) {
+        const project = this.projectStore.list().find((p) => p.id === projectId);
+        if (!project)
+            return;
+        try {
+            this.watcher = watch(project.cwd, { recursive: true }, (_event, filename) => {
+                if (!filename)
+                    return;
+                // Skip noisy paths (e.g., git objects, node_modules build chatter)
+                for (const ignore of IGNORE_PATHS) {
+                    if (filename.includes(ignore))
+                        return;
+                }
+                this.scheduleRePoll();
+            });
+            this.watcher.on('error', () => {
+                // Watcher failed (path missing, permission denied, etc.) — safety poll still runs
+                this.stopWatcher();
+            });
+        }
+        catch {
+            // fs.watch unavailable or path bad — silently rely on safety poll
+        }
+    }
+    stopWatcher() {
+        if (this.watcher) {
+            try {
+                this.watcher.close();
+            }
+            catch { }
+            this.watcher = null;
+        }
+    }
+    scheduleRePoll() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            this.poll();
+        }, WATCH_DEBOUNCE_MS);
+    }
+    async requestDiff(projectId, file, kind) {
+        const project = this.projectStore.list().find((p) => p.id === projectId);
+        if (!project)
+            return null;
+        return this.getDiff(project.cwd, file, kind);
+    }
+    async stage(projectId, files) {
+        return this.runAction(projectId, ['add', '--', ...files]);
+    }
+    async unstage(projectId, files) {
+        return this.runAction(projectId, ['restore', '--staged', '--', ...files]);
+    }
+    async discard(projectId, trackedFiles, untrackedFiles) {
+        const project = this.projectStore.list().find((p) => p.id === projectId);
+        if (!project)
+            return { ok: false, error: 'project not found' };
+        try {
+            if (trackedFiles.length > 0) {
+                await execFileP('git', ['restore', '--staged', '--worktree', '--', ...trackedFiles], {
+                    cwd: project.cwd,
+                    timeout: ACTION_TIMEOUT_MS,
+                });
+            }
+            if (untrackedFiles.length > 0) {
+                await execFileP('git', ['clean', '-f', '--', ...untrackedFiles], {
+                    cwd: project.cwd,
+                    timeout: ACTION_TIMEOUT_MS,
+                });
+            }
+            this.poll();
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    }
+    async commit(projectId, message) {
+        if (!message.trim())
+            return { ok: false, error: 'commit message is empty' };
+        return this.runAction(projectId, ['commit', '-m', message]);
+    }
+    async push(projectId) {
+        return this.runNetworkAction(projectId, ['push']);
+    }
+    async pull(projectId) {
+        return this.runNetworkAction(projectId, ['pull', '--ff-only']);
+    }
+    async stashCreate(projectId, message) {
+        const args = message.trim() ? ['stash', 'push', '-u', '-m', message] : ['stash', 'push', '-u'];
+        return this.runAction(projectId, args);
+    }
+    async stashPop(projectId, index) {
+        return this.runAction(projectId, ['stash', 'pop', `stash@{${index}}`]);
+    }
+    async stashApply(projectId, index) {
+        return this.runAction(projectId, ['stash', 'apply', `stash@{${index}}`]);
+    }
+    async stashDrop(projectId, index) {
+        return this.runAction(projectId, ['stash', 'drop', `stash@{${index}}`]);
+    }
+    async runNetworkAction(projectId, args) {
+        const project = this.projectStore.list().find((p) => p.id === projectId);
+        if (!project)
+            return { ok: false, error: 'project not found' };
+        try {
+            await execFileP('git', args, {
+                cwd: project.cwd,
+                timeout: NETWORK_TIMEOUT_MS,
+                env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            });
+            this.poll();
+            return { ok: true };
+        }
+        catch (e) {
+            const err = e;
+            const msg = (err.stderr || err.message || 'unknown error').trim();
+            return { ok: false, error: msg };
+        }
+    }
+    async runAction(projectId, args) {
+        const project = this.projectStore.list().find((p) => p.id === projectId);
+        if (!project)
+            return { ok: false, error: 'project not found' };
+        try {
+            await execFileP('git', args, { cwd: project.cwd, timeout: ACTION_TIMEOUT_MS });
+            this.poll();
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    }
+    async poll() {
+        if (this.destroyed || this.polling)
+            return;
+        const projectId = this.activeProjectId;
+        if (!projectId)
+            return;
+        this.polling = true;
+        try {
+            const project = this.projectStore.list().find((p) => p.id === projectId);
+            if (!project) {
+                if (this.lastStatus !== null) {
+                    this.lastStatus = null;
+                    this.onStatus(projectId, null);
+                }
+                return;
+            }
+            const status = await this.getStatus(project.cwd);
+            if (this.destroyed || this.activeProjectId !== projectId)
+                return;
+            if (this.statusEqual(status, this.lastStatus))
+                return;
+            this.lastStatus = status;
+            this.onStatus(projectId, status);
+        }
+        catch {
+            // Swallow — leave previous state in place
+        }
+        finally {
+            this.polling = false;
+        }
+    }
+    async getStatus(cwd) {
+        try {
+            const [statusRes, stashRes] = await Promise.all([
+                execFileP('git', ['status', '--porcelain=v2', '--untracked-files=all'], {
+                    cwd,
+                    timeout: 3000,
+                    maxBuffer: 4 * 1024 * 1024,
+                }),
+                execFileP('git', ['stash', 'list'], { cwd, timeout: 2000, maxBuffer: 256 * 1024 }).catch(() => ({ stdout: '' })),
+            ]);
+            const status = this.parseStatus(statusRes.stdout);
+            status.stashes = this.parseStashes(stashRes.stdout);
+            return status;
+        }
+        catch {
+            return null;
+        }
+    }
+    parseStashes(stdout) {
+        const out = [];
+        for (const line of stdout.split('\n')) {
+            if (!line)
+                continue;
+            // "stash@{0}: WIP on master: abc1234 commit subject" OR "stash@{0}: On master: my message"
+            const m = line.match(/^stash@\{(\d+)\}: (?:WIP )?[oO]n (\S+?): (?:[0-9a-f]+ )?(.+)$/);
+            if (!m)
+                continue;
+            out.push({ index: parseInt(m[1], 10), branch: m[2], message: m[3] });
+        }
+        return out;
+    }
+    parseStatus(stdout) {
+        const staged = [];
+        const changes = [];
+        const untracked = [];
+        const conflicted = [];
+        for (const line of stdout.split('\n')) {
+            if (line.length === 0)
+                continue;
+            if (line.startsWith('# '))
+                continue;
+            if (line.startsWith('? ')) {
+                untracked.push({ path: line.slice(2), status: '?' });
+                continue;
+            }
+            if (line.startsWith('! '))
+                continue;
+            if (line.startsWith('1 ')) {
+                // 1 XY sub mH mI mW hH hI <path>
+                const m = line.match(/^1 (\S\S) \S+ \S+ \S+ \S+ \S+ \S+ (.+)$/);
+                if (!m)
+                    continue;
+                const xy = m[1];
+                const path = m[2];
+                const x = xy[0];
+                const y = xy[1];
+                if (x !== '.' && x !== ' ') {
+                    staged.push({ path, status: x });
+                }
+                if (y !== '.' && y !== ' ') {
+                    changes.push({ path, status: y });
+                }
+                continue;
+            }
+            if (line.startsWith('2 ')) {
+                // 2 XY sub mH mI mW hH hI Xscore <path>\t<origPath>
+                const m = line.match(/^2 (\S\S) \S+ \S+ \S+ \S+ \S+ \S+ \S+ (.+)$/);
+                if (!m)
+                    continue;
+                const xy = m[1];
+                const rest = m[2];
+                const tabIdx = rest.indexOf('\t');
+                const path = tabIdx >= 0 ? rest.slice(0, tabIdx) : rest;
+                const oldPath = tabIdx >= 0 ? rest.slice(tabIdx + 1) : undefined;
+                const x = xy[0];
+                const y = xy[1];
+                if (x !== '.' && x !== ' ') {
+                    staged.push({ path, oldPath, status: x });
+                }
+                if (y !== '.' && y !== ' ') {
+                    changes.push({ path, oldPath, status: y });
+                }
+                continue;
+            }
+            if (line.startsWith('u ')) {
+                // u XY sub m1 m2 m3 mW h1 h2 h3 <path>
+                const m = line.match(/^u \S\S \S+ \S+ \S+ \S+ \S+ \S+ \S+ \S+ (.+)$/);
+                if (!m)
+                    continue;
+                conflicted.push({ path: m[1], status: 'U' });
+                continue;
+            }
+        }
+        return { staged, changes, untracked, conflicted, stashes: [] };
+    }
+    async getDiff(cwd, file, kind) {
+        let args;
+        if (kind === 'staged') {
+            args = ['diff', FULL_CONTEXT_FLAG, '--cached', '--', file];
+        }
+        else if (kind === 'untracked') {
+            // Show the file's full contents as an all-additions diff
+            args = ['diff', FULL_CONTEXT_FLAG, '--no-index', '--', '/dev/null', file];
+        }
+        else {
+            args = ['diff', FULL_CONTEXT_FLAG, '--', file];
+        }
+        try {
+            const { stdout } = await execFileP('git', args, {
+                cwd,
+                timeout: DIFF_TIMEOUT_MS,
+                maxBuffer: DIFF_MAX_BYTES + 1024,
+            });
+            const truncated = stdout.length >= DIFF_MAX_BYTES;
+            const diff = truncated ? stdout.slice(0, DIFF_MAX_BYTES) : stdout;
+            const binary = /^Binary files .* differ$/m.test(diff);
+            return { diff, binary, truncated };
+        }
+        catch (e) {
+            // `git diff --no-index` exits 1 when files differ — still valid output
+            const err = e;
+            if (err.stdout !== undefined && (err.code === 1 || kind === 'untracked')) {
+                const truncated = err.stdout.length >= DIFF_MAX_BYTES;
+                const diff = truncated ? err.stdout.slice(0, DIFF_MAX_BYTES) : err.stdout;
+                const binary = /^Binary files .* differ$/m.test(diff);
+                return { diff, binary, truncated };
+            }
+            return { diff: '', binary: false, truncated: false };
+        }
+    }
+    statusEqual(a, b) {
+        if (a === b)
+            return true;
+        if (!a || !b)
+            return false;
+        return (this.entriesEqual(a.staged, b.staged) &&
+            this.entriesEqual(a.changes, b.changes) &&
+            this.entriesEqual(a.untracked, b.untracked) &&
+            this.entriesEqual(a.conflicted, b.conflicted) &&
+            this.stashesEqual(a.stashes, b.stashes));
+    }
+    stashesEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (a[i].index !== b[i].index || a[i].message !== b[i].message || a[i].branch !== b[i].branch) {
+                return false;
+            }
+        }
+        return true;
+    }
+    entriesEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (a[i].path !== b[i].path)
+                return false;
+            if (a[i].status !== b[i].status)
+                return false;
+            if (a[i].oldPath !== b[i].oldPath)
+                return false;
+        }
+        return true;
+    }
+}