@oamm/textor 1.0.2 → 1.0.4

package/dist/index.cjs

@@ -9,8 +9,10 @@ var util = require('util');
 
 const CONFIG_DIR$1 = '.textor';
 const CONFIG_FILE = 'config.json';
+const CURRENT_CONFIG_VERSION = 2;
 /**
  * @typedef {Object} TextorConfig
+ * @property {number} configVersion
  * @property {Object} paths
  * @property {string} paths.pages
  * @property {string} paths.features
@@ -47,6 +49,9 @@ const CONFIG_FILE = 'config.json';
  * @property {boolean} components.createTypes
  * @property {Object} formatting
  * @property {string} formatting.tool
+ * @property {Object} filePatterns
+ * @property {Object} filePatterns.features
+ * @property {Object} filePatterns.components
  * @property {Object} git
  * @property {boolean} git.requireCleanRepo
  * @property {boolean} git.stageChanges
@@ -58,6 +63,7 @@ const CONFIG_FILE = 'config.json';
  * @type {TextorConfig}
  */
 const DEFAULT_CONFIG = {
+    configVersion: CURRENT_CONFIG_VERSION,
     paths: {
         pages: 'src/pages',
         features: 'src/features',
@@ -117,6 +123,34 @@ const DEFAULT_CONFIG = {
     formatting: {
         tool: 'none' // 'prettier' | 'biome' | 'none'
     },
+    filePatterns: {
+        features: {
+            index: 'index.ts',
+            types: 'index.ts',
+            api: 'index.ts',
+            services: 'index.ts',
+            schemas: 'index.ts',
+            hook: '{{hookName}}{{hookExtension}}',
+            context: '{{componentName}}Context.tsx',
+            test: '{{componentName}}{{testExtension}}',
+            readme: 'README.md',
+            stories: '{{componentName}}.stories.tsx'
+        },
+        components: {
+            index: 'index.ts',
+            types: 'index.ts',
+            api: 'index.ts',
+            services: 'index.ts',
+            schemas: 'index.ts',
+            hook: '{{hookName}}{{hookExtension}}',
+            context: '{{componentName}}Context.tsx',
+            test: '{{componentName}}{{testExtension}}',
+            config: 'index.ts',
+            constants: 'index.ts',
+            readme: 'README.md',
+            stories: '{{componentName}}.stories.tsx'
+        }
+    },
     hashing: {
         normalization: 'normalizeEOL', // 'none' | 'normalizeEOL' | 'stripGeneratedRegions'
         useMarkers: false
@@ -218,7 +252,7 @@ async function loadConfig() {
     try {
         const content = await promises.readFile(configPath, 'utf-8');
         const config = JSON.parse(content);
-        const merged = deepMerge(DEFAULT_CONFIG, config);
+        const merged = mergeConfig(DEFAULT_CONFIG, config);
         validateConfig(merged);
         return merged;
     }
@@ -250,6 +284,34 @@ async function saveConfig(config, force = false) {
     await promises.writeFile(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
     return configPath;
 }
+function mergeConfig(defaults, config) {
+    return deepMerge(defaults, config);
+}
+function normalizeConfigVersion(config) {
+    if (!config || typeof config !== 'object')
+        return config;
+    if (typeof config.configVersion !== 'number') {
+        return { ...config, configVersion: 1 };
+    }
+    return config;
+}
+function applyConfigMigrations(config) {
+    let current = normalizeConfigVersion(config);
+    let version = current.configVersion || 1;
+    let migrated = { ...current };
+    while (version < CURRENT_CONFIG_VERSION) {
+        if (version === 1) {
+            migrated = { ...migrated, configVersion: 2 };
+            version = 2;
+            continue;
+        }
+        break;
+    }
+    if (migrated.configVersion !== CURRENT_CONFIG_VERSION) {
+        migrated.configVersion = CURRENT_CONFIG_VERSION;
+    }
+    return migrated;
+}
 /**
  * Deeply merges source object into target object.
  * @param {Object} target
@@ -279,6 +341,9 @@ function validateConfig(config) {
     if (!config || typeof config !== 'object') {
         throw new Error('Invalid configuration: must be an object');
     }
+    if (config.configVersion !== undefined && typeof config.configVersion !== 'number') {
+        throw new Error('Invalid configuration: "configVersion" must be a number');
+    }
     const requiredSections = ['paths', 'naming', 'signatures', 'importAliases'];
     for (const section of requiredSections) {
         if (!config[section] || typeof config[section] !== 'object') {
@@ -288,6 +353,15 @@ function validateConfig(config) {
     if (config.kindRules && !Array.isArray(config.kindRules)) {
         throw new Error('Invalid configuration: "kindRules" must be an array');
     }
+    if (config.filePatterns && typeof config.filePatterns !== 'object') {
+        throw new Error('Invalid configuration: "filePatterns" must be an object');
+    }
+    if (config.filePatterns?.features && typeof config.filePatterns.features !== 'object') {
+        throw new Error('Invalid configuration: "filePatterns.features" must be an object');
+    }
+    if (config.filePatterns?.components && typeof config.filePatterns.components !== 'object') {
+        throw new Error('Invalid configuration: "filePatterns.components" must be an object');
+    }
     // Validate paths are strings
     for (const [key, value] of Object.entries(config.paths)) {
         if (typeof value !== 'string') {
@@ -799,6 +873,33 @@ var filesystem = /*#__PURE__*/Object.freeze({
     writeFileWithSignature: writeFileWithSignature
 });
 
+function renderNamePattern(pattern, data = {}, label = 'pattern') {
+    if (typeof pattern !== 'string')
+        return null;
+    const trimmed = pattern.trim();
+    if (!trimmed)
+        return null;
+    const missing = new Set();
+    const rendered = trimmed.replace(/{{\s*([a-zA-Z0-9_]+)\s*}}/g, (match, key) => {
+        if (!Object.prototype.hasOwnProperty.call(data, key)) {
+            missing.add(key);
+            return '';
+        }
+        return String(data[key]);
+    });
+    if (missing.size > 0) {
+        throw new Error(`Invalid ${label}: missing values for ${Array.from(missing).join(', ')}`);
+    }
+    return rendered;
+}
+function resolvePatternedPath(baseDir, pattern, data, fallback, label) {
+    const fileName = renderNamePattern(pattern, data, label) || fallback;
+    if (!fileName) {
+        throw new Error(`Invalid ${label}: resolved to empty file name`);
+    }
+    return secureJoin(baseDir, fileName);
+}
+
 function getTemplateOverride(templateName, extension, data = {}) {
     const overridePath = path.join(process.cwd(), '.textor', 'templates', `${templateName}${extension}`);
     if (fs.existsSync(overridePath)) {
@@ -1190,6 +1291,7 @@ async function loadState() {
         const state = JSON.parse(content);
         if (!state.files)
             state.files = {};
+        normalizeStatePaths(state);
         return state;
     }
     catch (error) {
@@ -1230,23 +1332,67 @@ async function registerFile(filePath, { kind, template, hash, templateVersion =
 }
 async function addSectionToState(section) {
     const state = await loadState();
+    const normalizedSection = { ...section };
+    if (normalizedSection.featurePath) {
+        normalizedSection.featurePath = normalizeStatePath(normalizedSection.featurePath);
+    }
     // Avoid duplicates by route OR by featurePath if route is null
-    if (section.route) {
-        state.sections = state.sections.filter(s => s.route !== section.route);
+    if (normalizedSection.route) {
+        state.sections = state.sections.filter(s => s.route !== normalizedSection.route);
     }
     else {
-        state.sections = state.sections.filter(s => s.featurePath !== section.featurePath || s.route);
+        state.sections = state.sections.filter(s => s.featurePath !== normalizedSection.featurePath || s.route);
     }
-    state.sections.push(section);
+    state.sections.push(normalizedSection);
     await saveState(state);
 }
 async function addComponentToState(component) {
     const state = await loadState();
+    const normalizedComponent = { ...component };
+    if (normalizedComponent.path) {
+        normalizedComponent.path = normalizeStatePath(normalizedComponent.path);
+    }
     // Avoid duplicates by name
-    state.components = state.components.filter(c => c.name !== component.name);
-    state.components.push(component);
+    state.components = state.components.filter(c => c.name !== normalizedComponent.name);
+    state.components.push(normalizedComponent);
     await saveState(state);
 }
+function normalizeStatePath(filePath) {
+    if (!filePath || typeof filePath !== 'string')
+        return filePath;
+    const relative = path.isAbsolute(filePath)
+        ? path.relative(process.cwd(), filePath)
+        : filePath;
+    return relative.replace(/\\/g, '/');
+}
+function normalizeStatePaths(state) {
+    if (!state || typeof state !== 'object')
+        return;
+    if (Array.isArray(state.sections)) {
+        state.sections = state.sections.map(section => {
+            if (!section || typeof section !== 'object')
+                return section;
+            if (!section.featurePath)
+                return section;
+            const normalized = normalizeStatePath(section.featurePath);
+            if (normalized === section.featurePath)
+                return section;
+            return { ...section, featurePath: normalized };
+        });
+    }
+    if (Array.isArray(state.components)) {
+        state.components = state.components.map(component => {
+            if (!component || typeof component !== 'object')
+                return component;
+            if (!component.path)
+                return component;
+            const normalized = normalizeStatePath(component.path);
+            if (normalized === component.path)
+                return component;
+            return { ...component, path: normalized };
+        });
+    }
+}
 function findSection(state, identifier) {
     return state.sections.find(s => s.route === identifier || s.name === identifier || s.featurePath === identifier);
 }
@@ -1407,16 +1553,25 @@ async function addSectionCommand(route, featurePath, options) {
         const servicesDirInside = secureJoin(featureDirPath, 'services');
         const schemasDirInside = secureJoin(featureDirPath, 'schemas');
         const { framework, createSubComponentsDir: shouldCreateSubComponentsDir, createScriptsDir: shouldCreateScriptsDir, createApi: shouldCreateApi, createServices: shouldCreateServices, createSchemas: shouldCreateSchemas, createHooks: shouldCreateHooks, createContext: shouldCreateContext, createTests: shouldCreateTests, createTypes: shouldCreateTypes, createReadme: shouldCreateReadme, createStories: shouldCreateStories, createIndex: shouldCreateIndex } = effectiveOptions;
-        const indexFilePath = path.join(featureDirPath, 'index.ts');
-        const contextFilePath = path.join(contextDirInside, `${featureComponentName}Context.tsx`);
-        const hookFilePath = path.join(hooksDirInside, getHookFileName(featureComponentName, config.naming.hookExtension));
-        const testFilePath = path.join(testsDir, `${featureComponentName}${config.naming.testExtension}`);
-        const typesFilePath = path.join(typesDirInside, 'index.ts');
-        const apiFilePath = path.join(apiDirInside, 'index.ts');
-        const servicesFilePath = path.join(servicesDirInside, 'index.ts');
-        const schemasFilePath = path.join(schemasDirInside, 'index.ts');
-        const readmeFilePath = path.join(featureDirPath, 'README.md');
-        const storiesFilePath = path.join(featureDirPath, `${featureComponentName}.stories.tsx`);
+        const featurePatterns = config.filePatterns?.features || {};
+        const patternData = {
+            componentName: featureComponentName,
+            hookName: getHookFunctionName(featureComponentName),
+            hookExtension: config.naming.hookExtension,
+            testExtension: config.naming.testExtension,
+            featureExtension: config.naming.featureExtension,
+            componentExtension: config.naming.componentExtension
+        };
+        const indexFilePath = resolvePatternedPath(featureDirPath, featurePatterns.index, patternData, 'index.ts', 'filePatterns.features.index');
+        const contextFilePath = resolvePatternedPath(contextDirInside, featurePatterns.context, patternData, `${featureComponentName}Context.tsx`, 'filePatterns.features.context');
+        const hookFilePath = resolvePatternedPath(hooksDirInside, featurePatterns.hook, patternData, getHookFileName(featureComponentName, config.naming.hookExtension), 'filePatterns.features.hook');
+        const testFilePath = resolvePatternedPath(testsDir, featurePatterns.test, patternData, `${featureComponentName}${config.naming.testExtension}`, 'filePatterns.features.test');
+        const typesFilePath = resolvePatternedPath(typesDirInside, featurePatterns.types, patternData, 'index.ts', 'filePatterns.features.types');
+        const apiFilePath = resolvePatternedPath(apiDirInside, featurePatterns.api, patternData, 'index.ts', 'filePatterns.features.api');
+        const servicesFilePath = resolvePatternedPath(servicesDirInside, featurePatterns.services, patternData, 'index.ts', 'filePatterns.features.services');
+        const schemasFilePath = resolvePatternedPath(schemasDirInside, featurePatterns.schemas, patternData, 'index.ts', 'filePatterns.features.schemas');
+        const readmeFilePath = resolvePatternedPath(featureDirPath, featurePatterns.readme, patternData, 'README.md', 'filePatterns.features.readme');
+        const storiesFilePath = resolvePatternedPath(featureDirPath, featurePatterns.stories, patternData, `${featureComponentName}.stories.tsx`, 'filePatterns.features.stories');
         const routeParts = normalizedRoute ? normalizedRoute.split('/').filter(Boolean) : [];
         const reorganizations = [];
         if (normalizedRoute && routeParts.length > 1 && config.routing.mode === 'flat') {
@@ -2304,19 +2459,28 @@ async function createComponentCommand(componentName, options) {
         const servicesDirInside = secureJoin(componentDir, 'services');
         const schemasDirInside = secureJoin(componentDir, 'schemas');
         const { framework, createContext: shouldCreateContext, createHook: shouldCreateHook, createTests: shouldCreateTests, createConfig: shouldCreateConfig, createConstants: shouldCreateConstants, createTypes: shouldCreateTypes, createSubComponentsDir: shouldCreateSubComponentsDir, createApi: shouldCreateApi, createServices: shouldCreateServices, createSchemas: shouldCreateSchemas, createReadme: shouldCreateReadme, createStories: shouldCreateStories } = effectiveOptions;
+        const componentPatterns = config.filePatterns?.components || {};
+        const patternData = {
+            componentName: normalizedName,
+            hookName: getHookFunctionName(normalizedName),
+            hookExtension: config.naming.hookExtension,
+            testExtension: config.naming.testExtension,
+            componentExtension: config.naming.componentExtension,
+            featureExtension: config.naming.featureExtension
+        };
         const componentFilePath = path.join(componentDir, `${normalizedName}${config.naming.componentExtension}`);
-        const indexFilePath = path.join(componentDir, 'index.ts');
-        const contextFilePath = path.join(contextDirInside, `${normalizedName}Context.tsx`);
-        const hookFilePath = path.join(hooksDirInside, getHookFileName(normalizedName, config.naming.hookExtension));
-        const testFilePath = path.join(testsDir, `${normalizedName}${config.naming.testExtension}`);
-        const configFilePath = path.join(configDirInside, 'index.ts');
-        const constantsFilePath = path.join(constantsDirInside, 'index.ts');
-        const typesFilePath = path.join(typesDirInside, 'index.ts');
-        const apiFilePath = path.join(apiDirInside, 'index.ts');
-        const servicesFilePath = path.join(servicesDirInside, 'index.ts');
-        const schemasFilePath = path.join(schemasDirInside, 'index.ts');
-        const readmeFilePath = path.join(componentDir, 'README.md');
-        const storiesFilePath = path.join(componentDir, `${normalizedName}.stories.tsx`);
+        const indexFilePath = resolvePatternedPath(componentDir, componentPatterns.index, patternData, 'index.ts', 'filePatterns.components.index');
+        const contextFilePath = resolvePatternedPath(contextDirInside, componentPatterns.context, patternData, `${normalizedName}Context.tsx`, 'filePatterns.components.context');
+        const hookFilePath = resolvePatternedPath(hooksDirInside, componentPatterns.hook, patternData, getHookFileName(normalizedName, config.naming.hookExtension), 'filePatterns.components.hook');
+        const testFilePath = resolvePatternedPath(testsDir, componentPatterns.test, patternData, `${normalizedName}${config.naming.testExtension}`, 'filePatterns.components.test');
+        const configFilePath = resolvePatternedPath(configDirInside, componentPatterns.config, patternData, 'index.ts', 'filePatterns.components.config');
+        const constantsFilePath = resolvePatternedPath(constantsDirInside, componentPatterns.constants, patternData, 'index.ts', 'filePatterns.components.constants');
+        const typesFilePath = resolvePatternedPath(typesDirInside, componentPatterns.types, patternData, 'index.ts', 'filePatterns.components.types');
+        const apiFilePath = resolvePatternedPath(apiDirInside, componentPatterns.api, patternData, 'index.ts', 'filePatterns.components.api');
+        const servicesFilePath = resolvePatternedPath(servicesDirInside, componentPatterns.services, patternData, 'index.ts', 'filePatterns.components.services');
+        const schemasFilePath = resolvePatternedPath(schemasDirInside, componentPatterns.schemas, patternData, 'index.ts', 'filePatterns.components.schemas');
+        const readmeFilePath = resolvePatternedPath(componentDir, componentPatterns.readme, patternData, 'README.md', 'filePatterns.components.readme');
+        const storiesFilePath = resolvePatternedPath(componentDir, componentPatterns.stories, patternData, `${normalizedName}.stories.tsx`, 'filePatterns.components.stories');
         if (options.dryRun) {
             console.log('Dry run - would create:');
             console.log(`  Component: ${componentFilePath}`);
@@ -2593,7 +2757,7 @@ async function removeComponentCommand(identifier, options) {
         const component = findComponent(state, identifier);
         let componentDir;
         if (component) {
-            componentDir = component.path;
+            componentDir = path.resolve(process.cwd(), component.path);
         }
         else {
             // Fallback: try to guess path if not in state
@@ -3220,15 +3384,74 @@ async function scanDirectoryOrFile(fullPath, fileSet, state) {
     }
 }
 
+async function upgradeConfigCommand(options) {
+    try {
+        const configPath = getConfigPath();
+        if (!fs.existsSync(configPath)) {
+            throw new Error(`Textor configuration not found at ${configPath}\n` +
+                `Run 'textor init' to create it.`);
+        }
+        const rawContent = await promises.readFile(configPath, 'utf-8');
+        const rawConfig = JSON.parse(rawContent);
+        const migrated = applyConfigMigrations(rawConfig);
+        const merged = mergeConfig(DEFAULT_CONFIG, migrated);
+        merged.configVersion = CURRENT_CONFIG_VERSION;
+        validateConfig(merged);
+        if (options.dryRun) {
+            console.log('Dry run - upgraded configuration:');
+            console.log(JSON.stringify(merged, null, 2));
+            return;
+        }
+        await promises.writeFile(configPath, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
+        console.log('Configuration upgraded successfully.');
+        console.log(`  Version: ${rawConfig.configVersion || 1} -> ${CURRENT_CONFIG_VERSION}`);
+        console.log(`  Path: ${configPath}`);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            console.error('Error: Failed to parse config: Invalid JSON');
+        }
+        else {
+            console.error('Error:', error.message);
+        }
+        if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+            process.exit(1);
+        }
+        throw error;
+    }
+}
+
+async function normalizeStateCommand(options) {
+    try {
+        const state = await loadState();
+        if (options.dryRun) {
+            console.log('Dry run - normalized state:');
+            console.log(JSON.stringify(state, null, 2));
+            return;
+        }
+        await saveState(state);
+        console.log('State normalized successfully.');
+    }
+    catch (error) {
+        console.error('Error:', error.message);
+        if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+            process.exit(1);
+        }
+        throw error;
+    }
+}
+
 exports.addSectionCommand = addSectionCommand;
 exports.adoptCommand = adoptCommand;
 exports.createComponentCommand = createComponentCommand;
 exports.initCommand = initCommand;
 exports.listSectionsCommand = listSectionsCommand;
 exports.moveSectionCommand = moveSectionCommand;
+exports.normalizeStateCommand = normalizeStateCommand;
 exports.removeComponentCommand = removeComponentCommand;
 exports.removeSectionCommand = removeSectionCommand;
 exports.statusCommand = statusCommand;
 exports.syncCommand = syncCommand;
+exports.upgradeConfigCommand = upgradeConfigCommand;
 exports.validateStateCommand = validateStateCommand;
 //# sourceMappingURL=index.cjs.map