@unson/brainbase-mcp 0.41.11 → 0.42.0

package/ui/area-nav.js

@@ -0,0 +1,249 @@
+/*
+ * Area navigation shared by OSS Personal and the organization edition
+ * (brainbase-project ledger D10, stage 2).
+ *
+ * The left side lists only the areas; the screens of the current area are tabs
+ * above the page.  An area link opens the screen last used in that area, which
+ * is remembered in the viewer's browser only (a display preference, not a fact
+ * of the organization).  Every area link and tab is a link to a screen, so
+ * screen addresses never change.  The part draws links only: showing and
+ * loading screens stays with the caller (`show` in, `onSelect` out).
+ */
+
+export const AREA_NAV_CONTRACT_VERSION = 'brainbase.area-nav.v1';
+export const AREA_NAV_MEMORY_KEY = 'brainbase.area-nav.last-screen.v1';
+
+function makeElement(doc, tag, { className, text, attrs = {} } = {}) {
+  const element = doc.createElement(tag);
+  if (className) element.className = className;
+  if (text !== undefined && text !== null) element.textContent = String(text);
+  for (const [name, value] of Object.entries(attrs)) {
+    if (value === undefined || value === null || value === false) continue;
+    element.setAttribute(name, value === true ? '' : String(value));
+  }
+  return element;
+}
+
+/**
+ * The last screen per area, kept in the given storage (for example the
+ * browser's localStorage).  A storage that is missing, full or blocked behaves
+ * as if nothing was remembered.
+ */
+export function createAreaMemory(storage, key = AREA_NAV_MEMORY_KEY) {
+  const read = () => {
+    try {
+      const raw = storage?.getItem?.(key);
+      const value = raw ? JSON.parse(raw) : null;
+      return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    } catch {
+      return {};
+    }
+  };
+  return Object.freeze({
+    get(areaId) {
+      const value = read()[areaId];
+      return typeof value === 'string' ? value : null;
+    },
+    set(areaId, screenId) {
+      try {
+        storage?.setItem?.(key, JSON.stringify({ ...read(), [areaId]: screenId }));
+      } catch {
+        // Not remembered; the area opens its default screen next time.
+      }
+    },
+  });
+}
+
+/** The browser's localStorage when it can be reached, otherwise null. */
+export function browserAreaStorage() {
+  try {
+    return globalThis.localStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The screen an area link opens: the remembered screen if it is still shown
+ * there, else the area's default, else its first shown screen.  External links
+ * (opened in another tab) are never a target.
+ */
+export function resolveAreaTarget(area, { remembered = null, isShown = () => true } = {}) {
+  const candidates = area.screens.filter((screen) => !screen.external && isShown(screen.id)).map((screen) => screen.id);
+  if (remembered && candidates.includes(remembered)) return remembered;
+  if (area.defaultScreen && candidates.includes(area.defaultScreen)) return area.defaultScreen;
+  return candidates[0] ?? null;
+}
+
+/**
+ * @param {object} options
+ * @param {Document} options.document
+ * @param {Array<{id: string, label: string|null, defaultScreen?: string, screenIds: string[]}>} options.areas
+ *   In menu order. A null label takes the label of the area's only screen.
+ * @param {Array<{id: string, label: string, href?: string, external?: boolean, hidden?: boolean}>} options.screens
+ * @param {{get(areaId: string): string|null, set(areaId: string, screenId: string): void}} [options.memory]
+ * @param {(screenId: string) => string} [options.hrefFor] Address of a screen (default `#<id>`).
+ * @param {(screenId: string, event: Event) => void} [options.onSelect]
+ * @param {(area: object) => Node|null} [options.iconFor] Icon in front of an area link.
+ * @param {string} [options.linkClassName] Extra class for the area links (the host's look).
+ */
+export function createAreaNav({
+  document: doc,
+  areas: areaInput,
+  screens: screenInput,
+  memory = createAreaMemory(null),
+  hrefFor = (screenId) => `#${screenId}`,
+  onSelect,
+  iconFor,
+  linkClassName = '',
+  label = '画面',
+} = {}) {
+  if (!doc || typeof doc.createElement !== 'function') throw new Error('document_unavailable');
+  const screens = new Map((screenInput ?? []).map((screen) => [screen.id, {
+    id: screen.id,
+    label: screen.label,
+    href: screen.href ?? null,
+    external: screen.external === true,
+    hidden: screen.hidden === true,
+    count: null,
+    waiting: false,
+  }]));
+  const areas = (areaInput ?? []).map((area) => ({
+    id: area.id,
+    label: area.label ?? null,
+    defaultScreen: area.defaultScreen ?? null,
+    screens: area.screenIds.map((id) => screens.get(id)).filter(Boolean),
+  })).filter((area) => area.screens.length > 0);
+  const areaByScreen = new Map();
+  for (const area of areas) for (const screen of area.screens) areaByScreen.set(screen.id, area);
+
+  let activeScreenId = null;
+  const isShown = (screenId) => screens.get(screenId)?.hidden === false;
+  const shownScreens = (area) => area.screens.filter((screen) => isShown(screen.id));
+  const targetFor = (areaId) => {
+    const area = areas.find((candidate) => candidate.id === areaId);
+    return area ? resolveAreaTarget(area, { remembered: memory.get(area.id), isShown }) : null;
+  };
+  const screenHref = (screen) => screen.href ?? hrefFor(screen.id);
+  const areaLabel = (area) => area.label ?? area.screens[0].label;
+
+  const countBadge = (count, ariaLabel) => makeElement(doc, 'span', {
+    className: 'bb-area-count',
+    text: count,
+    attrs: { 'aria-label': ariaLabel },
+  });
+
+  const nav = makeElement(doc, 'nav', { className: 'bb-area-nav', attrs: { 'aria-label': label, 'data-contract-version': AREA_NAV_CONTRACT_VERSION } });
+  const tabs = makeElement(doc, 'nav', { className: 'bb-area-tabs' });
+  tabs.hidden = true;
+  const areaLinks = new Map();
+
+  for (const area of areas) {
+    const link = makeElement(doc, 'a', {
+      className: ['bb-area-link', linkClassName].filter(Boolean).join(' '),
+      attrs: { 'data-area': area.id },
+    });
+    link.addEventListener('click', (event) => {
+      const target = targetFor(area.id);
+      if (target) onSelect?.(target, event);
+    });
+    areaLinks.set(area.id, link);
+    nav.append(link);
+  }
+
+  function renderAreaLink(area) {
+    const link = areaLinks.get(area.id);
+    const shown = shownScreens(area);
+    link.hidden = !shown.some((screen) => !screen.external);
+    const target = targetFor(area.id);
+    if (target) link.setAttribute('href', screenHref(screens.get(target)));
+    else link.removeAttribute('href');
+    if (areaByScreen.get(activeScreenId) === area) link.setAttribute('aria-current', 'page');
+    else link.removeAttribute('aria-current');
+    const waiting = shown.reduce((sum, screen) => sum + (screen.waiting && Number.isInteger(screen.count) ? screen.count : 0), 0);
+    const icon = iconFor?.(area) ?? null;
+    link.replaceChildren(...[
+      icon,
+      makeElement(doc, 'span', { className: 'bb-area-link-label', text: areaLabel(area) }),
+      waiting > 0 ? countBadge(waiting, `待っているもの${waiting}件`) : null,
+    ].filter(Boolean));
+  }
+
+  function renderTabs() {
+    const area = areaByScreen.get(activeScreenId) ?? null;
+    const shown = area ? shownScreens(area) : [];
+    if (!area || shown.length < 2) {
+      tabs.hidden = true;
+      tabs.replaceChildren();
+      tabs.removeAttribute('aria-label');
+      return;
+    }
+    tabs.hidden = false;
+    tabs.setAttribute('aria-label', `${areaLabel(area)}の画面`);
+    tabs.replaceChildren(...shown.map((screen) => {
+      const tab = makeElement(doc, 'a', {
+        className: 'bb-area-tab',
+        attrs: {
+          href: screenHref(screen),
+          'data-screen-tab': screen.id,
+          'aria-current': screen.id === activeScreenId ? 'page' : null,
+          target: screen.external ? '_blank' : null,
+          rel: screen.external ? 'noopener' : null,
+        },
+      });
+      tab.append(makeElement(doc, 'span', { text: screen.label }));
+      if (Number.isInteger(screen.count)) {
+        tab.append(countBadge(screen.count, screen.waiting ? `待っているもの${screen.count}件` : `${screen.count}件`));
+      }
+      if (!screen.external) tab.addEventListener('click', (event) => onSelect?.(screen.id, event));
+      return tab;
+    }));
+  }
+
+  function render() {
+    for (const area of areas) renderAreaLink(area);
+    renderTabs();
+  }
+
+  const controller = {
+    nav,
+    tabs,
+    get state() {
+      const area = areaByScreen.get(activeScreenId) ?? null;
+      return { activeScreenId, activeAreaId: area?.id ?? null };
+    },
+    areaOf(screenId) {
+      return areaByScreen.get(screenId)?.id ?? null;
+    },
+    targetFor,
+    /** Marks the shown screen; a screen in an area becomes that area's last screen. */
+    show(screenId) {
+      activeScreenId = screenId;
+      const area = areaByScreen.get(screenId);
+      const screen = screens.get(screenId);
+      if (area && screen && !screen.external && isShown(screenId)) memory.set(area.id, screenId);
+      render();
+      return controller;
+    },
+    setHidden(screenId, hidden) {
+      const screen = screens.get(screenId);
+      if (!screen) return controller;
+      screen.hidden = hidden === true;
+      render();
+      return controller;
+    },
+    /** `count` null removes it. `waiting` counts are added up on the area link too. */
+    setCount(screenId, count, { waiting = false } = {}) {
+      const screen = screens.get(screenId);
+      if (!screen) return controller;
+      screen.count = Number.isInteger(count) && count >= 0 ? count : null;
+      screen.waiting = waiting === true;
+      render();
+      return controller;
+    },
+  };
+  render();
+  return controller;
+}
+
+export default createAreaNav;

package/ui/foundation-overview.css

@@ -248,3 +248,12 @@
 .bb-fov-philosophy-card .bb-fov-original { border-top: 0; padding-top: 0; }
 .bb-fov-model-card .bb-fov-original { margin-top: 12px; padding-top: 10px; overflow-wrap: anywhere; }
 .bb-fov-objective-ledger .bb-ws-ledger-row:focus-visible { outline: 2px solid var(--bb-color-focus); outline-offset: 2px; }
+/* Whose what an objective waits for, and what can be done with it (story-objective-row-actions-v1). */
+.bb-fov-waiting { display: grid; gap: 2px; min-width: 0; }
+.bb-fov-waiting strong { font-weight: 600; }
+.bb-fov-waiting small { color: var(--bb-color-muted); font-size: 12px; line-height: 1.4; }
+.bb-fov-ledger-hint { margin: 8px 0 0; color: var(--bb-color-muted); font-size: 12px; }
+.bb-fov-actions { display: grid; gap: 8px; justify-items: start; padding: 12px; border: 1px solid var(--bb-color-border); border-radius: 8px; background: var(--bb-color-surface-subtle, rgb(0 0 0 / 2%)); }
+.bb-fov-actions h3 { margin: 0; }
+.bb-fov-action-note { margin: 0; color: var(--bb-color-muted); font-size: 13px; }
+.bb-fov-action-note.is-unavailable { color: var(--bb-color-ink); }

package/ui/foundation-overview.js

@@ -507,13 +507,79 @@ function objectiveCard(doc, record, variableMap) {
   return card;
 }
 
-function objectiveReading(doc, record, variableMap, recordContexts) {
+/**
+ * Whose what an objective waits for (story-objective-row-actions-v1), from its own record: the items its
+ * current state says were not confirmed when it was saved, or else the fields it has not recorded, and
+ * the accountable person who would settle them.  Nothing is waited for when the record names nothing.
+ */
+export function objectiveWaiting(record) {
+  const definition = recordDefinition(record);
+  const current = currentStateFor(record);
+  const accountable = nonEmpty(definition.accountableId);
+  const items = current.missing.length ? current.missing : missingObjectiveFields(record);
+  if (items.length === 0) return null;
+  const what = `${current.missing.length ? '未確認' : '未記録'}：${items.join('・')}`;
+  const who = accountable ? '責任者の確認待ち' : '責任者が未記録のため、確かめる人が決まっていません';
+  return { what, who, items, kind: current.missing.length ? 'unconfirmed' : 'unrecorded', accountableRecorded: Boolean(accountable) };
+}
+
+function waitingElement(doc, waiting) {
+  const cell = makeElement(doc, 'span', { className: 'bb-fov-waiting' });
+  if (!waiting) {
+    cell.append(makeElement(doc, 'span', { className: 'bb-fov-missing', text: '記録上はありません' }));
+    return cell;
+  }
+  cell.append(makeElement(doc, 'strong', { className: 'bb-fov-missing', text: waiting.what }), makeElement(doc, 'small', { text: waiting.who }));
+  return cell;
+}
+
+/**
+ * What the reader can do with this objective, from the host (`callbacks.objectiveAction`): a button that
+ * goes where it is corrected, or the reason it cannot be from here.  Without a host action the screen says
+ * it only reads; it never shows a control that does nothing.
+ */
+function objectiveActionElement(doc, record, recordContexts, callbacks, dialog) {
+  const definition = recordDefinition(record), details = detailsFor(record);
+  const part = makeElement(doc, 'section', { className: 'bb-fov-actions' });
+  part.append(makeElement(doc, 'h3', { text: 'この目的でできること' }));
+  const context = recordContexts?.get(record);
+  const action = typeof callbacks?.objectiveAction === 'function'
+    ? callbacks.objectiveAction({
+      objectiveId: definition.id ?? null,
+      revision: definition.revision ?? null,
+      title: formatAny(details.title) ?? formatAny(definition.meaning) ?? null,
+      scopeIds: context?.scopeIds ?? [],
+      record,
+    })
+    : null;
+  if (action && typeof action.onSelect === 'function') {
+    part.append(workspaceButton(doc, {
+      text: `${action.label ?? '目的を直す・現状を記録する'} ›`,
+      variant: 'primary',
+      onClick: () => { dialog()?.close(); action.onSelect(); },
+    }));
+    part.append(makeElement(doc, 'p', { className: 'bb-fov-action-note', text: action.description ?? '目指す状態・評価基準・現状を直し、新しい版として保存します。保存すると、この一覧の「待っていること」が変わります。' }));
+  } else {
+    part.append(makeElement(doc, 'p', {
+      className: 'bb-fov-action-note is-unavailable',
+      text: nonEmpty(action?.unavailable) ?? 'この画面は読むだけです。ここからは記録を変えられません。',
+    }));
+  }
+  return part;
+}
+
+function objectiveReading(doc, record, variableMap, recordContexts, callbacks = {}, dialog = () => null) {
   const definition = recordDefinition(record), details = detailsFor(record);
   const body = makeElement(doc, 'div', { className: 'bb-fov-reading' });
   const section = (title, content) => {
     const part = makeElement(doc, 'section');
     part.append(makeElement(doc, 'h3', { text: title }), content); body.append(part);
   };
+  const waiting = objectiveWaiting(record);
+  section('待っていること', waiting
+    ? workspaceDefinition(doc, [['何を', waiting.what], ['誰が', waiting.who]])
+    : makeElement(doc, 'p', { text: '記録上、待っていることはありません。達成・採用・検証済みを意味しません。' }));
+  body.append(objectiveActionElement(doc, record, recordContexts, callbacks, dialog));
   section('達成条件', workspaceDefinition(doc, [
     ['目指す状態', formatAny(definition.desiredState)],
     ['評価基準', criteriaElement(doc, definition, details, variableMap)],
@@ -560,18 +626,21 @@ function renderObjectives(doc, catalog, viewState, callbacks, recordContexts) {
         viewState.dialog?.close();
         viewState.dialog = workspaceDialog(doc, {
           title: formatAny(details.title) ?? formatAny(definition.meaning) ?? UNNAMED_RECORD, opener,
-          content: objectiveReading(doc, record, recordContexts?.get(record)?.variableMap ?? variableMap, recordContexts),
+          content: objectiveReading(doc, record, recordContexts?.get(record)?.variableMap ?? variableMap, recordContexts, callbacks, () => viewState.dialog),
         });
       },
       cells: [
         { primary: formatAny(details.title) ?? formatAny(definition.meaning) ?? UNNAMED_RECORD },
         current.text ?? current.status ?? '未記録',
-        { text: current.missing.length ? current.missing.join('・') : missingObjectiveFields(record).join('・') || '記録なし', className: 'bb-fov-missing' },
+        waitingElement(doc, objectiveWaiting(record)),
         formatDate(current.asOf),
       ],
     };
   });
-  section.append(workspaceLedger(doc, { className: 'bb-fov-objective-ledger', ariaLabel: '登録された目的', columns: ['目的', '現状', '確認待ち', '確認日'], rows }));
+  section.append(workspaceLedger(doc, { className: 'bb-fov-objective-ledger', ariaLabel: '登録された目的', columns: ['目的', '現状', '待っていること', '確認日'], rows }));
+  section.append(makeElement(doc, 'p', { className: 'bb-fov-ledger-hint', text: typeof callbacks?.objectiveAction === 'function'
+    ? '行を押すと、目的の詳細と、この目的でできること（直す・現状を記録する）が開きます。'
+    : '行を押すと、目的の詳細が開きます。この画面は読むだけです。' }));
   return section;
 }
 
@@ -912,13 +981,14 @@ export function renderFoundationCollectionOverview(root, sources, {
         if (existing) {
           const context = contexts.get(existing);
           if (!context.sources.includes(source.label)) context.sources.push(source.label);
+          if (!context.scopeIds.includes(source.scopeId)) context.scopeIds.push(source.scopeId);
           context.label = `${shared ? '組織共通 ／ ' : ''}${context.sources.join('・')}`;
           continue;
         }
         const record = { ...original };
         seen.set(key, record);
         catalog[kind].push(record);
-        contexts.set(record, { key, variableMap, sources: [source.label], label: `${shared ? '組織共通 ／ ' : ''}${source.label}` });
+        contexts.set(record, { key, variableMap, sources: [source.label], scopeIds: [source.scopeId], label: `${shared ? '組織共通 ／ ' : ''}${source.label}` });
       }
     }
   }

package/ui/graph-ontology-view.css

@@ -0,0 +1,88 @@
+/*
+ * 「情報の種類とつながり方」. Load after workspace-kit.css and graph-view-shared.css.
+ * Column templates of the kinds and relations ledgers, with and without the
+ * count column, and a 760px variant.
+ * Uses only the shared tokens in brainbase-tokens.css.
+ */
+.bb-go .bb-go-caption,
+.bb-go .bb-go-note {
+  margin: 0 0 10px;
+  color: var(--bb-color-muted);
+  font-size: 12px;
+}
+
+.bb-go .bb-ws-section-title {
+  margin-top: 30px;
+}
+
+.bb-go > .bb-graph-plain-list {
+  color: var(--bb-color-muted);
+}
+
+.bb-go > .bb-graph-audit {
+  margin-top: 14px;
+}
+
+.bb-go-type-ledger .bb-ws-ledger-row {
+  grid-template-columns: 160px minmax(0, 1fr);
+}
+
+.bb-go-type-ledger.is-counted .bb-ws-ledger-row {
+  grid-template-columns: 160px minmax(0, 1fr) 96px;
+}
+
+.bb-go-relation-ledger .bb-ws-ledger-row {
+  grid-template-columns: 140px minmax(0, 1.4fr) minmax(0, 1.6fr);
+}
+
+.bb-go-relation-ledger.is-counted .bb-ws-ledger-row {
+  grid-template-columns: 140px minmax(0, 1.4fr) minmax(0, 1.6fr) minmax(0, .8fr);
+}
+
+.bb-go-type-ledger .bb-ws-ledger-row,
+.bb-go-relation-ledger .bb-ws-ledger-row {
+  min-height: 48px;
+  align-items: start;
+}
+
+/* Meanings and kinds are read, not scanned: let them wrap. */
+.bb-go-type-ledger .bb-ws-ledger-row > span,
+.bb-go-relation-ledger .bb-ws-ledger-row > span {
+  white-space: normal;
+}
+
+.bb-go-type-ledger .bb-ws-ledger-row:not(.bb-ws-ledger-head) > :first-child,
+.bb-go-relation-ledger .bb-ws-ledger-row:not(.bb-ws-ledger-head) > :first-child {
+  color: var(--bb-color-ink);
+  font-weight: 690;
+}
+
+.bb-go-kinds {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.bb-go-kinds > li + li {
+  margin-top: 4px;
+}
+
+@media (max-width: 760px) {
+  .bb-go-type-ledger .bb-ws-ledger-row,
+  .bb-go-type-ledger.is-counted .bb-ws-ledger-row {
+    grid-template-columns: 96px minmax(0, 1fr);
+  }
+
+  .bb-go-type-ledger.is-counted .bb-ws-ledger-row > :nth-child(3) {
+    display: none;
+  }
+
+  .bb-go-relation-ledger .bb-ws-ledger-row,
+  .bb-go-relation-ledger.is-counted .bb-ws-ledger-row {
+    grid-template-columns: 96px minmax(0, 1fr);
+  }
+
+  .bb-go-relation-ledger .bb-ws-ledger-row > :nth-child(n + 3) {
+    display: none;
+  }
+}