@theia/ai-ide 1.75.0-next.8 → 1.75.0

package/src/browser/ai-configuration/ai-configuration-search.spec.ts

@@ -0,0 +1,91 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { AiConfigurationSearchItem } from '@theia/ai-core-ui/lib/browser/ai-configuration/ai-configuration-category';
+import { AiConfigurationSearch } from './ai-configuration-search';
+
+function item(label: string, options?: Partial<AiConfigurationSearchItem>): AiConfigurationSearchItem {
+    return {
+        label,
+        typeLabel: options?.typeLabel ?? 'Setting',
+        categoryId: options?.categoryId ?? 'general',
+        target: options?.target ?? { categoryId: options?.categoryId ?? 'general' },
+        keywords: options?.keywords
+    };
+}
+
+describe('AiConfigurationSearch', () => {
+
+    describe('terms', () => {
+        it('splits on whitespace, lower-cases, and drops empties', () => {
+            expect(AiConfigurationSearch.terms('  Default   Chat  ')).to.deep.equal(['default', 'chat']);
+        });
+
+        it('returns an empty array for a blank query', () => {
+            expect(AiConfigurationSearch.terms('   ')).to.deep.equal([]);
+        });
+    });
+
+    describe('matchKey', () => {
+        it('folds label, keywords, and type label into a lower-cased key', () => {
+            const key = AiConfigurationSearch.matchKey(item('Default Chat Agent', { typeLabel: 'Agent', keywords: 'orchestrator id-42' }));
+            expect(key).to.equal('default chat agent orchestrator id-42 agent');
+        });
+
+        it('omits missing keywords', () => {
+            expect(AiConfigurationSearch.matchKey(item('MCP Server', { typeLabel: 'MCP Server' }))).to.equal('mcp server  mcp server');
+        });
+    });
+
+    describe('matchesTerms', () => {
+        const index = [
+            item('Default Chat Agent', { typeLabel: 'Agent', categoryId: 'agents', keywords: 'orchestrator' }),
+            item('Universal', { typeLabel: 'Agent', categoryId: 'agents' }),
+            item('Filesystem', { typeLabel: 'MCP Server', categoryId: 'mcp-servers', keywords: 'files' }),
+            item('Enable AI Features', { typeLabel: 'Setting', categoryId: 'general' })
+        ];
+
+        /** Mirrors how the tree filter combines the helpers: `terms` once, then `matchesTerms` per item. */
+        function matching(query: string): string[] {
+            const searchTerms = AiConfigurationSearch.terms(query);
+            return index
+                .filter(candidate => AiConfigurationSearch.matchesTerms(AiConfigurationSearch.matchKey(candidate), searchTerms))
+                .map(candidate => candidate.label);
+        }
+
+        it('matches every item for a blank query', () => {
+            expect(matching('   ')).to.have.length(index.length);
+        });
+
+        it('requires every term to be present (AND semantics)', () => {
+            expect(matching('chat agent')).to.deep.equal(['Default Chat Agent']);
+        });
+
+        it('matches against keywords and type label', () => {
+            expect(matching('orchestrator')).to.deep.equal(['Default Chat Agent']);
+            expect(matching('mcp')).to.deep.equal(['Filesystem']);
+        });
+
+        it('is case-insensitive', () => {
+            expect(matching('UNIVERSAL')).to.deep.equal(['Universal']);
+        });
+
+        it('matches on substrings', () => {
+            expect(matching('a')).to.deep.equal(['Default Chat Agent', 'Universal', 'Enable AI Features']);
+        });
+    });
+});

package/src/browser/ai-configuration/ai-configuration-search.ts

@@ -0,0 +1,43 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { AiConfigurationSearchItem } from '@theia/ai-core-ui/lib/browser/ai-configuration/ai-configuration-category';
+
+/**
+ * Pure matching helpers for the tree-level (deep) search. Kept free of any DOM
+ * or DI dependency so the tree filter can reuse it and it can be unit-tested in
+ * isolation.
+ *
+ * Match semantics: every whitespace-separated term of the query must appear in
+ * the item's match key (`label + keywords + typeLabel`, lower-cased).
+ */
+export namespace AiConfigurationSearch {
+
+    /** The lower-cased text a search item is matched against. */
+    export function matchKey(item: AiConfigurationSearchItem): string {
+        return `${item.label} ${item.keywords ?? ''} ${item.typeLabel}`.toLowerCase();
+    }
+
+    /** Splits a query into lower-cased, non-empty terms. */
+    export function terms(query: string): string[] {
+        return query.trim().toLowerCase().split(/\s+/).filter(term => term.length > 0);
+    }
+
+    /** Returns whether every term is present in `key`. */
+    export function matchesTerms(key: string, searchTerms: string[]): boolean {
+        return searchTerms.every(term => key.includes(term));
+    }
+}

package/src/browser/ai-configuration/{components/empty-state.tsx → ai-configuration-tree-model.ts}

@@ -13,18 +13,14 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-import * as React from '@theia/core/shared/react';
 
-export interface EmptyStateProps {
-    message: string;
-    className?: string;
-}
+import { injectable } from '@theia/core/shared/inversify';
+import { TreeModelImpl } from '@theia/core/lib/browser';
 
 /**
- * A component to display an empty state message (e.g., "Please select an item").
+ * Tree model backing the AI Configuration category tree. A dedicated subclass so
+ * adopters can rebind/customize the model in {@link createAiConfigurationTreeContainer}.
  */
-export const EmptyState: React.FC<EmptyStateProps> = ({ message, className }) => (
-    <div className={`ai-configuration-empty-state ${className || ''}`}>
-        <span className='ai-empty-state-message'>{message}</span>
-    </div>
-);
+@injectable()
+export class AiConfigurationTreeModel extends TreeModelImpl {
+}

package/src/browser/ai-configuration/ai-configuration-tree-nodes.spec.ts

@@ -0,0 +1,150 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { CompositeTreeNode } from '@theia/core/lib/browser/tree/tree';
+import { ExpandableTreeNode } from '@theia/core/lib/browser/tree/tree-expansion';
+import { AiConfigurationCategory, AiConfigurationTreeItem } from '@theia/ai-core-ui/lib/browser/ai-configuration/ai-configuration-category';
+import { AiConfigurationCategoryNode, AiConfigurationItemNode, AiConfigurationSeparatorNode, AiConfigurationTree } from './ai-configuration-tree-nodes';
+
+function category(id: string, kind: 'single-page' | 'collection', options?: {
+    contributed?: boolean;
+    items?: AiConfigurationTreeItem[];
+}): AiConfigurationCategory {
+    return {
+        id,
+        label: id.toUpperCase(),
+        iconClass: 'codicon codicon-gear',
+        kind,
+        contributed: options?.contributed,
+        renderer: {
+            getTreeChildren: kind === 'collection' ? () => options?.items ?? [] : undefined
+        }
+    };
+}
+
+describe('AiConfigurationTree.buildRoot', () => {
+
+    it('builds an empty invisible root when there are no categories', () => {
+        const root = AiConfigurationTree.buildRoot([]);
+        expect(root.id).to.equal(AiConfigurationTree.ROOT_ID);
+        expect(root.visible).to.equal(false);
+        expect(root.children).to.have.length(0);
+    });
+
+    it('creates a non-expandable node for a single-page category', () => {
+        const root = AiConfigurationTree.buildRoot([category('general', 'single-page')]);
+        const node = root.children[0] as AiConfigurationCategoryNode;
+        expect(AiConfigurationCategoryNode.is(node)).to.equal(true);
+        expect(node.id).to.equal(AiConfigurationTree.categoryNodeId('general'));
+        expect(ExpandableTreeNode.is(node)).to.equal(false);
+        expect(node.children).to.have.length(0);
+    });
+
+    it('creates an expandable node with item children for a non-empty collection', () => {
+        const items: AiConfigurationTreeItem[] = [
+            { id: 'a', label: 'Agent A' },
+            { id: 'b', label: 'Agent B' }
+        ];
+        const root = AiConfigurationTree.buildRoot([category('agents', 'collection', { items })]);
+        const node = root.children[0] as AiConfigurationCategoryNode;
+        // Expandable, but collapsed by default (categories start collapsed).
+        expect(ExpandableTreeNode.is(node)).to.equal(true);
+        expect(ExpandableTreeNode.isExpanded(node)).to.equal(false);
+        expect(node.children.map(c => c.id)).to.deep.equal([
+            AiConfigurationTree.itemNodeId('agents', 'a'),
+            AiConfigurationTree.itemNodeId('agents', 'b')
+        ]);
+        const [first] = node.children;
+        expect(AiConfigurationItemNode.is(first)).to.equal(true);
+        expect(first.name).to.equal('Agent A');
+        expect(first.parent).to.equal(node);
+    });
+
+    it("carries an item's status onto its node, so the tree can show it as a dot", () => {
+        const items: AiConfigurationTreeItem[] = [
+            { id: 'github', label: 'GitHub', status: { kind: 'on', label: 'Running' } },
+            { id: 'local', label: 'Local', status: { kind: 'error', label: 'Errored', tooltip: 'spawn failed' } },
+            { id: 'plain', label: 'Plain' }
+        ];
+        const root = AiConfigurationTree.buildRoot([category('mcp-servers', 'collection', { items })]);
+        const children = (root.children[0] as AiConfigurationCategoryNode).children as AiConfigurationItemNode[];
+
+        expect(children.map(child => child.status?.kind)).to.deep.equal(['on', 'error', undefined]);
+        expect(children[1].status?.tooltip).to.equal('spawn failed');
+    });
+
+    it('keeps the first of two items claiming the same id, since a node is addressed by its id', () => {
+        const items: AiConfigurationTreeItem[] = [
+            { id: 'code-reviewer', label: 'Code Reviewer' },
+            { id: 'code-reviewer', label: 'Code Reviewer (copy)' },
+            { id: 'coder', label: 'Coder' }
+        ];
+        const root = AiConfigurationTree.buildRoot([category('agents', 'collection', { items })]);
+        const children = (root.children[0] as AiConfigurationCategoryNode).children as AiConfigurationItemNode[];
+
+        expect(children.map(child => child.name)).to.deep.equal(['Code Reviewer', 'Coder']);
+        expect(new Set(children.map(child => child.id)).size).to.equal(children.length);
+    });
+
+    it('marks an empty collection as non-expandable', () => {
+        const root = AiConfigurationTree.buildRoot([category('variables', 'collection', { items: [] })]);
+        const node = root.children[0] as AiConfigurationCategoryNode;
+        expect(ExpandableTreeNode.is(node)).to.equal(false);
+    });
+
+    it('preserves the previous expansion state', () => {
+        const items: AiConfigurationTreeItem[] = [{ id: 'a', label: 'Agent A' }];
+        const root = AiConfigurationTree.buildRoot([category('agents', 'collection', { items })], {
+            isExpanded: id => id === 'agents' ? false : undefined
+        });
+        const node = root.children[0] as AiConfigurationCategoryNode;
+        expect(ExpandableTreeNode.isCollapsed(node)).to.equal(true);
+    });
+
+    it('inserts a single separator before the first contributed category, preserving order', () => {
+        const root = AiConfigurationTree.buildRoot([
+            category('agents', 'collection', { items: [] }),
+            category('tools', 'single-page'),
+            category('sample-ext', 'single-page', { contributed: true }),
+            category('other-ext', 'single-page', { contributed: true })
+        ]);
+        const ids = root.children.map(child => child.id);
+        expect(ids).to.deep.equal([
+            AiConfigurationTree.categoryNodeId('agents'),
+            AiConfigurationTree.categoryNodeId('tools'),
+            AiConfigurationTree.CONTRIBUTED_SEPARATOR_ID,
+            AiConfigurationTree.categoryNodeId('sample-ext'),
+            AiConfigurationTree.categoryNodeId('other-ext')
+        ]);
+        const separator = root.children.find(AiConfigurationSeparatorNode.is);
+        expect(separator).to.not.equal(undefined);
+        expect(root.children.filter(AiConfigurationSeparatorNode.is)).to.have.length(1);
+    });
+
+    it('omits the separator when there are no contributed categories', () => {
+        const root = AiConfigurationTree.buildRoot([category('general', 'single-page')]);
+        expect(root.children.some(AiConfigurationSeparatorNode.is)).to.equal(false);
+    });
+
+    it('wires child siblings via CompositeTreeNode', () => {
+        const items: AiConfigurationTreeItem[] = [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }];
+        const root = AiConfigurationTree.buildRoot([category('agents', 'collection', { items })]);
+        const node = root.children[0] as AiConfigurationCategoryNode;
+        expect(CompositeTreeNode.is(node)).to.equal(true);
+        expect(node.children[0].nextSibling).to.equal(node.children[1]);
+    });
+});

package/src/browser/ai-configuration/ai-configuration-tree-nodes.ts

@@ -0,0 +1,167 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { nls } from '@theia/core';
+import { CompositeTreeNode, TreeNode } from '@theia/core/lib/browser/tree/tree';
+import { SelectableTreeNode } from '@theia/core/lib/browser/tree/tree-selection';
+import { AiConfigurationCategory, AiConfigurationItemStatus, AiConfigurationTreeItem } from '@theia/ai-core-ui/lib/browser/ai-configuration/ai-configuration-category';
+
+/**
+ * Top-level node representing a single {@link AiConfigurationCategory}.
+ * Carries the `expanded` property (making it an `ExpandableTreeNode`) only when
+ * the category is a non-empty collection.
+ */
+export interface AiConfigurationCategoryNode extends SelectableTreeNode, CompositeTreeNode {
+    readonly type: 'category';
+    readonly categoryId: string;
+    readonly iconClass: string;
+    readonly contributed: boolean;
+    children: AiConfigurationItemNode[];
+    expanded?: boolean;
+    selected: boolean;
+}
+export namespace AiConfigurationCategoryNode {
+    export function is(node: TreeNode | undefined): node is AiConfigurationCategoryNode {
+        return !!node && (node as AiConfigurationCategoryNode).type === 'category';
+    }
+}
+
+/** Child node representing one item of a collection category. */
+export interface AiConfigurationItemNode extends SelectableTreeNode {
+    readonly type: 'item';
+    readonly categoryId: string;
+    readonly itemId: string;
+    readonly iconClass: string;
+    /** The item's state, as the tree shows it: a dot next to the label (e.g. an MCP server that is running). */
+    readonly status?: AiConfigurationItemStatus;
+    selected: boolean;
+}
+export namespace AiConfigurationItemNode {
+    export function is(node: TreeNode | undefined): node is AiConfigurationItemNode {
+        return !!node && (node as AiConfigurationItemNode).type === 'item';
+    }
+}
+
+/** Non-selectable separator introducing the "Contributed by extensions" group. */
+export interface AiConfigurationSeparatorNode extends TreeNode {
+    readonly type: 'separator';
+}
+export namespace AiConfigurationSeparatorNode {
+    export function is(node: TreeNode | undefined): node is AiConfigurationSeparatorNode {
+        return !!node && (node as AiConfigurationSeparatorNode).type === 'separator';
+    }
+}
+
+export interface AiConfigurationTreeBuildOptions {
+    /** Returns the previous expansion state of a category, to preserve it across rebuilds. */
+    isExpanded?(categoryId: string): boolean | undefined;
+}
+
+/**
+ * Builds the (invisible) root of the AI Configuration category tree from the
+ * ordered list of categories. Extracted as a pure function so the tree shape
+ * (children, separator, expansion) can be tested without a DOM.
+ */
+export namespace AiConfigurationTree {
+
+    export const ROOT_ID = 'ai-configuration-tree-root';
+    export const CONTRIBUTED_SEPARATOR_ID = 'ai-configuration-contributed-separator';
+
+    export function categoryNodeId(categoryId: string): string {
+        return `category:${categoryId}`;
+    }
+
+    export function itemNodeId(categoryId: string, itemId: string): string {
+        return `item:${categoryId}:${itemId}`;
+    }
+
+    export function buildRoot(categories: AiConfigurationCategory[], options?: AiConfigurationTreeBuildOptions): CompositeTreeNode {
+        const root: CompositeTreeNode = {
+            id: ROOT_ID,
+            parent: undefined,
+            visible: false,
+            children: []
+        };
+        let separatorAdded = false;
+        for (const category of categories) {
+            if (category.contributed && !separatorAdded) {
+                CompositeTreeNode.addChild(root, createSeparatorNode());
+                separatorAdded = true;
+            }
+            const items = category.kind === 'collection' ? (category.renderer.getTreeChildren?.() ?? []) : [];
+            const categoryNode = createCategoryNode(category, items, options);
+            CompositeTreeNode.addChild(root, categoryNode);
+            // A tree node is addressed by its id (selection, navigation, expansion), so two items claiming the
+            // same id cannot both be nodes. Keep the first and skip the rest deterministically rather than
+            // leaving it to the tree model; the category's overview lists every one of them and flags the
+            // clash, which is where the user can see that something needs fixing.
+            const usedItemIds = new Set<string>();
+            for (const item of items) {
+                if (usedItemIds.has(item.id)) {
+                    continue;
+                }
+                usedItemIds.add(item.id);
+                CompositeTreeNode.addChild(categoryNode, createItemNode(category, item));
+            }
+        }
+        return root;
+    }
+
+    function createCategoryNode(category: AiConfigurationCategory, items: AiConfigurationTreeItem[], options?: AiConfigurationTreeBuildOptions): AiConfigurationCategoryNode {
+        const collection = category.kind === 'collection';
+        const node: AiConfigurationCategoryNode = {
+            type: 'category',
+            id: categoryNodeId(category.id),
+            categoryId: category.id,
+            name: category.label,
+            iconClass: category.iconClass,
+            contributed: !!category.contributed,
+            parent: undefined,
+            children: [],
+            selected: false
+        };
+        if (collection && items.length > 0) {
+            // Categories start collapsed; a rebuild preserves whatever state the user had.
+            node.expanded = options?.isExpanded?.(category.id) ?? false;
+        }
+        return node;
+    }
+
+    function createItemNode(category: AiConfigurationCategory, item: AiConfigurationTreeItem): AiConfigurationItemNode {
+        return {
+            type: 'item',
+            id: itemNodeId(category.id, item.id),
+            categoryId: category.id,
+            itemId: item.id,
+            name: item.label,
+            // Every child shows an icon so rows look consistent: a dedicated per-item icon where one exists
+            // (e.g. individual agents), otherwise the category's icon as a uniform fallback.
+            iconClass: item.iconClass ?? category.iconClass,
+            status: item.status,
+            parent: undefined,
+            selected: false
+        };
+    }
+
+    function createSeparatorNode(): AiConfigurationSeparatorNode {
+        return {
+            type: 'separator',
+            id: CONTRIBUTED_SEPARATOR_ID,
+            name: nls.localize('theia/ai/core/aiConfiguration/contributedByExtensions', 'Contributed by extensions'),
+            parent: undefined
+        };
+    }
+}