nickdavis · August 2, 2026 09:21
diff --git a/README.md b/README.md
diff --git a/merge_repoprompt_ce_mcp.py b/merge_repoprompt_ce_mcp.py
 #!/usr/bin/env python3
 """Merge missing Codex MCP settings into RepoPrompt CE's isolated config."""

 from __future__ import annotations

 import argparse
 import copy
 import datetime as dt
 import os
 from pathlib import Path
 import shutil
 import tempfile
 from typing import Any, MutableMapping

 try:
    import tomlkit
 except ImportError as exc:  # pragma: no cover - friendly CLI failure
    raise SystemExit(
        "tomlkit is required. Install it in a temporary virtual environment; "
        "see README.md."
    ) from exc


 DEFAULT_SOURCE = Path.home() / ".codex" / "config.toml"
 DEFAULT_TARGET = (
    Path.home()
    / "Library"
    / "Application Support"
    / "RepoPrompt CE"
    / "Codex"
    / "Release"
    / "home"
    / "config.toml"
 )


 def parse_config(path: Path) -> Any:
    if not path.is_file() or path.is_symlink():
        raise SystemExit(f"Expected a regular config file: {path}")
    try:
        return tomlkit.parse(path.read_text(encoding="utf-8"))
    except Exception as exc:
        raise SystemExit(f"Could not parse {path}: {exc}") from exc


 def merge_missing(
    destination: MutableMapping[str, Any],
    source: MutableMapping[str, Any],
    prefix: tuple[str, ...],
    added: list[str],
 ) -> None:
    """Recursively add missing keys; never replace destination values."""
    for key, source_value in source.items():
        path = (*prefix, str(key))
        if key not in destination:
            destination[key] = copy.deepcopy(source_value)
            added.append(".".join(path))
            continue

        destination_value = destination[key]
        if isinstance(destination_value, MutableMapping) and isinstance(
            source_value, MutableMapping
        ):
            merge_missing(destination_value, source_value, path, added)


 def atomic_write(target: Path, rendered: str) -> Path:
    stamp = dt.datetime.now(dt.timezone.utc).strftime("%Y%m%dT%H%M%SZ")
    backup = target.with_name(f"{target.name}.pre-mcp-merge-{stamp}")
    if backup.exists():
        raise SystemExit(f"Refusing to replace existing backup: {backup}")

    shutil.copy2(target, backup)
    os.chmod(backup, 0o600)

    temporary_name: str | None = None
    try:
        with tempfile.NamedTemporaryFile(
            mode="w",
            encoding="utf-8",
            dir=target.parent,
            prefix=f".{target.name}.merge-",
            delete=False,
        ) as temporary:
            temporary.write(rendered)
            temporary.flush()
            os.fsync(temporary.fileno())
            temporary_name = temporary.name

        os.chmod(temporary_name, 0o600)
        os.replace(temporary_name, target)
        temporary_name = None
    finally:
        if temporary_name is not None:
            Path(temporary_name).unlink(missing_ok=True)

    return backup


 def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--source", type=Path, default=DEFAULT_SOURCE)
    parser.add_argument("--target", type=Path, default=DEFAULT_TARGET)
    parser.add_argument(
        "--apply",
        action="store_true",
        help="Create a backup and atomically update the target; default is dry-run.",
    )
    args = parser.parse_args()

    source_path = args.source.expanduser().resolve()
    target_path = args.target.expanduser().resolve()
    if source_path == target_path:
        raise SystemExit("Source and target must be different files")

    source = parse_config(source_path)
    target = parse_config(target_path)
    source_mcp = source.get("mcp_servers")
    target_mcp = target.get("mcp_servers")
    if not isinstance(source_mcp, MutableMapping):
        raise SystemExit(f"No [mcp_servers] table found in {source_path}")
    if not isinstance(target_mcp, MutableMapping):
        raise SystemExit(f"No [mcp_servers] table found in {target_path}")

    added: list[str] = []
    merge_missing(target_mcp, source_mcp, ("mcp_servers",), added)
    rendered = tomlkit.dumps(target)
    tomlkit.parse(rendered)  # Refuse to write output that cannot be reparsed.

    if not added:
        print("No missing MCP keys found; target left unchanged.")
        return 0

    print("Missing key paths that would be added:")
    for path in sorted(added):
        print(f"  {path}")

    if not args.apply:
        print("Dry run only. Re-run with --apply after reviewing the key paths.")
        return 0

    backup = atomic_write(target_path, rendered)
    print(f"Updated: {target_path}")
    print(f"Backup:  {backup}")
    return 0


 if __name__ == "__main__":
    raise SystemExit(main())
	#!/usr/bin/env python3
	"""Merge missing Codex MCP settings into RepoPrompt CE's isolated config."""

	from __future__ import annotations

	import argparse
	import copy
	import datetime as dt
	import os
	from pathlib import Path
	import shutil
	import tempfile
	from typing import Any, MutableMapping

	try:
	import tomlkit
	except ImportError as exc: # pragma: no cover - friendly CLI failure
	raise SystemExit(
	"tomlkit is required. Install it in a temporary virtual environment; "
	"see README.md."
	) from exc


	DEFAULT_SOURCE = Path.home() / ".codex" / "config.toml"
	DEFAULT_TARGET = (
	Path.home()
	/ "Library"
	/ "Application Support"
	/ "RepoPrompt CE"
	/ "Codex"
	/ "Release"
	/ "home"
	/ "config.toml"
	)


	def parse_config(path: Path) -> Any:
	if not path.is_file() or path.is_symlink():
	raise SystemExit(f"Expected a regular config file: {path}")
	try:
	return tomlkit.parse(path.read_text(encoding="utf-8"))
	except Exception as exc:
	raise SystemExit(f"Could not parse {path}: {exc}") from exc


	def merge_missing(
	destination: MutableMapping[str, Any],
	source: MutableMapping[str, Any],
	prefix: tuple[str, ...],
	added: list[str],
	) -> None:
	"""Recursively add missing keys; never replace destination values."""
	for key, source_value in source.items():
	path = (*prefix, str(key))
	if key not in destination:
	destination[key] = copy.deepcopy(source_value)
	added.append(".".join(path))
	continue

	destination_value = destination[key]
	if isinstance(destination_value, MutableMapping) and isinstance(
	source_value, MutableMapping
	):
	merge_missing(destination_value, source_value, path, added)


	def atomic_write(target: Path, rendered: str) -> Path:
	stamp = dt.datetime.now(dt.timezone.utc).strftime("%Y%m%dT%H%M%SZ")
	backup = target.with_name(f"{target.name}.pre-mcp-merge-{stamp}")
	if backup.exists():
	raise SystemExit(f"Refusing to replace existing backup: {backup}")

	shutil.copy2(target, backup)
	os.chmod(backup, 0o600)

	temporary_name: str \| None = None
	try:
	with tempfile.NamedTemporaryFile(
	mode="w",
	encoding="utf-8",
	dir=target.parent,
	prefix=f".{target.name}.merge-",
	delete=False,
	) as temporary:
	temporary.write(rendered)
	temporary.flush()
	os.fsync(temporary.fileno())
	temporary_name = temporary.name

	os.chmod(temporary_name, 0o600)
	os.replace(temporary_name, target)
	temporary_name = None
	finally:
	if temporary_name is not None:
	Path(temporary_name).unlink(missing_ok=True)

	return backup


	def main() -> int:
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument("--source", type=Path, default=DEFAULT_SOURCE)
	parser.add_argument("--target", type=Path, default=DEFAULT_TARGET)
	parser.add_argument(
	"--apply",
	action="store_true",
	help="Create a backup and atomically update the target; default is dry-run.",
	)
	args = parser.parse_args()

	source_path = args.source.expanduser().resolve()
	target_path = args.target.expanduser().resolve()
	if source_path == target_path:
	raise SystemExit("Source and target must be different files")

	source = parse_config(source_path)
	target = parse_config(target_path)
	source_mcp = source.get("mcp_servers")
	target_mcp = target.get("mcp_servers")
	if not isinstance(source_mcp, MutableMapping):
	raise SystemExit(f"No [mcp_servers] table found in {source_path}")
	if not isinstance(target_mcp, MutableMapping):
	raise SystemExit(f"No [mcp_servers] table found in {target_path}")

	added: list[str] = []
	merge_missing(target_mcp, source_mcp, ("mcp_servers",), added)
	rendered = tomlkit.dumps(target)
	tomlkit.parse(rendered) # Refuse to write output that cannot be reparsed.

	if not added:
	print("No missing MCP keys found; target left unchanged.")
	return 0

	print("Missing key paths that would be added:")
	for path in sorted(added):
	print(f" {path}")

	if not args.apply:
	print("Dry run only. Re-run with --apply after reviewing the key paths.")
	return 0

	backup = atomic_write(target_path, rendered)
	print(f"Updated: {target_path}")
	print(f"Backup: {backup}")
	return 0


	if __name__ == "__main__":
	raise SystemExit(main())
No results found