@haaaiawd/second-nature 0.1.22 → 0.1.23

package/runtime/storage/narrative/narrative-state-store.js

@@ -0,0 +1,79 @@
+import { eq } from "drizzle-orm";
+import { narrativeState } from "../db/schema/narrative-state.js";
+function safeParseJson(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}
+function rowToState(row) {
+    return {
+        narrativeId: row.narrativeId,
+        revision: row.revision,
+        focus: row.focus,
+        progress: safeParseJson(row.progressJson, []),
+        nextIntent: row.nextIntent,
+        confidence: row.confidence,
+        sourceRefs: safeParseJson(row.sourceRefsJson, []),
+        unsupportedClaims: safeParseJson(row.unsupportedClaimsJson, []),
+        status: row.status,
+        updatedAt: row.updatedAt,
+    };
+}
+const DEFAULT_NARRATIVE_ID = "default";
+export function createNarrativeStateStore(database) {
+    const db = database.db;
+    return {
+        async updateNarrativeState(input) {
+            const existing = await db
+                .select()
+                .from(narrativeState)
+                .where(eq(narrativeState.narrativeId, input.narrativeId))
+                .limit(1);
+            if (existing.length > 0) {
+                await db
+                    .update(narrativeState)
+                    .set({
+                    revision: input.revision,
+                    focus: input.focus,
+                    progressJson: JSON.stringify(input.progress),
+                    nextIntent: input.nextIntent,
+                    confidence: input.confidence,
+                    sourceRefsJson: JSON.stringify(input.sourceRefs),
+                    unsupportedClaimsJson: JSON.stringify(input.unsupportedClaims),
+                    status: input.status,
+                    updatedAt: input.updatedAt,
+                })
+                    .where(eq(narrativeState.narrativeId, input.narrativeId));
+            }
+            else {
+                await db.insert(narrativeState).values({
+                    narrativeId: input.narrativeId,
+                    revision: input.revision,
+                    focus: input.focus,
+                    progressJson: JSON.stringify(input.progress),
+                    nextIntent: input.nextIntent,
+                    confidence: input.confidence,
+                    sourceRefsJson: JSON.stringify(input.sourceRefs),
+                    unsupportedClaimsJson: JSON.stringify(input.unsupportedClaims),
+                    status: input.status,
+                    updatedAt: input.updatedAt,
+                });
+            }
+            return { narrativeId: input.narrativeId, status: "acknowledged" };
+        },
+        async loadNarrativeState(narrativeId) {
+            const id = narrativeId ?? DEFAULT_NARRATIVE_ID;
+            const rows = await db
+                .select()
+                .from(narrativeState)
+                .where(eq(narrativeState.narrativeId, id))
+                .limit(1);
+            if (rows.length === 0)
+                return null;
+            return rowToState(rows[0]);
+        },
+    };
+}

package/runtime/storage/relationship/relationship-memory-store.d.ts

@@ -0,0 +1,42 @@
+import type { StateDatabase } from "../db/index.js";
+export interface SourceRef {
+    sourceId: string;
+    kind: string;
+    url?: string;
+    snippet?: string;
+}
+export interface TopicAffinity {
+    topic: string;
+    affinity: number;
+}
+export interface RelationshipMemory {
+    relationshipId: string;
+    revision: number;
+    tonePreference: "casual" | "direct" | "quiet" | "unknown";
+    averageReplyDelayMinutes?: number;
+    noReplyCount: number;
+    topicAffinities: TopicAffinity[];
+    lastInteractionAt?: string;
+    sourceRefs: SourceRef[];
+    updatedAt: string;
+}
+export interface RelationshipMemoryUpdate {
+    relationshipId: string;
+    revision: number;
+    tonePreference: "casual" | "direct" | "quiet" | "unknown";
+    averageReplyDelayMinutes?: number;
+    noReplyCount: number;
+    topicAffinities: TopicAffinity[];
+    lastInteractionAt?: string;
+    sourceRefs: SourceRef[];
+    updatedAt: string;
+}
+export interface RelationshipMemoryWriteAck {
+    relationshipId: string;
+    status: "acknowledged" | "degraded";
+}
+export interface RelationshipMemoryStore {
+    upsertRelationshipMemory(input: RelationshipMemoryUpdate): Promise<RelationshipMemoryWriteAck>;
+    loadRelationshipMemory(relationshipId?: string): Promise<RelationshipMemory | null>;
+}
+export declare function createRelationshipMemoryStore(database: StateDatabase): RelationshipMemoryStore;

package/runtime/storage/relationship/relationship-memory-store.js

@@ -0,0 +1,76 @@
+import { eq } from "drizzle-orm";
+import { relationshipMemory } from "../db/schema/relationship-memory.js";
+function safeParseJson(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}
+function rowToMemory(row) {
+    return {
+        relationshipId: row.relationshipId,
+        revision: row.revision,
+        tonePreference: row.tonePreference,
+        averageReplyDelayMinutes: row.averageReplyDelayMinutes ?? undefined,
+        noReplyCount: row.noReplyCount,
+        topicAffinities: safeParseJson(row.topicAffinitiesJson, []),
+        lastInteractionAt: row.lastInteractionAt ?? undefined,
+        sourceRefs: safeParseJson(row.sourceRefsJson, []),
+        updatedAt: row.updatedAt,
+    };
+}
+const DEFAULT_RELATIONSHIP_ID = "default";
+export function createRelationshipMemoryStore(database) {
+    const db = database.db;
+    return {
+        async upsertRelationshipMemory(input) {
+            const existing = await db
+                .select()
+                .from(relationshipMemory)
+                .where(eq(relationshipMemory.relationshipId, input.relationshipId))
+                .limit(1);
+            if (existing.length > 0) {
+                await db
+                    .update(relationshipMemory)
+                    .set({
+                    revision: input.revision,
+                    tonePreference: input.tonePreference,
+                    averageReplyDelayMinutes: input.averageReplyDelayMinutes ?? null,
+                    noReplyCount: input.noReplyCount,
+                    topicAffinitiesJson: JSON.stringify(input.topicAffinities),
+                    lastInteractionAt: input.lastInteractionAt ?? null,
+                    sourceRefsJson: JSON.stringify(input.sourceRefs),
+                    updatedAt: input.updatedAt,
+                })
+                    .where(eq(relationshipMemory.relationshipId, input.relationshipId));
+            }
+            else {
+                await db.insert(relationshipMemory).values({
+                    relationshipId: input.relationshipId,
+                    revision: input.revision,
+                    tonePreference: input.tonePreference,
+                    averageReplyDelayMinutes: input.averageReplyDelayMinutes ?? null,
+                    noReplyCount: input.noReplyCount,
+                    topicAffinitiesJson: JSON.stringify(input.topicAffinities),
+                    lastInteractionAt: input.lastInteractionAt ?? null,
+                    sourceRefsJson: JSON.stringify(input.sourceRefs),
+                    updatedAt: input.updatedAt,
+                });
+            }
+            return { relationshipId: input.relationshipId, status: "acknowledged" };
+        },
+        async loadRelationshipMemory(relationshipId) {
+            const id = relationshipId ?? DEFAULT_RELATIONSHIP_ID;
+            const rows = await db
+                .select()
+                .from(relationshipMemory)
+                .where(eq(relationshipMemory.relationshipId, id))
+                .limit(1);
+            if (rows.length === 0)
+                return null;
+            return rowToMemory(rows[0]);
+        },
+    };
+}