@anchrd/intel-ui 0.32.0 → 0.34.0

package/src/i18n/es.json

@@ -74,6 +74,7 @@
   "resource.move": "Mover",
   "resource.renameTitle": "Cambiar el nombre de {title}",
   "resource.archive": "Archivar",
+  "resource.columns": "Columnas",
   "resource.export": "Exportar",
   "resource.import": "Importar",
   "resource.validate": "Comprobar",
@@ -117,6 +118,23 @@
   "node.table.summary": "{rows} filas, {columns} columnas",
   "node.table.empty": "Todavía no hay filas. Las filas las añaden los flujos.",
   "node.table.undefined": "Esta tabla todavía no tiene columnas.",
+  "node.table.columnsTitle": "Columnas de {title}",
+  "node.table.columnName": "Nombre de la columna «{column}»",
+  "node.table.columnNewName": "Nombre de la nueva columna",
+  "node.table.columnAdd": "Añadir columna",
+  "node.table.columnDrop": "Eliminar la columna «{column}»",
+  "node.table.columnDropNew": "Eliminar la nueva columna",
+  "node.table.columnsDistinct": "Dos columnas no pueden llevar el mismo nombre.",
+  "node.table.columnsNamed": "Cada columna necesita un nombre.",
+  "node.table.columnsAtLeastOne": "Una tabla necesita al menos una columna.",
+  "node.table.columnsTooLong": "Un nombre de columna puede tener como máximo 120 caracteres.",
+  "node.table.columnsTooMany": "Una tabla puede tener como máximo 64 columnas.",
+  "node.table.columnsDropWarning.one": "Esta columna se elimina con todas sus celdas: {columns}",
+  "node.table.columnsDropWarning.many": "Estas columnas se eliminan con todas sus celdas: {columns}",
+  "node.table.columnsDropRows.none": "Ninguna fila tiene contenido ahí, así que no se pierde nada con ellas.",
+  "node.table.columnsDropRows.one": "Una fila tiene contenido ahí. Seguirá siendo legible en el historial de versiones y en ningún otro sitio.",
+  "node.table.columnsDropRows.many": "{count} filas tienen contenido ahí. Seguirá siendo legible en el historial de versiones y en ningún otro sitio.",
+  "node.table.columnsDropConfirm": "Eliminar y guardar",
   "node.select": "Elige un documento o una carpeta para trabajar con ello.",
   "node.folderEmpty": "En esta carpeta todavía no hay nada. Crea algo con el más de la barra lateral.",
   "node.folderFailed": "Esta carpeta no se ha podido leer.",
@@ -241,6 +259,7 @@
   "flows.node.condition": "Condición",
   "flows.node.subflow": "Flujo",
   "flows.node.output": "Fin",
+  "flows.nodeInvalid": "Ya no existe — sustituye o quita este paso",
   "flows.instruction": "Instrucción para la IA o la persona",
   "flows.instructionHint": "Las condiciones, comprobaciones y bifurcaciones se pueden describir aquí con palabras. No hace falta un paso propio para cada decisión pequeña.",
   "flows.linkEmpty": "Todavía no se ha elegido nada",
@@ -275,9 +294,13 @@
   "flows.tool": "Servidor MCP",
   "flows.selectTool": "Elegir un servidor",
   "flows.operationFailed": "La operación del flujo ha fallado. Carga la versión más reciente e inténtalo de nuevo.",
+  "flows.saveInvalid": "No se ha guardado: {detail}",
+  "flows.saveConflict": "No se ha guardado: otra persona ha cambiado este flujo antes. Carga la versión más reciente e inténtalo de nuevo.",
+  "flows.saveFailed": "El flujo no se ha guardado. Inténtalo de nuevo.",
   "flows.needs": "Qué necesita este flujo",
   "flows.needsNodes": "Documentos",
   "flows.needsTools": "Herramientas",
+  "flows.needsInvalid": "{count} más que ya no existen — sustituye o quita esos pasos",
   "flows.needsHidden": "{count} más que no puedes ver",
   "flows.needsEmpty": "Este flujo no lee ningún documento ni llama a ninguna herramienta.",
   "flows.needsFailed": "Lo que necesita este flujo no se ha podido cargar.",
@@ -344,6 +367,7 @@
   "common.loading": "Cargando…",
   "common.retry": "Intentarlo de nuevo",
   "common.close": "Cerrar",
+  "common.cancel": "Cancelar",
   "common.unavailable": "Intel no está disponible en este momento.",
   "common.noAccess": "Esto no está disponible para ti. Puede que no exista o que ya no esté compartido contigo.",
   "common.noPermission": "No tienes permiso para ver esto.",

package/src/node-editor/node-editor.tsx

@@ -12,6 +12,7 @@ import { Link2 } from "lucide-react";
 import { useEffect, useMemo, useRef, useState } from "react";
 import { ActionSlot } from "@/app/action-slot/action-slot.tsx";
 import { BlockNoteView, defaultSlashMenuItems } from "@/blocknote-view/blocknote-view.tsx";
+import { IntelRequestError } from "@/data/intel-data-provider/intel-data-provider.ts";
 import type { IntelDataProvider } from "@/data/intel-data-provider/intel-data-provider.types.ts";
 import {
   DocumentLinkProvider,
@@ -57,6 +58,28 @@ function editorSnapshot(blocks: unknown): string {
   return JSON.stringify(blocks);
 }
 
+/**
+ * Which of the two sentences a failed save is told with.
+ *
+ * ⚠️ The refusal's `code`, never the server's prose: `POST /nodes/{id}/versions` words the conflict
+ * as `A newer version already exists`, and an English sentence from the API is not a translation
+ * source. The code is the contract (`ProblemDetails.code`), and `IntelRequestError` is what carries
+ * it this far.
+ *
+ * ⚠️ The two are not a vaguer and a sharper wording of one event. `node.saveError` says "reload and
+ * try again", which is right for a network failure and dangerous for a conflict: reloading without
+ * knowing that a foreign version now stands loses either the reader's own work or, on the second
+ * attempt, the other one. That is why this distinction is worth a branch at all (#451).
+ *
+ * ⚠️ Local rather than through `resourceErrorKey`: that one answers for the resource menu and the
+ * column dialog, and its sentences are the `resource.*` ones. The editor has its own two.
+ */
+function saveErrorKey(error: unknown): string {
+  return error instanceof IntelRequestError && error.code === "version_conflict"
+    ? "node.saveConflict"
+    : "node.saveError";
+}
+
 export function NodeEditor({
   data,
   document,
@@ -173,7 +196,7 @@ export function NodeEditor({
       <UnsavedChangesGuard dirty={dirty} />
       {save.isError && (
         <p role="alert" className="mx-6 mt-4 text-sm text-destructive">
-          {i18n.t("node.saveError")}
+          {i18n.t(saveErrorKey(save.error))}
         </p>
       )}
       <TitleRowScrollArea className="min-h-0 flex-1 overflow-y-auto py-6">

package/src/nodes/nodes.tsx

@@ -3,7 +3,9 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useNavigate, useRouterState } from "@tanstack/react-router";
 import { Download, Paperclip } from "lucide-react";
 import { lazy, Suspense } from "react";
+import { treeLevelKey } from "@/app/tree-move/tree-move.tsx";
 import { ViewToggle } from "@/app/view-toggle/view-toggle.tsx";
+import { RefusalNotice } from "@/data/request-refusal/refusal-notice.tsx";
 import { refusalOf } from "@/data/request-refusal/request-refusal.ts";
 import { FolderContents } from "@/folder-contents/folder-contents.tsx";
 import { GraphPane } from "@/graph-pane/graph-pane.tsx";
@@ -41,6 +43,27 @@ export function Nodes() {
   // answered "no" (`packages/ui/CLAUDE.md`). While the request is in flight there is no refusal to
   // report, and the loading line below stays.
   const refusal = refusalOf(document.error);
+  /**
+   * The top level of the tree — the same query the sidebar already holds, by the same key and the
+   * same function, so this is a second reader of one cache entry rather than a second request.
+   *
+   * ⚠️ The screen needs a source of its own because the one above cannot answer here: the refusal
+   * branch hangs on `["node", selectedId]`, and without a selection that query is not enabled at
+   * all. The empty state was therefore reached BEFORE anything had been asked — and it invited the
+   * reader to select something, which is exactly what somebody without `intel.nodes.read` cannot
+   * do. The sidebar beside it has said so since #430; two surfaces, two answers (#445).
+   */
+  const rootLevel = useQuery({
+    queryKey: treeLevelKey(null),
+    queryFn: () => data.listTreeChildren(null),
+    enabled: selectedId === null,
+  });
+  // ⚠️ Off the ERROR, and here that is half the ticket rather than a detail. A sentence about a
+  // missing permission, shown while the answer is still travelling, claims a refusal nobody has
+  // spoken yet — the mistake from #350, and `packages/ui/CLAUDE.md` has the rule: a missing answer
+  // is a reason to say less, never to refuse more. So the negative sentence hangs off the refusal;
+  // until one arrives, what stands is the invitation, which claims nothing about permission.
+  const rootRefusal = refusalOf(rootLevel.error);
   // A folder shows its contents as a graph, and so does the root of the tree (#19). A document has
   // nothing to draw — which is why the switch is not offered on one rather than offered and empty.
   const graphable = selectedId === null || selected?.kind === "folder";
@@ -80,26 +103,17 @@ export function Nodes() {
             }
           />
         ) : !selectedId ? (
-          <div className="grid flex-1 place-items-center p-8 text-center text-sm text-muted-foreground">
-            {i18n.t("node.select")}
-          </div>
+          rootRefusal ? (
+            <RefusalNotice refusal={rootRefusal} />
+          ) : (
+            <div className="grid flex-1 place-items-center p-8 text-center text-sm text-muted-foreground">
+              {i18n.t("node.select")}
+            </div>
+          )
         ) : document.isPending ? (
           <p className="p-6 text-sm text-muted-foreground">{i18n.t("common.loading")}</p>
         ) : refusal ? (
-          /* ⚠️ A refusal is not a failure, and the difference is the whole of #430. Somebody whose
-             share was revoked was left in front of "Loading…" — the worst answer of all, because it
-             says the program is still working. They get a sentence and no retry button: the answer
-             was final, and a button that changes nothing is an invitation to keep waiting.
-
-             ⚠️ One sentence for `404`, whichever of its two reasons applies. Intel answers the same
-             status for "no such node" and "not for you" on purpose — `requireVisible` in
-             `packages/api/src/nodes/nodes.ts` — and a screen that told them apart would undo that
-             from the other side. */
-          <div role="status" className="grid flex-1 place-items-center p-8 text-center text-sm">
-            <p className="max-w-sm text-muted-foreground">
-              {i18n.t(refusal === "no-permission" ? "common.noPermission" : "common.noAccess")}
-            </p>
-          </div>
+          <RefusalNotice refusal={refusal} />
         ) : document.isError || !selected ? (
           <div role="alert" className="grid flex-1 place-items-center p-8 text-center text-sm">
             <div className="space-y-3">

package/src/resource-error.ts

@@ -0,0 +1,33 @@
+/**
+ * Which sentence a refused change to a resource is told with.
+ *
+ * ⚠️ A conflict is the one that must not be swallowed: every write in the product names the state it
+ * was made against — `baseUpdatedAt` for a record, `baseVersionId` for a table — and turns a parallel
+ * edit into a refusal. A refusal nobody words is indistinguishable from a change that went through.
+ *
+ * ⚠️ Flat and on its own since #531, where the table's column dialog became the second reader. It
+ * used to live in `resource-menu.tsx`; importing it from there would have made the menu and the
+ * dialog import each other, and a cycle is a thing that works until the bundler splits differently.
+ */
+export function resourceErrorKey(error: unknown): string {
+  const code =
+    typeof error === "object" && error !== null && "code" in error
+      ? String((error as { code: unknown }).code)
+      : null;
+  switch (code) {
+    // ⚠️ `version_conflict` is the table's word for the same event (`nodes.ts`, `tableStateFor`):
+    // the positions or the mapping were read from a version that is no longer the newest. It is the
+    // conflict sentence and not the general one — "reload it and try again" is exactly the way out,
+    // and letting it fall through to `resource.failed` would tell somebody to reload in the same
+    // breath as claiming nobody knows what happened.
+    case "version_conflict":
+    case "update_conflict":
+    case "flow_update_conflict":
+      return "resource.conflict";
+    case "node_forbidden":
+    case "flow_edit_forbidden":
+      return "resource.forbidden";
+    default:
+      return "resource.failed";
+  }
+}

package/src/resource-menu/resource-menu.tsx

@@ -5,6 +5,7 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useNavigate, useRouterState } from "@tanstack/react-router";
 import {
   Archive,
+  Columns3,
   CornerLeftUp,
   Ellipsis,
   FileArchive,
@@ -34,8 +35,10 @@ import type { TreeEntry } from "@/data/intel-data-provider/intel-data-provider.t
 import { useI18n } from "@/i18n/i18n-context.tsx";
 import { useBundleImport } from "@/import-bundle/import-bundle.tsx";
 import { Modal } from "@/modal/modal.tsx";
+import { resourceErrorKey } from "@/resource-error.ts";
 import { useIntelRouterContext } from "@/router/router-context.ts";
 import { selectedFrom } from "@/router/selection-search.ts";
+import { TableColumnsDialog } from "@/table-columns/table-columns.tsx";
 import { RelativeTime } from "@/time/relative-time.tsx";
 import { useDateTime } from "@/time/time-context.tsx";
 
@@ -92,26 +95,6 @@ export function verbHintKey(verb: ResourceVerb, subject: ResourceTarget["type"]
   return `${subject}.verbHint.${verb}`;
 }
 
-// ⚠️ The same reading `moveErrorKey` does for a move, for the changes this menu makes. A conflict is
-// the one that must not be swallowed: `baseUpdatedAt` turns a parallel edit into a refusal, and a
-// refusal nobody words is indistinguishable from a change that went through.
-export function resourceErrorKey(error: unknown): string {
-  const code =
-    typeof error === "object" && error !== null && "code" in error
-      ? String((error as { code: unknown }).code)
-      : null;
-  switch (code) {
-    case "update_conflict":
-    case "flow_update_conflict":
-      return "resource.conflict";
-    case "node_forbidden":
-    case "flow_edit_forbidden":
-      return "resource.forbidden";
-    default:
-      return "resource.failed";
-  }
-}
-
 /**
  * The three-dot menu.
  *
@@ -140,6 +123,7 @@ export function ResourceMenu({
   const [sharing, setSharing] = useState(false);
   const [linksOpen, setLinksOpen] = useState(false);
   const [versionsOpen, setVersionsOpen] = useState(false);
+  const [columnsOpen, setColumnsOpen] = useState(false);
   const selected = useRouterState({ select: (state) => selectedFrom(state.location.search) });
   const pathname = useRouterState({ select: (state) => state.location.pathname });
   // ⚠️ Dragging is a pointer gesture and nothing else: no keyboard, no screen reader, no touch worth
@@ -165,6 +149,10 @@ export function ResourceMenu({
   // ⚠️ Absent, not disabled — the rule at the top of this file. An import needs a folder to file
   // into; a document has nowhere to put a subtree, and a greyed-out entry would promise it does.
   const importable = node !== null && node.kind === "folder";
+  // ⚠️ Only a table has a header to change, so only a table carries the entry — absent, not
+  // disabled, the rule at the top of this file. Until #531 the header could be changed over MCP and
+  // nowhere else: a person had strictly less reach on their own table than a model did.
+  const isTable = node !== null && node.kind === "table";
   const bundleImport = useBundleImport({ where: title });
 
   // Everything a change here can make stale. The row sits in one level of the tree, the open screen
@@ -296,6 +284,15 @@ export function ResourceMenu({
             <Pencil aria-hidden="true" />
             {i18n.t("resource.rename")}
           </DropdownMenuItem>
+          {/* Directly under the rename, because they are the same gesture at two levels: one names
+              the table, the other names its columns. A reader looking for "change what this is
+              called" finds both without reading the rest of the menu (#531). */}
+          {isTable ? (
+            <DropdownMenuItem onSelect={() => setColumnsOpen(true)}>
+              <Columns3 aria-hidden="true" />
+              {i18n.t("resource.columns")}
+            </DropdownMenuItem>
+          ) : null}
           {/* The dialog stays the complete keyboard and touch path. Dragging is only a mouse
               shortcut; it does not need a second label beside this action. */}
           {/* ⚠️ `undefined`, and that is the honest answer rather than a missing one: this menu hangs
@@ -414,19 +411,30 @@ export function ResourceMenu({
                   (`flows.problem.<code>` is one string) and repeating it under itself says nothing
                   the reader did not just read. What differs is the detail, and every detail is
                   still here — which is the promise the comment above makes: somebody with two
-                  missing tools should not have to ask twice. */}
+                  missing tools should not have to ask twice.
+
+                  ⚠️ What identifies a detail is its POSITION in `problems`, not its text (#461).
+                  Two details of one code are routinely the same sentence: `collectRunProblems`
+                  files one problem per sub-flow NODE and words it with that node's label
+                  (`packages/api/src/flows/flows.ts`), and calling the same flow twice is the normal
+                  case. Under `key={detail}` those two collided on one key, and React does not
+                  answer that with a console warning alone — it drops one of the siblings on the
+                  next render, so the reader sees ONE entry where there are two causes. */}
               {[
                 ...validation.problems
-                  .reduce((byCode, problem) => {
-                    byCode.set(problem.code, [...(byCode.get(problem.code) ?? []), problem.detail]);
+                  .reduce((byCode, problem, at) => {
+                    byCode.set(problem.code, [
+                      ...(byCode.get(problem.code) ?? []),
+                      { at, detail: problem.detail },
+                    ]);
                     return byCode;
-                  }, new Map<string, string[]>())
+                  }, new Map<string, { at: number; detail: string }[]>())
                   .entries(),
               ].map(([code, details]) => (
                 <li key={code} className="rounded-md border p-3 text-sm">
                   <span className="block font-medium">{i18n.t(`flows.problem.${code}`)}</span>
-                  {details.map((detail) => (
-                    <span key={detail} className="mt-1 block text-xs text-muted-foreground">
+                  {details.map(({ at, detail }) => (
+                    <span key={at} className="mt-1 block text-xs text-muted-foreground">
                       {detail}
                     </span>
                   ))}
@@ -457,6 +465,9 @@ export function ResourceMenu({
       ) : null}
       {sharing ? <SharePanel target={target} close={() => setSharing(false)} /> : null}
       {linksOpen && node ? <NodeLinksPanel node={node} close={() => setLinksOpen(false)} /> : null}
+      {columnsOpen && node ? (
+        <TableColumnsDialog node={node} close={() => setColumnsOpen(false)} />
+      ) : null}
       {versionsOpen ? (
         <VersionHistory target={target} close={() => setVersionsOpen(false)} />
       ) : null}