prompture 1.13.3.dev1__tar.gz → 1.13.4.dev1__tar.gz

prompture-1.13.4.dev1/.gitattributes

@@ -0,0 +1,3 @@
+# LF in the repo and in checkouts, whatever core.autocrlf says, so tools that
+# write LF (cargo, formatters) never leave files that only differ in line ends.
+* text=auto eol=lf

{prompture-1.13.3.dev1 → prompture-1.13.4.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.13.3.dev1
+Version: 1.13.4.dev1
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT

{prompture-1.13.3.dev1 → prompture-1.13.4.dev1}/prompture/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.13.3.dev1'
-__version_tuple__ = version_tuple = (1, 13, 3, 'dev1')
+__version__ = version = '1.13.4.dev1'
+__version_tuple__ = version_tuple = (1, 13, 4, 'dev1')
 
 __commit_id__ = commit_id = None

{prompture-1.13.3.dev1 → prompture-1.13.4.dev1}/prompture/cli/cli.py

@@ -232,6 +232,16 @@ def test_suite(specfile: str, providers: str | None, models: str | None, fmt: st
     default=True,
     help="Let companion apps route Claude Code and Codex through this companion (default: on).",
 )
+@click.option(
+    "--memory/--no-memory",
+    default=True,
+    help="Give routed coding agents their project's shared notes at the start of each session (default: on).",
+)
+@click.option(
+    "--restore",
+    is_flag=True,
+    help="Point Claude Code and Codex back at their vendors (after a companion was killed) and exit.",
+)
 def companion(
     port: int | None,
     db_path: str | None,
@@ -239,6 +249,8 @@ def companion(
     coding_tools: bool,
     automations: bool,
     router: bool,
+    memory: bool,
+    restore: bool,
 ) -> None:
     """Serve this machine's Prompture usage to desktop companions (no hub needed).
 
@@ -253,10 +265,19 @@ def companion(
     so the companion prefers the same port each time: 47811.
     """
     from ..companion import Automations, CodingToolSource, CompanionServer, LedgerSource, running_instance
+    from ..companion.memory import MemoryService
     from ..companion.server import DEFAULT_PORT
     from ..companion.tool_routing import ToolRouting
 
     existing = running_instance()
+    if restore:
+        if existing:
+            raise click.ClickException(
+                f"A companion is running at {existing['url']}; turn routing off in its app, or stop it first."
+            )
+        restored = ToolRouting().restore_all()
+        click.echo(f"Restored: {', '.join(restored)}." if restored else "Nothing was routed.")
+        return
     if existing:
         click.echo(f"Prompture companion already running at {existing['url']} (pid {existing.get('pid')}).")
         return
@@ -267,6 +288,7 @@ def companion(
             port=on_port,
             coding_tools=CodingToolSource() if coding_tools else None,
             tool_routing=ToolRouting() if router else None,
+            memory=MemoryService() if router and memory else None,
         )
 
     if port is None:
@@ -458,3 +480,92 @@ def scaffold(output_dir: str, name: str, model: str, docker: bool) -> None:
         include_docker=docker,
     )
     click.echo(f"Project scaffolded at {output_dir}")
+
+
+@cli.group()
+def memory() -> None:
+    """Project notes shared by coding agents (decisions, conventions, commands, fixes).
+
+    The companion gives each Claude Code and Codex session its project's
+    relevant notes when it starts. The project is this folder's name unless
+    --project says otherwise.
+    """
+
+
+def _project_or_cwd(project: str | None) -> str:
+    import os
+
+    from ..session_memory.project import project_name
+
+    name = project or project_name(os.getcwd())
+    if not name:
+        raise click.ClickException("Can't tell the project from this folder; pass --project.")
+    return name
+
+
+@memory.command("add")
+@click.argument("text")
+@click.option(
+    "--kind",
+    type=click.Choice(["decision", "convention", "command", "fix", "fact"]),
+    default="fact",
+    help="What sort of note it is.",
+)
+@click.option("--source", default=None, help="Where it comes from: a file and line, a commit, a doc.")
+@click.option(
+    "--verified", is_flag=True, help="It was checked (tests pass, the command ran). Verified notes are shared."
+)
+@click.option("--pinned", is_flag=True, help="Give it to every session, whatever the task.")
+@click.option("--project", default=None, help="Project name (default: this folder's name).")
+@click.option("--agent", default=None, help="Who is adding it (default: the agent running this, if known).")
+def memory_add(
+    text: str, kind: str, source: str | None, verified: bool, pinned: bool, project: str | None, agent: str | None
+) -> None:
+    """Save a note for later sessions in this project."""
+    import os
+
+    from ..session_memory.project import ProjectMemory
+
+    name = _project_or_cwd(project)
+    who = agent or ("claude" if os.environ.get("CLAUDECODE") else "codex" if os.environ.get("CODEX_SANDBOX") else None)
+    fact = ProjectMemory().add(name, text, kind=kind, source=source, verified=verified, pinned=pinned, agent=who)
+    state = "verified" if verified else "unverified (shared once verified)"
+    click.echo(f"Saved {kind} note {fact.id[:8]} for {name}, {state}.")
+
+
+@memory.command("list")
+@click.option("--project", default=None, help="Project name (default: this folder's name).")
+@click.option("--json", "as_json", is_flag=True, help="Print JSON.")
+def memory_list(project: str | None, as_json: bool) -> None:
+    """Show this project's notes."""
+    from ..session_memory.project import ProjectMemory
+
+    name = _project_or_cwd(project)
+    facts = ProjectMemory().notes(name)
+    if as_json:
+        click.echo(
+            json.dumps([{"id": f.id, "kind": f.kind, "content": f.content, **f.metadata} for f in facts], indent=2)
+        )
+        return
+    if not facts:
+        click.echo(f"No notes for {name} yet.")
+    for f in facts:
+        flag = "✓" if f.metadata.get("verified") else " "
+        source = f" ({f.metadata['source']})" if f.metadata.get("source") else ""
+        click.echo(f"{flag} {f.id[:8]} [{f.kind}] {f.content}{source}")
+
+
+@memory.command("rm")
+@click.argument("note_id")
+@click.option("--project", default=None, help="Project name (default: this folder's name).")
+def memory_rm(note_id: str, project: str | None) -> None:
+    """Delete a note (the id, or the first characters of it, as `list` shows)."""
+    from ..session_memory.project import ProjectMemory
+
+    name = _project_or_cwd(project)
+    store = ProjectMemory()
+    matches = [f for f in store.notes(name) if f.id.startswith(note_id)]
+    if len(matches) != 1:
+        raise click.ClickException(f"{len(matches)} notes match {note_id!r} in {name}.")
+    store.delete(name, matches[0].id)
+    click.echo(f"Deleted {matches[0].id[:8]}.")

{prompture-1.13.3.dev1 → prompture-1.13.4.dev1}/prompture/companion/automations.py

@@ -9,7 +9,9 @@ permission prompts are skipped (``approval_mode="auto"``).
 A queue pauses by itself when a step fails, when the agent ends a step on a
 question (answering continues that step's session), when the agent's plan
 window is nearly used up (it resumes when the window resets), or when the run
-passes a cost cap. Steps that haven't started can be added, removed and
+passes a cost cap. With ``agent: "auto"`` the queue starts on whichever agent
+has the most plan left, and a step that starts a fresh session moves to the
+other agent instead of pausing when the current one runs low. Steps that haven't started can be added, removed and
 reordered while it runs. A step either continues the previous step's session
 (``"same"``) or starts a fresh one (``"new"``).
 
@@ -111,6 +113,8 @@ class Run:
     note: str | None = None
     #: Skip the plan-limit check for the next step ("Resume now").
     ignore_limit: bool = False
+    #: The agent is chosen by plan left, and may change between fresh sessions.
+    auto: bool = False
 
     @property
     def project(self) -> str:
@@ -128,6 +132,7 @@ class Run:
             "project": self.project,
             "agent": self.agent,
             "agent_name": AGENTS.get(self.agent, self.agent),
+            "auto": self.auto,
             "model": self.model,
             "status": self.status,
             "reason": self.reason,
@@ -349,8 +354,13 @@ class Automations:
         agent = str(body.get("agent") or "claude")
         if not cwd or not Path(cwd).is_dir():
             raise AutomationError(422, "Pick a project folder that exists.")
+        auto = agent == "auto"
+        note = None
+        if auto:
+            agent, why = self._most_room(list(AGENTS))
+            note = f"Started on {AGENTS[agent]}: {why}"
         if agent not in AGENTS:
-            raise AutomationError(422, f"agent must be one of {', '.join(AGENTS)}.")
+            raise AutomationError(422, f"agent must be auto or one of {', '.join(AGENTS)}.")
         steps = _parse_steps(body.get("steps"))
         if not steps:
             raise AutomationError(422, "Add at least one step.")
@@ -373,6 +383,8 @@ class Automations:
                     "cost_usd": float(cost) if isinstance(cost, (int, float)) and cost > 0 else None,
                 },
                 created_at=time.time(),
+                auto=auto,
+                note=note,
             )
             self.run = run
             self._save(run)
@@ -518,6 +530,41 @@ class Automations:
                 return step.session_id
         return None
 
+    def _most_room(self, agents: list[str]) -> tuple[str, str]:
+        """The agent with the most plan left, and why (plan windows from the companion's limits)."""
+        from .capacity import pick_agent
+
+        try:
+            limits = self.limits() if self.limits is not None else {}
+        except Exception:
+            logger.debug("plan limits failed", exc_info=True)
+            limits = {}
+        return pick_agent(limits, agents, PLAN_TARGETS)
+
+    def _switch_agent(self, run: Run, step: Step) -> bool:
+        """Move an auto queue to the other agent for a step that starts fresh; ``False`` if it can't."""
+        fresh = step.session == "new" or run.current == 0 or not self._session_before(run, run.current)
+        if not run.auto or step.reply or not fresh:
+            return False
+        others = [a for a in AGENTS if a != run.agent]
+        agent, why = self._most_room(others)
+        from .capacity import headroom
+
+        try:
+            room = headroom((self.limits() if self.limits is not None else {}).get(PLAN_TARGETS.get(agent, "")))
+        except Exception:
+            room = None
+        if room is not None and room <= NEAR_LIMIT:
+            return False
+        old, run.agent = run.agent, agent
+        run.note = f"Moved to {AGENTS[agent]} ({why}); {AGENTS[old]}'s plan is nearly used up"
+        # A step that continues a session must stay on the agent that owns it; new steps start fresh.
+        for later in run.steps[run.current + 1 :]:
+            if later.status == "pending" and later.session == "same":
+                later.session = "new"
+                break
+        return True
+
     def _plan_near(self, run: Run) -> tuple[bool, float | None]:
         """Whether the agent's plan is nearly used up, and when the tightest window resets."""
         if self.limits is None or not run.stop.get("limit"):
@@ -550,7 +597,7 @@ class Automations:
             run.ignore_limit = False
         else:
             near, resets = self._plan_near(run)
-            if near:
+            if near and not self._switch_agent(run, step):
                 self._pause(run, "limit", resets)
                 return None
         if step.reply: