@haaaiawd/second-nature 0.1.8 → 0.1.10

package/runtime/storage/user-interest/load-user-interest-snapshot.js

@@ -0,0 +1,150 @@
+/**
+ * Minimal loadUserInterestSnapshot: anchor + curated presence, no fabricated preferences (T4.2.2).
+ *
+ * Core logic: USER.md / MEMORY.md / memory/curated/*.md drive signals; otherwise insufficient.
+ * Boundaries: never invent topics; staleness insufficient when anchors missing and no curated signals.
+ */
+import * as crypto from "node:crypto";
+import * as fs from "fs/promises";
+import * as path from "node:path";
+import { fileExists, readText } from "../memory/workspace/paths.js";
+const MIN_MEANINGFUL_ANCHOR_CHARS = 24;
+const STALE_MS = 30 * 24 * 60 * 60 * 1000;
+const INSUFFICIENT_CONFIDENCE_THRESHOLD = 0.35;
+function anchorRef(asset, workspaceRoot) {
+    return {
+        id: `anchor:${asset}`,
+        kind: "user_anchor",
+        uri: path.join(workspaceRoot, asset),
+        observedAt: new Date().toISOString(),
+    };
+}
+async function newestMtime(paths) {
+    let max = 0;
+    for (const p of paths) {
+        try {
+            const st = await fs.stat(p);
+            max = Math.max(max, st.mtimeMs);
+        }
+        catch {
+            /* missing */
+        }
+    }
+    return max;
+}
+async function listCuratedSignalFiles(workspaceRoot) {
+    const dir = path.join(workspaceRoot, "memory", "curated");
+    if (!(await fileExists(dir)))
+        return [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => path.join(dir, e.name));
+}
+export async function loadUserInterestSnapshot(workspaceRoot) {
+    const generatedAt = new Date().toISOString();
+    const userPath = path.join(workspaceRoot, "USER.md");
+    const memoryPath = path.join(workspaceRoot, "MEMORY.md");
+    const hasUser = await fileExists(userPath);
+    const hasMemory = await fileExists(memoryPath);
+    const userText = hasUser ? (await readText(userPath)).trim() : "";
+    const memoryText = hasMemory ? (await readText(memoryPath)).trim() : "";
+    const curatedFiles = await listCuratedSignalFiles(workspaceRoot);
+    const curatedNonEmpty = [];
+    for (const fp of curatedFiles) {
+        const body = (await readText(fp)).trim();
+        if (body.length >= MIN_MEANINGFUL_ANCHOR_CHARS)
+            curatedNonEmpty.push(fp);
+    }
+    const userOk = hasUser && userText.length >= MIN_MEANINGFUL_ANCHOR_CHARS;
+    const memoryOk = hasMemory && memoryText.length >= MIN_MEANINGFUL_ANCHOR_CHARS;
+    if (!userOk && !memoryOk && curatedNonEmpty.length === 0) {
+        return {
+            snapshotId: crypto.randomUUID(),
+            generatedAt,
+            signals: [],
+            sourceRefs: [],
+            confidence: 0,
+            staleness: "insufficient",
+            missingReasons: ["missing_user_interest_model"],
+        };
+    }
+    const signals = [];
+    const allRefs = [];
+    if (userOk) {
+        const ref = anchorRef("USER.md", workspaceRoot);
+        allRefs.push(ref);
+        signals.push({
+            id: `interest:user:${crypto.randomUUID()}`,
+            topic: "user_anchor_profile",
+            affinity: "unknown",
+            reason: "derived_from_USER.md_anchor",
+            confidence: 0.55,
+            sourceRefs: [ref],
+            updatedAt: generatedAt,
+        });
+    }
+    if (memoryOk) {
+        const ref = anchorRef("MEMORY.md", workspaceRoot);
+        allRefs.push(ref);
+        signals.push({
+            id: `interest:memory:${crypto.randomUUID()}`,
+            topic: "relational_memory_anchor",
+            affinity: "watching",
+            reason: "derived_from_MEMORY.md_anchor",
+            confidence: 0.52,
+            sourceRefs: [ref],
+            updatedAt: generatedAt,
+        });
+    }
+    for (const fp of curatedNonEmpty) {
+        const ref = {
+            id: `curated:${path.basename(fp, ".md")}`,
+            kind: "workspace_artifact",
+            uri: fp,
+            observedAt: generatedAt,
+        };
+        allRefs.push(ref);
+        signals.push({
+            id: `interest:curated:${crypto.randomUUID()}`,
+            topic: `curated:${path.basename(fp, ".md")}`,
+            affinity: "positive",
+            reason: "derived_from_curated_memory_file",
+            confidence: 0.48,
+            sourceRefs: [ref],
+            updatedAt: generatedAt,
+        });
+    }
+    if (signals.length === 0) {
+        return {
+            snapshotId: crypto.randomUUID(),
+            generatedAt,
+            signals: [],
+            sourceRefs: [],
+            confidence: 0,
+            staleness: "insufficient",
+            missingReasons: ["missing_user_interest_model"],
+        };
+    }
+    const confidence = signals.reduce((s, x) => s + x.confidence, 0) / signals.length;
+    if (confidence < INSUFFICIENT_CONFIDENCE_THRESHOLD) {
+        return {
+            snapshotId: crypto.randomUUID(),
+            generatedAt,
+            signals: [],
+            sourceRefs: [],
+            confidence: 0,
+            staleness: "insufficient",
+            missingReasons: ["missing_user_interest_model"],
+        };
+    }
+    const mtimes = await newestMtime([hasUser ? userPath : "", hasMemory ? memoryPath : "", ...curatedNonEmpty].filter(Boolean));
+    const staleness = mtimes > 0 && Date.now() - mtimes > STALE_MS ? "stale" : "fresh";
+    const uniqueRefs = [...new Map(allRefs.map((r) => [r.uri, r])).values()];
+    return {
+        snapshotId: crypto.randomUUID(),
+        generatedAt,
+        signals,
+        sourceRefs: uniqueRefs,
+        confidence,
+        staleness,
+    };
+}

package/runtime/storage/user-interest/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * User interest read model (T4.2.2 / state-system v5 subset).
+ *
+ * Test coverage: tests/unit/storage/user-interest-snapshot.test.ts
+ */
+import type { SourceRef } from "../life-evidence/types.js";
+export type UserInterestStaleness = "fresh" | "stale" | "insufficient";
+export interface UserInterestSignal {
+    id: string;
+    topic: string;
+    affinity: "positive" | "negative" | "watching" | "unknown";
+    reason: string;
+    confidence: number;
+    sourceRefs: SourceRef[];
+    updatedAt: string;
+}
+export interface UserInterestSnapshot {
+    snapshotId: string;
+    generatedAt: string;
+    signals: UserInterestSignal[];
+    sourceRefs: SourceRef[];
+    confidence: number;
+    staleness: UserInterestStaleness;
+    missingReasons?: string[];
+}

package/runtime/storage/user-interest/types.js

@@ -0,0 +1 @@
+export {};

package/workspace-ops-bridge.js

@@ -0,0 +1,78 @@
+/**
+ * T1.1.4 — Lazy workspace full-ops bridge (OpenClaw plugin).
+ *
+ * Core logic: dynamic-import packaged `runtime/` + open workspace `data/*.db` with the same
+ * `createCliRuntimeDeps` + `createOpsRouter` + `createCliCommands` path as the workspace CLI.
+ * `process.chdir(workspaceRoot)` during dispatch so `memory/workspace` paths match CLI cwd semantics.
+ *
+ * Boundaries: no static imports from `./runtime/*` (sql.js top-level await stays out of register() graph).
+ *
+ * Plan B (CH-11-01): if the host VM blocks dynamic import + sql.js, fall back to a subprocess invoking
+ * the workspace `second-nature` CLI — not implemented here; bridge failures surface as explicit errors.
+ *
+ * Test coverage: tests/integration/cli/plugin-workspace-ops-bridge.test.ts
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const PLUGIN_PACKAGE_ROOT = path.dirname(fileURLToPath(import.meta.url));
+export async function openWorkspaceOpsBridge(workspaceRoot) {
+    const resolvedRoot = path.resolve(workspaceRoot);
+    try {
+        // Packaged `plugin/runtime` is emitted JS without sibling `.d.ts` in this repo layout.
+        // @ts-expect-error TS7016 — intentional dynamic import of artifact bundle
+        const cliIndex = (await import("./runtime/cli/index.js"));
+        const commandsMod = (await import("./runtime/cli/commands/index.js"));
+        const storageDb = (await import("./runtime/storage/db/index.js"));
+        const obsDb = (await import("./runtime/observability/db/index.js"));
+        const boundary = (await import("./runtime/cli/runtime/runtime-artifact-boundary.js"));
+        const dataDir = path.join(resolvedRoot, "data");
+        fs.mkdirSync(dataDir, { recursive: true });
+        const statePath = path.join(dataDir, "state.db");
+        const obsPath = path.join(dataDir, "observability.db");
+        const stateDb = storageDb.createStateDatabase(statePath);
+        const observabilityDb = obsDb.createObservabilityDatabase(obsPath);
+        const deps = cliIndex.createCliRuntimeDeps({ stateDb, observabilityDb });
+        const runtimeResolved = boundary.resolvePackagedRuntime(PLUGIN_PACKAGE_ROOT);
+        const opsRouter = cliIndex.createOpsRouter({
+            runtimeAvailable: runtimeResolved.ok,
+            readModels: deps.readModels,
+        });
+        const commands = commandsMod.createCliCommands({
+            readModels: deps.readModels,
+            actionBridge: deps.actionBridge,
+            opsRouter,
+        });
+        const dispatch = async (command, input) => {
+            const def = commands.find((c) => c.name === command);
+            if (!def) {
+                return {
+                    ok: false,
+                    error: { code: "unknown_command", message: `Unknown Second Nature command: ${command}` },
+                };
+            }
+            const prevCwd = process.cwd();
+            try {
+                process.chdir(resolvedRoot);
+                return await def.execute(input);
+            }
+            finally {
+                process.chdir(prevCwd);
+            }
+        };
+        const close = () => {
+            cliIndex.closeCliRuntimeDeps(deps);
+        };
+        return { ok: true, workspaceRoot: resolvedRoot, dispatch, close };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: {
+                code: "WORKSPACE_FULL_OPS_BRIDGE_FAILED",
+                message: error instanceof Error ? error.message : String(error),
+                nextStep: "Confirm the packaged plugin includes plugin/runtime and that the host allows dynamic import of sql.js. If the VM forbids it, use a subprocess workspace CLI (Plan B) or run outside the sandbox.",
+            },
+        };
+    }
+}