@renseiai/agentfactory 0.8.3 → 0.8.4

package/dist/src/providers/index.js

@@ -2,12 +2,18 @@
  * Agent Provider Factory
  *
  * Creates provider instances based on name.
- * Supports provider selection via env vars:
- *   AGENT_PROVIDER=claude            (global default)
- *   AGENT_PROVIDER_SOCIAL=codex      (per-project override)
- *   AGENT_PROVIDER_QA=amp            (per-work-type override)
+ * Supports provider selection via env vars, config, labels, and mentions.
  *
- * Resolution order: work-type → project → env default → 'claude'
+ * Resolution order (highest → lowest):
+ * 1. Issue label override (provider:codex)
+ * 2. Mention context override ("use codex", "@codex")
+ * 3. Config providers.byWorkType
+ * 4. Config providers.byProject
+ * 5. Env var AGENT_PROVIDER_{WORKTYPE}
+ * 6. Env var AGENT_PROVIDER_{PROJECT}
+ * 7. Config providers.default
+ * 8. Env var AGENT_PROVIDER
+ * 9. Hardcoded 'claude'
  */
 export { ClaudeProvider, createClaudeProvider } from './claude-provider.js';
 export { CodexProvider, createCodexProvider } from './codex-provider.js';
@@ -19,6 +25,18 @@ import { CodexProvider } from './codex-provider.js';
 import { AmpProvider } from './amp-provider.js';
 import { SpringAiProvider } from './spring-ai-provider.js';
 import { A2aProvider } from './a2a-provider.js';
+// ---------------------------------------------------------------------------
+// Aliases — friendly names that map to real provider names
+// ---------------------------------------------------------------------------
+export const PROVIDER_ALIASES = {
+    opus: 'claude',
+    sonnet: 'claude',
+    codex: 'codex',
+    gemini: 'a2a',
+};
+// ---------------------------------------------------------------------------
+// Provider factory
+// ---------------------------------------------------------------------------
 /**
  * Create a provider instance by name.
  *
@@ -39,47 +57,157 @@ export function createProvider(name) {
         case 'a2a':
             return new A2aProvider();
         default:
-            throw new Error(`Unknown agent provider: ${name}. Supported: claude, codex, amp, spring-ai, a2a`);
+            throw new Error(`Unknown agent provider: ${name}. Supported: claude, codex, amp, spring-ai, a2a. ` +
+                `If this is a CLI tool, ensure the binary is installed and on your PATH.`);
     }
 }
+// ---------------------------------------------------------------------------
+// Label & mention extraction
+// ---------------------------------------------------------------------------
 /**
- * Resolve which provider to use based on env vars, project, and work type.
+ * Extract provider name from issue labels.
+ * Looks for labels matching "provider:<name>" pattern.
+ */
+export function extractProviderFromLabels(labels) {
+    for (const label of labels) {
+        const match = label.match(/^provider:(\S+)$/i);
+        if (match) {
+            const resolved = resolveAlias(match[1]);
+            if (resolved && isValidProviderName(resolved)) {
+                return resolved;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Extract provider name from mention/prompt context text.
+ * Matches: "use <provider>", "@<provider>", "provider:<provider>"
+ * Case-insensitive, word-boundary aware.
+ */
+export function extractProviderFromMention(text) {
+    // Pattern 1: "use <provider>" (with word boundary to avoid "don't use")
+    const useMatch = text.match(/\buse\s+(\w[\w-]*)/i);
+    if (useMatch) {
+        const resolved = resolveAlias(useMatch[1]);
+        if (resolved && isValidProviderName(resolved)) {
+            return resolved;
+        }
+    }
+    // Pattern 2: "@<provider>"
+    const atMatch = text.match(/@(\w[\w-]*)/i);
+    if (atMatch) {
+        const resolved = resolveAlias(atMatch[1]);
+        if (resolved && isValidProviderName(resolved)) {
+            return resolved;
+        }
+    }
+    // Pattern 3: "provider:<provider>"
+    const providerMatch = text.match(/\bprovider:(\w[\w-]*)/i);
+    if (providerMatch) {
+        const resolved = resolveAlias(providerMatch[1]);
+        if (resolved && isValidProviderName(resolved)) {
+            return resolved;
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Provider resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve which provider to use with full priority cascade.
  *
- * Resolution order (highest priority first):
- * 1. AGENT_PROVIDER_{WORKTYPE} (e.g., AGENT_PROVIDER_QA=amp)
- * 2. AGENT_PROVIDER_{PROJECT} (e.g., AGENT_PROVIDER_SOCIAL=codex)
- * 3. AGENT_PROVIDER (global default)
- * 4. 'claude' (fallback)
+ * Resolution order (highest → lowest):
+ * 1. Issue label override (provider:codex)
+ * 2. Mention context override ("use codex", "@codex")
+ * 3. Config providers.byWorkType
+ * 4. Config providers.byProject
+ * 5. Env var AGENT_PROVIDER_{WORKTYPE}
+ * 6. Env var AGENT_PROVIDER_{PROJECT}
+ * 7. Config providers.default
+ * 8. Env var AGENT_PROVIDER
+ * 9. Hardcoded 'claude'
  *
- * @param options - Project and work type context for resolution
- * @returns The resolved provider name
+ * @param context - Full resolution context (backwards-compatible with old { project, workType } shape)
+ * @returns The resolved provider name and its source
  */
-export function resolveProviderName(options) {
-    // Check work-type-specific override
-    if (options?.workType) {
-        const workTypeKey = `AGENT_PROVIDER_${options.workType.toUpperCase().replace(/-/g, '_')}`;
+export function resolveProviderWithSource(context) {
+    // 1. Issue label override
+    if (context?.labels?.length) {
+        const fromLabel = extractProviderFromLabels(context.labels);
+        if (fromLabel) {
+            return { name: fromLabel, source: `label provider:${fromLabel}` };
+        }
+    }
+    // 2. Mention context override
+    if (context?.mentionContext) {
+        const fromMention = extractProviderFromMention(context.mentionContext);
+        if (fromMention) {
+            return { name: fromMention, source: `mention "${context.mentionContext.substring(0, 30)}"` };
+        }
+    }
+    // 3. Config byWorkType
+    if (context?.workType && context?.configProviders?.byWorkType) {
+        const configWorkType = context.configProviders.byWorkType[context.workType];
+        if (configWorkType && isValidProviderName(configWorkType)) {
+            return { name: configWorkType, source: `config providers.byWorkType.${context.workType}` };
+        }
+    }
+    // 4. Config byProject
+    if (context?.project && context?.configProviders?.byProject) {
+        const configProject = context.configProviders.byProject[context.project];
+        if (configProject && isValidProviderName(configProject)) {
+            return { name: configProject, source: `config providers.byProject.${context.project}` };
+        }
+    }
+    // 5. Env var AGENT_PROVIDER_{WORKTYPE}
+    if (context?.workType) {
+        const workTypeKey = `AGENT_PROVIDER_${context.workType.toUpperCase().replace(/-/g, '_')}`;
         const workTypeProvider = process.env[workTypeKey];
         if (workTypeProvider && isValidProviderName(workTypeProvider)) {
-            return workTypeProvider;
+            return { name: workTypeProvider, source: `env ${workTypeKey}` };
         }
     }
-    // Check project-specific override
-    if (options?.project) {
-        const projectKey = `AGENT_PROVIDER_${options.project.toUpperCase()}`;
+    // 6. Env var AGENT_PROVIDER_{PROJECT}
+    if (context?.project) {
+        const projectKey = `AGENT_PROVIDER_${context.project.toUpperCase()}`;
         const projectProvider = process.env[projectKey];
         if (projectProvider && isValidProviderName(projectProvider)) {
-            return projectProvider;
+            return { name: projectProvider, source: `env ${projectKey}` };
         }
     }
-    // Check global default
+    // 7. Config providers.default
+    if (context?.configProviders?.default && isValidProviderName(context.configProviders.default)) {
+        return { name: context.configProviders.default, source: 'config providers.default' };
+    }
+    // 8. Env var AGENT_PROVIDER
     const globalProvider = process.env.AGENT_PROVIDER;
     if (globalProvider && isValidProviderName(globalProvider)) {
-        return globalProvider;
+        return { name: globalProvider, source: 'env AGENT_PROVIDER' };
     }
-    // Fallback
-    return 'claude';
+    // 9. Hardcoded fallback
+    return { name: 'claude', source: 'default' };
 }
+/**
+ * Resolve which provider to use based on context.
+ * Backwards-compatible wrapper around resolveProviderWithSource().
+ *
+ * @param options - Project and work type context for resolution
+ * @returns The resolved provider name
+ */
+export function resolveProviderName(options) {
+    return resolveProviderWithSource(options).name;
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
 const VALID_PROVIDER_NAMES = ['claude', 'codex', 'amp', 'spring-ai', 'a2a'];
-function isValidProviderName(name) {
+export function isValidProviderName(name) {
     return VALID_PROVIDER_NAMES.includes(name);
 }
+/** Resolve an alias to a canonical provider name, or return the input if not an alias. */
+function resolveAlias(name) {
+    const lower = name.toLowerCase();
+    return PROVIDER_ALIASES[lower] ?? lower;
+}

package/dist/src/providers/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/src/providers/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/providers/index.test.ts"],"names":[],"mappings":""}

package/dist/src/providers/index.test.js

@@ -0,0 +1,225 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { resolveProviderName, resolveProviderWithSource, extractProviderFromLabels, extractProviderFromMention, PROVIDER_ALIASES, isValidProviderName, } from './index.js';
+describe('extractProviderFromLabels', () => {
+    it('extracts provider from "provider:<name>" label', () => {
+        expect(extractProviderFromLabels(['Bug', 'provider:codex', 'Feature'])).toBe('codex');
+    });
+    it('returns null when no provider label present', () => {
+        expect(extractProviderFromLabels(['Bug', 'Feature'])).toBeNull();
+    });
+    it('resolves aliases in labels', () => {
+        expect(extractProviderFromLabels(['provider:opus'])).toBe('claude');
+        expect(extractProviderFromLabels(['provider:sonnet'])).toBe('claude');
+        expect(extractProviderFromLabels(['provider:gemini'])).toBe('a2a');
+    });
+    it('is case-insensitive', () => {
+        expect(extractProviderFromLabels(['Provider:Codex'])).toBe('codex');
+        expect(extractProviderFromLabels(['PROVIDER:AMP'])).toBe('amp');
+    });
+    it('ignores invalid provider names', () => {
+        expect(extractProviderFromLabels(['provider:invalid'])).toBeNull();
+    });
+    it('returns first match when multiple provider labels exist', () => {
+        expect(extractProviderFromLabels(['provider:codex', 'provider:amp'])).toBe('codex');
+    });
+    it('handles empty array', () => {
+        expect(extractProviderFromLabels([])).toBeNull();
+    });
+});
+describe('extractProviderFromMention', () => {
+    it('matches "use <provider>" pattern', () => {
+        expect(extractProviderFromMention('please use codex for this')).toBe('codex');
+    });
+    it('matches "@<provider>" pattern', () => {
+        expect(extractProviderFromMention('@codex handle this')).toBe('codex');
+    });
+    it('matches "provider:<provider>" pattern', () => {
+        expect(extractProviderFromMention('run with provider:amp')).toBe('amp');
+    });
+    it('resolves aliases in mentions', () => {
+        expect(extractProviderFromMention('use opus')).toBe('claude');
+        expect(extractProviderFromMention('@sonnet')).toBe('claude');
+        expect(extractProviderFromMention('provider:gemini')).toBe('a2a');
+    });
+    it('is case-insensitive', () => {
+        expect(extractProviderFromMention('use Codex')).toBe('codex');
+        expect(extractProviderFromMention('USE AMP')).toBe('amp');
+    });
+    it('returns null for invalid provider names', () => {
+        expect(extractProviderFromMention('use invalid')).toBeNull();
+    });
+    it('returns null when no pattern matches', () => {
+        expect(extractProviderFromMention('fix the bug in login')).toBeNull();
+    });
+    it('handles empty string', () => {
+        expect(extractProviderFromMention('')).toBeNull();
+    });
+});
+describe('resolveProviderWithSource — full cascade', () => {
+    const envBackup = {};
+    beforeEach(() => {
+        // Save and clear relevant env vars
+        for (const key of ['AGENT_PROVIDER', 'AGENT_PROVIDER_QA', 'AGENT_PROVIDER_DEVELOPMENT', 'AGENT_PROVIDER_SOCIAL', 'AGENT_PROVIDER_AGENT']) {
+            envBackup[key] = process.env[key];
+            delete process.env[key];
+        }
+    });
+    afterEach(() => {
+        // Restore env vars
+        for (const [key, value] of Object.entries(envBackup)) {
+            if (value === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = value;
+            }
+        }
+    });
+    it('defaults to claude when no context provided', () => {
+        const result = resolveProviderWithSource();
+        expect(result).toEqual({ name: 'claude', source: 'default' });
+    });
+    it('1. label overrides everything', () => {
+        process.env.AGENT_PROVIDER = 'amp';
+        process.env.AGENT_PROVIDER_QA = 'amp';
+        const result = resolveProviderWithSource({
+            labels: ['provider:codex'],
+            mentionContext: 'use amp',
+            workType: 'qa',
+            project: 'Social',
+            configProviders: {
+                default: 'amp',
+                byWorkType: { qa: 'amp' },
+                byProject: { Social: 'amp' },
+            },
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toContain('label');
+    });
+    it('2. mention overrides config and env', () => {
+        process.env.AGENT_PROVIDER = 'amp';
+        const result = resolveProviderWithSource({
+            mentionContext: 'use codex',
+            workType: 'qa',
+            configProviders: { byWorkType: { qa: 'amp' } },
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toContain('mention');
+    });
+    it('3. config byWorkType overrides env and config defaults', () => {
+        process.env.AGENT_PROVIDER_QA = 'amp';
+        const result = resolveProviderWithSource({
+            workType: 'qa',
+            configProviders: { byWorkType: { qa: 'codex' }, default: 'amp' },
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toContain('config providers.byWorkType.qa');
+    });
+    it('4. config byProject overrides env vars', () => {
+        process.env.AGENT_PROVIDER_SOCIAL = 'amp';
+        const result = resolveProviderWithSource({
+            project: 'Social',
+            configProviders: { byProject: { Social: 'codex' } },
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toContain('config providers.byProject.Social');
+    });
+    it('5. env AGENT_PROVIDER_{WORKTYPE} overrides env project and defaults', () => {
+        process.env.AGENT_PROVIDER_QA = 'codex';
+        process.env.AGENT_PROVIDER_SOCIAL = 'amp';
+        process.env.AGENT_PROVIDER = 'amp';
+        const result = resolveProviderWithSource({
+            workType: 'qa',
+            project: 'Social',
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toBe('env AGENT_PROVIDER_QA');
+    });
+    it('6. env AGENT_PROVIDER_{PROJECT} overrides global default', () => {
+        process.env.AGENT_PROVIDER_SOCIAL = 'codex';
+        process.env.AGENT_PROVIDER = 'amp';
+        const result = resolveProviderWithSource({
+            project: 'Social',
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toBe('env AGENT_PROVIDER_SOCIAL');
+    });
+    it('7. config providers.default overrides env AGENT_PROVIDER', () => {
+        process.env.AGENT_PROVIDER = 'amp';
+        const result = resolveProviderWithSource({
+            configProviders: { default: 'codex' },
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toBe('config providers.default');
+    });
+    it('8. env AGENT_PROVIDER overrides hardcoded default', () => {
+        process.env.AGENT_PROVIDER = 'codex';
+        const result = resolveProviderWithSource();
+        expect(result.name).toBe('codex');
+        expect(result.source).toBe('env AGENT_PROVIDER');
+    });
+    it('normalizes work type with hyphens to env var format', () => {
+        process.env.AGENT_PROVIDER_QA_COORDINATION = 'codex';
+        const result = resolveProviderWithSource({ workType: 'qa-coordination' });
+        expect(result.name).toBe('codex');
+        expect(result.source).toBe('env AGENT_PROVIDER_QA_COORDINATION');
+        delete process.env.AGENT_PROVIDER_QA_COORDINATION;
+    });
+});
+describe('resolveProviderName — backwards compatibility', () => {
+    const envBackup = {};
+    beforeEach(() => {
+        for (const key of ['AGENT_PROVIDER', 'AGENT_PROVIDER_QA', 'AGENT_PROVIDER_SOCIAL']) {
+            envBackup[key] = process.env[key];
+            delete process.env[key];
+        }
+    });
+    afterEach(() => {
+        for (const [key, value] of Object.entries(envBackup)) {
+            if (value === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = value;
+            }
+        }
+    });
+    it('returns claude by default', () => {
+        expect(resolveProviderName()).toBe('claude');
+    });
+    it('respects old { project, workType } shape', () => {
+        process.env.AGENT_PROVIDER_QA = 'codex';
+        expect(resolveProviderName({ workType: 'qa' })).toBe('codex');
+    });
+    it('accepts new ProviderResolutionContext shape', () => {
+        expect(resolveProviderName({ labels: ['provider:codex'] })).toBe('codex');
+    });
+});
+describe('PROVIDER_ALIASES', () => {
+    it('maps opus to claude', () => {
+        expect(PROVIDER_ALIASES['opus']).toBe('claude');
+    });
+    it('maps sonnet to claude', () => {
+        expect(PROVIDER_ALIASES['sonnet']).toBe('claude');
+    });
+    it('maps gemini to a2a', () => {
+        expect(PROVIDER_ALIASES['gemini']).toBe('a2a');
+    });
+    it('maps codex to codex', () => {
+        expect(PROVIDER_ALIASES['codex']).toBe('codex');
+    });
+});
+describe('isValidProviderName', () => {
+    it('accepts valid provider names', () => {
+        expect(isValidProviderName('claude')).toBe(true);
+        expect(isValidProviderName('codex')).toBe(true);
+        expect(isValidProviderName('amp')).toBe(true);
+        expect(isValidProviderName('spring-ai')).toBe(true);
+        expect(isValidProviderName('a2a')).toBe(true);
+    });
+    it('rejects invalid names', () => {
+        expect(isValidProviderName('invalid')).toBe(false);
+        expect(isValidProviderName('')).toBe(false);
+        expect(isValidProviderName('opus')).toBe(false); // alias, not a provider name
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@renseiai/agentfactory",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "type": "module",
   "description": "Multi-agent fleet management for coding agents — orchestrator, providers, crash recovery",
   "author": "Rensei AI (https://rensei.ai)",
@@ -50,13 +50,13 @@
     "handlebars": "^4.7.8",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
-    "@renseiai/agentfactory-linear": "0.8.3"
+    "@renseiai/agentfactory-linear": "0.8.4"
   },
   "devDependencies": {
     "@types/node": "^22.5.4",
     "typescript": "^5.7.3",
     "vitest": "^3.2.3",
-    "@renseiai/create-agentfactory-app": "0.8.3"
+    "@renseiai/create-agentfactory-app": "0.8.4"
   },
   "scripts": {
     "build": "tsc",