Skip to content

Local-first 🧠 memory for Hermes Agent that lives in your Obsidian vault and remembers project context. Nightly 😴 dream passes turn repeat corrections into confirmed preferences with measurable confidence. Adapters ship for Claude Code, Codex, and OpenClaw, with an MCP server for anything else.

TypeScript
5.7 KB
Raw Blame
import { queryAgentSources, type AgentSourceQueryOptions } from "./query.ts";
import type { AgentSourceContribution, AgentSourceContributionKind } from "./types.ts";

export type AgentSourceDiffMode = "browse" | "search" | "diff" | "map";

export interface AgentSourceDiffOptions extends AgentSourceQueryOptions {
  readonly mode?: AgentSourceDiffMode;
}

export interface AgentSourceDiffPerAgent {
  readonly agent: string;
  readonly contribution_count: number;
  readonly topics: ReadonlyArray<string>;
  readonly kinds: ReadonlyArray<AgentSourceContributionKind>;
}

export interface AgentSourceDiffTopicMapEntry {
  readonly topic: string;
  readonly agents: ReadonlyArray<string>;
  readonly contribution_count: number;
}

export interface AgentSourceDiffResult {
  readonly mode: "agent-diff";
  readonly diff_mode: AgentSourceDiffMode;
  readonly agents: ReadonlyArray<string>;
  readonly unknown_agents: ReadonlyArray<string>;
  readonly per_agent: ReadonlyArray<AgentSourceDiffPerAgent>;
  readonly shared_topics: ReadonlyArray<string>;
  readonly unique_topics: Readonly<Record<string, ReadonlyArray<string>>>;
  readonly topic_map: ReadonlyArray<AgentSourceDiffTopicMapEntry>;
  readonly total_matched: number;
  readonly returned: number;
  readonly contributions: ReadonlyArray<AgentSourceContribution>;
  readonly summary: string;
}

export function diffAgentSources(
  vault: string,
  opts: AgentSourceDiffOptions = {},
): AgentSourceDiffResult {
  const diffMode = opts.mode ?? (opts.query ? "search" : "browse");
  const query = queryAgentSources(vault, opts);
  const perAgent = buildPerAgent(query.filters.agents, query.contributions);
  const topicMap = buildTopicMap(query.contributions);
  const sharedTopics = buildSharedTopics(query.filters.agents, perAgent);
  const uniqueTopics = buildUniqueTopics(query.filters.agents, perAgent);

  return Object.freeze({
    mode: "agent-diff",
    diff_mode: diffMode,
    agents: query.filters.agents,
    unknown_agents: query.unknown_agents,
    per_agent: Object.freeze(perAgent),
    shared_topics: Object.freeze(sharedTopics),
    unique_topics: Object.freeze(uniqueTopics),
    topic_map: Object.freeze(topicMap),
    total_matched: query.total_matched,
    returned: query.returned,
    contributions: query.contributions,
    summary: summarizeDiff(diffMode, sharedTopics, uniqueTopics),
  });
}

function buildPerAgent(
  agents: ReadonlyArray<string>,
  contributions: ReadonlyArray<AgentSourceContribution>,
): AgentSourceDiffPerAgent[] {
  return agents.map((agent) => {
    const agentContributions = contributions.filter((c) => c.agents.includes(agent));
    const topics = new Set<string>();
    const kinds = new Set<AgentSourceContributionKind>();
    for (const contribution of agentContributions) {
      if (contribution.topic !== undefined) topics.add(contribution.topic);
      kinds.add(contribution.kind);
    }
    return Object.freeze({
      agent,
      contribution_count: agentContributions.length,
      topics: Object.freeze([...topics].toSorted()),
      kinds: Object.freeze([...kinds].toSorted()),
    });
  });
}

function buildTopicMap(
  contributions: ReadonlyArray<AgentSourceContribution>,
): AgentSourceDiffTopicMapEntry[] {
  const byTopic = new Map<string, { agents: Set<string>; contributionCount: number }>();
  for (const contribution of contributions) {
    if (contribution.topic === undefined) continue;
    const current = byTopic.get(contribution.topic) ?? {
      agents: new Set<string>(),
      contributionCount: 0,
    };
    for (const agent of contribution.agents) current.agents.add(agent);
    current.contributionCount++;
    byTopic.set(contribution.topic, current);
  }

  const rows: AgentSourceDiffTopicMapEntry[] = [];
  for (const [topic, row] of byTopic) {
    rows.push(
      Object.freeze({
        topic,
        agents: Object.freeze([...row.agents].toSorted()),
        contribution_count: row.contributionCount,
      }),
    );
  }
  rows.sort((a, b) => a.topic.localeCompare(b.topic));
  return rows;
}

function buildSharedTopics(
  agents: ReadonlyArray<string>,
  perAgent: ReadonlyArray<AgentSourceDiffPerAgent>,
): string[] {
  if (agents.length === 0) return [];
  const topicSets = new Map(perAgent.map((entry) => [entry.agent, new Set(entry.topics)]));
  const first = topicSets.get(agents[0]!) ?? new Set<string>();
  const shared: string[] = [];
  for (const topic of first) {
    if (agents.every((agent) => topicSets.get(agent)?.has(topic) ?? false)) {
      shared.push(topic);
    }
  }
  return shared.toSorted();
}

function buildUniqueTopics(
  agents: ReadonlyArray<string>,
  perAgent: ReadonlyArray<AgentSourceDiffPerAgent>,
): Record<string, ReadonlyArray<string>> {
  const topicSets = new Map(perAgent.map((entry) => [entry.agent, new Set(entry.topics)]));
  const out: Record<string, ReadonlyArray<string>> = {};
  for (const agent of agents) {
    const own = topicSets.get(agent) ?? new Set<string>();
    const unique: string[] = [];
    for (const topic of own) {
      const appearsElsewhere = agents.some(
        (other) => other !== agent && (topicSets.get(other)?.has(topic) ?? false),
      );
      if (!appearsElsewhere) unique.push(topic);
    }
    out[agent] = Object.freeze(unique.toSorted());
  }
  return out;
}

function summarizeDiff(
  mode: AgentSourceDiffMode,
  sharedTopics: ReadonlyArray<string>,
  uniqueTopics: Readonly<Record<string, ReadonlyArray<string>>>,
): string {
  const sharedLabel = `${sharedTopics.length} shared ${sharedTopics.length === 1 ? "topic" : "topics"}`;
  const uniqueCount = Object.values(uniqueTopics).reduce((sum, topics) => sum + topics.length, 0);
  const uniqueLabel = `${uniqueCount} unique ${uniqueCount === 1 ? "topic" : "topics"}`;
  return `${mode}: ${sharedLabel}; ${uniqueLabel}.`;
}