@dxos/plugin-assistant 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

package/src/containers/TracePanel/dxn-extractor.test.ts

@@ -0,0 +1,153 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import {
+  extractDxnsFromObject,
+  extractDxnsFromString,
+  extractFirstDxnFromToolInput,
+  extractFirstDxnFromToolResult,
+} from './dxn-extractor';
+
+describe('dxn-extractor', () => {
+  describe('extractDxnsFromString', () => {
+    test('extracts plain DXN from string', ({ expect }) => {
+      const result = extractDxnsFromString('Found object dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+      expect(result).toHaveLength(1);
+      expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('extracts @dxn prefixed reference from string', ({ expect }) => {
+      const result = extractDxnsFromString('Reference to @dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4 in text');
+      expect(result).toHaveLength(1);
+      expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('extracts multiple DXNs from string', ({ expect }) => {
+      const result = extractDxnsFromString(
+        'Objects: dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4 and @dxn:queue:data:SPACE:QUEUE:01KG7R1ZXWFMWQ4DA1Q6TN1DG5',
+      );
+      expect(result).toHaveLength(2);
+    });
+
+    test('deduplicates DXNs', ({ expect }) => {
+      const result = extractDxnsFromString(
+        'Same object dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4 and dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',
+      );
+      expect(result).toHaveLength(1);
+    });
+
+    test('returns empty array for string without DXNs', ({ expect }) => {
+      const result = extractDxnsFromString('No DXNs here');
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('extractDxnsFromObject', () => {
+    test('extracts IPLD-style reference { "/": "dxn:..." }', ({ expect }) => {
+      const result = extractDxnsFromObject({
+        '/': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('extracts @dxn key reference { "@dxn": "dxn:..." }', ({ expect }) => {
+      const result = extractDxnsFromObject({
+        '@dxn': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',
+        name: 'Test',
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('extracts reference block { _tag: "reference", reference: { dxn: ... } }', ({ expect }) => {
+      const result = extractDxnsFromObject({
+        _tag: 'reference',
+        reference: {
+          dxn: 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',
+        },
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('extracts DXN from nested object', ({ expect }) => {
+      const result = extractDxnsFromObject({
+        data: {
+          items: [
+            {
+              ref: { '/': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4' },
+            },
+          ],
+        },
+      });
+      expect(result).toHaveLength(1);
+    });
+
+    test('extracts DXN from string property', ({ expect }) => {
+      const result = extractDxnsFromObject({
+        message: 'Created object dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',
+      });
+      expect(result).toHaveLength(1);
+    });
+
+    test('extracts DXN from array', ({ expect }) => {
+      const result = extractDxnsFromObject([
+        { '/': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4' },
+        { '/': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG5' },
+      ]);
+      expect(result).toHaveLength(2);
+    });
+
+    test('handles null and undefined', ({ expect }) => {
+      expect(extractDxnsFromObject(null)).toHaveLength(0);
+      expect(extractDxnsFromObject(undefined)).toHaveLength(0);
+    });
+  });
+
+  describe('extractFirstDxnFromToolInput', () => {
+    test('extracts DXN from JSON tool input', ({ expect }) => {
+      const input = JSON.stringify({
+        objectRef: { '/': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4' },
+      });
+      const result = extractFirstDxnFromToolInput(input);
+      expect(result?.toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('extracts DXN from invalid JSON string', ({ expect }) => {
+      const input = 'Invalid JSON but contains dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4';
+      const result = extractFirstDxnFromToolInput(input);
+      expect(result?.toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('returns undefined for input without DXNs', ({ expect }) => {
+      const input = JSON.stringify({ name: 'Test' });
+      const result = extractFirstDxnFromToolInput(input);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('extractFirstDxnFromToolResult', () => {
+    test('extracts DXN from JSON tool result', ({ expect }) => {
+      const result = JSON.stringify({
+        created: { '/': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4' },
+      });
+      const dxn = extractFirstDxnFromToolResult(result);
+      expect(dxn?.toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('returns undefined for undefined result', ({ expect }) => {
+      const dxn = extractFirstDxnFromToolResult(undefined);
+      expect(dxn).toBeUndefined();
+    });
+
+    test('returns undefined for result without DXNs', ({ expect }) => {
+      const result = JSON.stringify({ success: true });
+      const dxn = extractFirstDxnFromToolResult(result);
+      expect(dxn).toBeUndefined();
+    });
+  });
+});

package/src/containers/TracePanel/dxn-extractor.ts

@@ -0,0 +1,178 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { DXN } from '@dxos/keys';
+
+/**
+ * Patterns for extracting DXN references from tool call params/results.
+ *
+ * Supported formats:
+ * - `{ "/": "dxn:..." }` - IPLD-style encoded references
+ * - `{ "@dxn": "dxn:..." }` - Alternative format with @dxn key
+ * - `@dxn:...` - In-text references (with @ prefix)
+ * - `dxn:...` - Plain DXN strings
+ */
+
+/**
+ * Regex to match DXN strings in various formats.
+ * Matches: dxn:kind:part1:part2:...
+ */
+const DXN_PATTERN = /dxn:[a-zA-Z0-9]+(?::[a-zA-Z0-9@_-]+)+/g;
+
+/**
+ * Regex to match @dxn: prefixed references in text.
+ */
+const AT_DXN_PATTERN = /@(dxn:[a-zA-Z0-9]+(?::[a-zA-Z0-9@_-]+)+)/g;
+
+/**
+ * Extracts all DXN references from a string.
+ */
+export const extractDxnsFromString = (text: string): DXN[] => {
+  const dxns: DXN[] = [];
+  const seen = new Set<string>();
+
+  // Match @dxn: prefixed references.
+  let match;
+  while ((match = AT_DXN_PATTERN.exec(text)) !== null) {
+    const dxnStr = match[1];
+    if (!seen.has(dxnStr)) {
+      const dxn = DXN.tryParse(dxnStr);
+      if (dxn) {
+        dxns.push(dxn);
+        seen.add(dxnStr);
+      }
+    }
+  }
+
+  // Match plain dxn: strings.
+  while ((match = DXN_PATTERN.exec(text)) !== null) {
+    const dxnStr = match[0];
+    if (!seen.has(dxnStr)) {
+      const dxn = DXN.tryParse(dxnStr);
+      if (dxn) {
+        dxns.push(dxn);
+        seen.add(dxnStr);
+      }
+    }
+  }
+
+  return dxns;
+};
+
+/**
+ * Extracts DXN references from a JSON object.
+ * Handles IPLD-style references `{ "/": "dxn:..." }` and `{ "@dxn": "dxn:..." }`.
+ */
+export const extractDxnsFromObject = (obj: unknown): DXN[] => {
+  const dxns: DXN[] = [];
+  const seen = new Set<string>();
+
+  const addDxn = (dxnStr: string) => {
+    if (!seen.has(dxnStr)) {
+      const dxn = DXN.tryParse(dxnStr);
+      if (dxn) {
+        dxns.push(dxn);
+        seen.add(dxnStr);
+      }
+    }
+  };
+
+  const traverse = (value: unknown): void => {
+    if (value === null || value === undefined) {
+      return;
+    }
+
+    if (typeof value === 'string') {
+      // Check if the string itself is a DXN.
+      if (value.startsWith('dxn:')) {
+        addDxn(value);
+      } else if (value.startsWith('@dxn:')) {
+        addDxn(value.slice(1));
+      }
+      // Also extract DXNs from within the string.
+      const extracted = extractDxnsFromString(value);
+      for (const dxn of extracted) {
+        addDxn(dxn.toString());
+      }
+      return;
+    }
+
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        traverse(item);
+      }
+      return;
+    }
+
+    if (typeof value === 'object') {
+      const record = value as Record<string, unknown>;
+
+      // Check for IPLD-style reference: { "/": "dxn:..." }
+      if ('/' in record && typeof record['/'] === 'string') {
+        const dxnStr = record['/'];
+        if (typeof dxnStr === 'string' && dxnStr.startsWith('dxn:')) {
+          addDxn(dxnStr);
+        }
+      }
+
+      // Check for @dxn key: { "@dxn": "dxn:..." }
+      if ('@dxn' in record && typeof record['@dxn'] === 'string') {
+        const dxnStr = record['@dxn'];
+        if (typeof dxnStr === 'string' && dxnStr.startsWith('dxn:')) {
+          addDxn(dxnStr);
+        }
+      }
+
+      // Check for reference blocks: { _tag: 'reference', reference: { dxn: ... } }
+      if (record._tag === 'reference' && record.reference && typeof record.reference === 'object') {
+        const ref = record.reference as Record<string, unknown>;
+        if (ref.dxn && typeof ref.dxn === 'string') {
+          addDxn(ref.dxn);
+        }
+      }
+
+      // Recursively traverse all properties.
+      for (const key of Object.keys(record)) {
+        traverse(record[key]);
+      }
+    }
+  };
+
+  traverse(obj);
+  return dxns;
+};
+
+/**
+ * Extracts the first DXN from a tool call input string (JSON).
+ */
+export const extractFirstDxnFromToolInput = (input: string): DXN | undefined => {
+  try {
+    const parsed = JSON.parse(input);
+    const dxns = extractDxnsFromObject(parsed);
+    return dxns[0];
+  } catch {
+    // If JSON parsing fails, try to extract from the raw string.
+    const dxns = extractDxnsFromString(input);
+    return dxns[0];
+  }
+};
+
+/**
+ * Extracts the first DXN from a tool result string (JSON).
+ */
+export const extractFirstDxnFromToolResult = (result: string | undefined): DXN | undefined => {
+  if (!result) {
+    return undefined;
+  }
+
+  try {
+    const parsed = JSON.parse(result);
+    const dxns = extractDxnsFromObject(parsed);
+    return dxns[0];
+  } catch {
+    // If JSON parsing fails, try to extract from the raw string.
+    const dxns = extractDxnsFromString(result);
+    return dxns[0];
+  }
+};

package/src/containers/TracePanel/index.ts

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

package/src/containers/TriggerStatus/TriggerStatus.tsx

@@ -0,0 +1,144 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { useActiveSpace } from '@dxos/app-toolkit/ui';
+import { type InvocationsState } from '@dxos/functions-runtime';
+import { useTriggerRuntimeControls } from '@dxos/plugin-automation/hooks';
+import { StatusBar } from '@dxos/plugin-status-bar';
+import { type Database } from '@dxos/react-client/echo';
+import { IconButton, Input, Popover, useTranslation } from '@dxos/react-ui';
+
+import { meta } from '#meta';
+
+type TriggerStatusState = 'disabled' | 'idle' | 'running' | 'error';
+
+const getIcon = (state: TriggerStatusState): string => {
+  switch (state) {
+    case 'disabled':
+      return 'ph--lightning-slash--regular';
+    case 'idle':
+      return 'ph--lightning--regular';
+    case 'running':
+      return 'ph--lightning--fill';
+    case 'error':
+      return 'ph--warning--regular';
+  }
+};
+
+const getIconClassNames = (state: TriggerStatusState): string | undefined => {
+  switch (state) {
+    case 'running':
+      return 'animate-pulse text-accent-text';
+    case 'error':
+      return 'text-error-text';
+    default:
+      return undefined;
+  }
+};
+
+export const TriggerStatus = () => {
+  const space = useActiveSpace();
+  const db = space?.db;
+  if (!db) {
+    return null;
+  }
+
+  return <SpaceStatusMain db={db} />;
+};
+
+const SpaceStatusMain = ({ db }: { db: Database.Database }) => {
+  const { t } = useTranslation(meta.id);
+  const { state, start, stop } = useTriggerRuntimeControls(db);
+  const isRunning = state?.enabled ?? false;
+
+  // Determine the current trigger status state.
+  const triggerState: TriggerStatusState = useMemo(() => {
+    if (!isRunning) {
+      return 'disabled';
+    }
+
+    // Check if there's any pending invocation.
+    const hasPending = state?.invocations.some((invocation) => invocation.result === null);
+    if (hasPending) {
+      return 'running';
+    }
+
+    // Check if the last invocation failed.
+    const lastInvocation = state?.invocations.at(-1);
+    if (lastInvocation?.result?._tag === 'Failure') {
+      return 'error';
+    }
+
+    return 'idle';
+  }, [isRunning, state?.invocations]);
+
+  return (
+    <Popover.Root>
+      <Popover.Trigger asChild>
+        <StatusBar.Item>
+          <IconButton
+            icon={getIcon(triggerState)}
+            iconOnly
+            label={t(`trigger-status-${triggerState}.label`)}
+            classNames={getIconClassNames(triggerState)}
+          />
+        </StatusBar.Item>
+      </Popover.Trigger>
+      <Popover.Portal>
+        <Popover.Content side='left'>
+          <TriggerStatusPopover
+            isRunning={isRunning}
+            state={triggerState}
+            currentFunctionName={
+              state?.invocations.at(-1)?.function?.meta.name ?? state?.invocations.at(-1)?.function?.meta.key
+            }
+            lastInvocation={state?.invocations.at(-1)}
+            onToggle={isRunning ? stop : start}
+          />
+          <Popover.Arrow />
+        </Popover.Content>
+      </Popover.Portal>
+    </Popover.Root>
+  );
+};
+
+type TriggerStatusPopoverProps = {
+  isRunning: boolean;
+  state: TriggerStatusState;
+  currentFunctionName?: string;
+  lastInvocation?: InvocationsState;
+  onToggle: () => void;
+};
+
+const TriggerStatusPopover = ({
+  isRunning,
+  state,
+  currentFunctionName,
+  lastInvocation, // TODO(burdon): Show.
+  onToggle,
+}: TriggerStatusPopoverProps) => {
+  const { t } = useTranslation(meta.id);
+
+  return (
+    <div className='flex flex-col gap-2 p-2 w-[240px]'>
+      <Input.Root>
+        <div className='flex items-center gap-2'>
+          <Input.Switch checked={isRunning} onCheckedChange={onToggle} />
+          <Input.Label>{t('trigger-runtime.label')}</Input.Label>
+        </div>
+      </Input.Root>
+
+      <div className='flex flex-col gap-1'>
+        <div className='text-sm'>{t(`trigger-status-${state}.label`)}</div>
+        {currentFunctionName && state === 'running' && (
+          <div className='text-xs text-description'>{currentFunctionName}</div>
+        )}
+      </div>
+    </div>
+  );
+};
+
+export default TriggerStatus;

package/src/containers/TriggerStatus/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { TriggerStatus as default } from './TriggerStatus';

package/src/containers/index.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export const BlueprintArticle: ComponentType<any> = lazy(() => import('./BlueprintArticle'));
+export const ChatCompanion: ComponentType<any> = lazy(() => import('./ChatCompanion'));
+export const ChatContainer: ComponentType<any> = lazy(() => import('./ChatContainer'));
+export const ChatDialog: ComponentType<any> = lazy(() => import('./ChatDialog'));
+export const ProjectArticle: ComponentType<any> = lazy(() => import('./ProjectArticle'));
+export const ProjectSettings: ComponentType<any> = lazy(() => import('./ProjectSettings'));
+export const PromptArticle: ComponentType<any> = lazy(() => import('./PromptArticle'));
+export const PromptList: ComponentType<any> = lazy(() => import('./PromptList'));
+export const TracePanel: ComponentType<any> = lazy(() => import('./TracePanel'));
+export const TriggerStatus: ComponentType<any> = lazy(() => import('./TriggerStatus'));

package/src/extensions/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { promptRunExtension, type PromptExtensionOptions } from './prompt-extension';

package/src/extensions/prompt-extension.ts

@@ -0,0 +1,111 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { syntaxTree } from '@codemirror/language';
+import { type Extension } from '@codemirror/state';
+import { Decoration, type DecorationSet, EditorView, ViewPlugin, type ViewUpdate, WidgetType } from '@codemirror/view';
+
+import { Domino } from '@dxos/ui';
+
+export type PromptExtensionOptions = {
+  /** Called when the user clicks the run button on a prompt code block. */
+  onRun: (promptText: string) => void;
+};
+
+/**
+ * CodeMirror extension that adds a green "run" button to ```prompt fenced code blocks.
+ */
+export const promptRunExtension = ({ onRun }: PromptExtensionOptions): Extension => {
+  return [
+    ViewPlugin.fromClass(
+      class {
+        decorations: DecorationSet;
+
+        constructor(view: EditorView) {
+          this.decorations = this.buildDecorations(view);
+        }
+
+        update(update: ViewUpdate) {
+          if (update.docChanged || update.viewportChanged || update.selectionSet || update.focusChanged) {
+            this.decorations = this.buildDecorations(update.view);
+          }
+        }
+
+        buildDecorations(view: EditorView): DecorationSet {
+          const decorations: Array<{ from: number; to: number; decoration: Decoration }> = [];
+
+          syntaxTree(view.state).iterate({
+            enter: (node) => {
+              if (node.name === 'FencedCode') {
+                const info = node.node.getChild('CodeInfo');
+                if (info) {
+                  const type = view.state.sliceDoc(info.from, info.to);
+                  const text = node.node.getChild('CodeText');
+                  if (type === 'prompt' && text) {
+                    const content = view.state.sliceDoc(text.from, text.to).trim();
+                    if (content.length > 0) {
+                      const widget = new PromptRunWidget(content, onRun);
+                      decorations.push({
+                        from: node.from,
+                        to: node.from,
+                        decoration: Decoration.widget({ widget, side: -1 }),
+                      });
+                    }
+                  }
+                }
+              }
+            },
+          });
+
+          return Decoration.set(
+            decorations.sort((a, b) => a.from - b.from || a.to - b.to).map((d) => d.decoration.range(d.from, d.to)),
+          );
+        }
+      },
+      {
+        decorations: (v) => v.decorations,
+      },
+    ),
+  ];
+};
+
+class PromptRunWidget extends WidgetType {
+  constructor(
+    private readonly prompt: string,
+    private readonly onClick: (promptText: string) => void,
+  ) {
+    super();
+  }
+
+  override eq(other: this) {
+    return this.prompt === other.prompt;
+  }
+
+  override ignoreEvent() {
+    return false;
+  }
+
+  override toDOM() {
+    return Domino.of('div')
+      .classNames('relative')
+      .append(
+        Domino.of('button')
+          .classNames('dx-button absolute right-0 top-4')
+          .on('mousedown', (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            this.onClick(this.prompt);
+          })
+          .append(
+            Domino.of('svg', Domino.SVG)
+              .classNames('w-4 h-4 cursor-pointer')
+              .append(
+                Domino.of('use', Domino.SVG).attributes({
+                  href: Domino.icon('ph--play--regular'),
+                }),
+              ),
+          ),
+      ).root;
+  }
+}

package/src/hooks/index.ts

@@ -8,8 +8,8 @@ export * from './useChatServices';
 export * from './useChatToolbarActions';
 export * from './useContextBinder';
 export * from './useContextObjects';
+export * from './useFilteredTypes';
 export * from './useFlush';
-export * from './useItemTypes';
 export * from './useOnline';
 export * from './usePresets';
 export * from './useReferencesProvider';