@evo-hq/pi-evo 0.4.2-alpha.2

package/README.md

@@ -0,0 +1,38 @@
+# @evo-hq/pi-evo
+
+Evo plugin for [pi-coding-agent](https://pi.dev) — adds the `/discover`,
+`/optimize`, `/subagent`, and `/infra-setup` skills, plus a `before_provider_request`
+extension that consumes `evo direct` mid-run inject messages.
+
+## Install
+
+```bash
+pi install npm:@evo-hq/pi-evo
+```
+
+Pi auto-registers the extension under `~/.pi/agent/extensions/` and discovers
+the skills under `~/.pi/agent/skills/`. No additional setup steps.
+
+A parallel-subagent provider ([`pi-subagents`](https://pi.dev/packages/pi-subagents))
+is bundled — pi's default toolkit has no fanout primitive, and evo's `optimize`
+skill needs one to run multiple experiments per round.
+
+## What ships in this package
+
+| Path | Purpose |
+|---|---|
+| `extensions/evo/index.js` | Bundled JS that hooks `before_provider_request`, drains the workspace inject queue, appends `[evo direct]` directives to the outgoing LLM payload |
+| `skills/discover/` | First-run setup: explore repo, propose optimization dimensions, build benchmark, run first experiment |
+| `skills/optimize/` | The search loop: parallel subagents form hypotheses, edit, get scored, frontier picks next branch |
+| `skills/subagent/` | Per-experiment brief contract for the optimize round's fanout |
+| `skills/infra-setup/` | Provider matrix for remote-sandbox backends (Modal, E2B, Daytona, etc.) |
+
+## Versioning
+
+This package is versioned in lockstep with the [evo-hq/evo](https://github.com/evo-hq/evo)
+release line. The skills + bundled extension are sync'd from `plugins/evo/` in
+the source repo at publish time (see `scripts/sync-from-source.sh`).
+
+## Source
+
+[github.com/evo-hq/evo](https://github.com/evo-hq/evo) (Apache-2.0)

package/extensions/evo/index.js

@@ -0,0 +1,244 @@
+// ../opencode_plugin/drain.ts
+import * as fs from "fs";
+import * as path from "path";
+var QUEUE_SCHEMA_VERSION = 1;
+function injectRoot(runDir) {
+  return path.join(runDir, "inject");
+}
+function sessionFile(runDir, sid) {
+  return path.join(injectRoot(runDir), "sessions", `${sid}.json`);
+}
+function workspaceEventsPath(runDir) {
+  return path.join(injectRoot(runDir), "events", "workspace.jsonl");
+}
+function expEventsPath(runDir, expId) {
+  return path.join(injectRoot(runDir), "events", `${expId}.jsonl`);
+}
+function offsetFile(runDir, sid) {
+  return path.join(injectRoot(runDir), "offsets", `${sid}.json`);
+}
+function markerFile(runDir, sid) {
+  return path.join(injectRoot(runDir), "markers", `${sid}.flag`);
+}
+function readJsonOrNull(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function atomicWriteJson(p, data) {
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  const tmp = `${p}.tmp.${process.pid}`;
+  fs.writeFileSync(tmp, JSON.stringify(data));
+  fs.renameSync(tmp, p);
+}
+function unlinkIfExists(p) {
+  try {
+    fs.unlinkSync(p);
+  } catch {}
+}
+function readEventsAfter(queuePath, afterId) {
+  if (!fs.existsSync(queuePath))
+    return [];
+  let text;
+  try {
+    text = fs.readFileSync(queuePath, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of text.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    let rec;
+    try {
+      rec = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const recId = rec?.id;
+    if (typeof recId !== "string")
+      continue;
+    if (afterId === null || recId > afterId) {
+      out.push(rec);
+    }
+  }
+  return out;
+}
+function readOffset(runDir, sid, queue) {
+  const data = readJsonOrNull(offsetFile(runDir, sid));
+  if (!data)
+    return null;
+  if (queue === "workspace")
+    return data.last_workspace_event_id ?? null;
+  if (queue === "exp")
+    return data.last_exp_event_id ?? null;
+  return null;
+}
+function nowIso() {
+  return new Date().toISOString().replace(/\.\d{3}Z$/, "+00:00");
+}
+function writeOffset(runDir, sid, opts) {
+  const p = offsetFile(runDir, sid);
+  let data = readJsonOrNull(p) ?? {};
+  data.schema_version = QUEUE_SCHEMA_VERSION;
+  data.session_id = sid;
+  if (opts.workspaceId !== undefined && opts.workspaceId !== null) {
+    data.last_workspace_event_id = opts.workspaceId;
+  }
+  if (opts.expId !== undefined && opts.expId !== null) {
+    data.last_exp_event_id = opts.expId;
+  }
+  data.updated_at = nowIso();
+  atomicWriteJson(p, data);
+}
+function formatDirectiveText(events) {
+  const lines = [];
+  for (const ev of events) {
+    if (ev.text)
+      lines.push(`[evo direct] ${ev.text}`);
+  }
+  return lines.join(`
+`);
+}
+function getSession(runDir, sid) {
+  return readJsonOrNull(sessionFile(runDir, sid));
+}
+function isRegistered(runDir, sid) {
+  return fs.existsSync(sessionFile(runDir, sid));
+}
+var REGISTRY_SCHEMA_VERSION = 1;
+function registerSession(runDir, sid, host, expId = null) {
+  const p = sessionFile(runDir, sid);
+  const now = nowIso();
+  const existing = readJsonOrNull(p);
+  if (existing) {
+    existing.last_seen_at = now;
+    atomicWriteJson(p, existing);
+    return;
+  }
+  const rec = {
+    schema_version: REGISTRY_SCHEMA_VERSION,
+    session_id: sid,
+    host,
+    pid: process.pid,
+    registered_at: now,
+    last_seen_at: now,
+    exp_id: expId,
+    parent_session_id: null
+  };
+  atomicWriteJson(p, rec);
+}
+function findEvoRunDir(cwd) {
+  const envRunDir = process.env.EVO_RUN_DIR;
+  if (envRunDir)
+    return envRunDir;
+  let dir = cwd || process.cwd();
+  while (dir !== "/" && dir !== "") {
+    const evoDir = path.join(dir, ".evo");
+    if (fs.existsSync(evoDir)) {
+      try {
+        const runs = fs.readdirSync(evoDir).filter((n) => n.startsWith("run_")).sort();
+        if (runs.length === 0)
+          return null;
+        return path.join(evoDir, runs[runs.length - 1]);
+      } catch {
+        return null;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function drainSession(runDir, sessionId) {
+  const sess = getSession(runDir, sessionId);
+  if (!sess) {
+    unlinkIfExists(markerFile(runDir, sessionId));
+    return { text: null, newWorkspaceOffset: null, newExpOffset: null };
+  }
+  const expId = sess.exp_id;
+  let events = [];
+  let newWorkspaceOffset = null;
+  let newExpOffset = null;
+  if (expId) {
+    const lastId = readOffset(runDir, sessionId, "exp");
+    const newEvents = readEventsAfter(expEventsPath(runDir, expId), lastId);
+    events = newEvents;
+    if (newEvents.length > 0)
+      newExpOffset = newEvents[newEvents.length - 1].id;
+  } else {
+    const lastId = readOffset(runDir, sessionId, "workspace");
+    const newEvents = readEventsAfter(workspaceEventsPath(runDir), lastId);
+    events = newEvents;
+    if (newEvents.length > 0)
+      newWorkspaceOffset = newEvents[newEvents.length - 1].id;
+  }
+  const text = events.length > 0 ? formatDirectiveText(events) : null;
+  if (newWorkspaceOffset || newExpOffset) {
+    writeOffset(runDir, sessionId, {
+      workspaceId: newWorkspaceOffset,
+      expId: newExpOffset
+    });
+  }
+  unlinkIfExists(markerFile(runDir, sessionId));
+  return { text, newWorkspaceOffset, newExpOffset };
+}
+
+// index.ts
+import * as crypto from "crypto";
+function deriveSessionId() {
+  const hash = crypto.createHash("sha256").update(process.cwd()).digest("hex").slice(0, 12);
+  return `openclaw-${hash}`;
+}
+function register(api) {
+  const drainedTexts = [];
+  const ensureRegistered = () => {
+    const runDir = findEvoRunDir();
+    if (!runDir)
+      return null;
+    const sid = deriveSessionId();
+    if (!isRegistered(runDir, sid)) {
+      registerSession(runDir, sid, "openclaw");
+    }
+    return { sid, runDir };
+  };
+  const appendToPayload = (event, text) => {
+    if (Array.isArray(event.payload?.input)) {
+      event.payload.input.push({
+        role: "user",
+        content: [{ type: "input_text", text }]
+      });
+    } else if (Array.isArray(event.payload?.messages)) {
+      event.payload.messages.push({
+        role: "user",
+        content: [{ type: "text", text }]
+      });
+    }
+  };
+  api.on("session_start", () => {
+    ensureRegistered();
+  });
+  api.on("before_provider_request", (event, _ctx) => {
+    const ctx = ensureRegistered();
+    if (!ctx)
+      return;
+    const result = drainSession(ctx.runDir, ctx.sid);
+    if (result.text)
+      drainedTexts.push(result.text);
+    if (drainedTexts.length === 0)
+      return;
+    const combined = drainedTexts.join(`
+`);
+    appendToPayload(event, combined);
+    return event.payload;
+  });
+}
+export {
+  register as default
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@evo-hq/pi-evo",
+  "version": "0.4.2-alpha.2",
+  "description": "Evo plugin for pi-coding-agent: optimize/discover/subagent skills + mid-run inject extension.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "evo",
+    "evo-hq",
+    "coding-agent",
+    "optimization"
+  ],
+  "pi": {
+    "extensions": ["./extensions"],
+    "skills": ["./skills"]
+  },
+  "dependencies": {
+    "pi-subagents": "*"
+  },
+  "bundledDependencies": ["pi-subagents"],
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "pi-agent-core": "*",
+    "pi-coding-agent": "*",
+    "pi-tui": "*",
+    "typebox": "*"
+  },
+  "files": ["extensions", "skills", "README.md", "LICENSE"],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/evo-hq/evo.git",
+    "directory": "plugins/evo/npm"
+  },
+  "homepage": "https://github.com/evo-hq/evo#readme",
+  "bugs": "https://github.com/evo-hq/evo/issues"
+}