@things-factory/ai-assistant 10.1.88 → 10.1.91

package/client/utils/entry-proposal.ts

@@ -0,0 +1,103 @@
+/*
+ * The data entry card's rules and its handler (operato-application/design/ai/data-entry.md §5).
+ *
+ * The card is a review, not an editor: a correction is said in the conversation and the model proposes
+ * again - the newer card replaces the older one. Pressing asks the server to enter the stored rows; the
+ * screen sends no rows of its own.
+ */
+import type { ProposalContext, ProposalOutcome } from './assistant-proposals.js'
+
+export interface EntryIssueView {
+  field?: string
+  code: string
+  messageKey?: string
+  params?: Record<string, unknown>
+  blocking: boolean
+}
+
+export interface EntryRowView {
+  index: number
+  values: Record<string, unknown>
+  sources: { attachmentId?: string; where?: string }[]
+  issues: EntryIssueView[]
+  /** The server found this row's numbers and dates together on this line of the cited file. */
+  evidence?: { attachmentId: string; line: number }
+}
+
+export interface EntryTotalView {
+  field: string
+  all: number
+  ready: number
+  declared?: number
+  declaredFound?: boolean
+  difference?: number
+}
+
+export interface EntryRowResult {
+  index: number
+  ok: boolean
+  id?: string
+  label?: string
+  error?: string
+}
+
+export interface EntryApplyAnswer extends ProposalOutcome {
+  rows?: EntryRowResult[]
+}
+
+export function isEntryProposal(proposal: any): boolean {
+  return proposal?.kind === 'entry' && Array.isArray(proposal?.rows)
+}
+
+export function entryReadyCount(proposal: any): number {
+  return (proposal?.rows ?? []).filter((row: EntryRowView) => !row.issues?.some(issue => issue.blocking)).length
+}
+
+/** The i18n key of an issue - the target's own, or the framework's by code. */
+export function entryIssueKey(issue: EntryIssueView): string {
+  return issue.messageKey || `ai-assistant.entry.issue.${issue.code}`
+}
+
+/** The issues of one cell, and of the row as a whole (no field). */
+export function entryCellIssues(row: EntryRowView, field?: string): EntryIssueView[] {
+  return (row.issues ?? []).filter(issue => (field ? issue.field === field : !issue.field))
+}
+
+/** What stays in the conversation - the model reads it on its next turn, and the person sees what went in. */
+export function entryOutcomeNote(answer: EntryApplyAnswer, t: (key: string, options?: any) => string): string {
+  const refused = (answer.rows ?? []).filter(row => !row.ok)
+  const head = answer.applied
+    ? t('ai-assistant.entry.entered', { defaultValue: 'entered {count} rows.', count: answer.applied })
+    : t('ai-assistant.entry.entered-none', { defaultValue: 'no row was entered.' })
+  const lines = refused.slice(0, 20).map(row => t('ai-assistant.entry.row-refused', { defaultValue: 'row {n}: {reason}', n: row.index + 1, reason: row.error || '' }))
+  const more = refused.length > 20 ? [t('ai-assistant.entry.more-refused', { defaultValue: '{count} more rows were not entered.', count: refused.length - 20 })] : []
+  return [head, ...lines, ...more].join('\n')
+}
+
+/** The handler every entry card runs - built with the mutation so the rules are tested without a server. */
+export function entryProposalHandler(
+  apply: (sessionId: string, proposalKey: string) => Promise<EntryApplyAnswer>,
+  t: (key: string, options?: any) => string
+) {
+  return async (proposal: any, context: ProposalContext): Promise<ProposalOutcome> => {
+    if (!context.sessionId || !proposal?.key) return { verdict: 'unavailable', errorCode: 'no-conversation' }
+    const answer = await apply(context.sessionId, proposal.key)
+    return {
+      verdict: answer.verdict,
+      ...(answer.errorCode ? { errorCode: answer.errorCode } : {}),
+      applied: answer.applied ?? 0,
+      missed: answer.missed ?? 0,
+      note: entryOutcomeNote(answer, t)
+    }
+  }
+}
+
+/**
+ * The newest card per record, over the conversation's proposals in order - an older one is replaced and
+ * cannot be entered (the server refuses it as `superseded`; the card says so before anyone presses).
+ */
+export function latestEntryKeys(proposalsInOrder: any[][]): Map<string, string> {
+  const latest = new Map<string, string>()
+  for (const list of proposalsInOrder) for (const one of list ?? []) if (isEntryProposal(one) && one.key) latest.set(one.target, one.key)
+  return latest
+}

package/client/utils/workspace.ts

@@ -0,0 +1,89 @@
+/*
+ * The AI 작업판 on the screen - which versions a workspace has, and the table's sort and CSV
+ * (operato-application/design/ai/workspace.md). Pure - tested without a browser.
+ */
+
+export interface WorkspaceBlockView {
+  kind: string
+  [key: string]: any
+}
+
+export interface WorkspaceView {
+  name: string
+  title: string
+  summary?: string
+  blocks: WorkspaceBlockView[]
+}
+
+export interface WorkspaceVersion {
+  /** 1-based, in the order the conversation made them. */
+  version: number
+  messageId: string
+  createdAt?: string
+  workspace: WorkspaceView
+}
+
+export function isWorkspaceProposal(proposal: any): boolean {
+  return proposal?.kind === 'workspace' && !!proposal?.workspace?.name
+}
+
+/**
+ * Every version of the named workspace in a conversation, oldest first. A message the reader may not see
+ * comes back redacted without its proposals, so a version behind a door is simply not among them.
+ */
+export function workspaceVersions(messages: { id: string; createdAt?: string; proposalsJson?: any[] | null }[], name: string): WorkspaceVersion[] {
+  const versions: WorkspaceVersion[] = []
+  for (const message of messages) {
+    for (const proposal of message.proposalsJson ?? []) {
+      if (isWorkspaceProposal(proposal) && proposal.workspace.name === name) {
+        versions.push({ version: versions.length + 1, messageId: message.id, createdAt: message.createdAt, workspace: proposal.workspace })
+      }
+    }
+  }
+  return versions
+}
+
+/** The version of a card within its conversation - "2 of 3" on the card and on the page. */
+export function versionOfCard(proposalsInOrder: any[][], name: string, key: string): { version: number; of: number } {
+  let version = 0
+  let of = 0
+  for (const list of proposalsInOrder)
+    for (const one of list ?? []) {
+      if (!isWorkspaceProposal(one) || one.workspace.name !== name) continue
+      of += 1
+      if (one.key === key) version = of
+    }
+  return { version, of }
+}
+
+export function workspaceAddress(sessionId: string, name: string, version?: number): string {
+  const query = new URLSearchParams({ session: sessionId, name })
+  if (version) query.set('version', String(version))
+  return `assistant-workspace?${query.toString()}`
+}
+
+/** Sorts by one column - numbers as numbers, empty last, the rest by the reader's collation. */
+export function sortRows(rows: Record<string, any>[], column: string, direction: 'asc' | 'desc', locale?: string): Record<string, any>[] {
+  const factor = direction === 'asc' ? 1 : -1
+  const collator = new Intl.Collator(locale, { numeric: true })
+  return [...rows].sort((a, b) => {
+    const x = a[column]
+    const y = b[column]
+    const emptyX = x === null || x === undefined || x === ''
+    const emptyY = y === null || y === undefined || y === ''
+    if (emptyX || emptyY) return emptyX === emptyY ? 0 : emptyX ? 1 : -1
+    if (typeof x === 'number' && typeof y === 'number') return (x - y) * factor
+    return collator.compare(String(x), String(y)) * factor
+  })
+}
+
+const csvCell = (value: unknown) => {
+  const text = value === null || value === undefined ? '' : String(value)
+  return /[",\n\r]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text
+}
+
+/** The table as CSV - the heading row in the column labels, a BOM so a spreadsheet reads Korean. */
+export function tableCsv(columns: { name: string; label?: string }[], rows: Record<string, any>[]): string {
+  const lines = [columns.map(column => csvCell(column.label || column.name)).join(','), ...rows.map(row => columns.map(column => csvCell(row[column.name])).join(','))]
+  return '' + lines.join('\r\n')
+}

package/dist-client/components/assistant-chat.d.ts

@@ -20,6 +20,7 @@ import { LitElement } from 'lit';
 import './mention-popup.js';
 import { type FilterResult } from './mention-popup.js';
 import { type AssistantMode } from './assistant-mode.js';
+import './entry-review.js';
 export interface ChatAttachment {
     id: string;
     file: File;
@@ -539,6 +540,8 @@ export declare class OxAssistantChat extends LitElement {
      * 실행 결과는 호스트가 **대화에 기록**한다 — 누가 무엇을 실행했는지가 협의 이력에 남아야 한다.
      */
     private renderProposals;
+    /** The AI 작업판 card - what it holds, which version, and the way to open it. The person opens it; the model does not. */
+    private renderWorkspaceCard;
     /**
      * 눌린 카드가 말하는 것 — **호스트가 한 일**이고, 아직 모르면 모른다고 말한다.
      *

package/dist-client/components/assistant-chat.js

@@ -47,6 +47,9 @@ import { chatDefaults } from './chat-defaults.js';
 import { isDifferentConversation, resolveConversation, pickInitialMode } from './assistant-mode.js';
 import { parseProposalOutcomeLine, parseProposalRequestLine, proposalCardState } from './proposal-outcome-line.js';
 import { availableTriggers } from './chat-triggers.js';
+import './entry-review.js';
+import { entryReadyCount, isEntryProposal, latestEntryKeys } from '../utils/entry-proposal.js';
+import { isWorkspaceProposal, versionOfCard, workspaceAddress } from '../utils/workspace.js';
 function formatFileSize(bytes) {
     if (!bytes || bytes < 1024)
         return `${bytes || 0} B`;
@@ -3500,12 +3503,20 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
         /* The card's state is the conversation's rows - read once for every card of this line. */
         const outcomes = this.proposalOutcomes;
         const requested = this.proposalRequests;
+        /* A data entry card replaced by a newer one for the same record cannot be entered (design/ai/data-entry.md §5). */
+        const latestEntry = items.some(isEntryProposal) ? latestEntryKeys(this.lines.map(one => one.proposals ?? [])) : undefined;
         return html `
       <div class="proposals">
         ${items.map(p => {
             const key = this.proposalKey(p);
+            /* A workspace card opens the page; it runs nothing (design/ai/workspace.md §4). */
+            if (isWorkspaceProposal(p))
+                return this.renderWorkspaceCard(p, key);
             const card = proposalCardState(key, { outcomes, requested, sentHere: this.sentProposals.has(key) });
-            const sent = card.state !== 'ready';
+            const entry = isEntryProposal(p);
+            const replaced = entry && latestEntry?.get(p.target) !== key && card.state === 'ready';
+            const ready = entry ? entryReadyCount(p) : 0;
+            const sent = card.state !== 'ready' || replaced || (entry && ready === 0);
             /*
               Follow-up chips are the host's words, never this component's. The fallback that used
               to live here named a 3D modeller's operations in hardcoded Korean, and it reached the
@@ -3516,7 +3527,7 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
             <div class="proposal ${sent ? 'sent' : ''}">
               <md-icon>${p.icon || (p.source ? 'view_in_ar' : 'bolt')}</md-icon>
               <span class="pbody">
-                <span class="plabel">${p.label || p.command}</span>
+                <span class="plabel">${entry && p.labelKey ? i18next.t(p.labelKey) : p.label || p.command}</span>
                 ${p.reason ? html `<span class="preason">${p.reason}</span>` : nothing}
               </span>
               ${ /*
@@ -3538,9 +3549,15 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
                       class="run"
                       ?disabled=${sent}
                       @click=${() => this.executeProposal(p, key)}>
-                      ${sent
-                    ? this.proposalStateText(key)
-                    : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
+                      ${replaced
+                    ? i18next.t('ai-assistant.entry.replaced', { defaultValue: 'replaced by a newer card' })
+                    : card.state !== 'ready'
+                        ? this.proposalStateText(key)
+                        : entry
+                            ? ready
+                                ? i18next.t('ai-assistant.entry.enter', { defaultValue: 'enter {count} rows', count: ready })
+                                : i18next.t('ai-assistant.entry.nothing-to-enter', { defaultValue: 'nothing to enter' })
+                            : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
                     </button>
                   `}
               ${ /*
@@ -3556,6 +3573,7 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
                 </span>
               ` : nothing}
             </div>
+            ${entry ? html `<ox-assistant-entry-review .proposal=${p}></ox-assistant-entry-review>` : nothing}
             ${rawChoices.length ? html `
               <div class="proposal-choices" role="group" aria-label=${i18next.t('ai-assistant.text.proposal-choices', { defaultValue: 'follow-up choices' })}>
                 ${rawChoices.map((c) => html `
@@ -3574,6 +3592,29 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
       </div>
     `;
     }
+    /** The AI 작업판 card - what it holds, which version, and the way to open it. The person opens it; the model does not. */
+    renderWorkspaceCard(p, key) {
+        const { version, of } = versionOfCard(this.lines.map(one => one.proposals ?? []), p.workspace.name, key);
+        const contents = Object.entries(p.contents ?? {})
+            .map(([kind, count]) => String(i18next.t(`ai-assistant.workspace.contains-${kind}`, { defaultValue: `${kind} {count}`, count: Number(count) })))
+            .join(' · ');
+        const open = () => {
+            if (!this.sessionId)
+                return;
+            /* The page is the application's; navigate is the shell's, reached by an event so this component stays standalone. */
+            this.dispatchEvent(new CustomEvent('assistant-open-page', { detail: { href: workspaceAddress(this.sessionId, p.workspace.name, version) }, bubbles: true, composed: true }));
+        };
+        return html `
+      <div class="proposal workspace">
+        <md-icon>${p.icon || 'dashboard'}</md-icon>
+        <span class="pbody">
+          <span class="plabel">${p.workspace.title}</span>
+          <span class="preason">${[contents, of > 1 ? i18next.t('ai-assistant.workspace.version', { defaultValue: 'version {version} of {of}', version, of }) : ''].filter(Boolean).join(' · ')}</span>
+        </span>
+        <button class="run" ?disabled=${!this.sessionId} @click=${open}>${i18next.t('ai-assistant.workspace.open', { defaultValue: 'open in workspace' })}</button>
+      </div>
+    `;
+    }
     /**
      * 눌린 카드가 말하는 것 — **호스트가 한 일**이고, 아직 모르면 모른다고 말한다.
      *