rockycode 0.1.0__py3-none-any.whl

rockycode/dream/mining.py

@@ -0,0 +1,152 @@
+"""Weakness mining (self-evolve phase 1, slice 3) — Self-Harness's first stage.
+
+After the dream digests a pass's sessions, the failures among them are mined
+for RECURRING patterns with causal information, stored as `weakness` memories
+(<memory>/weaknesses/*.md, archive-not-delete like everything else). They
+surface as index lines in the system prompt and via recall_memory — the
+groundwork for the proposals inbox, which will turn hot weaknesses into
+prompt/skill proposals.
+
+Two layers, mirroring the judge:
+  1. failure_note — free, code-side gate: a session contributes only when it
+     shows real failure signals (low judge score, tool/engine errors,
+     interrupts, failed tests, or the digest's own "## failed" bullets).
+     No signals in the whole pass → no mining call at all.
+  2. mine_weaknesses — ONE local Ollama call over the pass's failure notes
+     plus the known weaknesses, so recurrence REINFORCES (importance up,
+     evidence appended) instead of duplicating. Local on purpose: episode
+     digests may carry exit-sheet-derived text, which must never reach a
+     cloud model — mining stays on the Ollama side of the split.
+"""
+from __future__ import annotations
+
+import json
+import re
+from typing import Optional
+
+from rockycode.dream.core import parse_bullets
+from rockycode.memory.store import Memory, _slugify
+
+# Below this judge score a session counts as a failure signal even when the
+# mechanical counters look clean (e.g. the agent confidently did the wrong thing).
+JUDGE_BAR = 0.7
+
+MAX_PATTERNS = 3  # per pass — weaknesses should be rare and load-bearing
+
+MINING_PROMPT = """\
+You maintain a coding agent's short list of its own recurring weaknesses.
+
+FAILURE NOTES from recent sessions:
+{notes}
+
+KNOWN WEAKNESSES:
+{existing}
+
+Identify at most {max_patterns} RECURRING failure patterns with a likely
+cause. Only patterns the notes actually support — no speculation, and an
+empty list is a fine answer. If a note is another instance of a KNOWN
+weakness, reinforce that one instead of writing a new one.
+
+Reply with ONLY a JSON array (possibly empty):
+[{{"pattern": "one-line name of the failure pattern",
+   "cause": "likely root cause, one or two sentences",
+   "advice": "one actionable instruction that would avoid it",
+   "reinforces": "name-of-known-weakness or null"}}]
+"""
+
+
+def failure_note(session: dict, sections: dict) -> Optional[str]:
+    """Layer 1 — compact failure evidence for one digested session, or None
+    when it shows no failure signals (free; decides whether mining runs)."""
+    heur = session.get("heuristic") or {}
+    out = session.get("outcome") or {}
+    signals: list[str] = []
+    if out.get("source") == "judge":
+        try:
+            score = float(out.get("score", 1.0))
+        except (TypeError, ValueError):
+            score = 1.0
+        if score < JUDGE_BAR:
+            signals.append(f"judge score {score} — {str(out.get('rationale', ''))[:200]}")
+    if heur.get("tool_errors"):
+        signals.append(f"{heur['tool_errors']} tool error(s)")
+    if heur.get("engine_errors"):
+        signals.append(f"{heur['engine_errors']} engine error(s)")
+    if heur.get("interrupts"):
+        signals.append(f"{heur['interrupts']} user interrupt(s) mid-work")
+    tests = heur.get("tests") or {}
+    if tests.get("run", 0) > tests.get("passed", 0):
+        signals.append(f"tests: only {tests.get('passed', 0)}/{tests['run']} passed")
+    failed = parse_bullets(sections.get("failed", ""))
+    if failed:
+        signals.append("failed approaches: " + "; ".join(failed[:4]))
+    if not signals:
+        return None
+    task = (sections.get("task") or "(unknown task)").strip().splitlines()[0][:150]
+    return f"### {task}\n" + "\n".join(f"- {s}" for s in signals)
+
+
+def _parse_items(answer: str) -> list[dict]:
+    """Lenient array extraction; items missing any required field are dropped
+    (a pattern without cause/advice is a vibe, not a weakness)."""
+    m = re.search(r"\[.*\]", answer, re.DOTALL)
+    if m is None:
+        return []
+    try:
+        arr = json.loads(m.group())
+    except json.JSONDecodeError:
+        return []
+    if not isinstance(arr, list):
+        return []
+    items = []
+    for it in arr:
+        if not isinstance(it, dict):
+            continue
+        if all(isinstance(it.get(k), str) and it[k].strip() for k in ("pattern", "cause", "advice")):
+            items.append(it)
+    return items[:MAX_PATTERNS]
+
+
+async def mine_weaknesses(runner, notes: list[tuple[str, str]]) -> None:
+    """Layer 2 — one local model call over this pass's failure notes.
+    Mutates runner.report; respects runner.dry_run (decisions only)."""
+    if not notes:
+        return
+    existing = [m for m in runner.store.load_all() if m.type == "weakness"]
+    existing_txt = "\n".join(f"[{m.name}] {m.description}" for m in existing) or "(none)"
+    answer = await runner.chat.chat(
+        MINING_PROMPT.format(
+            notes="\n\n".join(n for _, n in notes),
+            existing=existing_txt,
+            max_patterns=MAX_PATTERNS,
+        ),
+        max_tokens=1024,
+    )
+    sids = [sid for sid, _ in notes]
+    known = {m.name for m in existing}
+    for it in _parse_items(answer):
+        target = (it.get("reinforces") or "").strip("`'\" ")
+        name = target if target in known else _slugify(it["pattern"])
+        if name in known:
+            # Recurrence: same pattern seen again → more important, more evidence.
+            mem = runner.store.get(name)
+            runner.report.weaknesses_reinforced += 1
+            runner.report.decisions.append(f"WEAKNESS ~{name} (reinforced): {it['pattern'][:80]}")
+            if not runner.dry_run and mem is not None:
+                mem.importance = min(10, mem.importance + 1)
+                mem.evidence.extend(s for s in sids if s not in mem.evidence)
+                runner.store.save(mem)
+        else:
+            runner.report.weaknesses_added += 1
+            runner.report.decisions.append(f"WEAKNESS +{name}: {it['pattern'][:80]}")
+            if not runner.dry_run:
+                runner.store.save(Memory(
+                    name=name,
+                    type="weakness",
+                    description=it["pattern"][:150],
+                    importance=6,
+                    origin="dream",
+                    evidence=list(sids),
+                    body=(f"{it['pattern']}\n\n**cause:** {it['cause']}\n"
+                          f"**advice:** {it['advice']}"),
+                ))

rockycode/dream/proposals.py

@@ -0,0 +1,440 @@
+"""The proposals inbox (self-evolve phase 1, slice 4) — dream's only actuator.
+
+Memory writes are free; anything EXECUTABLE is proposal-only. The dream may
+draft a skill it thinks the project needs — from hot (reinforced) weaknesses
+and this pass's episodes — but nothing self-installs: drafts land in a global
+pending inbox and the user approves or archives each from the /proposals card
+in the TUI. Approve installs a SKILL.md into the global ~/.rockycode/skills
+(project skills still win discovery); archive keeps the file for provenance —
+nothing is deleted, same rule as memory.
+
+Drafting runs on LOCAL Ollama (episode text may carry exit-sheet-derived
+content, which never goes to a cloud model) and is deliberately scarce:
+at most ONE draft per dream pass, and none while the project already has
+MAX_PENDING_PER_PROJECT waiting — an inbox that piles up is one that gets
+ignored.
+
+Proposal files carry `evidence:` as rk_ PUBLIC session ids (the stable
+human-facing handle; resolve_session maps them back).
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from rockycode.engine.skills import _parse_frontmatter
+
+PENDING, APPROVED, ARCHIVED = "pending", "approved", "archived"
+MAX_PENDING_PER_PROJECT = 3
+HOT_IMPORTANCE = 7  # a weakness reinforced at least once
+
+PROPOSE_PROMPT = """\
+You draft SKILL playbooks for a coding agent — but ONLY when the evidence
+truly supports one. A skill is a reusable, step-by-step procedure the agent
+should follow for a recurring kind of task in this project.
+
+RECURRING WEAKNESSES (reinforced across sessions):
+{weaknesses}
+
+THIS PASS'S SESSION NOTES:
+{episodes}
+
+SKILLS THAT ALREADY EXIST (never re-draft these):
+{existing}
+
+The weaknesses above are already RECURRING — each was observed across
+multiple sessions. If a step-by-step checklist would prevent one of them,
+draft that skill now. With no weaknesses listed, draft only when the session
+notes themselves show a recurring procedure worth packaging. If neither
+holds, reply with exactly: null
+
+Reply with ONLY a JSON object (or the word null):
+{{"name": "short-kebab-case-name",
+  "description": "one line: when the agent should reach for this",
+  "when_to_use": "one or two sentences",
+  "steps": "markdown bullet list of concrete steps"}}
+"""
+
+
+def _home_root() -> Path:
+    base = os.environ.get("ROCKYCODE_HOME")
+    return Path(base).expanduser() if base else Path.home() / ".rockycode"
+
+
+def proposals_dir() -> Path:
+    """Global inbox, $ROCKYCODE_HOME-aware like trajectories. Proposal meta
+    carries project_id, so the TUI filters per project."""
+    return _home_root() / "proposals"
+
+
+def skills_home() -> Path:
+    """Global install target for approved skills (in skill discovery order
+    after the project dirs — a project skill always wins)."""
+    return _home_root() / "skills"
+
+
+@dataclass
+class Proposal:
+    name: str
+    kind: str = "skill"            # skill | (later: routine, prompt-edit)
+    description: str = ""
+    status: str = PENDING
+    origin: str = "dream"
+    created: str = ""
+    project_id: str = ""
+    project_name: str = ""
+    reason: str = ""               # why dream drafted it (weakness/pattern)
+    evidence: list[str] = field(default_factory=list)  # rk_ public session ids
+    body: str = ""                 # the drafted SKILL.md body
+    path: Optional[Path] = None
+
+
+def _slugify(text: str, max_len: int = 48) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
+    return slug[:max_len].rstrip("-") or "proposal"
+
+
+def to_markdown(p: Proposal) -> str:
+    return "\n".join([
+        "---",
+        f"name: {p.name}",
+        f"kind: {p.kind}",
+        f"description: {p.description}",
+        f"status: {p.status}",
+        f"origin: {p.origin}",
+        f"created: {p.created}",
+        f"project_id: {p.project_id}",
+        f"project_name: {p.project_name}",
+        f"reason: {p.reason}",
+        f"evidence: [{', '.join(p.evidence)}]",
+        "---",
+        "",
+        p.body.strip(),
+        "",
+    ])
+
+
+def parse_proposal(text: str, path: Optional[Path] = None) -> Proposal:
+    fields, body = _parse_frontmatter(text)
+    ev = [v.strip().strip("'\"") for v in fields.get("evidence", "").strip("[]").split(",")
+          if v.strip().strip("'\"")]
+    return Proposal(
+        name=fields.get("name") or (path.stem if path else "proposal"),
+        kind=fields.get("kind", "skill"),
+        description=fields.get("description", ""),
+        status=fields.get("status", PENDING),
+        origin=fields.get("origin", "dream"),
+        created=fields.get("created", ""),
+        project_id=fields.get("project_id", ""),
+        project_name=fields.get("project_name", ""),
+        reason=fields.get("reason", ""),
+        evidence=ev,
+        body=body.strip(),
+        path=path,
+    )
+
+
+class ProposalStore:
+    """pending/ approved/ archived/ under one global root — status IS the
+    directory, so `ls` tells the truth and nothing needs a database."""
+
+    def __init__(self, root: Optional[Path] = None) -> None:
+        self.root = root or proposals_dir()
+
+    def list(self, status: str = PENDING, project_id: Optional[str] = None) -> list[Proposal]:
+        folder = self.root / status
+        if not folder.is_dir():
+            return []
+        out = []
+        for f in sorted(folder.glob("*.md")):
+            try:
+                p = parse_proposal(f.read_text(encoding="utf-8", errors="replace"), path=f)
+            except OSError:
+                continue
+            if project_id is None or p.project_id == project_id:
+                out.append(p)
+        return out
+
+    def all_names(self) -> set[str]:
+        """Every proposal name in any status — the dedup set for drafting."""
+        names = set()
+        for status in (PENDING, APPROVED, ARCHIVED):
+            folder = self.root / status
+            if folder.is_dir():
+                names.update(f.stem for f in folder.glob("*.md"))
+        return names
+
+    def save(self, p: Proposal) -> Path:
+        if not p.created:
+            p.created = time.strftime("%Y-%m-%d")
+        folder = self.root / p.status
+        folder.mkdir(parents=True, exist_ok=True)
+        path = folder / f"{_slugify(p.name)}.md"
+        path.write_text(to_markdown(p), encoding="utf-8")
+        p.path = path
+        return path
+
+    def _move(self, p: Proposal, status: str) -> Path:
+        old = p.path
+        p.status = status
+        new_path = self.save(p)
+        if old is not None and old != new_path:
+            try:
+                old.unlink()
+            except OSError:
+                pass
+        return new_path
+
+    def approve(self, p: Proposal) -> Path:
+        """Install the drafted proposal by KIND and file it under approved/ for
+        provenance. A skill installs a SKILL.md; a routine installs a
+        routine.toml (disabled-of-auto, no lease — the user grants the run
+        envelope on the enable card, so nothing dream-drafted ever self-runs).
+        Returns the installed path."""
+        if p.kind == "routine":
+            return self._approve_routine(p)
+        name = _slugify(p.name)
+        target = skills_home() / name
+        while (target / "SKILL.md").exists():
+            name += "-dream"
+            target = skills_home() / name
+        target.mkdir(parents=True, exist_ok=True)
+        skill_md = "\n".join([
+            "---",
+            f"name: {name}",
+            f"description: {p.description}",
+            "origin: dream",
+            f"evidence: [{', '.join(p.evidence)}]",
+            f"project: {p.project_name}",
+            "---",
+            "",
+            p.body.strip(),
+            "",
+        ])
+        installed = target / "SKILL.md"
+        installed.write_text(skill_md, encoding="utf-8")
+        self._move(p, APPROVED)
+        return installed
+
+    def _approve_routine(self, p: Proposal) -> Path:
+        """Install a drafted routine.toml (p.body IS the toml). Installed
+        enabled-but-click-to-run: auto=false and no lease, so it shows as a due
+        card the user runs by hand until they explicitly grant the auto lease —
+        a dream draft never earns unattended execution on its own."""
+        from rockycode.routines import routines_dir
+        name = _slugify(p.name)
+        target = routines_dir() / name
+        while (target / "routine.toml").exists():
+            name += "-dream"
+            target = routines_dir() / name
+        target.mkdir(parents=True, exist_ok=True)
+        (target / "routine.toml").write_text(p.body.strip() + "\n", encoding="utf-8")
+        self._move(p, APPROVED)
+        return target / "routine.toml"
+
+    def archive(self, p: Proposal) -> Path:
+        return self._move(p, ARCHIVED)
+
+
+def failing_routines(project_id: str, *, window: int = 4, min_fails: int = 2) -> list[dict]:
+    """Routines whose recent runs keep failing — the signal for an amendment
+    proposal. A run status is 'done' on success; anything else (blocked/budget/
+    error) counts as a failure. Returns the routine + its recent failure count."""
+    from rockycode.routines import RoutineStore
+    store = RoutineStore()
+    out = []
+    for r in store.list(project_id=project_id):
+        runs = store.state(r).runs[-window:]
+        fails = [x for x in runs if x.get("status") != "done"]
+        if len(runs) >= min_fails and len(fails) >= min_fails:
+            out.append({"routine": r, "fails": len(fails), "of": len(runs),
+                        "last_status": (runs[-1].get("status") if runs else "error")})
+    return out
+
+
+PROPOSE_ROUTINE_PROMPT = """\
+You draft ROUTINES for a coding agent — a routine is a task the agent runs by
+itself on a schedule (daily or weekly). Draft one ONLY when the evidence
+genuinely supports it.
+
+A FAILING ROUTINE that needs amending (fix its prompt/cadence/budget):
+{failing}
+
+THIS PASS'S SESSION NOTES (look for a recurring MANUAL task worth automating):
+{episodes}
+
+ROUTINES THAT ALREADY EXIST (never re-draft these):
+{existing}
+
+If a routine above is failing, draft an amendment (same name, a clearer prompt
+or a smaller/larger cadence). Otherwise, if the notes show the user repeatedly
+doing the same task by hand, draft a routine to do it for them. If neither
+holds, reply with exactly: null
+
+Reply with ONLY a JSON object (or the word null):
+{{"name": "short-kebab-case-name",
+  "description": "one line: what this routine does",
+  "cadence": "daily" or "weekly",
+  "prompt": "the exact task line the agent should run each time"}}
+"""
+
+
+def _parse_routine_draft(answer: str) -> Optional[dict]:
+    if answer.strip().lower().startswith("null"):
+        return None
+    m = re.search(r"\{.*\}", answer, re.DOTALL)
+    if m is None:
+        return None
+    try:
+        obj = json.loads(m.group())
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(obj, dict):
+        return None
+    if obj.get("cadence") not in ("daily", "weekly"):
+        obj["cadence"] = "daily"
+    if not all(isinstance(obj.get(k), str) and obj[k].strip()
+               for k in ("name", "description", "prompt")):
+        return None
+    return obj
+
+
+async def draft_routine_proposals(runner, episode_summaries: list[str], session_ids: list[str]) -> None:
+    """The dream's ROUTINE-proposal job (phase 2, slice 4): amend a failing
+    routine, or propose automating a recurring manual task. Local Ollama only,
+    at most one draft, inbox-capped. Mutates runner.report; respects dry_run."""
+    from rockycode.routines import Routine, RoutineStore, _emit_toml
+    from rockycode.session import get_project, public_id
+
+    store = ProposalStore()
+    project = get_project(runner.workdir)
+    if len(store.list(PENDING, project_id=project.id)) >= MAX_PENDING_PER_PROJECT:
+        return
+
+    failing = failing_routines(project.id)
+    if not failing and len(episode_summaries) < 2:
+        return  # no failing routine and not enough recurrence to automate
+
+    rstore = RoutineStore()
+    existing = "\n".join(f"- {r.name}: {r.description}" for r in rstore.list(project.id)) or "(none)"
+    taken = {r.name for r in rstore.list(project.id)} | store.all_names()
+    fail_txt = "\n".join(
+        f"- {f['routine'].name}: failed {f['fails']}/{f['of']} recent runs "
+        f"(last: {f['last_status']}) — prompt was: {f['routine'].prompt[:160]}"
+        for f in failing) or "(none)"
+
+    runner.log("routine-proposal pass · drafting (local)")
+    answer = await runner.chat.chat(PROPOSE_ROUTINE_PROMPT.format(
+        failing=fail_txt,
+        episodes="\n\n".join(episode_summaries)[:4000],
+        existing=existing,
+    ), max_tokens=1024)
+    draft = _parse_routine_draft(answer)
+    if draft is None:
+        return
+    name = _slugify(draft["name"])
+    is_amendment = any(f["routine"].name == name for f in failing)
+    if name in taken and not is_amendment:
+        return  # a NEW routine can't reuse a name; an amendment reuses on purpose
+
+    # Conservative envelope — the user grants the real one on the enable card.
+    routine = Routine(
+        name=name, description=draft["description"][:200], cadence=draft["cadence"],
+        prompt=draft["prompt"], workdir=str(runner.workdir), project_id=project.id,
+        network=False, isolation=False, budget_run=0.10, max_steps=30,
+        auto=False, lease_deadline=0.0, enabled=True,
+    )
+    reason = (f"amend failing routine '{name}'" if is_amendment
+              else "recurring manual task in episodes")
+    proposal = Proposal(
+        name=name, kind="routine", description=draft["description"][:200],
+        project_id=project.id, project_name=project.name, reason=reason,
+        evidence=[public_id(sid) for sid in session_ids],
+        body=_emit_toml(routine),
+    )
+    if runner.dry_run:
+        runner.log(f"routine proposal (dry-run, not saved): {name} · {reason}")
+        return
+    store.save(proposal)
+    runner.report.proposals_drafted += 1
+    runner.log(f"drafted routine proposal: {name} — /proposals to review · {reason}")
+
+
+def _parse_draft(answer: str) -> Optional[dict]:
+    if answer.strip().lower().startswith("null"):
+        return None
+    m = re.search(r"\{.*\}", answer, re.DOTALL)
+    if m is None:
+        return None
+    try:
+        obj = json.loads(m.group())
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(obj, dict):
+        return None
+    # The prompt asks for a markdown-string `steps`, but stronger models
+    # reasonably emit a JSON array (observed live with qwen3.5:9b) —
+    # normalize a list of strings into bullets instead of voiding the draft.
+    steps = obj.get("steps")
+    if isinstance(steps, list) and steps and all(isinstance(s, str) for s in steps):
+        obj["steps"] = "\n".join(f"- {s.strip()}" for s in steps)
+    if not all(isinstance(obj.get(k), str) and obj[k].strip()
+               for k in ("name", "description", "when_to_use", "steps")):
+        return None
+    return obj
+
+
+async def draft_proposals(runner, episode_summaries: list[str], session_ids: list[str]) -> None:
+    """The dream's proposal job — gate first, one local call, at most one
+    draft. Mutates runner.report; respects runner.dry_run."""
+    from rockycode.engine.skills import discover_skills
+    from rockycode.session import get_project, public_id
+
+    store = ProposalStore()
+    project = get_project(runner.workdir)
+    if len(store.list(PENDING, project_id=project.id)) >= MAX_PENDING_PER_PROJECT:
+        return  # the inbox is full — earn attention before asking for more
+    hot = [m for m in runner.store.load_all()
+           if m.type == "weakness" and m.importance >= HOT_IMPORTANCE]
+    if not hot and len(episode_summaries) < 2:
+        return  # not enough recurrence to package anything
+
+    skills = discover_skills(runner.workdir, home=Path.home())
+    existing = "\n".join(f"- {s.name}: {s.description}" for s in skills) or "(none)"
+    taken = {s.name for s in skills} | store.all_names()
+
+    runner.log("proposal pass · drafting (local)")
+    answer = await runner.chat.chat(PROPOSE_PROMPT.format(
+        weaknesses="\n".join(f"- [{m.name}] {m.description} — {m.body[:200]}" for m in hot) or "(none)",
+        episodes="\n\n".join(episode_summaries)[:4000],
+        existing=existing,
+    ), max_tokens=1536)
+    draft = _parse_draft(answer)
+    if draft is None:
+        return
+    name = _slugify(draft["name"])
+    if name in taken:
+        return  # already exists or already proposed — recurrence isn't novelty
+
+    body = (f"# {draft['name']}\n\n{draft['description']}\n\n"
+            f"## when to use\n{draft['when_to_use']}\n\n"
+            f"## steps\n{draft['steps']}")
+    reason = f"hot weakness: {hot[0].name}" if hot else "recurring pattern in episodes"
+    proposal = Proposal(
+        name=name,
+        description=draft["description"][:200],
+        project_id=project.id,
+        project_name=project.name,
+        reason=reason,
+        evidence=[public_id(sid) for sid in session_ids],
+        body=body,
+    )
+    runner.report.proposals_drafted += 1
+    runner.report.decisions.append(f"PROPOSAL +{name}: {proposal.description[:80]}")
+    if not runner.dry_run:
+        store.save(proposal)

rockycode/engine/__init__.py

@@ -0,0 +1,10 @@
+"""rockycode engine: the model-and-UI-agnostic agent core.
+
+The engine runs the ReAct loop and emits a stream of events. UIs (TUI now,
+desktop later), the trajectory logger, and the future game layer are all
+just subscribers to that stream — none of them are imported here.
+"""
+from rockycode.engine.events import AgentState, Event
+from rockycode.engine.loop import Engine
+
+__all__ = ["Engine", "Event", "AgentState"]