toolnet-memory 0.2.1 → 0.2.2

package/dist/src/core/global-env.js

@@ -1,70 +0,0 @@
-import { existsSync, readFileSync, } from "node:fs";
-import { homedir, } from "node:os";
-import { join, } from "node:path";
-function decodeValue(input) {
-    let value = input.trim();
-    if (value.length >= 2 &&
-        value.startsWith('"') &&
-        value.endsWith('"')) {
-        value =
-            value.slice(1, -1);
-        return value
-            .replace(/\\n/g, "\n")
-            .replace(/\\r/g, "\r")
-            .replace(/\\t/g, "\t")
-            .replace(/\\"/g, '"')
-            .replace(/\\\\/g, "\\");
-    }
-    if (value.length >= 2 &&
-        value.startsWith("'") &&
-        value.endsWith("'")) {
-        return value.slice(1, -1);
-    }
-    return value;
-}
-export function loadGlobalToolNetEnv() {
-    const filePath = process.env
-        .TOOLNET_GLOBAL_ENV ??
-        join(homedir(), ".config", "toolnet-memory", ".env");
-    if (!existsSync(filePath)) {
-        return;
-    }
-    const content = readFileSync(filePath, "utf8");
-    for (const rawLine of content.split(/\r?\n/)) {
-        let line = rawLine.trim();
-        if (!line ||
-            line.startsWith("#")) {
-            continue;
-        }
-        if (line.startsWith("export ")) {
-            line =
-                line.slice("export ".length);
-        }
-        const index = line.indexOf("=");
-        if (index <= 0) {
-            continue;
-        }
-        const key = line
-            .slice(0, index)
-            .trim();
-        if (!/^[A-Za-z_][A-Za-z0-9_]*$/
-            .test(key)) {
-            continue;
-        }
-        /*
-         * Shell ENV / project-specific config wins.
-         *
-         * Global config only fills missing values.
-         */
-        if (process.env[key] !==
-            undefined) {
-            continue;
-        }
-        process.env[key] =
-            decodeValue(line.slice(index + 1));
-    }
-}
-/*
- * Load immediately when imported by config.ts.
- */
-loadGlobalToolNetEnv();

package/dist/src/core/importance.js

@@ -1,30 +0,0 @@
-const BASE_SCORES = {
-    critical: 100,
-    high: 75,
-    normal: 50,
-    temporary: 20,
-};
-export function getImportanceScore(level) {
-    return BASE_SCORES[level];
-}
-export function inferImportance(type, content) {
-    const text = content.toLowerCase();
-    if (text.includes("không được") ||
-        text.includes("bắt buộc") ||
-        text.includes("must not") ||
-        text.includes("critical")) {
-        return "critical";
-    }
-    if (type === "rule" ||
-        type === "decision") {
-        return "high";
-    }
-    if (type === "todo") {
-        return "normal";
-    }
-    if (type === "activity" ||
-        type === "summary") {
-        return "temporary";
-    }
-    return "normal";
-}

package/dist/src/core/index.js

@@ -1,5 +0,0 @@
-export * from "./types.js";
-export * from "./config.js";
-export * from "./importance.js";
-export * from "./project-manager.js";
-export * from "./memory-engine.js";

package/dist/src/core/memory-engine.js

@@ -1,183 +0,0 @@
-import { randomUUID, } from "node:crypto";
-import { getImportanceScore, inferImportance, } from "./importance.js";
-import { Sanitizer, } from "../security/sanitizer.js";
-import { ConflictDetector, } from "../memory/conflict-detector.js";
-import { defaultExpiry, effectiveImportanceScore, isExpired, isMemoryActive, } from "../memory/decay.js";
-export class MemoryEngine {
-    memories = new Map();
-    sanitizer = new Sanitizer();
-    conflicts = new ConflictDetector();
-    remember(input) {
-        const now = new Date().toISOString();
-        const content = this.sanitizer
-            .sanitize(input.content.trim()).text;
-        const importance = input.importance ??
-            inferImportance(input.type, content);
-        const memory = {
-            id: randomUUID(),
-            projectId: input.projectId,
-            type: input.type,
-            content,
-            importance,
-            importanceScore: getImportanceScore(importance),
-            tags: input.tags ?? [],
-            source: input.source ?? "agent",
-            createdAt: now,
-            updatedAt: now,
-            expiresAt: input.expiresAt ??
-                defaultExpiry(input.type, importance, new Date(now)),
-            metadata: this.sanitizer
-                .sanitizeValue(input.metadata),
-        };
-        const superseded = this.conflicts.findSuperseded(memory, this.list(input.projectId));
-        if (superseded.length) {
-            memory.metadata = {
-                ...(memory.metadata ?? {}),
-                supersedes: superseded.map((item) => item.id),
-            };
-            for (const old of superseded) {
-                old.updatedAt = now;
-                old.metadata = {
-                    ...(old.metadata ?? {}),
-                    supersededBy: memory.id,
-                    supersededAt: now,
-                };
-                this.memories.set(old.id, old);
-            }
-        }
-        this.memories.set(memory.id, memory);
-        return memory;
-    }
-    importRecords(records) {
-        let imported = 0;
-        for (const memory of records) {
-            if (!memory?.id) {
-                continue;
-            }
-            this.memories.set(memory.id, memory);
-            imported++;
-        }
-        return imported;
-    }
-    exportProject(projectId) {
-        return this.listAll(projectId);
-    }
-    get(id) {
-        return this.memories.get(id);
-    }
-    delete(id) {
-        return this.memories.delete(id);
-    }
-    listAll(projectId) {
-        return [...this.memories.values()]
-            .filter((memory) => memory.projectId ===
-            projectId)
-            .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-    }
-    list(projectId) {
-        return this.listAll(projectId).filter((memory) => isMemoryActive(memory));
-    }
-    recent(projectId, limit = 10) {
-        return this.list(projectId)
-            .slice(0, limit);
-    }
-    byType(projectId, type) {
-        return this.list(projectId)
-            .filter((memory) => memory.type === type);
-    }
-    search(query) {
-        const q = query.query
-            .trim()
-            .toLowerCase();
-        const limit = query.limit ?? 10;
-        const tokens = q.split(/\s+/)
-            .filter(Boolean);
-        return this.list(query.projectId)
-            .filter((memory) => {
-            if (query.types &&
-                !query.types.includes(memory.type)) {
-                return false;
-            }
-            const effective = effectiveImportanceScore(memory);
-            if (query.minImportanceScore &&
-                effective <
-                    query.minImportanceScore) {
-                return false;
-            }
-            if (query.tags?.length) {
-                const hasTag = query.tags.some((tag) => memory.tags.includes(tag));
-                if (!hasTag) {
-                    return false;
-                }
-            }
-            return true;
-        })
-            .map((memory) => {
-            const content = memory.content
-                .toLowerCase();
-            const matches = tokens.filter((token) => content.includes(token)).length;
-            const textScore = tokens.length === 0
-                ? 0
-                : matches /
-                    tokens.length;
-            const importanceBoost = effectiveImportanceScore(memory) / 500;
-            return {
-                memory,
-                score: textScore +
-                    importanceBoost,
-                source: "memory",
-            };
-        })
-            .filter((result) => q.length === 0 ||
-            result.score > 0)
-            .sort((a, b) => b.score - a.score)
-            .slice(0, limit);
-    }
-    pruneExpired(projectId, now = Date.now()) {
-        let removed = 0;
-        for (const [id, memory] of this.memories) {
-            if (memory.projectId ===
-                projectId &&
-                isExpired(memory, now)) {
-                this.memories.delete(id);
-                removed++;
-            }
-        }
-        return removed;
-    }
-    pruneSuperseded(projectId, retentionDays = 30, now = Date.now()) {
-        let removed = 0;
-        const retentionMs = retentionDays *
-            86_400_000;
-        for (const [id, memory] of this.memories) {
-            if (memory.projectId !==
-                projectId) {
-                continue;
-            }
-            const supersededAt = memory.metadata
-                ?.supersededAt;
-            if (typeof supersededAt !==
-                "string") {
-                continue;
-            }
-            const age = now -
-                new Date(supersededAt).getTime();
-            if (age >= retentionMs) {
-                this.memories.delete(id);
-                removed++;
-            }
-        }
-        return removed;
-    }
-    clearProject(projectId) {
-        let deleted = 0;
-        for (const [id, memory] of this.memories) {
-            if (memory.projectId ===
-                projectId) {
-                this.memories.delete(id);
-                deleted++;
-            }
-        }
-        return deleted;
-    }
-}

package/dist/src/core/project-manager.js

@@ -1,243 +0,0 @@
-import { createHash, } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
-import { basename, dirname, join, parse, resolve, } from "node:path";
-const TOOLNET_DIRECTORY = ".toolnet";
-const PROJECT_FILE = "project.json";
-/**
- * Legacy ID algorithm.
- *
- * IMPORTANT:
- * Existing ToolNet projects already use this ID internally.
- * We keep it for the first local manifest creation so no
- * graph/memory/snapshot projectId is invalidated.
- *
- * Once stored in .toolnet/project.json, the ID no longer
- * depends on the path.
- */
-function legacyProjectIdFromPath(rootPath) {
-    return createHash("sha256")
-        .update(rootPath)
-        .digest("hex")
-        .slice(0, 16);
-}
-function manifestPath(rootPath) {
-    return join(rootPath, TOOLNET_DIRECTORY, PROJECT_FILE);
-}
-function hasProjectManifest(rootPath) {
-    return existsSync(manifestPath(rootPath));
-}
-/**
- * Search upwards for an existing ToolNet project identity.
- *
- * This means running ToolNet from:
- *
- * ~/mercedes/src/foo/
- *
- * still resolves:
- *
- * ~/mercedes/.toolnet/project.json
- */
-function findExistingProjectRoot(startPath) {
-    let current = resolve(startPath);
-    const filesystemRoot = parse(current).root;
-    while (true) {
-        if (hasProjectManifest(current)) {
-            return current;
-        }
-        if (current ===
-            filesystemRoot) {
-            break;
-        }
-        const parent = dirname(current);
-        if (parent ===
-            current) {
-            break;
-        }
-        current =
-            parent;
-    }
-    return null;
-}
-/**
- * When a project has not been initialized yet, try to identify
- * its repository root instead of accidentally creating
- * .toolnet inside src/foo/.
- */
-function findRepositoryRoot(startPath) {
-    let current = resolve(startPath);
-    const filesystemRoot = parse(current).root;
-    const markers = [
-        ".git",
-        "package.json",
-        "pyproject.toml",
-        "Cargo.toml",
-        "go.mod",
-        "composer.json",
-    ];
-    while (true) {
-        if (markers.some((marker) => existsSync(join(current, marker)))) {
-            return current;
-        }
-        if (current ===
-            filesystemRoot) {
-            break;
-        }
-        const parent = dirname(current);
-        if (parent ===
-            current) {
-            break;
-        }
-        current =
-            parent;
-    }
-    return resolve(startPath);
-}
-function parseManifest(filePath) {
-    let value;
-    try {
-        value =
-            JSON.parse(readFileSync(filePath, "utf8"));
-    }
-    catch (error) {
-        throw new Error(`Invalid ToolNet project manifest: ${filePath}: ${error instanceof Error
-            ? error.message
-            : String(error)}`);
-    }
-    if (!value ||
-        typeof value !==
-            "object") {
-        throw new Error(`Invalid ToolNet project manifest: ${filePath}`);
-    }
-    const data = value;
-    if (typeof data.id !==
-        "string" ||
-        !data.id.trim()) {
-        throw new Error(`ToolNet project manifest is missing id: ${filePath}`);
-    }
-    if (typeof data.name !==
-        "string" ||
-        !data.name.trim()) {
-        throw new Error(`ToolNet project manifest is missing name: ${filePath}`);
-    }
-    const now = new Date()
-        .toISOString();
-    return {
-        version: 1,
-        id: data.id,
-        name: data.name,
-        remote: typeof data.remote ===
-            "string" &&
-            data.remote.trim()
-            ? data.remote
-            : data.name,
-        rootPath: typeof data.rootPath ===
-            "string"
-            ? data.rootPath
-            : dirname(dirname(filePath)),
-        createdAt: typeof data.createdAt ===
-            "string"
-            ? data.createdAt
-            : now,
-        updatedAt: typeof data.updatedAt ===
-            "string"
-            ? data.updatedAt
-            : now,
-        graphVersion: typeof data.graphVersion ===
-            "number"
-            ? data.graphVersion
-            : 0,
-        memoryVersion: typeof data.memoryVersion ===
-            "number"
-            ? data.memoryVersion
-            : 0,
-        metadata: data.metadata &&
-            typeof data.metadata ===
-                "object"
-            ? data.metadata
-            : undefined,
-    };
-}
-function writeManifest(rootPath, manifest) {
-    const directory = join(rootPath, TOOLNET_DIRECTORY);
-    mkdirSync(directory, {
-        recursive: true,
-    });
-    const target = manifestPath(rootPath);
-    const temporary = `${target}.tmp-${process.pid}`;
-    writeFileSync(temporary, JSON.stringify(manifest, null, 2) + "\n", {
-        encoding: "utf8",
-        mode: 0o600,
-    });
-    renameSync(temporary, target);
-}
-function toProjectManifest(local, rootPath) {
-    return {
-        id: local.id,
-        name: local.name,
-        remote: local.remote,
-        rootPath,
-        createdAt: local.createdAt,
-        updatedAt: local.updatedAt,
-        graphVersion: local.graphVersion,
-        memoryVersion: local.memoryVersion,
-        metadata: local.metadata,
-    };
-}
-export class ProjectManager {
-    detect(rootPath = process.cwd()) {
-        const requestedPath = resolve(rootPath);
-        /*
-         * Existing project identity always wins.
-         */
-        const existingRoot = findExistingProjectRoot(requestedPath);
-        if (existingRoot) {
-            const filePath = manifestPath(existingRoot);
-            const local = parseManifest(filePath);
-            /*
-             * Project may have been moved or its folder renamed.
-             *
-             * Update only rootPath.
-             * DO NOT change:
-             *   id
-             *   name
-             *   remote
-             */
-            if (local.rootPath !==
-                existingRoot) {
-                local.rootPath =
-                    existingRoot;
-                local.updatedAt =
-                    new Date()
-                        .toISOString();
-                writeManifest(existingRoot, local);
-            }
-            return toProjectManifest(local, existingRoot);
-        }
-        /*
-         * First ToolNet initialization.
-         */
-        const projectRoot = findRepositoryRoot(requestedPath);
-        const now = new Date()
-            .toISOString();
-        const name = basename(projectRoot);
-        const local = {
-            version: 1,
-            /*
-             * Preserve the legacy ID on first initialization.
-             *
-             * From now on this value lives in the manifest
-             * and becomes path-independent.
-             */
-            id: legacyProjectIdFromPath(projectRoot),
-            name,
-            remote: name,
-            rootPath: projectRoot,
-            createdAt: now,
-            updatedAt: now,
-            graphVersion: 0,
-            memoryVersion: 0,
-        };
-        writeManifest(projectRoot, local);
-        return toProjectManifest(local, projectRoot);
-    }
-}

package/dist/src/core/types.js

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

package/dist/src/embeddings/batch-embedder.js

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

package/dist/src/embeddings/cache.js

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

package/dist/src/embeddings/embedder.js

@@ -1,51 +0,0 @@
-import { HuggingFaceEmbeddingProvider, } from "./remote.js";
-import { HashEmbeddingProvider, } from "./local.js";
-export class ResilientEmbeddingProvider {
-    primary;
-    fallback;
-    name = "resilient";
-    constructor(primary, fallback = new HashEmbeddingProvider()) {
-        this.primary = primary;
-        this.fallback = fallback;
-    }
-    async embed(text) {
-        if (this.primary) {
-            try {
-                return await this.primary.embed(text);
-            }
-            catch (error) {
-                console.warn("[embedding] primary failed, fallback enabled:", error instanceof Error
-                    ? error.message
-                    : error);
-            }
-        }
-        return this.fallback.embed(text);
-    }
-    async embedMany(texts) {
-        if (this.primary) {
-            try {
-                return await this.primary
-                    .embedMany(texts);
-            }
-            catch (error) {
-                console.warn("[embedding] primary failed, fallback enabled:", error instanceof Error
-                    ? error.message
-                    : error);
-            }
-        }
-        return this.fallback
-            .embedMany(texts);
-    }
-}
-export function createEmbeddingProvider() {
-    const token = process.env.HF_TOKEN;
-    const model = process.env.HF_EMBEDDING_MODEL ??
-        "sentence-transformers/all-MiniLM-L6-v2";
-    const primary = token
-        ? new HuggingFaceEmbeddingProvider({
-            token,
-            model,
-        })
-        : null;
-    return new ResilientEmbeddingProvider(primary);
-}

package/dist/src/embeddings/index.js

@@ -1,4 +0,0 @@
-export * from "./provider.js";
-export * from "./embedder.js";
-export * from "./remote.js";
-export * from "./local.js";

package/dist/src/embeddings/local.js

@@ -1,37 +0,0 @@
-import { createHash, } from "node:crypto";
-/*
- * Fallback nhẹ để hệ thống không chết
- * khi HF API lỗi/quota.
- *
- * Không thay thế semantic embedding thật.
- */
-export class HashEmbeddingProvider {
-    name = "hash-fallback";
-    dimensions = 128;
-    async embed(text) {
-        const vector = new Array(this.dimensions).fill(0);
-        const words = text
-            .toLowerCase()
-            .split(/\s+/)
-            .filter(Boolean);
-        for (const word of words) {
-            const hash = createHash("sha256")
-                .update(word)
-                .digest();
-            const index = hash.readUInt32BE(0) %
-                this.dimensions;
-            vector[index] += 1;
-        }
-        return normalize(vector);
-    }
-    async embedMany(texts) {
-        return Promise.all(texts.map((text) => this.embed(text)));
-    }
-}
-function normalize(vector) {
-    const norm = Math.sqrt(vector.reduce((sum, value) => sum + value * value, 0));
-    if (norm === 0) {
-        return vector;
-    }
-    return vector.map((value) => value / norm);
-}

package/dist/src/embeddings/provider.js

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