machineconfig 1.97__py3-none-any.whl → 2.1__py3-none-any.whl

machineconfig/scripts/python/ai/chatmodes/deepResearch.chatmode.md

@@ -0,0 +1,81 @@
+---
+description: 'Autonomous, multi-step web research with numbered citations, cross-source verification, and a final Markdown report.'
+tools: ['extensions', 'fetch', 'websearch', 'search', 'githubRepo', 'editFiles']
+---
+
+# Deep Research mode
+
+You are a rigorous research agent. Emulate the behavior of OpenAI “Deep Research” and Perplexity “Pro/Research” modes:
+- Plan first, then execute iterative searches and browsing.
+- Read broadly, follow relevant links recursively, and take structured notes.
+- Attribute every non-trivial claim with numbered citations and quotes.
+- Cross-verify important facts across independent, high-quality sources.
+- Produce a clean, self-contained Markdown report saved to ./.ai/deep_research_$suffix.md.
+
+This mode is read-heavy. Do not modify project code. Only create or update files under ./.ai/.
+
+## Inputs and outputs
+- Input: a research question or task, optional `suffix` for report naming, optional provided URLs.
+- Output: a Markdown report written to ./.ai/deep_research_$suffix.md and a concise chat summary with key findings and links.
+
+## Tools you should use
+- fetch: fetch page contents for provided or discovered URLs.
+- websearch: perform web searches to discover authoritative sources. Iterate as needed.
+- search: only for searching the local workspace when relevant (not the web).
+- githubRepo: optionally pull examples or repos if directly relevant.
+- editFiles: create/update the report file under ./.ai/.
+
+## Execution protocol
+Follow these phases every time. Provide compact progress updates between phases and after every ~3–5 tool calls: what you did and what’s next.
+
+1) Planning and scope
+- Restate the question. Extract explicit and implicit sub-questions as a checklist.
+- Define success criteria (decision to be made, comparison outcome, data needed, etc.).
+- Draft a search plan: keywords, entities, time range/recency requirements, likely primary sources, and anticipated pitfalls.
+
+2) Initial search and source triage
+- Use websearch to find diverse, reputable sources (docs, standards, primary data, peer-reviewed or recognized outlets). Prefer primary sources where possible.
+- For each candidate, use fetch to open it. Capture: title, author/org, publish/update date, URL, key quotes (with exact wording), and quick trust notes.
+- Track sources in a table within your working notes (not necessarily in the final report) to avoid duplication.
+
+3) Recursive exploration and verification
+- Follow relevant links found in good sources (fetch them). Stop when additional sources stop changing conclusions materially.
+- Cross-check critical numbers, timelines, and quotes against at least two independent sources when available.
+- If sources conflict, explain the disagreement and weigh credibility (recency, expertise, methodology, bias, primary vs. secondary).
+
+4) Synthesis and reporting
+- Draft a clear, structured Markdown report with:
+  - Title and date
+  - Executive summary (bulleted, 5–10 lines, with [n] citations inline)
+  - Key findings (short sections, each claim supported by [n] citations and brief quotes)
+  - Analysis (trade-offs, areas of uncertainty, limitations, and what to watch next)
+  - Recommendations or direct answers, if applicable (with citations)
+  - Appendix: Sources list with numbered entries [n], each including title, author/org, date (published/updated), URL, and quoted snippets used
+- Ensure the report is readable and skimmable. Keep sentences concise.
+
+5) Save the report
+- Determine `$suffix` in this order: (a) user-provided; else (b) a short kebab-case slug from the question; append date (YYYYMMDD) if helpful.
+- Ensure directory ./.ai exists; create it if missing.
+- Write the report to ./.ai/deep_research_$suffix.md using editFiles.
+
+6) Final checks
+- Verify every non-obvious statement has a citation [n] pointing to a source in Appendix.
+- Verify dates are present for sources when available; prefer the most recent reputable sources.
+- Remove dead links if discovered; replace with archived or alternative sources when possible.
+- Share a concise chat summary with 3–6 bullets and the saved file path.
+
+## Citation rules
+- Use numeric references [1], [2], ... inline; match them in the Appendix.
+- Quote short key phrases exactly (with quotation marks) and include context.
+- Include publish/update date and access date (today) when available.
+- Prefer primary documentation, official standards, authors/organizations with recognized expertise, and recent updates.
+
+## Guardrails and quality
+- Be explicit when uncertain; avoid speculation. If evidence is weak, state it.
+- Distinguish proven facts vs. interpretations. Label opinions as such.
+- Avoid paywalled content if it prevents verification; seek alternative open sources or include accessible abstracts.
+- If new questions arise, loop back with targeted websearch/fetch until conclusions are well-supported.
+
+## Usage
+- In chat, switch to “Deep Research” mode. Provide your query and optionally `suffix:` or `filename:` hint (e.g., suffix: chiplet-market-2025).
+- This mode will produce the report and post the saved path, e.g., ./.ai/deep_research_chiplet-market-2025.md.

machineconfig/scripts/python/ai/configs/.gemini/settings.json

@@ -0,0 +1,81 @@
+{
+  // Appearance
+  "theme": "Default",          // Could also be "GitHub", "Dracula", etc.
+
+  // Authentication
+  "selectedAuthType": "gemini-api-key",  // Options: "gemini-api-key", "oauth-personal", "vertex-ai"
+
+  // Tool usage and safety
+  "sandbox": false,                    // Enable with true or specify backend ("docker", "podman")
+  "autoAccept": true,                 // Auto-approve safe tool calls
+  "usageStatisticsEnabled": false,      // Collect anonymized usage stats
+  "telemetry": {
+    "enabled": false,
+    "target": "remote",               // or "local"
+    "logPrompts": false
+  },
+
+  // Work environment configuration
+  "preferredEditor": "vim",            // or "vscode", "nano", etc.
+  "fileFiltering": {
+    "respectGitIgnore": true,
+    "enableRecursiveFileSearch": true
+  },
+
+  // Context and workspace behavior
+  "contextFileName": "GEMINI.md",      // Can also be an array of filenames
+  "includeDirectories": [],            // e.g., ["../shared", "~/common-utils"]
+  "chatCompression": {
+    "contextPercentageThreshold": 0.5   // Threshold for compressing history
+  },
+
+  // Bug reporting customization
+  "bugCommand": {
+    "urlTemplate": "https://github.com/google-gemini/gemini-cli/issues/new?template=bug_report.yml&title={title}&info={info}"
+  },
+
+  // Extensions and integrations via MCP servers
+  "mcpServers": {
+    // Example structure; override or extend as needed
+    // "myServer": {
+    //   "command": "my_mcp_tool",
+    //   "args": [],
+    //   "httpUrl": "http://localhost:####/mcp",
+    //   "headers": {},
+    //   "timeout": 10000,
+    //   "trust": false,
+    //   "includeTools": [],
+    //   "excludeTools": []
+    // }
+  },
+
+  // Control which tools are available
+  "coreTools": [
+    "EditTool",
+    "GlobTool",
+    "WebSearchTool",
+    "ReadFileTool",
+    "LSTool",
+    "ReadManyFilesTool",
+    "MemoryTool",
+    "GrepTool",
+    "ShellTool",
+    "WebFetchTool",
+    "WriteFileTool"
+  ],
+  "excludeTools": [],
+
+  // Custom color themes (optional)
+  "customThemes": {
+    "MyCustomTheme": {
+      "name": "MyCustomTheme",
+      "type": "custom",
+      "Background": "#181818",
+      "Foreground": "#F8F8F2",
+      "AccentBlue": "#61AFEF",
+      "AccentPurple": "#C678DD",
+      "AccentGreen": "#98C379"
+      // Add more as desired
+    }
+  }
+}

machineconfig/scripts/python/ai/generate_files.py

@@ -0,0 +1,84 @@
+
+#!/usr/bin/env python3
+"""Script to generate a markdown table with checkboxes for all Python files in the repo."""
+
+from pathlib import Path
+
+
+def get_python_files(repo_root: Path) -> list[str]:
+    """Get all Python files relative to repo root."""
+    # Get all .py files recursively
+    py_files = list(repo_root.glob("**/*.py"))
+    
+    # Filter out files in .venv and __pycache__ directories
+    filtered_files = []
+    for file_path in py_files:
+        relative_path = file_path.relative_to(repo_root)
+        path_parts = relative_path.parts
+        
+        # Skip files in .venv or __pycache__ directories
+        if any(part in {".venv", "__pycache__"} for part in path_parts):
+            continue
+            
+        filtered_files.append(str(relative_path))
+    
+    return sorted(filtered_files)
+
+
+def generate_markdown_table(files: list[str]) -> str:
+    """Generate markdown table with checkboxes."""
+    header = "# Python Files Checklist\n\n"
+    table = "| Index | File Path | Status |\n|-------|-----------|--------|\n"
+    
+    for index, file_path in enumerate(files, start=1):
+        # Remove leading ./ if present
+        clean_path = file_path.lstrip('./')
+        table += f"| {index} | {clean_path} | - [ ] |\n"
+    
+    return header + table
+
+
+def main() -> None:
+    """Main function."""
+    repo_root = Path.cwd()
+    if not repo_root.joinpath("pyproject.toml").exists():
+        raise RuntimeError(f" {repo_root} Not a repo root")
+    output_file = repo_root / ".ai" / "all_files_with_index.md"
+    
+    print(f"Repo root: {repo_root}")
+    print(f"Output file: {output_file}")
+    
+    # Ensure output directory exists
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Get Python files
+    python_files = get_python_files(repo_root)
+    print(f"Found {len(python_files)} Python files")
+    
+    # Generate markdown
+    markdown_content = generate_markdown_table(python_files)
+    print(f"Generated markdown content length: {len(markdown_content)}")
+    
+    # Write to file
+    output_file.write_text(markdown_content)
+    print(f"Generated {output_file} with {len(python_files)} Python files")
+    
+    # Create 5 symlinks to repo_root at ~/code_copies/${repo_name}_copy_{i}
+    import pathlib
+    # import os
+    repo_root = pathlib.Path.cwd().resolve()
+    repo_name: str = pathlib.Path(repo_root).name
+    symlink_dir: pathlib.Path = pathlib.Path.home() / "code_copies"
+    symlink_dir.mkdir(exist_ok=True)
+    for i in range(1, 6):
+        symlink_path: pathlib.Path = symlink_dir / f"{repo_name}_copy_{i}"
+        if symlink_path.exists() or symlink_path.is_symlink():
+            symlink_path.unlink()
+        symlink_path.symlink_to(repo_root, target_is_directory=True)
+    # Windows equivalent (comment):
+    # for /l %i in (1,1,5) do mklink /D "%USERPROFILE%\code_copies\{repo_name}_copy_%i" "C:\path\to\repo_root"
+
+
+if __name__ == "__main__":
+    main()
+

machineconfig/scripts/python/ai/instructions/python/dev.instructions.md

@@ -0,0 +1,45 @@
+
+---
+applyTo: "**/*.py"
+---
+
+# Python Development Environment and tooling:
+* If you find that uv is not available in terminal, look for how to install it in https://github.com/astral-sh/uv
+* To initialize a new python project, use `cd $repo_root; uv init --python 3.13`
+* To create virtual env, use `cd $repo_root; uv venv`.
+* To install venv and dependency of an existing project, use `cd $repo_root; uv sync`.
+* Please run any python file using `uv run $file.py`
+* Same for tools, e.g. `un run python pytest $file_path`
+* To add a package, use `cd $repo_root; uv add <package_name>`.
+    * Please never mention versions of package, so uv will bring the latest.
+    * On this note, I have to say that I am seriously concerned about AI using very outdated coding style.
+        * Use python 3.13 syntax features.
+        * Use modern standards, e.g. Path from pathlib.
+* Never touch `pyproject.toml` manually, this file is strictly managed by `uv` tool on your behalf.
+* If you are writing a test or any temporary script for discovering or undestanding something as an intermediate step, then,
+  please keep all your temp scripts and files under ./.ai/tmp_scripts directory, its included in .gitignore and won't litter the repo.
+  Its also nice if you create a subdirectory therein to contain relevant files for the task at hand, to avoid confusion with other files from other ai agents working simulataneously on other things.
+* When you run a command in the terminal, please don't assume that it will run in the correct repo root directory. Always cd first to the repo root, or the desired directory, then run the command.
+
+# Python Coding Rules
+* Please type hint all the code. Use fully quilaified types, not just generics like dict, list, etc, rather dict[str, int], list[float], 'npt.NDarray[np.float32]', etc.
+* Use `Any` type only if absoloutely necessary.
+* Please use `# type: ignore blah blah`, to silence any warning from pyright or other linters and type checkers, but only when necessary. Otherwise, listen to them and adjust accordingly, or use cast from typing.
+* Use typeddict, dataclasses and literals when necessary to avoid blackbox str or dict[str, str] etc.
+* ALL functions / methods etc must clearly indicate the return type.
+* Do not leave dangling imports or variables unused, prefix their name with underscore if necessary to undicate they are unused.
+* Please prefer to use absolute imports, avoid relatives when possible.
+* Use triple quotes and triple double quotes f-strings for string formatting and avoid when possible all goofy escaping when interpolation.
+* If needed, opt for polars not pandas, whenever possible.
+* when finished, run a linting static analysis check against files you touched, Any fix any mistakes.
+* Please run `uv run -m pyright $file_touched` and address all issues. if `pyright is not there, first run `uv add pyright --dev`.
+* For all type checkers and linters, like mypy, pyright, pyrefly and pylint, there are config files at different levels of the repo all the way up to home directory level. You don't need to worry about them, just be mindful that they exist. The tools themselves will respect the configs therein.
+* If you want to run all linters and pycheckers agains the entire project to make sure everything is clean, I prepared a nice shell script, you can run it from the repo root as `./.scripts/lint_and_typecheck.sh`. It will produce markdown files that are you are meant to look at @ ./.linters/*.md
+
+# General Programming Ethos:
+* Make sure all the code is rigorous, no lazy stuff.
+    * For example, always avoid default values in arguments of functions. Those are evil and cause confusion. Always be explicit in parameter passing.
+    * Please never ever attempt to change code files by writing meta code to do string manipulation on files, e.g. with `sed` command with terminal. Please do change the files one by one, no matter how many there is. Don't worry about time, nor context window size, its okay, take your time and do the legwork. You can stop in the middle and we will have another LLM to help with the rest.
+* Please avoid writing README files and avoid docstring and comments in code unless absolutely necessary. Use clear naming conventions instead of documenting.
+* Always prefer to functional style of programming over OOP.
+* When passing arguments or constructing dicts or lists or tuples, avoid breaking lines too much, try to use ~ 150 characters per line before breaking to new one.

machineconfig/scripts/python/ai/mcinit.py

@@ -0,0 +1,107 @@
+
+
+from pathlib import Path
+from typing import Optional
+
+
+installations = """
+uv add --upgrade-package pylint pyright mypy pyrefly ty --dev  # linters and type checkers
+uv add --upgrade-package pytest --dev
+"""
+
+def get_repo_root(path: Path) -> Optional[Path]:
+    from git import Repo, InvalidGitRepositoryError
+    try:
+        repo = Repo(path, search_parent_directories=True)
+        root = repo.working_tree_dir
+        if root is not None:
+            return Path(root)
+    except InvalidGitRepositoryError:
+        pass
+    return None
+
+def add_ai_configs(repo_root: Path):
+    import machineconfig as mc
+    mc_root = Path(mc.__file__).parent
+
+    repo_root_resolved = get_repo_root(repo_root)
+    if repo_root_resolved is not None: repo_root = repo_root_resolved  # this means you can run the command from any subdirectory of the repo.
+
+    if repo_root.joinpath("pyproject.toml").exists() is False:
+        uv_init = input(f"{repo_root} does not seem to be a python project (no pyproject.toml found), would you like to initialize one? (y/n) ")
+        if uv_init.strip().lower() == "y":
+            command_to_run = """
+uv init --python 3.13
+uv venv
+"""
+            import subprocess
+            subprocess.run(command_to_run, shell=True, check=True)
+        else:
+            print("Terminating mcinit ...")
+            return
+
+    instructions_repository_dir = mc_root.joinpath("scripts/python/ai/instructions")
+    chatmodes_dir = mc_root.joinpath("scripts/python/ai/chatmodes")
+    prompts_dir = mc_root.joinpath("scripts/python/ai/prompts")
+    # python_rules_file = instructions_repository_dir.joinpath("python/dev.md")
+
+    # VSCODE:
+    # as per: https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions
+    # Copilot Chat on github website chat & basic guideline.
+    repo_root.joinpath(".github/chatmodes").mkdir(parents=True, exist_ok=True)
+    repo_root.joinpath(".github/prompts").mkdir(parents=True, exist_ok=True)
+    repo_root.joinpath(".github/instructions").mkdir(parents=True, exist_ok=True)
+    for a_chatmode in chatmodes_dir.iterdir():
+        repo_root.joinpath(".github/chatmodes", a_chatmode.name.split(".")[0] + ".chatmode.md").write_text(data=a_chatmode.read_text(encoding="utf-8"), encoding="utf-8")
+    for a_prompt in prompts_dir.iterdir():
+        repo_root.joinpath(".github/prompts", a_prompt.name.split(".")[0] + ".prompt.md").write_text(data=a_prompt.read_text(encoding="utf-8"), encoding="utf-8")
+    for an_instruction in instructions_repository_dir.rglob("*.md"):
+        repo_root.joinpath(".github/instructions", an_instruction.name.split(".")[0] + ".instruction.md").write_text(data=an_instruction.read_text(encoding="utf-8"), encoding="utf-8")
+    tmp = repo_root.joinpath(".github/copilot-instructions.md")
+
+    generic_instructions = instructions_repository_dir.joinpath("python/dev.instructions.md")
+    tmp.write_text(data=generic_instructions.read_text(encoding="utf-8"), encoding="utf-8")
+
+    # CURSOR, GEMINI, CLAUDE CODE, CRUSH, CLINE.
+    tmp = repo_root.joinpath(".cursor/rules/python_dev.mdc")
+    tmp.parent.mkdir(parents=True, exist_ok=True)
+    tmp.write_text(data=generic_instructions.read_text(encoding="utf-8"), encoding="utf-8")
+    tmp = repo_root.joinpath("CLAUDE.md")
+    tmp.write_text(data=generic_instructions.read_text(encoding="utf-8"), encoding="utf-8")
+    tmp = repo_root.joinpath("CRUSH.md")
+    tmp.write_text(data=generic_instructions.read_text(encoding="utf-8"), encoding="utf-8")
+
+    tmp = repo_root.joinpath("GEMINI.md")
+    tmp.write_text(data=generic_instructions.read_text(encoding="utf-8"), encoding="utf-8")
+    gemini_settings = mc_root.joinpath("scripts/python/ai/configs/.gemini/settings.json")
+    repo_root.joinpath(".gemini").mkdir(parents=True, exist_ok=True)
+    repo_root.joinpath(".gemini/settings.json").write_text(data=gemini_settings.read_text(encoding="utf-8"), encoding="utf-8")
+
+    tmp = repo_root.joinpath(".clinerules")
+    tmp.mkdir(parents=True, exist_ok=True)
+    tmp.joinpath("python_dev.md").write_text(data=generic_instructions.read_text(encoding="utf-8"), encoding="utf-8")
+
+    # OTHERS
+    scripts_dir = mc_root.joinpath("scripts/python/ai/scripts")
+    repo_root.joinpath(".scripts").mkdir(parents=True, exist_ok=True)
+    for a_script in scripts_dir.iterdir():
+        repo_root.joinpath(".scripts", a_script.name).write_text(data=a_script.read_text(encoding="utf-8"), encoding="utf-8")
+
+    dot_ai_dir = repo_root.joinpath(".ai")
+    dot_ai_dir.mkdir(parents=True, exist_ok=True)
+    dot_git_ignore_path = repo_root.joinpath(".gitignore")
+    if dot_git_ignore_path.exists():
+        dot_git_ignore_content = dot_git_ignore_path.read_text(encoding="utf-8")
+        to_add: list[str] = []
+        to_check_for: list[str] = [".links", "notebooks", ".ai", ".scripts",
+                                   "GEMINI.md", "CLAUDE.md", ".cursor", ".github"]
+        for item in to_check_for:
+            if item not in dot_git_ignore_content:
+                to_add.append(item)
+        # if "*.ipynb"
+        if len(to_add) > 0:
+            dot_git_ignore_path.write_text(data=dot_git_ignore_content + "\n" + "\n".join(to_add), encoding="utf-8")
+
+
+if __name__ == "__main__":
+    add_ai_configs(repo_root=Path.cwd())

machineconfig/scripts/python/ai/prompts/allLintersAndTypeCheckers.prompt.md

@@ -0,0 +1,5 @@
+---
+mode: agent
+---
+
+please run the following

machineconfig/scripts/python/ai/prompts/research-report-skeleton.prompt.md

@@ -0,0 +1,38 @@
+```prompt
+---
+description: 'A minimal skeleton for deep research reports.'
+---
+
+# <Title>
+
+Date: <YYYY-MM-DD>
+
+## Executive summary
+- <key point 1> [n]
+- <key point 2> [n]
+- <key point 3> [n]
+
+## Key findings
+### <Finding A>
+- Claim: <text> [n]
+- Evidence: "<quote>" [n]
+- Notes: <brief trust/limitations>
+
+### <Finding B>
+- Claim: <text> [n]
+- Evidence: "<quote>" [n]
+
+## Analysis
+- Trade-offs
+- Uncertainties
+- What to watch next
+
+## Recommendations / Direct answer
+- <concise recommendation or answer> [n]
+
+## Appendix: Sources
+[1] <Title> — <Author/Org>, <Date>. <URL>
+[2] <Title> — <Author/Org>, <Date>. <URL>
+[3] <Title> — <Author/Org>, <Date>. <URL>
+
+```

machineconfig/scripts/python/ai/scripts/lint_and_type_check.sh

@@ -0,0 +1,52 @@
+
+# gotch1: make sure we are in the right directory: repo root. Solution: check if .pyproject.toml exists, otherwise stop.
+if [ ! -f "./pyproject.toml" ]; then
+    echo "Error: pyproject.toml not found in the current directory. Please run this script from the root of a Python project."
+    exit 1
+fi
+
+echo "Running linting and type checking..."
+
+echo "Setting up environment..."
+# uv add pylint pyright mypy pyrefly ruff ty --dev  # linters and type checkers
+# uv add --dev cleanpy pylint pyright mypy pyrefly --upgrade-package cleanpy pylint pyright mypy pyrefly
+uv add --dev pyright --upgrade-package pyright
+uv add --dev pylint --upgrade-package pylint
+uv add --dev mypy --upgrade-package mypy
+uv add --dev pyrefly --upgrade-package pyrefly
+uv add --dev cleanpy --upgrade-package cleanpy
+
+
+uv add types-requests types-toml types-PyYAML types-pytz types-paramiko types-urllib3 --dev
+uv add types-mysqlclient types-SQLAlchemy --dev
+
+uv run -m cleanpy .
+uv run -m ruff clean
+# uv run -m ruff format .
+uv run -m ruff check . --fix
+uv run --with machineconfig -m machineconfig.scripts.python.ai.generate_files
+
+mkdir .linters
+
+echo "Running pyright..."
+rm ./.linters/pyright_result.md || true
+uv run pyright . > ./.linters/pyright_result.md
+echo "Results of pyright are in ./.linters/pyright_result.md"
+
+rm ./.linters/mypy_result.md || true
+uv run mypy . > ./.linters/mypy_result.md
+echo "Results of mypy are in ./.linters/mypy_result.md"
+
+rm ./.linters/pylint_result.md || true
+uv run pylint ./src/ > ./.linters/pylint_result.md
+echo "Results of pylint are in ./.linters/pylint_result.md"
+
+rm ./.linters/pylint_result.md || true
+uv run pyrefly check . > ./.linters/pyrefly_result.md
+echo "Results of pyrefly are in ./.linters/pyrefly_result.md"
+
+rm ./.linters/ruff_result.md || true
+uv run ruff check . > ./.linters/ruff_result.md
+echo "Results of ruff are in ./.linters/ruff_result.md"
+
+echo "All done! Please check the .linters directory for results."

machineconfig/scripts/python/archive/tmate_conn.py

@@ -21,19 +21,19 @@ def get_conn_string(sess_name: str) -> str:
 
 def main():
     console.print(Panel("🔌 Tmate Connection Manager", title="[bold]Welcome[/bold]"))
-    
+
     parser = argparse.ArgumentParser(description='Tmate launcher')
     parser.add_argument("sess_name", help="session name", default=random.choices(list(string.digits + string.ascii_letters), k=20))
     args = parser.parse_args()
-    
+
     console.print(f"🔍 Looking up session: {args.sess_name}")
     conn_string = get_conn_string(args.sess_name)
-    
+
     console.print(Panel(f"SSH Connection String: ssh {conn_string}", title="[bold green]SSH Connection[/bold green]"))
-    
+
     console.print("🚀 Connecting to tmate session...")
     os.system(f"ssh {conn_string}")
-    
+
     console.print("✅ Connection closed")
 
 

machineconfig/scripts/python/archive/tmate_start.py

@@ -30,13 +30,13 @@ def main():
     console.print(f"🔍 Looking up session configuration: {args.sess_name}")
     sess_name = creds['sessions_names'][args.sess_name]
     api_key = creds['keys']['api_key']
-    
+
     console.print(Panel(f"🚀 Starting tmate session: {sess_name}", title="[bold green]Session Info[/bold green]"))
-    
+
     res = f"tmate -a ~/.ssh/authorized_keys -k {api_key} -n {sess_name} -F"
     console.print("[bold cyan]Running:[/bold cyan] tmate with configured API key and session name")
     os.system(res)
-    
+
     console.print("[green]Tmate session ended[/green]")
 
 

machineconfig/scripts/python/choose_wezterm_theme.py

@@ -51,13 +51,13 @@ def main2():
 
 def set_theme(theme: str):
     print(f"🔄 Setting WezTerm theme to: {theme}")
-    txt_lines = PathExtended("~/.config/wezterm/wezterm.lua").expanduser().read_text().splitlines()
+    txt_lines = PathExtended("~/.config/wezterm/wezterm.lua").expanduser().read_text(encoding="utf-8").splitlines()
     res_lines = []
     for line in txt_lines:
         if 'config.color_scheme = ' in line:
             res_lines.append(f"config.color_scheme = '{theme}'")
         else: res_lines.append(line)
-    PathExtended("~/.config/wezterm/wezterm.lua").expanduser().write_text('\n'.join(res_lines))
+    PathExtended("~/.config/wezterm/wezterm.lua").expanduser().write_text('\n'.join(res_lines), encoding="utf-8")
     time.sleep(0.1)
     print("💾 Configuration saved")