opencommand 0.1.0__py3-none-any.whl

opencommand/__init__.py

@@ -0,0 +1,4 @@
+def main() -> None:
+    from .cli import cli
+
+    cli()

opencommand/cli.py

@@ -0,0 +1,375 @@
+"""click-based CLI for OpenCommand (fully embedded, no external servers).
+
+Commands:
+  opencommand workspace [path]            # show workspace + engine status
+  opencommand models pull [role]          # download built-in GGUF models
+  opencommand models list                 # list built-in model catalog
+  opencommand run "goal"                  # run the swarm autonomously
+  opencommand tui                         # live swarm dashboard
+  opencommand notify "msg"                # send a test ntfy notification
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from pathlib import Path
+
+import click
+
+from .core.config import OpenCommandConfig
+from .core.logging import configure_logging, get_logger
+from .core.supervisor import Supervisor
+from .core.tools import ToolRegistry
+from .engine import Engine
+from .modules.system.platform import describe
+
+log = get_logger("cli")
+
+
+def _build_tools(engine: Engine, cfg: OpenCommandConfig) -> ToolRegistry:
+    from .modules.tools.desktop import DesktopTool
+    from .modules.tools.files import FilesTool
+    from .modules.tools.instructions import InstructionsTool
+    from .modules.tools.memory import MemoryTool
+    from .modules.tools.playwright import PlaywrightTool
+    from .modules.tools.research import ResearchTool
+    from .modules.tools.system import SystemTool
+    from .modules.tools.terminal import TerminalTool
+
+    reg = ToolRegistry()
+    reg.register(TerminalTool())
+    reg.register(FilesTool(cfg.workspace))
+    reg.register(MemoryTool(cfg.workspace))
+    reg.register(InstructionsTool(cfg.workspace))
+    reg.register(ResearchTool())
+    reg.register(PlaywrightTool())
+    reg.register(SystemTool())
+    vision_role = cfg.vision_model if cfg.vision else None
+    reg.register(DesktopTool(engine.runner(vision_role) if vision_role else None))
+    return reg
+
+
+def _load_cfg(path: str | None) -> OpenCommandConfig:
+    ws = Path(path).resolve() if path else Path.cwd()
+    return OpenCommandConfig.load(ws)
+
+
+@click.group()
+@click.version_option(version="0.1.0")
+@click.option("-v", "--verbose", is_flag=True, help="Enable verbose (DEBUG) logging.")
+def cli(verbose: bool) -> None:
+    """OpenCommand  -  all-in-one local model runner & command center."""
+    configure_logging(level=logging.DEBUG if verbose else logging.INFO,
+                      workspace=_load_cfg(None).workspace, verbose=verbose)
+
+
+@cli.command()
+@click.argument("path", required=False)
+def workspace(path: str | None) -> None:
+    """Show workspace info and embedded engine status."""
+    cfg = _load_cfg(path)
+    engine = Engine(model_dir=cfg.workspace / "models")
+    click.echo(f"Workspace: {cfg.workspace}")
+    click.echo(f"Platform: {describe()}")
+    click.echo(engine.status())
+
+
+@cli.command()
+@click.argument("path", required=False)
+@click.option("--apply", is_flag=True, help="Write the recommended config to the workspace.")
+@click.option("--rebuild", is_flag=True, help="Rebuild llama-cpp-python from source with detected ISA flags.")
+def setup(path: str | None, apply: bool, rebuild: bool) -> None:
+    """Autodetect the host and show (or --apply / --rebuild) a per-host setup."""
+    from .modules.system.platform import detect, recommend_config
+
+    ws = Path(path).resolve() if path else Path.cwd()
+    d = detect()
+    rec = recommend_config(d)
+    click.echo(describe())
+    click.echo(f"Cores: {d['cores']}  RAM: {d['ram_gb']} GB  GPU: {d['gpu']['backend']}")
+    click.echo(f"ISA: {', '.join(d['isa']['extensions']) or 'base'}")
+    click.echo(f"Tools: {', '.join(k for k, v in d['tools'].items() if v) or 'none'}")
+    click.echo("\nRecommended config:")
+    click.echo(f"  max_workers={rec['config']['max_workers']}  "
+               f"pool_size={rec['engine']['pool_size']}  "
+               f"n_gpu_layers={rec['runner']['n_gpu_layers']}")
+    click.echo(f"  vision={rec['config']['vision']}")
+    if rec["build"]["cmake_args"]:
+        click.echo(f"  llama.cpp build: {rec['build']['cmake_args']}")
+    if apply:
+        cfg = OpenCommandConfig.from_host(ws)
+        cfg.save()
+        click.echo(click.style(f"\nWrote config -> {cfg._path()}", fg="green"))
+    if rebuild:
+        _rebuild_llama_cpp(rec["build"]["cmake_args"])
+
+
+def _rebuild_llama_cpp(cmake_args: str) -> None:
+    """Reinstall llama-cpp-python from source with the given CMAKE_ARGS.
+
+    Mirrors the manual x64 AVX2 build: on Windows we must compile inside the
+    MSVC x64 dev shell (vcvars64.bat), otherwise a 32-bit DLL is produced.
+    """
+    import subprocess
+
+    click.echo(click.style(f"\nRebuilding llama-cpp-python (CMAKE_ARGS={cmake_args or 'none'})...",
+                           fg="yellow"))
+    if not cmake_args:
+        click.echo("No ISA build flags detected; building with defaults.")
+    cmd, shell, env = _build_rebuild_command(cmake_args)
+    try:
+        subprocess.run(cmd, shell=shell, env=env, check=True)
+        click.echo(click.style("llama-cpp-python rebuilt.", fg="green"))
+    except subprocess.CalledProcessError as e:
+        click.echo(click.style(f"Rebuild failed (exit {e.returncode}). "
+                               "Ensure MSVC Build Tools 2022 is installed.", fg="red"))
+
+
+def _build_rebuild_command(cmake_args: str) -> tuple:
+    """Return (command, shell, env) for the llama-cpp-python source rebuild.
+
+    Windows compiles inside the MSVC x64 dev shell; POSIX sets CMAKE_ARGS in env.
+    """
+    base = ["uv", "pip", "install", "--no-binary", "llama-cpp-python",
+            "--no-cache", "llama-cpp-python"]
+    if sys.platform.startswith("win"):
+        vcvars = (r"C:\Program Files\Microsoft Visual Studio\2022\BuildTools"
+                  r"\Common7\Tools\vcvars64.bat")
+        if not Path(vcvars).exists():
+            vcvars = (r"C:\Program Files (x86)\Microsoft Visual Studio\2022"
+                      r"\BuildTools\Common7\Tools\vcvars64.bat")
+        cmd = f'call "{vcvars}" && set CMAKE_ARGS={cmake_args} && ' + " ".join(base)
+        return cmd, True, None
+    return base, False, dict(os.environ, CMAKE_ARGS=cmake_args)
+
+
+@cli.group()
+def models() -> None:
+    """Manage built-in embedded models."""
+
+
+@models.command("list")
+def models_list() -> None:
+    """List the built-in model catalog."""
+    from .engine.runner import CATALOG
+
+    for spec in CATALOG.values():
+        click.echo(f"  {spec.role:10} {spec.repo_id} [{spec.kind}] fmt={spec.chat_format}")
+
+
+@models.command("pull")
+@click.argument("role", required=False)
+@click.option("--path", default=None, help="Workspace directory.")
+def models_pull(role: str | None, path: str | None) -> None:
+    """Download built-in GGUF model(s). Role: commander|worker|vision|all."""
+    cfg = _load_cfg(path)
+    engine = Engine(model_dir=cfg.workspace / "models")
+    roles = ["commander", "worker", "vision", "vision_small"] if role in (None, "all") else [role]
+    for r in roles:
+        click.echo(f"Downloading {r}...")
+        p = engine.ensure_downloaded(r)
+        click.echo(f"  -> {p}")
+
+
+@cli.group()
+def cron() -> None:
+    """Schedule recurring tasks (e.g. 'every 1h', 'daily 09:00')."""
+
+
+@cron.command("add")
+@click.argument("name")
+@click.argument("schedule")
+@click.argument("command")
+@click.option("--path", default=None, help="Workspace directory.")
+def cron_add(name: str, schedule: str, command: str, path: str | None) -> None:
+    """Add a cron job NAME on SCHEDULE that runs COMMAND (shell)."""
+    from .modules.system.cron import CronScheduler
+
+    cfg = _load_cfg(path)
+    cron_file = cfg.workspace / ".opencommand" / "cron.json"
+    sched = CronScheduler.load(cron_file)
+    sched.schedule_command(name, schedule, command)
+    sched.save(cron_file)
+    click.echo(f"Added cron job '{name}' on '{schedule}': {command}")
+    click.echo(f"Persisted to {cron_file}")
+
+
+@cron.command("list")
+@click.option("--path", default=None, help="Workspace directory.")
+def cron_list(path: str | None) -> None:
+    """List persisted cron jobs."""
+    from .modules.system.cron import CronScheduler
+
+    cfg = _load_cfg(path)
+    cron_file = cfg.workspace / ".opencommand" / "cron.json"
+    sched = CronScheduler.load(cron_file)
+    click.echo(sched.status())
+
+
+@cron.command("remove")
+@click.argument("name")
+@click.option("--path", default=None, help="Workspace directory.")
+def cron_remove(name: str, path: str | None) -> None:
+    """Remove a persisted cron job by NAME."""
+    import json as _json
+
+    cfg = _load_cfg(path)
+    cron_file = cfg.workspace / ".opencommand" / "cron.json"
+    if not cron_file.exists():
+        click.echo("No cron jobs persisted.")
+        return
+    data = _json.loads(cron_file.read_text(encoding="utf-8"))
+    kept = [j for j in data if j["name"] != name]
+    if len(kept) == len(data):
+        click.echo(f"No job named '{name}'.")
+        return
+    cron_file.write_text(_json.dumps(kept, indent=2), encoding="utf-8")
+    click.echo(f"Removed cron job '{name}'.")
+
+
+@cron.command("status")
+@click.option("--path", default=None, help="Workspace directory.")
+def cron_status(path: str | None) -> None:
+    """Show loaded cron jobs (live in-process schedules)."""
+    from .modules.system.cron import CronScheduler
+
+    cfg = _load_cfg(path)
+    cron_file = cfg.workspace / ".opencommand" / "cron.json"
+    sched = CronScheduler.load(cron_file)
+    click.echo(sched.status())
+
+
+@cron.command("start")
+@click.option("--path", default=None, help="Workspace directory.")
+def cron_start(path: str | None) -> None:
+    """Load persisted cron jobs and run the scheduler in the foreground."""
+    import asyncio
+
+    from .modules.system.cron import CronScheduler
+
+    cfg = _load_cfg(path)
+    cron_file = cfg.workspace / ".opencommand" / "cron.json"
+    sched = CronScheduler.load(cron_file)
+    if not sched._jobs:
+        click.echo("No persisted cron jobs. Use `cron add` first.")
+        return
+    click.echo(sched.status())
+    click.echo("Running scheduler (Ctrl-C to stop)...")
+
+    async def _run() -> None:
+        sched.start()
+        try:
+            while not sched._stop.is_set():
+                await asyncio.sleep(sched._tick)
+        finally:
+            sched.stop()
+
+    try:
+        asyncio.run(_run())
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        pass
+    click.echo("Scheduler stopped.")
+
+
+@cli.command()
+@click.argument("goal")
+@click.option("--path", default=None, help="Workspace directory.")
+@click.option("--max-iter", default=5, help="Automatic-mode iterations.")
+@click.option("--verify", default=None, help="Shell command to verify success (e.g. 'pytest -q').")
+@click.option("--pool", default=None, type=int, help="Worker model pool size (parallelism).")
+@click.option("--no-vision", is_flag=True, help="Disable the desktop/vision tool.")
+@click.option("--vision-model", default=None,
+              type=click.Choice(["vision", "vision_small"]),
+              help="Vision model for the desktop tool (vision=Qwen3-VL-4B, "
+                   "vision_small=MiniCPM-V-4.6 0.8B for CPU/low-RAM).")
+@click.option("--pipeline", default=None,
+              type=click.Choice(["standard", "advanced"]),
+              help="Pipeline: standard (plan->research->workers) or advanced "
+                   "(Phase 6: scaffold + research-context + commander review gate).")
+@click.option("--live-verify", is_flag=True,
+              help="After tests pass, run the desktop tool to interactively verify UI goals.")
+def run(goal: str, path: str | None, max_iter: int, verify: str | None,
+        pool: int | None, no_vision: bool, vision_model: str | None,
+        pipeline: str | None, live_verify: bool) -> None:
+    """Run a GOAL autonomously using embedded models."""
+    import asyncio
+
+    from .modules.system.automatic import run_automatic
+    from .swarm.agents.commander import Commander
+
+    cfg = _load_cfg(path)
+    if no_vision:
+        cfg.vision = None
+    if vision_model:
+        cfg.vision_model = vision_model
+    if pipeline:
+        cfg.pipeline = pipeline
+    if live_verify:
+        cfg.live_verify = True
+    engine = Engine(model_dir=cfg.workspace / "models",
+                    pool_size=pool or cfg.max_workers)
+    sup = Supervisor(max_retries=cfg.max_retries)
+    tools = _build_tools(engine, cfg)
+    commander = Commander(engine, sup, tools, cfg.workspace)
+    # Boot persisted cron jobs: they run inside the agent event loop and dispatch
+    # goals through the Commander (or run shell commands) when they fire.
+    from .modules.system.cron import CronScheduler
+    cron_file = cfg.workspace / ".opencommand" / "cron.json"
+    cron = CronScheduler.load(cron_file)
+    if cron._jobs:
+        cron.on_goal = lambda g: run_automatic(
+            commander, g, max_iterations=max_iter, verify_cmd=verify,
+            pipeline=cfg.pipeline, live_verify=cfg.live_verify)
+        click.echo(click.style(f"Loaded {len(cron._jobs)} cron job(s).", fg="green"))
+
+    async def _main() -> str:
+        if cron._jobs:
+            cron.start()
+        try:
+            return await run_automatic(
+                commander, goal, max_iterations=max_iter, verify_cmd=verify,
+                pipeline=cfg.pipeline, live_verify=cfg.live_verify)
+        finally:
+            cron.stop()
+            sup.shutdown()
+
+    click.echo(f"OpenCommand on {describe()}")
+    click.echo(click.style(f"Pipeline: {cfg.pipeline}"
+                           + (" + live-verify" if cfg.live_verify else ""), fg="cyan"))
+    click.echo(click.style("Loading embedded models...", fg="cyan"))
+    click.echo(click.style("Running automatic mode...", fg="cyan"))
+    report = asyncio.run(_main())
+    click.echo(report)
+
+
+@cli.command()
+def tui() -> None:
+    """Launch the live swarm dashboard (asciimatics)."""
+    from .tui.dashboard import run_dashboard
+
+    run_dashboard()
+
+
+@cli.command()
+@click.argument("message")
+@click.option("--title", default=None, help="Notification title.")
+@click.option("--priority", default=3, help="ntfy priority 1..5 (default 3).")
+def notify(message: str, title: str | None, priority: int) -> None:
+    """Send a test ntfy notification (needs NTFY_TOPIC env var)."""
+    from .modules.system.notify import Notifier
+
+    n = Notifier()
+    if not n.enabled:
+        click.echo(
+            "ntfy not configured. Set NTFY_TOPIC (e.g. "
+            "https://ntfy.sh/your-topic) in the environment."
+        )
+        return
+    ok = n.send(message, title=title, priority=priority)
+    click.echo("Notification sent." if ok else "Notification FAILED.")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    cli()

opencommand/core/agent.py

@@ -0,0 +1,91 @@
+"""AgentLoop: the per-worker reasoning loop (prompt -> LLM -> tools -> observe)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from ..providers.provider import BaseProvider, ChatMessage
+from .errors import ContextWindowError, RetryableError
+from .tools import ToolRegistry, parse_tool_calls
+
+SYSTEM_PROMPT = (
+    "You are an OpenCommand agent operating inside a workspace on {platform}. "
+    "You complete tasks by calling tools. Think step by step, then emit tool "
+    "calls. When the task is fully done, reply with a final summary and no "
+    "tool calls. Be concise and correct; prefer running tests to claiming success."
+)
+
+
+@dataclass
+class AgentState:
+    messages: list[ChatMessage] = field(default_factory=list)
+    steps: int = 0
+    max_steps: int = 40
+
+
+class AgentLoop:
+    """Drives one worker: repeatedly calls the LLM and executes its tools."""
+
+    def __init__(
+        self,
+        provider: BaseProvider,
+        tools: ToolRegistry,
+        system: str | None = None,
+        platform: str = "this machine",
+    ) -> None:
+        self.provider = provider
+        self.tools = tools
+        self.system = system or SYSTEM_PROMPT.format(platform=platform)
+
+    async def run(self, task: str, max_steps: int = 40) -> str:
+        state = AgentState(max_steps=max_steps)
+        state.messages.append(ChatMessage(role="system", content=self.system))
+        state.messages.append(ChatMessage(role="user", content=task))
+        while state.steps < state.max_steps:
+            state.steps += 1
+            try:
+                msg = await self.provider.acomplete(state.messages, tools=self.tools.schemas())
+            except ContextWindowError:
+                # Bound history and retry instead of failing the whole run.
+                state.messages = _truncate(state.messages, keep=20)
+                state.messages.append(ChatMessage(
+                    role="system",
+                    content="Context was truncated to fit the model window. Continue."))
+                continue
+            except Exception as e:  # noqa: BLE001
+                if "context" in str(e).lower():
+                    raise ContextWindowError(str(e)) from e
+                raise RetryableError(str(e)) from e  # noqa: TRY003
+            state.messages.append(msg)
+            calls = parse_tool_calls(msg)
+            if not calls:
+                # No structured calls. If the model emitted a tool-call marker in
+                # text but parsing failed, nudge it to retry rather than stop.
+                if "<function=" in (msg.content or "") or "<tool_call" in (msg.content or ""):
+                    state.messages.append(ChatMessage(
+                        role="system",
+                        content=("Your tool call could not be parsed. Re-emit it using the "
+                                 "exact <tool_call><function=name><parameter=key>value"
+                                 "</parameter></function></tool_call> format, or reply with a "
+                                 "final summary if the task is done.")))
+                    continue
+                return msg.content or "(no output)"
+            for call in calls:
+                result = await self.tools.adispatch(call)
+                obs = result.output if result.ok else f"ERROR: {result.error}"
+                state.messages.append(
+                    ChatMessage(role="tool", content=obs, name=call.name, tool_call_id=call.id)
+                )
+            # Proactively cap history to stay within n_ctx on long tool loops.
+            if len(state.messages) > 24:
+                state.messages = _truncate(state.messages, keep=20)
+        return "(max steps reached)"
+
+
+def _truncate(messages: list[ChatMessage], keep: int = 20) -> list[ChatMessage]:
+    """Keep system + recent messages to bound context on retry."""
+    if len(messages) <= keep:
+        return messages
+    head = [m for m in messages if m.role == "system"]
+    tail = messages[-(keep - len(head)) :]
+    return head + tail

opencommand/core/config.py

@@ -0,0 +1,65 @@
+"""Configuration for OpenCommand: workspace, model flags, limits."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class OpenCommandConfig:
+    """Runtime configuration, persisted to <workspace>/.opencommand/config.json."""
+
+    workspace: Path = field(default_factory=Path.cwd)
+    vision: bool = True
+    vision_model: str = "vision"  # catalog role for the desktop/vision tool
+    max_workers: int = 4
+    max_retries: int = 3
+    pipeline: str = "standard"  # standard | advanced (Phase 6)
+    live_verify: bool = False  # interactive desktop check after verify passes
+
+    def save(self) -> None:
+        self._path().parent.mkdir(parents=True, exist_ok=True)
+        self._path().write_text(self.to_json(), encoding="utf-8")
+
+    def to_json(self) -> str:
+        import json
+        return json.dumps({
+            "workspace": str(self.workspace),
+            "vision": self.vision,
+            "vision_model": self.vision_model,
+            "max_workers": self.max_workers,
+            "max_retries": self.max_retries,
+            "pipeline": self.pipeline,
+            "live_verify": self.live_verify,
+        }, indent=2)
+
+    @classmethod
+    def load(cls, workspace: Path) -> "OpenCommandConfig":
+        path = workspace / ".opencommand" / "config.json"
+        if not path.exists():
+            return cls(workspace=workspace)
+        import json
+        d = json.loads(path.read_text(encoding="utf-8"))
+        return cls(
+            workspace=Path(d.get("workspace", workspace)),
+            vision=d.get("vision", True),
+            vision_model=d.get("vision_model", "vision"),
+            max_workers=d.get("max_workers", 4),
+            max_retries=d.get("max_retries", 3),
+            pipeline=d.get("pipeline", "standard"),
+            live_verify=d.get("live_verify", False),
+        )
+
+    def _path(self) -> Path:
+        return self.workspace / ".opencommand" / "config.json"
+
+    @classmethod
+    def from_host(cls, workspace: Path) -> "OpenCommandConfig":
+        """Build a config tuned to the current host via platform autodetection."""
+        from ..modules.system.platform import detect, recommend_config
+        rec = recommend_config(detect())
+        cfg = cls(workspace=workspace)
+        for k, v in rec["config"].items():
+            setattr(cfg, k, v)
+        return cfg

opencommand/core/errors.py

@@ -0,0 +1,23 @@
+"""Error types for OpenCommand agents and tools."""
+
+from __future__ import annotations
+
+
+class OpenCommandError(Exception):
+    """Base class for all OpenCommand errors."""
+
+
+class ToolError(OpenCommandError):
+    """Raised when a tool fails."""
+
+
+class AgentError(OpenCommandError):
+    """Raised when an agent loop fails irrecoverably."""
+
+
+class RetryableError(OpenCommandError):
+    """Signal the supervisor to retry the task (e.g. transient LLM/HTTP error)."""
+
+
+class ContextWindowError(RetryableError):
+    """Context overflow - supervisor should summarize/truncate and retry."""

opencommand/core/logging.py

@@ -0,0 +1,65 @@
+"""Structured logging for OpenCommand.
+
+Provides a module-level logger configured for verbose, machine-readable output.
+Logs are emitted to stderr (so they never corrupt tool stdout) and optionally to
+a rotating file under the workspace. Every component imports ``get_logger`` and
+logs at the appropriate level so a full autonomous run is fully auditable.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+_DEFAULT_FORMAT = (
+    "%(asctime)s.%(msecs)03d | %(levelname)-8s | %(name)s | "
+    "%(funcName)s:%(lineno)d | %(message)s"
+)
+_DATE_FORMAT = "%Y-%m-%dT%H:%M:%S"
+
+_CONFIGURED = False
+
+
+def configure_logging(level: int = logging.INFO, workspace: Path | None = None,
+                      verbose: bool = False) -> None:
+    """Configure the root OpenCommand logger once.
+
+    ``verbose`` raises the level to DEBUG and attaches a rotating file handler
+    under ``<workspace>/.opencommand/logs/opencommand.log`` when a workspace is
+    given.
+    """
+    global _CONFIGURED
+    if _CONFIGURED:
+        return
+    _CONFIGURED = True
+
+    if verbose:
+        level = logging.DEBUG
+
+    root = logging.getLogger("opencommand")
+    root.setLevel(level)
+    root.propagate = False
+
+    formatter = logging.Formatter(_DEFAULT_FORMAT, datefmt=_DATE_FORMAT)
+
+    stream = logging.StreamHandler(sys.stderr)
+    stream.setFormatter(formatter)
+    root.addHandler(stream)
+
+    if workspace is not None:
+        log_dir = workspace / ".opencommand" / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        file_handler = RotatingFileHandler(
+            log_dir / "opencommand.log", maxBytes=5_000_000, backupCount=5,
+            encoding="utf-8")
+        file_handler.setFormatter(formatter)
+        root.addHandler(file_handler)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Return a child logger under the ``opencommand`` namespace."""
+    if not name.startswith("opencommand"):
+        name = f"opencommand.{name}"
+    return logging.getLogger(name)