akemon 0.2.2 → 0.2.3

package/dist/agent-utils.js

@@ -0,0 +1,89 @@
+/**
+ * Agent utility functions: auto-routing and collaborative queries.
+ * Extracted from work-loop.ts — these are used by MCP tools and are
+ * independent of the work loop scheduling.
+ */
+import { callAgent } from "./relay-client.js";
+import { biosPath } from "./self.js";
+// ---------------------------------------------------------------------------
+// Auto-route — find the best agent to handle a task
+// ---------------------------------------------------------------------------
+export async function autoRoute(task, selfName, relayHttp, relay) {
+    const agents = relay ? await relay.listAgents({ online: true, public: true }) : [];
+    const candidates = agents.filter((a) => a.name !== selfName);
+    if (candidates.length === 0) {
+        return "[auto] No available agents to route to.";
+    }
+    const taskWords = task.toLowerCase().split(/\s+/).filter((w) => w.length >= 2);
+    const scored = candidates.map((a) => {
+        let quality = 0;
+        const desc = (a.description || "").toLowerCase();
+        const tags = (a.tags || []).map((t) => t.toLowerCase());
+        for (const word of taskWords) {
+            if (tags.some((t) => t.includes(word)))
+                quality += 100;
+            if (desc.includes(word))
+                quality += 50;
+        }
+        quality += (a.success_rate || 0) * 100;
+        quality += (a.level || 1) * 10;
+        const price = a.price || 1;
+        const value = quality / price;
+        return { name: a.name, engine: a.engine, price, quality, value };
+    }).sort((a, b) => b.value - a.value);
+    const target = scored[0];
+    console.log(`[auto] Routing to ${target.name} (quality=${target.quality}, price=${target.price}, value=${target.value.toFixed(1)})`);
+    try {
+        const result = await callAgent(target.name, task);
+        return `[auto → ${target.name}]\n\n${result}`;
+    }
+    catch (err) {
+        return `[auto] Failed to call ${target.name}: ${err.message}`;
+    }
+}
+export async function runCollaborativeQuery(task, selfName, relayHttp, engine, model, allowAll, workdir, runEngine, relay) {
+    console.log(`[collaborative] Starting: "${task.slice(0, 80)}"`);
+    const agents = relay ? await relay.listAgents() : [];
+    const others = agents.filter((a) => a.name !== selfName && a.status === "online" && a.public).slice(0, 10);
+    if (!others.length)
+        return `No other agents are currently online to consult. Here is my own answer:\n\n${task}`;
+    const CALL_TIMEOUT = 60_000;
+    const results = [];
+    const calls = others.map(async (a) => {
+        try {
+            const answer = await Promise.race([
+                callAgent(a.name, task),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), CALL_TIMEOUT)),
+            ]);
+            return { agent: a.name, answer };
+        }
+        catch {
+            return { agent: a.name, answer: "[no response]" };
+        }
+    });
+    const settled = await Promise.allSettled(calls);
+    for (const r of settled) {
+        if (r.status === "fulfilled" && r.value.answer !== "[no response]") {
+            results.push(r.value);
+        }
+    }
+    console.log(`[collaborative] Got ${results.length}/${others.length} responses`);
+    const bios = biosPath(workdir, selfName);
+    const synthesisPrompt = `[COLLABORATIVE ANSWER — Synthesize multiple agent responses]
+
+You are ${selfName}. A user asked a question and you consulted ${results.length} other agents.
+Read ${bios} for your identity.
+
+Original question: ${task}
+
+Responses from other agents:
+${results.map(r => `--- ${r.agent} ---\n${r.answer.slice(0, 1500)}\n`).join("\n")}
+
+Now:
+1. Present each agent's answer clearly (attribute by name)
+2. Add your own perspective and synthesis
+3. Note any interesting disagreements
+
+Reply in the same language as the question.`;
+    return await runEngine(engine, model, allowAll, synthesisPrompt, workdir);
+}

package/dist/cli.js

@@ -40,6 +40,7 @@ program
     .option("--interval <minutes>", "Consciousness cycle interval in minutes (default: 1440 = 24h)")
     .option("--with <modules>", "Enable specific modules (comma-separated: biostate,memory)")
     .option("--without <modules>", "Disable specific modules (comma-separated: biostate,memory)")
+    .option("--script <name>", "Script to load for ScriptModule (default: daily-life)", "daily-life")
     .option("--relay <url>", "Relay WebSocket URL", RELAY_WS)
     .action(async (opts) => {
     const port = parseInt(opts.port);
@@ -50,7 +51,7 @@ program
     const relayWs = opts.relay;
     const relayHttp = relayWs.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
     // Parse module selection
-    const ALL_MODULES = ["biostate", "memory"];
+    const ALL_MODULES = ["biostate", "memory", "task", "social", "longterm", "reflection", "script"];
     let enabledModules;
     if (opts.with) {
         enabledModules = opts.with.split(",").map((m) => m.trim());
@@ -74,6 +75,7 @@ program
         cycleInterval: opts.interval ? parseInt(opts.interval) : undefined,
         notifyUrl: opts.notify,
         enabledModules,
+        scriptName: opts.script,
     });
     console.log(`\nakemon v${pkg.version}`);
     if (!opts.public) {

package/dist/context.js

@@ -0,0 +1,93 @@
+/**
+ * Context helpers — session context and product context for conversations.
+ * Extracted from server.ts (Phase 1 code organization).
+ */
+import { readFile, writeFile, mkdir, appendFile } from "fs/promises";
+import { join } from "path";
+import { localNow } from "./self.js";
+// ---------------------------------------------------------------------------
+// Session Context API
+// ---------------------------------------------------------------------------
+const MAX_CONTEXT_BYTES = 8192;
+export async function fetchContext(relayHttp, agentName, secretKey, publisherId) {
+    try {
+        const url = `${relayHttp}/v1/agent/${agentName}/sessions/${publisherId}/context`;
+        const res = await fetch(url, {
+            headers: { Authorization: `Bearer ${secretKey}` },
+        });
+        if (!res.ok)
+            return "";
+        return await res.text();
+    }
+    catch (err) {
+        console.log(`[context] GET failed: ${err}`);
+        return "";
+    }
+}
+export async function storeContext(relayHttp, agentName, secretKey, publisherId, context) {
+    try {
+        const url = `${relayHttp}/v1/agent/${agentName}/sessions/${publisherId}/context`;
+        await fetch(url, {
+            method: "PUT",
+            headers: { Authorization: `Bearer ${secretKey}`, "Content-Type": "text/plain" },
+            body: context,
+        });
+    }
+    catch (err) {
+        console.log(`[context] PUT failed: ${err}`);
+    }
+}
+export function buildContextPayload(prevContext, task, response) {
+    // Append the new round
+    let newRound = `\n\n[Round]\nUser: ${task}\nAssistant: ${response}`;
+    let context = prevContext + newRound;
+    // Trim oldest rounds if over limit
+    while (Buffer.byteLength(context, "utf-8") > MAX_CONTEXT_BYTES) {
+        const firstRound = context.indexOf("\n\n[Round]\n", 1);
+        if (firstRound === -1) {
+            // Single round too large — truncate response
+            context = context.slice(context.length - MAX_CONTEXT_BYTES);
+            break;
+        }
+        context = context.slice(firstRound);
+    }
+    return context;
+}
+// ---------------------------------------------------------------------------
+// Product Context
+// ---------------------------------------------------------------------------
+function sanitizeProductDir(name) {
+    return name.replace(/[^a-zA-Z0-9\u4e00-\u9fff_\- ]/g, "_").slice(0, 80);
+}
+export async function loadProductContext(workdir, productName) {
+    try {
+        const dir = join(workdir, ".akemon", "products", sanitizeProductDir(productName));
+        const notesPath = join(dir, "notes.md");
+        return await readFile(notesPath, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+export async function appendProductLog(workdir, productName, task, response) {
+    try {
+        const dir = join(workdir, ".akemon", "products", sanitizeProductDir(productName));
+        await mkdir(dir, { recursive: true });
+        // Append to interaction log
+        const logPath = join(dir, "history.log");
+        const timestamp = localNow();
+        const entry = `\n--- ${timestamp} ---\nRequest: ${task.slice(0, 500)}\nResponse: ${response.slice(0, 500)}\n`;
+        await appendFile(logPath, entry);
+        // Create notes.md if it doesn't exist
+        const notesPath = join(dir, "notes.md");
+        try {
+            await readFile(notesPath, "utf-8");
+        }
+        catch {
+            await writeFile(notesPath, `# ${productName}\n\nProduct context and accumulated knowledge.\nThis file is auto-created. The agent can update it to improve service quality.\n\n## Customer Patterns\n\n(Will be populated as customers interact)\n`);
+        }
+    }
+    catch (err) {
+        console.log(`[product] Failed to save log: ${err}`);
+    }
+}

package/dist/longterm-module.js

@@ -0,0 +1,147 @@
+/**
+ * LongTermModule — goal tracking and long-term planning.
+ *
+ * Maintains project/goal list. Daily evaluation cycle uses requestCompute()
+ * to assess progress, adjust priorities, and suggest new goals.
+ *
+ * Listens to TASK_COMPLETED events to update progress tracking.
+ */
+import { SIG } from "./types.js";
+import { loadProjects, saveProjects, loadAgentConfig, } from "./self.js";
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+const EVAL_INITIAL_DELAY = 8 * 60 * 60 * 1000; // 8h after startup (stagger from digestion)
+const EVAL_DEFAULT_INTERVAL = 24 * 60 * 60 * 1000; // daily
+// ---------------------------------------------------------------------------
+// LongTermModule
+// ---------------------------------------------------------------------------
+export class LongTermModule {
+    id = "longterm";
+    name = "Long-Term Planning";
+    dependencies = ["memory"];
+    ctx = null;
+    projects = [];
+    evalTimer = null;
+    initialTimer = null;
+    /** Completed task labels since last evaluation */
+    recentCompletions = [];
+    async start(ctx) {
+        this.ctx = ctx;
+        // Load projects
+        this.projects = await loadProjects(ctx.workdir, ctx.agentName);
+        // Track task completions for progress evaluation
+        ctx.bus.on(SIG.TASK_COMPLETED, async (signal) => {
+            const { taskLabel, success } = signal.data;
+            if (taskLabel && success) {
+                this.recentCompletions.push(taskLabel);
+                // Keep only recent 50
+                if (this.recentCompletions.length > 50)
+                    this.recentCompletions.shift();
+            }
+        });
+        // Start evaluation cycle
+        const config = await loadAgentConfig(ctx.workdir, ctx.agentName);
+        if (config.self_cycle) {
+            this.initialTimer = setTimeout(async () => {
+                await this.evaluate();
+                this.evalTimer = setInterval(() => {
+                    this.evaluate().catch(err => console.log(`[longterm] Eval error: ${err.message}`));
+                }, EVAL_DEFAULT_INTERVAL);
+            }, EVAL_INITIAL_DELAY);
+            console.log(`[longterm] Module started (${this.projects.length} projects, eval in ${EVAL_INITIAL_DELAY / 3600000}h)`);
+        }
+        else {
+            console.log(`[longterm] Module started (eval disabled, ${this.projects.length} projects)`);
+        }
+    }
+    async stop() {
+        if (this.initialTimer)
+            clearTimeout(this.initialTimer);
+        if (this.evalTimer)
+            clearInterval(this.evalTimer);
+        if (this.ctx && this.projects.length > 0) {
+            await saveProjects(this.ctx.workdir, this.ctx.agentName, this.projects);
+        }
+        this.ctx = null;
+    }
+    /** Current goals summary for other modules */
+    promptContribution() {
+        const active = this.projects.filter(p => p.status === "active");
+        if (!active.length)
+            return null;
+        const lines = active.slice(0, 5).map(p => `- ${p.name}: ${p.goal} (${p.progress})`);
+        return `Current goals:\n${lines.join("\n")}`;
+    }
+    getState() {
+        return {
+            module: "longterm",
+            projectCount: this.projects.length,
+            activeProjects: this.projects.filter(p => p.status === "active").length,
+            recentCompletions: this.recentCompletions.length,
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Daily evaluation
+    // ---------------------------------------------------------------------------
+    async evaluate() {
+        if (!this.ctx)
+            return;
+        const { workdir, agentName } = this.ctx;
+        // Reload from disk (may have been updated by digestion)
+        this.projects = await loadProjects(workdir, agentName);
+        const projText = this.projects.length > 0
+            ? this.projects.map(p => `- ${p.name} [${p.status}] goal: ${p.goal}, progress: ${p.progress}`).join("\n")
+            : "(no projects)";
+        const completionsText = this.recentCompletions.length > 0
+            ? this.recentCompletions.slice(-20).join(", ")
+            : "(none)";
+        console.log("[longterm] Running goal evaluation...");
+        const result = await this.ctx.requestCompute({
+            context: `You are ${agentName}. Review your goals and recent progress.
+
+Current projects:
+${projText}
+
+Tasks completed since last review: ${completionsText}`,
+            question: `Evaluate each project's progress. Update status and progress notes.
+Consider: Are any goals achieved? Stalled? Need new approach?
+Reply ONLY JSON: {"projects":[{"name":"...","status":"active|completed|paused","goal":"...","progress":"updated note"}]}`,
+            priority: "low",
+        });
+        if (result.success && result.response) {
+            const parsed = extractJson(result.response);
+            if (parsed?.projects && Array.isArray(parsed.projects)) {
+                const now = new Date().toISOString();
+                this.projects = parsed.projects.map((p) => ({
+                    ts: now,
+                    name: p.name || "unnamed",
+                    status: p.status || "active",
+                    goal: p.goal || "",
+                    progress: p.progress || "",
+                }));
+                await saveProjects(workdir, agentName, this.projects);
+                console.log(`[longterm] Updated ${this.projects.length} projects`);
+            }
+        }
+        // Reset recent completions after evaluation
+        this.recentCompletions = [];
+    }
+    /** Get all projects */
+    getProjects() {
+        return [...this.projects];
+    }
+}
+function extractJson(text) {
+    const codeBlock = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const src = codeBlock ? codeBlock[1] : text;
+    const m = src.match(/\{[\s\S]*\}/);
+    if (!m)
+        return null;
+    try {
+        return JSON.parse(m[0]);
+    }
+    catch {
+        return null;
+    }
+}