devchain-cli 0.7.2 → 0.8.0

package/dist/server/modules/projects/services/projects.service.js

@@ -117,13 +117,26 @@ let ProjectsService = class ProjectsService {
     }
     async createFromTemplate(input) {
         logger.info({ input }, 'createFromTemplate');
-        const templateResult = await this.unifiedTemplateService.getTemplate(input.slug, input.version ?? undefined);
+        let templateResult;
+        let templateSlug;
+        if (input.templatePath) {
+            templateResult = this.unifiedTemplateService.getTemplateFromFilePath(input.templatePath);
+            const manifest = templateResult.content._manifest;
+            templateSlug = manifest?.slug ?? this.deriveSlugFromPath(input.templatePath);
+        }
+        else if (input.slug) {
+            templateResult = await this.unifiedTemplateService.getTemplate(input.slug, input.version ?? undefined);
+            templateSlug = input.slug;
+        }
+        else {
+            throw new error_types_1.ValidationError('Either slug or templatePath is required', {});
+        }
         let payload;
         try {
             payload = shared_1.ExportSchema.parse(templateResult.content);
         }
         catch (error) {
-            logger.error({ error, slug: input.slug, version: input.version }, 'Invalid template format');
+            logger.error({ error, slug: templateSlug, version: input.version }, 'Invalid template format');
             throw new error_types_1.ValidationError('Invalid template format', {
                 hint: 'Template file does not match expected export schema',
             });
@@ -199,6 +212,81 @@ let ProjectsService = class ProjectsService {
             isTemplate: false,
         }, templatePayload);
         const { agentNameToId: agentNameToNewId, profileNameToId: profileNameToNewId } = this.buildNameToIdMaps(templatePayload, result.mappings);
+        const configLookupMap = new Map();
+        for (const prof of selectedProfilesByFamily.profilesToCreate) {
+            if (!prof.id)
+                continue;
+            const newProfileId = result.mappings.profileIdMap[prof.id];
+            if (!newProfileId)
+                continue;
+            const providerConfigs = prof.providerConfigs;
+            if (providerConfigs && providerConfigs.length > 0) {
+                for (const config of providerConfigs) {
+                    const configProviderId = available.get(config.providerName.trim().toLowerCase());
+                    if (!configProviderId) {
+                        logger.warn({ profileName: prof.name, providerName: config.providerName }, 'Provider not found for config in createFromTemplate, skipping');
+                        continue;
+                    }
+                    const createdConfig = await this.storage.createProfileProviderConfig({
+                        profileId: newProfileId,
+                        providerId: configProviderId,
+                        name: config.name,
+                        options: config.options ?? null,
+                        env: config.env ?? null,
+                    });
+                    const lookupKey = `${newProfileId}:${config.name.trim().toLowerCase()}`;
+                    configLookupMap.set(lookupKey, createdConfig.id);
+                }
+            }
+        }
+        const profilesWithProviderConfigs = new Map();
+        for (const prof of selectedProfilesByFamily.profilesToCreate) {
+            if (!prof.id)
+                continue;
+            const newProfileId = result.mappings.profileIdMap[prof.id];
+            if (!newProfileId)
+                continue;
+            const providerConfigs = prof.providerConfigs;
+            if (providerConfigs && providerConfigs.length > 0) {
+                profilesWithProviderConfigs.set(newProfileId, {
+                    profileName: prof.name,
+                    configNames: new Set(providerConfigs.map((pc) => pc.name.trim().toLowerCase())),
+                });
+            }
+        }
+        for (const a of payload.agents) {
+            const agentWithConfig = a;
+            if (!agentWithConfig.providerConfigName || !a.id)
+                continue;
+            const newAgentId = result.mappings.agentIdMap[a.id];
+            if (!newAgentId)
+                continue;
+            const remappedProfileId = selectedProfilesByFamily.agentProfileMap.get(a.id) ?? a.profileId;
+            const newProfileId = remappedProfileId
+                ? result.mappings.profileIdMap[remappedProfileId]
+                : null;
+            if (!newProfileId)
+                continue;
+            const lookupKey = `${newProfileId}:${agentWithConfig.providerConfigName.trim().toLowerCase()}`;
+            const providerConfigId = configLookupMap.get(lookupKey);
+            if (providerConfigId) {
+                await this.storage.updateAgent(newAgentId, { providerConfigId });
+                logger.debug({ agentName: a.name, providerConfigId }, 'Updated agent with providerConfigId');
+            }
+            else {
+                logger.warn({ agentName: a.name, providerConfigName: agentWithConfig.providerConfigName }, 'Provider config not found for agent in createFromTemplate');
+            }
+        }
+        for (const [newProfileId, { profileName, configNames }] of profilesWithProviderConfigs) {
+            const existingConfigs = await this.storage.listProfileProviderConfigsByProfile(newProfileId);
+            for (const existingConfig of existingConfigs) {
+                const isFromProviderConfigs = configNames.has(existingConfig.name.trim().toLowerCase());
+                if (!isFromProviderConfigs && existingConfig.name === profileName) {
+                    await this.storage.deleteProfileProviderConfig(existingConfig.id);
+                    logger.debug({ profileName, configId: existingConfig.id }, 'Deleted duplicate config created by storage layer');
+                }
+            }
+        }
         let mergedInitialPromptTitle;
         if (payload.initialPrompt?.title) {
             mergedInitialPromptTitle = payload.initialPrompt.title;
@@ -246,7 +334,7 @@ let ProjectsService = class ProjectsService {
         const installedVersion = templateResult.version ?? manifestVersion;
         const registryConfig = this.settings.getRegistryConfig();
         await this.settings.setProjectTemplateMetadata(result.project.id, {
-            templateSlug: input.slug,
+            templateSlug,
             source: templateResult.source,
             installedVersion,
             registryUrl: templateResult.source === 'registry' ? registryConfig.url : null,
@@ -254,10 +342,29 @@ let ProjectsService = class ProjectsService {
         });
         logger.info({
             projectId: result.project.id,
-            slug: input.slug,
+            slug: templateSlug,
             source: templateResult.source,
             version: installedVersion,
         }, 'Template metadata set for project');
+        const rawPresets = payload.presets;
+        const templatePresets = Array.isArray(rawPresets) ? rawPresets : [];
+        if (templatePresets.length > 0) {
+            await this.settings.setProjectPresets(result.project.id, templatePresets);
+            logger.info({ projectId: result.project.id, presetCount: templatePresets.length }, 'Presets stored for project');
+        }
+        if (input.presetName) {
+            const selectedPreset = templatePresets.find((p) => typeof p === 'object' && p !== null && 'name' in p && p.name === input.presetName);
+            if (!selectedPreset) {
+                logger.warn({ projectId: result.project.id, presetName: input.presetName }, 'Selected preset not found in template');
+            }
+            else {
+                await this.applyPreset(result.project.id, input.presetName, {
+                    agentNameToId: agentNameToNewId,
+                    configLookupMap,
+                });
+                logger.info({ projectId: result.project.id, presetName: input.presetName }, 'Applied preset to project');
+            }
+        }
         return {
             success: true,
             project: result.project,
@@ -273,7 +380,7 @@ let ProjectsService = class ProjectsService {
     }
     async exportProject(projectId, opts) {
         logger.info({ projectId }, 'exportProject');
-        const { manifestOverrides } = opts ?? {};
+        const { manifestOverrides, presets: presetsOverride } = opts ?? {};
         const [project, promptsRes, profilesRes, agentsRes, statusesRes, initialPrompt, settings, watchersRes, subscribersRes,] = await Promise.all([
             this.storage.getProject(projectId),
             this.storage.listPrompts({ projectId, limit: 1000, offset: 0 }),
@@ -326,11 +433,6 @@ let ProjectsService = class ProjectsService {
             }
             return value;
         };
-        const sanitizeOptionsString = (options) => {
-            if (!options)
-                return null;
-            return options;
-        };
         const fullPrompts = await Promise.all(promptsRes.items.map((p) => this.storage.getPrompt(p.id)));
         const prompts = fullPrompts.map((p) => ({
             id: p.id,
@@ -339,25 +441,66 @@ let ProjectsService = class ProjectsService {
             version: p.version,
             tags: p.tags,
         }));
-        const profiles = await Promise.all(profilesRes.items.map(async (prof) => {
-            const provider = await this.storage.getProvider(prof.providerId);
+        const configIdToInfo = new Map();
+        const profileIds = profilesRes.items.map((p) => p.id);
+        const allConfigsByProfile = new Map();
+        await Promise.all(profileIds.map(async (profileId) => {
+            const configs = await this.storage.listProfileProviderConfigsByProfile(profileId);
+            allConfigsByProfile.set(profileId, configs);
+        }));
+        const allProviderIds = new Set();
+        for (const configs of allConfigsByProfile.values()) {
+            for (const config of configs) {
+                allProviderIds.add(config.providerId);
+            }
+        }
+        const providersArray = await this.storage.listProvidersByIds([...allProviderIds]);
+        const providersMap = new Map(providersArray.map((p) => [p.id, p]));
+        const profiles = profilesRes.items.map((prof) => {
+            const configs = allConfigsByProfile.get(prof.id) || [];
+            let primaryProvider = null;
+            const providerConfigs = configs.map((config) => {
+                const configProvider = providersMap.get(config.providerId);
+                if (!primaryProvider && configProvider) {
+                    primaryProvider = { id: configProvider.id, name: configProvider.name };
+                }
+                const configName = config.name;
+                configIdToInfo.set(config.id, { name: configName, profileId: prof.id });
+                return {
+                    name: configName,
+                    providerName: configProvider?.name || 'unknown',
+                    options: config.options,
+                    env: config.env,
+                    position: config.position,
+                };
+            });
             return {
                 id: prof.id,
                 name: prof.name,
-                provider: { id: provider.id, name: provider.name },
+                provider: primaryProvider,
                 familySlug: prof.familySlug,
-                options: sanitizeOptionsString(prof.options),
                 instructions: prof.instructions,
                 temperature: prof.temperature,
                 maxTokens: prof.maxTokens,
+                ...(providerConfigs.length > 0 && { providerConfigs }),
             };
-        }));
-        const agents = agentsRes.items.map((a) => ({
-            id: a.id,
-            name: a.name,
-            profileId: a.profileId,
-            description: a.description,
-        }));
+        });
+        const agents = agentsRes.items.map((a) => {
+            let providerConfigName = null;
+            if (a.providerConfigId) {
+                const configInfo = configIdToInfo.get(a.providerConfigId);
+                if (configInfo) {
+                    providerConfigName = configInfo.name;
+                }
+            }
+            return {
+                id: a.id,
+                name: a.name,
+                profileId: a.profileId,
+                description: a.description,
+                ...(providerConfigName && { providerConfigName }),
+            };
+        });
         const statuses = statusesRes.items.map((s) => ({
             id: s.id,
             label: s.label,
@@ -467,9 +610,114 @@ let ProjectsService = class ProjectsService {
             ...(Object.keys(projectSettings).length > 0 && { projectSettings }),
             watchers,
             subscribers,
+            ...(presetsOverride !== undefined
+                ? { presets: presetsOverride }
+                : this.settings.getProjectPresets(projectId).length > 0
+                    ? { presets: this.settings.getProjectPresets(projectId) }
+                    : {}),
         };
         return exportPayload;
     }
+    async doesProjectMatchPreset(projectId, preset) {
+        const agentsRes = await this.storage.listAgents(projectId, { limit: 1000, offset: 0 });
+        const agentsByName = new Map(agentsRes.items.map((a) => [a.name.toLowerCase(), a]));
+        const uniqueProviderConfigIds = new Set();
+        for (const agent of agentsRes.items) {
+            if (agent.providerConfigId) {
+                uniqueProviderConfigIds.add(agent.providerConfigId);
+            }
+        }
+        const allProviderConfigs = uniqueProviderConfigIds.size > 0
+            ? await this.storage.listProfileProviderConfigsByIds(Array.from(uniqueProviderConfigIds))
+            : [];
+        const providerConfigNames = new Map(allProviderConfigs.map((c) => [c.id, c.name]));
+        for (const agentConfig of preset.agentConfigs) {
+            const agentNameLower = agentConfig.agentName.trim().toLowerCase();
+            const providerConfigNameLower = agentConfig.providerConfigName.trim().toLowerCase();
+            const agent = agentsByName.get(agentNameLower);
+            if (!agent) {
+                return false;
+            }
+            const currentProviderConfigName = providerConfigNames.get(agent.providerConfigId ?? '');
+            if (currentProviderConfigName?.toLowerCase() !== providerConfigNameLower) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async applyPreset(projectId, presetName, nameMaps) {
+        logger.info({ projectId, presetName }, 'applyPreset');
+        const warnings = [];
+        const presets = this.settings.getProjectPresets(projectId);
+        const selectedPreset = presets.find((p) => p.name === presetName);
+        if (!selectedPreset) {
+            throw new error_types_1.NotFoundError('Preset', presetName);
+        }
+        if (!selectedPreset.agentConfigs || !Array.isArray(selectedPreset.agentConfigs)) {
+            throw new error_types_1.ValidationError(`Preset "${presetName}" has invalid or missing agentConfigs`, {
+                presetName,
+            });
+        }
+        const agentsRes = await this.storage.listAgents(projectId, { limit: 1000, offset: 0 });
+        let agentNameToId;
+        if (nameMaps?.agentNameToId) {
+            agentNameToId = nameMaps.agentNameToId;
+        }
+        else {
+            agentNameToId = new Map();
+            for (const agent of agentsRes.items) {
+                agentNameToId.set(agent.name.toLowerCase(), agent.id);
+            }
+        }
+        let configLookupMap;
+        if (nameMaps?.configLookupMap) {
+            configLookupMap = nameMaps.configLookupMap;
+        }
+        else {
+            configLookupMap = new Map();
+            const profilesRes = await this.storage.listAgentProfiles({
+                projectId,
+                limit: 1000,
+                offset: 0,
+            });
+            for (const profile of profilesRes.items) {
+                const configs = await this.storage.listProfileProviderConfigsByProfile(profile.id);
+                for (const config of configs) {
+                    const lookupKey = `${profile.id}:${config.name.trim().toLowerCase()}`;
+                    configLookupMap.set(lookupKey, config.id);
+                }
+            }
+        }
+        let applied = 0;
+        const agentsById = new Map(agentsRes.items.map((a) => [a.id, a]));
+        for (const agentConfig of selectedPreset.agentConfigs) {
+            const agentId = agentNameToId.get(agentConfig.agentName.trim().toLowerCase());
+            if (!agentId) {
+                warnings.push(`Agent "${agentConfig.agentName}" not found in project`);
+                continue;
+            }
+            const agent = agentsById.get(agentId);
+            if (!agent)
+                continue;
+            const profileId = agent.profileId;
+            const lookupKey = `${profileId}:${agentConfig.providerConfigName.trim().toLowerCase()}`;
+            const providerConfigId = configLookupMap.get(lookupKey);
+            if (!providerConfigId) {
+                warnings.push(`Provider config "${agentConfig.providerConfigName}" not found for agent "${agentConfig.agentName}"`);
+                continue;
+            }
+            await this.storage.updateAgent(agentId, { providerConfigId });
+            applied++;
+            logger.debug({ projectId, agentId, agentName: agentConfig.agentName, providerConfigId }, 'Applied preset: updated agent provider config');
+        }
+        const fullMatch = warnings.length === 0 && applied === selectedPreset.agentConfigs.length;
+        if (fullMatch) {
+            await this.settings.setProjectActivePreset(projectId, presetName);
+            logger.info({ projectId, presetName }, 'Active preset set (full match)');
+        }
+        logger.info({ projectId, presetName, applied, warnings: warnings.length }, 'Preset applied');
+        return { applied, warnings };
+    }
     async importProject(input) {
         logger.info({ projectId: input.projectId, dryRun: input.dryRun }, 'importProject');
         const isDryRun = input.dryRun ?? false;
@@ -668,16 +916,10 @@ let ProjectsService = class ProjectsService {
                 createdPrompts.push({ id: created.id, title: created.title });
             }
             for (const prof of selectedProfilesByFamily.profilesToCreate) {
-                const providerId = available.get(prof.provider.name.trim().toLowerCase());
-                if (!providerId) {
-                    throw new error_types_1.NotFoundError('Provider', prof.provider.name);
-                }
                 const created = await this.storage.createAgentProfile({
                     projectId: input.projectId,
                     name: prof.name,
-                    providerId,
                     familySlug: prof.familySlug ?? null,
-                    options: this.normalizeProfileOptions(prof.options),
                     systemPrompt: null,
                     instructions: prof.instructions ?? null,
                     temperature: prof.temperature ?? null,
@@ -686,6 +928,55 @@ let ProjectsService = class ProjectsService {
                 const profKey = prof.id || `name:${prof.name.trim().toLowerCase()}`;
                 profileIdMap[profKey] = created.id;
             }
+            const configLookupMap = new Map();
+            const configIdMap = {};
+            for (const prof of selectedProfilesByFamily.profilesToCreate) {
+                const profKey = prof.id || `name:${prof.name.trim().toLowerCase()}`;
+                const newProfileId = profileIdMap[profKey];
+                if (!newProfileId)
+                    continue;
+                const providerConfigs = prof.providerConfigs;
+                if (providerConfigs && providerConfigs.length > 0) {
+                    for (const config of providerConfigs) {
+                        const configProviderId = available.get(config.providerName.trim().toLowerCase());
+                        if (!configProviderId) {
+                            logger.warn({ profileName: prof.name, providerName: config.providerName }, 'Provider not found for config, skipping');
+                            continue;
+                        }
+                        const createdConfig = await this.storage.createProfileProviderConfig({
+                            profileId: newProfileId,
+                            providerId: configProviderId,
+                            name: config.name,
+                            options: config.options ?? null,
+                            env: config.env ?? null,
+                        });
+                        const lookupKey = `${newProfileId}:${config.name.trim().toLowerCase()}`;
+                        configLookupMap.set(lookupKey, createdConfig.id);
+                        configIdMap[`${profKey}:${config.name}`] = createdConfig.id;
+                    }
+                }
+                else {
+                    const providerName = prof.provider.name.trim().toLowerCase();
+                    const configProviderId = available.get(providerName);
+                    if (configProviderId) {
+                        const options = prof.options != null
+                            ? typeof prof.options === 'string'
+                                ? prof.options
+                                : JSON.stringify(prof.options)
+                            : null;
+                        const createdConfig = await this.storage.createProfileProviderConfig({
+                            profileId: newProfileId,
+                            providerId: configProviderId,
+                            name: 'default',
+                            options,
+                            env: null,
+                        });
+                        const lookupKey = `${newProfileId}:default`;
+                        configLookupMap.set(lookupKey, createdConfig.id);
+                        configIdMap[`${profKey}:default`] = createdConfig.id;
+                    }
+                }
+            }
             for (const a of payload.agents) {
                 const remappedProfileId = selectedProfilesByFamily.agentProfileMap.get(a.id ?? '');
                 const oldProfileId = remappedProfileId ?? a.profileId ?? '';
@@ -695,11 +986,33 @@ let ProjectsService = class ProjectsService {
                         profileId: oldProfileId || null,
                     });
                 }
+                let providerConfigId;
+                const agentWithConfig = a;
+                if (agentWithConfig.providerConfigName && newProfileId) {
+                    const lookupKey = `${newProfileId}:${agentWithConfig.providerConfigName.trim().toLowerCase()}`;
+                    providerConfigId = configLookupMap.get(lookupKey);
+                }
+                if (!providerConfigId && newProfileId) {
+                    const profilePrefix = `${newProfileId}:`;
+                    for (const [key, configId] of configLookupMap.entries()) {
+                        if (key.startsWith(profilePrefix)) {
+                            providerConfigId = configId;
+                            break;
+                        }
+                    }
+                }
+                if (!providerConfigId) {
+                    throw new error_types_1.ValidationError(`No provider config available for agent ${a.name}`, {
+                        profileId: newProfileId,
+                        providerConfigName: agentWithConfig.providerConfigName || null,
+                    });
+                }
                 const created = await this.storage.createAgent({
                     projectId: input.projectId,
                     name: a.name,
                     profileId: newProfileId,
                     description: a.description ?? null,
+                    providerConfigId,
                 });
                 const agentKey = a.id || `name:${a.name.trim().toLowerCase()}`;
                 agentIdMap[agentKey] = created.id;
@@ -796,6 +1109,16 @@ let ProjectsService = class ProjectsService {
                 });
                 logger.info({ projectId: input.projectId, slug: payload._manifest.slug, source: templateSource }, 'Updated template metadata after import');
             }
+            const rawPresets = payload.presets;
+            const templatePresets = Array.isArray(rawPresets) ? rawPresets : [];
+            if (templatePresets.length > 0) {
+                await this.settings.setProjectPresets(input.projectId, templatePresets);
+                logger.info({ projectId: input.projectId, presetCount: templatePresets.length }, 'Presets replaced from template during import');
+            }
+            else {
+                await this.settings.clearProjectPresets(input.projectId);
+                logger.info({ projectId: input.projectId }, 'Presets cleared during import (template has none)');
+            }
             return {
                 success: true,
                 mode: 'replace',
@@ -1261,6 +1584,11 @@ let ProjectsService = class ProjectsService {
             .replace(/[^a-z0-9]+/g, '-')
             .replace(/(^-|-$)/g, '');
     }
+    deriveSlugFromPath(filePath) {
+        const filename = (0, path_1.basename)(filePath);
+        const nameWithoutExt = filename.replace(/\.json$/i, '');
+        return this.slugify(nameWithoutExt);
+    }
     async getTemplateManifestForProject(projectId) {
         const metadata = this.settings.getProjectTemplateMetadata(projectId);
         if (!metadata?.templateSlug) {
@@ -1268,6 +1596,10 @@ let ProjectsService = class ProjectsService {
             return null;
         }
         try {
+            if (metadata.source === 'file') {
+                logger.debug({ projectId, templateSlug: metadata.templateSlug }, 'File-based template - no manifest available');
+                return null;
+            }
             if (metadata.source === 'bundled') {
                 const template = this.unifiedTemplateService.getBundledTemplate(metadata.templateSlug);
                 return template.content._manifest ?? null;