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

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

@@ -0,0 +1,65 @@
+import {
+  USER_LOCAL_COMMAND_ARGUMENT_HINT,
+  USER_LOCAL_COMMAND_DESCRIPTION,
+  executeUserLocalCommand,
+} from './user-local-command.js';
+
+import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+export function createUserLocalCommandEntry(): ICommand {
+  return {
+    name: 'user-local',
+    displayName: 'User Config',
+    description: USER_LOCAL_COMMAND_DESCRIPTION,
+    source: 'user-local',
+    argumentHint: USER_LOCAL_COMMAND_ARGUMENT_HINT,
+    // User-only: the user's private cross-project storage.
+    modelInvocable: false,
+    safety: 'read-only',
+    subcommands: [
+      {
+        name: 'storage',
+        description: 'Inspect user-local storage categories',
+        source: 'user-local',
+      },
+      {
+        name: 'memory',
+        description: 'Inspect and manage user-local memory items',
+        source: 'user-local',
+      },
+    ],
+  };
+}
+
+function createUserLocalSystemCommand(storageRoot: string): ISystemCommand {
+  const entry = createUserLocalCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    argumentHint: entry.argumentHint,
+    safety: entry.safety,
+    subcommands: entry.subcommands,
+    execute: (context, rawArgs) => executeUserLocalCommand(context, rawArgs, storageRoot),
+  };
+}
+
+export class UserLocalCommandSource implements ICommandSource {
+  readonly name = 'user-local';
+
+  getCommands(): ICommand[] {
+    return [createUserLocalCommandEntry()];
+  }
+}
+
+export function createUserLocalCommandModule(storageRoot: string): ICommandModule {
+  return {
+    name: 'agent-command-user-local',
+    commandSources: [new UserLocalCommandSource()],
+    systemCommands: [createUserLocalSystemCommand(storageRoot)],
+  };
+}

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

@@ -0,0 +1,214 @@
+import { inspectUserLocalStorage } from '@robota-sdk/agent-framework';
+
+import { USER_LOCAL_COMMAND_USAGE } from './user-local-command-constants.js';
+import { executeMemoryCommand } from './user-local-memory-command.js';
+
+import type { ICommandHostWorkspace } from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+export {
+  USER_LOCAL_COMMAND_ARGUMENT_HINT,
+  USER_LOCAL_COMMAND_DESCRIPTION,
+  USER_LOCAL_COMMAND_USAGE,
+} from './user-local-command-constants.js';
+
+type TUserLocalOutputFormat = 'text' | 'json';
+
+export interface IUserLocalDirectCommandOptions {
+  readonly cwd: string;
+  readonly storageRoot: string;
+  readonly argv: readonly string[];
+  readonly format?: string;
+  readonly summary?: string;
+  readonly source?: string;
+}
+
+interface IParsedUserLocalCommand {
+  readonly target?: string;
+  readonly action?: string;
+  readonly positional: readonly string[];
+  readonly format: TUserLocalOutputFormat;
+  readonly summary?: string;
+  readonly source?: string;
+}
+
+interface IParsedUserLocalOption {
+  readonly format?: string;
+  readonly summary?: string;
+  readonly source?: string;
+  readonly nextIndex: number;
+}
+
+function parseOutputFormat(value: string | undefined): TUserLocalOutputFormat {
+  if (value === undefined || value === 'text') {
+    return 'text';
+  }
+  if (value === 'json') {
+    return 'json';
+  }
+  throw new Error(`Unsupported user-local output format: ${value}`);
+}
+
+function parseUserLocalOption(
+  arg: string,
+  argv: readonly string[],
+  index: number,
+): IParsedUserLocalOption | null {
+  if (arg === '--format') {
+    return { format: argv[index + 1], nextIndex: index + 1 };
+  }
+  if (arg.startsWith('--format=')) {
+    return { format: arg.slice('--format='.length), nextIndex: index };
+  }
+  if (arg === '--summary') {
+    return { summary: argv[index + 1], nextIndex: index + 1 };
+  }
+  if (arg.startsWith('--summary=')) {
+    return { summary: arg.slice('--summary='.length), nextIndex: index };
+  }
+  if (arg === '--source') {
+    return { source: argv[index + 1], nextIndex: index + 1 };
+  }
+  if (arg.startsWith('--source=')) {
+    return { source: arg.slice('--source='.length), nextIndex: index };
+  }
+  return null;
+}
+
+function parseUserLocalArgs(
+  argv: readonly string[],
+  directOptions: {
+    readonly format?: string;
+    readonly summary?: string;
+    readonly source?: string;
+  } = {},
+): IParsedUserLocalCommand {
+  let format = directOptions.format;
+  let summary = directOptions.summary;
+  let source = directOptions.source;
+  const positional: string[] = [];
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const option = parseUserLocalOption(arg, argv, index);
+    if (option !== null) {
+      format = option.format ?? format;
+      summary = option.summary ?? summary;
+      source = option.source ?? source;
+      index = option.nextIndex;
+      continue;
+    }
+    positional.push(arg);
+  }
+
+  return {
+    target: positional[0],
+    action: positional[1],
+    positional: positional.slice(2),
+    format: parseOutputFormat(format),
+    summary,
+    source,
+  };
+}
+
+function splitRawArgs(rawArgs: string): readonly string[] {
+  return rawArgs.trim().split(/\s+/).filter(Boolean);
+}
+
+function formatStorageInspectionText(
+  root: string,
+  categories: readonly { category: string }[],
+): string {
+  const categoryLines = categories.map((item) => `- ${item.category}`);
+  return [`User-local storage root: ${root}`, 'Categories:', ...categoryLines].join('\n');
+}
+
+async function executeStorageCommand(
+  cwd: string,
+  storageRoot: string,
+  parsed: IParsedUserLocalCommand,
+): Promise<ICommandResult> {
+  if ((parsed.action ?? 'list') !== 'list') {
+    return {
+      message: USER_LOCAL_COMMAND_USAGE,
+      success: false,
+    };
+  }
+
+  const inspection = await inspectUserLocalStorage({ activeRepositoryRoot: cwd, storageRoot });
+  return {
+    message:
+      parsed.format === 'json'
+        ? JSON.stringify(inspection, null, 2)
+        : formatStorageInspectionText(inspection.root, inspection.categories),
+    success: true,
+    data: {
+      root: inspection.root,
+      categories: inspection.categories,
+      inspection,
+    },
+  };
+}
+
+async function executeParsedUserLocalCommand(
+  cwd: string,
+  storageRoot: string,
+  parsed: IParsedUserLocalCommand,
+): Promise<ICommandResult> {
+  if (parsed.target === 'storage') {
+    return executeStorageCommand(cwd, storageRoot, parsed);
+  }
+  if (parsed.target === 'memory') {
+    return executeMemoryCommand(cwd, storageRoot, parsed);
+  }
+  return {
+    message: USER_LOCAL_COMMAND_USAGE,
+    success: false,
+  };
+}
+
+function formatCommandErrorMessage(errorMessage: string): string {
+  if (errorMessage.includes('ENOENT')) {
+    return 'User-local memory item not found.';
+  }
+  return errorMessage;
+}
+
+export async function executeUserLocalDirectCommand(
+  options: IUserLocalDirectCommandOptions,
+): Promise<ICommandResult> {
+  try {
+    return await executeParsedUserLocalCommand(
+      options.cwd,
+      options.storageRoot,
+      parseUserLocalArgs(options.argv, {
+        format: options.format,
+        summary: options.summary,
+        source: options.source,
+      }),
+    );
+  } catch (error) {
+    return {
+      message: formatCommandErrorMessage(error instanceof Error ? error.message : String(error)),
+      success: false,
+    };
+  }
+}
+
+export async function executeUserLocalCommand(
+  context: ICommandHostWorkspace,
+  rawArgs: string,
+  storageRoot: string,
+): Promise<ICommandResult> {
+  try {
+    return await executeParsedUserLocalCommand(
+      context.getCwd(),
+      storageRoot,
+      parseUserLocalArgs(splitRawArgs(rawArgs)),
+    );
+  } catch (error) {
+    return {
+      message: formatCommandErrorMessage(error instanceof Error ? error.message : String(error)),
+      success: false,
+    };
+  }
+}

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

@@ -0,0 +1,160 @@
+import {
+  deleteUserLocalMemoryItem,
+  disableUserLocalMemoryItem,
+  inspectUserLocalMemoryItem,
+  listUserLocalMemoryItems,
+  setUserLocalMemoryItem,
+} from '@robota-sdk/agent-framework';
+
+import { USER_LOCAL_COMMAND_USAGE } from './user-local-command-constants.js';
+
+import type { TUserLocalMemoryCategory } from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+
+export interface IUserLocalMemoryCommandArgs {
+  readonly action?: string;
+  readonly positional: readonly string[];
+  readonly format: 'text' | 'json';
+  readonly summary?: string;
+  readonly source?: string;
+}
+
+function formatMemoryListText(
+  items: readonly { category: string; key: string; enabled: boolean }[],
+): string {
+  if (items.length === 0) {
+    return 'No user-local memory items.';
+  }
+  return items
+    .map((item) => `- ${item.category}/${item.key} (${item.enabled ? 'enabled' : 'disabled'})`)
+    .join('\n');
+}
+
+function parseMemoryCategory(value: string | undefined): TUserLocalMemoryCategory {
+  if (value === undefined) {
+    throw new Error('User-local memory category is required.');
+  }
+  return value as TUserLocalMemoryCategory;
+}
+
+async function executeMemoryListCommand(
+  activeRepositoryRoot: string,
+  storageRoot: string,
+  parsed: IUserLocalMemoryCommandArgs,
+): Promise<ICommandResult> {
+  const list = await listUserLocalMemoryItems({ activeRepositoryRoot, storageRoot });
+  return {
+    message:
+      parsed.format === 'json' ? JSON.stringify(list, null, 2) : formatMemoryListText(list.items),
+    success: true,
+    data: { list },
+  };
+}
+
+async function executeMemorySetCommand(
+  activeRepositoryRoot: string,
+  storageRoot: string,
+  parsed: IUserLocalMemoryCommandArgs,
+): Promise<ICommandResult> {
+  const [category, key, value] = parsed.positional;
+  const item = await setUserLocalMemoryItem({
+    activeRepositoryRoot,
+    storageRoot,
+    category: parseMemoryCategory(category),
+    key: key ?? '',
+    value: value ?? '',
+    summary: parsed.summary ?? '',
+    source: parsed.source ?? '',
+  });
+  return {
+    message: `Stored user-local memory item ${item.category}/${item.key} at ${item.storageLocation}`,
+    success: true,
+    data: { item },
+  };
+}
+
+async function executeMemoryInspectCommand(
+  activeRepositoryRoot: string,
+  storageRoot: string,
+  parsed: IUserLocalMemoryCommandArgs,
+): Promise<ICommandResult> {
+  const [category, key] = parsed.positional;
+  const item = await inspectUserLocalMemoryItem({
+    activeRepositoryRoot,
+    storageRoot,
+    category: parseMemoryCategory(category),
+    key: key ?? '',
+  });
+  return {
+    message:
+      parsed.format === 'json'
+        ? JSON.stringify(item, null, 2)
+        : `${item.category}/${item.key}: ${item.summary}`,
+    success: true,
+    data: { item },
+  };
+}
+
+async function executeMemoryDisableCommand(
+  activeRepositoryRoot: string,
+  storageRoot: string,
+  parsed: IUserLocalMemoryCommandArgs,
+): Promise<ICommandResult> {
+  const [category, key] = parsed.positional;
+  const item = await disableUserLocalMemoryItem({
+    activeRepositoryRoot,
+    storageRoot,
+    category: parseMemoryCategory(category),
+    key: key ?? '',
+  });
+  return {
+    message: `Disabled user-local memory item ${item.category}/${item.key}`,
+    success: true,
+    data: { item },
+  };
+}
+
+async function executeMemoryDeleteCommand(
+  activeRepositoryRoot: string,
+  storageRoot: string,
+  parsed: IUserLocalMemoryCommandArgs,
+): Promise<ICommandResult> {
+  const [category, key] = parsed.positional;
+  const result = await deleteUserLocalMemoryItem({
+    activeRepositoryRoot,
+    storageRoot,
+    category: parseMemoryCategory(category),
+    key: key ?? '',
+  });
+  return {
+    message: `Deleted user-local memory item ${result.category}/${result.key}`,
+    success: true,
+    data: { result },
+  };
+}
+
+export async function executeMemoryCommand(
+  cwd: string,
+  storageRoot: string,
+  parsed: IUserLocalMemoryCommandArgs,
+): Promise<ICommandResult> {
+  if ((parsed.action ?? 'list') === 'list') {
+    return executeMemoryListCommand(cwd, storageRoot, parsed);
+  }
+  if (parsed.action === 'set') {
+    return executeMemorySetCommand(cwd, storageRoot, parsed);
+  }
+  if (parsed.action === 'inspect') {
+    return executeMemoryInspectCommand(cwd, storageRoot, parsed);
+  }
+  if (parsed.action === 'disable') {
+    return executeMemoryDisableCommand(cwd, storageRoot, parsed);
+  }
+  if (parsed.action === 'delete') {
+    return executeMemoryDeleteCommand(cwd, storageRoot, parsed);
+  }
+  return {
+    message: USER_LOCAL_COMMAND_USAGE,
+    success: false,
+  };
+}