fuli-context 0.2.0

package/src/agent/context-pack-service.js

@@ -0,0 +1,83 @@
+import { FactStatus } from '../models.js';
+import { compactHistoryFact, compactMatch } from './read-projection.js';
+import { requirePersonalSpace, requirePublicSpace } from './space-boundary.js';
+
+export class AgentContextPackService {
+  constructor(store, publicReads, search, candidateReads) {
+    this.store = store;
+    this.publicReads = publicReads;
+    this.search = search;
+    this.candidateReads = candidateReads;
+  }
+
+  build({ personalSpaceId, spaceId, query = '' }) {
+    const personal = requirePersonalSpace(this.store, personalSpaceId);
+    const project = requirePublicSpace(this.store, spaceId);
+    const personalMatches = this.search
+      .personalMatches({ personalSpaceId, query, includeHistorical: false }, personal.name)
+      .filter(({ fact }) => [FactStatus.CONFIRMED, FactStatus.OBSERVED].includes(fact.status));
+    const publicMatches = this.search.publicMatches([spaceId], query);
+    const matches = [...personalMatches, ...publicMatches].map(compactMatch);
+    const candidates = this.candidateReads.listForSpace(personalSpaceId, spaceId);
+    return {
+      query,
+      personalSpace: compactSpace(personal),
+      space: compactSpace(project),
+      rules: this.#rules(spaceId),
+      matches,
+      histories: this.#histories(publicMatches),
+      candidateCount: candidates.length,
+      candidates,
+      answer: formatAnswer(matches)
+    };
+  }
+
+  #rules(spaceId) {
+    const rules = this.publicReads.projectRules(spaceId);
+    const compact = (fact) => compactHistoryFact(this.store, {
+      ...fact,
+      current: true
+    });
+    return {
+      spaceId: rules.spaceId,
+      spaceName: rules.spaceName,
+      forbidden: rules.forbidden.map(compact),
+      parameters: rules.parameters.map(compact),
+      links: rules.links.map(compact)
+    };
+  }
+
+  #histories(matches) {
+    const seen = new Set();
+    const histories = [];
+    for (const match of matches) {
+      const key = `${match.fact.spaceId}:${match.fact.predicate}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const history = this.publicReads.factHistory({
+        spaceId: match.fact.spaceId,
+        predicate: match.fact.predicate
+      });
+      if (history.facts.length <= 1) continue;
+      histories.push({
+        spaceId: history.spaceId,
+        spaceName: history.spaceName,
+        predicate: history.predicate,
+        facts: history.facts.map((fact) => compactHistoryFact(this.store, fact))
+      });
+    }
+    return histories;
+  }
+
+}
+
+function compactSpace(space) {
+  return { id: space.id, name: space.name, kind: space.kind };
+}
+
+function formatAnswer(matches) {
+  if (!matches.length) return 'No matching current facts found.';
+  return matches
+    .map(({ fact }) => `${fact.subject} ${fact.predicate} ${fact.object}`)
+    .join('\n');
+}

package/src/agent/public-read-policy.js

@@ -0,0 +1,39 @@
+import { FactScope, FactStatus, Sensitivity } from '../models.js';
+import { detectSensitiveContent } from '../security/sensitive-content.js';
+
+export function isAgentReadablePublicFact(store, fact) {
+  return fact?.scope === FactScope.PUBLIC &&
+    fact.status === FactStatus.CONFIRMED &&
+    fact.sensitivity === Sensitivity.NORMAL &&
+    [fact.subject, fact.predicate, fact.object].every(isSafeText) &&
+    getAgentReadablePublicSource(store, fact) !== null;
+}
+
+export function getAgentReadablePublicSource(store, fact) {
+  const episode = fact ? store.getEpisode(fact.sourceEpisodeId) : null;
+  if (!episode || episode.spaceId !== fact.spaceId) return null;
+  if (![
+    episode.sourceKind,
+    episode.sourceUri,
+    episode.body,
+    JSON.stringify(episode.metadata)
+  ].every(isSafeText)) return null;
+  return episode;
+}
+
+export function getAgentReadableReplacementId(store, fact) {
+  if (!fact.replacedByFactId) return null;
+  const replacement = store.getFact(fact.replacedByFactId);
+  return replacement?.spaceId === fact.spaceId && isAgentReadablePublicFact(store, replacement)
+    ? replacement.id
+    : null;
+}
+
+export function isSafeAgentText(value) {
+  return isSafeText(value);
+}
+
+function isSafeText(value) {
+  return value === null || value === undefined ||
+    !detectSensitiveContent(String(value)).restricted;
+}

package/src/agent/public-read-service.js

@@ -0,0 +1,69 @@
+import { getFactHistory } from '../fact-history.js';
+import { FactScope } from '../models.js';
+import { getProjectRules } from '../project-rules.js';
+import { projectPublicMatch } from './read-projection.js';
+import { requirePublicSpace } from './space-boundary.js';
+
+export class AgentPublicReadService {
+  constructor(store) {
+    this.store = store;
+  }
+
+  currentFacts(spaceId) {
+    requirePublicSpace(this.store, spaceId);
+    return this.#publicFacts(this.store.currentFacts(spaceId));
+  }
+
+  timeline(spaceId, subject) {
+    requirePublicSpace(this.store, spaceId);
+    return this.#publicFacts(this.store.timeline(spaceId, subject));
+  }
+
+  projectRules(spaceId) {
+    requirePublicSpace(this.store, spaceId);
+    const rules = getProjectRules(this.store, spaceId);
+    const facts = rules.facts
+      .filter((fact) => fact.scope === FactScope.PUBLIC)
+      .map((fact) => this.#enrich(fact))
+      .filter(Boolean);
+    return {
+      spaceId: rules.spaceId,
+      spaceName: rules.spaceName,
+      forbidden: facts.filter((fact) => fact.predicate === 'forbids'),
+      parameters: facts.filter(isProjectParameter),
+      links: facts.filter((fact) => fact.predicate === 'has_url'),
+      facts
+    };
+  }
+
+  factHistory(input) {
+    requirePublicSpace(this.store, input.spaceId);
+    const history = getFactHistory(this.store, input);
+    return {
+      ...history,
+      facts: history.facts
+        .filter((fact) => fact.scope === FactScope.PUBLIC)
+        .map((fact) => {
+          const enriched = this.#enrich(fact);
+          return enriched ? { ...enriched, current: fact.current } : null;
+        })
+        .filter(Boolean)
+    };
+  }
+
+  #publicFacts(facts) {
+    return facts
+      .filter((fact) => fact.scope === FactScope.PUBLIC)
+      .map((fact) => projectPublicMatch(this.store, fact)?.fact)
+      .filter(Boolean);
+  }
+
+  #enrich(fact) {
+    const match = projectPublicMatch(this.store, fact);
+    return match ? { ...match.fact, source: match.source } : null;
+  }
+}
+
+function isProjectParameter(fact) {
+  return fact.predicate.startsWith('has_') && fact.predicate !== 'has_url';
+}

package/src/agent/read-projection.js

@@ -0,0 +1,107 @@
+import { isCurrentFact } from '../models.js';
+import {
+  getAgentReadablePublicSource,
+  getAgentReadableReplacementId,
+  isAgentReadablePublicFact
+} from './public-read-policy.js';
+
+export function projectPersonalMatch(item, spaceName) {
+  return {
+    spaceId: item.fact.spaceId,
+    spaceName,
+    current: item.current,
+    fact: item.fact,
+    source: projectEpisode(item.sourceEpisode)
+  };
+}
+
+export function projectPublicMatch(store, fact) {
+  if (!isAgentReadablePublicFact(store, fact)) return null;
+  const source = projectEpisode(getAgentReadablePublicSource(store, fact));
+  return {
+    spaceId: fact.spaceId,
+    spaceName: store.getSpace(fact.spaceId)?.name ?? fact.spaceId,
+    current: isCurrentFact(fact),
+    fact: projectPublicFact(store, fact, source),
+    source
+  };
+}
+
+export function compactMatch(match) {
+  return {
+    spaceId: match.spaceId,
+    spaceName: match.spaceName,
+    current: match.current,
+    fact: {
+      id: match.fact.id,
+      spaceId: match.fact.spaceId,
+      subject: match.fact.subject,
+      predicate: match.fact.predicate,
+      object: match.fact.object,
+      status: match.fact.status,
+      validAt: match.fact.validAt,
+      invalidAt: match.fact.invalidAt
+    },
+    source: compactSource(match.source)
+  };
+}
+
+export function compactHistoryFact(store, fact) {
+  return {
+    id: fact.id,
+    spaceId: fact.spaceId,
+    spaceName: store.getSpace(fact.spaceId)?.name ?? fact.spaceId,
+    subject: fact.subject,
+    predicate: fact.predicate,
+    object: fact.object,
+    status: fact.status,
+    current: fact.current,
+    validAt: fact.validAt,
+    invalidAt: fact.invalidAt,
+    source: compactSource(fact.source)
+  };
+}
+
+export function compactSource(source) {
+  if (!source) return null;
+  return {
+    id: source.id,
+    kind: source.kind ?? source.sourceKind,
+    uri: source.uri ?? source.sourceUri,
+    createdAt: source.createdAt,
+    preview: firstLine(source.body)
+  };
+}
+
+function projectPublicFact(store, fact, source) {
+  return {
+    id: fact.id,
+    spaceId: fact.spaceId,
+    subject: fact.subject,
+    predicate: fact.predicate,
+    object: fact.object,
+    sourceEpisodeId: source?.id ?? null,
+    validAt: fact.validAt,
+    invalidAt: fact.invalidAt,
+    replacedByFactId: getAgentReadableReplacementId(store, fact),
+    confidence: fact.confidence,
+    sensitivity: fact.sensitivity,
+    scope: fact.scope,
+    status: fact.status
+  };
+}
+
+function projectEpisode(episode) {
+  if (!episode) return null;
+  return {
+    id: episode.id,
+    kind: episode.sourceKind,
+    uri: episode.sourceUri,
+    body: episode.body,
+    createdAt: episode.createdAt
+  };
+}
+
+function firstLine(value) {
+  return value === undefined ? undefined : String(value).split(/\r?\n/)[0].slice(0, 160);
+}

package/src/agent/search-service.js

@@ -0,0 +1,61 @@
+import { FactScope } from '../models.js';
+import { projectPersonalMatch, projectPublicMatch } from './read-projection.js';
+import { requirePersonalSpace } from './space-boundary.js';
+
+export class AgentSearchService {
+  constructor(store, lensQuery) {
+    this.store = store;
+    this.lensQuery = lensQuery;
+  }
+
+  search({ personalSpaceId, query, includeHistorical = false }) {
+    const personal = requirePersonalSpace(this.store, personalSpaceId);
+    const publicSpaceIds = this.#subscribedPublicSpaceIds(personalSpaceId);
+    const matches = [
+      ...this.personalMatches({ personalSpaceId, query, includeHistorical }, personal.name),
+      ...this.publicMatches(publicSpaceIds, query, includeHistorical)
+    ];
+    const facts = matches.map((match) => match.fact);
+    return {
+      query,
+      spaceIds: [personalSpaceId, ...publicSpaceIds],
+      matches,
+      facts,
+      answer: formatAnswer(facts)
+    };
+  }
+
+  personalMatches(input, spaceName) {
+    const personal = spaceName ?? requirePersonalSpace(this.store, input.personalSpaceId).name;
+    return this.lensQuery.searchUserContext({
+      ...input,
+      includeRestricted: false
+    }).facts.map((item) => projectPersonalMatch(item, personal));
+  }
+
+  publicMatches(spaceIds, query, includeHistorical = false) {
+    if (!spaceIds.length) return [];
+    return this.store.searchFacts(spaceIds, query, { includeHistorical })
+      .filter((fact) => fact.scope === FactScope.PUBLIC)
+      .map((fact) => projectPublicMatch(this.store, fact))
+      .filter(Boolean);
+  }
+
+  #subscribedPublicSpaceIds(personalSpaceId) {
+    return this.store.subscriptionsFor(personalSpaceId)
+      .map((subscription) => this.store.getSpace(subscription.spaceId))
+      .filter((space) => space?.kind === 'public')
+      .map((space) => space.id);
+  }
+}
+
+function formatAnswer(facts) {
+  if (!facts.length) return '没有找到相关当前事实';
+  return facts
+    .map((fact) => `${fact.subject}：${humanPredicate(fact.predicate)} 是 ${fact.object}`)
+    .join('\n');
+}
+
+function humanPredicate(predicate) {
+  return predicate.startsWith('has_') ? predicate.slice(4) : predicate;
+}

package/src/agent/space-boundary.js

@@ -0,0 +1,33 @@
+import { ApplicationError, ApplicationErrorCode } from '../app/application-error.js';
+import { SpaceKind } from '../models.js';
+
+export function requirePublicSpace(store, spaceId) {
+  const space = store.getSpace(spaceId);
+  if (!space) {
+    throw new ApplicationError(ApplicationErrorCode.NOT_FOUND, `Space not found: ${spaceId}`);
+  }
+  if (space.kind !== SpaceKind.PUBLIC) {
+    throw new ApplicationError(
+      ApplicationErrorCode.VALIDATION,
+      `Agent project reads require a public space: ${spaceId}`
+    );
+  }
+  return space;
+}
+
+export function requirePersonalSpace(store, spaceId) {
+  const space = store.getSpace(spaceId);
+  if (!space) {
+    throw new ApplicationError(
+      ApplicationErrorCode.NOT_FOUND,
+      `Personal space not found: ${spaceId}`
+    );
+  }
+  if (space.kind !== SpaceKind.PERSONAL) {
+    throw new ApplicationError(
+      ApplicationErrorCode.VALIDATION,
+      `Space is not personal: ${spaceId}`
+    );
+  }
+  return space;
+}