toolnet-memory 0.2.1 → 0.2.3

package/dist/src/work-continuity/semantic-extractor.js

@@ -1,360 +0,0 @@
-import { sha256, } from "../session/utils.js";
-const TEXT_KEYS = new Set([
-    "content",
-    "text",
-    "message",
-    "prompt",
-    "summary",
-    "description",
-    "title",
-    "reason",
-    "last_assistant_message",
-    "lastAssistantMessage",
-]);
-function normalize(value) {
-    return value
-        .normalize("NFKC")
-        .replace(/\s+/g, " ")
-        .replace(/^[\s>*#•-]+/u, "")
-        .trim();
-}
-function collectStrings(value, output, depth = 0) {
-    if (depth >
-        6) {
-        return;
-    }
-    if (typeof value ===
-        "string") {
-        output.push(value);
-        return;
-    }
-    if (Array.isArray(value)) {
-        for (const item of value.slice(0, 50)) {
-            collectStrings(item, output, depth + 1);
-        }
-        return;
-    }
-    if (!value ||
-        typeof value !==
-            "object") {
-        return;
-    }
-    for (const [key, child,] of Object.entries(value)) {
-        if (TEXT_KEYS.has(key) ||
-            [
-                "data",
-                "payload",
-                "parts",
-                "messages",
-            ].includes(key)) {
-            collectStrings(child, output, depth + 1);
-        }
-    }
-}
-function observation(identity, event, kind, value, scope, confidence = 0.95) {
-    const clean = normalize(value);
-    const id = sha256([
-        identity
-            .projectId,
-        kind,
-        scope.type,
-        scope.key ??
-            "",
-        clean
-            .toLowerCase(),
-        event.id,
-    ].join("|")).slice(0, 32);
-    return {
-        version: 1,
-        id,
-        projectId: identity
-            .projectId,
-        kind,
-        value: clean,
-        scope: scope.type,
-        scopeKey: scope.key,
-        scopeOrder: scope.order,
-        confidence,
-        evidence: {
-            agent: identity.agent,
-            nativeSessionId: identity
-                .nativeSessionId,
-            sessionKey: identity
-                .sessionKey,
-            eventId: event.id,
-            sourceEventId: event
-                .sourceEventId,
-            sequence: event.sequence,
-            occurredAt: event.timestamp,
-        },
-    };
-}
-function fieldValue(line, labels) {
-    const lower = line.toLowerCase();
-    for (const label of labels) {
-        const normalizedLabel = label.toLowerCase();
-        if (lower.startsWith(`${normalizedLabel}:`) ||
-            lower.startsWith(`${normalizedLabel} -`) ||
-            lower.startsWith(`${normalizedLabel} —`)) {
-            return normalize(line.slice(label.length + 1));
-        }
-    }
-    return null;
-}
-function isBullet(raw) {
-    const line = raw.trimStart();
-    return (line.startsWith("- ") ||
-        line.startsWith("* ") ||
-        /^\d+[.)]\s+/u.test(line));
-}
-function bulletValue(raw) {
-    return normalize(raw
-        .trim()
-        .replace(/^[-*]\s+/u, "")
-        .replace(/^\d+[.)]\s+/u, ""));
-}
-export function extractSemanticObservations(identity, events) {
-    const output = [];
-    const seen = new Set();
-    function push(item) {
-        if (!item.value ||
-            item.value.length <
-                3 ||
-            seen.has(item.id)) {
-            return;
-        }
-        seen.add(item.id);
-        output.push(item);
-    }
-    for (const event of events) {
-        const blocks = [];
-        collectStrings(event.data, blocks);
-        for (const block of blocks) {
-            let scope = {
-                type: "project",
-            };
-            let listMode = null;
-            for (const raw of block.split(/\r?\n/u)) {
-                const line = normalize(raw);
-                if (!line) {
-                    listMode =
-                        null;
-                    continue;
-                }
-                const phase = line.match(/^(?:phase|giai đoạn|giai doan|stage)\s*(\d+)\s*(?:[:\-–—]\s*)?(.*)$/iu);
-                if (phase) {
-                    const order = Number(phase[1]);
-                    scope = {
-                        type: "phase",
-                        key: `phase:${order}`,
-                        order,
-                        title: normalize(phase[2] ??
-                            ""),
-                    };
-                    listMode =
-                        null;
-                    continue;
-                }
-                const task = line.match(/^(?:todo|task|việc)\s*(\d+)\s*(?:[:\-–—]\s*)?(.*)$/iu);
-                if (task) {
-                    const order = Number(task[1]);
-                    scope = {
-                        type: "task",
-                        key: `task:${order}`,
-                        order,
-                        title: normalize(task[2] ??
-                            ""),
-                    };
-                    listMode =
-                        null;
-                    continue;
-                }
-                const mission = fieldValue(line, [
-                    "mission",
-                    "sứ mệnh",
-                    "mục tiêu tổng thể",
-                    "mục tiêu project",
-                    "project goal",
-                ]);
-                if (mission) {
-                    push(observation(identity, event, "mission", mission, {
-                        type: "project",
-                    }, 0.99));
-                    listMode =
-                        null;
-                    continue;
-                }
-                const activeObjective = fieldValue(line, [
-                    "current objective",
-                    "active objective",
-                    "mục tiêu hiện tại",
-                    "objective",
-                    "mục tiêu",
-                    "mục đích",
-                ]);
-                if (activeObjective) {
-                    push(observation(identity, event, scope.type ===
-                        "phase"
-                        ? "phase_objective"
-                        : "objective", activeObjective, scope, 0.98));
-                    listMode =
-                        null;
-                    continue;
-                }
-                const why = fieldValue(line, [
-                    "why",
-                    "why this",
-                    "why this phase",
-                    "reason",
-                    "rationale",
-                    "vì sao",
-                    "lý do",
-                    "tại sao",
-                    "ý nghĩa",
-                ]);
-                if (why) {
-                    push(observation(identity, event, scope.type ===
-                        "phase"
-                        ? "phase_why"
-                        : "why", why, scope, 0.98));
-                    listMode =
-                        null;
-                    continue;
-                }
-                const outcome = fieldValue(line, [
-                    "desired outcome",
-                    "final outcome",
-                    "kết quả cuối",
-                    "kết quả mong muốn",
-                    "mục tiêu cuối",
-                ]);
-                if (outcome) {
-                    push(observation(identity, event, "desired_outcome", outcome, {
-                        type: "project",
-                    }, 0.98));
-                    listMode =
-                        null;
-                    continue;
-                }
-                const planRationale = fieldValue(line, [
-                    "plan rationale",
-                    "approach rationale",
-                    "why this approach",
-                    "tại sao chọn hướng này",
-                    "lý do chọn hướng này",
-                    "lý do chọn kiến trúc",
-                ]);
-                if (planRationale) {
-                    push(observation(identity, event, "plan_rationale", planRationale, {
-                        type: "project",
-                    }, 0.98));
-                    listMode =
-                        null;
-                    continue;
-                }
-                const deliverable = fieldValue(line, [
-                    "deliverable",
-                    "output",
-                    "kết quả cần đạt",
-                    "phải tạo ra",
-                    "đầu ra",
-                ]);
-                if (deliverable) {
-                    push(observation(identity, event, "phase_deliverable", deliverable, scope, 0.97));
-                    listMode =
-                        null;
-                    continue;
-                }
-                const acceptance = fieldValue(line, [
-                    "acceptance criteria",
-                    "definition of done",
-                    "done khi",
-                    "hoàn thành khi",
-                    "tiêu chí hoàn thành",
-                ]);
-                if (acceptance) {
-                    push(observation(identity, event, "acceptance_criterion", acceptance, scope, 0.98));
-                    listMode =
-                        "acceptance_criterion";
-                    continue;
-                }
-                const dependency = fieldValue(line, [
-                    "depends on",
-                    "dependency",
-                    "dependencies",
-                    "phụ thuộc",
-                    "cần có trước",
-                ]);
-                if (dependency) {
-                    push(observation(identity, event, "dependency", dependency, scope, 0.97));
-                    listMode =
-                        "dependency";
-                    continue;
-                }
-                const openQuestion = fieldValue(line, [
-                    "open question",
-                    "open questions",
-                    "câu hỏi mở",
-                    "chưa quyết định",
-                    "chưa rõ",
-                ]);
-                if (openQuestion) {
-                    push(observation(identity, event, "open_question", openQuestion, scope, 0.95));
-                    listMode =
-                        "open_question";
-                    continue;
-                }
-                const constraint = fieldValue(line, [
-                    "constraint",
-                    "constraints",
-                    "ràng buộc",
-                    "giới hạn",
-                ]);
-                if (constraint) {
-                    push(observation(identity, event, "constraint", constraint, scope, 0.97));
-                    listMode =
-                        "constraint";
-                    continue;
-                }
-                if (/^(?:acceptance criteria|definition of done|done khi|tiêu chí hoàn thành)\s*:?\s*$/iu
-                    .test(line)) {
-                    listMode =
-                        "acceptance_criterion";
-                    continue;
-                }
-                if (/^(?:dependencies|dependency|phụ thuộc)\s*:?\s*$/iu
-                    .test(line)) {
-                    listMode =
-                        "dependency";
-                    continue;
-                }
-                if (/^(?:open questions|open question|câu hỏi mở)\s*:?\s*$/iu
-                    .test(line)) {
-                    listMode =
-                        "open_question";
-                    continue;
-                }
-                if (/^(?:constraints|constraint|ràng buộc)\s*:?\s*$/iu
-                    .test(line)) {
-                    listMode =
-                        "constraint";
-                    continue;
-                }
-                if (listMode &&
-                    isBullet(raw)) {
-                    push(observation(identity, event, listMode, bulletValue(raw), scope, 0.96));
-                    continue;
-                }
-                /*
-                 * No implicit "why" inference here.
-                 *
-                 * If the previous session never recorded WHY,
-                 * ToolNet deliberately leaves it unknown.
-                 */
-                listMode =
-                    null;
-            }
-        }
-    }
-    return output;
-}

package/dist/src/work-continuity/semantic-journal.js

@@ -1,55 +0,0 @@
-import { sha256, } from "../session/utils.js";
-function pad(value) {
-    return String(value).padStart(12, "0");
-}
-export class SemanticObservationJournal {
-    storage;
-    constructor(storage) {
-        this.storage = storage;
-    }
-    async write(identity, observations) {
-        if (observations.length ===
-            0) {
-            return null;
-        }
-        const firstSequence = Math.min(...observations.map(item => item.evidence
-            .sequence));
-        const lastSequence = Math.max(...observations.map(item => item.evidence
-            .sequence));
-        const batch = {
-            version: 1,
-            projectId: identity
-                .projectId,
-            agent: identity.agent,
-            nativeSessionId: identity
-                .nativeSessionId,
-            sessionKey: identity
-                .sessionKey,
-            firstSequence,
-            lastSequence,
-            createdAt: new Date()
-                .toISOString(),
-            observations,
-        };
-        const digest = sha256(observations
-            .map(item => item.id)
-            .sort()
-            .join("|")).slice(0, 16);
-        const key = [
-            `projects/${identity.projectId}`,
-            "work",
-            "semantic",
-            "observations",
-            identity.agent,
-            identity.nativeSessionId,
-            `${pad(firstSequence)}-${pad(lastSequence)}-${digest}.json`,
-        ].join("/");
-        if (!await this.storage
-            .exists(key)) {
-            await this.storage
-                .put(key, JSON.stringify(batch, null, 2) +
-                "\n", "application/json");
-        }
-        return key;
-    }
-}

package/dist/src/work-continuity/semantic-learner.js

@@ -1,125 +0,0 @@
-import { closeSync, existsSync, openSync, readSync, statSync, } from "node:fs";
-import { extractSemanticObservations, } from "./semantic-extractor.js";
-import { SemanticObservationJournal, } from "./semantic-journal.js";
-import { reconcileSemanticWorkState, } from "./semantic-reducer.js";
-function readEvents(filePath, offset) {
-    if (!existsSync(filePath)) {
-        return {
-            events: [],
-            nextOffset: offset,
-        };
-    }
-    const size = statSync(filePath).size;
-    let start = Number.isFinite(offset)
-        ? Math.max(0, offset)
-        : 0;
-    if (start >
-        size) {
-        start =
-            0;
-    }
-    if (start ===
-        size) {
-        return {
-            events: [],
-            nextOffset: size,
-        };
-    }
-    const buffer = Buffer.alloc(size -
-        start);
-    const fd = openSync(filePath, "r");
-    try {
-        readSync(fd, buffer, 0, buffer.length, start);
-    }
-    finally {
-        closeSync(fd);
-    }
-    const text = buffer.toString("utf8");
-    const lastNewline = text.lastIndexOf("\n");
-    if (lastNewline <
-        0) {
-        return {
-            events: [],
-            nextOffset: start,
-        };
-    }
-    const complete = text.slice(0, lastNewline +
-        1);
-    return {
-        events: complete
-            .split("\n")
-            .filter(Boolean)
-            .flatMap(line => {
-            try {
-                return [
-                    JSON.parse(line),
-                ];
-            }
-            catch {
-                return [];
-            }
-        }),
-        nextOffset: start +
-            Buffer.byteLength(complete, "utf8"),
-    };
-}
-export class SemanticWorkLearner {
-    options;
-    journal;
-    constructor(options) {
-        this.options = options;
-        this.journal =
-            new SemanticObservationJournal(options.storage);
-    }
-    async learnNew() {
-        const state = this.options
-            .wal
-            .loadState();
-        const rawOffset = Number(state.sourceCursors["work.semantic.offset"] ??
-            0);
-        const read = readEvents(this.options
-            .wal
-            .eventsFile, Number.isFinite(rawOffset)
-            ? rawOffset
-            : 0);
-        if (read.events.length ===
-            0) {
-            return {
-                scannedEvents: 0,
-                observations: 0,
-                journalWritten: false,
-                reconciled: false,
-                nextOffset: read.nextOffset,
-            };
-        }
-        const observations = extractSemanticObservations(this.options
-            .identity, read.events);
-        let journalWritten = false;
-        let reconciled = false;
-        if (observations.length >
-            0) {
-            const key = await this.journal
-                .write(this.options
-                .identity, observations);
-            journalWritten =
-                Boolean(key);
-            if (journalWritten) {
-                await reconcileSemanticWorkState(this.options
-                    .project, this.options
-                    .storage);
-                reconciled =
-                    true;
-            }
-        }
-        this.options
-            .wal
-            .setSourceCursor("work.semantic.offset", read.nextOffset);
-        return {
-            scannedEvents: read.events.length,
-            observations: observations.length,
-            journalWritten,
-            reconciled,
-            nextOffset: read.nextOffset,
-        };
-    }
-}