snodo 0.1.0__py3-none-any.whl

snodo/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

snodo/__main__.py

@@ -0,0 +1,6 @@
+"""Allow python -m snodo invocation (e.g. sys.executable -m snodo)."""
+
+from snodo.cli.main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

snodo/agents/adapter.py

@@ -0,0 +1,18 @@
+"""Agent adapter layer - backward compatibility re-exports.
+
+FILE: snodo/agents/adapter.py
+
+All adapter classes now live in snodo.coders.
+This module re-exports them for backward compatibility.
+"""
+
+from snodo.coders import (  # noqa: F401
+    LiteLLMAdapter,
+    MockAdapter,
+    BasicCoderAdapter,
+    MockCoderAdapter,
+    create_coder,
+    AdapterError,
+    LLMCallError,
+    ParseError,
+)

snodo/cli/commands/__init__.py

@@ -0,0 +1,79 @@
+"""Snodo CLI command modules.
+
+Shared utilities used across command modules live here.
+"""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+from snodo.compiler.models import Protocol
+from snodo.compiler.verifier import verify_protocol, ProtocolWellFormednessError
+
+
+_TEMPLATES_DIR = Path(__file__).parent.parent.parent / "protocols" / "templates"
+
+
+def _load_template(name: str) -> str:
+    """Load a protocol template YAML file from disk.
+
+    Templates live as standalone YAML files in snodo/protocols/templates/.
+    This replaces the previous approach of embedding templates as Python
+    triple-quoted string constants, making protocols reviewable documents
+    and editable without code changes (Paper Section 6.4).
+
+    Args:
+        name: Template name without extension (e.g., "solo", "team", "2+n")
+
+    Returns:
+        Raw YAML content as a string
+    """
+    return (_TEMPLATES_DIR / f"{name}.yml").read_text()
+
+
+# Default protocol template
+DEFAULT_PROTOCOL = _load_template("team")
+
+# Alias for clarity
+TEAM_PROTOCOL = DEFAULT_PROTOCOL
+
+SOLO_PROTOCOL = _load_template("solo")
+
+TWO_PLUS_N_PROTOCOL = _load_template("2+n")
+
+PROTOCOL_TEMPLATES = {"solo": SOLO_PROTOCOL, "team": TEAM_PROTOCOL, "2+n": TWO_PLUS_N_PROTOCOL}
+
+
+def load_protocol(protocol_path: Path) -> Optional[Protocol]:
+    """Load, parse, and verify protocol from YAML file.
+
+    Runs all WF1-WF5 well-formedness checks after parsing.
+    """
+    try:
+        with open(protocol_path) as f:
+            data = yaml.safe_load(f)
+
+        protocol = Protocol(**data)
+
+        # WF1-WF5 verification (Section 4.4)
+        result = verify_protocol(protocol)
+        if not result.passed:
+            raise ProtocolWellFormednessError(result.errors)
+
+        return protocol
+
+    except FileNotFoundError:
+        print(f"Error: Protocol file not found: {protocol_path}", file=sys.stderr)
+        print("Run 'snodo init' to create default protocol.", file=sys.stderr)
+        return None
+    except yaml.YAMLError as e:
+        print(f"Error: Invalid YAML in protocol file: {e}", file=sys.stderr)
+        return None
+    except ProtocolWellFormednessError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return None
+    except Exception as e:
+        print(f"Error: Failed to parse protocol: {e}", file=sys.stderr)
+        return None

snodo/cli/commands/agent_cmd.py

@@ -0,0 +1,101 @@
+"""Agent command - Manage agent memory and threads.
+
+FILE: snodo/cli/commands/agent_cmd.py (Task 5.2)
+"""
+
+import sys
+import time
+
+
+def agent_command(args) -> int:
+    """Manage agent memory and threads."""
+    from snodo.infrastructure.memory import AgentMemoryManager, MemoryError
+
+    try:
+        manager = AgentMemoryManager()
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    action = args.agent_action
+    try:
+        if action == "list":
+            return _agent_list(manager)
+        elif action == "memory":
+            return _agent_memory(manager, args.agent_id)
+        elif action == "reset":
+            return _agent_reset(manager, args.agent_id)
+        elif action == "rotate":
+            return _agent_rotate(manager, args.agent_id)
+        else:
+            print("Unknown agent action. Use: list, memory, reset, rotate", file=sys.stderr)
+            return 1
+    except MemoryError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+def _agent_list(manager) -> int:
+    """List all registered agents."""
+    agents = manager.list_agents()
+    if not agents:
+        print("No agents found.")
+        print("Agents are created automatically when you run tasks.")
+        return 0
+
+    print(f"{'ID':<30} {'Thread':<12} {'Tasks':<8} {'Last Used'}")
+    print("-" * 72)
+    for agent in agents:
+        thread_short = agent["thread_id"][:8] + "..."
+        task_count = agent.get("task_count", 0)
+        last_used = _format_time(agent.get("last_used_at"))
+        print(f"{agent['id']:<30} {thread_short:<12} {task_count:<8} {last_used}")
+    return 0
+
+
+def _agent_memory(manager, agent_id: str) -> int:
+    """Show memory summary for an agent."""
+    agent = manager.get_agent(agent_id)
+    if agent is None:
+        print(f"Error: Agent not found: {agent_id}", file=sys.stderr)
+        return 1
+
+    summary = manager.get_memory_summary(agent_id)
+
+    print(f"Agent: {agent_id}")
+    print(f"Thread ID: {agent['thread_id']}")
+    print(f"Project: {agent.get('project', 'N/A')}")
+    print(f"Mode: {agent.get('mode', 'N/A')}")
+    print(f"Tasks completed: {agent.get('task_count', 0)}")
+    print(f"Created: {_format_time(agent.get('created_at'))}")
+    print(f"Last used: {_format_time(agent.get('last_used_at'))}")
+    print()
+    print(f"Checkpoints: {summary.get('checkpoint_count', 0)}")
+    print(f"Database: {'exists' if summary.get('db_exists') else 'not created'}")
+    return 0
+
+
+def _agent_reset(manager, agent_id: str) -> int:
+    """Reset agent memory (clear checkpoints and assign new thread)."""
+    result = manager.reset_memory(agent_id)
+    print(f"Agent {agent_id} memory cleared.")
+    print(f"New thread ID: {result['thread_id']}")
+    return 0
+
+
+def _agent_rotate(manager, agent_id: str) -> int:
+    """Rotate agent thread ID (keeps old checkpoints)."""
+    result = manager.rotate_thread(agent_id)
+    print(f"Agent {agent_id} thread rotated.")
+    print(f"New thread ID: {result['thread_id']}")
+    return 0
+
+
+def _format_time(ts) -> str:
+    """Format a timestamp for display."""
+    if not ts:
+        return "N/A"
+    try:
+        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ts))
+    except (TypeError, ValueError, OSError):
+        return "N/A"

snodo/cli/commands/config_cmd.py

@@ -0,0 +1,138 @@
+"""Config command - Manage Snodo configuration and API keys.
+
+FILE: snodo/cli/commands/config_cmd.py
+"""
+
+import sys
+
+from snodo.cli.config import ConfigManager, ConfigError, DEFAULT_MODEL
+
+
+def config_command(args) -> int:
+    """Manage Snodo configuration and API keys."""
+    mgr = ConfigManager()
+
+    if args.config_action == "show":
+        return _config_show(mgr)
+    elif args.config_action == "add":
+        return _config_add(mgr, args.provider, args.key)
+    elif args.config_action == "remove":
+        return _config_remove(mgr, args.provider)
+    elif args.config_action == "test":
+        return _config_test(mgr)
+    elif args.config_action == "set":
+        return _config_set(mgr, args.key, args.value)
+    elif args.config_action == "get":
+        return _config_get(mgr, args.key)
+    else:
+        print("Unknown config action. Use: show, add, remove, test, set, get", file=sys.stderr)
+        return 1
+
+
+def _config_show(mgr: ConfigManager) -> int:
+    """Show current configuration."""
+    config = mgr.load()
+    keys = config.get("api_keys", {})
+    model = config.get("model", DEFAULT_MODEL)
+
+    print(f"Config: {mgr.config_path}")
+    print(f"Model:  {model}")
+    print()
+
+    if keys:
+        print("API Keys:")
+        for provider, key in keys.items():
+            print(f"  {provider}: {ConfigManager.mask_key(key)}")
+    else:
+        print("No API keys configured.")
+        print("  Add one: snodo config add <provider> <key>")
+    return 0
+
+
+def _config_add(mgr: ConfigManager, provider: str, key: str) -> int:
+    """Add an API key."""
+    try:
+        mgr.add_key(provider, key)
+        masked = ConfigManager.mask_key(key)
+        print(f"✓ Stored {provider} key: {masked}")
+        return 0
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+def _config_remove(mgr: ConfigManager, provider: str) -> int:
+    """Remove an API key."""
+    if mgr.remove_key(provider):
+        print(f"✓ Removed {provider} key")
+        return 0
+    else:
+        print(f"No key found for provider: {provider}", file=sys.stderr)
+        return 1
+
+
+def _config_test(mgr: ConfigManager) -> int:
+    """Test all configured API keys."""
+    config = mgr.load()
+    keys = config.get("api_keys", {})
+    if not keys:
+        print("No API keys configured. Add one first:")
+        print("  snodo config add <provider> <key>")
+        return 1
+
+    print("Testing API keys...")
+    results = mgr.test_keys()
+    all_ok = True
+    for provider, ok in results.items():
+        status = "✓ valid" if ok else "✗ invalid"
+        print(f"  {provider}: {status}")
+        if not ok:
+            all_ok = False
+    return 0 if all_ok else 1
+
+
+def _config_set(mgr: ConfigManager, key: str, value: str) -> int:
+    """Set a config value using dot notation."""
+    parts = key.split(".", 1)
+    if len(parts) == 2 and parts[0] == "engine":
+        engine_key = parts[1]
+        if engine_key in ("max_subtask_depth", "max_session_age_days", "token_ttl_seconds"):
+            try:
+                int_value = int(value)
+            except ValueError:
+                print(f"Error: {engine_key} must be an integer", file=sys.stderr)
+                return 1
+            try:
+                mgr.set_engine_value(engine_key, int_value)
+            except (ValueError, ConfigError) as e:
+                print(f"Error: {e}", file=sys.stderr)
+                return 1
+        else:
+            mgr.set_engine_value(engine_key, value)
+        print(f"Set {key} = {value}")
+        return 0
+    elif key == "model":
+        mgr.set_model(value)
+        print(f"Set model = {value}")
+        return 0
+    else:
+        print(f"Error: Unknown config key: {key}", file=sys.stderr)
+        return 1
+
+
+def _config_get(mgr: ConfigManager, key: str) -> int:
+    """Get a config value using dot notation."""
+    parts = key.split(".", 1)
+    if len(parts) == 2 and parts[0] == "engine":
+        value = mgr.get_engine_value(parts[1])
+        if value is None:
+            print(f"Not set: {key}", file=sys.stderr)
+            return 1
+        print(value)
+        return 0
+    elif key == "model":
+        print(mgr.get_model())
+        return 0
+    else:
+        print(f"Error: Unknown config key: {key}", file=sys.stderr)
+        return 1

snodo/cli/commands/dashboard_cmd.py

@@ -0,0 +1,38 @@
+"""Dashboard command - Launch TUI dashboard.
+
+FILE: snodo/cli/commands/dashboard_cmd.py (Task 5.3)
+"""
+
+import sys
+from pathlib import Path
+
+
+def snop_entry():
+    """Entry point for the 'snop' shortcut command."""
+    from types import SimpleNamespace
+    args = SimpleNamespace()
+    sys.exit(dashboard_command(args))
+
+
+def dashboard_command(args) -> int:
+    """Launch the Snodo TUI dashboard."""
+    project_root = str(Path.cwd())
+
+    # Verify .snodo/ exists
+    snodo_dir = Path(project_root) / ".snodo"
+    if not snodo_dir.is_dir():
+        print("Error: Not a snodo project (no .snodo/ directory)", file=sys.stderr)
+        print("Run 'snodo init' first.", file=sys.stderr)
+        return 1
+
+    try:
+        from snodo.dashboard.app import run_dashboard
+        run_dashboard(project_root=project_root)
+        return 0
+    except ImportError as e:
+        print(f"Error: Dashboard requires 'textual' package: {e}", file=sys.stderr)
+        print("Install with: pip install textual", file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"Error: Dashboard failed: {e}", file=sys.stderr)
+        return 1

snodo/cli/commands/init_cmd.py

@@ -0,0 +1,156 @@
+"""Init command - Initialize Snodo project structure.
+
+FILE: snodo/cli/commands/init_cmd.py
+"""
+
+import sys
+from pathlib import Path
+
+import yaml
+
+from snodo.cli.commands import PROTOCOL_TEMPLATES
+from snodo.infrastructure.state import ProjectState, write_state
+
+
+def _select_template(args) -> str:
+    """Select protocol template from flag or interactive prompt.
+
+    Returns:
+        The selected template YAML string.
+    """
+    template_name = getattr(args, "template", None)
+
+    if template_name:
+        return PROTOCOL_TEMPLATES[template_name]
+
+    # Interactive prompt
+    print("Choose protocol template:")
+    print("  1. solo  - Single developer (producer merges directly)")
+    print("  2. team  - Team workflow (producer + reviewer + planner)")
+    print("  3. 2+n   - Paper reference config (producer + reviewer)")
+    choice = input("Select [1/2/3]: ").strip()
+
+    if choice == "1":
+        return PROTOCOL_TEMPLATES["solo"]
+    elif choice == "2":
+        return PROTOCOL_TEMPLATES["team"]
+    elif choice == "3":
+        return PROTOCOL_TEMPLATES["2+n"]
+    else:
+        print(f"Invalid choice: {choice!r}. Using team template.", file=sys.stderr)
+        return PROTOCOL_TEMPLATES["team"]
+
+
+def _pick_mode(args, modes: list, default_mode: str) -> str:
+    """Interactive mode picker. Returns selected mode_id.
+
+    Skips picker when:
+    - --mode <m> passed (validated against available modes)
+    - Not a TTY (piped / CI — keep default silently)
+    """
+    cli_mode = getattr(args, "mode", None)
+
+    # Build mode_id -> info lookup
+    mode_info: dict = {}
+    for m in modes:
+        mid = m.get("mode_id", "")
+        name = m.get("name", mid)
+        tools = m.get("tools", [])
+        mode_info[mid] = {"name": name, "tools": tools}
+
+    if cli_mode:
+        if cli_mode not in mode_info:
+            available = ", ".join(sorted(mode_info.keys()))
+            print(
+                f"Error: Mode '{cli_mode}' not in protocol. "
+                f"Available: {available}",
+                file=sys.stderr,
+            )
+            raise SystemExit(1)
+        return cli_mode
+
+    # Non-TTY → keep default silently (CI / piped)
+    if not sys.stdin.isatty():
+        return default_mode
+
+    # Single-mode protocol → no choice needed
+    if len(mode_info) <= 1:
+        return default_mode
+
+    # Interactive picker
+    print()
+    print("Select your starting mode:")
+    mode_ids = sorted(mode_info.keys())
+    default_idx = mode_ids.index(default_mode) if default_mode in mode_ids else 0
+
+    for i, mid in enumerate(mode_ids):
+        info = mode_info[mid]
+        tools_str = ", ".join(info["tools"]) if info["tools"] else "none"
+        marker = "  [default]" if mid == default_mode else ""
+        print(f"  {i + 1}. {info['name']} ({mid})  tools: {tools_str}{marker}")
+
+    try:
+        choice = input(f"Select [1-{len(mode_ids)}, default={default_idx + 1}]: ").strip()
+        if not choice:
+            return default_mode
+        idx = int(choice) - 1
+        if 0 <= idx < len(mode_ids):
+            return mode_ids[idx]
+    except (ValueError, KeyboardInterrupt):
+        pass
+
+    print(f"Using default: {default_mode}")
+    return default_mode
+
+
+def init_command(args) -> int:
+    """Initialize Snodo project structure."""
+    snodo_dir = Path(".snodo")
+
+    if snodo_dir.exists():
+        if not args.force:
+            print("Error: .snodo/ already exists. Use --force to overwrite.", file=sys.stderr)
+            return 1
+        print("Warning: Overwriting existing .snodo/ directory")
+
+    try:
+        snodo_dir.mkdir(exist_ok=True)
+        print(f"Created {snodo_dir}/")
+    except Exception as e:
+        print(f"Error: Failed to create .snodo/ directory: {e}", file=sys.stderr)
+        return 1
+
+    # Select template
+    template = _select_template(args)
+
+    protocol_file = snodo_dir / "protocol.yml"
+    try:
+        protocol_file.write_text(template + "\n")
+        print(f"Created {protocol_file}")
+    except Exception as e:
+        print(f"Error: Failed to create protocol.yml: {e}", file=sys.stderr)
+        return 1
+
+    # Write .snodo/state.json — set current_mode from protocol.initial_mode
+    # Ctrl-C safe: this write IS the state; no subsequent prompt can kill it.
+    try:
+        data = yaml.safe_load(template)
+        initial_mode = data.get("initial_mode", "")
+        modes = data.get("modes", [])
+        if initial_mode:
+            write_state(".", ProjectState(current_mode=initial_mode))
+
+            # Interactive mode picker (or --mode flag skips it)
+            selected_mode = _pick_mode(args, modes, initial_mode)
+            if selected_mode and selected_mode != initial_mode:
+                write_state(".", ProjectState(current_mode=selected_mode))
+            print(f"Active mode: {selected_mode or initial_mode}")
+    except Exception as e:
+        print(f"Warning: Could not write state.json: {e}", file=sys.stderr)
+
+    print("\nSnodo initialized successfully!")
+    print("\nNext steps:")
+    print("  1. Edit .snodo/protocol.yml to customize your protocol")
+    print("  2. Run: snodo run \"your task description\"")
+
+    return 0