@things-factory/ai-assistant 10.1.107 → 10.1.109

package/client/utils/pasted-table.ts

@@ -0,0 +1,145 @@
+/*
+ * A table pasted into the composer, carried as a file (design/ai/data-entry.md §4-1, design/ai/shared-dock.md §9-5).
+ *
+ * Rows copied from a spreadsheet or a web page are what an AI 입력 is made from most often. Pasted as words they
+ * reach the model as something the person said, and the entry card cannot check a row against them nor read a
+ * printed total. Carried as a CSV file they are a source like an attached sheet: each row is found on its line.
+ *
+ * - The HTML of the clipboard is read first when it holds a table - a spreadsheet and a browser both put one there,
+ *   and it keeps a cell that holds a line break or a tab whole. A web page whose words lie mostly outside the table
+ *   is not a table paste; it is left as words.
+ * - Otherwise the plain text is a table when its lines are tab-separated (a spreadsheet's own text).
+ * - The file has the shape of a read sheet: a line naming it, then every row led by its own number.
+ * - The limit is on the text, as for a sheet - a table over it is refused, never cut.
+ *
+ * Pure: the screen hands in the clipboard's strings.
+ */
+import { textCharsOf, type AttachmentPolicy } from './attachment-policy.js'
+import { csvField } from './spreadsheet-text.js'
+
+export interface PastedTable {
+  rows: string[][]
+  columns: number
+}
+
+/** Words outside the table beyond this are a page that holds a table, not a table. */
+const WORDS_OUTSIDE_A_TABLE = 20
+
+const ENTITIES: Record<string, string> = { nbsp: ' ', amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", '#39': "'" }
+
+function decodeEntities(text: string): string {
+  return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+\d*|#39);/gi, (whole, name: string) => {
+    const lower = name.toLowerCase()
+    if (lower in ENTITIES) return ENTITIES[lower]
+    if (lower.startsWith('#x')) return String.fromCodePoint(parseInt(lower.slice(2), 16))
+    if (lower.startsWith('#')) return String.fromCodePoint(parseInt(lower.slice(1), 10))
+    return whole
+  })
+}
+
+/** What a piece of HTML shows as words - a line break and a cell's own breaks become one space. */
+function wordsOf(html: string): string {
+  return decodeEntities(html.replace(/<br\s*\/?>/gi, ' ').replace(/<[^>]*>/g, ''))
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+/** What the clipboard's HTML shows, without what is never shown - comments, styles, scripts, the head. */
+function shownHtml(html: string): string {
+  return html
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/<(style|script|head)\b[\s\S]*?<\/\1\s*>/gi, '')
+}
+
+/** The rows of the tables in the clipboard's HTML, or null when it holds none or is mostly not a table. */
+export function tableOfHtml(html: string | null | undefined): string[][] | null {
+  if (!html || !/<table\b/i.test(html)) return null
+  const shown = shownHtml(html)
+  const outside = wordsOf(shown.replace(/<table\b[\s\S]*?<\/table\s*>/gi, ' '))
+  if (outside.replace(/\s/g, '').length > WORDS_OUTSIDE_A_TABLE) return null
+
+  const rows: string[][] = []
+  for (const part of shown.split(/<tr\b[^>]*>/i).slice(1)) {
+    const body = part.split(/<\/table\s*>/i)[0]
+    const row: string[] = []
+    for (const cell of body.matchAll(/<(td|th)\b([^>]*)>([\s\S]*?)(?=<\/?(?:td|th|tr)\b|$)/gi)) {
+      row.push(wordsOf(cell[3]))
+      const span = Number(/\bcolspan\s*=\s*["']?(\d+)/i.exec(cell[2])?.[1] ?? 1)
+      for (let more = 1; more < Math.min(span, 100); more++) row.push('')
+    }
+    if (row.some(text => text !== '')) rows.push(row)
+  }
+  return rows.length ? rows : null
+}
+
+/** The rows of a spreadsheet's plain text - tab-separated lines, a cell with a break or a tab in quotes. */
+export function tableOfText(text: string | null | undefined): string[][] | null {
+  if (!text || !text.includes('\t')) return null
+  const rows: string[][] = []
+  let row: string[] = []
+  let cell = ''
+  let quoted = false
+  for (let at = 0; at < text.length; at++) {
+    const c = text[at]
+    if (quoted) {
+      if (c === '"' && text[at + 1] === '"') (cell += '"'), at++
+      else if (c === '"') quoted = false
+      else cell += c
+    } else if (c === '"' && cell === '') quoted = true
+    else if (c === '\t') row.push(cell), (cell = '')
+    else if (c === '\n' || c === '\r') {
+      if (c === '\r' && text[at + 1] === '\n') at++
+      row.push(cell), rows.push(row), (row = []), (cell = '')
+    } else cell += c
+  }
+  if (cell !== '' || row.length) row.push(cell), rows.push(row)
+  const kept = rows.map(one => one.map(text => text.replace(/\s+/g, ' ').trim())).filter(one => one.some(text => text !== ''))
+  /* One tab in a sentence is not a table - most lines must be split into columns. */
+  if (kept.filter(one => one.length > 1).length < Math.max(2, Math.ceil(kept.length / 2))) return null
+  return kept
+}
+
+/** The table a paste holds, or null for words - at least two rows of at least two columns. */
+export function pastedTable(clipboard: { html?: string | null; text?: string | null }): PastedTable | null {
+  const fromHtml = tableOfHtml(clipboard.html)
+  /* A page the HTML shows to be mostly words stays words - its plain text would read the table out of it anyway. */
+  if (!fromHtml && clipboard.html && /<table\b/i.test(clipboard.html)) return null
+  for (const rows of [fromHtml, tableOfText(clipboard.text)]) {
+    if (!rows) continue
+    const trimmed = rows.map(row => {
+      let cells = row
+      while (cells.length && cells[cells.length - 1] === '') cells = cells.slice(0, -1)
+      return cells
+    })
+    const columns = Math.max(...trimmed.map(row => row.length))
+    if (trimmed.length >= 2 && columns >= 2) return { rows: trimmed, columns }
+  }
+  return null
+}
+
+/** The table as the text of its file: a line naming it, then every row led by its own number. */
+export function pastedTableText(table: PastedTable, name: string): string {
+  const lines = table.rows.map((row, i) => [String(i + 1), ...row].map(csvField).join(','))
+  return [`# ${name} · a table the person pasted · the first column is the row number in the pasted table`, ...lines].join('\n') + '\n'
+}
+
+export type PasteRefusal = { code: 'attachment-paste-too-long'; rows: number; maxChars: number }
+
+/**
+ * What a paste becomes in a conversation under this policy: a table file, a refusal, or null - the paste stays words
+ * (no table in it, or a conversation that takes no text files).
+ */
+export function pastedTableFile(
+  clipboard: { html?: string | null; text?: string | null },
+  policy: AttachmentPolicy | null | undefined,
+  nameOf: (rows: number) => string
+): { name: string; text: string } | { refusal: PasteRefusal } | null {
+  if (!policy?.kinds?.some(kind => kind === 'text' || kind === 'spreadsheet')) return null
+  const table = pastedTable(clipboard)
+  if (!table) return null
+  const name = nameOf(table.rows.length)
+  const text = pastedTableText(table, name)
+  const maxChars = textCharsOf(policy)
+  if (text.length > maxChars) return { refusal: { code: 'attachment-paste-too-long', rows: table.rows.length, maxChars } }
+  return { name: `${name.replace(/[\\/:*?"<>|]/g, '_')}.csv`, text }
+}

package/client/utils/spreadsheet-text.ts

@@ -0,0 +1,125 @@
+/*
+ * A spreadsheet read into text the conversation can carry (design/ai/shared-dock.md §9-5).
+ *
+ * The door takes images and text only; a mode that opens 'spreadsheet' has the screen read each .xlsx sheet into
+ * CSV before sending, so the model reads the sheet and the entry card can name where a row came from.
+ *
+ * - Read with exceljs. The old binary .xls is not read - it is refused by name (exceljs cannot open it, and the
+ *   npm SheetJS that can has unfixed flaws; a file a person uploads is not opened with it).
+ * - A cell is its value - a formula as its computed result, a date as ISO, rich text as its text.
+ * - Every line carries the sheet's own row number. Empty rows are left out, never renumbered, so "sheet · row" on a
+ *   card is the row the person sees in Excel.
+ * - The limit is on the text after reading - a small .xlsx can be a long text. A sheet over it is refused, never cut:
+ *   a cut ledger is read as the whole ledger.
+ */
+
+export type SpreadsheetKind = 'xlsx' | 'xls'
+
+const XLSX_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+const XLS_TYPE = 'application/vnd.ms-excel'
+
+/** A spreadsheet by its type, or by its name when the browser did not know the type. */
+export function spreadsheetKindOf(file: { type?: string; name?: string }): SpreadsheetKind | null {
+  const type = (file.type || '').toLowerCase()
+  const name = (file.name || '').toLowerCase()
+  if (type === XLSX_TYPE || name.endsWith('.xlsx')) return 'xlsx'
+  if (type === XLS_TYPE || name.endsWith('.xls')) return 'xls'
+  return null
+}
+
+/** The picker's `accept` for spreadsheets. */
+export const SPREADSHEET_ACCEPT = ['.xlsx', XLSX_TYPE]
+
+const pad = (n: number) => String(n).padStart(2, '0')
+
+/** One cell as text - what Excel shows as the value, not how it is stored. */
+export function cellText(value: unknown): string {
+  if (value === null || value === undefined) return ''
+  if (value instanceof Date) {
+    if (isNaN(value.getTime())) return ''
+    const day = `${value.getUTCFullYear()}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`
+    const h = value.getUTCHours()
+    const m = value.getUTCMinutes()
+    const s = value.getUTCSeconds()
+    return h || m || s ? `${day}T${pad(h)}:${pad(m)}:${pad(s)}` : day
+  }
+  if (typeof value === 'object') {
+    const v = value as any
+    if ('result' in v) return cellText(v.result)
+    if ('formula' in v || 'sharedFormula' in v) return ''
+    if (Array.isArray(v.richText)) return v.richText.map((part: any) => part?.text ?? '').join('')
+    if ('text' in v) return cellText(v.text)
+    if ('error' in v) return String(v.error)
+    return ''
+  }
+  return String(value)
+}
+
+/** One CSV field - quoted when it holds a comma, a quote or a line break. */
+export const csvField = (text: string) => (/[",\n\r]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text)
+
+export interface SheetRow {
+  /** The row number in the sheet - 1 for Excel's first row. */
+  number: number
+  cells: unknown[]
+}
+
+/** One sheet as CSV: a line naming the file and sheet, then every non-empty row led by its own row number. */
+export function sheetText(fileName: string, sheetName: string, rows: SheetRow[]): string {
+  const lines = rows
+    .map(row => ({ number: row.number, cells: row.cells.map(cellText) }))
+    .filter(row => row.cells.some(cell => cell.trim() !== ''))
+    .map(row => {
+      let cells = row.cells
+      while (cells.length && cells[cells.length - 1] === '') cells = cells.slice(0, -1)
+      return [String(row.number), ...cells].map(csvField).join(',')
+    })
+  return [`# ${fileName} · sheet "${sheetName}" · the first column is the sheet's own row number`, ...lines].join('\n') + '\n'
+}
+
+export interface SheetFile {
+  name: string
+  text: string
+}
+
+export type SpreadsheetRefusal = { code: 'attachment-xls-not-read'; name: string } | { code: 'attachment-sheet-too-long'; name: string; maxChars: number } | { code: 'attachment-sheet-unreadable'; name: string }
+  | { code: 'attachment-sheet-empty'; name: string }
+
+/** The file name a sheet travels under - "거래내역.xlsx" sheet "9월" → "거래내역 - 9월.csv". */
+export function sheetFileName(fileName: string, sheetName: string): string {
+  return `${fileName.replace(/\.xlsx?$/i, '')} - ${sheetName.replace(/[\\/:*?"<>|]/g, '_')}.csv`
+}
+
+/**
+ * Every non-empty sheet of an .xlsx as text, or why not. `load` is exceljs's Workbook - passed in so the screen
+ * loads the library only when a spreadsheet is attached.
+ */
+export async function readSpreadsheet(
+  data: ArrayBuffer | Uint8Array,
+  fileName: string,
+  maxChars: number,
+  Workbook: new () => any
+): Promise<{ files: SheetFile[] } | { refusal: SpreadsheetRefusal }> {
+  const workbook = new Workbook()
+  try {
+    await workbook.xlsx.load(data)
+  } catch {
+    return { refusal: { code: 'attachment-sheet-unreadable', name: fileName } }
+  }
+  const files: SheetFile[] = []
+  for (const sheet of workbook.worksheets) {
+    const rows: SheetRow[] = []
+    sheet.eachRow({ includeEmpty: false }, (row: any, number: number) => {
+      const values = Array.isArray(row.values) ? row.values.slice(1) : []
+      rows.push({ number, cells: values })
+    })
+    if (!rows.length) continue
+    const text = sheetText(fileName, sheet.name, rows)
+    const name = sheetFileName(fileName, sheet.name)
+    if (text.length > maxChars) return { refusal: { code: 'attachment-sheet-too-long', name: `${fileName} · ${sheet.name}`, maxChars } }
+    files.push({ name, text })
+  }
+  /* A workbook with nothing in it is said, not dropped: the person would think it was sent. */
+  if (!files.length) return { refusal: { code: 'attachment-sheet-empty', name: fileName } }
+  return { files }
+}

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

@@ -234,6 +234,8 @@ export declare class OxAssistantChat extends LitElement {
     /** A refusal in the reader's words - the same keys the door uses. */
     private attachmentRefusalText;
     private onAttachFiles;
+    /** Each .xlsx replaced by one CSV file per sheet; any other file passes as it is. */
+    private readSpreadsheets;
     private readFileAsBase64;
     private removeAttachment;
     private onComposerPaste;

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

@@ -27,7 +27,10 @@ import { i18next } from '@operato/i18n';
 import { ScrollbarStyles } from '@operato/styles';
 import gql from 'graphql-tag';
 import { renderMarkdown, injectMentionRefids, injectMentionUserIds, stripMentionRefids } from './markdown.js';
-import { acceptOf, chatAttachmentUrl, refuseAttachments } from '../utils/attachment-policy.js';
+import { acceptOf, chatAttachmentUrl, refuseAttachments, textCharsOf } from '../utils/attachment-policy.js';
+import { pastedTableFile } from '../utils/pasted-table.js';
+import { readSpreadsheet, spreadsheetKindOf } from '../utils/spreadsheet-text.js';
+import { entryReviewAddress, offersWorkspaceReview } from '../utils/entry-workspace.js';
 import { buildAssistantChatInput, buildChatMutationInput } from './chat-input-builder.js';
 import { receiveRemoteMessage, reconcileSentLine, remoteMessageToLine } from './chat-echo-dedup.js';
 import './mention-popup.js';
@@ -449,7 +452,16 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
     async onAttachFiles(files) {
         if (!files || files.length === 0)
             return;
-        const list = Array.from(files);
+        let list = Array.from(files);
+        if (this.usesAttachmentPolicy && this.modeView?.attachments?.kinds?.includes('spreadsheet')) {
+            /* A spreadsheet travels as the text of its sheets (§9-5) - read here, refused by name when it cannot be. */
+            const read = await this.readSpreadsheets(list);
+            if ('refusal' in read) {
+                this.errorMessage = String(i18next.t(`ai-assistant.text.${read.refusal.code}`, { ...read.refusal, defaultValue: read.refusal.code }));
+                return;
+            }
+            list = read.files;
+        }
         if (this.usesAttachmentPolicy) {
             /* Said before anything is sent - never cut silently (§9-1). */
             const refusal = refuseAttachments(this.modeView?.attachments, [...this.attachments, ...list].map(f => ({ name: f.name, type: f.type, size: f.size })));
@@ -481,6 +493,30 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
         }
         this.attachments = [...this.attachments, ...newAttachments];
     }
+    /** Each .xlsx replaced by one CSV file per sheet; any other file passes as it is. */
+    async readSpreadsheets(list) {
+        const out = [];
+        let Workbook;
+        for (const file of list) {
+            const kind = spreadsheetKindOf(file);
+            if (!kind) {
+                out.push(file);
+                continue;
+            }
+            if (kind === 'xls')
+                return { refusal: { code: 'attachment-xls-not-read', name: file.name } };
+            if (!Workbook) {
+                const mod = await import('exceljs');
+                Workbook = (mod.default ?? mod).Workbook;
+            }
+            const read = await readSpreadsheet(await file.arrayBuffer(), file.name, textCharsOf(this.modeView?.attachments), Workbook);
+            if ('refusal' in read)
+                return read;
+            for (const sheet of read.files)
+                out.push(new File([sheet.text], sheet.name, { type: 'text/csv' }));
+        }
+        return { files: out };
+    }
     readFileAsBase64(file) {
         return new Promise((resolve, reject) => {
             const reader = new FileReader();
@@ -500,6 +536,22 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
         const items = e.clipboardData?.items;
         if (!items || items.length === 0)
             return;
+        /*
+          Rows copied from a spreadsheet or a web page travel as a file, so the entry card can check each row against
+          its line. A spreadsheet also puts a picture of the cells on the clipboard - with the table taken, it is left.
+        */
+        if (this.usesAttachmentPolicy) {
+            const pasted = pastedTableFile({ html: e.clipboardData?.getData('text/html'), text: e.clipboardData?.getData('text/plain') }, this.modeView?.attachments, rows => String(i18next.t('ai-assistant.text.pasted-table-name', { rows, defaultValue: 'pasted table ({rows} rows)' })));
+            if (pasted) {
+                e.preventDefault();
+                if ('refusal' in pasted) {
+                    this.errorMessage = String(i18next.t(`ai-assistant.text.${pasted.refusal.code}`, { ...pasted.refusal, defaultValue: pasted.refusal.code }));
+                    return;
+                }
+                this.onAttachFiles([new File([pasted.text], pasted.name, { type: 'text/csv' })]);
+                return;
+            }
+        }
         const files = [];
         for (let i = 0; i < items.length; i++) {
             const item = items[i];
@@ -1619,6 +1671,42 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
       color: inherit;
     }
 
+    /* The entry card's way to the large review - a quiet action under its table, never a second run button. */
+    .workspace-review {
+      display: flex;
+      align-items: center;
+      gap: 5px;
+      margin: 6px 0 0 auto;
+      padding: 5px 11px 5px 9px;
+      border: 1px solid transparent;
+      border-radius: 999px;
+      background: transparent;
+      color: var(--md-sys-color-primary, #0f766e);
+      font-family: inherit;
+      font-size: 12px;
+      font-weight: 600;
+      letter-spacing: 0.01em;
+      cursor: pointer;
+      transition:
+        background-color 0.14s ease-in-out,
+        border-color 0.14s ease-in-out;
+    }
+    .workspace-review md-icon {
+      --md-icon-size: 15px;
+      color: inherit;
+    }
+    .workspace-review:hover {
+      background: color-mix(in srgb, var(--md-sys-color-primary, #0f766e) 8%, transparent);
+      border-color: color-mix(in srgb, var(--md-sys-color-primary, #0f766e) 24%, transparent);
+    }
+    .workspace-review:active {
+      background: color-mix(in srgb, var(--md-sys-color-primary, #0f766e) 14%, transparent);
+    }
+    .workspace-review:focus-visible {
+      outline: 2px solid var(--md-sys-color-primary, #0f766e);
+      outline-offset: 1px;
+    }
+
     /* ── 접지 경고 — 근거에 없는 대상을 지목한 답 ───── */
     .grounding-warning {
       display: flex;
@@ -2899,6 +2987,12 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
     `;
     }
     onKeyDown(e) {
+        /*
+          The Enter that ends a Korean (or Japanese, Chinese) syllable belongs to the input method - sending on it
+          sends the line without its last syllable, which then lands in the emptied box.
+        */
+        if (e.isComposing || e.keyCode === 229)
+            return;
         // Mention popup 활성 시 — 화살표/Enter/Tab/Esc 가로채서 popup 네비게이션
         if (this.mentionOpen) {
             if (e.key === 'ArrowDown') {
@@ -3576,6 +3670,15 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
               ` : nothing}
             </div>
             ${entry ? html `<ox-assistant-entry-review .proposal=${p}></ox-assistant-entry-review>` : nothing}
+            ${entry && this.sessionId && offersWorkspaceReview(p)
+                ? html `<button
+                  class="workspace-review"
+                  @click=${() => this.dispatchEvent(new CustomEvent('assistant-open-page', { detail: { href: entryReviewAddress(this.sessionId, key) }, bubbles: true, composed: true }))}
+                >
+                  <md-icon>open_in_full</md-icon>
+                  <span>${i18next.t('ai-assistant.entry.review-in-workspace', { defaultValue: 'review in the workspace' })}</span>
+                </button>`
+                : 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 `