toolnet-memory 0.2.0 → 0.2.2

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

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

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

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

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

package/dist/src/memory/deduplicate.js

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

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

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

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

package/dist/src/memory/rules.js

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

package/dist/src/memory/search.js

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

package/dist/src/memory/summaries.js

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

package/dist/src/memory/todos.js

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

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

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

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

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

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

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

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

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

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