@agimon-ai/doompi-author 0.0.1-alpha.2

package/src/web/stores/authorProfiles.ts

@@ -0,0 +1,130 @@
+import type { AuthorJsonSchema } from '../../types/author.ts';
+import type { AuthorDocumentKind, AuthorTrustedProfile } from '../lib/authorViewportTypes.ts';
+import { authorGridTools } from './authorGridTools.ts';
+import { addAuthorAnnotation } from './authorWorkspaceStore.ts';
+import { AUTHOR_RUNTIME_BINDING_IDS } from '../api/authorRuntime.ts';
+
+function record(input: unknown): Record<string, unknown> {
+  if (typeof input !== 'object' || input === null || Array.isArray(input)) throw new Error('Expected an object');
+  return input as Record<string, unknown>;
+}
+
+function text(value: unknown, field: string): string {
+  if (typeof value !== 'string') throw new Error(`${field} must be a string`);
+  return value;
+}
+
+function target(input: unknown): { sessionId: string; path: string; value: Record<string, unknown> } {
+  const value = record(input);
+  return { sessionId: text(value.sessionId, 'sessionId'), path: text(value.path, 'path'), value };
+}
+
+const TARGET_PROPERTIES = {
+  sessionId: { type: 'string', minLength: 1 },
+  path: { type: 'string', minLength: 1 },
+} as const;
+
+export const AUTHOR_TEXT_PROFILE: AuthorTrustedProfile = {
+  id: AUTHOR_RUNTIME_BINDING_IDS.text,
+  tools: [
+    {
+      name: 'author_add_comment',
+      label: 'Add comment',
+      description: 'Add a local review comment to one open Author document.',
+      inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['sessionId', 'path', 'body'],
+        properties: { ...TARGET_PROPERTIES, body: { type: 'string' }, quote: { type: 'string' } },
+      },
+      execute: async (input) => {
+        const { sessionId, path, value } = target(input);
+        const body = text(value.body, 'body');
+        addAuthorAnnotation(sessionId, path, {
+          id: `${Date.now()}:${body.length}`,
+          kind: 'comment',
+          body,
+          ...(typeof value.quote === 'string' ? { quote: value.quote } : {}),
+        });
+        return { added: true };
+      },
+    },
+    {
+      name: 'author_add_highlight',
+      label: 'Add highlight',
+      description: 'Highlight a line range in one open Author text document.',
+      inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['sessionId', 'path', 'startLine', 'endLine'],
+        properties: {
+          ...TARGET_PROPERTIES,
+          startLine: { type: 'integer', minimum: 1 },
+          endLine: { type: 'integer', minimum: 1 },
+        },
+      },
+      execute: async (input) => {
+        const { sessionId, path, value } = target(input);
+        if (!Number.isSafeInteger(value.startLine) || !Number.isSafeInteger(value.endLine)) {
+          throw new Error('Highlight lines must be integers');
+        }
+        const startLine = value.startLine as number;
+        const endLine = value.endLine as number;
+        if (startLine < 1 || endLine < startLine) throw new Error('Invalid highlight range');
+        addAuthorAnnotation(sessionId, path, {
+          id: `${Date.now()}:${startLine}:${endLine}`,
+          kind: 'highlight',
+          body: '',
+          startLine,
+          endLine,
+        });
+        return { added: true };
+      },
+    },
+  ],
+};
+
+export const AUTHOR_MEDIA_PROFILE: AuthorTrustedProfile = {
+  id: AUTHOR_RUNTIME_BINDING_IDS.media,
+  tools: [],
+};
+
+export const AUTHOR_TRUSTED_PROFILES = [AUTHOR_TEXT_PROFILE, AUTHOR_MEDIA_PROFILE] as const;
+
+function bindProfile(profile: AuthorTrustedProfile, sessionId: string, path: string): AuthorTrustedProfile {
+  return {
+    id: profile.id,
+    tools: profile.tools.map((tool) => {
+      const schema = tool.inputSchema as Record<string, unknown>;
+      const properties = record(schema.properties);
+      const { sessionId: _sessionId, path: _path, ...boundProperties } = properties;
+      const required = Array.isArray(schema.required)
+        ? schema.required.filter((entry) => entry !== 'sessionId' && entry !== 'path')
+        : [];
+      return {
+        ...tool,
+        inputSchema: { ...schema, properties: boundProperties, required } as AuthorJsonSchema,
+        execute: async (input: unknown, signal: AbortSignal) =>
+          await tool.execute({ ...record(input), sessionId, path }, signal),
+      };
+    }),
+  };
+}
+
+export function authorProfilesForDocument(
+  sessionId: string,
+  path: string,
+  kind: AuthorDocumentKind,
+): readonly AuthorTrustedProfile[] {
+  const profiles =
+    kind === 'image'
+      ? [bindProfile(AUTHOR_MEDIA_PROFILE, sessionId, path)]
+      : kind === 'text' || kind === 'markdown'
+        ? [bindProfile(AUTHOR_TEXT_PROFILE, sessionId, path)]
+        : [];
+  const tools = authorGridTools(sessionId, path, kind);
+  if (tools.length === 0) return profiles;
+  return profiles.length === 0
+    ? [{ id: AUTHOR_RUNTIME_BINDING_IDS.media, tools }]
+    : [{ ...profiles[0]!, tools: [...profiles[0]!.tools, ...tools] }];
+}

package/src/web/stores/authorRequestLifecycle.ts

@@ -0,0 +1,82 @@
+import type { CaptureStatusEvent, ComposerSubmission } from '@agimon-ai/doompi-web-contracts';
+import type { AuthorCapturePacket } from './authorCapture.ts';
+import type { AuthorRegionDraft } from '../lib/authorViewportTypes.ts';
+import {
+  authorSessionWorkspace,
+  putAuthorRequest,
+  removeAuthorRegion,
+  updateAuthorRequest,
+} from './authorWorkspaceStore.ts';
+
+function capturePacket(content: string): AuthorCapturePacket | undefined {
+  try {
+    const value = JSON.parse(content) as Partial<AuthorCapturePacket>;
+    if (
+      value.version !== 1 ||
+      typeof value.captureId !== 'string' ||
+      typeof value.capturedAt !== 'number' ||
+      typeof value.document?.path !== 'string' ||
+      typeof value.document.revision !== 'number' ||
+      !Array.isArray(value.regions) ||
+      value.regions.length === 0
+    ) {
+      return undefined;
+    }
+    return value as AuthorCapturePacket;
+  } catch {
+    return undefined;
+  }
+}
+
+export function recordAuthorComposerSubmission(submission: ComposerSubmission): void {
+  for (const item of submission.contextItems) {
+    if (item.source !== 'author' || item.kind !== 'author-capture') continue;
+    const packet = capturePacket(item.metadata ?? item.content);
+    if (packet === undefined || packet.captureId !== item.id) continue;
+    if (authorSessionWorkspace(submission.sessionId).requests.some((request) => request.captureId === packet.captureId))
+      continue;
+    const regions: AuthorRegionDraft[] = packet.regions.map((region) => ({
+      id: region.id,
+      documentPath: packet.document.path,
+      revision: packet.document.revision,
+      sourceSha256: packet.document.sourceSha256,
+      comment: region.comment,
+      quote: region.quote,
+      anchor: structuredClone(region.anchor),
+      viewport: { ...region.viewport },
+      voiceGrid: region.voiceGrid && { ...region.voiceGrid },
+      createdAt: packet.capturedAt,
+    }));
+    putAuthorRequest(submission.sessionId, {
+      id: crypto.randomUUID(),
+      captureId: packet.captureId,
+      documentPath: packet.document.path,
+      requestText: submission.message,
+      regions,
+      pendingRegions: regions,
+      status: 'REQUESTED',
+      createdAt: submission.submittedAt,
+      updatedAt: submission.submittedAt,
+      revision: packet.document.revision,
+      sourceSha256: packet.document.sourceSha256,
+    });
+    for (const region of packet.regions) removeAuthorRegion(submission.sessionId, region.id);
+  }
+}
+
+/** Only the host's correlated execution events may settle a submitted capture. */
+export function recordAuthorCaptureStatus(event: CaptureStatusEvent): void {
+  const request = authorSessionWorkspace(event.sessionId).requests.find(
+    (record) => record.captureId === event.captureId,
+  );
+  if (request === undefined || ['COMPLETE', 'FAILED', 'CANCELLED'].includes(request.status)) return;
+  if (event.status === 'queued') return;
+  updateAuthorRequest(event.sessionId, request.id, (record) => ({
+    ...record,
+    status: event.status === 'working' ? 'CHANGING' : event.status === 'completed' ? 'COMPLETE' : 'FAILED',
+    currentOperation: event.status === 'working' ? 'Agent is working on this request' : undefined,
+    pendingRegions: event.status === 'completed' ? [] : record.pendingRegions,
+    error: event.status === 'error' ? event.error || 'Request execution failed.' : undefined,
+    updatedAt: Date.now(),
+  }));
+}

package/src/web/stores/authorStore.ts

@@ -0,0 +1,60 @@
+import { defineSessionStore, type SessionChannelContribution } from '@agimon-ai/doompi-web-contracts';
+import { authorChannelType, type AuthorHubMessage, type AuthorWebView } from '../../types/webAuthor.ts';
+import { applyAuthorHubMessage, authorBridgeView, dropAuthorViewportSession } from '../api/authorBrowserBridge.ts';
+import { clearAuthorGridGeometry } from '../lib/authorGrid.ts';
+import { dropAuthorSession } from './authorWorkspaceStore.ts';
+
+export const author = defineSessionStore<AuthorWebView>({ activation: 'inactive', capabilityCount: 0 });
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function parseAuthorHubMessage(input: unknown): AuthorHubMessage | AuthorWebView | null {
+  if (!isRecord(input)) return null;
+  if (
+    (input.activation === 'active' || input.activation === 'inactive') &&
+    Number.isSafeInteger(input.capabilityCount) &&
+    (input.capabilityCount as number) >= 0
+  ) {
+    return input as unknown as AuthorWebView;
+  }
+  if (typeof input.kind !== 'string') return null;
+  if (input.kind === 'rejected')
+    return typeof input.reason === 'string' ? (input as unknown as AuthorHubMessage) : null;
+  if (!Number.isSafeInteger(input.generation) || typeof input.ownerToken !== 'string') return null;
+  if (input.kind === 'accepted') {
+    return typeof input.leaseMs === 'number' &&
+      (input.catalogToken === undefined || typeof input.catalogToken === 'string')
+      ? (input as unknown as AuthorHubMessage)
+      : null;
+  }
+  if (
+    (input.kind === 'request' || input.kind === 'cancel') &&
+    typeof input.catalogToken === 'string' &&
+    typeof input.requestId === 'string'
+  ) {
+    if (input.kind === 'cancel') return input as unknown as AuthorHubMessage;
+    return typeof input.name === 'string' && isRecord(input.arguments) ? (input as unknown as AuthorHubMessage) : null;
+  }
+  return null;
+}
+
+export const authorChannel: SessionChannelContribution<AuthorHubMessage | AuthorWebView> = {
+  channel: authorChannelType,
+  parse: parseAuthorHubMessage,
+  apply(sessionId, message) {
+    if ('activation' in message) {
+      author.update(sessionId, () => message);
+      return;
+    }
+    applyAuthorHubMessage(sessionId, message);
+    author.update(sessionId, () => authorBridgeView(sessionId));
+  },
+  drop(sessionId) {
+    clearAuthorGridGeometry(sessionId);
+    dropAuthorViewportSession(sessionId);
+    dropAuthorSession(sessionId);
+    author.drop(sessionId);
+  },
+};