forge-openclaw-plugin 0.2.25 → 0.2.27

package/dist/server/src/lib/calendar-name-deduper.js

@@ -0,0 +1,144 @@
+function normalizeNameKey(value) {
+    return value.trim().replace(/\s+/g, " ").toLocaleLowerCase();
+}
+function cleanLabel(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function readBaseCalendarName(value) {
+    return cleanLabel(value) ?? "Unnamed calendar";
+}
+function shortCalendarProviderLabel(provider) {
+    switch (provider) {
+        case "google":
+            return "Google";
+        case "apple":
+            return "Apple";
+        case "microsoft":
+            return "Microsoft";
+        case "caldav":
+        default:
+            return "CalDAV";
+    }
+}
+function readUrlQualifier(value) {
+    const trimmed = cleanLabel(value);
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const url = new URL(trimmed);
+        const segments = url.pathname
+            .split("/")
+            .map((segment) => segment.trim())
+            .filter(Boolean);
+        const lastSegment = segments.at(-1);
+        if (lastSegment) {
+            return `${url.host}/${decodeURIComponent(lastSegment)}`;
+        }
+        return url.host;
+    }
+    catch {
+        return trimmed;
+    }
+}
+function joinQualifier(parts) {
+    const cleaned = parts
+        .map(cleanLabel)
+        .filter((part) => Boolean(part));
+    return cleaned.length > 0 ? cleaned.join(" · ") : null;
+}
+function selectUniqueQualifier(group) {
+    const selectors = [
+        (entry) => entry.providerLabel,
+        (entry) => joinQualifier([entry.providerLabel, entry.accountLabel]),
+        (entry) => joinQualifier([entry.providerLabel, entry.connectionLabel]),
+        (entry) => entry.connectionLabel,
+        (entry) => entry.accountLabel,
+        (entry) => readUrlQualifier(entry.url),
+        (entry) => entry.url
+    ];
+    for (const select of selectors) {
+        const qualifiers = group.map(select);
+        if (qualifiers.some((qualifier) => !cleanLabel(qualifier))) {
+            continue;
+        }
+        const normalized = qualifiers.map((qualifier) => normalizeNameKey(qualifier));
+        if (new Set(normalized).size === group.length) {
+            return qualifiers;
+        }
+    }
+    return group.map((entry, index) => joinQualifier([entry.providerLabel, `${index + 1}`]) ?? `${index + 1}`);
+}
+function buildDedupedNameMap(entries) {
+    const deduped = new Map();
+    const groups = new Map();
+    for (const entry of entries) {
+        const key = normalizeNameKey(entry.baseName);
+        const bucket = groups.get(key) ?? [];
+        bucket.push(entry);
+        groups.set(key, bucket);
+    }
+    for (const group of groups.values()) {
+        if (group.length === 1) {
+            deduped.set(group[0].id, group[0].baseName);
+            continue;
+        }
+        const qualifiers = selectUniqueQualifier(group);
+        group.forEach((entry, index) => {
+            deduped.set(entry.id, `${entry.baseName} (${qualifiers[index]})`);
+        });
+    }
+    return deduped;
+}
+export function dedupeCalendarDiscoveryPayload(payload) {
+    const dedupedNames = buildDedupedNameMap(payload.calendars.map((calendar) => ({
+        id: calendar.url,
+        baseName: readBaseCalendarName(calendar.displayName),
+        providerLabel: shortCalendarProviderLabel(payload.provider),
+        connectionLabel: null,
+        accountLabel: payload.accountLabel,
+        url: calendar.url
+    })));
+    return {
+        ...payload,
+        calendars: payload.calendars.map((calendar) => ({
+            ...calendar,
+            dedupedName: dedupedNames.get(calendar.url) ??
+                readBaseCalendarName(calendar.displayName)
+        }))
+    };
+}
+export function dedupeCalendarResourcesWithConnections(calendars, connections) {
+    const connectionsById = new Map(connections.map((connection) => [connection.id, connection]));
+    const dedupedNames = buildDedupedNameMap(calendars.map((calendar) => {
+        const connection = connectionsById.get(calendar.connectionId);
+        return {
+            id: calendar.id,
+            baseName: readBaseCalendarName(calendar.title),
+            providerLabel: connection
+                ? shortCalendarProviderLabel(connection.provider)
+                : null,
+            connectionLabel: connection?.label ?? null,
+            accountLabel: connection?.accountLabel ?? null,
+            url: calendar.remoteId
+        };
+    }));
+    return calendars.map((calendar) => ({
+        ...calendar,
+        dedupedName: dedupedNames.get(calendar.id) ?? readBaseCalendarName(calendar.title)
+    }));
+}
+export function dedupeCalendarOverviewPayload(payload) {
+    return {
+        ...payload,
+        calendars: dedupeCalendarResourcesWithConnections(payload.calendars, payload.connections)
+    };
+}
+export function readCalendarDisplayName(calendar) {
+    if ("title" in calendar) {
+        return (cleanLabel(calendar.dedupedName) ?? readBaseCalendarName(calendar.title));
+    }
+    return (cleanLabel(calendar.dedupedName) ??
+        readBaseCalendarName(calendar.displayName));
+}

package/dist/server/src/lib/data-management-types.js

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

package/dist/server/src/lib/diagnostics.js

@@ -0,0 +1,67 @@
+import { resolveForgePath } from "./runtime-paths.js";
+function sanitizeValue(value, depth = 0) {
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "number" ||
+        typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack ?? null
+        };
+    }
+    if (Array.isArray(value)) {
+        if (depth >= 3) {
+            return `[Array(${value.length})]`;
+        }
+        return value.slice(0, 20).map((entry) => sanitizeValue(entry, depth + 1));
+    }
+    if (value && typeof value === "object") {
+        if (depth >= 3) {
+            return "[Object]";
+        }
+        return Object.fromEntries(Object.entries(value)
+            .slice(0, 30)
+            .map(([key, entry]) => [key, sanitizeValue(entry, depth + 1)]));
+    }
+    return String(value);
+}
+function sanitizeDetails(details) {
+    if (!details) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(details).map(([key, value]) => [key, sanitizeValue(value)]));
+}
+export async function publishUiDiagnosticLog(input) {
+    try {
+        await fetch(resolveForgePath("/api/v1/diagnostics/logs"), {
+            method: "POST",
+            credentials: "same-origin",
+            keepalive: true,
+            headers: {
+                "content-type": "application/json",
+                "x-forge-source": "ui"
+            },
+            body: JSON.stringify({
+                ...input,
+                source: input.source ?? "ui",
+                details: sanitizeDetails(input.details)
+            })
+        });
+    }
+    catch {
+        // Diagnostics should never break the user flow.
+    }
+}
+export function createUiDiagnosticLogger(defaults) {
+    return (input) => publishUiDiagnosticLog({
+        ...defaults,
+        ...input
+    });
+}

package/dist/server/src/lib/entity-visuals.js

@@ -0,0 +1,279 @@
+import { Bot, CalendarDays, Compass, FileText, FolderOpen, GitBranch, Heart, ListTodo, Network, NotebookPen, PanelTop, Quote, RefreshCw, Repeat, Route, Shapes, Sparkles, StickyNote, Target, Timer, Workflow } from "lucide-react";
+export const ENTITY_KINDS = [
+    "goal",
+    "project",
+    "task",
+    "strategy",
+    "habit",
+    "tag",
+    "note",
+    "wiki_page",
+    "wiki_space",
+    "insight",
+    "calendar_event",
+    "work_block",
+    "timebox",
+    "value",
+    "pattern",
+    "behavior",
+    "belief",
+    "mode",
+    "mode_session",
+    "report",
+    "event_type",
+    "emotion",
+    "workbench",
+    "functor",
+    "chat"
+];
+const ENTITY_VISUAL_SEEDS = [
+    {
+        kind: "goal",
+        label: "Goal",
+        icon: Target,
+        iconName: "Target",
+        accentRgb: [251, 191, 36]
+    },
+    {
+        kind: "project",
+        label: "Project",
+        icon: FolderOpen,
+        iconName: "FolderOpen",
+        accentRgb: [56, 189, 248]
+    },
+    {
+        kind: "task",
+        label: "Task",
+        icon: ListTodo,
+        iconName: "ListTodo",
+        accentRgb: [129, 140, 248]
+    },
+    {
+        kind: "strategy",
+        label: "Strategy",
+        icon: GitBranch,
+        iconName: "GitBranch",
+        accentRgb: [34, 211, 238]
+    },
+    {
+        kind: "habit",
+        label: "Habit",
+        icon: RefreshCw,
+        iconName: "RefreshCw",
+        accentRgb: [45, 212, 191]
+    },
+    {
+        kind: "tag",
+        label: "Tag",
+        icon: PanelTop,
+        iconName: "PanelTop",
+        accentRgb: [163, 230, 53]
+    },
+    {
+        kind: "note",
+        label: "Note",
+        icon: NotebookPen,
+        iconName: "NotebookPen",
+        accentRgb: [148, 163, 184]
+    },
+    {
+        kind: "wiki_page",
+        label: "Wiki Page",
+        icon: StickyNote,
+        iconName: "StickyNote",
+        accentRgb: [125, 211, 252]
+    },
+    {
+        kind: "wiki_space",
+        label: "Wiki Space",
+        icon: Network,
+        iconName: "Network",
+        accentRgb: [99, 102, 241]
+    },
+    {
+        kind: "insight",
+        label: "Insight",
+        icon: Sparkles,
+        iconName: "Sparkles",
+        accentRgb: [244, 63, 94]
+    },
+    {
+        kind: "calendar_event",
+        label: "Calendar Event",
+        icon: CalendarDays,
+        iconName: "CalendarDays",
+        accentRgb: [14, 165, 233]
+    },
+    {
+        kind: "work_block",
+        label: "Work Block",
+        icon: PanelTop,
+        iconName: "PanelTop",
+        accentRgb: [16, 185, 129]
+    },
+    {
+        kind: "timebox",
+        label: "Timebox",
+        icon: Timer,
+        iconName: "Timer",
+        accentRgb: [244, 114, 182]
+    },
+    {
+        kind: "value",
+        label: "Value",
+        icon: Heart,
+        iconName: "Heart",
+        accentRgb: [52, 211, 153]
+    },
+    {
+        kind: "pattern",
+        label: "Pattern",
+        icon: Repeat,
+        iconName: "Repeat",
+        accentRgb: [251, 113, 133]
+    },
+    {
+        kind: "behavior",
+        label: "Behavior",
+        icon: Route,
+        iconName: "Route",
+        accentRgb: [251, 146, 60]
+    },
+    {
+        kind: "belief",
+        label: "Belief",
+        icon: Quote,
+        iconName: "Quote",
+        accentRgb: [167, 139, 250]
+    },
+    {
+        kind: "mode",
+        label: "Mode",
+        icon: Shapes,
+        iconName: "Shapes",
+        accentRgb: [217, 70, 239]
+    },
+    {
+        kind: "mode_session",
+        label: "Mode Session",
+        icon: Compass,
+        iconName: "Compass",
+        accentRgb: [192, 132, 252]
+    },
+    {
+        kind: "report",
+        label: "Report",
+        icon: FileText,
+        iconName: "FileText",
+        accentRgb: [96, 165, 250]
+    },
+    {
+        kind: "event_type",
+        label: "Event Type",
+        icon: CalendarDays,
+        iconName: "CalendarDays",
+        accentRgb: [45, 212, 191]
+    },
+    {
+        kind: "emotion",
+        label: "Emotion",
+        icon: Heart,
+        iconName: "Heart",
+        accentRgb: [248, 113, 113]
+    },
+    {
+        kind: "workbench",
+        label: "Workbench",
+        icon: Workflow,
+        iconName: "Workflow",
+        accentRgb: [45, 212, 191]
+    },
+    {
+        kind: "functor",
+        label: "Functor",
+        icon: Sparkles,
+        iconName: "Sparkles",
+        accentRgb: [250, 204, 21]
+    },
+    {
+        kind: "chat",
+        label: "Chat",
+        icon: Bot,
+        iconName: "Bot",
+        accentRgb: [129, 140, 248]
+    }
+];
+function toHex(rgb) {
+    return `#${rgb.map((value) => value.toString(16).padStart(2, "0")).join("")}`;
+}
+function toRgbaVar(kind, rgb, alpha) {
+    return `rgba(var(--forge-entity-${kind}-rgb,${rgb.join(",")}),${alpha})`;
+}
+function createEntityVisual(seed) {
+    return {
+        kind: seed.kind,
+        label: seed.label,
+        icon: seed.icon,
+        iconName: seed.iconName,
+        colorToken: {
+            cssVariable: `--forge-entity-${seed.kind}-rgb`,
+            rgb: seed.accentRgb,
+            hex: toHex(seed.accentRgb)
+        },
+        iconClassName: `text-[${toRgbaVar(seed.kind, seed.accentRgb, 0.96)}]`,
+        nameClassName: `text-[${toRgbaVar(seed.kind, seed.accentRgb, 0.96)}]`,
+        badgeClassName: `border-[${toRgbaVar(seed.kind, seed.accentRgb, 0.24)}] ` +
+            `bg-[linear-gradient(135deg,${toRgbaVar(seed.kind, seed.accentRgb, 0.24)},${toRgbaVar(seed.kind, seed.accentRgb, 0.08)})] text-white`,
+        subtleBadgeClassName: `border-[${toRgbaVar(seed.kind, seed.accentRgb, 0.18)}] ` +
+            `bg-[${toRgbaVar(seed.kind, seed.accentRgb, 0.08)}] text-[${toRgbaVar(seed.kind, seed.accentRgb, 0.92)}]`,
+        buttonClassName: `border-[${toRgbaVar(seed.kind, seed.accentRgb, 0.2)}] ` +
+            `bg-[${toRgbaVar(seed.kind, seed.accentRgb, 0.12)}] text-white hover:bg-[${toRgbaVar(seed.kind, seed.accentRgb, 0.18)}]`
+    };
+}
+const ENTITY_VISUALS = Object.fromEntries(ENTITY_VISUAL_SEEDS.map((seed) => [seed.kind, createEntityVisual(seed)]));
+const CRUD_ENTITY_KIND_MAP = {
+    goal: "goal",
+    project: "project",
+    task: "task",
+    strategy: "strategy",
+    habit: "habit",
+    tag: "tag",
+    note: "note",
+    insight: "insight",
+    calendar_event: "calendar_event",
+    work_block_template: "work_block",
+    task_timebox: "timebox",
+    psyche_value: "value",
+    behavior_pattern: "pattern",
+    behavior: "behavior",
+    belief_entry: "belief",
+    mode_profile: "mode",
+    mode_guide_session: "mode_session",
+    event_type: "event_type",
+    emotion_definition: "emotion",
+    trigger_report: "report"
+};
+export function getEntityVisual(kind) {
+    return ENTITY_VISUALS[kind];
+}
+export function getEntityVisualCatalog() {
+    return ENTITY_KINDS.map((kind) => getEntityVisual(kind));
+}
+export function isEntityKind(value) {
+    return ENTITY_KINDS.includes(value);
+}
+export function getEntityKindForCrudEntityType(entityType, options) {
+    if (entityType === "note" && options?.noteKind === "wiki") {
+        return "wiki_page";
+    }
+    return CRUD_ENTITY_KIND_MAP[entityType] ?? null;
+}
+export function getEntityKindForWorkbenchFlowKind(kind) {
+    return kind === "chat" ? "chat" : "functor";
+}
+export function getEntityButtonClassName(kind, selected) {
+    const visual = getEntityVisual(kind);
+    return selected
+        ? `border ${visual.buttonClassName}`
+        : "border border-white/8 bg-white/[0.05] text-white/62 hover:bg-white/[0.08] hover:text-white";
+}