stackops 26.6.1__tar.gz → 26.6.2__tar.gz

{stackops-26.6.1 → stackops-26.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackops
-Version: 26.6.1
+Version: 26.6.2
 Summary: Developer Stack Manager
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0

{stackops-26.6.1 → stackops-26.6.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stackops"
-version = "26.6.1"
+version = "26.6.2"
 description = "Developer Stack Manager"
 readme = "README.md"
 license = {text = "Apache 2.0"}

{stackops-26.6.1 → stackops-26.6.2}/src/stackops/scripts/python/graph/visualize/helpers_navigator/devops_navigator.py

@@ -2,7 +2,7 @@
 # /// script
 # requires-python = ">=3.13"
 # dependencies = [
-#     "stackops>=26.6.1",
+#     "stackops>=26.6.2",
 #     "textual",
 # ]
 # ///

{stackops-26.6.1 → stackops-26.6.2}/src/stackops/scripts/python/helpers/helpers_devops/cli_config_dotfile_transfer.py

@@ -83,7 +83,7 @@ def export_dotfiles(
 
     port = 8888
     msg = f"""On the remote machine, run the following:
-d c i -u http://{local_ipv4}:{port} -p {pwd}
+d c I -u http://{local_ipv4}:{port} -p {pwd}
 """
 
     from stackops.utils.accessories import display_with_flashy_style

{stackops-26.6.1 → stackops-26.6.2}/src/stackops/scripts/python/helpers/helpers_devops/cli_repos.py

@@ -135,7 +135,7 @@ def count_lines_in_repo(repo_path: Annotated[str, typer.Argument(help="Path to t
     # from stackops.scripts.python.helpers.helpers_repos import repo_analyzer_1
     # repo_analyzer_1.count_historical_line_edits(repo_path=repo_path)
     # from stackops.utils.code import run_lambda_function
-    # run_lambda_function(lambda: func(repo_path=repo_path), uv_project_dir=None, uv_with=["stackops>=26.6.1"])
+    # run_lambda_function(lambda: func(repo_path=repo_path), uv_project_dir=None, uv_with=["stackops>=26.6.2"])
     resolved_repo_path = Path(repo_path).expanduser().absolute().resolve()
     if not resolved_repo_path.exists():
         typer.echo(f"❌ Repository path does not exist: {resolved_repo_path}", err=True)
@@ -170,7 +170,7 @@ def print_python_files_by_size(repo_path: Annotated[str, typer.Argument(..., hel
     #     from stackops.scripts.python.helpers.helpers_repos.repo_analyzer_2 import print_python_files_by_size_impl
     #     print_python_files_by_size_impl(repo_path=repo_path)
     # from stackops.utils.code import run_lambda_function
-    # run_lambda_function(lambda: func(repo_path=repo_path), uv_project_dir=None, uv_with=["stackops[plot]>=26.6.1"])
+    # run_lambda_function(lambda: func(repo_path=repo_path), uv_project_dir=None, uv_with=["stackops[plot]>=26.6.2"])
     from stackops.scripts.python.helpers.helpers_repos.repo_analyzer_2 import print_python_files_by_size_impl
 
     print_python_files_by_size_impl(repo_path=repo_path)

{stackops-26.6.1 → stackops-26.6.2}/src/stackops/scripts/python/helpers/helpers_env/env_manager_tui.py

@@ -2,7 +2,7 @@
 # /// script
 # requires-python = ">=3.13"
 # dependencies = [
-#     "stackops>=26.6.1",
+#     "stackops>=26.6.2",
 #     "textual",
 #     "pyperclip",
 # ]

{stackops-26.6.1 → stackops-26.6.2}/src/stackops/scripts/python/helpers/helpers_env/path_manager_tui.py

@@ -2,7 +2,7 @@
 # /// script
 # requires-python = ">=3.13"
 # dependencies = [
-#     "stackops>=26.6.1",
+#     "stackops>=26.6.2",
 #     "textual",
 #     "pyperclip",
 # ]

{stackops-26.6.1 → stackops-26.6.2}/src/stackops/scripts/python/helpers/helpers_sessions/_tmux_backend_preview.py

@@ -1,6 +1,21 @@
-from collections import defaultdict
+from collections import Counter, defaultdict
+from collections.abc import Sequence
 from subprocess import CompletedProcess
-from typing import Callable
+from typing import Callable, Literal, TypeAlias, TypedDict
+
+
+PaneStatusCategory: TypeAlias = Literal["idle", "running", "exited", "unknown"]
+
+
+class ClassifiedPane(TypedDict):
+    window_index: str
+    window_name: str
+    pane_index: str
+    process_name: str
+    status: str
+    category: PaneStatusCategory
+    cwd: str
+    is_active: bool
 
 
 def session_sort_key(
@@ -107,10 +122,108 @@ def _render_window_summary_table(windows: list[dict[str, str]]) -> list[str]:
     return lines
 
 
-def _render_pane_details_table(
+def _classify_status(status: str) -> PaneStatusCategory:
+    if status == "idle shell":
+        return "idle"
+    if status.startswith("running:"):
+        return "running"
+    if status.startswith("exited ("):
+        return "exited"
+    return "unknown"
+
+
+def _classify_panes_by_window(
     windows: list[dict[str, str]],
     panes_by_window: dict[str, list[dict[str, str]]],
     classify_pane_status_fn: Callable[[dict[str, str]], tuple[str, str]],
+) -> dict[str, list[ClassifiedPane]]:
+    classified_panes_by_window: dict[str, list[ClassifiedPane]] = {}
+    for window in windows:
+        window_index = window["window_index"]
+        classified_panes: list[ClassifiedPane] = []
+        for pane in panes_by_window.get(window_index, []):
+            process_name, status = classify_pane_status_fn(pane)
+            classified_panes.append(
+                {
+                    "window_index": window_index,
+                    "window_name": window["window_name"],
+                    "pane_index": pane["pane_index"],
+                    "process_name": process_name,
+                    "status": status,
+                    "category": _classify_status(status=status),
+                    "cwd": pane["pane_cwd"] or "—",
+                    "is_active": bool(pane["pane_active"]),
+                }
+            )
+        classified_panes_by_window[window_index] = classified_panes
+    return classified_panes_by_window
+
+
+def _process_group_name(process_name: str) -> str:
+    text = process_name.strip().strip("`")
+    if not text or text == "—":
+        return "—"
+    return text.split(maxsplit=1)[0]
+
+
+def _format_process_counts(process_counts: Counter[str]) -> str:
+    if not process_counts:
+        return "—"
+    ordered_processes = sorted(process_counts.items(), key=lambda item: (-item[1], item[0]))
+    return ", ".join(
+        f"{process_name} x{count}" if count > 1 else process_name
+        for process_name, count in ordered_processes
+    )
+
+
+def _render_process_summary_table(classified_panes_by_window: dict[str, list[ClassifiedPane]]) -> list[str]:
+    category_counts: Counter[PaneStatusCategory] = Counter()
+    running_process_counts: Counter[str] = Counter()
+    total_panes = 0
+
+    for classified_panes in classified_panes_by_window.values():
+        for pane in classified_panes:
+            total_panes += 1
+            category = pane["category"]
+            category_counts[category] += 1
+            if category == "running":
+                running_process_counts[_process_group_name(process_name=pane["process_name"])] += 1
+
+    return [
+        "## Process Summary",
+        "",
+        "| Panes | Idle Shell | Running | Exited | Unknown | Running Processes |",
+        "|------:|-----------:|--------:|-------:|--------:|-------------------|",
+        (
+            f"| {total_panes} | {category_counts['idle']} | {category_counts['running']} | "
+            f"{category_counts['exited']} | {category_counts['unknown']} | "
+            f"{_format_process_counts(process_counts=running_process_counts)} |"
+        ),
+        "",
+    ]
+
+
+def _render_window_pane_details_table(
+    classified_panes: Sequence[ClassifiedPane],
+) -> list[str]:
+    lines = [
+        "| Pane | Process | Status | Directory |",
+        "|------|---------|--------|-----------|",
+    ]
+    if not classified_panes:
+        lines.append("| — | — | — | — |")
+    for pane in classified_panes:
+        active_flag = " ⇐" if pane["is_active"] else ""
+        lines.append(
+            f"| {pane['pane_index']}{active_flag} | {pane['process_name']} | {pane['status']} | `{pane['cwd']}` |"
+        )
+    lines.append("")
+    return lines
+
+
+def _render_pane_details_table(
+    windows: list[dict[str, str]],
+    classified_panes_by_window: dict[str, list[ClassifiedPane]],
 ) -> list[str]:
     lines = [
         "## Pane Details",
@@ -119,16 +232,14 @@ def _render_pane_details_table(
         "|---------|------------|------|---------|--------|-----------|",
     ]
     for window in windows:
-        window_panes = panes_by_window.get(window["window_index"], [])
+        window_panes = classified_panes_by_window.get(window["window_index"], [])
         if not window_panes:
             lines.append(f"| {window['window_index']} | {window['window_name']} | — | — | — | — |")
             continue
         for pane in window_panes:
-            process_name, status = classify_pane_status_fn(pane)
-            cwd = pane["pane_cwd"] or "—"
-            active_flag = " ⇐" if pane["pane_active"] else ""
+            active_flag = " ⇐" if pane["is_active"] else ""
             lines.append(
-                f"| {window['window_index']} | {window['window_name']} | {pane['pane_index']}{active_flag} | {process_name} | {status} | `{cwd}` |"
+                f"| {window['window_index']} | {window['window_name']} | {pane['pane_index']}{active_flag} | {pane['process_name']} | {pane['status']} | `{pane['cwd']}` |"
             )
     lines.append("")
     return lines
@@ -144,10 +255,16 @@ def build_preview(
     if windows is None:
         return "\n".join(lines + ["", pane_warning or "No preview data available"])
 
+    classified_panes_by_window = _classify_panes_by_window(
+        windows=windows,
+        panes_by_window=panes_by_window,
+        classify_pane_status_fn=classify_pane_status_fn,
+    )
     lines.append(f"  |  **windows:** {len(windows)}")
     lines.append("")
+    lines.extend(_render_process_summary_table(classified_panes_by_window=classified_panes_by_window))
     lines.extend(_render_window_summary_table(windows))
-    lines.extend(_render_pane_details_table(windows, panes_by_window, classify_pane_status_fn))
+    lines.extend(_render_pane_details_table(windows, classified_panes_by_window))
     if pane_warning:
         lines.append(f"> ⚠ pane query warning: {pane_warning}")
     return "\n".join(lines)
@@ -160,23 +277,21 @@ def build_window_preview(
     pane_warning: str | None,
     classify_pane_status_fn: Callable[[dict[str, str]], tuple[str, str]],
 ) -> str:
+    classified_panes_by_window = _classify_panes_by_window(
+        windows=[window],
+        panes_by_window={window["window_index"]: panes},
+        classify_pane_status_fn=classify_pane_status_fn,
+    )
+    classified_panes = classified_panes_by_window[window["window_index"]]
     lines = [
         f"# Session: {session_name}",
         "",
         "**backend:** tmux",
         f"**window:** {window['window_index']}:{window['window_name']}",
         "",
-        "| Pane | Process | Status | Directory |",
-        "|------|---------|--------|-----------|",
     ]
-    if not panes:
-        lines.append("| — | — | — | — |")
-    for pane in panes:
-        process_name, status = classify_pane_status_fn(pane)
-        cwd = pane["pane_cwd"] or "—"
-        active_flag = " ⇐" if pane["pane_active"] else ""
-        lines.append(f"| {pane['pane_index']}{active_flag} | {process_name} | {status} | `{cwd}` |")
-    lines.append("")
+    lines.extend(_render_process_summary_table(classified_panes_by_window=classified_panes_by_window))
+    lines.extend(_render_window_pane_details_table(classified_panes=classified_panes))
     if pane_warning:
         lines.append(f"> ⚠ pane query warning: {pane_warning}")
     return "\n".join(lines)

{stackops-26.6.1 → stackops-26.6.2}/src/stackops/scripts/setup/linux/interactive.sh

@@ -8,14 +8,14 @@
 # live from github version
 # alias stackops='$HOME/.local/bin/uvx --python 3.14 --from "git+https://github.com/thisismygitrepo/stackops" stackops'
 
-alias devops='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.1" devops'
-alias cloud='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.1" cloud'
-alias agents='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.1" agents'
-alias fire='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.1" fire'
-alias preview='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.1" preview'
-alias utils='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.1" utils'
-alias terminal='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.1" terminal'
-seek() { "$HOME/.local/bin/uvx" --python 3.14 --from "stackops>=26.6.1" seek "$@"; }
+alias devops='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.2" devops'
+alias cloud='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.2" cloud'
+alias agents='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.2" agents'
+alias fire='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.2" fire'
+alias preview='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.2" preview'
+alias utils='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.2" utils'
+alias terminal='$HOME/.local/bin/uvx --python 3.14 --from "stackops>=26.6.2" terminal'
+seek() { "$HOME/.local/bin/uvx" --python 3.14 --from "stackops>=26.6.2" seek "$@"; }
 
 alias d='wrap_in_shell_script devops'
 alias c='wrap_in_shell_script cloud'

{stackops-26.6.1 → stackops-26.6.2}/src/stackops/scripts/setup/windows/interactive.ps1

@@ -8,15 +8,15 @@ irm "https://raw.githubusercontent.com/thisismygitrepo/stackops/main/src/stackop
 # live from github version
 # function stackops { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "git+https://github.com/thisismygitrepo/stackops" stackops $args }
 
-function devops   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.1" devops $args }
-function cloud    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.1" cloud $args }
-function agents   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.1" agents $args }
-function sessions { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.1" sessions $args }
-function fire     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.1" fire $args }
-function preview { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.1" preview $args }
-function utils    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.1" utils $args }
-function terminal { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.1" terminal $args }
-function seek     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.1" seek @args }
+function devops   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.2" devops $args }
+function cloud    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.2" cloud $args }
+function agents   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.2" agents $args }
+function sessions { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.2" sessions $args }
+function fire     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.2" fire $args }
+function preview { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.2" preview $args }
+function utils    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.2" utils $args }
+function terminal { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.2" terminal $args }
+function seek     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "stackops>=26.6.2" seek @args }
 
 function d { wrap_in_shell_script devops @args }
 function c { wrap_in_shell_script cloud @args }

{stackops-26.6.1 → stackops-26.6.2}/src/stackops/utils/options_utils/textual_options_form_types.py

@@ -62,7 +62,7 @@ def use_textual_options_form(
 
     from stackops.utils.code import run_lambda_function
     uv_with, uv_project_dir = resolve_uv_run_config(cwd=Path.cwd(), module_file=Path(__file__).resolve())
-    # uv_with, uv_project_dir = ["textual", "stackops>=26.6.1"], None
+    # uv_with, uv_project_dir = ["textual", "stackops>=26.6.2"], None
     run_lambda_function(
         lambda: func(
             inputs=options,

{stackops-26.6.1 → stackops-26.6.2}/src/stackops/utils/schemas/installer/installer_data.json

@@ -3923,6 +3923,27 @@
         }
       }
     },
+    {
+      "appName": "openhands",
+      "license": "MIT License",
+      "repoURL": "https://github.com/OpenHands/OpenHands",
+      "doc": "OpenHands AI-driven development CLI and local GUI.",
+      "categoryLabels": [
+        "ai-agents-assistants"
+      ],
+      "fileNamePattern": {
+        "amd64": {
+          "linux": "uv tool install openhands --python 3.12",
+          "windows": "uv tool install openhands --python 3.12",
+          "darwin": "uv tool install openhands --python 3.12"
+        },
+        "arm64": {
+          "linux": "uv tool install openhands --python 3.12",
+          "windows": "uv tool install openhands --python 3.12",
+          "darwin": "uv tool install openhands --python 3.12"
+        }
+      }
+    },
     {
       "appName": "ai-devkit",
       "license": "MIT",

stackops-26.6.2/src/stackops/utils/schemas/layouts/layout_types.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""
+Type definitions for the standardized layout configuration schema.
+This module defines the data structures that match the layout.json schema.
+"""
+
+from pathlib import Path
+import json
+from typing import Literal, NotRequired, TypeAlias, TypedDict, cast
+
+LayoutFileWriteMode: TypeAlias = Literal["replace_file", "merge_by_layout_name"]
+
+
+class TabConfig(TypedDict):
+    """Configuration for a single tab in a layout."""
+    tabName: str
+    startDir: str
+    command: str
+    tabWeight: NotRequired[int]
+
+
+class LayoutConfig(TypedDict):
+    """Configuration for a complete layout with its tabs."""
+    layoutName: str
+    layoutTabs: list[TabConfig]
+
+
+class LayoutsFile(TypedDict):
+    """Complete layout file structure."""
+    version: str
+    layouts: list[LayoutConfig]
+
+
+LayoutJsonFile = TypedDict(
+    "LayoutJsonFile",
+    {
+        "$schema": str,
+        "version": str,
+        "layouts": list[LayoutConfig],
+    },
+)
+
+
+def _get_unique_layout_indexes_by_name(layouts: list[LayoutConfig], source: str) -> dict[str, int]:
+    layout_indexes: dict[str, int] = {}
+    for layout_index, layout_config in enumerate(layouts):
+        layout_name = layout_config["layoutName"]
+        if layout_name in layout_indexes:
+            raise ValueError(f"Duplicate layoutName {layout_name!r} in {source}")
+        layout_indexes[layout_name] = layout_index
+    return layout_indexes
+
+
+def _merge_layouts_by_name(existing_layouts: list[LayoutConfig], new_layouts: list[LayoutConfig]) -> list[LayoutConfig]:
+    merged_layouts = list(existing_layouts)
+    layout_indexes = _get_unique_layout_indexes_by_name(layouts=merged_layouts, source="existing layout file")
+    _get_unique_layout_indexes_by_name(layouts=new_layouts, source="new layouts")
+    for new_layout in new_layouts:
+        new_layout_name = new_layout["layoutName"]
+        existing_index = layout_indexes.get(new_layout_name)
+        if existing_index is None:
+            layout_indexes[new_layout_name] = len(merged_layouts)
+            merged_layouts.append(new_layout)
+        else:
+            merged_layouts[existing_index] = new_layout
+    return merged_layouts
+
+
+def serialize_layouts_to_file(layouts: list[LayoutConfig], version: Literal["0.1"], path: str, *, write_mode: LayoutFileWriteMode) -> None:
+    _get_unique_layout_indexes_by_name(layouts=layouts, source="new layouts")
+    layout_file: LayoutJsonFile = {
+        "$schema": "https://bit.ly/cfglayout",
+        "version": version,
+        "layouts": layouts,
+    }
+    p = Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    match write_mode:
+        case "replace_file":
+            pass
+        case "merge_by_layout_name":
+            if p.exists():
+                existing_layout_file = cast(LayoutsFile, json.loads(p.read_text(encoding="utf-8")))
+                layout_file["layouts"] = _merge_layouts_by_name(existing_layouts=existing_layout_file["layouts"], new_layouts=layouts)
+    p.write_text(json.dumps(layout_file, indent=4), encoding="utf-8")
+
+
+def substitute_home(tabs: list[TabConfig]) -> list["TabConfig"]:
+    json_str = json.dumps(tabs)
+    json_str = json_str.replace("~", str(Path.home())).replace("$HOME", str(Path.home()))
+    json_str = json_str.replace("""command": "f """, """command": "~/.config/stackops/scripts/wrap_stackops fire """)
+    json_str = json_str.replace("""command": "t """, """command": "~/.config/stackops/scripts/wrap_stackops terminal """)
+    json_str = json_str.replace("""command": "s """, """command": "~/.config/stackops/scripts/wrap_stackops seek """)
+    return cast(list[TabConfig], json.loads(json_str))

{stackops-26.6.1 → stackops-26.6.2}/src/stackops/utils/ssh_utils/abc.py

@@ -1,5 +1,5 @@
 
 
-STACKOPS_VERSION = "26.6.1"
+STACKOPS_VERSION = "26.6.2"
 STACKOPS_REQUIREMENT = f"stackops>={STACKOPS_VERSION}"
 DEFAULT_PICKLE_SUBDIR = "tmp_results/tmp_scripts/ssh"

{stackops-26.6.1 → stackops-26.6.2}/src/stackops.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackops
-Version: 26.6.1
+Version: 26.6.2
 Summary: Developer Stack Manager
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0

stackops-26.6.1/src/stackops/utils/schemas/layouts/layout_types.py

@@ -1,70 +0,0 @@
-#!/usr/bin/env python3
-"""
-Type definitions for the standardized layout configuration schema.
-This module defines the data structures that match the layout.json schema.
-"""
-
-from typing import TypedDict, List, Literal, NotRequired
-
-
-class TabConfig(TypedDict):
-    """Configuration for a single tab in a layout."""
-    tabName: str
-    startDir: str
-    command: str
-    tabWeight: NotRequired[int]
-
-
-class LayoutConfig(TypedDict):
-    """Configuration for a complete layout with its tabs."""
-    layoutName: str
-    layoutTabs: List[TabConfig]
-
-
-class LayoutsFile(TypedDict):
-    """Complete layout file structure."""
-    version: str
-    layouts: List[LayoutConfig]
-
-
-def serialize_layouts_to_file(layouts: list[LayoutConfig], version: Literal["0.1"], path: str):
-    """Serialize a LayoutConfig to a JSON string."""
-    import json
-    layout_file: LayoutsFile = {
-        "version": version,
-        "layouts": layouts,
-    }
-    # add "$schema" key pointing to https://bit.ly/cfglayout
-    layout_dict = {
-        "$schema": "https://bit.ly/cfglayout",
-        **layout_file
-    }
-    json_string = json.dumps(layout_dict, indent=4)
-    from pathlib import Path
-    p = Path(path)
-    p.parent.mkdir(parents=True, exist_ok=True)
-    if not p.exists():
-        p.write_text(json_string, encoding="utf-8")
-        return None
-    existing_content_layout: LayoutsFile = json.loads(p.read_text(encoding="utf-8"))
-    # policy: if layout with same name exists, replace it. we don't lool at tabConfig differences.
-    for a_new_layout in layouts:
-        for i, existing_layout in enumerate(existing_content_layout["layouts"]):
-            if existing_layout["layoutName"] == a_new_layout["layoutName"]:
-                existing_content_layout["layouts"][i] = a_new_layout
-                break
-        else:
-            existing_content_layout["layouts"].append(a_new_layout)
-    p.write_text(json.dumps(existing_content_layout, indent=4), encoding="utf-8")
-    return None
-
-
-def substitute_home(tabs: list[TabConfig]) -> list["TabConfig"]:
-    import json
-    from pathlib import Path
-    json_str = json.dumps(tabs)
-    json_str = json_str.replace("~", str(Path.home())).replace("$HOME", str(Path.home()))
-    json_str = json_str.replace("""command": "f """, """command": "~/.config/stackops/scripts/wrap_stackops fire """)
-    json_str = json_str.replace("""command": "t """, """command": "~/.config/stackops/scripts/wrap_stackops terminal """)
-    json_str = json_str.replace("""command": "s """, """command": "~/.config/stackops/scripts/wrap_stackops seek """)
-    return json.loads(json_str)