@agentprojectcontext/apx 1.24.0 → 1.27.1

package/src/host/daemon/api/config.js

@@ -0,0 +1,104 @@
+// Per-project config (.apc/config.json) — read, full replace, dotted patch.
+//   GET   /projects/:pid/config        effective + project-only
+//   PUT   /projects/:pid/config        full replace of project-only file
+//   PATCH /projects/:pid/config        { set?: {dotted: value}, unset?: [dotted] }
+import path from "node:path";
+import fs from "node:fs";
+import {
+  readProjectConfig,
+  writeProjectConfig,
+  setDottedKey,
+  unsetDottedKey,
+} from "../project-config.js";
+
+function projectJsonPath(root) {
+  return path.join(root, ".apc", "project.json");
+}
+
+function readProjectJson(root) {
+  const p = projectJsonPath(root);
+  if (!fs.existsSync(p)) return {};
+  return JSON.parse(fs.readFileSync(p, "utf8"));
+}
+
+function writeProjectJson(root, body) {
+  const p = projectJsonPath(root);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(body, null, 2) + "\n");
+}
+
+export function register(app, { projects, project }) {
+  app.get("/projects/:pid/config", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    res.json({
+      effective: p.config || {},
+      project_only: readProjectConfig(p.path),
+      project_config_path: path.join(p.path, ".apc", "config.json"),
+      apc_project: readProjectJson(p.path),
+      project_json_path: projectJsonPath(p.path),
+    });
+  });
+
+  app.put("/projects/:pid/config", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const body = req.body || {};
+    if (typeof body !== "object" || Array.isArray(body))
+      return res.status(400).json({ error: "body must be a JSON object" });
+    writeProjectConfig(p.path, body);
+    projects.rebuild(p.id);
+    res.json({ ok: true });
+  });
+
+  app.patch("/projects/:pid/config", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const { set, unset } = req.body || {};
+    const cfg = readProjectConfig(p.path);
+    if (set && typeof set === "object") {
+      for (const [k, v] of Object.entries(set)) setDottedKey(cfg, k, v);
+    }
+    if (Array.isArray(unset)) {
+      for (const k of unset) unsetDottedKey(cfg, k);
+    }
+    writeProjectConfig(p.path, cfg);
+    projects.rebuild(p.id);
+    res.json({ ok: true, project_only: cfg });
+  });
+
+  app.put("/projects/:pid/apc-project", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const body = req.body || {};
+    if (typeof body !== "object" || Array.isArray(body))
+      return res.status(400).json({ error: "body must be a JSON object" });
+    try {
+      writeProjectJson(p.path, body);
+      projects.rebuild(p.id);
+      res.json({ ok: true, apc_project: body });
+    } catch (e) {
+      res.status(400).json({ error: e.message });
+    }
+  });
+
+  app.patch("/projects/:pid/apc-project", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    try {
+      const { set, unset } = req.body || {};
+      const cfg = readProjectJson(p.path);
+      if (set && typeof set === "object") {
+        for (const [k, v] of Object.entries(set)) setDottedKey(cfg, k, v);
+      }
+      if (Array.isArray(unset)) {
+        for (const k of unset) unsetDottedKey(cfg, k);
+      }
+      writeProjectJson(p.path, cfg);
+      projects.rebuild(p.id);
+      res.json({ ok: true, apc_project: cfg });
+    } catch (e) {
+      res.status(400).json({ error: e.message });
+    }
+  });
+}

package/src/host/daemon/api/connections.js

@@ -0,0 +1,42 @@
+// GET /projects/:pid/agents/:slug/connections
+// Builds a per-peer summary of an agent's a2a traffic from the messages store.
+import { readAgents } from "../../../core/parser.js";
+import { readProjectMessages } from "../../../core/messages-store.js";
+
+export function register(app, { project }) {
+  app.get("/projects/:pid/agents/:slug/connections", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const agents = readAgents(p.path);
+    if (!agents.find((a) => a.slug === req.params.slug))
+      return res.status(404).json({ error: "agent not found" });
+
+    const messages = readProjectMessages(p.storagePath, {
+      agent_slug: req.params.slug,
+    });
+    const peers = new Map();
+    for (const m of messages) {
+      const peer = m.meta?.from || m.meta?.to || null;
+      if (!peer) continue;
+      const key = `${peer}|${m.channel}|${m.direction}`;
+      const existing = peers.get(key);
+      if (!existing) {
+        peers.set(key, {
+          peer,
+          channel: m.channel,
+          direction: m.direction,
+          n: 1,
+          last_ts: m.ts,
+        });
+      } else {
+        existing.n++;
+        if (m.ts > existing.last_ts) existing.last_ts = m.ts;
+      }
+    }
+    res.json(
+      Array.from(peers.values()).sort((a, b) =>
+        (b.last_ts || "").localeCompare(a.last_ts || "")
+      )
+    );
+  });
+}

package/src/host/daemon/api/conversations.js

@@ -0,0 +1,161 @@
+// Per-agent conversation surface: list, fetch, compact, and a2a /send.
+//   GET  /projects/:pid/agents/:slug/conversations
+//   GET  /projects/:pid/agents/:slug/conversations/:id
+//   POST /projects/:pid/agents/:slug/compact
+//   POST /projects/:pid/agents/:slug/conversations/:id/compact
+//   POST /projects/:pid/send                                   (agent-to-agent)
+import fs from "node:fs";
+import path from "node:path";
+import { readAgents } from "../../../core/parser.js";
+import { callEngine } from "../../../core/engines/index.js";
+import { listConversations, readConversation } from "../conversations.js";
+import { compactConversation } from "../compact.js";
+import { nowIso } from "./shared.js";
+
+export function register(app, { project, config }) {
+  app.get("/projects/:pid/agents/:slug/conversations", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const agents = readAgents(p.path);
+    if (!agents.find((a) => a.slug === req.params.slug))
+      return res.status(404).json({ error: "agent not found" });
+    res.json(listConversations(p.storagePath, req.params.slug));
+  });
+
+  app.get("/projects/:pid/agents/:slug/conversations/:id", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const conv = readConversation(p.storagePath, req.params.slug, req.params.id);
+    if (!conv) return res.status(404).json({ error: "conversation not found" });
+    res.json(conv);
+  });
+
+  async function handleCompact(req, res, filename) {
+    const p = project(req, res);
+    if (!p) return;
+    const agents = readAgents(p.path);
+    const agent = agents.find((a) => a.slug === req.params.slug);
+    if (!agent) return res.status(404).json({ error: "agent not found" });
+    const modelId = (req.body || {}).model || agent.fields.Model;
+    if (!modelId) return res.status(400).json({ error: "agent has no model" });
+    try {
+      const result = await compactConversation({
+        storagePath: p.storagePath,
+        agentSlug: agent.slug,
+        filename: filename || null,
+        modelId,
+        config: p.config || config,
+      });
+      res.json(result);
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  }
+
+  app.post("/projects/:pid/agents/:slug/compact", (req, res) =>
+    handleCompact(req, res, null)
+  );
+
+  app.post(
+    "/projects/:pid/agents/:slug/conversations/:id/compact",
+    (req, res) => handleCompact(req, res, req.params.id)
+  );
+
+  // ---- Agent-to-agent routing ----
+  app.post("/projects/:pid/send", async (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const { from, to, body, deliver = false, _depth = 0 } = req.body || {};
+    if (!from || !to || !body)
+      return res.status(400).json({ error: "from, to, body required" });
+    if (_depth > 3)
+      return res.status(429).json({ error: "a2a depth limit (3) exceeded" });
+
+    const agents = readAgents(p.path);
+    const fromAgent = agents.find((a) => a.slug === from);
+    const toAgent = agents.find((a) => a.slug === to);
+    if (!fromAgent)
+      return res.status(404).json({ error: `from agent "${from}" not found` });
+    if (!toAgent)
+      return res.status(404).json({ error: `to agent "${to}" not found` });
+
+    const ts = nowIso();
+    p.logMessage({
+      agent_slug: from,
+      channel: "a2a",
+      direction: "out",
+      author: from,
+      body,
+      meta: { to, depth: _depth },
+      ts,
+    });
+    p.logMessage({
+      agent_slug: to,
+      channel: "a2a",
+      direction: "in",
+      author: from,
+      body,
+      meta: { from, depth: _depth },
+      ts,
+    });
+
+    let reply = null;
+    if (deliver && toAgent.fields.Model) {
+      try {
+        const tf = toAgent.fields;
+        const parts = [];
+        if (tf.Description) parts.push(tf.Description);
+        if (tf.Role) parts.push(`Role: ${tf.Role}`);
+        if (tf.Language) parts.push(`Default language: ${tf.Language}`);
+        parts.push(
+          `You are ${toAgent.slug}. You just received a message from ${fromAgent.slug}. Reply concisely.`
+        );
+        const memPath = path.join(
+          p.path,
+          ".apc",
+          "agents",
+          toAgent.slug,
+          "memory.md"
+        );
+        if (fs.existsSync(memPath))
+          parts.push("## Memory\n" + fs.readFileSync(memPath, "utf8"));
+
+        const result = await callEngine({
+          modelId: toAgent.fields.Model,
+          system: parts.join("\n\n"),
+          messages: [
+            { role: "user", content: `From ${fromAgent.slug}:\n\n${body}` },
+          ],
+          config: p.config || config,
+        });
+
+        p.logMessage({
+          agent_slug: to,
+          channel: "a2a",
+          direction: "out",
+          author: to,
+          body: result.text,
+          meta: {
+            to: from,
+            depth: _depth + 1,
+            reply_to: fromAgent.slug,
+            usage: result.usage,
+          },
+        });
+        p.logMessage({
+          agent_slug: from,
+          channel: "a2a",
+          direction: "in",
+          author: to,
+          body: result.text,
+          meta: { from: to, depth: _depth + 1 },
+        });
+        reply = { text: result.text, usage: result.usage };
+      } catch (e) {
+        reply = { error: e.message };
+      }
+    }
+
+    res.json({ from, to, body, ts, reply });
+  });
+}