@lumiflora/fsdk 0.1.4

package/dist/commands/sync-template.js

@@ -0,0 +1,94 @@
+import fs from 'fs-extra';
+import path from 'path';
+import fg from 'fast-glob';
+import { logger } from '../utils/index.js';
+import { templateEngine } from '../core/index.js';
+export async function syncTemplate(cwd, options = {}) {
+    try {
+        const template = options.template || 'base';
+        logger.info(`Syncing template ${template}...`);
+        const templatePath = path.resolve(cwd, '.fsdk', 'template');
+        const currentTemplatePath = path.resolve(templatePath, template);
+        if (!fs.existsSync(currentTemplatePath)) {
+            logger.warning(`Template ${template} not found in .fsdk/template`);
+            logger.info('Run "fsdk create" first to initialize a template');
+            return;
+        }
+        const srcDir = path.resolve(cwd, 'src');
+        if (!fs.existsSync(srcDir)) {
+            logger.error('src directory does not exist. Run "fsdk create" first.');
+            return;
+        }
+        const { modifiedFiles, addedFiles, removedFiles } = await compareTemplates(currentTemplatePath, srcDir);
+        if (modifiedFiles.length === 0 && addedFiles.length === 0 && removedFiles.length === 0) {
+            logger.success('Template is already up to date');
+            return;
+        }
+        if (options.force) {
+            await applyTemplateSync(currentTemplatePath, srcDir, { modifiedFiles, addedFiles, removedFiles });
+        }
+        else {
+            await interactiveSync(currentTemplatePath, srcDir, { modifiedFiles, addedFiles, removedFiles });
+        }
+        templateEngine.clearCache();
+        logger.success('Template sync completed');
+    }
+    catch (error) {
+        logger.error('Failed to sync template:', error);
+        throw error;
+    }
+}
+async function compareTemplates(templateDir, srcDir) {
+    const templateFiles = await fg.glob('**/*', { cwd: templateDir, dot: true, onlyFiles: true });
+    const srcFiles = await fg.glob('**/*', { cwd: srcDir, dot: true, onlyFiles: true });
+    const templateSet = new Set(templateFiles);
+    const srcSet = new Set(srcFiles);
+    const modifiedFiles = [];
+    const addedFiles = [];
+    const removedFiles = [];
+    for (const file of srcFiles) {
+        if (templateSet.has(file)) {
+            const templateContent = await fs.readFile(path.resolve(templateDir, file), 'utf-8');
+            const srcContent = await fs.readFile(path.resolve(srcDir, file), 'utf-8');
+            if (templateContent !== srcContent) {
+                modifiedFiles.push(file);
+            }
+        }
+        else {
+            addedFiles.push(file);
+        }
+    }
+    for (const file of templateFiles) {
+        if (!srcSet.has(file)) {
+            removedFiles.push(file);
+        }
+    }
+    return { modifiedFiles, addedFiles, removedFiles };
+}
+async function applyTemplateSync(templateDir, srcDir, changes) {
+    const { modifiedFiles, addedFiles, removedFiles } = changes;
+    for (const file of removedFiles) {
+        const filePath = path.resolve(srcDir, file);
+        await fs.remove(filePath);
+        logger.debug(`Removed: ${file}`);
+    }
+    for (const file of [...modifiedFiles, ...addedFiles]) {
+        await fs.copy(path.resolve(templateDir, file), path.resolve(srcDir, file));
+        logger.debug(`Copied: ${file}`);
+    }
+    logger.info(`Synced: ${modifiedFiles.length} modified, ${addedFiles.length} added, ${removedFiles.length} removed`);
+}
+async function interactiveSync(templateDir, srcDir, changes) {
+    const { modifiedFiles, addedFiles, removedFiles } = changes;
+    logger.info('Changes detected:');
+    if (modifiedFiles.length > 0) {
+        logger.info(`  Modified: ${modifiedFiles.length} files`);
+    }
+    if (addedFiles.length > 0) {
+        logger.info(`  Added: ${addedFiles.length} files`);
+    }
+    if (removedFiles.length > 0) {
+        logger.info(`  Removed: ${removedFiles.length} files`);
+    }
+    logger.warning('Use --force to apply all changes without confirmation');
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1,7 @@
+export interface ValidateOptions {
+    config?: boolean;
+    templates?: boolean;
+    strict?: boolean;
+}
+export declare function validate(cwd: string, options?: ValidateOptions): Promise<void>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/commands/validate.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAsB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6BxF"}

package/dist/commands/validate.js

@@ -0,0 +1,136 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { z } from 'zod';
+import fg from 'fast-glob';
+import { logger } from '../utils/index.js';
+import { FsdkConfigSchema } from '../core/index.js';
+export async function validate(cwd, options = {}) {
+    const errors = [];
+    const warnings = [];
+    try {
+        if (options.config || (!options.config && !options.templates)) {
+            await validateConfig(cwd, errors, warnings);
+        }
+        if (options.templates || (!options.config && !options.templates)) {
+            await validateTemplates(cwd, errors, warnings);
+        }
+        if (errors.length > 0) {
+            logger.error('Validation failed with errors:');
+            errors.forEach((e) => logger.error(`  - ${e}`));
+            process.exit(1);
+        }
+        if (warnings.length > 0) {
+            logger.warning('Validation passed with warnings:');
+            warnings.forEach((w) => logger.warning(`  - ${w}`));
+        }
+        else {
+            logger.success('All validations passed!');
+        }
+    }
+    catch (error) {
+        logger.error('Validation error:', error);
+        throw error;
+    }
+}
+async function validateConfig(cwd, errors, warnings) {
+    logger.info('Validating configuration...');
+    const configFiles = [
+        '.fsdkrc.ts',
+        '.fsdkrc.js',
+        '.fsdkrc.json',
+        '.fsdkrc',
+        'fsdk.config.ts',
+        'fsdk.config.js',
+        'fsdk.config.json',
+    ];
+    const foundConfig = configFiles.find((f) => fs.existsSync(path.resolve(cwd, f)));
+    if (!foundConfig) {
+        warnings.push('No .fsdkrc configuration file found, using defaults');
+        return;
+    }
+    try {
+        const configPath = path.resolve(cwd, foundConfig);
+        const ext = path.extname(foundConfig).toLowerCase();
+        let config;
+        if (ext === '.ts' || ext === '.js') {
+            const module = await import(configPath);
+            config = module.default || module;
+        }
+        else {
+            const content = await fs.readFile(configPath, 'utf-8');
+            config = JSON.parse(content);
+        }
+        const result = FsdkConfigSchema.safeParse(config);
+        if (!result.success) {
+            result.error.errors.forEach((e) => {
+                errors.push(`Config validation failed: ${e.path.join('.')} - ${e.message}`);
+            });
+        }
+        else {
+            logger.success(`Config file ${foundConfig} is valid`);
+        }
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            error.errors.forEach((e) => {
+                errors.push(`Config validation failed: ${e.path.join('.')} - ${e.message}`);
+            });
+        }
+        else {
+            errors.push(`Failed to parse config file: ${error}`);
+        }
+    }
+}
+async function validateTemplates(cwd, errors, warnings) {
+    logger.info('Validating templates...');
+    const templateDir = path.resolve(cwd, '.fsdk', 'template');
+    if (!fs.existsSync(templateDir)) {
+        warnings.push('No template directory found');
+        return;
+    }
+    const templateFiles = await fg.glob('**/*', { cwd: templateDir, dot: true, onlyFiles: true });
+    if (templateFiles.length === 0) {
+        warnings.push('Template directory is empty');
+        return;
+    }
+    const vueFiles = templateFiles.filter((f) => String(f).endsWith('.vue'));
+    const tsFiles = templateFiles.filter((f) => String(f).endsWith('.ts'));
+    const lessFiles = templateFiles.filter((f) => String(f).endsWith('.less'));
+    logger.debug(`Found ${vueFiles.length} Vue files, ${tsFiles.length} TS files, ${lessFiles.length} Less files`);
+    let valid = true;
+    for (const vueFile of vueFiles) {
+        const content = await fs.readFile(path.resolve(templateDir, vueFile), 'utf-8');
+        if (!validateVueFile(content)) {
+            errors.push(`Invalid Vue file: ${vueFile}`);
+            valid = false;
+        }
+    }
+    for (const tsFile of tsFiles) {
+        const content = await fs.readFile(path.resolve(templateDir, tsFile), 'utf-8');
+        if (!validateTsFile(content)) {
+            errors.push(`Invalid TypeScript file: ${tsFile}`);
+            valid = false;
+        }
+    }
+    if (valid) {
+        logger.success(`Template validation passed (${templateFiles.length} files)`);
+    }
+}
+function validateVueFile(content) {
+    const hasTemplate = content.includes('<template>');
+    const hasScript = content.includes('<script');
+    return hasTemplate || hasScript;
+}
+function validateTsFile(content) {
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*')) {
+            continue;
+        }
+        if (trimmed.includes(':') && !trimmed.match(/^\s*\/\//)) {
+            return true;
+        }
+    }
+    return content.includes('export') || content.includes('import');
+}

package/dist/completion/completion-scripts.d.ts

@@ -0,0 +1,4 @@
+export declare const BASH_COMPLETION = "#!/bin/bash\n# fsdk bash completion\n\n_fsdk_completion() {\n  local cur prev opts\n  COMPREPLY=()\n  cur=\"${COMP_WORDS[COMP_CWORD]}\"\n  prev=\"${COMP_WORDS[COMP_CWORD-1]}\"\n\n  opts=\"create add-page add-component add-store sync-template validate preview completion\"\n\n  case \"${prev}\" in\n    create)\n      opts=\"--template --package-manager --eslint --no-git --no-install\"\n      ;;\n    add-page)\n      opts=\"--router-path --page-name\"\n      ;;\n    add-component)\n      opts=\"--type --name --dir\"\n      ;;\n    add-store)\n      opts=\"--type --name\"\n      ;;\n    sync-template)\n      opts=\"--template --force\"\n      ;;\n    validate)\n      opts=\"--config --templates --strict\"\n      ;;\n    preview)\n      opts=\"--port --host --open --template\"\n      ;;\n    completion)\n      opts=\"bash zsh fish\"\n      ;;\n  esac\n\n  COMPREPLY=($(compgen -W \"${opts}\" -- \"${cur}\"))\n  return 0\n}\n\ncomplete -F _fsdk_completion fsdk\n";
+export declare const FISH_COMPLETION = "# fsdk fish completion\n\nfunction __fsdk_commands\n  echo \"create\tCreate a new application\"\n  echo \"add-page\t\tAdd a new page\"\n  echo \"add-component\tAdd a new component\"\n  echo \"add-store\tAdd a new store\"\n  echo \"sync-template\tSync template files\"\n  echo \"validate\t\tValidate configuration and templates\"\n  echo \"preview\t\tPreview template\"\n  echo \"completion\tGenerate shell completion script\"\nend\n\nfunction __fsdk_create_app_opts\n  echo \"--template\tTemplate name (base|full)\"\n  echo \"--package-manager\tPackage manager (npm|pnpm|yarn|bun)\"\n  echo \"--eslint\tEnable ESLint\"\n  echo \"--no-git\tSkip git initialization\"\n  echo \"--no-install\tSkip dependency installation\"\nend\n\nfunction __fsdk_add_page_opts\n  echo \"--router-path\tRouter path\"\n  echo \"--page-name\tPage name\"\nend\n\nfunction __fsdk_add_component_opts\n  echo \"--type\tComponent type (page|common|business)\"\n  echo \"--name\tComponent name\"\n  echo \"--dir\tSubdirectory\"\nend\n\nfunction __fsdk_add_store_opts\n  echo \"--type\tStore type (pinia|redux)\"\n  echo \"--name\tStore name\"\nend\n\nfunction __fsdk_sync_template_opts\n  echo \"--template\tTemplate name\"\n  echo \"--force\tForce sync\"\nend\n\nfunction __fsdk_validate_opts\n  echo \"--config\tValidate config only\"\n  echo \"--templates\tValidate templates only\"\n  echo \"--strict\tStrict validation\"\nend\n\nfunction __fsdk_preview_opts\n  echo \"--port\tPort number\"\n  echo \"--host\tHost address\"\n  echo \"--open\tOpen browser\"\n  echo \"--template\tTemplate name\"\nend\n\nfunction __fsdk_completion_opts\n  echo \"bash\tGenerate bash completion\"\n  echo \"zsh\tGenerate zsh completion\"\n  echo \"fish\tGenerate fish completion\"\nend\n\ncomplete -c fsdk -f -a \"(__fsdk_commands)\"\n\ncomplete -c fsdk -n \"not __fish_seen_subcommand_from create\" -a \"(__fsdk_create_app_opts)\" --option\ncomplete -c fsdk -n \"not __fish_seen_subcommand_from add-page\" -a \"(__fsdk_add_page_opts)\" --option\ncomplete -c fsdk -n \"not __fish_seen_subcommand_from add-component\" -a \"(__fsdk_add_component_opts)\" --option\ncomplete -c fsdk -n \"not __fish_seen_subcommand_from add-store\" -a \"(__fsdk_add_store_opts)\" --option\ncomplete -c fsdk -n \"not __fish_seen_subcommand_from sync-template\" -a \"(__fsdk_sync_template_opts)\" --option\ncomplete -c fsdk -n \"not __fish_seen_subcommand_from validate\" -a \"(__fsdk_validate_opts)\" --option\ncomplete -c fsdk -n \"not __fish_seen_subcommand_from preview\" -a \"(__fsdk_preview_opts)\" --option\ncomplete -c fsdk -n \"not __fish_seen_subcommand_from completion\" -a \"(__fsdk_completion_opts)\" --option\n";
+export declare const ZSH_COMPLETION = "#compdef fsdk\n\nlocal -a commands\ncommands=(\n  'create:Create a new application'\n  'add-page:Add a new page'\n  'add-component:Add a new component'\n  'add-store:Add a new store'\n  'sync-template:Sync template files'\n  'validate:Validate configuration and templates'\n  'preview:Preview template'\n  'completion:Generate shell completion script'\n)\n\n_arguments -C \\\n  '1: :->command' \\\n  '2: :->args' \\\n  '*: :->rest'\n\ncase \"$state\" in\n  command)\n    _describe 'command' commands\n    ;;\n  args)\n    case $words[1] in\n      create)\n        _arguments -s \\\n          '--template[Template name]' \\\n          '--package-manager[Package manager: npm|pnpm|yarn|bun]' \\\n          '--eslint[Enable ESLint]' \\\n          '--no-git[Skip git initialization]' \\\n          '--no-install[Skip dependency installation]'\n        ;;\n      add-page)\n        _arguments -s \\\n          '--router-path[Router path]' \\\n          '--page-name[Page name]'\n        ;;\n      add-component)\n        _arguments -s \\\n          '--type[Component type: page|common|business]' \\\n          '--name[Component name]' \\\n          '--dir[Subdirectory]'\n        ;;\n      add-store)\n        _arguments -s \\\n          '--type[Store type: pinia|redux]' \\\n          '--name[Store name]'\n        ;;\n      sync-template)\n        _arguments -s \\\n          '--template[Template name]' \\\n          '--force[Force sync]'\n        ;;\n      validate)\n        _arguments -s \\\n          '--config[Validate config only]' \\\n          '--templates[Validate templates only]' \\\n          '--strict[Strict validation]'\n        ;;\n      preview)\n        _arguments -s \\\n          '--port[Port number]' \\\n          '--host[Host address]' \\\n          '--open[Open browser]' \\\n          '--template[Template name]'\n        ;;\n      completion)\n        _arguments -s \\\n          'bash:Generate bash completion' \\\n          'zsh:Generate zsh completion' \\\n          'fish:Generate fish completion'\n        ;;\n    esac\n    ;;\nesac\n";
+//# sourceMappingURL=completion-scripts.d.ts.map

package/dist/completion/completion-scripts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion-scripts.d.ts","sourceRoot":"","sources":["../../src/completion/completion-scripts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,68BA2C3B,CAAC;AAEF,eAAO,MAAM,eAAe,umFAuE3B,CAAC;AAEF,eAAO,MAAM,cAAc,ohEA4E1B,CAAC"}

package/dist/completion/completion-scripts.js

@@ -0,0 +1,193 @@
+export const BASH_COMPLETION = `#!/bin/bash
+# fsdk bash completion
+
+_fsdk_completion() {
+  local cur prev opts
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  opts="create add-page add-component add-store sync-template validate preview completion"
+
+  case "\${prev}" in
+    create)
+      opts="--template --package-manager --eslint --no-git --no-install"
+      ;;
+    add-page)
+      opts="--router-path --page-name"
+      ;;
+    add-component)
+      opts="--type --name --dir"
+      ;;
+    add-store)
+      opts="--type --name"
+      ;;
+    sync-template)
+      opts="--template --force"
+      ;;
+    validate)
+      opts="--config --templates --strict"
+      ;;
+    preview)
+      opts="--port --host --open --template"
+      ;;
+    completion)
+      opts="bash zsh fish"
+      ;;
+  esac
+
+  COMPREPLY=($(compgen -W "\${opts}" -- "\${cur}"))
+  return 0
+}
+
+complete -F _fsdk_completion fsdk
+`;
+export const FISH_COMPLETION = `# fsdk fish completion
+
+function __fsdk_commands
+  echo "create\tCreate a new application"
+  echo "add-page\t\tAdd a new page"
+  echo "add-component\tAdd a new component"
+  echo "add-store\tAdd a new store"
+  echo "sync-template\tSync template files"
+  echo "validate\t\tValidate configuration and templates"
+  echo "preview\t\tPreview template"
+  echo "completion\tGenerate shell completion script"
+end
+
+function __fsdk_create_app_opts
+  echo "--template\tTemplate name (base|full)"
+  echo "--package-manager\tPackage manager (npm|pnpm|yarn|bun)"
+  echo "--eslint\tEnable ESLint"
+  echo "--no-git\tSkip git initialization"
+  echo "--no-install\tSkip dependency installation"
+end
+
+function __fsdk_add_page_opts
+  echo "--router-path\tRouter path"
+  echo "--page-name\tPage name"
+end
+
+function __fsdk_add_component_opts
+  echo "--type\tComponent type (page|common|business)"
+  echo "--name\tComponent name"
+  echo "--dir\tSubdirectory"
+end
+
+function __fsdk_add_store_opts
+  echo "--type\tStore type (pinia|redux)"
+  echo "--name\tStore name"
+end
+
+function __fsdk_sync_template_opts
+  echo "--template\tTemplate name"
+  echo "--force\tForce sync"
+end
+
+function __fsdk_validate_opts
+  echo "--config\tValidate config only"
+  echo "--templates\tValidate templates only"
+  echo "--strict\tStrict validation"
+end
+
+function __fsdk_preview_opts
+  echo "--port\tPort number"
+  echo "--host\tHost address"
+  echo "--open\tOpen browser"
+  echo "--template\tTemplate name"
+end
+
+function __fsdk_completion_opts
+  echo "bash\tGenerate bash completion"
+  echo "zsh\tGenerate zsh completion"
+  echo "fish\tGenerate fish completion"
+end
+
+complete -c fsdk -f -a "(__fsdk_commands)"
+
+complete -c fsdk -n "not __fish_seen_subcommand_from create" -a "(__fsdk_create_app_opts)" --option
+complete -c fsdk -n "not __fish_seen_subcommand_from add-page" -a "(__fsdk_add_page_opts)" --option
+complete -c fsdk -n "not __fish_seen_subcommand_from add-component" -a "(__fsdk_add_component_opts)" --option
+complete -c fsdk -n "not __fish_seen_subcommand_from add-store" -a "(__fsdk_add_store_opts)" --option
+complete -c fsdk -n "not __fish_seen_subcommand_from sync-template" -a "(__fsdk_sync_template_opts)" --option
+complete -c fsdk -n "not __fish_seen_subcommand_from validate" -a "(__fsdk_validate_opts)" --option
+complete -c fsdk -n "not __fish_seen_subcommand_from preview" -a "(__fsdk_preview_opts)" --option
+complete -c fsdk -n "not __fish_seen_subcommand_from completion" -a "(__fsdk_completion_opts)" --option
+`;
+export const ZSH_COMPLETION = `#compdef fsdk
+
+local -a commands
+commands=(
+  'create:Create a new application'
+  'add-page:Add a new page'
+  'add-component:Add a new component'
+  'add-store:Add a new store'
+  'sync-template:Sync template files'
+  'validate:Validate configuration and templates'
+  'preview:Preview template'
+  'completion:Generate shell completion script'
+)
+
+_arguments -C \\
+  '1: :->command' \\
+  '2: :->args' \\
+  '*: :->rest'
+
+case "$state" in
+  command)
+    _describe 'command' commands
+    ;;
+  args)
+    case $words[1] in
+      create)
+        _arguments -s \\
+          '--template[Template name]' \\
+          '--package-manager[Package manager: npm|pnpm|yarn|bun]' \\
+          '--eslint[Enable ESLint]' \\
+          '--no-git[Skip git initialization]' \\
+          '--no-install[Skip dependency installation]'
+        ;;
+      add-page)
+        _arguments -s \\
+          '--router-path[Router path]' \\
+          '--page-name[Page name]'
+        ;;
+      add-component)
+        _arguments -s \\
+          '--type[Component type: page|common|business]' \\
+          '--name[Component name]' \\
+          '--dir[Subdirectory]'
+        ;;
+      add-store)
+        _arguments -s \\
+          '--type[Store type: pinia|redux]' \\
+          '--name[Store name]'
+        ;;
+      sync-template)
+        _arguments -s \\
+          '--template[Template name]' \\
+          '--force[Force sync]'
+        ;;
+      validate)
+        _arguments -s \\
+          '--config[Validate config only]' \\
+          '--templates[Validate templates only]' \\
+          '--strict[Strict validation]'
+        ;;
+      preview)
+        _arguments -s \\
+          '--port[Port number]' \\
+          '--host[Host address]' \\
+          '--open[Open browser]' \\
+          '--template[Template name]'
+        ;;
+      completion)
+        _arguments -s \\
+          'bash:Generate bash completion' \\
+          'zsh:Generate zsh completion' \\
+          'fish:Generate fish completion'
+        ;;
+    esac
+    ;;
+esac
+`;

package/dist/completion/index.d.ts

@@ -0,0 +1,2 @@
+export { BASH_COMPLETION, ZSH_COMPLETION, FISH_COMPLETION } from './completion-scripts.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/completion/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/completion/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/completion/index.js

@@ -0,0 +1 @@
+export { BASH_COMPLETION, ZSH_COMPLETION, FISH_COMPLETION } from './completion-scripts.js';

package/dist/core/config-loader.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+export declare const FsdkConfigSchema: z.ZodObject<{
+    template: z.ZodOptional<z.ZodString>;
+    packageManager: z.ZodOptional<z.ZodEnum<["npm", "pnpm", "yarn", "bun"]>>;
+    eslint: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    git: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    install: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    router: z.ZodOptional<z.ZodObject<{
+        type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["hash", "history"]>>>;
+        base: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "hash" | "history";
+        base?: string | undefined;
+    }, {
+        type?: "hash" | "history" | undefined;
+        base?: string | undefined;
+    }>>;
+    store: z.ZodOptional<z.ZodObject<{
+        type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["pinia", "redux"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "pinia" | "redux";
+    }, {
+        type?: "pinia" | "redux" | undefined;
+    }>>;
+    aliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    transforms: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        options?: Record<string, unknown> | undefined;
+    }, {
+        name: string;
+        options?: Record<string, unknown> | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    eslint: boolean;
+    git: boolean;
+    install: boolean;
+    template?: string | undefined;
+    packageManager?: "npm" | "pnpm" | "yarn" | "bun" | undefined;
+    router?: {
+        type: "hash" | "history";
+        base?: string | undefined;
+    } | undefined;
+    store?: {
+        type: "pinia" | "redux";
+    } | undefined;
+    aliases?: Record<string, string> | undefined;
+    transforms?: {
+        name: string;
+        options?: Record<string, unknown> | undefined;
+    }[] | undefined;
+}, {
+    template?: string | undefined;
+    packageManager?: "npm" | "pnpm" | "yarn" | "bun" | undefined;
+    eslint?: boolean | undefined;
+    git?: boolean | undefined;
+    install?: boolean | undefined;
+    router?: {
+        type?: "hash" | "history" | undefined;
+        base?: string | undefined;
+    } | undefined;
+    store?: {
+        type?: "pinia" | "redux" | undefined;
+    } | undefined;
+    aliases?: Record<string, string> | undefined;
+    transforms?: {
+        name: string;
+        options?: Record<string, unknown> | undefined;
+    }[] | undefined;
+}>;
+export type FsdkConfig = z.infer<typeof FsdkConfigSchema>;
+export interface PluginContext {
+    cwd: string;
+    config: FsdkConfig;
+    templatesDir: string;
+    pluginsDir: string;
+}
+export declare class ConfigLoader {
+    private configCache;
+    loadConfig(cwd?: string): Promise<FsdkConfig>;
+    private findConfigFile;
+    private parseConfigFile;
+    private getDefaultConfig;
+    clearCache(cwd?: string): void;
+    getDefault(): FsdkConfig;
+    createPluginContext(cwd: string, templatesDir: string, pluginsDir: string): PluginContext;
+}
+export declare const configLoader: ConfigLoader;
+//# sourceMappingURL=config-loader.d.ts.map

package/dist/core/config-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../../src/core/config-loader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkB3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,UAAU,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,WAAW,CAAsC;IAEnD,UAAU,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,UAAU,CAAC;IA2BlE,OAAO,CAAC,cAAc;YAqBR,eAAe;IAiB7B,OAAO,CAAC,gBAAgB;IAYxB,UAAU,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAS9B,UAAU,IAAI,UAAU;IAIxB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,aAAa;CAQ1F;AAED,eAAO,MAAM,YAAY,cAAqB,CAAC"}

package/dist/core/config-loader.js

@@ -0,0 +1,118 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { z } from 'zod';
+import json5 from 'json5';
+import { logger } from '../utils/index.js';
+import { normalizePath } from '../utils/path.js';
+export const FsdkConfigSchema = z.object({
+    template: z.string().optional(),
+    packageManager: z.enum(['npm', 'pnpm', 'yarn', 'bun']).optional(),
+    eslint: z.boolean().optional().default(true),
+    git: z.boolean().optional().default(true),
+    install: z.boolean().optional().default(true),
+    router: z.object({
+        type: z.enum(['hash', 'history']).optional().default('hash'),
+        base: z.string().optional(),
+    }).optional(),
+    store: z.object({
+        type: z.enum(['pinia', 'redux']).optional().default('pinia'),
+    }).optional(),
+    aliases: z.record(z.string()).optional(),
+    transforms: z.array(z.object({
+        name: z.string(),
+        options: z.record(z.unknown()).optional(),
+    })).optional(),
+});
+export class ConfigLoader {
+    configCache = new Map();
+    async loadConfig(cwd = process.cwd()) {
+        const cacheKey = normalizePath(cwd);
+        if (this.configCache.has(cacheKey)) {
+            return this.configCache.get(cacheKey);
+        }
+        const configPath = this.findConfigFile(cwd);
+        if (!configPath) {
+            logger.debug('No .fsdkrc.ts found, using defaults');
+            return this.getDefaultConfig();
+        }
+        try {
+            const config = await this.parseConfigFile(configPath);
+            const validated = FsdkConfigSchema.parse(config);
+            this.configCache.set(cacheKey, validated);
+            logger.success(`Loaded config from ${path.basename(configPath)}`);
+            return validated;
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                logger.error('Config validation failed:', error.errors);
+                throw new Error(`Config validation failed: ${error.errors.map((e) => e.message).join(', ')}`);
+            }
+            throw error;
+        }
+    }
+    findConfigFile(cwd) {
+        const candidates = [
+            '.fsdkrc.ts',
+            '.fsdkrc.js',
+            '.fsdkrc.json',
+            '.fsdkrc',
+            'fsdk.config.ts',
+            'fsdk.config.js',
+            'fsdk.config.json',
+        ];
+        for (const candidate of candidates) {
+            const configPath = path.resolve(cwd, candidate);
+            if (fs.existsSync(configPath)) {
+                return configPath;
+            }
+        }
+        return null;
+    }
+    async parseConfigFile(configPath) {
+        const ext = path.extname(configPath).toLowerCase();
+        switch (ext) {
+            case '.ts':
+            case '.js': {
+                const module = await import(configPath);
+                return module.default || module;
+            }
+            case '.json':
+            case '':
+                return json5.parse(fs.readFileSync(configPath, 'utf-8'));
+            default:
+                throw new Error(`Unsupported config file format: ${ext}`);
+        }
+    }
+    getDefaultConfig() {
+        return {
+            template: 'base',
+            packageManager: 'pnpm',
+            eslint: true,
+            git: true,
+            install: true,
+            router: { type: 'hash' },
+            store: { type: 'pinia' },
+        };
+    }
+    clearCache(cwd) {
+        if (cwd) {
+            this.configCache.delete(normalizePath(cwd));
+        }
+        else {
+            this.configCache.clear();
+        }
+        logger.debug('Config cache cleared');
+    }
+    getDefault() {
+        return this.getDefaultConfig();
+    }
+    createPluginContext(cwd, templatesDir, pluginsDir) {
+        return {
+            cwd,
+            config: this.getDefaultConfig(),
+            templatesDir,
+            pluginsDir,
+        };
+    }
+}
+export const configLoader = new ConfigLoader();