claude-memory-layer 1.0.31 → 1.0.33

package/src/core/derive/fact-deriver.ts

@@ -1,170 +0,0 @@
-import { createHash } from 'crypto';
-
-import type { MemoryEvent } from '../types.js';
-import type { MemoryFact, MemoryFactType } from '../model/memory-fact.js';
-
-export interface FactDerivationOptions {
-  /** Fallback project hash when the source event metadata does not carry scope.project.hash. */
-  projectHash?: string;
-  /** Optional current time hook for deterministic tests. */
-  now?: Date;
-}
-
-const DEFAULT_PROJECT_HASH = 'default';
-const MAX_FACT_TEXT_LENGTH = 600;
-
-/**
- * Create a stable, rebuild-safe fact id for an event-derived fact.
- *
- * Format intentionally avoids UUID randomness so derived fact stores can be
- * dropped and rebuilt without producing duplicate logical facts.
- */
-export function makeEventDerivedFactId(
-  eventId: string,
-  factType: MemoryFactType,
-  ordinal = 0
-): string {
-  const digest = createHash('sha1')
-    .update(`${eventId}:${factType}:${ordinal}`)
-    .digest('hex')
-    .slice(0, 16);
-
-  return `fact:event:${eventId}:${factType}:${ordinal}:${digest}`;
-}
-
-export class FactDeriver {
-  deriveFromEvent(event: MemoryEvent, options: FactDerivationOptions = {}): MemoryFact[] {
-    const text = this.toFactText(event);
-    if (!text) return [];
-
-    const factType = this.inferFactType(event);
-    const now = (options.now ?? new Date()).toISOString();
-    const metadata = this.asRecord(event.metadata);
-    const projectHash = this.getProjectHash(metadata) ?? options.projectHash ?? DEFAULT_PROJECT_HASH;
-    const tags = this.getTags(metadata);
-
-    return [{
-      factId: makeEventDerivedFactId(event.id, factType),
-      projectHash,
-      factType,
-      text,
-      derivedFromEventIds: [event.id],
-      sourceKind: this.getSourceKind(event),
-      confidence: this.getConfidence(event),
-      importance: this.getImportance(event),
-      tags,
-      ...(this.getFileRefs(metadata).length > 0 ? { fileRefs: this.getFileRefs(metadata) } : {}),
-      createdAt: now,
-      updatedAt: now
-    }];
-  }
-
-  private toFactText(event: MemoryEvent): string | null {
-    const content = event.content.trim().replace(/\s+/g, ' ');
-    if (!content) return null;
-
-    const clipped = content.length > MAX_FACT_TEXT_LENGTH
-      ? `${content.slice(0, MAX_FACT_TEXT_LENGTH - 1)}…`
-      : content;
-
-    switch (event.eventType) {
-      case 'user_prompt':
-        return `User asked: ${clipped}`;
-      case 'agent_response':
-        return `Assistant responded: ${clipped}`;
-      case 'session_summary':
-        return `Session summary: ${clipped}`;
-      case 'tool_observation': {
-        const metadata = this.asRecord(event.metadata);
-        const toolName = typeof metadata.toolName === 'string' ? metadata.toolName : 'unknown_tool';
-        const success = typeof metadata.success === 'boolean'
-          ? metadata.success
-          : undefined;
-        const status = success === undefined ? '' : success ? ' succeeded' : ' failed';
-        return `Tool ${toolName}${status}: ${clipped}`;
-      }
-    }
-  }
-
-  private inferFactType(event: MemoryEvent): MemoryFactType {
-    if (event.eventType === 'tool_observation') return 'tool_observation';
-    if (event.eventType === 'session_summary') return 'summary_fact';
-
-    const content = event.content.toLowerCase();
-    if (/\b(decided|decision|선택|결정)\b/.test(content)) return 'decision';
-    if (/\b(must|should not|constraint|requirement|제약|필수|금지)\b/.test(content)) return 'constraint';
-    if (/\b(todo|task|next|pending|해야|작업|진행)\b/.test(content)) return 'task_state';
-    if (/\b(prefer|preference|선호)\b/.test(content)) return 'preference';
-    if (/\b(src\/|tests\/|\.ts|\.tsx|\.js|\.py|function|class)\b/.test(content)) return 'code_context';
-
-    return 'task_state';
-  }
-
-  private getSourceKind(event: MemoryEvent): MemoryFact['sourceKind'] {
-    switch (event.eventType) {
-      case 'user_prompt':
-        return 'prompt';
-      case 'agent_response':
-      case 'session_summary':
-        return 'assistant';
-      case 'tool_observation':
-        return 'tool';
-    }
-  }
-
-  private getConfidence(event: MemoryEvent): number {
-    switch (event.eventType) {
-      case 'session_summary':
-        return 0.8;
-      case 'tool_observation':
-        return 0.75;
-      case 'agent_response':
-        return 0.7;
-      case 'user_prompt':
-        return 0.65;
-    }
-  }
-
-  private getImportance(event: MemoryEvent): number {
-    const metadata = this.asRecord(event.metadata);
-    const importance = metadata.importance;
-    if (typeof importance === 'number' && Number.isFinite(importance)) {
-      return Math.max(0, Math.min(1, importance));
-    }
-
-    if (event.eventType === 'session_summary') return 0.8;
-    if (event.eventType === 'tool_observation') return 0.6;
-    return 0.5;
-  }
-
-  private getProjectHash(metadata: Record<string, unknown>): string | undefined {
-    const scope = this.asRecord(metadata.scope);
-    const project = this.asRecord(scope.project);
-    return typeof project.hash === 'string' && project.hash.length > 0
-      ? project.hash
-      : undefined;
-  }
-
-  private getTags(metadata: Record<string, unknown>): string[] {
-    return Array.isArray(metadata.tags)
-      ? metadata.tags.filter((tag): tag is string => typeof tag === 'string' && tag.length > 0)
-      : [];
-  }
-
-  private getFileRefs(metadata: Record<string, unknown>): string[] {
-    const refs = metadata.fileRefs ?? metadata.files;
-    return Array.isArray(refs)
-      ? refs.filter((ref): ref is string => typeof ref === 'string' && ref.length > 0)
-      : [];
-  }
-
-  private asRecord(value: unknown): Record<string, unknown> {
-    return value && typeof value === 'object' && !Array.isArray(value)
-      ? value as Record<string, unknown>
-      : {};
-  }
-}
-
-export function createFactDeriver(): FactDeriver {
-  return new FactDeriver();
-}

package/src/core/derive/index.ts

@@ -1,2 +0,0 @@
-export * from './fact-deriver.js';
-export * from './summary-deriver.js';

package/src/core/derive/summary-deriver.ts

@@ -1,76 +0,0 @@
-import type { MemoryEvent } from '../types.js';
-
-export interface SessionSummaryDerivation {
-  text: string;
-  metadata: {
-    generated: 'rule-based';
-    eventCount: number;
-  };
-}
-
-const MAX_FIRST_PROMPT_LENGTH = 120;
-const MAX_TOOL_NAMES = 6;
-
-export class SummaryDeriver {
-  /**
-   * Derive the current lightweight rule-based session summary from raw events.
-   *
-   * The deriver is intentionally pure: callers own persistence and lifecycle
-   * orchestration, while this class owns summary text and metadata decisions.
-   */
-  deriveSessionSummary(events: MemoryEvent[]): SessionSummaryDerivation | null {
-    if (events.length < 3) return null;
-    if (events.some((event) => event.eventType === 'session_summary')) return null;
-
-    const prompts = events.filter((event) => event.eventType === 'user_prompt');
-    const toolObservations = events.filter((event) => event.eventType === 'tool_observation');
-    const toolNames = Array.from(new Set(
-      toolObservations
-        .map((event) => this.asRecord(event.metadata).toolName)
-        .filter((toolName): toolName is string => typeof toolName === 'string' && toolName.length > 0)
-    ));
-    const errorObservations = toolObservations.filter((event) => this.isErrorObservation(event));
-
-    const datePart = events[0].timestamp.toISOString().split('T')[0];
-    const parts: string[] = [`[${datePart}] ${prompts.length}턴 세션`];
-
-    if (prompts.length > 0) {
-      parts.push(`주요 작업: ${this.firstPromptPreview(prompts[0].content)}`);
-    }
-    if (toolNames.length > 0) {
-      parts.push(`사용 툴: ${toolNames.slice(0, MAX_TOOL_NAMES).join(', ')}`);
-    }
-    if (errorObservations.length > 0) {
-      parts.push(`오류 ${errorObservations.length}건 발생`);
-    }
-
-    return {
-      text: parts.join('. '),
-      metadata: { generated: 'rule-based', eventCount: events.length }
-    };
-  }
-
-  private firstPromptPreview(content: string): string {
-    return content.slice(0, MAX_FIRST_PROMPT_LENGTH).replace(/\r?\n/g, ' ');
-  }
-
-  private isErrorObservation(event: MemoryEvent): boolean {
-    const metadata = this.asRecord(event.metadata);
-
-    if (metadata.exitCode !== undefined) {
-      return metadata.exitCode !== 0;
-    }
-
-    return metadata.success === false;
-  }
-
-  private asRecord(value: unknown): Record<string, unknown> {
-    return value && typeof value === 'object' && !Array.isArray(value)
-      ? value as Record<string, unknown>
-      : {};
-  }
-}
-
-export function createSummaryDeriver(): SummaryDeriver {
-  return new SummaryDeriver();
-}

package/src/core/edge-repo.ts

@@ -1,333 +0,0 @@
-/**
- * Edge Repository - CRUD operations for entity/entry relationships
- * AXIOMMIND Entity-Edge Model
- */
-
-import { dbRun, dbAll, toDate, type Database } from './db-wrapper.js';
-import { randomUUID } from 'crypto';
-import type { Edge, NodeType, RelationType } from './types.js';
-
-export interface CreateEdgeInput {
-  srcType: NodeType;
-  srcId: string;
-  relType: RelationType;
-  dstType: NodeType;
-  dstId: string;
-  metaJson?: Record<string, unknown>;
-}
-
-export class EdgeRepo {
-  constructor(private db: Database) {}
-
-  /**
-   * Create a new edge (idempotent - ignores duplicates)
-   */
-  async create(input: CreateEdgeInput): Promise<Edge> {
-    const edgeId = randomUUID();
-    const now = new Date();
-
-    await dbRun(
-      this.db,
-      `INSERT INTO edges (edge_id, src_type, src_id, rel_type, dst_type, dst_id, meta_json, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-       ON CONFLICT DO NOTHING`,
-      [
-        edgeId,
-        input.srcType,
-        input.srcId,
-        input.relType,
-        input.dstType,
-        input.dstId,
-        JSON.stringify(input.metaJson ?? {}),
-        now.toISOString()
-      ]
-    );
-
-    return {
-      edgeId,
-      srcType: input.srcType,
-      srcId: input.srcId,
-      relType: input.relType,
-      dstType: input.dstType,
-      dstId: input.dstId,
-      metaJson: input.metaJson,
-      createdAt: now
-    };
-  }
-
-  /**
-   * Create or update edge
-   */
-  async upsert(input: CreateEdgeInput): Promise<Edge> {
-    // Check for existing edge
-    const existing = await this.findByEndpoints(
-      input.srcType,
-      input.srcId,
-      input.relType,
-      input.dstType,
-      input.dstId
-    );
-
-    if (existing) {
-      // Update meta_json
-      await dbRun(
-        this.db,
-        `UPDATE edges SET meta_json = ? WHERE edge_id = ?`,
-        [JSON.stringify(input.metaJson ?? {}), existing.edgeId]
-      );
-      return { ...existing, metaJson: input.metaJson };
-    }
-
-    return this.create(input);
-  }
-
-  /**
-   * Find edge by endpoints
-   */
-  async findByEndpoints(
-    srcType: NodeType,
-    srcId: string,
-    relType: RelationType,
-    dstType: NodeType,
-    dstId: string
-  ): Promise<Edge | null> {
-    const rows = await dbAll<Record<string, unknown>>(
-      this.db,
-      `SELECT * FROM edges
-       WHERE src_type = ? AND src_id = ? AND rel_type = ?
-       AND dst_type = ? AND dst_id = ?`,
-      [srcType, srcId, relType, dstType, dstId]
-    );
-
-    if (rows.length === 0) return null;
-    return this.rowToEdge(rows[0]);
-  }
-
-  /**
-   * Find edges by source
-   */
-  async findBySrc(
-    srcId: string,
-    relType?: RelationType
-  ): Promise<Edge[]> {
-    let query = `SELECT * FROM edges WHERE src_id = ?`;
-    const params: unknown[] = [srcId];
-
-    if (relType) {
-      query += ` AND rel_type = ?`;
-      params.push(relType);
-    }
-
-    query += ` ORDER BY created_at DESC`;
-
-    const rows = await dbAll<Record<string, unknown>>(this.db, query, params);
-    return rows.map(row => this.rowToEdge(row));
-  }
-
-  /**
-   * Find edges by destination
-   */
-  async findByDst(
-    dstId: string,
-    relType?: RelationType
-  ): Promise<Edge[]> {
-    let query = `SELECT * FROM edges WHERE dst_id = ?`;
-    const params: unknown[] = [dstId];
-
-    if (relType) {
-      query += ` AND rel_type = ?`;
-      params.push(relType);
-    }
-
-    query += ` ORDER BY created_at DESC`;
-
-    const rows = await dbAll<Record<string, unknown>>(this.db, query, params);
-    return rows.map(row => this.rowToEdge(row));
-  }
-
-  /**
-   * Find all edges for a node (both directions)
-   */
-  async findByNode(nodeId: string): Promise<{ outgoing: Edge[]; incoming: Edge[] }> {
-    const outgoing = await this.findBySrc(nodeId);
-    const incoming = await this.findByDst(nodeId);
-    return { outgoing, incoming };
-  }
-
-  /**
-   * Delete edge by ID
-   */
-  async delete(edgeId: string): Promise<boolean> {
-    await dbRun(
-      this.db,
-      `DELETE FROM edges WHERE edge_id = ?`,
-      [edgeId]
-    );
-    return true; // DuckDB doesn't return affected rows easily
-  }
-
-  /**
-   * Delete edges by source and relation type
-   */
-  async deleteBySrcAndRel(srcId: string, relType: RelationType): Promise<number> {
-    await dbRun(
-      this.db,
-      `DELETE FROM edges WHERE src_id = ? AND rel_type = ?`,
-      [srcId, relType]
-    );
-    return 0; // DuckDB doesn't return affected rows easily
-  }
-
-  /**
-   * Delete edges by destination and relation type
-   */
-  async deleteByDstAndRel(dstId: string, relType: RelationType): Promise<number> {
-    await dbRun(
-      this.db,
-      `DELETE FROM edges WHERE dst_id = ? AND rel_type = ?`,
-      [dstId, relType]
-    );
-    return 0;
-  }
-
-  /**
-   * Replace edges for a source and relation type
-   * Used for mode=replace in task_blockers_set
-   */
-  async replaceEdges(
-    srcId: string,
-    relType: RelationType,
-    newEdges: Omit<CreateEdgeInput, 'srcId' | 'relType'>[]
-  ): Promise<Edge[]> {
-    // Delete existing edges
-    await this.deleteBySrcAndRel(srcId, relType);
-
-    // Create new edges
-    const created: Edge[] = [];
-    for (const edge of newEdges) {
-      const newEdge = await this.create({
-        srcType: edge.srcType,
-        srcId,
-        relType,
-        dstType: edge.dstType,
-        dstId: edge.dstId,
-        metaJson: edge.metaJson
-      });
-      created.push(newEdge);
-    }
-
-    return created;
-  }
-
-  /**
-   * Get effective blockers (resolving condition → task)
-   * Returns resolved blocker if condition has resolves_to edge
-   */
-  async getEffectiveBlockers(taskId: string): Promise<Array<{
-    originalId: string;
-    effectiveId: string;
-    isResolved: boolean;
-  }>> {
-    const blockerEdges = await this.findBySrc(taskId, 'blocked_by');
-    const results: Array<{
-      originalId: string;
-      effectiveId: string;
-      isResolved: boolean;
-    }> = [];
-
-    for (const edge of blockerEdges) {
-      // Check if blocker has resolves_to edge
-      const resolvesTo = await dbAll<Record<string, unknown>>(
-        this.db,
-        `SELECT dst_id FROM edges
-         WHERE src_id = ? AND rel_type = 'resolves_to'
-         LIMIT 1`,
-        [edge.dstId]
-      );
-
-      if (resolvesTo.length > 0) {
-        results.push({
-          originalId: edge.dstId,
-          effectiveId: resolvesTo[0].dst_id as string,
-          isResolved: true
-        });
-      } else {
-        results.push({
-          originalId: edge.dstId,
-          effectiveId: edge.dstId,
-          isResolved: false
-        });
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Find 2-hop related entries (Entry → Entity → Entry)
-   */
-  async findRelatedEntries(entryId: string): Promise<Array<{
-    entryId: string;
-    viaEntityId: string;
-    relationPath: string;
-  }>> {
-    const rows = await dbAll<Record<string, unknown>>(
-      this.db,
-      `WITH first_hop AS (
-         SELECT e1.dst_id AS entity_id
-         FROM edges e1
-         WHERE e1.src_type = 'entry'
-           AND e1.rel_type = 'evidence_of'
-           AND e1.src_id = ?
-       )
-       SELECT
-         e2.src_id AS entry_id,
-         f.entity_id AS via_entity_id,
-         'evidence_of→evidence_of' AS relation_path
-       FROM first_hop f
-       JOIN edges e2 ON e2.dst_id = f.entity_id
-                    AND e2.rel_type = 'evidence_of'
-                    AND e2.src_type = 'entry'
-       WHERE e2.src_id != ?`,
-      [entryId, entryId]
-    );
-
-    return rows.map(row => ({
-      entryId: row.entry_id as string,
-      viaEntityId: row.via_entity_id as string,
-      relationPath: row.relation_path as string
-    }));
-  }
-
-  /**
-   * Count edges by relation type
-   */
-  async countByRelType(): Promise<Array<{ relType: string; count: number }>> {
-    const rows = await dbAll<{ rel_type: string; count: number }>(
-      this.db,
-      `SELECT rel_type, COUNT(*) as count FROM edges GROUP BY rel_type`
-    );
-    return rows.map(row => ({
-      relType: row.rel_type,
-      count: Number(row.count)
-    }));
-  }
-
-  /**
-   * Convert database row to Edge
-   */
-  private rowToEdge(row: Record<string, unknown>): Edge {
-    return {
-      edgeId: row.edge_id as string,
-      srcType: row.src_type as NodeType,
-      srcId: row.src_id as string,
-      relType: row.rel_type as RelationType,
-      dstType: row.dst_type as NodeType,
-      dstId: row.dst_id as string,
-      metaJson: typeof row.meta_json === 'string'
-        ? JSON.parse(row.meta_json)
-        : row.meta_json as Record<string, unknown> | undefined,
-      createdAt: toDate(row.created_at)
-    };
-  }
-}

package/src/core/embedder.ts

@@ -1,4 +0,0 @@
-// Compatibility re-export. Embedding is an optional vector extension, but
-// existing core/engine imports still resolve through this path during the
-// strangler migration.
-export * from '../extensions/vector/index.js';