typespun-codegen 0.0.8 → 0.0.9

package/dist/analyzer/diagnostic.d.ts

@@ -0,0 +1,5 @@
+import ts from 'typescript';
+import type { Diagnostic, SourceLocation } from '../contracts.js';
+export declare function locationOf(node: ts.Node): SourceLocation;
+export declare function sortDiagnostics(diagnostics: Diagnostic[]): Diagnostic[];
+//# sourceMappingURL=diagnostic.d.ts.map

package/dist/analyzer/diagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic.d.ts","sourceRoot":"","sources":["../../src/analyzer/diagnostic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAElE,wBAAgB,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,cAAc,CAUxD;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAQvE"}

package/dist/analyzer/diagnostic.js

@@ -0,0 +1,16 @@
+import ts from 'typescript';
+export function locationOf(node) {
+    const source = node.getSourceFile();
+    const position = source.getLineAndCharacterOfPosition(ts.isSourceFile(node) ? 0 : node.getStart(source));
+    return {
+        file: source.fileName,
+        line: position.line + 1,
+        column: position.character + 1,
+    };
+}
+export function sortDiagnostics(diagnostics) {
+    return diagnostics.sort((a, b) => a.location.file.localeCompare(b.location.file) ||
+        a.location.line - b.location.line ||
+        a.location.column - b.location.column ||
+        a.code.localeCompare(b.code));
+}

package/dist/analyzer/ir.d.ts

@@ -0,0 +1,2 @@
+export type { AnalyzeResult, Diagnostic, FieldIR, RootExport, SourceLocation, } from '../contracts.js';
+//# sourceMappingURL=ir.d.ts.map

package/dist/analyzer/ir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.d.ts","sourceRoot":"","sources":["../../src/analyzer/ir.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,aAAa,EACb,UAAU,EACV,OAAO,EACP,UAAU,EACV,cAAc,GACf,MAAM,iBAAiB,CAAC"}

package/dist/analyzer/ir.js

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

package/dist/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":""}

package/dist/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runCli } from './cli/main.js';
+process.exitCode = await runCli(process.argv.slice(2));

package/dist/cli/diagnostics.d.ts

@@ -0,0 +1,7 @@
+import type { GenerateDiagnostic } from '../generate.js';
+export interface DiagnosticFormatOptions {
+    readonly cwd: string;
+    readonly color: boolean;
+}
+export declare function formatDiagnostic(diagnostic: GenerateDiagnostic, options: DiagnosticFormatOptions): string;
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/cli/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../src/cli/diagnostics.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,kBAAkB,EAC9B,OAAO,EAAE,uBAAuB,GAC/B,MAAM,CAoBR"}

package/dist/cli/diagnostics.js

@@ -0,0 +1,26 @@
+import { isAbsolute, relative } from 'node:path';
+export function formatDiagnostic(diagnostic, options) {
+    const file = diagnosticFile(diagnostic);
+    const location = 'location' in diagnostic ? diagnostic.location : undefined;
+    const displayedFile = file === undefined
+        ? '<project>'
+        : isAbsolute(file)
+            ? relative(options.cwd, file) || file
+            : file;
+    const prefix = `${displayedFile}:${location?.line ?? 1}:${location?.column ?? 1}`;
+    const code = options.color
+        ? `\u001b[36m[${diagnostic.code}]\u001b[0m`
+        : `[${diagnostic.code}]`;
+    const suggestion = 'suggestion' in diagnostic && diagnostic.suggestion !== undefined
+        ? `\n  suggestion: ${diagnostic.suggestion}`
+        : '';
+    const affectedPath = 'path' in diagnostic && diagnostic.path ? `path ${diagnostic.path}: ` : '';
+    return `${prefix} ${code} ${affectedPath}${diagnostic.message}${suggestion}`;
+}
+function diagnosticFile(diagnostic) {
+    if ('location' in diagnostic)
+        return diagnostic.location.file;
+    if ('file' in diagnostic)
+        return diagnostic.file;
+    return undefined;
+}

package/dist/cli/init.d.ts

@@ -0,0 +1,19 @@
+import type { GenerateDiagnostic } from '../generate.js';
+export interface InitOptions {
+    readonly style?: 'interface' | 'class';
+    readonly input?: string;
+    readonly output?: string;
+    readonly envPrefix?: string;
+    readonly interactive?: boolean;
+}
+export interface InitResult {
+    readonly exitCode: 0 | 1 | 2;
+    readonly messages: readonly string[];
+    readonly warnings: readonly string[];
+    readonly diagnostics: readonly GenerateDiagnostic[];
+}
+export declare class InitProjectError extends Error {
+    constructor(message: string);
+}
+export declare function initializeProject(cwd: string, options: InitOptions): Promise<InitResult>;
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/cli/init.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAQzD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACrD;AAkBD,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAED,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,CAAC,CAuJrB"}

package/dist/cli/init.js

@@ -0,0 +1,531 @@
+import { existsSync, lstatSync, readFileSync, realpathSync, statSync, } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { basename, dirname, extname, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import ts from 'typescript';
+import { generateProject } from '../generate.js';
+import { CONVENTIONAL_INPUTS, discoverDefaultsPath, findNearestTsconfig, } from '../project/discovery.js';
+const SCHEMA_EXTENSIONS = new Set(['.ts', '.mts', '.cts']);
+export class InitProjectError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InitProjectError';
+    }
+}
+export async function initializeProject(cwd, options) {
+    const projectDirectory = resolve(cwd);
+    const packagePath = join(projectDirectory, 'package.json');
+    rejectMutableSymlink(packagePath, 'package.json');
+    const packageDocument = readPackageDocument(packagePath);
+    const configPath = join(projectDirectory, 'typespun.json');
+    rejectMutableSymlink(configPath, 'typespun.json');
+    const existingConfig = existsSync(configPath)
+        ? readInitConfig(configPath)
+        : undefined;
+    const shouldPrompt = options.interactive !== undefined
+        ? options.interactive
+        : process.stdin.isTTY === true && process.env.CI !== 'true';
+    const input = selectInput(projectDirectory, options, existingConfig);
+    const output = options.output ??
+        existingConfig?.output ??
+        `src/generated/typespun${extname(input)}`;
+    validateSchemaPath(input, '--input');
+    validateSchemaPath(output, '--output');
+    rejectConflictingOptions(options, existingConfig, input, output);
+    validateExistingSchemaStyle(projectDirectory, input, options.style);
+    const inputPath = resolve(projectDirectory, input);
+    const outputPath = resolve(projectDirectory, output);
+    const inputNeedsCreation = !existsSync(inputPath);
+    const style = inputNeedsCreation
+        ? await resolveStyle(options.style, shouldPrompt)
+        : (options.style ?? 'interface');
+    const envPrefix = options.envPrefix === undefined
+        ? await resolveEnvPrefix(options.envPrefix, existingConfig?.envPrefix, shouldPrompt)
+        : options.envPrefix;
+    if (pathsReferToSameFile(inputPath, outputPath)) {
+        throw new InitProjectError('Schema input and generated output must differ');
+    }
+    if (pathEntryExists(outputPath) && !isTypespunGeneratedOutput(outputPath)) {
+        throw new InitProjectError(`Initialization refuses to overwrite the existing output at ${output}`);
+    }
+    const discoveredDefaults = existingConfig?.defaults === undefined
+        ? discoverDefaultsPath(projectDirectory)
+        : undefined;
+    const createDefaults = existingConfig?.defaults === undefined && discoveredDefaults === undefined;
+    const defaultDefaultsPath = join(projectDirectory, 'config.yaml');
+    if (createDefaults && pathEntryExists(defaultDefaultsPath)) {
+        throw new InitProjectError('Initialization refuses to overwrite the existing entry at config.yaml');
+    }
+    const config = {
+        ...existingConfig,
+        input,
+        output,
+        ...(envPrefix === undefined ? {} : { envPrefix }),
+    };
+    preflightResolvedConfig(projectDirectory, config, inputPath);
+    const configNeedsMissingKeys = existingConfig !== undefined &&
+        (existingConfig.input === undefined ||
+            existingConfig.output === undefined ||
+            (options.envPrefix !== undefined &&
+                existingConfig.envPrefix === undefined));
+    const messages = [];
+    if (inputNeedsCreation) {
+        await writeNewFile(inputPath, schemaTemplate(style));
+        messages.push(`Created ${input}.`);
+    }
+    if (createDefaults) {
+        await writeNewFile(defaultDefaultsPath, inputNeedsCreation ? 'port: 3000\n' : '{}\n');
+        messages.push('Created config.yaml.');
+    }
+    const serializedConfig = existingConfig === undefined
+        ? serializeNewConfig(config, discoveredDefaults === undefined
+            ? 'config.yaml'
+            : displayPath(projectDirectory, discoveredDefaults))
+        : `${JSON.stringify(config, null, 2)}\n`;
+    if (existingConfig === undefined) {
+        await writeNewFile(configPath, serializedConfig);
+        messages.push('Created typespun.json.');
+    }
+    else if (configNeedsMissingKeys) {
+        await writeFile(configPath, serializedConfig);
+        messages.push('Added missing paths to typespun.json.');
+    }
+    if (addMissingScripts(packageDocument)) {
+        await writeFile(packagePath, `${JSON.stringify(packageDocument, null, 2)}\n`);
+        messages.push('Added config:generate and config:check scripts.');
+    }
+    const missing = missingDependencies(projectDirectory);
+    if (missing.length > 0) {
+        return {
+            exitCode: 0,
+            messages,
+            warnings: installationGuidance(projectDirectory, packageDocument, missing),
+            diagnostics: [],
+        };
+    }
+    const generated = await generateProject({
+        projectDirectory,
+        configPath,
+        mode: 'write',
+    });
+    if (generated.diagnostics.length > 0) {
+        return {
+            exitCode: generated.diagnostics.some((diagnostic) => diagnostic.code === 'typescript_config')
+                ? 2
+                : 1,
+            messages,
+            warnings: [],
+            diagnostics: [...generated.warnings, ...generated.diagnostics],
+        };
+    }
+    messages.push(`${generated.status === 'written' ? 'Generated' : 'Unchanged'} ${displayPath(projectDirectory, generated.outputPath)}.`);
+    return {
+        exitCode: 0,
+        messages,
+        warnings: [],
+        diagnostics: generated.warnings,
+    };
+}
+function readPackageDocument(path) {
+    if (!isFile(path))
+        throw new InitProjectError('package.json is required');
+    let value;
+    try {
+        value = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        throw new InitProjectError('package.json must contain valid JSON');
+    }
+    if (!isRecord(value)) {
+        throw new InitProjectError('package.json must contain an object');
+    }
+    if (value.scripts !== undefined && !isRecord(value.scripts)) {
+        throw new InitProjectError('package.json scripts must contain an object');
+    }
+    return value;
+}
+async function resolveStyle(style, shouldPrompt) {
+    if (style !== undefined)
+        return style;
+    if (!shouldPrompt)
+        return 'interface';
+    while (true) {
+        const answer = await promptLine('Which schema style would you like for config? [interface/class] (default: interface): ');
+        if (answer.length === 0)
+            return 'interface';
+        if (answer === 'interface' || answer === 'class')
+            return answer;
+        process.stderr.write('Please answer "interface" or "class"\n');
+    }
+}
+async function resolveEnvPrefix(provided, existing, shouldPrompt) {
+    if (provided !== undefined || existing !== undefined) {
+        return provided ?? existing;
+    }
+    if (!shouldPrompt)
+        return undefined;
+    const answer = await promptLine('Optional environment variable prefix (leave blank to skip): ');
+    return answer.length === 0 ? undefined : answer;
+}
+async function promptLine(question) {
+    const input = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const value = await input.question(question);
+        return value.trim();
+    }
+    finally {
+        input.close();
+    }
+}
+function validateTsconfig(path) {
+    if (!isFile(path))
+        throw new InitProjectError('tsconfig.json is required');
+    const loaded = ts.readConfigFile(path, ts.sys.readFile);
+    if (loaded.error !== undefined) {
+        throw new InitProjectError('tsconfig.json must contain usable TypeScript configuration');
+    }
+    const parsed = ts.parseJsonConfigFileContent(loaded.config, ts.sys, dirname(path), undefined, path);
+    if (parsed.errors.some((diagnostic) => diagnostic.code !== 18003)) {
+        throw new InitProjectError('tsconfig.json must contain usable TypeScript configuration');
+    }
+}
+function preflightResolvedConfig(projectDirectory, config, inputPath) {
+    const tsconfigPath = config.tsconfig === undefined
+        ? findNearestTsconfig(inputPath)
+        : resolve(projectDirectory, config.tsconfig);
+    if (tsconfigPath === undefined) {
+        throw new InitProjectError(`Could not find tsconfig.json for ${displayPath(projectDirectory, inputPath)}`);
+    }
+    validateTsconfig(tsconfigPath);
+    const defaults = config.defaults;
+    const hasExplicitDefaultsPath = typeof defaults === 'string' ||
+        (isRecord(defaults) && typeof defaults.path === 'string');
+    if (!hasExplicitDefaultsPath) {
+        try {
+            discoverDefaultsPath(projectDirectory);
+        }
+        catch (error) {
+            throw new InitProjectError(error instanceof Error
+                ? error.message
+                : 'Defaults-file discovery failed');
+        }
+    }
+}
+function readInitConfig(path) {
+    let value;
+    try {
+        const parsed = ts.parseConfigFileTextToJson(path, readFileSync(path, 'utf8'));
+        if (parsed.error !== undefined)
+            throw new Error('invalid JSON');
+        value = parsed.config;
+    }
+    catch {
+        throw new InitProjectError('typespun.json must contain valid JSON with comments');
+    }
+    if (!isRecord(value)) {
+        throw new InitProjectError('typespun.json must contain an object');
+    }
+    const allowed = new Set([
+        'input',
+        'output',
+        'tsconfig',
+        'envPrefix',
+        'defaults',
+        'secretDefaults',
+    ]);
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key)) {
+            throw new InitProjectError(`Unknown typespun.json key: ${key}`);
+        }
+    }
+    for (const key of ['input', 'output', 'tsconfig', 'envPrefix']) {
+        if (value[key] !== undefined && typeof value[key] !== 'string') {
+            throw new InitProjectError(`typespun.json ${key} must be a string`);
+        }
+    }
+    validateDefaultsConfig(value.defaults);
+    if (value.secretDefaults !== undefined &&
+        value.secretDefaults !== 'warn' &&
+        value.secretDefaults !== 'allow' &&
+        value.secretDefaults !== 'error') {
+        throw new InitProjectError('typespun.json secretDefaults must be warn, allow, or error');
+    }
+    return value;
+}
+function serializeNewConfig(config, defaultsPath) {
+    const prefixLines = config.envPrefix === undefined
+        ? [
+            '',
+            '  // Optional environment prefix. APP produces keys such as APP_PORT.',
+            '  // "envPrefix": "APP",',
+        ]
+        : [
+            `  "envPrefix": ${JSON.stringify(config.envPrefix)},`,
+            '',
+            '  // Environment keys use the configured prefix, such as APP_PORT.',
+        ];
+    return `${[
+        '{',
+        `  "input": ${JSON.stringify(config.input)},`,
+        `  "output": ${JSON.stringify(config.output)},`,
+        ...prefixLines,
+        '',
+        '  // Optional tsconfig override. Default: nearest tsconfig.json to the input.',
+        '  // "tsconfig": "tsconfig.json",',
+        '',
+        `  // Optional defaults override. ${defaultsPath} is discovered automatically.`,
+        '  // "defaults": {',
+        `  //   "path": ${JSON.stringify(defaultsPath)},`,
+        '  //   "unknownKeys": "error" // Allowed: "error", "warn", or "ignore".',
+        '  // },',
+        '',
+        '  // Policy for defaults on secret fields. Allowed: "warn", "allow", or "error".',
+        '  // "secretDefaults": "warn"',
+        '}',
+    ].join('\n')}\n`;
+}
+function validateDefaultsConfig(value) {
+    if (value === undefined || typeof value === 'string')
+        return;
+    if (!isRecord(value)) {
+        throw new InitProjectError('typespun.json defaults must be a string or object');
+    }
+    for (const key of Object.keys(value)) {
+        if (key !== 'path' && key !== 'unknownKeys') {
+            throw new InitProjectError(`Unknown typespun.json defaults key: ${key}`);
+        }
+    }
+    if (value.path !== undefined && typeof value.path !== 'string') {
+        throw new InitProjectError('typespun.json defaults.path must be a string');
+    }
+    if (value.unknownKeys !== undefined &&
+        value.unknownKeys !== 'error' &&
+        value.unknownKeys !== 'warn' &&
+        value.unknownKeys !== 'ignore') {
+        throw new InitProjectError('typespun.json defaults.unknownKeys must be error, warn, or ignore');
+    }
+}
+function selectInput(projectDirectory, options, existingConfig) {
+    if (options.input !== undefined)
+        return options.input;
+    if (existingConfig?.input !== undefined)
+        return existingConfig.input;
+    const candidates = CONVENTIONAL_INPUTS.filter((path) => isFile(resolve(projectDirectory, path)));
+    if (candidates.length > 1) {
+        throw new InitProjectError(`Multiple conventional schemas exist: ${candidates.join(', ')}; use --input.`);
+    }
+    return candidates[0] ?? 'src/config.ts';
+}
+function rejectConflictingOptions(options, existing, input, output) {
+    if (existing === undefined)
+        return;
+    const comparisons = [
+        ['--input', options.input, existing.input ?? input],
+        ['--output', options.output, existing.output ?? output],
+        [
+            '--env-prefix',
+            options.envPrefix,
+            existing.envPrefix ?? options.envPrefix,
+        ],
+    ];
+    for (const [flag, requested, configured] of comparisons) {
+        if (requested !== undefined && requested !== configured) {
+            throw new InitProjectError(`${flag} conflicts with the existing typespun.json`);
+        }
+    }
+}
+function validateExistingSchemaStyle(projectDirectory, input, requestedStyle) {
+    const path = resolve(projectDirectory, input);
+    if (requestedStyle === undefined || !isFile(path))
+        return;
+    const source = readFileSync(path, 'utf8');
+    const matches = requestedStyle === 'class'
+        ? /\b(?:export\s+)?class\s+[A-Za-z_$]/.test(source)
+        : /\b(?:export\s+)?interface\s+[A-Za-z_$]/.test(source);
+    if (!matches) {
+        throw new InitProjectError(`--style ${requestedStyle} conflicts with the existing schema at ${input}`);
+    }
+}
+function validateSchemaPath(path, flag) {
+    if (!SCHEMA_EXTENSIONS.has(extname(path))) {
+        throw new InitProjectError(`${flag} must use a .ts, .mts, or .cts extension`);
+    }
+}
+function schemaTemplate(style) {
+    return style === 'interface'
+        ? `/** @typespun */\nexport interface AppConfig {\n  port: number;\n}\n`
+        : `import { Config } from 'typespun';\n\n@Config()\nexport class AppConfig {\n  port!: number;\n}\n`;
+}
+function addMissingScripts(document) {
+    const scripts = document.scripts ?? {};
+    let changed = false;
+    if (scripts['config:generate'] === undefined) {
+        scripts['config:generate'] = 'typespun generate';
+        changed = true;
+    }
+    if (scripts['config:check'] === undefined) {
+        scripts['config:check'] = 'typespun check';
+        changed = true;
+    }
+    if (document.scripts === undefined)
+        document.scripts = scripts;
+    return changed;
+}
+function missingDependencies(projectDirectory) {
+    return ['typespun', 'typespun-codegen'].filter((name) => !findInstalledPackage(projectDirectory, name));
+}
+function findInstalledPackage(projectDirectory, packageName) {
+    let directory = resolve(projectDirectory);
+    while (true) {
+        if (isFile(join(directory, 'node_modules', packageName, 'package.json'))) {
+            return true;
+        }
+        const parent = dirname(directory);
+        if (parent === directory)
+            return false;
+        directory = parent;
+    }
+}
+function installationGuidance(projectDirectory, packageDocument, missing) {
+    const manager = detectPackageManager(projectDirectory, packageDocument);
+    const commands = [];
+    if (missing.includes('typespun')) {
+        commands.push(installCommand(manager, 'typespun', false));
+    }
+    if (missing.includes('typespun-codegen')) {
+        commands.push(installCommand(manager, 'typespun-codegen', true));
+    }
+    return [
+        'Dependencies are missing; generated output was not created. Install them, then run typespun generate:',
+        ...commands,
+    ];
+}
+function detectPackageManager(projectDirectory, document) {
+    const configured = document.packageManager?.split('@')[0];
+    if (configured === 'bun' ||
+        configured === 'npm' ||
+        configured === 'pnpm' ||
+        configured === 'yarn') {
+        return configured;
+    }
+    if (isFile(join(projectDirectory, 'bun.lock')) ||
+        isFile(join(projectDirectory, 'bun.lockb'))) {
+        return 'bun';
+    }
+    if (isFile(join(projectDirectory, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (isFile(join(projectDirectory, 'yarn.lock')))
+        return 'yarn';
+    return 'npm';
+}
+function installCommand(manager, packageName, development) {
+    if (manager === 'npm') {
+        return `npm install${development ? ' --save-dev' : ''} ${packageName}`;
+    }
+    if (manager === 'yarn') {
+        return `yarn add${development ? ' --dev' : ''} ${packageName}`;
+    }
+    const developmentFlag = development
+        ? manager === 'pnpm'
+            ? ' --save-dev'
+            : ' --dev'
+        : '';
+    return `${manager} add${developmentFlag} ${packageName}`;
+}
+async function writeNewFile(path, contents) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, contents, { encoding: 'utf8', flag: 'wx' });
+}
+function displayPath(projectDirectory, path) {
+    return path.startsWith(`${projectDirectory}/`)
+        ? path.slice(projectDirectory.length + 1)
+        : path;
+}
+function pathsReferToSameFile(first, second) {
+    const firstIdentity = fileIdentity(first);
+    const secondIdentity = fileIdentity(second);
+    if (firstIdentity.stat !== undefined &&
+        secondIdentity.stat !== undefined &&
+        firstIdentity.stat.dev === secondIdentity.stat.dev &&
+        firstIdentity.stat.ino === secondIdentity.stat.ino) {
+        return true;
+    }
+    return firstIdentity.canonicalPath === secondIdentity.canonicalPath;
+}
+function fileIdentity(path) {
+    try {
+        return { canonicalPath: realpathSync(path), stat: statSync(path) };
+    }
+    catch {
+        let ancestor = dirname(path);
+        const remainder = [basename(path)];
+        while (true) {
+            try {
+                return {
+                    canonicalPath: resolve(realpathSync(ancestor), ...remainder),
+                };
+            }
+            catch {
+                const parent = dirname(ancestor);
+                if (parent === ancestor)
+                    return { canonicalPath: resolve(path) };
+                remainder.unshift(basename(ancestor));
+                ancestor = parent;
+            }
+        }
+    }
+}
+function isTypespunGeneratedOutput(path) {
+    let contents;
+    try {
+        contents = readFileSync(path, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    return (/^\/\/ Generated by typespun-codegen\. Do not edit\.\n\/\/ Schema fingerprint: [a-f0-9]{64}\n\n/u.test(contents) &&
+        contents.includes("from 'typespun/generated';") &&
+        contents.includes('export type Config = TypespunConfig;') &&
+        contents.includes('export const loadConfig = createLoader<Config>(schema);'));
+}
+function isFile(path) {
+    try {
+        return existsSync(path) && statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function pathEntryExists(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function rejectMutableSymlink(path, displayName) {
+    try {
+        if (lstatSync(path).isSymbolicLink()) {
+            throw new InitProjectError(`Initialization refuses to update the symbolic link at ${displayName}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof InitProjectError)
+            throw error;
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return;
+        }
+        throw new InitProjectError(`Could not inspect ${displayName}`);
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/cli/main.d.ts

@@ -0,0 +1,13 @@
+interface CliStreams {
+    readonly stdout: {
+        write(value: string): unknown;
+        readonly isTTY?: boolean;
+    };
+    readonly stderr: {
+        write(value: string): unknown;
+        readonly isTTY?: boolean;
+    };
+}
+export declare function runCli(args: readonly string[], streams?: CliStreams, cwd?: string): Promise<number>;
+export {};
+//# sourceMappingURL=main.d.ts.map

package/dist/cli/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":"AAyBA,UAAU,UAAU;IAClB,QAAQ,CAAC,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;QAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC7E,QAAQ,CAAC,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;QAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC9E;AAID,wBAAsB,MAAM,CAC1B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,GAAE,UAAoB,EAC7B,GAAG,SAAgB,GAClB,OAAO,CAAC,MAAM,CAAC,CA+EjB"}