cluxion-agentplugin-preprocessing 0.3.21__tar.gz → 0.3.23__tar.gz

{cluxion_agentplugin_preprocessing-0.3.21 → cluxion_agentplugin_preprocessing-0.3.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cluxion-agentplugin-preprocessing
-Version: 0.3.21
+Version: 0.3.23
 Summary: Universal agent plugin for Cluxion preprocessing, honesty contracts, clarification, Rust work queue, and resource-aware harness handoff.
 Project-URL: Homepage, https://github.com/cluxion/cluxion-Agentplugin-preprocessing
 Project-URL: Repository, https://github.com/cluxion/cluxion-Agentplugin-preprocessing

{cluxion_agentplugin_preprocessing-0.3.21 → cluxion_agentplugin_preprocessing-0.3.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cluxion-agentplugin-preprocessing"
-version = "0.3.21"
+version = "0.3.23"
 description = "Universal agent plugin for Cluxion preprocessing, honesty contracts, clarification, Rust work queue, and resource-aware harness handoff."
 readme = "README.md"
 requires-python = ">=3.11"

cluxion_agentplugin_preprocessing-0.3.23/rust/cluxion_queue/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "cluxion-queue-native"
+version = "0.2.1"
+source = { editable = "." }

{cluxion_agentplugin_preprocessing-0.3.21 → cluxion_agentplugin_preprocessing-0.3.23}/src/cluxion_agentplugin_preprocessing/plugin.py

@@ -20,6 +20,7 @@ from cluxion_agentplugin_preprocessing.schemas import (
     CONTEXT_COMPRESS_SCHEMA,
     GUARD_SCHEMA,
     HERMES_CONFIG_SCHEMA,
+    LOOP_AUTO_SCHEMA,
     PLAN_SCHEMA,
     QUEUE_BRIEF_SCHEMA,
     QUEUE_NEXT_SCHEMA,
@@ -27,11 +28,13 @@ from cluxion_agentplugin_preprocessing.schemas import (
     SERVE_LOCAL_SCHEMA,
     WEB_SEARCH_SCHEMA,
 )
+from cluxion_agentplugin_preprocessing.slash_commands import register_slash_commands
 from cluxion_runtime.core.context_compress import (
     DEFAULT_TRIGGER_RATIO,
     _resolve_context_limit,
     compress,
 )
+from cluxion_runtime.core.loop_auto import strip_loop_auto_directive
 from cluxion_runtime.core.preprocess import estimate_tokens
 
 if TYPE_CHECKING:
@@ -40,6 +43,7 @@ if TYPE_CHECKING:
 
 def register(ctx: object) -> None:
     """Register Cluxion preprocessing tools with the host agent."""
+    register_slash_commands(ctx)
     register_hook = getattr(ctx, "register_hook", None)
     if callable(register_hook):
         register_hook("on_session_start", guard_watch.on_session_start)
@@ -114,6 +118,14 @@ def register(ctx: object) -> None:
         check_fn=_check_runtime_available,
         emoji="📌",
     )
+    ctx.register_tool(
+        name="cluxion_loop_auto",
+        toolset="cluxion",
+        schema=LOOP_AUTO_SCHEMA,
+        handler=_handle_loop_auto,
+        check_fn=_check_runtime_available,
+        emoji="🔁",
+    )
     ctx.register_tool(
         name="cluxion_context_compress",
         toolset="cluxion",
@@ -201,7 +213,17 @@ def _check_browser_tool_available() -> bool:
 
 
 def _handle_plan(args: dict[str, object], **_: object) -> str:
-    return _json_result(lambda: runner.plan(args).to_json())
+    return _json_result(lambda: runner.plan(_plan_args_with_loop_auto(args)).to_json())
+
+
+def _plan_args_with_loop_auto(args: dict[str, object]) -> dict[str, object]:
+    payload = dict(args)
+    prompt = str(payload.get("prompt", ""))
+    cleaned, had_directive = strip_loop_auto_directive(prompt)
+    if had_directive:
+        payload["prompt"] = cleaned
+        payload["loop_auto"] = True
+    return payload
 
 
 def _handle_clarify(args: dict[str, object], **_: object) -> str:
@@ -232,6 +254,10 @@ def _handle_queue_brief(args: dict[str, object], **_: object) -> str:
     return _json_result(lambda: runner.queue_brief(args).to_json())
 
 
+def _handle_loop_auto(args: dict[str, object], **_: object) -> str:
+    return _json_result(lambda: runner.loop_auto(args).to_json())
+
+
 def _handle_context_compress(args: dict[str, object], **_: object) -> str:
     return _json_result(lambda: runner.context_compress(args).to_json())
 

{cluxion_agentplugin_preprocessing-0.3.21 → cluxion_agentplugin_preprocessing-0.3.23}/src/cluxion_agentplugin_preprocessing/plugin.yaml

@@ -1,5 +1,5 @@
 name: cluxion-agentplugin-preprocessing
-version: 0.3.20
+version: 0.3.23
 description: "Universal agent preprocessing plugin: honesty contracts, clarification, Rust work queue, resource-aware harness handoff. Connected AI calls cluxion tools; plugin does not own models."
 author: cluxion
 kind: standalone
@@ -12,6 +12,7 @@ provides_tools:
   - cluxion_queue_next
   - cluxion_queue_record
   - cluxion_queue_brief
+  - cluxion_loop_auto
   - cluxion_context_compress
   - cluxion_guard
   - cluxion_web_search

{cluxion_agentplugin_preprocessing-0.3.21 → cluxion_agentplugin_preprocessing-0.3.23}/src/cluxion_agentplugin_preprocessing/runner.py

@@ -144,6 +144,19 @@ def queue_brief(payload: Mapping[str, object], *, command_runner: CommandRunner
     return _execute_json(command, None, command_runner)
 
 
+def loop_auto(payload: Mapping[str, object], *, command_runner: CommandRunner | None = None) -> RuntimeResult:
+    """Autonomously drain the dispatch queue via Hermes oneshot calls (/loopAuto)."""
+    command = (
+        _runtime_binary(None),
+        "loop-auto",
+        "--work-id",
+        _required_str(payload, "work_id"),
+        "--json-stdin",
+    )
+    stdin = json.dumps(dict(payload), ensure_ascii=False)
+    return _execute_json(command, stdin, command_runner)
+
+
 def context_compress(payload: Mapping[str, object], *, command_runner: CommandRunner | None = None) -> RuntimeResult:
     """Compress conversation context deterministically once it exceeds the trigger ratio."""
     messages = payload.get("messages")
@@ -367,6 +380,7 @@ __all__ = [
     "context_compress",
     "guard",
     "hermes_config",
+    "loop_auto",
     "plan",
     "queue_brief",
     "queue_next",

{cluxion_agentplugin_preprocessing-0.3.21 → cluxion_agentplugin_preprocessing-0.3.23}/src/cluxion_agentplugin_preprocessing/schemas.py

@@ -58,6 +58,31 @@ PLAN_SCHEMA = {
                 "default": "",
                 "description": "Answers that resolve a prior clarification gate; required to enqueue an ambiguous or large task.",
             },
+            "loop_auto": {
+                "type": "boolean",
+                "default": True,
+                "description": "After a queued plan is stored, autonomously drain segments via Hermes oneshot calls.",
+            },
+            "loop_auto_dry_run": {
+                "type": "boolean",
+                "default": False,
+                "description": "Simulate Hermes segment execution without calling the hermes binary.",
+            },
+            "loop_auto_timeout_s": {
+                "type": "number",
+                "default": 600,
+                "description": "Maximum seconds for the full autonomous drain loop.",
+            },
+            "hermes_bin": {
+                "type": "string",
+                "default": "hermes",
+                "description": "Hermes CLI binary used for each segment oneshot.",
+            },
+            "model": {
+                "type": "string",
+                "default": "",
+                "description": "Optional Hermes model override (-m) for segment oneshots.",
+            },
         },
         "required": ["prompt"],
     },
@@ -142,6 +167,32 @@ QUEUE_BRIEF_SCHEMA = {
     },
 }
 
+LOOP_AUTO_SCHEMA = {
+    "name": "cluxion_loop_auto",
+    "description": (
+        "Autonomously drain the Cluxion dispatch queue via Hermes oneshot calls. "
+        "Equivalent to /loopAuto: next segment -> hermes -z -> record -> ... -> briefing. "
+        "Use after cluxion_plan queued a durable work bundle, or pass loop_auto on plan."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "work_id": {"type": "string", "description": "Queued work bundle id from cluxion_plan."},
+            "cwd": {"type": "string", "default": ""},
+            "hermes_bin": {"type": "string", "default": "hermes"},
+            "model": {"type": "string", "default": ""},
+            "timeout_seconds": {"type": "number", "default": 600},
+            "max_segment_retries": {"type": "integer", "minimum": 0, "default": 2},
+            "dry_run": {
+                "type": "boolean",
+                "default": False,
+                "description": "Simulate Hermes without calling the binary (tests and diagnostics).",
+            },
+        },
+        "required": ["work_id"],
+    },
+}
+
 CONTEXT_COMPRESS_SCHEMA = {
     "name": "cluxion_context_compress",
     "description": (
@@ -370,6 +421,7 @@ __all__ = [
     "CONTEXT_COMPRESS_SCHEMA",
     "GUARD_SCHEMA",
     "HERMES_CONFIG_SCHEMA",
+    "LOOP_AUTO_SCHEMA",
     "PLAN_SCHEMA",
     "QUEUE_BRIEF_SCHEMA",
     "QUEUE_NEXT_SCHEMA",

cluxion_agentplugin_preprocessing-0.3.23/src/cluxion_agentplugin_preprocessing/slash_commands.py

@@ -0,0 +1,121 @@
+"""In-session slash commands for Hermes (/loopauto, /cluxion-doctor)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from cluxion_agentplugin_preprocessing import runner
+from cluxion_agentplugin_preprocessing.doctor import render_text, run_doctor
+from cluxion_agentplugin_preprocessing.doctor.probes import PROBES
+
+LOOPAUTO_HELP = """\
+/loopauto <prompt> — Autonomous queue drain (loopAuto)
+
+Plans the task, stores segment content in the Rust queue, then loops:
+  queue_next → hermes -z → queue_record → … → briefing
+
+Examples:
+  /loopauto implement every REQ line and record evidence
+  /loopauto refactor auth module with tests
+
+Notes:
+  - Equivalent to prefixing a prompt with /loopAuto on cluxion_plan
+  - Disable auto-loop: export CLUXION_LOOP_AUTO=0
+  - Diagnostics only: add loop_auto_dry_run via cluxion_plan tool
+"""
+
+CLUXION_DOCTOR_HELP = "/cluxion-doctor — Run preprocessing plugin health checks (doctor)."
+
+
+def register_slash_commands(ctx: object) -> None:
+    register = getattr(ctx, "register_command", None)
+    if not callable(register):
+        return
+    register(
+        "loopauto",
+        handle_loopauto,
+        description="Autonomous queue drain (loopAuto) — plan + Hermes oneshot segment loop",
+        args_hint="<prompt>",
+    )
+    register(
+        "cluxion-doctor",
+        handle_cluxion_doctor,
+        description="Run cluxion preprocessing plugin doctor checks",
+    )
+
+
+def handle_loopauto(raw_args: str) -> str:
+    prompt = raw_args.strip()
+    if not prompt or prompt.lower() in {"help", "-h", "--help"}:
+        return LOOPAUTO_HELP
+    try:
+        result = runner.plan(
+            {
+                "prompt": f"/loopAuto {prompt}",
+                "cwd": str(Path.cwd()),
+                "clarification_answers": "confirmed via /loopauto slash command",
+            }
+        )
+        return _format_plan_response(result.to_json())
+    except Exception as exc:
+        return f"loopauto error: {exc}"
+
+
+def handle_cluxion_doctor(raw_args: str) -> str:
+    if raw_args.strip().lower() in {"help", "-h", "--help"}:
+        return CLUXION_DOCTOR_HELP
+    import importlib.resources
+
+    from cluxion_agentplugin_preprocessing import __version__
+    from cluxion_agentplugin_preprocessing.doctor.framework import load_catalog
+
+    pkg = "cluxion_agentplugin_preprocessing.doctor"
+    catalog_path = Path(str(importlib.resources.files(pkg).joinpath("catalog.json")))
+    result = run_doctor(
+        cwd=Path.cwd(),
+        hermes_bin="hermes",
+        catalog_path=catalog_path,
+        probes=PROBES,
+        plugin="preprocessing",
+        version=__version__,
+    )
+    return render_text(result, load_catalog(catalog_path))
+
+
+def _format_plan_response(raw_json: str) -> str:
+    payload = json.loads(raw_json)
+    if not payload.get("ok"):
+        return f"loopauto failed: {payload.get('error', 'unknown error')}"
+    body = payload.get("result", payload)
+    if not isinstance(body, dict):
+        return str(body)
+    loop = body.get("loop_auto")
+    if isinstance(loop, dict):
+        lines = [
+            f"[loopauto] ok={loop.get('ok')} status={loop.get('status')}",
+            f"segments_processed={loop.get('segments_processed')} "
+            f"segments_failed={loop.get('segments_failed')} "
+            f"duration_ms={loop.get('duration_ms')}",
+        ]
+        if loop.get("error"):
+            lines.append(f"error: {loop['error']}")
+        briefing = str(loop.get("briefing_answer", "")).strip()
+        if briefing:
+            lines.extend(["", briefing])
+        return "\n".join(lines)
+    host = body.get("host_execution")
+    if isinstance(host, dict) and host.get("queue_required"):
+        return (
+            "Plan queued but loop_auto did not run. "
+            "Check CLUXION_LOOP_AUTO=1 and hermes on PATH (cluxion-preprocess doctor)."
+        )
+    return json.dumps(body, ensure_ascii=False, indent=2)[:8000]
+
+
+__all__ = [
+    "LOOPAUTO_HELP",
+    "handle_cluxion_doctor",
+    "handle_loopauto",
+    "register_slash_commands",
+]

{cluxion_agentplugin_preprocessing-0.3.21 → cluxion_agentplugin_preprocessing-0.3.23}/src/cluxion_runtime/cli.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import argparse
 import json
 import sys
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from cluxion_runtime.adapters.contract import work_item_from_adapter_payload
@@ -23,6 +24,12 @@ from cluxion_runtime.core.dispatch_store import (
     record_dispatch_result,
 )
 from cluxion_runtime.core.harness import build_harness_plan
+from cluxion_runtime.core.loop_auto import (
+    LoopAutoOptions,
+    run_loop_auto,
+    should_auto_loop_plan,
+    strip_loop_auto_directive,
+)
 from cluxion_runtime.core.plan_codec import plan_to_dict
 from cluxion_runtime.core.types import AgentSurface, ModelRuntimeProfile
 from cluxion_runtime.models import LocalModelSupervisor, build_vllm_mlx_profile
@@ -49,6 +56,8 @@ def main(argv: Sequence[str] | None = None) -> int:
         return _run_queue_record(args)
     if args.command == "queue-brief":
         return _run_queue_brief(args)
+    if args.command == "loop-auto":
+        return _run_loop_auto(args)
     if args.command == "context-compress":
         return _run_context_compress(args)
     if args.command == "guard":
@@ -111,6 +120,18 @@ def _build_parser() -> argparse.ArgumentParser:
         "queue-brief", help="Build the final briefing prompt from stored segment results"
     )
     queue_brief.add_argument("--work-id", required=True)
+    loop_auto = subparsers.add_parser(
+        "loop-auto",
+        help="Autonomously drain the dispatch queue via Hermes oneshot calls (/loopAuto)",
+    )
+    loop_auto.add_argument("--work-id", required=True)
+    loop_auto.add_argument("--cwd", default="")
+    loop_auto.add_argument("--hermes-bin", default="hermes")
+    loop_auto.add_argument("--model", default="")
+    loop_auto.add_argument("--timeout-seconds", type=float, default=600.0)
+    loop_auto.add_argument("--max-segment-retries", type=int, default=2)
+    loop_auto.add_argument("--dry-run", action="store_true")
+    loop_auto.add_argument("--json-stdin", action="store_true")
     context_compress = subparsers.add_parser(
         "context-compress",
         help="Deterministically compress conversation context to the target ratio once past the trigger ratio",
@@ -137,6 +158,7 @@ def _run_bootstrap(args: argparse.Namespace) -> int:
 def _run_plan(args: argparse.Namespace) -> int:
     surface = AgentSurface(str(args.surface))
     payload = _payload_from_stdin() if args.json_stdin else _payload_from_args(args)
+    payload = _apply_loop_auto_directive(payload)
     item = work_item_from_adapter_payload(payload, default_surface=surface)
     plan = build_harness_plan(item)
     persisted = persist_dispatch_bundle(plan)
@@ -146,10 +168,43 @@ def _run_plan(args: argparse.Namespace) -> int:
         if isinstance(item_output, dict):
             item_output["original_prompt_stored"] = True
         output["dispatch_store"] = {"stored": True, "path": str(persisted)}
+    loop_auto_flag = payload.get("loop_auto") if isinstance(payload, dict) else None
+    if should_auto_loop_plan(output, loop_auto=bool(loop_auto_flag) if loop_auto_flag is not None else None):
+        cwd = str(payload.get("cwd", "")) if isinstance(payload, dict) else ""
+        loop_result = run_loop_auto(
+            LoopAutoOptions(
+                work_id=plan.item.work_id,
+                cwd=Path(cwd).expanduser() if cwd else Path.cwd(),
+                hermes_bin=str(payload.get("hermes_bin", "hermes")) if isinstance(payload, dict) else "hermes",
+                model=str(payload.get("model", "")) if isinstance(payload, dict) else "",
+                timeout_seconds=float(payload.get("loop_auto_timeout_s", 600)) if isinstance(payload, dict) else 600.0,
+                dry_run=bool(payload.get("loop_auto_dry_run", False)) if isinstance(payload, dict) else False,
+            )
+        )
+        output["loop_auto"] = loop_result.to_dict()
     print(json.dumps(output, ensure_ascii=False, sort_keys=True))
     return 0
 
 
+def _run_loop_auto(args: argparse.Namespace) -> int:
+    payload = _payload_from_stdin() if args.json_stdin else {}
+    work_id = str(payload.get("work_id", args.work_id))
+    cwd_raw = str(payload.get("cwd", args.cwd))
+    result = run_loop_auto(
+        LoopAutoOptions(
+            work_id=work_id,
+            cwd=Path(cwd_raw).expanduser() if cwd_raw else Path.cwd(),
+            hermes_bin=str(payload.get("hermes_bin", args.hermes_bin)),
+            model=str(payload.get("model", args.model)),
+            timeout_seconds=float(payload.get("timeout_seconds", args.timeout_seconds)),
+            max_segment_retries=int(payload.get("max_segment_retries", args.max_segment_retries)),
+            dry_run=bool(payload.get("dry_run", args.dry_run)),
+        )
+    )
+    print(json.dumps(result.to_dict(), ensure_ascii=False, sort_keys=True))
+    return 0 if result.ok else 1
+
+
 def _run_queue_next(args: argparse.Namespace) -> int:
     try:
         payload = next_dispatch_step(str(args.work_id))
@@ -389,6 +444,17 @@ def _payload_from_args(args: argparse.Namespace) -> dict[str, object]:
     }
 
 
+def _apply_loop_auto_directive(payload: dict[str, object]) -> dict[str, object]:
+    prompt = str(payload.get("prompt", ""))
+    cleaned, had_directive = strip_loop_auto_directive(prompt)
+    if not had_directive:
+        return payload
+    updated = dict(payload)
+    updated["prompt"] = cleaned
+    updated["loop_auto"] = True
+    return updated
+
+
 if __name__ == "__main__":
     raise SystemExit(main())
 

{cluxion_agentplugin_preprocessing-0.3.21 → cluxion_agentplugin_preprocessing-0.3.23}/src/cluxion_runtime/core/harness.py

@@ -201,10 +201,12 @@ def _host_execution_plan_for(
             next_tool="cluxion_queue_next",
             record_tool="cluxion_queue_record",
             brief_tool="cluxion_queue_brief",
+            loop_tool="cluxion_loop_auto",
             performance_notes=(
                 *base_notes,
                 "queued_plan_stores_segment_content_out_of_band",
                 "initial_plan_returns_metadata_not_full_segment_payload",
+                "use_cluxion_loop_auto_or_slash_loopAuto_for_autonomous_drain",
             ),
         )
     return HostExecutionPlan(