haywire-studio 0.0.2__tar.gz

haywire_studio-0.0.2/.gitignore

@@ -0,0 +1,205 @@
+# 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
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.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/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# 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/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the enitre vscode folder
+.vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+.DS_Store
+saves/*.*
+
+# Dev-mode graphs (local testing only, not part of the repo)
+graphs/*.json
+# MkDocs build output
+site/
+
+# Local git worktrees (claude-code workflow)
+.worktrees/

haywire_studio-0.0.2/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: haywire-studio
+Version: 0.0.2
+Summary: Haywire Node Editor Application
+Author: Haywire Team
+License: MIT
+Keywords: application,haywire,node-editor,visual-programming
+Requires-Python: >=3.10
+Requires-Dist: haywire-core~=0.0.2

haywire_studio-0.0.2/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "haywire-studio"
+version = "0.0.2"
+description = "Haywire Node Editor Application"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "Haywire Team"}
+]
+keywords = ["haywire", "node-editor", "visual-programming", "application"]
+
+dependencies = [
+    "haywire-core~=0.0.2",
+]
+
+[project.scripts]
+haywire = "haywire_studio:main"
+
+[tool.uv.sources]
+haywire-core = { workspace = true }
+haybale-core = { workspace = true }
+haybale-studio = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/haywire_studio"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/haywire_studio/",
+]
+
+[tool.mypy]
+python_version = "3.10"
+
+[[tool.mypy.overrides]]
+module = ["toml", "haywire.*"]
+ignore_missing_imports = true

haywire_studio-0.0.2/src/haywire_studio/__init__.py

@@ -0,0 +1,3 @@
+from .app import main
+
+__all__ = ["main"]

haywire_studio-0.0.2/src/haywire_studio/__main__.py

@@ -0,0 +1,3 @@
+from .app import main
+
+main()

haywire_studio-0.0.2/src/haywire_studio/app.py

@@ -0,0 +1,406 @@
+"""
+HaywireApp — main application entry point.
+
+Manages shared services (libraries) and per-session UI shells.
+Each browser connection gets its own Session and AppShell; all sessions share
+the same library registry.
+
+Execution is per-graph: each GraphEntry owns its own Interpreter,
+started/stopped via entry.start_execution() / entry.stop_execution().
+
+Haystack lifecycle (open graphs, auto-load on startup) is handled by
+HaystackState, accessed via ctx.app_data[HaystackState].
+"""
+
+import os
+import logging
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from nicegui import ui, app
+
+# Core imports
+from haywire.core.graph.editor import Editor
+from haywire.core.graph.base import BaseGraph
+from haywire.core.undo.config import DEVELOPMENT_CONFIG
+from haywire.core.di.config import create_library_system_service
+from haywire.core.di.context import set_workspace_root
+from haywire.core.host import HostStore
+
+# UI imports
+from haywire.ui.console_bridge import get_bridge
+
+if TYPE_CHECKING:
+    from haywire.ui.app.shell import AppShell
+
+logger = logging.getLogger(__name__)
+
+
+class HaywireApp:
+    """Main Haywire application.
+
+    Constructs shared services (library system, session manager, workspace manager)
+    and registers per-session UI shells.  Graph/haystack lifecycle is delegated
+    to HaystackState (accessed via ctx.app_data[HaystackState]).
+    """
+
+    def __init__(self, workspace_root: str | None = None):
+        self.workspace_root = workspace_root or os.getcwd()
+        set_workspace_root(self.workspace_root)
+        print(f"Haywire workspace: {self.workspace_root}")
+        print("Setting up Haywire application...")
+
+        self.setup_library_system()
+        self.setup_shared_services()
+
+        self._is_shutting_down = False
+        self._shells: dict[str, "AppShell"] = {}
+        # Maps NiceGUI client.id → haywire session_id so on_disconnect can
+        # resolve which session to tear down without monkey-patching the
+        # Client object.
+        self._client_to_session: dict[str, str] = {}
+
+        app.on_disconnect(self.on_disconnect)
+        app.on_shutdown(self.on_app_shutdown)
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    def on_app_shutdown(self):
+        """Clean up all resources on application shutdown."""
+        if self._is_shutting_down:
+            return
+        self._is_shutting_down = True
+        print("Application shutdown initiated...")
+
+        # 1. Clean up all sessions
+        print(f"  Cleaning up {self.session_manager.session_count} sessions...")
+        self.session_manager.cleanup_all()
+
+        # 2. Clean up console bridge
+        try:
+            bridge = get_bridge()
+            bridge.log_elements.clear()
+            bridge.clear_history()
+        except Exception as e:
+            print(f"  Error cleaning up console bridge: {e}")
+
+        # 3. Cleanup library system
+        try:
+            if hasattr(self.library_service, "cleanup"):
+                self.library_service.cleanup()
+        except Exception as e:
+            print(f"  Error cleaning up library system: {e}")
+
+        print("Application shutdown complete")
+
+    def on_disconnect(self, client):
+        """Handle client disconnect.
+
+        Shell-upstream model (Q7A): tear down the AppShell first, then
+        detach the session. SessionManager.remove_session does only state
+        cleanup now — UI cleanup is the shell's responsibility.
+        """
+        if self._is_shutting_down:
+            return
+        session_id = self._client_to_session.pop(client.id, None)
+        if not session_id:
+            return
+        print(f"Client disconnected, cleaning up session {session_id[:8]}")
+
+        shell = self._shells.pop(session_id, None)
+        if shell is not None:
+            try:
+                shell.cleanup()
+            except Exception as e:
+                print(f"  Error cleaning up shell for session {session_id[:8]}: {e}")
+
+        self.session_manager.remove_session(session_id)
+
+    # ------------------------------------------------------------------
+    # Shared services setup
+    # ------------------------------------------------------------------
+
+    def setup_library_system(self):
+        """Initialize the library system service (shared across sessions)."""
+        self.undo_config = DEVELOPMENT_CONFIG
+
+        library_paths = []
+        workspace_libs = os.path.join(self.workspace_root, "barn")
+        if os.path.isdir(workspace_libs):
+            library_paths.append(workspace_libs)
+
+        # HostStore — engine bootstrap persistence the LibraryRegistry uses
+        # to remember which libraries the user has disabled. File-backed
+        # because this is a real workspace; an embedded / headless host
+        # could pass HostStore.in_memory() or omit the argument entirely.
+        host_store = HostStore(Path(self.workspace_root) / ".haywire" / "host.toml")
+
+        # create_library_system_service.initialize() publishes both the
+        # service (via set_library_system) and the injector (via
+        # set_global_injector) BEFORE the enable phase, so AppState.on_enable
+        # hooks can resolve framework services from the ambient context.
+        self.library_service = create_library_system_service(
+            workspace_root=self.workspace_root,
+            library_paths=library_paths if library_paths else None,
+            enable_file_watching=True,
+            watch_settings=False,
+            host_store=host_store,
+        )
+        print("Library system initialized.")
+
+    def setup_shared_services(self):
+        """Setup services shared across all sessions."""
+        from haywire.core.state import LibraryStateContainer
+        from haywire.core.session.session_manager import SessionManager
+
+        # Registries and factories (from DI)
+        self.node_registry = self.library_service.get_node_registry()
+        self.node_factory = self.library_service.get_node_factory()
+        self.skin_factory = self.library_service.get_skin_factory()
+        self.adapter_factory = self.library_service.get_adapter_factory()
+        self.panel_registry = self.library_service.get_panel_registry()
+        self.library_state_container = self.library_service.injector.get(LibraryStateContainer)
+
+        # SessionManager comes from the DI container; provide_session_manager()
+        # also publishes it via set_session_manager() into the ambient context.
+        self.session_manager = self.library_service.injector.get(SessionManager)
+
+        from haywire.core.session.workspace.manager import WorkspaceManager
+
+        self.workspace_manager = WorkspaceManager(project_path=Path(self.workspace_root))
+
+        # LibraryManager is now published by haybale-marketplace as
+        # LibraryManagerState. Persisted disabled-state is applied by the
+        # library system during create_library_system_service. See ADR-0001.
+
+        print("Shared services configured successfully.")
+
+    # ------------------------------------------------------------------
+    # Graph factory
+    # ------------------------------------------------------------------
+
+    def _graph_factory(self, graph_id: str, name: str) -> tuple[BaseGraph, Editor]:
+        """Standard factory producing (BaseGraph, Editor) pairs."""
+        g = BaseGraph(graph_id, name)
+        e = Editor(g, self.node_factory, undo_config=self.undo_config)
+        return g, e
+
+    def save_workspace(self, shell=None, active_graph_path=None) -> None:
+        """Save workspace snapshot atomically.
+
+        Args:
+            shell: The active AppShell. When provided, collects the current slot
+                snapshot from it. When None, re-saves the existing snapshot.
+            active_graph_path: Path of the currently active graph (unused here;
+                retained for call-site compatibility — callers that need to persist
+                haystack state call persistence.dump_haystack before this).
+        """
+        snapshot = self.workspace_manager.snapshot.copy()
+        if shell is not None:
+            slot_data = shell.collect_snapshot()
+            snapshot.update(slot_data)
+        self.workspace_manager.save(snapshot)
+
+    # ------------------------------------------------------------------
+    # UI creation
+    # ------------------------------------------------------------------
+
+    def setup_services(self):
+        """Stub kept for compatibility."""
+        pass
+
+    def create_ui(self):
+        """Register NiceGUI page routes."""
+
+        @ui.page("/", title="Haywire")
+        def main_page():
+            from haywire.ui.app.shell import AppShell
+            from haywire.ui.editor.registry import EditorTypeRegistry
+            from nicegui import context
+
+            print(f"Creating UI for session: {context.client.id[:8]}")
+
+            editor_registry = self.library_service.injector.get(EditorTypeRegistry)
+
+            haywire_session = self.session_manager.create_session(
+                project_state=self,
+                workspace_manager=self.workspace_manager,
+            )
+
+            # Map this client to its session so on_disconnect can resolve
+            # which session to tear down.
+            self._client_to_session[context.client.id] = haywire_session.session_id
+
+            # Set studio theme defaults on context before rendering
+            haywire_session.context.active_workbench_theme_key = "core:theme:workbench:haywire-dark"
+            haywire_session.context.active_node_theme_key = "core:theme:node:default"
+
+            app_shell = AppShell(haywire_session, editor_registry=editor_registry)
+            self._shells[haywire_session.session_id] = app_shell
+            app_shell.render()
+
+    # ------------------------------------------------------------------
+    # Run / cleanup
+    # ------------------------------------------------------------------
+
+    def cleanup(self):
+        """Manual cleanup fallback."""
+        self.on_app_shutdown()
+
+    def run(self):
+        """Run the application."""
+        print("Starting Haywire...")
+        self.create_ui()
+        try:
+            ui.run(
+                port=8082,
+                show=True,
+                title="Haywire",
+                reload=False,
+            )
+        except KeyboardInterrupt:
+            print("\nKeyboard interrupt received")
+        finally:
+            if not self._is_shutting_down:
+                self.cleanup()
+
+
+# ---------------------------------------------------------------------------
+# Entry points
+# ---------------------------------------------------------------------------
+
+
+def run_app():
+    """Launch the Haywire application."""
+    # logging.getLogger("haywire.ui.editor.graph_canvas_manager").setLevel(logging.DEBUG)
+    # use DebugSettings.log_ui instead
+    app_instance = HaywireApp()
+    app.on_shutdown(app_instance.cleanup)
+    app_instance.run()
+
+
+def main():
+    """Main entry point — routes CLI subcommands."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="haywire",
+        description="Haywire visual programming system",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    init_parser = subparsers.add_parser("init", help="Create a new haywire project")
+    init_parser.add_argument("name", help="Project name")
+    init_parser.add_argument(
+        "--no-sync",
+        action="store_true",
+        help="Skip running uv sync after scaffolding",
+    )
+    init_parser.add_argument(
+        "--dev",
+        action="store_true",
+        help="Use editable local sources from this dev repo instead of PyPI",
+    )
+
+    share_parser = subparsers.add_parser(
+        "share", help="Generate a marketplace.toml snippet for sharing a library"
+    )
+    share_parser.add_argument(
+        "library_path",
+        nargs="?",
+        default=None,
+        help="Path to the library directory (e.g. libs/haybale-myproject). "
+        "Auto-detected if libs/ contains exactly one library.",
+    )
+    share_parser.add_argument(
+        "--save",
+        action="store_true",
+        help="Aggregate every barn/* library into <repo-root>/marketstall.toml.",
+    )
+    share_parser.add_argument(
+        "--strict",
+        action="store_true",
+        help="Exit non-zero if any library has dependency drift (declared vs. imported).",
+    )
+    share_parser.add_argument(
+        "--fix",
+        action="store_true",
+        help="Auto-correct dependency drift by updating pyproject.toml and the "
+        "@library decorator before sharing.",
+    )
+    share_parser.add_argument(
+        "--ref",
+        type=str,
+        default=None,
+        help="Specific ref (branch, tag, or SHA) to encode in the share URL.",
+    )
+    share_parser.add_argument(
+        "--tag",
+        type=str,
+        default=None,
+        help="Tag to encode in the share URL. Use 'latest' to resolve to the most recent tag reachable from HEAD.",  # noqa: E501
+    )
+    share_parser.add_argument(
+        "--no-update-readme",
+        dest="update_readme",
+        action="store_false",
+        default=True,
+        help="Don't rewrite the marketstall:share-url marker block in any README.",
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "init":
+        from .init import init_project, _get_dev_repo_root
+
+        dev_repo = _get_dev_repo_root() if args.dev else None
+        init_project(args.name, auto_sync=not args.no_sync, dev_repo=dev_repo)
+    elif args.command == "share":
+        if args.save:
+            from pathlib import Path
+
+            from .share import DriftError, NoBarnError, share_save_repo
+
+            try:
+                result = share_save_repo(
+                    Path.cwd(),
+                    strict=args.strict,
+                    fix=args.fix,
+                    ref=args.ref,
+                    tag=args.tag,
+                    update_readme=args.update_readme,
+                )
+                print(f"✓ Wrote {result.out_path}")
+                if result.share_url is not None:
+                    print(f"✓ Share this URL:\n  {result.share_url}")
+                elif result.warning is not None:
+                    print(f"⚠ {result.warning}")
+            except NoBarnError as exc:
+                print(f"Error: {exc}")
+                sys.exit(1)
+            except DriftError as exc:
+                print(str(exc), file=sys.stderr)
+                sys.exit(1)
+        elif args.library_path is not None:
+            from .share import share_library
+
+            share_library(args.library_path, strict=args.strict, fix=args.fix)
+        else:
+            from pathlib import Path
+
+            from .share import derive_share_url_only
+
+            result = derive_share_url_only(Path.cwd(), ref=args.ref, tag=args.tag)
+            if result.share_url is not None:
+                print(f"✓ Share this URL:\n  {result.share_url}")
+            elif result.warning is not None:
+                print(f"⚠ {result.warning}")
+    else:
+        run_app()
+
+
+if __name__ in {"__main__", "__mp_main__"}:
+    main()