@theia/ai-core 1.73.0-next.7 → 1.73.0

package/src/browser/frontend-variable-service.ts

@@ -14,9 +14,9 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Disposable, MessageService, nls, Prioritizeable } from '@theia/core';
+import { Disposable, MessageService, nls, Prioritizeable, ILogger } from '@theia/core';
 import { FrontendApplicationContribution, OpenerService, open } from '@theia/core/lib/browser';
-import { inject, injectable } from '@theia/core/shared/inversify';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
 import {
     AIVariable,
     AIVariableArg,
@@ -108,6 +108,8 @@ export class DefaultFrontendVariableService extends DefaultAIVariableService imp
     @inject(MessageService) protected readonly messageService: MessageService;
     @inject(AIVariableResourceResolver) protected readonly aiResourceResolver: AIVariableResourceResolver;
     @inject(OpenerService) protected readonly openerService: OpenerService;
+    @inject(ILogger) @named('ai-core:DefaultFrontendVariableService')
+    protected override readonly logger: ILogger;
 
     onStart(): void {
         this.initContributions();
@@ -199,7 +201,7 @@ export class DefaultFrontendVariableService extends DefaultAIVariableService imp
         try {
             return opener ? opener.open({ variable, arg }, context ?? {}) : this.openReadonly({ variable, arg }, context);
         } catch (err) {
-            console.error('Unable to open variable:', err);
+            this.logger.error('Unable to open variable:', err);
             this.messageService.error(nls.localize('theia/ai/core/unableToDisplayVariableValue', 'Unable to display variable value.'));
         }
     }

package/src/browser/index.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-export * from './agent-completion-notification-service';
+export * from './agent-notification-service';
 export * from './os-notification-service';
 export * from './window-blink-service';
 export * from './ai-activation-service';

package/src/browser/os-notification-service.ts

@@ -14,9 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from '@theia/core/shared/inversify';
+import { injectable, inject, named } from '@theia/core/shared/inversify';
 import { nls } from '@theia/core/lib/common/nls';
-import { environment } from '@theia/core';
+import { environment, ILogger } from '@theia/core';
+import { AgentNotificationKind, AGENT_NOTIFICATION_KIND_INPUT_NEEDED } from '../common/notification-types';
 
 /**
  * Configuration options for OS notifications
@@ -55,6 +56,9 @@ export interface OSNotificationResult {
 @injectable()
 export class OSNotificationService {
 
+    @inject(ILogger) @named('ai-core:OSNotificationService')
+    protected readonly logger: ILogger;
+
     private isElectron: boolean;
 
     constructor() {
@@ -96,7 +100,7 @@ export class OSNotificationService {
             };
 
         } catch (error) {
-            console.error('Failed to show OS notification:', error);
+            this.logger.error('Failed to show OS notification:', error);
             return {
                 success: false,
                 error: error instanceof Error ? error.message : 'Unknown error occurred'
@@ -134,7 +138,7 @@ export class OSNotificationService {
             const permission = await Notification.requestPermission();
             return permission;
         } catch (error) {
-            console.error('Failed to request notification permission:', error);
+            this.logger.error('Failed to request notification permission:', error);
             return 'denied';
         }
     }
@@ -149,33 +153,44 @@ export class OSNotificationService {
     }
 
     /**
-     * Show a notification specifically for agent completion
-     * This is a convenience method with pre-configured options for agent notifications
+     * Show a notification for an agent event (task completed or input needed).
+     * This is a convenience method with pre-configured options for agent notifications.
      *
-     * @param agentName The name of the agent that completed
+     * @param agentName The name of the agent
+     * @param kind Whether the agent completed its task or needs user input
      * @param sessionTitle Optional title of the chat session for identification
      * @param onClickCallback Optional callback to invoke when the notification is clicked
      * @returns Promise resolving to the notification result
      */
-    async showAgentCompletionNotification(
+    async showAgentNotification(
         agentName: string,
+        kind: AgentNotificationKind,
         sessionTitle?: string,
         onClickCallback?: () => void,
     ): Promise<OSNotificationResult> {
-        const title = nls.localize('theia/ai-core/agentCompletionTitle', 'Agent "{0}" Task Completed', agentName);
-        const body = sessionTitle
-            ? nls.localize('theia/ai-core/agentCompletionMessageWithSession',
-                'Agent "{0}" has completed its task in "{1}".', agentName, sessionTitle)
-            : nls.localize('theia/ai-core/agentCompletionMessage',
-                'Agent "{0}" has completed its task.', agentName);
+        const inputNeeded = kind === AGENT_NOTIFICATION_KIND_INPUT_NEEDED;
+        const title = inputNeeded
+            ? nls.localize('theia/ai-core/agentInputNeededTitle', 'Agent "{0}" Needs Your Input', agentName)
+            : nls.localize('theia/ai-core/agentCompletionTitle', 'Agent "{0}" Task Completed', agentName);
+        const body = inputNeeded
+            ? (sessionTitle
+                ? nls.localize('theia/ai-core/agentInputNeededMessageWithSession',
+                    'Agent "{0}" needs your input in "{1}".', agentName, sessionTitle)
+                : nls.localize('theia/ai-core/agentInputNeededMessage',
+                    'Agent "{0}" needs your input.', agentName))
+            : (sessionTitle
+                ? nls.localize('theia/ai-core/agentCompletionMessageWithSession',
+                    'Agent "{0}" has completed its task in "{1}".', agentName, sessionTitle)
+                : nls.localize('theia/ai-core/agentCompletionMessage',
+                    'Agent "{0}" has completed its task.', agentName));
 
         return this.showNotification(title, {
             body,
-            icon: this.getAgentCompletionIcon(),
-            tag: `agent-completion-${agentName}-${sessionTitle ?? 'default'}`,
+            icon: this.getAgentNotificationIcon(),
+            tag: `agent-${kind}-${agentName}-${sessionTitle ?? 'default'}`,
             requireInteraction: false,
             data: {
-                type: 'agent-completion',
+                type: `agent-${kind}`,
                 agentName,
                 sessionTitle,
                 timestamp: Date.now()
@@ -229,16 +244,16 @@ export class OSNotificationService {
                 const notification = new Notification(title, notificationOptions);
 
                 notification.onshow = () => {
-                    console.debug('OS notification shown:', title);
+                    this.logger.debug('OS notification shown:', title);
                 };
 
                 notification.onerror = error => {
-                    console.error('OS notification error:', error);
+                    this.logger.error('OS notification error:', error);
                     reject(new Error('Failed to show notification'));
                 };
 
                 notification.onclick = () => {
-                    console.debug('OS notification clicked:', title);
+                    this.logger.debug('OS notification clicked:', title);
                     this.focusApplicationWindow();
                     if (onClickCallback) {
                         onClickCallback();
@@ -247,7 +262,7 @@ export class OSNotificationService {
                 };
 
                 notification.onclose = () => {
-                    console.debug('OS notification closed:', title);
+                    this.logger.debug('OS notification closed:', title);
                 };
 
                 resolve(notification);
@@ -271,16 +286,16 @@ export class OSNotificationService {
                 }
             }
         } catch (error) {
-            console.debug('Could not focus application window:', error);
+            this.logger.debug('Could not focus application window:', error);
         }
     }
 
     /**
-     * Get the icon URL for agent completion notifications
+     * Get the icon URL for agent notifications
      *
      * @returns The icon URL or undefined if not available
      */
-    private getAgentCompletionIcon(): string | undefined {
+    private getAgentNotificationIcon(): string | undefined {
         // This could return a path to an icon file
         // For now, we'll return undefined to use the default system icon
         return undefined;

package/src/browser/prompt-variable-contribution.spec.ts

@@ -44,7 +44,8 @@ describe('PromptVariableContribution', () => {
         // Set up PromptService
         container.bind<PromptService>(PromptService).to(PromptServiceImpl).inSingletonScope();
         const logger = sinon.createStubInstance(Logger);
-        const variableService = new DefaultAIVariableService({ getContributions: () => [] }, logger);
+        const variableService = new DefaultAIVariableService({ getContributions: () => [] });
+        (variableService as unknown as Record<string, unknown>)['logger'] = logger;
         container.bind<AIVariableService>(AIVariableService).toConstantValue(variableService);
         container.bind<ILogger>(ILogger).toConstantValue(new MockLogger);
 

package/src/browser/skill-service.spec.ts

@@ -55,94 +55,127 @@ describe('SkillService', () => {
     });
 
     describe('directory prioritization', () => {
-        it('workspace directory comes first when all directories provided', () => {
+        it('workspace directories come first when all directories provided', () => {
             const result = combineSkillDirectories(
-                '/workspace/.prompts/skills',
+                ['/workspace/.prompts/skills', '/workspace/.agents/skills'],
                 ['/custom/skills1', '/custom/skills2'],
-                '/home/user/.theia/skills'
+                ['/home/user/.theia/skills', '/home/user/.agents/skills']
             );
 
             expect(result).to.deep.equal([
+                { path: '/workspace/.prompts/skills', tier: 'workspace' },
+                { path: '/workspace/.agents/skills', tier: 'workspace' },
+                { path: '/custom/skills1', tier: 'configured' },
+                { path: '/custom/skills2', tier: 'configured' },
+                { path: '/home/user/.theia/skills', tier: 'default' },
+                { path: '/home/user/.agents/skills', tier: 'default' }
+            ]);
+        });
+
+        it('preserves the workspace-tier order: .prompts/skills wins over .agents/skills on duplicate skill names', () => {
+            // The `.prompts/skills` directory is intentionally listed first within the workspace tier
+            // because it is the Theia-explicit folder; users opting into it signal stronger intent than
+            // those relying on the generic `.agents/skills` convention.
+            const result = combineSkillDirectories(
+                ['/workspace/.prompts/skills', '/workspace/.agents/skills'],
+                [],
+                []
+            );
+
+            expect(result.map(entry => entry.path)).to.deep.equal([
                 '/workspace/.prompts/skills',
-                '/custom/skills1',
-                '/custom/skills2',
-                '/home/user/.theia/skills'
+                '/workspace/.agents/skills'
             ]);
         });
 
-        it('works without workspace directory', () => {
+        it('works without workspace directories', () => {
             const result = combineSkillDirectories(
-                undefined,
+                [],
                 ['/custom/skills'],
-                '/home/user/.theia/skills'
+                ['/home/user/.theia/skills']
             );
 
             expect(result).to.deep.equal([
-                '/custom/skills',
-                '/home/user/.theia/skills'
+                { path: '/custom/skills', tier: 'configured' },
+                { path: '/home/user/.theia/skills', tier: 'default' }
             ]);
         });
 
-        it('works with only default directory', () => {
+        it('works with only default directories', () => {
             const result = combineSkillDirectories(
-                undefined,
                 [],
-                '/home/user/.theia/skills'
+                [],
+                ['/home/user/.theia/skills', '/home/user/.agents/skills']
             );
 
-            expect(result).to.deep.equal(['/home/user/.theia/skills']);
+            expect(result).to.deep.equal([
+                { path: '/home/user/.theia/skills', tier: 'default' },
+                { path: '/home/user/.agents/skills', tier: 'default' }
+            ]);
         });
 
         it('deduplicates workspace directory if also in configured', () => {
             const result = combineSkillDirectories(
-                '/workspace/.prompts/skills',
+                ['/workspace/.prompts/skills'],
                 ['/workspace/.prompts/skills', '/custom/skills'],
-                '/home/user/.theia/skills'
+                ['/home/user/.theia/skills']
             );
 
             expect(result).to.deep.equal([
-                '/workspace/.prompts/skills',
-                '/custom/skills',
-                '/home/user/.theia/skills'
+                { path: '/workspace/.prompts/skills', tier: 'workspace' },
+                { path: '/custom/skills', tier: 'configured' },
+                { path: '/home/user/.theia/skills', tier: 'default' }
             ]);
         });
 
         it('deduplicates default directory if also in configured', () => {
             const result = combineSkillDirectories(
-                '/workspace/.prompts/skills',
+                ['/workspace/.prompts/skills'],
                 ['/home/user/.theia/skills'],
-                '/home/user/.theia/skills'
+                ['/home/user/.theia/skills']
             );
 
             expect(result).to.deep.equal([
-                '/workspace/.prompts/skills',
-                '/home/user/.theia/skills'
+                { path: '/workspace/.prompts/skills', tier: 'workspace' },
+                { path: '/home/user/.theia/skills', tier: 'configured' }
             ]);
         });
 
         it('handles empty configured directories', () => {
             const result = combineSkillDirectories(
-                '/workspace/.prompts/skills',
+                ['/workspace/.prompts/skills'],
                 [],
-                '/home/user/.theia/skills'
+                ['/home/user/.theia/skills']
             );
 
             expect(result).to.deep.equal([
-                '/workspace/.prompts/skills',
-                '/home/user/.theia/skills'
+                { path: '/workspace/.prompts/skills', tier: 'workspace' },
+                { path: '/home/user/.theia/skills', tier: 'default' }
             ]);
         });
 
-        it('handles undefined default directory', () => {
+        it('handles empty default directories', () => {
             const result = combineSkillDirectories(
-                '/workspace/.prompts/skills',
+                ['/workspace/.prompts/skills'],
                 ['/custom/skills'],
-                undefined
+                []
             );
 
             expect(result).to.deep.equal([
-                '/workspace/.prompts/skills',
-                '/custom/skills'
+                { path: '/workspace/.prompts/skills', tier: 'workspace' },
+                { path: '/custom/skills', tier: 'configured' }
+            ]);
+        });
+
+        it('deduplicates duplicate workspace directories', () => {
+            const result = combineSkillDirectories(
+                ['/workspace/.prompts/skills', '/workspace/.prompts/skills'],
+                [],
+                []
+            );
+
+            expect(result).to.deep.equal([
+                { path: '/workspace/.prompts/skills', tier: 'workspace' }
             ]);
         });
     });
@@ -278,6 +311,7 @@ description: Skill with no content
         let fileServiceMock: any;
         let loggerWarnSpy: sinon.SinonStub;
         let loggerInfoSpy: sinon.SinonStub;
+        let loggerDebugSpy: sinon.SinonStub;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let envVariablesServerMock: any;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -295,6 +329,7 @@ description: Skill with no content
             const loggerMock: ILogger = sinon.createStubInstance(Logger);
             loggerMock.warn = loggerWarnSpy;
             loggerMock.info = loggerInfoSpy;
+            loggerMock.debug = loggerDebugSpy;
             (service as unknown as { logger: unknown }).logger = loggerMock;
             (service as unknown as { envVariablesServer: unknown }).envVariablesServer = envVariablesServerMock;
             (service as unknown as { workspaceService: unknown }).workspaceService = workspaceServiceMock;
@@ -315,6 +350,7 @@ description: Skill with no content
 
             loggerWarnSpy = sinon.stub();
             loggerInfoSpy = sinon.stub();
+            loggerDebugSpy = sinon.stub();
 
             envVariablesServerMock = {
                 getHomeDirUri: sinon.stub().resolves('file:///home/testuser'),
@@ -362,13 +398,17 @@ description: Skill with no content
                 sinon.match({ recursive: false, excludes: [] })
             )).to.be.true;
 
-            // Verify info log about watching parent
-            expect(loggerInfoSpy.calledWith(
+            // Verify debug log about watching parent (demoted from info to keep startup quiet)
+            expect(loggerDebugSpy.calledWith(
                 sinon.match(/Watching parent directory.*for skills folder creation/)
             )).to.be.true;
+            // And the same line must not be emitted at info level any more.
+            expect(loggerInfoSpy.calledWith(
+                sinon.match(/Watching parent directory/)
+            )).to.be.false;
         });
 
-        it('should log warning when parent directory does not exist', async () => {
+        it('should log a debug entry when parent directory does not exist', async () => {
             const service = createService();
 
             // Neither skills directory nor parent exists
@@ -379,10 +419,42 @@ description: Skill with no content
             await workspaceServiceMock.ready;
             await new Promise(resolve => setTimeout(resolve, 10));
 
-            // Verify warning is logged about parent not existing
-            expect(loggerWarnSpy.calledWith(
+            // The absent-default-tree case is expected on fresh machines and is now debug-level only.
+            expect(loggerDebugSpy.calledWith(
                 sinon.match(/Cannot watch skills directory.*parent directory does not exist/)
             )).to.be.true;
+            // It must no longer surface as a startup warning.
+            expect(loggerWarnSpy.calledWith(
+                sinon.match(/Cannot watch skills directory.*parent directory does not exist/)
+            )).to.be.false;
+        });
+
+        it('coalesces concurrent update() calls so a single scan runs at a time', async () => {
+            const service = createService();
+
+            // Default skills directory does not exist, but parent does, so each update logs once.
+            fileServiceMock.exists
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === '/home/testuser/.theia-ide/skills'))
+                .resolves(false);
+            fileServiceMock.exists
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === '/home/testuser/.theia-ide'))
+                .resolves(true);
+
+            // Drive two updates in the same tick - the second must be coalesced into a follow-up
+            // re-schedule rather than racing the first and producing duplicated log lines.
+            const update = (service as unknown as { update: () => Promise<void> }).update.bind(service);
+            await Promise.all([update(), update()]);
+            // Give the rescheduled run (debounced via scheduleUpdate) time to fire.
+            await new Promise(resolve => setTimeout(resolve, 80));
+
+            // The watcher must be installed (the underlying scan must have run); the same log line
+            // must have been emitted at most once per scan, never twice from interleaved scans.
+            const matchingDebugCalls = loggerDebugSpy.getCalls().filter(call =>
+                /Watching parent directory.*for skills folder creation/.test(String(call.args[0]))
+            );
+            // Two scans (initial + rescheduled) are allowed, but never more, and never zero.
+            expect(matchingDebugCalls.length).to.be.greaterThan(0);
+            expect(matchingDebugCalls.length).to.be.lessThan(3);
         });
 
         it('should log warning for non-existent configured directories', async () => {
@@ -477,5 +549,86 @@ Test skill content`
             expect(skills).to.have.length(1);
             expect(skills[0].name).to.equal('test-skill');
         });
+
+        it('prefers a workspace `.prompts/skills` skill over a same-named `.agents/skills` skill in the same root', async () => {
+            const service = createService();
+
+            workspaceServiceMock.tryGetRoots.returns([
+                { resource: URI.fromFilePath('/workspace') }
+            ]);
+
+            // Stub default skill directories as non-existent to keep focus on workspace behavior.
+            fileServiceMock.exists
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === '/home/testuser/.theia-ide/skills'))
+                .resolves(false);
+            fileServiceMock.exists
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === '/home/testuser/.theia-ide'))
+                .resolves(false);
+            fileServiceMock.exists
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === '/home/testuser/.agents/skills'))
+                .resolves(false);
+            fileServiceMock.exists
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === '/home/testuser/.agents'))
+                .resolves(false);
+
+            // Both workspace skill directories exist and contain a `dup-skill` directory.
+            const promptsSkillDir = '/workspace/.prompts/skills';
+            const agentsSkillDir = '/workspace/.agents/skills';
+            fileServiceMock.exists
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === promptsSkillDir))
+                .resolves(true);
+            fileServiceMock.exists
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === agentsSkillDir))
+                .resolves(true);
+            fileServiceMock.resolve
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === promptsSkillDir))
+                .resolves({
+                    children: [{
+                        isDirectory: true,
+                        name: 'dup-skill',
+                        resource: URI.fromFilePath(`${promptsSkillDir}/dup-skill`)
+                    }]
+                });
+            fileServiceMock.resolve
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === agentsSkillDir))
+                .resolves({
+                    children: [{
+                        isDirectory: true,
+                        name: 'dup-skill',
+                        resource: URI.fromFilePath(`${agentsSkillDir}/dup-skill`)
+                    }]
+                });
+
+            // Each tier provides its own SKILL.md so we can distinguish them by location.
+            fileServiceMock.exists
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === `${promptsSkillDir}/dup-skill/SKILL.md`))
+                .resolves(true);
+            fileServiceMock.exists
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === `${agentsSkillDir}/dup-skill/SKILL.md`))
+                .resolves(true);
+            fileServiceMock.read
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === `${promptsSkillDir}/dup-skill/SKILL.md`))
+                .resolves({
+                    value: '---\nname: dup-skill\ndescription: from prompts\n---\nFrom prompts'
+                });
+            fileServiceMock.read
+                .withArgs(sinon.match((uri: URI) => uri.path.toString() === `${agentsSkillDir}/dup-skill/SKILL.md`))
+                .resolves({
+                    value: '---\nname: dup-skill\ndescription: from agents\n---\nFrom agents'
+                });
+
+            (service as unknown as { init: () => void }).init();
+            await workspaceServiceMock.ready;
+            await new Promise(resolve => setTimeout(resolve, 10));
+
+            const skill = service.getSkill('dup-skill');
+            expect(skill, 'dup-skill should be discovered').to.not.be.undefined;
+            expect(skill!.description).to.equal('from prompts');
+            expect(skill!.location).to.equal(new Path(`${promptsSkillDir}/dup-skill/SKILL.md`).fsPath());
+            // The second occurrence is reported (not silently swallowed) via a warning.
+            expect(loggerWarnSpy.calledWith(
+                sinon.match(/Duplicate skill found.*dup-skill/)
+            )).to.be.true;
+        });
     });
 });