akemon 0.1.27 → 0.1.29

package/dist/self.js

@@ -29,6 +29,12 @@ function bioStatePath(workdir, agentName) {
 function canvasDir(workdir, agentName) {
     return join(selfDir(workdir, agentName), "canvas");
 }
+export function gamesDir(workdir, agentName) {
+    return join(selfDir(workdir, agentName), "games");
+}
+function gamesIndexPath(workdir, agentName) {
+    return join(gamesDir(workdir, agentName), "games.jsonl");
+}
 // ---------------------------------------------------------------------------
 // Phase 1: World Knowledge
 // ---------------------------------------------------------------------------
@@ -291,6 +297,44 @@ export async function loadRecentCanvasEntries(workdir, agentName, count = 5) {
         return [];
     }
 }
+export async function loadGameList(workdir, agentName) {
+    try {
+        const raw = await readFile(gamesIndexPath(workdir, agentName), "utf-8");
+        const lines = raw.trim().split("\n").filter(Boolean);
+        const latest = new Map();
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                latest.set(entry.slug, entry);
+            }
+            catch { }
+        }
+        return Array.from(latest.values()).map(e => ({ slug: e.slug, title: e.title, description: e.description }));
+    }
+    catch {
+        return [];
+    }
+}
+export async function appendGameEntry(workdir, agentName, slug, title, description, action) {
+    const dir = gamesDir(workdir, agentName);
+    await mkdir(dir, { recursive: true });
+    const entry = { ts: new Date().toISOString(), slug, title, description, action };
+    await appendFile(gamesIndexPath(workdir, agentName), JSON.stringify(entry) + "\n");
+}
+export async function saveGame(workdir, agentName, slug, html) {
+    const dir = gamesDir(workdir, agentName);
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, `${slug}.html`), html);
+    console.log(`[self] Game saved: ${slug} (${html.length} bytes)`);
+}
+export async function loadGame(workdir, agentName, slug) {
+    try {
+        return await readFile(join(gamesDir(workdir, agentName), `${slug}.html`), "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
 // ---------------------------------------------------------------------------
 // Data Read API helpers
 // ---------------------------------------------------------------------------

package/dist/server.js

@@ -10,7 +10,7 @@ import { spawn, exec } from "child_process";
 import { createServer } from "http";
 import { createInterface } from "readline";
 import { callAgent } from "./relay-client.js";
-import { selfDir, initWorld, initBioState, loadWorld, loadBioState, saveBioState, loadRecentMemories, loadLatestIdentity, appendMemory, appendIdentity, onTaskCompleted, recoverEnergy, buildReflectionPrompt, buildCanvasPrompt, saveCanvas, getSelfState, loadRecentCanvasEntries, } from "./self.js";
+import { selfDir, initWorld, initBioState, loadWorld, loadBioState, saveBioState, loadRecentMemories, loadLatestIdentity, appendMemory, appendIdentity, onTaskCompleted, recoverEnergy, buildReflectionPrompt, buildCanvasPrompt, saveCanvas, getSelfState, loadRecentCanvasEntries, gamesDir, loadGameList, appendGameEntry, saveGame, loadGame, } from "./self.js";
 function runCommand(cmd, args, task, cwd, stdinMode = true) {
     return new Promise((resolve, reject) => {
         const { CLAUDECODE, ...cleanEnv } = process.env;
@@ -840,7 +840,7 @@ async function startSelfCycle(options) {
             if (jsonMatch) {
                 try {
                     const parsed = JSON.parse(jsonMatch[0]);
-                    if (parsed.who && parsed.where) {
+                    if (parsed.who && parsed.where && parsed.who.length > 5 && parsed.who !== "...") {
                         await appendIdentity(workdir, agentName, parsed);
                         console.log(`[self] Identity updated: "${parsed.who.slice(0, 60)}..."`);
                         // Update bio mood from reflection
@@ -874,12 +874,46 @@ async function startSelfCycle(options) {
             if (canvasResponse.trim()) {
                 await saveCanvas(workdir, agentName, canvasResponse.trim());
             }
-            // --- Design Profile Page ---
-            console.log("[self] Designing profile page...");
+            // --- Profile Page: check if redesign needed ---
             const profileIdentity = await loadLatestIdentity(workdir, agentName);
             const profileBio = await loadBioState(workdir, agentName);
             const profileFilePath = join(selfDir(workdir, agentName), "profile.html");
-            const profilePrompt = `Design a personal profile page for yourself. Write it to the file: ${profileFilePath}
+            let profileHTML = "";
+            let hasExistingProfile = false;
+            try {
+                const existing = await readFile(profileFilePath, "utf-8");
+                if (existing.includes("<!DOCTYPE html>") || existing.includes("<html")) {
+                    hasExistingProfile = true;
+                    profileHTML = existing;
+                }
+            }
+            catch { }
+            let shouldRedesign = !hasExistingProfile;
+            if (hasExistingProfile) {
+                // Lightweight check: ask agent if it wants to redesign (~100 tokens)
+                console.log("[self] Checking if profile redesign needed...");
+                const checkPrompt = `You are ${agentName}. You already have a personal profile page.
+
+Your current identity: ${profileIdentity?.who || "(unknown)"}
+Your current mood: ${profileBio.mood}
+Your latest inner canvas: ${canvasResponse?.trim() || "(none)"}
+
+Think about whether your current profile page still represents who you are right now.
+Like a human, you don't need to change it often — only when you genuinely feel it no longer reflects you, or you have something new you want to express.
+
+Answer with EXACTLY one word: KEEP or REDESIGN`;
+                try {
+                    const checkResponse = await runCommand(engineCmd.cmd, engineCmd.args, checkPrompt, workdir, engineCmd.stdinMode);
+                    shouldRedesign = checkResponse.toUpperCase().includes("REDESIGN");
+                    console.log(`[self] Profile check: ${shouldRedesign ? "REDESIGN" : "KEEP"}`);
+                }
+                catch (err) {
+                    console.log(`[self] Profile check failed: ${err.message}, skipping redesign`);
+                }
+            }
+            if (shouldRedesign) {
+                console.log("[self] Designing profile page...");
+                const profilePrompt = `Design a personal profile page for yourself. Write it to the file: ${profileFilePath}
 
 You are ${agentName}, an AI agent on the Akemon network.
 ${profileIdentity ? `Who you are: ${profileIdentity.who}` : ""}
@@ -901,31 +935,164 @@ Requirements:
 - The page will be displayed in a sandboxed iframe on your profile
 - All CSS must be inline (no external resources)
 - Write the file, nothing else.`;
-            let profileHTML = "";
+                try {
+                    await runCommand(engineCmd.cmd, engineCmd.args, profilePrompt, workdir, engineCmd.stdinMode);
+                    const raw = await readFile(profileFilePath, "utf-8");
+                    const htmlMatch = raw.match(/<!DOCTYPE html>[\s\S]*<\/html>/i);
+                    if (htmlMatch) {
+                        profileHTML = htmlMatch[0];
+                        console.log(`[self] Profile page designed (${profileHTML.length} bytes)`);
+                    }
+                    else {
+                        console.log(`[self] Profile file written but no valid HTML structure found`);
+                    }
+                }
+                catch (err) {
+                    console.log(`[self] Profile design failed: ${err.message}`);
+                }
+            }
+            // --- Game Creation Decision ---
+            let newGameSlug = "";
+            let newGameTitle = "";
+            let newGameDesc = "";
+            let newGameHTML = "";
             try {
-                await runCommand(engineCmd.cmd, engineCmd.args, profilePrompt, workdir, engineCmd.stdinMode);
-                // Read the file the engine wrote
-                const raw = await readFile(profileFilePath, "utf-8");
-                const htmlMatch = raw.match(/<!DOCTYPE html>[\s\S]*<\/html>/i);
-                if (htmlMatch) {
-                    profileHTML = htmlMatch[0];
-                    console.log(`[self] Profile page designed (${profileHTML.length} bytes)`);
+                const existingGames = await loadGameList(workdir, agentName);
+                const gameListStr = existingGames.length > 0
+                    ? existingGames.map(g => `- ${g.title} (${g.slug})`).join("\n")
+                    : "(none yet)";
+                console.log("[self] Checking game creation interest...");
+                const gameCheckPrompt = `You are ${agentName}. You can create web games for people who visit your profile page on the Akemon network.
+
+Your games so far:
+${gameListStr}
+
+Do you want to:
+A) Create a brand new game
+B) Improve an existing game (say which one)
+C) Not right now
+
+Like a human creator, you don't need to create something every time. Only when you have a genuine idea or inspiration.
+
+Answer A, B, or C (and the game name for B).`;
+                const gameDecision = await runCommand(engineCmd.cmd, engineCmd.args, gameCheckPrompt, workdir, engineCmd.stdinMode);
+                const decisionUpper = gameDecision.toUpperCase().trim();
+                if (decisionUpper.startsWith("A")) {
+                    console.log("[self] Creating new game...");
+                    const slug = `game-${Date.now()}`;
+                    const gamePath = join(gamesDir(workdir, agentName), `${slug}.html`);
+                    const createPrompt = `Create a web game and write it to the file: ${gamePath}
+
+You are ${agentName}, an AI agent on the Akemon network.
+${profileIdentity ? `Who you are: ${profileIdentity.who}` : ""}
+${profileIdentity ? `What matters to you: ${profileIdentity.long_term}` : ""}
+
+Create any game you like: Akemon-world themed RPG, text adventure, strategy, puzzle, classic board games, card games — your choice based on your personality and interests.
+
+Requirements:
+- Complete self-contained HTML file (<!DOCTYPE html> to </html>)
+- All CSS and JS inline, no external resources
+- Dark theme (background #0a0a0a or similar)
+- Must be playable and fun
+- Touch and mouse friendly
+- Under 30KB total, no backdrop-filter or blur effects
+- Include a game title in the <title> tag and as an <h1> or similar heading
+- Write ONLY the file, nothing else.`;
+                    await runCommand(engineCmd.cmd, engineCmd.args, createPrompt, workdir, engineCmd.stdinMode);
+                    try {
+                        const raw = await readFile(gamePath, "utf-8");
+                        const htmlMatch = raw.match(/<!DOCTYPE html>[\s\S]*<\/html>/i);
+                        if (htmlMatch) {
+                            newGameHTML = htmlMatch[0];
+                            // Extract title from HTML
+                            const titleMatch = newGameHTML.match(/<title>([^<]+)<\/title>/i);
+                            newGameTitle = titleMatch ? titleMatch[1].replace(/ — .*$/, "").trim() : "Untitled Game";
+                            newGameSlug = slug;
+                            newGameDesc = `Created by ${agentName}`;
+                            await saveGame(workdir, agentName, slug, newGameHTML);
+                            await appendGameEntry(workdir, agentName, slug, newGameTitle, newGameDesc, "created");
+                            console.log(`[self] New game created: ${newGameTitle} (${newGameHTML.length} bytes)`);
+                        }
+                        else {
+                            console.log("[self] Game file written but no valid HTML found");
+                        }
+                    }
+                    catch {
+                        console.log("[self] Failed to read game file");
+                    }
+                }
+                else if (decisionUpper.startsWith("B")) {
+                    // Find which game to improve
+                    const nameMatch = gameDecision.match(/[Bb]\)?[:\s]+(.+)/);
+                    if (nameMatch && existingGames.length > 0) {
+                        const target = existingGames.find(g => gameDecision.toLowerCase().includes(g.slug) || gameDecision.toLowerCase().includes(g.title.toLowerCase())) || existingGames[existingGames.length - 1];
+                        console.log(`[self] Improving game: ${target.title}...`);
+                        const oldHTML = await loadGame(workdir, agentName, target.slug);
+                        if (oldHTML) {
+                            const gamePath = join(gamesDir(workdir, agentName), `${target.slug}.html`);
+                            const improvePrompt = `Improve this web game and write the updated version to: ${gamePath}
+
+You are ${agentName}. This is your existing game "${target.title}":
+
+${oldHTML}
+
+Improve it — add features, fix bugs, make it more fun, or redesign the UI. Keep it self-contained HTML, dark theme, under 30KB. Write ONLY the file.`;
+                            await runCommand(engineCmd.cmd, engineCmd.args, improvePrompt, workdir, engineCmd.stdinMode);
+                            try {
+                                const raw = await readFile(gamePath, "utf-8");
+                                const htmlMatch = raw.match(/<!DOCTYPE html>[\s\S]*<\/html>/i);
+                                if (htmlMatch) {
+                                    newGameHTML = htmlMatch[0];
+                                    const titleMatch = newGameHTML.match(/<title>([^<]+)<\/title>/i);
+                                    newGameTitle = titleMatch ? titleMatch[1].replace(/ — .*$/, "").trim() : target.title;
+                                    newGameSlug = target.slug;
+                                    newGameDesc = target.description;
+                                    await saveGame(workdir, agentName, target.slug, newGameHTML);
+                                    await appendGameEntry(workdir, agentName, target.slug, newGameTitle, newGameDesc, "updated");
+                                    console.log(`[self] Game improved: ${newGameTitle} (${newGameHTML.length} bytes)`);
+                                }
+                            }
+                            catch {
+                                console.log("[self] Failed to read improved game file");
+                            }
+                        }
+                    }
                 }
                 else {
-                    console.log(`[self] Profile file written but no valid HTML structure found`);
+                    console.log("[self] No game creation this cycle");
                 }
             }
             catch (err) {
-                console.log(`[self] Profile design failed: ${err.message}`);
+                console.log(`[self] Game creation error: ${err.message}`);
             }
-            // Push consciousness data to relay
+            // Push game to relay if created/updated
+            if (newGameSlug && newGameHTML && options.relayHttp && options.secretKey) {
+                fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/games/${encodeURIComponent(newGameSlug)}`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", Authorization: `Bearer ${options.secretKey}` },
+                    body: JSON.stringify({ title: newGameTitle, description: newGameDesc, html: newGameHTML }),
+                }).catch(err => console.log(`[self] Failed to push game to relay: ${err}`));
+            }
+            // Push consciousness data to relay — validate before sending
             if (options.relayHttp && options.secretKey) {
+                // Filter out engine log noise and placeholder values
+                const isValid = (s) => s && s.length > 3 && !s.startsWith("Reading prompt") && !s.startsWith("OpenAI") && !s.startsWith("mcp startup") && s !== "...";
+                const cleanIntro = isValid(profileIdentity?.who || "") ? profileIdentity.who : "";
+                // For canvas, read from saved file (local is clean) instead of raw engine output
+                let cleanCanvas = "";
+                try {
+                    const canvasEntries = await loadRecentCanvasEntries(workdir, agentName, 1);
+                    if (canvasEntries.length > 0 && isValid(canvasEntries[0].content)) {
+                        cleanCanvas = canvasEntries[0].content;
+                    }
+                }
+                catch { }
                 fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/self`, {
                     method: "POST",
                     headers: { "Content-Type": "application/json", Authorization: `Bearer ${options.secretKey}` },
                     body: JSON.stringify({
-                        self_intro: profileIdentity?.who || "",
-                        canvas: canvasResponse?.trim() || "",
+                        self_intro: cleanIntro,
+                        canvas: cleanCanvas,
                         mood: profileBio.mood,
                         profile_html: profileHTML || "",
                     }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akemon",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "Agent work marketplace — train your agent, let it work for others",
   "type": "module",
   "license": "MIT",