toolnet-memory 0.2.1 → 0.2.3

package/dist/src/session/core.js

@@ -1,239 +0,0 @@
-import { Sanitizer, } from "../security/sanitizer.js";
-import { createSessionIdentity, } from "./identity.js";
-import { RemoteSessionStore, } from "./store.js";
-import { SessionWal, } from "./wal.js";
-import { SessionMemoryLearner, } from "./learner/learner.js";
-import { WorkContinuityLearner, } from "../work-continuity/learner.js";
-import { SemanticWorkLearner, } from "../work-continuity/semantic-learner.js";
-import { SmartHandoffManager, } from "../work-continuity/handoff.js";
-export class SessionCore {
-    identity;
-    wal;
-    remote;
-    sanitizer = new Sanitizer();
-    learner;
-    continuity;
-    semantic;
-    handoff;
-    title;
-    metadata;
-    constructor(options) {
-        this.identity =
-            createSessionIdentity(options.project, options.agent, options.nativeSessionId);
-        this.title =
-            options.title;
-        this.metadata =
-            (this.sanitizer
-                .sanitizeValue(options.metadata ??
-                {}));
-        this.wal =
-            new SessionWal(this.identity);
-        this.remote =
-            new RemoteSessionStore(options.storage, options.maxEventsPerChunk ??
-                100, options.maxChunkBytes ??
-                512 * 1024);
-        this.learner =
-            new SessionMemoryLearner({
-                project: options.project,
-                storage: options.storage,
-                identity: this.identity,
-                wal: this.wal,
-            });
-        this.continuity =
-            new WorkContinuityLearner({
-                project: options.project,
-                storage: options.storage,
-                identity: this.identity,
-                wal: this.wal,
-            });
-        this.semantic =
-            new SemanticWorkLearner({
-                project: options.project,
-                storage: options.storage,
-                identity: this.identity,
-                wal: this.wal,
-            });
-        this.handoff =
-            new SmartHandoffManager({
-                project: options.project,
-                storage: options.storage,
-                identity: this.identity,
-            });
-    }
-    sanitizeEvent(event) {
-        const provenance = event.provenance
-            ? {
-                ...event.provenance,
-                metadata: this.sanitizer
-                    .sanitizeValue(event.provenance
-                    .metadata),
-            }
-            : undefined;
-        return {
-            ...event,
-            data: this.sanitizer
-                .sanitizeValue(event.data ??
-                {}),
-            provenance,
-        };
-    }
-    start(data = {}) {
-        const state = this.wal.loadState();
-        return this.record({
-            type: state.lastSequence ===
-                0
-                ? "session_start"
-                : "session_resume",
-            data,
-            provenance: {
-                source: this.identity.agent,
-            },
-        });
-    }
-    record(event) {
-        return this.wal.append([
-            this.sanitizeEvent(event),
-        ])[0];
-    }
-    recordMany(events) {
-        return this.wal.append(events.map(event => this.sanitizeEvent(event)));
-    }
-    setSourceCursor(source, value) {
-        this.wal
-            .setSourceCursor(source, value);
-    }
-    async flush() {
-        const pending = this.wal
-            .readPending();
-        const state = this.wal
-            .loadState();
-        const result = await this.remote.append(this.identity, pending.events, state.sourceCursors, {
-            title: this.title,
-            metadata: this.metadata,
-        });
-        if (pending.events.length >
-            0) {
-            const last = pending.events[pending.events.length -
-                1];
-            this.wal.markRemote(last.sequence, pending.endOffset);
-        }
-        /*
-         * Long-term learning is deliberately downstream
-         * of durable session persistence.
-         *
-         * A learner failure must NEVER destroy session capture.
-         * Cursor is not advanced on learner failure,
-         * so next flush retries.
-         */
-        if (process.env
-            .TOOLNET_SESSION_LEARNING !==
-            "0") {
-            try {
-                await this.learner
-                    .learnNew();
-            }
-            catch {
-                // Retry automatically on a later flush.
-            }
-        }
-        /*
-         * Work continuity is a separate projection from
-         * long-term memory.
-         *
-         * Failure here must never break session capture.
-         */
-        if (process.env
-            .TOOLNET_WORK_CONTINUITY !==
-            "0") {
-            try {
-                await this.continuity
-                    .learnNew();
-            }
-            catch {
-                // Immutable session WAL allows retry later.
-            }
-        }
-        /*
-         * Semantic continuity learns meaning, rationale,
-         * deliverables and completion criteria.
-         *
-         * It never invents missing rationale.
-         */
-        if (process.env
-            .TOOLNET_SEMANTIC_CONTINUITY !==
-            "0") {
-            try {
-                await this.semantic
-                    .learnNew();
-            }
-            catch {
-                // Derived projection: session capture must continue.
-            }
-        }
-        /*
-         * Smart Handoff checkpoint.
-         *
-         * We checkpoint on every durable flush, not only graceful
-         * session_end. This protects continuity when an agent hits
-         * token limit, terminal disconnect, crash, or user stops
-         * unexpectedly.
-         *
-         * Handoff IDs are state-digest based, so unchanged work
-         * does not create endless duplicate snapshots.
-         */
-        if (process.env
-            .TOOLNET_SMART_HANDOFF !==
-            "0" &&
-            pending.events.length >
-                0) {
-            try {
-                const lastEvent = pending.events[pending.events.length -
-                    1];
-                const explicitReason = [
-                    "session_idle",
-                    "session_end",
-                    "session_compact",
-                ].includes(lastEvent.type)
-                    ? lastEvent.type
-                    : "checkpoint";
-                await this.handoff
-                    .capture(explicitReason, lastEvent.sequence);
-            }
-            catch {
-                /*
-                 * Handoff is a derived projection.
-                 * It must never break durable session capture.
-                 */
-            }
-        }
-        return result;
-    }
-    async idle(data = {}) {
-        this.record({
-            type: "session_idle",
-            data,
-            provenance: {
-                source: this.identity.agent,
-            },
-        });
-        return this.flush();
-    }
-    async end(data = {}) {
-        this.record({
-            type: "session_end",
-            data,
-            provenance: {
-                source: this.identity.agent,
-            },
-        });
-        return this.flush();
-    }
-    status() {
-        return this.wal
-            .loadState();
-    }
-    recoverRemote() {
-        return this.remote
-            .recover(this.identity);
-    }
-}

package/dist/src/session/identity.js

@@ -1,57 +0,0 @@
-import { join, } from "node:path";
-import { sha256, } from "./utils.js";
-function safeSegment(value, fallback) {
-    const trimmed = value.trim();
-    const readable = trimmed
-        .replace(/\s+/g, "_")
-        .replace(/[^A-Za-z0-9._-]/g, "_")
-        .replace(/_+/g, "_")
-        .replace(/^\.+|\.+$/g, "");
-    const digest = sha256(trimmed).slice(0, 12);
-    if (!readable ||
-        readable === "." ||
-        readable === "..") {
-        return `${fallback}--${digest}`;
-    }
-    const limited = readable.slice(0, 100);
-    /*
-     * Preserve normal UUID/OpenCode IDs exactly.
-     * Add hash only when sanitization changed the value.
-     */
-    if (limited ===
-        trimmed &&
-        trimmed.length <=
-            100) {
-        return limited;
-    }
-    return `${limited.slice(0, 85)}--${digest}`;
-}
-export function createSessionIdentity(project, agent, nativeSessionId) {
-    const cleanAgent = agent.trim();
-    const cleanSessionId = nativeSessionId.trim();
-    if (!cleanAgent) {
-        throw new Error("Session agent is required");
-    }
-    if (!cleanSessionId) {
-        throw new Error("Native session ID is required");
-    }
-    const agentFolder = safeSegment(cleanAgent
-        .toLowerCase(), "agent");
-    const sessionFolder = safeSegment(cleanSessionId, "session");
-    return {
-        projectId: project.id,
-        projectName: project.name,
-        projectRoot: project.rootPath,
-        agent: cleanAgent,
-        nativeSessionId: cleanSessionId,
-        sessionKey: `${cleanAgent}:${cleanSessionId}`,
-        remotePrefix: [
-            "projects",
-            project.id,
-            "sessions",
-            agentFolder,
-            sessionFolder,
-        ].join("/"),
-        localDirectory: join(project.rootPath, ".toolnet", "sessions", agentFolder, sessionFolder),
-    };
-}

package/dist/src/session/index.js

@@ -1,9 +0,0 @@
-export * from "./types.js";
-export * from "./identity.js";
-export * from "./wal.js";
-export * from "./store.js";
-export * from "./core.js";
-export * from "./opencode/index.js";
-export * from "./agy/index.js";
-export * from "./codex/index.js";
-export * from "./learner/index.js";

package/dist/src/session/learner/cli.js

@@ -1,62 +0,0 @@
-import { loadConfig, ProjectManager, } from "../../core/index.js";
-import { createStorageProvider, ProjectScopedStorageProvider, withStorageRetry, } from "../../storage/index.js";
-import { ProjectLock, } from "../../production/project-lock.js";
-import { reconcileSessionMemoryJournal, } from "./journal.js";
-function after(args, flag) {
-    const index = args.indexOf(flag);
-    return index >=
-        0
-        ? args[index + 1]
-        : undefined;
-}
-async function main() {
-    const [command = "help", ...args] = process.argv.slice(2);
-    if (command !==
-        "reconcile") {
-        console.log(`Session Memory Learner
-
-Commands:
-  reconcile [--project PATH]
-`);
-        return;
-    }
-    const projectPath = after(args, "--project") ??
-        process.cwd();
-    const project = new ProjectManager()
-        .detect(projectPath);
-    const config = loadConfig();
-    const raw = withStorageRetry(createStorageProvider({
-        provider: config.storage
-            .provider,
-        huggingface: config.storage
-            .huggingface,
-        localRoot: config.storage
-            .localRoot,
-    }), {
-        attempts: 3,
-    });
-    const storage = new ProjectScopedStorageProvider(raw, project.id, project.name, project.remote ??
-        project.name);
-    /*
-     * Reconcile writes current.json.
-     * Serialize against ToolNet runtime.
-     */
-    const lock = new ProjectLock(project.id);
-    await lock.acquire();
-    try {
-        const result = await reconcileSessionMemoryJournal(project, storage);
-        console.log(JSON.stringify({
-            project: project.name,
-            ...result,
-        }, null, 2));
-    }
-    finally {
-        await lock.release();
-    }
-}
-main().catch(error => {
-    console.error(error instanceof Error
-        ? error.message
-        : error);
-    process.exit(1);
-});