toolnet-memory 0.2.0

package/dist/src/memory/conflict-detector.js

@@ -0,0 +1,105 @@
+const GENERIC_TAGS = new Set([
+    "decision",
+    "rule",
+    "todo",
+    "summary",
+    "activity",
+    "user",
+    "error",
+    "file",
+    "write",
+    "command",
+    "learned",
+    "session",
+    "architecture",
+    "fix",
+    "context",
+    "opencode",
+    "agy",
+    "codex",
+]);
+const STOPWORDS = new Set([
+    "dùng",
+    "sử",
+    "dụng",
+    "use",
+    "using",
+    "the",
+    "a",
+    "an",
+    "cho",
+    "và",
+    "là",
+    "của",
+    "to",
+    "for",
+    "with",
+    "quyết",
+    "định",
+]);
+function words(text) {
+    return new Set(text
+        .toLowerCase()
+        .normalize("NFKC")
+        .replace(/[^\p{L}\p{N}_-]+/gu, " ")
+        .split(/\s+/)
+        .filter((word) => word.length > 2 &&
+        !STOPWORDS.has(word)));
+}
+function similarity(a, b) {
+    const aa = words(a);
+    const bb = words(b);
+    if (aa.size === 0 ||
+        bb.size === 0) {
+        return 0;
+    }
+    let intersection = 0;
+    for (const word of aa) {
+        if (bb.has(word)) {
+            intersection++;
+        }
+    }
+    const union = new Set([
+        ...aa,
+        ...bb,
+    ]).size;
+    return intersection / union;
+}
+function meaningfulTags(memory) {
+    return new Set(memory.tags.filter((tag) => !GENERIC_TAGS.has(tag.toLowerCase())));
+}
+export class ConflictDetector {
+    findSuperseded(next, existing) {
+        if (next.type !== "rule" &&
+            next.type !== "decision") {
+            return [];
+        }
+        const nextTopic = typeof next.metadata?.topic === "string"
+            ? next.metadata.topic
+            : undefined;
+        const nextTags = meaningfulTags(next);
+        return existing.filter((old) => {
+            if (old.id === next.id ||
+                old.projectId !== next.projectId ||
+                old.type !== next.type ||
+                old.metadata?.supersededBy) {
+                return false;
+            }
+            const oldTopic = typeof old.metadata?.topic === "string"
+                ? old.metadata.topic
+                : undefined;
+            if (nextTopic &&
+                oldTopic &&
+                nextTopic === oldTopic) {
+                return true;
+            }
+            const oldTags = meaningfulTags(old);
+            for (const tag of nextTags) {
+                if (oldTags.has(tag)) {
+                    return true;
+                }
+            }
+            return (similarity(next.content, old.content) >= 0.6);
+        });
+    }
+}

package/dist/src/memory/consolidator.js

@@ -0,0 +1,104 @@
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+export class MemoryConsolidator {
+    memory;
+    constructor(memory) {
+        this.memory = memory;
+    }
+    consolidate(projectId, options = {}) {
+        const minItems = options.minItems ?? 4;
+        const maxItems = options.maxItems ?? 50;
+        const retentionDays = options.retentionDays ?? 90;
+        const activities = this.memory
+            .byType(projectId, "activity")
+            .slice(0, maxItems);
+        if (activities.length <
+            minItems) {
+            return {
+                scanned: activities.length,
+                consolidated: 0,
+                summaryCreated: false,
+            };
+        }
+        const content = this.buildSummary(activities);
+        const now = new Date();
+        const expiresAt = new Date(now.getTime() +
+            retentionDays *
+                86_400_000).toISOString();
+        const summary = this.memory.remember({
+            projectId,
+            type: "summary",
+            content,
+            importance: "normal",
+            tags: [
+                "consolidated",
+                "activity-summary",
+            ],
+            source: "auto-consolidation",
+            expiresAt,
+            metadata: {
+                consolidatedFrom: activities.map((item) => item.id),
+                itemCount: activities.length,
+            },
+        });
+        const supersededAt = now.toISOString();
+        for (const activity of activities) {
+            const source = this.memory.get(activity.id);
+            if (!source) {
+                continue;
+            }
+            source.updatedAt =
+                supersededAt;
+            source.metadata = {
+                ...(source.metadata ?? {}),
+                consolidated: true,
+                supersededBy: summary.id,
+                supersededAt,
+            };
+        }
+        return {
+            scanned: activities.length,
+            consolidated: activities.length,
+            summaryCreated: true,
+            summaryId: summary.id,
+        };
+    }
+    buildSummary(activities) {
+        const files = unique(activities
+            .filter((item) => item.content.startsWith("Modified file:"))
+            .map((item) => item.content
+            .replace("Modified file:", "")
+            .trim()));
+        const commands = unique(activities
+            .filter((item) => item.content.startsWith("Command:"))
+            .map((item) => item.content
+            .replace("Command:", "")
+            .trim()));
+        const errors = unique(activities
+            .filter((item) => item.content.startsWith("Error:"))
+            .map((item) => item.content
+            .replace("Error:", "")
+            .trim()));
+        const lines = [
+            "Activity consolidation:",
+            `- Activities: ${activities.length}`,
+        ];
+        if (files.length) {
+            lines.push(`- Files changed: ${files
+                .slice(0, 15)
+                .join(", ")}`);
+        }
+        if (commands.length) {
+            lines.push(`- Commands: ${commands
+                .slice(0, 10)
+                .join("; ")}`);
+        }
+        if (errors.length) {
+            lines.push(`- Errors: ${errors
+                .slice(0, 10)
+                .join("; ")}`);
+        }
+        return lines.join("\n");
+    }
+}

package/dist/src/memory/decay.js

@@ -0,0 +1,59 @@
+const BASE_SCORE = {
+    critical: 100,
+    high: 75,
+    normal: 50,
+    temporary: 20,
+};
+const HALF_LIFE_DAYS = {
+    activity: 14,
+    summary: 30,
+    todo: 90,
+    decision: 365,
+    rule: 730,
+    code: 180,
+};
+export function defaultExpiry(type, importance, now = new Date()) {
+    let days;
+    if (importance === "temporary") {
+        days = 30;
+    }
+    if (type === "activity") {
+        days = Math.min(days ?? 14, 14);
+    }
+    if (type === "summary") {
+        days = Math.min(days ?? 30, 30);
+    }
+    if (!days) {
+        return undefined;
+    }
+    return new Date(now.getTime() +
+        days * 86_400_000).toISOString();
+}
+export function isExpired(memory, now = Date.now()) {
+    if (!memory.expiresAt) {
+        return false;
+    }
+    return (new Date(memory.expiresAt).getTime() <= now);
+}
+export function isSuperseded(memory) {
+    return Boolean(memory.metadata?.supersededBy);
+}
+export function isMemoryActive(memory, now = Date.now()) {
+    return (!isExpired(memory, now) &&
+        !isSuperseded(memory));
+}
+export function effectiveImportanceScore(memory, now = Date.now()) {
+    if (!isMemoryActive(memory, now)) {
+        return 0;
+    }
+    const base = BASE_SCORE[memory.importance];
+    if (memory.importance === "critical") {
+        return base;
+    }
+    const halfLife = HALF_LIFE_DAYS[memory.type] ?? 180;
+    const ageMs = Math.max(0, now -
+        new Date(memory.updatedAt).getTime());
+    const ageDays = ageMs / 86_400_000;
+    const decay = Math.pow(0.5, ageDays / halfLife);
+    return base * decay;
+}

package/dist/src/memory/decisions.js

@@ -0,0 +1,3 @@
+export function getDecisions(engine, projectId) {
+    return engine.byType(projectId, "decision");
+}

package/dist/src/memory/deduplicate.js

@@ -0,0 +1,25 @@
+import { createHash, } from "node:crypto";
+export function memoryFingerprint(memory) {
+    return createHash("sha256")
+        .update([
+        memory.projectId,
+        memory.type,
+        memory.content
+            .trim()
+            .toLowerCase(),
+    ].join("|"))
+        .digest("hex");
+}
+export function deduplicateMemories(memories) {
+    const seen = new Set();
+    const result = [];
+    for (const memory of memories) {
+        const hash = memoryFingerprint(memory);
+        if (seen.has(hash)) {
+            continue;
+        }
+        seen.add(hash);
+        result.push(memory);
+    }
+    return result;
+}

package/dist/src/memory/index.js

@@ -0,0 +1,11 @@
+export * from "./remember.js";
+export * from "./search.js";
+export * from "./rules.js";
+export * from "./decisions.js";
+export * from "./todos.js";
+export * from "./activity.js";
+export * from "./deduplicate.js";
+export * from "./decay.js";
+export * from "./conflict-detector.js";
+export * from "./maintenance.js";
+export * from "./consolidator.js";

package/dist/src/memory/maintenance.js

@@ -0,0 +1,16 @@
+export class MemoryMaintenance {
+    memory;
+    constructor(memory) {
+        this.memory = memory;
+    }
+    run(projectId) {
+        const expiredRemoved = this.memory.pruneExpired(projectId);
+        const supersededRemoved = this.memory.pruneSuperseded(projectId, 30);
+        return {
+            expiredRemoved,
+            supersededRemoved,
+            active: this.memory.list(projectId).length,
+            total: this.memory.listAll(projectId).length,
+        };
+    }
+}

package/dist/src/memory/remember.js

@@ -0,0 +1,3 @@
+export function rememberMemory(engine, input) {
+    return engine.remember(input);
+}

package/dist/src/memory/rules.js

@@ -0,0 +1,3 @@
+export function getRules(engine, projectId) {
+    return engine.byType(projectId, "rule");
+}

package/dist/src/memory/search.js

@@ -0,0 +1,3 @@
+export function searchMemory(engine, query) {
+    return engine.search(query);
+}

package/dist/src/memory/summaries.js

@@ -0,0 +1 @@
+export {};

package/dist/src/memory/todos.js

@@ -0,0 +1,3 @@
+export function getTodos(engine, projectId) {
+    return engine.byType(projectId, "todo");
+}

package/dist/src/processor/decision-extractor.js

@@ -0,0 +1,13 @@
+export function looksLikeDecision(text) {
+    const value = text.toLowerCase();
+    return [
+        "quyết định",
+        "chọn ",
+        "sử dụng ",
+        "dùng ",
+        "decided",
+        "decision",
+        "we will use",
+        "use ",
+    ].some((pattern) => value.includes(pattern));
+}

package/dist/src/processor/importance-scorer.js

@@ -0,0 +1,22 @@
+export function scoreImportance(type, content) {
+    const text = content.toLowerCase();
+    if (text.includes("không được") ||
+        text.includes("tuyệt đối") ||
+        text.includes("must not") ||
+        text.includes("never ")) {
+        return "critical";
+    }
+    if (type === "rule" ||
+        type === "decision") {
+        return "high";
+    }
+    if (type === "todo") {
+        return "normal";
+    }
+    if (text.includes("error") ||
+        text.includes("failed") ||
+        text.includes("exception")) {
+        return "normal";
+    }
+    return "temporary";
+}

package/dist/src/processor/index.js

@@ -0,0 +1,7 @@
+export * from "./memory-processor.js";
+export * from "./memory-extractor.js";
+export * from "./summarizer.js";
+export * from "./decision-extractor.js";
+export * from "./rule-extractor.js";
+export * from "./todo-extractor.js";
+export * from "./importance-scorer.js";

package/dist/src/processor/memory-extractor.js

@@ -0,0 +1,59 @@
+export class MemoryExtractor {
+    extract(event) {
+        switch (event.type) {
+            case "decision":
+                return {
+                    type: "decision",
+                    content: String(event.data.content ??
+                        "Decision recorded"),
+                    tags: ["decision"],
+                    source: "auto-extractor",
+                    metadata: event.data,
+                };
+            case "todo":
+                return {
+                    type: "todo",
+                    content: String(event.data.content ??
+                        "TODO recorded"),
+                    tags: ["todo"],
+                    source: "auto-extractor",
+                    metadata: event.data,
+                };
+            case "error":
+                return {
+                    type: "activity",
+                    content: `Error: ${String(event.data.message ?? "")}`,
+                    tags: ["error"],
+                    source: "auto-extractor",
+                    metadata: event.data,
+                };
+            case "file_write":
+                return {
+                    type: "activity",
+                    content: `Modified file: ${String(event.data.filePath ?? "")}`,
+                    tags: ["file", "write"],
+                    source: "auto-extractor",
+                    metadata: event.data,
+                };
+            case "command":
+                return {
+                    type: "activity",
+                    content: `Command: ${String(event.data.command ?? "")}`,
+                    tags: ["command"],
+                    source: "auto-extractor",
+                    metadata: event.data,
+                };
+            case "session_start":
+            case "session_end":
+            case "file_read":
+            case "tool_call":
+            case "user_prompt":
+            case "test":
+            case "commit":
+            case "deploy":
+                return null;
+            default:
+                return null;
+        }
+    }
+}

package/dist/src/processor/memory-processor.js

@@ -0,0 +1,105 @@
+import { MemoryExtractor, } from "./memory-extractor.js";
+import { looksLikeRule, } from "./rule-extractor.js";
+import { looksLikeDecision, } from "./decision-extractor.js";
+import { looksLikeTodo, } from "./todo-extractor.js";
+import { scoreImportance, } from "./importance-scorer.js";
+import { Summarizer, } from "./summarizer.js";
+export class MemoryProcessor {
+    memory;
+    extractor = new MemoryExtractor();
+    summarizer = new Summarizer();
+    constructor(memory) {
+        this.memory = memory;
+    }
+    process(events) {
+        let created = 0;
+        for (const event of events) {
+            const extracted = this.extractor.extract(event);
+            if (extracted) {
+                const type = this.refineType(extracted.type, extracted.content);
+                this.memory.remember({
+                    projectId: event.projectId,
+                    type,
+                    content: extracted.content,
+                    importance: scoreImportance(type, extracted.content),
+                    tags: extracted.tags,
+                    source: extracted.source,
+                    metadata: {
+                        eventId: event.id,
+                        timestamp: event.timestamp,
+                        ...extracted.metadata,
+                    },
+                });
+                created++;
+            }
+            if (event.type ===
+                "user_prompt") {
+                const content = String(event.data.content ??
+                    "");
+                const type = this.detectPromptMemoryType(content);
+                if (type) {
+                    this.memory.remember({
+                        projectId: event.projectId,
+                        type,
+                        content,
+                        importance: scoreImportance(type, content),
+                        tags: [
+                            "user",
+                            type,
+                        ],
+                        source: "auto-prompt-extractor",
+                        metadata: {
+                            eventId: event.id,
+                            timestamp: event.timestamp,
+                        },
+                    });
+                    created++;
+                }
+            }
+        }
+        const summary = this.summarizer
+            .summarize(events);
+        if (summary) {
+            const projectId = events[0]?.projectId;
+            if (projectId) {
+                this.memory.remember({
+                    projectId,
+                    type: "summary",
+                    content: summary,
+                    importance: "temporary",
+                    tags: ["summary"],
+                    source: "auto-summary",
+                    metadata: {
+                        eventCount: events.length,
+                    },
+                });
+                created++;
+            }
+        }
+        return created;
+    }
+    refineType(initial, content) {
+        if (looksLikeRule(content)) {
+            return "rule";
+        }
+        if (looksLikeTodo(content)) {
+            return "todo";
+        }
+        if (looksLikeDecision(content)) {
+            return "decision";
+        }
+        return initial;
+    }
+    detectPromptMemoryType(content) {
+        if (looksLikeRule(content)) {
+            return "rule";
+        }
+        if (looksLikeTodo(content)) {
+            return "todo";
+        }
+        if (looksLikeDecision(content)) {
+            return "decision";
+        }
+        return null;
+    }
+}

package/dist/src/processor/rule-extractor.js

@@ -0,0 +1,13 @@
+export function looksLikeRule(text) {
+    const value = text.toLowerCase();
+    return [
+        "không được",
+        "bắt buộc",
+        "phải luôn",
+        "tuyệt đối",
+        "never ",
+        "must ",
+        "always ",
+        "do not ",
+    ].some((pattern) => value.includes(pattern));
+}

package/dist/src/processor/summarizer.js

@@ -0,0 +1,71 @@
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function truncate(text, max = 120) {
+    return text.length > max
+        ? `${text.slice(0, max)}…`
+        : text;
+}
+export class Summarizer {
+    summarize(events) {
+        if (events.length === 0) {
+            return null;
+        }
+        const files = unique(events
+            .filter((event) => event.type ===
+            "file_write")
+            .map((event) => String(event.data.filePath ?? "")));
+        const commands = unique(events
+            .filter((event) => event.type ===
+            "command")
+            .map((event) => truncate(String(event.data.command ?? ""))));
+        const errors = unique(events
+            .filter((event) => event.type ===
+            "error")
+            .map((event) => truncate(String(event.data.message ?? ""))));
+        const decisions = unique(events
+            .filter((event) => event.type ===
+            "decision")
+            .map((event) => truncate(String(event.data.content ?? ""))));
+        const todos = unique(events
+            .filter((event) => event.type ===
+            "todo")
+            .map((event) => truncate(String(event.data.content ?? ""))));
+        if (files.length === 0 &&
+            commands.length === 0 &&
+            errors.length === 0 &&
+            decisions.length === 0 &&
+            todos.length === 0) {
+            return null;
+        }
+        const lines = [
+            "Session summary:",
+        ];
+        if (files.length) {
+            lines.push(`- Files changed (${files.length}): ${files
+                .slice(0, 10)
+                .join(", ")}`);
+        }
+        if (commands.length) {
+            lines.push(`- Commands (${commands.length}): ${commands
+                .slice(0, 5)
+                .join("; ")}`);
+        }
+        if (errors.length) {
+            lines.push(`- Errors (${errors.length}): ${errors
+                .slice(0, 5)
+                .join("; ")}`);
+        }
+        if (decisions.length) {
+            lines.push(`- Decisions: ${decisions
+                .slice(0, 5)
+                .join("; ")}`);
+        }
+        if (todos.length) {
+            lines.push(`- TODO: ${todos
+                .slice(0, 5)
+                .join("; ")}`);
+        }
+        return lines.join("\n");
+    }
+}

package/dist/src/processor/todo-extractor.js

@@ -0,0 +1,12 @@
+export function looksLikeTodo(text) {
+    const value = text.toLowerCase();
+    return [
+        "todo",
+        "cần làm",
+        "chưa xong",
+        "còn phải",
+        "next:",
+        "next step",
+        "pending",
+    ].some((pattern) => value.includes(pattern));
+}