@dxos/plugin-daily-summary 0.8.3

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@dxos/plugin-daily-summary",
+  "version": "0.8.3",
+  "description": "Daily activity summary plugin",
+  "homepage": "https://dxos.org",
+  "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
+  "license": "MIT",
+  "author": "DXOS.org",
+  "sideEffects": true,
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/types/src/index.d.ts",
+      "browser": "./dist/lib/browser/index.mjs"
+    }
+  },
+  "types": "dist/types/src/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@effect/ai": "0.33.2",
+    "effect": "3.20.0",
+    "@dxos/ai": "0.8.3",
+    "@dxos/app-toolkit": "0.8.3",
+    "@dxos/app-framework": "0.8.3",
+    "@dxos/client": "0.8.3",
+    "@dxos/assistant": "0.8.3",
+    "@dxos/client-protocol": "0.8.3",
+    "@dxos/functions": "0.8.3",
+    "@dxos/functions-runtime": "0.8.3",
+    "@dxos/effect": "0.8.3",
+    "@dxos/blueprints": "0.8.3",
+    "@dxos/echo": "0.8.3",
+    "@dxos/invariant": "0.8.3",
+    "@dxos/operation": "0.8.3",
+    "@dxos/keys": "0.8.3",
+    "@dxos/plugin-space": "0.8.3",
+    "@dxos/react-client": "0.8.3",
+    "@dxos/types": "0.8.3",
+    "@dxos/util": "0.8.3",
+    "@dxos/plugin-graph": "0.8.3",
+    "@dxos/schema": "0.8.3"
+  },
+  "devDependencies": {
+    "@storybook/react-vite": "^10.2.12",
+    "@types/react": "~19.2.7",
+    "@types/react-dom": "~19.2.3",
+    "react": "~19.2.3",
+    "react-dom": "~19.2.3",
+    "vite": "^7.1.11",
+    "@dxos/react-ui": "0.8.3",
+    "@dxos/storybook-utils": "0.8.3",
+    "@dxos/echo-db": "0.8.3"
+  },
+  "peerDependencies": {
+    "effect": "3.20.0",
+    "react": "~19.2.3",
+    "react-dom": "~19.2.3",
+    "@dxos/react-ui": "0.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/DailySummaryPlugin.tsx

@@ -0,0 +1,18 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
+
+import { AppGraphBuilder, BlueprintDefinition, ReactSurface } from './capabilities';
+import { meta } from './meta';
+import { translations } from './translations';
+
+export const DailySummaryPlugin = Plugin.define(meta).pipe(
+  AppPlugin.addAppGraphModule({ activate: AppGraphBuilder }),
+  AppPlugin.addBlueprintDefinitionModule({ activate: BlueprintDefinition }),
+  AppPlugin.addSurfaceModule({ activate: ReactSurface }),
+  AppPlugin.addTranslationsModule({ translations }),
+  Plugin.make,
+);

package/src/blueprints/daily-summary-blueprint.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { Blueprint, Template } from '@dxos/blueprints';
+import { trim } from '@dxos/util';
+
+import { DailySummaryHandlers, GenerateSummary } from './functions';
+
+export const BLUEPRINT_KEY = 'org.dxos.blueprint.daily-summary';
+
+export { DailySummaryHandlers };
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Daily Summary',
+    tools: Blueprint.toolDefinitions({ operations: [GenerateSummary] }),
+    instructions: Template.make({
+      source: trim`
+        {{! Daily Summary }}
+
+        You generate concise daily activity summaries as Markdown documents.
+        When asked to summarize, use the generate tool to query recent objects and produce a summary.
+        The tool creates a Markdown document in a "Summaries" collection.
+        If a summary for today already exists, it updates the existing document.
+      `,
+    }),
+  });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  make,
+};
+
+export default blueprint;

package/src/blueprints/functions/definitions.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { AiService } from '@dxos/ai';
+import { Database } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+/**
+ * Generates a daily summary of recently modified objects using AI.
+ * Queries the database for objects updated within a time window,
+ * sends them to an LLM for summarization, and creates/updates
+ * a Markdown document in a "Summaries" collection.
+ */
+export const GenerateSummary = Operation.make({
+  meta: {
+    key: 'org.dxos.function.daily-summary.generate',
+    name: 'Generate Daily Summary',
+    description: 'Queries objects modified in the last day and generates an AI-summarized markdown document.',
+  },
+  input: Schema.Struct({
+    previousSummary: Schema.optional(Schema.String).annotations({
+      description: 'The previous day summary text for context continuity.',
+    }),
+    lookbackHours: Schema.optional(Schema.Number).annotations({
+      description: 'Number of hours to look back for modified objects. Defaults to 24.',
+    }),
+  }),
+  output: Schema.Struct({
+    id: Schema.String.annotations({
+      description: 'DXN of the created or updated markdown document.',
+    }),
+    objectCount: Schema.Number.annotations({
+      description: 'Number of objects included in the summary.',
+    }),
+    date: Schema.String.annotations({
+      description: 'Date label for the summary (e.g., "March 20").',
+    }),
+  }),
+  services: [Database.Service, AiService.AiService],
+});

package/src/blueprints/functions/generate.test.ts

@@ -0,0 +1,143 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Schema from 'effect/Schema';
+import * as Effect from 'effect/Effect';
+
+import { AssistantTestLayer } from '@dxos/assistant/testing';
+import { Blueprint } from '@dxos/blueprints';
+import { SpaceProperties } from '@dxos/client-protocol';
+import { Collection, DXN, Database, Obj, Query, Ref, Type } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { FunctionInvocationService } from '@dxos/functions';
+import { ObjectId } from '@dxos/keys';
+import { Text } from '@dxos/schema';
+import { HasSubject } from '@dxos/types';
+
+import { DailySummaryHandlers } from '../daily-summary-blueprint';
+
+import { GenerateSummary } from './definitions';
+
+ObjectId.dangerouslyDisableRandomness();
+
+const MarkdownDocument = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  content: Ref.Ref(Text.Text),
+}).pipe(Type.object({ typename: 'org.dxos.type.document', version: '0.1.0' }));
+
+const WithProperties = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | Database.Service> =>
+  Effect.zipRight(
+    Effect.gen(function* () {
+      yield* Database.add(
+        Obj.make(SpaceProperties, {
+          [Collection.Collection.typename]: Ref.make(Collection.make()),
+        }) as any,
+      );
+    }),
+    effect,
+  );
+
+const TestLayer = AssistantTestLayer({
+  operationHandlers: DailySummaryHandlers,
+  types: [SpaceProperties, Collection.Collection, Blueprint.Blueprint, MarkdownDocument, HasSubject.HasSubject],
+  tracing: 'pretty',
+});
+
+describe('GenerateSummary', () => {
+  it.effect(
+    'creates a Markdown document with summary content',
+    Effect.fnUntraced(
+      function* (_) {
+        const result = yield* FunctionInvocationService.invokeFunction(GenerateSummary, {
+          lookbackHours: 24,
+        });
+
+        expect(result.id).toBeTruthy();
+        expect(result.date).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+        expect(result.objectCount).toBeGreaterThanOrEqual(0);
+
+        const doc = yield* Database.resolve(DXN.parse(result.id), MarkdownDocument);
+        expect(doc.name).toContain('Daily Summary');
+        const text = yield* Database.load(doc.content);
+        expect(text.content).toContain('Daily Summary');
+        expect(text.content).toContain('objects were modified today');
+      },
+      WithProperties,
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.effect(
+    'creates a "Summaries" collection if none exists',
+    Effect.fnUntraced(
+      function* (_) {
+        yield* FunctionInvocationService.invokeFunction(GenerateSummary, {});
+
+        const collections = yield* Database.runQuery(Query.type(Collection.Collection, { name: 'Summaries' }));
+        expect(collections.length).toBe(1);
+        expect(collections[0].objects.length).toBe(1);
+      },
+      WithProperties,
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.effect(
+    'reuses existing "Summaries" collection on subsequent calls',
+    Effect.fnUntraced(
+      function* (_) {
+        yield* FunctionInvocationService.invokeFunction(GenerateSummary, {});
+        yield* FunctionInvocationService.invokeFunction(GenerateSummary, {});
+
+        const collections = yield* Database.runQuery(Query.type(Collection.Collection, { name: 'Summaries' }));
+        expect(collections.length).toBe(1);
+        expect(collections[0].objects.length).toBe(2);
+      },
+      WithProperties,
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.effect(
+    'includes previous summary in content when provided',
+    Effect.fnUntraced(
+      function* (_) {
+        const previousSummary = 'Yesterday was productive. 10 objects edited.';
+        const result = yield* FunctionInvocationService.invokeFunction(GenerateSummary, {
+          previousSummary,
+          lookbackHours: 24,
+        });
+
+        const doc = yield* Database.resolve(DXN.parse(result.id), MarkdownDocument);
+        const text = yield* Database.load(doc.content);
+        expect(text.content).toContain('Previous Summary');
+        expect(text.content).toContain(previousSummary);
+      },
+      WithProperties,
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.effect(
+    'names document with today date',
+    Effect.fnUntraced(
+      function* (_) {
+        const result = yield* FunctionInvocationService.invokeFunction(GenerateSummary, {});
+        const today = new Date().toISOString().slice(0, 10);
+        expect(result.date).toBe(today);
+
+        const doc = yield* Database.resolve(DXN.parse(result.id), MarkdownDocument);
+        expect(doc.name).toContain(today);
+      },
+      WithProperties,
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});

package/src/blueprints/functions/generate.ts

@@ -0,0 +1,182 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as LanguageModel from '@effect/ai/LanguageModel';
+import * as Prompt from '@effect/ai/Prompt';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schema from 'effect/Schema';
+
+import { AiService, ToolExecutionService, ToolResolverService } from '@dxos/ai';
+import { Collection, Database, Filter, Obj, Query, Ref, Type } from '@dxos/echo';
+import { FunctionInvocationService, TracingService } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+import { Text } from '@dxos/schema';
+import { CollectionModel } from '@dxos/schema';
+import { trim } from '@dxos/util';
+
+import { GenerateSummary } from './definitions';
+
+const DEFAULT_LOOKBACK_HOURS = 24;
+const SUMMARIES_COLLECTION_NAME = 'Summaries';
+const SUMMARY_TITLE_PREFIX = 'Daily Summary —';
+
+/**
+ * Predefined structure for the AI-generated daily summary.
+ * Used as the system prompt for the summarization model.
+ */
+export const SUMMARY_STRUCTURE = trim`
+  Given a list of recently modified objects,
+  generate a concise daily summary in markdown, 
+  try to pull insights from the changes and the context of the changes.
+  Focus on the meaningful changes and try to avoid changes in the system objects.
+
+  Follow this exact structure:
+
+  ## Highlights
+  Bullet points capturing the most significant changes or accomplishments.
+
+  ## TODOs
+  List of TODOs that is inferred from the changes and the content of the changes.
+  Make it short, do not force it, only strong call to action data should be included.
+  Use - [ ] syntax for the TODOs.
+
+  Rules:
+  - Do NOT include the heading "Daily Summary" — the document already has a title.
+  - Be concise. Each bullet should be one sentence.
+  - If a previous summary is provided, note what changed since then.
+  - Try to pull actionable points from the changes and the context of the changes.
+  - Output raw markdown only, no wrapping code fences.
+`;
+
+const MarkdownDocument = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  content: Ref.Ref(Text.Text),
+}).pipe(Type.object({ typename: 'org.dxos.type.document', version: '0.1.0' }));
+
+type MarkdownDoc = Schema.Schema.Type<typeof MarkdownDocument>;
+
+const makeMarkdownDoc = ({ name, content }: { name: string; content: string }) => {
+  const doc = Obj.make(MarkdownDocument, { name, content: Ref.make(Text.make(content)) });
+  Obj.setParent(doc.content.target!, doc);
+  return doc;
+};
+
+export default GenerateSummary.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(
+      function* ({ previousSummary, lookbackHours }) {
+        const hours = lookbackHours ?? DEFAULT_LOOKBACK_HOURS;
+        const cutoff = Date.now() - hours * 60 * 60 * 1000;
+        const now = new Date();
+        const dateLabel = now.toLocaleDateString('en-US', { month: 'long', day: 'numeric' });
+        const docName = `${SUMMARY_TITLE_PREFIX} ${dateLabel}`;
+
+        const recentObjects = yield* Database.runQuery(Filter.updated({ after: cutoff }));
+
+        const objectDescriptions = recentObjects.map((obj) => {
+          return JSON.stringify(Obj.toJSON(obj));
+        });
+
+        const content = yield* summarizeWithAi({
+          dateLabel,
+          objectDescriptions,
+          previousSummary,
+          hours,
+        });
+
+        const existingDoc = yield* findExistingDaySummary(docName);
+
+        let doc;
+        if (existingDoc) {
+          yield* updateDocContent(existingDoc, content);
+          doc = existingDoc;
+        } else {
+          doc = makeMarkdownDoc({ name: docName, content });
+          const summariesCollection = yield* findOrCreateSummariesCollection();
+          yield* CollectionModel.add({ object: doc, target: summariesCollection });
+        }
+
+        return {
+          id: Obj.getDXN(doc).toString(),
+          objectCount: recentObjects.length,
+          date: dateLabel,
+        };
+      },
+      Effect.provide(
+        Layer.mergeAll(
+          AiService.model('@anthropic/claude-haiku-4-5'),
+          ToolResolverService.layerEmpty,
+          ToolExecutionService.layerEmpty,
+          TracingService.layerNoop,
+          FunctionInvocationService.layerNotAvailable,
+        ),
+      ),
+    ),
+  ),
+);
+
+const summarizeWithAi = Effect.fn(function* ({
+  dateLabel,
+  objectDescriptions,
+  previousSummary,
+  hours,
+}: {
+  dateLabel: string;
+  objectDescriptions: string[];
+  previousSummary?: string;
+  hours: number;
+}) {
+  const userContent = [
+    `Date: ${dateLabel}`,
+    `Time window: last ${hours} hours`,
+    `Total objects modified: ${objectDescriptions.length}`,
+    '',
+    'Modified objects:',
+    ...objectDescriptions,
+    ...(previousSummary ? ['', 'Previous summary for context:', previousSummary] : []),
+  ].join('\n');
+
+  const { text } = yield* LanguageModel.generateText({
+    prompt: Prompt.fromMessages([
+      Prompt.systemMessage({ content: SUMMARY_STRUCTURE }),
+      Prompt.userMessage({ content: [Prompt.makePart('text', { text: userContent })] }),
+    ]),
+  });
+
+  return text;
+});
+
+const findExistingDaySummary = Effect.fn(function* (docName: string) {
+  const docs = yield* Database.runQuery(Query.type(MarkdownDocument, { name: docName }));
+  return docs.length > 0 ? docs[0] : null;
+});
+
+const updateDocContent = Effect.fn(function* (doc: MarkdownDoc, newContent: string) {
+  const textRef = doc.content;
+  if (Ref.isRef(textRef)) {
+    const text: Text.Text | undefined = yield* Effect.promise(() => textRef.load());
+    if (text) {
+      Obj.change(text, (mutable) => {
+        mutable.content = newContent;
+      });
+      return;
+    }
+  }
+  Obj.change(doc, (mutable) => {
+    mutable.content = Ref.make(Text.make(newContent));
+  });
+});
+
+const findOrCreateSummariesCollection = Effect.fn(function* () {
+  const collections = yield* Database.runQuery(Query.type(Collection.Collection, { name: SUMMARIES_COLLECTION_NAME }));
+
+  if (collections.length > 0) {
+    return collections[0];
+  }
+
+  const collection = Collection.make({ name: SUMMARIES_COLLECTION_NAME });
+  yield* CollectionModel.add({ object: collection });
+  return collection;
+});

package/src/blueprints/functions/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/operation';
+
+export * from './definitions';
+
+export const DailySummaryHandlers = OperationHandlerSet.lazy(() => import('./generate'));

package/src/blueprints/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { default as DailySummaryBlueprint, BLUEPRINT_KEY } from './daily-summary-blueprint';
+export * from './functions';

package/src/capabilities/app-graph-builder/app-graph-builder.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { GraphBuilder, NodeMatcher } from '@dxos/plugin-graph';
+import { meta as spaceMeta } from '@dxos/plugin-space';
+
+import { meta } from '../../meta';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const extensions = yield* Effect.all([
+      GraphBuilder.createExtension({
+        id: `${meta.id}.space-settings-daily-summary`,
+        match: NodeMatcher.whenNodeType(`${spaceMeta.id}.settings`),
+        connector: (node) =>
+          Effect.succeed([
+            {
+              id: `${meta.id}.daily-summary`,
+              type: `${meta.id}.space-settings-daily-summary`,
+              data: `${meta.id}.space-settings-daily-summary`,
+              properties: {
+                label: ['plugin name', { ns: meta.id }],
+                icon: 'ph--calendar-check--regular',
+              },
+            },
+          ]),
+      }),
+    ]);
+
+    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
+  }),
+);

package/src/capabilities/app-graph-builder/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));

package/src/capabilities/blueprint-definition/blueprint-definition.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+
+import { DailySummaryBlueprint } from '../../blueprints';
+
+const blueprintDefinition = Capability.makeModule<
+  [],
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]
+>(() => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, DailySummaryBlueprint)]));
+
+export default blueprintDefinition;

package/src/capabilities/blueprint-definition/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));

package/src/capabilities/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './app-graph-builder';
+export * from './blueprint-definition';
+export * from './react-surface';

package/src/capabilities/react-surface/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));

package/src/capabilities/react-surface/react-surface.tsx

@@ -0,0 +1,33 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
+import { useActiveSpace } from '@dxos/plugin-space';
+
+import { DailySummarySettings } from '../../containers';
+import { meta } from '../../meta';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: `${meta.id}.space-settings-daily-summary`,
+        role: 'article',
+        filter: (data): data is { subject: string } => data.subject === `${meta.id}.space-settings-daily-summary`,
+        component: () => {
+          const space = useActiveSpace();
+          if (!space) {
+            return null;
+          }
+
+          return <DailySummarySettings space={space} />;
+        },
+      }),
+    ]),
+  ),
+);