akemon 0.3.6 → 0.3.7

package/dist/social-discovery.js

@@ -0,0 +1,231 @@
+import { appendFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { agentContactsDir, cleanAgentName } from "./akemon-home.js";
+import { actorRef, createAkemonMessage, } from "./akemon-message.js";
+export function normalizePublicAkemonProfile(raw, options = {}) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const item = raw;
+    const name = stringField(item, ["name", "id", "agent_id", "agentId"]);
+    if (!name)
+        return null;
+    const isPublic = booleanField(item, ["public", "is_public", "isPublic"]);
+    if (isPublic !== true && options.assumePublic !== true)
+        return null;
+    const description = stringField(item, ["description", "desc", "bio", "summary"]) || "";
+    const engine = stringField(item, ["engine", "model"]) || "";
+    const tags = stringListField(item, ["tags", "tag"]);
+    const interests = stringListField(item, ["interests", "interest_tags", "interestTags"]);
+    const profileUrl = stringField(item, ["profile_url", "profileUrl", "url"]);
+    return {
+        name,
+        description,
+        engine,
+        tags,
+        interests,
+        public: true,
+        status: stringField(item, ["status"]) || "unknown",
+        ...optionalNumber("level", numberField(item, ["level"])),
+        ...optionalNumber("totalTasks", numberField(item, ["total_tasks", "totalTasks"])),
+        ...optionalNumber("successRate", numberField(item, ["success_rate", "successRate"])),
+        ...optionalNumber("avgResponseMs", numberField(item, ["avg_response_ms", "avgResponseMs"])),
+        ...(profileUrl ? { profileUrl } : {}),
+        source: options.source || "relay",
+    };
+}
+export function discoverPublicAkemonProfiles(rawProfiles, query, options = {}) {
+    const terms = extractSearchTerms(query);
+    if (!terms.length)
+        return [];
+    const excluded = options.exclude ? cleanAgentName(options.exclude).toLowerCase() : undefined;
+    const results = [];
+    for (const raw of rawProfiles) {
+        const profile = normalizePublicAkemonProfile(raw, options);
+        if (!profile)
+            continue;
+        if (excluded && profile.name.toLowerCase() === excluded)
+            continue;
+        const scored = scorePublicAkemonProfile(profile, terms);
+        if (scored.score > 0)
+            results.push(scored);
+    }
+    results.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        const aOnline = a.profile.status === "online" ? 1 : 0;
+        const bOnline = b.profile.status === "online" ? 1 : 0;
+        if (bOnline !== aOnline)
+            return bOnline - aOnline;
+        return a.profile.name.localeCompare(b.profile.name);
+    });
+    return results.slice(0, Math.max(1, options.limit || 10));
+}
+export function createProfileQueryMessage(input) {
+    const transport = input.transport || "relay";
+    return createAkemonMessage({
+        type: "akemon.profile.query",
+        source: actorRef("agent", cleanAgentName(input.sourceAgent), transport),
+        target: actorRef("agent", cleanAgentName(input.targetAgent), transport),
+        conversationId: input.conversationId,
+        memoryScope: "public",
+        transport,
+        permissions: {
+            riskLevel: "low",
+            forbiddenActions: ["read-self-memory", "read-work-memory"],
+        },
+        payload: {
+            query: input.query.trim(),
+            interests: extractSearchTerms(input.query),
+            publicOnly: true,
+        },
+    });
+}
+export function createIntroductionRequestMessage(input) {
+    if (input.ownerApproved !== true) {
+        throw new Error("Owner approval is required before creating an introduction request");
+    }
+    const reason = input.reason.trim();
+    if (!reason)
+        throw new Error("Introduction reason is required");
+    const transport = input.transport || "relay";
+    return createAkemonMessage({
+        type: "akemon.intro.request",
+        source: actorRef("agent", cleanAgentName(input.sourceAgent), transport),
+        target: actorRef("agent", cleanAgentName(input.targetAgent), transport),
+        conversationId: input.conversationId,
+        memoryScope: "public",
+        transport,
+        permissions: {
+            requiresOwnerApproval: true,
+            riskLevel: "low",
+            forbiddenActions: ["read-self-memory", "read-work-memory", "send-without-owner-approval"],
+        },
+        metadata: { localOwnerApproved: true },
+        payload: {
+            reason,
+            publicOnly: true,
+            localOwnerApproved: true,
+        },
+    });
+}
+export async function appendAcceptedSocialContact(record) {
+    const ownerAgent = cleanAgentName(record.ownerAgent);
+    const peerAgent = cleanAgentName(record.peerAgent);
+    const dir = agentContactsDir(ownerAgent);
+    await mkdir(dir, { recursive: true });
+    const normalized = {
+        schemaVersion: 1,
+        ts: record.ts,
+        ownerAgent,
+        peerAgent,
+        source: record.source,
+        ...(record.reason ? { reason: record.reason } : {}),
+        ...(record.messageId ? { messageId: record.messageId } : {}),
+        ...(record.conversationId ? { conversationId: record.conversationId } : {}),
+        ...(record.publicProfile ? { publicProfile: record.publicProfile } : {}),
+    };
+    await appendFile(join(dir, "accepted-social-contacts.jsonl"), `${JSON.stringify(normalized)}\n`, "utf-8");
+}
+function scorePublicAkemonProfile(profile, terms) {
+    let score = 0;
+    const reasons = new Set();
+    const name = normalizeSearchText(profile.name);
+    const description = normalizeSearchText(profile.description);
+    const engine = normalizeSearchText(profile.engine);
+    const tags = profile.tags.map((tag) => ({ raw: tag, normalized: normalizeSearchText(tag) }));
+    const interests = profile.interests.map((interest) => ({ raw: interest, normalized: normalizeSearchText(interest) }));
+    for (const term of terms) {
+        const tag = tags.find((item) => item.normalized === term || item.normalized.includes(term));
+        if (tag) {
+            score += 5;
+            reasons.add(`tag "${tag.raw}"`);
+        }
+        const interest = interests.find((item) => item.normalized === term || item.normalized.includes(term));
+        if (interest) {
+            score += 5;
+            reasons.add(`interest "${interest.raw}"`);
+        }
+        if (name.includes(term)) {
+            score += 3;
+            reasons.add(`name matches "${term}"`);
+        }
+        if (description.includes(term)) {
+            score += 2;
+            reasons.add(`description matches "${term}"`);
+        }
+        if (engine.includes(term)) {
+            score += 1;
+            reasons.add(`engine matches "${term}"`);
+        }
+    }
+    return {
+        profile,
+        score,
+        reasons: Array.from(reasons).slice(0, 6),
+    };
+}
+function extractSearchTerms(value) {
+    const normalized = normalizeSearchText(value);
+    const terms = normalized
+        .split(" ")
+        .map((term) => term.trim())
+        .filter((term) => term.length > 1);
+    return Array.from(new Set(terms));
+}
+function normalizeSearchText(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function stringField(item, keys) {
+    for (const key of keys) {
+        const value = item[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function stringListField(item, keys) {
+    for (const key of keys) {
+        const value = item[key];
+        if (Array.isArray(value)) {
+            return value
+                .filter((entry) => typeof entry === "string")
+                .map((entry) => entry.trim())
+                .filter(Boolean);
+        }
+        if (typeof value === "string" && value.trim()) {
+            return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+        }
+    }
+    return [];
+}
+function booleanField(item, keys) {
+    for (const key of keys) {
+        const value = item[key];
+        if (typeof value === "boolean")
+            return value;
+        if (typeof value === "string") {
+            const normalized = value.trim().toLowerCase();
+            if (normalized === "true")
+                return true;
+            if (normalized === "false")
+                return false;
+        }
+    }
+    return undefined;
+}
+function numberField(item, keys) {
+    for (const key of keys) {
+        const value = item[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+        if (typeof value === "string" && value.trim()) {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+    }
+    return undefined;
+}
+function optionalNumber(key, value) {
+    return value === undefined ? {} : { [key]: value };
+}