agent-procedures 0.1.0 → 0.3.0

package/lib/main.js

@@ -0,0 +1,51 @@
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { handleEvent } from "./engine.js";
+import { runGroomer } from "./groomer.js";
+import { getHarness } from "./harnesses/index.js";
+
+// Bundled to <repo>/.reflex/runtime.js. That file sits inside .reflex/.
+const REFLEX_DIR = path.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();
+}
+
+export async function run(harnessId, argv = process.argv.slice(2)) {
+  const [eventName] = argv;
+  if (!eventName) return;
+
+  if (eventName === "Groom") {
+    await runGroomer(path.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");
+}

package/lib/providers.js

@@ -0,0 +1,178 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+// Shared by `auth` (CLI) and the groomer (background hook). Keep dependency-free.
+
+export function reflexHome() {
+  return process.env.REFLEX_HOME || path.join(os.homedir(), ".reflex");
+}
+
+export function credentialsFile() {
+  return path.join(reflexHome(), "credentials.json");
+}
+
+const 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 {
+    // All three providers return { error: { message } } on failure.
+    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}` : ""}`);
+}
+
+export const 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;
+    },
+  },
+};
+
+export const PROVIDER_NAMES = Object.keys(PROVIDERS);
+
+export function readCredentials() {
+  const file = credentialsFile();
+  if (!fs.existsSync(file)) return null;
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+/**
+ * Resolve which provider/key/model the groomer should use.
+ *
+ * Provider: credentials.json's defaultProvider if present, else the first
+ * provider with an env var set.
+ * Key: the provider's env var wins over the stored key.
+ * Model: stored model, else the provider default.
+ *
+ * Returns null if nothing usable is found.
+ */
+export 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",
+  };
+}

package/lib/store.js

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import path from "node:path";
+
+// Disk layout under .reflex/. Harness-free.
+
+export 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));
+}
+
+export function traceFile(reflexDir, sessionId, promptId) {
+  return path.join(paths(reflexDir).tracesDir, sessionId, `${promptId}.jsonl`);
+}
+
+export 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");
+}
+
+export 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");
+}
+
+export function readTrace(reflexDir, sessionId, promptId) {
+  return readJsonl(traceFile(reflexDir, sessionId, promptId));
+}
+
+export function deleteTrace(reflexDir, sessionId, promptId) {
+  try {
+    fs.unlinkSync(traceFile(reflexDir, sessionId, promptId));
+  } catch (e) {}
+}
+
+export function readProcedures(reflexDir) {
+  return readJsonl(paths(reflexDir).proceduresFile);
+}
+
+export 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");
+}

package/package.json

@@ -1,16 +1,25 @@
 {
   "name": "agent-procedures",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Procedural memory for coding agents",
   "type": "module",
-  "bin": "./bin/cli.js",
+  "bin": {
+    "agent-procedures": "bin/cli.js"
+  },
   "files": [
     "bin",
-    "lib"
+    "lib",
+    "dist"
   ],
   "engines": {
     "node": ">=18"
   },
+  "scripts": {
+    "build": "node scripts/build.js",
+    "pretest": "node scripts/build.js",
+    "prepublishOnly": "node scripts/build.js",
+    "test": "vitest run"
+  },
   "keywords": [
     "agents",
     "coding-agents",
@@ -27,5 +36,9 @@
   "bugs": {
     "url": "https://github.com/itskrishna21/reflex/issues"
   },
-  "homepage": "https://github.com/itskrishna21/reflex#readme"
+  "homepage": "https://github.com/itskrishna21/reflex#readme",
+  "devDependencies": {
+    "esbuild": "^0.28.2",
+    "vitest": "^5.0.3"
+  }
 }