akemon 0.3.5 → 0.3.7

package/dist/cognitive-artifact-store.js

@@ -0,0 +1,101 @@
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { redactSecrets } from "./redaction.js";
+const ARTIFACT_FILE_BY_KIND = {
+    reflection: "reflections.jsonl",
+    landmark_candidate: "landmark-candidates.jsonl",
+    memory_weight: "memory-weights.jsonl",
+    memory_relation: "memory-relations.jsonl",
+    failed_attempt: "failed-attempts.jsonl",
+    rejected_approach: "rejected-approaches.jsonl",
+};
+export function createCognitiveArtifactId(kind) {
+    return `${kind}_${Date.now()}_${randomUUID().slice(0, 8)}`;
+}
+export function cognitiveArtifactsDir(workdir, agentName) {
+    return join(workdir, ".akemon", "agents", agentName, "cognitive");
+}
+export function cognitiveArtifactPath(workdir, agentName, kind) {
+    return join(cognitiveArtifactsDir(workdir, agentName), ARTIFACT_FILE_BY_KIND[kind]);
+}
+export async function appendCognitiveArtifact(input) {
+    const now = new Date().toISOString();
+    const kind = input.record.kind;
+    const record = redactSecrets({
+        ...input.record,
+        schemaVersion: 1,
+        id: input.record.id || createCognitiveArtifactId(kind),
+        createdAt: input.record.createdAt || now,
+        updatedAt: input.record.updatedAt || input.record.createdAt || now,
+        agentName: input.agentName,
+        workdir: input.workdir,
+        refs: input.record.refs || [],
+        tags: normalizeTags(input.record.tags),
+    });
+    await mkdir(cognitiveArtifactsDir(input.workdir, input.agentName), { recursive: true });
+    await appendFile(cognitiveArtifactPath(input.workdir, input.agentName, kind), `${JSON.stringify(record)}\n`, "utf-8");
+    return record;
+}
+export async function recordFailedAttempt(input) {
+    return appendCognitiveArtifact({
+        workdir: input.workdir,
+        agentName: input.agentName,
+        record: {
+            ...input.record,
+            kind: "failed_attempt",
+            status: input.record.status || "observed",
+        },
+    });
+}
+export async function recordRejectedApproach(input) {
+    return appendCognitiveArtifact({
+        workdir: input.workdir,
+        agentName: input.agentName,
+        record: {
+            ...input.record,
+            kind: "rejected_approach",
+            status: input.record.status || "rejected",
+        },
+    });
+}
+export async function readCognitiveArtifacts(input) {
+    try {
+        const content = await readFile(cognitiveArtifactPath(input.workdir, input.agentName, input.kind), "utf-8");
+        const lines = content.split(/\r?\n/).filter((line) => line.trim());
+        const selected = typeof input.limit === "number" && input.limit > 0
+            ? lines.slice(-input.limit)
+            : lines;
+        return selected.flatMap((line) => {
+            try {
+                return [JSON.parse(line)];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export function normalizeMemoryWeights(weights) {
+    return {
+        importance: clampScore(weights.importance),
+        confidence: clampScore(weights.confidence),
+        validation: clampScore(weights.validation),
+        userPriority: clampScore(weights.userPriority),
+        ...(weights.relevance === undefined ? {} : { relevance: clampScore(weights.relevance) }),
+        ...(weights.freshness === undefined ? {} : { freshness: clampScore(weights.freshness) }),
+    };
+}
+function normalizeTags(tags) {
+    if (!Array.isArray(tags))
+        return [];
+    return [...new Set(tags.map((tag) => String(tag).trim()).filter(Boolean))];
+}
+function clampScore(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(1, value));
+}

package/dist/cognitive-event-log.js

@@ -0,0 +1,47 @@
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { redactSecrets } from "./redaction.js";
+const EVENT_FILE_BY_STREAM = {
+    main_chat: "main_chat.jsonl",
+    peripheral: "peripheral.jsonl",
+    cm: "cm.jsonl",
+    compute: "compute.jsonl",
+    task: "task.jsonl",
+};
+export function createCognitiveEventId(prefix = "evt") {
+    return `${prefix}_${Date.now()}_${randomUUID().slice(0, 8)}`;
+}
+export function cognitiveEventsDir(workdir, agentName) {
+    return join(workdir, ".akemon", "agents", agentName, "events");
+}
+export function cognitiveEventLogPath(workdir, agentName, stream) {
+    return join(cognitiveEventsDir(workdir, agentName), EVENT_FILE_BY_STREAM[stream]);
+}
+export async function appendCognitiveEvent(input) {
+    const event = {
+        schemaVersion: 1,
+        id: input.event.id || createCognitiveEventId(),
+        createdAt: input.event.createdAt || new Date().toISOString(),
+        ...input.event,
+    };
+    const dir = cognitiveEventsDir(input.workdir, input.agentName);
+    await mkdir(dir, { recursive: true });
+    const path = cognitiveEventLogPath(input.workdir, input.agentName, event.stream);
+    await appendFile(path, `${JSON.stringify(redactSecrets(event))}\n`, "utf-8");
+    return event;
+}
+export async function readCognitiveEvents(input) {
+    try {
+        const path = cognitiveEventLogPath(input.workdir, input.agentName, input.stream);
+        const content = await readFile(path, "utf-8");
+        const lines = content.split(/\r?\n/).filter((line) => line.trim());
+        const selected = typeof input.limit === "number" && input.limit > 0
+            ? lines.slice(-input.limit)
+            : lines;
+        return selected.map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/config.js

@@ -1,24 +1,42 @@
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { existsSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
 import { randomBytes, randomUUID } from "crypto";
-const CONFIG_DIR = join(homedir(), ".akemon");
-const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+import { akemonHome } from "./akemon-home.js";
+function configPath() {
+    return join(akemonHome(), "config.json");
+}
 export function generateKey(prefix = "ak") {
     return prefix + "_" + randomBytes(24).toString("base64url");
 }
 export async function loadConfig() {
-    if (!existsSync(CONFIG_PATH))
+    const path = configPath();
+    if (!existsSync(path))
         return {};
-    const raw = await readFile(CONFIG_PATH, "utf-8");
+    const raw = await readFile(path, "utf-8");
     return JSON.parse(raw);
 }
 export async function saveConfig(config) {
-    if (!existsSync(CONFIG_DIR)) {
-        await mkdir(CONFIG_DIR, { recursive: true });
+    const dir = akemonHome();
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
     }
-    await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
+    await writeFile(configPath(), JSON.stringify(config, null, 2));
+}
+export async function getLocalManagerName() {
+    const config = await loadConfig();
+    return typeof config.local_manager === "string" && config.local_manager
+        ? config.local_manager
+        : null;
+}
+export async function setLocalManagerName(name) {
+    const config = await loadConfig();
+    const cleaned = name.trim();
+    if (!cleaned)
+        throw new Error("Local manager name must not be empty");
+    config.local_manager = cleaned;
+    await saveConfig(config);
+    return cleaned;
 }
 // Legacy: single key for direct mode
 export async function getOrCreateKey(explicitKey) {
@@ -35,6 +53,22 @@ export async function getOrCreateKey(explicitKey) {
     await saveConfig(config);
     return key;
 }
+export async function getOrCreateLocalOwnerSecret() {
+    const config = await loadConfig();
+    if (typeof config.local_owner_key === "string" && config.local_owner_key) {
+        return config.local_owner_key;
+    }
+    // Keep existing local installations usable: older local owner endpoints used
+    // secret_key even when relay was disabled.
+    if (typeof config.secret_key === "string" && config.secret_key) {
+        config.local_owner_key = config.secret_key;
+        await saveConfig(config);
+        return config.local_owner_key;
+    }
+    config.local_owner_key = generateKey("ak_local");
+    await saveConfig(config);
+    return config.local_owner_key;
+}
 export async function getOrCreateRelayCredentials() {
     const config = await loadConfig();
     let changed = false;
@@ -43,7 +77,9 @@ export async function getOrCreateRelayCredentials() {
         changed = true;
     }
     if (!config.secret_key) {
-        config.secret_key = generateKey("ak_secret");
+        config.secret_key = typeof config.local_owner_key === "string" && config.local_owner_key
+            ? config.local_owner_key
+            : generateKey("ak_secret");
         changed = true;
     }
     if (!config.access_key) {

package/dist/context.js

@@ -15,6 +15,7 @@
 import { readFile, writeFile, mkdir, appendFile, readdir, stat, unlink } from "fs/promises";
 import { join } from "path";
 import { localNow } from "./self.js";
+import { createConversationMessage, } from "./akemon-message.js";
 function conversationsDir(workdir, agentName) {
     return join(workdir, ".akemon", "agents", agentName, "conversations");
 }
@@ -30,7 +31,7 @@ export function resolveConvId(publisherId, sessionId) {
     return "ses_anonymous";
 }
 /** Parse a conversation markdown file into structured data. */
-function parseConversation(content) {
+function parseConversation(content, agentName = "unknown", convId = "unknown") {
     let summary = "";
     const rounds = [];
     const summaryMatch = content.match(/## Summary\n([\s\S]*?)(?=\n## Recent|$)/);
@@ -44,16 +45,28 @@ function parseConversation(content) {
             // Format: [ts] [kind] Role: text  OR (legacy)  [ts] Role: text
             const m = line.match(/^\[(.+?)\] (?:\[(order)\] )?(User|Agent): (.*)$/);
             if (m) {
+                const kind = m[2] ?? "chat";
+                const role = m[3];
+                const text = m[4];
                 rounds.push({
                     ts: m[1],
-                    kind: m[2] ?? "chat",
-                    role: m[3].toLowerCase(),
-                    content: m[4],
+                    kind,
+                    role: role.toLowerCase(),
+                    content: text,
+                    message: createConversationMessage({
+                        agentName,
+                        conversationId: convId,
+                        role,
+                        text,
+                        kind,
+                        createdAt: m[1],
+                    }),
                 });
             }
             else if (rounds.length > 0 && line !== "") {
                 // Continuation line — append to previous round
                 rounds[rounds.length - 1].content += "\n" + line;
+                rounds[rounds.length - 1].message.payload.text = rounds[rounds.length - 1].content;
             }
         }
     }
@@ -63,7 +76,7 @@ function parseConversation(content) {
 export async function loadConversation(workdir, agentName, convId) {
     try {
         const content = await readFile(conversationPath(workdir, agentName, convId), "utf-8");
-        return parseConversation(content);
+        return parseConversation(content, agentName, convId);
     }
     catch {
         return { summary: "", rounds: [] };
@@ -88,6 +101,14 @@ export async function appendMessage(workdir, agentName, convId, role, message, k
     const kindTag = kind === "order" ? "[order] " : "";
     content = content.trimEnd() + "\n" + `[${ts}] ${kindTag}${role}: ${message}` + "\n";
     await writeFile(p, content);
+    return createConversationMessage({
+        agentName,
+        conversationId: convId,
+        role,
+        text: message,
+        kind,
+        createdAt: ts,
+    });
 }
 /** Append a user+agent round to a conversation file. Creates file if needed. */
 export async function appendRound(workdir, agentName, convId, userMsg, agentMsg) {
@@ -144,7 +165,7 @@ export async function listConversations(workdir, agentName) {
             try {
                 const st = await stat(join(dir, f));
                 const content = await readFile(join(dir, f), "utf-8");
-                const conv = parseConversation(content);
+                const conv = parseConversation(content, agentName, id);
                 results.push({
                     id,
                     lastActive: st.mtime.toISOString(),

package/dist/core/contracts/layers.js

@@ -0,0 +1 @@
+export {};

package/dist/core/contracts/permission.js

@@ -0,0 +1 @@
+export {};

package/dist/core/contracts/workspace.js

@@ -0,0 +1 @@
+export {};