forge-openclaw-plugin 0.2.3 → 0.2.7

package/dist/server/psyche-types.js

@@ -0,0 +1,395 @@
+import { z } from "zod";
+const trimmedString = z.string().trim();
+const nonEmptyTrimmedString = trimmedString.min(1);
+const uniqueStringArraySchema = z.array(nonEmptyTrimmedString);
+export const triggerReportStatusSchema = z.enum(["draft", "reviewed", "integrated"]);
+export const commentSourceSchema = z.enum(["ui", "openclaw", "agent", "system"]);
+export const behaviorKindSchema = z.enum(["away", "committed", "recovery"]);
+export const beliefTypeSchema = z.enum(["absolute", "conditional"]);
+export const modeFamilySchema = z.enum(["coping", "child", "critic_parent", "healthy_adult", "happy_child"]);
+export const schemaTypeSchema = z.enum(["maladaptive", "adaptive"]);
+export const PSYCHE_ENTITY_TYPES = [
+    "psyche_value",
+    "behavior_pattern",
+    "behavior",
+    "belief_entry",
+    "mode_profile",
+    "trigger_report"
+];
+export const domainSchema = z.object({
+    id: z.string(),
+    slug: nonEmptyTrimmedString,
+    title: nonEmptyTrimmedString,
+    description: trimmedString,
+    themeColor: z.string(),
+    sensitive: z.boolean(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const schemaCatalogEntrySchema = z.object({
+    id: z.string(),
+    slug: nonEmptyTrimmedString,
+    title: nonEmptyTrimmedString,
+    family: nonEmptyTrimmedString,
+    schemaType: schemaTypeSchema,
+    description: trimmedString,
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const eventTypeSchema = z.object({
+    id: z.string(),
+    domainId: z.string(),
+    label: nonEmptyTrimmedString,
+    description: trimmedString,
+    system: z.boolean(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const emotionDefinitionSchema = z.object({
+    id: z.string(),
+    domainId: z.string(),
+    label: nonEmptyTrimmedString,
+    description: trimmedString,
+    category: trimmedString,
+    system: z.boolean(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const psycheValueSchema = z.object({
+    id: z.string(),
+    domainId: z.string(),
+    title: nonEmptyTrimmedString,
+    description: trimmedString,
+    valuedDirection: trimmedString,
+    whyItMatters: trimmedString,
+    linkedGoalIds: uniqueStringArraySchema.default([]),
+    linkedProjectIds: uniqueStringArraySchema.default([]),
+    linkedTaskIds: uniqueStringArraySchema.default([]),
+    committedActions: z.array(trimmedString).default([]),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const behaviorPatternSchema = z.object({
+    id: z.string(),
+    domainId: z.string(),
+    title: nonEmptyTrimmedString,
+    description: trimmedString,
+    targetBehavior: trimmedString,
+    cueContexts: z.array(trimmedString).default([]),
+    shortTermPayoff: trimmedString,
+    longTermCost: trimmedString,
+    preferredResponse: trimmedString,
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    linkedSchemaLabels: z.array(trimmedString).default([]),
+    linkedModeLabels: z.array(trimmedString).default([]),
+    linkedModeIds: uniqueStringArraySchema.default([]),
+    linkedBeliefIds: uniqueStringArraySchema.default([]),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const behaviorSchema = z.object({
+    id: z.string(),
+    domainId: z.string(),
+    kind: behaviorKindSchema,
+    title: nonEmptyTrimmedString,
+    description: trimmedString,
+    commonCues: z.array(trimmedString).default([]),
+    urgeStory: trimmedString,
+    shortTermPayoff: trimmedString,
+    longTermCost: trimmedString,
+    replacementMove: trimmedString,
+    repairPlan: trimmedString,
+    linkedPatternIds: uniqueStringArraySchema.default([]),
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    linkedSchemaIds: uniqueStringArraySchema.default([]),
+    linkedModeIds: uniqueStringArraySchema.default([]),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const beliefEntrySchema = z.object({
+    id: z.string(),
+    domainId: z.string(),
+    schemaId: z.string().nullable(),
+    statement: nonEmptyTrimmedString,
+    beliefType: beliefTypeSchema,
+    originNote: trimmedString,
+    confidence: z.number().int().min(0).max(100),
+    evidenceFor: z.array(trimmedString).default([]),
+    evidenceAgainst: z.array(trimmedString).default([]),
+    flexibleAlternative: trimmedString,
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorIds: uniqueStringArraySchema.default([]),
+    linkedModeIds: uniqueStringArraySchema.default([]),
+    linkedReportIds: uniqueStringArraySchema.default([]),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const modeProfileSchema = z.object({
+    id: z.string(),
+    domainId: z.string(),
+    family: modeFamilySchema,
+    archetype: trimmedString,
+    title: nonEmptyTrimmedString,
+    persona: trimmedString,
+    imagery: trimmedString,
+    symbolicForm: trimmedString,
+    facialExpression: trimmedString,
+    fear: trimmedString,
+    burden: trimmedString,
+    protectiveJob: trimmedString,
+    originContext: trimmedString,
+    firstAppearanceAt: z.string().nullable(),
+    linkedPatternIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorIds: uniqueStringArraySchema.default([]),
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const modeTimelineEntrySchema = z.object({
+    id: z.string(),
+    stage: nonEmptyTrimmedString,
+    modeId: z.string().nullable(),
+    label: nonEmptyTrimmedString,
+    note: trimmedString.default("")
+});
+export const modeGuideAnswerSchema = z.object({
+    questionKey: nonEmptyTrimmedString,
+    value: nonEmptyTrimmedString
+});
+export const modeGuideResultSchema = z.object({
+    family: modeFamilySchema,
+    archetype: trimmedString,
+    label: nonEmptyTrimmedString,
+    confidence: z.number().min(0).max(1),
+    reasoning: trimmedString
+});
+export const modeGuideSessionSchema = z.object({
+    id: z.string(),
+    summary: nonEmptyTrimmedString,
+    answers: z.array(modeGuideAnswerSchema),
+    results: z.array(modeGuideResultSchema),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const triggerEmotionSchema = z.object({
+    id: z.string(),
+    emotionDefinitionId: z.string().nullable().default(null),
+    label: nonEmptyTrimmedString,
+    intensity: z.number().int().min(0).max(100),
+    note: trimmedString.default("")
+});
+export const triggerThoughtSchema = z.object({
+    id: z.string(),
+    text: nonEmptyTrimmedString,
+    parentMode: trimmedString.default(""),
+    criticMode: trimmedString.default(""),
+    beliefId: z.string().nullable().default(null)
+});
+export const triggerBehaviorSchema = z.object({
+    id: z.string(),
+    text: nonEmptyTrimmedString,
+    mode: trimmedString.default(""),
+    behaviorId: z.string().nullable().default(null)
+});
+export const triggerConsequencesSchema = z.object({
+    selfShortTerm: z.array(trimmedString).default([]),
+    selfLongTerm: z.array(trimmedString).default([]),
+    othersShortTerm: z.array(trimmedString).default([]),
+    othersLongTerm: z.array(trimmedString).default([])
+});
+export const triggerReportSchema = z.object({
+    id: z.string(),
+    domainId: z.string(),
+    title: nonEmptyTrimmedString,
+    status: triggerReportStatusSchema,
+    eventTypeId: z.string().nullable(),
+    customEventType: trimmedString,
+    eventSituation: trimmedString,
+    occurredAt: z.string().nullable(),
+    emotions: z.array(triggerEmotionSchema).default([]),
+    thoughts: z.array(triggerThoughtSchema).default([]),
+    behaviors: z.array(triggerBehaviorSchema).default([]),
+    consequences: triggerConsequencesSchema,
+    linkedPatternIds: uniqueStringArraySchema.default([]),
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    linkedGoalIds: uniqueStringArraySchema.default([]),
+    linkedProjectIds: uniqueStringArraySchema.default([]),
+    linkedTaskIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorIds: uniqueStringArraySchema.default([]),
+    linkedBeliefIds: uniqueStringArraySchema.default([]),
+    linkedModeIds: uniqueStringArraySchema.default([]),
+    modeOverlays: z.array(trimmedString).default([]),
+    schemaLinks: z.array(trimmedString).default([]),
+    modeTimeline: z.array(modeTimelineEntrySchema).default([]),
+    nextMoves: z.array(trimmedString).default([]),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const commentSchema = z.object({
+    id: z.string(),
+    entityType: nonEmptyTrimmedString,
+    entityId: nonEmptyTrimmedString,
+    anchorKey: trimmedString.nullable(),
+    body: nonEmptyTrimmedString,
+    author: trimmedString.nullable(),
+    source: commentSourceSchema,
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const schemaPressureEntrySchema = z.object({
+    schemaId: z.string(),
+    title: nonEmptyTrimmedString,
+    activationCount: z.number().int().nonnegative()
+});
+export const psycheOverviewPayloadSchema = z.object({
+    generatedAt: z.string(),
+    domain: domainSchema,
+    values: z.array(psycheValueSchema),
+    patterns: z.array(behaviorPatternSchema),
+    behaviors: z.array(behaviorSchema),
+    beliefs: z.array(beliefEntrySchema),
+    modes: z.array(modeProfileSchema),
+    reports: z.array(triggerReportSchema),
+    schemaPressure: z.array(schemaPressureEntrySchema),
+    openInsights: z.number().int().nonnegative(),
+    unresolvedComments: z.number().int().nonnegative(),
+    committedActions: z.array(trimmedString)
+});
+export const createPsycheValueSchema = z.object({
+    title: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    valuedDirection: trimmedString.default(""),
+    whyItMatters: trimmedString.default(""),
+    linkedGoalIds: uniqueStringArraySchema.default([]),
+    linkedProjectIds: uniqueStringArraySchema.default([]),
+    linkedTaskIds: uniqueStringArraySchema.default([]),
+    committedActions: z.array(trimmedString).default([])
+});
+export const updatePsycheValueSchema = createPsycheValueSchema.partial();
+export const createBehaviorPatternSchema = z.object({
+    title: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    targetBehavior: trimmedString.default(""),
+    cueContexts: z.array(trimmedString).default([]),
+    shortTermPayoff: trimmedString.default(""),
+    longTermCost: trimmedString.default(""),
+    preferredResponse: trimmedString.default(""),
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    linkedSchemaLabels: z.array(trimmedString).default([]),
+    linkedModeLabels: z.array(trimmedString).default([]),
+    linkedModeIds: uniqueStringArraySchema.default([]),
+    linkedBeliefIds: uniqueStringArraySchema.default([])
+});
+export const updateBehaviorPatternSchema = createBehaviorPatternSchema.partial();
+export const createBehaviorSchema = z.object({
+    kind: behaviorKindSchema,
+    title: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    commonCues: z.array(trimmedString).default([]),
+    urgeStory: trimmedString.default(""),
+    shortTermPayoff: trimmedString.default(""),
+    longTermCost: trimmedString.default(""),
+    replacementMove: trimmedString.default(""),
+    repairPlan: trimmedString.default(""),
+    linkedPatternIds: uniqueStringArraySchema.default([]),
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    linkedSchemaIds: uniqueStringArraySchema.default([]),
+    linkedModeIds: uniqueStringArraySchema.default([])
+});
+export const updateBehaviorSchema = createBehaviorSchema.partial();
+export const createBeliefEntrySchema = z.object({
+    schemaId: z.string().nullable().default(null),
+    statement: nonEmptyTrimmedString,
+    beliefType: beliefTypeSchema,
+    originNote: trimmedString.default(""),
+    confidence: z.number().int().min(0).max(100).default(60),
+    evidenceFor: z.array(trimmedString).default([]),
+    evidenceAgainst: z.array(trimmedString).default([]),
+    flexibleAlternative: trimmedString.default(""),
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorIds: uniqueStringArraySchema.default([]),
+    linkedModeIds: uniqueStringArraySchema.default([]),
+    linkedReportIds: uniqueStringArraySchema.default([])
+});
+export const updateBeliefEntrySchema = createBeliefEntrySchema.partial();
+export const createModeProfileSchema = z.object({
+    family: modeFamilySchema,
+    archetype: trimmedString.default(""),
+    title: nonEmptyTrimmedString,
+    persona: trimmedString.default(""),
+    imagery: trimmedString.default(""),
+    symbolicForm: trimmedString.default(""),
+    facialExpression: trimmedString.default(""),
+    fear: trimmedString.default(""),
+    burden: trimmedString.default(""),
+    protectiveJob: trimmedString.default(""),
+    originContext: trimmedString.default(""),
+    firstAppearanceAt: trimmedString.nullable().default(null),
+    linkedPatternIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorIds: uniqueStringArraySchema.default([]),
+    linkedValueIds: uniqueStringArraySchema.default([])
+});
+export const updateModeProfileSchema = createModeProfileSchema.partial();
+export const createModeGuideSessionSchema = z.object({
+    summary: nonEmptyTrimmedString,
+    answers: z.array(modeGuideAnswerSchema).min(1)
+});
+export const updateModeGuideSessionSchema = createModeGuideSessionSchema.partial();
+export const createEventTypeSchema = z.object({
+    label: nonEmptyTrimmedString,
+    description: trimmedString.default("")
+});
+export const updateEventTypeSchema = createEventTypeSchema.partial();
+export const createEmotionDefinitionSchema = z.object({
+    label: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    category: trimmedString.default("")
+});
+export const updateEmotionDefinitionSchema = createEmotionDefinitionSchema.partial();
+export const createTriggerReportSchema = z.object({
+    title: nonEmptyTrimmedString,
+    status: triggerReportStatusSchema.default("draft"),
+    eventTypeId: z.string().nullable().default(null),
+    customEventType: trimmedString.default(""),
+    eventSituation: trimmedString.default(""),
+    occurredAt: trimmedString.nullable().default(null),
+    emotions: z.array(triggerEmotionSchema.omit({ id: true }).extend({ id: z.string().optional() })).default([]),
+    thoughts: z.array(triggerThoughtSchema.omit({ id: true }).extend({ id: z.string().optional() })).default([]),
+    behaviors: z.array(triggerBehaviorSchema.omit({ id: true }).extend({ id: z.string().optional() })).default([]),
+    consequences: triggerConsequencesSchema.default({
+        selfShortTerm: [],
+        selfLongTerm: [],
+        othersShortTerm: [],
+        othersLongTerm: []
+    }),
+    linkedPatternIds: uniqueStringArraySchema.default([]),
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    linkedGoalIds: uniqueStringArraySchema.default([]),
+    linkedProjectIds: uniqueStringArraySchema.default([]),
+    linkedTaskIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorIds: uniqueStringArraySchema.default([]),
+    linkedBeliefIds: uniqueStringArraySchema.default([]),
+    linkedModeIds: uniqueStringArraySchema.default([]),
+    modeOverlays: z.array(trimmedString).default([]),
+    schemaLinks: z.array(trimmedString).default([]),
+    modeTimeline: z.array(modeTimelineEntrySchema.omit({ id: true }).extend({ id: z.string().optional() })).default([]),
+    nextMoves: z.array(trimmedString).default([])
+});
+export const updateTriggerReportSchema = createTriggerReportSchema.partial();
+export const createCommentSchema = z.object({
+    entityType: nonEmptyTrimmedString,
+    entityId: nonEmptyTrimmedString,
+    anchorKey: trimmedString.nullable().default(null),
+    body: nonEmptyTrimmedString,
+    author: trimmedString.nullable().default(null)
+});
+export const updateCommentSchema = z.object({
+    body: nonEmptyTrimmedString,
+    author: trimmedString.nullable().default(null)
+});
+export const commentsListQuerySchema = z.object({
+    entityType: nonEmptyTrimmedString.optional(),
+    entityId: nonEmptyTrimmedString.optional(),
+    limit: z.coerce.number().int().positive().max(200).optional()
+});
+export const commentListQuerySchema = commentsListQuerySchema;

package/dist/server/repositories/activity-events.js

@@ -0,0 +1,157 @@
+import { randomUUID } from "node:crypto";
+import { getDatabase, runInTransaction } from "../db.js";
+import { recordEventLog } from "./event-log.js";
+import { activityEventSchema } from "../types.js";
+function mapActivityEvent(row) {
+    return activityEventSchema.parse({
+        id: row.id,
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        eventType: row.event_type,
+        title: row.title,
+        description: row.description,
+        actor: row.actor,
+        source: row.source,
+        metadata: JSON.parse(row.metadata_json),
+        createdAt: row.created_at
+    });
+}
+export function recordActivityEvent(input, now = new Date()) {
+    const id = `evt_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
+    const createdAt = now.toISOString();
+    const event = activityEventSchema.parse({
+        id,
+        entityType: input.entityType,
+        entityId: input.entityId,
+        eventType: input.eventType,
+        title: input.title,
+        description: input.description ?? "",
+        actor: input.actor ?? null,
+        source: input.source,
+        metadata: input.metadata ?? {},
+        createdAt
+    });
+    getDatabase()
+        .prepare(`INSERT INTO activity_events (
+        id, entity_type, entity_id, event_type, title, description, actor, source, metadata_json, created_at
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(event.id, event.entityType, event.entityId, event.eventType, event.title, event.description, event.actor, event.source, JSON.stringify(event.metadata), event.createdAt);
+    recordEventLog({
+        eventKind: `activity.${event.eventType}`,
+        entityType: event.entityType,
+        entityId: event.entityId,
+        actor: event.actor,
+        source: event.source,
+        metadata: {
+            activityEventId: event.id,
+            title: event.title
+        }
+    }, now);
+    return event;
+}
+export function listActivityEvents(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.source) {
+        whereClauses.push("source = ?");
+        params.push(filters.source);
+    }
+    if (!filters.includeCorrected) {
+        whereClauses.push("event_type != 'activity_corrected'");
+        whereClauses.push("NOT EXISTS (SELECT 1 FROM activity_event_corrections WHERE activity_event_corrections.corrected_event_id = activity_events.id)");
+    }
+    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, entity_type, entity_id, event_type, title, description, actor, source, metadata_json, created_at
+       FROM activity_events
+       ${whereSql}
+       ORDER BY created_at DESC
+       ${limitSql}`)
+        .all(...params);
+    return rows.map(mapActivityEvent);
+}
+export function listActivityEventsForTask(taskId, limit = 25) {
+    const rows = getDatabase()
+        .prepare(`SELECT
+         activity_events.id,
+         activity_events.entity_type,
+         activity_events.entity_id,
+         activity_events.event_type,
+         activity_events.title,
+         activity_events.description,
+         activity_events.actor,
+         activity_events.source,
+         activity_events.metadata_json,
+         activity_events.created_at
+       FROM activity_events
+       LEFT JOIN task_runs
+         ON activity_events.entity_type = 'task_run'
+        AND task_runs.id = activity_events.entity_id
+       WHERE (
+            (activity_events.entity_type = 'task' AND activity_events.entity_id = ?)
+         OR (activity_events.entity_type = 'task_run' AND task_runs.task_id = ?)
+       )
+         AND activity_events.event_type != 'activity_corrected'
+         AND NOT EXISTS (
+           SELECT 1
+           FROM activity_event_corrections
+           WHERE activity_event_corrections.corrected_event_id = activity_events.id
+         )
+       ORDER BY activity_events.created_at DESC
+       LIMIT ?`)
+        .all(taskId, taskId, limit);
+    return rows.map(mapActivityEvent);
+}
+export function getActivityEventById(eventId) {
+    const row = getDatabase()
+        .prepare(`SELECT id, entity_type, entity_id, event_type, title, description, actor, source, metadata_json, created_at
+       FROM activity_events
+       WHERE id = ?`)
+        .get(eventId);
+    return row ? mapActivityEvent(row) : undefined;
+}
+export function removeActivityEvent(eventId, input, activity) {
+    const original = getActivityEventById(eventId);
+    if (!original || original.eventType === "activity_corrected") {
+        return undefined;
+    }
+    return runInTransaction(() => {
+        const existingCorrection = getDatabase()
+            .prepare(`SELECT correcting_event_id FROM activity_event_corrections WHERE corrected_event_id = ?`)
+            .get(eventId);
+        if (existingCorrection) {
+            return getActivityEventById(existingCorrection.correcting_event_id);
+        }
+        const correction = recordActivityEvent({
+            entityType: "system",
+            entityId: original.id,
+            eventType: "activity_corrected",
+            title: `Log removed: ${original.title}`,
+            description: input.reason,
+            actor: activity.actor ?? null,
+            source: activity.source,
+            metadata: {
+                correctedEventId: original.id,
+                correctedEntityType: original.entityType,
+                correctedEntityId: original.entityId
+            }
+        });
+        getDatabase()
+            .prepare(`INSERT INTO activity_event_corrections (corrected_event_id, correcting_event_id, created_at)
+         VALUES (?, ?, ?)`)
+            .run(original.id, correction.id, correction.createdAt);
+        return correction;
+    });
+}