linksee-memory 0.0.1

package/dist/lib/heat-index.js

@@ -0,0 +1,29 @@
+// Ported from sales-intelligence-os/lib/heat-index.ts (human-facing names → agent-memory names).
+// Drives "importance hierarchy" (Michie's memory principle 3).
+export function computeHeat(input) {
+    const last30 = Math.min(input.accessesLast30d * 3, 30);
+    const last90 = Math.min(input.accessesLast90d * 1, 20);
+    let recencyBonus = 0;
+    if (input.daysSinceLastAccess <= 7)
+        recencyBonus = 20;
+    else if (input.daysSinceLastAccess <= 30)
+        recencyBonus = 10;
+    else if (input.daysSinceLastAccess <= 90)
+        recencyBonus = 0;
+    else
+        recencyBonus = -10;
+    const tenureBonus = Math.min(input.totalAccesses * 0.5, 15);
+    const importanceBoost = (input.baseImportance ?? 0.5) * 15; // 0-15 extra from user mark
+    const score = Math.max(0, Math.min(100, last30 + last90 + recencyBonus + tenureBonus + importanceBoost));
+    let band;
+    if (score >= 70)
+        band = 'hot';
+    else if (score >= 40)
+        band = 'warm';
+    else if (score >= 20)
+        band = 'cold';
+    else
+        band = 'frozen';
+    return { score, band };
+}
+//# sourceMappingURL=heat-index.js.map

package/dist/lib/momentum.d.ts

@@ -0,0 +1,19 @@
+import type Database from 'better-sqlite3';
+export interface MomentumInput {
+    eventsLast24h: number;
+    eventsLast7d: number;
+    eventsHistorical: number;
+    daysObserved: number;
+    avgImportanceRecent: number;
+}
+export interface MomentumResult {
+    score: number;
+    band: 'surging' | 'active' | 'quiet' | 'dormant';
+    breakdown: {
+        quality: number;
+        velocity: number;
+        relativeVolume: number;
+    };
+}
+export declare function computeMomentum(input: MomentumInput): MomentumResult;
+export declare function refreshMomentumForEntity(db: Database.Database, entityId: number): MomentumResult;

package/dist/lib/momentum.js

@@ -0,0 +1,75 @@
+// Ported from sales-intelligence-os/lib/momentum-calculator-v3.ts
+// Original: detects "this company has momentum" from news/signal bursts.
+// Agent-memory adaptation: detects "this entity is currently active in the agent's context."
+// Drives "context-dependent retrieval" (Michie's memory principle 5).
+export function computeMomentum(input) {
+    // --- velocity (30%): how fast is activity arriving ---
+    let velocity = 0;
+    if (input.eventsLast24h >= 3)
+        velocity = 10;
+    else if (input.eventsLast24h >= 1)
+        velocity = 7;
+    else if (input.eventsLast7d >= 3)
+        velocity = 4;
+    else if (input.eventsLast7d >= 1)
+        velocity = 2;
+    else
+        velocity = 0;
+    // --- relativeVolume (30%): recent vs historical baseline ---
+    const weeklyAvg = input.daysObserved > 0 ? (input.eventsHistorical / input.daysObserved) * 7 : 0;
+    let relativeVolume = 0;
+    if (weeklyAvg === 0 && input.eventsLast7d > 0)
+        relativeVolume = 5; // brand-new activity
+    else if (weeklyAvg > 0) {
+        const ratio = input.eventsLast7d / weeklyAvg;
+        if (ratio >= 3)
+            relativeVolume = 10;
+        else if (ratio >= 2)
+            relativeVolume = 7;
+        else if (ratio >= 1)
+            relativeVolume = 4;
+        else
+            relativeVolume = Math.max(0, ratio * 4);
+    }
+    // --- quality (40%): avg importance of what's arriving ---
+    const quality = Math.min(10, input.avgImportanceRecent * 10);
+    const weighted = quality * 0.4 + velocity * 0.3 + relativeVolume * 0.3;
+    const score = Math.max(0, Math.min(10, weighted));
+    let band;
+    if (score >= 7)
+        band = 'surging';
+    else if (score >= 4)
+        band = 'active';
+    else if (score >= 1.5)
+        band = 'quiet';
+    else
+        band = 'dormant';
+    return { score, band, breakdown: { quality, velocity, relativeVolume } };
+}
+// Compute and cache momentum for an entity using DB state.
+export function refreshMomentumForEntity(db, entityId) {
+    const now = Math.floor(Date.now() / 1000);
+    const dayAgo = now - 86400;
+    const weekAgo = now - 7 * 86400;
+    const stats = db
+        .prepare(`
+      SELECT
+        (SELECT COUNT(*) FROM events WHERE entity_id = ? AND occurred_at >= ?) as e24,
+        (SELECT COUNT(*) FROM events WHERE entity_id = ? AND occurred_at >= ?) as e7d,
+        (SELECT COUNT(*) FROM events WHERE entity_id = ?) as eAll,
+        (SELECT created_at FROM entities WHERE id = ?) as createdAt,
+        (SELECT COALESCE(AVG(importance), 0.5) FROM memories WHERE entity_id = ? AND created_at >= ?) as avgImpRecent
+      `)
+        .get(entityId, dayAgo, entityId, weekAgo, entityId, entityId, entityId, weekAgo);
+    const daysObserved = stats.createdAt ? Math.max(1, (now - stats.createdAt) / 86400) : 1;
+    const result = computeMomentum({
+        eventsLast24h: stats.e24,
+        eventsLast7d: stats.e7d,
+        eventsHistorical: stats.eAll,
+        daysObserved,
+        avgImportanceRecent: stats.avgImpRecent,
+    });
+    db.prepare('UPDATE entities SET momentum_score = ?, momentum_at = ? WHERE id = ?').run(result.score, now, entityId);
+    return result;
+}
+//# sourceMappingURL=momentum.js.map

package/dist/lib/session-extractor.d.ts

@@ -0,0 +1,34 @@
+import type { ParsedSession } from './session-parser.js';
+export interface ExtractedMemory {
+    layer: 'goal' | 'context' | 'emotion' | 'implementation' | 'caveat' | 'learning';
+    content: string;
+    importance: number;
+    source: {
+        session_id: string;
+        turn_uuid?: string;
+        kind: string;
+    };
+}
+export interface ExtractedFileEdit {
+    session_id: string;
+    file_path: string;
+    operation: 'read' | 'edit' | 'write' | 'bash' | 'other';
+    turn_uuid?: string;
+    occurred_at: number;
+    context_snippet: string;
+    memory_content?: string;
+}
+export interface ExtractionResult {
+    project_name: string;
+    project_cwd: string;
+    session_id: string;
+    memories: ExtractedMemory[];
+    file_edits: ExtractedFileEdit[];
+    stats: {
+        turns_total: number;
+        turns_meaningful_user: number;
+        file_ops_raw: number;
+        file_ops_unique_paths: number;
+    };
+}
+export declare function extractSession(session: ParsedSession, projectName: string): ExtractionResult;

package/dist/lib/session-extractor.js

@@ -0,0 +1,263 @@
+// Extract 6-layer memories + file_edit links from a parsed session.
+// Core mission: break the Mem0 "flat metatag" wall by attaching each memory
+// to its intent context. A memory like "edited server.ts" becomes
+// "edited server.ts BECAUSE the user wanted the FTS5 + LIKE merge fix".
+import { isMetaOrNoise, isAutomatedSession, isPastedExternalContent } from './session-parser.js';
+// ============================================================
+// Intent detection — first non-noise user message in the session.
+// ============================================================
+function findFirstIntent(session) {
+    for (const t of session.turns) {
+        if (t.role !== 'user')
+            continue;
+        if (t.tool_results && t.tool_results.length > 0)
+            continue; // tool result carriers, not intents
+        if (isMetaOrNoise(t.text))
+            continue;
+        if (t.text.trim().length < 20)
+            continue; // "ok" / "yes" / "next"
+        return t;
+    }
+    return null;
+}
+// ============================================================
+// Decisions & learnings — user messages containing explicit commitment words.
+// ============================================================
+const DECISION_PATTERNS = [
+    /決めた|採用|確定|これで(いい|進め)|OK進めて|やろう|行こう/,
+    /learn(ed)?|decide|chose|picked|going with/i,
+];
+const FAILURE_PATTERNS = [
+    /失敗|バグ|エラー|直して|修正|戻して/,
+    /error|bug|fail|broken|revert|rollback/i,
+];
+const CAVEAT_PATTERNS = [
+    /注意|気をつけ|避けて|やらない|禁止/,
+    /do not|never|avoid|watch out/i,
+];
+function matchesAny(text, patterns) {
+    return patterns.some((p) => p.test(text));
+}
+// Dedupe successive file edits to the same path within N seconds —
+// they're usually the same logical change.
+// NOTE: this only dedupes for memory CREATION (1 implementation memory per file
+// per logical edit cluster). The session_file_edits table preserves ALL physical
+// edits with their individual timestamps so cross-file/cross-session queries stay accurate.
+function dedupeEdits(edits) {
+    const WINDOW = 10; // sec — tighter so legitimate sequential edits are preserved
+    const seen = new Map(); // path → last timestamp kept
+    const out = [];
+    for (const e of edits) {
+        const key = `${e.operation}::${e.path}`;
+        const last = seen.get(key);
+        if (last && Math.abs(e.timestamp - last) < WINDOW)
+            continue;
+        seen.set(key, e.timestamp);
+        out.push(e);
+    }
+    return out;
+}
+export function extractSession(session, projectName) {
+    const memories = [];
+    const file_edits = [];
+    // Detect fully-automated sessions (e.g. scheduled cron tasks) — no user intent to extract
+    const firstRawUserText = session.turns.find((t) => t.role === 'user' && !t.tool_results)?.text ?? '';
+    const automated = isAutomatedSession(firstRawUserText);
+    // 1) Goal layer — the first REAL intent (or synthetic marker for automated sessions)
+    const firstIntent = findFirstIntent(session);
+    if (firstIntent) {
+        memories.push({
+            layer: 'goal',
+            content: JSON.stringify({
+                intent: firstIntent.text.slice(0, 1000),
+                when: new Date(firstIntent.timestamp * 1000).toISOString(),
+                session_id: session.session_id,
+                git_branch: session.git_branch,
+            }, null, 2),
+            importance: automated ? 0.3 : 0.8, // lower for automated runs
+            source: { session_id: session.session_id, turn_uuid: firstIntent.uuid, kind: 'first_intent' },
+        });
+    }
+    else if (automated) {
+        // Synthetic goal so the session is still discoverable
+        const match = firstRawUserText.match(/<scheduled-task\s+name="([^"]+)"/);
+        const taskName = match ? match[1] : 'unknown';
+        memories.push({
+            layer: 'goal',
+            content: JSON.stringify({
+                intent: `Automated scheduled task run: ${taskName}`,
+                automated: true,
+                when: new Date(session.started_at * 1000).toISOString(),
+                session_id: session.session_id,
+                git_branch: session.git_branch,
+            }, null, 2),
+            importance: 0.2,
+            source: { session_id: session.session_id, kind: 'automated_task' },
+        });
+    }
+    // 2) Context layer — subsequent clarifying user messages (up to 3 more)
+    let clarifyCount = 0;
+    for (const t of session.turns) {
+        if (clarifyCount >= 3)
+            break;
+        if (t === firstIntent)
+            continue;
+        if (t.role !== 'user')
+            continue;
+        if (t.tool_results && t.tool_results.length > 0)
+            continue;
+        if (isMetaOrNoise(t.text))
+            continue;
+        if (t.text.trim().length < 40)
+            continue;
+        clarifyCount++;
+        memories.push({
+            layer: 'context',
+            content: JSON.stringify({
+                message: t.text.slice(0, 600),
+                when: new Date(t.timestamp * 1000).toISOString(),
+                session_id: session.session_id,
+            }),
+            importance: 0.5,
+            source: { session_id: session.session_id, turn_uuid: t.uuid, kind: 'clarification' },
+        });
+    }
+    // 3) Implementation layer + file_edits — one memory per unique file touched
+    const uniqueOps = dedupeEdits(session.file_ops).filter((e) => e.operation === 'edit' || e.operation === 'write');
+    const byPath = new Map();
+    for (const e of uniqueOps) {
+        const arr = byPath.get(e.path) ?? [];
+        arr.push(e);
+        byPath.set(e.path, arr);
+    }
+    for (const [path, ops] of byPath) {
+        const first = ops[0];
+        const opsKinds = Array.from(new Set(ops.map((o) => o.operation))).join('+');
+        const why = (first.preceding_user_text || '(no explicit preceding intent)').slice(0, 400);
+        const contentSnippet = ops.map((o) => o.tool_input_preview).slice(0, 2).join(' | ').slice(0, 500);
+        const memoryContent = JSON.stringify({
+            file: path,
+            ops: opsKinds,
+            op_count: ops.length,
+            why_extracted: why,
+            sample_change: contentSnippet,
+            when: new Date(first.timestamp * 1000).toISOString(),
+            session_id: session.session_id,
+        }, null, 2);
+        memories.push({
+            layer: 'implementation',
+            content: memoryContent,
+            importance: 0.6,
+            source: { session_id: session.session_id, turn_uuid: first.turn_uuid, kind: 'file_edit' },
+        });
+        // Create a file_edit link record for EACH physical op (NOT deduped),
+        // all pointing at this memory's content. This preserves the TRUE timeline
+        // of edits (session_file_edits) while keeping memories at a useful granularity.
+        const allOpsForPath = session.file_ops.filter((o) => o.path === path && (o.operation === 'edit' || o.operation === 'write'));
+        for (const op of allOpsForPath) {
+            file_edits.push({
+                session_id: session.session_id,
+                file_path: op.path,
+                operation: op.operation,
+                turn_uuid: op.turn_uuid,
+                occurred_at: op.timestamp,
+                context_snippet: (op.preceding_user_text || '').slice(0, 300),
+                memory_content: memoryContent, // linker will resolve to memory_id after insert
+            });
+        }
+    }
+    // 4) Caveat layer — user messages matching caveat/failure patterns
+    //    Stricter filter: must NOT be pasted external content.
+    for (const t of session.turns) {
+        if (t.role !== 'user' || isMetaOrNoise(t.text))
+            continue;
+        if (t.tool_results && t.tool_results.length > 0)
+            continue;
+        if (isPastedExternalContent(t.text))
+            continue;
+        if (matchesAny(t.text, CAVEAT_PATTERNS) && t.text.length > 20) {
+            memories.push({
+                layer: 'caveat',
+                content: JSON.stringify({
+                    rule_or_warning: t.text.slice(0, 500),
+                    when: new Date(t.timestamp * 1000).toISOString(),
+                    session_id: session.session_id,
+                }),
+                importance: 0.75,
+                source: { session_id: session.session_id, turn_uuid: t.uuid, kind: 'caveat' },
+            });
+        }
+    }
+    // 5) Learning layer — messages matching decision patterns
+    //    Same strict filter applies.
+    for (const t of session.turns) {
+        if (t.role !== 'user' || isMetaOrNoise(t.text))
+            continue;
+        if (t.tool_results && t.tool_results.length > 0)
+            continue;
+        if (isPastedExternalContent(t.text))
+            continue;
+        if (matchesAny(t.text, DECISION_PATTERNS) && t.text.length > 15) {
+            memories.push({
+                layer: 'learning',
+                content: JSON.stringify({
+                    decision: t.text.slice(0, 500),
+                    when: new Date(t.timestamp * 1000).toISOString(),
+                    session_id: session.session_id,
+                }),
+                importance: 0.7,
+                source: { session_id: session.session_id, turn_uuid: t.uuid, kind: 'decision' },
+            });
+        }
+    }
+    // 6) Error-recovery patterns — only if NOT already covered by an extracted caveat,
+    //    and skip the boilerplate wording. Now writes to 'context' layer (not caveat)
+    //    so caveat stays reserved for genuine user-stated rules.
+    if (session.errors_count > 3) {
+        memories.push({
+            layer: 'context',
+            content: JSON.stringify({
+                why_now: `This session had ${session.errors_count} tool errors across ${session.turns.length} turns.`,
+                triggering_event: 'high_error_rate',
+                when: new Date(session.started_at * 1000).toISOString(),
+                session_id: session.session_id,
+            }),
+            importance: 0.4,
+            source: { session_id: session.session_id, kind: 'error_recovery' },
+        });
+    }
+    // 7) Session summary — one meta-implementation memory per session for overview
+    if (memories.length > 0) {
+        memories.push({
+            layer: 'implementation',
+            content: JSON.stringify({
+                summary_kind: 'session_overview',
+                session_id: session.session_id,
+                started_at: new Date(session.started_at * 1000).toISOString(),
+                ended_at: new Date(session.ended_at * 1000).toISOString(),
+                duration_min: Math.round((session.ended_at - session.started_at) / 60),
+                turns_user: session.turn_count_user,
+                turns_assistant: session.turn_count_assistant,
+                files_touched: byPath.size,
+                errors: session.errors_count,
+                git_branch: session.git_branch,
+            }, null, 2),
+            importance: 0.4,
+            source: { session_id: session.session_id, kind: 'session_summary' },
+        });
+    }
+    return {
+        project_name: projectName,
+        project_cwd: session.project_cwd,
+        session_id: session.session_id,
+        memories,
+        file_edits,
+        stats: {
+            turns_total: session.turns.length,
+            turns_meaningful_user: session.turns.filter((t) => t.role === 'user' && !isMetaOrNoise(t.text)).length,
+            file_ops_raw: session.file_ops.length,
+            file_ops_unique_paths: byPath.size,
+        },
+    };
+}
+//# sourceMappingURL=session-extractor.js.map

package/dist/lib/session-parser.d.ts

@@ -0,0 +1,40 @@
+export interface SessionTurn {
+    uuid: string;
+    role: 'user' | 'assistant';
+    timestamp: number;
+    text: string;
+    tool_calls?: Array<{
+        name: string;
+        input: any;
+        tool_use_id: string;
+    }>;
+    tool_results?: Array<{
+        tool_use_id: string;
+        is_error: boolean;
+        output_preview: string;
+    }>;
+}
+export interface ParsedSession {
+    session_id: string;
+    project_cwd: string;
+    started_at: number;
+    ended_at: number;
+    git_branch?: string;
+    turns: SessionTurn[];
+    file_ops: Array<{
+        operation: 'read' | 'edit' | 'write' | 'bash' | 'other';
+        path: string;
+        turn_uuid: string;
+        timestamp: number;
+        preceding_user_text: string;
+        tool_input_preview: string;
+    }>;
+    turn_count_user: number;
+    turn_count_assistant: number;
+    errors_count: number;
+}
+export declare function isMetaOrNoise(text: string): boolean;
+export declare function isPastedExternalContent(text: string): boolean;
+export declare function isAutomatedSession(firstUserText: string): boolean;
+export declare function parseSessionFile(jsonlPath: string): ParsedSession | null;
+export declare function projectNameFromCwd(cwd: string): string;