myg 0.1.0__tar.gz

myg-0.1.0/.gitignore

@@ -0,0 +1,170 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# myg tooling
+.ruff_cache/
+basedpyright/
+node_modules/
+.next/
+dist/
+*.rej
+*.orig
+.devin/

myg-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.5
+Name: myg
+Version: 0.1.0
+Summary: myg — your guy for agent apps. Scaffold a full CopilotKit + LangGraph agent app in one command.
+Project-URL: Homepage, https://github.com/control-shift-escape-co/myguy
+Project-URL: Documentation, https://control-shift-escape-co.github.io/myguy
+Project-URL: Issues, https://github.com/control-shift-escape-co/myguy/issues
+Author: Abhi Avadhani
+License: MIT
+Keywords: agents,cli,copilotkit,langgraph,scaffold
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: cookiecutter>=2.6
+Requires-Dist: cruft>=2.15
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.8
+Requires-Dist: questionary>=2.0
+Requires-Dist: rich>=13.7
+Requires-Dist: tomli-w>=1.0
+Requires-Dist: typer>=0.15
+Provides-Extra: agent
+Requires-Dist: claude-agent-sdk>=0.1.0; extra == 'agent'
+Description-Content-Type: text/markdown
+
+# myg
+
+Your guy for agent apps.
+
+`myg init` scaffolds a production-shaped single-page agent app — Next.js + CopilotKit frontend, FastAPI + LangGraph backend (AG-UI), Postgres thread persistence, optional Kong AI Gateway — ready for `docker compose up` or a Railway deploy.
+
+See the main repo for docs, contributing, and the full story: <https://github.com/control-shift-escape-co/myguy>
+
+## Install
+
+```bash
+uvx myg init          # recommended — no install
+pipx run myg init     # pipx
+pip install myg       # classic
+npm create myg        # npm folks — delegates to uvx/pipx
+```
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `myg init` | Wizard → renders the template → optional instant Neon DB → next steps |
+| `myg configure` | Edit `myg.toml` and re-render template files (`get`/`set`/`--ai`) |
+| `myg prompt "…"` | Agentic edits to an existing app (Claude Agent SDK, or `--backend devin`) |
+| `myg dev` | `docker compose up` — or runs both apps natively |
+| `myg db` | Provisions an instant Neon Postgres + prints the claim URL |
+| `myg deploy` | Deploys to Railway (CLI detected) or prints the guided steps |
+| `myg doctor` | Checks docker/node/uv/keys/ports |
+| `myg update` | Pulls template upgrades into your project (cruft) |
+| `myg templates` | Lists built-in + community templates |
+
+MIT licensed.

myg-0.1.0/README.md

@@ -0,0 +1,32 @@
+# myg
+
+Your guy for agent apps.
+
+`myg init` scaffolds a production-shaped single-page agent app — Next.js + CopilotKit frontend, FastAPI + LangGraph backend (AG-UI), Postgres thread persistence, optional Kong AI Gateway — ready for `docker compose up` or a Railway deploy.
+
+See the main repo for docs, contributing, and the full story: <https://github.com/control-shift-escape-co/myguy>
+
+## Install
+
+```bash
+uvx myg init          # recommended — no install
+pipx run myg init     # pipx
+pip install myg       # classic
+npm create myg        # npm folks — delegates to uvx/pipx
+```
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `myg init` | Wizard → renders the template → optional instant Neon DB → next steps |
+| `myg configure` | Edit `myg.toml` and re-render template files (`get`/`set`/`--ai`) |
+| `myg prompt "…"` | Agentic edits to an existing app (Claude Agent SDK, or `--backend devin`) |
+| `myg dev` | `docker compose up` — or runs both apps natively |
+| `myg db` | Provisions an instant Neon Postgres + prints the claim URL |
+| `myg deploy` | Deploys to Railway (CLI detected) or prints the guided steps |
+| `myg doctor` | Checks docker/node/uv/keys/ports |
+| `myg update` | Pulls template upgrades into your project (cruft) |
+| `myg templates` | Lists built-in + community templates |
+
+MIT licensed.

myg-0.1.0/myg/__init__.py

@@ -0,0 +1,3 @@
+"""myg — your guy for agent apps."""
+
+__version__ = "0.1.0"

myg-0.1.0/myg/cli.py

@@ -0,0 +1,59 @@
+"""myg CLI — your guy for agent apps."""
+
+from __future__ import annotations
+
+import sys
+
+# Windows consoles default to cp1252 — unicode output must not depend on locale.
+for stream in (sys.stdout, sys.stderr):
+    if getattr(stream, "encoding", "") and stream.encoding.lower() not in ("utf-8", "utf8"):
+        stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[union-attr]
+
+import typer  # noqa: E402
+
+from myg import __version__  # noqa: E402
+from myg.commands import (  # noqa: E402
+    configure,
+    db,
+    deploy,
+    dev,
+    doctor,
+    eject,
+    init,
+    prompt,
+    templates,
+    update,
+)
+
+app = typer.Typer(
+    name="myg",
+    help="Your guy for agent apps — scaffold a CopilotKit + LangGraph agent in one command.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    add_completion=False,
+)
+
+app.command()(init.init)
+app.command()(configure.configure)
+app.command()(db.db)
+app.command("db-claim")(db.claim_url)
+app.command()(prompt.prompt)
+app.command()(dev.dev)
+app.command()(deploy.deploy)
+app.command()(doctor.doctor)
+app.command()(update.update)
+app.command()(eject.eject)
+app.command()(templates.templates)
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    version: bool = typer.Option(False, "--version", "-V", help="Print version"),
+) -> None:
+    if version:
+        typer.echo(f"myg {__version__}")
+        raise typer.Exit()
+
+
+if __name__ == "__main__":
+    app()

myg-0.1.0/myg/commands/configure.py

@@ -0,0 +1,136 @@
+"""`myg configure` — edit myg.toml values and re-render template files in place."""
+
+from __future__ import annotations
+
+import subprocess
+import tomllib
+from pathlib import Path
+from typing import Annotated
+
+import questionary
+import tomli_w
+import typer
+from rich.console import Console
+
+from myg import render, wizard
+from myg.context import MygContext, find_project_root
+
+console = Console()
+
+_FLAT_KEYS = {
+    "name": "project_name",
+    "pattern": "agent_pattern",
+    "model": "model",
+    "prompt": "system_prompt",
+    "system_prompt": "system_prompt",
+    "style": "ui_style",
+    "db": "db",
+    "gateway": "gateway",
+}
+_SECTION_KEYS = {
+    "agent.pattern": "agent_pattern",
+    "agent.model": "model",
+    "agent.system_prompt": "system_prompt",
+    "ui.style": "ui_style",
+    "ui.primary_color": "primary_color",
+    "ui.secondary_color": "secondary_color",
+    "db.provider": "db",
+    "gateway.mode": "gateway",
+    "project.name": "project_name",
+    "project.description": "description",
+}
+
+
+def configure(
+    set_: Annotated[
+        list[str] | None,
+        typer.Option("--set", "-s", help="key=value, e.g. agent.pattern=supervisor"),
+    ] = None,
+    get: Annotated[str | None, typer.Option("--get", "-g", help="Print a config value")] = None,
+    ai: Annotated[bool, typer.Option("--ai", help="Reconfigure by chatting with an LLM")] = False,
+    github_style: Annotated[
+        str | None, typer.Option("--github-style", help="Extract UI style from a GitHub repo")
+    ] = None,
+    project_dir: Annotated[Path | None, typer.Option("--dir", "-d")] = None,
+    no_render: Annotated[bool, typer.Option("--no-render", help="Only update myg.toml")] = False,
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation prompts")] = False,
+) -> None:
+    """Change config on an existing generated app."""
+    root = project_dir or find_project_root()
+    toml_path = root / "myg.toml"
+    ctx = MygContext.from_myg_toml(toml_path)
+
+    if get:
+        key = _SECTION_KEYS.get(get, _FLAT_KEYS.get(get, get))
+        console.print(getattr(ctx, key))
+        raise typer.Exit()
+
+    changed = False
+    if github_style:
+        with console.status(f"Extracting style from {github_style}…"):
+            for key, value in wizard.style_from_github(github_style).items():
+                setattr(ctx, key, value)
+        changed = True
+    for assignment in set_ or []:
+        key, _, value = assignment.partition("=")
+        attr = _SECTION_KEYS.get(key.strip(), _FLAT_KEYS.get(key.strip(), key.strip()))
+        if not hasattr(ctx, attr):
+            console.print(f"[red]Unknown config key: {key}[/red]")
+            raise typer.Exit(2)
+        setattr(ctx, attr, value.strip())
+        changed = True
+    if ai:
+        ctx = wizard.run_assist(ctx)
+        changed = True
+    if not changed:
+        console.print("Nothing to do — pass --set, --ai or --github-style.")
+        raise typer.Exit()
+
+    if not no_render and _git_dirty(root) and not (yes or _confirm_overwrite()):
+        console.print("Aborted — nothing written.")
+        raise typer.Abort()
+
+    ctx.write_myg_toml(toml_path)
+    console.print("[green]✓[/green] myg.toml updated")
+    if no_render:
+        return
+    with console.status("Re-rendering template files…"):
+        render.rerender(root, ctx.cookiecutter_context())
+    console.print("[green]✓[/green] Template files re-rendered")
+
+
+def _confirm_overwrite() -> bool:
+    try:
+        return bool(
+            questionary.confirm(
+                "Uncommitted changes detected — re-render may overwrite template files. Continue?",
+                default=False,
+            ).ask()
+        )
+    except Exception:
+        console.print(
+            "[yellow]Non-interactive shell — pass --yes to re-render over a dirty tree.[/yellow]"
+        )
+        return False
+
+
+def _git_dirty(root: Path) -> bool:
+    try:
+        out = subprocess.run(
+            ["git", "status", "--porcelain"], cwd=root, capture_output=True, text=True, timeout=10
+        )
+        return bool(out.stdout.strip())
+    except Exception:
+        return False
+
+
+def read_db_section(root: Path) -> dict:
+    data = tomllib.loads((root / "myg.toml").read_text(encoding="utf-8"))
+    return data.get("db", {})
+
+
+def update_db_section(root: Path, values: dict) -> None:
+    path = root / "myg.toml"
+    data = tomllib.loads(path.read_text(encoding="utf-8"))
+    data.setdefault("db", {}).update(values)
+    path.write_text(tomli_w.dumps(data), encoding="utf-8")

myg-0.1.0/myg/commands/db.py

@@ -0,0 +1,64 @@
+"""`myg db` — instant Neon Postgres for a generated project."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from myg import neon
+from myg.commands.configure import read_db_section, update_db_section
+from myg.context import find_project_root
+
+console = Console()
+
+
+def db(
+    db_id: Annotated[
+        str | None, typer.Option("--status", help="Check status of a provisioned DB id")
+    ] = None,
+    project_dir: Annotated[Path | None, typer.Option("--dir", "-d")] = None,
+) -> None:
+    """Provision an instant Neon Postgres (no account needed) and wire it into .env."""
+    if db_id:
+        console.print_json(data=neon.status(db_id))
+        raise typer.Exit()
+
+    root = project_dir or find_project_root()
+    with console.status("Provisioning instant Neon Postgres…"):
+        ndb = neon.provision(ref=root.name)
+    env_file = neon.write_database_url(root, ndb.connection_string)
+    update_db_section(
+        root,
+        {
+            "provider": "neon",
+            "project_id": ndb.id,
+            "claim_url": ndb.claim_url,
+            "expires_at": ndb.expires_at,
+        },
+    )
+    console.print(f"[green]✓[/green] DATABASE_URL written to {env_file}")
+    console.print(
+        Panel(
+            f"[bold]This DB expires in 72h unless claimed.[/bold]\n\n"
+            "Claim it (free Neon account, no card):\n"
+            f"[link={ndb.claim_url}]{ndb.claim_url}[/link]\n\n"
+            f"DB id: {ndb.id}  (check later: myg db --status {ndb.id})",
+            title="⚡ instant postgres",
+            border_style="yellow",
+        )
+    )
+
+
+def claim_url(project_dir: Annotated[Path | None, typer.Option("--dir", "-d")] = None) -> None:
+    """Reprint the claim URL stored in myg.toml."""
+    root = project_dir or find_project_root()
+    info = read_db_section(root)
+    url = info.get("claim_url")
+    if not url:
+        console.print("[yellow]No claim URL recorded — run `myg db` first.[/yellow]")
+        raise typer.Exit(1)
+    console.print(url)

myg-0.1.0/myg/commands/deploy.py

@@ -0,0 +1,38 @@
+"""`myg deploy` — ship the generated app to Railway."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from myg.context import find_project_root
+
+console = Console()
+
+
+def deploy(project_dir: Annotated[Path | None, typer.Option("--dir", "-d")] = None) -> None:
+    """Deploy to Railway — uses the railway CLI if installed, else prints the guide."""
+    root = (project_dir or find_project_root()).resolve()
+    if shutil.which("railway"):
+        console.print("Handing off to [bold]railway up[/bold] — follow its prompts.")
+        raise typer.Exit(subprocess.run(["railway", "up"], cwd=root).returncode)
+    console.print(
+        Panel(
+            "Railway CLI not found — no problem, the dashboard flow is 2 minutes:\n\n"
+            "1. Push this project to GitHub\n"
+            "2. railway.app → New Project → Deploy from GitHub repo\n"
+            "3. Add TWO services with root dirs: "
+            "[bold]apps/web[/bold] and [bold]apps/agent[/bold]\n"
+            "4. Add a Postgres plugin (or reuse Neon) → set DATABASE_URL on agent\n"
+            "5. Set env vars on each service (see .env.example + RAILWAY.md)\n\n"
+            "Or: npm i -g @railway/cli && railway login && myg deploy",
+            title="deploy to railway",
+            border_style="blue",
+        )
+    )

myg-0.1.0/myg/commands/dev.py

@@ -0,0 +1,79 @@
+"""`myg dev` — run the generated app: docker compose when available, else natively."""
+
+from __future__ import annotations
+
+import shutil
+import signal
+import subprocess
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from myg.context import find_project_root
+
+console = Console()
+
+
+def dev(
+    detach: Annotated[bool, typer.Option("-d", "--detach", help="Compose in background")] = False,
+    project_dir: Annotated[Path | None, typer.Option("--dir", "-d")] = None,
+) -> None:
+    """Start the generated app locally."""
+    root = (project_dir or find_project_root()).resolve()
+    if shutil.which("docker") and _compose_up(root, detach):
+        return
+    console.print(
+        "[yellow]Docker not found — starting apps natively (needs uv + node/pnpm).[/yellow]"
+    )
+    _native(root)
+
+
+def _compose_up(root: Path, detach: bool) -> bool:
+    cmd = ["docker", "compose", "up"] + (["-d"] if detach else [])
+    try:
+        subprocess.run(cmd, cwd=root, check=True)
+        if detach:
+            console.print("[green]✓[/green] Running — http://localhost:3000")
+        return True
+    except subprocess.CalledProcessError as exc:
+        console.print(f"[red]docker compose failed ({exc.returncode})[/red]")
+        raise typer.Exit(exc.returncode or 1) from None
+
+
+def _native(root: Path) -> None:
+    uv, pnpm, npm = shutil.which("uv"), shutil.which("pnpm"), shutil.which("npm")
+    if not uv or not (pnpm or npm):
+        console.print(
+            "[red]Need `uv` and `pnpm`/`npm` for native dev, or Docker for compose.[/red]"
+        )
+        raise typer.Exit(1)
+    agent = subprocess.Popen(
+        [
+            uv,
+            "run",
+            "--directory",
+            str(root / "apps/agent"),
+            "uvicorn",
+            "agent.main:app",
+            "--host",
+            "127.0.0.1",
+            "--port",
+            "8123",
+            "--reload",
+        ],
+        cwd=root,
+    )
+    pm = pnpm or npm
+    web = subprocess.Popen([pm, "--dir", str(root / "apps/web"), "dev"], cwd=root, shell=True)
+    console.print("agent → http://127.0.0.1:8123  ·  web → http://localhost:3000  (Ctrl+C to stop)")
+    try:
+        web.wait()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        for proc in (web, agent):
+            proc.send_signal(signal.SIGINT)
+        web.wait(timeout=10)
+        agent.wait(timeout=10)