Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
Render the native menu from the shared command registry (Phase 2b) (#2721)
Andrew Mikofalvyd0f3b04884fc
diff --git a/.changeset/menu-registry-phase-2b.md b/.changeset/menu-registry-phase-2b.mdnew file mode 100644index 000000000..8604d75b7--- /dev/null+++ b/.changeset/menu-registry-phase-2b.md@@ -0,0 +1,16 @@+---+"@inkeep/open-knowledge": patch+---++Internal refactor (no user-facing change): the native application menu now+renders its actionable command leaves from the same shared command registry the+Cmd+K palette uses, so each command's identity — label, accelerator, keyboard+shortcut, availability, and menu placement — is declared once in+`@inkeep/open-knowledge-core` instead of being hand-maintained in two lists.+Command availability is a pure, declarative evaluator both surfaces call; the+menu's structural scaffolding (roles, separators, submenus, the dynamic+Recent-project list, and the platform branches) stays declarative. The+"Check for updates" and "Settings" platform placements are now data-driven,+and a ratchet fails the build if a command is ever hand-placed twice in the same+platform's menu bar. Menu items, order, labels, accelerators, and enabled/checked+states are unchanged on every platform.diff --git a/packages/app/src/components/command-palette-commands.ts b/packages/app/src/components/command-palette-commands.tsindex 9ab4922db..3b8813abd 100644--- a/packages/app/src/components/command-palette-commands.ts+++ b/packages/app/src/components/command-palette-commands.ts@@ -1,5 +1,13 @@-import { OPEN_KNOWLEDGE_GITHUB_URL, SHOW_INSTALL_SKILL } from '@inkeep/open-knowledge-core';-import { t } from '@lingui/core/macro';+import {+ COMMAND_IDENTITIES,+ type CommandContext,+ type CommandIdentity,+ evaluateCommandAvailability,+ OPEN_KNOWLEDGE_GITHUB_URL,+ SHOW_INSTALL_SKILL,+} from '@inkeep/open-knowledge-core';+import type { MessageDescriptor } from '@lingui/core';+import { msg, t } from '@lingui/core/macro';import {Blocks,Bug,@@ -34,36 +42,34 @@ import { requestDocPanelTab } from '@/components/doc-panel-events';import { GithubIcon } from '@/components/icons/github';import type { ResolvedNavigationTarget } from '@/components/navigation-targets';import type { OkDesktopBridge, OkMenuAction } from '@/lib/desktop-bridge-types';+import { i18n } from '@/lib/i18n';import type { KeyboardShortcutId } from '@/lib/keyboard-shortcuts';import { SETTINGS_OPEN_HASH } from '@/lib/use-settings-route';import type { ViewMenuState } from '@/lib/view-menu-state-store';/**- * The command registry for the Cmd+K palette's FIXED command rows — the single- * source of truth the palette renders from, and the source the parity ratchets- * derive their palette-reachable id classification from- * (`command-menu-parity.test-helper.ts`).- *- * Fixed commands only. The palette's query/state-driven populations stay- * bespoke in `CommandPalette.tsx` and are deliberately NOT registry entries:- * search results, tag mode, semantic ("by meaning"), recents, the recent-project- * and worktree-switch lists, and the per-target Open-with-AI group (`send-to-ai`- * is one install-gated row per agent target, which a single descriptor cannot- * represent).+ * The Cmd+K palette's FIXED command rows, joined here from the shared command+ * identity (`@inkeep/open-knowledge-core/commands`, `COMMAND_IDENTITIES`) with+ * the renderer presentation the identity cannot carry: `lucide` icons, Lingui+ * `msg` labels (resolved through the app's global i18n), and dispatch closures+ * over the palette context. The native menu joins the SAME identity with its+ * own plain-string labels + click deps (`packages/desktop/src/main/menu.ts`),+ * so command identity has one declaration point across both surfaces.*- * The native menu stays hand-authored (`packages/desktop/src/main/menu.ts`);- * Ratchet B classifies its leaves against this registry's id space. Rendering- * the menu from the registry is a separate step gated on where labels and- * availability predicates can live (the menu runs in the Electron main process,- * outside the Lingui macro pipeline).+ * The palette's query/state-driven populations stay bespoke in+ * `CommandPalette.tsx` and are NOT registry rows: search results, tag mode,+ * semantic ("by meaning"), recents, the recent-project and worktree-switch+ * lists, and the per-target Open-with-AI group (`send-to-ai` is one+ * install-gated row per agent target, which a single descriptor cannot carry —+ * it stays a menu-only identity in the core registry).*//*** Projection of the palette's 7-kind {@link ResolvedNavigationTarget} onto the- * 4-kind gating the native File menu uses for contextual commands: doc-like and- * folder allow every contextual command (folder still allows Duplicate);- * asset-like (asset / skill-file / large-file) disables Duplicate; a missing /- * absent target hides them all.+ * gating kinds the shared availability spec reads. The palette never produces+ * `project` (the menu's project-scope signal); a missing/absent target is+ * `none`, which is how reveal / copy-path hide with no target here yet stay+ * actionable in the menu's project scope — one spec, two contexts.*/export type ContextualTargetKind = 'doc' | 'folder' | 'asset' | 'none';@@ -91,7 +97,7 @@ export function projectContextualTargetKind(* palette component assembles this per render: state snapshots for* `available` / `label` / `checked`, and dispatch seams that reuse the existing* handlers (the local menu-action bus, toast-wrapped bridge calls, and the- * palette's own dialog launchers) so no handler logic is re-implemented here.+ * palette's own dialog launchers).*/export interface PaletteCommandContext {bridge: OkDesktopBridge | null;@@ -121,21 +127,12 @@ export interface PaletteCommand {id: string;/*** The `OkMenuAction` this row makes palette-reachable, feeding the derived- * `PALETTE_COMMAND_IDS` classification (Ratchets A/C). Two roles:- * - `busDispatch` rows: this IS the id `dispatch` emits on the menu-action- * bus, and the DOM suite's `ID_BACKED` loop pins that emission, so the two- * cannot drift.- * - dialog rows (whose `dispatch` opens a dialog instead of calling- * `emitMenuAction`): a classification-only annotation. Dispatch emits- * nothing, so no dispatch test guards it; set it by hand to the matching- * native menu leaf's action.+ * `PALETTE_COMMAND_IDS` classification. For bus-dispatched rows this IS the id+ * `dispatch` emits, and the DOM suite's `ID_BACKED` loop pins that emission.* Absent for commands with no menu-action id (Settings, Open graph, …).*/menuActionId?: OkMenuAction;- /**- * Localized label, resolved at render time so it tracks the active locale- * and can reflect state (Show/Hide toggles read `ctx.viewMenuState`).- */+ /** Localized label, resolved at render so it tracks locale and reflects state. */label(ctx: PaletteCommandContext): string;/** Extra `matchesCommandQuery` tokens beyond the label. Not localized. */keywords: readonly string[];@@ -143,16 +140,12 @@ export interface PaletteCommand {group: PaletteCommandGroup;/*** `always` rows render on empty open (query-filtered once the user types);- * `search-only` rows render only under a matching non-empty query, keeping- * the empty-open state lean.+ * `search-only` rows render only under a matching non-empty query.*/visibility: 'always' | 'search-only';/** Accelerator glyphs rendered via `formatShortcut(shortcutId)`. */shortcutId?: KeyboardShortcutId;- /**- * The binding only fires through a native-menu accelerator, so the glyphs- * render on the desktop host only.- */+ /** The binding fires only through a native-menu accelerator (desktop host only). */shortcutDesktopOnly?: boolean;/** Trailing check indicator for checkbox-style View toggles. */checked?(ctx: PaletteCommandContext): boolean;@@ -160,456 +153,218 @@ export interface PaletteCommand {dispatch(ctx: PaletteCommandContext): void;}-const contextualAvailable = (ctx: PaletteCommandContext): boolean =>- ctx.bridge !== null && ctx.contextualTargetKind !== 'none';+/**+ * Palette label descriptors keyed by the registry `labelKey` (and Show/Hide+ * toggle keys). The label-parity test asserts this map covers every registry+ * labelKey and that each string is present in the compiled catalog, keeping the+ * palette in lockstep with the native menu's `MENU_LABELS` source.+ */+const PALETTE_COMMAND_LABELS = {+ newFile: msg`New file`,+ newFolder: msg`New folder`,+ openGraph: msg`Open graph`,+ initializeStarterPack: msg`Initialize starter pack`,+ newProject: msg`New project`,+ openFolderOnDisk: msg`Open folder on disk`,+ switchProject: msg`Switch project`,+ settings: msg`Settings`,+ installClaudeDesktop: msg`Install for Claude Chat & Cowork (Desktop App)`,+ reportBug: msg`Report a bug`,+ newFromTemplate: msg`New from template`,+ rename: msg`Rename`,+ duplicate: msg`Duplicate`,+ moveToTrash: msg`Move to Trash`,+ revealInFinder: msg`Reveal in Finder`,+ copyFullPath: msg`Copy full path`,+ copyRelativePath: msg`Copy relative path`,+ closeTab: msg`Close tab`,+ newWorktree: msg`New worktree`,+ switchWorktree: msg`Switch worktree`,+ sidebarShow: msg`Show sidebar`,+ sidebarHide: msg`Hide sidebar`,+ docPanelShow: msg`Show document panel`,+ docPanelHide: msg`Hide document panel`,+ terminalShow: msg`Show Terminal`,+ terminalHide: msg`Hide Terminal`,+ showHiddenFiles: msg`Show hidden files`,+ showOkFolders: msg`Show .ok folders`,+ showOnlyMarkdownFiles: msg`Show only markdown files`,+ showSkillsSection: msg`Show skills section`,+ expandAll: msg`Expand all`,+ collapseAll: msg`Collapse all`,+ newTerminal: msg`New Terminal`,+ killTerminal: msg`Kill Terminal`,+ checkForUpdates: msg`Check for updates`,+ setUpIntegrations: msg`Set up OpenKnowledge integrations`,+ checkSpelling: msg`Check spelling while typing`,+ openOnGithub: msg`OpenKnowledge on GitHub`,+} as const satisfies Record<string, MessageDescriptor>;++/** Exported for the label-parity test (completeness + catalog presence). */+export type PaletteLabelKey = keyof typeof PALETTE_COMMAND_LABELS;+export { PALETTE_COMMAND_LABELS };++/** Renderer icon per command id. Every palette command must have one:+ * `toPaletteCommand` throws at module load if an id is missing, rather than+ * silently substituting a wrong default. */+const COMMAND_ICONS: Record<string, ComponentType<{ className?: string }>> = {+ 'new-file': FilePlus2,+ 'new-folder': FolderPlus,+ 'open-graph': Network,+ 'initialize-starter-pack': Package,+ 'new-project': Plus,+ 'open-folder': FolderOpen,+ 'switch-project': LayoutGrid,+ settings: Settings,+ 'install-claude-desktop': Download,+ 'report-bug': Bug,+ 'new-from-template': FilePlus2,+ rename: Pencil,+ duplicate: Copy,+ 'move-to-trash': Trash2,+ 'reveal-in-finder': FolderOpen,+ 'copy-full-path': Copy,+ 'copy-relative-path': Copy,+ 'close-tab': X,+ 'new-worktree': GitBranch,+ 'switch-worktree': GitBranch,+ 'toggle-sidebar': PanelLeft,+ 'toggle-doc-panel': PanelRight,+ 'toggle-terminal': SquareTerminal,+ 'toggle-show-hidden-files': Eye,+ 'toggle-show-ok-folders': Folder,+ 'toggle-show-only-markdown-files': FileText,+ 'toggle-show-skills-section': Sparkles,+ 'expand-all-tree': UnfoldVertical,+ 'collapse-all-tree': FoldVertical,+ 'new-terminal': SquareTerminal,+ 'kill-terminal': SquareTerminal,+ 'check-for-updates': RefreshCw,+ 'set-up-integrations': Blocks,+ 'toggle-spell-check': SpellCheck,+ 'open-github': GithubIcon,+};/**- * Fields for a command whose dispatch is exactly "emit this id on the local- * menu-action bus": one action literal produces BOTH the classification- * (`menuActionId`) and the dispatch that emits it, so the two cannot drift.+ * Dispatch closures for commands that do NOT route through the menu-action bus+ * (dialog launchers, bridge invokes, direct renderer calls). Bus commands fall+ * through to {@link busDispatch}, which emits their `menuActionId`.*/-const busDispatch = (action: OkMenuAction): Pick<PaletteCommand, 'menuActionId' | 'dispatch'> => ({- menuActionId: action,- dispatch: (ctx) => ctx.emitMenuAction(action),-});+const COMMAND_DISPATCH: Record<string, (ctx: PaletteCommandContext) => void> = {+ 'new-file': (ctx) => {+ ctx.closePalette();+ ctx.openNewItemDialog('file');+ },+ 'new-folder': (ctx) => {+ ctx.closePalette();+ ctx.openNewItemDialog('folder');+ },+ 'open-graph': (ctx) => {+ ctx.closePalette();+ requestDocPanelTab('graph');+ },+ 'initialize-starter-pack': (ctx) => {+ ctx.closePalette();+ ctx.openSeedDialog();+ },+ 'new-project': (ctx) => {+ ctx.closePalette();+ ctx.openCreateProjectDialog();+ },+ 'open-folder': (ctx) => {+ const bridge = ctx.bridge;+ if (!bridge) return;+ ctx.runAction(async () => {+ const path = await bridge.dialog.openFolder();+ if (!path) return;+ await bridge.project.open({ path, target: 'new-window', entryPoint: 'pick-existing' });+ });+ },+ 'switch-project': (ctx) => {+ const bridge = ctx.bridge;+ if (!bridge) return;+ ctx.runAction(() => bridge.navigator.open(), t`Failed to open Project Navigator.`);+ },+ settings: (ctx) => {+ ctx.closePalette();+ if (window.location.hash !== SETTINGS_OPEN_HASH) {+ window.location.hash = SETTINGS_OPEN_HASH;+ }+ },+ 'install-claude-desktop': (ctx) => {+ ctx.closePalette();+ window.location.hash = '#install-claude-desktop';+ },+ 'report-bug': (ctx) => {+ ctx.closePalette();+ ctx.openReportBugDialog();+ },+ 'check-for-updates': (ctx) =>+ ctx.runAction(async () => {+ await ctx.bridge?.update.checkNow();+ }),+ 'set-up-integrations': (ctx) =>+ ctx.runAction(async () => {+ await ctx.bridge?.mcpWiring.reconfigure();+ }),+ 'toggle-spell-check': (ctx) =>+ ctx.runAction(async () => {+ await ctx.bridge?.spellcheck.toggle();+ }),+ 'open-github': (ctx) => ctx.openExternalUrl(OPEN_KNOWLEDGE_GITHUB_URL),+};-export const PALETTE_COMMANDS: readonly PaletteCommand[] = [- // ── Commands ──────────────────────────────────────────────────────────────- {- id: 'new-file',- menuActionId: 'new-doc',- label: () => t`New file`,- keywords: ['create file'],- icon: FilePlus2,- group: 'commands',- visibility: 'always',- shortcutId: 'new-item',- available: () => true,- dispatch: (ctx) => {- ctx.closePalette();- ctx.openNewItemDialog('file');- },- },- {- id: 'new-folder',- menuActionId: 'new-folder',- label: () => t`New folder`,- keywords: ['create folder'],- icon: FolderPlus,- group: 'commands',- visibility: 'always',- shortcutId: 'new-folder',- // The ⇧⌘N chord is a native-menu accelerator with no web keydown handler.- shortcutDesktopOnly: true,- available: () => true,- dispatch: (ctx) => {- ctx.closePalette();- ctx.openNewItemDialog('folder');- },- },- {- id: 'open-graph',- label: () => t`Open graph`,- keywords: ['graph panel network'],- icon: Network,- group: 'commands',- visibility: 'always',- available: (ctx) => ctx.activeDocName !== null,- dispatch: (ctx) => {- ctx.closePalette();- requestDocPanelTab('graph');- },- },- {- id: 'initialize-starter-pack',- label: () => t`Initialize starter pack`,- keywords: ['scaffold', 'seed', 'pack', 'starter'],- icon: Package,- group: 'commands',- visibility: 'always',- available: () => true,- dispatch: (ctx) => {- ctx.closePalette();- ctx.openSeedDialog();- },- },- // ── Project ───────────────────────────────────────────────────────────────- {- id: 'new-project',- menuActionId: 'new-project',- label: () => t`New project`,- keywords: ['create new project scaffold'],- icon: Plus,- group: 'project',- visibility: 'always',- available: (ctx) => ctx.bridge !== null,- dispatch: (ctx) => {- ctx.closePalette();- ctx.openCreateProjectDialog();- },- },- {- id: 'open-folder',- label: () => t`Open folder on disk`,- keywords: ['project'],- icon: FolderOpen,- group: 'project',- visibility: 'always',- shortcutId: 'open-folder',- available: (ctx) => ctx.bridge !== null,- dispatch: (ctx) => {- const bridge = ctx.bridge;- if (!bridge) return;- ctx.runAction(async () => {- const path = await bridge.dialog.openFolder();- if (!path) return;- await bridge.project.open({- path,- target: 'new-window',- entryPoint: 'pick-existing',- });- });- },- },- {- id: 'switch-project',- label: () => t`Switch project`,- keywords: ['switch project navigator projects'],- icon: LayoutGrid,- group: 'project',- visibility: 'always',- shortcutId: 'switch-project',- available: (ctx) => ctx.bridge !== null && !ctx.singleFile,- dispatch: (ctx) => {- const bridge = ctx.bridge;- if (!bridge) return;- ctx.runAction(() => bridge.navigator.open(), t`Failed to open Project Navigator.`);- },- },- {- id: 'settings',- label: () => t`Settings`,- keywords: ['preferences config'],- icon: Settings,- group: 'project',- visibility: 'always',- shortcutId: 'settings',- available: (ctx) => !ctx.singleFile,- dispatch: (ctx) => {- ctx.closePalette();- if (window.location.hash !== SETTINGS_OPEN_HASH) {- window.location.hash = SETTINGS_OPEN_HASH;- }- },- },- {- id: 'install-claude-desktop',- label: () => t`Install for Claude Chat & Cowork (Desktop App)`,- keywords: ['claude desktop install cowork'],- icon: Download,- group: 'project',- visibility: 'always',- available: () => SHOW_INSTALL_SKILL,- dispatch: (ctx) => {- ctx.closePalette();- window.location.hash = '#install-claude-desktop';- },- },- {- id: 'report-bug',- menuActionId: 'report-bug',- label: () => t`Report a bug`,- keywords: ['bug report issue feedback problem'],- icon: Bug,- group: 'project',- visibility: 'always',- // Bundle creation runs over the Electron bridge. Not gated on `singleFile`:- // with no project open the report degrades to the system-wide bundle.- available: (ctx) => ctx.bridge !== null,- dispatch: (ctx) => {- ctx.closePalette();- ctx.openReportBugDialog();- },- },- // ── File ──────────────────────────────────────────────────────────────────- {- id: 'new-from-template',- ...busDispatch('new-from-template'),- label: () => t`New from template`,- keywords: ['template', 'create', 'new'],- icon: FilePlus2,- group: 'file',- visibility: 'search-only',- available: (ctx) => !ctx.singleFile,- },- {- id: 'rename',- ...busDispatch('rename'),- label: () => t`Rename`,- keywords: ['rename', 'file', 'folder'],- icon: Pencil,- group: 'file',- visibility: 'search-only',- available: contextualAvailable,- },- {- id: 'duplicate',- ...busDispatch('duplicate'),- label: () => t`Duplicate`,- keywords: ['duplicate', 'copy', 'file', 'folder'],- icon: Copy,- group: 'file',- visibility: 'search-only',- shortcutId: 'file-tree-duplicate',- available: (ctx) =>- ctx.bridge !== null &&- (ctx.contextualTargetKind === 'doc' || ctx.contextualTargetKind === 'folder'),- },- {- id: 'move-to-trash',- ...busDispatch('move-to-trash'),- label: () => t`Move to Trash`,- keywords: ['delete', 'trash', 'remove'],- icon: Trash2,- group: 'file',- visibility: 'search-only',- shortcutId: 'file-tree-delete',- available: contextualAvailable,- },- {- id: 'reveal-in-finder',- ...busDispatch('reveal-in-finder'),- label: () => t`Reveal in Finder`,- keywords: ['finder', 'reveal', 'show', 'file'],- icon: FolderOpen,- group: 'file',- visibility: 'search-only',- available: contextualAvailable,- },- {- id: 'copy-full-path',- ...busDispatch('copy-full-path'),- label: () => t`Copy full path`,- keywords: ['copy', 'path', 'absolute', 'full'],- icon: Copy,- group: 'file',- visibility: 'search-only',- available: contextualAvailable,- },- {- id: 'copy-relative-path',- ...busDispatch('copy-relative-path'),- label: () => t`Copy relative path`,- keywords: ['copy', 'path', 'relative'],- icon: Copy,- group: 'file',- visibility: 'search-only',- available: contextualAvailable,- },- {- id: 'close-tab',- ...busDispatch('close-active-tab-or-window'),- label: () => t`Close tab`,- keywords: ['close', 'tab', 'window'],- icon: X,- group: 'file',- visibility: 'search-only',- available: (ctx) => ctx.bridge !== null,- },- {- id: 'new-worktree',- ...busDispatch('new-worktree'),- label: () => t`New worktree`,- keywords: ['worktree', 'branch', 'new'],- icon: GitBranch,- group: 'file',- visibility: 'search-only',- available: (ctx) => ctx.bridge !== null,- },- {- id: 'switch-worktree',- ...busDispatch('switch-worktree'),- label: () => t`Switch worktree`,- keywords: ['worktree', 'switch', 'branch'],- icon: GitBranch,- group: 'file',- visibility: 'search-only',- available: (ctx) => ctx.bridge !== null,- },- // ── View ──────────────────────────────────────────────────────────────────- {- id: 'toggle-sidebar',- ...busDispatch('toggle-sidebar'),- label: (ctx) => (ctx.viewMenuState.sidebarVisible ? t`Hide sidebar` : t`Show sidebar`),- keywords: ['sidebar', 'files', 'panel', 'toggle'],- icon: PanelLeft,- group: 'view',- visibility: 'search-only',- shortcutId: 'toggle-files-sidebar',- available: () => true,- },- {- id: 'toggle-doc-panel',- ...busDispatch('toggle-doc-panel'),- label: (ctx) =>- ctx.viewMenuState.docPanelVisible ? t`Hide document panel` : t`Show document panel`,- keywords: ['document', 'panel', 'info', 'toggle'],- icon: PanelRight,- group: 'view',- visibility: 'search-only',- shortcutId: 'toggle-document-panel',- available: () => true,- },- {- id: 'toggle-terminal',- ...busDispatch('toggle-terminal'),- label: (ctx) => (ctx.viewMenuState.terminalVisible ? t`Hide Terminal` : t`Show Terminal`),- keywords: ['terminal', 'shell', 'console', 'toggle'],- icon: SquareTerminal,- group: 'view',- visibility: 'search-only',- shortcutId: 'toggle-terminal-panel',- available: (ctx) => ctx.bridge !== null,- },- {- id: 'toggle-show-hidden-files',- ...busDispatch('toggle-show-hidden-files'),- label: () => t`Show hidden files`,- keywords: ['hidden', 'dotfiles', 'files', 'show'],- icon: Eye,- group: 'view',- visibility: 'search-only',- checked: (ctx) => ctx.viewMenuState.showHiddenFiles === true,- available: () => true,- },- {- id: 'toggle-show-ok-folders',- ...busDispatch('toggle-show-ok-folders'),- label: () => t`Show .ok folders`,- keywords: ['ok', 'folders', 'hidden', 'show'],- icon: Folder,- group: 'view',- visibility: 'search-only',- checked: (ctx) => ctx.viewMenuState.showOkFolders === true,- available: () => true,- },- {- id: 'toggle-show-only-markdown-files',- ...busDispatch('toggle-show-only-markdown-files'),- label: () => t`Show only markdown files`,- keywords: ['markdown', 'filter', 'files', 'only'],- icon: FileText,- group: 'view',- visibility: 'search-only',- checked: (ctx) => ctx.viewMenuState.showOnlyMarkdownFiles === true,- available: () => true,- },- {- id: 'toggle-show-skills-section',- ...busDispatch('toggle-show-skills-section'),- label: () => t`Show skills section`,- keywords: ['skills', 'section', 'sidebar', 'show'],- icon: Sparkles,- group: 'view',- visibility: 'search-only',- checked: (ctx) => ctx.viewMenuState.showSkillsSection === true,- available: () => true,- },- {- id: 'expand-all-tree',- ...busDispatch('expand-all-tree'),- label: () => t`Expand all`,- keywords: ['expand', 'tree', 'folders', 'all'],- icon: UnfoldVertical,- group: 'view',- visibility: 'search-only',- // Mirror the native menu's smart-hide (visible: canExpandAll ?? true):- // suppress the row when the tree is already fully expanded, so searching- // "expand" doesn't surface a pure no-op. Unknown (web/pre-push) stays available.- available: (ctx) => ctx.viewMenuState.canExpandAll !== false,- },- {- id: 'collapse-all-tree',- ...busDispatch('collapse-all-tree'),- label: () => t`Collapse all`,- keywords: ['collapse', 'tree', 'folders', 'all'],- icon: FoldVertical,- group: 'view',- visibility: 'search-only',- // Mirror the native menu's smart-hide (visible: canCollapseAll ?? true).- available: (ctx) => ctx.viewMenuState.canCollapseAll !== false,- },- // ── Terminal ──────────────────────────────────────────────────────────────- {- id: 'new-terminal',- ...busDispatch('new-terminal'),- label: () => t`New Terminal`,- keywords: ['terminal', 'shell', 'new', 'tab'],- icon: SquareTerminal,- group: 'terminal',- visibility: 'search-only',- available: (ctx) => ctx.bridge !== null,- },- {- id: 'kill-terminal',- ...busDispatch('kill-terminal'),- label: () => t`Kill Terminal`,- keywords: ['terminal', 'kill', 'close', 'session'],- icon: SquareTerminal,- group: 'terminal',- visibility: 'search-only',- available: (ctx) => ctx.bridge !== null && ctx.viewMenuState.terminalLive === true,- },- // ── Application ───────────────────────────────────────────────────────────- {- id: 'check-for-updates',- label: () => t`Check for updates`,- keywords: ['update', 'upgrade', 'version', 'check'],- icon: RefreshCw,- group: 'app',- visibility: 'search-only',- available: (ctx) => ctx.bridge !== null,- dispatch: (ctx) =>- ctx.runAction(async () => {- await ctx.bridge?.update.checkNow();- }),- },- {- id: 'set-up-integrations',- label: () => t`Set up OpenKnowledge integrations`,- keywords: ['integrations', 'mcp', 'setup', 'claude', 'configure'],- icon: Blocks,- group: 'app',- visibility: 'search-only',- available: (ctx) => ctx.bridge !== null,- dispatch: (ctx) =>- ctx.runAction(async () => {- await ctx.bridge?.mcpWiring.reconfigure();- }),- },- {- id: 'toggle-spell-check',- label: () => t`Check spelling while typing`,- keywords: ['spell', 'spelling', 'check', 'typing'],- icon: SpellCheck,- group: 'app',- visibility: 'search-only',- // App-wide flag owned by the Electron main process (not view-menu-state):- // the invoke reads + toggles it there, so the row carries no checkmark.- available: (ctx) => ctx.bridge !== null,- dispatch: (ctx) =>- ctx.runAction(async () => {- await ctx.bridge?.spellcheck.toggle();- }),- },- {- id: 'open-github',- label: () => t`OpenKnowledge on GitHub`,- keywords: ['github', 'source', 'repository', 'code'],- icon: GithubIcon,- group: 'app',- visibility: 'search-only',- available: () => true,- dispatch: (ctx) => ctx.openExternalUrl(OPEN_KNOWLEDGE_GITHUB_URL),- },-];+function paletteCoreContext(ctx: PaletteCommandContext): CommandContext {+ return {+ host: ctx.bridge !== null ? 'desktop' : 'web',+ activeTargetKind: ctx.contextualTargetKind,+ singleFile: ctx.singleFile,+ terminalLive: ctx.viewMenuState.terminalLive === true,+ canExpandAll: ctx.viewMenuState.canExpandAll !== false,+ canCollapseAll: ctx.viewMenuState.canCollapseAll !== false,+ hasActiveDoc: ctx.activeDocName !== null,+ showInstallSkill: SHOW_INSTALL_SKILL,+ };+}++function resolvePaletteLabel(cmd: CommandIdentity, ctx: PaletteCommandContext): string {+ if (cmd.stateToggle) {+ // Palette form: `state ? Hide : Show` (undefined → Show), independent of the+ // native menu's default-visible fallback.+ const visible = ctx.viewMenuState[cmd.stateToggle.stateField] === true;+ const key = visible ? cmd.stateToggle.hideKey : cmd.stateToggle.showKey;+ return i18n._(PALETTE_COMMAND_LABELS[key as PaletteLabelKey]);+ }+ return i18n._(PALETTE_COMMAND_LABELS[cmd.labelKey as PaletteLabelKey]);+}++function busDispatch(cmd: CommandIdentity): (ctx: PaletteCommandContext) => void {+ const action = cmd.menuActionId as OkMenuAction;+ return (ctx) => ctx.emitMenuAction(action);+}++function toPaletteCommand(cmd: CommandIdentity): PaletteCommand {+ const presence = cmd.palette;+ if (!presence) throw new Error(`command ${cmd.id} has no palette presence`);+ const icon = COMMAND_ICONS[cmd.id];+ if (!icon) throw new Error(`command ${cmd.id} has no palette icon`);+ const checkField = cmd.checkField;+ return {+ id: cmd.id,+ menuActionId: cmd.menuActionId as OkMenuAction | undefined,+ label: (ctx) => resolvePaletteLabel(cmd, ctx),+ keywords: cmd.keywords,+ icon,+ group: presence.group,+ visibility: presence.visibility,+ shortcutId: cmd.shortcutId as KeyboardShortcutId | undefined,+ shortcutDesktopOnly: cmd.shortcutDesktopOnly,+ checked: checkField ? (ctx) => ctx.viewMenuState[checkField] === true : undefined,+ available: (ctx) => evaluateCommandAvailability(cmd.availability, paletteCoreContext(ctx)),+ dispatch: COMMAND_DISPATCH[cmd.id] ?? busDispatch(cmd),+ };+}++export const PALETTE_COMMANDS: readonly PaletteCommand[] = COMMAND_IDENTITIES.flatMap((cmd) =>+ cmd.palette ? [toPaletteCommand(cmd)] : [],+);diff --git a/packages/app/src/lib/command-menu-parity.test.ts b/packages/app/src/lib/command-menu-parity.test.tsindex f9c4ee5b7..c7b455fc6 100644--- a/packages/app/src/lib/command-menu-parity.test.ts+++ b/packages/app/src/lib/command-menu-parity.test.ts@@ -18,11 +18,16 @@import { describe, expect, test } from 'bun:test';import { readdirSync, readFileSync } from 'node:fs';import { join, relative } from 'node:path';+import { COMMAND_IDENTITIES, type MenuPlatform } from '@inkeep/open-knowledge-core';import { PALETTE_COMMANDS } from '@/components/command-palette-commands';import { APP_RESERVED_IDS, PALETTE_COMMAND_IDS } from '@/lib/command-menu-parity.test-helper';import { formatShortcut, type KeyboardShortcutId } from '@/lib/keyboard-shortcuts';import { OK_MENU_ACTIONS } from '@/lib/ok-menu-actions';-import { buildMenuTemplate, type MenuDeps } from '../../../desktop/src/main/menu.ts';+import {+ buildMenuTemplate,+ MENU_BINDING_IDS,+ type MenuDeps,+} from '../../../desktop/src/main/menu.ts';// Derive the menu-item type from buildMenuTemplate itself, so the ratchet does// not take a direct `electron` dependency (the app package has none).@@ -177,10 +182,19 @@ interface Leaf {label: string;role?: string;accelerator?: string;+ // State-dependent output the registry now drives generically. Captured so the+ // state-rendering tests below can pin the Show/Hide variant, smart-hide+ // `visible`, and checkbox `type`/`checked`: a condition inversion in that+ // generic code would otherwise stay green under the all-enabled sweep snapshot.+ visible?: boolean;+ itemType?: string;+ checked?: boolean;}/** Recurse the template, collecting actionable leaves (skip separators, disabled- * placeholders, and submenu parents — which contribute their children). */+ * placeholders, and submenu parents — which contribute their children). A+ * smart-hidden leaf (`visible: false`, still enabled) is retained so its+ * `visible` state can be asserted. */function collectLeaves(items: readonly MenuTemplateItem[], out: Leaf[]): void {for (const item of items) {if (item.type === 'separator') continue;@@ -191,16 +205,19 @@ function collectLeaves(items: readonly MenuTemplateItem[], out: Leaf[]): void {}if (item.enabled === false) continue; // disabled placeholder (e.g. "No recent projects")const accelerator = typeof item.accelerator === 'string' ? item.accelerator : undefined;+ const visible = typeof item.visible === 'boolean' ? item.visible : undefined;+ const checked = typeof item.checked === 'boolean' ? item.checked : undefined;if (item.role) {out.push({label: typeof item.label === 'string' ? item.label : '',role: item.role,accelerator,+ visible,});continue;}if (typeof item.label === 'string') {- out.push({ label: item.label, accelerator });+ out.push({ label: item.label, accelerator, visible, itemType: item.type, checked });}}}@@ -210,12 +227,15 @@ function normalizeLabel(label: string): string {return label.replace(/…$/, '').trim();}-function collectLeavesForPlatform(platform: NodeJS.Platform): Leaf[] {+function collectLeavesForPlatform(+ platform: NodeJS.Platform,+ deps: MenuDeps = makeFullDeps(),+): Leaf[] {const original = process.platform;Object.defineProperty(process, 'platform', { value: platform, configurable: true });try {const leaves: Leaf[] = [];- collectLeaves(buildMenuTemplate(makeFullDeps()), leaves);+ collectLeaves(buildMenuTemplate(deps), leaves);return leaves;} finally {Object.defineProperty(process, 'platform', { value: original, configurable: true });@@ -398,3 +418,210 @@ describe('command-menu parity ratchet', () => {expect(callSites.sort()).toEqual(['lib/local-menu-action-bus.ts']);});});++// ─── Phase 2b: registry drives both surfaces ────────────────────────────────+// The native menu now renders its command leaves from the same core registry+// (`COMMAND_IDENTITIES`) the palette does. These guard the registry itself, now+// that it is the single declaration point across menu + palette.+describe('command identity registry (Phase 2b)', () => {+ const OK_MENU_ACTION_SET = new Set<string>(OK_MENU_ACTIONS);++ test('every registry menuActionId is a real OkMenuAction', () => {+ const bad = COMMAND_IDENTITIES.flatMap((cmd) =>+ cmd.menuActionId && !OK_MENU_ACTION_SET.has(cmd.menuActionId) ? [cmd.id] : [],+ );+ expect(bad).toEqual([]);+ });++ test('every palette command without an override dispatch has a menuActionId to emit', () => {+ // Bus-dispatched palette rows derive their dispatch from the id; a palette+ // command that neither overrides dispatch nor carries a menuActionId would+ // have nothing to emit. The known override ids are the dialog / bridge /+ // renderer commands.+ const OVERRIDES = new Set<string>([+ 'new-file',+ 'new-folder',+ 'open-graph',+ 'initialize-starter-pack',+ 'new-project',+ 'open-folder',+ 'switch-project',+ 'settings',+ 'install-claude-desktop',+ 'report-bug',+ 'check-for-updates',+ 'set-up-integrations',+ 'toggle-spell-check',+ 'open-github',+ ]);+ const missing = COMMAND_IDENTITIES.flatMap((cmd) =>+ cmd.palette && !OVERRIDES.has(cmd.id) && cmd.menuActionId === undefined ? [cmd.id] : [],+ );+ expect(missing).toEqual([]);+ });++ test('every registry shortcutId resolves in the keyboard-shortcut registry', () => {+ const bad = COMMAND_IDENTITIES.flatMap((cmd) => {+ if (cmd.shortcutId === undefined) return [];+ try {+ formatShortcut(cmd.shortcutId as KeyboardShortcutId, 'mac');+ return [];+ } catch {+ return [cmd.id];+ }+ });+ expect(bad).toEqual([]);+ });++ // Ratchet B, structural cure: with placement now DECLARED in the registry, a+ // command that lists two placements resolving to the same platform is the+ // hand-duplication class the "Check for updates" App+Help dupe belonged to.+ // Flag it at the declaration level — earlier than the rendered-output dupe+ // check above. A deliberate multi-placement earns an allowlist entry.+ const DECLARED_MULTI_PLACEMENT = new Set<string>([]);++ test('Ratchet B (declared): no command has two same-platform menu placements', () => {+ const resolvesTo = (platform: 'mac' | 'other', p: MenuPlatform): boolean =>+ p === 'all' || p === platform;+ const offenders = COMMAND_IDENTITIES.flatMap((cmd) => {+ if (DECLARED_MULTI_PLACEMENT.has(cmd.id)) return [];+ const placements = cmd.menu ?? [];+ const macCount = placements.filter((p) => resolvesTo('mac', p.platform ?? 'all')).length;+ const otherCount = placements.filter((p) => resolvesTo('other', p.platform ?? 'all')).length;+ return macCount > 1 || otherCount > 1 ? [cmd.id] : [];+ });+ expect(offenders).toEqual([]);+ });++ // The registry-driven menu decouples identity (core) from the desktop binding+ // (click / enabled / presence / checkbox). A menu-placed command with no+ // binding renders a leaf with no click handler, enabled by default — a silent+ // no-op the optional-chained `MENU_BINDINGS[cmd.id]` lookup would not flag.+ test('every menu-placed command has a MENU_BINDINGS entry', () => {+ const missing = COMMAND_IDENTITIES.flatMap((cmd) =>+ cmd.menu && cmd.menu.length > 0 && !MENU_BINDING_IDS.has(cmd.id) ? [cmd.id] : [],+ );+ expect(missing).toEqual([]);+ });++ test('every MENU_BINDINGS entry maps to a menu-placed command (no stale bindings)', () => {+ const menuPlaced = new Set(+ COMMAND_IDENTITIES.flatMap((cmd) => (cmd.menu && cmd.menu.length > 0 ? [cmd.id] : [])),+ );+ const stale = [...MENU_BINDING_IDS].filter((id) => !menuPlaced.has(id));+ expect(stale).toEqual([]);+ });+});++// ─── Menu state-dependent rendering ─────────────────────────────────────────+// The registry drives the Show/Hide toggle label, the smart-hide `visible`+// flag, the checkbox `type`/`checked` state, and presence-gated absence through+// generic code in `buildCommandLeaves` / `menuLeafLabel`. The classification+// sweeps above run a single all-enabled `makeFullDeps` snapshot, so a condition+// inversion in that generic code (a flipped Show/Hide, availability mapped to+// `enabled` instead of `visible`, an inverted `checked`, a dropped presence+// gate) would render a user-visible menu regression while staying green. These+// pin each branch by building the template with the triggering state.+describe('menu state-dependent rendering', () => {+ const findLeaf = (leaves: Leaf[], label: string): Leaf | undefined =>+ leaves.find((leaf) => normalizeLabel(leaf.label) === label);++ test('Show/Hide toggles render the Show variant when the panel is hidden', () => {+ const leaves = collectLeavesForPlatform('darwin', {+ ...makeFullDeps(),+ sidebarVisible: false,+ docPanelVisible: false,+ terminalVisible: false,+ });+ const labels = new Set(leaves.map((leaf) => normalizeLabel(leaf.label)));+ expect(labels.has('Show sidebar')).toBe(true);+ expect(labels.has('Show document panel')).toBe(true);+ expect(labels.has('Show Terminal')).toBe(true);+ // A flipped `visible ? hideKey : showKey` would leave the Hide variants here.+ expect(labels.has('Hide sidebar')).toBe(false);+ expect(labels.has('Hide document panel')).toBe(false);+ expect(labels.has('Hide Terminal')).toBe(false);+ });++ test('Show/Hide toggles render the Hide variant when the panel is visible', () => {+ const leaves = collectLeavesForPlatform('darwin', {+ ...makeFullDeps(),+ sidebarVisible: true,+ docPanelVisible: true,+ terminalVisible: true,+ });+ const labels = new Set(leaves.map((leaf) => normalizeLabel(leaf.label)));+ expect(labels.has('Hide sidebar')).toBe(true);+ expect(labels.has('Show sidebar')).toBe(false);+ });++ test('smart-hide maps availability to `visible` (not `enabled`) for Expand/Collapse all', () => {+ // canExpandAll:false → the Expand all leaf renders `visible:false` while+ // staying enabled (its click dep is wired). Mapping availability to `enabled`+ // instead would drop the leaf from the collected set (disabled-item filter),+ // which the `toBeDefined` assertion catches.+ const collapsedTree = collectLeavesForPlatform('darwin', {+ ...makeFullDeps(),+ canExpandAll: false,+ canCollapseAll: true,+ });+ const expandAll = findLeaf(collapsedTree, 'Expand all');+ expect(expandAll).toBeDefined();+ expect(expandAll?.visible).toBe(false);+ expect(findLeaf(collapsedTree, 'Collapse all')?.visible).toBe(true);++ const expandedTree = collectLeavesForPlatform('darwin', {+ ...makeFullDeps(),+ canExpandAll: true,+ canCollapseAll: false,+ });+ expect(findLeaf(expandedTree, 'Expand all')?.visible).toBe(true);+ expect(findLeaf(expandedTree, 'Collapse all')?.visible).toBe(false);+ });++ test('checkbox items carry `type: checkbox` and track the checked state', () => {+ const checkedLeaf = findLeaf(+ collectLeavesForPlatform('darwin', { ...makeFullDeps(), showHiddenFilesChecked: true }),+ 'Show hidden files',+ );+ expect(checkedLeaf?.itemType).toBe('checkbox');+ expect(checkedLeaf?.checked).toBe(true);++ const uncheckedLeaf = findLeaf(+ collectLeavesForPlatform('darwin', { ...makeFullDeps(), showHiddenFilesChecked: false }),+ 'Show hidden files',+ );+ expect(uncheckedLeaf?.itemType).toBe('checkbox');+ expect(uncheckedLeaf?.checked).toBe(false);+ });++ test('presence-gated leaves disappear when their dep is unwired', () => {+ // `check-for-updates` is presence-gated on `onCheckForUpdates`; dropping the+ // dep removes the leaf entirely (not render it disabled) on both the macOS+ // App-menu and the Windows/Linux Help-menu placement.+ for (const platform of ['darwin', 'win32'] as const) {+ expect(+ findLeaf(collectLeavesForPlatform(platform, makeFullDeps()), 'Check for updates'),+ ).toBeDefined();+ const withoutDep = collectLeavesForPlatform(platform, {+ ...makeFullDeps(),+ onCheckForUpdates: undefined,+ });+ expect(findLeaf(withoutDep, 'Check for updates')).toBeUndefined();+ }+ // `set-up-integrations` is presence-gated on `reconfigureMcpWiring`: unwiring+ // it must remove the File-menu leaf, not render a non-functional MCP entry.+ expect(+ findLeaf(+ collectLeavesForPlatform('darwin', makeFullDeps()),+ 'Set up OpenKnowledge integrations',+ ),+ ).toBeDefined();+ expect(+ findLeaf(+ collectLeavesForPlatform('darwin', { ...makeFullDeps(), reconfigureMcpWiring: undefined }),+ 'Set up OpenKnowledge integrations',+ ),+ ).toBeUndefined();+ });+});diff --git a/packages/app/src/lib/menu-label-parity.test.ts b/packages/app/src/lib/menu-label-parity.test.tsindex f8b12aa3d..b24f516e3 100644--- a/packages/app/src/lib/menu-label-parity.test.ts+++ b/packages/app/src/lib/menu-label-parity.test.ts@@ -1,19 +1,29 @@import { beforeAll, describe, expect, it } from 'bun:test';import { readFileSync } from 'node:fs';import { join } from 'node:path';-import { MENU_LABELS } from '@inkeep/open-knowledge-core';+import { COMMAND_IDENTITIES, MENU_LABELS } from '@inkeep/open-knowledge-core';+import {+ PALETTE_COMMAND_LABELS,+ type PaletteLabelKey,+} from '@/components/command-palette-commands';+import { i18n } from '@/lib/i18n';/**- * Parity guard for the file/tree labels that appear in BOTH the native Electron- * menu and the in-app renderer menus.+ * Parity guard for the labels that appear in BOTH the native Electron menu and+ * the in-app renderer (the Cmd+K palette).** The native menu (`packages/desktop/src/main/menu.ts`) reads `MENU_LABELS`- * directly. The renderer wraps the SAME strings in Lingui `<Trans>` / t``- * macros — which require string literals, so the renderer can't import the- * constants — and those macros compile into this catalog. If a renderer label- * drifts from a shared constant (e.g. a casing change on one surface only), its- * value disappears from the catalog and this test fails, catching a divergence- * the native menu can't observe at runtime (it has no i18n).+ * directly (via each command's registry `labelKey`). The palette maps the SAME+ * `labelKey` to a Lingui `msg` descriptor in `PALETTE_COMMAND_LABELS` — the+ * macro requires a string literal, so the renderer can't import the constants —+ * and those descriptors compile into this catalog. This file asserts three+ * things, so a drift the native menu can't observe at runtime (it has no i18n)+ * turns the suite red:+ * 1. every `MENU_LABELS` value is in the compiled catalog (the original guard);+ * 2. every registry command's palette `labelKey` (and Show/Hide toggle keys)+ * has a descriptor in `PALETTE_COMMAND_LABELS` (completeness);+ * 3. every palette descriptor resolves to a string that is in the catalog and,+ * where the key is also a `MENU_LABELS` key, equals the menu string.*/function collectStrings(node: unknown, out: Set<string>): void {if (typeof node === 'string') {@@ -44,3 +54,40 @@ describe('shared menu labels stay in sync between the native menu and the render});}});++describe('palette label map covers every registry labelKey (Phase 2b)', () => {+ for (const cmd of COMMAND_IDENTITIES) {+ if (!cmd.palette) continue;+ const keys = cmd.stateToggle+ ? [cmd.stateToggle.showKey, cmd.stateToggle.hideKey]+ : cmd.labelKey !== undefined+ ? [cmd.labelKey]+ : [];+ for (const key of keys) {+ it(`palette command "${cmd.id}" label key "${key}" has a descriptor`, () => {+ expect(key in PALETTE_COMMAND_LABELS).toBe(true);+ });+ }+ }+});++describe('every palette descriptor is in the catalog and agrees with MENU_LABELS', () => {+ for (const [key, descriptor] of Object.entries(PALETTE_COMMAND_LABELS)) {+ const paletteString = i18n._(descriptor);+ it(`palette label "${key}" resolves to a catalog string`, () => {+ expect(catalogStrings.has(paletteString)).toBe(true);+ });+ if (key in MENU_LABELS) {+ it(`palette label "${key}" equals MENU_LABELS.${key}`, () => {+ expect(paletteString).toBe(MENU_LABELS[key as keyof typeof MENU_LABELS]);+ });+ }+ }++ it('every palette label key is a MENU_LABELS key (no orphan palette labels)', () => {+ const orphans = (Object.keys(PALETTE_COMMAND_LABELS) as PaletteLabelKey[]).filter(+ (key) => !(key in MENU_LABELS),+ );+ expect(orphans).toEqual([]);+ });+});diff --git a/packages/core/src/commands/command-identity.test.ts b/packages/core/src/commands/command-identity.test.tsnew file mode 100644index 000000000..8e87da611--- /dev/null+++ b/packages/core/src/commands/command-identity.test.ts@@ -0,0 +1,149 @@+import { describe, expect, test } from 'bun:test';+import { MENU_LABELS } from '../constants/menu-labels.ts';+import {+ COMMAND_IDENTITIES,+ type CommandContext,+ evaluateCommandAvailability,+} from './command-identity.ts';++function ctx(overrides: Partial<CommandContext> = {}): CommandContext {+ return {+ host: 'desktop',+ activeTargetKind: 'doc',+ singleFile: false,+ terminalLive: false,+ canExpandAll: true,+ canCollapseAll: true,+ hasActiveDoc: true,+ showInstallSkill: true,+ ...overrides,+ };+}++describe('evaluateCommandAvailability', () => {+ test('empty spec is always available', () => {+ expect(evaluateCommandAvailability({}, ctx())).toBe(true);+ expect(evaluateCommandAvailability({}, ctx({ host: 'web', activeTargetKind: 'none' }))).toBe(+ true,+ );+ });++ test('host: desktop hides on web', () => {+ expect(evaluateCommandAvailability({ host: 'desktop' }, ctx({ host: 'web' }))).toBe(false);+ expect(evaluateCommandAvailability({ host: 'desktop' }, ctx({ host: 'desktop' }))).toBe(true);+ expect(evaluateCommandAvailability({ host: 'all' }, ctx({ host: 'web' }))).toBe(true);+ });++ test('requiresTargetKinds gates on the projected kind', () => {+ const spec = { requiresTargetKinds: ['doc', 'folder'] as const };+ expect(evaluateCommandAvailability(spec, ctx({ activeTargetKind: 'doc' }))).toBe(true);+ expect(evaluateCommandAvailability(spec, ctx({ activeTargetKind: 'folder' }))).toBe(true);+ expect(evaluateCommandAvailability(spec, ctx({ activeTargetKind: 'asset' }))).toBe(false);+ expect(evaluateCommandAvailability(spec, ctx({ activeTargetKind: 'none' }))).toBe(false);+ expect(evaluateCommandAvailability(spec, ctx({ activeTargetKind: 'project' }))).toBe(false);+ });++ // The load-bearing reconciliation: reveal/copy are actionable in the menu's+ // project scope but hidden in the palette with no target — one spec, two+ // contexts, because the menu projects project-scope to `project` and the+ // palette projects no-target to `none`.+ test('reveal/copy spec: project-scope actionable, no-target hidden', () => {+ const spec = { requiresTargetKinds: ['doc', 'folder', 'asset', 'project'] as const };+ // Menu: project scope → project → available.+ expect(evaluateCommandAvailability(spec, ctx({ activeTargetKind: 'project' }))).toBe(true);+ // Palette: no target → none → hidden.+ expect(evaluateCommandAvailability(spec, ctx({ activeTargetKind: 'none' }))).toBe(false);+ });++ test('singleFileHidden, terminalLive, expand/collapse, activeDoc, installSkill gates', () => {+ expect(evaluateCommandAvailability({ singleFileHidden: true }, ctx({ singleFile: true }))).toBe(+ false,+ );+ expect(+ evaluateCommandAvailability({ requiresTerminalLive: true }, ctx({ terminalLive: false })),+ ).toBe(false);+ expect(+ evaluateCommandAvailability({ requiresCanExpandAll: true }, ctx({ canExpandAll: false })),+ ).toBe(false);+ expect(+ evaluateCommandAvailability({ requiresCanCollapseAll: true }, ctx({ canCollapseAll: false })),+ ).toBe(false);+ expect(+ evaluateCommandAvailability({ requiresActiveDoc: true }, ctx({ hasActiveDoc: false })),+ ).toBe(false);+ expect(+ evaluateCommandAvailability({ requiresInstallSkill: true }, ctx({ showInstallSkill: false })),+ ).toBe(false);+ });++ // Real commands combine gates (e.g. rename is host:desktop + requiresTargetKinds).+ // Pin the multi-gate path so a reorder or short-circuit interaction can't pass.+ test('compound gates: host AND target-kind must both pass', () => {+ const spec = { host: 'desktop', requiresTargetKinds: ['doc'] } as const;+ expect(evaluateCommandAvailability(spec, ctx({ host: 'web', activeTargetKind: 'doc' }))).toBe(+ false,+ );+ expect(+ evaluateCommandAvailability(spec, ctx({ host: 'desktop', activeTargetKind: 'asset' })),+ ).toBe(false);+ expect(+ evaluateCommandAvailability(spec, ctx({ host: 'desktop', activeTargetKind: 'doc' })),+ ).toBe(true);+ });+});++describe('COMMAND_IDENTITIES registry invariants', () => {+ test('command ids are unique', () => {+ const ids = COMMAND_IDENTITIES.map((c) => c.id);+ expect(new Set(ids).size).toBe(ids.length);+ });++ test('menuActionIds are unique among commands that declare one', () => {+ const actionIds = COMMAND_IDENTITIES.flatMap((c) => (c.menuActionId ? [c.menuActionId] : []));+ expect(new Set(actionIds).size).toBe(actionIds.length);+ });++ test('every palette command has a labelKey that resolves in MENU_LABELS', () => {+ for (const cmd of COMMAND_IDENTITIES) {+ if (!cmd.palette) continue;+ expect(cmd.labelKey).toBeDefined();+ expect(MENU_LABELS[cmd.labelKey as keyof typeof MENU_LABELS]).toBeDefined();+ }+ });++ test('every menu placement labelKey / stateToggle key resolves in MENU_LABELS', () => {+ for (const cmd of COMMAND_IDENTITIES) {+ if (cmd.stateToggle) {+ expect(MENU_LABELS[cmd.stateToggle.showKey]).toBeDefined();+ expect(MENU_LABELS[cmd.stateToggle.hideKey]).toBeDefined();+ }+ for (const placement of cmd.menu ?? []) {+ if (placement.menuLabelKey) expect(MENU_LABELS[placement.menuLabelKey]).toBeDefined();+ // A menu leaf must resolve to SOME label: an explicit literal, a menu+ // key override, or the command's own labelKey.+ const resolvable =+ placement.menuLabelText !== undefined ||+ placement.menuLabelKey !== undefined ||+ cmd.stateToggle !== undefined ||+ cmd.labelKey !== undefined;+ expect({ id: cmd.id, resolvable }).toEqual({ id: cmd.id, resolvable: true });+ }+ }+ });++ // Structural cure precondition: no command declares two placements that+ // resolve to the same platform (that is how a leaf gets hand-duplicated). The+ // palette-side Ratchet B extension asserts this against the rendered menu too.+ test('no command has two menu placements for the same platform', () => {+ for (const cmd of COMMAND_IDENTITIES) {+ const platforms = (cmd.menu ?? []).map((p) => p.platform ?? 'all');+ const macCount = platforms.filter((p) => p === 'all' || p === 'mac').length;+ const otherCount = platforms.filter((p) => p === 'all' || p === 'other').length;+ expect({ id: cmd.id, macCount: macCount <= 1, otherCount: otherCount <= 1 }).toEqual({+ id: cmd.id,+ macCount: true,+ otherCount: true,+ });+ }+ });+});diff --git a/packages/core/src/commands/command-identity.ts b/packages/core/src/commands/command-identity.tsnew file mode 100644index 000000000..41e892d04--- /dev/null+++ b/packages/core/src/commands/command-identity.ts@@ -0,0 +1,633 @@+import type { MenuLabelKey } from '../constants/menu-labels.ts';++/**+ * Shared, serializable command identity for OpenKnowledge's global command+ * surfaces — the ONE declaration point the native Electron menu+ * (`packages/desktop/src/main/menu.ts`) and the Cmd+K palette+ * (`packages/app/src/components/command-palette-commands.ts`) both render from.+ *+ * This module is CORE: browser + node safe, Lingui-free, `tsdown`-built (no+ * macro transform). So every field here is PLAIN DATA — no functions, no+ * `lucide-react` icons, no Lingui `msg` descriptors. Each surface joins this+ * identity with its own presentation (the menu adds plain labels + click deps;+ * the palette adds `msg` labels + `lucide` icons + dispatch closures).+ *+ * `menuActionId` and `shortcutId` are typed as bare strings here because their+ * unions (`OkMenuAction`, `KeyboardShortcutId`) live in the desktop/app+ * packages, which core cannot import. The app/desktop wrappers narrow them, and+ * the parity ratchets (`command-menu-parity.test.ts`) assert every id is real.+ */++/** Palette render buckets; the palette renders each group under its own heading. */+export type CommandGroup = 'commands' | 'project' | 'file' | 'view' | 'terminal' | 'app';++/**+ * Projected active-target kind, shared by both surfaces' availability contexts.+ * `project` is the menu's project-scope signal (a window is open on a project,+ * no file selected — contentDir is still an actionable target); `none` is the+ * palette's "no target" signal. Keeping them distinct lets one availability+ * spec drive both surfaces: `reveal-in-finder` / copy-path are actionable in+ * project scope (menu) yet hidden with no target (palette), which is exactly+ * `requiresTargetKinds` including `project` but not `none`.+ */+export type ContextualTargetKind = 'doc' | 'folder' | 'asset' | 'project' | 'none';++/** Host gate. `all` = web + desktop; `desktop` hides on the web host. */+export type CommandHostScope = 'all' | 'desktop';++/**+ * Declarative availability. The pure {@link evaluateCommandAvailability}+ * evaluates this against a {@link CommandContext}; the menu maps the result to+ * `enabled` (or `visible`, for smart-hidden tree commands) and the palette maps+ * it to whether the row renders. Every field references DATA only, so this+ * predicate stays core-safe: a declarative spec + pure evaluator, never a+ * renderer-reaching predicate.+ */+export interface CommandAvailabilitySpec {+ /** Host gate; defaults to `all`. */+ readonly host?: CommandHostScope;+ /** Active target must project to one of these kinds. */+ readonly requiresTargetKinds?: readonly ContextualTargetKind[];+ /** Hidden in a no-project single-file session. */+ readonly singleFileHidden?: boolean;+ /** Requires a live (mounted) terminal session. */+ readonly requiresTerminalLive?: boolean;+ /** Requires an expandable tree (smart-hide when everything is expanded). */+ readonly requiresCanExpandAll?: boolean;+ /** Requires a collapsible tree (smart-hide when everything is collapsed). */+ readonly requiresCanCollapseAll?: boolean;+ /** Requires an active document (e.g. Open graph). */+ readonly requiresActiveDoc?: boolean;+ /** Requires the install-skill feature flag (`SHOW_INSTALL_SKILL`). */+ readonly requiresInstallSkill?: boolean;+}++/**+ * The DATA a command needs to decide availability, assembled per render by each+ * surface: the menu from the IPC-pushed active-target snapshot + platform; the+ * palette from `DocumentContext` + the view-menu-state store. Booleans are+ * pre-normalized by the caller (e.g. `canExpandAll = raw !== false`,+ * `terminalLive = raw === true`) so the evaluator stays a plain membership test.+ */+export interface CommandContext {+ readonly host: 'desktop' | 'web';+ readonly activeTargetKind: ContextualTargetKind;+ readonly singleFile: boolean;+ readonly terminalLive: boolean;+ readonly canExpandAll: boolean;+ readonly canCollapseAll: boolean;+ readonly hasActiveDoc: boolean;+ readonly showInstallSkill: boolean;+}++/** Pure availability predicate. No side effects, no renderer/desktop concepts. */+export function evaluateCommandAvailability(+ spec: CommandAvailabilitySpec,+ ctx: CommandContext,+): boolean {+ if (spec.host === 'desktop' && ctx.host !== 'desktop') return false;+ if (spec.singleFileHidden && ctx.singleFile) return false;+ if (spec.requiresTerminalLive && !ctx.terminalLive) return false;+ if (spec.requiresCanExpandAll && !ctx.canExpandAll) return false;+ if (spec.requiresCanCollapseAll && !ctx.canCollapseAll) return false;+ if (spec.requiresActiveDoc && !ctx.hasActiveDoc) return false;+ if (spec.requiresInstallSkill && !ctx.showInstallSkill) return false;+ if (spec.requiresTargetKinds && !spec.requiresTargetKinds.includes(ctx.activeTargetKind)) {+ return false;+ }+ return true;+}++/** Which platform's menu bar a placement targets. `all` = both. */+export type MenuPlatform = 'all' | 'mac' | 'other';++/**+ * Named slots in the native menu's declarative scaffolding. `buildMenuTemplate`+ * owns the roles / separators / submenu parents / recents around these; each+ * command leaf declares which slot it lands in and at what order. A command may+ * declare more than one placement (e.g. Settings / Check for updates are+ * platform-XOR: one `mac` placement, one `other`), which is how the+ * "Check for updates" duplicate becomes data instead of a hand-branch.+ */+export type MenuSection =+ | 'app-updates'+ | 'app-settings'+ | 'app-uninstall'+ | 'file-create'+ | 'file-project'+ | 'file-worktree'+ | 'file-item'+ | 'file-reveal'+ | 'file-copy-path'+ | 'file-integrations'+ | 'file-settings'+ | 'file-close'+ | 'edit-spell'+ | 'view-panels'+ | 'view-visibility'+ | 'view-tree'+ | 'terminal'+ | 'help-install'+ | 'help-links'+ | 'help-updates';++export interface CommandMenuPlacement {+ readonly section: MenuSection;+ /** Sort key within the section (menu leaves render in ascending order). */+ readonly order: number;+ /** Platform gate; defaults to `all`. */+ readonly platform?: MenuPlatform;+ /** Electron accelerator, single-sourced here; a parity test asserts it agrees+ * with the app's keyboard-shortcut registry (the two share no import). */+ readonly accelerator?: string;+ /** Append the native "opens a new surface" ellipsis (…) at render time. */+ readonly ellipsis?: boolean;+ /** Render as an Electron checkbox item. */+ readonly checkbox?: boolean;+ /** Smart-hide: map availability to `visible` (not `enabled`) — Expand/Collapse all. */+ readonly smartHide?: boolean;+ /**+ * Menu label key override into `MENU_LABELS`, when the native menu renders a+ * different label than the palette (e.g. Copy path's children are "Full path"+ * / "Relative path" in the menu, "Copy full path" / "Copy relative path" in+ * the palette). Defaults to the command's `labelKey`.+ */+ readonly menuLabelKey?: MenuLabelKey;+ /**+ * Literal native-menu label, for the handful of menu strings that are NOT in+ * the shared `MENU_LABELS` parity contract: menu-only leaves (Uninstall, New+ * Terminal Window) and two leaves whose native label predates the app's+ * sentence-case convention and stays byte-identical here (Report a Bug,+ * Install…(desktop app)). Takes precedence over `menuLabelKey`.+ */+ readonly menuLabelText?: string;+}++/** Show/Hide state-toggle labels (single menu row whose label flips on state). */+export interface CommandStateToggle {+ readonly showKey: MenuLabelKey;+ readonly hideKey: MenuLabelKey;+ /** View-menu-state field driving the label. */+ readonly stateField: 'sidebarVisible' | 'docPanelVisible' | 'terminalVisible';+ /** Menu default when the state is unknown (sidebar/doc-panel start visible → "Hide"). */+ readonly defaultVisible: boolean;+}++/** View-menu-state checkbox field a command's check indicator reads. */+export type CommandCheckField =+ | 'showHiddenFiles'+ | 'showOkFolders'+ | 'showOnlyMarkdownFiles'+ | 'showSkillsSection';++/** Palette presentation hints (serializable subset; icon/label/dispatch are app-side). */+export interface CommandPalettePresence {+ readonly group: CommandGroup;+ /** `always` renders on empty open; `search-only` renders only under a matching query. */+ readonly visibility: 'always' | 'search-only';+}++export interface CommandIdentity {+ /** Stable id; the palette DOM testid is `command-palette-${id}`. */+ readonly id: string;+ /** The `OkMenuAction` this command dispatches, when it routes through the menu-action bus. */+ readonly menuActionId?: string;+ /**+ * Canonical label key (into `MENU_LABELS`) — the palette's label + the menu's+ * default. Omitted for menu-only leaves that render a literal `menuLabelText`+ * (Uninstall, New Terminal Window) with no palette row.+ */+ readonly labelKey?: MenuLabelKey;+ /** Extra `matchesCommandQuery` tokens beyond the label. Not localized. */+ readonly keywords: readonly string[];+ /** Keyboard-shortcut id whose accelerator the palette renders (`formatShortcut`). */+ readonly shortcutId?: string;+ /** The shortcut only fires via a native-menu accelerator (no web keydown). */+ readonly shortcutDesktopOnly?: boolean;+ /** Show/Hide toggle metadata (sidebar / document panel / terminal). */+ readonly stateToggle?: CommandStateToggle;+ /** Checkbox check-state field (palette check indicator + menu checked source). */+ readonly checkField?: CommandCheckField;+ readonly availability: CommandAvailabilitySpec;+ /** Palette presence (omitted for menu-only commands: send-to-ai, uninstall, new-terminal-window). */+ readonly palette?: CommandPalettePresence;+ /** Native-menu placement(s) (omitted for palette-only commands: open-graph, initialize-starter-pack). */+ readonly menu?: readonly CommandMenuPlacement[];+}++/**+ * The command identity registry. Order matches the palette's row order+ * within each group (the palette filters by group and preserves array order).+ * Menu-only commands are interleaved near their menu neighbors.+ */+export const COMMAND_IDENTITIES: readonly CommandIdentity[] = [+ // ── Commands group (palette) / File-create (menu) ───────────────────────────+ {+ id: 'new-file',+ menuActionId: 'new-doc',+ labelKey: 'newFile',+ keywords: ['create file'],+ shortcutId: 'new-item',+ availability: {},+ palette: { group: 'commands', visibility: 'always' },+ menu: [{ section: 'file-create', order: 0, accelerator: 'CmdOrCtrl+N' }],+ },+ {+ id: 'new-folder',+ menuActionId: 'new-folder',+ labelKey: 'newFolder',+ keywords: ['create folder'],+ shortcutId: 'new-folder',+ shortcutDesktopOnly: true,+ availability: {},+ palette: { group: 'commands', visibility: 'always' },+ menu: [{ section: 'file-create', order: 1, accelerator: 'CmdOrCtrl+Shift+N' }],+ },+ {+ id: 'open-graph',+ labelKey: 'openGraph',+ keywords: ['graph panel network'],+ availability: { requiresActiveDoc: true },+ palette: { group: 'commands', visibility: 'always' },+ },+ {+ id: 'initialize-starter-pack',+ labelKey: 'initializeStarterPack',+ keywords: ['scaffold', 'seed', 'pack', 'starter'],+ availability: {},+ palette: { group: 'commands', visibility: 'always' },+ },+ // ── Project group (palette) / File-project (menu) ───────────────────────────+ {+ id: 'new-project',+ menuActionId: 'new-project',+ labelKey: 'newProject',+ keywords: ['create new project scaffold'],+ availability: { host: 'desktop' },+ palette: { group: 'project', visibility: 'always' },+ menu: [{ section: 'file-project', order: 0, ellipsis: true }],+ },+ {+ id: 'open-folder',+ labelKey: 'openFolderOnDisk',+ keywords: ['project'],+ shortcutId: 'open-folder',+ availability: { host: 'desktop' },+ palette: { group: 'project', visibility: 'always' },+ menu: [+ {+ section: 'file-project',+ order: 2,+ accelerator: 'CmdOrCtrl+O',+ ellipsis: true,+ menuLabelKey: 'openFolder',+ },+ ],+ },+ {+ id: 'switch-project',+ labelKey: 'switchProject',+ keywords: ['switch project navigator projects'],+ shortcutId: 'switch-project',+ availability: { host: 'desktop', singleFileHidden: true },+ palette: { group: 'project', visibility: 'always' },+ menu: [{ section: 'file-project', order: 1, accelerator: 'CmdOrCtrl+Shift+P', ellipsis: true }],+ },+ {+ id: 'settings',+ labelKey: 'settings',+ keywords: ['preferences config'],+ shortcutId: 'settings',+ availability: { singleFileHidden: true },+ palette: { group: 'project', visibility: 'always' },+ menu: [+ {+ section: 'app-settings',+ order: 0,+ platform: 'mac',+ accelerator: 'CmdOrCtrl+,',+ ellipsis: true,+ },+ {+ section: 'file-settings',+ order: 0,+ platform: 'other',+ accelerator: 'CmdOrCtrl+,',+ ellipsis: true,+ },+ ],+ },+ {+ id: 'install-claude-desktop',+ labelKey: 'installClaudeDesktop',+ keywords: ['claude desktop install cowork'],+ availability: { requiresInstallSkill: true },+ palette: { group: 'project', visibility: 'always' },+ menu: [+ {+ section: 'help-install',+ order: 0,+ ellipsis: true,+ menuLabelText: 'Install for Claude Chat & Cowork (desktop app)',+ },+ ],+ },+ {+ id: 'report-bug',+ menuActionId: 'report-bug',+ labelKey: 'reportBug',+ keywords: ['bug report issue feedback problem'],+ availability: { host: 'desktop' },+ palette: { group: 'project', visibility: 'always' },+ menu: [{ section: 'help-links', order: 1, ellipsis: true, menuLabelText: 'Report a Bug' }],+ },+ // ── File group (palette) / File-item + worktree (menu) ──────────────────────+ {+ id: 'new-from-template',+ menuActionId: 'new-from-template',+ labelKey: 'newFromTemplate',+ keywords: ['template', 'create', 'new'],+ availability: { singleFileHidden: true },+ palette: { group: 'file', visibility: 'search-only' },+ menu: [{ section: 'file-create', order: 2, ellipsis: true }],+ },+ {+ id: 'rename',+ menuActionId: 'rename',+ labelKey: 'rename',+ keywords: ['rename', 'file', 'folder'],+ availability: { host: 'desktop', requiresTargetKinds: ['doc', 'folder', 'asset'] },+ palette: { group: 'file', visibility: 'search-only' },+ menu: [{ section: 'file-item', order: 1 }],+ },+ {+ id: 'duplicate',+ menuActionId: 'duplicate',+ labelKey: 'duplicate',+ keywords: ['duplicate', 'copy', 'file', 'folder'],+ shortcutId: 'file-tree-duplicate',+ availability: { host: 'desktop', requiresTargetKinds: ['doc', 'folder'] },+ palette: { group: 'file', visibility: 'search-only' },+ menu: [{ section: 'file-item', order: 0, accelerator: 'CmdOrCtrl+D' }],+ },+ {+ id: 'move-to-trash',+ menuActionId: 'move-to-trash',+ labelKey: 'moveToTrash',+ keywords: ['delete', 'trash', 'remove'],+ shortcutId: 'file-tree-delete',+ availability: { host: 'desktop', requiresTargetKinds: ['doc', 'folder', 'asset'] },+ palette: { group: 'file', visibility: 'search-only' },+ menu: [{ section: 'file-item', order: 2, accelerator: 'CmdOrCtrl+Delete' }],+ },+ {+ id: 'reveal-in-finder',+ menuActionId: 'reveal-in-finder',+ labelKey: 'revealInFinder',+ keywords: ['finder', 'reveal', 'show', 'file'],+ availability: { host: 'desktop', requiresTargetKinds: ['doc', 'folder', 'asset', 'project'] },+ palette: { group: 'file', visibility: 'search-only' },+ menu: [{ section: 'file-reveal', order: 0 }],+ },+ {+ // Menu-only "Open with AI" leaf. The palette surfaces send-to-ai as a+ // bespoke per-target Open-with-AI group, not a fixed registry row.+ id: 'send-to-ai',+ menuActionId: 'send-to-ai',+ labelKey: 'openWithAi',+ keywords: ['ai', 'agent', 'handoff'],+ availability: { host: 'desktop', requiresTargetKinds: ['doc', 'folder', 'project'] },+ menu: [{ section: 'file-reveal', order: 1 }],+ },+ {+ id: 'copy-full-path',+ menuActionId: 'copy-full-path',+ labelKey: 'copyFullPath',+ keywords: ['copy', 'path', 'absolute', 'full'],+ availability: { host: 'desktop', requiresTargetKinds: ['doc', 'folder', 'asset', 'project'] },+ palette: { group: 'file', visibility: 'search-only' },+ menu: [{ section: 'file-copy-path', order: 0, menuLabelKey: 'fullPath' }],+ },+ {+ id: 'copy-relative-path',+ menuActionId: 'copy-relative-path',+ labelKey: 'copyRelativePath',+ keywords: ['copy', 'path', 'relative'],+ availability: { host: 'desktop', requiresTargetKinds: ['doc', 'folder', 'asset', 'project'] },+ palette: { group: 'file', visibility: 'search-only' },+ menu: [{ section: 'file-copy-path', order: 1, menuLabelKey: 'relativePath' }],+ },+ {+ id: 'close-tab',+ menuActionId: 'close-active-tab-or-window',+ labelKey: 'closeTab',+ keywords: ['close', 'tab', 'window'],+ availability: { host: 'desktop' },+ palette: { group: 'file', visibility: 'search-only' },+ menu: [{ section: 'file-close', order: 0, platform: 'mac', accelerator: 'CmdOrCtrl+W' }],+ },+ {+ id: 'new-worktree',+ menuActionId: 'new-worktree',+ labelKey: 'newWorktree',+ keywords: ['worktree', 'branch', 'new'],+ availability: { host: 'desktop' },+ palette: { group: 'file', visibility: 'search-only' },+ menu: [{ section: 'file-worktree', order: 0, ellipsis: true }],+ },+ {+ id: 'switch-worktree',+ menuActionId: 'switch-worktree',+ labelKey: 'switchWorktree',+ keywords: ['worktree', 'switch', 'branch'],+ availability: { host: 'desktop' },+ palette: { group: 'file', visibility: 'search-only' },+ menu: [{ section: 'file-worktree', order: 1, ellipsis: true }],+ },+ // ── View group (palette) / View-panels + visibility + tree (menu) ───────────+ {+ id: 'toggle-sidebar',+ menuActionId: 'toggle-sidebar',+ labelKey: 'sidebarHide',+ keywords: ['sidebar', 'files', 'panel', 'toggle'],+ shortcutId: 'toggle-files-sidebar',+ stateToggle: {+ showKey: 'sidebarShow',+ hideKey: 'sidebarHide',+ stateField: 'sidebarVisible',+ defaultVisible: true,+ },+ availability: {},+ palette: { group: 'view', visibility: 'search-only' },+ menu: [{ section: 'view-panels', order: 0, accelerator: 'CmdOrCtrl+Alt+S' }],+ },+ {+ id: 'toggle-doc-panel',+ menuActionId: 'toggle-doc-panel',+ labelKey: 'docPanelHide',+ keywords: ['document', 'panel', 'info', 'toggle'],+ shortcutId: 'toggle-document-panel',+ stateToggle: {+ showKey: 'docPanelShow',+ hideKey: 'docPanelHide',+ stateField: 'docPanelVisible',+ defaultVisible: true,+ },+ availability: {},+ palette: { group: 'view', visibility: 'search-only' },+ menu: [{ section: 'view-panels', order: 1, accelerator: 'CmdOrCtrl+Alt+B' }],+ },+ {+ id: 'toggle-terminal',+ menuActionId: 'toggle-terminal',+ labelKey: 'terminalShow',+ keywords: ['terminal', 'shell', 'console', 'toggle'],+ shortcutId: 'toggle-terminal-panel',+ stateToggle: {+ showKey: 'terminalShow',+ hideKey: 'terminalHide',+ stateField: 'terminalVisible',+ defaultVisible: false,+ },+ availability: { host: 'desktop' },+ palette: { group: 'view', visibility: 'search-only' },+ menu: [{ section: 'view-panels', order: 2, accelerator: 'CmdOrCtrl+J' }],+ },+ {+ id: 'toggle-show-hidden-files',+ menuActionId: 'toggle-show-hidden-files',+ labelKey: 'showHiddenFiles',+ keywords: ['hidden', 'dotfiles', 'files', 'show'],+ checkField: 'showHiddenFiles',+ availability: {},+ palette: { group: 'view', visibility: 'search-only' },+ menu: [+ { section: 'view-visibility', order: 0, accelerator: 'CmdOrCtrl+Shift+.', checkbox: true },+ ],+ },+ {+ id: 'toggle-show-ok-folders',+ menuActionId: 'toggle-show-ok-folders',+ labelKey: 'showOkFolders',+ keywords: ['ok', 'folders', 'hidden', 'show'],+ checkField: 'showOkFolders',+ availability: {},+ palette: { group: 'view', visibility: 'search-only' },+ menu: [{ section: 'view-visibility', order: 1, checkbox: true }],+ },+ {+ id: 'toggle-show-only-markdown-files',+ menuActionId: 'toggle-show-only-markdown-files',+ labelKey: 'showOnlyMarkdownFiles',+ keywords: ['markdown', 'filter', 'files', 'only'],+ checkField: 'showOnlyMarkdownFiles',+ availability: {},+ palette: { group: 'view', visibility: 'search-only' },+ menu: [{ section: 'view-visibility', order: 2, checkbox: true }],+ },+ {+ id: 'toggle-show-skills-section',+ menuActionId: 'toggle-show-skills-section',+ labelKey: 'showSkillsSection',+ keywords: ['skills', 'section', 'sidebar', 'show'],+ checkField: 'showSkillsSection',+ availability: {},+ palette: { group: 'view', visibility: 'search-only' },+ menu: [{ section: 'view-visibility', order: 3, checkbox: true }],+ },+ {+ id: 'expand-all-tree',+ menuActionId: 'expand-all-tree',+ labelKey: 'expandAll',+ keywords: ['expand', 'tree', 'folders', 'all'],+ availability: { requiresCanExpandAll: true },+ palette: { group: 'view', visibility: 'search-only' },+ menu: [{ section: 'view-tree', order: 0, smartHide: true }],+ },+ {+ id: 'collapse-all-tree',+ menuActionId: 'collapse-all-tree',+ labelKey: 'collapseAll',+ keywords: ['collapse', 'tree', 'folders', 'all'],+ availability: { requiresCanCollapseAll: true },+ palette: { group: 'view', visibility: 'search-only' },+ menu: [{ section: 'view-tree', order: 1, smartHide: true }],+ },+ // ── Terminal group (palette) / Terminal (menu) ──────────────────────────────+ {+ id: 'new-terminal',+ menuActionId: 'new-terminal',+ labelKey: 'newTerminal',+ keywords: ['terminal', 'shell', 'new', 'tab'],+ availability: { host: 'desktop' },+ palette: { group: 'terminal', visibility: 'search-only' },+ menu: [{ section: 'terminal', order: 0 }],+ },+ {+ // Menu-only leaf; opens a dedicated terminal window in main (no renderer handler).+ id: 'new-terminal-window',+ keywords: [],+ availability: { host: 'desktop' },+ menu: [{ section: 'terminal', order: 1, menuLabelText: 'New Terminal Window' }],+ },+ {+ id: 'kill-terminal',+ menuActionId: 'kill-terminal',+ labelKey: 'killTerminal',+ keywords: ['terminal', 'kill', 'close', 'session'],+ availability: { host: 'desktop', requiresTerminalLive: true },+ palette: { group: 'terminal', visibility: 'search-only' },+ menu: [{ section: 'terminal', order: 2 }],+ },+ // ── Application group (palette) / App + Edit + Help (menu) ───────────────────+ {+ id: 'check-for-updates',+ labelKey: 'checkForUpdates',+ keywords: ['update', 'upgrade', 'version', 'check'],+ availability: { host: 'desktop' },+ palette: { group: 'app', visibility: 'search-only' },+ menu: [+ { section: 'app-updates', order: 0, platform: 'mac', ellipsis: true },+ { section: 'help-updates', order: 0, platform: 'other', ellipsis: true },+ ],+ },+ {+ id: 'set-up-integrations',+ labelKey: 'setUpIntegrations',+ keywords: ['integrations', 'mcp', 'setup', 'claude', 'configure'],+ availability: { host: 'desktop' },+ palette: { group: 'app', visibility: 'search-only' },+ menu: [{ section: 'file-integrations', order: 0, ellipsis: true }],+ },+ {+ id: 'toggle-spell-check',+ labelKey: 'checkSpelling',+ keywords: ['spell', 'spelling', 'check', 'typing'],+ availability: { host: 'desktop' },+ palette: { group: 'app', visibility: 'search-only' },+ menu: [{ section: 'edit-spell', order: 0, checkbox: true }],+ },+ {+ id: 'open-github',+ labelKey: 'openOnGithub',+ keywords: ['github', 'source', 'repository', 'code'],+ availability: {},+ palette: { group: 'app', visibility: 'search-only' },+ menu: [{ section: 'help-links', order: 0 }],+ },+ {+ // Menu-only leaf; macOS App menu, presence-gated + rare/destructive.+ id: 'uninstall',+ keywords: [],+ availability: { host: 'desktop' },+ menu: [+ {+ section: 'app-uninstall',+ order: 0,+ platform: 'mac',+ ellipsis: true,+ menuLabelText: 'Uninstall OpenKnowledge',+ },+ ],+ },+];diff --git a/packages/core/src/constants/menu-labels.ts b/packages/core/src/constants/menu-labels.tsindex 8d1ee7e3a..8cd48757b 100644--- a/packages/core/src/constants/menu-labels.ts+++ b/packages/core/src/constants/menu-labels.ts@@ -1,7 +1,11 @@/**- * Canonical sentence-case labels for file/tree actions that appear in BOTH the- * native Electron menu bar (`packages/desktop/src/main/menu.ts`) and the in-app- * renderer menus (`FileTree.tsx` / `FileSidebar.tsx`).+ * Canonical sentence-case labels the shared command registry+ * (`@inkeep/open-knowledge-core/commands`) points its `labelKey` at. Most+ * surface in BOTH the native Electron menu bar (`packages/desktop/src/main/menu.ts`)+ * and the in-app renderer (`FileTree.tsx` / `FileSidebar.tsx` and the Cmd+K+ * palette); a few (e.g. `openGraph`, `initializeStarterPack`, the Show/Hide+ * toggle variants) are palette-only, kept here so the label-parity test guards+ * them and the registry keeps a single label source.** Why a shared constant: the same action surfaces twice and the two copies* must read identically. The native menu has no i18n runtime, so it imports@@ -16,8 +20,8 @@* (`packages/app/scripts/audit-strings/check-casing.ts`). Proper nouns keep* their capitals (Finder, Terminal, AI). Native menu items that open a new* surface append the platform ellipsis (…) per the Apple HIG — that suffix is- * native-only and is added at the menu.ts call site, not stored here (same- * split as `SWITCH_PROJECT_LABEL_WITH_ELLIPSIS` in the desktop package).+ * native-only and is added at the menu render site (the command registry's+ * per-placement `ellipsis` flag), not stored here.*/export const MENU_LABELS = {newFile: 'New file',@@ -58,7 +62,34 @@ export const MENU_LABELS = {killTerminal: 'Kill Terminal',checkSpelling: 'Check spelling while typing',openOnGithub: 'OpenKnowledge on GitHub',-} as const;+ // Additional shared command labels the registry references. Each string is+ // rendered identically by the palette, so the parity test stays green. The+ // native menu appends the … ellipsis at its call site where the command opens+ // a new surface (Switch project…, Settings…).+ switchProject: 'Switch project',+ settings: 'Settings',+ // Open folder's palette row is the descriptive "Open folder on disk"; the+ // native File menu renders the terser "Open folder…" via `openFolder` above.+ openFolderOnDisk: 'Open folder on disk',+ // Palette-only commands (no native-menu leaf); shared here so the label-parity+ // test guards them and the registry keeps a single label source.+ openGraph: 'Open graph',+ initializeStarterPack: 'Initialize starter pack',+ // State-aware Show/Hide toggles — both surfaces render both variants; the+ // native menu is a single row whose label flips on the pushed view-menu-state.+ sidebarShow: 'Show sidebar',+ sidebarHide: 'Hide sidebar',+ docPanelShow: 'Show document panel',+ docPanelHide: 'Hide document panel',+ terminalShow: 'Show Terminal',+ terminalHide: 'Hide Terminal',+ // Palette forms for the two commands whose native-menu leaf renders a+ // different literal via the placement's `menuLabelText` ("Report a Bug" keeps+ // its capital B; the install leaf renders "…(desktop app)" lowercase), so only+ // these palette strings participate in the shared-label parity contract.+ reportBug: 'Report a bug',+ installClaudeDesktop: 'Install for Claude Chat & Cowork (Desktop App)',+} as const satisfies Record<string, string>;export type MenuLabelKey = keyof typeof MENU_LABELS;diff --git a/packages/core/src/index.ts b/packages/core/src/index.tsindex a40ca50b6..41a4cb215 100644--- a/packages/core/src/index.ts+++ b/packages/core/src/index.ts@@ -62,6 +62,24 @@ export { PROTOCOL_VERSION } from './protocol-version.ts';// Re-export VFileMessage for Observer B's error classification (instanceof check// instead of fragile constructor.name string comparison).export { VFileMessage } from 'vfile-message';+// Shared command identity — the single declaration point the native menu and+// the Cmd+K palette both render from. Plain data + a pure evaluator.+export {+ COMMAND_IDENTITIES,+ type CommandAvailabilitySpec,+ type CommandCheckField,+ type CommandContext,+ type CommandGroup,+ type CommandHostScope,+ type CommandIdentity,+ type CommandMenuPlacement,+ type CommandPalettePresence,+ type CommandStateToggle,+ type ContextualTargetKind,+ evaluateCommandAvailability,+ type MenuPlatform,+ type MenuSection,+} from './commands/command-identity.ts';// Headless config writers + UI ConfigBinding.// Browser+node compatible — no Node deps; structural ConfigDocProvider type// keeps `@hocuspocus/provider` out of core's runtime deps.diff --git a/packages/desktop/src/main/menu.ts b/packages/desktop/src/main/menu.tsindex 91a38e9bf..164905a17 100644--- a/packages/desktop/src/main/menu.ts+++ b/packages/desktop/src/main/menu.ts@@ -32,14 +32,20 @@*/import {+ COMMAND_IDENTITIES,+ type CommandContext,+ type CommandIdentity,+ type CommandMenuPlacement,+ type ContextualTargetKind,+ evaluateCommandAvailability,MENU_LABELS,+ type MenuSection,OPEN_KNOWLEDGE_GITHUB_URL,SHOW_INSTALL_SKILL,} from '@inkeep/open-knowledge-core';import type { Dialog, MenuItemConstructorOptions } from 'electron';import type { EntryPoint } from '../shared/entry-point.ts';import type { EditorActiveTargetSnapshot } from '../shared/ipc-channels.ts';-import { SWITCH_PROJECT_LABEL_WITH_ELLIPSIS } from '../shared/labels.ts';import { promptForExistingFolder } from './dialog-helpers.ts';export interface MenuDeps {@@ -331,10 +337,300 @@ export async function installApplicationMenu(deps: MenuDeps): Promise<void> {Menu.setApplicationMenu(Menu.buildFromTemplate(template));}-/** Exported for unit testing — pure function over deps. */+/**+ * Desktop-side binding for each command identity: how the native menu derives a+ * leaf's click / enabled / presence / checkbox state from the injected+ * `MenuDeps`. This is the "click handlers stay wired by id" layer — a leaf's+ * label, accelerator, placement, and availability all come from the shared+ * registry (`@inkeep/open-knowledge-core`), and only this desktop glue lives+ * here.+ *+ * `enabled` is the dep-presence gate ANDed with the registry availability (an+ * unwired dep disables the leaf — the unit-test-safe behavior the menu has+ * always had; in production every dep is wired, so availability drives it).+ * `present` omits the leaf entirely — capability/flag-gated items that render as+ * absence, not disabled. Both default to "always".+ */+interface MenuCommandBinding {+ click?(deps: MenuDeps): MenuItemConstructorOptions['click'];+ enabled?(deps: MenuDeps): boolean;+ present?(deps: MenuDeps): boolean;+ checked?(deps: MenuDeps): boolean;+}++const MENU_BINDINGS: Record<string, MenuCommandBinding> = {+ 'new-file': { click: (d) => () => d.onNewFile?.(), enabled: (d) => d.onNewFile !== undefined },+ 'new-folder': {+ click: (d) => () => d.onNewFolder?.(),+ enabled: (d) => d.onNewFolder !== undefined,+ },+ 'new-from-template': {+ click: (d) => () => d.onNewFromTemplate?.(),+ enabled: (d) => d.onNewFromTemplate !== undefined,+ },+ 'new-project': {+ click: (d) => () => d.onNewProject?.(),+ enabled: (d) => d.onNewProject !== undefined,+ },+ // Switch project / Open folder are always enabled — their deps are required.+ 'switch-project': { click: (d) => () => d.openNavigator() },+ 'open-folder': {+ click: (d) => async () => {+ // Shared with the `ok:dialog:open-folder` IPC handler so both call sites+ // agree on dialog options forever — see dialog-helpers.+ const picked = await promptForExistingFolder(d.dialog);+ if (picked) {+ await d.openProject(picked, 'pick-existing');+ }+ },+ },+ 'new-worktree': {+ click: (d) => () => d.onNewWorktree?.(),+ enabled: (d) => d.onNewWorktree !== undefined,+ },+ 'switch-worktree': {+ click: (d) => () => d.onSwitchWorktree?.(),+ enabled: (d) => d.onSwitchWorktree !== undefined,+ },+ duplicate: { click: (d) => () => d.onDuplicate?.(), enabled: (d) => d.onDuplicate !== undefined },+ rename: { click: (d) => () => d.onRename?.(), enabled: (d) => d.onRename !== undefined },+ 'move-to-trash': {+ click: (d) => () => d.onMoveToTrash?.(),+ enabled: (d) => d.onMoveToTrash !== undefined,+ },+ 'reveal-in-finder': {+ click: (d) => () => d.onRevealInFinder?.(),+ enabled: (d) => d.onRevealInFinder !== undefined,+ },+ 'send-to-ai': {+ click: (d) => () => d.onSendToAi?.(),+ enabled: (d) => d.onSendToAi !== undefined,+ },+ 'copy-full-path': {+ click: (d) => () => d.onCopyFullPath?.(),+ enabled: (d) => d.onCopyFullPath !== undefined,+ },+ 'copy-relative-path': {+ click: (d) => () => d.onCopyRelativePath?.(),+ enabled: (d) => d.onCopyRelativePath !== undefined,+ },+ // Re-trigger first-launch MCP consent. Presence-gated: non-macOS / non-packaged+ // contexts (where MCP wiring no-ops anyway) plumb `undefined` and hide the row.+ 'set-up-integrations': {+ click: (d) => () => {+ void d.reconfigureMcpWiring?.();+ },+ present: (d) => d.reconfigureMcpWiring !== undefined,+ },+ settings: { click: (d) => () => d.openSettings?.() },+ 'close-tab': {+ click: (d) => () => d.onCloseActiveTabOrWindow?.(),+ enabled: (d) => d.onCloseActiveTabOrWindow !== undefined,+ },+ // Presence-gated on the booted updater handle; a bare click reference matches+ // the runtime shape Electron invokes for a shortcut-less item.+ 'check-for-updates': {+ click: (d) => d.onCheckForUpdates,+ present: (d) => d.onCheckForUpdates !== undefined,+ },+ uninstall: { click: (d) => () => d.onUninstall?.(), present: (d) => d.onUninstall !== undefined },+ 'new-terminal': {+ click: (d) => () => d.onNewTerminal?.(),+ enabled: (d) => d.onNewTerminal !== undefined,+ },+ 'new-terminal-window': {+ click: (d) => () => d.onNewTerminalWindow?.(),+ enabled: (d) => d.onNewTerminalWindow !== undefined,+ },+ 'kill-terminal': {+ click: (d) => () => d.onKillTerminal?.(),+ enabled: (d) => d.onKillTerminal !== undefined,+ },+ 'toggle-spell-check': {+ click: (d) => () => d.onToggleSpellCheck?.(),+ enabled: (d) => d.onToggleSpellCheck !== undefined,+ checked: (d) => d.spellCheckEnabled ?? true,+ },+ 'toggle-sidebar': {+ click: (d) => () => d.onToggleSidebar?.(),+ enabled: (d) => d.onToggleSidebar !== undefined,+ },+ 'toggle-doc-panel': {+ click: (d) => () => d.onToggleDocPanel?.(),+ enabled: (d) => d.onToggleDocPanel !== undefined,+ },+ 'toggle-terminal': {+ click: (d) => () => d.onToggleTerminal?.(),+ enabled: (d) => d.onToggleTerminal !== undefined,+ },+ 'toggle-show-hidden-files': {+ click: (d) => () => d.onToggleShowHiddenFiles?.(),+ enabled: (d) => d.onToggleShowHiddenFiles !== undefined,+ checked: (d) => d.showHiddenFilesChecked ?? false,+ },+ 'toggle-show-ok-folders': {+ click: (d) => () => d.onToggleShowOkFolders?.(),+ enabled: (d) => d.onToggleShowOkFolders !== undefined,+ checked: (d) => d.showOkFoldersChecked ?? false,+ },+ 'toggle-show-only-markdown-files': {+ click: (d) => () => d.onToggleShowOnlyMarkdownFiles?.(),+ enabled: (d) => d.onToggleShowOnlyMarkdownFiles !== undefined,+ checked: (d) => d.showOnlyMarkdownFilesChecked ?? false,+ },+ 'toggle-show-skills-section': {+ click: (d) => () => d.onToggleShowSkillsSection?.(),+ enabled: (d) => d.onToggleShowSkillsSection !== undefined,+ // Skills section is default-on, so the unwired checkbox reads checked.+ checked: (d) => d.showSkillsSectionChecked ?? true,+ },+ 'expand-all-tree': {+ click: (d) => () => d.onExpandAll?.(),+ enabled: (d) => d.onExpandAll !== undefined,+ },+ 'collapse-all-tree': {+ click: (d) => () => d.onCollapseAll?.(),+ enabled: (d) => d.onCollapseAll !== undefined,+ },+ 'open-github': { click: (d) => () => d.openExternalUrl(OPEN_KNOWLEDGE_GITHUB_URL) },+ // Report a Bug always renders + is enabled; the click no-ops when unwired.+ 'report-bug': { click: (d) => () => d.onReportBug?.() },+ 'install-claude-desktop': {+ click: (d) => () => d.openInstallSkillDialog?.(),+ present: () => SHOW_INSTALL_SKILL,+ },+};++/**+ * The command ids that carry a desktop binding. Exported so the parity ratchet+ * can assert every menu-placed registry command has one: a command with a `menu`+ * placement but no binding would render a leaf with no click handler, enabled by+ * default — a silent no-op the optional-chained lookup in `buildCommandLeaves`+ * would not catch.+ */+export const MENU_BINDING_IDS: ReadonlySet<string> = new Set(Object.keys(MENU_BINDINGS));++/** Project the pushed active-target snapshot onto the shared gating kind. The+ * menu maps project scope (and the pre-first-push `undefined`) to `project`:+ * contentDir is still an actionable target, so reveal / copy-path stay enabled+ * there, while rename / duplicate / trash (which require a real file) do not. */+function menuTargetKind(target: EditorActiveTargetSnapshot | undefined): ContextualTargetKind {+ if (target === undefined || target.kind === null) return 'project';+ return target.kind;+}++function menuCommandContext(deps: MenuDeps): CommandContext {+ return {+ host: 'desktop',+ activeTargetKind: menuTargetKind(deps.activeTarget),+ // The native menu has no single-file concept; those commands never gate here.+ singleFile: false,+ terminalLive: deps.terminalLive === true,+ canExpandAll: deps.canExpandAll ?? true,+ canCollapseAll: deps.canCollapseAll ?? true,+ // No Open-graph leaf in the menu; the field is palette-only.+ hasActiveDoc: false,+ showInstallSkill: SHOW_INSTALL_SKILL,+ };+}++/** Resolve a menu leaf's plain-string label: an explicit literal, the Show/Hide+ * toggle variant driven by the pushed view-menu-state, a per-placement key+ * override (Copy path's children), or the command's own `labelKey`. */+function menuLeafLabel(+ cmd: CommandIdentity,+ placement: CommandMenuPlacement,+ deps: MenuDeps,+): string {+ if (placement.menuLabelText !== undefined) return placement.menuLabelText;+ if (cmd.stateToggle) {+ const { stateField, defaultVisible, showKey, hideKey } = cmd.stateToggle;+ const visible = deps[stateField] ?? defaultVisible;+ return MENU_LABELS[visible ? hideKey : showKey];+ }+ const key = placement.menuLabelKey ?? cmd.labelKey;+ if (key === undefined) {+ throw new Error(`command ${cmd.id} menu leaf has no resolvable label`);+ }+ return MENU_LABELS[key];+}++/** Generate the actionable command leaves for the current platform, grouped by+ * their declared menu section. `buildMenuTemplate` slots each group into the+ * declarative scaffolding (roles / separators / submenu parents / recents). */+function buildCommandLeaves(+ deps: MenuDeps,+ isMac: boolean,+): Map<MenuSection, MenuItemConstructorOptions[]> {+ const platform = isMac ? 'mac' : 'other';+ const ctx = menuCommandContext(deps);+ const staged = new Map<MenuSection, Array<{ order: number; item: MenuItemConstructorOptions }>>();+ for (const cmd of COMMAND_IDENTITIES) {+ if (!cmd.menu) continue;+ const binding = MENU_BINDINGS[cmd.id];+ for (const placement of cmd.menu) {+ const plat = placement.platform ?? 'all';+ if (plat !== 'all' && plat !== platform) continue;+ if (binding?.present && !binding.present(deps)) continue;+ const available = evaluateCommandAvailability(cmd.availability, ctx);+ const depWired = binding?.enabled ? binding.enabled(deps) : true;+ const label = menuLeafLabel(cmd, placement, deps);+ const item: MenuItemConstructorOptions = {+ label: placement.ellipsis ? `${label}…` : label,+ };+ const click = binding?.click?.(deps);+ if (click !== undefined) item.click = click;+ if (placement.accelerator !== undefined) item.accelerator = placement.accelerator;+ if (placement.checkbox === true) {+ item.type = 'checkbox';+ item.checked = binding?.checked ? binding.checked(deps) : false;+ }+ if (placement.smartHide === true) {+ // Smart-hide (Expand/Collapse all): availability maps to `visible`, so a+ // fully-expanded tree hides the no-op affordance rather than disabling it.+ item.visible = available;+ item.enabled = depWired;+ } else {+ item.enabled = available && depWired;+ }+ const list = staged.get(placement.section) ?? [];+ list.push({ order: placement.order, item });+ staged.set(placement.section, list);+ }+ }+ const result = new Map<MenuSection, MenuItemConstructorOptions[]>();+ for (const [section, entries] of staged) {+ entries.sort((a, b) => a.order - b.order);+ result.set(+ section,+ entries.map((e) => e.item),+ );+ }+ return result;+}++/** Append a trailing separator iff the section rendered any leaves (so a+ * presence-gated section contributes neither leaf nor stray separator). */+function withTrailingSep(items: MenuItemConstructorOptions[]): MenuItemConstructorOptions[] {+ return items.length > 0 ? [...items, { type: 'separator' as const }] : [];+}++/** Prepend a leading separator iff the section rendered any leaves. */+function withLeadingSep(items: MenuItemConstructorOptions[]): MenuItemConstructorOptions[] {+ return items.length > 0 ? [{ type: 'separator' as const }, ...items] : [];+}++/**+ * Exported for unit testing — pure function over deps. The actionable command+ * leaves are generated from the shared registry (`buildCommandLeaves`); the+ * roles, separators, submenu parents (Recent project, Copy path), the dynamic+ * recents rows, and the `isMac` platform branches stay declarative here.+ */export function buildMenuTemplate(deps: MenuDeps): MenuItemConstructorOptions[] {const isMac = process.platform === 'darwin';const recents = deps.getRecentProjects();+ const leaves = buildCommandLeaves(deps, isMac);+ const leafOf = (section: MenuSection): MenuItemConstructorOptions[] => leaves.get(section) ?? [];const recentSubmenu: MenuItemConstructorOptions[] =recents.length === 0@@ -363,28 +659,14 @@ export function buildMenuTemplate(deps: MenuDeps): MenuItemConstructorOptions[]submenu: [{ role: 'about' as const },{ type: 'separator' as const },- // Apple HIG canonical placement: "Check for updates…"- // immediately under About in the application menu. Hidden- // when the updater handle isn't available (dev mode, boot- // failure) — see MenuDeps.onCheckForUpdates rationale.- ...(deps.onCheckForUpdates- ? ([- {- label: `${MENU_LABELS.checkForUpdates}\u2026`,- click: deps.onCheckForUpdates,- },- { type: 'separator' as const },- ] satisfies MenuItemConstructorOptions[])- : []),- // Apple HIG places "Settings…" / "Preferences…" immediately- // before the services group. The CmdOrCtrl+, accelerator is- // OS-captured: Electron routes the keypress to this menu- // item before it reaches the renderer's keydown handler.- {- label: 'Settings…',- accelerator: 'CmdOrCtrl+,',- click: () => deps.openSettings?.(),- },+ // Apple HIG: "Check for updates…" under About, then "Settings…".+ // Both are platform-conditional placements in the shared registry+ // (the App-menu placement is `mac`-only; each has a mirror `other`+ // placement in the File / Help menu), so the leaf renders exactly+ // once per platform — the previously hand-branched dedupe, now+ // expressed as data.+ ...withTrailingSep(leafOf('app-updates')),+ ...leafOf('app-settings'),{ type: 'separator' as const },{ role: 'services' as const },{ type: 'separator' as const },@@ -392,15 +674,7 @@ export function buildMenuTemplate(deps: MenuDeps): MenuItemConstructorOptions[]{ role: 'hideOthers' as const },{ role: 'unhide' as const },{ type: 'separator' as const },- ...(deps.onUninstall- ? ([- {- label: 'Uninstall OpenKnowledge…',- click: () => deps.onUninstall?.(),- },- { type: 'separator' as const },- ] satisfies MenuItemConstructorOptions[])- : []),+ ...withTrailingSep(leafOf('app-uninstall')),{ role: 'quit' as const },],},@@ -410,172 +684,36 @@ export function buildMenuTemplate(deps: MenuDeps): MenuItemConstructorOptions[]{label: 'File',submenu: [- // Creation items head the File menu (New file / New folder / New from- // template), then the project section, then the item-management actions- // (Duplicate / Rename / Move to Trash). Each item-management action is- // enable/disabled per `activeTarget` so a project-scope window doesn't- // surface Rename / Duplicate / Move to Trash with no target; asset scope- // enables Rename / Move to Trash but keeps Duplicate disabled.- {- label: MENU_LABELS.newFile,- accelerator: 'CmdOrCtrl+N',- enabled: deps.onNewFile !== undefined,- click: () => deps.onNewFile?.(),- },- {- label: MENU_LABELS.newFolder,- accelerator: 'CmdOrCtrl+Shift+N',- enabled: deps.onNewFolder !== undefined,- click: () => deps.onNewFolder?.(),- },- {- label: `${MENU_LABELS.newFromTemplate}\u2026`,- enabled: deps.onNewFromTemplate !== undefined,- click: () => deps.onNewFromTemplate?.(),- },+ // Creation items head the File menu; then the project section (mirrors+ // the in-app ProjectSwitcher order: Recent → New project → Switch →+ // Open folder); then worktrees; then the activeTarget-gated+ // item-management actions; then reveal / AI / copy-path. Every command+ // leaf comes from the registry — the separators, the Recent-project+ // submenu, and the Copy-path submenu parent stay declarative here.+ ...leafOf('file-create'),{ type: 'separator' },- // Project section — order mirrors the in-app ProjectSwitcher- // (packages/app/src/components/ProjectSwitcher.tsx) so the native menu- // and the sidebar footer read identically. The recents submenu and the- // create / switch / open wiring are unchanged; only position, order,- // and labels moved here.{label: 'Recent project',submenu: recentSubmenu,},- {- // Scaffolds a brand-new project (opens the create-new-project dialog).- // No `activeTarget` gate — creating a project doesn't depend on scope.- label: `${MENU_LABELS.newProject}\u2026`,- enabled: deps.onNewProject !== undefined,- click: () => deps.onNewProject?.(),- },- {- label: SWITCH_PROJECT_LABEL_WITH_ELLIPSIS,- // Rebound from Cmd+Shift+N (now New folder) to Cmd+Shift+P per macOS- // HIG for navigation/palette-style commands.- accelerator: 'CmdOrCtrl+Shift+P',- click: () => deps.openNavigator(),- },- {- label: `${MENU_LABELS.openFolder}\u2026`,- accelerator: 'CmdOrCtrl+O',- click: async () => {- // Shared with the `ok:dialog:open-folder` IPC handler so both call- // sites agree on dialog options forever — see dialog-helpers.- const picked = await promptForExistingFolder(deps.dialog);- if (picked) {- await deps.openProject(picked, 'pick-existing');- }- },- },+ ...leafOf('file-project'),{ type: 'separator' },- // Worktree selector (worktree = window). Mirrors the sidebar- // ProjectSwitcher's worktree section — both delegate to the same- // renderer surface. Disabled (not hidden) in the Navigator window and- // in unit-test contexts, where the deps aren't wired.- {- label: `${MENU_LABELS.newWorktree}\u2026`,- enabled: deps.onNewWorktree !== undefined,- click: () => deps.onNewWorktree?.(),- },- {- label: `${MENU_LABELS.switchWorktree}\u2026`,- enabled: deps.onSwitchWorktree !== undefined,- click: () => deps.onSwitchWorktree?.(),- },+ ...leafOf('file-worktree'),{ type: 'separator' },- {- label: MENU_LABELS.duplicate,- accelerator: 'CmdOrCtrl+D',- enabled:- deps.onDuplicate !== undefined &&- deps.activeTarget !== undefined &&- (deps.activeTarget.kind === 'doc' || deps.activeTarget.kind === 'folder'),- click: () => deps.onDuplicate?.(),- },- {- label: MENU_LABELS.rename,- // Project scope (kind === null) has no target to rename \u2192 disabled.- enabled:- deps.onRename !== undefined &&- deps.activeTarget !== undefined &&- deps.activeTarget.kind !== null,- click: () => deps.onRename?.(),- },- {- label: MENU_LABELS.moveToTrash,- accelerator: 'CmdOrCtrl+Delete',- enabled:- deps.onMoveToTrash !== undefined &&- deps.activeTarget !== undefined &&- deps.activeTarget.kind !== null,- click: () => deps.onMoveToTrash?.(),- },+ ...leafOf('file-item'),{ type: 'separator' },- {- label: MENU_LABELS.revealInFinder,- enabled: deps.onRevealInFinder !== undefined,- click: () => deps.onRevealInFinder?.(),- },- {- label: MENU_LABELS.openWithAi,- enabled: deps.onSendToAi !== undefined && deps.activeTarget?.kind !== 'asset',- click: () => deps.onSendToAi?.(),- },+ ...leafOf('file-reveal'),{label: MENU_LABELS.copyPath,enabled: deps.onCopyFullPath !== undefined || deps.onCopyRelativePath !== undefined,- submenu: [- {- label: MENU_LABELS.fullPath,- enabled: deps.onCopyFullPath !== undefined,- click: () => deps.onCopyFullPath?.(),- },- {- label: MENU_LABELS.relativePath,- enabled: deps.onCopyRelativePath !== undefined,- click: () => deps.onCopyRelativePath?.(),- },- ],+ submenu: leafOf('file-copy-path'),},{ type: 'separator' },- // Re-trigger first-launch MCP consent. The dep is optional so- // non-macOS / non-packaged contexts (where MCP wiring no-ops- // anyway) hide the row. `deps`- // plumbs `undefined` when the runtime has nothing to offer.- ...(deps.reconfigureMcpWiring- ? ([- {- label: `${MENU_LABELS.setUpIntegrations}\u2026`,- click: () => {- void deps.reconfigureMcpWiring?.();- },- },- { type: 'separator' as const },- ] satisfies MenuItemConstructorOptions[])- : []),- // On Windows/Linux Settings… belongs in the File menu (Apple- // HIG only governs macOS; on macOS the Settings entry lives in the- // App menu above). Placed above the trailing close/quit role.- ...(!isMac- ? ([- {- label: 'Settings…',- accelerator: 'CmdOrCtrl+,',- click: () => deps.openSettings?.(),- },- { type: 'separator' as const },- ] satisfies MenuItemConstructorOptions[])- : []),- isMac- ? {- label: MENU_LABELS.closeTab,- accelerator: 'CmdOrCtrl+W',- enabled: deps.onCloseActiveTabOrWindow !== undefined,- click: () => deps.onCloseActiveTabOrWindow?.(),- }- : { role: 'quit' },+ ...withTrailingSep(leafOf('file-integrations')),+ // On Windows/Linux Settings… belongs in the File menu (macOS renders it+ // in the App menu above); its registry placement is `other`-only.+ ...withTrailingSep(leafOf('file-settings')),+ ...(isMac ? leafOf('file-close') : [{ role: 'quit' as const }]),],},@@ -590,120 +728,26 @@ export function buildMenuTemplate(deps: MenuDeps): MenuItemConstructorOptions[]{ role: 'paste' },{ role: 'selectAll' },{ type: 'separator' },- // macOS Edit-menu spell-check toggle. `checked` is derived from the- // persisted app-wide flag at build time; toggling (here or from the- // in-editor context menu) rebuilds the menu so the checkmark stays in- // sync. No accelerator — macOS has no canonical one for this item.- {- label: MENU_LABELS.checkSpelling,- type: 'checkbox',- checked: deps.spellCheckEnabled ?? true,- enabled: deps.onToggleSpellCheck !== undefined,- click: () => deps.onToggleSpellCheck?.(),- },+ ...leafOf('edit-spell'),],},{label: 'View',submenu: [- // Reload / Force Reload ship on every channel — a page-level recovery- // affordance for stable users (parity with Electron apps like Claude- // Code Desktop), not a dev-only tool. Toggle Developer Tools stays- // gated on `showDevToolsMenu` (dev + beta), so stable doesn't expose- // the raw web inspector.+ // Reload / Force Reload ship on every channel; Toggle Developer Tools is+ // gated on `showDevToolsMenu` (dev + beta) — Electron built-in roles.{ role: 'reload' as const },{ role: 'forceReload' as const },...(deps.showDevToolsMenu? ([{ role: 'toggleDevTools' as const }] satisfies MenuItemConstructorOptions[]): []),{ type: 'separator' as const },- // Sidebar visibility toggle. Apple HIG convention: a single row whose- // label flips between "Show sidebar" / "Hide sidebar" based on the- // current state (Finder's pattern), rather than a checkbox row. ⌥⌘S- // is Apple's canonical accelerator for sidebar toggle — ⌘B is Bold in- // the TipTap editor, and ⌘\ is non-standard. Spelled `CmdOrCtrl+Alt+S`- // (not `Option+Cmd+S`): Electron renders `Alt` as ⌥ and `CmdOrCtrl` as- // ⌘ on macOS, so this is the identical ⌥⌘S here while staying the- // cross-platform-safe form the sibling accelerators use. The accelerator- // is OS-captured: Electron routes the keypress to this menu item before- // it reaches the renderer's keydown handler, so the renderer's- // shadcn sidebar primitive does NOT also bind a window keydown.- {- label: deps.sidebarVisible === false ? 'Show sidebar' : 'Hide sidebar',- accelerator: 'CmdOrCtrl+Alt+S',- enabled: deps.onToggleSidebar !== undefined,- click: () => deps.onToggleSidebar?.(),- },- {- label: deps.docPanelVisible === false ? 'Show document panel' : 'Hide document panel',- accelerator: 'CmdOrCtrl+Alt+B',- enabled: deps.onToggleDocPanel !== undefined,- click: () => deps.onToggleDocPanel?.(),- },- {- // Terminal starts hidden, so falsy/undefined reads "Show Terminal".- // ⌘J / Ctrl+J is OS-captured (fires before the renderer), so a- // focused xterm can't swallow it — same model as the sidebar item.- label: deps.terminalVisible ? 'Hide Terminal' : 'Show Terminal',- accelerator: 'CmdOrCtrl+J',- enabled: deps.onToggleTerminal !== undefined,- click: () => deps.onToggleTerminal?.(),- },+ ...leafOf('view-panels'),{ type: 'separator' },- // Sidebar visibility toggles. Checkbox state mirrors the sidebar's- // tree-options popover + empty-space context menu, in the same order.- // Toggling any of them flips the projectLocalBinding flag via the- // renderer's menu-action handler; the resulting CRDT write propagates- // back through merged config so every surface stays in sync. The- // unwired `checked` fallbacks match the renderer's resolved config- // defaults (hidden files + .ok folders + only-markdown off, skills- // section on).- {- label: MENU_LABELS.showHiddenFiles,- accelerator: 'CmdOrCtrl+Shift+.',- type: 'checkbox',- checked: deps.showHiddenFilesChecked ?? false,- enabled: deps.onToggleShowHiddenFiles !== undefined,- click: () => deps.onToggleShowHiddenFiles?.(),- },- {- label: MENU_LABELS.showOkFolders,- type: 'checkbox',- checked: deps.showOkFoldersChecked ?? false,- enabled: deps.onToggleShowOkFolders !== undefined,- click: () => deps.onToggleShowOkFolders?.(),- },- {- label: MENU_LABELS.showOnlyMarkdownFiles,- type: 'checkbox',- checked: deps.showOnlyMarkdownFilesChecked ?? false,- enabled: deps.onToggleShowOnlyMarkdownFiles !== undefined,- click: () => deps.onToggleShowOnlyMarkdownFiles?.(),- },- {- label: MENU_LABELS.showSkillsSection,- type: 'checkbox',- checked: deps.showSkillsSectionChecked ?? true,- enabled: deps.onToggleShowSkillsSection !== undefined,- click: () => deps.onToggleShowSkillsSection?.(),- },+ ...leafOf('view-visibility'),{ type: 'separator' },- // Tree-scoped Expand/Collapse all. Smart-hide via `visible: false`- // (rather than `enabled: false`) so a fully-expanded tree doesn't- // render a useless enabled-with-no-op Expand all affordance.- {- label: MENU_LABELS.expandAll,- visible: deps.canExpandAll ?? true,- enabled: deps.onExpandAll !== undefined,- click: () => deps.onExpandAll?.(),- },- {- label: MENU_LABELS.collapseAll,- visible: deps.canCollapseAll ?? true,- enabled: deps.onCollapseAll !== undefined,- click: () => deps.onCollapseAll?.(),- },+ ...leafOf('view-tree'),{ type: 'separator' },{ role: 'resetZoom' },{ role: 'zoomIn' },@@ -715,37 +759,8 @@ export function buildMenuTemplate(deps: MenuDeps): MenuItemConstructorOptions[]{// Top-level Terminal menu (VS Code placement, between View and Window).- // The discoverable home for terminal actions; the View → Show/Hide- // Terminal toggle stays as-is to keep the established ⌘J muscle memory.label: 'Terminal',- submenu: [- {- // Opens a new terminal tab each click (revealing the dock if hidden;- // never hides). No accelerator here: ⌘J belongs to the View →- // Show/Hide Terminal toggle, and advertising the same key on two- // items only mislabels this one — the OS does not guarantee which- // item a duplicate accelerator dispatches to.- label: MENU_LABELS.newTerminal,- enabled: deps.onNewTerminal !== undefined,- click: () => deps.onNewTerminal?.(),- },- {- // Opens a dedicated terminal window (1:1 with VS Code's "New Terminal- // Window"). No accelerator — VS Code ships the command unbound, and- // ⌘J stays the docked Show/Hide Terminal toggle.- label: 'New Terminal Window',- enabled: deps.onNewTerminalWindow !== undefined,- click: () => deps.onNewTerminalWindow?.(),- },- {- // Closes the active tab — kills its shell (not just hide). Enabled- // only when at least one session is live; a collapsed-but-alive- // terminal still qualifies.- label: MENU_LABELS.killTerminal,- enabled: deps.onKillTerminal !== undefined && deps.terminalLive === true,- click: () => deps.onKillTerminal?.(),- },- ],+ submenu: leafOf('terminal'),},{@@ -765,38 +780,11 @@ export function buildMenuTemplate(deps: MenuDeps): MenuItemConstructorOptions[]{label: 'Help',submenu: [- ...(SHOW_INSTALL_SKILL- ? ([- {- label: 'Install for Claude Chat & Cowork (desktop app)…',- click: () => deps.openInstallSkillDialog?.(),- },- { type: 'separator' as const },- ] satisfies MenuItemConstructorOptions[])- : []),- {- label: MENU_LABELS.openOnGithub,- click: () => deps.openExternalUrl(OPEN_KNOWLEDGE_GITHUB_URL),- },- {- label: 'Report a Bug…',- click: () => deps.onReportBug?.(),- },- // "Check for updates…" — non-macOS only. Windows/Linux have no- // application menu, so Help is the convention there. macOS gets the- // Apple-HIG-canonical placement under the App menu (above), so gating- // this on `!isMac` keeps exactly one entry per platform — mirroring the- // Settings XOR (App menu on macOS, File menu elsewhere). Without the- // guard macOS renders the item in BOTH menus.- ...(!isMac && deps.onCheckForUpdates- ? ([- { type: 'separator' as const },- {- label: `${MENU_LABELS.checkForUpdates}\u2026`,- click: deps.onCheckForUpdates,- },- ] satisfies MenuItemConstructorOptions[])- : []),+ ...withTrailingSep(leafOf('help-install')),+ ...leafOf('help-links'),+ // macOS gets the Apple-HIG App-menu placement above; Windows/Linux have+ // no application menu, so Help is the convention there (leading sep).+ ...withLeadingSep(leafOf('help-updates')),],},];diff --git a/packages/desktop/src/shared/labels.ts b/packages/desktop/src/shared/labels.tsdeleted file mode 100644index b18be1d42..000000000--- a/packages/desktop/src/shared/labels.ts+++ /dev/null@@ -1,20 +0,0 @@-/**- * User-facing string constants surfaced from the desktop app's main process.- *- * Inclusion rule: native-OS menu items consumed only by `main/menu.ts`. Other- * surfaces (renderer dropdowns, command palette, CLI) inline their literals.- *- * Keep this file zero-dep — it loads in main, preload, and any test runner.- */--/**- * macOS / Windows / Linux native menu bar item for re-summoning the Project- * Navigator (`File → Switch project…`, accelerator `Cmd+Shift+N`). Consumed- * only by `packages/desktop/src/main/menu.ts`.- *- * The trailing `…` is the native-menu convention for "opens a new surface"- * (Apple HIG / Windows HIG / GTK). Renderer-side surfaces (ProjectSwitcher- * dropdown, CommandPalette row) render the bare `Switch project` label —- * `…` is reserved for native menus and truncation indicators only.- */-export const SWITCH_PROJECT_LABEL_WITH_ELLIPSIS = 'Switch project…' as const;