@eide/uniformgen 0.1.0

package/dist/commands/setup.js

@@ -0,0 +1,51 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { getSettings, updateSettings } from '../config/settings.js';
+const FRAMEWORK_CHOICES = [
+    {
+        name: 'React (Apollo Client)',
+        value: 'react',
+        description: 'Generate useQuery/useMutation hooks with Apollo Client',
+    },
+    {
+        name: 'Remix (Hydrogen/Storefront)',
+        value: 'remix',
+        description: 'Generate loader/action helpers for Remix and Hydrogen',
+    },
+    {
+        name: 'Agnostic (typed helpers only)',
+        value: 'agnostic',
+        description: 'Generate framework-agnostic typed parser functions',
+    },
+];
+/**
+ * Setup command - configure UniformGen preferences
+ */
+export async function setup() {
+    const currentSettings = await getSettings();
+    console.log(chalk.bold('\nUniformGen Setup\n'));
+    console.log('Configure your code generation preferences.\n');
+    // Framework selection
+    const { framework } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'framework',
+            message: 'Select your target framework:',
+            default: currentSettings.framework,
+            choices: FRAMEWORK_CHOICES.map((choice) => ({
+                name: `${choice.name}\n     ${chalk.gray(choice.description)}`,
+                value: choice.value,
+                short: choice.name,
+            })),
+        },
+    ]);
+    // Save settings
+    await updateSettings({ framework });
+    console.log('');
+    console.log(chalk.green('✓ Settings saved!'));
+    console.log('');
+    console.log(chalk.gray('Your preferences:'));
+    console.log(chalk.gray(`  Framework: ${framework}`));
+    console.log('');
+    console.log(chalk.cyan('Run `uniformgen pull` to generate typed hooks for your models.'));
+}

package/dist/commands/sync.d.ts

@@ -0,0 +1,13 @@
+interface SyncOptions {
+    apiUrl: string;
+    schemasDir: string;
+    pattern?: string;
+    publish?: boolean;
+    config?: string;
+}
+/**
+ * Sync command - push local schemas then pull generated types
+ */
+export declare function sync(options: SyncOptions): Promise<void>;
+export {};
+//# sourceMappingURL=sync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/commands/sync.ts"],"names":[],"mappings":"AAgEA,UAAU,WAAW;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAyX9D"}

package/dist/commands/sync.js

@@ -0,0 +1,318 @@
+import chalk from 'chalk';
+import { push } from './push.js';
+import { loadConfig } from '../config/load-config.js';
+import { getSettings } from '../config/settings.js';
+import { fetchEntityModels } from '../fetcher/fetch-schemas.js';
+import { fetchWorkflows } from '../fetcher/fetch-workflows.js';
+import { generateEntityModelTypes, generateEntityModelsIndex, } from '../generators/types/entity-models.js';
+import { generateFieldTypesFile } from '../generators/types/field-types.js';
+import { generateHooksFile } from '../generators/types/hooks.js';
+import { generateConfigFile } from '../generators/types/config.js';
+import { generateEntityModelDocuments } from '../generators/documents/entity-models.js';
+import { generateAgnosticHooks, generateAgnosticHooksIndex, generateReactHooks, generateReactHooksIndex, generateRemixHooks, generateRemixHooksIndex, } from '../generators/hooks/index.js';
+// Phase 13: Admin layer generators
+import { generateAdminHooksReact, generateAdminHooksRemix, generateAdminHooksIndexReact, generateAdminHooksIndexRemix, } from '../generators/admin/index.js';
+// Phase 13: Platform resolve generators
+import { generatePlatformResolveReact, generatePlatformResolveRemix, generatePlatformResolveIndexReact, generatePlatformResolveIndexRemix, } from '../generators/resolve/index.js';
+// Phase 13: CMS layer generators
+import { getRoutableModels, generateCmsTypes, generateResolveRouteReact as generateCmsRouteReact, generateResolveRouteRemix as generateCmsRouteRemix, generateCmsIndexReact, generateCmsIndexRemix, } from '../generators/cms/index.js';
+import { generateModelFilters, generateFiltersIndex, } from '../generators/filters/index.js';
+// Workflow generators
+import { generateWorkflowTypes, generateWorkflowTypesIndex, } from '../generators/types/workflows.js';
+import { generateWorkflowReactHooks, generateWorkflowRemixHooks, generateWorkflowReactHooksIndex, generateWorkflowRemixHooksIndex, } from '../generators/hooks/workflows.js';
+import { generateWorkflowDocuments } from '../generators/documents/workflows.js';
+import { writeFiles } from '../writer/write-files.js';
+import { join } from 'path';
+/**
+ * Sync command - push local schemas then pull generated types
+ */
+export async function sync(options) {
+    console.log(chalk.bold('Phase 1: Push local schemas\n'));
+    console.log('─'.repeat(40));
+    // Push schemas
+    await push({
+        apiUrl: options.apiUrl,
+        schemasDir: options.schemasDir,
+        pattern: options.pattern,
+        dryRun: false,
+        publish: options.publish,
+    });
+    console.log('\n' + chalk.bold('Phase 2: Pull generated types\n'));
+    console.log('─'.repeat(40));
+    // Load config for pull
+    const config = await loadConfig(options.config, process.cwd());
+    if (options.apiUrl)
+        config.apiUrl = options.apiUrl;
+    // Fetch updated entity models
+    console.log('Fetching updated entity models...');
+    const entityModels = await fetchEntityModels(config.apiUrl, config.accessToken, config.tenantId, config.projectId, { includeInline: true });
+    const recordModels = entityModels.filter((m) => m.modes.records);
+    const inlineOnlyModels = entityModels.filter((m) => m.modes.inline && !m.modes.records);
+    console.log(`Fetched ${entityModels.length} entity models (${recordModels.length} with records, ${inlineOnlyModels.length} inline-only)\n`);
+    // Generate files
+    const files = [];
+    // Generate base type files
+    console.log('Generating type definitions...');
+    files.push({
+        path: join(config.output.types, 'field-types.ts'),
+        content: generateFieldTypesFile(),
+    });
+    files.push({
+        path: join(config.output.types, 'hooks.ts'),
+        content: generateHooksFile(),
+    });
+    files.push({
+        path: join(config.output.types, 'config.ts'),
+        content: generateConfigFile(),
+    });
+    // Generate entity model types
+    if (entityModels.length > 0) {
+        const modelsDir = join(config.output.types, 'models');
+        for (const model of entityModels) {
+            files.push({
+                path: join(modelsDir, `${model.key}.ts`),
+                content: generateEntityModelTypes(model, entityModels),
+            });
+        }
+        files.push({
+            path: join(modelsDir, 'index.ts'),
+            content: generateEntityModelsIndex(entityModels),
+        });
+    }
+    // Generate GraphQL documents for public API models
+    const publicApiModels = recordModels.filter((m) => m.modes.publicApi);
+    if (publicApiModels.length > 0) {
+        console.log(`Generating GraphQL documents for ${publicApiModels.length} public API models...`);
+        for (const model of publicApiModels) {
+            files.push({
+                path: join(config.output.documents, `${model.key}.graphql`),
+                content: generateEntityModelDocuments(model),
+            });
+        }
+    }
+    // Generate typed hooks based on framework setting
+    const settings = await getSettings();
+    const framework = config.framework || settings.framework || 'agnostic';
+    const hooksDir = config.output.hooks;
+    if (publicApiModels.length > 0) {
+        console.log(`Generating ${framework} hooks for ${publicApiModels.length} models...`);
+        let generateHook;
+        let generateIndex;
+        switch (framework) {
+            case 'react':
+                generateHook = generateReactHooks;
+                generateIndex = generateReactHooksIndex;
+                break;
+            case 'remix':
+                generateHook = generateRemixHooks;
+                generateIndex = generateRemixHooksIndex;
+                break;
+            default:
+                generateHook = generateAgnosticHooks;
+                generateIndex = generateAgnosticHooksIndex;
+        }
+        for (const model of publicApiModels) {
+            const hookContent = generateHook(model, entityModels);
+            if (hookContent) {
+                files.push({
+                    path: join(hooksDir, `${model.key}.ts`),
+                    content: hookContent,
+                });
+            }
+        }
+        files.push({
+            path: join(hooksDir, 'index.ts'),
+            content: generateIndex(publicApiModels),
+        });
+    }
+    // ========================================================================
+    // Phase 13: Generate layered API structure
+    // ========================================================================
+    // Phase 13: Generate admin hooks (CRUD, versioning)
+    if (publicApiModels.length > 0 && framework !== 'agnostic') {
+        console.log(`Generating ${framework} admin hooks for ${publicApiModels.length} models...`);
+        const adminDir = join(hooksDir, 'admin');
+        const generateAdmin = framework === 'react' ? generateAdminHooksReact : generateAdminHooksRemix;
+        const generateAdminIndex = framework === 'react' ? generateAdminHooksIndexReact : generateAdminHooksIndexRemix;
+        for (const model of publicApiModels) {
+            const adminContent = generateAdmin(model, entityModels);
+            if (adminContent) {
+                files.push({
+                    path: join(adminDir, `${model.key}.ts`),
+                    content: adminContent,
+                });
+            }
+        }
+        files.push({
+            path: join(adminDir, 'index.ts'),
+            content: generateAdminIndex(publicApiModels),
+        });
+    }
+    // Phase 13: Generate platform resolve hooks (clean, no CMS features)
+    if (publicApiModels.length > 0 && framework !== 'agnostic') {
+        console.log(`Generating ${framework} platform resolve hooks for ${publicApiModels.length} models...`);
+        const platformResolveDir = join(hooksDir, 'resolve');
+        const generatePlatformResolve = framework === 'react' ? generatePlatformResolveReact : generatePlatformResolveRemix;
+        const generatePlatformIndex = framework === 'react' ? generatePlatformResolveIndexReact : generatePlatformResolveIndexRemix;
+        for (const model of publicApiModels) {
+            const resolveContent = generatePlatformResolve(model, entityModels);
+            if (resolveContent) {
+                files.push({
+                    path: join(platformResolveDir, `${model.key}.ts`),
+                    content: resolveContent,
+                });
+            }
+        }
+        files.push({
+            path: join(platformResolveDir, 'index.ts'),
+            content: generatePlatformIndex(publicApiModels),
+        });
+    }
+    // Phase 13: Generate CMS hooks (only if cms.enabled models exist)
+    const routableModels = getRoutableModels(entityModels);
+    if (routableModels.length > 0 && framework !== 'agnostic') {
+        console.log(`Generating ${framework} CMS hooks for ${routableModels.length} routable models...`);
+        const cmsDir = join(hooksDir, 'cms');
+        const generateCmsRoute = framework === 'react' ? generateCmsRouteReact : generateCmsRouteRemix;
+        const generateCmsIndex = framework === 'react' ? generateCmsIndexReact : generateCmsIndexRemix;
+        // Generate CMS types
+        files.push({
+            path: join(cmsDir, 'types.ts'),
+            content: generateCmsTypes(),
+        });
+        // Generate resolveRoute hook/function
+        files.push({
+            path: join(cmsDir, 'route.ts'),
+            content: generateCmsRoute(routableModels),
+        });
+        // Generate CMS index
+        files.push({
+            path: join(cmsDir, 'index.ts'),
+            content: generateCmsIndex(entityModels),
+        });
+    }
+    // Generate typed filters
+    if (publicApiModels.length > 0) {
+        console.log(`Generating typed filters for ${publicApiModels.length} models...`);
+        const filtersDir = join(config.output.types, '..', 'filters');
+        for (const model of publicApiModels) {
+            const filterContent = generateModelFilters(model, entityModels);
+            if (filterContent) {
+                files.push({
+                    path: join(filtersDir, `${model.key}.ts`),
+                    content: filterContent,
+                });
+            }
+        }
+        files.push({
+            path: join(filtersDir, 'index.ts'),
+            content: generateFiltersIndex(publicApiModels),
+        });
+    }
+    // ========================================================================
+    // Workflow Codegen: Generate typed workflow code
+    // ========================================================================
+    // Fetch workflows with API touchpoint
+    console.log('Fetching API workflows...');
+    let workflows = [];
+    try {
+        workflows = await fetchWorkflows(config.apiUrl, config.accessToken, config.tenantId, config.projectId);
+        console.log(`Fetched ${workflows.length} workflows with API touchpoint\n`);
+    }
+    catch (error) {
+        // Workflows may not exist yet - continue without them
+        console.log(chalk.yellow('Could not fetch workflows (this is OK if no workflows exist)\n'));
+    }
+    if (workflows.length > 0) {
+        // Generate workflow types
+        console.log(`Generating workflow types for ${workflows.length} workflows...`);
+        const workflowTypesDir = join(config.output.types, 'workflows');
+        for (const workflow of workflows) {
+            files.push({
+                path: join(workflowTypesDir, `${workflow.key}.ts`),
+                content: generateWorkflowTypes(workflow),
+            });
+        }
+        files.push({
+            path: join(workflowTypesDir, 'index.ts'),
+            content: generateWorkflowTypesIndex(workflows),
+        });
+        // Generate workflow GraphQL documents
+        console.log('Generating workflow GraphQL documents...');
+        files.push({
+            path: join(config.output.documents, 'workflows.ts'),
+            content: generateWorkflowDocuments(),
+        });
+        // Generate workflow hooks based on framework
+        if (framework !== 'agnostic') {
+            console.log(`Generating ${framework} workflow hooks for ${workflows.length} workflows...`);
+            const workflowHooksDir = join(hooksDir, 'workflows');
+            const generateWorkflowHook = framework === 'react'
+                ? generateWorkflowReactHooks
+                : generateWorkflowRemixHooks;
+            const generateWorkflowIndex = framework === 'react'
+                ? generateWorkflowReactHooksIndex
+                : generateWorkflowRemixHooksIndex;
+            for (const workflow of workflows) {
+                files.push({
+                    path: join(workflowHooksDir, `${workflow.key}.ts`),
+                    content: generateWorkflowHook(workflow),
+                });
+            }
+            files.push({
+                path: join(workflowHooksDir, 'index.ts'),
+                content: generateWorkflowIndex(workflows),
+            });
+        }
+    }
+    // Generate main index
+    files.push({
+        path: join(config.output.types, 'index.ts'),
+        content: `/**
+ * Generated types for EIDE project
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */
+
+export * from './field-types.js';
+export * from './hooks.js';
+export * from './config.js';
+${entityModels.length > 0 ? "export * from './models/index.js';" : ''}
+${workflows.length > 0 ? "export * from './workflows/index.js';" : ''}
+`,
+    });
+    // Write files
+    console.log(`Writing ${files.length} files...`);
+    await writeFiles(files, config.prettier);
+    console.log(chalk.green(`\n✓ Sync complete!`));
+    console.log(chalk.gray(`  Types: ${config.output.types}`));
+    console.log(chalk.gray(`  Documents: ${config.output.documents}`));
+    console.log(chalk.gray(`  Hooks: ${config.output.hooks}`));
+    console.log('');
+    console.log(chalk.cyan('Generated:'));
+    console.log(chalk.gray(`  • field-types.ts - Field type definitions and value types`));
+    console.log(chalk.gray(`  • hooks.ts - Lifecycle hook type definitions`));
+    console.log(chalk.gray(`  • config.ts - EntityModelConfig base type`));
+    console.log(chalk.gray(`  • ${entityModels.length} model files (${recordModels.length} configs + ${inlineOnlyModels.length} inline types)`));
+    if (publicApiModels.length > 0) {
+        console.log(chalk.gray(`  • ${publicApiModels.length} GraphQL document files`));
+        console.log(chalk.gray(`  • ${publicApiModels.length} ${framework} hook files`));
+        console.log(chalk.gray(`  • ${publicApiModels.length} typed filter files`));
+    }
+    // Phase 13 output
+    if (publicApiModels.length > 0 && framework !== 'agnostic') {
+        console.log(chalk.gray(`  • hooks/admin/ - ${publicApiModels.length} admin CRUD hooks`));
+        console.log(chalk.gray(`  • hooks/resolve/ - ${publicApiModels.length} platform resolve hooks`));
+    }
+    if (routableModels.length > 0 && framework !== 'agnostic') {
+        console.log(chalk.gray(`  • hooks/cms/ - CMS route resolution (${routableModels.length} routable models)`));
+    }
+    // Workflow output
+    if (workflows.length > 0) {
+        console.log(chalk.gray(`  • types/workflows/ - ${workflows.length} workflow type definitions`));
+        console.log(chalk.gray(`  • documents/workflows.ts - Workflow GraphQL documents`));
+        if (framework !== 'agnostic') {
+            console.log(chalk.gray(`  • hooks/workflows/ - ${workflows.length} ${framework} workflow hooks`));
+        }
+    }
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Whoami command - show current authentication status
+ */
+export declare function whoami(): Promise<void>;
+//# sourceMappingURL=whoami.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"whoami.d.ts","sourceRoot":"","sources":["../../src/commands/whoami.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAsB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CA6B5C"}

package/dist/commands/whoami.js

@@ -0,0 +1,31 @@
+import { getCredentials, isTokenExpired } from '../auth/credentials.js';
+/**
+ * Whoami command - show current authentication status
+ */
+export async function whoami() {
+    const credentials = await getCredentials();
+    if (!credentials) {
+        console.log('Not logged in.');
+        console.log('\nRun `uniformgen login` to authenticate.');
+        process.exit(1);
+    }
+    const expired = isTokenExpired(credentials);
+    console.log('Authentication Status');
+    console.log('─'.repeat(40));
+    console.log(`User:    ${credentials.user.name} <${credentials.user.email}>`);
+    console.log(`User ID: ${credentials.user.id}`);
+    console.log(`Token:   ${expired ? '⚠ Expired' : '✓ Valid'}`);
+    if (credentials.selectedProject) {
+        console.log('');
+        console.log('Selected Project');
+        console.log('─'.repeat(40));
+        console.log(`Name:      ${credentials.selectedProject.name}`);
+        console.log(`ID:        ${credentials.selectedProject.id}`);
+        console.log(`Tenant ID: ${credentials.selectedProject.tenantId}`);
+    }
+    else {
+        console.log('');
+        console.log('No project selected.');
+        console.log('Run `uniformgen select-project` to choose a project.');
+    }
+}

package/dist/config/load-config.d.ts

@@ -0,0 +1,6 @@
+import { type UniformGenConfig } from './types.js';
+/**
+ * Load configuration from file or use defaults
+ */
+export declare function loadConfig(configPath?: string, cwd?: string): Promise<UniformGenConfig>;
+//# sourceMappingURL=load-config.d.ts.map

package/dist/config/load-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-config.d.ts","sourceRoot":"","sources":["../../src/config/load-config.ts"],"names":[],"mappings":"AAGA,OAAO,EAA+B,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAehF;;GAEG;AACH,wBAAsB,UAAU,CAC9B,UAAU,CAAC,EAAE,MAAM,EACnB,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,gBAAgB,CAAC,CAuG3B"}

package/dist/config/load-config.js

@@ -0,0 +1,103 @@
+import { pathToFileURL } from 'url';
+import { existsSync } from 'fs';
+import { resolve, join } from 'path';
+import { ConfigSchema, defaultConfig } from './types.js';
+import { getCredentials } from '../auth/credentials.js';
+/**
+ * Possible config file names
+ */
+const CONFIG_FILES = [
+    '.uniformrc.ts',
+    '.uniformrc.js',
+    '.uniformrc.mjs',
+    'uniformgen.config.ts',
+    'uniformgen.config.js',
+    'uniformgen.config.mjs',
+];
+/**
+ * Load configuration from file or use defaults
+ */
+export async function loadConfig(configPath, cwd = process.cwd()) {
+    let configFile = null;
+    // If explicit config path provided, use it
+    if (configPath) {
+        const absolutePath = resolve(cwd, configPath);
+        if (!existsSync(absolutePath)) {
+            throw new Error(`Config file not found: ${absolutePath}`);
+        }
+        configFile = absolutePath;
+    }
+    else {
+        // Search for config file in current directory
+        for (const fileName of CONFIG_FILES) {
+            const filePath = join(cwd, fileName);
+            if (existsSync(filePath)) {
+                configFile = filePath;
+                break;
+            }
+        }
+    }
+    let userConfig = {};
+    // Load config file if found
+    if (configFile) {
+        try {
+            const configUrl = pathToFileURL(configFile).href;
+            const configModule = await import(configUrl);
+            userConfig = configModule.default || configModule;
+        }
+        catch (error) {
+            throw new Error(`Failed to load config file: ${configFile}\n${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Get API URL from environment variable if not in config
+    const apiUrl = userConfig.apiUrl ||
+        process.env.UNIFORMGEN_API_URL ||
+        process.env.FOIR_API_URL ||
+        defaultConfig.apiUrl;
+    // Get credentials from CLI login
+    const credentials = await getCredentials();
+    // Try to get access token from multiple sources in order of preference:
+    // 1. Explicit access token in config/env
+    // 2. CLI credentials from login
+    const accessToken = userConfig.accessToken ||
+        process.env.UNIFORMGEN_ACCESS_TOKEN ||
+        process.env.FOIR_ACCESS_TOKEN ||
+        credentials?.accessToken;
+    // Require an access token
+    if (!accessToken) {
+        throw new Error('Authentication required. Run `uniformgen login` and `uniformgen select-project` to authenticate via CLI.');
+    }
+    // Require a selected project
+    if (!credentials?.selectedProject) {
+        throw new Error('No project selected. Run `uniformgen select-project` to choose a project.');
+    }
+    // Get tenant and project IDs from selected project
+    const tenantId = credentials.selectedProject.tenantId;
+    const projectId = credentials.selectedProject.id;
+    // Project key is optional (kept for backwards compatibility)
+    const projectKey = userConfig.projectKey ||
+        process.env.UNIFORMGEN_PROJECT_KEY ||
+        process.env.EIDE_PROJECT_KEY ||
+        credentials?.selectedProject?.apiKey;
+    // Merge with defaults
+    const mergedConfig = {
+        ...defaultConfig,
+        ...userConfig,
+        accessToken,
+        tenantId,
+        projectId,
+        projectKey,
+        apiUrl,
+        output: {
+            ...defaultConfig.output,
+            ...userConfig.output,
+        },
+    };
+    // Validate config
+    try {
+        return ConfigSchema.parse(mergedConfig);
+    }
+    catch (error) {
+        throw new Error(`Invalid configuration:\n${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/config/settings.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Local settings structure (stored per-machine, not per-project)
+ */
+export interface LocalSettings {
+    /** Target framework for generated hooks */
+    framework: 'agnostic' | 'react' | 'remix';
+}
+/**
+ * Read local settings
+ */
+export declare function getSettings(): Promise<LocalSettings>;
+/**
+ * Write settings to file
+ */
+export declare function writeSettings(settings: LocalSettings): Promise<void>;
+/**
+ * Update settings with new values
+ */
+export declare function updateSettings(updates: Partial<LocalSettings>): Promise<void>;
+//# sourceMappingURL=settings.d.ts.map

package/dist/config/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/config/settings.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,SAAS,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC;CAC3C;AAkCD;;GAEG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,aAAa,CAAC,CAU1D;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAM1E;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAC9B,OAAO,CAAC,IAAI,CAAC,CAGf"}

package/dist/config/settings.js

@@ -0,0 +1,64 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const DEFAULT_SETTINGS = {
+    framework: 'agnostic',
+};
+/**
+ * Get the settings directory path
+ */
+function getSettingsDir() {
+    return join(homedir(), '.uniformgen');
+}
+/**
+ * Get the settings file path
+ */
+function getSettingsPath() {
+    return join(getSettingsDir(), 'settings.json');
+}
+/**
+ * Ensure the settings directory exists
+ */
+async function ensureSettingsDir() {
+    const dir = getSettingsDir();
+    try {
+        await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST') {
+            throw error;
+        }
+    }
+}
+/**
+ * Read local settings
+ */
+export async function getSettings() {
+    try {
+        const content = await fs.readFile(getSettingsPath(), 'utf-8');
+        return { ...DEFAULT_SETTINGS, ...JSON.parse(content) };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return DEFAULT_SETTINGS;
+        }
+        throw error;
+    }
+}
+/**
+ * Write settings to file
+ */
+export async function writeSettings(settings) {
+    await ensureSettingsDir();
+    const path = getSettingsPath();
+    await fs.writeFile(path, JSON.stringify(settings, null, 2), {
+        mode: 0o600,
+    });
+}
+/**
+ * Update settings with new values
+ */
+export async function updateSettings(updates) {
+    const existing = await getSettings();
+    await writeSettings({ ...existing, ...updates });
+}