opencommand 0.1.1__tar.gz → 0.1.2__tar.gz

{opencommand-0.1.1 → opencommand-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: opencommand
-Version: 0.1.1
+Version: 0.1.2
 Summary: Local-first swarm agent framework: a Commander plans and dispatches a swarm of Workers that research, code, test, and interactively drive the computer to complete long-horizon codebase goals.
 Author: DSiENT
 Author-email: DSiENT <w.caskey7@gmail.com>
@@ -55,12 +55,26 @@ playwright install   # optional, for the playwright tool
 ```bash
 opencommand models list                 # list built-in embedded models
 opencommand models pull all             # download GGUF models into ./models
+opencommand config                      # interactive menu: workers, batch size, GPU, etc.
 opencommand run "Add unit tests for the engine module."
+opencommand run --goal-file Goal.md    # run from a Goal.md spec (intended state)
 opencommand run "Build a Panda3D FPS" --pipeline advanced --verify "uv run pytest -q"
 opencommand tui                         # live swarm dashboard
 opencommand cron add healthcheck "every 1h" "echo ok"
 ```
 
+### Goal.md spec
+
+Instead of an inline goal, point `run` at a `Goal.md` file that defines the
+intended end state / requirements for the session. Its contents become the goal
+fed to the swarm (and the advanced pipeline's review gate checks against it):
+
+```bash
+opencommand run --goal-file Goal.md
+```
+
+The file name is configurable via `opencommand config` (default `Goal.md`).
+
 ## Built-in models
 
 | Role          | Model                                  |

{opencommand-0.1.1 → opencommand-0.1.2}/README.md

@@ -32,12 +32,26 @@ playwright install   # optional, for the playwright tool
 ```bash
 opencommand models list                 # list built-in embedded models
 opencommand models pull all             # download GGUF models into ./models
+opencommand config                      # interactive menu: workers, batch size, GPU, etc.
 opencommand run "Add unit tests for the engine module."
+opencommand run --goal-file Goal.md    # run from a Goal.md spec (intended state)
 opencommand run "Build a Panda3D FPS" --pipeline advanced --verify "uv run pytest -q"
 opencommand tui                         # live swarm dashboard
 opencommand cron add healthcheck "every 1h" "echo ok"
 ```
 
+### Goal.md spec
+
+Instead of an inline goal, point `run` at a `Goal.md` file that defines the
+intended end state / requirements for the session. Its contents become the goal
+fed to the swarm (and the advanced pipeline's review gate checks against it):
+
+```bash
+opencommand run --goal-file Goal.md
+```
+
+The file name is configurable via `opencommand config` (default `Goal.md`).
+
 ## Built-in models
 
 | Role          | Model                                  |

{opencommand-0.1.1 → opencommand-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "opencommand"
-version = "0.1.1"
+version = "0.1.2"
 description = "Local-first swarm agent framework: a Commander plans and dispatches a swarm of Workers that research, code, test, and interactively drive the computer to complete long-horizon codebase goals."
 readme = "README.md"
 authors = [

{opencommand-0.1.1 → opencommand-0.1.2}/src/opencommand/cli.py

@@ -57,7 +57,7 @@ def _load_cfg(path: str | None) -> OpenCommandConfig:
 
 
 @click.group()
-@click.version_option(version="0.1.0")
+@click.version_option(version="0.1.1")
 @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."""
@@ -145,6 +145,44 @@ def _build_rebuild_command(cmake_args: str) -> tuple:
     return base, False, dict(os.environ, CMAKE_ARGS=cmake_args)
 
 
+@cli.command()
+@click.argument("path", required=False)
+def config(path: str | None) -> None:
+    """Interactive menu to set advanced swarm settings (persisted to config.json)."""
+    cfg = _load_cfg(path)
+    click.echo(click.style("OpenCommand configuration", fg="cyan", bold=True))
+    click.echo(f"Workspace: {cfg.workspace}\n")
+
+    cfg.vision = click.confirm("Enable vision / desktop tool?", default=cfg.vision)
+    cfg.vision_model = click.prompt(
+        "Vision model role", type=click.Choice(["vision", "vision_small"]),
+        default=cfg.vision_model)
+    cfg.max_workers = click.prompt(
+        "Max workers (concurrent model pool size)", type=int, default=cfg.max_workers)
+    cfg.batch_size = click.prompt(
+        "Workers per swarm batch", type=int, default=cfg.batch_size)
+    cfg.max_retries = click.prompt(
+        "Max retries per worker", type=int, default=cfg.max_retries)
+    cfg.pipeline = click.prompt(
+        "Pipeline", type=click.Choice(["standard", "advanced"]), default=cfg.pipeline)
+    cfg.live_verify = click.confirm(
+        "Enable live-verify (interactive desktop check after tests pass)?",
+        default=cfg.live_verify)
+    cfg.max_iterations = click.prompt(
+        "Max automatic-mode iterations", type=int, default=cfg.max_iterations)
+    cfg.max_research_loops = click.prompt(
+        "Max research refinement loops / phase", type=int, default=cfg.max_research_loops)
+    cfg.max_test_loops = click.prompt(
+        "Max test+debug fix loops / phase", type=int, default=cfg.max_test_loops)
+    cfg.n_gpu_layers = click.prompt(
+        "GPU layers to offload (0=CPU, -1=all)", type=int, default=cfg.n_gpu_layers)
+    cfg.goal_file = click.prompt(
+        "Session goal spec file name", default=cfg.goal_file)
+
+    cfg.save()
+    click.echo(click.style(f"\nSaved config -> {cfg._path()}", fg="green"))
+
+
 @cli.group()
 def models() -> None:
     """Manage built-in embedded models."""
@@ -274,11 +312,15 @@ def cron_start(path: str | None) -> None:
 
 
 @cli.command()
-@click.argument("goal")
+@click.argument("goal", required=False)
 @click.option("--path", default=None, help="Workspace directory.")
-@click.option("--max-iter", default=5, help="Automatic-mode iterations.")
+@click.option("--goal-file", default=None,
+              help="Path to a Goal.md spec defining the intended state/goal. "
+                   "If omitted, the configured goal_file in the workspace is used.")
+@click.option("--max-iter", default=None, type=int, 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("--batch-size", default=None, type=int, help="Workers spawned per swarm batch.")
 @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"]),
@@ -290,10 +332,16 @@ def cron_start(path: str | None) -> None:
                    "(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."""
+def run(goal: str | None, path: str | None, goal_file: str | None, max_iter: int | None,
+        verify: str | None, pool: int | None, batch_size: int | None,
+        no_vision: bool, vision_model: str | None, pipeline: str | None,
+        live_verify: bool) -> None:
+    """Run a GOAL autonomously using embedded models.
+
+    The GOAL may be passed inline, or defined in a Goal.md spec file (see
+    --goal-file) that describes the intended end state / requirements for the
+    session. When a goal file is used, its contents become the goal.
+    """
     import asyncio
 
     from .modules.system.automatic import run_automatic
@@ -308,6 +356,23 @@ def run(goal: str, path: str | None, max_iter: int, verify: str | None,
         cfg.pipeline = pipeline
     if live_verify:
         cfg.live_verify = True
+    if max_iter is not None:
+        cfg.max_iterations = max_iter
+    if batch_size is not None:
+        cfg.batch_size = batch_size
+
+    # Resolve the goal: inline arg wins; otherwise load from a Goal.md spec.
+    goal_path = Path(goal_file or cfg.goal_file)
+    if goal is None:
+        if not goal_path.is_absolute():
+            goal_path = cfg.workspace / goal_path
+        if not goal_path.exists():
+            raise click.UsageError(
+                f"No goal provided and no spec file found at {goal_path}. "
+                "Pass a GOAL argument or create a Goal.md spec.")
+        goal = goal_path.read_text(encoding="utf-8").strip()
+        click.echo(click.style(f"Loaded goal spec: {goal_path}", fg="green"))
+
     engine = Engine(model_dir=cfg.workspace / "models",
                     pool_size=pool or cfg.max_workers)
     sup = Supervisor(max_retries=cfg.max_retries)
@@ -320,8 +385,9 @@ def run(goal: str, path: str | None, max_iter: int, verify: str | None,
     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)
+            commander, g, max_iterations=cfg.max_iterations, verify_cmd=verify,
+            pipeline=cfg.pipeline, live_verify=cfg.live_verify,
+            batch_size=cfg.batch_size)
         click.echo(click.style(f"Loaded {len(cron._jobs)} cron job(s).", fg="green"))
 
     async def _main() -> str:
@@ -329,8 +395,9 @@ def run(goal: str, path: str | None, max_iter: int, verify: str | None,
             cron.start()
         try:
             return await run_automatic(
-                commander, goal, max_iterations=max_iter, verify_cmd=verify,
-                pipeline=cfg.pipeline, live_verify=cfg.live_verify)
+                commander, goal, max_iterations=cfg.max_iterations, verify_cmd=verify,
+                pipeline=cfg.pipeline, live_verify=cfg.live_verify,
+                batch_size=cfg.batch_size)
         finally:
             cron.stop()
             sup.shutdown()
@@ -338,6 +405,8 @@ def run(goal: str, path: str | None, max_iter: int, verify: str | None,
     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(f"Batch size: {cfg.batch_size}  Pool: {pool or cfg.max_workers}",
+                           fg="cyan"))
     click.echo(click.style("Loading embedded models...", fg="cyan"))
     click.echo(click.style("Running automatic mode...", fg="cyan"))
     report = asyncio.run(_main())

{opencommand-0.1.1 → opencommand-0.1.2}/src/opencommand/core/config.py

@@ -17,6 +17,13 @@ class OpenCommandConfig:
     max_retries: int = 3
     pipeline: str = "standard"  # standard | advanced (Phase 6)
     live_verify: bool = False  # interactive desktop check after verify passes
+    # --- Advanced settings (config menu / Goal.md) -------------------------
+    max_iterations: int = 5  # outer automatic-mode iterations
+    max_research_loops: int = 3  # research refinement loops per phase
+    max_test_loops: int = 5  # test+debug fix loops per phase
+    batch_size: int = 4  # workers spawned per swarm batch
+    n_gpu_layers: int = 0  # 0 = CPU; -1 = all GPU layers
+    goal_file: str = "Goal.md"  # session goal spec file name
 
     def save(self) -> None:
         self._path().parent.mkdir(parents=True, exist_ok=True)
@@ -32,6 +39,12 @@ class OpenCommandConfig:
             "max_retries": self.max_retries,
             "pipeline": self.pipeline,
             "live_verify": self.live_verify,
+            "max_iterations": self.max_iterations,
+            "max_research_loops": self.max_research_loops,
+            "max_test_loops": self.max_test_loops,
+            "batch_size": self.batch_size,
+            "n_gpu_layers": self.n_gpu_layers,
+            "goal_file": self.goal_file,
         }, indent=2)
 
     @classmethod
@@ -49,6 +62,12 @@ class OpenCommandConfig:
             max_retries=d.get("max_retries", 3),
             pipeline=d.get("pipeline", "standard"),
             live_verify=d.get("live_verify", False),
+            max_iterations=d.get("max_iterations", 5),
+            max_research_loops=d.get("max_research_loops", 3),
+            max_test_loops=d.get("max_test_loops", 5),
+            batch_size=d.get("batch_size", 4),
+            n_gpu_layers=d.get("n_gpu_layers", 0),
+            goal_file=d.get("goal_file", "Goal.md"),
         )
 
     def _path(self) -> Path:

{opencommand-0.1.1 → opencommand-0.1.2}/src/opencommand/modules/system/automatic.py

@@ -28,12 +28,13 @@ log = get_logger("system.automatic")
 
 async def run_automatic(commander: Commander, goal: str, max_iterations: int = 5,
                         verify_cmd: str | None = None, pipeline: str = "standard",
-                        live_verify: bool = False) -> str:
+                        live_verify: bool = False, batch_size: int = 4) -> str:
     """Iteratively execute the goal, auto-fixing failures, until 100% met.
 
     ``pipeline`` is "standard" or "advanced" (scaffold + research loop +
     commander review gate + test/debug loop). ``live_verify`` runs the desktop
     tool as a final interactive check when the goal is UI/UX facing.
+    ``batch_size`` is the number of workers spawned per swarm batch.
 
     The loop only returns success when BOTH the exit-code verify gate AND the
     Commander review gate pass (and, if enabled, the live-verify check). If the
@@ -47,10 +48,11 @@ async def run_automatic(commander: Commander, goal: str, max_iterations: int = 5
                               tags=["rocket", "opencommand"])
     last = ""
     for i in range(max_iterations):
-        log.info("iteration=%d/%d goal=%r pipeline=%s", i + 1, max_iterations,
-                 original_goal, pipeline)
+        log.info("iteration=%d/%d goal=%r pipeline=%s batch=%d", i + 1,
+                 max_iterations, original_goal, pipeline, batch_size)
         last = await _execute(commander, original_goal, pipeline,
-                              verify_cmd=verify_cmd, live_verify=live_verify)
+                              verify_cmd=verify_cmd, live_verify=live_verify,
+                              batch_size=batch_size)
         # Exit-code gate (real verification, not string matching).
         if verify_cmd:
             rc, out = _verify(commander, verify_cmd)
@@ -98,11 +100,13 @@ async def run_automatic(commander: Commander, goal: str, max_iterations: int = 5
 
 
 async def _execute(commander: Commander, goal: str, pipeline: str,
-                   verify_cmd: str | None = None, live_verify: bool = False) -> str:
+                   verify_cmd: str | None = None, live_verify: bool = False,
+                   batch_size: int = 4) -> str:
     if pipeline == "advanced":
         return await commander.execute_advanced(
-            goal, verify_cmd=verify_cmd, live_verify=live_verify)
-    return await commander.execute(goal)
+            goal, verify_cmd=verify_cmd, live_verify=live_verify,
+            batch_size=batch_size)
+    return await commander.execute(goal, batch_size=batch_size)
 
 
 def _fix_prompt(original_goal: str, last: str) -> str:

{opencommand-0.1.1 → opencommand-0.1.2}/src/opencommand/swarm/agents/commander.py

@@ -184,7 +184,7 @@ class Commander:
 
     # --- Standard pipeline (backward compatible) ---------------------------
 
-    async def execute(self, goal: str) -> str:
+    async def execute(self, goal: str, batch_size: int = 4) -> str:
         """Standard pipeline: plan -> research -> workers (no scaffold/review)."""
         plan = await self.plan(goal)
         save_note(self.workspace, "goal_plan",
@@ -201,7 +201,7 @@ class Commander:
             worker_jobs = {f"worker-{i}": self._worker_job(i, t)
                            for i, t in enumerate(phase.workers)}
             if worker_jobs:
-                for k, v in (await self.supervisor.run_all(worker_jobs)).items():
+                for k, v in (await self._run_batched(worker_jobs, batch_size)).items():
                     report.append(f"  [{k}] {v[:300]}")
         save_note(self.workspace, "goal_report", "\n".join(report), tags=["report"])
         return "\n".join(report)
@@ -211,7 +211,8 @@ class Commander:
     async def execute_advanced(self, goal: str, max_research_loops: int = 3,
                                max_test_loops: int = 5,
                                verify_cmd: str | None = None,
-                               live_verify: bool = False) -> str:
+                               live_verify: bool = False,
+                               batch_size: int = 4) -> str:
         """Fully-featured autonomous loop for a GOAL.
 
         Per phase:
@@ -257,7 +258,7 @@ class Commander:
             worker_jobs = {f"worker-{i}": self._worker_job(i, t, context)
                            for i, t in enumerate(phase.workers)}
             if worker_jobs:
-                for k, v in (await self.supervisor.run_all(worker_jobs)).items():
+                for k, v in (await self._run_batched(worker_jobs, batch_size)).items():
                     report.append(f"  [{k}] {v[:300]}")
             # 4. TEST+DEBUG LOOP: reach a testable state, then fix until green.
             if verify_cmd:
@@ -469,6 +470,24 @@ class Commander:
 
     # --- Helpers -----------------------------------------------------------
 
+    async def _run_batched(self, jobs: dict[str, Callable[[], Awaitable[str]]],
+                           batch_size: int = 4) -> dict[str, str]:
+        """Run jobs in bounded batches so at most ``batch_size`` run at once.
+
+        Workers share a fixed-size runner pool, so capping concurrency here keeps
+        the pool from thrashing and bounds RAM/CPU usage on smaller hosts. Each
+        batch is dispatched through the Supervisor (which isolates every job with
+        crash containment), so behavior is identical to ``run_all`` but bounded.
+        """
+        if batch_size <= 0:
+            batch_size = 1
+        results: dict[str, str] = {}
+        items = list(jobs.items())
+        for start in range(0, len(items), batch_size):
+            batch = dict(items[start:start + batch_size])
+            results.update(await self.supervisor.run_all(batch))
+        return results
+
     def _scaffold(self, phase: Phase, idx: int) -> str:
         """Lay the foundation for a phase so workers fill in structure, not fight it.