tmux-ide 2.1.4 → 2.6.0

package/packages/daemon/dist/widgets/lib/config-model.js

@@ -0,0 +1,99 @@
+import { IdeConfigSchema } from "../../schemas/ide-config.js";
+function flattenValue(obj, path, depth, nodes) {
+    if (Array.isArray(obj)) {
+        const label = path[path.length - 1] ?? "";
+        nodes.push({ path: [...path], label, value: null, depth, expandable: true });
+        for (let i = 0; i < obj.length; i++) {
+            flattenValue(obj[i], [...path, String(i)], depth + 1, nodes);
+        }
+    }
+    else if (obj !== null && typeof obj === "object") {
+        const label = path[path.length - 1] ?? "";
+        nodes.push({ path: [...path], label, value: null, depth, expandable: true });
+        for (const [key, val] of Object.entries(obj)) {
+            flattenValue(val, [...path, key], depth + 1, nodes);
+        }
+    }
+    else {
+        const label = path[path.length - 1] ?? "";
+        nodes.push({
+            path: [...path],
+            label,
+            value: obj === undefined || obj === null ? null : String(obj),
+            depth,
+            expandable: false,
+        });
+    }
+}
+export function flattenConfigTree(config) {
+    const nodes = [];
+    for (const [key, val] of Object.entries(config)) {
+        if (val === undefined)
+            continue;
+        flattenValue(val, [key], 0, nodes);
+    }
+    return nodes;
+}
+// ---------------------------------------------------------------------------
+// Config Mutations
+// ---------------------------------------------------------------------------
+export function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+export function updateConfigAtPath(config, path, value) {
+    const cloned = deepClone(config);
+    let current = cloned;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        current = current[key];
+    }
+    const lastKey = path[path.length - 1];
+    current[lastKey] = value;
+    return cloned;
+}
+export function addPane(config, rowIdx) {
+    const cloned = deepClone(config);
+    const row = cloned.rows[rowIdx];
+    if (!row)
+        return cloned;
+    row.panes.push({ title: "New Pane" });
+    return cloned;
+}
+export function removePane(config, rowIdx, paneIdx) {
+    const cloned = deepClone(config);
+    const row = cloned.rows[rowIdx];
+    if (!row)
+        return cloned;
+    if (row.panes.length <= 1)
+        return cloned;
+    row.panes.splice(paneIdx, 1);
+    return cloned;
+}
+export function addRow(config, size) {
+    const cloned = deepClone(config);
+    const row = { panes: [{ title: "Shell" }] };
+    if (size)
+        row.size = size;
+    cloned.rows.push(row);
+    return cloned;
+}
+export function removeRow(config, rowIdx) {
+    const cloned = deepClone(config);
+    if (cloned.rows.length <= 1)
+        return cloned;
+    cloned.rows.splice(rowIdx, 1);
+    return cloned;
+}
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+export function validateSetupConfig(config) {
+    const result = IdeConfigSchema.safeParse(config);
+    if (result.success) {
+        return { valid: true, config: result.data };
+    }
+    return {
+        valid: false,
+        errors: result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`),
+    };
+}

package/packages/daemon/dist/widgets/lib/files.d.ts

@@ -0,0 +1,11 @@
+import { type Ignore } from "ignore";
+export { type Ignore };
+export interface FileEntry {
+    name: string;
+    path: string;
+    absolutePath: string;
+    isDir: boolean;
+    ignored: boolean;
+}
+export declare function createIgnoreFilter(rootDir: string): Ignore;
+export declare function readDirectory(dir: string, rootDir: string, ig: Ignore, showHidden: boolean, showIgnored?: boolean): FileEntry[];

package/packages/daemon/dist/widgets/lib/files.js

@@ -0,0 +1,76 @@
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join, relative } from "node:path";
+import ignore from "ignore";
+const ALWAYS_IGNORE = new Set([
+    "node_modules",
+    ".git",
+    ".svn",
+    ".hg",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".turbo",
+    ".cache",
+    "__pycache__",
+    "coverage",
+    ".nyc_output",
+    "target",
+    "vendor",
+    "bower_components",
+]);
+export function createIgnoreFilter(rootDir) {
+    const ig = ignore();
+    const gitignorePath = join(rootDir, ".gitignore");
+    if (existsSync(gitignorePath)) {
+        ig.add(readFileSync(gitignorePath, "utf-8"));
+    }
+    return ig;
+}
+export function readDirectory(dir, rootDir, ig, showHidden, showIgnored = false) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((e) => {
+        if (ALWAYS_IGNORE.has(e.name))
+            return false;
+        if (!showHidden && e.name.startsWith("."))
+            return false;
+        if (showIgnored)
+            return true;
+        const rel = relative(rootDir, join(dir, e.name));
+        try {
+            return !ig.ignores(e.isDirectory() ? rel + "/" : rel);
+        }
+        catch {
+            return true;
+        }
+    })
+        .map((e) => {
+        const rel = relative(rootDir, join(dir, e.name));
+        let isIgnored = false;
+        try {
+            isIgnored = ig.ignores(e.isDirectory() ? rel + "/" : rel);
+        }
+        catch {
+            // ignore malformed paths for ignore rules
+        }
+        return {
+            name: e.name,
+            path: rel,
+            absolutePath: join(dir, e.name),
+            isDir: e.isDirectory(),
+            ignored: isIgnored,
+        };
+    })
+        .sort((a, b) => {
+        if (a.isDir !== b.isDir)
+            return a.isDir ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+}

package/packages/daemon/dist/widgets/lib/git.d.ts

@@ -0,0 +1,11 @@
+export interface GitFileStatus {
+    path: string;
+    status: "M" | "A" | "D" | "R" | "?";
+    additions: number;
+    deletions: number;
+}
+export declare function getGitBranch(dir: string): string | null;
+export declare function getGitFileStatuses(dir: string): GitFileStatus[];
+export declare function getGitStatusMap(dir: string): Map<string, string>;
+export declare function getFileDiff(dir: string, path: string, staged: boolean): string;
+export declare function isGitRepo(dir: string): boolean;

package/packages/daemon/dist/widgets/lib/git.js

@@ -0,0 +1,70 @@
+import { execFileSync } from "node:child_process";
+function execGit(dir, args) {
+    try {
+        return execFileSync("git", ["-c", "core.fsmonitor=false", "-c", "core.quotepath=false", ...args], { cwd: dir, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    }
+    catch {
+        return "";
+    }
+}
+export function getGitBranch(dir) {
+    const result = execGit(dir, ["rev-parse", "--abbrev-ref", "HEAD"]).trim();
+    return result || null;
+}
+export function getGitFileStatuses(dir) {
+    const results = [];
+    // 1. Identify deleted files first so we can tag them correctly in numstat
+    const deleted = execGit(dir, ["diff", "--name-only", "--diff-filter=D", "HEAD"]);
+    const deletedPaths = new Set(deleted.split("\n").filter(Boolean));
+    // 2. Modified/deleted files with line counts
+    const numstat = execGit(dir, ["diff", "--numstat", "HEAD"]);
+    for (const line of numstat.split("\n").filter(Boolean)) {
+        const parts = line.split("\t");
+        if (parts.length < 3)
+            continue;
+        const [added, removed, ...pathParts] = parts;
+        const filepath = pathParts.join("\t");
+        if (added === "-")
+            continue; // binary file
+        results.push({
+            path: filepath,
+            status: deletedPaths.has(filepath) ? "D" : "M",
+            additions: parseInt(added, 10) || 0,
+            deletions: parseInt(removed, 10) || 0,
+        });
+    }
+    // 3. Deleted files not in numstat (shouldn't happen, but be safe)
+    const numstatPaths = new Set(results.map((r) => r.path));
+    for (const filepath of deletedPaths) {
+        if (!numstatPaths.has(filepath)) {
+            results.push({ path: filepath, status: "D", additions: 0, deletions: 0 });
+        }
+    }
+    // 4. Untracked files
+    const untracked = execGit(dir, ["ls-files", "--others", "--exclude-standard"]);
+    for (const filepath of untracked.split("\n").filter(Boolean)) {
+        results.push({ path: filepath, status: "?", additions: 0, deletions: 0 });
+    }
+    return results;
+}
+export function getGitStatusMap(dir) {
+    const map = new Map();
+    for (const file of getGitFileStatuses(dir)) {
+        map.set(file.path, file.status);
+        // Propagate to parent directories
+        let parent = file.path;
+        while (parent.includes("/")) {
+            parent = parent.substring(0, parent.lastIndexOf("/"));
+            if (!map.has(parent))
+                map.set(parent, file.status);
+        }
+    }
+    return map;
+}
+export function getFileDiff(dir, path, staged) {
+    const args = staged ? ["diff", "--cached", "--", path] : ["diff", "--", path];
+    return execGit(dir, args);
+}
+export function isGitRepo(dir) {
+    return execGit(dir, ["rev-parse", "--is-inside-work-tree"]).trim() === "true";
+}

package/packages/daemon/dist/widgets/lib/grammar.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The ONE interaction grammar shared by every TUI surface — the sidebar,
+ * explorer, changes, config, and the team cockpit/picker.
+ *
+ * Cohesion is muscle memory: `j`/`k` (+ arrows) move, `enter` activates, `/`
+ * filters, `esc` closes the topmost thing (filter → detail → widget), `q`
+ * quits, `?` toggles help. These keys mean the SAME thing everywhere, so a
+ * widget never invents its own drift for a universal verb.
+ *
+ * Widgets call {@link matchGrammar} FIRST in their key handler and act on the
+ * returned {@link GrammarAction}, falling through to their own widget-specific
+ * keys only when it returns `null`. The escape precedence is factored into the
+ * pure {@link dismiss} state-machine so "esc closes the filter before it quits"
+ * is defined (and tested) in one place.
+ *
+ * This module is the SINGLE SOURCE for the grammar: the per-widget help
+ * overlays and the cheat sheet both render their "in panels & sidebar" section
+ * from {@link GRAMMAR_HELP}, so documentation can never drift from behaviour.
+ *
+ * Pure — no io, no solid, no opentui — so it unit-tests as a plain table.
+ */
+/** The universal verbs every surface understands. */
+export type GrammarAction = "navDown" | "navUp" | "activate" | "filter" | "help" | "dismiss" | "quit";
+/** The subset of an @opentui key event the grammar needs. */
+export interface GrammarKeyEvent {
+    name: string;
+    ctrl?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+}
+/**
+ * Deterministic iteration order for {@link matchGrammar}. The grammar keys are
+ * mutually exclusive (no key appears in two actions), so order only fixes the
+ * lookup for readers/tests — it never changes a result.
+ */
+export declare const GRAMMAR_ACTION_ORDER: GrammarAction[];
+/**
+ * The fixed key → action bindings. Unlike the team app's configurable
+ * `DEFAULT_KEYMAP`, the GRAMMAR itself is not user-configurable — its whole
+ * value is that it is the same everywhere. The team keymap's universal actions
+ * (up/down/enter/filter/help/quit) agree with these by construction.
+ */
+export declare const GRAMMAR_KEYS: Record<GrammarAction, string[]>;
+/**
+ * Human-facing rows for the help overlays and the cheat sheet — rendered
+ * straight from this constant so the docs are sourced from the grammar itself.
+ */
+export declare const GRAMMAR_HELP: ReadonlyArray<{
+    keys: string;
+    label: string;
+}>;
+/**
+ * Map a key event to its {@link GrammarAction}, or `null` when the key is not
+ * part of the grammar (so the caller falls through to its widget-specific
+ * keys).
+ *
+ * `ctrl`/`alt`/`meta` combos are NEVER grammar — those namespaces belong to the
+ * widgets (`ctrl+s` save, `ctrl+c` quit, the `M-…` dock popups). `shift` is
+ * allowed through because `?` arrives as a shifted `/` on most layouts; no
+ * widget binds a `shift+<grammar key>` combo, so letting it pass is safe.
+ */
+export declare function matchGrammar(evt: GrammarKeyEvent): GrammarAction | null;
+/** Which layer an `esc` (or `q`) should close, given what is currently open. */
+export type DismissTarget = "filter" | "detail" | "widget";
+/** The open-overlay layers a surface can stack, topmost-wins. */
+export interface OverlayState {
+    /** A `/` filter prompt is open (typing narrows a list). */
+    filterOpen?: boolean;
+    /** A transient detail view is open (help overlay, field editor, preview). */
+    detailOpen?: boolean;
+}
+/**
+ * The escape precedence, as a pure function: esc closes the FILTER first, then
+ * an open DETAIL, and only when nothing is layered does it fall through to the
+ * WIDGET itself (quit / close the popup). Widgets call this to decide what a
+ * bare `esc` (grammar `dismiss`) should do without re-deriving the order.
+ */
+export declare function dismiss(state: OverlayState): DismissTarget;

package/packages/daemon/dist/widgets/lib/grammar.js

@@ -0,0 +1,95 @@
+/**
+ * The ONE interaction grammar shared by every TUI surface — the sidebar,
+ * explorer, changes, config, and the team cockpit/picker.
+ *
+ * Cohesion is muscle memory: `j`/`k` (+ arrows) move, `enter` activates, `/`
+ * filters, `esc` closes the topmost thing (filter → detail → widget), `q`
+ * quits, `?` toggles help. These keys mean the SAME thing everywhere, so a
+ * widget never invents its own drift for a universal verb.
+ *
+ * Widgets call {@link matchGrammar} FIRST in their key handler and act on the
+ * returned {@link GrammarAction}, falling through to their own widget-specific
+ * keys only when it returns `null`. The escape precedence is factored into the
+ * pure {@link dismiss} state-machine so "esc closes the filter before it quits"
+ * is defined (and tested) in one place.
+ *
+ * This module is the SINGLE SOURCE for the grammar: the per-widget help
+ * overlays and the cheat sheet both render their "in panels & sidebar" section
+ * from {@link GRAMMAR_HELP}, so documentation can never drift from behaviour.
+ *
+ * Pure — no io, no solid, no opentui — so it unit-tests as a plain table.
+ */
+/**
+ * Deterministic iteration order for {@link matchGrammar}. The grammar keys are
+ * mutually exclusive (no key appears in two actions), so order only fixes the
+ * lookup for readers/tests — it never changes a result.
+ */
+export const GRAMMAR_ACTION_ORDER = [
+    "navDown",
+    "navUp",
+    "activate",
+    "filter",
+    "help",
+    "dismiss",
+    "quit",
+];
+/**
+ * The fixed key → action bindings. Unlike the team app's configurable
+ * `DEFAULT_KEYMAP`, the GRAMMAR itself is not user-configurable — its whole
+ * value is that it is the same everywhere. The team keymap's universal actions
+ * (up/down/enter/filter/help/quit) agree with these by construction.
+ */
+export const GRAMMAR_KEYS = {
+    navDown: ["j", "down"],
+    navUp: ["k", "up"],
+    activate: ["return"],
+    filter: ["/"],
+    help: ["?"],
+    dismiss: ["escape"],
+    quit: ["q"],
+};
+/**
+ * Human-facing rows for the help overlays and the cheat sheet — rendered
+ * straight from this constant so the docs are sourced from the grammar itself.
+ */
+export const GRAMMAR_HELP = [
+    { keys: "j / ↓", label: "move down" },
+    { keys: "k / ↑", label: "move up" },
+    { keys: "enter", label: "activate / open" },
+    { keys: "/", label: "filter list" },
+    { keys: "esc", label: "close filter → detail → widget" },
+    { keys: "q", label: "quit" },
+    { keys: "?", label: "toggle this help" },
+];
+/**
+ * Map a key event to its {@link GrammarAction}, or `null` when the key is not
+ * part of the grammar (so the caller falls through to its widget-specific
+ * keys).
+ *
+ * `ctrl`/`alt`/`meta` combos are NEVER grammar — those namespaces belong to the
+ * widgets (`ctrl+s` save, `ctrl+c` quit, the `M-…` dock popups). `shift` is
+ * allowed through because `?` arrives as a shifted `/` on most layouts; no
+ * widget binds a `shift+<grammar key>` combo, so letting it pass is safe.
+ */
+export function matchGrammar(evt) {
+    if (evt.ctrl || evt.alt || evt.meta)
+        return null;
+    for (const action of GRAMMAR_ACTION_ORDER) {
+        if (GRAMMAR_KEYS[action].includes(evt.name))
+            return action;
+    }
+    return null;
+}
+/**
+ * The escape precedence, as a pure function: esc closes the FILTER first, then
+ * an open DETAIL, and only when nothing is layered does it fall through to the
+ * WIDGET itself (quit / close the popup). Widgets call this to decide what a
+ * bare `esc` (grammar `dismiss`) should do without re-deriving the order.
+ */
+export function dismiss(state) {
+    if (state.filterOpen)
+        return "filter";
+    if (state.detailOpen)
+        return "detail";
+    return "widget";
+}

package/packages/daemon/dist/widgets/lib/help-overlay.d.ts

@@ -0,0 +1,19 @@
+import type { WidgetTheme } from "./theme.ts";
+/** A widget-specific key row: the rendered key(s) and what they do. */
+export interface WidgetKey {
+    key: string;
+    label: string;
+}
+export interface HelpOverlayProps {
+    theme: WidgetTheme;
+    /** Surface name shown in the header (e.g. "explorer", "sidebar"). */
+    title: string;
+    /** The surface's own keys, listed under the shared grammar. */
+    widgetKeys: WidgetKey[];
+}
+/**
+ * A centered help card: a "grammar" section (shared verbs) then a section of
+ * the surface's own keys. Replaces the surface body while `?` is held open;
+ * `esc`/`q`/`?` close it.
+ */
+export declare function HelpOverlay(props: HelpOverlayProps): any;

package/packages/daemon/dist/widgets/lib/help-overlay.jsx

@@ -0,0 +1,69 @@
+/**
+ * The shared `?` help overlay — one box, every surface.
+ *
+ * Renders the UNIVERSAL interaction grammar (from {@link GRAMMAR_HELP}, the same
+ * constant the cheat sheet reads) above the caller's OWN widget-specific keys.
+ * Because the grammar rows come from `grammar.ts`, no surface can document
+ * `j`/`k`/`enter`/`/`/`esc`/`q`/`?` differently from how it behaves.
+ *
+ * Each surface keeps a `helpOpen` signal, routes `?` (grammar `help`) to toggle
+ * it and `esc`/`q` to close it, and renders `<HelpOverlay …>` in place of its
+ * body while open. Kept theme-driven and io-free so it drops into any widget.
+ */
+import { For, Show } from "solid-js";
+import { RGBA, TextAttributes } from "@opentui/core";
+import { GRAMMAR_HELP } from "./grammar.js";
+function toRGBA(c) {
+    return RGBA.fromInts(c.r, c.g, c.b, c.a);
+}
+/**
+ * A centered help card: a "grammar" section (shared verbs) then a section of
+ * the surface's own keys. Replaces the surface body while `?` is held open;
+ * `esc`/`q`/`?` close it.
+ */
+export function HelpOverlay(props) {
+    const keyCol = () => {
+        const widths = [
+            ...GRAMMAR_HELP.map((r) => r.keys.length),
+            ...props.widgetKeys.map((r) => r.key.length),
+        ];
+        return Math.max(6, ...widths);
+    };
+    return (<box flexDirection="column" flexGrow={1} alignItems="center" paddingTop={2}>
+      <box flexDirection="column" border borderColor={toRGBA(props.theme.accent)} backgroundColor={toRGBA(props.theme.selected)} paddingLeft={2} paddingRight={2} paddingTop={1} paddingBottom={1}>
+        <text fg={toRGBA(props.theme.accent)} attributes={TextAttributes.BOLD}>
+          {props.title} — help
+        </text>
+
+        <box paddingTop={1}>
+          <text fg={toRGBA(props.theme.fgMuted)} attributes={TextAttributes.BOLD}>
+            grammar
+          </text>
+        </box>
+        <For each={GRAMMAR_HELP}>
+          {(row) => (<box flexDirection="row" gap={1}>
+              <text fg={toRGBA(props.theme.accent)}>{row.keys.padEnd(keyCol())}</text>
+              <text fg={toRGBA(props.theme.fg)}>{row.label}</text>
+            </box>)}
+        </For>
+
+        <Show when={props.widgetKeys.length > 0}>
+          <box paddingTop={1}>
+            <text fg={toRGBA(props.theme.fgMuted)} attributes={TextAttributes.BOLD}>
+              {props.title}
+            </text>
+          </box>
+          <For each={props.widgetKeys}>
+            {(row) => (<box flexDirection="row" gap={1}>
+                <text fg={toRGBA(props.theme.accent)}>{row.key.padEnd(keyCol())}</text>
+                <text fg={toRGBA(props.theme.fg)}>{row.label}</text>
+              </box>)}
+          </For>
+        </Show>
+
+        <box paddingTop={1}>
+          <text fg={toRGBA(props.theme.fgMuted)}>esc / q / ? to close</text>
+        </box>
+      </box>
+    </box>);
+}

package/packages/daemon/dist/widgets/lib/pane-comms.d.ts

@@ -0,0 +1,28 @@
+import type { PaneInfo } from "@tmux-ide/contracts";
+export type { PaneInfo };
+type TmuxExecutor = (cmd: string, args: string[], options?: object) => string;
+export declare function _setExecutor(fn: TmuxExecutor): () => void;
+export declare function listSessionPanes(session: string): PaneInfo[];
+export declare function findPaneByTitle(session: string, title: string): string | null;
+export declare function findPaneByPattern(session: string, pattern: string): string | null;
+export declare function findAdjacentPane(session: string, currentPaneId: string): string | null;
+export type PaneBusyStatus = "idle" | "busy" | "agent";
+export declare function isPaneBusy(session: string, paneId: string): boolean;
+export declare function getPaneBusyStatus(session: string, paneId: string): PaneBusyStatus;
+export declare function sendText(session: string, paneId: string, text: string): void;
+export declare function sendLiteralToPane(_session: string, paneId: string, text: string): void;
+export declare function sendEnterToPane(_session: string, paneId: string): void;
+export declare function sendCommand(session: string, paneId: string, command: string): boolean;
+export declare function openFileInEditor(session: string, paneId: string, filePath: string): void;
+export interface TargetOptions {
+    title?: string;
+    titlePattern?: string;
+    paneId?: string;
+    selfPaneId?: string;
+}
+export declare function resolveTarget(session: string, opts: TargetOptions): string | null;
+/**
+ * Capture the last line of a tmux pane. Uses the mockable executor so tests
+ * can intercept the call instead of hitting a real tmux server.
+ */
+export declare function captureLastLine(paneId: string): string;