@dxos/plugin-assistant 0.8.4-main.3eb6e50203 → 0.8.4-main.4a85c3132b

package/src/components/Typewriter/Typewriter.stories.tsx

@@ -11,15 +11,14 @@ import React, { useEffect, useState } from 'react';
 
 import { AiService } from '@dxos/ai';
 import { AiServiceTestingPreset } from '@dxos/ai/testing';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
 
 import { Typewriter } from './Typewriter';
 
 const meta: Meta<typeof Typewriter> = {
-  title: 'plugins/plugin-assistant/Typewriter',
+  title: 'plugins/plugin-assistant/components/Typewriter',
   component: Typewriter,
-  parameters: {
-    layout: 'centered',
-  },
+  decorators: [withTheme(), withLayout({ layout: 'column' })],
 };
 
 export default meta;
@@ -49,7 +48,7 @@ The quick brown fox jumps over teh lazy dog. i think this is cool.
 
 export const Default: Story = {
   render: () => {
-    const [rtEffect, setRtEffect] = useState<Runtime.Runtime<LanguageModel.LanguageModel>>();
+    const [runtime, setRuntime] = useState<Runtime.Runtime<LanguageModel.LanguageModel>>();
     useEffect(() => {
       let disposed = false;
       const rt = ManagedRuntime.make(
@@ -59,10 +58,18 @@ export const Default: Story = {
         ),
       );
       queueMicrotask(async () => {
-        if (disposed) return;
-        const x = await rt.runtime();
-        if (disposed) return;
-        setRtEffect(x);
+        try {
+          if (disposed) {
+            return;
+          }
+          const runtime = await rt.runtime();
+          if (disposed) {
+            return;
+          }
+          setRuntime(runtime);
+        } catch (error) {
+          console.error('Failed to initialize runtime:', error);
+        }
       });
       return () => {
         disposed = true;
@@ -70,14 +77,10 @@ export const Default: Story = {
       };
     }, []);
 
-    if (!rtEffect) {
+    if (!runtime) {
       return <div>...Loading</div>;
     }
 
-    return (
-      <div className='w-[800px] p-4'>
-        <Typewriter initialContent={sampleText} runtime={rtEffect} />
-      </div>
-    );
+    return <Typewriter initialContent={sampleText} runtime={runtime} />;
   },
 };

package/src/components/Typewriter/Typewriter.tsx

@@ -41,7 +41,7 @@ export const Typewriter = ({ initialContent = '', extensions = [], runtime }: Ty
   return (
     <ThemeProvider>
       <DensityProvider density='fine'>
-        <div className='is-full bs-full grid overflow-hidden'>
+        <div className='w-full h-full grid overflow-hidden'>
           <Editor.Root ref={editorRef}>
             <Editor.Viewport>
               <Editor.Content initialValue={initialContent} extensions={extension} />

package/src/components/Typewriter/assistant-extension.tsx

@@ -111,9 +111,7 @@ const assistantLinter = (runtime: Runtime.Runtime<LanguageModel.LanguageModel>)
         if (match) {
           suggestions = JSON.parse(match[0]);
         }
-      } catch (e) {
-        // failed to parse
-      }
+      } catch {}
 
       const diagnostics: Diagnostic[] = [];
       for (const s of suggestions) {
@@ -137,8 +135,8 @@ const assistantLinter = (runtime: Runtime.Runtime<LanguageModel.LanguageModel>)
         }
       }
       return diagnostics;
-    } catch (e) {
-      log.error('Proofreading failed', { error: e });
+    } catch (error) {
+      log.catch(error);
       return [];
     }
   });

package/src/components/index.ts

@@ -2,24 +2,6 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type LazyExoticComponent, lazy } from 'react';
-
-export * from './AssistantSettings';
 export * from './Chat';
 export * from './TemplateEditor';
 export * from './Toolbox';
-export * from './TriggerStatus';
-
-export const BlueprintArticle = lazy(() => import('./BlueprintArticle'));
-export const ChatCompanion = lazy(() => import('./ChatCompanion'));
-// Type annotation needed to avoid declaration file emission issues with @dxos/assistant-toolkit types.
-// eslint-disable-next-line @typescript-eslint/consistent-type-imports
-export const ChatContainer: LazyExoticComponent<typeof import('./ChatContainer').default> = lazy(
-  () => import('./ChatContainer'),
-);
-export const ChatDialog = lazy(() => import('./ChatDialog'));
-export const InitiativeContainer = lazy(() => import('./InitiativeContainer'));
-export const PromptArticle = lazy(() => import('./PromptArticle'));
-
-export type { ChatContainerProps } from './ChatContainer';
-export type { ChatDialogProps } from './ChatDialog';

package/src/containers/AssistantSettings/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { AssistantSettings } from './AssistantSettings';
+
+export default AssistantSettings;

package/src/{components → containers/BlueprintArticle}/BlueprintArticle.tsx

@@ -7,10 +7,10 @@ import React from 'react';
 import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
 import { type Blueprint } from '@dxos/blueprints';
 import { Obj } from '@dxos/echo';
-import { Layout, Toolbar } from '@dxos/react-ui';
+import { Panel, Toolbar } from '@dxos/react-ui';
 import { useAttention } from '@dxos/react-ui-attention';
 
-import { TemplateEditor } from './TemplateEditor';
+import { TemplateEditor } from '../../components';
 
 export type BlueprintArticleProps = SurfaceComponentProps<Blueprint.Blueprint>;
 
@@ -18,11 +18,13 @@ export const BlueprintArticle = ({ role, subject }: BlueprintArticleProps) => {
   const { hasAttention } = useAttention(Obj.getDXN(subject).toString());
 
   return (
-    <Layout.Main role={role} toolbar>
-      <Toolbar.Root disabled={!hasAttention} />
-      <TemplateEditor id={subject.id} template={subject.instructions} classNames='container-max-width' />
-    </Layout.Main>
+    <Panel.Root role={role} classNames='dx-article'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention} />
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <TemplateEditor id={subject.id} template={subject.instructions} />
+      </Panel.Content>
+    </Panel.Root>
   );
 };
-
-export default BlueprintArticle;

package/src/containers/BlueprintArticle/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { BlueprintArticle } from './BlueprintArticle';
+
+export default BlueprintArticle;

package/src/{components → containers/ChatCompanion}/ChatCompanion.tsx

@@ -17,9 +17,10 @@ import { SpaceOperation } from '@dxos/plugin-space/types';
 import { useQuery } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 
-import { ChatContainer, type ChatEvent } from '../components';
-import { useBlueprintRegistry, useContextBinder } from '../hooks';
-import { Assistant, AssistantCapabilities, AssistantOperation } from '../types';
+import { type ChatEvent } from '../../components';
+import { useBlueprintRegistry, useContextBinder } from '../../hooks';
+import { Assistant, AssistantCapabilities, AssistantOperation } from '../../types';
+import ChatContainer from '../ChatContainer';
 
 export type ChatCompanionProps = {
   role?: string;
@@ -222,5 +223,3 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
     );
   },
 );
-
-export default ChatCompanion;

package/src/containers/ChatCompanion/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ChatCompanion } from './ChatCompanion';
+
+export default ChatCompanion;

package/src/{components → containers/ChatContainer}/ChatContainer.tsx

@@ -8,12 +8,11 @@ import { useAtomCapability } from '@dxos/app-framework/ui';
 import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
 import { type Space, getSpace } from '@dxos/client/echo';
 import { type Obj } from '@dxos/echo';
-import { Layout } from '@dxos/react-ui';
+import { Panel } from '@dxos/react-ui';
 
-import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../hooks';
-import { AssistantCapabilities, type ChatType } from '../types';
-
-import { Chat as ChatComponent, type ChatRootProps } from './Chat';
+import { Chat as ChatComponent, type ChatRootProps } from '../../components';
+import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../../hooks';
+import { AssistantCapabilities, type ChatType } from '../../types';
 
 export type ChatContainerProps = SurfaceComponentProps<
   ChatType.Chat | undefined,
@@ -45,24 +44,26 @@ export const ChatContainer = forwardRef<HTMLDivElement, ChatContainerProps>((pro
   }
 
   return (
-    <Layout.Main toolbar role={role} ref={forwardedRef}>
-      <ChatComponent.Root db={space?.db} chat={chat} processor={processor} onEvent={onEvent}>
-        <ChatComponent.Toolbar companionTo={companionTo} />
-        <ChatComponent.Viewport classNames='container-max-width'>
-          <ChatComponent.Thread />
-          <div role='none' className='p-4'>
-            <ChatComponent.Prompt
-              {...chatProps}
-              outline
-              preset={preset?.id}
-              online={online}
-              onOnlineChange={setOnline}
-            />
-          </div>
-        </ChatComponent.Viewport>
-      </ChatComponent.Root>
-    </Layout.Main>
+    <ChatComponent.Root db={space?.db} chat={chat} processor={processor} onEvent={onEvent}>
+      <Panel.Root role={role} classNames='dx-article' ref={forwardedRef}>
+        <Panel.Toolbar>
+          <ChatComponent.Toolbar companionTo={companionTo} />
+        </Panel.Toolbar>
+        <Panel.Content>
+          <ChatComponent.Viewport>
+            <ChatComponent.Thread />
+            <div role='none' className='p-4'>
+              <ChatComponent.Prompt
+                {...chatProps}
+                outline
+                preset={preset?.id}
+                online={online}
+                onOnlineChange={setOnline}
+              />
+            </div>
+          </ChatComponent.Viewport>
+        </Panel.Content>
+      </Panel.Root>
+    </ChatComponent.Root>
   );
 });
-
-export default ChatContainer;

package/src/containers/ChatContainer/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ChatContainer } from './ChatContainer';
+
+export default ChatContainer;

package/src/{components → containers/ChatDialog}/ChatDialog.tsx

@@ -10,11 +10,10 @@ import { Obj } from '@dxos/echo';
 import { useTranslation } from '@dxos/react-ui';
 import { ChatDialog as NaturalChatDialog } from '@dxos/react-ui-chat';
 
-import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../hooks';
-import { meta } from '../meta';
-import { AssistantCapabilities } from '../types';
-
-import { Chat, type ChatRootProps } from './Chat';
+import { Chat, type ChatRootProps } from '../../components';
+import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../../hooks';
+import { meta } from '../../meta';
+import { AssistantCapabilities } from '../../types';
 
 export type ChatDialogProps = {
   chat?: ChatTypes.Chat;
@@ -71,5 +70,3 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
     </Chat.Root>
   );
 };
-
-export default ChatDialog;

package/src/containers/ChatDialog/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ChatDialog } from './ChatDialog';
+
+export default ChatDialog;

package/src/containers/Project/ProjectArticle.tsx

@@ -0,0 +1,117 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import * as Option from 'effect/Option';
+import React, { forwardRef, useMemo, useState } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { type SurfaceComponentProps, useObjectMenuItems, useObjectNavigate } from '@dxos/app-toolkit/ui';
+import { type Project } from '@dxos/assistant-toolkit';
+import { Filter, Obj, Query } from '@dxos/echo';
+import { AtomObj, AtomRef } from '@dxos/echo-atom';
+import { useQuery } from '@dxos/react-client/echo';
+import { Card, Panel, ScrollArea, Toolbar } from '@dxos/react-ui';
+import { Menu } from '@dxos/react-ui-menu';
+import { Focus, Mosaic, type MosaicTileProps } from '@dxos/react-ui-mosaic';
+import { isNonNullable } from '@dxos/util';
+
+export type ProjectArticleProps = SurfaceComponentProps<Project.Project>;
+
+export const ProjectArticle = ({ subject: project }: ProjectArticleProps) => {
+  const inputQueue = useAtomValue(
+    AtomObj.make(project).pipe((_) =>
+      Atom.make((get) =>
+        Option.fromNullable(get(_).queue).pipe(Option.map(AtomRef.make), Option.map(get), Option.getOrUndefined),
+      ),
+    ),
+  );
+
+  const inputQueueItems: Obj.Unknown[] = useQuery(inputQueue, Query.select(Filter.everything()));
+
+  const artifacts = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(project).pipe((project) =>
+          Atom.make((get) => {
+            return get(project).artifacts.map((artifact) => get(AtomRef.make(artifact.data)) as Obj.Unknown);
+          }),
+        ),
+      [project],
+    ),
+  );
+
+  const [viewport, setViewport] = useState<HTMLElement | null>(null);
+
+  const stackObjects = [...artifacts, ...inputQueueItems].filter(isNonNullable);
+
+  return (
+    <Panel.Root className='dx-article'>
+      <Panel.Content>
+        {/* TODO(burdon): Factor out. */}
+        {stackObjects.length === 0 && (
+          <div className='text-subdued'>
+            Project has no objects associated with it.
+            <br />
+            <br />
+            To get started:
+            <br />- Write the initative spec: what is the goal of the project?
+            <br />- subscribe project to your email.
+            <br />- Chat with the agent.
+          </div>
+        )}
+
+        {stackObjects.length > 0 && (
+          <Focus.Group asChild>
+            <Mosaic.Container asChild withFocus autoScroll={viewport}>
+              <ScrollArea.Root orientation='vertical'>
+                <ScrollArea.Viewport classNames='p-2' ref={setViewport}>
+                  <Mosaic.Stack items={stackObjects} getId={(item) => item.id} draggable={false} Tile={StackTile} />
+                </ScrollArea.Viewport>
+              </ScrollArea.Root>
+            </Mosaic.Container>
+          </Focus.Group>
+        )}
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const StackTile = forwardRef<HTMLDivElement, MosaicTileProps<Obj.Unknown>>(
+  ({ data, location, debug }, forwardedRef) => {
+    const objectMenuItems = useObjectMenuItems(data);
+    const handleNavigate = useObjectNavigate(data);
+
+    return (
+      <Mosaic.Tile asChild id={data.id} data={data} location={location} debug={debug}>
+        <Focus.Group asChild>
+          <Menu.Root>
+            <Card.Root ref={forwardedRef} data-testid='board-item'>
+              <Card.Toolbar>
+                <Card.IconBlock></Card.IconBlock>
+                <Card.Title onClick={handleNavigate}>{Obj.getLabel(data)}</Card.Title>
+                {/* TODO(wittjosiah): Reconcile with Card.Menu. */}
+                <Menu.Trigger asChild disabled={!objectMenuItems?.length}>
+                  <Toolbar.IconButton
+                    iconOnly
+                    variant='ghost'
+                    icon='ph--dots-three-vertical--regular'
+                    label='Actions'
+                  />
+                </Menu.Trigger>
+                <Menu.Content items={objectMenuItems} />
+              </Card.Toolbar>
+              <Card.Content>
+                <Surface.Surface role='card--content' limit={1} data={{ subject: data }} />
+              </Card.Content>
+            </Card.Root>
+          </Menu.Root>
+        </Focus.Group>
+      </Mosaic.Tile>
+    );
+  },
+);
+StackTile.displayName = 'StackTile';
+
+export default ProjectArticle;

package/src/containers/Project/ProjectSettings.tsx

@@ -0,0 +1,118 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom';
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import React, { useCallback, useEffect, useMemo } from 'react';
+
+import { useCapability } from '@dxos/app-framework/ui';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { Project } from '@dxos/assistant-toolkit';
+import { Feed, Obj, Query, Ref } from '@dxos/echo';
+import { DXN } from '@dxos/echo';
+import { AtomObj, AtomRef } from '@dxos/echo-atom';
+import { QueueService } from '@dxos/functions';
+import { AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { MarkdownEditor } from '@dxos/plugin-markdown';
+import { Filter, useQuery } from '@dxos/react-client/echo';
+import { useObject } from '@dxos/react-client/echo';
+import { Button } from '@dxos/react-ui';
+import { ButtonGroup, Input } from '@dxos/react-ui';
+
+import { syncTriggers } from './triggers';
+
+export const ProjectSettings = ({ subject: project }: SurfaceComponentProps<Project.Project>) => {
+  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
+
+  const handleResetHistory = useCallback(async () => {
+    const runtime = computeRuntime.getRuntime(Obj.getDatabase(project)!.spaceId);
+
+    await runtime.runPromise(Project.resetChatHistory(project));
+
+    if (!project.queue) {
+      await runtime.runPromise(
+        Effect.gen(function* () {
+          const queue = yield* QueueService.createQueue();
+          Obj.change(project, (project) => {
+            project.queue = Ref.fromDXN(queue.dxn);
+          });
+        }),
+      );
+    }
+  }, [project, computeRuntime]);
+
+  const spec = useAtomValue(AtomRef.make(project.spec));
+  const [specInitialValue] = useObject(spec, 'content');
+
+  useEffect(() => {
+    return Obj.subscribe(project, () => {
+      queueMicrotask(() => syncTriggers(project));
+    });
+  }, [project]);
+
+  const subscribableObjects = useQuery(Obj.getDatabase(project), Query.select(Filter.type(Feed.Feed)));
+
+  const existingSubscripts = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(project).pipe((_) =>
+          Atom.make((get) => {
+            const project = get(_);
+            const selectedSubscriptions: Obj.Unknown[] = subscribableObjects.filter((object) =>
+              project.subscriptions.some((subscription) => DXN.equals(subscription.dxn, Obj.getDXN(object))),
+            );
+
+            return selectedSubscriptions;
+          }),
+        ),
+      [project, subscribableObjects],
+    ),
+  );
+
+  return (
+    <div className='flex flex-col gap-4'>
+      <Input.Root>
+        <Input.Label>Spec (what is the goal of the project?)</Input.Label>
+        <MarkdownEditor.Root id={spec?.id ?? ''} object={spec}>
+          <MarkdownEditor.Content initialValue={specInitialValue} />
+        </MarkdownEditor.Root>
+      </Input.Root>
+      <ButtonGroup classNames='h-10'>
+        <Button onClick={handleResetHistory}>Reset Chat History</Button>
+      </ButtonGroup>
+      <div>
+        <h2 className='text-lg font-bold'>Subscriptions</h2>
+        {subscribableObjects.length > 0 && (
+          <div>
+            {subscribableObjects.map((object) => (
+              <Input.Root key={object.id}>
+                <Input.Checkbox
+                  checked={existingSubscripts.includes(object)}
+                  onCheckedChange={(checked) => {
+                    Obj.change(project, (project) => {
+                      if (checked) {
+                        project.subscriptions.push(Ref.fromDXN(Obj.getDXN(object)));
+                      } else {
+                        project.subscriptions = project.subscriptions.filter(
+                          (subscription) => !DXN.equals(subscription.dxn, Obj.getDXN(object)),
+                        );
+                      }
+                    });
+                  }}
+                />
+                <Input.Label>{Obj.getLabel(object)}</Input.Label>
+              </Input.Root>
+            ))}
+          </div>
+        )}
+        {subscribableObjects.length === 0 && (
+          <div className='text-sm text-description'>Space has no feeds to subscribe to.</div>
+        )}
+      </div>
+    </div>
+  );
+};
+
+export default ProjectSettings;

package/src/containers/Project/index.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type ComponentType, type FunctionComponent, lazy } from 'react';
+
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import type { Project } from '@dxos/assistant-toolkit';
+
+import type { ProjectArticleProps } from './ProjectArticle';
+
+export const ProjectArticle: ComponentType<ProjectArticleProps> = lazy(() => import('./ProjectArticle'));
+
+export const ProjectSettings: FunctionComponent<SurfaceComponentProps<Project.Project>> = lazy(
+  () => import('./ProjectSettings'),
+);