@sandro-sikic/maker 1.0.11 → 1.1.0

package/README.md

@@ -47,13 +47,13 @@ loading.succeed('Project created! 🎉');
 
 ### Core Functions
 
-| Function             | Description                                        |
-| -------------------- | -------------------------------------------------- |
-| `init()`             | Validates interactive terminal environment         |
-| `run(command, opts)` | Executes shell commands with streaming output      |
-| `onExit(callback)`   | Registers cleanup function for graceful shutdown   |
-| `prompt.*`           | Interactive prompts (input, select, confirm, etc.) |
-| `spinner(text)`      | Creates terminal loading indicators                |
+| Function             | Description                                                                                             |
+| -------------------- | ------------------------------------------------------------------------------------------------------- |
+| `init(opts?)`        | Validates interactive terminal environment; accepts optional options object (`{ configPath?: string }`) |
+| `run(command, opts)` | Executes shell commands with streaming output                                                           |
+| `onExit(callback)`   | Registers cleanup function for graceful shutdown                                                        |
+| `prompt.*`           | Interactive prompts (input, select, confirm, etc.)                                                      |
+| `spinner(text)`      | Creates terminal loading indicators                                                                     |
 
 ### Example: Simple Build Tool
 
@@ -100,12 +100,18 @@ build();
 
 ### `init()`
 
-Ensures your CLI is running in an interactive terminal. Always call this first.
+Initializes CLI environment and validates your process is running in an interactive terminal. Call first in your CLI app. Accepts an optional options object: `{ configPath?: string }`.
 
 ```javascript
+// default
 maker.init();
+
+// override config file location
+maker.init({ configPath: '/path/to/config.cfg' });
 ```
 
+Note: passing a plain string to `init()` is not supported — use an options object instead.
+
 ### `run(command, opts)`
 
 Execute shell commands with real-time output streaming.

package/docs/API.md

@@ -6,13 +6,17 @@ Quick reference guide for `@sandro-sikic/maker` functions.
 
 ## `init()`
 
-Validates interactive terminal environment. **Call first** in your CLI app.
+Validates interactive terminal environment. **Call first** in your CLI app. Accepts an optional options object `{ configPath?: string }` to override the location of `config.cfg`.
 
 ```javascript
+// default
 maker.init();
+
+// with options
+maker.init({ configPath: '/custom/path/config.cfg' });
 ```
 
-Exits with code 1 if not running in an interactive terminal (TTY).
+Exits with code 1 if not running in an interactive terminal (TTY). Passing a plain string is not supported.
 
 ---
 

package/docs/USAGE.md

@@ -28,18 +28,22 @@ loading.succeed('Installation complete!');
 
 ### `init()`
 
-Initializes the CLI environment and validates that the application is running in an interactive terminal (TTY). This should be called at the start of your CLI application.
+Initializes the CLI environment and validates that the application is running in an interactive terminal (TTY). This should be called at the start of your CLI application. You may pass an optional options object `{ configPath?: string }` to change where `config.cfg` is read/written.
 
 **Returns:** `void`
 
 **Throws:** Exits with code 1 if not running in an interactive terminal
 
-**Example:**
+**Examples:**
 
 ```javascript
 import { init } from '@sandro-sikic/maker';
 
-init(); // Call this first in your CLI app
+// default
+init();
+
+// override config file
+init({ configPath: '/custom/path/config.cfg' });
 ```
 
 **Why use it?**  

package/example.ts

@@ -0,0 +1,24 @@
+import * as maker from './index.js';
+
+(async () => {
+	maker.init();
+
+	maker.save('test key', 'test.txt');
+	maker.save('key test', 'test.txt');
+
+	const answer = await maker.prompt.confirm({
+		message: 'Do you want to continue?',
+	});
+
+	const processing = await maker.spinner('Processing...').start();
+	console.log('Answer:', answer);
+
+	await new Promise((resolve) => setTimeout(resolve, 1000));
+
+	await maker.run('echo "Hello, World!"');
+
+	processing.succeed();
+
+	console.log(maker.load('key test'));
+	console.log(maker.load('test key'));
+})();

package/index.d.ts

@@ -1,4 +1,6 @@
-export function init(): void;
+/// <reference path="./storage.generated.d.ts" />
+
+export function init(opts?: { configPath?: string }): void;
 
 export type RunResult = {
 	output: string;
@@ -16,8 +18,24 @@ export function run(
 
 export function onExit(cb: () => void | Promise<void>): () => void;
 
+export function save<K extends keyof StorageSchema>(
+	key: K,
+	value: StorageSchema[K],
+): void;
+
+export function save(key: string, value: unknown): void;
+
+export function load<K extends keyof StorageSchema>(key: K): StorageSchema[K];
+
+/**
+ * Overload for unknown string keys.
+ * @deprecated Key not found in `StorageSchema`. The call is allowed and returns `unknown`.
+ */
+export function load(key: string): unknown;
+
 export const prompt: typeof import('@inquirer/prompts');
-export const spinner: typeof import('ora');
+
+export const spinner: typeof import('ora').default;
 
 export type { Ora } from 'ora';
 export * from '@inquirer/prompts';

package/index.js

@@ -1,8 +1,49 @@
 import * as inquirer from '@inquirer/prompts';
 import * as ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// filename for runtime-generated storage types
+const GENERATED_TYPES_FILENAME = 'storage.generated.d.ts';
+
+let _overrideConfigPath = null;
+
+function init(opts) {
+	if (opts !== undefined) {
+		if (!opts || typeof opts !== 'object' || Array.isArray(opts)) {
+			throw new TypeError(
+				'init(opts) expects an options object (e.g. { configPath?: string })',
+			);
+		}
+
+		if (Object.prototype.hasOwnProperty.call(opts, 'configPath')) {
+			if (typeof opts.configPath !== 'string') {
+				throw new TypeError('init(opts).configPath must be a string');
+			}
+			_overrideConfigPath = opts.configPath;
+		}
+	}
+
+	// Clear the auto-generated storage types file so previously-generated keys are removed
+	try {
+		const dir = path.dirname(fileURLToPath(import.meta.url));
+		const gen = path.join(dir, GENERATED_TYPES_FILENAME);
+		try {
+			fs.unlinkSync(gen);
+		} catch (err) {
+			// ignore if file does not exist or cannot be removed
+		}
+	} catch (err) {
+		/* non-fatal; don't prevent init from continuing */
+		try {
+			console.warn(
+				'maker: failed to clear generated storage types:',
+				err && err.message ? err.message : err,
+			);
+		} catch (__) {}
+	}
 
-function init() {
-	// Ensure we're running in an interactive terminal
 	if (!process.stdin.isTTY || !process.stdout.isTTY) {
 		console.error(
 			'\n⚠ This TUI requires an interactive terminal. Run this in a terminal (not the Node REPL or a non-interactive/debug console).\n',
@@ -145,7 +186,156 @@ function onExit(cb) {
 	};
 }
 
-const prompt = inquirer.default ?? inquirer;
-const spinner = ora.default ?? ora;
+/**
+ * Resolve path to the `config.cfg` file placed next to this module.
+ * If an override was provided to `init(opts)` return that path instead.
+ * @returns {string}
+ */
+function _configPath() {
+	if (_overrideConfigPath) return _overrideConfigPath;
+	const dir = path.dirname(fileURLToPath(import.meta.url));
+	return path.join(dir, 'config.json');
+}
+
+/**
+ * Save a value under `key` in `config.cfg` (creates file if missing).
+ * - Overwrites existing keys
+ * - Accepts objects and primitives (stored as JSON)
+ * - Additionally generates `storage.generated.d.ts` (next-time autocomplete)
+ *
+ * @param {string} key
+ * @param {*} value
+ * @returns {void}
+ */
+function save(key, value) {
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('save(key, value) requires a non-empty string key');
+	}
+
+	const file = _configPath();
+	let cfg = {};
+	try {
+		const txt = fs.readFileSync(file, 'utf8');
+		cfg = txt.trim() ? JSON.parse(txt) : {};
+	} catch (err) {
+		if (err && err.code !== 'ENOENT') throw err;
+		cfg = {};
+	}
+
+	cfg[key] = value;
+	fs.writeFileSync(file, JSON.stringify(cfg, null, 2), 'utf8');
+
+	// Generate (or update) `storage.generated.d.ts` so consumers get autocomplete
+	try {
+		_writeGeneratedStorageTypes(file);
+	} catch (err) {
+		// non-fatal: don't break save() if typegen fails
+		/* istanbul ignore next */
+		try {
+			console.warn(
+				'maker: failed to generate storage types:',
+				err && err.message ? err.message : err,
+			);
+		} catch (__) {}
+	}
+}
+
+/**
+ * Generate `storage.generated.d.ts` from the current config file.
+ * This writes a declaration that augments `StorageSchema` with all keys
+ * currently present in the config file so that TypeScript autocompletes
+ * on subsequent runs.
+ */
+function _writeGeneratedStorageTypes(configFile) {
+	const outDir = path.dirname(fileURLToPath(import.meta.url));
+	const outPath = path.join(outDir, GENERATED_TYPES_FILENAME);
+	let txt = '';
+	try {
+		txt = fs.readFileSync(configFile, 'utf8');
+	} catch (err) {
+		if (err && err.code === 'ENOENT') {
+			// nothing saved yet — remove generated file if it exists
+			try {
+				fs.unlinkSync(outPath);
+			} catch (__) {}
+			return;
+		}
+		throw err;
+	}
+
+	const cfg = txt.trim() ? JSON.parse(txt) : {};
+	const keys = Object.keys(cfg).sort();
+
+	function tsTypeForValue(v) {
+		if (v === null) return 'null';
+		const t = typeof v;
+		if (t === 'string') return 'string';
+		if (t === 'number') return 'number';
+		if (t === 'boolean') return 'boolean';
+		if (Array.isArray(v)) {
+			if (v.length === 0) return 'unknown[]';
+			const types = Array.from(new Set(v.map(tsTypeForValue)));
+			if (types.length === 1) return `${types[0]}[]`;
+			return `(${types.join(' | ')})[]`;
+		}
+		if (t === 'object') {
+			// shallow object -> prefer a loose index signature to avoid fragile typings
+			const props = Object.keys(v);
+			if (props.length === 0) return 'Record<string, unknown>';
+			// construct a shallow literal type for better DX when shape is simple
+			const parts = props.map((p) => {
+				const pn = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p) ? p : JSON.stringify(p);
+				return `${pn}: ${tsTypeForValue(v[p])}`;
+			});
+			return `{ ${parts.join('; ')} }`;
+		}
+		return 'unknown';
+	}
+
+	const lines = keys.map((k) => {
+		const v = cfg[k];
+		const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k)
+			? k
+			: JSON.stringify(k);
+		return `    ${safeKey}: ${tsTypeForValue(v)};`;
+	});
+
+	const content =
+		`/* Auto-generated by maker — do not edit. */\n` +
+		`interface StorageSchema {\n` +
+		(lines.length ? lines.join('\n') + '\n' : '') +
+		`}\n`;
+
+	fs.writeFileSync(outPath, content, 'utf8');
+}
+
+/**
+ * Load a value by `key` from `config.cfg` located next to this module.
+ * Returns undefined when the file or key does not exist.
+ *
+ * @param {string} key
+ * @returns {*|undefined}
+ */
+function load(key) {
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('load(key) requires a non-empty string key');
+	}
+
+	const file = _configPath();
+	try {
+		const txt = fs.readFileSync(file, 'utf8');
+		if (!txt.trim()) return undefined;
+		const cfg = JSON.parse(txt);
+		return Object.prototype.hasOwnProperty.call(cfg, key)
+			? cfg[key]
+			: undefined;
+	} catch (err) {
+		if (err && err.code === 'ENOENT') return undefined;
+		throw err;
+	}
+}
+
+const prompt = inquirer;
+const spinner = ora.default;
 
-export { init, run, onExit, prompt, spinner };
+export { init, run, onExit, prompt, spinner, save, load };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sandro-sikic/maker",
-	"version": "1.0.11",
+	"version": "1.1.0",
 	"type": "module",
 	"description": "A lightweight library for building interactive command-line tools with prompts, command execution, spinners, and graceful shutdown handling",
 	"main": "index.js",

package/test/index.test.js

@@ -1,12 +1,34 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, afterEach } from 'vitest';
 
 vi.mock('ora', () => ({
 	default: () => ({ start: () => ({ stop: () => {} }) }),
 }));
 
-import { run, onExit, init, prompt, spinner } from '../index.js';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { run, onExit, init, prompt, spinner, save, load } from '../index.js';
 
 describe('run()', () => {
+	it('throws TypeError when command is not a string', async () => {
+		await expect(run(null)).rejects.toThrow(TypeError);
+		await expect(run(undefined)).rejects.toThrow(TypeError);
+		await expect(run(123)).rejects.toThrow(TypeError);
+		await expect(run({})).rejects.toThrow(TypeError);
+		await expect(run([])).rejects.toThrow(TypeError);
+	});
+
+	it('throws TypeError when command is an empty string', async () => {
+		await expect(run('')).rejects.toThrow(TypeError);
+		await expect(run('')).rejects.toThrow(/non-empty string/);
+	});
+
+	it('throws TypeError when command is only whitespace', async () => {
+		await expect(run('   ')).rejects.toThrow(TypeError);
+		await expect(run('\t\n')).rejects.toThrow(TypeError);
+	});
+
 	it('captures stdout for successful commands (mocked)', async () => {
 		vi.resetModules();
 		vi.doMock('child_process', () => ({
@@ -285,6 +307,25 @@ describe('init()', () => {
 		process.stdout.isTTY = origStdoutTTY;
 	});
 
+	it('throws when passed a non-object argument', () => {
+		expect(() => init('some/path/config.cfg')).toThrow(TypeError);
+		expect(() => init(123)).toThrow(TypeError);
+		expect(() => init(true)).toThrow(TypeError);
+		expect(() => init(null)).toThrow(TypeError);
+	});
+
+	it('throws when passed an array instead of object', () => {
+		expect(() => init([])).toThrow(TypeError);
+		expect(() => init(['path'])).toThrow(TypeError);
+	});
+
+	it('throws TypeError when configPath is not a string', () => {
+		expect(() => init({ configPath: 123 })).toThrow(TypeError);
+		expect(() => init({ configPath: {} })).toThrow(TypeError);
+		expect(() => init({ configPath: null })).toThrow(TypeError);
+		expect(() => init({ configPath: true })).toThrow(TypeError);
+	});
+
 	it('exits with code 1 and logs error when not in a TTY', () => {
 		const origStdinTTY = process.stdin.isTTY;
 		const origStdoutTTY = process.stdout.isTTY;
@@ -302,6 +343,38 @@ describe('init()', () => {
 		process.stdin.isTTY = origStdinTTY;
 		process.stdout.isTTY = origStdoutTTY;
 	});
+
+	it('clears generated storage types file when present', async () => {
+		const genPath = path.join(
+			path.dirname(fileURLToPath(new URL('../index.js', import.meta.url).href)),
+			'storage.generated.d.ts',
+		);
+
+		// create a dummy generated file
+		await fs.writeFile(genPath, '/* generated */', 'utf8');
+
+		const origStdinTTY = process.stdin.isTTY;
+		const origStdoutTTY = process.stdout.isTTY;
+		process.stdin.isTTY = true;
+		process.stdout.isTTY = true;
+
+		try {
+			init();
+			let exists = true;
+			try {
+				await fs.access(genPath);
+			} catch (e) {
+				exists = false;
+			}
+			expect(exists).toBe(false);
+		} finally {
+			process.stdin.isTTY = origStdinTTY;
+			process.stdout.isTTY = origStdoutTTY;
+			try {
+				await fs.rm(genPath);
+			} catch (e) {}
+		}
+	});
 });
 
 describe('exports', () => {
@@ -314,6 +387,311 @@ describe('exports', () => {
 	});
 });
 
+describe('config: save/load', () => {
+	const cfgPath = path.join(
+		path.dirname(fileURLToPath(new URL('../index.js', import.meta.url).href)),
+		'config.json',
+	);
+
+	afterEach(async () => {
+		try {
+			await fs.rm(cfgPath);
+		} catch (e) {
+			// ignore
+		}
+	});
+
+	it('creates file and saves/loads primitive value', async () => {
+		save('foo', 'bar');
+		expect(load('foo')).toBe('bar');
+		const txt = await fs.readFile(cfgPath, 'utf8');
+		expect(JSON.parse(txt)).toEqual({ foo: 'bar' });
+	});
+
+	it('throws TypeError when save() key is not a string', () => {
+		expect(() => save(null, 'value')).toThrow(TypeError);
+		expect(() => save(undefined, 'value')).toThrow(TypeError);
+		expect(() => save(123, 'value')).toThrow(TypeError);
+		expect(() => save({}, 'value')).toThrow(TypeError);
+		expect(() => save([], 'value')).toThrow(TypeError);
+	});
+
+	it('throws TypeError when save() key is an empty string', () => {
+		expect(() => save('', 'value')).toThrow(TypeError);
+		expect(() => save('', 'value')).toThrow(/non-empty string key/);
+	});
+
+	it('throws TypeError when load() key is not a string', () => {
+		expect(() => load(null)).toThrow(TypeError);
+		expect(() => load(undefined)).toThrow(TypeError);
+		expect(() => load(123)).toThrow(TypeError);
+		expect(() => load({})).toThrow(TypeError);
+		expect(() => load([])).toThrow(TypeError);
+	});
+
+	it('throws TypeError when load() key is an empty string', () => {
+		expect(() => load('')).toThrow(TypeError);
+		expect(() => load('')).toThrow(/non-empty string key/);
+	});
+
+	it('saves and loads null values', () => {
+		save('nullKey', null);
+		expect(load('nullKey')).toBeNull();
+	});
+
+	it('saves and loads boolean values', () => {
+		save('trueKey', true);
+		save('falseKey', false);
+		expect(load('trueKey')).toBe(true);
+		expect(load('falseKey')).toBe(false);
+	});
+
+	it('saves and loads number values including zero and negative', () => {
+		save('zero', 0);
+		save('negative', -42);
+		save('float', 3.14);
+		expect(load('zero')).toBe(0);
+		expect(load('negative')).toBe(-42);
+		expect(load('float')).toBe(3.14);
+	});
+
+	it('saves and loads deeply nested objects', () => {
+		const nested = {
+			level1: {
+				level2: {
+					level3: {
+						value: 'deep',
+						array: [1, 2, { nested: true }],
+					},
+				},
+			},
+		};
+		save('nested', nested);
+		expect(load('nested')).toEqual(nested);
+	});
+
+	it('saves and loads arrays with mixed types', () => {
+		const mixed = [1, 'two', true, null, { key: 'value' }, [1, 2]];
+		save('mixedArray', mixed);
+		expect(load('mixedArray')).toEqual(mixed);
+	});
+
+	it('saves and loads empty arrays and objects', () => {
+		save('emptyArray', []);
+		save('emptyObject', {});
+		expect(load('emptyArray')).toEqual([]);
+		expect(load('emptyObject')).toEqual({});
+	});
+
+	it('handles keys with special characters', () => {
+		save('key-with-dashes', 'value1');
+		save('key.with.dots', 'value2');
+		save('key_with_underscores', 'value3');
+		save('key with spaces', 'value4');
+		expect(load('key-with-dashes')).toBe('value1');
+		expect(load('key.with.dots')).toBe('value2');
+		expect(load('key_with_underscores')).toBe('value3');
+		expect(load('key with spaces')).toBe('value4');
+	});
+
+	it('handles corrupted JSON file gracefully in load()', async () => {
+		const cfgPath = path.join(
+			path.dirname(fileURLToPath(new URL('../index.js', import.meta.url).href)),
+			'config.json',
+		);
+		await fs.writeFile(cfgPath, '{invalid json', 'utf8');
+		expect(() => load('anyKey')).toThrow(SyntaxError);
+		await fs.rm(cfgPath);
+	});
+
+	it('preserves all keys when saving multiple values', () => {
+		save('key1', 'value1');
+		save('key2', 'value2');
+		save('key3', 'value3');
+		expect(load('key1')).toBe('value1');
+		expect(load('key2')).toBe('value2');
+		expect(load('key3')).toBe('value3');
+	});
+
+	it('accepts and returns object values', async () => {
+		save('obj', { a: 1, b: 'x' });
+		expect(load('obj')).toEqual({ a: 1, b: 'x' });
+	});
+
+	it('overwrites existing key', async () => {
+		save('k', 'v1');
+		save('k', 'v2');
+		expect(load('k')).toBe('v2');
+	});
+
+	it('returns undefined for missing key or missing file', async () => {
+		try {
+			await fs.rm(cfgPath);
+		} catch (e) {}
+		expect(load('nope')).toBeUndefined();
+	});
+
+	it('respects config path passed to init(opts)', async () => {
+		const origStdinTTY = process.stdin.isTTY;
+		const origStdoutTTY = process.stdout.isTTY;
+		process.stdin.isTTY = true;
+		process.stdout.isTTY = true;
+
+		vi.resetModules();
+		const { init: freshInit, save: freshSave } = await import('../index.js');
+		const customPath = path.join(
+			path.dirname(fileURLToPath(new URL('../index.js', import.meta.url).href)),
+			'custom-config.cfg',
+		);
+		try {
+			await fs.rm(customPath);
+		} catch (e) {}
+		freshInit({ configPath: customPath });
+		freshSave('customKey', 'value');
+		const txt = await fs.readFile(customPath, 'utf8');
+		expect(JSON.parse(txt)).toEqual({ customKey: 'value' });
+		await fs.rm(customPath);
+
+		process.stdin.isTTY = origStdinTTY;
+		process.stdout.isTTY = origStdoutTTY;
+	});
+
+	it('handles empty config file in load()', async () => {
+		const cfgPath = path.join(
+			path.dirname(fileURLToPath(new URL('../index.js', import.meta.url).href)),
+			'config.json',
+		);
+		await fs.writeFile(cfgPath, '', 'utf8');
+		expect(load('anyKey')).toBeUndefined();
+		await fs.rm(cfgPath);
+	});
+
+	it('handles whitespace-only config file in load()', async () => {
+		const cfgPath = path.join(
+			path.dirname(fileURLToPath(new URL('../index.js', import.meta.url).href)),
+			'config.json',
+		);
+		await fs.writeFile(cfgPath, '   \n\t  ', 'utf8');
+		expect(load('anyKey')).toBeUndefined();
+		await fs.rm(cfgPath);
+	});
+});
+
+describe('type generation (storage.generated.d.ts)', () => {
+	const cfgPath = path.join(
+		path.dirname(fileURLToPath(new URL('../index.js', import.meta.url).href)),
+		'config.json',
+	);
+	const genPath = path.join(
+		path.dirname(fileURLToPath(new URL('../index.js', import.meta.url).href)),
+		'storage.generated.d.ts',
+	);
+
+	afterEach(async () => {
+		try {
+			await fs.rm(cfgPath);
+		} catch (e) {}
+		try {
+			await fs.rm(genPath);
+		} catch (e) {}
+	});
+
+	it('generates TypeScript types for string values', async () => {
+		save('name', 'John');
+		const content = await fs.readFile(genPath, 'utf8');
+		expect(content).toContain('interface StorageSchema');
+		expect(content).toContain('name: string');
+	});
+
+	it('generates TypeScript types for number values', async () => {
+		save('age', 42);
+		save('price', 19.99);
+		const content = await fs.readFile(genPath, 'utf8');
+		expect(content).toContain('age: number');
+		expect(content).toContain('price: number');
+	});
+
+	it('generates TypeScript types for boolean values', async () => {
+		save('enabled', true);
+		save('disabled', false);
+		const content = await fs.readFile(genPath, 'utf8');
+		expect(content).toContain('enabled: boolean');
+		expect(content).toContain('disabled: boolean');
+	});
+
+	it('generates TypeScript types for null values', async () => {
+		save('nullValue', null);
+		const content = await fs.readFile(genPath, 'utf8');
+		expect(content).toContain('nullValue: null');
+	});
+
+	it('generates TypeScript types for empty arrays', async () => {
+		save('emptyArr', []);
+		const content = await fs.readFile(genPath, 'utf8');
+		expect(content).toContain('emptyArr: unknown[]');
+	});
+
+	it('generates TypeScript types for homogeneous arrays', async () => {
+		save('numbers', [1, 2, 3]);
+		save('strings', ['a', 'b', 'c']);
+		const content = await fs.readFile(genPath, 'utf8');
+		expect(content).toContain('numbers: number[]');
+		expect(content).toContain('strings: string[]');
+	});
+
+	it('generates TypeScript types for arrays with mixed types', async () => {
+		save('mixed', [1, 'two', true]);
+		const content = await fs.readFile(genPath, 'utf8');
+		expect(content).toMatch(/mixed: \(.*\)\[\]/);
+		expect(content).toContain('number');
+		expect(content).toContain('string');
+		expect(content).toContain('boolean');
+	});
+
+	it('generates TypeScript types for empty objects', async () => {
+		save('emptyObj', {});
+		const content = await fs.readFile(genPath, 'utf8');
+		expect(content).toContain('emptyObj: Record<string, unknown>');
+	});
+
+	it('generates TypeScript types for shallow objects', async () => {
+		save('user', { name: 'Alice', age: 30, active: true });
+		const content = await fs.readFile(genPath, 'utf8');
+		expect(content).toContain('user:');
+		expect(content).toContain('name: string');
+		expect(content).toContain('age: number');
+		expect(content).toContain('active: boolean');
+	});
+
+	it('handles keys with special characters in generated types', async () => {
+		save('key-with-dash', 'value');
+		save('key with space', 'value');
+		const content = await fs.readFile(genPath, 'utf8');
+		// Keys that aren't valid identifiers should be quoted
+		expect(content).toContain('"key-with-dash": string');
+		expect(content).toContain('"key with space": string');
+	});
+
+	it('sorts keys alphabetically in generated types', async () => {
+		save('zebra', 1);
+		save('apple', 2);
+		save('banana', 3);
+		const content = await fs.readFile(genPath, 'utf8');
+		const appleIdx = content.indexOf('apple');
+		const bananaIdx = content.indexOf('banana');
+		const zebraIdx = content.indexOf('zebra');
+		expect(appleIdx).toBeLessThan(bananaIdx);
+		expect(bananaIdx).toBeLessThan(zebraIdx);
+	});
+
+	it('includes auto-generated comment header', async () => {
+		save('test', 'value');
+		const content = await fs.readFile(genPath, 'utf8');
+		expect(content).toContain('Auto-generated by maker');
+		expect(content).toContain('do not edit');
+	});
+});
+
 describe('run() - additional edge cases', () => {
 	it('combines stdout and stderr in output field', async () => {
 		vi.resetModules();
@@ -353,39 +731,13 @@ describe('run() - additional edge cases', () => {
 		vi.resetModules();
 	});
 
-	it('handles null stdout stream gracefully', async () => {
+	it('handles null stdout and stderr streams gracefully', async () => {
 		vi.resetModules();
 		vi.doMock('child_process', () => ({
 			spawn: () => {
 				let closeCb;
 				const child = {
 					stdout: null,
-					stderr: { on: () => {} },
-					on: (ev, cb) => {
-						if (ev === 'close') closeCb = cb;
-					},
-				};
-				process.nextTick(() => {
-					if (closeCb) closeCb(0);
-				});
-				return child;
-			},
-		}));
-		const { run: mockedRun } = await import('../index.js');
-		const res = await mockedRun('anything');
-		expect(res.code).toBe(0);
-		expect(res.stdout).toBe('');
-		expect(res.isError).toBe(false);
-		vi.resetModules();
-	});
-
-	it('handles null stderr stream gracefully', async () => {
-		vi.resetModules();
-		vi.doMock('child_process', () => ({
-			spawn: () => {
-				let closeCb;
-				const child = {
-					stdout: { on: () => {} },
 					stderr: null,
 					on: (ev, cb) => {
 						if (ev === 'close') closeCb = cb;
@@ -400,12 +752,13 @@ describe('run() - additional edge cases', () => {
 		const { run: mockedRun } = await import('../index.js');
 		const res = await mockedRun('anything');
 		expect(res.code).toBe(0);
+		expect(res.stdout).toBe('');
 		expect(res.stderr).toBe('');
 		expect(res.isError).toBe(false);
 		vi.resetModules();
 	});
 
-	it('forwards opts directly to spawn (no alias)', async () => {
+	it('forwards opts including cwd, env, and shell to spawn', async () => {
 		vi.resetModules();
 		let captured;
 		vi.doMock('child_process', () => ({
@@ -425,40 +778,14 @@ describe('run() - additional edge cases', () => {
 		const res = await mockedRun('anything', {
 			cwd: '/tmp',
 			env: { FOO: 'bar' },
+			maxLines: 5, // Should be filtered out
+			shell: false,
 		});
 		expect(captured.cwd).toBe('/tmp');
 		expect(captured.env).toEqual(expect.objectContaining({ FOO: 'bar' }));
-		expect(captured.shell).toBe(true);
-		expect(captured.stdio).toBe('pipe');
-		expect(res.code).toBe(0);
-		vi.resetModules();
-	});
-
-	it('forwards top-level spawn options (maxLines is capture-only)', async () => {
-		vi.resetModules();
-		let captured;
-		vi.doMock('child_process', () => ({
-			spawn: (cmd, spawnOpts) => {
-				captured = spawnOpts;
-				const child = {
-					stdout: { on: () => {} },
-					stderr: { on: () => {} },
-					on: (ev, cb) => {
-						if (ev === 'close') cb(0);
-					},
-				};
-				return child;
-			},
-		}));
-		const { run: mockedRun } = await import('../index.js');
-		const res = await mockedRun('anything', {
-			cwd: '/cwd',
-			maxLines: 5,
-			shell: false,
-		});
-		expect(captured.cwd).toBe('/cwd');
-		expect(captured.maxLines).toBeUndefined();
 		expect(captured.shell).toBe(false);
+		expect(captured.stdio).toBe('pipe');
+		expect(captured.maxLines).toBeUndefined(); // maxLines should not be forwarded
 		expect(res.code).toBe(0);
 		vi.resetModules();
 	});
@@ -1104,18 +1431,6 @@ describe('run() - enhanced edge cases', () => {
 });
 
 describe('onExit() - enhanced edge cases', () => {
-	it('handles callback that returns a value (not a promise)', async () => {
-		const cb = vi.fn(() => 42);
-		const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
-		const off = onExit(cb);
-		process.emit('SIGINT');
-		await new Promise((r) => setTimeout(r, 10));
-		expect(cb).toHaveBeenCalled();
-		expect(exitSpy).toHaveBeenCalledWith(0);
-		off();
-		exitSpy.mockRestore();
-	});
-
 	it('handles callback throwing synchronously', async () => {
 		const cb = vi.fn(() => {
 			throw new Error('sync error');
@@ -1175,7 +1490,7 @@ describe('onExit() - enhanced edge cases', () => {
 		});
 		const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
 		const off = onExit(cb);
-		process.emit('SIGINT');
+		process.emit('SIGTERM'); // Test different signal
 		await new Promise((r) => setTimeout(r, 15));
 		expect(cb).toHaveBeenCalled();
 		expect(exitSpy).toHaveBeenCalledWith(0);
@@ -1183,6 +1498,18 @@ describe('onExit() - enhanced edge cases', () => {
 		exitSpy.mockRestore();
 	});
 
+	it('responds to SIGQUIT signal', async () => {
+		const cb = vi.fn(async () => {});
+		const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
+		const off = onExit(cb);
+		process.emit('SIGQUIT');
+		await new Promise((r) => setTimeout(r, 10));
+		expect(cb).toHaveBeenCalled();
+		expect(exitSpy).toHaveBeenCalledWith(0);
+		off();
+		exitSpy.mockRestore();
+	});
+
 	it('unsubscribe can be called multiple times safely', () => {
 		const cb = vi.fn();
 		const off = onExit(cb);

package/example.js

@@ -1,13 +0,0 @@
-import * as maker from './index.js';
-
-(async () => {
-	maker.init();
-
-	const spinner = await maker.spinner('Testing maker.run()...').start();
-
-	await new Promise((resolve) => setTimeout(resolve, 1000));
-
-	await maker.run('echo "Hello, World!"');
-
-	spinner.succeed('Done!');
-})();