forge-openclaw-plugin 0.2.4 → 0.2.10

package/dist/server/repositories/deleted-entities.js

@@ -0,0 +1,226 @@
+import { getDatabase } from "../db.js";
+import { activitySourceSchema, crudEntityTypeSchema, deletedEntityRecordSchema, settingsBinPayloadSchema } from "../types.js";
+function mapDeletedEntity(row) {
+    return deletedEntityRecordSchema.parse({
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        title: row.title,
+        subtitle: row.subtitle,
+        deletedAt: row.deleted_at,
+        deletedByActor: row.deleted_by_actor,
+        deletedSource: row.deleted_source,
+        deleteReason: row.delete_reason,
+        snapshot: JSON.parse(row.snapshot_json)
+    });
+}
+function listDeletedEntityRows(entityType) {
+    if (entityType) {
+        return getDatabase()
+            .prepare(`SELECT entity_type, entity_id, title, subtitle, deleted_at, deleted_by_actor, deleted_source, delete_reason, snapshot_json
+         FROM deleted_entities
+         WHERE entity_type = ?
+         ORDER BY deleted_at DESC`)
+            .all(entityType);
+    }
+    return getDatabase()
+        .prepare(`SELECT entity_type, entity_id, title, subtitle, deleted_at, deleted_by_actor, deleted_source, delete_reason, snapshot_json
+       FROM deleted_entities
+       ORDER BY deleted_at DESC`)
+        .all();
+}
+export function getDeletedEntityRecord(entityType, entityId) {
+    const row = getDatabase()
+        .prepare(`SELECT entity_type, entity_id, title, subtitle, deleted_at, deleted_by_actor, deleted_source, delete_reason, snapshot_json
+       FROM deleted_entities
+       WHERE entity_type = ? AND entity_id = ?`)
+        .get(entityType, entityId);
+    return row ? mapDeletedEntity(row) : undefined;
+}
+export function listDeletedEntities() {
+    return listDeletedEntityRows().map(mapDeletedEntity);
+}
+export function getDeletedEntityIdSet(entityType) {
+    const rows = getDatabase()
+        .prepare(`SELECT entity_id FROM deleted_entities WHERE entity_type = ?`)
+        .all(entityType);
+    return new Set(rows.map((row) => row.entity_id));
+}
+export function isEntityDeleted(entityType, entityId) {
+    const row = getDatabase()
+        .prepare(`SELECT 1
+       FROM deleted_entities
+       WHERE entity_type = ? AND entity_id = ?
+       LIMIT 1`)
+        .get(entityType, entityId);
+    return Boolean(row);
+}
+export function filterDeletedEntities(entityType, items) {
+    if (items.length === 0) {
+        return items;
+    }
+    const deletedIds = getDeletedEntityIdSet(entityType);
+    if (deletedIds.size === 0) {
+        return items;
+    }
+    return items.filter((item) => !deletedIds.has(item.id));
+}
+export function filterDeletedIds(entityType, ids) {
+    if (ids.length === 0) {
+        return ids;
+    }
+    const deletedIds = getDeletedEntityIdSet(entityType);
+    if (deletedIds.size === 0) {
+        return ids;
+    }
+    return ids.filter((id) => !deletedIds.has(id));
+}
+export function upsertDeletedEntityRecord(input) {
+    const entityType = crudEntityTypeSchema.parse(input.entityType);
+    const deletedAt = new Date().toISOString();
+    getDatabase()
+        .prepare(`INSERT INTO deleted_entities (
+        entity_type, entity_id, title, subtitle, deleted_at, deleted_by_actor, deleted_source, delete_reason, snapshot_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(entity_type, entity_id) DO UPDATE SET
+        title = excluded.title,
+        subtitle = excluded.subtitle,
+        deleted_at = excluded.deleted_at,
+        deleted_by_actor = excluded.deleted_by_actor,
+        deleted_source = excluded.deleted_source,
+        delete_reason = excluded.delete_reason,
+        snapshot_json = excluded.snapshot_json`)
+        .run(entityType, input.entityId, input.title, input.subtitle ?? "", deletedAt, input.context.actor ?? null, activitySourceSchema.parse(input.context.source), input.deleteReason ?? "", JSON.stringify(input.snapshot));
+}
+export function restoreDeletedEntityRecord(entityType, entityId) {
+    const existing = getDeletedEntityRecord(entityType, entityId);
+    if (!existing) {
+        return undefined;
+    }
+    getDatabase()
+        .prepare(`DELETE FROM deleted_entities WHERE entity_type = ? AND entity_id = ?`)
+        .run(entityType, entityId);
+    return existing;
+}
+export function clearDeletedEntityRecord(entityType, entityId) {
+    getDatabase()
+        .prepare(`DELETE FROM deleted_entities WHERE entity_type = ? AND entity_id = ?`)
+        .run(entityType, entityId);
+}
+export function cascadeSoftDeleteAnchoredCollaboration(parentEntityType, parentEntityId, context, deleteReason = "") {
+    const noteRows = getDatabase()
+        .prepare(`SELECT DISTINCT
+         notes.id AS id,
+         notes.content_markdown AS content_markdown,
+         notes.content_plain AS content_plain,
+         notes.author AS author,
+         notes.source AS source,
+         notes.created_at AS created_at,
+         notes.updated_at AS updated_at
+       FROM notes
+       INNER JOIN note_links
+         ON note_links.note_id = notes.id
+       LEFT JOIN deleted_entities
+         ON deleted_entities.entity_type = 'note'
+        AND deleted_entities.entity_id = notes.id
+       WHERE note_links.entity_type = ?
+         AND note_links.entity_id = ?
+         AND deleted_entities.entity_id IS NULL`)
+        .all(parentEntityType, parentEntityId);
+    if (noteRows.length > 0) {
+        const placeholders = noteRows.map(() => "?").join(", ");
+        const linkRows = getDatabase()
+            .prepare(`SELECT note_id, entity_type, entity_id, anchor_key
+         FROM note_links
+         WHERE note_id IN (${placeholders})
+         ORDER BY created_at ASC`)
+            .all(...noteRows.map((row) => row.id));
+        const linksByNoteId = new Map();
+        for (const link of linkRows) {
+            const current = linksByNoteId.get(link.note_id) ?? [];
+            current.push({
+                entityType: link.entity_type,
+                entityId: link.entity_id,
+                anchorKey: link.anchor_key.trim().length > 0 ? link.anchor_key : null
+            });
+            linksByNoteId.set(link.note_id, current);
+        }
+        for (const row of noteRows) {
+            const compact = (row.content_plain || row.content_markdown).replace(/\s+/g, " ").trim();
+            upsertDeletedEntityRecord({
+                entityType: "note",
+                entityId: row.id,
+                title: compact.slice(0, 72) || "Note",
+                subtitle: compact.length > 72 ? compact.slice(72, 168).trim() : `Linked to ${parentEntityType.replaceAll("_", " ")}`,
+                snapshot: {
+                    id: row.id,
+                    contentMarkdown: row.content_markdown,
+                    contentPlain: row.content_plain,
+                    author: row.author,
+                    source: row.source,
+                    createdAt: row.created_at,
+                    updatedAt: row.updated_at,
+                    links: linksByNoteId.get(row.id) ?? []
+                },
+                deleteReason,
+                context
+            });
+        }
+    }
+    const insightRows = getDatabase()
+        .prepare(`SELECT id, title, summary, created_at, updated_at
+       FROM insights
+       WHERE entity_type = ? AND entity_id = ?`)
+        .all(parentEntityType, parentEntityId);
+    for (const row of insightRows) {
+        upsertDeletedEntityRecord({
+            entityType: "insight",
+            entityId: row.id,
+            title: row.title,
+            subtitle: row.summary,
+            snapshot: {
+                id: row.id,
+                entityType: parentEntityType,
+                entityId: parentEntityId,
+                title: row.title,
+                summary: row.summary,
+                createdAt: row.created_at,
+                updatedAt: row.updated_at
+            },
+            deleteReason,
+            context
+        });
+    }
+}
+export function restoreAnchoredCollaboration(parentEntityType, parentEntityId) {
+    getDatabase()
+        .prepare(`DELETE FROM deleted_entities
+       WHERE entity_type = 'note'
+         AND entity_id IN (
+           SELECT DISTINCT note_id
+           FROM note_links
+           WHERE entity_type = ? AND entity_id = ?
+         )`)
+        .run(parentEntityType, parentEntityId);
+    getDatabase()
+        .prepare(`DELETE FROM deleted_entities
+       WHERE entity_type = 'insight'
+         AND entity_id IN (
+           SELECT id
+           FROM insights
+           WHERE entity_type = ? AND entity_id = ?
+         )`)
+        .run(parentEntityType, parentEntityId);
+}
+export function buildSettingsBinPayload() {
+    const items = listDeletedEntities();
+    const counts = items.reduce((acc, item) => {
+        acc[item.entityType] = (acc[item.entityType] ?? 0) + 1;
+        return acc;
+    }, {});
+    return settingsBinPayloadSchema.parse({
+        generatedAt: new Date().toISOString(),
+        totalCount: items.length,
+        countsByEntityType: counts,
+        records: items
+    });
+}

package/dist/server/repositories/domains.js

@@ -0,0 +1,30 @@
+import { getDatabase } from "../db.js";
+import { domainSchema } from "../psyche-types.js";
+function mapDomain(row) {
+    return domainSchema.parse({
+        id: row.id,
+        slug: row.slug,
+        title: row.title,
+        description: row.description,
+        themeColor: row.theme_color,
+        sensitive: row.sensitive === 1,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+    });
+}
+export function listDomains() {
+    const rows = getDatabase()
+        .prepare(`SELECT id, slug, title, description, theme_color, sensitive, created_at, updated_at
+       FROM domains
+       ORDER BY sensitive DESC, title`)
+        .all();
+    return rows.map(mapDomain);
+}
+export function getDomainBySlug(slug) {
+    const row = getDatabase()
+        .prepare(`SELECT id, slug, title, description, theme_color, sensitive, created_at, updated_at
+       FROM domains
+       WHERE slug = ?`)
+        .get(slug);
+    return row ? mapDomain(row) : undefined;
+}

package/dist/server/repositories/event-log.js

@@ -0,0 +1,64 @@
+import { randomUUID } from "node:crypto";
+import { getDatabase } from "../db.js";
+import { eventLogEntrySchema } from "../types.js";
+function mapEvent(row) {
+    return eventLogEntrySchema.parse({
+        id: row.id,
+        eventKind: row.event_kind,
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        actor: row.actor,
+        source: row.source,
+        causedByEventId: row.caused_by_event_id,
+        metadata: JSON.parse(row.metadata_json),
+        createdAt: row.created_at
+    });
+}
+export function recordEventLog(input, now = new Date()) {
+    const event = eventLogEntrySchema.parse({
+        id: `log_${randomUUID().replaceAll("-", "").slice(0, 10)}`,
+        eventKind: input.eventKind,
+        entityType: input.entityType,
+        entityId: input.entityId,
+        actor: input.actor ?? null,
+        source: input.source,
+        causedByEventId: input.causedByEventId ?? null,
+        metadata: input.metadata ?? {},
+        createdAt: now.toISOString()
+    });
+    getDatabase()
+        .prepare(`INSERT INTO event_log (
+        id, event_kind, entity_type, entity_id, actor, source, caused_by_event_id, metadata_json, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(event.id, event.eventKind, event.entityType, event.entityId, event.actor, event.source, event.causedByEventId, JSON.stringify(event.metadata), event.createdAt);
+    return event;
+}
+export function listEventLog(filters = {}) {
+    const whereClauses = [];
+    const params = [];
+    if (filters.entityType) {
+        whereClauses.push("entity_type = ?");
+        params.push(filters.entityType);
+    }
+    if (filters.entityId) {
+        whereClauses.push("entity_id = ?");
+        params.push(filters.entityId);
+    }
+    if (filters.eventKind) {
+        whereClauses.push("event_kind = ?");
+        params.push(filters.eventKind);
+    }
+    const whereSql = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+    const limitSql = filters.limit ? "LIMIT ?" : "";
+    if (filters.limit) {
+        params.push(filters.limit);
+    }
+    const rows = getDatabase()
+        .prepare(`SELECT id, event_kind, entity_type, entity_id, actor, source, caused_by_event_id, metadata_json, created_at
+       FROM event_log
+       ${whereSql}
+       ORDER BY created_at DESC
+       ${limitSql}`)
+        .all(...params);
+    return rows.map(mapEvent);
+}

package/dist/server/repositories/goals.js

@@ -0,0 +1,156 @@
+import { randomUUID } from "node:crypto";
+import { getDatabase, runInTransaction } from "../db.js";
+import { recordActivityEvent } from "./activity-events.js";
+import { filterDeletedEntities, filterDeletedIds, isEntityDeleted } from "./deleted-entities.js";
+import { createLinkedNotes } from "./notes.js";
+import { assertGoalRelations } from "../services/relations.js";
+import { pruneLinkedEntityReferences } from "./psyche.js";
+import { goalSchema } from "../types.js";
+function readGoalTagIds(goalId) {
+    const rows = getDatabase()
+        .prepare(`SELECT tag_id FROM goal_tags WHERE goal_id = ? ORDER BY tag_id`)
+        .all(goalId);
+    return filterDeletedIds("tag", rows.map((row) => row.tag_id));
+}
+function mapGoal(row) {
+    return goalSchema.parse({
+        id: row.id,
+        title: row.title,
+        description: row.description,
+        horizon: row.horizon,
+        status: row.status,
+        targetPoints: row.target_points,
+        themeColor: row.theme_color,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        tagIds: readGoalTagIds(row.id)
+    });
+}
+function replaceGoalTags(goalId, tagIds) {
+    const database = getDatabase();
+    database.prepare(`DELETE FROM goal_tags WHERE goal_id = ?`).run(goalId);
+    const insert = database.prepare(`INSERT INTO goal_tags (goal_id, tag_id) VALUES (?, ?)`);
+    for (const tagId of tagIds) {
+        insert.run(goalId, tagId);
+    }
+}
+export function listGoals() {
+    const rows = getDatabase()
+        .prepare(`SELECT id, title, description, horizon, status, target_points, theme_color, created_at, updated_at
+       FROM goals
+       ORDER BY created_at`)
+        .all();
+    return filterDeletedEntities("goal", rows.map(mapGoal));
+}
+export function createGoal(input, activity) {
+    return runInTransaction(() => {
+        assertGoalRelations(input);
+        const now = new Date().toISOString();
+        const id = `goal_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
+        getDatabase()
+            .prepare(`INSERT INTO goals (id, title, description, horizon, status, target_points, theme_color, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(id, input.title, input.description, input.horizon, input.status, input.targetPoints, input.themeColor, now, now);
+        replaceGoalTags(id, input.tagIds);
+        const goal = getGoalById(id);
+        createLinkedNotes(input.notes, { entityType: "goal", entityId: goal.id, anchorKey: null }, activity ?? { source: "ui", actor: null });
+        if (activity) {
+            recordActivityEvent({
+                entityType: "goal",
+                entityId: goal.id,
+                eventType: "goal_created",
+                title: `Goal created: ${goal.title}`,
+                description: `Target set to ${goal.targetPoints} points.`,
+                actor: activity.actor ?? null,
+                source: activity.source,
+                metadata: {
+                    horizon: goal.horizon,
+                    status: goal.status,
+                    targetPoints: goal.targetPoints
+                }
+            });
+        }
+        return goal;
+    });
+}
+export function updateGoal(goalId, input, activity) {
+    const current = getGoalById(goalId);
+    if (!current) {
+        return undefined;
+    }
+    return runInTransaction(() => {
+        const next = {
+            ...current,
+            ...input,
+            updatedAt: new Date().toISOString(),
+            tagIds: input.tagIds ?? current.tagIds
+        };
+        assertGoalRelations(next);
+        getDatabase()
+            .prepare(`UPDATE goals
+         SET title = ?, description = ?, horizon = ?, status = ?, target_points = ?, theme_color = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(next.title, next.description, next.horizon, next.status, next.targetPoints, next.themeColor, next.updatedAt, goalId);
+        replaceGoalTags(goalId, next.tagIds);
+        const goal = getGoalById(goalId);
+        if (goal && activity) {
+            const statusChanged = current.status !== goal.status;
+            recordActivityEvent({
+                entityType: "goal",
+                entityId: goal.id,
+                eventType: statusChanged ? "goal_status_changed" : "goal_updated",
+                title: statusChanged ? `Goal ${goal.status}: ${goal.title}` : `Goal updated: ${goal.title}`,
+                description: statusChanged ? `Goal status moved from ${current.status} to ${goal.status}.` : "Goal details were edited.",
+                actor: activity.actor ?? null,
+                source: activity.source,
+                metadata: {
+                    previousStatus: current.status,
+                    status: goal.status,
+                    targetPoints: goal.targetPoints,
+                    previousTargetPoints: current.targetPoints
+                }
+            });
+        }
+        return goal;
+    });
+}
+export function getGoalById(goalId) {
+    if (isEntityDeleted("goal", goalId)) {
+        return undefined;
+    }
+    const row = getDatabase()
+        .prepare(`SELECT id, title, description, horizon, status, target_points, theme_color, created_at, updated_at
+       FROM goals
+       WHERE id = ?`)
+        .get(goalId);
+    return row ? mapGoal(row) : undefined;
+}
+export function deleteGoal(goalId, activity) {
+    const current = getGoalById(goalId);
+    if (!current) {
+        return undefined;
+    }
+    return runInTransaction(() => {
+        pruneLinkedEntityReferences("goal", goalId);
+        getDatabase()
+            .prepare(`DELETE FROM goals WHERE id = ?`)
+            .run(goalId);
+        if (activity) {
+            recordActivityEvent({
+                entityType: "goal",
+                entityId: current.id,
+                eventType: "goal_deleted",
+                title: `Goal deleted: ${current.title}`,
+                description: "Goal removed from the system.",
+                actor: activity.actor ?? null,
+                source: activity.source,
+                metadata: {
+                    horizon: current.horizon,
+                    status: current.status,
+                    targetPoints: current.targetPoints
+                }
+            });
+        }
+        return current;
+    });
+}