Feat/tool registry discovery (google-gemini#28113)

(cherry picked from commit d845bc5)

Author: ved015

scripts/tests/tool-registry.test.ts

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, it } from 'vitest';
+import {
+  buildToolRegistry,
+  resolveToolName,
+  getToolsByCategory,
+  type ToolCategory,
+} from '../utils/tool-registry.js';
+
+describe('tool-registry', () => {
+  const registry = buildToolRegistry();
+
+  describe('buildToolRegistry', () => {
+    it('includes all canonical built-in tools', () => {
+      expect(registry.totalTools).toBeGreaterThanOrEqual(26);
+    });
+
+    it('every tool has a valid category', () => {
+      for (const [name, entry] of registry.tools) {
+        expect(entry.category).toBeTruthy();
+        expect(entry.name).toBe(name);
+      }
+    });
+
+    it('byCategory entries match tools map', () => {
+      let categoryTotal = 0;
+      for (const [, entries] of registry.byCategory) {
+        for (const entry of entries) {
+          expect(registry.tools.get(entry.name)).toBe(entry);
+        }
+        categoryTotal += entries.length;
+      }
+      expect(categoryTotal).toBe(registry.totalTools);
+    });
+
+    it('aliasLookup covers every canonical name', () => {
+      for (const name of registry.tools.keys()) {
+        expect(registry.aliasLookup.get(name)).toBe(name);
+      }
+    });
+
+    it('aliasLookup covers every legacy alias', () => {
+      for (const [, entry] of registry.tools) {
+        for (const alias of entry.aliases) {
+          expect(registry.aliasLookup.get(alias)).toBe(entry.name);
+        }
+      }
+    });
+
+    it('is deterministic across calls', () => {
+      const second = buildToolRegistry();
+      expect([...second.tools.keys()]).toEqual([...registry.tools.keys()]);
+      expect(second.totalTools).toBe(registry.totalTools);
+    });
+  });
+
+  describe('resolveToolName', () => {
+    it('resolves canonical names to themselves', () => {
+      expect(resolveToolName(registry, 'grep_search')).toBe('grep_search');
+      expect(resolveToolName(registry, 'run_shell_command')).toBe(
+        'run_shell_command',
+      );
+    });
+
+    it('resolves legacy alias to canonical name', () => {
+      expect(resolveToolName(registry, 'search_file_content')).toBe(
+        'grep_search',
+      );
+    });
+
+    it('returns undefined for unknown tool names', () => {
+      expect(resolveToolName(registry, 'nonexistent_tool')).toBeUndefined();
+    });
+
+    it('returns undefined for empty string', () => {
+      expect(resolveToolName(registry, '')).toBeUndefined();
+    });
+  });
+
+  describe('getToolsByCategory', () => {
+    it('returns file-system tools', () => {
+      const tools = getToolsByCategory(registry, 'file-system');
+      const names = tools.map((t) => t.name);
+      expect(names).toContain('glob');
+      expect(names).toContain('grep_search');
+      expect(names).toContain('read_file');
+      expect(names).toContain('write_file');
+      expect(names).toContain('replace');
+    });
+
+    it('returns task-tracker tools', () => {
+      const tools = getToolsByCategory(registry, 'task-tracker');
+      const names = tools.map((t) => t.name);
+      expect(names).toContain('tracker_create_task');
+      expect(names).toContain('tracker_update_task');
+      expect(names).toContain('tracker_get_task');
+      expect(names).toContain('tracker_list_tasks');
+      expect(names).toContain('tracker_add_dependency');
+      expect(names).toContain('tracker_visualize');
+      expect(names).toHaveLength(6);
+    });
+
+    it('returns agent tools', () => {
+      const tools = getToolsByCategory(registry, 'agent');
+      const names = tools.map((t) => t.name);
+      expect(names).toContain('invoke_agent');
+      expect(names).toContain('complete_task');
+      expect(names).toContain('update_topic');
+    });
+
+    it('returns empty array for unknown category', () => {
+      expect(
+        getToolsByCategory(registry, 'nonexistent' as ToolCategory),
+      ).toEqual([]);
+    });
+
+    it('every defined category has at least one tool', () => {
+      const expectedCategories: ToolCategory[] = [
+        'file-system',
+        'shell',
+        'web',
+        'planning',
+        'user-interaction',
+        'skills',
+        'task-tracker',
+        'agent',
+        'mcp',
+      ];
+      for (const cat of expectedCategories) {
+        expect(getToolsByCategory(registry, cat).length).toBeGreaterThan(0);
+      }
+    });
+  });
+});

scripts/utils/tool-registry.ts

@@ -0,0 +1,143 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  ALL_BUILTIN_TOOL_NAMES,
+  TOOL_LEGACY_ALIASES,
+} from '@google/gemini-cli-core';
+
+export type ToolCategory =
+  | 'file-system'
+  | 'shell'
+  | 'web'
+  | 'planning'
+  | 'user-interaction'
+  | 'skills'
+  | 'task-tracker'
+  | 'agent'
+  | 'mcp';
+
+export interface ToolRegistryEntry {
+  name: string;
+  category: ToolCategory;
+  aliases: readonly string[];
+}
+
+export interface ToolRegistry {
+  tools: ReadonlyMap<string, ToolRegistryEntry>;
+  totalTools: number;
+  byCategory: ReadonlyMap<ToolCategory, readonly ToolRegistryEntry[]>;
+  aliasLookup: ReadonlyMap<string, string>;
+}
+
+const TOOL_CATEGORIES: Record<
+  (typeof ALL_BUILTIN_TOOL_NAMES)[number],
+  ToolCategory
+> = {
+  glob: 'file-system',
+  grep_search: 'file-system',
+  list_directory: 'file-system',
+  read_file: 'file-system',
+  read_many_files: 'file-system',
+  write_file: 'file-system',
+  replace: 'file-system',
+  run_shell_command: 'shell',
+  google_web_search: 'web',
+  web_fetch: 'web',
+  enter_plan_mode: 'planning',
+  exit_plan_mode: 'planning',
+  write_todos: 'planning',
+  ask_user: 'user-interaction',
+  activate_skill: 'skills',
+  get_internal_docs: 'skills',
+  tracker_create_task: 'task-tracker',
+  tracker_update_task: 'task-tracker',
+  tracker_get_task: 'task-tracker',
+  tracker_list_tasks: 'task-tracker',
+  tracker_add_dependency: 'task-tracker',
+  tracker_visualize: 'task-tracker',
+  invoke_agent: 'agent',
+  complete_task: 'agent',
+  update_topic: 'agent',
+  read_mcp_resource: 'mcp',
+  list_mcp_resources: 'mcp',
+};
+
+let registryCache: ToolRegistry | undefined;
+
+export function buildToolRegistry(): ToolRegistry {
+  if (registryCache) {
+    return registryCache;
+  }
+
+  const tools = new Map<string, ToolRegistryEntry>();
+  const aliasLookup = new Map<string, string>();
+  const categoryGroups = new Map<ToolCategory, ToolRegistryEntry[]>();
+
+  for (const name of ALL_BUILTIN_TOOL_NAMES) {
+    const category = TOOL_CATEGORIES[name];
+    const aliases: string[] = [];
+
+    for (const [legacyName, canonicalName] of Object.entries(
+      TOOL_LEGACY_ALIASES,
+    )) {
+      if (canonicalName === name) {
+        aliases.push(legacyName);
+        aliasLookup.set(legacyName, name);
+      }
+    }
+
+    aliasLookup.set(name, name);
+
+    const entry: ToolRegistryEntry = {
+      name,
+      category,
+      aliases: Object.freeze(aliases),
+    };
+
+    tools.set(name, entry);
+
+    const group = categoryGroups.get(category);
+    if (group) {
+      group.push(entry);
+    } else {
+      categoryGroups.set(category, [entry]);
+    }
+  }
+
+  const frozenCategories = new Map<
+    ToolCategory,
+    readonly ToolRegistryEntry[]
+  >();
+  for (const [cat, entries] of categoryGroups) {
+    frozenCategories.set(cat, Object.freeze(entries));
+  }
+
+  registryCache = {
+    tools,
+    totalTools: tools.size,
+    byCategory: frozenCategories,
+    aliasLookup,
+  };
+  return registryCache;
+}
+
+export function resolveToolName(
+  registry: ToolRegistry,
+  name: string,
+): string | undefined {
+  if (!name) {
+    return undefined;
+  }
+  return registry.aliasLookup.get(name);
+}
+
+export function getToolsByCategory(
+  registry: ToolRegistry,
+  category: ToolCategory,
+): readonly ToolRegistryEntry[] {
+  return registry.byCategory.get(category) ?? [];
+}