cli-jaw 2.0.6 → 2.0.13

package/public/manager/src/notes/NotesToolbar.tsx

@@ -1,7 +1,7 @@
 import type { NotesAuthoringMode, NotesViewMode } from './notes-types';
 import { canSaveNote, noteDisplayName } from './note-revisions';
 
-type NotesPrimaryMode = 'raw' | 'split' | 'preview' | 'wysiwyg';
+type NotesPrimaryMode = 'raw' | 'split' | 'preview' | 'wysiwyg' | 'graph';
 
 type NotesToolbarProps = {
     selectedPath: string | null;
@@ -17,17 +17,19 @@ type NotesToolbarProps = {
     onReload: () => void;
 };
 
-const PRIMARY_MODES: NotesPrimaryMode[] = ['raw', 'split', 'preview', 'wysiwyg'];
+const PRIMARY_MODES: NotesPrimaryMode[] = ['raw', 'split', 'preview', 'wysiwyg', 'graph'];
 
 function primaryModeLabel(mode: NotesPrimaryMode): string {
     if (mode === 'raw') return 'Raw';
     if (mode === 'split') return 'Split';
     if (mode === 'preview') return 'Preview';
+    if (mode === 'graph') return 'Graph';
     return 'WYSIWYG';
 }
 
 function activePrimaryMode(viewMode: NotesViewMode, authoringMode: NotesAuthoringMode): NotesPrimaryMode | null {
     if (viewMode === 'settings') return null;
+    if (viewMode === 'graph') return 'graph';
     if (viewMode === 'split') return 'split';
     if (viewMode === 'preview') return 'preview';
     if (authoringMode === 'wysiwyg') return 'wysiwyg';
@@ -36,6 +38,10 @@ function activePrimaryMode(viewMode: NotesViewMode, authoringMode: NotesAuthorin
 
 export function NotesToolbar(props: NotesToolbarProps) {
     function activatePrimaryMode(mode: NotesPrimaryMode): void {
+        if (mode === 'graph') {
+            props.onViewModeChange('graph');
+            return;
+        }
         if (mode === 'split') {
             props.onViewModeChange('split');
             props.onAuthoringModeChange('plain');
@@ -66,7 +72,7 @@ export function NotesToolbar(props: NotesToolbarProps) {
                             role="tab"
                             aria-selected={activeMode === mode}
                             className={activeMode === mode ? 'is-active' : ''}
-                            disabled={!props.selectedPath}
+                            disabled={mode === 'graph' ? false : !props.selectedPath}
                             onClick={() => activatePrimaryMode(mode)}
                         >
                             {primaryModeLabel(mode)}

package/public/manager/src/notes/NotesWorkspace.tsx

@@ -1,15 +1,24 @@
-import { useEffect, useRef, useState } from 'react';
+import { lazy, Suspense, useEffect, useMemo, useRef, useState } from 'react';
 import { MarkdownEditor } from './MarkdownEditor';
 import { MarkdownPreview } from './MarkdownPreview';
+import { NotesBacklinksPanel } from './NotesBacklinksPanel';
 import { NotesEmptyState } from './NotesEmptyState';
 import { NotesFrontmatterStrip } from './NotesFrontmatterStrip';
 import { NotesQuickSwitcher } from './NotesQuickSwitcher';
 import { NotesToolbar } from './NotesToolbar';
+import { canSaveNote } from './note-revisions';
+import { useRegisterNoteCommands, type NoteCommand } from './notes-command-registry';
+import { isQuickSwitcherShortcut } from './notes-shortcuts';
 import { renameNotePath } from './notes-api';
 import { useNoteDocument } from './useNoteDocument';
 import { publishInvalidation } from '../sync/invalidation-bus';
 import type { NotesAuthoringMode, NotesNoteMetadata, NotesVaultIndexSnapshot, NotesViewMode } from './notes-types';
 
+const NotesGraphView = lazy(async () => {
+    const module = await import('./NotesGraphView');
+    return { default: module.NotesGraphView };
+});
+
 type NotesPrimaryMode = 'raw' | 'preview' | 'wysiwyg';
 
 type NotesWorkspaceProps = {
@@ -107,7 +116,7 @@ export function NotesWorkspace(props: NotesWorkspaceProps) {
     useEffect(() => {
         if (!props.active) return;
         function handleQuickSwitcherShortcut(event: KeyboardEvent): void {
-            if (!(event.metaKey || event.ctrlKey) || event.key.toLowerCase() !== 'p') return;
+            if (!isQuickSwitcherShortcut(event)) return;
             event.preventDefault();
             setQuickSwitcherOpen(open => !open);
         }
@@ -116,6 +125,114 @@ export function NotesWorkspace(props: NotesWorkspaceProps) {
         return () => window.removeEventListener('keydown', handleQuickSwitcherShortcut);
     }, [props.active]);
 
+    const saveDisabledReason = !props.selectedPath
+        ? 'No note selected'
+        : document.saving
+            ? 'Save in progress'
+            : !document.dirty
+                ? 'No unsaved changes'
+                : undefined;
+    const workspaceCommands = useMemo<NoteCommand[]>(() => [
+        {
+            id: 'workspace:save',
+            section: 'File',
+            label: 'Save note',
+            shortcut: 'Cmd+S',
+            disabled: !canSaveNote(props.selectedPath, document.dirty, document.saving),
+            disabledReason: saveDisabledReason,
+            keywords: ['write', 'persist'],
+            run: () => void document.save(),
+        },
+        {
+            id: 'workspace:reload',
+            section: 'File',
+            label: 'Reload note from disk',
+            keywords: ['refresh', 'discard'],
+            disabled: !props.selectedPath,
+            disabledReason: 'No note selected',
+            run: () => void document.reloadFromDisk(),
+        },
+        {
+            id: 'workspace:view-raw',
+            section: 'View',
+            label: 'Switch to raw editor',
+            run: () => {
+                props.onViewModeChange('raw');
+                props.onAuthoringModeChange('plain');
+            },
+        },
+        {
+            id: 'workspace:view-split',
+            section: 'View',
+            label: 'Switch to split view',
+            run: () => {
+                props.onViewModeChange('split');
+                props.onAuthoringModeChange('plain');
+            },
+        },
+        {
+            id: 'workspace:view-preview',
+            section: 'View',
+            label: 'Switch to preview',
+            shortcut: 'Cmd+E',
+            run: () => props.onViewModeChange('preview'),
+        },
+        {
+            id: 'workspace:view-wysiwyg',
+            section: 'View',
+            label: 'Switch to WYSIWYG editor',
+            run: () => {
+                props.onViewModeChange('raw');
+                props.onAuthoringModeChange('wysiwyg');
+            },
+        },
+        {
+            id: 'workspace:view-graph',
+            section: 'View',
+            label: 'Open graph view',
+            run: () => props.onViewModeChange('graph'),
+        },
+        {
+            id: 'workspace:open-settings',
+            section: 'View',
+            label: 'Open Notes settings',
+            run: () => props.onViewModeChange('settings'),
+        },
+        {
+            id: 'workspace:toggle-word-wrap',
+            section: 'Editor',
+            label: props.wordWrap ? 'Disable word wrap' : 'Enable word wrap',
+            run: () => props.onWordWrapChange(!props.wordWrap),
+        },
+        {
+            id: 'workspace:open-search',
+            section: 'Navigate',
+            label: 'Search notes',
+            shortcut: 'Cmd+Shift+F',
+            run: props.onOpenSidebarSearch,
+        },
+        {
+            id: 'workspace:quick-switch-note',
+            section: 'Navigate',
+            label: 'Quick switch note',
+            shortcut: 'Cmd+P',
+            run: () => setQuickSwitcherOpen(true),
+        },
+    ], [
+        document.dirty,
+        document.reloadFromDisk,
+        document.save,
+        document.saving,
+        props.onAuthoringModeChange,
+        props.onOpenSidebarSearch,
+        props.onViewModeChange,
+        props.onWordWrapChange,
+        props.selectedPath,
+        props.wordWrap,
+        saveDisabledReason,
+    ]);
+    useRegisterNoteCommands(workspaceCommands, props.active);
+
     async function handleTitleBlur(event: React.FocusEvent<HTMLInputElement>): Promise<void> {
         if (renamingRef.current || !props.selectedPath) return;
         const newTitle = event.currentTarget.value.trim().replace(INVALID_TITLE_CHARS, '');
@@ -147,6 +264,7 @@ export function NotesWorkspace(props: NotesWorkspaceProps) {
     const showEditor = props.viewMode === 'raw' || props.viewMode === 'split';
     const showPreview = props.viewMode === 'preview' || props.viewMode === 'split';
     const selectedOutgoingLinks = (props.selectedPath && props.vaultIndex?.outgoingLinks?.[props.selectedPath]) || [];
+    const selectedBacklinks = (props.selectedPath && props.vaultIndex?.backlinks?.[props.selectedPath]) || [];
     const indexedNotes = props.vaultIndex?.notes || [];
     const wysiwygOwnsFrontmatter = props.authoringMode === 'wysiwyg' && showEditor;
 
@@ -198,8 +316,20 @@ export function NotesWorkspace(props: NotesWorkspaceProps) {
                             </label>
                         </section>
                     )}
-                    {!props.selectedPath && props.viewMode !== 'settings' && <NotesEmptyState />}
-                    {props.selectedPath && props.viewMode !== 'settings' && (
+                    {props.viewMode === 'graph' && (
+                        <Suspense fallback={<div className="notes-graph-loading">Loading graph...</div>}>
+                            <NotesGraphView
+                                graph={props.vaultIndex?.graph ?? { nodes: [], edges: [] }}
+                                selectedPath={props.selectedPath}
+                                onNavigate={(path) => {
+                                    props.onSelectedPathChange(path);
+                                    props.onViewModeChange('raw');
+                                }}
+                            />
+                        </Suspense>
+                    )}
+                    {!props.selectedPath && props.viewMode !== 'settings' && props.viewMode !== 'graph' && <NotesEmptyState />}
+                    {props.selectedPath && props.viewMode !== 'settings' && props.viewMode !== 'graph' && (
                         <div className="notes-document-grid">
                             <input
                                 className="notes-inline-title"
@@ -244,6 +374,12 @@ export function NotesWorkspace(props: NotesWorkspaceProps) {
                         </div>
                     )}
                 </div>
+                {props.viewMode !== 'graph' && props.viewMode !== 'settings' && props.selectedPath && (
+                    <NotesBacklinksPanel
+                        backlinks={selectedBacklinks}
+                        onNavigate={props.onWikiLinkNavigate}
+                    />
+                )}
             </main>
             <NotesQuickSwitcher
                 open={quickSwitcherOpen}

package/public/manager/src/notes/notes-api.ts

@@ -3,6 +3,8 @@ export {
     fetchNotesIndex,
     fetchNotesCapabilities,
     fetchNotesTree,
+    fetchNoteTemplates,
+    fetchNoteTemplate,
     searchNotes,
     fetchNoteFile,
     createNoteFile,

package/public/manager/src/notes/notes-command-registry.tsx

@@ -0,0 +1,79 @@
+import { createContext, useCallback, useContext, useEffect, useMemo, useState, type ReactNode } from 'react';
+
+export type NoteCommand = {
+    id: string;
+    section: string;
+    label: string;
+    keywords?: string[] | undefined;
+    shortcut?: string | undefined;
+    disabled?: boolean | undefined;
+    disabledReason?: string | undefined;
+    run: () => void | Promise<void>;
+};
+
+type NotesCommandRegistry = {
+    commands: NoteCommand[];
+    register: (commands: NoteCommand[]) => () => void;
+};
+
+const NotesCommandRegistryContext = createContext<NotesCommandRegistry | null>(null);
+
+export function NotesCommandProvider(props: { children: ReactNode }) {
+    const [commandsById, setCommandsById] = useState<Map<string, NoteCommand>>(() => new Map());
+
+    const register = useCallback((commands: NoteCommand[]) => {
+        const incoming = new Map(commands.map(command => [command.id, command]));
+        setCommandsById(previous => {
+            const next = new Map(previous);
+            for (const command of commands) {
+                const existing = next.get(command.id);
+                if (existing && existing !== command) {
+                    console.warn(`[notes-command-palette] duplicate command id: ${command.id}`);
+                }
+                next.set(command.id, command);
+            }
+            return next;
+        });
+
+        return () => {
+            setCommandsById(previous => {
+                const next = new Map(previous);
+                for (const [id, command] of incoming) {
+                    if (next.get(id) === command) next.delete(id);
+                }
+                return next;
+            });
+        };
+    }, []);
+
+    const commands = useMemo(() => [...commandsById.values()].sort((a, b) => {
+        const section = a.section.localeCompare(b.section);
+        if (section !== 0) return section;
+        return a.label.localeCompare(b.label);
+    }), [commandsById]);
+
+    const value = useMemo(() => ({ commands, register }), [commands, register]);
+
+    return (
+        <NotesCommandRegistryContext.Provider value={value}>
+            {props.children}
+        </NotesCommandRegistryContext.Provider>
+    );
+}
+
+export function useNoteCommands(): NoteCommand[] {
+    const registry = useContext(NotesCommandRegistryContext);
+    if (!registry) throw new Error('useNoteCommands must be used inside NotesCommandProvider');
+    return registry.commands;
+}
+
+export function useRegisterNoteCommands(commands: NoteCommand[], active = true): void {
+    const registry = useContext(NotesCommandRegistryContext);
+    if (!registry) throw new Error('useRegisterNoteCommands must be used inside NotesCommandProvider');
+    const register = registry.register;
+
+    useEffect(() => {
+        if (!active || commands.length === 0) return undefined;
+        return register(commands);
+    }, [active, commands, register]);
+}

package/public/manager/src/notes/notes-quick-switcher.css

@@ -149,3 +149,154 @@
         grid-row: auto;
     }
 }
+
+.notes-command-palette-backdrop {
+    position: fixed;
+    inset: 0;
+    z-index: 72;
+    display: grid;
+    place-items: start center;
+    padding: 12vh 16px 24px;
+    background: color-mix(in srgb, var(--canvas-deep) 58%, transparent);
+}
+
+.notes-command-palette {
+    width: min(620px, 100%);
+    max-height: min(620px, 78vh);
+    display: grid;
+    grid-template-rows: auto minmax(0, 1fr) auto;
+    overflow: hidden;
+    border: 1px solid var(--border-subtle);
+    border-radius: 8px;
+    background: var(--surface-raised);
+    color: var(--text-primary);
+}
+
+.notes-command-palette-input {
+    width: 100%;
+    min-height: 48px;
+    border: 0;
+    border-bottom: 1px solid var(--border-subtle);
+    border-radius: 0;
+    background: var(--surface-panel);
+    color: var(--text-primary);
+    padding: 0 16px;
+    font: inherit;
+    font-size: 15px;
+}
+
+.notes-command-palette-input:focus {
+    outline: 2px solid var(--accent-soft);
+    outline-offset: -2px;
+}
+
+.notes-command-palette-list {
+    min-height: 0;
+    overflow: auto;
+    padding: 8px;
+}
+
+.notes-command-palette-item {
+    width: 100%;
+    min-height: 56px;
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) max-content;
+    gap: 4px 12px;
+    align-items: center;
+    margin: 0 0 4px;
+    padding: 9px 10px;
+    border: 1px solid transparent;
+    border-radius: 7px;
+    background: transparent;
+    color: var(--text-primary);
+    text-align: left;
+    font: inherit;
+}
+
+.notes-command-palette-item:hover,
+.notes-command-palette-item.is-active {
+    border-color: var(--border-subtle);
+    background: var(--accent-soft);
+}
+
+.notes-command-palette-item.is-disabled {
+    opacity: 0.58;
+}
+
+.notes-command-palette-title {
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-weight: 500;
+}
+
+.notes-command-palette-meta {
+    min-width: 0;
+    grid-column: 1 / 2;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    color: var(--text-secondary);
+    font-size: 12px;
+}
+
+.notes-command-palette-shortcut {
+    grid-column: 2 / 3;
+    grid-row: 1 / span 2;
+    align-self: center;
+    border: 1px solid var(--border-subtle);
+    border-radius: 5px;
+    background: var(--surface-panel);
+    color: var(--text-secondary);
+    padding: 1px 5px;
+    font: inherit;
+    font-size: 12px;
+}
+
+.notes-command-palette-empty {
+    margin: 0;
+    padding: 18px 12px;
+    color: var(--text-secondary);
+    font-size: 13px;
+}
+
+.notes-command-palette-footer {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 10px;
+    padding: 9px 12px;
+    border-top: 1px solid var(--border-subtle);
+    color: var(--text-tertiary);
+    font-size: 12px;
+}
+
+.notes-command-palette-footer kbd {
+    border: 1px solid var(--border-subtle);
+    border-radius: 5px;
+    background: var(--surface-panel);
+    color: var(--text-secondary);
+    padding: 1px 5px;
+    font: inherit;
+}
+
+@media (max-width: 720px) {
+    .notes-command-palette-backdrop {
+        place-items: start stretch;
+        padding: 10vh 10px 16px;
+    }
+
+    .notes-command-palette {
+        max-height: 82vh;
+    }
+
+    .notes-command-palette-item {
+        grid-template-columns: minmax(0, 1fr);
+    }
+
+    .notes-command-palette-shortcut {
+        grid-column: 1 / 2;
+        grid-row: auto;
+        width: max-content;
+    }
+}

package/public/manager/src/notes/notes-shortcuts.ts

@@ -0,0 +1,23 @@
+type NotesShortcutEvent = Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'key' | 'metaKey' | 'shiftKey' | 'target'>;
+
+function hasPrimaryModifier(event: NotesShortcutEvent): boolean {
+    return (event.metaKey || event.ctrlKey) && !event.altKey;
+}
+
+function isInsideNotesPalette(target: EventTarget | null): boolean {
+    if (typeof HTMLElement === 'undefined' || !(target instanceof HTMLElement)) return false;
+    return Boolean(target.closest('[data-notes-palette]'));
+}
+
+export function isQuickSwitcherShortcut(event: NotesShortcutEvent): boolean {
+    return hasPrimaryModifier(event)
+        && !event.shiftKey
+        && event.key.toLowerCase() === 'p'
+        && !isInsideNotesPalette(event.target);
+}
+
+export function isCommandPaletteShortcut(event: NotesShortcutEvent): boolean {
+    return hasPrimaryModifier(event)
+        && event.shiftKey
+        && event.key.toLowerCase() === 'p';
+}

package/public/manager/src/notes/notes-types.ts

@@ -8,7 +8,7 @@ import type {
     VaultIndexSnapshot,
 } from '../types';
 
-export type NotesViewMode = 'raw' | 'split' | 'preview' | 'settings';
+export type NotesViewMode = 'raw' | 'split' | 'preview' | 'settings' | 'graph';
 export type NotesAuthoringMode = 'plain' | 'rich' | 'wysiwyg';
 
 export type NotesTreeSelection = {

package/public/manager/src/notes/template-engine.ts

@@ -0,0 +1,27 @@
+type TemplateVars = Record<string, string>;
+
+const VARIABLE_PATTERN = /\{\{(\w+)\}\}/g;
+
+function defaultVars(): TemplateVars {
+    const now = new Date();
+    const pad = (n: number) => String(n).padStart(2, '0');
+    const yyyy = now.getFullYear();
+    const mm = pad(now.getMonth() + 1);
+    const dd = pad(now.getDate());
+    const hh = pad(now.getHours());
+    const mi = pad(now.getMinutes());
+    return {
+        date: `${yyyy}-${mm}-${dd}`,
+        time: `${hh}:${mi}`,
+        year: String(yyyy),
+        month: mm,
+        day: dd,
+    };
+}
+
+export function applyTemplate(template: string, extraVars: TemplateVars = {}): string {
+    const vars: TemplateVars = { ...defaultVars(), ...extraVars };
+    return template.replace(VARIABLE_PATTERN, (match, key: string) => {
+        return Object.hasOwn(vars, key) ? vars[key] : match;
+    });
+}

package/public/manager/src/settings/pages/components/agent/agent-meta.ts

@@ -25,9 +25,15 @@ export type ActiveOverride = {
     effort?: string;
 };
 
-export const PRIMARY_CLIS: ReadonlyArray<string> = ['claude', 'codex', 'gemini'];
+export const PRIMARY_CLIS: ReadonlyArray<string> = ['claude', 'claude-e', 'agy', 'codex', 'gemini'];
 
 export const CLI_META: Record<string, CliMeta> = {
+    agy: {
+        label: 'Antigravity',
+        models: ['gemini-3.5-flash'],
+        efforts: [],
+        effortNote: 'AGY print mode uses the current AGY-selected model; switch models in native AGY UI, no --model/--effort flags in agy 1.0.0',
+    },
     'ai-e': {
         label: 'AI-E',
         defaultProvider: 'claude',

package/public/manager/src/types.ts

@@ -19,7 +19,7 @@ export type DashboardShortcutAction =
     | 'previousInstance'
     | 'nextInstance';
 export type DashboardShortcutKeymap = Record<DashboardShortcutAction, string>;
-export type DashboardNotesViewMode = 'raw' | 'split' | 'preview' | 'settings';
+export type DashboardNotesViewMode = 'raw' | 'split' | 'preview' | 'settings' | 'graph';
 export type DashboardNotesAuthoringMode = 'plain' | 'rich' | 'wysiwyg';
 export type DashboardActivityTitleSupportStatus = 'ready' | 'legacy' | 'offline';
 export type DashboardProfileId = string;
@@ -60,6 +60,7 @@ export type DashboardInstance = {
     instanceId: string | null;
     homeDisplay: string | null;
     workingDir: string | null;
+    projectDirs: string[] | null;
     currentCli: string | null;
     currentModel: string | null;
     serviceMode: DashboardServiceMode;