toolnet-memory 0.2.1 → 0.2.2

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

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

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

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