fuli-context 0.4.0 → 0.7.2

package/src/agent/read-projection.js

@@ -1,107 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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;
-}

package/src/app/bootstrap.js

@@ -1,8 +0,0 @@
-import { SpaceKind } from '../models.js';
-
-export function bootstrapStarterSpaces(store) {
-  const personal = store.createSpace('我', SpaceKind.PERSONAL);
-  const space = store.createSpace('工作', SpaceKind.PUBLIC);
-  const subscription = store.subscribe(personal.id, space.id);
-  return { personal, space, subscription };
-}

package/src/app/create-application.js

@@ -1,143 +0,0 @@
-import { assertStorePort } from '../storage/store-port.js';
-import { AgentCandidateReadService } from '../agent/candidate-read-service.js';
-import { AgentContextPackService } from '../agent/context-pack-service.js';
-import { AgentPublicReadService } from '../agent/public-read-service.js';
-import { AgentSearchService } from '../agent/search-service.js';
-import { ContextRouter } from '../router.js';
-import { IngestionService } from '../ingestion.js';
-import { observeGitDiff } from '../observer.js';
-import { decideCandidate } from '../candidates.js';
-import { buildContextPack } from '../context-pack.js';
-import { FactService } from '../facts/fact-service.js';
-import { ApplicationError, ApplicationErrorCode } from './application-error.js';
-import { StateService } from './state-service.js';
-import { bootstrapStarterSpaces } from './bootstrap.js';
-import { LensService } from '../lens/lens-service.js';
-import { LensQuery } from '../lens/lens-query.js';
-import { LensResourceService } from '../lens/lens-resource-service.js';
-import { PublicationService } from '../publication/publication-service.js';
-import { OutboxService } from '../publication/outbox-service.js';
-
-const CANDIDATE_DECISIONS = new Set(['sync', 'personal_only', 'ignore']);
-
-export function createApplication({ store, activePersonalSpaceName = '我' }) {
-  assertStorePort(store);
-  const facts = new FactService(store);
-  const lensService = new LensService(store);
-  const lensQuery = new LensQuery(store);
-  const publicationService = new PublicationService(store);
-  const outboxService = new OutboxService(store);
-  const ingestion = new IngestionService(store, {
-    facts,
-    lens: lensService,
-    publication: publicationService
-  });
-  const context = new ContextRouter(store);
-  const state = new StateService(store);
-  const agentReads = new AgentPublicReadService(store);
-  const agentSearch = new AgentSearchService(store, lensQuery);
-  const agentCandidates = new AgentCandidateReadService(store);
-  const agentContextPack = new AgentContextPackService(
-    store,
-    agentReads,
-    agentSearch,
-    agentCandidates
-  );
-  const applyCandidateDecision = (candidateId, decision) => {
-    if (!CANDIDATE_DECISIONS.has(decision)) {
-      throw new ApplicationError(
-        ApplicationErrorCode.VALIDATION,
-        `Unknown candidate decision: ${decision}`
-      );
-    }
-    if (!store.getCandidate(candidateId)) {
-      throw new ApplicationError(
-        ApplicationErrorCode.NOT_FOUND,
-        `Candidate not found: ${candidateId}`
-      );
-    }
-    return decideCandidate(store, candidateId, decision, { ingestion });
-  };
-  const lens = Object.freeze({
-    rememberUserFact: (input) => lensService.rememberUserFact(input),
-    submitUserObservation: (input) => lensService.submitUserObservation(input),
-    confirmObservation: (input) => lensService.confirmObservation(input),
-    correctUserFact: (input) => lensService.correctUserFact(input),
-    getUserLens: (input) => lensQuery.getUserLens(input),
-    getUserLensView: (input) => lensQuery.getUserLensView(input),
-    searchUserContext: (input) => lensQuery.searchUserContext(input)
-  });
-  const lensResourceService = new LensResourceService({
-    store,
-    lens,
-    activePersonalSpace: () => requireActivePersonalSpace(store, activePersonalSpaceName)
-  });
-  const publication = Object.freeze({
-    prepare: (input) => publicationService.prepare(input),
-    verify: (envelope) => publicationService.verify(envelope),
-    pending: (at) => outboxService.pending(at),
-    markFailed: (id, error) => outboxService.markFailed(id, error),
-    markSent: (id) => outboxService.markSent(id)
-  });
-  const lensResources = Object.freeze({
-    current: () => lensResourceService.current(),
-    history: () => lensResourceService.history(),
-    subscribed: () => lensResourceService.subscribed()
-  });
-  const agent = Object.freeze({
-    remember: (input) => ingestion.remember(input),
-    search: (input) => agentSearch.search(input),
-    currentFacts: (spaceId) => agentReads.currentFacts(spaceId),
-    timeline: (spaceId, subject) => agentReads.timeline(spaceId, subject),
-    projectRules: (spaceId) => agentReads.projectRules(spaceId),
-    factHistory: (input) => agentReads.factHistory(input),
-    contextPack: (input) => agentContextPack.build(input),
-    observe: (input) => observeGitDiff({ store, ...input }),
-    listCandidates: (personalSpaceId) => agentCandidates.list(personalSpaceId),
-    decideCandidate: applyCandidateDecision
-  });
-
-  return {
-    bootstrap: () => bootstrapStarterSpaces(store),
-    createSpace: (name, kind, description = null) =>
-      store.createSpace(name, kind, description),
-    resolveSpace: ({ id, name } = {}) => {
-      if (id) return store.getSpace(id);
-      return name ? store.findSpaceByName(name) : null;
-    },
-    requireSpaceId: ({ id, name, label }) => {
-      const space = id ? store.getSpace(id) : (name ? store.findSpaceByName(name) : null);
-      if (space) return space.id;
-      throw new ApplicationError(
-        ApplicationErrorCode.NOT_FOUND,
-        `${label} not found: ${name || id || 'missing'}`
-      );
-    },
-    subscribe: (personalSpaceId, spaceId, mode = 'latest') =>
-      store.subscribe(personalSpaceId, spaceId, mode),
-    remember: agent.remember,
-    agent,
-    lens,
-    lensResources,
-    publication,
-    observe: agent.observe,
-    decideCandidate: agent.decideCandidate,
-    search: (input) => context.searchContext(input),
-    contextPack: (input) => buildContextPack(store, input),
-    state: () => state.build(),
-    activePersonalSpace: () => requireActivePersonalSpace(store, activePersonalSpaceName),
-    requireActivePersonalSpace: () => requireActivePersonalSpace(store, activePersonalSpaceName),
-    close: () => store.close()
-  };
-}
-
-function requireActivePersonalSpace(store, name) {
-  const space = store.findSpaceByName(name);
-  if (!space || space.kind !== 'personal') {
-    throw new ApplicationError(
-      ApplicationErrorCode.NOT_FOUND,
-      `Active personal space not found: ${name}`
-    );
-  }
-  return space;
-}

package/src/app/state-service.js

@@ -1,38 +0,0 @@
-import { enrichCandidate } from '../candidates.js';
-
-export class StateService {
-  constructor(store) {
-    this.store = store;
-  }
-
-  build() {
-    const spaces = this.store.listSpaces();
-    const currentFacts = spaces.flatMap((space) =>
-      this.store.currentFacts(space.id).map((fact) => this.#enrichFact(fact))
-    );
-    const historicalFacts = this.store
-      .listFacts({ includeHistorical: true })
-      .filter((fact) => fact.invalidAt)
-      .map((fact) => this.#enrichFact(fact));
-    const candidates = this.store.listCandidates().map((candidate) =>
-      enrichCandidate(this.store, candidate)
-    );
-
-    return {
-      spaces,
-      subscriptions: this.store.listSubscriptions(),
-      episodes: this.store.listEpisodes(),
-      currentFacts,
-      historicalFacts,
-      candidates
-    };
-  }
-
-  #enrichFact(fact) {
-    return {
-      ...fact,
-      spaceName: this.store.getSpace(fact.spaceId)?.name ?? fact.spaceId,
-      episode: this.store.getEpisode(fact.sourceEpisodeId)
-    };
-  }
-}

package/src/candidates.js

@@ -1,78 +0,0 @@
-import { IngestionService } from './ingestion.js';
-import { ApplicationError, ApplicationErrorCode } from './app/application-error.js';
-import { CandidateStatus } from './models.js';
-
-export function listCandidates(store, personalSpaceId) {
-  return store.pendingCandidates(personalSpaceId).map((candidate) => enrichCandidate(store, candidate));
-}
-
-export function decideCandidate(store, candidateId, decision, { ingestion = new IngestionService(store) } = {}) {
-  return store.transaction(
-    () => decideCandidateInCurrentTransaction(store, candidateId, decision, ingestion),
-    { mode: 'immediate' }
-  );
-}
-
-function decideCandidateInCurrentTransaction(store, candidateId, decision, ingestion) {
-  const candidate = store.getCandidate(candidateId);
-  if (!candidate) {
-    throw new Error(`Candidate not found: ${candidateId}`);
-  }
-  if (candidate.status !== CandidateStatus.PENDING) {
-    throw new ApplicationError(
-      ApplicationErrorCode.VALIDATION,
-      `Candidate already decided: ${candidateId}`
-    );
-  }
-
-  if (decision === 'sync') {
-    if (!candidate.targetSpaceId) {
-      throw new ApplicationError(
-        ApplicationErrorCode.VALIDATION,
-        'Syncing a candidate requires a target space'
-      );
-    }
-    const episode = episodeFor(store, candidate);
-    if (episode) {
-      ingestion.publishConfirmedInCurrentTransaction({
-        targetSpaceId: candidate.targetSpaceId,
-        sourceKind: episode.sourceKind,
-        body: episode.body,
-        sourceUri: episode.sourceUri
-      });
-    }
-    return store.updateCandidateStatus(candidate.id, CandidateStatus.SYNCED);
-  }
-
-  if (decision === 'personal_only') {
-    const episode = episodeFor(store, candidate);
-    if (episode) {
-      ingestion.confirmEpisodeInCurrentTransaction({
-        spaceId: candidate.personalSpaceId,
-        episode
-      });
-    }
-    return store.updateCandidateStatus(candidate.id, CandidateStatus.PERSONAL_ONLY);
-  }
-
-  if (decision === 'ignore') {
-    return store.updateCandidateStatus(candidate.id, CandidateStatus.IGNORED);
-  }
-
-  throw new Error(`Unknown candidate decision: ${decision}`);
-}
-
-export function enrichCandidate(store, candidate) {
-  return {
-    ...candidate,
-    personalSpaceName: store.getSpace(candidate.personalSpaceId)?.name ?? candidate.personalSpaceId,
-    targetSpaceName: candidate.targetSpaceId
-      ? store.getSpace(candidate.targetSpaceId)?.name ?? candidate.targetSpaceId
-      : null,
-    episode: episodeFor(store, candidate)
-  };
-}
-
-function episodeFor(store, candidate) {
-  return store.getEpisode(candidate.episodeId);
-}

package/src/classifier.js

@@ -1,63 +0,0 @@
-import { PublishRoute } from './models.js';
-
-const PUBLIC_SOURCE_KINDS = new Set(['prd', 'git', 'config', 'docs']);
-const PERSONAL_SOURCE_KINDS = new Set(['personal']);
-const PERSONAL_MARKERS = [
-  '我觉得',
-  '我认为',
-  '我希望',
-  '我想',
-  '我打算',
-  '我更喜欢',
-  '我喜欢',
-  '我不喜欢',
-  '我的',
-  '个人',
-  '偏好',
-  '判断'
-];
-const UNCERTAIN_MARKERS = ['可能', '也许', '不确定', '待确认', '以后要', '似乎'];
-
-export function classifyEpisode({ sourceKind, body }) {
-  if (PERSONAL_SOURCE_KINDS.has(sourceKind)) {
-    return PublishRoute.PERSONAL;
-  }
-
-  if (hasAny(body, PERSONAL_MARKERS)) {
-    return PublishRoute.PERSONAL;
-  }
-
-  if (hasAny(body, UNCERTAIN_MARKERS)) {
-    return PublishRoute.CANDIDATE;
-  }
-
-  if (PUBLIC_SOURCE_KINDS.has(sourceKind) && looksLikeFact(body)) {
-    return PublishRoute.PUBLIC;
-  }
-
-  return PublishRoute.CANDIDATE;
-}
-
-function looksLikeFact(body) {
-  return (
-    body.includes(':') ||
-    body.includes('：') ||
-    body.includes('=>') ||
-    /https?:\/\//.test(body) ||
-    looksLikeForbiddenRule(body)
-  );
-}
-
-function looksLikeForbiddenRule(body) {
-  return body
-    .split(/\r?\n/)
-    .some((line) =>
-      /^(?:这个项目|本项目|项目)?\s*(?:禁止|不要|不允许)\s*(?:使用|采用|引入|用)?\s*\S+/.test(
-        line.trim()
-      )
-    );
-}
-
-function hasAny(body, markers) {
-  return markers.some((marker) => body.includes(marker));
-}

package/src/cli/command-arguments.js

@@ -1,14 +0,0 @@
-export function option(args, flag) {
-  const index = args.indexOf(flag);
-  return index === -1 ? null : args[index + 1];
-}
-
-export function requireSpace(app, name) {
-  const space = app.resolveSpace({ name });
-  if (!space) throw new Error(`Space not found: ${name}`);
-  return space;
-}
-
-export function humanPredicate(predicate) {
-  return predicate.startsWith('has_') ? predicate.slice(4) : predicate;
-}