@robota-sdk/agent-command 3.0.0-beta.100

package/src/theme/__tests__/theme-command.test.ts

@@ -0,0 +1,204 @@
+/**
+ * SCREEN-2002 TC-09 — `/theme`.
+ *
+ * Three properties carry this command. It emits EXACTLY ONE patch per invocation, so a submission
+ * cannot half-apply. An unknown id writes NOTHING — not the theme, and not the toggles submitted
+ * beside it — because a user who mistyped an id did not also ask for the rest. And `motion on`
+ * means `reducedMotion: false`: the inversion is the easy thing to read backwards, and a user
+ * asking for motion and getting stillness would look like the command doing nothing at all.
+ */
+import { describe, expect, it } from 'vitest';
+
+import { executeThemeCommand } from '../theme-command-module.js';
+
+import type { TAppearanceSettingsPatch } from '@robota-sdk/agent-framework';
+import type {
+  IThemeAppearanceState,
+  IThemeCatalogueEntry,
+  IThemeCataloguePort,
+  TReducedMotionOverride,
+} from '@robota-sdk/agent-interface-command';
+
+const THEMES: IThemeCatalogueEntry[] = [
+  { id: 'dark', name: 'Dark', appearance: 'dark', source: 'built-in' },
+  { id: 'light', name: 'Light', appearance: 'light', source: 'built-in' },
+  {
+    id: 'dark-daltonized',
+    name: 'Dark (daltonized)',
+    appearance: 'dark',
+    source: 'built-in',
+  },
+];
+
+function catalogue(
+  state: Partial<IThemeAppearanceState['settings']> = {},
+  reducedMotionOverride?: TReducedMotionOverride,
+  reducedMotionForRun?: boolean,
+): IThemeCataloguePort {
+  const settings = {
+    theme: 'dark',
+    syntaxHighlighting: true,
+    reducedMotion: false,
+    ...state,
+  };
+  return {
+    listThemes: () => THEMES,
+    getTheme: (id) => THEMES.find((theme) => theme.id === id),
+    getAppearance: () => ({
+      settings,
+      ...(reducedMotionOverride === undefined
+        ? {}
+        : {
+            reducedMotionPin: {
+              tier: reducedMotionOverride,
+              reducedMotion: reducedMotionForRun ?? true,
+            },
+          }),
+    }),
+  };
+}
+
+function patchOf(result: { hostActions?: readonly unknown[] }): TAppearanceSettingsPatch {
+  expect(result.hostActions).toHaveLength(1);
+  const action = result.hostActions?.[0] as {
+    type: string;
+    patch: TAppearanceSettingsPatch;
+  };
+  expect(action.type).toBe('appearance-settings-patch');
+  return action.patch;
+}
+
+describe('/theme without a catalogue (SCREEN-2002 TC-09)', () => {
+  it('reports its unavailability instead of failing silently or writing anything', () => {
+    const result = executeThemeCommand(undefined, 'light');
+
+    expect(result.success).toBe(false);
+    expect(result.message).toMatch(/Run \/theme there/);
+    expect(result.hostActions).toBeUndefined();
+  });
+});
+
+describe('/theme with no argument (SCREEN-2002 TC-09)', () => {
+  it('asks the surface for the picker rather than changing anything', () => {
+    const result = executeThemeCommand(catalogue(), '   ');
+
+    expect(result.success).toBe(true);
+    expect(result.uiIntents).toEqual([{ type: 'show-theme-picker' }]);
+    expect(result.hostActions).toBeUndefined();
+  });
+});
+
+describe('/theme list (SCREEN-2002 TC-09)', () => {
+  it('marks the active theme and names each source, and writes nothing', () => {
+    const result = executeThemeCommand(catalogue({ theme: 'light' }), 'list');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('* light — Light (light, built-in)');
+    expect(result.message).toContain('  dark — Dark (dark, built-in)');
+    expect(result.message).toContain('syntax highlighting: on');
+    expect(result.message).toContain('reduced motion: off');
+    expect(result.hostActions).toBeUndefined();
+  });
+
+  it('reports what THIS RUN does and what is saved, never one in place of the other', () => {
+    // SCREEN-2002 TC-13 found this at the PTY level: reporting the persisted value beside the tier
+    // printed `reduced motion: off (… pinned by flag)` on a `--reduced-motion` run — a line that
+    // contradicts itself, and that answers "is motion reduced right now" with the wrong word.
+    const pinnedOn = executeThemeCommand(catalogue({ reducedMotion: false }, 'flag', true), 'list');
+    expect(pinnedOn.message).toContain(
+      'reduced motion: on for this run (pinned by flag; saved off)',
+    );
+
+    // `--no-reduced-motion` is an override too, and it pins the opposite value: a surface that
+    // renders the TIER alone cannot tell these two runs apart.
+    const pinnedOff = executeThemeCommand(
+      catalogue({ reducedMotion: true }, 'flag', false),
+      'list',
+    );
+    expect(pinnedOff.message).toContain(
+      'reduced motion: off for this run (pinned by flag; saved on)',
+    );
+  });
+});
+
+describe('/theme <id> (SCREEN-2002 TC-09)', () => {
+  it('emits exactly one patch naming the theme', () => {
+    const result = executeThemeCommand(catalogue(), 'dark-daltonized');
+
+    expect(result.success).toBe(true);
+    expect(patchOf(result)).toEqual({ theme: 'dark-daltonized' });
+    expect(result.message).toContain('Dark (daltonized)');
+  });
+
+  it('refuses an unknown id, names the catalogue, and writes NOTHING', () => {
+    const result = executeThemeCommand(catalogue(), 'solarized');
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('Unknown theme "solarized"');
+    expect(result.message).toContain('dark, light, dark-daltonized');
+    expect(result.hostActions).toBeUndefined();
+  });
+
+  it('does not apply the toggles submitted beside an unknown id', () => {
+    const result = executeThemeCommand(catalogue(), 'solarized syntax off');
+
+    expect(result.success).toBe(false);
+    expect(result.hostActions).toBeUndefined();
+  });
+
+  it('carries the theme and its toggles in ONE patch', () => {
+    const result = executeThemeCommand(catalogue(), 'light syntax off motion off');
+
+    expect(patchOf(result)).toEqual({
+      theme: 'light',
+      syntaxHighlighting: false,
+      reducedMotion: true,
+    });
+  });
+});
+
+describe('the motion inversion (SCREEN-2002 TC-09)', () => {
+  it('reads `motion on` as animation, which is reducedMotion FALSE', () => {
+    expect(patchOf(executeThemeCommand(catalogue({ reducedMotion: true }), 'motion on'))).toEqual({
+      reducedMotion: false,
+    });
+  });
+
+  it('reads `motion off` as stillness, which is reducedMotion TRUE', () => {
+    expect(patchOf(executeThemeCommand(catalogue(), 'motion off'))).toEqual({
+      reducedMotion: true,
+    });
+  });
+
+  it('reports the change in the user s words, not the settings key s', () => {
+    expect(executeThemeCommand(catalogue(), 'motion off').message).toContain('motion off');
+  });
+
+  it('persists the setting but says this run keeps what pinned it', () => {
+    const result = executeThemeCommand(catalogue({ reducedMotion: true }, 'flag'), 'motion on');
+
+    expect(patchOf(result)).toEqual({ reducedMotion: false });
+    expect(result.message).toContain('Saved, but this run keeps reduced motion pinned by flag');
+  });
+});
+
+describe('/theme syntax (SCREEN-2002 TC-09)', () => {
+  it('toggles highlighting without touching the theme', () => {
+    expect(patchOf(executeThemeCommand(catalogue(), 'syntax off'))).toEqual({
+      syntaxHighlighting: false,
+    });
+  });
+});
+
+describe('a malformed argument (SCREEN-2002 TC-09)', () => {
+  it.each(['motion', 'syntax', 'motion yes', 'syntax enable', 'light motion', 'light nonsense on'])(
+    'refuses %o with the usage line rather than guessing',
+    (args) => {
+      const result = executeThemeCommand(catalogue(), args);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain('Usage: /theme');
+      expect(result.hostActions).toBeUndefined();
+    },
+  );
+});

package/src/theme/index.ts

@@ -0,0 +1,12 @@
+export {
+  createThemeCommandEntry,
+  createThemeCommandModule,
+  executeThemeCommand,
+  ThemeCommandSource,
+} from './theme-command-module.js';
+export type {
+  IThemeAppearanceState,
+  IThemeCatalogueEntry,
+  IThemeCataloguePort,
+  TReducedMotionOverride,
+} from '@robota-sdk/agent-interface-command';

package/src/theme/theme-command-module.ts

@@ -0,0 +1,221 @@
+import type {
+  ICommandModule,
+  ISystemCommand,
+  TAppearanceSettingsPatch,
+} from '@robota-sdk/agent-framework';
+import type {
+  ICommand,
+  ICommandResult,
+  ICommandSource,
+  IThemeAppearanceState,
+  IThemeCatalogueEntry,
+  IThemeCataloguePort,
+} from '@robota-sdk/agent-interface-command';
+
+const THEME_DESCRIPTION =
+  'List, preview or switch the terminal colour theme, and toggle syntax highlighting and motion';
+const THEME_ARGUMENT_HINT = 'list | <theme-id> | syntax on|off | motion on|off';
+
+// A host without a terminal (the desktop app's sidecar) still answers, so the command is never
+// "unknown" there — it says where themes live instead.
+const THEME_UNAVAILABLE =
+  'Themes are available in an interactive terminal. Run /theme there.';
+
+function formatToggle(value: boolean): string {
+  return value ? 'on' : 'off';
+}
+
+function formatCatalogue(catalogue: IThemeCataloguePort): string {
+  const { settings, reducedMotionPin } = catalogue.getAppearance();
+  const rows = catalogue.listThemes().map((theme) => {
+    const marker = theme.id === settings.theme ? '* ' : '  ';
+    return `${marker}${theme.id} — ${theme.name} (${theme.appearance}, ${theme.source})`;
+  });
+  // Two facts, never one: what this run does, and what is saved. Reporting the SAVED value beside
+  // the tier reads as a contradiction on a `--no-reduced-motion` run over a `true` setting, and as
+  // an outright wrong answer to "is motion reduced right now".
+  const motion = reducedMotionPin
+    ? `${formatToggle(reducedMotionPin.reducedMotion)} for this run (pinned by ${reducedMotionPin.tier}; saved ${formatToggle(settings.reducedMotion)})`
+    : formatToggle(settings.reducedMotion);
+  return [
+    'Available themes:',
+    ...rows,
+    '',
+    `syntax highlighting: ${formatToggle(settings.syntaxHighlighting)}`,
+    `reduced motion: ${motion}`,
+  ].join('\n');
+}
+
+function listResult(catalogue: IThemeCataloguePort): ICommandResult {
+  return {
+    success: true,
+    message: formatCatalogue(catalogue),
+    data: {
+      themes: catalogue.listThemes().map((theme) => ({ ...theme })),
+      appearance: { ...catalogue.getAppearance().settings },
+    },
+  };
+}
+
+function unknownThemeResult(id: string, catalogue: IThemeCataloguePort): ICommandResult {
+  const known = catalogue
+    .listThemes()
+    .map((theme) => theme.id)
+    .join(', ');
+  return {
+    success: false,
+    message: `Unknown theme "${id}". Available: ${known || '(none)'}`,
+  };
+}
+
+/** `on` / `off`, and nothing else — a typo must not read as its opposite. */
+function parseToggle(word: string | undefined): boolean | undefined {
+  if (word === 'on') return true;
+  if (word === 'off') return false;
+  return undefined;
+}
+
+interface IParsedThemeArgs {
+  readonly patch?: TAppearanceSettingsPatch;
+  readonly themeId?: string;
+  readonly error?: string;
+}
+
+/**
+ * `/theme <id> [syntax on|off] [motion on|off]`, or a bare `syntax`/`motion` toggle. The theme id is
+ * NOT resolved here — parsing answers what was asked for, and the caller decides whether the
+ * catalogue holds it, so an unknown id is reported with the catalogue rather than as a parse error.
+ */
+function parseThemeArgs(tokens: readonly string[]): IParsedThemeArgs {
+  const patch: TAppearanceSettingsPatch = {};
+  let index = 0;
+  let themeId: string | undefined;
+  if (tokens[0] !== 'syntax' && tokens[0] !== 'motion') {
+    themeId = tokens[0];
+    index = 1;
+  }
+  while (index < tokens.length) {
+    const key = tokens[index];
+    const value = parseToggle(tokens[index + 1]);
+    if ((key !== 'syntax' && key !== 'motion') || value === undefined) {
+      return { error: `Usage: /theme ${THEME_ARGUMENT_HINT}` };
+    }
+    if (key === 'syntax') patch.syntaxHighlighting = value;
+    else patch.reducedMotion = !value;
+    index += 2;
+  }
+  return { patch, ...(themeId === undefined ? {} : { themeId }) };
+}
+
+/**
+ * `motion on` means "animate", which is `reducedMotion: false`. The inversion lives in one place
+ * precisely because reading it backwards is the easy mistake — a user asking for motion and getting
+ * stillness would look like the command doing nothing.
+ */
+function describeChange(
+  patch: TAppearanceSettingsPatch,
+  theme: IThemeCatalogueEntry | undefined,
+  state: IThemeAppearanceState,
+): string {
+  const parts: string[] = [];
+  if (theme) parts.push(`theme ${theme.name}`);
+  if (patch.syntaxHighlighting !== undefined) {
+    parts.push(`syntax highlighting ${formatToggle(patch.syntaxHighlighting)}`);
+  }
+  if (patch.reducedMotion !== undefined) {
+    parts.push(`motion ${formatToggle(!patch.reducedMotion)}`);
+  }
+  const applied = parts.length > 0 ? `Applied: ${parts.join(', ')}.` : 'Nothing to change.';
+  // The pin is reported, never silently obeyed or silently overridden: the setting IS persisted and
+  // takes effect next run, while this run keeps what pinned it.
+  if (patch.reducedMotion !== undefined && state.reducedMotionPin) {
+    return `${applied} Saved, but this run keeps reduced motion pinned by ${state.reducedMotionPin.tier}.`;
+  }
+  return applied;
+}
+
+export function executeThemeCommand(
+  catalogue: IThemeCataloguePort | undefined,
+  args: string,
+): ICommandResult {
+  if (!catalogue) return { success: false, message: THEME_UNAVAILABLE };
+
+  const tokens = args.trim().split(/\s+/u).filter(Boolean);
+  if (tokens.length === 0) {
+    return {
+      success: true,
+      message: 'Opening the theme picker...',
+      uiIntents: [{ type: 'show-theme-picker' }],
+    };
+  }
+  if (tokens.length === 1 && tokens[0] === 'list') return listResult(catalogue);
+
+  const parsed = parseThemeArgs(tokens);
+  if (parsed.error !== undefined || !parsed.patch) {
+    return { success: false, message: parsed.error ?? `Usage: /theme ${THEME_ARGUMENT_HINT}` };
+  }
+
+  const patch = { ...parsed.patch };
+  let theme: IThemeCatalogueEntry | undefined;
+  if (parsed.themeId !== undefined) {
+    theme = catalogue.getTheme(parsed.themeId);
+    // An unknown id writes NOTHING — not the theme, and not the toggles submitted beside it.
+    if (!theme) return unknownThemeResult(parsed.themeId, catalogue);
+    patch.theme = theme.id;
+  }
+
+  return {
+    success: true,
+    message: describeChange(patch, theme, catalogue.getAppearance()),
+    data: { appearance: { ...patch } },
+    hostActions: [{ type: 'appearance-settings-patch', patch }],
+  };
+}
+
+export function createThemeCommandEntry(): ICommand {
+  return {
+    name: 'theme',
+    displayName: 'Theme',
+    description: THEME_DESCRIPTION,
+    argumentHint: THEME_ARGUMENT_HINT,
+    source: 'theme',
+    userInvocable: true,
+    // User-only: UI preference.
+    modelInvocable: false,
+    // Themes belong to the terminal the user sits at, so that terminal runs it, even when attached.
+    runner: 'client',
+    surfaces: ['terminal'],
+  };
+}
+
+export class ThemeCommandSource implements ICommandSource {
+  readonly name = 'theme';
+
+  getCommands(): ICommand[] {
+    return [createThemeCommandEntry()];
+  }
+}
+
+export function createThemeCommandModule(
+  catalogue: IThemeCataloguePort | undefined,
+): ICommandModule {
+  const entry = createThemeCommandEntry();
+  const command: ISystemCommand = {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    argumentHint: entry.argumentHint,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    runner: entry.runner,
+    surfaces: entry.surfaces,
+    lifecycle: 'inline',
+    execute: (_context, args) => executeThemeCommand(catalogue, args),
+  };
+  return {
+    name: 'agent-command-theme',
+    commandSources: [new ThemeCommandSource()],
+    systemCommands: [command],
+  };
+}

package/src/user-local/__tests__/user-local-command.test.ts

@@ -0,0 +1,180 @@
+import { promises as fs } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { executeUserLocalCommand, executeUserLocalDirectCommand } from '../user-local-command.js';
+import { createUserLocalCommandModule } from '../user-local-command-module.js';
+
+const tempRoots: string[] = [];
+
+async function createTempRoot(name: string): Promise<string> {
+  const root = await fs.mkdtemp(path.join(tmpdir(), name));
+  tempRoots.push(root);
+  return root;
+}
+
+afterEach(async () => {
+  vi.unstubAllEnvs();
+  await Promise.all(
+    tempRoots.splice(0).map((root) => fs.rm(root, { recursive: true, force: true })),
+  );
+});
+
+describe('user-local command', () => {
+  it('does not advertise a specific product from the neutral command entry', async () => {
+    const module = createUserLocalCommandModule(await createTempRoot('agent-test-selected-storage-'));
+    expect(module.commandSources?.[0]?.getCommands()[0]?.description).not.toMatch(/ConversationAgent/i);
+  });
+
+  it('fails closed when a direct caller omits the storage root', async () => {
+    const workspace = await createTempRoot('agent-test-user-local-missing-root-');
+    const repo = path.join(workspace, 'repo');
+    await fs.mkdir(repo);
+
+    const result = await executeUserLocalDirectCommand({
+      cwd: repo,
+      argv: ['storage', 'list'],
+    } as never);
+    expect(result).toMatchObject({ success: false });
+    expect(result.message).toContain('userLocalStorageRoot is required');
+  });
+
+  it('uses the explicit root for slash commands', async () => {
+    const workspace = await createTempRoot('agent-test-user-local-slash-root-');
+    const repo = path.join(workspace, 'repo');
+    const selectedRoot = path.join(workspace, 'selected', '.fixture-state');
+    await fs.mkdir(repo);
+    vi.stubEnv('HOME', path.join(workspace, 'ambient-home'));
+
+    const directResult = await executeUserLocalCommand(
+      { getCwd: () => repo } as never,
+      'storage list --format=json',
+      selectedRoot,
+    );
+    expect(directResult.success).toBe(true);
+    expect(JSON.parse(directResult.message)).toMatchObject({ root: selectedRoot });
+
+    const slashCommand = createUserLocalCommandModule(selectedRoot).systemCommands?.[0];
+    expect(slashCommand).toBeDefined();
+    const result = await slashCommand!.execute(
+      { getCwd: () => repo } as never,
+      'storage list --format=json',
+    );
+    expect(result.success).toBe(true);
+    expect(JSON.parse(result.message)).toMatchObject({ root: selectedRoot });
+  });
+
+  it('prints storage inspection JSON without provider configuration', async () => {
+    const workspace = await createTempRoot('agent-test-user-local-command-');
+    const repo = path.join(workspace, 'repo');
+    const home = path.join(workspace, 'home');
+    await fs.mkdir(repo);
+    await fs.mkdir(home);
+    vi.stubEnv('HOME', path.join(workspace, 'ambient-home'));
+
+    const result = await executeUserLocalDirectCommand({
+      cwd: repo,
+      storageRoot: path.join(home, '.fixture-state'),
+      argv: ['storage', 'list'],
+      format: 'json',
+    });
+    const parsed = JSON.parse(result.message) as {
+      root: string;
+      categories: readonly { category: string; mayExecuteCommands: boolean }[];
+    };
+
+    expect(result.success).toBe(true);
+    expect(parsed.root).toBe(path.join(home, '.fixture-state'));
+    expect(parsed.categories.map((item) => item.category)).toEqual([
+      'preferences',
+      'view-state',
+      'memory-projections',
+      'task-associations',
+      'workflow-metadata',
+      'inspection-index',
+    ]);
+    expect(parsed.categories.every((item) => item.mayExecuteCommands === false)).toBe(true);
+  });
+
+  it('stores, lists, inspects, disables, and deletes user-local memory items', async () => {
+    const workspace = await createTempRoot('agent-test-user-local-memory-command-');
+    const repo = path.join(workspace, 'repo');
+    const home = path.join(workspace, 'home');
+    await fs.mkdir(repo);
+    await fs.mkdir(home);
+    vi.stubEnv('HOME', path.join(workspace, 'ambient-home'));
+
+    const setResult = await executeUserLocalDirectCommand({
+      cwd: repo,
+      storageRoot: path.join(home, '.fixture-state'),
+      argv: ['memory', 'set', 'view-preference', 'last-panel', 'background'],
+      summary: 'Open the background panel',
+      source: 'user-input',
+    });
+    expect(setResult.success).toBe(true);
+    expect(setResult.message).toContain('view-preference/last-panel');
+
+    const listResult = await executeUserLocalDirectCommand({
+      cwd: repo,
+      storageRoot: path.join(home, '.fixture-state'),
+      argv: ['memory', 'list'],
+      format: 'json',
+    });
+    const list = JSON.parse(listResult.message) as {
+      items: readonly { category: string; key: string; enabled: boolean }[];
+    };
+    expect(listResult.success).toBe(true);
+    expect(list.items).toHaveLength(1);
+    expect(list.items[0]).toMatchObject({
+      category: 'view-preference',
+      key: 'last-panel',
+      enabled: true,
+    });
+
+    const inspectResult = await executeUserLocalDirectCommand({
+      cwd: repo,
+      storageRoot: path.join(home, '.fixture-state'),
+      argv: ['memory', 'inspect', 'view-preference', 'last-panel'],
+      format: 'json',
+    });
+    const inspected = JSON.parse(inspectResult.message) as {
+      commandExecutionEffect: string;
+      displayNavigationRule: string;
+    };
+    expect(inspectResult.success).toBe(true);
+    expect(inspected.commandExecutionEffect).toBe('none');
+    expect(inspected.displayNavigationRule).toContain('display/navigation only');
+
+    const disableResult = await executeUserLocalDirectCommand({
+      cwd: repo,
+      storageRoot: path.join(home, '.fixture-state'),
+      argv: ['memory', 'disable', 'view-preference', 'last-panel'],
+    });
+    expect(disableResult.success).toBe(true);
+
+    const disabledInspectResult = await executeUserLocalDirectCommand({
+      cwd: repo,
+      storageRoot: path.join(home, '.fixture-state'),
+      argv: ['memory', 'inspect', 'view-preference', 'last-panel'],
+      format: 'json',
+    });
+    const disabled = JSON.parse(disabledInspectResult.message) as { enabled: boolean };
+    expect(disabled.enabled).toBe(false);
+
+    const deleteResult = await executeUserLocalDirectCommand({
+      cwd: repo,
+      storageRoot: path.join(home, '.fixture-state'),
+      argv: ['memory', 'delete', 'view-preference', 'last-panel'],
+    });
+    expect(deleteResult.success).toBe(true);
+
+    const missingResult = await executeUserLocalDirectCommand({
+      cwd: repo,
+      storageRoot: path.join(home, '.fixture-state'),
+      argv: ['memory', 'inspect', 'view-preference', 'last-panel'],
+      format: 'json',
+    });
+    expect(missingResult.success).toBe(false);
+    expect(missingResult.message).toBe('User-local memory item not found.');
+  });
+});

package/src/user-local/index.ts

@@ -0,0 +1,13 @@
+export {
+  UserLocalCommandSource,
+  createUserLocalCommandEntry,
+  createUserLocalCommandModule,
+} from './user-local-command-module.js';
+export {
+  USER_LOCAL_COMMAND_ARGUMENT_HINT,
+  USER_LOCAL_COMMAND_DESCRIPTION,
+  USER_LOCAL_COMMAND_USAGE,
+  executeUserLocalCommand,
+  executeUserLocalDirectCommand,
+} from './user-local-command.js';
+export type { IUserLocalDirectCommandOptions } from './user-local-command.js';

package/src/user-local/user-local-command-constants.ts

@@ -0,0 +1,5 @@
+export const USER_LOCAL_COMMAND_DESCRIPTION = 'Inspect user-local storage and memory state.';
+export const USER_LOCAL_COMMAND_ARGUMENT_HINT =
+  'storage list [--format json] | memory set/list/inspect/disable/delete';
+export const USER_LOCAL_COMMAND_USAGE =
+  'Usage: user-local storage list [--format json] | user-local memory set <category> <key> <value> --summary <summary> --source <source> | user-local memory list [--format json] | user-local memory inspect <category> <key> [--format json] | user-local memory disable <category> <key> | user-local memory delete <category> <key>';