@chendpoc/pi-memory 0.1.12 → 0.2.0

package/src/trainer/extractFacts.ts

@@ -1,312 +0,0 @@
-import type { SessionTurn, LoadedSession } from "./sessionLoader.js";
-
-/** Relation catalog mirroring Kocoro compactMemoryRelationCatalog. */
-export const RELATION_CATALOG = {
-  people_and_social: [
-    "employed_at", "previously_employed_at", "works_on", "affiliated_with",
-    "studied_under", "studied_at", "collaborates_with", "follows_person",
-    "followed_by_person", "commented_on", "knows_about", "has_handle_on",
-    "has_email",
-  ],
-  ownership_and_company: [
-    "created", "created_by", "maintained_by", "develops",
-    "developed_by_org", "owns", "owned_by", "acquired", "acquired_by",
-    "subsidiary_of", "parent_of", "founded", "founded_by", "invested_in",
-    "received_investment_from", "customer_of", "has_customer",
-    "competes_with", "banking_relationship",
-  ],
-  technical_and_project: [
-    "uses", "used_by", "depends_on", "implemented_in", "runs_on",
-    "integrates_with", "supports", "powered_by", "loaded_via",
-    "has_component", "part_of", "has_property", "has_path", "stored_at",
-    "monitors", "targets", "enables", "enabled_by", "generates",
-    "generated_from", "implements", "implemented_by", "excludes",
-    "deleted_from",
-  ],
-  content_and_metadata: [
-    "published_on", "released", "latest_release_tag", "forked_from",
-    "inspired_by", "succeeds", "preceded_by", "describes", "described_in",
-    "category", "has_alias", "has_url", "located_in", "scheduled_for",
-    "ranked_on", "listed_on", "features_project",
-  ],
-  generic_fallback: ["related_to", "other"],
-} as const;
-
-export const ALL_RELATIONS = Object.values(RELATION_CATALOG).flat();
-
-export type EntityType =
-  | "Person" | "Company" | "Organization" | "Project" | "Tool"
-  | "Language" | "Concept" | "Document" | "File" | "Location"
-  | "Product" | "Website" | "Platform" | "Unknown";
-
-export interface ExtractedEntity {
-  name: string;
-  type: EntityType;
-  mentions: EntityMention[];
-}
-
-export interface EntityMention {
-  sessionId: string;
-  turnIndex: number;
-  snippet: string;
-}
-
-export interface ExtractedRelation {
-  headName: string;
-  relation: string;
-  tailName: string;
-  sessionId: string;
-  turnIndex: number;
-  evidence: string;
-  /** True when the session explicitly negates this relation ("no longer uses X"). */
-  negated?: boolean;
-}
-
-export interface ExtractedEvent {
-  description: string;
-  sessionId: string;
-  timestamp: string;
-  turnIndex: number;
-}
-
-export interface ExtractionResult {
-  entities: ExtractedEntity[];
-  relations: ExtractedRelation[];
-  events: ExtractedEvent[];
-}
-
-/**
- * Optional LLM-backed extractor interface. The default implementation
- * uses regex/heuristic patterns only and does not require an LLM.
- */
-export interface LLMFactExtractor {
-  extractFacts(
-    turns: SessionTurn[],
-    sessionId: string,
-  ): Promise<{
-    entities: ExtractedEntity[];
-    relations: ExtractedRelation[];
-    events: ExtractedEvent[];
-  }>;
-}
-
-export interface ExtractFactsOptions {
-  llmExtractor?: LLMFactExtractor | null;
-}
-
-// ── Heuristic patterns ──
-
-const CAPITALIZED_NAME_RE = /\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b/g;
-
-const TOOL_PROJECT_RE =
-  /\b(React|Vue|Angular|Svelte|Next\.js|Nuxt|Django|Flask|Rails|Spring|Express|FastAPI|Rust|Go|Python|TypeScript|JavaScript|Node\.js|Docker|Kubernetes|Redis|PostgreSQL|MySQL|MongoDB|SQLite|Terraform|AWS|GCP|Azure|GitHub|GitLab|Slack|Figma|Notion|Linear|Jira|Vercel|Netlify|Supabase|Firebase|Anthropic|OpenAI|Claude|GPT|Gemini|Ollama|Tailwind|GSAP|Prisma|Drizzle|Vite|Webpack|ESLint|Prettier|Vitest|Jest|Playwright|Cypress)\b/gi;
-
-const RELATION_PATTERNS: Array<{
-  re: RegExp;
-  relation: string;
-  headGroup: number;
-  tailGroup: number;
-}> = [
-  { re: /\b(\w[\w\s]*?)\s+(?:uses?|is using|使用)\s+(\w[\w\s.]*?\b)/gi, relation: "uses", headGroup: 1, tailGroup: 2 },
-  { re: /\b(\w[\w\s]*?)\s+(?:created|built|made|开发了|创建了)\s+(\w[\w\s.]*?\b)/gi, relation: "created", headGroup: 1, tailGroup: 2 },
-  { re: /\b(\w[\w\s]*?)\s+(?:works?\s+(?:at|for)|在.+工作)\s+(\w[\w\s.]*?\b)/gi, relation: "employed_at", headGroup: 1, tailGroup: 2 },
-  { re: /\b(\w[\w\s]*?)\s+(?:works?\s+on|负责)\s+(\w[\w\s.]*?\b)/gi, relation: "works_on", headGroup: 1, tailGroup: 2 },
-  { re: /\b(\w[\w\s]*?)\s+(?:collaborates?\s+with|合作)\s+(\w[\w\s.]*?\b)/gi, relation: "collaborates_with", headGroup: 1, tailGroup: 2 },
-  { re: /\b(\w[\w\s]*?)\s+(?:depends?\s+on|依赖)\s+(\w[\w\s.]*?\b)/gi, relation: "depends_on", headGroup: 1, tailGroup: 2 },
-  { re: /\b(\w[\w\s]*?)\s+(?:runs?\s+on|运行在)\s+(\w[\w\s.]*?\b)/gi, relation: "runs_on", headGroup: 1, tailGroup: 2 },
-  { re: /\b(\w[\w\s]*?)\s+(?:integrates?\s+with|集成)\s+(\w[\w\s.]*?\b)/gi, relation: "integrates_with", headGroup: 1, tailGroup: 2 },
-  { re: /\b(\w[\w\s]*?)\s+(?:founded|创立了)\s+(\w[\w\s.]*?\b)/gi, relation: "founded", headGroup: 1, tailGroup: 2 },
-  { re: /\b(\w[\w\s]*?)\s+(?:implements?|实现了)\s+(\w[\w\s.]*?\b)/gi, relation: "implements", headGroup: 1, tailGroup: 2 },
-];
-
-const NEGATION_PATTERNS: Array<{
-  re: RegExp;
-  relation: string;
-  entityGroup: number;
-}> = [
-  { re: /\b(?:no longer|stopped|quit|dropped|gave up|abandoned)\s+(?:using|uses?)\s+(\w[\w\s.]*?\b)/gi, relation: "uses", entityGroup: 1 },
-  { re: /(?:不再|停止|放弃)(?:使用|用)\s*([A-Za-z][\w\s.]*\w)/gi, relation: "uses", entityGroup: 1 },
-  { re: /\b(?:left|quit|resigned from|no longer (?:works?|employed) (?:at|for))\s+(\w[\w\s.]*?\b)/gi, relation: "employed_at", entityGroup: 1 },
-  { re: /(?:不再|离开了|辞去了?)(?:在)?\s*([A-Za-z][\w\s.]*\w)/gi, relation: "employed_at", entityGroup: 1 },
-  { re: /\b(?:stopped|quit|no longer)\s+(?:working on|developing|maintaining)\s+(\w[\w\s.]*?\b)/gi, relation: "works_on", entityGroup: 1 },
-  { re: /(?:不再|停止)\s*(?:负责|开发|维护)\s*([A-Za-z][\w\s.]*\w)/gi, relation: "works_on", entityGroup: 1 },
-  { re: /\b(?:removed|dropped|deleted|uninstalled)\s+(\w[\w\s.]*?\b)/gi, relation: "uses", entityGroup: 1 },
-  { re: /\b(?:switched|migrated|moved)\s+(?:from)\s+(\w[\w\s.]*?)\s+(?:to)\s+\w/gi, relation: "uses", entityGroup: 1 },
-  { re: /(?:从)\s*([A-Za-z][\w\s.]*\w)\s*(?:迁移|切换|换)(?:到|成)/gi, relation: "uses", entityGroup: 1 },
-];
-
-export const UPDATE_SIGNAL_RE = /\b(?:now|switched to|migrated to|moved to|changed to|upgraded to|replaced with|改用|换成|切换到|迁移到|升级到)\b/i;
-
-const EVENT_PATTERNS: RegExp[] = [
-  /\b(?:decided|agreed|shipped|released|launched|deployed|migrated|completed|finished|merged|approved|resolved)\b/i,
-  /\b(?:决定|完成|上线|发布|部署|迁移|合并|通过)\b/,
-];
-
-const NOISE_WORDS = new Set([
-  "the", "a", "an", "this", "that", "it", "i", "we", "they", "he", "she",
-  "my", "our", "their", "you", "your", "its",
-  "is", "are", "was", "were", "be", "been", "being",
-  "has", "have", "had", "do", "does", "did",
-  "will", "would", "could", "should", "can", "may", "might",
-  "not", "no", "yes", "ok", "sure", "thanks", "thank",
-  "if", "but", "and", "or", "so", "then", "also",
-]);
-
-function isNoiseName(name: string): boolean {
-  const lower = name.toLowerCase().trim();
-  if (lower.length < 2 || lower.length > 60) return true;
-  const words = lower.split(/\s+/);
-  return words.every((w) => NOISE_WORDS.has(w));
-}
-
-function inferEntityType(name: string): EntityType {
-  const lower = name.toLowerCase();
-  const toolMatch = name.match(TOOL_PROJECT_RE);
-  if (toolMatch && toolMatch[0]!.toLowerCase() === lower) return "Tool";
-
-  if (/\b(?:inc|corp|ltd|llc|gmbh|co|company|group)\b/i.test(name)) return "Company";
-  if (/\b(?:university|institute|foundation|org)\b/i.test(name)) return "Organization";
-  if (/^[A-Z][a-z]+(?:\s+[A-Z][a-z]+)+$/.test(name)) return "Person";
-
-  return "Unknown";
-}
-
-function snippet(text: string, maxLen = 120): string {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen) + "...";
-}
-
-/**
- * Extract structured facts from a single session's turns using
- * regex/heuristic patterns. For deeper extraction, pass an LLMFactExtractor.
- */
-export async function extractFacts(
-  session: LoadedSession,
-  opts?: ExtractFactsOptions,
-): Promise<ExtractionResult> {
-  if (opts?.llmExtractor) {
-    return opts.llmExtractor.extractFacts(session.turns, session.id);
-  }
-
-  const entMap = new Map<string, ExtractedEntity>();
-  const relations: ExtractedRelation[] = [];
-  const events: ExtractedEvent[] = [];
-
-  function addEntity(
-    name: string,
-    type: EntityType,
-    turn: SessionTurn,
-  ): void {
-    const trimmed = name.trim();
-    if (isNoiseName(trimmed)) return;
-    const key = trimmed.toLowerCase();
-    let ent = entMap.get(key);
-    if (!ent) {
-      ent = { name: trimmed, type, mentions: [] };
-      entMap.set(key, ent);
-    }
-    if (type !== "Unknown" && ent.type === "Unknown") {
-      ent.type = type;
-    }
-    ent.mentions.push({
-      sessionId: session.id,
-      turnIndex: turn.turnIndex,
-      snippet: snippet(turn.content),
-    });
-  }
-
-  for (const turn of session.turns) {
-    const text = turn.content;
-
-    // Extract capitalized multi-word names (likely Person names)
-    for (const m of text.matchAll(CAPITALIZED_NAME_RE)) {
-      addEntity(m[1]!, inferEntityType(m[1]!), turn);
-    }
-
-    // Extract known tools/projects
-    for (const m of text.matchAll(TOOL_PROJECT_RE)) {
-      addEntity(m[0]!, "Tool", turn);
-    }
-
-    // Extract relations
-    for (const pattern of RELATION_PATTERNS) {
-      for (const m of text.matchAll(pattern.re)) {
-        const head = m[pattern.headGroup]?.trim() ?? "";
-        const tail = m[pattern.tailGroup]?.trim() ?? "";
-        if (isNoiseName(head) || isNoiseName(tail)) continue;
-        addEntity(head, inferEntityType(head), turn);
-        addEntity(tail, inferEntityType(tail), turn);
-        relations.push({
-          headName: head,
-          relation: pattern.relation,
-          tailName: tail,
-          sessionId: session.id,
-          turnIndex: turn.turnIndex,
-          evidence: snippet(text),
-        });
-      }
-    }
-
-    // Extract negated relations ("no longer uses X", "stopped using X")
-    for (const pattern of NEGATION_PATTERNS) {
-      for (const m of text.matchAll(pattern.re)) {
-        const entityName = m[pattern.entityGroup]?.trim() ?? "";
-        if (isNoiseName(entityName)) continue;
-        addEntity(entityName, inferEntityType(entityName), turn);
-        relations.push({
-          headName: "",
-          relation: pattern.relation,
-          tailName: entityName,
-          sessionId: session.id,
-          turnIndex: turn.turnIndex,
-          evidence: snippet(text),
-          negated: true,
-        });
-      }
-    }
-
-    // Detect events (decisions, milestones)
-    for (const re of EVENT_PATTERNS) {
-      if (re.test(text)) {
-        events.push({
-          description: snippet(text, 200),
-          sessionId: session.id,
-          timestamp: session.createdAt || new Date().toISOString(),
-          turnIndex: turn.turnIndex,
-        });
-        break;
-      }
-    }
-  }
-
-  return {
-    entities: [...entMap.values()],
-    relations,
-    events,
-  };
-}
-
-/**
- * Extract facts from multiple sessions and merge results.
- */
-export async function extractFactsFromSessions(
-  sessions: LoadedSession[],
-  opts?: ExtractFactsOptions,
-): Promise<ExtractionResult> {
-  const allEntities: ExtractedEntity[] = [];
-  const allRelations: ExtractedRelation[] = [];
-  const allEvents: ExtractedEvent[] = [];
-
-  for (const session of sessions) {
-    const result = await extractFacts(session, opts);
-    allEntities.push(...result.entities);
-    allRelations.push(...result.relations);
-    allEvents.push(...result.events);
-  }
-
-  return {
-    entities: allEntities,
-    relations: allRelations,
-    events: allEvents,
-  };
-}

package/src/trainer/index.ts

@@ -1,147 +0,0 @@
-import { installBundle } from "../bundle/install.js";
-import { defaultBundleRoot, defaultSessionsDir } from "../paths.js";
-
-import { loadSessions } from "./sessionLoader.js";
-import { extractFactsFromSessions, type ExtractFactsOptions } from "./extractFacts.js";
-import { resolveEntities } from "./entityResolver.js";
-import { buildBundle, type BuildBundleResult } from "./bundleBuilder.js";
-import { readMarker, writeMarker } from "./marker.js";
-import { loadExistingBundle } from "./bundleLoader.js";
-import { deltaMerge, type DeltaLog } from "./deltaMerge.js";
-
-export interface TrainBundleConfig {
-  sessionsDir?: string;
-  bundleRoot?: string;
-  /** Ignore marker and rebuild from all sessions. */
-  full?: boolean;
-  /** Show what would be extracted without writing. */
-  dryRun?: boolean;
-  /** Bundle version to stamp (default "0.6.0"). */
-  bundleVersion?: string;
-  /** Extraction options (optional LLM extractor). */
-  extractOpts?: ExtractFactsOptions;
-  /** Skip delta merge — full rebuild even if existing bundle present (default false). */
-  noMerge?: boolean;
-}
-
-export interface TrainBundleResult {
-  sessionsProcessed: number;
-  entityCount: number;
-  relationCount: number;
-  eventCount: number;
-  bundleResult?: BuildBundleResult;
-  installResult?: {
-    bundle_ts: string;
-    bundle_version: string;
-    installed_dir: string;
-    files_copied: number;
-  };
-  dryRun: boolean;
-  /** Delta operation log when merge was performed. */
-  delta?: DeltaLog;
-}
-
-/**
- * Full training pipeline:
- *   load existing bundle → extract new → delta merge → build → install → update marker.
- *
- * When `noMerge` is true (or no existing bundle), falls back to full rebuild.
- */
-export async function trainBundle(
-  config: TrainBundleConfig = {},
-): Promise<TrainBundleResult> {
-  const sessionsDir = config.sessionsDir ?? defaultSessionsDir();
-  const bundleRoot = config.bundleRoot ?? defaultBundleRoot();
-
-  let modifiedAfter: Date | null = null;
-  if (!config.full) {
-    modifiedAfter = await readMarker(bundleRoot);
-  }
-
-  const sessions = await loadSessions({ sessionsDir, modifiedAfter });
-
-  if (sessions.length === 0) {
-    return {
-      sessionsProcessed: 0,
-      entityCount: 0,
-      relationCount: 0,
-      eventCount: 0,
-      dryRun: config.dryRun ?? false,
-    };
-  }
-
-  const extracted = await extractFactsFromSessions(sessions, config.extractOpts);
-  const newGraph = resolveEntities(extracted.entities, extracted.relations);
-
-  let finalGraph = newGraph;
-  let finalEvents = extracted.events;
-  let deltaLog: DeltaLog | undefined;
-
-  if (!config.noMerge) {
-    const existingBundle = await loadExistingBundle(bundleRoot);
-    if (existingBundle) {
-      const merged = deltaMerge(
-        existingBundle,
-        { graph: newGraph, events: extracted.events },
-      );
-      finalGraph = merged.graph;
-      finalEvents = merged.events;
-      deltaLog = merged.delta;
-    }
-  }
-
-  if (config.dryRun) {
-    return {
-      sessionsProcessed: sessions.length,
-      entityCount: finalGraph.entities.length,
-      relationCount: finalGraph.relations.length,
-      eventCount: finalEvents.length,
-      dryRun: true,
-      delta: deltaLog,
-    };
-  }
-
-  const bundleResult = await buildBundle(
-    { graph: finalGraph, events: finalEvents },
-    { outputDir: bundleRoot, bundleVersion: config.bundleVersion },
-  );
-
-  const installResult = await installBundle({
-    bundleRoot,
-    sourceDir: bundleResult.bundleDir,
-  });
-
-  const latestMtime = sessions.reduce(
-    (max, s) => (s.modifiedAt > max ? s.modifiedAt : max),
-    sessions[0]!.modifiedAt,
-  );
-  await writeMarker(bundleRoot, latestMtime);
-
-  return {
-    sessionsProcessed: sessions.length,
-    entityCount: bundleResult.stats.entityCount,
-    relationCount: bundleResult.stats.edgeCount,
-    eventCount: bundleResult.stats.eventCount,
-    bundleResult,
-    installResult,
-    dryRun: false,
-    delta: deltaLog,
-  };
-}
-
-export { loadSessions } from "./sessionLoader.js";
-export type { LoadedSession, SessionTurn, SessionLoaderOptions } from "./sessionLoader.js";
-export { extractFacts, extractFactsFromSessions, RELATION_CATALOG, ALL_RELATIONS } from "./extractFacts.js";
-export type {
-  ExtractedEntity, ExtractedRelation, ExtractedEvent,
-  ExtractionResult, EntityType, LLMFactExtractor, ExtractFactsOptions,
-} from "./extractFacts.js";
-export { resolveEntities } from "./entityResolver.js";
-export type { ResolvedEntity, ResolvedRelation, ResolvedGraph } from "./entityResolver.js";
-export { buildBundle } from "./bundleBuilder.js";
-export type { BundleData, BuildBundleOptions, BuildBundleResult } from "./bundleBuilder.js";
-export { readMarker, writeMarker } from "./marker.js";
-export { loadExistingBundle } from "./bundleLoader.js";
-export type { ExistingBundle } from "./bundleLoader.js";
-export { deltaMerge } from "./deltaMerge.js";
-export type { DeltaOp, DeltaLogEntry, DeltaLog, MergeResult } from "./deltaMerge.js";

package/src/trainer/llmExtractor.ts

@@ -1,206 +0,0 @@
-import type { SessionTurn } from "./sessionLoader.js";
-import type {
-  ExtractedEntity,
-  ExtractedRelation,
-  ExtractedEvent,
-  LLMFactExtractor,
-  EntityType,
-} from "./extractFacts.js";
-import { extractFacts } from "./extractFacts.js";
-import type { LoadedSession } from "./sessionLoader.js";
-import { ALL_RELATIONS } from "./extractFacts.js";
-
-/** Provider-agnostic LLM client — any backend that can complete a prompt. */
-export interface LLMClient {
-  complete(prompt: string): Promise<string>;
-}
-
-export interface LLMExtractorOptions {
-  client: LLMClient;
-  /** How many turns to send per LLM call (default 10). */
-  batchSize?: number;
-}
-
-const VALID_ENTITY_TYPES = new Set<string>([
-  "Person", "Project", "Tool", "Company", "Organization",
-  "Location", "Document",
-]);
-
-const VALID_ENTITY_TYPES_FULL = new Set<string>([
-  ...VALID_ENTITY_TYPES,
-  "Language", "Concept", "File", "Product", "Website", "Platform", "Unknown",
-]);
-
-const RELATION_SET: Set<string> = new Set(ALL_RELATIONS);
-
-function buildPrompt(turns: SessionTurn[], sessionId: string): string {
-  const turnsText = turns
-    .map((t) => `[${t.role} #${t.turnIndex}]: ${t.content}`)
-    .join("\n\n");
-
-  return `You are a structured fact extractor. Analyze the following conversation turns and extract:
-
-1. **Entities** — people, projects, tools, companies, organizations, locations, documents mentioned.
-   Each entity: { "name": string, "type": one of "Person"|"Project"|"Tool"|"Company"|"Organization"|"Location"|"Document" }
-
-2. **Relations** — connections between entities. Use ONLY these relation types:
-   ${ALL_RELATIONS.join(", ")}
-   Each relation: { "head": string, "relation": string, "tail": string, "turn_index": number, "evidence": string, "negated": boolean }
-   Set negated=true only when the text explicitly says something is no longer true (e.g. "no longer uses X").
-
-3. **Events** — decisions, milestones, deadlines, deployments.
-   Each event: { "description": string, "turn_index": number }
-
-Session ID: ${sessionId}
-
-Conversation:
-${turnsText}
-
-Respond with ONLY a JSON object (no markdown fences, no explanation):
-{
-  "entities": [...],
-  "relations": [...],
-  "events": [...]
-}`;
-}
-
-function parseEntityType(raw: string): EntityType {
-  if (VALID_ENTITY_TYPES_FULL.has(raw)) return raw as EntityType;
-  return "Unknown";
-}
-
-interface RawLLMEntity {
-  name?: string;
-  type?: string;
-}
-
-interface RawLLMRelation {
-  head?: string;
-  relation?: string;
-  tail?: string;
-  turn_index?: number;
-  evidence?: string;
-  negated?: boolean;
-}
-
-interface RawLLMEvent {
-  description?: string;
-  turn_index?: number;
-}
-
-interface RawLLMResponse {
-  entities?: RawLLMEntity[];
-  relations?: RawLLMRelation[];
-  events?: RawLLMEvent[];
-}
-
-function parseLLMResponse(
-  raw: string,
-  sessionId: string,
-  turns: SessionTurn[],
-): { entities: ExtractedEntity[]; relations: ExtractedRelation[]; events: ExtractedEvent[] } {
-  const cleaned = raw.replace(/^```(?:json)?\s*/m, "").replace(/\s*```\s*$/m, "").trim();
-  const parsed: RawLLMResponse = JSON.parse(cleaned);
-
-  const entities: ExtractedEntity[] = [];
-  if (Array.isArray(parsed.entities)) {
-    for (const e of parsed.entities) {
-      const name = typeof e.name === "string" ? e.name.trim() : "";
-      if (!name || name.length > 100) continue;
-      entities.push({
-        name,
-        type: parseEntityType(typeof e.type === "string" ? e.type : "Unknown"),
-        mentions: [{
-          sessionId,
-          turnIndex: 0,
-          snippet: name,
-        }],
-      });
-    }
-  }
-
-  const relations: ExtractedRelation[] = [];
-  if (Array.isArray(parsed.relations)) {
-    for (const r of parsed.relations) {
-      const head = typeof r.head === "string" ? r.head.trim() : "";
-      const tail = typeof r.tail === "string" ? r.tail.trim() : "";
-      const relation = typeof r.relation === "string" ? r.relation.trim() : "";
-      if (!head || !tail || !relation) continue;
-      if (!RELATION_SET.has(relation)) continue;
-      const turnIdx = typeof r.turn_index === "number" ? r.turn_index : 0;
-      relations.push({
-        headName: head,
-        relation,
-        tailName: tail,
-        sessionId,
-        turnIndex: turnIdx,
-        evidence: typeof r.evidence === "string" ? r.evidence.slice(0, 200) : "",
-        negated: r.negated === true ? true : undefined,
-      });
-    }
-  }
-
-  const events: ExtractedEvent[] = [];
-  if (Array.isArray(parsed.events)) {
-    for (const ev of parsed.events) {
-      const desc = typeof ev.description === "string" ? ev.description.trim() : "";
-      if (!desc) continue;
-      const turnIdx = typeof ev.turn_index === "number" ? ev.turn_index : 0;
-      const matchingTurn = turns.find((t) => t.turnIndex === turnIdx);
-      events.push({
-        description: desc.slice(0, 300),
-        sessionId,
-        timestamp: new Date().toISOString(),
-        turnIndex: matchingTurn?.turnIndex ?? turnIdx,
-      });
-    }
-  }
-
-  return { entities, relations, events };
-}
-
-/**
- * LLM-backed fact extractor. Sends turn batches to the LLM, parses
- * structured JSON. Falls back to regex extraction on any LLM failure.
- */
-export function createLLMFactExtractor(opts: LLMExtractorOptions): LLMFactExtractor {
-  const batchSize = opts.batchSize ?? 10;
-
-  return {
-    async extractFacts(
-      turns: SessionTurn[],
-      sessionId: string,
-    ): Promise<{ entities: ExtractedEntity[]; relations: ExtractedRelation[]; events: ExtractedEvent[] }> {
-      const allEntities: ExtractedEntity[] = [];
-      const allRelations: ExtractedRelation[] = [];
-      const allEvents: ExtractedEvent[] = [];
-
-      for (let i = 0; i < turns.length; i += batchSize) {
-        const batch = turns.slice(i, i + batchSize);
-        try {
-          const prompt = buildPrompt(batch, sessionId);
-          const response = await opts.client.complete(prompt);
-          const parsed = parseLLMResponse(response, sessionId, batch);
-          allEntities.push(...parsed.entities);
-          allRelations.push(...parsed.relations);
-          allEvents.push(...parsed.events);
-        } catch {
-          const fallbackSession: LoadedSession = {
-            id: sessionId,
-            title: "",
-            createdAt: new Date().toISOString(),
-            filePath: "",
-            modifiedAt: new Date(),
-            turns: batch,
-          };
-          const fallback = await extractFacts(fallbackSession);
-          allEntities.push(...fallback.entities);
-          allRelations.push(...fallback.relations);
-          allEvents.push(...fallback.events);
-        }
-      }
-
-      return { entities: allEntities, relations: allRelations, events: allEvents };
-    },
-  };
-}

package/src/trainer/marker.ts

@@ -1,30 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-/**
- * Read the last-trained marker timestamp.
- * Returns null if marker file does not exist or is unreadable.
- */
-export async function readMarker(memoryDir: string): Promise<Date | null> {
-  const markerPath = path.join(memoryDir, ".train_marker");
-  try {
-    const raw = (await fs.readFile(markerPath, "utf8")).trim();
-    if (!raw) return null;
-    const d = new Date(raw);
-    return isNaN(d.getTime()) ? null : d;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Write the last-trained marker timestamp (ISO string).
- */
-export async function writeMarker(
-  memoryDir: string,
-  ts: Date,
-): Promise<void> {
-  const markerPath = path.join(memoryDir, ".train_marker");
-  await fs.mkdir(memoryDir, { recursive: true });
-  await fs.writeFile(markerPath, ts.toISOString() + "\n", "utf8");
-}