toolnet-memory 0.2.0

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

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

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

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