toolnet-memory 0.2.0

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

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

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

@@ -0,0 +1,127 @@
+import { closeSync, existsSync, openSync, readSync, statSync, } from "node:fs";
+import { extractWorkObservations, } from "./extractor.js";
+import { WorkObservationJournal, } from "./journal.js";
+import { reconcileWorkState, } from "./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 length = size -
+        start;
+    const buffer = Buffer.alloc(length);
+    const fd = openSync(filePath, "r");
+    try {
+        readSync(fd, buffer, 0, 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);
+    const events = complete
+        .split("\n")
+        .filter(Boolean)
+        .flatMap(line => {
+        try {
+            return [
+                JSON.parse(line),
+            ];
+        }
+        catch {
+            return [];
+        }
+    });
+    return {
+        events,
+        nextOffset: start +
+            Buffer.byteLength(complete, "utf8"),
+    };
+}
+export class WorkContinuityLearner {
+    options;
+    journal;
+    constructor(options) {
+        this.options = options;
+        this.journal =
+            new WorkObservationJournal(options.storage);
+    }
+    async learnNew() {
+        const state = this.options
+            .wal
+            .loadState();
+        const rawOffset = Number(state.sourceCursors["work.continuity.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 = extractWorkObservations(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 reconcileWorkState(this.options
+                    .project, this.options
+                    .storage);
+                reconciled =
+                    true;
+            }
+        }
+        this.options
+            .wal
+            .setSourceCursor("work.continuity.offset", read.nextOffset);
+        return {
+            scannedEvents: read.events.length,
+            observations: observations.length,
+            journalWritten,
+            reconciled,
+            nextOffset: read.nextOffset,
+        };
+    }
+}

package/dist/src/work-continuity/reducer.js

@@ -0,0 +1,316 @@
+import { join, } from "node:path";
+import { mkdirSync, } from "node:fs";
+import { sha256, writeJsonAtomic, } from "../session/utils.js";
+function normalizedKey(value) {
+    return value
+        .normalize("NFKC")
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function uniqueRecent(values, limit = 20) {
+    const output = [];
+    const seen = new Set();
+    for (const value of values
+        .slice()
+        .reverse()) {
+        const key = normalizedKey(value);
+        if (!key ||
+            seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        output.push(value);
+        if (output.length >=
+            limit) {
+            break;
+        }
+    }
+    return output.reverse();
+}
+function isPlaceholderTitle(observation) {
+    if (observation.kind ===
+        "phase") {
+        return /^Phase\s+\d+$/iu
+            .test(observation.text);
+    }
+    if (observation.kind ===
+        "task") {
+        return /^(?:TODO|Task|Việc)\s+\d+$/iu
+            .test(observation.text);
+    }
+    return false;
+}
+function mergeItem(previous, observation) {
+    const incomingStatus = observation.status ??
+        previous?.status ??
+        "pending";
+    let status = incomingStatus;
+    if (previous) {
+        /*
+         * Completed work is sticky.
+         * A stale plan from another agent must not reopen it.
+         */
+        if (previous.status ===
+            "completed" &&
+            incomingStatus !==
+                "completed") {
+            status =
+                "completed";
+        }
+        /*
+         * A plain plan restatement is pending.
+         * It must not downgrade active/blocked work.
+         */
+        else if (incomingStatus ===
+            "pending" &&
+            (previous.status ===
+                "in_progress" ||
+                previous.status ===
+                    "blocked")) {
+            status =
+                previous.status;
+        }
+    }
+    /*
+     * Status-only update:
+     *
+     * TODO 2: Viết adapter
+     * TODO 2 đang làm
+     *
+     * keeps descriptive title "Viết adapter".
+     */
+    const title = previous &&
+        isPlaceholderTitle(observation)
+        ? previous.title
+        : observation.text;
+    return {
+        id: previous?.id ??
+            sha256(observation.key).slice(0, 24),
+        title,
+        status,
+        order: observation.order ??
+            previous?.order,
+        confidence: Math.max(observation.confidence, previous?.confidence ??
+            0),
+        updatedAt: observation.occurredAt,
+        updatedBy: {
+            agent: observation.agent,
+            nativeSessionId: observation.nativeSessionId,
+            eventId: observation.eventId,
+        },
+    };
+}
+async function loadBatches(project, storage) {
+    const prefix = `projects/${project.id}/work/observations/`;
+    const objects = await storage.list(prefix);
+    const batches = [];
+    for (const object of objects
+        .filter(item => item.key.endsWith(".json"))
+        .sort((left, right) => left.key.localeCompare(right.key))) {
+        const text = await storage.getText(object.key);
+        if (!text) {
+            continue;
+        }
+        try {
+            const batch = JSON.parse(text);
+            if (batch.version ===
+                1 &&
+                Array.isArray(batch.observations)) {
+                batches.push(batch);
+            }
+        }
+        catch {
+            // Ignore corrupt/incomplete optional batch.
+        }
+    }
+    return batches;
+}
+export async function reconcileWorkState(project, storage) {
+    const batches = await loadBatches(project, storage);
+    /*
+     * Important:
+     * batches come from multiple agents and each session has
+     * its own sequence counter.
+     *
+     * Never assume global sequence ordering.
+     * Timestamp is primary; sequence is only a local tie-breaker.
+     */
+    const observations = batches
+        .flatMap(batch => batch.observations)
+        .sort((left, right) => {
+        const time = left.occurredAt
+            .localeCompare(right.occurredAt);
+        if (time !== 0) {
+            return time;
+        }
+        const sequence = left.sequence -
+            right.sequence;
+        if (sequence !== 0) {
+            return sequence;
+        }
+        return left.id
+            .localeCompare(right.id);
+    });
+    const phases = new Map();
+    const tasks = new Map();
+    let goal;
+    let plan;
+    let lastSession;
+    const decisions = [];
+    const blockers = [];
+    const warnings = [];
+    const explicitNext = [];
+    const files = [];
+    const tests = [];
+    for (const observation of observations) {
+        switch (observation.kind) {
+            case "goal":
+                goal =
+                    observation.text;
+                break;
+            case "plan":
+                plan =
+                    observation.text;
+                break;
+            case "phase":
+                phases.set(observation.key, mergeItem(phases.get(observation.key), observation));
+                break;
+            case "task":
+                tasks.set(observation.key, mergeItem(tasks.get(observation.key), observation));
+                break;
+            case "decision":
+                decisions.push(observation.text);
+                break;
+            case "blocker":
+                blockers.push(observation.text);
+                break;
+            case "warning":
+                warnings.push(observation.text);
+                break;
+            case "next_action":
+                explicitNext.push(observation.text);
+                break;
+            case "file":
+                files.push(observation.text);
+                break;
+            case "test":
+                tests.push(observation.text);
+                break;
+            case "session":
+                lastSession = {
+                    agent: observation.agent,
+                    nativeSessionId: observation.nativeSessionId,
+                    sessionKey: observation.sessionKey,
+                    updatedAt: observation.occurredAt,
+                };
+                break;
+        }
+    }
+    const phaseList = Array.from(phases.values()).sort((left, right) => (left.order ??
+        Number.MAX_SAFE_INTEGER) -
+        (right.order ??
+            Number.MAX_SAFE_INTEGER));
+    const taskList = Array.from(tasks.values()).sort((left, right) => (left.order ??
+        Number.MAX_SAFE_INTEGER) -
+        (right.order ??
+            Number.MAX_SAFE_INTEGER));
+    const currentPhase = phaseList.find(item => item.status ===
+        "in_progress") ??
+        phaseList.find(item => item.status ===
+            "blocked") ??
+        phaseList.find(item => item.status ===
+            "pending");
+    const currentTask = taskList.find(item => item.status ===
+        "in_progress") ??
+        taskList.find(item => item.status ===
+            "blocked") ??
+        taskList.find(item => item.status ===
+            "pending");
+    const nextActions = uniqueRecent([
+        ...explicitNext,
+        ...(currentTask
+            ? [
+                currentTask.title,
+            ]
+            : []),
+        ...(!currentTask &&
+            currentPhase
+            ? [
+                currentPhase.title,
+            ]
+            : []),
+        ...taskList
+            .filter(item => item.status ===
+            "pending")
+            .slice(0, 5)
+            .map(item => item.title),
+    ], 8);
+    const activeBlockers = uniqueRecent([
+        ...blockers,
+        ...phaseList
+            .filter(item => item.status ===
+            "blocked")
+            .map(item => item.title),
+        ...taskList
+            .filter(item => item.status ===
+            "blocked")
+            .map(item => item.title),
+    ], 20);
+    const state = {
+        version: 1,
+        projectId: project.id,
+        projectName: project.name,
+        goal,
+        plan,
+        phases: phaseList,
+        tasks: taskList,
+        decisions: uniqueRecent(decisions, 20),
+        blockers: activeBlockers,
+        warnings: uniqueRecent(warnings, 20),
+        nextActions,
+        filesTouched: uniqueRecent(files, 30),
+        tests: uniqueRecent(tests, 20),
+        currentPhase,
+        currentTask,
+        progress: {
+            phasesTotal: phaseList.length,
+            phasesCompleted: phaseList.filter(item => item.status ===
+                "completed").length,
+            tasksTotal: taskList.length,
+            tasksCompleted: taskList.filter(item => item.status ===
+                "completed").length,
+            blocked: phaseList.filter(item => item.status ===
+                "blocked").length +
+                taskList.filter(item => item.status ===
+                    "blocked").length,
+        },
+        lastSession,
+        updatedAt: observations.length
+            ? observations[observations.length -
+                1].occurredAt
+            : new Date()
+                .toISOString(),
+    };
+    const localDirectory = join(project.rootPath, ".toolnet", "work");
+    mkdirSync(localDirectory, {
+        recursive: true,
+    });
+    writeJsonAtomic(join(localDirectory, "current.json"), state);
+    await storage.put(`projects/${project.id}/work/current.json`, JSON.stringify(state, null, 2) +
+        "\n", "application/json");
+    return state;
+}
+export async function loadWorkState(project, storage) {
+    const text = await storage.getText(`projects/${project.id}/work/current.json`);
+    if (!text) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}