@stripchatdev/create-stripchat-extension 0.1.46 → 0.1.48

package/dist/src/{helpers/detectPackageManager.test.js → projectConfig/detectPackageManagerRuntime.test.js}

@@ -1,6 +1,6 @@
 /* eslint-disable camelcase */
 import { afterEach, describe, expect, it } from 'vitest';
-import { detectPackageManager } from './detectPackageManager.js';
+import { detectPackageManagerRuntime } from './detectPackageManagerRuntime.js';
 describe('detectPackageManager', () => {
     const originalEnv = process.env.npm_config_user_agent;
     afterEach(() => {
@@ -13,41 +13,41 @@ describe('detectPackageManager', () => {
         // @ts-expect-error -- simulating Bun runtime
         globalThis.Bun = {};
         process.env.npm_config_user_agent = 'pnpm/9.0.0';
-        expect(detectPackageManager()).toBe('bun');
+        expect(detectPackageManagerRuntime()).toBe('bun');
     });
     it('returns bun when user agent contains bun', () => {
         process.env.npm_config_user_agent = 'bun/1.2.0 node/v22.12.0';
-        expect(detectPackageManager()).toBe('bun');
+        expect(detectPackageManagerRuntime()).toBe('bun');
     });
     it('returns pnpm when user agent contains pnpm', () => {
         process.env.npm_config_user_agent = 'pnpm/9.0.0 node/v22.12.0';
-        expect(detectPackageManager()).toBe('pnpm');
+        expect(detectPackageManagerRuntime()).toBe('pnpm');
     });
     it('returns yarn when user agent contains yarn', () => {
         process.env.npm_config_user_agent = 'yarn/4.1.0 node/v22.12.0';
-        expect(detectPackageManager()).toBe('yarn');
+        expect(detectPackageManagerRuntime()).toBe('yarn');
     });
     it('returns npm when user agent contains npm', () => {
         process.env.npm_config_user_agent = 'npm/10.9.0 node/v22.12.0';
-        expect(detectPackageManager()).toBe('npm');
+        expect(detectPackageManagerRuntime()).toBe('npm');
     });
     it('returns npm when user agent is undefined', () => {
         delete process.env.npm_config_user_agent;
-        expect(detectPackageManager()).toBe('npm');
+        expect(detectPackageManagerRuntime()).toBe('npm');
     });
     it('prioritises bun over user agent', () => {
         // @ts-expect-error -- simulating Bun runtime
         globalThis.Bun = {};
         process.env.npm_config_user_agent = 'yarn/4.1.0';
-        expect(detectPackageManager()).toBe('bun');
+        expect(detectPackageManagerRuntime()).toBe('bun');
     });
     it('prioritises pnpm over yarn in user agent', () => {
         process.env.npm_config_user_agent = 'pnpm/9.0.0 yarn/4.1.0';
-        expect(detectPackageManager()).toBe('pnpm');
+        expect(detectPackageManagerRuntime()).toBe('pnpm');
     });
     it('returns bun when process.versions.bun is set', () => {
         process.versions.bun = '1.0.0';
         process.env.npm_config_user_agent = 'yarn/4.1.0';
-        expect(detectPackageManager()).toBe('bun');
+        expect(detectPackageManagerRuntime()).toBe('bun');
     });
 });

package/dist/src/projectConfig/recoverProjectConfig.d.ts

@@ -0,0 +1 @@
+export declare const recoverProjectConfig: (projectDir: string) => import("../types.js").TProjectConfig;

package/dist/src/projectConfig/recoverProjectConfig.js

@@ -0,0 +1,34 @@
+import { CLI_COMMANDS_MAP, EXT_HELPER_VERSION } from '../constants.js';
+import { AppError } from '../helpers/error.js';
+import { INIT_TEMPLATE_VERSION, MANAGED_TEMPLATES } from '../templates/constants.js';
+import { TEMPLATES_DIR } from '../templates/templates.js';
+import { buildProjectConfig } from './buildProjectConfig.js';
+import { detectPackageManagerRuntime } from './detectPackageManagerRuntime.js';
+import { detectPackageManagerFromFiles } from './recovery/detectPackageManagerFromFiles.js';
+import { parseAgentsMd } from './recovery/parseAgentsMd.js';
+import { resolveProjectNameFromDir } from './recovery/resolveProjectNameFromDir.js';
+export const recoverProjectConfig = (projectDir) => {
+    const lastTemplateVersion = INIT_TEMPLATE_VERSION; // suppose version is 1 when we did not have a project config file in our template
+    const name = resolveProjectNameFromDir(projectDir);
+    const { category, framework, language, slots } = parseAgentsMd(projectDir, lastTemplateVersion);
+    let packageManager = detectPackageManagerFromFiles(projectDir);
+    if (!packageManager) {
+        packageManager = detectPackageManagerRuntime();
+    }
+    if (!category || !framework || !language || !slots) {
+        throw new AppError('Unable to recover project config, some information is missing');
+    }
+    return buildProjectConfig({
+        name,
+        category,
+        slots,
+        language,
+        framework,
+        packageManager,
+        extHelperVersion: EXT_HELPER_VERSION,
+        lastTemplateVersion,
+        cliCommands: CLI_COMMANDS_MAP,
+        managedTemplates: MANAGED_TEMPLATES,
+        templatesDir: TEMPLATES_DIR,
+    });
+};

package/dist/src/projectConfig/recovery/detectPackageManagerFromFiles.d.ts

@@ -0,0 +1,2 @@
+import type { TPackageManager } from '../../types.js';
+export declare const detectPackageManagerFromFiles: (projectDir: string) => TPackageManager | null;

package/dist/src/projectConfig/recovery/detectPackageManagerFromFiles.js

@@ -0,0 +1,16 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { PACKAGE_MANAGER_LOCK_FILE_MAP } from '../../constants.js';
+import { getIsValidPackageManager } from '../../validators/getIsValidPackageManager.js';
+export const detectPackageManagerFromFiles = (projectDir) => {
+    for (const packageManager in PACKAGE_MANAGER_LOCK_FILE_MAP) {
+        if (!getIsValidPackageManager(packageManager)) {
+            continue;
+        }
+        const lockFile = PACKAGE_MANAGER_LOCK_FILE_MAP[packageManager];
+        if (lockFile && existsSync(join(projectDir, lockFile))) {
+            return packageManager;
+        }
+    }
+    return null;
+};

package/dist/src/projectConfig/recovery/detectPackageManagerFromFiles.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/projectConfig/recovery/detectPackageManagerFromFiles.test.js

@@ -0,0 +1,37 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, it, expect } from 'vitest';
+import { PACKAGE_MANAGER_LOCK_FILE_MAP } from '../../constants.js';
+import { detectPackageManagerFromFiles } from './detectPackageManagerFromFiles.js';
+const createDirWithLockfile = (packageLockRelPath) => {
+    const projectDir = mkdtempSync(join(tmpdir(), 'sce-detectPackageManagerFromFiles-'));
+    writeFileSync(join(projectDir, packageLockRelPath), '', {
+        encoding: 'utf8',
+    });
+    return projectDir;
+};
+describe('detectPackageManagerFromFiles', () => {
+    it('return value from valid lock', () => {
+        const packageManager = 'npm';
+        const packageLockFileName = PACKAGE_MANAGER_LOCK_FILE_MAP[packageManager];
+        const projectDir = createDirWithLockfile(packageLockFileName);
+        try {
+            const result = detectPackageManagerFromFiles(projectDir);
+            expect(result).toBe(packageManager);
+        }
+        finally {
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+    it('return null is no known lock file', () => {
+        const projectDir = createDirWithLockfile('some.lock');
+        try {
+            const result = detectPackageManagerFromFiles(projectDir);
+            expect(result).toBe(null);
+        }
+        finally {
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/src/projectConfig/recovery/parseAgentsMd.d.ts

@@ -0,0 +1,10 @@
+import type { TCategory, TFramework, TLanguage, TSlot } from '../../types.js';
+type TParseAgentsMdResult = {
+    category?: TCategory;
+    framework?: TFramework;
+    language?: TLanguage;
+    slots: TSlot[];
+};
+export declare const parseAgentsMdV1: (projectDir: string) => TParseAgentsMdResult;
+export declare const parseAgentsMd: (projectDir: string, templateVersion: number) => TParseAgentsMdResult;
+export {};

package/dist/src/projectConfig/recovery/parseAgentsMd.js

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { AGENTS_MD_REL_PATH } from '../../constants.js';
+import { AppError } from '../../helpers/error.js';
+import { getIsValidCategory } from '../../validators/getIsValidCategory.js';
+import { getIsValidFramework } from '../../validators/getIsValidFramework.js';
+import { getIsValidLanguage } from '../../validators/getIsValidLanguage.js';
+import { getIsValidSlot } from '../../validators/getIsValidSlot.js';
+export const parseAgentsMdV1 = (projectDir) => {
+    const result = {
+        slots: [],
+    };
+    const agentsMdPath = join(projectDir, AGENTS_MD_REL_PATH);
+    if (!existsSync(agentsMdPath)) {
+        throw new AppError(`Agents.md not found, can not recover project config: ${agentsMdPath}`);
+    }
+    const content = readFileSync(agentsMdPath, 'utf8');
+    const languageMatch = content.match(/-\sLanguage: (.+)/);
+    const frameworkMatch = content.match(/-\sFramework: (.+)/);
+    const categoryMatch = content.match(/-\sCategory: (.+)/);
+    const slotsMatch = content.match(/-\sSlots: (.+)/);
+    const languageRaw = languageMatch?.[1] || '';
+    const frameworkRaw = frameworkMatch?.[1] || '';
+    const categoryRaw = categoryMatch?.[1] || '';
+    const slotsRaw = slotsMatch?.[1] || '';
+    if (getIsValidLanguage(languageRaw)) {
+        result.language = languageRaw;
+    }
+    if (getIsValidFramework(frameworkRaw)) {
+        result.framework = frameworkRaw;
+    }
+    if (getIsValidCategory(categoryRaw)) {
+        result.category = categoryRaw;
+    }
+    const slots = new Set();
+    const slotsRawParts = slotsRaw.split(', ');
+    slotsRawParts.forEach((slot) => {
+        if (getIsValidSlot(slot)) {
+            slots.add(slot);
+        }
+    });
+    result.slots = Array.from(slots);
+    return result;
+};
+export const parseAgentsMd = (projectDir, templateVersion) => {
+    switch (templateVersion) {
+        case 1:
+            return parseAgentsMdV1(projectDir);
+        default:
+            throw new AppError('Failed to parse agents md file, version is not supported');
+    }
+};

package/dist/src/projectConfig/recovery/parseAgentsMd.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/projectConfig/recovery/parseAgentsMd.test.js

@@ -0,0 +1,67 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, it, expect } from 'vitest';
+import { CLI_COMMANDS_MAP, EXT_HELPER_VERSION } from '../../constants.js';
+import { executeCommands } from '../../templater/executor.js';
+import { mapProjectConfigToTemplateData } from '../../templater/mappers/mapProjectConfigToTemplateModel.js';
+import { planProject } from '../../templater/planner.js';
+import { MANAGED_TEMPLATES } from '../../templates/constants.js';
+import { LAST_TEMPLATE_VERSION, TEMPLATES_DIR } from '../../templates/templates.js';
+import { buildProjectConfig } from '../buildProjectConfig.js';
+import { parseAgentsMd } from './parseAgentsMd.js';
+const testProjectConfig = buildProjectConfig({
+    category: 'games-and-fun',
+    framework: 'preact',
+    lastTemplateVersion: LAST_TEMPLATE_VERSION,
+    cliCommands: CLI_COMMANDS_MAP,
+    managedTemplates: MANAGED_TEMPLATES,
+    templatesDir: TEMPLATES_DIR,
+    name: 'test',
+    slots: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
+    extHelperVersion: EXT_HELPER_VERSION,
+    language: 'ts',
+    packageManager: 'npm',
+});
+describe('parseAgentsMd', () => {
+    it('throw error if agents md is not 1 version', () => {
+        expect(() => parseAgentsMd('/some-project-dir', 2)).toThrow();
+    });
+    it('throw error in agents md is not found', () => {
+        expect(() => parseAgentsMd('/some-project-dir', 1)).toThrow();
+    });
+    it('correct parse all data', () => {
+        const projectDir = mkdtempSync(join(tmpdir(), 'sce-parse-agents-md-'));
+        try {
+            const templateVersion = 1;
+            const templateData = mapProjectConfigToTemplateData(testProjectConfig);
+            const commands = planProject(projectDir, templateVersion, templateData);
+            executeCommands(commands);
+            const result = parseAgentsMd(projectDir, templateVersion);
+            expect(result).toEqual({
+                category: templateData.config.category,
+                framework: templateData.config.framework,
+                language: templateData.config.language,
+                slots: templateData.config.slots,
+            });
+        }
+        finally {
+            rmSync(projectDir, { force: true, recursive: true });
+        }
+    });
+    it('return empty values for non parsed values', () => {
+        const projectDir = mkdtempSync(join(tmpdir(), 'sce-parse-agents-md-'));
+        try {
+            writeFileSync(join(projectDir, 'AGENTS.md'), 'some invalid content', {
+                encoding: 'utf8',
+            });
+            const result = parseAgentsMd(projectDir, 1);
+            expect(result).toEqual({
+                slots: [],
+            });
+        }
+        finally {
+            rmSync(projectDir, { force: true, recursive: true });
+        }
+    });
+});

package/dist/src/projectConfig/recovery/resolveProjectNameFromDir.d.ts

@@ -0,0 +1 @@
+export declare const resolveProjectNameFromDir: (projectDir: string) => string;

package/dist/src/projectConfig/recovery/resolveProjectNameFromDir.js

@@ -0,0 +1,11 @@
+import { basename } from 'node:path';
+import { AppError } from '../../helpers/error.js';
+import { validateName } from '../../validators/validateName.js';
+export const resolveProjectNameFromDir = (projectDir) => {
+    const name = basename(projectDir);
+    const result = validateName(name);
+    if (result === true) {
+        return name;
+    }
+    throw new AppError(`Unable to resolve valid project name: ${result}`);
+};

package/dist/src/projectConfig/recovery/resolveProjectNameFromDir.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/projectConfig/recovery/resolveProjectNameFromDir.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+import { AppError } from '../../helpers/error.js';
+import { resolveProjectNameFromDir } from './resolveProjectNameFromDir.js';
+describe('resolveProjectNameFromDir', () => {
+    it('returns valid project name from directory basename', () => {
+        expect(resolveProjectNameFromDir('/tmp/some-extension')).toBe('some-extension');
+    });
+    it('returns valid project name from directory basename with trailing slash', () => {
+        expect(resolveProjectNameFromDir('/tmp/some-extension/')).toBe('some-extension');
+    });
+    it('throws AppError when basename is not a valid project name', () => {
+        try {
+            resolveProjectNameFromDir('/tmp/Invalid Name With Spaces');
+            throw new Error('Expected resolveProjectNameFromDir to throw');
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(AppError);
+            expect(error.message).toMatch(/^Unable to resolve valid project name:/);
+        }
+    });
+});

package/dist/src/projectConfig/resolveExistsProjectConfig.d.ts

@@ -0,0 +1,2 @@
+import type { TProjectConfig } from '../types.js';
+export declare const resolveExistsProjectConfig: (projectDir: string) => TProjectConfig;

package/dist/src/projectConfig/resolveExistsProjectConfig.js

@@ -0,0 +1,34 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { PROJECT_CONFIG_REL_PATH } from '../constants.js';
+import { AppError } from '../helpers/error.js';
+import { recoverProjectConfig } from './recoverProjectConfig.js';
+import { getIsValidProjectConfig } from './validators/getIsValidProjectConfig.js';
+import { validateProjectConfig } from './validators/validateProjectConfig.js';
+export const resolveExistsProjectConfig = (projectDir) => {
+    const projectConfigPath = join(projectDir, PROJECT_CONFIG_REL_PATH);
+    let projectConfig;
+    if (!existsSync(projectConfigPath)) {
+        projectConfig = recoverProjectConfig(projectDir);
+    }
+    else {
+        const contentRaw = readFileSync(projectConfigPath, 'utf8');
+        if (!contentRaw) {
+            throw new AppError(`Project config is empty: ${projectConfigPath}`);
+        }
+        try {
+            projectConfig = JSON.parse(contentRaw);
+        }
+        catch {
+            throw new AppError(`Failed to parse exists project config: ${projectConfigPath}`);
+        }
+    }
+    if (!getIsValidProjectConfig(projectConfig)) {
+        throw new AppError(`Project config is invalid: ${projectConfigPath}`);
+    }
+    const validationResult = validateProjectConfig(projectConfig);
+    if (validationResult !== true) {
+        throw new AppError(`Project config setup is invalid: ${validationResult}`);
+    }
+    return projectConfig;
+};

package/dist/src/projectConfig/updateProjectConfig.d.ts

@@ -0,0 +1,2 @@
+import type { TProjectConfig, TProjectConfigUserProps } from '../types.js';
+export declare const updateProjectConfig: (lastTemplateVersion: number, projectConfigUserProps: TProjectConfigUserProps) => TProjectConfig;

package/dist/src/projectConfig/updateProjectConfig.js

@@ -0,0 +1,20 @@
+import { CLI_COMMANDS_MAP, EXT_HELPER_VERSION } from '../constants.js';
+import { MANAGED_TEMPLATES } from '../templates/constants.js';
+import { TEMPLATES_DIR } from '../templates/templates.js';
+import { buildProjectConfig } from './buildProjectConfig.js';
+export const updateProjectConfig = (lastTemplateVersion, projectConfigUserProps) => {
+    const { category, framework, language, name, packageManager, slots } = projectConfigUserProps;
+    return buildProjectConfig({
+        name,
+        category,
+        language,
+        framework,
+        packageManager,
+        slots,
+        extHelperVersion: EXT_HELPER_VERSION,
+        lastTemplateVersion,
+        cliCommands: CLI_COMMANDS_MAP,
+        managedTemplates: MANAGED_TEMPLATES,
+        templatesDir: TEMPLATES_DIR,
+    });
+};

package/dist/src/projectConfig/validators/getIsValidProjectConfig.d.ts

@@ -0,0 +1,2 @@
+import type { TProjectConfig } from '../../types.js';
+export declare const getIsValidProjectConfig: (data: unknown) => data is TProjectConfig;

package/dist/src/projectConfig/validators/getIsValidProjectConfig.js

@@ -0,0 +1,6 @@
+export const getIsValidProjectConfig = (data) => {
+    if (!data) {
+        return false;
+    }
+    return typeof data === 'object';
+};

package/dist/src/projectConfig/validators/getIsValidProjectConfig.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/projectConfig/validators/getIsValidProjectConfig.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { CLI_COMMANDS_MAP } from '../../constants.js';
+import { resolveDependencies } from '../../dependencies/resolveDependencies.js';
+import { LAST_TEMPLATE_VERSION } from '../../templates/templates.js';
+import { getIsValidProjectConfig } from './getIsValidProjectConfig.js';
+describe('isValidProjectConfig', () => {
+    const language = 'ts';
+    const framework = 'preact';
+    const { dependencies, devDependencies } = resolveDependencies(language, framework);
+    const baseConfig = {
+        cliCommands: CLI_COMMANDS_MAP,
+        name: 'project-name',
+        packageManager: 'npm',
+        framework,
+        language,
+        category: 'chat-bots',
+        dependencies,
+        devDependencies,
+        extHelperVersion: '0.0.0-test',
+        slots: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
+        managedFiles: [],
+        lastTemplateVersion: LAST_TEMPLATE_VERSION,
+    };
+    it('return true if config project is valid', () => {
+        expect(getIsValidProjectConfig(baseConfig)).toBe(true);
+    });
+    it('return false for non object type', () => {
+        expect(getIsValidProjectConfig('')).toBe(false);
+    });
+    it('return false for null', () => {
+        expect(getIsValidProjectConfig(null)).toBe(false);
+    });
+});

package/dist/src/projectConfig/validators/validateProjectConfig.d.ts

@@ -0,0 +1,2 @@
+import type { TProjectConfig } from '../../types.js';
+export declare const validateProjectConfig: (projectConfig: TProjectConfig) => string | true;

package/dist/src/projectConfig/validators/validateProjectConfig.js

@@ -0,0 +1,30 @@
+import { getIsValidCategory } from '../../validators/getIsValidCategory.js';
+import { getIsValidFramework } from '../../validators/getIsValidFramework.js';
+import { getIsValidLanguage } from '../../validators/getIsValidLanguage.js';
+import { getIsValidPackageManager } from '../../validators/getIsValidPackageManager.js';
+import { validateName } from '../../validators/validateName.js';
+import { validateSlots } from '../../validators/validateSlots.js';
+export const validateProjectConfig = (projectConfig) => {
+    const { category, framework, language, name, packageManager, slots } = projectConfig;
+    const validateNameResult = validateName(name);
+    if (validateNameResult !== true) {
+        return validateNameResult;
+    }
+    if (!getIsValidFramework(framework)) {
+        return `Framework is invalid: ${framework}`;
+    }
+    if (!getIsValidLanguage(language)) {
+        return `Language is invalid: ${language}`;
+    }
+    if (!getIsValidCategory(category)) {
+        return `Category is invalid: ${category}`;
+    }
+    if (!getIsValidPackageManager(packageManager)) {
+        return 'Invalid package manager';
+    }
+    const validateSlotsResult = validateSlots(slots, category);
+    if (validateSlotsResult.invalid.length > 0 || validateSlotsResult.violations.length > 0) {
+        return `Invalid slots ${slots.join(', ')} for category: ${category}`;
+    }
+    return true;
+};

package/dist/src/projectConfig/validators/validateProjectConfig.test.d.ts

@@ -0,0 +1 @@
+export {};