agent-procedures 0.1.0 → 0.3.0

package/dist/runtime.js

@@ -0,0 +1,569 @@
+// Generated by agent-procedures@0.3.0. Do not edit.
+// To upgrade: npx agent-procedures init
+
+// lib/main.js
+import path5 from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+// lib/store.js
+import fs from "node:fs";
+import path from "node:path";
+function paths(reflexDir) {
+  return {
+    reflexDir,
+    tracesDir: path.join(reflexDir, "traces"),
+    proceduresFile: path.join(reflexDir, "procedures.jsonl")
+  };
+}
+function readJsonl(file) {
+  if (!fs.existsSync(file)) return [];
+  return fs.readFileSync(file, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+}
+function traceFile(reflexDir, sessionId, promptId) {
+  return path.join(paths(reflexDir).tracesDir, sessionId, `${promptId}.jsonl`);
+}
+function startTrace(reflexDir, sessionId, promptId, goal) {
+  const file = traceFile(reflexDir, sessionId, promptId);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(goal) + "\n", "utf8");
+}
+function appendTrace(reflexDir, sessionId, promptId, line) {
+  const file = traceFile(reflexDir, sessionId, promptId);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, JSON.stringify(line) + "\n", "utf8");
+}
+function readTrace(reflexDir, sessionId, promptId) {
+  return readJsonl(traceFile(reflexDir, sessionId, promptId));
+}
+function deleteTrace(reflexDir, sessionId, promptId) {
+  try {
+    fs.unlinkSync(traceFile(reflexDir, sessionId, promptId));
+  } catch (e) {
+  }
+}
+function readProcedures(reflexDir) {
+  return readJsonl(paths(reflexDir).proceduresFile);
+}
+function appendProcedure(reflexDir, node) {
+  const file = paths(reflexDir).proceduresFile;
+  if (!fs.existsSync(file)) fs.writeFileSync(file, "", "utf8");
+  fs.appendFileSync(file, JSON.stringify(node) + "\n", "utf8");
+}
+
+// lib/engine.js
+function handleEvent(evt, reflexDir, deps = {}) {
+  if (!evt || !evt.sessionId || !evt.promptId) return { context: null };
+  if (evt.type === "prompt") return onPrompt(evt, reflexDir);
+  if (evt.type === "tool") return onTool(evt, reflexDir);
+  if (evt.type === "stop") return onStop(evt, reflexDir, deps);
+  return { context: null };
+}
+var GROOM_THRESHOLD = 5;
+function onPrompt(evt, reflexDir) {
+  const { sessionId, promptId, prompt } = evt;
+  startTrace(reflexDir, sessionId, promptId, { t: "Goal", prompt });
+  const hit = recall(prompt, readProcedures(reflexDir));
+  if (!hit) return { context: null };
+  appendTrace(reflexDir, sessionId, promptId, { t: "Recall", hit: hit.node.id });
+  return { context: hit.text };
+}
+function recall(prompt, procs) {
+  if (!prompt) return null;
+  const p = prompt.toLowerCase();
+  const fmt = (steps) => steps.map((s) => `- ${s.t}: ${s.target}`).join("\n");
+  for (const node of procs) {
+    if (node.enabled === false || node.parent_id) continue;
+    let match = node.trigger && p.includes(node.trigger.toLowerCase());
+    if (!match && Array.isArray(node.aliases)) {
+      match = node.aliases.some((a) => p.includes(a.toLowerCase()));
+    }
+    if (!match) continue;
+    let text = fmt(node.steps);
+    const alt = procs.find((e) => e.parent_id === node.id && e.type === "alt" && e.enabled !== false);
+    const onFail = procs.find((e) => e.parent_id === node.id && e.type === "on_fail" && e.enabled !== false);
+    if (alt) text += "\n\nAlternative path that worked:\n" + fmt(alt.steps);
+    if (onFail) text += "\n\nIf it fails, this recovery worked:\n" + fmt(onFail.steps);
+    return {
+      node,
+      text: `Reflex memory found a procedure for this task:
+
+${text}
+
+Follow these steps instead of figuring it out from scratch.`
+    };
+  }
+  return null;
+}
+function onTool(evt, reflexDir) {
+  appendTrace(reflexDir, evt.sessionId, evt.promptId, { t: evt.tool, target: evt.target || "", ok: evt.ok });
+  return { context: null };
+}
+function onStop(evt, reflexDir, deps) {
+  const { sessionId, promptId } = evt;
+  const lines = readTrace(reflexDir, sessionId, promptId);
+  if (lines.length === 0) return { context: null };
+  let goal = "";
+  let recallHit = null;
+  for (const l of lines) {
+    if (l.t === "Goal") goal = l.prompt;
+    if (l.t === "Recall" && l.hit) recallHit = l.hit;
+  }
+  if (judge(lines, evt)) {
+    const steps = synthesize(lines);
+    if (steps.length > 0) {
+      if (!recallHit) {
+        appendProcedure(reflexDir, {
+          id: Math.random().toString(36).slice(2, 11),
+          title: goal,
+          trigger: goal,
+          steps,
+          enabled: true,
+          hits: 0,
+          last_used_at: (/* @__PURE__ */ new Date()).toISOString(),
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "pending_review"
+        });
+      } else {
+        const parent = readProcedures(reflexDir).find((p) => p.id === recallHit);
+        const parentSteps = parent ? parent.steps : [];
+        const same = parentSteps.length === steps.length && parentSteps.every((s, i) => s.t === steps[i].t && s.target === steps[i].target);
+        if (!same) {
+          appendProcedure(reflexDir, {
+            parent_id: recallHit,
+            type: "alt",
+            steps,
+            created_at: (/* @__PURE__ */ new Date()).toISOString(),
+            status: "pending_review"
+          });
+        }
+      }
+      const pending = readProcedures(reflexDir).filter((p) => p.status === "pending_review").length;
+      if (pending >= GROOM_THRESHOLD && deps.spawnGroomer) deps.spawnGroomer();
+    }
+  }
+  deleteTrace(reflexDir, sessionId, promptId);
+  return { context: null };
+}
+var READ_ONLY_CMDS = ["cat", "ls", "git", "pwd", "head", "tail", "echo", "grep", "find"];
+var PURE_READ_CMDS = ["cat", "ls", "pwd", "head", "tail"];
+function isMutating(t, target) {
+  if (t === "Edit" || t === "Write" || t === "NotebookEdit") return true;
+  if (t === "Bash" || t === "bash") {
+    const cmd = (target || "").trim();
+    if (!cmd) return false;
+    const first = cmd.split(" ")[0];
+    if (READ_ONLY_CMDS.includes(first)) {
+      return first === "git" && /\s(commit|push|add|rm|mv)\b/.test(cmd);
+    }
+    return true;
+  }
+  return false;
+}
+function judge(lines, evt) {
+  const steps = lines.filter((l) => l.t !== "Goal" && l.t !== "Recall");
+  if (!steps.some((l) => isMutating(l.t, l.target))) return false;
+  if (evt.interrupted || evt.busy) return false;
+  const failed = /* @__PURE__ */ new Set();
+  for (const l of steps) {
+    const key = `${l.t}|${l.target}`;
+    if (l.ok === false) failed.add(key);
+    else if (l.ok === true) failed.delete(key);
+  }
+  return failed.size === 0;
+}
+function synthesize(lines) {
+  const steps = [];
+  for (const l of lines) {
+    if (l.t === "Goal" || l.t === "Recall" || l.ok === false) continue;
+    if (l.t === "Read" || l.t === "View") continue;
+    if (l.t === "Bash" || l.t === "bash") {
+      const target = l.target || "";
+      if (PURE_READ_CMDS.includes(target.trim().split(" ")[0])) continue;
+      if (/^git (status|log|diff)/.test(target)) continue;
+    }
+    steps.push({ t: l.t, target: l.target });
+  }
+  return steps;
+}
+
+// lib/groomer.js
+import fs3 from "node:fs";
+import path3 from "node:path";
+
+// lib/providers.js
+import fs2 from "node:fs";
+import path2 from "node:path";
+import os from "node:os";
+function reflexHome() {
+  return process.env.REFLEX_HOME || path2.join(os.homedir(), ".reflex");
+}
+function credentialsFile() {
+  return path2.join(reflexHome(), "credentials.json");
+}
+var SYSTEM_PROMPT = "You are the Reflex graph groomer. Your job is to review execution edges from coding agents, drop bad ones, and add semantic aliases.";
+async function expectOk(res, label) {
+  if (res.ok) return;
+  let detail = await res.text().catch(() => "");
+  try {
+    detail = JSON.parse(detail).error?.message || detail;
+  } catch (e) {
+  }
+  detail = detail.replace(/\s+/g, " ").trim().slice(0, 200);
+  throw new Error(`${label} API error: ${res.status} ${res.statusText}${detail ? ` - ${detail}` : ""}`);
+}
+var PROVIDERS = {
+  anthropic: {
+    label: "Anthropic",
+    envVar: "ANTHROPIC_API_KEY",
+    defaultModel: "claude-haiku-4-5",
+    keyPrefix: "sk-ant-",
+    keysUrl: "https://console.anthropic.com/settings/keys",
+    async verify(apiKey) {
+      const res = await fetch("https://api.anthropic.com/v1/models?limit=1", {
+        headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" }
+      });
+      await expectOk(res, "Anthropic");
+    },
+    async complete(apiKey, model, prompt) {
+      const res = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: 1024,
+          system: SYSTEM_PROMPT,
+          messages: [{ role: "user", content: prompt }]
+        })
+      });
+      await expectOk(res, "Anthropic");
+      const data = await res.json();
+      return data.content[0].text;
+    }
+  },
+  openai: {
+    label: "OpenAI",
+    envVar: "OPENAI_API_KEY",
+    defaultModel: "gpt-6-luna",
+    keyPrefix: "sk-",
+    keysUrl: "https://platform.openai.com/api-keys",
+    async verify(apiKey) {
+      const res = await fetch("https://api.openai.com/v1/models", {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      await expectOk(res, "OpenAI");
+    },
+    async complete(apiKey, model, prompt) {
+      const res = await fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: 1024,
+          messages: [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: prompt }
+          ]
+        })
+      });
+      await expectOk(res, "OpenAI");
+      const data = await res.json();
+      return data.choices[0].message.content;
+    }
+  },
+  gemini: {
+    label: "Gemini",
+    envVar: "GEMINI_API_KEY",
+    defaultModel: "gemini-3.5-flash-lite",
+    keyPrefix: "AIza",
+    keysUrl: "https://aistudio.google.com/apikey",
+    async verify(apiKey) {
+      const res = await fetch(
+        "https://generativelanguage.googleapis.com/v1beta/models?pageSize=1",
+        { headers: { "x-goog-api-key": apiKey } }
+      );
+      await expectOk(res, "Gemini");
+    },
+    async complete(apiKey, model, prompt) {
+      const res = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`,
+        {
+          method: "POST",
+          headers: {
+            "x-goog-api-key": apiKey,
+            "content-type": "application/json"
+          },
+          body: JSON.stringify({
+            system_instruction: { parts: [{ text: SYSTEM_PROMPT }] },
+            contents: [{ role: "user", parts: [{ text: prompt }] }],
+            generationConfig: { maxOutputTokens: 1024 }
+          })
+        }
+      );
+      await expectOk(res, "Gemini");
+      const data = await res.json();
+      return data.candidates[0].content.parts[0].text;
+    }
+  }
+};
+var PROVIDER_NAMES = Object.keys(PROVIDERS);
+function readCredentials() {
+  const file = credentialsFile();
+  if (!fs2.existsSync(file)) return null;
+  return JSON.parse(fs2.readFileSync(file, "utf8"));
+}
+function resolveCredentials(env = process.env) {
+  let stored = null;
+  try {
+    stored = readCredentials();
+  } catch (e) {
+    throw new Error(`Failed to parse ${credentialsFile()}: ${e.message}`);
+  }
+  let provider = stored?.defaultProvider;
+  if (!provider) {
+    provider = PROVIDER_NAMES.find((p) => env[PROVIDERS[p].envVar]);
+  }
+  if (!provider || !PROVIDERS[provider]) return null;
+  const def = PROVIDERS[provider];
+  const entry = stored?.providers?.[provider] || {};
+  const envKey = env[def.envVar];
+  const apiKey = envKey || entry.apiKey;
+  if (!apiKey) return null;
+  return {
+    provider,
+    apiKey,
+    model: entry.model || def.defaultModel,
+    source: envKey ? "env" : "file"
+  };
+}
+
+// lib/groomer.js
+function logError(proceduresFile, msg) {
+  const reflexDir = path3.dirname(proceduresFile);
+  const logFile = path3.join(reflexDir, "worker.log");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    fs3.appendFileSync(logFile, `[${timestamp}] ${msg}
+`, "utf8");
+  } catch (e) {
+  }
+}
+async function runGroomer(proceduresFile) {
+  let creds;
+  try {
+    creds = resolveCredentials();
+  } catch (e) {
+    logError(proceduresFile, e.message);
+    return;
+  }
+  if (!creds) {
+    logError(
+      proceduresFile,
+      "No API key found. Run `npx agent-procedures auth login` or set ANTHROPIC_API_KEY / OPENAI_API_KEY / GEMINI_API_KEY."
+    );
+    return;
+  }
+  const { provider, apiKey, model } = creds;
+  if (!fs3.existsSync(proceduresFile)) return;
+  const lines = fs3.readFileSync(proceduresFile, "utf8").split("\n").filter(Boolean);
+  const nodes = lines.map((l) => {
+    try {
+      return JSON.parse(l);
+    } catch (e) {
+      return null;
+    }
+  }).filter(Boolean);
+  const pending = nodes.filter((n) => n.status === "pending_review");
+  if (pending.length === 0) return;
+  const prompt = `
+Here are ${pending.length} new execution nodes/edges added by a coding agent.
+
+<edges>
+${JSON.stringify(pending, null, 2)}
+</edges>
+
+For each item:
+1) Did the agent verify this worked? (e.g. ran a test, checked a log). If it just wrote code and blindly stopped without checking, it's risky.
+2) Is this a generic/reusable workflow, or a one-off anomaly?
+If it's unverified and risky, or a pure anomaly, decide to DROP it.
+If it's good, KEEP it.
+
+If you KEEP a root node (has no parent_id), generate 5-10 semantic aliases (synonyms) for its 'trigger' text so we can match variations of the user's prompt later.
+
+Return ONLY a JSON array of objects with this schema:
+[
+  {
+    "id": "node_id",
+    "action": "KEEP" | "DROP",
+    "aliases": ["alias1", "alias2"] // only if KEEP and root node
+  }
+]
+`;
+  let responseText;
+  try {
+    responseText = await PROVIDERS[provider].complete(apiKey, model, prompt);
+  } catch (err) {
+    logError(proceduresFile, err.message);
+    return;
+  }
+  let actions = [];
+  try {
+    const jsonStr = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
+    actions = JSON.parse(jsonStr);
+  } catch (e) {
+    logError(
+      proceduresFile,
+      "Failed to parse LLM JSON response: " + responseText
+    );
+    return;
+  }
+  const newNodes = [];
+  for (const node of nodes) {
+    if (node.status === "pending_review") {
+      const actionDef = actions.find((a) => a.id === node.id);
+      if (actionDef) {
+        if (actionDef.action === "DROP") {
+          continue;
+        } else {
+          delete node.status;
+          if (!node.parent_id && actionDef.aliases) {
+            node.aliases = actionDef.aliases;
+          }
+        }
+      }
+    }
+    newNodes.push(node);
+  }
+  const newFileContent = newNodes.map((n) => JSON.stringify(n)).join("\n") + "\n";
+  const tmpFile = proceduresFile + ".tmp";
+  try {
+    fs3.writeFileSync(tmpFile, newFileContent, "utf8");
+    fs3.renameSync(tmpFile, proceduresFile);
+  } catch (err) {
+    logError(proceduresFile, `Failed atomic write: ${err.message}`);
+  }
+}
+
+// lib/harnesses/claude.js
+import fs4 from "node:fs";
+import path4 from "node:path";
+var EVENTS = ["UserPromptSubmit", "PostToolUse", "PostToolUseFailure", "Stop"];
+var claude_default = {
+  id: "claude",
+  /** Where the generated hook shim goes, relative to the repo root. */
+  hookFile: ".claude/hooks/reflex.mjs",
+  /** Merge our hooks into .claude/settings.json without touching anything else. */
+  register(cwd) {
+    const settingsPath = path4.join(cwd, ".claude", "settings.json");
+    let settings = {};
+    if (fs4.existsSync(settingsPath)) {
+      try {
+        settings = JSON.parse(fs4.readFileSync(settingsPath, "utf8"));
+      } catch (e) {
+        console.warn("Failed to parse existing .claude/settings.json, overwriting...");
+      }
+    }
+    settings.hooks = settings.hooks || {};
+    for (const event of EVENTS) {
+      if (!Array.isArray(settings.hooks[event])) settings.hooks[event] = [];
+      const command = `node "$CLAUDE_PROJECT_DIR/${this.hookFile}" ${event}`;
+      const wired = settings.hooks[event].some((g) => (g.hooks || []).some((h) => h.command === command));
+      if (!wired) settings.hooks[event].push({ hooks: [{ type: "command", command }] });
+    }
+    fs4.mkdirSync(path4.dirname(settingsPath), { recursive: true });
+    fs4.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  },
+  /** Claude's stdin payload → normalized engine event, or null to ignore. */
+  normalize(eventName, payload) {
+    const name = payload.hook_event_name || eventName;
+    const base = { sessionId: payload.session_id, promptId: payload.prompt_id };
+    if (name === "UserPromptSubmit") {
+      return { type: "prompt", ...base, prompt: payload.prompt };
+    }
+    if (name === "PostToolUse" || name === "PostToolUseFailure") {
+      const tool = payload.tool_name;
+      const input = payload.tool_input || {};
+      let target = "";
+      if (tool === "Bash" || tool === "bash") target = input.command || "";
+      else if (typeof input === "string") target = input;
+      else target = input.target || input.file_path || input.path || "";
+      return { type: "tool", ...base, tool, target, ok: name === "PostToolUse" };
+    }
+    if (name === "Stop") {
+      return {
+        type: "stop",
+        ...base,
+        interrupted: payload.stop_hook_active === true,
+        busy: Array.isArray(payload.background_tasks) && payload.background_tasks.length > 0
+      };
+    }
+    return null;
+  },
+  /** Engine result → what to print on stdout for Claude. */
+  render(evt, result) {
+    if (evt.type !== "prompt") return "";
+    if (!result.context) return "{}";
+    return JSON.stringify({
+      hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: result.context }
+    });
+  }
+};
+
+// lib/harnesses/index.js
+var HARNESSES = { claude: claude_default };
+var DEFAULT_HARNESS = "claude";
+function getHarness(id = DEFAULT_HARNESS) {
+  const h = HARNESSES[id];
+  if (!h) {
+    throw new Error(`Unknown harness "${id}". Available: ${Object.keys(HARNESSES).join(", ")}`);
+  }
+  return h;
+}
+
+// lib/main.js
+var REFLEX_DIR = path5.dirname(fileURLToPath(import.meta.url));
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => data += c);
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", () => resolve(data));
+  });
+}
+function spawnGroomer() {
+  const child = spawn(process.argv[0], [process.argv[1], "Groom"], { detached: true, stdio: "ignore" });
+  child.unref();
+}
+async function run(harnessId, argv = process.argv.slice(2)) {
+  const [eventName] = argv;
+  if (!eventName) return;
+  if (eventName === "Groom") {
+    await runGroomer(path5.join(REFLEX_DIR, "procedures.jsonl"));
+    return;
+  }
+  const raw = await readStdin();
+  if (!raw) return;
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch (e) {
+    return;
+  }
+  const harness = getHarness(harnessId);
+  const evt = harness.normalize(eventName, payload);
+  if (!evt) return;
+  const result = handleEvent(evt, REFLEX_DIR, { spawnGroomer });
+  const out = harness.render(evt, result);
+  if (out) process.stdout.write(out + "\n");
+}
+export {
+  run
+};